diff --git a/core/rexcode/isa/x86/encoder.odin b/core/rexcode/isa/x86/encoder.odin index 23db1e7dc..c269dad27 100644 --- a/core/rexcode/isa/x86/encoder.odin +++ b/core/rexcode/isa/x86/encoder.odin @@ -33,13 +33,6 @@ import "core:rexcode/isa" MAX_INST_SIZE :: 15 // Maximum x64 instruction length -// Extra bytes reserved past each instruction so the branchless emitters can -// write a few speculative bytes beyond the logical end (e.g. a widened 4-byte -// displacement store when only a disp8 is kept). The over-written tail is -// reclaimed by the next emit; this slack just guarantees the wide store stays -// in bounds even for the final instruction against a tight buffer. -ENCODE_TAIL_SLACK :: 8 - // ----------------------------------------------------------------------------- // SECTION: 7.6 Core Encoding Function @@ -107,7 +100,7 @@ encode :: proc( } // Check buffer space - if byte_count + MAX_INST_SIZE + ENCODE_TAIL_SLACK > u32(len(code)) { + if byte_count + MAX_INST_SIZE > u32(len(code)) { append(errors, Error{u32(instruction_index), .BUFFER_OVERFLOW, {}}) ok = false continue @@ -147,27 +140,38 @@ encode :: proc( } } - // Find matching encoding from table (O(1) mnemonic lookup) - encodings := encoding_forms(inst.mnemonic) - if len(encodings) == 0 { - append(errors, Error{u32(instruction_index), .INVALID_MNEMONIC, {}}) - ok = false - continue - } - - // Find the first encoding that matches operands matched_enc: ^Encoding = nil - for &e in encodings { - if encoding_matches_inline(&inst, &e, mode) { - matched_enc = &e - break - } - } - if matched_enc == nil { - append(errors, Error{u32(instruction_index), .NO_MATCHING_ENCODING, {}}) - ok = false - continue + // Pre-matched form fast-path: a typed builder that maps to a single + // encoding form bakes `global_index + 1` into enc_hint, letting us skip + // the O(forms) match scan entirely -- and with it the scan's branches, + // which are the unpredictable ones in a varied instruction stream. Only + // in long mode (the builders' target); bounds-checked; anything else + // (hand-built, generic builders, i386, decode) falls back to matching. + if mode == ._64 && inst.enc_hint != ENC_HINT_NONE && int(inst.enc_hint) <= len(ENCODE_FORMS) { + matched_enc = &ENCODE_FORMS[inst.enc_hint - 1] + } else { + // Find matching encoding from table (O(1) mnemonic lookup) + encodings := encoding_forms(inst.mnemonic) + if len(encodings) == 0 { + append(errors, Error{u32(instruction_index), .INVALID_MNEMONIC, {}}) + ok = false + continue + } + + // Find the first encoding that matches operands + for &e in encodings { + if encoding_matches_inline(&inst, &e, mode) { + matched_enc = &e + break + } + } + + if matched_enc == nil { + append(errors, Error{u32(instruction_index), .NO_MATCHING_ENCODING, {}}) + ok = false + continue + } } // ===================================================================== @@ -208,34 +212,37 @@ encode :: proc( } has_modrm := mr_slot >= 0 || reg_slot >= 0 - // --- Legacy Prefixes (branchless) --- + // --- Legacy Prefixes --- // - // Each optional prefix byte is written *speculatively* at `pos`, then - // `pos` advances only if the prefix is actually present. When absent the - // speculative byte is overwritten by the next emit (the opcode always - // writes at `pos`), so the final stream is identical to the branching - // form -- with four data-dependent branches removed. The buffer carries - // MAX_INST_SIZE slack (checked above), so the spec writes stay in bounds. + // 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. // Lock prefix (F0) - out[pos] = 0xF0 - pos += u32(inst.flags.lock && enc.flags.lock_ok) + if inst.flags.lock && enc.flags.lock_ok { + out[pos] = 0xF0 + pos += 1 + } - // Rep/Repne prefix (NONE -> 0, REP -> F3, REPNE -> F2) - REP_BYTE := [Rep]u8{ .NONE = 0, .REP = 0xF3, .REPNE = 0xF2 } - rep_b := REP_BYTE[inst.flags.rep] - out[pos] = rep_b - pos += u32(rep_b != 0) + // Rep/Repne prefix + #partial switch inst.flags.rep { + case .REP: out[pos] = 0xF3; pos += 1 + case .REPNE: out[pos] = 0xF2; pos += 1 + } - // Segment override (table already maps 0 -> 0) - seg_prefix := [8]u8{0, 0x26, 0x2E, 0x36, 0x3E, 0x64, 0x65, 0} - seg_b := seg_prefix[inst.flags.segment] - out[pos] = seg_b - pos += u32(seg_b != 0) + // 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) - out[pos] = 0x67 - pos += u32(inst.flags.addr32) + if inst.flags.addr32 { + out[pos] = 0x67 + pos += 1 + } // --- VEX/EVEX or Legacy Encoding --- @@ -580,15 +587,14 @@ encode :: proc( pos += 1 } - // Displacement: four unconditional little-endian byte stores, then - // advance by the real size (0/1/4) -- no data-dependent loop. The - // untaken tail bytes are reclaimed by the next emit; ENCODE_TAIL_SLACK - // keeps the widened store in bounds. - out[pos+0] = u8(disp) - out[pos+1] = u8(disp >> 8) - out[pos+2] = u8(disp >> 16) - out[pos+3] = u8(disp >> 24) - pos += u32(displacement_size) + // Displacement: bounded little-endian emit. Kept as a counted loop + // (0/1/4 trips, highly predictable per code pattern) so no buffer + // tail-slack is needed and no bytes are written past the real size. + for _ in 0..>= 8 + pos += 1 + } } // Fixed ModR/M for special instructions. Triggered for: @@ -912,7 +918,7 @@ imm_matches_inline :: #force_inline proc "contextless" (op: ^Operand, op_type: O // Compute safe buffer sizes for encoding encode_max_code_size :: #force_inline proc "contextless" (n: int) -> int { - return n * MAX_INST_SIZE + ENCODE_TAIL_SLACK + return n * MAX_INST_SIZE } encode_max_relocation_count :: #force_inline proc "contextless" (n: int) -> int { diff --git a/core/rexcode/isa/x86/instructions.odin b/core/rexcode/isa/x86/instructions.odin index 9a81900d2..dd313948b 100644 --- a/core/rexcode/isa/x86/instructions.odin +++ b/core/rexcode/isa/x86/instructions.odin @@ -35,10 +35,25 @@ Instruction :: struct #packed { operand_count: u8, // 1 byte flags: Instruction_Flags, // 1 byte length: u8, // 1 byte (filled by decoder, used for iteration) - _: [11]u8, // 11 bytes + enc_hint: u16, // 2 bytes (pre-matched form, +1 biased; 0 = none) + _: [9]u8, // 9 bytes } #assert(size_of(Instruction) == 64) +// Pre-matched encoding hint: a typed builder that maps to exactly one encoding +// form (no value-dependent immediate selection) stores `global_form_index + 1` +// in `Instruction.enc_hint`, letting encode() skip the form-match scan. 0 means +// "no hint" -- the zero value, so every hand-built / generic-builder / decoded +// instruction stays on the matching path unchanged. +ENC_HINT_NONE :: u16(0) + +@(require_results) +with_hint :: #force_inline proc "contextless" (inst: Instruction, hint: u16) -> Instruction { + inst := inst + inst.enc_hint = hint + return inst +} + // ----------------------------------------------------------------------------- // SECTION: 7.9 Instruction Builder Helpers // ----------------------------------------------------------------------------- diff --git a/core/rexcode/isa/x86/mnemonic_builders.odin b/core/rexcode/isa/x86/mnemonic_builders.odin index 620a6a06c..c6b6ec9f8 100644 --- a/core/rexcode/isa/x86/mnemonic_builders.odin +++ b/core/rexcode/isa/x86/mnemonic_builders.odin @@ -71,3410 +71,3410 @@ mem512 :: #force_inline proc "contextless" (m: Memory) -> Mem512 { // Individual Typed Builder Procedures // ============================================================================= -inst_mov_r8_r8 :: #force_inline proc "contextless" (dst: GPR8, src: GPR8) -> Instruction { return inst_r_r(.MOV, Register(dst), Register(src)) } -inst_mov_m8_r8 :: #force_inline proc "contextless" (dst: Mem8, src: GPR8) -> Instruction { return inst_m_r(.MOV, dst.mem, 1, Register(src)) } -inst_mov_r16_r16 :: #force_inline proc "contextless" (dst: GPR16, src: GPR16) -> Instruction { return inst_r_r(.MOV, Register(dst), Register(src)) } -inst_mov_m16_r16 :: #force_inline proc "contextless" (dst: Mem16, src: GPR16) -> Instruction { return inst_m_r(.MOV, dst.mem, 2, Register(src)) } -inst_mov_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return inst_r_r(.MOV, Register(dst), Register(src)) } -inst_mov_m32_r32 :: #force_inline proc "contextless" (dst: Mem32, src: GPR32) -> Instruction { return inst_m_r(.MOV, dst.mem, 4, Register(src)) } -inst_mov_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return inst_r_r(.MOV, Register(dst), Register(src)) } -inst_mov_m64_r64 :: #force_inline proc "contextless" (dst: Mem64, src: GPR64) -> Instruction { return inst_m_r(.MOV, dst.mem, 8, Register(src)) } -inst_mov_r8_m8 :: #force_inline proc "contextless" (dst: GPR8, src: Mem8) -> Instruction { return inst_r_m(.MOV, Register(dst), src.mem, 1) } -inst_mov_r16_m16 :: #force_inline proc "contextless" (dst: GPR16, src: Mem16) -> Instruction { return inst_r_m(.MOV, Register(dst), src.mem, 2) } -inst_mov_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32) -> Instruction { return inst_r_m(.MOV, Register(dst), src.mem, 4) } -inst_mov_r64_m64 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64) -> Instruction { return inst_r_m(.MOV, Register(dst), src.mem, 8) } -inst_mov_r8_imm8 :: #force_inline proc "contextless" (dst: GPR8, imm: i8) -> Instruction { return inst_r_i(.MOV, Register(dst), i64(imm), 1) } -inst_mov_r16_imm16 :: #force_inline proc "contextless" (dst: GPR16, imm: i16) -> Instruction { return inst_r_i(.MOV, Register(dst), i64(imm), 2) } -inst_mov_r32_imm32 :: #force_inline proc "contextless" (dst: GPR32, imm: i32) -> Instruction { return inst_r_i(.MOV, Register(dst), i64(imm), 4) } -inst_mov_r64_imm64 :: #force_inline proc "contextless" (dst: GPR64, imm: i64) -> Instruction { return inst_r_i(.MOV, Register(dst), i64(imm), 8) } -inst_mov_m8_imm8 :: #force_inline proc "contextless" (dst: Mem8, imm: i8) -> Instruction { return inst_m_i(.MOV, dst.mem, 1, i64(imm), 1) } -inst_mov_m16_imm16 :: #force_inline proc "contextless" (dst: Mem16, imm: i16) -> Instruction { return inst_m_i(.MOV, dst.mem, 2, i64(imm), 2) } -inst_mov_m32_imm32 :: #force_inline proc "contextless" (dst: Mem32, imm: i32) -> Instruction { return inst_m_i(.MOV, dst.mem, 4, i64(imm), 4) } -inst_mov_r64_imm32 :: #force_inline proc "contextless" (dst: GPR64, imm: i32) -> Instruction { return inst_r_i(.MOV, Register(dst), i64(imm), 4) } -inst_mov_m64_imm32 :: #force_inline proc "contextless" (dst: Mem64, imm: i32) -> Instruction { return inst_m_i(.MOV, dst.mem, 8, i64(imm), 4) } -inst_mov_r16_sreg :: #force_inline proc "contextless" (dst: GPR16, src: SREG) -> Instruction { return inst_r_r(.MOV, Register(dst), Register(src)) } -inst_mov_m16_sreg :: #force_inline proc "contextless" (dst: Mem16, src: SREG) -> Instruction { return inst_m_r(.MOV, dst.mem, 2, Register(src)) } -inst_mov_r64_sreg :: #force_inline proc "contextless" (dst: GPR64, src: SREG) -> Instruction { return inst_r_r(.MOV, Register(dst), Register(src)) } -inst_mov_m64_sreg :: #force_inline proc "contextless" (dst: Mem64, src: SREG) -> Instruction { return inst_m_r(.MOV, dst.mem, 8, Register(src)) } -inst_mov_sreg_r16 :: #force_inline proc "contextless" (dst: SREG, src: GPR16) -> Instruction { return inst_r_r(.MOV, Register(dst), Register(src)) } -inst_mov_sreg_m16 :: #force_inline proc "contextless" (dst: SREG, src: Mem16) -> Instruction { return inst_r_m(.MOV, Register(dst), src.mem, 2) } -inst_mov_sreg_r64 :: #force_inline proc "contextless" (dst: SREG, src: GPR64) -> Instruction { return inst_r_r(.MOV, Register(dst), Register(src)) } -inst_mov_sreg_m64 :: #force_inline proc "contextless" (dst: SREG, src: Mem64) -> Instruction { return inst_r_m(.MOV, Register(dst), src.mem, 8) } -inst_mov_r64_cr :: #force_inline proc "contextless" (dst: GPR64, src: CREG) -> Instruction { return inst_r_r(.MOV, Register(dst), Register(src)) } -inst_mov_cr_r64 :: #force_inline proc "contextless" (dst: CREG, src: GPR64) -> Instruction { return inst_r_r(.MOV, Register(dst), Register(src)) } -inst_mov_r64_dr :: #force_inline proc "contextless" (dst: GPR64, src: DREG) -> Instruction { return inst_r_r(.MOV, Register(dst), Register(src)) } -inst_mov_dr_r64 :: #force_inline proc "contextless" (dst: DREG, src: GPR64) -> Instruction { return inst_r_r(.MOV, Register(dst), Register(src)) } -emit_mov_r8_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8, src: GPR8) { emit_rr(instructions, .MOV, Register(dst), Register(src)) } -emit_mov_m8_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8, src: GPR8) { emit_mr(instructions, .MOV, dst.mem, 1, Register(src)) } -emit_mov_r16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: GPR16) { emit_rr(instructions, .MOV, Register(dst), Register(src)) } -emit_mov_m16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16, src: GPR16) { emit_mr(instructions, .MOV, dst.mem, 2, Register(src)) } -emit_mov_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { emit_rr(instructions, .MOV, Register(dst), Register(src)) } -emit_mov_m32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, src: GPR32) { emit_mr(instructions, .MOV, dst.mem, 4, Register(src)) } -emit_mov_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { emit_rr(instructions, .MOV, Register(dst), Register(src)) } -emit_mov_m64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, src: GPR64) { emit_mr(instructions, .MOV, dst.mem, 8, Register(src)) } -emit_mov_r8_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8, src: Mem8) { emit_rm(instructions, .MOV, Register(dst), src.mem, 1) } -emit_mov_r16_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: Mem16) { emit_rm(instructions, .MOV, Register(dst), src.mem, 2) } -emit_mov_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32) { emit_rm(instructions, .MOV, Register(dst), src.mem, 4) } -emit_mov_r64_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem64) { emit_rm(instructions, .MOV, Register(dst), src.mem, 8) } -emit_mov_r8_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8, imm: i8) { emit_ri(instructions, .MOV, Register(dst), i64(imm), 1) } -emit_mov_r16_imm16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, imm: i16) { emit_ri(instructions, .MOV, Register(dst), i64(imm), 2) } -emit_mov_r32_imm32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, imm: i32) { emit_ri(instructions, .MOV, Register(dst), i64(imm), 4) } -emit_mov_r64_imm64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, imm: i64) { emit_ri(instructions, .MOV, Register(dst), i64(imm), 8) } -emit_mov_m8_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8, imm: i8) { emit_mi(instructions, .MOV, dst.mem, 1, i64(imm), 1) } -emit_mov_m16_imm16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16, imm: i16) { emit_mi(instructions, .MOV, dst.mem, 2, i64(imm), 2) } -emit_mov_m32_imm32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, imm: i32) { emit_mi(instructions, .MOV, dst.mem, 4, i64(imm), 4) } -emit_mov_r64_imm32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, imm: i32) { emit_ri(instructions, .MOV, Register(dst), i64(imm), 4) } -emit_mov_m64_imm32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, imm: i32) { emit_mi(instructions, .MOV, dst.mem, 8, i64(imm), 4) } -emit_mov_r16_sreg :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: SREG) { emit_rr(instructions, .MOV, Register(dst), Register(src)) } -emit_mov_m16_sreg :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16, src: SREG) { emit_mr(instructions, .MOV, dst.mem, 2, Register(src)) } -emit_mov_r64_sreg :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: SREG) { emit_rr(instructions, .MOV, Register(dst), Register(src)) } -emit_mov_m64_sreg :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, src: SREG) { emit_mr(instructions, .MOV, dst.mem, 8, Register(src)) } -emit_mov_sreg_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: SREG, src: GPR16) { emit_rr(instructions, .MOV, Register(dst), Register(src)) } -emit_mov_sreg_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: SREG, src: Mem16) { emit_rm(instructions, .MOV, Register(dst), src.mem, 2) } -emit_mov_sreg_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: SREG, src: GPR64) { emit_rr(instructions, .MOV, Register(dst), Register(src)) } -emit_mov_sreg_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: SREG, src: Mem64) { emit_rm(instructions, .MOV, Register(dst), src.mem, 8) } -emit_mov_r64_cr :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: CREG) { emit_rr(instructions, .MOV, Register(dst), Register(src)) } -emit_mov_cr_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: CREG, src: GPR64) { emit_rr(instructions, .MOV, Register(dst), Register(src)) } -emit_mov_r64_dr :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: DREG) { emit_rr(instructions, .MOV, Register(dst), Register(src)) } -emit_mov_dr_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: DREG, src: GPR64) { emit_rr(instructions, .MOV, Register(dst), Register(src)) } -inst_movabs_r64_imm64 :: #force_inline proc "contextless" (dst: GPR64, imm: i64) -> Instruction { return inst_r_i(.MOVABS, Register(dst), i64(imm), 8) } -emit_movabs_r64_imm64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, imm: i64) { emit_ri(instructions, .MOVABS, Register(dst), i64(imm), 8) } -inst_movzx_r16_r8 :: #force_inline proc "contextless" (dst: GPR16, src: GPR8) -> Instruction { return inst_r_r(.MOVZX, Register(dst), Register(src)) } -inst_movzx_r16_m8 :: #force_inline proc "contextless" (dst: GPR16, src: Mem8) -> Instruction { return inst_r_m(.MOVZX, Register(dst), src.mem, 1) } -inst_movzx_r32_r8 :: #force_inline proc "contextless" (dst: GPR32, src: GPR8) -> Instruction { return inst_r_r(.MOVZX, Register(dst), Register(src)) } -inst_movzx_r32_m8 :: #force_inline proc "contextless" (dst: GPR32, src: Mem8) -> Instruction { return inst_r_m(.MOVZX, Register(dst), src.mem, 1) } -inst_movzx_r64_r8 :: #force_inline proc "contextless" (dst: GPR64, src: GPR8) -> Instruction { return inst_r_r(.MOVZX, Register(dst), Register(src)) } -inst_movzx_r64_m8 :: #force_inline proc "contextless" (dst: GPR64, src: Mem8) -> Instruction { return inst_r_m(.MOVZX, Register(dst), src.mem, 1) } -inst_movzx_r32_r16 :: #force_inline proc "contextless" (dst: GPR32, src: GPR16) -> Instruction { return inst_r_r(.MOVZX, Register(dst), Register(src)) } -inst_movzx_r32_m16 :: #force_inline proc "contextless" (dst: GPR32, src: Mem16) -> Instruction { return inst_r_m(.MOVZX, Register(dst), src.mem, 2) } -inst_movzx_r64_r16 :: #force_inline proc "contextless" (dst: GPR64, src: GPR16) -> Instruction { return inst_r_r(.MOVZX, Register(dst), Register(src)) } -inst_movzx_r64_m16 :: #force_inline proc "contextless" (dst: GPR64, src: Mem16) -> Instruction { return inst_r_m(.MOVZX, Register(dst), src.mem, 2) } -emit_movzx_r16_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: GPR8) { emit_rr(instructions, .MOVZX, Register(dst), Register(src)) } -emit_movzx_r16_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: Mem8) { emit_rm(instructions, .MOVZX, Register(dst), src.mem, 1) } -emit_movzx_r32_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR8) { emit_rr(instructions, .MOVZX, Register(dst), Register(src)) } -emit_movzx_r32_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem8) { emit_rm(instructions, .MOVZX, Register(dst), src.mem, 1) } -emit_movzx_r64_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR8) { emit_rr(instructions, .MOVZX, Register(dst), Register(src)) } -emit_movzx_r64_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem8) { emit_rm(instructions, .MOVZX, Register(dst), src.mem, 1) } -emit_movzx_r32_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR16) { emit_rr(instructions, .MOVZX, Register(dst), Register(src)) } -emit_movzx_r32_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem16) { emit_rm(instructions, .MOVZX, Register(dst), src.mem, 2) } -emit_movzx_r64_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR16) { emit_rr(instructions, .MOVZX, Register(dst), Register(src)) } -emit_movzx_r64_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem16) { emit_rm(instructions, .MOVZX, Register(dst), src.mem, 2) } -inst_movsx_r16_r8 :: #force_inline proc "contextless" (dst: GPR16, src: GPR8) -> Instruction { return inst_r_r(.MOVSX, Register(dst), Register(src)) } -inst_movsx_r16_m8 :: #force_inline proc "contextless" (dst: GPR16, src: Mem8) -> Instruction { return inst_r_m(.MOVSX, Register(dst), src.mem, 1) } -inst_movsx_r32_r8 :: #force_inline proc "contextless" (dst: GPR32, src: GPR8) -> Instruction { return inst_r_r(.MOVSX, Register(dst), Register(src)) } -inst_movsx_r32_m8 :: #force_inline proc "contextless" (dst: GPR32, src: Mem8) -> Instruction { return inst_r_m(.MOVSX, Register(dst), src.mem, 1) } -inst_movsx_r64_r8 :: #force_inline proc "contextless" (dst: GPR64, src: GPR8) -> Instruction { return inst_r_r(.MOVSX, Register(dst), Register(src)) } -inst_movsx_r64_m8 :: #force_inline proc "contextless" (dst: GPR64, src: Mem8) -> Instruction { return inst_r_m(.MOVSX, Register(dst), src.mem, 1) } -inst_movsx_r32_r16 :: #force_inline proc "contextless" (dst: GPR32, src: GPR16) -> Instruction { return inst_r_r(.MOVSX, Register(dst), Register(src)) } -inst_movsx_r32_m16 :: #force_inline proc "contextless" (dst: GPR32, src: Mem16) -> Instruction { return inst_r_m(.MOVSX, Register(dst), src.mem, 2) } -inst_movsx_r64_r16 :: #force_inline proc "contextless" (dst: GPR64, src: GPR16) -> Instruction { return inst_r_r(.MOVSX, Register(dst), Register(src)) } -inst_movsx_r64_m16 :: #force_inline proc "contextless" (dst: GPR64, src: Mem16) -> Instruction { return inst_r_m(.MOVSX, Register(dst), src.mem, 2) } -emit_movsx_r16_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: GPR8) { emit_rr(instructions, .MOVSX, Register(dst), Register(src)) } -emit_movsx_r16_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: Mem8) { emit_rm(instructions, .MOVSX, Register(dst), src.mem, 1) } -emit_movsx_r32_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR8) { emit_rr(instructions, .MOVSX, Register(dst), Register(src)) } -emit_movsx_r32_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem8) { emit_rm(instructions, .MOVSX, Register(dst), src.mem, 1) } -emit_movsx_r64_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR8) { emit_rr(instructions, .MOVSX, Register(dst), Register(src)) } -emit_movsx_r64_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem8) { emit_rm(instructions, .MOVSX, Register(dst), src.mem, 1) } -emit_movsx_r32_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR16) { emit_rr(instructions, .MOVSX, Register(dst), Register(src)) } -emit_movsx_r32_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem16) { emit_rm(instructions, .MOVSX, Register(dst), src.mem, 2) } -emit_movsx_r64_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR16) { emit_rr(instructions, .MOVSX, Register(dst), Register(src)) } -emit_movsx_r64_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem16) { emit_rm(instructions, .MOVSX, Register(dst), src.mem, 2) } -inst_movsxd_r64_r32 :: #force_inline proc "contextless" (dst: GPR64, src: GPR32) -> Instruction { return inst_r_r(.MOVSXD, Register(dst), Register(src)) } -inst_movsxd_r64_m32 :: #force_inline proc "contextless" (dst: GPR64, src: Mem32) -> Instruction { return inst_r_m(.MOVSXD, Register(dst), src.mem, 4) } -emit_movsxd_r64_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR32) { emit_rr(instructions, .MOVSXD, Register(dst), Register(src)) } -emit_movsxd_r64_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem32) { emit_rm(instructions, .MOVSXD, Register(dst), src.mem, 4) } -inst_xchg_r16 :: #force_inline proc "contextless" (dst: GPR16) -> Instruction { return inst_r(.XCHG, Register(dst)) } -inst_xchg_r32 :: #force_inline proc "contextless" (dst: GPR32) -> Instruction { return inst_r(.XCHG, Register(dst)) } -inst_xchg_r64 :: #force_inline proc "contextless" (dst: GPR64) -> Instruction { return inst_r(.XCHG, Register(dst)) } -inst_xchg_r8_r8 :: #force_inline proc "contextless" (dst: GPR8, src: GPR8) -> Instruction { return inst_r_r(.XCHG, Register(dst), Register(src)) } -inst_xchg_m8_r8 :: #force_inline proc "contextless" (dst: Mem8, src: GPR8) -> Instruction { return inst_m_r(.XCHG, dst.mem, 1, Register(src)) } -inst_xchg_r16_r16 :: #force_inline proc "contextless" (dst: GPR16, src: GPR16) -> Instruction { return inst_r_r(.XCHG, Register(dst), Register(src)) } -inst_xchg_m16_r16 :: #force_inline proc "contextless" (dst: Mem16, src: GPR16) -> Instruction { return inst_m_r(.XCHG, dst.mem, 2, Register(src)) } -inst_xchg_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return inst_r_r(.XCHG, Register(dst), Register(src)) } -inst_xchg_m32_r32 :: #force_inline proc "contextless" (dst: Mem32, src: GPR32) -> Instruction { return inst_m_r(.XCHG, dst.mem, 4, Register(src)) } -inst_xchg_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return inst_r_r(.XCHG, Register(dst), Register(src)) } -inst_xchg_m64_r64 :: #force_inline proc "contextless" (dst: Mem64, src: GPR64) -> Instruction { return inst_m_r(.XCHG, dst.mem, 8, Register(src)) } -emit_xchg_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16) { emit_r(instructions, .XCHG, Register(dst)) } -emit_xchg_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32) { emit_r(instructions, .XCHG, Register(dst)) } -emit_xchg_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64) { emit_r(instructions, .XCHG, Register(dst)) } -emit_xchg_r8_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8, src: GPR8) { emit_rr(instructions, .XCHG, Register(dst), Register(src)) } -emit_xchg_m8_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8, src: GPR8) { emit_mr(instructions, .XCHG, dst.mem, 1, Register(src)) } -emit_xchg_r16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: GPR16) { emit_rr(instructions, .XCHG, Register(dst), Register(src)) } -emit_xchg_m16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16, src: GPR16) { emit_mr(instructions, .XCHG, dst.mem, 2, Register(src)) } -emit_xchg_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { emit_rr(instructions, .XCHG, Register(dst), Register(src)) } -emit_xchg_m32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, src: GPR32) { emit_mr(instructions, .XCHG, dst.mem, 4, Register(src)) } -emit_xchg_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { emit_rr(instructions, .XCHG, Register(dst), Register(src)) } -emit_xchg_m64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, src: GPR64) { emit_mr(instructions, .XCHG, dst.mem, 8, Register(src)) } -inst_push_r16 :: #force_inline proc "contextless" (dst: GPR16) -> Instruction { return inst_r(.PUSH, Register(dst)) } -inst_push_r64 :: #force_inline proc "contextless" (dst: GPR64) -> Instruction { return inst_r(.PUSH, Register(dst)) } -inst_push_m16 :: #force_inline proc "contextless" (dst: Mem16) -> Instruction { return inst_m(.PUSH, dst.mem, 2) } -inst_push_m64 :: #force_inline proc "contextless" (dst: Mem64) -> Instruction { return inst_m(.PUSH, dst.mem, 8) } -inst_push_imm16 :: #force_inline proc "contextless" (imm: i16) -> Instruction { return inst_i(.PUSH, i64(imm), 2) } -inst_push_imm32 :: #force_inline proc "contextless" (imm: i32) -> Instruction { return inst_i(.PUSH, i64(imm), 4) } -inst_push_sreg :: #force_inline proc "contextless" (dst: SREG) -> Instruction { return inst_r(.PUSH, Register(dst)) } -emit_push_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16) { emit_r(instructions, .PUSH, Register(dst)) } -emit_push_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64) { emit_r(instructions, .PUSH, Register(dst)) } -emit_push_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16) { emit_m(instructions, .PUSH, dst.mem, 2) } -emit_push_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64) { emit_m(instructions, .PUSH, dst.mem, 8) } -emit_push_imm16 :: #force_inline proc(instructions: ^[dynamic]Instruction, imm: i16) { emit_i(instructions, .PUSH, i64(imm), 2) } -emit_push_imm32 :: #force_inline proc(instructions: ^[dynamic]Instruction, imm: i32) { emit_i(instructions, .PUSH, i64(imm), 4) } -emit_push_sreg :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: SREG) { emit_r(instructions, .PUSH, Register(dst)) } -inst_pop_r16 :: #force_inline proc "contextless" (dst: GPR16) -> Instruction { return inst_r(.POP, Register(dst)) } -inst_pop_r64 :: #force_inline proc "contextless" (dst: GPR64) -> Instruction { return inst_r(.POP, Register(dst)) } -inst_pop_m16 :: #force_inline proc "contextless" (dst: Mem16) -> Instruction { return inst_m(.POP, dst.mem, 2) } -inst_pop_m64 :: #force_inline proc "contextless" (dst: Mem64) -> Instruction { return inst_m(.POP, dst.mem, 8) } -inst_pop_sreg :: #force_inline proc "contextless" (dst: SREG) -> Instruction { return inst_r(.POP, Register(dst)) } -emit_pop_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16) { emit_r(instructions, .POP, Register(dst)) } -emit_pop_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64) { emit_r(instructions, .POP, Register(dst)) } -emit_pop_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16) { emit_m(instructions, .POP, dst.mem, 2) } -emit_pop_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64) { emit_m(instructions, .POP, dst.mem, 8) } -emit_pop_sreg :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: SREG) { emit_r(instructions, .POP, Register(dst)) } -inst_lea_r16_m :: #force_inline proc "contextless" (dst: GPR16, src: Memory) -> Instruction { return inst_r_m(.LEA, Register(dst), src, 0) } -inst_lea_r32_m :: #force_inline proc "contextless" (dst: GPR32, src: Memory) -> Instruction { return inst_r_m(.LEA, Register(dst), src, 0) } -inst_lea_r64_m :: #force_inline proc "contextless" (dst: GPR64, src: Memory) -> Instruction { return inst_r_m(.LEA, Register(dst), src, 0) } -emit_lea_r16_m :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: Memory) { emit_rm(instructions, .LEA, Register(dst), src, 0) } -emit_lea_r32_m :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Memory) { emit_rm(instructions, .LEA, Register(dst), src, 0) } -emit_lea_r64_m :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Memory) { emit_rm(instructions, .LEA, Register(dst), src, 0) } -inst_add_r8_r8 :: #force_inline proc "contextless" (dst: GPR8, src: GPR8) -> Instruction { return inst_r_r(.ADD, Register(dst), Register(src)) } -inst_add_m8_r8 :: #force_inline proc "contextless" (dst: Mem8, src: GPR8) -> Instruction { return inst_m_r(.ADD, dst.mem, 1, Register(src)) } -inst_add_r16_r16 :: #force_inline proc "contextless" (dst: GPR16, src: GPR16) -> Instruction { return inst_r_r(.ADD, Register(dst), Register(src)) } -inst_add_m16_r16 :: #force_inline proc "contextless" (dst: Mem16, src: GPR16) -> Instruction { return inst_m_r(.ADD, dst.mem, 2, Register(src)) } -inst_add_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return inst_r_r(.ADD, Register(dst), Register(src)) } -inst_add_m32_r32 :: #force_inline proc "contextless" (dst: Mem32, src: GPR32) -> Instruction { return inst_m_r(.ADD, dst.mem, 4, Register(src)) } -inst_add_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return inst_r_r(.ADD, Register(dst), Register(src)) } -inst_add_m64_r64 :: #force_inline proc "contextless" (dst: Mem64, src: GPR64) -> Instruction { return inst_m_r(.ADD, dst.mem, 8, Register(src)) } -inst_add_r8_m8 :: #force_inline proc "contextless" (dst: GPR8, src: Mem8) -> Instruction { return inst_r_m(.ADD, Register(dst), src.mem, 1) } -inst_add_r16_m16 :: #force_inline proc "contextless" (dst: GPR16, src: Mem16) -> Instruction { return inst_r_m(.ADD, Register(dst), src.mem, 2) } -inst_add_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32) -> Instruction { return inst_r_m(.ADD, Register(dst), src.mem, 4) } -inst_add_r64_m64 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64) -> Instruction { return inst_r_m(.ADD, Register(dst), src.mem, 8) } -inst_add_imm8 :: #force_inline proc "contextless" (imm: i8) -> Instruction { return inst_i(.ADD, i64(imm), 1) } -inst_add_imm16 :: #force_inline proc "contextless" (imm: i16) -> Instruction { return inst_i(.ADD, i64(imm), 2) } -inst_add_imm32 :: #force_inline proc "contextless" (imm: i32) -> Instruction { return inst_i(.ADD, i64(imm), 4) } -inst_add_r8_imm8 :: #force_inline proc "contextless" (dst: GPR8, imm: i8) -> Instruction { return inst_r_i(.ADD, Register(dst), i64(imm), 1) } -inst_add_m8_imm8 :: #force_inline proc "contextless" (dst: Mem8, imm: i8) -> Instruction { return inst_m_i(.ADD, dst.mem, 1, i64(imm), 1) } -inst_add_r16_imm16 :: #force_inline proc "contextless" (dst: GPR16, imm: i16) -> Instruction { return inst_r_i(.ADD, Register(dst), i64(imm), 2) } -inst_add_m16_imm16 :: #force_inline proc "contextless" (dst: Mem16, imm: i16) -> Instruction { return inst_m_i(.ADD, dst.mem, 2, i64(imm), 2) } -inst_add_r32_imm32 :: #force_inline proc "contextless" (dst: GPR32, imm: i32) -> Instruction { return inst_r_i(.ADD, Register(dst), i64(imm), 4) } -inst_add_m32_imm32 :: #force_inline proc "contextless" (dst: Mem32, imm: i32) -> Instruction { return inst_m_i(.ADD, dst.mem, 4, i64(imm), 4) } -inst_add_r64_imm32 :: #force_inline proc "contextless" (dst: GPR64, imm: i32) -> Instruction { return inst_r_i(.ADD, Register(dst), i64(imm), 4) } -inst_add_m64_imm32 :: #force_inline proc "contextless" (dst: Mem64, imm: i32) -> Instruction { return inst_m_i(.ADD, dst.mem, 8, i64(imm), 4) } -emit_add_r8_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8, src: GPR8) { emit_rr(instructions, .ADD, Register(dst), Register(src)) } -emit_add_m8_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8, src: GPR8) { emit_mr(instructions, .ADD, dst.mem, 1, Register(src)) } -emit_add_r16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: GPR16) { emit_rr(instructions, .ADD, Register(dst), Register(src)) } -emit_add_m16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16, src: GPR16) { emit_mr(instructions, .ADD, dst.mem, 2, Register(src)) } -emit_add_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { emit_rr(instructions, .ADD, Register(dst), Register(src)) } -emit_add_m32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, src: GPR32) { emit_mr(instructions, .ADD, dst.mem, 4, Register(src)) } -emit_add_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { emit_rr(instructions, .ADD, Register(dst), Register(src)) } -emit_add_m64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, src: GPR64) { emit_mr(instructions, .ADD, dst.mem, 8, Register(src)) } -emit_add_r8_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8, src: Mem8) { emit_rm(instructions, .ADD, Register(dst), src.mem, 1) } -emit_add_r16_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: Mem16) { emit_rm(instructions, .ADD, Register(dst), src.mem, 2) } -emit_add_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32) { emit_rm(instructions, .ADD, Register(dst), src.mem, 4) } -emit_add_r64_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem64) { emit_rm(instructions, .ADD, Register(dst), src.mem, 8) } -emit_add_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, imm: i8) { emit_i(instructions, .ADD, i64(imm), 1) } -emit_add_imm16 :: #force_inline proc(instructions: ^[dynamic]Instruction, imm: i16) { emit_i(instructions, .ADD, i64(imm), 2) } -emit_add_imm32 :: #force_inline proc(instructions: ^[dynamic]Instruction, imm: i32) { emit_i(instructions, .ADD, i64(imm), 4) } -emit_add_r8_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8, imm: i8) { emit_ri(instructions, .ADD, Register(dst), i64(imm), 1) } -emit_add_m8_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8, imm: i8) { emit_mi(instructions, .ADD, dst.mem, 1, i64(imm), 1) } -emit_add_r16_imm16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, imm: i16) { emit_ri(instructions, .ADD, Register(dst), i64(imm), 2) } -emit_add_m16_imm16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16, imm: i16) { emit_mi(instructions, .ADD, dst.mem, 2, i64(imm), 2) } -emit_add_r32_imm32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, imm: i32) { emit_ri(instructions, .ADD, Register(dst), i64(imm), 4) } -emit_add_m32_imm32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, imm: i32) { emit_mi(instructions, .ADD, dst.mem, 4, i64(imm), 4) } -emit_add_r64_imm32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, imm: i32) { emit_ri(instructions, .ADD, Register(dst), i64(imm), 4) } -emit_add_m64_imm32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, imm: i32) { emit_mi(instructions, .ADD, dst.mem, 8, i64(imm), 4) } -inst_adc_r8_r8 :: #force_inline proc "contextless" (dst: GPR8, src: GPR8) -> Instruction { return inst_r_r(.ADC, Register(dst), Register(src)) } -inst_adc_m8_r8 :: #force_inline proc "contextless" (dst: Mem8, src: GPR8) -> Instruction { return inst_m_r(.ADC, dst.mem, 1, Register(src)) } -inst_adc_r16_r16 :: #force_inline proc "contextless" (dst: GPR16, src: GPR16) -> Instruction { return inst_r_r(.ADC, Register(dst), Register(src)) } -inst_adc_m16_r16 :: #force_inline proc "contextless" (dst: Mem16, src: GPR16) -> Instruction { return inst_m_r(.ADC, dst.mem, 2, Register(src)) } -inst_adc_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return inst_r_r(.ADC, Register(dst), Register(src)) } -inst_adc_m32_r32 :: #force_inline proc "contextless" (dst: Mem32, src: GPR32) -> Instruction { return inst_m_r(.ADC, dst.mem, 4, Register(src)) } -inst_adc_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return inst_r_r(.ADC, Register(dst), Register(src)) } -inst_adc_m64_r64 :: #force_inline proc "contextless" (dst: Mem64, src: GPR64) -> Instruction { return inst_m_r(.ADC, dst.mem, 8, Register(src)) } -inst_adc_r8_m8 :: #force_inline proc "contextless" (dst: GPR8, src: Mem8) -> Instruction { return inst_r_m(.ADC, Register(dst), src.mem, 1) } -inst_adc_r16_m16 :: #force_inline proc "contextless" (dst: GPR16, src: Mem16) -> Instruction { return inst_r_m(.ADC, Register(dst), src.mem, 2) } -inst_adc_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32) -> Instruction { return inst_r_m(.ADC, Register(dst), src.mem, 4) } -inst_adc_r64_m64 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64) -> Instruction { return inst_r_m(.ADC, Register(dst), src.mem, 8) } -inst_adc_imm8 :: #force_inline proc "contextless" (imm: i8) -> Instruction { return inst_i(.ADC, i64(imm), 1) } -inst_adc_imm16 :: #force_inline proc "contextless" (imm: i16) -> Instruction { return inst_i(.ADC, i64(imm), 2) } -inst_adc_imm32 :: #force_inline proc "contextless" (imm: i32) -> Instruction { return inst_i(.ADC, i64(imm), 4) } -inst_adc_r8_imm8 :: #force_inline proc "contextless" (dst: GPR8, imm: i8) -> Instruction { return inst_r_i(.ADC, Register(dst), i64(imm), 1) } -inst_adc_m8_imm8 :: #force_inline proc "contextless" (dst: Mem8, imm: i8) -> Instruction { return inst_m_i(.ADC, dst.mem, 1, i64(imm), 1) } -inst_adc_r16_imm16 :: #force_inline proc "contextless" (dst: GPR16, imm: i16) -> Instruction { return inst_r_i(.ADC, Register(dst), i64(imm), 2) } -inst_adc_m16_imm16 :: #force_inline proc "contextless" (dst: Mem16, imm: i16) -> Instruction { return inst_m_i(.ADC, dst.mem, 2, i64(imm), 2) } -inst_adc_r32_imm32 :: #force_inline proc "contextless" (dst: GPR32, imm: i32) -> Instruction { return inst_r_i(.ADC, Register(dst), i64(imm), 4) } -inst_adc_m32_imm32 :: #force_inline proc "contextless" (dst: Mem32, imm: i32) -> Instruction { return inst_m_i(.ADC, dst.mem, 4, i64(imm), 4) } -inst_adc_r64_imm32 :: #force_inline proc "contextless" (dst: GPR64, imm: i32) -> Instruction { return inst_r_i(.ADC, Register(dst), i64(imm), 4) } -inst_adc_m64_imm32 :: #force_inline proc "contextless" (dst: Mem64, imm: i32) -> Instruction { return inst_m_i(.ADC, dst.mem, 8, i64(imm), 4) } -emit_adc_r8_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8, src: GPR8) { emit_rr(instructions, .ADC, Register(dst), Register(src)) } -emit_adc_m8_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8, src: GPR8) { emit_mr(instructions, .ADC, dst.mem, 1, Register(src)) } -emit_adc_r16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: GPR16) { emit_rr(instructions, .ADC, Register(dst), Register(src)) } -emit_adc_m16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16, src: GPR16) { emit_mr(instructions, .ADC, dst.mem, 2, Register(src)) } -emit_adc_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { emit_rr(instructions, .ADC, Register(dst), Register(src)) } -emit_adc_m32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, src: GPR32) { emit_mr(instructions, .ADC, dst.mem, 4, Register(src)) } -emit_adc_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { emit_rr(instructions, .ADC, Register(dst), Register(src)) } -emit_adc_m64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, src: GPR64) { emit_mr(instructions, .ADC, dst.mem, 8, Register(src)) } -emit_adc_r8_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8, src: Mem8) { emit_rm(instructions, .ADC, Register(dst), src.mem, 1) } -emit_adc_r16_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: Mem16) { emit_rm(instructions, .ADC, Register(dst), src.mem, 2) } -emit_adc_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32) { emit_rm(instructions, .ADC, Register(dst), src.mem, 4) } -emit_adc_r64_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem64) { emit_rm(instructions, .ADC, Register(dst), src.mem, 8) } -emit_adc_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, imm: i8) { emit_i(instructions, .ADC, i64(imm), 1) } -emit_adc_imm16 :: #force_inline proc(instructions: ^[dynamic]Instruction, imm: i16) { emit_i(instructions, .ADC, i64(imm), 2) } -emit_adc_imm32 :: #force_inline proc(instructions: ^[dynamic]Instruction, imm: i32) { emit_i(instructions, .ADC, i64(imm), 4) } -emit_adc_r8_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8, imm: i8) { emit_ri(instructions, .ADC, Register(dst), i64(imm), 1) } -emit_adc_m8_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8, imm: i8) { emit_mi(instructions, .ADC, dst.mem, 1, i64(imm), 1) } -emit_adc_r16_imm16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, imm: i16) { emit_ri(instructions, .ADC, Register(dst), i64(imm), 2) } -emit_adc_m16_imm16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16, imm: i16) { emit_mi(instructions, .ADC, dst.mem, 2, i64(imm), 2) } -emit_adc_r32_imm32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, imm: i32) { emit_ri(instructions, .ADC, Register(dst), i64(imm), 4) } -emit_adc_m32_imm32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, imm: i32) { emit_mi(instructions, .ADC, dst.mem, 4, i64(imm), 4) } -emit_adc_r64_imm32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, imm: i32) { emit_ri(instructions, .ADC, Register(dst), i64(imm), 4) } -emit_adc_m64_imm32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, imm: i32) { emit_mi(instructions, .ADC, dst.mem, 8, i64(imm), 4) } -inst_sub_r8_r8 :: #force_inline proc "contextless" (dst: GPR8, src: GPR8) -> Instruction { return inst_r_r(.SUB, Register(dst), Register(src)) } -inst_sub_m8_r8 :: #force_inline proc "contextless" (dst: Mem8, src: GPR8) -> Instruction { return inst_m_r(.SUB, dst.mem, 1, Register(src)) } -inst_sub_r16_r16 :: #force_inline proc "contextless" (dst: GPR16, src: GPR16) -> Instruction { return inst_r_r(.SUB, Register(dst), Register(src)) } -inst_sub_m16_r16 :: #force_inline proc "contextless" (dst: Mem16, src: GPR16) -> Instruction { return inst_m_r(.SUB, dst.mem, 2, Register(src)) } -inst_sub_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return inst_r_r(.SUB, Register(dst), Register(src)) } -inst_sub_m32_r32 :: #force_inline proc "contextless" (dst: Mem32, src: GPR32) -> Instruction { return inst_m_r(.SUB, dst.mem, 4, Register(src)) } -inst_sub_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return inst_r_r(.SUB, Register(dst), Register(src)) } -inst_sub_m64_r64 :: #force_inline proc "contextless" (dst: Mem64, src: GPR64) -> Instruction { return inst_m_r(.SUB, dst.mem, 8, Register(src)) } -inst_sub_r8_m8 :: #force_inline proc "contextless" (dst: GPR8, src: Mem8) -> Instruction { return inst_r_m(.SUB, Register(dst), src.mem, 1) } -inst_sub_r16_m16 :: #force_inline proc "contextless" (dst: GPR16, src: Mem16) -> Instruction { return inst_r_m(.SUB, Register(dst), src.mem, 2) } -inst_sub_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32) -> Instruction { return inst_r_m(.SUB, Register(dst), src.mem, 4) } -inst_sub_r64_m64 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64) -> Instruction { return inst_r_m(.SUB, Register(dst), src.mem, 8) } -inst_sub_imm8 :: #force_inline proc "contextless" (imm: i8) -> Instruction { return inst_i(.SUB, i64(imm), 1) } -inst_sub_imm16 :: #force_inline proc "contextless" (imm: i16) -> Instruction { return inst_i(.SUB, i64(imm), 2) } -inst_sub_imm32 :: #force_inline proc "contextless" (imm: i32) -> Instruction { return inst_i(.SUB, i64(imm), 4) } -inst_sub_r8_imm8 :: #force_inline proc "contextless" (dst: GPR8, imm: i8) -> Instruction { return inst_r_i(.SUB, Register(dst), i64(imm), 1) } -inst_sub_m8_imm8 :: #force_inline proc "contextless" (dst: Mem8, imm: i8) -> Instruction { return inst_m_i(.SUB, dst.mem, 1, i64(imm), 1) } -inst_sub_r16_imm16 :: #force_inline proc "contextless" (dst: GPR16, imm: i16) -> Instruction { return inst_r_i(.SUB, Register(dst), i64(imm), 2) } -inst_sub_m16_imm16 :: #force_inline proc "contextless" (dst: Mem16, imm: i16) -> Instruction { return inst_m_i(.SUB, dst.mem, 2, i64(imm), 2) } -inst_sub_r32_imm32 :: #force_inline proc "contextless" (dst: GPR32, imm: i32) -> Instruction { return inst_r_i(.SUB, Register(dst), i64(imm), 4) } -inst_sub_m32_imm32 :: #force_inline proc "contextless" (dst: Mem32, imm: i32) -> Instruction { return inst_m_i(.SUB, dst.mem, 4, i64(imm), 4) } -inst_sub_r64_imm32 :: #force_inline proc "contextless" (dst: GPR64, imm: i32) -> Instruction { return inst_r_i(.SUB, Register(dst), i64(imm), 4) } -inst_sub_m64_imm32 :: #force_inline proc "contextless" (dst: Mem64, imm: i32) -> Instruction { return inst_m_i(.SUB, dst.mem, 8, i64(imm), 4) } -emit_sub_r8_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8, src: GPR8) { emit_rr(instructions, .SUB, Register(dst), Register(src)) } -emit_sub_m8_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8, src: GPR8) { emit_mr(instructions, .SUB, dst.mem, 1, Register(src)) } -emit_sub_r16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: GPR16) { emit_rr(instructions, .SUB, Register(dst), Register(src)) } -emit_sub_m16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16, src: GPR16) { emit_mr(instructions, .SUB, dst.mem, 2, Register(src)) } -emit_sub_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { emit_rr(instructions, .SUB, Register(dst), Register(src)) } -emit_sub_m32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, src: GPR32) { emit_mr(instructions, .SUB, dst.mem, 4, Register(src)) } -emit_sub_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { emit_rr(instructions, .SUB, Register(dst), Register(src)) } -emit_sub_m64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, src: GPR64) { emit_mr(instructions, .SUB, dst.mem, 8, Register(src)) } -emit_sub_r8_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8, src: Mem8) { emit_rm(instructions, .SUB, Register(dst), src.mem, 1) } -emit_sub_r16_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: Mem16) { emit_rm(instructions, .SUB, Register(dst), src.mem, 2) } -emit_sub_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32) { emit_rm(instructions, .SUB, Register(dst), src.mem, 4) } -emit_sub_r64_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem64) { emit_rm(instructions, .SUB, Register(dst), src.mem, 8) } -emit_sub_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, imm: i8) { emit_i(instructions, .SUB, i64(imm), 1) } -emit_sub_imm16 :: #force_inline proc(instructions: ^[dynamic]Instruction, imm: i16) { emit_i(instructions, .SUB, i64(imm), 2) } -emit_sub_imm32 :: #force_inline proc(instructions: ^[dynamic]Instruction, imm: i32) { emit_i(instructions, .SUB, i64(imm), 4) } -emit_sub_r8_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8, imm: i8) { emit_ri(instructions, .SUB, Register(dst), i64(imm), 1) } -emit_sub_m8_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8, imm: i8) { emit_mi(instructions, .SUB, dst.mem, 1, i64(imm), 1) } -emit_sub_r16_imm16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, imm: i16) { emit_ri(instructions, .SUB, Register(dst), i64(imm), 2) } -emit_sub_m16_imm16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16, imm: i16) { emit_mi(instructions, .SUB, dst.mem, 2, i64(imm), 2) } -emit_sub_r32_imm32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, imm: i32) { emit_ri(instructions, .SUB, Register(dst), i64(imm), 4) } -emit_sub_m32_imm32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, imm: i32) { emit_mi(instructions, .SUB, dst.mem, 4, i64(imm), 4) } -emit_sub_r64_imm32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, imm: i32) { emit_ri(instructions, .SUB, Register(dst), i64(imm), 4) } -emit_sub_m64_imm32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, imm: i32) { emit_mi(instructions, .SUB, dst.mem, 8, i64(imm), 4) } -inst_sbb_r8_r8 :: #force_inline proc "contextless" (dst: GPR8, src: GPR8) -> Instruction { return inst_r_r(.SBB, Register(dst), Register(src)) } -inst_sbb_m8_r8 :: #force_inline proc "contextless" (dst: Mem8, src: GPR8) -> Instruction { return inst_m_r(.SBB, dst.mem, 1, Register(src)) } -inst_sbb_r16_r16 :: #force_inline proc "contextless" (dst: GPR16, src: GPR16) -> Instruction { return inst_r_r(.SBB, Register(dst), Register(src)) } -inst_sbb_m16_r16 :: #force_inline proc "contextless" (dst: Mem16, src: GPR16) -> Instruction { return inst_m_r(.SBB, dst.mem, 2, Register(src)) } -inst_sbb_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return inst_r_r(.SBB, Register(dst), Register(src)) } -inst_sbb_m32_r32 :: #force_inline proc "contextless" (dst: Mem32, src: GPR32) -> Instruction { return inst_m_r(.SBB, dst.mem, 4, Register(src)) } -inst_sbb_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return inst_r_r(.SBB, Register(dst), Register(src)) } -inst_sbb_m64_r64 :: #force_inline proc "contextless" (dst: Mem64, src: GPR64) -> Instruction { return inst_m_r(.SBB, dst.mem, 8, Register(src)) } -inst_sbb_r8_m8 :: #force_inline proc "contextless" (dst: GPR8, src: Mem8) -> Instruction { return inst_r_m(.SBB, Register(dst), src.mem, 1) } -inst_sbb_r16_m16 :: #force_inline proc "contextless" (dst: GPR16, src: Mem16) -> Instruction { return inst_r_m(.SBB, Register(dst), src.mem, 2) } -inst_sbb_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32) -> Instruction { return inst_r_m(.SBB, Register(dst), src.mem, 4) } -inst_sbb_r64_m64 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64) -> Instruction { return inst_r_m(.SBB, Register(dst), src.mem, 8) } -inst_sbb_imm8 :: #force_inline proc "contextless" (imm: i8) -> Instruction { return inst_i(.SBB, i64(imm), 1) } -inst_sbb_imm16 :: #force_inline proc "contextless" (imm: i16) -> Instruction { return inst_i(.SBB, i64(imm), 2) } -inst_sbb_imm32 :: #force_inline proc "contextless" (imm: i32) -> Instruction { return inst_i(.SBB, i64(imm), 4) } -inst_sbb_r8_imm8 :: #force_inline proc "contextless" (dst: GPR8, imm: i8) -> Instruction { return inst_r_i(.SBB, Register(dst), i64(imm), 1) } -inst_sbb_m8_imm8 :: #force_inline proc "contextless" (dst: Mem8, imm: i8) -> Instruction { return inst_m_i(.SBB, dst.mem, 1, i64(imm), 1) } -inst_sbb_r16_imm16 :: #force_inline proc "contextless" (dst: GPR16, imm: i16) -> Instruction { return inst_r_i(.SBB, Register(dst), i64(imm), 2) } -inst_sbb_m16_imm16 :: #force_inline proc "contextless" (dst: Mem16, imm: i16) -> Instruction { return inst_m_i(.SBB, dst.mem, 2, i64(imm), 2) } -inst_sbb_r32_imm32 :: #force_inline proc "contextless" (dst: GPR32, imm: i32) -> Instruction { return inst_r_i(.SBB, Register(dst), i64(imm), 4) } -inst_sbb_m32_imm32 :: #force_inline proc "contextless" (dst: Mem32, imm: i32) -> Instruction { return inst_m_i(.SBB, dst.mem, 4, i64(imm), 4) } -inst_sbb_r64_imm32 :: #force_inline proc "contextless" (dst: GPR64, imm: i32) -> Instruction { return inst_r_i(.SBB, Register(dst), i64(imm), 4) } -inst_sbb_m64_imm32 :: #force_inline proc "contextless" (dst: Mem64, imm: i32) -> Instruction { return inst_m_i(.SBB, dst.mem, 8, i64(imm), 4) } -emit_sbb_r8_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8, src: GPR8) { emit_rr(instructions, .SBB, Register(dst), Register(src)) } -emit_sbb_m8_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8, src: GPR8) { emit_mr(instructions, .SBB, dst.mem, 1, Register(src)) } -emit_sbb_r16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: GPR16) { emit_rr(instructions, .SBB, Register(dst), Register(src)) } -emit_sbb_m16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16, src: GPR16) { emit_mr(instructions, .SBB, dst.mem, 2, Register(src)) } -emit_sbb_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { emit_rr(instructions, .SBB, Register(dst), Register(src)) } -emit_sbb_m32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, src: GPR32) { emit_mr(instructions, .SBB, dst.mem, 4, Register(src)) } -emit_sbb_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { emit_rr(instructions, .SBB, Register(dst), Register(src)) } -emit_sbb_m64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, src: GPR64) { emit_mr(instructions, .SBB, dst.mem, 8, Register(src)) } -emit_sbb_r8_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8, src: Mem8) { emit_rm(instructions, .SBB, Register(dst), src.mem, 1) } -emit_sbb_r16_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: Mem16) { emit_rm(instructions, .SBB, Register(dst), src.mem, 2) } -emit_sbb_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32) { emit_rm(instructions, .SBB, Register(dst), src.mem, 4) } -emit_sbb_r64_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem64) { emit_rm(instructions, .SBB, Register(dst), src.mem, 8) } -emit_sbb_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, imm: i8) { emit_i(instructions, .SBB, i64(imm), 1) } -emit_sbb_imm16 :: #force_inline proc(instructions: ^[dynamic]Instruction, imm: i16) { emit_i(instructions, .SBB, i64(imm), 2) } -emit_sbb_imm32 :: #force_inline proc(instructions: ^[dynamic]Instruction, imm: i32) { emit_i(instructions, .SBB, i64(imm), 4) } -emit_sbb_r8_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8, imm: i8) { emit_ri(instructions, .SBB, Register(dst), i64(imm), 1) } -emit_sbb_m8_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8, imm: i8) { emit_mi(instructions, .SBB, dst.mem, 1, i64(imm), 1) } -emit_sbb_r16_imm16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, imm: i16) { emit_ri(instructions, .SBB, Register(dst), i64(imm), 2) } -emit_sbb_m16_imm16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16, imm: i16) { emit_mi(instructions, .SBB, dst.mem, 2, i64(imm), 2) } -emit_sbb_r32_imm32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, imm: i32) { emit_ri(instructions, .SBB, Register(dst), i64(imm), 4) } -emit_sbb_m32_imm32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, imm: i32) { emit_mi(instructions, .SBB, dst.mem, 4, i64(imm), 4) } -emit_sbb_r64_imm32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, imm: i32) { emit_ri(instructions, .SBB, Register(dst), i64(imm), 4) } -emit_sbb_m64_imm32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, imm: i32) { emit_mi(instructions, .SBB, dst.mem, 8, i64(imm), 4) } -inst_mul_r8 :: #force_inline proc "contextless" (dst: GPR8) -> Instruction { return inst_r(.MUL, Register(dst)) } -inst_mul_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return inst_m(.MUL, dst.mem, 1) } -inst_mul_r16 :: #force_inline proc "contextless" (dst: GPR16) -> Instruction { return inst_r(.MUL, Register(dst)) } -inst_mul_m16 :: #force_inline proc "contextless" (dst: Mem16) -> Instruction { return inst_m(.MUL, dst.mem, 2) } -inst_mul_r32 :: #force_inline proc "contextless" (dst: GPR32) -> Instruction { return inst_r(.MUL, Register(dst)) } -inst_mul_m32 :: #force_inline proc "contextless" (dst: Mem32) -> Instruction { return inst_m(.MUL, dst.mem, 4) } -inst_mul_r64 :: #force_inline proc "contextless" (dst: GPR64) -> Instruction { return inst_r(.MUL, Register(dst)) } -inst_mul_m64 :: #force_inline proc "contextless" (dst: Mem64) -> Instruction { return inst_m(.MUL, dst.mem, 8) } -emit_mul_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8) { emit_r(instructions, .MUL, Register(dst)) } -emit_mul_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { emit_m(instructions, .MUL, dst.mem, 1) } -emit_mul_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16) { emit_r(instructions, .MUL, Register(dst)) } -emit_mul_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16) { emit_m(instructions, .MUL, dst.mem, 2) } -emit_mul_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32) { emit_r(instructions, .MUL, Register(dst)) } -emit_mul_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32) { emit_m(instructions, .MUL, dst.mem, 4) } -emit_mul_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64) { emit_r(instructions, .MUL, Register(dst)) } -emit_mul_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64) { emit_m(instructions, .MUL, dst.mem, 8) } -inst_imul_r8 :: #force_inline proc "contextless" (dst: GPR8) -> Instruction { return inst_r(.IMUL, Register(dst)) } -inst_imul_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return inst_m(.IMUL, dst.mem, 1) } -inst_imul_r16 :: #force_inline proc "contextless" (dst: GPR16) -> Instruction { return inst_r(.IMUL, Register(dst)) } -inst_imul_m16 :: #force_inline proc "contextless" (dst: Mem16) -> Instruction { return inst_m(.IMUL, dst.mem, 2) } -inst_imul_r32 :: #force_inline proc "contextless" (dst: GPR32) -> Instruction { return inst_r(.IMUL, Register(dst)) } -inst_imul_m32 :: #force_inline proc "contextless" (dst: Mem32) -> Instruction { return inst_m(.IMUL, dst.mem, 4) } -inst_imul_r64 :: #force_inline proc "contextless" (dst: GPR64) -> Instruction { return inst_r(.IMUL, Register(dst)) } -inst_imul_m64 :: #force_inline proc "contextless" (dst: Mem64) -> Instruction { return inst_m(.IMUL, dst.mem, 8) } -inst_imul_r16_r16 :: #force_inline proc "contextless" (dst: GPR16, src: GPR16) -> Instruction { return inst_r_r(.IMUL, Register(dst), Register(src)) } -inst_imul_r16_m16 :: #force_inline proc "contextless" (dst: GPR16, src: Mem16) -> Instruction { return inst_r_m(.IMUL, Register(dst), src.mem, 2) } -inst_imul_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return inst_r_r(.IMUL, Register(dst), Register(src)) } -inst_imul_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32) -> Instruction { return inst_r_m(.IMUL, Register(dst), src.mem, 4) } -inst_imul_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return inst_r_r(.IMUL, Register(dst), Register(src)) } -inst_imul_r64_m64 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64) -> Instruction { return inst_r_m(.IMUL, Register(dst), src.mem, 8) } -inst_imul_r16_r16_imm16 :: #force_inline proc "contextless" (dst: GPR16, src: GPR16, imm: i16) -> Instruction { return inst_r_r_i(.IMUL, Register(dst), Register(src), i64(imm), 2) } -inst_imul_r16_m16_imm16 :: #force_inline proc "contextless" (dst: GPR16, src: Mem16, imm: i16) -> Instruction { return inst_r_m_i(.IMUL, Register(dst), src.mem, 2, i64(imm), 2) } -inst_imul_r32_r32_imm32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32, imm: i32) -> Instruction { return inst_r_r_i(.IMUL, Register(dst), Register(src), i64(imm), 4) } -inst_imul_r32_m32_imm32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32, imm: i32) -> Instruction { return inst_r_m_i(.IMUL, Register(dst), src.mem, 4, i64(imm), 4) } -inst_imul_r64_r64_imm32 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64, imm: i32) -> Instruction { return inst_r_r_i(.IMUL, Register(dst), Register(src), i64(imm), 4) } -inst_imul_r64_m64_imm32 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64, imm: i32) -> Instruction { return inst_r_m_i(.IMUL, Register(dst), src.mem, 8, i64(imm), 4) } -emit_imul_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8) { emit_r(instructions, .IMUL, Register(dst)) } -emit_imul_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { emit_m(instructions, .IMUL, dst.mem, 1) } -emit_imul_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16) { emit_r(instructions, .IMUL, Register(dst)) } -emit_imul_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16) { emit_m(instructions, .IMUL, dst.mem, 2) } -emit_imul_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32) { emit_r(instructions, .IMUL, Register(dst)) } -emit_imul_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32) { emit_m(instructions, .IMUL, dst.mem, 4) } -emit_imul_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64) { emit_r(instructions, .IMUL, Register(dst)) } -emit_imul_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64) { emit_m(instructions, .IMUL, dst.mem, 8) } -emit_imul_r16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: GPR16) { emit_rr(instructions, .IMUL, Register(dst), Register(src)) } -emit_imul_r16_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: Mem16) { emit_rm(instructions, .IMUL, Register(dst), src.mem, 2) } -emit_imul_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { emit_rr(instructions, .IMUL, Register(dst), Register(src)) } -emit_imul_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32) { emit_rm(instructions, .IMUL, Register(dst), src.mem, 4) } -emit_imul_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { emit_rr(instructions, .IMUL, Register(dst), Register(src)) } -emit_imul_r64_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem64) { emit_rm(instructions, .IMUL, Register(dst), src.mem, 8) } -emit_imul_r16_r16_imm16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: GPR16, imm: i16) { emit_rri(instructions, .IMUL, Register(dst), Register(src), i64(imm), 2) } -emit_imul_r16_m16_imm16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: Mem16, imm: i16) { emit_rmi(instructions, .IMUL, Register(dst), src.mem, 2, i64(imm), 2) } -emit_imul_r32_r32_imm32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32, imm: i32) { emit_rri(instructions, .IMUL, Register(dst), Register(src), i64(imm), 4) } -emit_imul_r32_m32_imm32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32, imm: i32) { emit_rmi(instructions, .IMUL, Register(dst), src.mem, 4, i64(imm), 4) } -emit_imul_r64_r64_imm32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64, imm: i32) { emit_rri(instructions, .IMUL, Register(dst), Register(src), i64(imm), 4) } -emit_imul_r64_m64_imm32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem64, imm: i32) { emit_rmi(instructions, .IMUL, Register(dst), src.mem, 8, i64(imm), 4) } -inst_div_r8 :: #force_inline proc "contextless" (dst: GPR8) -> Instruction { return inst_r(.DIV, Register(dst)) } -inst_div_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return inst_m(.DIV, dst.mem, 1) } -inst_div_r16 :: #force_inline proc "contextless" (dst: GPR16) -> Instruction { return inst_r(.DIV, Register(dst)) } -inst_div_m16 :: #force_inline proc "contextless" (dst: Mem16) -> Instruction { return inst_m(.DIV, dst.mem, 2) } -inst_div_r32 :: #force_inline proc "contextless" (dst: GPR32) -> Instruction { return inst_r(.DIV, Register(dst)) } -inst_div_m32 :: #force_inline proc "contextless" (dst: Mem32) -> Instruction { return inst_m(.DIV, dst.mem, 4) } -inst_div_r64 :: #force_inline proc "contextless" (dst: GPR64) -> Instruction { return inst_r(.DIV, Register(dst)) } -inst_div_m64 :: #force_inline proc "contextless" (dst: Mem64) -> Instruction { return inst_m(.DIV, dst.mem, 8) } -emit_div_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8) { emit_r(instructions, .DIV, Register(dst)) } -emit_div_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { emit_m(instructions, .DIV, dst.mem, 1) } -emit_div_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16) { emit_r(instructions, .DIV, Register(dst)) } -emit_div_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16) { emit_m(instructions, .DIV, dst.mem, 2) } -emit_div_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32) { emit_r(instructions, .DIV, Register(dst)) } -emit_div_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32) { emit_m(instructions, .DIV, dst.mem, 4) } -emit_div_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64) { emit_r(instructions, .DIV, Register(dst)) } -emit_div_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64) { emit_m(instructions, .DIV, dst.mem, 8) } -inst_idiv_r8 :: #force_inline proc "contextless" (dst: GPR8) -> Instruction { return inst_r(.IDIV, Register(dst)) } -inst_idiv_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return inst_m(.IDIV, dst.mem, 1) } -inst_idiv_r16 :: #force_inline proc "contextless" (dst: GPR16) -> Instruction { return inst_r(.IDIV, Register(dst)) } -inst_idiv_m16 :: #force_inline proc "contextless" (dst: Mem16) -> Instruction { return inst_m(.IDIV, dst.mem, 2) } -inst_idiv_r32 :: #force_inline proc "contextless" (dst: GPR32) -> Instruction { return inst_r(.IDIV, Register(dst)) } -inst_idiv_m32 :: #force_inline proc "contextless" (dst: Mem32) -> Instruction { return inst_m(.IDIV, dst.mem, 4) } -inst_idiv_r64 :: #force_inline proc "contextless" (dst: GPR64) -> Instruction { return inst_r(.IDIV, Register(dst)) } -inst_idiv_m64 :: #force_inline proc "contextless" (dst: Mem64) -> Instruction { return inst_m(.IDIV, dst.mem, 8) } -emit_idiv_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8) { emit_r(instructions, .IDIV, Register(dst)) } -emit_idiv_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { emit_m(instructions, .IDIV, dst.mem, 1) } -emit_idiv_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16) { emit_r(instructions, .IDIV, Register(dst)) } -emit_idiv_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16) { emit_m(instructions, .IDIV, dst.mem, 2) } -emit_idiv_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32) { emit_r(instructions, .IDIV, Register(dst)) } -emit_idiv_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32) { emit_m(instructions, .IDIV, dst.mem, 4) } -emit_idiv_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64) { emit_r(instructions, .IDIV, Register(dst)) } -emit_idiv_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64) { emit_m(instructions, .IDIV, dst.mem, 8) } -inst_inc_r16 :: #force_inline proc "contextless" (dst: GPR16) -> Instruction { return inst_r(.INC, Register(dst)) } -inst_inc_r32 :: #force_inline proc "contextless" (dst: GPR32) -> Instruction { return inst_r(.INC, Register(dst)) } -inst_inc_r8 :: #force_inline proc "contextless" (dst: GPR8) -> Instruction { return inst_r(.INC, Register(dst)) } -inst_inc_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return inst_m(.INC, dst.mem, 1) } -inst_inc_m16 :: #force_inline proc "contextless" (dst: Mem16) -> Instruction { return inst_m(.INC, dst.mem, 2) } -inst_inc_m32 :: #force_inline proc "contextless" (dst: Mem32) -> Instruction { return inst_m(.INC, dst.mem, 4) } -inst_inc_r64 :: #force_inline proc "contextless" (dst: GPR64) -> Instruction { return inst_r(.INC, Register(dst)) } -inst_inc_m64 :: #force_inline proc "contextless" (dst: Mem64) -> Instruction { return inst_m(.INC, dst.mem, 8) } -emit_inc_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16) { emit_r(instructions, .INC, Register(dst)) } -emit_inc_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32) { emit_r(instructions, .INC, Register(dst)) } -emit_inc_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8) { emit_r(instructions, .INC, Register(dst)) } -emit_inc_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { emit_m(instructions, .INC, dst.mem, 1) } -emit_inc_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16) { emit_m(instructions, .INC, dst.mem, 2) } -emit_inc_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32) { emit_m(instructions, .INC, dst.mem, 4) } -emit_inc_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64) { emit_r(instructions, .INC, Register(dst)) } -emit_inc_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64) { emit_m(instructions, .INC, dst.mem, 8) } -inst_dec_r16 :: #force_inline proc "contextless" (dst: GPR16) -> Instruction { return inst_r(.DEC, Register(dst)) } -inst_dec_r32 :: #force_inline proc "contextless" (dst: GPR32) -> Instruction { return inst_r(.DEC, Register(dst)) } -inst_dec_r8 :: #force_inline proc "contextless" (dst: GPR8) -> Instruction { return inst_r(.DEC, Register(dst)) } -inst_dec_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return inst_m(.DEC, dst.mem, 1) } -inst_dec_m16 :: #force_inline proc "contextless" (dst: Mem16) -> Instruction { return inst_m(.DEC, dst.mem, 2) } -inst_dec_m32 :: #force_inline proc "contextless" (dst: Mem32) -> Instruction { return inst_m(.DEC, dst.mem, 4) } -inst_dec_r64 :: #force_inline proc "contextless" (dst: GPR64) -> Instruction { return inst_r(.DEC, Register(dst)) } -inst_dec_m64 :: #force_inline proc "contextless" (dst: Mem64) -> Instruction { return inst_m(.DEC, dst.mem, 8) } -emit_dec_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16) { emit_r(instructions, .DEC, Register(dst)) } -emit_dec_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32) { emit_r(instructions, .DEC, Register(dst)) } -emit_dec_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8) { emit_r(instructions, .DEC, Register(dst)) } -emit_dec_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { emit_m(instructions, .DEC, dst.mem, 1) } -emit_dec_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16) { emit_m(instructions, .DEC, dst.mem, 2) } -emit_dec_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32) { emit_m(instructions, .DEC, dst.mem, 4) } -emit_dec_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64) { emit_r(instructions, .DEC, Register(dst)) } -emit_dec_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64) { emit_m(instructions, .DEC, dst.mem, 8) } -inst_neg_r8 :: #force_inline proc "contextless" (dst: GPR8) -> Instruction { return inst_r(.NEG, Register(dst)) } -inst_neg_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return inst_m(.NEG, dst.mem, 1) } -inst_neg_r16 :: #force_inline proc "contextless" (dst: GPR16) -> Instruction { return inst_r(.NEG, Register(dst)) } -inst_neg_m16 :: #force_inline proc "contextless" (dst: Mem16) -> Instruction { return inst_m(.NEG, dst.mem, 2) } -inst_neg_r32 :: #force_inline proc "contextless" (dst: GPR32) -> Instruction { return inst_r(.NEG, Register(dst)) } -inst_neg_m32 :: #force_inline proc "contextless" (dst: Mem32) -> Instruction { return inst_m(.NEG, dst.mem, 4) } -inst_neg_r64 :: #force_inline proc "contextless" (dst: GPR64) -> Instruction { return inst_r(.NEG, Register(dst)) } -inst_neg_m64 :: #force_inline proc "contextless" (dst: Mem64) -> Instruction { return inst_m(.NEG, dst.mem, 8) } -emit_neg_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8) { emit_r(instructions, .NEG, Register(dst)) } -emit_neg_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { emit_m(instructions, .NEG, dst.mem, 1) } -emit_neg_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16) { emit_r(instructions, .NEG, Register(dst)) } -emit_neg_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16) { emit_m(instructions, .NEG, dst.mem, 2) } -emit_neg_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32) { emit_r(instructions, .NEG, Register(dst)) } -emit_neg_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32) { emit_m(instructions, .NEG, dst.mem, 4) } -emit_neg_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64) { emit_r(instructions, .NEG, Register(dst)) } -emit_neg_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64) { emit_m(instructions, .NEG, dst.mem, 8) } -inst_cmp_r8_r8 :: #force_inline proc "contextless" (dst: GPR8, src: GPR8) -> Instruction { return inst_r_r(.CMP, Register(dst), Register(src)) } -inst_cmp_m8_r8 :: #force_inline proc "contextless" (dst: Mem8, src: GPR8) -> Instruction { return inst_m_r(.CMP, dst.mem, 1, Register(src)) } -inst_cmp_r16_r16 :: #force_inline proc "contextless" (dst: GPR16, src: GPR16) -> Instruction { return inst_r_r(.CMP, Register(dst), Register(src)) } -inst_cmp_m16_r16 :: #force_inline proc "contextless" (dst: Mem16, src: GPR16) -> Instruction { return inst_m_r(.CMP, dst.mem, 2, Register(src)) } -inst_cmp_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return inst_r_r(.CMP, Register(dst), Register(src)) } -inst_cmp_m32_r32 :: #force_inline proc "contextless" (dst: Mem32, src: GPR32) -> Instruction { return inst_m_r(.CMP, dst.mem, 4, Register(src)) } -inst_cmp_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return inst_r_r(.CMP, Register(dst), Register(src)) } -inst_cmp_m64_r64 :: #force_inline proc "contextless" (dst: Mem64, src: GPR64) -> Instruction { return inst_m_r(.CMP, dst.mem, 8, Register(src)) } -inst_cmp_r8_m8 :: #force_inline proc "contextless" (dst: GPR8, src: Mem8) -> Instruction { return inst_r_m(.CMP, Register(dst), src.mem, 1) } -inst_cmp_r16_m16 :: #force_inline proc "contextless" (dst: GPR16, src: Mem16) -> Instruction { return inst_r_m(.CMP, Register(dst), src.mem, 2) } -inst_cmp_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32) -> Instruction { return inst_r_m(.CMP, Register(dst), src.mem, 4) } -inst_cmp_r64_m64 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64) -> Instruction { return inst_r_m(.CMP, Register(dst), src.mem, 8) } -inst_cmp_imm8 :: #force_inline proc "contextless" (imm: i8) -> Instruction { return inst_i(.CMP, i64(imm), 1) } -inst_cmp_imm16 :: #force_inline proc "contextless" (imm: i16) -> Instruction { return inst_i(.CMP, i64(imm), 2) } -inst_cmp_imm32 :: #force_inline proc "contextless" (imm: i32) -> Instruction { return inst_i(.CMP, i64(imm), 4) } -inst_cmp_r8_imm8 :: #force_inline proc "contextless" (dst: GPR8, imm: i8) -> Instruction { return inst_r_i(.CMP, Register(dst), i64(imm), 1) } -inst_cmp_m8_imm8 :: #force_inline proc "contextless" (dst: Mem8, imm: i8) -> Instruction { return inst_m_i(.CMP, dst.mem, 1, i64(imm), 1) } -inst_cmp_r16_imm16 :: #force_inline proc "contextless" (dst: GPR16, imm: i16) -> Instruction { return inst_r_i(.CMP, Register(dst), i64(imm), 2) } -inst_cmp_m16_imm16 :: #force_inline proc "contextless" (dst: Mem16, imm: i16) -> Instruction { return inst_m_i(.CMP, dst.mem, 2, i64(imm), 2) } -inst_cmp_r32_imm32 :: #force_inline proc "contextless" (dst: GPR32, imm: i32) -> Instruction { return inst_r_i(.CMP, Register(dst), i64(imm), 4) } -inst_cmp_m32_imm32 :: #force_inline proc "contextless" (dst: Mem32, imm: i32) -> Instruction { return inst_m_i(.CMP, dst.mem, 4, i64(imm), 4) } -inst_cmp_r64_imm32 :: #force_inline proc "contextless" (dst: GPR64, imm: i32) -> Instruction { return inst_r_i(.CMP, Register(dst), i64(imm), 4) } -inst_cmp_m64_imm32 :: #force_inline proc "contextless" (dst: Mem64, imm: i32) -> Instruction { return inst_m_i(.CMP, dst.mem, 8, i64(imm), 4) } -emit_cmp_r8_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8, src: GPR8) { emit_rr(instructions, .CMP, Register(dst), Register(src)) } -emit_cmp_m8_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8, src: GPR8) { emit_mr(instructions, .CMP, dst.mem, 1, Register(src)) } -emit_cmp_r16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: GPR16) { emit_rr(instructions, .CMP, Register(dst), Register(src)) } -emit_cmp_m16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16, src: GPR16) { emit_mr(instructions, .CMP, dst.mem, 2, Register(src)) } -emit_cmp_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { emit_rr(instructions, .CMP, Register(dst), Register(src)) } -emit_cmp_m32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, src: GPR32) { emit_mr(instructions, .CMP, dst.mem, 4, Register(src)) } -emit_cmp_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { emit_rr(instructions, .CMP, Register(dst), Register(src)) } -emit_cmp_m64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, src: GPR64) { emit_mr(instructions, .CMP, dst.mem, 8, Register(src)) } -emit_cmp_r8_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8, src: Mem8) { emit_rm(instructions, .CMP, Register(dst), src.mem, 1) } -emit_cmp_r16_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: Mem16) { emit_rm(instructions, .CMP, Register(dst), src.mem, 2) } -emit_cmp_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32) { emit_rm(instructions, .CMP, Register(dst), src.mem, 4) } -emit_cmp_r64_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem64) { emit_rm(instructions, .CMP, Register(dst), src.mem, 8) } -emit_cmp_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, imm: i8) { emit_i(instructions, .CMP, i64(imm), 1) } -emit_cmp_imm16 :: #force_inline proc(instructions: ^[dynamic]Instruction, imm: i16) { emit_i(instructions, .CMP, i64(imm), 2) } -emit_cmp_imm32 :: #force_inline proc(instructions: ^[dynamic]Instruction, imm: i32) { emit_i(instructions, .CMP, i64(imm), 4) } -emit_cmp_r8_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8, imm: i8) { emit_ri(instructions, .CMP, Register(dst), i64(imm), 1) } -emit_cmp_m8_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8, imm: i8) { emit_mi(instructions, .CMP, dst.mem, 1, i64(imm), 1) } -emit_cmp_r16_imm16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, imm: i16) { emit_ri(instructions, .CMP, Register(dst), i64(imm), 2) } -emit_cmp_m16_imm16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16, imm: i16) { emit_mi(instructions, .CMP, dst.mem, 2, i64(imm), 2) } -emit_cmp_r32_imm32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, imm: i32) { emit_ri(instructions, .CMP, Register(dst), i64(imm), 4) } -emit_cmp_m32_imm32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, imm: i32) { emit_mi(instructions, .CMP, dst.mem, 4, i64(imm), 4) } -emit_cmp_r64_imm32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, imm: i32) { emit_ri(instructions, .CMP, Register(dst), i64(imm), 4) } -emit_cmp_m64_imm32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, imm: i32) { emit_mi(instructions, .CMP, dst.mem, 8, i64(imm), 4) } -inst_and_r8_r8 :: #force_inline proc "contextless" (dst: GPR8, src: GPR8) -> Instruction { return inst_r_r(.AND, Register(dst), Register(src)) } -inst_and_m8_r8 :: #force_inline proc "contextless" (dst: Mem8, src: GPR8) -> Instruction { return inst_m_r(.AND, dst.mem, 1, Register(src)) } -inst_and_r16_r16 :: #force_inline proc "contextless" (dst: GPR16, src: GPR16) -> Instruction { return inst_r_r(.AND, Register(dst), Register(src)) } -inst_and_m16_r16 :: #force_inline proc "contextless" (dst: Mem16, src: GPR16) -> Instruction { return inst_m_r(.AND, dst.mem, 2, Register(src)) } -inst_and_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return inst_r_r(.AND, Register(dst), Register(src)) } -inst_and_m32_r32 :: #force_inline proc "contextless" (dst: Mem32, src: GPR32) -> Instruction { return inst_m_r(.AND, dst.mem, 4, Register(src)) } -inst_and_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return inst_r_r(.AND, Register(dst), Register(src)) } -inst_and_m64_r64 :: #force_inline proc "contextless" (dst: Mem64, src: GPR64) -> Instruction { return inst_m_r(.AND, dst.mem, 8, Register(src)) } -inst_and_r8_m8 :: #force_inline proc "contextless" (dst: GPR8, src: Mem8) -> Instruction { return inst_r_m(.AND, Register(dst), src.mem, 1) } -inst_and_r16_m16 :: #force_inline proc "contextless" (dst: GPR16, src: Mem16) -> Instruction { return inst_r_m(.AND, Register(dst), src.mem, 2) } -inst_and_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32) -> Instruction { return inst_r_m(.AND, Register(dst), src.mem, 4) } -inst_and_r64_m64 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64) -> Instruction { return inst_r_m(.AND, Register(dst), src.mem, 8) } -inst_and_imm8 :: #force_inline proc "contextless" (imm: i8) -> Instruction { return inst_i(.AND, i64(imm), 1) } -inst_and_imm16 :: #force_inline proc "contextless" (imm: i16) -> Instruction { return inst_i(.AND, i64(imm), 2) } -inst_and_imm32 :: #force_inline proc "contextless" (imm: i32) -> Instruction { return inst_i(.AND, i64(imm), 4) } -inst_and_r8_imm8 :: #force_inline proc "contextless" (dst: GPR8, imm: i8) -> Instruction { return inst_r_i(.AND, Register(dst), i64(imm), 1) } -inst_and_m8_imm8 :: #force_inline proc "contextless" (dst: Mem8, imm: i8) -> Instruction { return inst_m_i(.AND, dst.mem, 1, i64(imm), 1) } -inst_and_r16_imm16 :: #force_inline proc "contextless" (dst: GPR16, imm: i16) -> Instruction { return inst_r_i(.AND, Register(dst), i64(imm), 2) } -inst_and_m16_imm16 :: #force_inline proc "contextless" (dst: Mem16, imm: i16) -> Instruction { return inst_m_i(.AND, dst.mem, 2, i64(imm), 2) } -inst_and_r32_imm32 :: #force_inline proc "contextless" (dst: GPR32, imm: i32) -> Instruction { return inst_r_i(.AND, Register(dst), i64(imm), 4) } -inst_and_m32_imm32 :: #force_inline proc "contextless" (dst: Mem32, imm: i32) -> Instruction { return inst_m_i(.AND, dst.mem, 4, i64(imm), 4) } -inst_and_r64_imm32 :: #force_inline proc "contextless" (dst: GPR64, imm: i32) -> Instruction { return inst_r_i(.AND, Register(dst), i64(imm), 4) } -inst_and_m64_imm32 :: #force_inline proc "contextless" (dst: Mem64, imm: i32) -> Instruction { return inst_m_i(.AND, dst.mem, 8, i64(imm), 4) } -emit_and_r8_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8, src: GPR8) { emit_rr(instructions, .AND, Register(dst), Register(src)) } -emit_and_m8_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8, src: GPR8) { emit_mr(instructions, .AND, dst.mem, 1, Register(src)) } -emit_and_r16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: GPR16) { emit_rr(instructions, .AND, Register(dst), Register(src)) } -emit_and_m16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16, src: GPR16) { emit_mr(instructions, .AND, dst.mem, 2, Register(src)) } -emit_and_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { emit_rr(instructions, .AND, Register(dst), Register(src)) } -emit_and_m32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, src: GPR32) { emit_mr(instructions, .AND, dst.mem, 4, Register(src)) } -emit_and_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { emit_rr(instructions, .AND, Register(dst), Register(src)) } -emit_and_m64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, src: GPR64) { emit_mr(instructions, .AND, dst.mem, 8, Register(src)) } -emit_and_r8_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8, src: Mem8) { emit_rm(instructions, .AND, Register(dst), src.mem, 1) } -emit_and_r16_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: Mem16) { emit_rm(instructions, .AND, Register(dst), src.mem, 2) } -emit_and_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32) { emit_rm(instructions, .AND, Register(dst), src.mem, 4) } -emit_and_r64_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem64) { emit_rm(instructions, .AND, Register(dst), src.mem, 8) } -emit_and_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, imm: i8) { emit_i(instructions, .AND, i64(imm), 1) } -emit_and_imm16 :: #force_inline proc(instructions: ^[dynamic]Instruction, imm: i16) { emit_i(instructions, .AND, i64(imm), 2) } -emit_and_imm32 :: #force_inline proc(instructions: ^[dynamic]Instruction, imm: i32) { emit_i(instructions, .AND, i64(imm), 4) } -emit_and_r8_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8, imm: i8) { emit_ri(instructions, .AND, Register(dst), i64(imm), 1) } -emit_and_m8_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8, imm: i8) { emit_mi(instructions, .AND, dst.mem, 1, i64(imm), 1) } -emit_and_r16_imm16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, imm: i16) { emit_ri(instructions, .AND, Register(dst), i64(imm), 2) } -emit_and_m16_imm16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16, imm: i16) { emit_mi(instructions, .AND, dst.mem, 2, i64(imm), 2) } -emit_and_r32_imm32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, imm: i32) { emit_ri(instructions, .AND, Register(dst), i64(imm), 4) } -emit_and_m32_imm32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, imm: i32) { emit_mi(instructions, .AND, dst.mem, 4, i64(imm), 4) } -emit_and_r64_imm32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, imm: i32) { emit_ri(instructions, .AND, Register(dst), i64(imm), 4) } -emit_and_m64_imm32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, imm: i32) { emit_mi(instructions, .AND, dst.mem, 8, i64(imm), 4) } -inst_or_r8_r8 :: #force_inline proc "contextless" (dst: GPR8, src: GPR8) -> Instruction { return inst_r_r(.OR, Register(dst), Register(src)) } -inst_or_m8_r8 :: #force_inline proc "contextless" (dst: Mem8, src: GPR8) -> Instruction { return inst_m_r(.OR, dst.mem, 1, Register(src)) } -inst_or_r16_r16 :: #force_inline proc "contextless" (dst: GPR16, src: GPR16) -> Instruction { return inst_r_r(.OR, Register(dst), Register(src)) } -inst_or_m16_r16 :: #force_inline proc "contextless" (dst: Mem16, src: GPR16) -> Instruction { return inst_m_r(.OR, dst.mem, 2, Register(src)) } -inst_or_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return inst_r_r(.OR, Register(dst), Register(src)) } -inst_or_m32_r32 :: #force_inline proc "contextless" (dst: Mem32, src: GPR32) -> Instruction { return inst_m_r(.OR, dst.mem, 4, Register(src)) } -inst_or_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return inst_r_r(.OR, Register(dst), Register(src)) } -inst_or_m64_r64 :: #force_inline proc "contextless" (dst: Mem64, src: GPR64) -> Instruction { return inst_m_r(.OR, dst.mem, 8, Register(src)) } -inst_or_r8_m8 :: #force_inline proc "contextless" (dst: GPR8, src: Mem8) -> Instruction { return inst_r_m(.OR, Register(dst), src.mem, 1) } -inst_or_r16_m16 :: #force_inline proc "contextless" (dst: GPR16, src: Mem16) -> Instruction { return inst_r_m(.OR, Register(dst), src.mem, 2) } -inst_or_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32) -> Instruction { return inst_r_m(.OR, Register(dst), src.mem, 4) } -inst_or_r64_m64 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64) -> Instruction { return inst_r_m(.OR, Register(dst), src.mem, 8) } -inst_or_imm8 :: #force_inline proc "contextless" (imm: i8) -> Instruction { return inst_i(.OR, i64(imm), 1) } -inst_or_imm16 :: #force_inline proc "contextless" (imm: i16) -> Instruction { return inst_i(.OR, i64(imm), 2) } -inst_or_imm32 :: #force_inline proc "contextless" (imm: i32) -> Instruction { return inst_i(.OR, i64(imm), 4) } -inst_or_r8_imm8 :: #force_inline proc "contextless" (dst: GPR8, imm: i8) -> Instruction { return inst_r_i(.OR, Register(dst), i64(imm), 1) } -inst_or_m8_imm8 :: #force_inline proc "contextless" (dst: Mem8, imm: i8) -> Instruction { return inst_m_i(.OR, dst.mem, 1, i64(imm), 1) } -inst_or_r16_imm16 :: #force_inline proc "contextless" (dst: GPR16, imm: i16) -> Instruction { return inst_r_i(.OR, Register(dst), i64(imm), 2) } -inst_or_m16_imm16 :: #force_inline proc "contextless" (dst: Mem16, imm: i16) -> Instruction { return inst_m_i(.OR, dst.mem, 2, i64(imm), 2) } -inst_or_r32_imm32 :: #force_inline proc "contextless" (dst: GPR32, imm: i32) -> Instruction { return inst_r_i(.OR, Register(dst), i64(imm), 4) } -inst_or_m32_imm32 :: #force_inline proc "contextless" (dst: Mem32, imm: i32) -> Instruction { return inst_m_i(.OR, dst.mem, 4, i64(imm), 4) } -inst_or_r64_imm32 :: #force_inline proc "contextless" (dst: GPR64, imm: i32) -> Instruction { return inst_r_i(.OR, Register(dst), i64(imm), 4) } -inst_or_m64_imm32 :: #force_inline proc "contextless" (dst: Mem64, imm: i32) -> Instruction { return inst_m_i(.OR, dst.mem, 8, i64(imm), 4) } -emit_or_r8_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8, src: GPR8) { emit_rr(instructions, .OR, Register(dst), Register(src)) } -emit_or_m8_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8, src: GPR8) { emit_mr(instructions, .OR, dst.mem, 1, Register(src)) } -emit_or_r16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: GPR16) { emit_rr(instructions, .OR, Register(dst), Register(src)) } -emit_or_m16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16, src: GPR16) { emit_mr(instructions, .OR, dst.mem, 2, Register(src)) } -emit_or_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { emit_rr(instructions, .OR, Register(dst), Register(src)) } -emit_or_m32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, src: GPR32) { emit_mr(instructions, .OR, dst.mem, 4, Register(src)) } -emit_or_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { emit_rr(instructions, .OR, Register(dst), Register(src)) } -emit_or_m64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, src: GPR64) { emit_mr(instructions, .OR, dst.mem, 8, Register(src)) } -emit_or_r8_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8, src: Mem8) { emit_rm(instructions, .OR, Register(dst), src.mem, 1) } -emit_or_r16_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: Mem16) { emit_rm(instructions, .OR, Register(dst), src.mem, 2) } -emit_or_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32) { emit_rm(instructions, .OR, Register(dst), src.mem, 4) } -emit_or_r64_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem64) { emit_rm(instructions, .OR, Register(dst), src.mem, 8) } -emit_or_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, imm: i8) { emit_i(instructions, .OR, i64(imm), 1) } -emit_or_imm16 :: #force_inline proc(instructions: ^[dynamic]Instruction, imm: i16) { emit_i(instructions, .OR, i64(imm), 2) } -emit_or_imm32 :: #force_inline proc(instructions: ^[dynamic]Instruction, imm: i32) { emit_i(instructions, .OR, i64(imm), 4) } -emit_or_r8_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8, imm: i8) { emit_ri(instructions, .OR, Register(dst), i64(imm), 1) } -emit_or_m8_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8, imm: i8) { emit_mi(instructions, .OR, dst.mem, 1, i64(imm), 1) } -emit_or_r16_imm16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, imm: i16) { emit_ri(instructions, .OR, Register(dst), i64(imm), 2) } -emit_or_m16_imm16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16, imm: i16) { emit_mi(instructions, .OR, dst.mem, 2, i64(imm), 2) } -emit_or_r32_imm32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, imm: i32) { emit_ri(instructions, .OR, Register(dst), i64(imm), 4) } -emit_or_m32_imm32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, imm: i32) { emit_mi(instructions, .OR, dst.mem, 4, i64(imm), 4) } -emit_or_r64_imm32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, imm: i32) { emit_ri(instructions, .OR, Register(dst), i64(imm), 4) } -emit_or_m64_imm32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, imm: i32) { emit_mi(instructions, .OR, dst.mem, 8, i64(imm), 4) } -inst_xor_r8_r8 :: #force_inline proc "contextless" (dst: GPR8, src: GPR8) -> Instruction { return inst_r_r(.XOR, Register(dst), Register(src)) } -inst_xor_m8_r8 :: #force_inline proc "contextless" (dst: Mem8, src: GPR8) -> Instruction { return inst_m_r(.XOR, dst.mem, 1, Register(src)) } -inst_xor_r16_r16 :: #force_inline proc "contextless" (dst: GPR16, src: GPR16) -> Instruction { return inst_r_r(.XOR, Register(dst), Register(src)) } -inst_xor_m16_r16 :: #force_inline proc "contextless" (dst: Mem16, src: GPR16) -> Instruction { return inst_m_r(.XOR, dst.mem, 2, Register(src)) } -inst_xor_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return inst_r_r(.XOR, Register(dst), Register(src)) } -inst_xor_m32_r32 :: #force_inline proc "contextless" (dst: Mem32, src: GPR32) -> Instruction { return inst_m_r(.XOR, dst.mem, 4, Register(src)) } -inst_xor_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return inst_r_r(.XOR, Register(dst), Register(src)) } -inst_xor_m64_r64 :: #force_inline proc "contextless" (dst: Mem64, src: GPR64) -> Instruction { return inst_m_r(.XOR, dst.mem, 8, Register(src)) } -inst_xor_r8_m8 :: #force_inline proc "contextless" (dst: GPR8, src: Mem8) -> Instruction { return inst_r_m(.XOR, Register(dst), src.mem, 1) } -inst_xor_r16_m16 :: #force_inline proc "contextless" (dst: GPR16, src: Mem16) -> Instruction { return inst_r_m(.XOR, Register(dst), src.mem, 2) } -inst_xor_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32) -> Instruction { return inst_r_m(.XOR, Register(dst), src.mem, 4) } -inst_xor_r64_m64 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64) -> Instruction { return inst_r_m(.XOR, Register(dst), src.mem, 8) } -inst_xor_imm8 :: #force_inline proc "contextless" (imm: i8) -> Instruction { return inst_i(.XOR, i64(imm), 1) } -inst_xor_imm16 :: #force_inline proc "contextless" (imm: i16) -> Instruction { return inst_i(.XOR, i64(imm), 2) } -inst_xor_imm32 :: #force_inline proc "contextless" (imm: i32) -> Instruction { return inst_i(.XOR, i64(imm), 4) } -inst_xor_r8_imm8 :: #force_inline proc "contextless" (dst: GPR8, imm: i8) -> Instruction { return inst_r_i(.XOR, Register(dst), i64(imm), 1) } -inst_xor_m8_imm8 :: #force_inline proc "contextless" (dst: Mem8, imm: i8) -> Instruction { return inst_m_i(.XOR, dst.mem, 1, i64(imm), 1) } -inst_xor_r16_imm16 :: #force_inline proc "contextless" (dst: GPR16, imm: i16) -> Instruction { return inst_r_i(.XOR, Register(dst), i64(imm), 2) } -inst_xor_m16_imm16 :: #force_inline proc "contextless" (dst: Mem16, imm: i16) -> Instruction { return inst_m_i(.XOR, dst.mem, 2, i64(imm), 2) } -inst_xor_r32_imm32 :: #force_inline proc "contextless" (dst: GPR32, imm: i32) -> Instruction { return inst_r_i(.XOR, Register(dst), i64(imm), 4) } -inst_xor_m32_imm32 :: #force_inline proc "contextless" (dst: Mem32, imm: i32) -> Instruction { return inst_m_i(.XOR, dst.mem, 4, i64(imm), 4) } -inst_xor_r64_imm32 :: #force_inline proc "contextless" (dst: GPR64, imm: i32) -> Instruction { return inst_r_i(.XOR, Register(dst), i64(imm), 4) } -inst_xor_m64_imm32 :: #force_inline proc "contextless" (dst: Mem64, imm: i32) -> Instruction { return inst_m_i(.XOR, dst.mem, 8, i64(imm), 4) } -emit_xor_r8_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8, src: GPR8) { emit_rr(instructions, .XOR, Register(dst), Register(src)) } -emit_xor_m8_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8, src: GPR8) { emit_mr(instructions, .XOR, dst.mem, 1, Register(src)) } -emit_xor_r16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: GPR16) { emit_rr(instructions, .XOR, Register(dst), Register(src)) } -emit_xor_m16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16, src: GPR16) { emit_mr(instructions, .XOR, dst.mem, 2, Register(src)) } -emit_xor_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { emit_rr(instructions, .XOR, Register(dst), Register(src)) } -emit_xor_m32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, src: GPR32) { emit_mr(instructions, .XOR, dst.mem, 4, Register(src)) } -emit_xor_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { emit_rr(instructions, .XOR, Register(dst), Register(src)) } -emit_xor_m64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, src: GPR64) { emit_mr(instructions, .XOR, dst.mem, 8, Register(src)) } -emit_xor_r8_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8, src: Mem8) { emit_rm(instructions, .XOR, Register(dst), src.mem, 1) } -emit_xor_r16_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: Mem16) { emit_rm(instructions, .XOR, Register(dst), src.mem, 2) } -emit_xor_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32) { emit_rm(instructions, .XOR, Register(dst), src.mem, 4) } -emit_xor_r64_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem64) { emit_rm(instructions, .XOR, Register(dst), src.mem, 8) } -emit_xor_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, imm: i8) { emit_i(instructions, .XOR, i64(imm), 1) } -emit_xor_imm16 :: #force_inline proc(instructions: ^[dynamic]Instruction, imm: i16) { emit_i(instructions, .XOR, i64(imm), 2) } -emit_xor_imm32 :: #force_inline proc(instructions: ^[dynamic]Instruction, imm: i32) { emit_i(instructions, .XOR, i64(imm), 4) } -emit_xor_r8_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8, imm: i8) { emit_ri(instructions, .XOR, Register(dst), i64(imm), 1) } -emit_xor_m8_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8, imm: i8) { emit_mi(instructions, .XOR, dst.mem, 1, i64(imm), 1) } -emit_xor_r16_imm16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, imm: i16) { emit_ri(instructions, .XOR, Register(dst), i64(imm), 2) } -emit_xor_m16_imm16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16, imm: i16) { emit_mi(instructions, .XOR, dst.mem, 2, i64(imm), 2) } -emit_xor_r32_imm32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, imm: i32) { emit_ri(instructions, .XOR, Register(dst), i64(imm), 4) } -emit_xor_m32_imm32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, imm: i32) { emit_mi(instructions, .XOR, dst.mem, 4, i64(imm), 4) } -emit_xor_r64_imm32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, imm: i32) { emit_ri(instructions, .XOR, Register(dst), i64(imm), 4) } -emit_xor_m64_imm32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, imm: i32) { emit_mi(instructions, .XOR, dst.mem, 8, i64(imm), 4) } -inst_not_r8 :: #force_inline proc "contextless" (dst: GPR8) -> Instruction { return inst_r(.NOT, Register(dst)) } -inst_not_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return inst_m(.NOT, dst.mem, 1) } -inst_not_r16 :: #force_inline proc "contextless" (dst: GPR16) -> Instruction { return inst_r(.NOT, Register(dst)) } -inst_not_m16 :: #force_inline proc "contextless" (dst: Mem16) -> Instruction { return inst_m(.NOT, dst.mem, 2) } -inst_not_r32 :: #force_inline proc "contextless" (dst: GPR32) -> Instruction { return inst_r(.NOT, Register(dst)) } -inst_not_m32 :: #force_inline proc "contextless" (dst: Mem32) -> Instruction { return inst_m(.NOT, dst.mem, 4) } -inst_not_r64 :: #force_inline proc "contextless" (dst: GPR64) -> Instruction { return inst_r(.NOT, Register(dst)) } -inst_not_m64 :: #force_inline proc "contextless" (dst: Mem64) -> Instruction { return inst_m(.NOT, dst.mem, 8) } -emit_not_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8) { emit_r(instructions, .NOT, Register(dst)) } -emit_not_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { emit_m(instructions, .NOT, dst.mem, 1) } -emit_not_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16) { emit_r(instructions, .NOT, Register(dst)) } -emit_not_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16) { emit_m(instructions, .NOT, dst.mem, 2) } -emit_not_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32) { emit_r(instructions, .NOT, Register(dst)) } -emit_not_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32) { emit_m(instructions, .NOT, dst.mem, 4) } -emit_not_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64) { emit_r(instructions, .NOT, Register(dst)) } -emit_not_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64) { emit_m(instructions, .NOT, dst.mem, 8) } -inst_test_r8_r8 :: #force_inline proc "contextless" (dst: GPR8, src: GPR8) -> Instruction { return inst_r_r(.TEST, Register(dst), Register(src)) } -inst_test_m8_r8 :: #force_inline proc "contextless" (dst: Mem8, src: GPR8) -> Instruction { return inst_m_r(.TEST, dst.mem, 1, Register(src)) } -inst_test_r16_r16 :: #force_inline proc "contextless" (dst: GPR16, src: GPR16) -> Instruction { return inst_r_r(.TEST, Register(dst), Register(src)) } -inst_test_m16_r16 :: #force_inline proc "contextless" (dst: Mem16, src: GPR16) -> Instruction { return inst_m_r(.TEST, dst.mem, 2, Register(src)) } -inst_test_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return inst_r_r(.TEST, Register(dst), Register(src)) } -inst_test_m32_r32 :: #force_inline proc "contextless" (dst: Mem32, src: GPR32) -> Instruction { return inst_m_r(.TEST, dst.mem, 4, Register(src)) } -inst_test_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return inst_r_r(.TEST, Register(dst), Register(src)) } -inst_test_m64_r64 :: #force_inline proc "contextless" (dst: Mem64, src: GPR64) -> Instruction { return inst_m_r(.TEST, dst.mem, 8, Register(src)) } -inst_test_imm8 :: #force_inline proc "contextless" (imm: i8) -> Instruction { return inst_i(.TEST, i64(imm), 1) } -inst_test_imm16 :: #force_inline proc "contextless" (imm: i16) -> Instruction { return inst_i(.TEST, i64(imm), 2) } -inst_test_imm32 :: #force_inline proc "contextless" (imm: i32) -> Instruction { return inst_i(.TEST, i64(imm), 4) } -inst_test_r8_imm8 :: #force_inline proc "contextless" (dst: GPR8, imm: i8) -> Instruction { return inst_r_i(.TEST, Register(dst), i64(imm), 1) } -inst_test_m8_imm8 :: #force_inline proc "contextless" (dst: Mem8, imm: i8) -> Instruction { return inst_m_i(.TEST, dst.mem, 1, i64(imm), 1) } -inst_test_r16_imm16 :: #force_inline proc "contextless" (dst: GPR16, imm: i16) -> Instruction { return inst_r_i(.TEST, Register(dst), i64(imm), 2) } -inst_test_m16_imm16 :: #force_inline proc "contextless" (dst: Mem16, imm: i16) -> Instruction { return inst_m_i(.TEST, dst.mem, 2, i64(imm), 2) } -inst_test_r32_imm32 :: #force_inline proc "contextless" (dst: GPR32, imm: i32) -> Instruction { return inst_r_i(.TEST, Register(dst), i64(imm), 4) } -inst_test_m32_imm32 :: #force_inline proc "contextless" (dst: Mem32, imm: i32) -> Instruction { return inst_m_i(.TEST, dst.mem, 4, i64(imm), 4) } -inst_test_r64_imm32 :: #force_inline proc "contextless" (dst: GPR64, imm: i32) -> Instruction { return inst_r_i(.TEST, Register(dst), i64(imm), 4) } -inst_test_m64_imm32 :: #force_inline proc "contextless" (dst: Mem64, imm: i32) -> Instruction { return inst_m_i(.TEST, dst.mem, 8, i64(imm), 4) } -emit_test_r8_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8, src: GPR8) { emit_rr(instructions, .TEST, Register(dst), Register(src)) } -emit_test_m8_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8, src: GPR8) { emit_mr(instructions, .TEST, dst.mem, 1, Register(src)) } -emit_test_r16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: GPR16) { emit_rr(instructions, .TEST, Register(dst), Register(src)) } -emit_test_m16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16, src: GPR16) { emit_mr(instructions, .TEST, dst.mem, 2, Register(src)) } -emit_test_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { emit_rr(instructions, .TEST, Register(dst), Register(src)) } -emit_test_m32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, src: GPR32) { emit_mr(instructions, .TEST, dst.mem, 4, Register(src)) } -emit_test_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { emit_rr(instructions, .TEST, Register(dst), Register(src)) } -emit_test_m64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, src: GPR64) { emit_mr(instructions, .TEST, dst.mem, 8, Register(src)) } -emit_test_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, imm: i8) { emit_i(instructions, .TEST, i64(imm), 1) } -emit_test_imm16 :: #force_inline proc(instructions: ^[dynamic]Instruction, imm: i16) { emit_i(instructions, .TEST, i64(imm), 2) } -emit_test_imm32 :: #force_inline proc(instructions: ^[dynamic]Instruction, imm: i32) { emit_i(instructions, .TEST, i64(imm), 4) } -emit_test_r8_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8, imm: i8) { emit_ri(instructions, .TEST, Register(dst), i64(imm), 1) } -emit_test_m8_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8, imm: i8) { emit_mi(instructions, .TEST, dst.mem, 1, i64(imm), 1) } -emit_test_r16_imm16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, imm: i16) { emit_ri(instructions, .TEST, Register(dst), i64(imm), 2) } -emit_test_m16_imm16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16, imm: i16) { emit_mi(instructions, .TEST, dst.mem, 2, i64(imm), 2) } -emit_test_r32_imm32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, imm: i32) { emit_ri(instructions, .TEST, Register(dst), i64(imm), 4) } -emit_test_m32_imm32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, imm: i32) { emit_mi(instructions, .TEST, dst.mem, 4, i64(imm), 4) } -emit_test_r64_imm32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, imm: i32) { emit_ri(instructions, .TEST, Register(dst), i64(imm), 4) } -emit_test_m64_imm32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, imm: i32) { emit_mi(instructions, .TEST, dst.mem, 8, i64(imm), 4) } -inst_shl_r8 :: #force_inline proc "contextless" (dst: GPR8) -> Instruction { return inst_r(.SHL, Register(dst)) } -inst_shl_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return inst_m(.SHL, dst.mem, 1) } -inst_shl_r8_imm8 :: #force_inline proc "contextless" (dst: GPR8, imm: i8) -> Instruction { return inst_r_i(.SHL, Register(dst), i64(imm), 1) } -inst_shl_m8_imm8 :: #force_inline proc "contextless" (dst: Mem8, imm: i8) -> Instruction { return inst_m_i(.SHL, dst.mem, 1, i64(imm), 1) } -inst_shl_r16 :: #force_inline proc "contextless" (dst: GPR16) -> Instruction { return inst_r(.SHL, Register(dst)) } -inst_shl_m16 :: #force_inline proc "contextless" (dst: Mem16) -> Instruction { return inst_m(.SHL, dst.mem, 2) } -inst_shl_r16_imm8 :: #force_inline proc "contextless" (dst: GPR16, imm: i8) -> Instruction { return inst_r_i(.SHL, Register(dst), i64(imm), 1) } -inst_shl_m16_imm8 :: #force_inline proc "contextless" (dst: Mem16, imm: i8) -> Instruction { return inst_m_i(.SHL, dst.mem, 2, i64(imm), 1) } -inst_shl_r32 :: #force_inline proc "contextless" (dst: GPR32) -> Instruction { return inst_r(.SHL, Register(dst)) } -inst_shl_m32 :: #force_inline proc "contextless" (dst: Mem32) -> Instruction { return inst_m(.SHL, dst.mem, 4) } -inst_shl_r32_imm8 :: #force_inline proc "contextless" (dst: GPR32, imm: i8) -> Instruction { return inst_r_i(.SHL, Register(dst), i64(imm), 1) } -inst_shl_m32_imm8 :: #force_inline proc "contextless" (dst: Mem32, imm: i8) -> Instruction { return inst_m_i(.SHL, dst.mem, 4, i64(imm), 1) } -inst_shl_r64 :: #force_inline proc "contextless" (dst: GPR64) -> Instruction { return inst_r(.SHL, Register(dst)) } -inst_shl_m64 :: #force_inline proc "contextless" (dst: Mem64) -> Instruction { return inst_m(.SHL, dst.mem, 8) } -inst_shl_r64_imm8 :: #force_inline proc "contextless" (dst: GPR64, imm: i8) -> Instruction { return inst_r_i(.SHL, Register(dst), i64(imm), 1) } -inst_shl_m64_imm8 :: #force_inline proc "contextless" (dst: Mem64, imm: i8) -> Instruction { return inst_m_i(.SHL, dst.mem, 8, i64(imm), 1) } -emit_shl_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8) { emit_r(instructions, .SHL, Register(dst)) } -emit_shl_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { emit_m(instructions, .SHL, dst.mem, 1) } -emit_shl_r8_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8, imm: i8) { emit_ri(instructions, .SHL, Register(dst), i64(imm), 1) } -emit_shl_m8_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8, imm: i8) { emit_mi(instructions, .SHL, dst.mem, 1, i64(imm), 1) } -emit_shl_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16) { emit_r(instructions, .SHL, Register(dst)) } -emit_shl_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16) { emit_m(instructions, .SHL, dst.mem, 2) } -emit_shl_r16_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, imm: i8) { emit_ri(instructions, .SHL, Register(dst), i64(imm), 1) } -emit_shl_m16_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16, imm: i8) { emit_mi(instructions, .SHL, dst.mem, 2, i64(imm), 1) } -emit_shl_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32) { emit_r(instructions, .SHL, Register(dst)) } -emit_shl_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32) { emit_m(instructions, .SHL, dst.mem, 4) } -emit_shl_r32_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, imm: i8) { emit_ri(instructions, .SHL, Register(dst), i64(imm), 1) } -emit_shl_m32_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, imm: i8) { emit_mi(instructions, .SHL, dst.mem, 4, i64(imm), 1) } -emit_shl_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64) { emit_r(instructions, .SHL, Register(dst)) } -emit_shl_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64) { emit_m(instructions, .SHL, dst.mem, 8) } -emit_shl_r64_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, imm: i8) { emit_ri(instructions, .SHL, Register(dst), i64(imm), 1) } -emit_shl_m64_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, imm: i8) { emit_mi(instructions, .SHL, dst.mem, 8, i64(imm), 1) } -inst_shr_r8 :: #force_inline proc "contextless" (dst: GPR8) -> Instruction { return inst_r(.SHR, Register(dst)) } -inst_shr_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return inst_m(.SHR, dst.mem, 1) } -inst_shr_r8_imm8 :: #force_inline proc "contextless" (dst: GPR8, imm: i8) -> Instruction { return inst_r_i(.SHR, Register(dst), i64(imm), 1) } -inst_shr_m8_imm8 :: #force_inline proc "contextless" (dst: Mem8, imm: i8) -> Instruction { return inst_m_i(.SHR, dst.mem, 1, i64(imm), 1) } -inst_shr_r16 :: #force_inline proc "contextless" (dst: GPR16) -> Instruction { return inst_r(.SHR, Register(dst)) } -inst_shr_m16 :: #force_inline proc "contextless" (dst: Mem16) -> Instruction { return inst_m(.SHR, dst.mem, 2) } -inst_shr_r16_imm8 :: #force_inline proc "contextless" (dst: GPR16, imm: i8) -> Instruction { return inst_r_i(.SHR, Register(dst), i64(imm), 1) } -inst_shr_m16_imm8 :: #force_inline proc "contextless" (dst: Mem16, imm: i8) -> Instruction { return inst_m_i(.SHR, dst.mem, 2, i64(imm), 1) } -inst_shr_r32 :: #force_inline proc "contextless" (dst: GPR32) -> Instruction { return inst_r(.SHR, Register(dst)) } -inst_shr_m32 :: #force_inline proc "contextless" (dst: Mem32) -> Instruction { return inst_m(.SHR, dst.mem, 4) } -inst_shr_r32_imm8 :: #force_inline proc "contextless" (dst: GPR32, imm: i8) -> Instruction { return inst_r_i(.SHR, Register(dst), i64(imm), 1) } -inst_shr_m32_imm8 :: #force_inline proc "contextless" (dst: Mem32, imm: i8) -> Instruction { return inst_m_i(.SHR, dst.mem, 4, i64(imm), 1) } -inst_shr_r64 :: #force_inline proc "contextless" (dst: GPR64) -> Instruction { return inst_r(.SHR, Register(dst)) } -inst_shr_m64 :: #force_inline proc "contextless" (dst: Mem64) -> Instruction { return inst_m(.SHR, dst.mem, 8) } -inst_shr_r64_imm8 :: #force_inline proc "contextless" (dst: GPR64, imm: i8) -> Instruction { return inst_r_i(.SHR, Register(dst), i64(imm), 1) } -inst_shr_m64_imm8 :: #force_inline proc "contextless" (dst: Mem64, imm: i8) -> Instruction { return inst_m_i(.SHR, dst.mem, 8, i64(imm), 1) } -emit_shr_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8) { emit_r(instructions, .SHR, Register(dst)) } -emit_shr_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { emit_m(instructions, .SHR, dst.mem, 1) } -emit_shr_r8_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8, imm: i8) { emit_ri(instructions, .SHR, Register(dst), i64(imm), 1) } -emit_shr_m8_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8, imm: i8) { emit_mi(instructions, .SHR, dst.mem, 1, i64(imm), 1) } -emit_shr_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16) { emit_r(instructions, .SHR, Register(dst)) } -emit_shr_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16) { emit_m(instructions, .SHR, dst.mem, 2) } -emit_shr_r16_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, imm: i8) { emit_ri(instructions, .SHR, Register(dst), i64(imm), 1) } -emit_shr_m16_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16, imm: i8) { emit_mi(instructions, .SHR, dst.mem, 2, i64(imm), 1) } -emit_shr_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32) { emit_r(instructions, .SHR, Register(dst)) } -emit_shr_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32) { emit_m(instructions, .SHR, dst.mem, 4) } -emit_shr_r32_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, imm: i8) { emit_ri(instructions, .SHR, Register(dst), i64(imm), 1) } -emit_shr_m32_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, imm: i8) { emit_mi(instructions, .SHR, dst.mem, 4, i64(imm), 1) } -emit_shr_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64) { emit_r(instructions, .SHR, Register(dst)) } -emit_shr_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64) { emit_m(instructions, .SHR, dst.mem, 8) } -emit_shr_r64_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, imm: i8) { emit_ri(instructions, .SHR, Register(dst), i64(imm), 1) } -emit_shr_m64_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, imm: i8) { emit_mi(instructions, .SHR, dst.mem, 8, i64(imm), 1) } -inst_sar_r8 :: #force_inline proc "contextless" (dst: GPR8) -> Instruction { return inst_r(.SAR, Register(dst)) } -inst_sar_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return inst_m(.SAR, dst.mem, 1) } -inst_sar_r8_imm8 :: #force_inline proc "contextless" (dst: GPR8, imm: i8) -> Instruction { return inst_r_i(.SAR, Register(dst), i64(imm), 1) } -inst_sar_m8_imm8 :: #force_inline proc "contextless" (dst: Mem8, imm: i8) -> Instruction { return inst_m_i(.SAR, dst.mem, 1, i64(imm), 1) } -inst_sar_r16 :: #force_inline proc "contextless" (dst: GPR16) -> Instruction { return inst_r(.SAR, Register(dst)) } -inst_sar_m16 :: #force_inline proc "contextless" (dst: Mem16) -> Instruction { return inst_m(.SAR, dst.mem, 2) } -inst_sar_r16_imm8 :: #force_inline proc "contextless" (dst: GPR16, imm: i8) -> Instruction { return inst_r_i(.SAR, Register(dst), i64(imm), 1) } -inst_sar_m16_imm8 :: #force_inline proc "contextless" (dst: Mem16, imm: i8) -> Instruction { return inst_m_i(.SAR, dst.mem, 2, i64(imm), 1) } -inst_sar_r32 :: #force_inline proc "contextless" (dst: GPR32) -> Instruction { return inst_r(.SAR, Register(dst)) } -inst_sar_m32 :: #force_inline proc "contextless" (dst: Mem32) -> Instruction { return inst_m(.SAR, dst.mem, 4) } -inst_sar_r32_imm8 :: #force_inline proc "contextless" (dst: GPR32, imm: i8) -> Instruction { return inst_r_i(.SAR, Register(dst), i64(imm), 1) } -inst_sar_m32_imm8 :: #force_inline proc "contextless" (dst: Mem32, imm: i8) -> Instruction { return inst_m_i(.SAR, dst.mem, 4, i64(imm), 1) } -inst_sar_r64 :: #force_inline proc "contextless" (dst: GPR64) -> Instruction { return inst_r(.SAR, Register(dst)) } -inst_sar_m64 :: #force_inline proc "contextless" (dst: Mem64) -> Instruction { return inst_m(.SAR, dst.mem, 8) } -inst_sar_r64_imm8 :: #force_inline proc "contextless" (dst: GPR64, imm: i8) -> Instruction { return inst_r_i(.SAR, Register(dst), i64(imm), 1) } -inst_sar_m64_imm8 :: #force_inline proc "contextless" (dst: Mem64, imm: i8) -> Instruction { return inst_m_i(.SAR, dst.mem, 8, i64(imm), 1) } -emit_sar_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8) { emit_r(instructions, .SAR, Register(dst)) } -emit_sar_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { emit_m(instructions, .SAR, dst.mem, 1) } -emit_sar_r8_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8, imm: i8) { emit_ri(instructions, .SAR, Register(dst), i64(imm), 1) } -emit_sar_m8_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8, imm: i8) { emit_mi(instructions, .SAR, dst.mem, 1, i64(imm), 1) } -emit_sar_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16) { emit_r(instructions, .SAR, Register(dst)) } -emit_sar_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16) { emit_m(instructions, .SAR, dst.mem, 2) } -emit_sar_r16_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, imm: i8) { emit_ri(instructions, .SAR, Register(dst), i64(imm), 1) } -emit_sar_m16_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16, imm: i8) { emit_mi(instructions, .SAR, dst.mem, 2, i64(imm), 1) } -emit_sar_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32) { emit_r(instructions, .SAR, Register(dst)) } -emit_sar_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32) { emit_m(instructions, .SAR, dst.mem, 4) } -emit_sar_r32_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, imm: i8) { emit_ri(instructions, .SAR, Register(dst), i64(imm), 1) } -emit_sar_m32_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, imm: i8) { emit_mi(instructions, .SAR, dst.mem, 4, i64(imm), 1) } -emit_sar_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64) { emit_r(instructions, .SAR, Register(dst)) } -emit_sar_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64) { emit_m(instructions, .SAR, dst.mem, 8) } -emit_sar_r64_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, imm: i8) { emit_ri(instructions, .SAR, Register(dst), i64(imm), 1) } -emit_sar_m64_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, imm: i8) { emit_mi(instructions, .SAR, dst.mem, 8, i64(imm), 1) } -inst_rol_r8 :: #force_inline proc "contextless" (dst: GPR8) -> Instruction { return inst_r(.ROL, Register(dst)) } -inst_rol_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return inst_m(.ROL, dst.mem, 1) } -inst_rol_r8_imm8 :: #force_inline proc "contextless" (dst: GPR8, imm: i8) -> Instruction { return inst_r_i(.ROL, Register(dst), i64(imm), 1) } -inst_rol_m8_imm8 :: #force_inline proc "contextless" (dst: Mem8, imm: i8) -> Instruction { return inst_m_i(.ROL, dst.mem, 1, i64(imm), 1) } -inst_rol_r16 :: #force_inline proc "contextless" (dst: GPR16) -> Instruction { return inst_r(.ROL, Register(dst)) } -inst_rol_m16 :: #force_inline proc "contextless" (dst: Mem16) -> Instruction { return inst_m(.ROL, dst.mem, 2) } -inst_rol_r16_imm8 :: #force_inline proc "contextless" (dst: GPR16, imm: i8) -> Instruction { return inst_r_i(.ROL, Register(dst), i64(imm), 1) } -inst_rol_m16_imm8 :: #force_inline proc "contextless" (dst: Mem16, imm: i8) -> Instruction { return inst_m_i(.ROL, dst.mem, 2, i64(imm), 1) } -inst_rol_r32 :: #force_inline proc "contextless" (dst: GPR32) -> Instruction { return inst_r(.ROL, Register(dst)) } -inst_rol_m32 :: #force_inline proc "contextless" (dst: Mem32) -> Instruction { return inst_m(.ROL, dst.mem, 4) } -inst_rol_r32_imm8 :: #force_inline proc "contextless" (dst: GPR32, imm: i8) -> Instruction { return inst_r_i(.ROL, Register(dst), i64(imm), 1) } -inst_rol_m32_imm8 :: #force_inline proc "contextless" (dst: Mem32, imm: i8) -> Instruction { return inst_m_i(.ROL, dst.mem, 4, i64(imm), 1) } -inst_rol_r64 :: #force_inline proc "contextless" (dst: GPR64) -> Instruction { return inst_r(.ROL, Register(dst)) } -inst_rol_m64 :: #force_inline proc "contextless" (dst: Mem64) -> Instruction { return inst_m(.ROL, dst.mem, 8) } -inst_rol_r64_imm8 :: #force_inline proc "contextless" (dst: GPR64, imm: i8) -> Instruction { return inst_r_i(.ROL, Register(dst), i64(imm), 1) } -inst_rol_m64_imm8 :: #force_inline proc "contextless" (dst: Mem64, imm: i8) -> Instruction { return inst_m_i(.ROL, dst.mem, 8, i64(imm), 1) } -emit_rol_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8) { emit_r(instructions, .ROL, Register(dst)) } -emit_rol_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { emit_m(instructions, .ROL, dst.mem, 1) } -emit_rol_r8_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8, imm: i8) { emit_ri(instructions, .ROL, Register(dst), i64(imm), 1) } -emit_rol_m8_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8, imm: i8) { emit_mi(instructions, .ROL, dst.mem, 1, i64(imm), 1) } -emit_rol_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16) { emit_r(instructions, .ROL, Register(dst)) } -emit_rol_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16) { emit_m(instructions, .ROL, dst.mem, 2) } -emit_rol_r16_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, imm: i8) { emit_ri(instructions, .ROL, Register(dst), i64(imm), 1) } -emit_rol_m16_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16, imm: i8) { emit_mi(instructions, .ROL, dst.mem, 2, i64(imm), 1) } -emit_rol_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32) { emit_r(instructions, .ROL, Register(dst)) } -emit_rol_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32) { emit_m(instructions, .ROL, dst.mem, 4) } -emit_rol_r32_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, imm: i8) { emit_ri(instructions, .ROL, Register(dst), i64(imm), 1) } -emit_rol_m32_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, imm: i8) { emit_mi(instructions, .ROL, dst.mem, 4, i64(imm), 1) } -emit_rol_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64) { emit_r(instructions, .ROL, Register(dst)) } -emit_rol_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64) { emit_m(instructions, .ROL, dst.mem, 8) } -emit_rol_r64_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, imm: i8) { emit_ri(instructions, .ROL, Register(dst), i64(imm), 1) } -emit_rol_m64_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, imm: i8) { emit_mi(instructions, .ROL, dst.mem, 8, i64(imm), 1) } -inst_ror_r8 :: #force_inline proc "contextless" (dst: GPR8) -> Instruction { return inst_r(.ROR, Register(dst)) } -inst_ror_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return inst_m(.ROR, dst.mem, 1) } -inst_ror_r8_imm8 :: #force_inline proc "contextless" (dst: GPR8, imm: i8) -> Instruction { return inst_r_i(.ROR, Register(dst), i64(imm), 1) } -inst_ror_m8_imm8 :: #force_inline proc "contextless" (dst: Mem8, imm: i8) -> Instruction { return inst_m_i(.ROR, dst.mem, 1, i64(imm), 1) } -inst_ror_r16 :: #force_inline proc "contextless" (dst: GPR16) -> Instruction { return inst_r(.ROR, Register(dst)) } -inst_ror_m16 :: #force_inline proc "contextless" (dst: Mem16) -> Instruction { return inst_m(.ROR, dst.mem, 2) } -inst_ror_r16_imm8 :: #force_inline proc "contextless" (dst: GPR16, imm: i8) -> Instruction { return inst_r_i(.ROR, Register(dst), i64(imm), 1) } -inst_ror_m16_imm8 :: #force_inline proc "contextless" (dst: Mem16, imm: i8) -> Instruction { return inst_m_i(.ROR, dst.mem, 2, i64(imm), 1) } -inst_ror_r32 :: #force_inline proc "contextless" (dst: GPR32) -> Instruction { return inst_r(.ROR, Register(dst)) } -inst_ror_m32 :: #force_inline proc "contextless" (dst: Mem32) -> Instruction { return inst_m(.ROR, dst.mem, 4) } -inst_ror_r32_imm8 :: #force_inline proc "contextless" (dst: GPR32, imm: i8) -> Instruction { return inst_r_i(.ROR, Register(dst), i64(imm), 1) } -inst_ror_m32_imm8 :: #force_inline proc "contextless" (dst: Mem32, imm: i8) -> Instruction { return inst_m_i(.ROR, dst.mem, 4, i64(imm), 1) } -inst_ror_r64 :: #force_inline proc "contextless" (dst: GPR64) -> Instruction { return inst_r(.ROR, Register(dst)) } -inst_ror_m64 :: #force_inline proc "contextless" (dst: Mem64) -> Instruction { return inst_m(.ROR, dst.mem, 8) } -inst_ror_r64_imm8 :: #force_inline proc "contextless" (dst: GPR64, imm: i8) -> Instruction { return inst_r_i(.ROR, Register(dst), i64(imm), 1) } -inst_ror_m64_imm8 :: #force_inline proc "contextless" (dst: Mem64, imm: i8) -> Instruction { return inst_m_i(.ROR, dst.mem, 8, i64(imm), 1) } -emit_ror_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8) { emit_r(instructions, .ROR, Register(dst)) } -emit_ror_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { emit_m(instructions, .ROR, dst.mem, 1) } -emit_ror_r8_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8, imm: i8) { emit_ri(instructions, .ROR, Register(dst), i64(imm), 1) } -emit_ror_m8_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8, imm: i8) { emit_mi(instructions, .ROR, dst.mem, 1, i64(imm), 1) } -emit_ror_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16) { emit_r(instructions, .ROR, Register(dst)) } -emit_ror_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16) { emit_m(instructions, .ROR, dst.mem, 2) } -emit_ror_r16_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, imm: i8) { emit_ri(instructions, .ROR, Register(dst), i64(imm), 1) } -emit_ror_m16_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16, imm: i8) { emit_mi(instructions, .ROR, dst.mem, 2, i64(imm), 1) } -emit_ror_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32) { emit_r(instructions, .ROR, Register(dst)) } -emit_ror_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32) { emit_m(instructions, .ROR, dst.mem, 4) } -emit_ror_r32_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, imm: i8) { emit_ri(instructions, .ROR, Register(dst), i64(imm), 1) } -emit_ror_m32_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, imm: i8) { emit_mi(instructions, .ROR, dst.mem, 4, i64(imm), 1) } -emit_ror_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64) { emit_r(instructions, .ROR, Register(dst)) } -emit_ror_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64) { emit_m(instructions, .ROR, dst.mem, 8) } -emit_ror_r64_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, imm: i8) { emit_ri(instructions, .ROR, Register(dst), i64(imm), 1) } -emit_ror_m64_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, imm: i8) { emit_mi(instructions, .ROR, dst.mem, 8, i64(imm), 1) } -inst_rcl_r8 :: #force_inline proc "contextless" (dst: GPR8) -> Instruction { return inst_r(.RCL, Register(dst)) } -inst_rcl_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return inst_m(.RCL, dst.mem, 1) } -inst_rcl_r8_imm8 :: #force_inline proc "contextless" (dst: GPR8, imm: i8) -> Instruction { return inst_r_i(.RCL, Register(dst), i64(imm), 1) } -inst_rcl_m8_imm8 :: #force_inline proc "contextless" (dst: Mem8, imm: i8) -> Instruction { return inst_m_i(.RCL, dst.mem, 1, i64(imm), 1) } -inst_rcl_r16 :: #force_inline proc "contextless" (dst: GPR16) -> Instruction { return inst_r(.RCL, Register(dst)) } -inst_rcl_m16 :: #force_inline proc "contextless" (dst: Mem16) -> Instruction { return inst_m(.RCL, dst.mem, 2) } -inst_rcl_r16_imm8 :: #force_inline proc "contextless" (dst: GPR16, imm: i8) -> Instruction { return inst_r_i(.RCL, Register(dst), i64(imm), 1) } -inst_rcl_m16_imm8 :: #force_inline proc "contextless" (dst: Mem16, imm: i8) -> Instruction { return inst_m_i(.RCL, dst.mem, 2, i64(imm), 1) } -inst_rcl_r32 :: #force_inline proc "contextless" (dst: GPR32) -> Instruction { return inst_r(.RCL, Register(dst)) } -inst_rcl_m32 :: #force_inline proc "contextless" (dst: Mem32) -> Instruction { return inst_m(.RCL, dst.mem, 4) } -inst_rcl_r32_imm8 :: #force_inline proc "contextless" (dst: GPR32, imm: i8) -> Instruction { return inst_r_i(.RCL, Register(dst), i64(imm), 1) } -inst_rcl_m32_imm8 :: #force_inline proc "contextless" (dst: Mem32, imm: i8) -> Instruction { return inst_m_i(.RCL, dst.mem, 4, i64(imm), 1) } -inst_rcl_r64 :: #force_inline proc "contextless" (dst: GPR64) -> Instruction { return inst_r(.RCL, Register(dst)) } -inst_rcl_m64 :: #force_inline proc "contextless" (dst: Mem64) -> Instruction { return inst_m(.RCL, dst.mem, 8) } -inst_rcl_r64_imm8 :: #force_inline proc "contextless" (dst: GPR64, imm: i8) -> Instruction { return inst_r_i(.RCL, Register(dst), i64(imm), 1) } -inst_rcl_m64_imm8 :: #force_inline proc "contextless" (dst: Mem64, imm: i8) -> Instruction { return inst_m_i(.RCL, dst.mem, 8, i64(imm), 1) } -emit_rcl_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8) { emit_r(instructions, .RCL, Register(dst)) } -emit_rcl_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { emit_m(instructions, .RCL, dst.mem, 1) } -emit_rcl_r8_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8, imm: i8) { emit_ri(instructions, .RCL, Register(dst), i64(imm), 1) } -emit_rcl_m8_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8, imm: i8) { emit_mi(instructions, .RCL, dst.mem, 1, i64(imm), 1) } -emit_rcl_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16) { emit_r(instructions, .RCL, Register(dst)) } -emit_rcl_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16) { emit_m(instructions, .RCL, dst.mem, 2) } -emit_rcl_r16_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, imm: i8) { emit_ri(instructions, .RCL, Register(dst), i64(imm), 1) } -emit_rcl_m16_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16, imm: i8) { emit_mi(instructions, .RCL, dst.mem, 2, i64(imm), 1) } -emit_rcl_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32) { emit_r(instructions, .RCL, Register(dst)) } -emit_rcl_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32) { emit_m(instructions, .RCL, dst.mem, 4) } -emit_rcl_r32_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, imm: i8) { emit_ri(instructions, .RCL, Register(dst), i64(imm), 1) } -emit_rcl_m32_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, imm: i8) { emit_mi(instructions, .RCL, dst.mem, 4, i64(imm), 1) } -emit_rcl_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64) { emit_r(instructions, .RCL, Register(dst)) } -emit_rcl_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64) { emit_m(instructions, .RCL, dst.mem, 8) } -emit_rcl_r64_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, imm: i8) { emit_ri(instructions, .RCL, Register(dst), i64(imm), 1) } -emit_rcl_m64_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, imm: i8) { emit_mi(instructions, .RCL, dst.mem, 8, i64(imm), 1) } -inst_rcr_r8 :: #force_inline proc "contextless" (dst: GPR8) -> Instruction { return inst_r(.RCR, Register(dst)) } -inst_rcr_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return inst_m(.RCR, dst.mem, 1) } -inst_rcr_r8_imm8 :: #force_inline proc "contextless" (dst: GPR8, imm: i8) -> Instruction { return inst_r_i(.RCR, Register(dst), i64(imm), 1) } -inst_rcr_m8_imm8 :: #force_inline proc "contextless" (dst: Mem8, imm: i8) -> Instruction { return inst_m_i(.RCR, dst.mem, 1, i64(imm), 1) } -inst_rcr_r16 :: #force_inline proc "contextless" (dst: GPR16) -> Instruction { return inst_r(.RCR, Register(dst)) } -inst_rcr_m16 :: #force_inline proc "contextless" (dst: Mem16) -> Instruction { return inst_m(.RCR, dst.mem, 2) } -inst_rcr_r16_imm8 :: #force_inline proc "contextless" (dst: GPR16, imm: i8) -> Instruction { return inst_r_i(.RCR, Register(dst), i64(imm), 1) } -inst_rcr_m16_imm8 :: #force_inline proc "contextless" (dst: Mem16, imm: i8) -> Instruction { return inst_m_i(.RCR, dst.mem, 2, i64(imm), 1) } -inst_rcr_r32 :: #force_inline proc "contextless" (dst: GPR32) -> Instruction { return inst_r(.RCR, Register(dst)) } -inst_rcr_m32 :: #force_inline proc "contextless" (dst: Mem32) -> Instruction { return inst_m(.RCR, dst.mem, 4) } -inst_rcr_r32_imm8 :: #force_inline proc "contextless" (dst: GPR32, imm: i8) -> Instruction { return inst_r_i(.RCR, Register(dst), i64(imm), 1) } -inst_rcr_m32_imm8 :: #force_inline proc "contextless" (dst: Mem32, imm: i8) -> Instruction { return inst_m_i(.RCR, dst.mem, 4, i64(imm), 1) } -inst_rcr_r64 :: #force_inline proc "contextless" (dst: GPR64) -> Instruction { return inst_r(.RCR, Register(dst)) } -inst_rcr_m64 :: #force_inline proc "contextless" (dst: Mem64) -> Instruction { return inst_m(.RCR, dst.mem, 8) } -inst_rcr_r64_imm8 :: #force_inline proc "contextless" (dst: GPR64, imm: i8) -> Instruction { return inst_r_i(.RCR, Register(dst), i64(imm), 1) } -inst_rcr_m64_imm8 :: #force_inline proc "contextless" (dst: Mem64, imm: i8) -> Instruction { return inst_m_i(.RCR, dst.mem, 8, i64(imm), 1) } -emit_rcr_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8) { emit_r(instructions, .RCR, Register(dst)) } -emit_rcr_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { emit_m(instructions, .RCR, dst.mem, 1) } -emit_rcr_r8_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8, imm: i8) { emit_ri(instructions, .RCR, Register(dst), i64(imm), 1) } -emit_rcr_m8_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8, imm: i8) { emit_mi(instructions, .RCR, dst.mem, 1, i64(imm), 1) } -emit_rcr_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16) { emit_r(instructions, .RCR, Register(dst)) } -emit_rcr_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16) { emit_m(instructions, .RCR, dst.mem, 2) } -emit_rcr_r16_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, imm: i8) { emit_ri(instructions, .RCR, Register(dst), i64(imm), 1) } -emit_rcr_m16_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16, imm: i8) { emit_mi(instructions, .RCR, dst.mem, 2, i64(imm), 1) } -emit_rcr_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32) { emit_r(instructions, .RCR, Register(dst)) } -emit_rcr_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32) { emit_m(instructions, .RCR, dst.mem, 4) } -emit_rcr_r32_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, imm: i8) { emit_ri(instructions, .RCR, Register(dst), i64(imm), 1) } -emit_rcr_m32_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, imm: i8) { emit_mi(instructions, .RCR, dst.mem, 4, i64(imm), 1) } -emit_rcr_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64) { emit_r(instructions, .RCR, Register(dst)) } -emit_rcr_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64) { emit_m(instructions, .RCR, dst.mem, 8) } -emit_rcr_r64_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, imm: i8) { emit_ri(instructions, .RCR, Register(dst), i64(imm), 1) } -emit_rcr_m64_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, imm: i8) { emit_mi(instructions, .RCR, dst.mem, 8, i64(imm), 1) } -inst_shld_r16_r16_imm8 :: #force_inline proc "contextless" (dst: GPR16, src: GPR16, imm: i8) -> Instruction { return inst_r_r_i(.SHLD, Register(dst), Register(src), i64(imm), 1) } -inst_shld_m16_r16_imm8 :: #force_inline proc "contextless" (dst: Mem16, src: GPR16, imm: i8) -> Instruction { return inst_m_r_i(.SHLD, dst.mem, 2, Register(src), i64(imm), 1) } -inst_shld_r32_r32_imm8 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32, imm: i8) -> Instruction { return inst_r_r_i(.SHLD, Register(dst), Register(src), i64(imm), 1) } -inst_shld_m32_r32_imm8 :: #force_inline proc "contextless" (dst: Mem32, src: GPR32, imm: i8) -> Instruction { return inst_m_r_i(.SHLD, dst.mem, 4, Register(src), i64(imm), 1) } -inst_shld_r64_r64_imm8 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64, imm: i8) -> Instruction { return inst_r_r_i(.SHLD, Register(dst), Register(src), i64(imm), 1) } -inst_shld_m64_r64_imm8 :: #force_inline proc "contextless" (dst: Mem64, src: GPR64, imm: i8) -> Instruction { return inst_m_r_i(.SHLD, dst.mem, 8, Register(src), i64(imm), 1) } -inst_shld_r16_r16 :: #force_inline proc "contextless" (dst: GPR16, src: GPR16) -> Instruction { return inst_r_r(.SHLD, Register(dst), Register(src)) } -inst_shld_m16_r16 :: #force_inline proc "contextless" (dst: Mem16, src: GPR16) -> Instruction { return inst_m_r(.SHLD, dst.mem, 2, Register(src)) } -inst_shld_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return inst_r_r(.SHLD, Register(dst), Register(src)) } -inst_shld_m32_r32 :: #force_inline proc "contextless" (dst: Mem32, src: GPR32) -> Instruction { return inst_m_r(.SHLD, dst.mem, 4, Register(src)) } -inst_shld_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return inst_r_r(.SHLD, Register(dst), Register(src)) } -inst_shld_m64_r64 :: #force_inline proc "contextless" (dst: Mem64, src: GPR64) -> Instruction { return inst_m_r(.SHLD, dst.mem, 8, Register(src)) } -emit_shld_r16_r16_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: GPR16, imm: i8) { emit_rri(instructions, .SHLD, Register(dst), Register(src), i64(imm), 1) } -emit_shld_m16_r16_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16, src: GPR16, imm: i8) { emit_mri(instructions, .SHLD, dst.mem, 2, Register(src), i64(imm), 1) } -emit_shld_r32_r32_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32, imm: i8) { emit_rri(instructions, .SHLD, Register(dst), Register(src), i64(imm), 1) } -emit_shld_m32_r32_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, src: GPR32, imm: i8) { emit_mri(instructions, .SHLD, dst.mem, 4, Register(src), i64(imm), 1) } -emit_shld_r64_r64_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64, imm: i8) { emit_rri(instructions, .SHLD, Register(dst), Register(src), i64(imm), 1) } -emit_shld_m64_r64_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, src: GPR64, imm: i8) { emit_mri(instructions, .SHLD, dst.mem, 8, Register(src), i64(imm), 1) } -emit_shld_r16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: GPR16) { emit_rr(instructions, .SHLD, Register(dst), Register(src)) } -emit_shld_m16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16, src: GPR16) { emit_mr(instructions, .SHLD, dst.mem, 2, Register(src)) } -emit_shld_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { emit_rr(instructions, .SHLD, Register(dst), Register(src)) } -emit_shld_m32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, src: GPR32) { emit_mr(instructions, .SHLD, dst.mem, 4, Register(src)) } -emit_shld_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { emit_rr(instructions, .SHLD, Register(dst), Register(src)) } -emit_shld_m64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, src: GPR64) { emit_mr(instructions, .SHLD, dst.mem, 8, Register(src)) } -inst_shrd_r16_r16_imm8 :: #force_inline proc "contextless" (dst: GPR16, src: GPR16, imm: i8) -> Instruction { return inst_r_r_i(.SHRD, Register(dst), Register(src), i64(imm), 1) } -inst_shrd_m16_r16_imm8 :: #force_inline proc "contextless" (dst: Mem16, src: GPR16, imm: i8) -> Instruction { return inst_m_r_i(.SHRD, dst.mem, 2, Register(src), i64(imm), 1) } -inst_shrd_r32_r32_imm8 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32, imm: i8) -> Instruction { return inst_r_r_i(.SHRD, Register(dst), Register(src), i64(imm), 1) } -inst_shrd_m32_r32_imm8 :: #force_inline proc "contextless" (dst: Mem32, src: GPR32, imm: i8) -> Instruction { return inst_m_r_i(.SHRD, dst.mem, 4, Register(src), i64(imm), 1) } -inst_shrd_r64_r64_imm8 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64, imm: i8) -> Instruction { return inst_r_r_i(.SHRD, Register(dst), Register(src), i64(imm), 1) } -inst_shrd_m64_r64_imm8 :: #force_inline proc "contextless" (dst: Mem64, src: GPR64, imm: i8) -> Instruction { return inst_m_r_i(.SHRD, dst.mem, 8, Register(src), i64(imm), 1) } -inst_shrd_r16_r16 :: #force_inline proc "contextless" (dst: GPR16, src: GPR16) -> Instruction { return inst_r_r(.SHRD, Register(dst), Register(src)) } -inst_shrd_m16_r16 :: #force_inline proc "contextless" (dst: Mem16, src: GPR16) -> Instruction { return inst_m_r(.SHRD, dst.mem, 2, Register(src)) } -inst_shrd_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return inst_r_r(.SHRD, Register(dst), Register(src)) } -inst_shrd_m32_r32 :: #force_inline proc "contextless" (dst: Mem32, src: GPR32) -> Instruction { return inst_m_r(.SHRD, dst.mem, 4, Register(src)) } -inst_shrd_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return inst_r_r(.SHRD, Register(dst), Register(src)) } -inst_shrd_m64_r64 :: #force_inline proc "contextless" (dst: Mem64, src: GPR64) -> Instruction { return inst_m_r(.SHRD, dst.mem, 8, Register(src)) } -emit_shrd_r16_r16_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: GPR16, imm: i8) { emit_rri(instructions, .SHRD, Register(dst), Register(src), i64(imm), 1) } -emit_shrd_m16_r16_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16, src: GPR16, imm: i8) { emit_mri(instructions, .SHRD, dst.mem, 2, Register(src), i64(imm), 1) } -emit_shrd_r32_r32_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32, imm: i8) { emit_rri(instructions, .SHRD, Register(dst), Register(src), i64(imm), 1) } -emit_shrd_m32_r32_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, src: GPR32, imm: i8) { emit_mri(instructions, .SHRD, dst.mem, 4, Register(src), i64(imm), 1) } -emit_shrd_r64_r64_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64, imm: i8) { emit_rri(instructions, .SHRD, Register(dst), Register(src), i64(imm), 1) } -emit_shrd_m64_r64_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, src: GPR64, imm: i8) { emit_mri(instructions, .SHRD, dst.mem, 8, Register(src), i64(imm), 1) } -emit_shrd_r16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: GPR16) { emit_rr(instructions, .SHRD, Register(dst), Register(src)) } -emit_shrd_m16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16, src: GPR16) { emit_mr(instructions, .SHRD, dst.mem, 2, Register(src)) } -emit_shrd_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { emit_rr(instructions, .SHRD, Register(dst), Register(src)) } -emit_shrd_m32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, src: GPR32) { emit_mr(instructions, .SHRD, dst.mem, 4, Register(src)) } -emit_shrd_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { emit_rr(instructions, .SHRD, Register(dst), Register(src)) } -emit_shrd_m64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, src: GPR64) { emit_mr(instructions, .SHRD, dst.mem, 8, Register(src)) } -inst_bt_r16_r16 :: #force_inline proc "contextless" (dst: GPR16, src: GPR16) -> Instruction { return inst_r_r(.BT, Register(dst), Register(src)) } -inst_bt_m16_r16 :: #force_inline proc "contextless" (dst: Mem16, src: GPR16) -> Instruction { return inst_m_r(.BT, dst.mem, 2, Register(src)) } -inst_bt_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return inst_r_r(.BT, Register(dst), Register(src)) } -inst_bt_m32_r32 :: #force_inline proc "contextless" (dst: Mem32, src: GPR32) -> Instruction { return inst_m_r(.BT, dst.mem, 4, Register(src)) } -inst_bt_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return inst_r_r(.BT, Register(dst), Register(src)) } -inst_bt_m64_r64 :: #force_inline proc "contextless" (dst: Mem64, src: GPR64) -> Instruction { return inst_m_r(.BT, dst.mem, 8, Register(src)) } -inst_bt_r16_imm8 :: #force_inline proc "contextless" (dst: GPR16, imm: i8) -> Instruction { return inst_r_i(.BT, Register(dst), i64(imm), 1) } -inst_bt_m16_imm8 :: #force_inline proc "contextless" (dst: Mem16, imm: i8) -> Instruction { return inst_m_i(.BT, dst.mem, 2, i64(imm), 1) } -inst_bt_r32_imm8 :: #force_inline proc "contextless" (dst: GPR32, imm: i8) -> Instruction { return inst_r_i(.BT, Register(dst), i64(imm), 1) } -inst_bt_m32_imm8 :: #force_inline proc "contextless" (dst: Mem32, imm: i8) -> Instruction { return inst_m_i(.BT, dst.mem, 4, i64(imm), 1) } -inst_bt_r64_imm8 :: #force_inline proc "contextless" (dst: GPR64, imm: i8) -> Instruction { return inst_r_i(.BT, Register(dst), i64(imm), 1) } -inst_bt_m64_imm8 :: #force_inline proc "contextless" (dst: Mem64, imm: i8) -> Instruction { return inst_m_i(.BT, dst.mem, 8, i64(imm), 1) } -emit_bt_r16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: GPR16) { emit_rr(instructions, .BT, Register(dst), Register(src)) } -emit_bt_m16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16, src: GPR16) { emit_mr(instructions, .BT, dst.mem, 2, Register(src)) } -emit_bt_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { emit_rr(instructions, .BT, Register(dst), Register(src)) } -emit_bt_m32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, src: GPR32) { emit_mr(instructions, .BT, dst.mem, 4, Register(src)) } -emit_bt_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { emit_rr(instructions, .BT, Register(dst), Register(src)) } -emit_bt_m64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, src: GPR64) { emit_mr(instructions, .BT, dst.mem, 8, Register(src)) } -emit_bt_r16_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, imm: i8) { emit_ri(instructions, .BT, Register(dst), i64(imm), 1) } -emit_bt_m16_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16, imm: i8) { emit_mi(instructions, .BT, dst.mem, 2, i64(imm), 1) } -emit_bt_r32_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, imm: i8) { emit_ri(instructions, .BT, Register(dst), i64(imm), 1) } -emit_bt_m32_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, imm: i8) { emit_mi(instructions, .BT, dst.mem, 4, i64(imm), 1) } -emit_bt_r64_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, imm: i8) { emit_ri(instructions, .BT, Register(dst), i64(imm), 1) } -emit_bt_m64_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, imm: i8) { emit_mi(instructions, .BT, dst.mem, 8, i64(imm), 1) } -inst_bts_r16_r16 :: #force_inline proc "contextless" (dst: GPR16, src: GPR16) -> Instruction { return inst_r_r(.BTS, Register(dst), Register(src)) } -inst_bts_m16_r16 :: #force_inline proc "contextless" (dst: Mem16, src: GPR16) -> Instruction { return inst_m_r(.BTS, dst.mem, 2, Register(src)) } -inst_bts_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return inst_r_r(.BTS, Register(dst), Register(src)) } -inst_bts_m32_r32 :: #force_inline proc "contextless" (dst: Mem32, src: GPR32) -> Instruction { return inst_m_r(.BTS, dst.mem, 4, Register(src)) } -inst_bts_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return inst_r_r(.BTS, Register(dst), Register(src)) } -inst_bts_m64_r64 :: #force_inline proc "contextless" (dst: Mem64, src: GPR64) -> Instruction { return inst_m_r(.BTS, dst.mem, 8, Register(src)) } -inst_bts_r16_imm8 :: #force_inline proc "contextless" (dst: GPR16, imm: i8) -> Instruction { return inst_r_i(.BTS, Register(dst), i64(imm), 1) } -inst_bts_m16_imm8 :: #force_inline proc "contextless" (dst: Mem16, imm: i8) -> Instruction { return inst_m_i(.BTS, dst.mem, 2, i64(imm), 1) } -inst_bts_r32_imm8 :: #force_inline proc "contextless" (dst: GPR32, imm: i8) -> Instruction { return inst_r_i(.BTS, Register(dst), i64(imm), 1) } -inst_bts_m32_imm8 :: #force_inline proc "contextless" (dst: Mem32, imm: i8) -> Instruction { return inst_m_i(.BTS, dst.mem, 4, i64(imm), 1) } -inst_bts_r64_imm8 :: #force_inline proc "contextless" (dst: GPR64, imm: i8) -> Instruction { return inst_r_i(.BTS, Register(dst), i64(imm), 1) } -inst_bts_m64_imm8 :: #force_inline proc "contextless" (dst: Mem64, imm: i8) -> Instruction { return inst_m_i(.BTS, dst.mem, 8, i64(imm), 1) } -emit_bts_r16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: GPR16) { emit_rr(instructions, .BTS, Register(dst), Register(src)) } -emit_bts_m16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16, src: GPR16) { emit_mr(instructions, .BTS, dst.mem, 2, Register(src)) } -emit_bts_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { emit_rr(instructions, .BTS, Register(dst), Register(src)) } -emit_bts_m32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, src: GPR32) { emit_mr(instructions, .BTS, dst.mem, 4, Register(src)) } -emit_bts_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { emit_rr(instructions, .BTS, Register(dst), Register(src)) } -emit_bts_m64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, src: GPR64) { emit_mr(instructions, .BTS, dst.mem, 8, Register(src)) } -emit_bts_r16_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, imm: i8) { emit_ri(instructions, .BTS, Register(dst), i64(imm), 1) } -emit_bts_m16_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16, imm: i8) { emit_mi(instructions, .BTS, dst.mem, 2, i64(imm), 1) } -emit_bts_r32_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, imm: i8) { emit_ri(instructions, .BTS, Register(dst), i64(imm), 1) } -emit_bts_m32_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, imm: i8) { emit_mi(instructions, .BTS, dst.mem, 4, i64(imm), 1) } -emit_bts_r64_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, imm: i8) { emit_ri(instructions, .BTS, Register(dst), i64(imm), 1) } -emit_bts_m64_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, imm: i8) { emit_mi(instructions, .BTS, dst.mem, 8, i64(imm), 1) } -inst_btr_r16_r16 :: #force_inline proc "contextless" (dst: GPR16, src: GPR16) -> Instruction { return inst_r_r(.BTR, Register(dst), Register(src)) } -inst_btr_m16_r16 :: #force_inline proc "contextless" (dst: Mem16, src: GPR16) -> Instruction { return inst_m_r(.BTR, dst.mem, 2, Register(src)) } -inst_btr_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return inst_r_r(.BTR, Register(dst), Register(src)) } -inst_btr_m32_r32 :: #force_inline proc "contextless" (dst: Mem32, src: GPR32) -> Instruction { return inst_m_r(.BTR, dst.mem, 4, Register(src)) } -inst_btr_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return inst_r_r(.BTR, Register(dst), Register(src)) } -inst_btr_m64_r64 :: #force_inline proc "contextless" (dst: Mem64, src: GPR64) -> Instruction { return inst_m_r(.BTR, dst.mem, 8, Register(src)) } -inst_btr_r16_imm8 :: #force_inline proc "contextless" (dst: GPR16, imm: i8) -> Instruction { return inst_r_i(.BTR, Register(dst), i64(imm), 1) } -inst_btr_m16_imm8 :: #force_inline proc "contextless" (dst: Mem16, imm: i8) -> Instruction { return inst_m_i(.BTR, dst.mem, 2, i64(imm), 1) } -inst_btr_r32_imm8 :: #force_inline proc "contextless" (dst: GPR32, imm: i8) -> Instruction { return inst_r_i(.BTR, Register(dst), i64(imm), 1) } -inst_btr_m32_imm8 :: #force_inline proc "contextless" (dst: Mem32, imm: i8) -> Instruction { return inst_m_i(.BTR, dst.mem, 4, i64(imm), 1) } -inst_btr_r64_imm8 :: #force_inline proc "contextless" (dst: GPR64, imm: i8) -> Instruction { return inst_r_i(.BTR, Register(dst), i64(imm), 1) } -inst_btr_m64_imm8 :: #force_inline proc "contextless" (dst: Mem64, imm: i8) -> Instruction { return inst_m_i(.BTR, dst.mem, 8, i64(imm), 1) } -emit_btr_r16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: GPR16) { emit_rr(instructions, .BTR, Register(dst), Register(src)) } -emit_btr_m16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16, src: GPR16) { emit_mr(instructions, .BTR, dst.mem, 2, Register(src)) } -emit_btr_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { emit_rr(instructions, .BTR, Register(dst), Register(src)) } -emit_btr_m32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, src: GPR32) { emit_mr(instructions, .BTR, dst.mem, 4, Register(src)) } -emit_btr_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { emit_rr(instructions, .BTR, Register(dst), Register(src)) } -emit_btr_m64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, src: GPR64) { emit_mr(instructions, .BTR, dst.mem, 8, Register(src)) } -emit_btr_r16_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, imm: i8) { emit_ri(instructions, .BTR, Register(dst), i64(imm), 1) } -emit_btr_m16_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16, imm: i8) { emit_mi(instructions, .BTR, dst.mem, 2, i64(imm), 1) } -emit_btr_r32_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, imm: i8) { emit_ri(instructions, .BTR, Register(dst), i64(imm), 1) } -emit_btr_m32_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, imm: i8) { emit_mi(instructions, .BTR, dst.mem, 4, i64(imm), 1) } -emit_btr_r64_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, imm: i8) { emit_ri(instructions, .BTR, Register(dst), i64(imm), 1) } -emit_btr_m64_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, imm: i8) { emit_mi(instructions, .BTR, dst.mem, 8, i64(imm), 1) } -inst_btc_r16_r16 :: #force_inline proc "contextless" (dst: GPR16, src: GPR16) -> Instruction { return inst_r_r(.BTC, Register(dst), Register(src)) } -inst_btc_m16_r16 :: #force_inline proc "contextless" (dst: Mem16, src: GPR16) -> Instruction { return inst_m_r(.BTC, dst.mem, 2, Register(src)) } -inst_btc_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return inst_r_r(.BTC, Register(dst), Register(src)) } -inst_btc_m32_r32 :: #force_inline proc "contextless" (dst: Mem32, src: GPR32) -> Instruction { return inst_m_r(.BTC, dst.mem, 4, Register(src)) } -inst_btc_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return inst_r_r(.BTC, Register(dst), Register(src)) } -inst_btc_m64_r64 :: #force_inline proc "contextless" (dst: Mem64, src: GPR64) -> Instruction { return inst_m_r(.BTC, dst.mem, 8, Register(src)) } -inst_btc_r16_imm8 :: #force_inline proc "contextless" (dst: GPR16, imm: i8) -> Instruction { return inst_r_i(.BTC, Register(dst), i64(imm), 1) } -inst_btc_m16_imm8 :: #force_inline proc "contextless" (dst: Mem16, imm: i8) -> Instruction { return inst_m_i(.BTC, dst.mem, 2, i64(imm), 1) } -inst_btc_r32_imm8 :: #force_inline proc "contextless" (dst: GPR32, imm: i8) -> Instruction { return inst_r_i(.BTC, Register(dst), i64(imm), 1) } -inst_btc_m32_imm8 :: #force_inline proc "contextless" (dst: Mem32, imm: i8) -> Instruction { return inst_m_i(.BTC, dst.mem, 4, i64(imm), 1) } -inst_btc_r64_imm8 :: #force_inline proc "contextless" (dst: GPR64, imm: i8) -> Instruction { return inst_r_i(.BTC, Register(dst), i64(imm), 1) } -inst_btc_m64_imm8 :: #force_inline proc "contextless" (dst: Mem64, imm: i8) -> Instruction { return inst_m_i(.BTC, dst.mem, 8, i64(imm), 1) } -emit_btc_r16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: GPR16) { emit_rr(instructions, .BTC, Register(dst), Register(src)) } -emit_btc_m16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16, src: GPR16) { emit_mr(instructions, .BTC, dst.mem, 2, Register(src)) } -emit_btc_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { emit_rr(instructions, .BTC, Register(dst), Register(src)) } -emit_btc_m32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, src: GPR32) { emit_mr(instructions, .BTC, dst.mem, 4, Register(src)) } -emit_btc_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { emit_rr(instructions, .BTC, Register(dst), Register(src)) } -emit_btc_m64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, src: GPR64) { emit_mr(instructions, .BTC, dst.mem, 8, Register(src)) } -emit_btc_r16_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, imm: i8) { emit_ri(instructions, .BTC, Register(dst), i64(imm), 1) } -emit_btc_m16_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16, imm: i8) { emit_mi(instructions, .BTC, dst.mem, 2, i64(imm), 1) } -emit_btc_r32_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, imm: i8) { emit_ri(instructions, .BTC, Register(dst), i64(imm), 1) } -emit_btc_m32_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, imm: i8) { emit_mi(instructions, .BTC, dst.mem, 4, i64(imm), 1) } -emit_btc_r64_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, imm: i8) { emit_ri(instructions, .BTC, Register(dst), i64(imm), 1) } -emit_btc_m64_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, imm: i8) { emit_mi(instructions, .BTC, dst.mem, 8, i64(imm), 1) } -inst_bsf_r16_r16 :: #force_inline proc "contextless" (dst: GPR16, src: GPR16) -> Instruction { return inst_r_r(.BSF, Register(dst), Register(src)) } -inst_bsf_r16_m16 :: #force_inline proc "contextless" (dst: GPR16, src: Mem16) -> Instruction { return inst_r_m(.BSF, Register(dst), src.mem, 2) } -inst_bsf_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return inst_r_r(.BSF, Register(dst), Register(src)) } -inst_bsf_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32) -> Instruction { return inst_r_m(.BSF, Register(dst), src.mem, 4) } -inst_bsf_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return inst_r_r(.BSF, Register(dst), Register(src)) } -inst_bsf_r64_m64 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64) -> Instruction { return inst_r_m(.BSF, Register(dst), src.mem, 8) } -emit_bsf_r16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: GPR16) { emit_rr(instructions, .BSF, Register(dst), Register(src)) } -emit_bsf_r16_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: Mem16) { emit_rm(instructions, .BSF, Register(dst), src.mem, 2) } -emit_bsf_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { emit_rr(instructions, .BSF, Register(dst), Register(src)) } -emit_bsf_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32) { emit_rm(instructions, .BSF, Register(dst), src.mem, 4) } -emit_bsf_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { emit_rr(instructions, .BSF, Register(dst), Register(src)) } -emit_bsf_r64_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem64) { emit_rm(instructions, .BSF, Register(dst), src.mem, 8) } -inst_bsr_r16_r16 :: #force_inline proc "contextless" (dst: GPR16, src: GPR16) -> Instruction { return inst_r_r(.BSR, Register(dst), Register(src)) } -inst_bsr_r16_m16 :: #force_inline proc "contextless" (dst: GPR16, src: Mem16) -> Instruction { return inst_r_m(.BSR, Register(dst), src.mem, 2) } -inst_bsr_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return inst_r_r(.BSR, Register(dst), Register(src)) } -inst_bsr_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32) -> Instruction { return inst_r_m(.BSR, Register(dst), src.mem, 4) } -inst_bsr_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return inst_r_r(.BSR, Register(dst), Register(src)) } -inst_bsr_r64_m64 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64) -> Instruction { return inst_r_m(.BSR, Register(dst), src.mem, 8) } -emit_bsr_r16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: GPR16) { emit_rr(instructions, .BSR, Register(dst), Register(src)) } -emit_bsr_r16_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: Mem16) { emit_rm(instructions, .BSR, Register(dst), src.mem, 2) } -emit_bsr_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { emit_rr(instructions, .BSR, Register(dst), Register(src)) } -emit_bsr_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32) { emit_rm(instructions, .BSR, Register(dst), src.mem, 4) } -emit_bsr_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { emit_rr(instructions, .BSR, Register(dst), Register(src)) } -emit_bsr_r64_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem64) { emit_rm(instructions, .BSR, Register(dst), src.mem, 8) } -inst_popcnt_r16_r16 :: #force_inline proc "contextless" (dst: GPR16, src: GPR16) -> Instruction { return inst_r_r(.POPCNT, Register(dst), Register(src)) } -inst_popcnt_r16_m16 :: #force_inline proc "contextless" (dst: GPR16, src: Mem16) -> Instruction { return inst_r_m(.POPCNT, Register(dst), src.mem, 2) } -inst_popcnt_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return inst_r_r(.POPCNT, Register(dst), Register(src)) } -inst_popcnt_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32) -> Instruction { return inst_r_m(.POPCNT, Register(dst), src.mem, 4) } -inst_popcnt_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return inst_r_r(.POPCNT, Register(dst), Register(src)) } -inst_popcnt_r64_m64 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64) -> Instruction { return inst_r_m(.POPCNT, Register(dst), src.mem, 8) } -emit_popcnt_r16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: GPR16) { emit_rr(instructions, .POPCNT, Register(dst), Register(src)) } -emit_popcnt_r16_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: Mem16) { emit_rm(instructions, .POPCNT, Register(dst), src.mem, 2) } -emit_popcnt_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { emit_rr(instructions, .POPCNT, Register(dst), Register(src)) } -emit_popcnt_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32) { emit_rm(instructions, .POPCNT, Register(dst), src.mem, 4) } -emit_popcnt_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { emit_rr(instructions, .POPCNT, Register(dst), Register(src)) } -emit_popcnt_r64_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem64) { emit_rm(instructions, .POPCNT, Register(dst), src.mem, 8) } -inst_lzcnt_r16_r16 :: #force_inline proc "contextless" (dst: GPR16, src: GPR16) -> Instruction { return inst_r_r(.LZCNT, Register(dst), Register(src)) } -inst_lzcnt_r16_m16 :: #force_inline proc "contextless" (dst: GPR16, src: Mem16) -> Instruction { return inst_r_m(.LZCNT, Register(dst), src.mem, 2) } -inst_lzcnt_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return inst_r_r(.LZCNT, Register(dst), Register(src)) } -inst_lzcnt_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32) -> Instruction { return inst_r_m(.LZCNT, Register(dst), src.mem, 4) } -inst_lzcnt_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return inst_r_r(.LZCNT, Register(dst), Register(src)) } -inst_lzcnt_r64_m64 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64) -> Instruction { return inst_r_m(.LZCNT, Register(dst), src.mem, 8) } -emit_lzcnt_r16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: GPR16) { emit_rr(instructions, .LZCNT, Register(dst), Register(src)) } -emit_lzcnt_r16_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: Mem16) { emit_rm(instructions, .LZCNT, Register(dst), src.mem, 2) } -emit_lzcnt_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { emit_rr(instructions, .LZCNT, Register(dst), Register(src)) } -emit_lzcnt_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32) { emit_rm(instructions, .LZCNT, Register(dst), src.mem, 4) } -emit_lzcnt_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { emit_rr(instructions, .LZCNT, Register(dst), Register(src)) } -emit_lzcnt_r64_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem64) { emit_rm(instructions, .LZCNT, Register(dst), src.mem, 8) } -inst_tzcnt_r16_r16 :: #force_inline proc "contextless" (dst: GPR16, src: GPR16) -> Instruction { return inst_r_r(.TZCNT, Register(dst), Register(src)) } -inst_tzcnt_r16_m16 :: #force_inline proc "contextless" (dst: GPR16, src: Mem16) -> Instruction { return inst_r_m(.TZCNT, Register(dst), src.mem, 2) } -inst_tzcnt_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return inst_r_r(.TZCNT, Register(dst), Register(src)) } -inst_tzcnt_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32) -> Instruction { return inst_r_m(.TZCNT, Register(dst), src.mem, 4) } -inst_tzcnt_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return inst_r_r(.TZCNT, Register(dst), Register(src)) } -inst_tzcnt_r64_m64 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64) -> Instruction { return inst_r_m(.TZCNT, Register(dst), src.mem, 8) } -emit_tzcnt_r16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: GPR16) { emit_rr(instructions, .TZCNT, Register(dst), Register(src)) } -emit_tzcnt_r16_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: Mem16) { emit_rm(instructions, .TZCNT, Register(dst), src.mem, 2) } -emit_tzcnt_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { emit_rr(instructions, .TZCNT, Register(dst), Register(src)) } -emit_tzcnt_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32) { emit_rm(instructions, .TZCNT, Register(dst), src.mem, 4) } -emit_tzcnt_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { emit_rr(instructions, .TZCNT, Register(dst), Register(src)) } -emit_tzcnt_r64_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem64) { emit_rm(instructions, .TZCNT, Register(dst), src.mem, 8) } -inst_jmp_rel8 :: #force_inline proc "contextless" (offset: i8) -> Instruction { return inst_rel_offset(.JMP, i64(offset), 1) } -inst_jmp_rel32 :: #force_inline proc "contextless" (offset: i32) -> Instruction { return inst_rel_offset(.JMP, i64(offset), 4) } -inst_jmp_r64 :: #force_inline proc "contextless" (dst: GPR64) -> Instruction { return inst_r(.JMP, Register(dst)) } -inst_jmp_m64 :: #force_inline proc "contextless" (dst: Mem64) -> Instruction { return inst_m(.JMP, dst.mem, 8) } -inst_jmp_m :: #force_inline proc "contextless" (dst: Memory) -> Instruction { return inst_m(.JMP, dst, 0) } -emit_jmp_rel8 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i8) { emit_rel_offset(instructions, .JMP, i64(offset), 1) } -emit_jmp_rel32 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i32) { emit_rel_offset(instructions, .JMP, i64(offset), 4) } -emit_jmp_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64) { emit_r(instructions, .JMP, Register(dst)) } -emit_jmp_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64) { emit_m(instructions, .JMP, dst.mem, 8) } -emit_jmp_m :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Memory) { emit_m(instructions, .JMP, dst, 0) } -inst_ja_rel8 :: #force_inline proc "contextless" (offset: i8) -> Instruction { return inst_rel_offset(.JA, i64(offset), 1) } -inst_ja_rel32 :: #force_inline proc "contextless" (offset: i32) -> Instruction { return inst_rel_offset(.JA, i64(offset), 4) } -emit_ja_rel8 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i8) { emit_rel_offset(instructions, .JA, i64(offset), 1) } -emit_ja_rel32 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i32) { emit_rel_offset(instructions, .JA, i64(offset), 4) } -inst_jae_rel8 :: #force_inline proc "contextless" (offset: i8) -> Instruction { return inst_rel_offset(.JAE, i64(offset), 1) } -inst_jae_rel32 :: #force_inline proc "contextless" (offset: i32) -> Instruction { return inst_rel_offset(.JAE, i64(offset), 4) } -emit_jae_rel8 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i8) { emit_rel_offset(instructions, .JAE, i64(offset), 1) } -emit_jae_rel32 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i32) { emit_rel_offset(instructions, .JAE, i64(offset), 4) } -inst_jb_rel8 :: #force_inline proc "contextless" (offset: i8) -> Instruction { return inst_rel_offset(.JB, i64(offset), 1) } -inst_jb_rel32 :: #force_inline proc "contextless" (offset: i32) -> Instruction { return inst_rel_offset(.JB, i64(offset), 4) } -emit_jb_rel8 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i8) { emit_rel_offset(instructions, .JB, i64(offset), 1) } -emit_jb_rel32 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i32) { emit_rel_offset(instructions, .JB, i64(offset), 4) } -inst_jbe_rel8 :: #force_inline proc "contextless" (offset: i8) -> Instruction { return inst_rel_offset(.JBE, i64(offset), 1) } -inst_jbe_rel32 :: #force_inline proc "contextless" (offset: i32) -> Instruction { return inst_rel_offset(.JBE, i64(offset), 4) } -emit_jbe_rel8 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i8) { emit_rel_offset(instructions, .JBE, i64(offset), 1) } -emit_jbe_rel32 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i32) { emit_rel_offset(instructions, .JBE, i64(offset), 4) } -inst_jc_rel8 :: #force_inline proc "contextless" (offset: i8) -> Instruction { return inst_rel_offset(.JC, i64(offset), 1) } -inst_jc_rel32 :: #force_inline proc "contextless" (offset: i32) -> Instruction { return inst_rel_offset(.JC, i64(offset), 4) } -emit_jc_rel8 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i8) { emit_rel_offset(instructions, .JC, i64(offset), 1) } -emit_jc_rel32 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i32) { emit_rel_offset(instructions, .JC, i64(offset), 4) } -inst_je_rel8 :: #force_inline proc "contextless" (offset: i8) -> Instruction { return inst_rel_offset(.JE, i64(offset), 1) } -inst_je_rel32 :: #force_inline proc "contextless" (offset: i32) -> Instruction { return inst_rel_offset(.JE, i64(offset), 4) } -emit_je_rel8 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i8) { emit_rel_offset(instructions, .JE, i64(offset), 1) } -emit_je_rel32 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i32) { emit_rel_offset(instructions, .JE, i64(offset), 4) } -inst_jz_rel8 :: #force_inline proc "contextless" (offset: i8) -> Instruction { return inst_rel_offset(.JZ, i64(offset), 1) } -inst_jz_rel32 :: #force_inline proc "contextless" (offset: i32) -> Instruction { return inst_rel_offset(.JZ, i64(offset), 4) } -emit_jz_rel8 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i8) { emit_rel_offset(instructions, .JZ, i64(offset), 1) } -emit_jz_rel32 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i32) { emit_rel_offset(instructions, .JZ, i64(offset), 4) } -inst_jg_rel8 :: #force_inline proc "contextless" (offset: i8) -> Instruction { return inst_rel_offset(.JG, i64(offset), 1) } -inst_jg_rel32 :: #force_inline proc "contextless" (offset: i32) -> Instruction { return inst_rel_offset(.JG, i64(offset), 4) } -emit_jg_rel8 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i8) { emit_rel_offset(instructions, .JG, i64(offset), 1) } -emit_jg_rel32 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i32) { emit_rel_offset(instructions, .JG, i64(offset), 4) } -inst_jge_rel8 :: #force_inline proc "contextless" (offset: i8) -> Instruction { return inst_rel_offset(.JGE, i64(offset), 1) } -inst_jge_rel32 :: #force_inline proc "contextless" (offset: i32) -> Instruction { return inst_rel_offset(.JGE, i64(offset), 4) } -emit_jge_rel8 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i8) { emit_rel_offset(instructions, .JGE, i64(offset), 1) } -emit_jge_rel32 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i32) { emit_rel_offset(instructions, .JGE, i64(offset), 4) } -inst_jl_rel8 :: #force_inline proc "contextless" (offset: i8) -> Instruction { return inst_rel_offset(.JL, i64(offset), 1) } -inst_jl_rel32 :: #force_inline proc "contextless" (offset: i32) -> Instruction { return inst_rel_offset(.JL, i64(offset), 4) } -emit_jl_rel8 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i8) { emit_rel_offset(instructions, .JL, i64(offset), 1) } -emit_jl_rel32 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i32) { emit_rel_offset(instructions, .JL, i64(offset), 4) } -inst_jle_rel8 :: #force_inline proc "contextless" (offset: i8) -> Instruction { return inst_rel_offset(.JLE, i64(offset), 1) } -inst_jle_rel32 :: #force_inline proc "contextless" (offset: i32) -> Instruction { return inst_rel_offset(.JLE, i64(offset), 4) } -emit_jle_rel8 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i8) { emit_rel_offset(instructions, .JLE, i64(offset), 1) } -emit_jle_rel32 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i32) { emit_rel_offset(instructions, .JLE, i64(offset), 4) } -inst_jna_rel8 :: #force_inline proc "contextless" (offset: i8) -> Instruction { return inst_rel_offset(.JNA, i64(offset), 1) } -inst_jna_rel32 :: #force_inline proc "contextless" (offset: i32) -> Instruction { return inst_rel_offset(.JNA, i64(offset), 4) } -emit_jna_rel8 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i8) { emit_rel_offset(instructions, .JNA, i64(offset), 1) } -emit_jna_rel32 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i32) { emit_rel_offset(instructions, .JNA, i64(offset), 4) } -inst_jnae_rel8 :: #force_inline proc "contextless" (offset: i8) -> Instruction { return inst_rel_offset(.JNAE, i64(offset), 1) } -inst_jnae_rel32 :: #force_inline proc "contextless" (offset: i32) -> Instruction { return inst_rel_offset(.JNAE, i64(offset), 4) } -emit_jnae_rel8 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i8) { emit_rel_offset(instructions, .JNAE, i64(offset), 1) } -emit_jnae_rel32 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i32) { emit_rel_offset(instructions, .JNAE, i64(offset), 4) } -inst_jnb_rel8 :: #force_inline proc "contextless" (offset: i8) -> Instruction { return inst_rel_offset(.JNB, i64(offset), 1) } -inst_jnb_rel32 :: #force_inline proc "contextless" (offset: i32) -> Instruction { return inst_rel_offset(.JNB, i64(offset), 4) } -emit_jnb_rel8 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i8) { emit_rel_offset(instructions, .JNB, i64(offset), 1) } -emit_jnb_rel32 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i32) { emit_rel_offset(instructions, .JNB, i64(offset), 4) } -inst_jnbe_rel8 :: #force_inline proc "contextless" (offset: i8) -> Instruction { return inst_rel_offset(.JNBE, i64(offset), 1) } -inst_jnbe_rel32 :: #force_inline proc "contextless" (offset: i32) -> Instruction { return inst_rel_offset(.JNBE, i64(offset), 4) } -emit_jnbe_rel8 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i8) { emit_rel_offset(instructions, .JNBE, i64(offset), 1) } -emit_jnbe_rel32 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i32) { emit_rel_offset(instructions, .JNBE, i64(offset), 4) } -inst_jnc_rel8 :: #force_inline proc "contextless" (offset: i8) -> Instruction { return inst_rel_offset(.JNC, i64(offset), 1) } -inst_jnc_rel32 :: #force_inline proc "contextless" (offset: i32) -> Instruction { return inst_rel_offset(.JNC, i64(offset), 4) } -emit_jnc_rel8 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i8) { emit_rel_offset(instructions, .JNC, i64(offset), 1) } -emit_jnc_rel32 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i32) { emit_rel_offset(instructions, .JNC, i64(offset), 4) } -inst_jne_rel8 :: #force_inline proc "contextless" (offset: i8) -> Instruction { return inst_rel_offset(.JNE, i64(offset), 1) } -inst_jne_rel32 :: #force_inline proc "contextless" (offset: i32) -> Instruction { return inst_rel_offset(.JNE, i64(offset), 4) } -emit_jne_rel8 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i8) { emit_rel_offset(instructions, .JNE, i64(offset), 1) } -emit_jne_rel32 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i32) { emit_rel_offset(instructions, .JNE, i64(offset), 4) } -inst_jnz_rel8 :: #force_inline proc "contextless" (offset: i8) -> Instruction { return inst_rel_offset(.JNZ, i64(offset), 1) } -inst_jnz_rel32 :: #force_inline proc "contextless" (offset: i32) -> Instruction { return inst_rel_offset(.JNZ, i64(offset), 4) } -emit_jnz_rel8 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i8) { emit_rel_offset(instructions, .JNZ, i64(offset), 1) } -emit_jnz_rel32 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i32) { emit_rel_offset(instructions, .JNZ, i64(offset), 4) } -inst_jng_rel8 :: #force_inline proc "contextless" (offset: i8) -> Instruction { return inst_rel_offset(.JNG, i64(offset), 1) } -inst_jng_rel32 :: #force_inline proc "contextless" (offset: i32) -> Instruction { return inst_rel_offset(.JNG, i64(offset), 4) } -emit_jng_rel8 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i8) { emit_rel_offset(instructions, .JNG, i64(offset), 1) } -emit_jng_rel32 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i32) { emit_rel_offset(instructions, .JNG, i64(offset), 4) } -inst_jnge_rel8 :: #force_inline proc "contextless" (offset: i8) -> Instruction { return inst_rel_offset(.JNGE, i64(offset), 1) } -inst_jnge_rel32 :: #force_inline proc "contextless" (offset: i32) -> Instruction { return inst_rel_offset(.JNGE, i64(offset), 4) } -emit_jnge_rel8 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i8) { emit_rel_offset(instructions, .JNGE, i64(offset), 1) } -emit_jnge_rel32 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i32) { emit_rel_offset(instructions, .JNGE, i64(offset), 4) } -inst_jnl_rel8 :: #force_inline proc "contextless" (offset: i8) -> Instruction { return inst_rel_offset(.JNL, i64(offset), 1) } -inst_jnl_rel32 :: #force_inline proc "contextless" (offset: i32) -> Instruction { return inst_rel_offset(.JNL, i64(offset), 4) } -emit_jnl_rel8 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i8) { emit_rel_offset(instructions, .JNL, i64(offset), 1) } -emit_jnl_rel32 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i32) { emit_rel_offset(instructions, .JNL, i64(offset), 4) } -inst_jnle_rel8 :: #force_inline proc "contextless" (offset: i8) -> Instruction { return inst_rel_offset(.JNLE, i64(offset), 1) } -inst_jnle_rel32 :: #force_inline proc "contextless" (offset: i32) -> Instruction { return inst_rel_offset(.JNLE, i64(offset), 4) } -emit_jnle_rel8 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i8) { emit_rel_offset(instructions, .JNLE, i64(offset), 1) } -emit_jnle_rel32 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i32) { emit_rel_offset(instructions, .JNLE, i64(offset), 4) } -inst_jno_rel8 :: #force_inline proc "contextless" (offset: i8) -> Instruction { return inst_rel_offset(.JNO, i64(offset), 1) } -inst_jno_rel32 :: #force_inline proc "contextless" (offset: i32) -> Instruction { return inst_rel_offset(.JNO, i64(offset), 4) } -emit_jno_rel8 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i8) { emit_rel_offset(instructions, .JNO, i64(offset), 1) } -emit_jno_rel32 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i32) { emit_rel_offset(instructions, .JNO, i64(offset), 4) } -inst_jnp_rel8 :: #force_inline proc "contextless" (offset: i8) -> Instruction { return inst_rel_offset(.JNP, i64(offset), 1) } -inst_jnp_rel32 :: #force_inline proc "contextless" (offset: i32) -> Instruction { return inst_rel_offset(.JNP, i64(offset), 4) } -emit_jnp_rel8 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i8) { emit_rel_offset(instructions, .JNP, i64(offset), 1) } -emit_jnp_rel32 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i32) { emit_rel_offset(instructions, .JNP, i64(offset), 4) } -inst_jns_rel8 :: #force_inline proc "contextless" (offset: i8) -> Instruction { return inst_rel_offset(.JNS, i64(offset), 1) } -inst_jns_rel32 :: #force_inline proc "contextless" (offset: i32) -> Instruction { return inst_rel_offset(.JNS, i64(offset), 4) } -emit_jns_rel8 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i8) { emit_rel_offset(instructions, .JNS, i64(offset), 1) } -emit_jns_rel32 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i32) { emit_rel_offset(instructions, .JNS, i64(offset), 4) } -inst_jo_rel8 :: #force_inline proc "contextless" (offset: i8) -> Instruction { return inst_rel_offset(.JO, i64(offset), 1) } -inst_jo_rel32 :: #force_inline proc "contextless" (offset: i32) -> Instruction { return inst_rel_offset(.JO, i64(offset), 4) } -emit_jo_rel8 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i8) { emit_rel_offset(instructions, .JO, i64(offset), 1) } -emit_jo_rel32 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i32) { emit_rel_offset(instructions, .JO, i64(offset), 4) } -inst_jp_rel8 :: #force_inline proc "contextless" (offset: i8) -> Instruction { return inst_rel_offset(.JP, i64(offset), 1) } -inst_jp_rel32 :: #force_inline proc "contextless" (offset: i32) -> Instruction { return inst_rel_offset(.JP, i64(offset), 4) } -emit_jp_rel8 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i8) { emit_rel_offset(instructions, .JP, i64(offset), 1) } -emit_jp_rel32 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i32) { emit_rel_offset(instructions, .JP, i64(offset), 4) } -inst_jpe_rel8 :: #force_inline proc "contextless" (offset: i8) -> Instruction { return inst_rel_offset(.JPE, i64(offset), 1) } -inst_jpe_rel32 :: #force_inline proc "contextless" (offset: i32) -> Instruction { return inst_rel_offset(.JPE, i64(offset), 4) } -emit_jpe_rel8 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i8) { emit_rel_offset(instructions, .JPE, i64(offset), 1) } -emit_jpe_rel32 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i32) { emit_rel_offset(instructions, .JPE, i64(offset), 4) } -inst_jpo_rel8 :: #force_inline proc "contextless" (offset: i8) -> Instruction { return inst_rel_offset(.JPO, i64(offset), 1) } -inst_jpo_rel32 :: #force_inline proc "contextless" (offset: i32) -> Instruction { return inst_rel_offset(.JPO, i64(offset), 4) } -emit_jpo_rel8 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i8) { emit_rel_offset(instructions, .JPO, i64(offset), 1) } -emit_jpo_rel32 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i32) { emit_rel_offset(instructions, .JPO, i64(offset), 4) } -inst_js_rel8 :: #force_inline proc "contextless" (offset: i8) -> Instruction { return inst_rel_offset(.JS, i64(offset), 1) } -inst_js_rel32 :: #force_inline proc "contextless" (offset: i32) -> Instruction { return inst_rel_offset(.JS, i64(offset), 4) } -emit_js_rel8 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i8) { emit_rel_offset(instructions, .JS, i64(offset), 1) } -emit_js_rel32 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i32) { emit_rel_offset(instructions, .JS, i64(offset), 4) } -inst_jcxz_rel8 :: #force_inline proc "contextless" (offset: i8) -> Instruction { return inst_rel_offset(.JCXZ, i64(offset), 1) } -emit_jcxz_rel8 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i8) { emit_rel_offset(instructions, .JCXZ, i64(offset), 1) } -inst_jecxz_rel8 :: #force_inline proc "contextless" (offset: i8) -> Instruction { return inst_rel_offset(.JECXZ, i64(offset), 1) } -emit_jecxz_rel8 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i8) { emit_rel_offset(instructions, .JECXZ, i64(offset), 1) } -inst_jrcxz_rel8 :: #force_inline proc "contextless" (offset: i8) -> Instruction { return inst_rel_offset(.JRCXZ, i64(offset), 1) } -emit_jrcxz_rel8 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i8) { emit_rel_offset(instructions, .JRCXZ, i64(offset), 1) } -inst_loop_rel8 :: #force_inline proc "contextless" (offset: i8) -> Instruction { return inst_rel_offset(.LOOP, i64(offset), 1) } -emit_loop_rel8 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i8) { emit_rel_offset(instructions, .LOOP, i64(offset), 1) } -inst_loope_rel8 :: #force_inline proc "contextless" (offset: i8) -> Instruction { return inst_rel_offset(.LOOPE, i64(offset), 1) } -emit_loope_rel8 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i8) { emit_rel_offset(instructions, .LOOPE, i64(offset), 1) } -inst_loopne_rel8 :: #force_inline proc "contextless" (offset: i8) -> Instruction { return inst_rel_offset(.LOOPNE, i64(offset), 1) } -emit_loopne_rel8 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i8) { emit_rel_offset(instructions, .LOOPNE, i64(offset), 1) } -inst_call_rel32 :: #force_inline proc "contextless" (offset: i32) -> Instruction { return inst_rel_offset(.CALL, i64(offset), 4) } -inst_call_r64 :: #force_inline proc "contextless" (dst: GPR64) -> Instruction { return inst_r(.CALL, Register(dst)) } -inst_call_m64 :: #force_inline proc "contextless" (dst: Mem64) -> Instruction { return inst_m(.CALL, dst.mem, 8) } -inst_call_m :: #force_inline proc "contextless" (dst: Memory) -> Instruction { return inst_m(.CALL, dst, 0) } -emit_call_rel32 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i32) { emit_rel_offset(instructions, .CALL, i64(offset), 4) } -emit_call_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64) { emit_r(instructions, .CALL, Register(dst)) } -emit_call_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64) { emit_m(instructions, .CALL, dst.mem, 8) } -emit_call_m :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Memory) { emit_m(instructions, .CALL, dst, 0) } -inst_ret_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.RET) } -inst_ret_imm16 :: #force_inline proc "contextless" (imm: i16) -> Instruction { return inst_i(.RET, i64(imm), 2) } -emit_ret_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .RET) } -emit_ret_imm16 :: #force_inline proc(instructions: ^[dynamic]Instruction, imm: i16) { emit_i(instructions, .RET, i64(imm), 2) } -inst_iret_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.IRET) } -emit_iret_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .IRET) } -inst_iretd_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.IRETD) } -emit_iretd_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .IRETD) } -inst_iretq_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.IRETQ) } -emit_iretq_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .IRETQ) } -inst_int_imm8 :: #force_inline proc "contextless" (imm: i8) -> Instruction { return inst_i(.INT, i64(imm), 1) } -emit_int_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, imm: i8) { emit_i(instructions, .INT, i64(imm), 1) } -inst_int3_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.INT3) } -emit_int3_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .INT3) } -inst_into_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.INTO) } -emit_into_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .INTO) } -inst_syscall_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.SYSCALL) } -emit_syscall_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .SYSCALL) } -inst_sysret_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.SYSRET) } -emit_sysret_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .SYSRET) } -inst_sysenter_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.SYSENTER) } -emit_sysenter_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .SYSENTER) } -inst_sysexit_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.SYSEXIT) } -emit_sysexit_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .SYSEXIT) } -inst_seta_r8 :: #force_inline proc "contextless" (dst: GPR8) -> Instruction { return inst_r(.SETA, Register(dst)) } -inst_seta_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return inst_m(.SETA, dst.mem, 1) } -emit_seta_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8) { emit_r(instructions, .SETA, Register(dst)) } -emit_seta_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { emit_m(instructions, .SETA, dst.mem, 1) } -inst_setae_r8 :: #force_inline proc "contextless" (dst: GPR8) -> Instruction { return inst_r(.SETAE, Register(dst)) } -inst_setae_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return inst_m(.SETAE, dst.mem, 1) } -emit_setae_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8) { emit_r(instructions, .SETAE, Register(dst)) } -emit_setae_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { emit_m(instructions, .SETAE, dst.mem, 1) } -inst_setb_r8 :: #force_inline proc "contextless" (dst: GPR8) -> Instruction { return inst_r(.SETB, Register(dst)) } -inst_setb_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return inst_m(.SETB, dst.mem, 1) } -emit_setb_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8) { emit_r(instructions, .SETB, Register(dst)) } -emit_setb_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { emit_m(instructions, .SETB, dst.mem, 1) } -inst_setbe_r8 :: #force_inline proc "contextless" (dst: GPR8) -> Instruction { return inst_r(.SETBE, Register(dst)) } -inst_setbe_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return inst_m(.SETBE, dst.mem, 1) } -emit_setbe_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8) { emit_r(instructions, .SETBE, Register(dst)) } -emit_setbe_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { emit_m(instructions, .SETBE, dst.mem, 1) } -inst_setc_r8 :: #force_inline proc "contextless" (dst: GPR8) -> Instruction { return inst_r(.SETC, Register(dst)) } -inst_setc_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return inst_m(.SETC, dst.mem, 1) } -emit_setc_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8) { emit_r(instructions, .SETC, Register(dst)) } -emit_setc_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { emit_m(instructions, .SETC, dst.mem, 1) } -inst_sete_r8 :: #force_inline proc "contextless" (dst: GPR8) -> Instruction { return inst_r(.SETE, Register(dst)) } -inst_sete_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return inst_m(.SETE, dst.mem, 1) } -emit_sete_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8) { emit_r(instructions, .SETE, Register(dst)) } -emit_sete_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { emit_m(instructions, .SETE, dst.mem, 1) } -inst_setg_r8 :: #force_inline proc "contextless" (dst: GPR8) -> Instruction { return inst_r(.SETG, Register(dst)) } -inst_setg_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return inst_m(.SETG, dst.mem, 1) } -emit_setg_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8) { emit_r(instructions, .SETG, Register(dst)) } -emit_setg_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { emit_m(instructions, .SETG, dst.mem, 1) } -inst_setge_r8 :: #force_inline proc "contextless" (dst: GPR8) -> Instruction { return inst_r(.SETGE, Register(dst)) } -inst_setge_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return inst_m(.SETGE, dst.mem, 1) } -emit_setge_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8) { emit_r(instructions, .SETGE, Register(dst)) } -emit_setge_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { emit_m(instructions, .SETGE, dst.mem, 1) } -inst_setl_r8 :: #force_inline proc "contextless" (dst: GPR8) -> Instruction { return inst_r(.SETL, Register(dst)) } -inst_setl_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return inst_m(.SETL, dst.mem, 1) } -emit_setl_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8) { emit_r(instructions, .SETL, Register(dst)) } -emit_setl_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { emit_m(instructions, .SETL, dst.mem, 1) } -inst_setle_r8 :: #force_inline proc "contextless" (dst: GPR8) -> Instruction { return inst_r(.SETLE, Register(dst)) } -inst_setle_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return inst_m(.SETLE, dst.mem, 1) } -emit_setle_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8) { emit_r(instructions, .SETLE, Register(dst)) } -emit_setle_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { emit_m(instructions, .SETLE, dst.mem, 1) } -inst_setna_r8 :: #force_inline proc "contextless" (dst: GPR8) -> Instruction { return inst_r(.SETNA, Register(dst)) } -inst_setna_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return inst_m(.SETNA, dst.mem, 1) } -emit_setna_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8) { emit_r(instructions, .SETNA, Register(dst)) } -emit_setna_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { emit_m(instructions, .SETNA, dst.mem, 1) } -inst_setnae_r8 :: #force_inline proc "contextless" (dst: GPR8) -> Instruction { return inst_r(.SETNAE, Register(dst)) } -inst_setnae_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return inst_m(.SETNAE, dst.mem, 1) } -emit_setnae_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8) { emit_r(instructions, .SETNAE, Register(dst)) } -emit_setnae_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { emit_m(instructions, .SETNAE, dst.mem, 1) } -inst_setnb_r8 :: #force_inline proc "contextless" (dst: GPR8) -> Instruction { return inst_r(.SETNB, Register(dst)) } -inst_setnb_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return inst_m(.SETNB, dst.mem, 1) } -emit_setnb_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8) { emit_r(instructions, .SETNB, Register(dst)) } -emit_setnb_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { emit_m(instructions, .SETNB, dst.mem, 1) } -inst_setnbe_r8 :: #force_inline proc "contextless" (dst: GPR8) -> Instruction { return inst_r(.SETNBE, Register(dst)) } -inst_setnbe_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return inst_m(.SETNBE, dst.mem, 1) } -emit_setnbe_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8) { emit_r(instructions, .SETNBE, Register(dst)) } -emit_setnbe_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { emit_m(instructions, .SETNBE, dst.mem, 1) } -inst_setnc_r8 :: #force_inline proc "contextless" (dst: GPR8) -> Instruction { return inst_r(.SETNC, Register(dst)) } -inst_setnc_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return inst_m(.SETNC, dst.mem, 1) } -emit_setnc_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8) { emit_r(instructions, .SETNC, Register(dst)) } -emit_setnc_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { emit_m(instructions, .SETNC, dst.mem, 1) } -inst_setne_r8 :: #force_inline proc "contextless" (dst: GPR8) -> Instruction { return inst_r(.SETNE, Register(dst)) } -inst_setne_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return inst_m(.SETNE, dst.mem, 1) } -emit_setne_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8) { emit_r(instructions, .SETNE, Register(dst)) } -emit_setne_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { emit_m(instructions, .SETNE, dst.mem, 1) } -inst_setng_r8 :: #force_inline proc "contextless" (dst: GPR8) -> Instruction { return inst_r(.SETNG, Register(dst)) } -inst_setng_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return inst_m(.SETNG, dst.mem, 1) } -emit_setng_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8) { emit_r(instructions, .SETNG, Register(dst)) } -emit_setng_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { emit_m(instructions, .SETNG, dst.mem, 1) } -inst_setnge_r8 :: #force_inline proc "contextless" (dst: GPR8) -> Instruction { return inst_r(.SETNGE, Register(dst)) } -inst_setnge_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return inst_m(.SETNGE, dst.mem, 1) } -emit_setnge_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8) { emit_r(instructions, .SETNGE, Register(dst)) } -emit_setnge_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { emit_m(instructions, .SETNGE, dst.mem, 1) } -inst_setnl_r8 :: #force_inline proc "contextless" (dst: GPR8) -> Instruction { return inst_r(.SETNL, Register(dst)) } -inst_setnl_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return inst_m(.SETNL, dst.mem, 1) } -emit_setnl_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8) { emit_r(instructions, .SETNL, Register(dst)) } -emit_setnl_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { emit_m(instructions, .SETNL, dst.mem, 1) } -inst_setnle_r8 :: #force_inline proc "contextless" (dst: GPR8) -> Instruction { return inst_r(.SETNLE, Register(dst)) } -inst_setnle_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return inst_m(.SETNLE, dst.mem, 1) } -emit_setnle_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8) { emit_r(instructions, .SETNLE, Register(dst)) } -emit_setnle_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { emit_m(instructions, .SETNLE, dst.mem, 1) } -inst_setno_r8 :: #force_inline proc "contextless" (dst: GPR8) -> Instruction { return inst_r(.SETNO, Register(dst)) } -inst_setno_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return inst_m(.SETNO, dst.mem, 1) } -emit_setno_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8) { emit_r(instructions, .SETNO, Register(dst)) } -emit_setno_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { emit_m(instructions, .SETNO, dst.mem, 1) } -inst_setnp_r8 :: #force_inline proc "contextless" (dst: GPR8) -> Instruction { return inst_r(.SETNP, Register(dst)) } -inst_setnp_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return inst_m(.SETNP, dst.mem, 1) } -emit_setnp_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8) { emit_r(instructions, .SETNP, Register(dst)) } -emit_setnp_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { emit_m(instructions, .SETNP, dst.mem, 1) } -inst_setns_r8 :: #force_inline proc "contextless" (dst: GPR8) -> Instruction { return inst_r(.SETNS, Register(dst)) } -inst_setns_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return inst_m(.SETNS, dst.mem, 1) } -emit_setns_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8) { emit_r(instructions, .SETNS, Register(dst)) } -emit_setns_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { emit_m(instructions, .SETNS, dst.mem, 1) } -inst_setnz_r8 :: #force_inline proc "contextless" (dst: GPR8) -> Instruction { return inst_r(.SETNZ, Register(dst)) } -inst_setnz_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return inst_m(.SETNZ, dst.mem, 1) } -emit_setnz_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8) { emit_r(instructions, .SETNZ, Register(dst)) } -emit_setnz_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { emit_m(instructions, .SETNZ, dst.mem, 1) } -inst_seto_r8 :: #force_inline proc "contextless" (dst: GPR8) -> Instruction { return inst_r(.SETO, Register(dst)) } -inst_seto_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return inst_m(.SETO, dst.mem, 1) } -emit_seto_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8) { emit_r(instructions, .SETO, Register(dst)) } -emit_seto_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { emit_m(instructions, .SETO, dst.mem, 1) } -inst_setp_r8 :: #force_inline proc "contextless" (dst: GPR8) -> Instruction { return inst_r(.SETP, Register(dst)) } -inst_setp_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return inst_m(.SETP, dst.mem, 1) } -emit_setp_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8) { emit_r(instructions, .SETP, Register(dst)) } -emit_setp_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { emit_m(instructions, .SETP, dst.mem, 1) } -inst_setpe_r8 :: #force_inline proc "contextless" (dst: GPR8) -> Instruction { return inst_r(.SETPE, Register(dst)) } -inst_setpe_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return inst_m(.SETPE, dst.mem, 1) } -emit_setpe_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8) { emit_r(instructions, .SETPE, Register(dst)) } -emit_setpe_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { emit_m(instructions, .SETPE, dst.mem, 1) } -inst_setpo_r8 :: #force_inline proc "contextless" (dst: GPR8) -> Instruction { return inst_r(.SETPO, Register(dst)) } -inst_setpo_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return inst_m(.SETPO, dst.mem, 1) } -emit_setpo_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8) { emit_r(instructions, .SETPO, Register(dst)) } -emit_setpo_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { emit_m(instructions, .SETPO, dst.mem, 1) } -inst_sets_r8 :: #force_inline proc "contextless" (dst: GPR8) -> Instruction { return inst_r(.SETS, Register(dst)) } -inst_sets_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return inst_m(.SETS, dst.mem, 1) } -emit_sets_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8) { emit_r(instructions, .SETS, Register(dst)) } -emit_sets_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { emit_m(instructions, .SETS, dst.mem, 1) } -inst_setz_r8 :: #force_inline proc "contextless" (dst: GPR8) -> Instruction { return inst_r(.SETZ, Register(dst)) } -inst_setz_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return inst_m(.SETZ, dst.mem, 1) } -emit_setz_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8) { emit_r(instructions, .SETZ, Register(dst)) } -emit_setz_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { emit_m(instructions, .SETZ, dst.mem, 1) } -inst_cmova_r16_r16 :: #force_inline proc "contextless" (dst: GPR16, src: GPR16) -> Instruction { return inst_r_r(.CMOVA, Register(dst), Register(src)) } -inst_cmova_r16_m16 :: #force_inline proc "contextless" (dst: GPR16, src: Mem16) -> Instruction { return inst_r_m(.CMOVA, Register(dst), src.mem, 2) } -inst_cmova_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return inst_r_r(.CMOVA, Register(dst), Register(src)) } -inst_cmova_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32) -> Instruction { return inst_r_m(.CMOVA, Register(dst), src.mem, 4) } -inst_cmova_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return inst_r_r(.CMOVA, Register(dst), Register(src)) } -inst_cmova_r64_m64 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64) -> Instruction { return inst_r_m(.CMOVA, Register(dst), src.mem, 8) } -emit_cmova_r16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: GPR16) { emit_rr(instructions, .CMOVA, Register(dst), Register(src)) } -emit_cmova_r16_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: Mem16) { emit_rm(instructions, .CMOVA, Register(dst), src.mem, 2) } -emit_cmova_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { emit_rr(instructions, .CMOVA, Register(dst), Register(src)) } -emit_cmova_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32) { emit_rm(instructions, .CMOVA, Register(dst), src.mem, 4) } -emit_cmova_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { emit_rr(instructions, .CMOVA, Register(dst), Register(src)) } -emit_cmova_r64_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem64) { emit_rm(instructions, .CMOVA, Register(dst), src.mem, 8) } -inst_cmovae_r16_r16 :: #force_inline proc "contextless" (dst: GPR16, src: GPR16) -> Instruction { return inst_r_r(.CMOVAE, Register(dst), Register(src)) } -inst_cmovae_r16_m16 :: #force_inline proc "contextless" (dst: GPR16, src: Mem16) -> Instruction { return inst_r_m(.CMOVAE, Register(dst), src.mem, 2) } -inst_cmovae_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return inst_r_r(.CMOVAE, Register(dst), Register(src)) } -inst_cmovae_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32) -> Instruction { return inst_r_m(.CMOVAE, Register(dst), src.mem, 4) } -inst_cmovae_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return inst_r_r(.CMOVAE, Register(dst), Register(src)) } -inst_cmovae_r64_m64 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64) -> Instruction { return inst_r_m(.CMOVAE, Register(dst), src.mem, 8) } -emit_cmovae_r16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: GPR16) { emit_rr(instructions, .CMOVAE, Register(dst), Register(src)) } -emit_cmovae_r16_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: Mem16) { emit_rm(instructions, .CMOVAE, Register(dst), src.mem, 2) } -emit_cmovae_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { emit_rr(instructions, .CMOVAE, Register(dst), Register(src)) } -emit_cmovae_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32) { emit_rm(instructions, .CMOVAE, Register(dst), src.mem, 4) } -emit_cmovae_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { emit_rr(instructions, .CMOVAE, Register(dst), Register(src)) } -emit_cmovae_r64_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem64) { emit_rm(instructions, .CMOVAE, Register(dst), src.mem, 8) } -inst_cmovb_r16_r16 :: #force_inline proc "contextless" (dst: GPR16, src: GPR16) -> Instruction { return inst_r_r(.CMOVB, Register(dst), Register(src)) } -inst_cmovb_r16_m16 :: #force_inline proc "contextless" (dst: GPR16, src: Mem16) -> Instruction { return inst_r_m(.CMOVB, Register(dst), src.mem, 2) } -inst_cmovb_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return inst_r_r(.CMOVB, Register(dst), Register(src)) } -inst_cmovb_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32) -> Instruction { return inst_r_m(.CMOVB, Register(dst), src.mem, 4) } -inst_cmovb_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return inst_r_r(.CMOVB, Register(dst), Register(src)) } -inst_cmovb_r64_m64 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64) -> Instruction { return inst_r_m(.CMOVB, Register(dst), src.mem, 8) } -emit_cmovb_r16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: GPR16) { emit_rr(instructions, .CMOVB, Register(dst), Register(src)) } -emit_cmovb_r16_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: Mem16) { emit_rm(instructions, .CMOVB, Register(dst), src.mem, 2) } -emit_cmovb_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { emit_rr(instructions, .CMOVB, Register(dst), Register(src)) } -emit_cmovb_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32) { emit_rm(instructions, .CMOVB, Register(dst), src.mem, 4) } -emit_cmovb_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { emit_rr(instructions, .CMOVB, Register(dst), Register(src)) } -emit_cmovb_r64_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem64) { emit_rm(instructions, .CMOVB, Register(dst), src.mem, 8) } -inst_cmovbe_r16_r16 :: #force_inline proc "contextless" (dst: GPR16, src: GPR16) -> Instruction { return inst_r_r(.CMOVBE, Register(dst), Register(src)) } -inst_cmovbe_r16_m16 :: #force_inline proc "contextless" (dst: GPR16, src: Mem16) -> Instruction { return inst_r_m(.CMOVBE, Register(dst), src.mem, 2) } -inst_cmovbe_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return inst_r_r(.CMOVBE, Register(dst), Register(src)) } -inst_cmovbe_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32) -> Instruction { return inst_r_m(.CMOVBE, Register(dst), src.mem, 4) } -inst_cmovbe_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return inst_r_r(.CMOVBE, Register(dst), Register(src)) } -inst_cmovbe_r64_m64 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64) -> Instruction { return inst_r_m(.CMOVBE, Register(dst), src.mem, 8) } -emit_cmovbe_r16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: GPR16) { emit_rr(instructions, .CMOVBE, Register(dst), Register(src)) } -emit_cmovbe_r16_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: Mem16) { emit_rm(instructions, .CMOVBE, Register(dst), src.mem, 2) } -emit_cmovbe_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { emit_rr(instructions, .CMOVBE, Register(dst), Register(src)) } -emit_cmovbe_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32) { emit_rm(instructions, .CMOVBE, Register(dst), src.mem, 4) } -emit_cmovbe_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { emit_rr(instructions, .CMOVBE, Register(dst), Register(src)) } -emit_cmovbe_r64_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem64) { emit_rm(instructions, .CMOVBE, Register(dst), src.mem, 8) } -inst_cmovc_r16_r16 :: #force_inline proc "contextless" (dst: GPR16, src: GPR16) -> Instruction { return inst_r_r(.CMOVC, Register(dst), Register(src)) } -inst_cmovc_r16_m16 :: #force_inline proc "contextless" (dst: GPR16, src: Mem16) -> Instruction { return inst_r_m(.CMOVC, Register(dst), src.mem, 2) } -inst_cmovc_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return inst_r_r(.CMOVC, Register(dst), Register(src)) } -inst_cmovc_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32) -> Instruction { return inst_r_m(.CMOVC, Register(dst), src.mem, 4) } -inst_cmovc_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return inst_r_r(.CMOVC, Register(dst), Register(src)) } -inst_cmovc_r64_m64 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64) -> Instruction { return inst_r_m(.CMOVC, Register(dst), src.mem, 8) } -emit_cmovc_r16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: GPR16) { emit_rr(instructions, .CMOVC, Register(dst), Register(src)) } -emit_cmovc_r16_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: Mem16) { emit_rm(instructions, .CMOVC, Register(dst), src.mem, 2) } -emit_cmovc_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { emit_rr(instructions, .CMOVC, Register(dst), Register(src)) } -emit_cmovc_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32) { emit_rm(instructions, .CMOVC, Register(dst), src.mem, 4) } -emit_cmovc_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { emit_rr(instructions, .CMOVC, Register(dst), Register(src)) } -emit_cmovc_r64_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem64) { emit_rm(instructions, .CMOVC, Register(dst), src.mem, 8) } -inst_cmove_r16_r16 :: #force_inline proc "contextless" (dst: GPR16, src: GPR16) -> Instruction { return inst_r_r(.CMOVE, Register(dst), Register(src)) } -inst_cmove_r16_m16 :: #force_inline proc "contextless" (dst: GPR16, src: Mem16) -> Instruction { return inst_r_m(.CMOVE, Register(dst), src.mem, 2) } -inst_cmove_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return inst_r_r(.CMOVE, Register(dst), Register(src)) } -inst_cmove_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32) -> Instruction { return inst_r_m(.CMOVE, Register(dst), src.mem, 4) } -inst_cmove_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return inst_r_r(.CMOVE, Register(dst), Register(src)) } -inst_cmove_r64_m64 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64) -> Instruction { return inst_r_m(.CMOVE, Register(dst), src.mem, 8) } -emit_cmove_r16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: GPR16) { emit_rr(instructions, .CMOVE, Register(dst), Register(src)) } -emit_cmove_r16_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: Mem16) { emit_rm(instructions, .CMOVE, Register(dst), src.mem, 2) } -emit_cmove_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { emit_rr(instructions, .CMOVE, Register(dst), Register(src)) } -emit_cmove_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32) { emit_rm(instructions, .CMOVE, Register(dst), src.mem, 4) } -emit_cmove_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { emit_rr(instructions, .CMOVE, Register(dst), Register(src)) } -emit_cmove_r64_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem64) { emit_rm(instructions, .CMOVE, Register(dst), src.mem, 8) } -inst_cmovg_r16_r16 :: #force_inline proc "contextless" (dst: GPR16, src: GPR16) -> Instruction { return inst_r_r(.CMOVG, Register(dst), Register(src)) } -inst_cmovg_r16_m16 :: #force_inline proc "contextless" (dst: GPR16, src: Mem16) -> Instruction { return inst_r_m(.CMOVG, Register(dst), src.mem, 2) } -inst_cmovg_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return inst_r_r(.CMOVG, Register(dst), Register(src)) } -inst_cmovg_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32) -> Instruction { return inst_r_m(.CMOVG, Register(dst), src.mem, 4) } -inst_cmovg_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return inst_r_r(.CMOVG, Register(dst), Register(src)) } -inst_cmovg_r64_m64 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64) -> Instruction { return inst_r_m(.CMOVG, Register(dst), src.mem, 8) } -emit_cmovg_r16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: GPR16) { emit_rr(instructions, .CMOVG, Register(dst), Register(src)) } -emit_cmovg_r16_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: Mem16) { emit_rm(instructions, .CMOVG, Register(dst), src.mem, 2) } -emit_cmovg_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { emit_rr(instructions, .CMOVG, Register(dst), Register(src)) } -emit_cmovg_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32) { emit_rm(instructions, .CMOVG, Register(dst), src.mem, 4) } -emit_cmovg_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { emit_rr(instructions, .CMOVG, Register(dst), Register(src)) } -emit_cmovg_r64_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem64) { emit_rm(instructions, .CMOVG, Register(dst), src.mem, 8) } -inst_cmovge_r16_r16 :: #force_inline proc "contextless" (dst: GPR16, src: GPR16) -> Instruction { return inst_r_r(.CMOVGE, Register(dst), Register(src)) } -inst_cmovge_r16_m16 :: #force_inline proc "contextless" (dst: GPR16, src: Mem16) -> Instruction { return inst_r_m(.CMOVGE, Register(dst), src.mem, 2) } -inst_cmovge_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return inst_r_r(.CMOVGE, Register(dst), Register(src)) } -inst_cmovge_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32) -> Instruction { return inst_r_m(.CMOVGE, Register(dst), src.mem, 4) } -inst_cmovge_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return inst_r_r(.CMOVGE, Register(dst), Register(src)) } -inst_cmovge_r64_m64 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64) -> Instruction { return inst_r_m(.CMOVGE, Register(dst), src.mem, 8) } -emit_cmovge_r16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: GPR16) { emit_rr(instructions, .CMOVGE, Register(dst), Register(src)) } -emit_cmovge_r16_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: Mem16) { emit_rm(instructions, .CMOVGE, Register(dst), src.mem, 2) } -emit_cmovge_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { emit_rr(instructions, .CMOVGE, Register(dst), Register(src)) } -emit_cmovge_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32) { emit_rm(instructions, .CMOVGE, Register(dst), src.mem, 4) } -emit_cmovge_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { emit_rr(instructions, .CMOVGE, Register(dst), Register(src)) } -emit_cmovge_r64_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem64) { emit_rm(instructions, .CMOVGE, Register(dst), src.mem, 8) } -inst_cmovl_r16_r16 :: #force_inline proc "contextless" (dst: GPR16, src: GPR16) -> Instruction { return inst_r_r(.CMOVL, Register(dst), Register(src)) } -inst_cmovl_r16_m16 :: #force_inline proc "contextless" (dst: GPR16, src: Mem16) -> Instruction { return inst_r_m(.CMOVL, Register(dst), src.mem, 2) } -inst_cmovl_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return inst_r_r(.CMOVL, Register(dst), Register(src)) } -inst_cmovl_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32) -> Instruction { return inst_r_m(.CMOVL, Register(dst), src.mem, 4) } -inst_cmovl_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return inst_r_r(.CMOVL, Register(dst), Register(src)) } -inst_cmovl_r64_m64 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64) -> Instruction { return inst_r_m(.CMOVL, Register(dst), src.mem, 8) } -emit_cmovl_r16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: GPR16) { emit_rr(instructions, .CMOVL, Register(dst), Register(src)) } -emit_cmovl_r16_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: Mem16) { emit_rm(instructions, .CMOVL, Register(dst), src.mem, 2) } -emit_cmovl_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { emit_rr(instructions, .CMOVL, Register(dst), Register(src)) } -emit_cmovl_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32) { emit_rm(instructions, .CMOVL, Register(dst), src.mem, 4) } -emit_cmovl_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { emit_rr(instructions, .CMOVL, Register(dst), Register(src)) } -emit_cmovl_r64_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem64) { emit_rm(instructions, .CMOVL, Register(dst), src.mem, 8) } -inst_cmovle_r16_r16 :: #force_inline proc "contextless" (dst: GPR16, src: GPR16) -> Instruction { return inst_r_r(.CMOVLE, Register(dst), Register(src)) } -inst_cmovle_r16_m16 :: #force_inline proc "contextless" (dst: GPR16, src: Mem16) -> Instruction { return inst_r_m(.CMOVLE, Register(dst), src.mem, 2) } -inst_cmovle_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return inst_r_r(.CMOVLE, Register(dst), Register(src)) } -inst_cmovle_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32) -> Instruction { return inst_r_m(.CMOVLE, Register(dst), src.mem, 4) } -inst_cmovle_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return inst_r_r(.CMOVLE, Register(dst), Register(src)) } -inst_cmovle_r64_m64 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64) -> Instruction { return inst_r_m(.CMOVLE, Register(dst), src.mem, 8) } -emit_cmovle_r16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: GPR16) { emit_rr(instructions, .CMOVLE, Register(dst), Register(src)) } -emit_cmovle_r16_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: Mem16) { emit_rm(instructions, .CMOVLE, Register(dst), src.mem, 2) } -emit_cmovle_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { emit_rr(instructions, .CMOVLE, Register(dst), Register(src)) } -emit_cmovle_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32) { emit_rm(instructions, .CMOVLE, Register(dst), src.mem, 4) } -emit_cmovle_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { emit_rr(instructions, .CMOVLE, Register(dst), Register(src)) } -emit_cmovle_r64_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem64) { emit_rm(instructions, .CMOVLE, Register(dst), src.mem, 8) } -inst_cmovna_r16_r16 :: #force_inline proc "contextless" (dst: GPR16, src: GPR16) -> Instruction { return inst_r_r(.CMOVNA, Register(dst), Register(src)) } -inst_cmovna_r16_m16 :: #force_inline proc "contextless" (dst: GPR16, src: Mem16) -> Instruction { return inst_r_m(.CMOVNA, Register(dst), src.mem, 2) } -inst_cmovna_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return inst_r_r(.CMOVNA, Register(dst), Register(src)) } -inst_cmovna_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32) -> Instruction { return inst_r_m(.CMOVNA, Register(dst), src.mem, 4) } -inst_cmovna_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return inst_r_r(.CMOVNA, Register(dst), Register(src)) } -inst_cmovna_r64_m64 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64) -> Instruction { return inst_r_m(.CMOVNA, Register(dst), src.mem, 8) } -emit_cmovna_r16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: GPR16) { emit_rr(instructions, .CMOVNA, Register(dst), Register(src)) } -emit_cmovna_r16_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: Mem16) { emit_rm(instructions, .CMOVNA, Register(dst), src.mem, 2) } -emit_cmovna_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { emit_rr(instructions, .CMOVNA, Register(dst), Register(src)) } -emit_cmovna_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32) { emit_rm(instructions, .CMOVNA, Register(dst), src.mem, 4) } -emit_cmovna_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { emit_rr(instructions, .CMOVNA, Register(dst), Register(src)) } -emit_cmovna_r64_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem64) { emit_rm(instructions, .CMOVNA, Register(dst), src.mem, 8) } -inst_cmovnae_r16_r16 :: #force_inline proc "contextless" (dst: GPR16, src: GPR16) -> Instruction { return inst_r_r(.CMOVNAE, Register(dst), Register(src)) } -inst_cmovnae_r16_m16 :: #force_inline proc "contextless" (dst: GPR16, src: Mem16) -> Instruction { return inst_r_m(.CMOVNAE, Register(dst), src.mem, 2) } -inst_cmovnae_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return inst_r_r(.CMOVNAE, Register(dst), Register(src)) } -inst_cmovnae_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32) -> Instruction { return inst_r_m(.CMOVNAE, Register(dst), src.mem, 4) } -inst_cmovnae_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return inst_r_r(.CMOVNAE, Register(dst), Register(src)) } -inst_cmovnae_r64_m64 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64) -> Instruction { return inst_r_m(.CMOVNAE, Register(dst), src.mem, 8) } -emit_cmovnae_r16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: GPR16) { emit_rr(instructions, .CMOVNAE, Register(dst), Register(src)) } -emit_cmovnae_r16_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: Mem16) { emit_rm(instructions, .CMOVNAE, Register(dst), src.mem, 2) } -emit_cmovnae_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { emit_rr(instructions, .CMOVNAE, Register(dst), Register(src)) } -emit_cmovnae_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32) { emit_rm(instructions, .CMOVNAE, Register(dst), src.mem, 4) } -emit_cmovnae_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { emit_rr(instructions, .CMOVNAE, Register(dst), Register(src)) } -emit_cmovnae_r64_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem64) { emit_rm(instructions, .CMOVNAE, Register(dst), src.mem, 8) } -inst_cmovnb_r16_r16 :: #force_inline proc "contextless" (dst: GPR16, src: GPR16) -> Instruction { return inst_r_r(.CMOVNB, Register(dst), Register(src)) } -inst_cmovnb_r16_m16 :: #force_inline proc "contextless" (dst: GPR16, src: Mem16) -> Instruction { return inst_r_m(.CMOVNB, Register(dst), src.mem, 2) } -inst_cmovnb_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return inst_r_r(.CMOVNB, Register(dst), Register(src)) } -inst_cmovnb_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32) -> Instruction { return inst_r_m(.CMOVNB, Register(dst), src.mem, 4) } -inst_cmovnb_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return inst_r_r(.CMOVNB, Register(dst), Register(src)) } -inst_cmovnb_r64_m64 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64) -> Instruction { return inst_r_m(.CMOVNB, Register(dst), src.mem, 8) } -emit_cmovnb_r16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: GPR16) { emit_rr(instructions, .CMOVNB, Register(dst), Register(src)) } -emit_cmovnb_r16_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: Mem16) { emit_rm(instructions, .CMOVNB, Register(dst), src.mem, 2) } -emit_cmovnb_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { emit_rr(instructions, .CMOVNB, Register(dst), Register(src)) } -emit_cmovnb_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32) { emit_rm(instructions, .CMOVNB, Register(dst), src.mem, 4) } -emit_cmovnb_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { emit_rr(instructions, .CMOVNB, Register(dst), Register(src)) } -emit_cmovnb_r64_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem64) { emit_rm(instructions, .CMOVNB, Register(dst), src.mem, 8) } -inst_cmovnbe_r16_r16 :: #force_inline proc "contextless" (dst: GPR16, src: GPR16) -> Instruction { return inst_r_r(.CMOVNBE, Register(dst), Register(src)) } -inst_cmovnbe_r16_m16 :: #force_inline proc "contextless" (dst: GPR16, src: Mem16) -> Instruction { return inst_r_m(.CMOVNBE, Register(dst), src.mem, 2) } -inst_cmovnbe_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return inst_r_r(.CMOVNBE, Register(dst), Register(src)) } -inst_cmovnbe_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32) -> Instruction { return inst_r_m(.CMOVNBE, Register(dst), src.mem, 4) } -inst_cmovnbe_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return inst_r_r(.CMOVNBE, Register(dst), Register(src)) } -inst_cmovnbe_r64_m64 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64) -> Instruction { return inst_r_m(.CMOVNBE, Register(dst), src.mem, 8) } -emit_cmovnbe_r16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: GPR16) { emit_rr(instructions, .CMOVNBE, Register(dst), Register(src)) } -emit_cmovnbe_r16_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: Mem16) { emit_rm(instructions, .CMOVNBE, Register(dst), src.mem, 2) } -emit_cmovnbe_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { emit_rr(instructions, .CMOVNBE, Register(dst), Register(src)) } -emit_cmovnbe_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32) { emit_rm(instructions, .CMOVNBE, Register(dst), src.mem, 4) } -emit_cmovnbe_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { emit_rr(instructions, .CMOVNBE, Register(dst), Register(src)) } -emit_cmovnbe_r64_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem64) { emit_rm(instructions, .CMOVNBE, Register(dst), src.mem, 8) } -inst_cmovnc_r16_r16 :: #force_inline proc "contextless" (dst: GPR16, src: GPR16) -> Instruction { return inst_r_r(.CMOVNC, Register(dst), Register(src)) } -inst_cmovnc_r16_m16 :: #force_inline proc "contextless" (dst: GPR16, src: Mem16) -> Instruction { return inst_r_m(.CMOVNC, Register(dst), src.mem, 2) } -inst_cmovnc_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return inst_r_r(.CMOVNC, Register(dst), Register(src)) } -inst_cmovnc_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32) -> Instruction { return inst_r_m(.CMOVNC, Register(dst), src.mem, 4) } -inst_cmovnc_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return inst_r_r(.CMOVNC, Register(dst), Register(src)) } -inst_cmovnc_r64_m64 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64) -> Instruction { return inst_r_m(.CMOVNC, Register(dst), src.mem, 8) } -emit_cmovnc_r16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: GPR16) { emit_rr(instructions, .CMOVNC, Register(dst), Register(src)) } -emit_cmovnc_r16_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: Mem16) { emit_rm(instructions, .CMOVNC, Register(dst), src.mem, 2) } -emit_cmovnc_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { emit_rr(instructions, .CMOVNC, Register(dst), Register(src)) } -emit_cmovnc_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32) { emit_rm(instructions, .CMOVNC, Register(dst), src.mem, 4) } -emit_cmovnc_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { emit_rr(instructions, .CMOVNC, Register(dst), Register(src)) } -emit_cmovnc_r64_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem64) { emit_rm(instructions, .CMOVNC, Register(dst), src.mem, 8) } -inst_cmovne_r16_r16 :: #force_inline proc "contextless" (dst: GPR16, src: GPR16) -> Instruction { return inst_r_r(.CMOVNE, Register(dst), Register(src)) } -inst_cmovne_r16_m16 :: #force_inline proc "contextless" (dst: GPR16, src: Mem16) -> Instruction { return inst_r_m(.CMOVNE, Register(dst), src.mem, 2) } -inst_cmovne_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return inst_r_r(.CMOVNE, Register(dst), Register(src)) } -inst_cmovne_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32) -> Instruction { return inst_r_m(.CMOVNE, Register(dst), src.mem, 4) } -inst_cmovne_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return inst_r_r(.CMOVNE, Register(dst), Register(src)) } -inst_cmovne_r64_m64 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64) -> Instruction { return inst_r_m(.CMOVNE, Register(dst), src.mem, 8) } -emit_cmovne_r16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: GPR16) { emit_rr(instructions, .CMOVNE, Register(dst), Register(src)) } -emit_cmovne_r16_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: Mem16) { emit_rm(instructions, .CMOVNE, Register(dst), src.mem, 2) } -emit_cmovne_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { emit_rr(instructions, .CMOVNE, Register(dst), Register(src)) } -emit_cmovne_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32) { emit_rm(instructions, .CMOVNE, Register(dst), src.mem, 4) } -emit_cmovne_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { emit_rr(instructions, .CMOVNE, Register(dst), Register(src)) } -emit_cmovne_r64_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem64) { emit_rm(instructions, .CMOVNE, Register(dst), src.mem, 8) } -inst_cmovng_r16_r16 :: #force_inline proc "contextless" (dst: GPR16, src: GPR16) -> Instruction { return inst_r_r(.CMOVNG, Register(dst), Register(src)) } -inst_cmovng_r16_m16 :: #force_inline proc "contextless" (dst: GPR16, src: Mem16) -> Instruction { return inst_r_m(.CMOVNG, Register(dst), src.mem, 2) } -inst_cmovng_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return inst_r_r(.CMOVNG, Register(dst), Register(src)) } -inst_cmovng_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32) -> Instruction { return inst_r_m(.CMOVNG, Register(dst), src.mem, 4) } -inst_cmovng_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return inst_r_r(.CMOVNG, Register(dst), Register(src)) } -inst_cmovng_r64_m64 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64) -> Instruction { return inst_r_m(.CMOVNG, Register(dst), src.mem, 8) } -emit_cmovng_r16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: GPR16) { emit_rr(instructions, .CMOVNG, Register(dst), Register(src)) } -emit_cmovng_r16_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: Mem16) { emit_rm(instructions, .CMOVNG, Register(dst), src.mem, 2) } -emit_cmovng_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { emit_rr(instructions, .CMOVNG, Register(dst), Register(src)) } -emit_cmovng_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32) { emit_rm(instructions, .CMOVNG, Register(dst), src.mem, 4) } -emit_cmovng_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { emit_rr(instructions, .CMOVNG, Register(dst), Register(src)) } -emit_cmovng_r64_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem64) { emit_rm(instructions, .CMOVNG, Register(dst), src.mem, 8) } -inst_cmovnge_r16_r16 :: #force_inline proc "contextless" (dst: GPR16, src: GPR16) -> Instruction { return inst_r_r(.CMOVNGE, Register(dst), Register(src)) } -inst_cmovnge_r16_m16 :: #force_inline proc "contextless" (dst: GPR16, src: Mem16) -> Instruction { return inst_r_m(.CMOVNGE, Register(dst), src.mem, 2) } -inst_cmovnge_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return inst_r_r(.CMOVNGE, Register(dst), Register(src)) } -inst_cmovnge_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32) -> Instruction { return inst_r_m(.CMOVNGE, Register(dst), src.mem, 4) } -inst_cmovnge_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return inst_r_r(.CMOVNGE, Register(dst), Register(src)) } -inst_cmovnge_r64_m64 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64) -> Instruction { return inst_r_m(.CMOVNGE, Register(dst), src.mem, 8) } -emit_cmovnge_r16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: GPR16) { emit_rr(instructions, .CMOVNGE, Register(dst), Register(src)) } -emit_cmovnge_r16_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: Mem16) { emit_rm(instructions, .CMOVNGE, Register(dst), src.mem, 2) } -emit_cmovnge_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { emit_rr(instructions, .CMOVNGE, Register(dst), Register(src)) } -emit_cmovnge_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32) { emit_rm(instructions, .CMOVNGE, Register(dst), src.mem, 4) } -emit_cmovnge_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { emit_rr(instructions, .CMOVNGE, Register(dst), Register(src)) } -emit_cmovnge_r64_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem64) { emit_rm(instructions, .CMOVNGE, Register(dst), src.mem, 8) } -inst_cmovnl_r16_r16 :: #force_inline proc "contextless" (dst: GPR16, src: GPR16) -> Instruction { return inst_r_r(.CMOVNL, Register(dst), Register(src)) } -inst_cmovnl_r16_m16 :: #force_inline proc "contextless" (dst: GPR16, src: Mem16) -> Instruction { return inst_r_m(.CMOVNL, Register(dst), src.mem, 2) } -inst_cmovnl_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return inst_r_r(.CMOVNL, Register(dst), Register(src)) } -inst_cmovnl_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32) -> Instruction { return inst_r_m(.CMOVNL, Register(dst), src.mem, 4) } -inst_cmovnl_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return inst_r_r(.CMOVNL, Register(dst), Register(src)) } -inst_cmovnl_r64_m64 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64) -> Instruction { return inst_r_m(.CMOVNL, Register(dst), src.mem, 8) } -emit_cmovnl_r16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: GPR16) { emit_rr(instructions, .CMOVNL, Register(dst), Register(src)) } -emit_cmovnl_r16_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: Mem16) { emit_rm(instructions, .CMOVNL, Register(dst), src.mem, 2) } -emit_cmovnl_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { emit_rr(instructions, .CMOVNL, Register(dst), Register(src)) } -emit_cmovnl_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32) { emit_rm(instructions, .CMOVNL, Register(dst), src.mem, 4) } -emit_cmovnl_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { emit_rr(instructions, .CMOVNL, Register(dst), Register(src)) } -emit_cmovnl_r64_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem64) { emit_rm(instructions, .CMOVNL, Register(dst), src.mem, 8) } -inst_cmovnle_r16_r16 :: #force_inline proc "contextless" (dst: GPR16, src: GPR16) -> Instruction { return inst_r_r(.CMOVNLE, Register(dst), Register(src)) } -inst_cmovnle_r16_m16 :: #force_inline proc "contextless" (dst: GPR16, src: Mem16) -> Instruction { return inst_r_m(.CMOVNLE, Register(dst), src.mem, 2) } -inst_cmovnle_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return inst_r_r(.CMOVNLE, Register(dst), Register(src)) } -inst_cmovnle_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32) -> Instruction { return inst_r_m(.CMOVNLE, Register(dst), src.mem, 4) } -inst_cmovnle_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return inst_r_r(.CMOVNLE, Register(dst), Register(src)) } -inst_cmovnle_r64_m64 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64) -> Instruction { return inst_r_m(.CMOVNLE, Register(dst), src.mem, 8) } -emit_cmovnle_r16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: GPR16) { emit_rr(instructions, .CMOVNLE, Register(dst), Register(src)) } -emit_cmovnle_r16_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: Mem16) { emit_rm(instructions, .CMOVNLE, Register(dst), src.mem, 2) } -emit_cmovnle_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { emit_rr(instructions, .CMOVNLE, Register(dst), Register(src)) } -emit_cmovnle_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32) { emit_rm(instructions, .CMOVNLE, Register(dst), src.mem, 4) } -emit_cmovnle_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { emit_rr(instructions, .CMOVNLE, Register(dst), Register(src)) } -emit_cmovnle_r64_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem64) { emit_rm(instructions, .CMOVNLE, Register(dst), src.mem, 8) } -inst_cmovno_r16_r16 :: #force_inline proc "contextless" (dst: GPR16, src: GPR16) -> Instruction { return inst_r_r(.CMOVNO, Register(dst), Register(src)) } -inst_cmovno_r16_m16 :: #force_inline proc "contextless" (dst: GPR16, src: Mem16) -> Instruction { return inst_r_m(.CMOVNO, Register(dst), src.mem, 2) } -inst_cmovno_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return inst_r_r(.CMOVNO, Register(dst), Register(src)) } -inst_cmovno_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32) -> Instruction { return inst_r_m(.CMOVNO, Register(dst), src.mem, 4) } -inst_cmovno_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return inst_r_r(.CMOVNO, Register(dst), Register(src)) } -inst_cmovno_r64_m64 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64) -> Instruction { return inst_r_m(.CMOVNO, Register(dst), src.mem, 8) } -emit_cmovno_r16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: GPR16) { emit_rr(instructions, .CMOVNO, Register(dst), Register(src)) } -emit_cmovno_r16_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: Mem16) { emit_rm(instructions, .CMOVNO, Register(dst), src.mem, 2) } -emit_cmovno_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { emit_rr(instructions, .CMOVNO, Register(dst), Register(src)) } -emit_cmovno_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32) { emit_rm(instructions, .CMOVNO, Register(dst), src.mem, 4) } -emit_cmovno_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { emit_rr(instructions, .CMOVNO, Register(dst), Register(src)) } -emit_cmovno_r64_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem64) { emit_rm(instructions, .CMOVNO, Register(dst), src.mem, 8) } -inst_cmovnp_r16_r16 :: #force_inline proc "contextless" (dst: GPR16, src: GPR16) -> Instruction { return inst_r_r(.CMOVNP, Register(dst), Register(src)) } -inst_cmovnp_r16_m16 :: #force_inline proc "contextless" (dst: GPR16, src: Mem16) -> Instruction { return inst_r_m(.CMOVNP, Register(dst), src.mem, 2) } -inst_cmovnp_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return inst_r_r(.CMOVNP, Register(dst), Register(src)) } -inst_cmovnp_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32) -> Instruction { return inst_r_m(.CMOVNP, Register(dst), src.mem, 4) } -inst_cmovnp_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return inst_r_r(.CMOVNP, Register(dst), Register(src)) } -inst_cmovnp_r64_m64 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64) -> Instruction { return inst_r_m(.CMOVNP, Register(dst), src.mem, 8) } -emit_cmovnp_r16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: GPR16) { emit_rr(instructions, .CMOVNP, Register(dst), Register(src)) } -emit_cmovnp_r16_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: Mem16) { emit_rm(instructions, .CMOVNP, Register(dst), src.mem, 2) } -emit_cmovnp_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { emit_rr(instructions, .CMOVNP, Register(dst), Register(src)) } -emit_cmovnp_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32) { emit_rm(instructions, .CMOVNP, Register(dst), src.mem, 4) } -emit_cmovnp_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { emit_rr(instructions, .CMOVNP, Register(dst), Register(src)) } -emit_cmovnp_r64_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem64) { emit_rm(instructions, .CMOVNP, Register(dst), src.mem, 8) } -inst_cmovns_r16_r16 :: #force_inline proc "contextless" (dst: GPR16, src: GPR16) -> Instruction { return inst_r_r(.CMOVNS, Register(dst), Register(src)) } -inst_cmovns_r16_m16 :: #force_inline proc "contextless" (dst: GPR16, src: Mem16) -> Instruction { return inst_r_m(.CMOVNS, Register(dst), src.mem, 2) } -inst_cmovns_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return inst_r_r(.CMOVNS, Register(dst), Register(src)) } -inst_cmovns_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32) -> Instruction { return inst_r_m(.CMOVNS, Register(dst), src.mem, 4) } -inst_cmovns_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return inst_r_r(.CMOVNS, Register(dst), Register(src)) } -inst_cmovns_r64_m64 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64) -> Instruction { return inst_r_m(.CMOVNS, Register(dst), src.mem, 8) } -emit_cmovns_r16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: GPR16) { emit_rr(instructions, .CMOVNS, Register(dst), Register(src)) } -emit_cmovns_r16_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: Mem16) { emit_rm(instructions, .CMOVNS, Register(dst), src.mem, 2) } -emit_cmovns_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { emit_rr(instructions, .CMOVNS, Register(dst), Register(src)) } -emit_cmovns_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32) { emit_rm(instructions, .CMOVNS, Register(dst), src.mem, 4) } -emit_cmovns_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { emit_rr(instructions, .CMOVNS, Register(dst), Register(src)) } -emit_cmovns_r64_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem64) { emit_rm(instructions, .CMOVNS, Register(dst), src.mem, 8) } -inst_cmovnz_r16_r16 :: #force_inline proc "contextless" (dst: GPR16, src: GPR16) -> Instruction { return inst_r_r(.CMOVNZ, Register(dst), Register(src)) } -inst_cmovnz_r16_m16 :: #force_inline proc "contextless" (dst: GPR16, src: Mem16) -> Instruction { return inst_r_m(.CMOVNZ, Register(dst), src.mem, 2) } -inst_cmovnz_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return inst_r_r(.CMOVNZ, Register(dst), Register(src)) } -inst_cmovnz_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32) -> Instruction { return inst_r_m(.CMOVNZ, Register(dst), src.mem, 4) } -inst_cmovnz_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return inst_r_r(.CMOVNZ, Register(dst), Register(src)) } -inst_cmovnz_r64_m64 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64) -> Instruction { return inst_r_m(.CMOVNZ, Register(dst), src.mem, 8) } -emit_cmovnz_r16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: GPR16) { emit_rr(instructions, .CMOVNZ, Register(dst), Register(src)) } -emit_cmovnz_r16_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: Mem16) { emit_rm(instructions, .CMOVNZ, Register(dst), src.mem, 2) } -emit_cmovnz_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { emit_rr(instructions, .CMOVNZ, Register(dst), Register(src)) } -emit_cmovnz_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32) { emit_rm(instructions, .CMOVNZ, Register(dst), src.mem, 4) } -emit_cmovnz_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { emit_rr(instructions, .CMOVNZ, Register(dst), Register(src)) } -emit_cmovnz_r64_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem64) { emit_rm(instructions, .CMOVNZ, Register(dst), src.mem, 8) } -inst_cmovo_r16_r16 :: #force_inline proc "contextless" (dst: GPR16, src: GPR16) -> Instruction { return inst_r_r(.CMOVO, Register(dst), Register(src)) } -inst_cmovo_r16_m16 :: #force_inline proc "contextless" (dst: GPR16, src: Mem16) -> Instruction { return inst_r_m(.CMOVO, Register(dst), src.mem, 2) } -inst_cmovo_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return inst_r_r(.CMOVO, Register(dst), Register(src)) } -inst_cmovo_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32) -> Instruction { return inst_r_m(.CMOVO, Register(dst), src.mem, 4) } -inst_cmovo_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return inst_r_r(.CMOVO, Register(dst), Register(src)) } -inst_cmovo_r64_m64 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64) -> Instruction { return inst_r_m(.CMOVO, Register(dst), src.mem, 8) } -emit_cmovo_r16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: GPR16) { emit_rr(instructions, .CMOVO, Register(dst), Register(src)) } -emit_cmovo_r16_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: Mem16) { emit_rm(instructions, .CMOVO, Register(dst), src.mem, 2) } -emit_cmovo_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { emit_rr(instructions, .CMOVO, Register(dst), Register(src)) } -emit_cmovo_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32) { emit_rm(instructions, .CMOVO, Register(dst), src.mem, 4) } -emit_cmovo_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { emit_rr(instructions, .CMOVO, Register(dst), Register(src)) } -emit_cmovo_r64_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem64) { emit_rm(instructions, .CMOVO, Register(dst), src.mem, 8) } -inst_cmovp_r16_r16 :: #force_inline proc "contextless" (dst: GPR16, src: GPR16) -> Instruction { return inst_r_r(.CMOVP, Register(dst), Register(src)) } -inst_cmovp_r16_m16 :: #force_inline proc "contextless" (dst: GPR16, src: Mem16) -> Instruction { return inst_r_m(.CMOVP, Register(dst), src.mem, 2) } -inst_cmovp_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return inst_r_r(.CMOVP, Register(dst), Register(src)) } -inst_cmovp_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32) -> Instruction { return inst_r_m(.CMOVP, Register(dst), src.mem, 4) } -inst_cmovp_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return inst_r_r(.CMOVP, Register(dst), Register(src)) } -inst_cmovp_r64_m64 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64) -> Instruction { return inst_r_m(.CMOVP, Register(dst), src.mem, 8) } -emit_cmovp_r16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: GPR16) { emit_rr(instructions, .CMOVP, Register(dst), Register(src)) } -emit_cmovp_r16_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: Mem16) { emit_rm(instructions, .CMOVP, Register(dst), src.mem, 2) } -emit_cmovp_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { emit_rr(instructions, .CMOVP, Register(dst), Register(src)) } -emit_cmovp_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32) { emit_rm(instructions, .CMOVP, Register(dst), src.mem, 4) } -emit_cmovp_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { emit_rr(instructions, .CMOVP, Register(dst), Register(src)) } -emit_cmovp_r64_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem64) { emit_rm(instructions, .CMOVP, Register(dst), src.mem, 8) } -inst_cmovpe_r16_r16 :: #force_inline proc "contextless" (dst: GPR16, src: GPR16) -> Instruction { return inst_r_r(.CMOVPE, Register(dst), Register(src)) } -inst_cmovpe_r16_m16 :: #force_inline proc "contextless" (dst: GPR16, src: Mem16) -> Instruction { return inst_r_m(.CMOVPE, Register(dst), src.mem, 2) } -inst_cmovpe_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return inst_r_r(.CMOVPE, Register(dst), Register(src)) } -inst_cmovpe_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32) -> Instruction { return inst_r_m(.CMOVPE, Register(dst), src.mem, 4) } -inst_cmovpe_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return inst_r_r(.CMOVPE, Register(dst), Register(src)) } -inst_cmovpe_r64_m64 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64) -> Instruction { return inst_r_m(.CMOVPE, Register(dst), src.mem, 8) } -emit_cmovpe_r16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: GPR16) { emit_rr(instructions, .CMOVPE, Register(dst), Register(src)) } -emit_cmovpe_r16_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: Mem16) { emit_rm(instructions, .CMOVPE, Register(dst), src.mem, 2) } -emit_cmovpe_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { emit_rr(instructions, .CMOVPE, Register(dst), Register(src)) } -emit_cmovpe_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32) { emit_rm(instructions, .CMOVPE, Register(dst), src.mem, 4) } -emit_cmovpe_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { emit_rr(instructions, .CMOVPE, Register(dst), Register(src)) } -emit_cmovpe_r64_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem64) { emit_rm(instructions, .CMOVPE, Register(dst), src.mem, 8) } -inst_cmovpo_r16_r16 :: #force_inline proc "contextless" (dst: GPR16, src: GPR16) -> Instruction { return inst_r_r(.CMOVPO, Register(dst), Register(src)) } -inst_cmovpo_r16_m16 :: #force_inline proc "contextless" (dst: GPR16, src: Mem16) -> Instruction { return inst_r_m(.CMOVPO, Register(dst), src.mem, 2) } -inst_cmovpo_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return inst_r_r(.CMOVPO, Register(dst), Register(src)) } -inst_cmovpo_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32) -> Instruction { return inst_r_m(.CMOVPO, Register(dst), src.mem, 4) } -inst_cmovpo_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return inst_r_r(.CMOVPO, Register(dst), Register(src)) } -inst_cmovpo_r64_m64 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64) -> Instruction { return inst_r_m(.CMOVPO, Register(dst), src.mem, 8) } -emit_cmovpo_r16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: GPR16) { emit_rr(instructions, .CMOVPO, Register(dst), Register(src)) } -emit_cmovpo_r16_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: Mem16) { emit_rm(instructions, .CMOVPO, Register(dst), src.mem, 2) } -emit_cmovpo_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { emit_rr(instructions, .CMOVPO, Register(dst), Register(src)) } -emit_cmovpo_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32) { emit_rm(instructions, .CMOVPO, Register(dst), src.mem, 4) } -emit_cmovpo_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { emit_rr(instructions, .CMOVPO, Register(dst), Register(src)) } -emit_cmovpo_r64_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem64) { emit_rm(instructions, .CMOVPO, Register(dst), src.mem, 8) } -inst_cmovs_r16_r16 :: #force_inline proc "contextless" (dst: GPR16, src: GPR16) -> Instruction { return inst_r_r(.CMOVS, Register(dst), Register(src)) } -inst_cmovs_r16_m16 :: #force_inline proc "contextless" (dst: GPR16, src: Mem16) -> Instruction { return inst_r_m(.CMOVS, Register(dst), src.mem, 2) } -inst_cmovs_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return inst_r_r(.CMOVS, Register(dst), Register(src)) } -inst_cmovs_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32) -> Instruction { return inst_r_m(.CMOVS, Register(dst), src.mem, 4) } -inst_cmovs_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return inst_r_r(.CMOVS, Register(dst), Register(src)) } -inst_cmovs_r64_m64 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64) -> Instruction { return inst_r_m(.CMOVS, Register(dst), src.mem, 8) } -emit_cmovs_r16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: GPR16) { emit_rr(instructions, .CMOVS, Register(dst), Register(src)) } -emit_cmovs_r16_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: Mem16) { emit_rm(instructions, .CMOVS, Register(dst), src.mem, 2) } -emit_cmovs_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { emit_rr(instructions, .CMOVS, Register(dst), Register(src)) } -emit_cmovs_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32) { emit_rm(instructions, .CMOVS, Register(dst), src.mem, 4) } -emit_cmovs_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { emit_rr(instructions, .CMOVS, Register(dst), Register(src)) } -emit_cmovs_r64_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem64) { emit_rm(instructions, .CMOVS, Register(dst), src.mem, 8) } -inst_cmovz_r16_r16 :: #force_inline proc "contextless" (dst: GPR16, src: GPR16) -> Instruction { return inst_r_r(.CMOVZ, Register(dst), Register(src)) } -inst_cmovz_r16_m16 :: #force_inline proc "contextless" (dst: GPR16, src: Mem16) -> Instruction { return inst_r_m(.CMOVZ, Register(dst), src.mem, 2) } -inst_cmovz_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return inst_r_r(.CMOVZ, Register(dst), Register(src)) } -inst_cmovz_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32) -> Instruction { return inst_r_m(.CMOVZ, Register(dst), src.mem, 4) } -inst_cmovz_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return inst_r_r(.CMOVZ, Register(dst), Register(src)) } -inst_cmovz_r64_m64 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64) -> Instruction { return inst_r_m(.CMOVZ, Register(dst), src.mem, 8) } -emit_cmovz_r16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: GPR16) { emit_rr(instructions, .CMOVZ, Register(dst), Register(src)) } -emit_cmovz_r16_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: Mem16) { emit_rm(instructions, .CMOVZ, Register(dst), src.mem, 2) } -emit_cmovz_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { emit_rr(instructions, .CMOVZ, Register(dst), Register(src)) } -emit_cmovz_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32) { emit_rm(instructions, .CMOVZ, Register(dst), src.mem, 4) } -emit_cmovz_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { emit_rr(instructions, .CMOVZ, Register(dst), Register(src)) } -emit_cmovz_r64_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem64) { emit_rm(instructions, .CMOVZ, Register(dst), src.mem, 8) } -inst_movs_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.MOVS) } -emit_movs_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .MOVS) } -inst_movsb_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.MOVSB) } -emit_movsb_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .MOVSB) } -inst_movsw_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.MOVSW) } -emit_movsw_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .MOVSW) } -inst_movsd_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.MOVSD) } -emit_movsd_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .MOVSD) } -inst_movsq_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.MOVSQ) } -emit_movsq_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .MOVSQ) } -inst_cmps_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.CMPS) } -emit_cmps_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .CMPS) } -inst_cmpsb_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.CMPSB) } -emit_cmpsb_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .CMPSB) } -inst_cmpsw_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.CMPSW) } -emit_cmpsw_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .CMPSW) } -inst_cmpsd_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.CMPSD) } -emit_cmpsd_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .CMPSD) } -inst_cmpsq_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.CMPSQ) } -emit_cmpsq_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .CMPSQ) } -inst_scas_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.SCAS) } -emit_scas_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .SCAS) } -inst_scasb_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.SCASB) } -emit_scasb_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .SCASB) } -inst_scasw_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.SCASW) } -emit_scasw_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .SCASW) } -inst_scasd_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.SCASD) } -emit_scasd_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .SCASD) } -inst_scasq_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.SCASQ) } -emit_scasq_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .SCASQ) } -inst_lods_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.LODS) } -emit_lods_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .LODS) } -inst_lodsb_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.LODSB) } -emit_lodsb_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .LODSB) } -inst_lodsw_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.LODSW) } -emit_lodsw_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .LODSW) } -inst_lodsd_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.LODSD) } -emit_lodsd_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .LODSD) } -inst_lodsq_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.LODSQ) } -emit_lodsq_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .LODSQ) } -inst_stos_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.STOS) } -emit_stos_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .STOS) } -inst_stosb_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.STOSB) } -emit_stosb_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .STOSB) } -inst_stosw_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.STOSW) } -emit_stosw_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .STOSW) } -inst_stosd_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.STOSD) } -emit_stosd_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .STOSD) } -inst_stosq_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.STOSQ) } -emit_stosq_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .STOSQ) } -inst_clc_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.CLC) } -emit_clc_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .CLC) } -inst_stc_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.STC) } -emit_stc_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .STC) } -inst_cmc_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.CMC) } -emit_cmc_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .CMC) } -inst_cld_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.CLD) } -emit_cld_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .CLD) } -inst_std_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.STD) } -emit_std_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .STD) } -inst_cli_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.CLI) } -emit_cli_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .CLI) } -inst_sti_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.STI) } -emit_sti_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .STI) } -inst_lahf_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.LAHF) } -emit_lahf_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .LAHF) } -inst_sahf_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.SAHF) } -emit_sahf_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .SAHF) } -inst_pushf_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.PUSHF) } -emit_pushf_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .PUSHF) } -inst_pushfd_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.PUSHFD) } -emit_pushfd_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .PUSHFD) } -inst_pushfq_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.PUSHFQ) } -emit_pushfq_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .PUSHFQ) } -inst_popf_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.POPF) } -emit_popf_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .POPF) } -inst_popfd_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.POPFD) } -emit_popfd_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .POPFD) } -inst_popfq_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.POPFQ) } -emit_popfq_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .POPFQ) } -inst_nop_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.NOP) } -inst_nop_r16 :: #force_inline proc "contextless" (dst: GPR16) -> Instruction { return inst_r(.NOP, Register(dst)) } -inst_nop_m16 :: #force_inline proc "contextless" (dst: Mem16) -> Instruction { return inst_m(.NOP, dst.mem, 2) } -inst_nop_r32 :: #force_inline proc "contextless" (dst: GPR32) -> Instruction { return inst_r(.NOP, Register(dst)) } -inst_nop_m32 :: #force_inline proc "contextless" (dst: Mem32) -> Instruction { return inst_m(.NOP, dst.mem, 4) } -inst_nop_r64 :: #force_inline proc "contextless" (dst: GPR64) -> Instruction { return inst_r(.NOP, Register(dst)) } -inst_nop_m64 :: #force_inline proc "contextless" (dst: Mem64) -> Instruction { return inst_m(.NOP, dst.mem, 8) } -emit_nop_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .NOP) } -emit_nop_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16) { emit_r(instructions, .NOP, Register(dst)) } -emit_nop_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16) { emit_m(instructions, .NOP, dst.mem, 2) } -emit_nop_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32) { emit_r(instructions, .NOP, Register(dst)) } -emit_nop_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32) { emit_m(instructions, .NOP, dst.mem, 4) } -emit_nop_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64) { emit_r(instructions, .NOP, Register(dst)) } -emit_nop_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64) { emit_m(instructions, .NOP, dst.mem, 8) } -inst_hlt_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.HLT) } -emit_hlt_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .HLT) } -inst_wait_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.WAIT) } -emit_wait_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .WAIT) } -inst_lock_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.LOCK) } -emit_lock_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .LOCK) } -inst_ud0_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return inst_r_r(.UD0, Register(dst), Register(src)) } -inst_ud0_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32) -> Instruction { return inst_r_m(.UD0, Register(dst), src.mem, 4) } -emit_ud0_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { emit_rr(instructions, .UD0, Register(dst), Register(src)) } -emit_ud0_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32) { emit_rm(instructions, .UD0, Register(dst), src.mem, 4) } -inst_ud1_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return inst_r_r(.UD1, Register(dst), Register(src)) } -inst_ud1_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32) -> Instruction { return inst_r_m(.UD1, Register(dst), src.mem, 4) } -emit_ud1_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { emit_rr(instructions, .UD1, Register(dst), Register(src)) } -emit_ud1_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32) { emit_rm(instructions, .UD1, Register(dst), src.mem, 4) } -inst_ud2_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.UD2) } -emit_ud2_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .UD2) } -inst_cpuid_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.CPUID) } -emit_cpuid_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .CPUID) } -inst_rdtsc_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.RDTSC) } -emit_rdtsc_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .RDTSC) } -inst_rdtscp_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.RDTSCP) } -emit_rdtscp_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .RDTSCP) } -inst_rdpmc_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.RDPMC) } -emit_rdpmc_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .RDPMC) } -inst_xgetbv_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.XGETBV) } -emit_xgetbv_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .XGETBV) } -inst_xsetbv_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.XSETBV) } -emit_xsetbv_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .XSETBV) } -inst_cbw_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.CBW) } -emit_cbw_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .CBW) } -inst_cwde_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.CWDE) } -emit_cwde_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .CWDE) } -inst_cdqe_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.CDQE) } -emit_cdqe_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .CDQE) } -inst_cwd_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.CWD) } -emit_cwd_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .CWD) } -inst_cdq_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.CDQ) } -emit_cdq_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .CDQ) } -inst_cqo_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.CQO) } -emit_cqo_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .CQO) } -inst_andn_r32_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32, src2: GPR32) -> Instruction { return inst_r_r_r(.ANDN, Register(dst), Register(src), Register(src2)) } -inst_andn_r32_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32, src2: Mem32) -> Instruction { return inst_r_r_m(.ANDN, Register(dst), Register(src), src2.mem, 4) } -inst_andn_r64_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64, src2: GPR64) -> Instruction { return inst_r_r_r(.ANDN, Register(dst), Register(src), Register(src2)) } -inst_andn_r64_r64_m64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64, src2: Mem64) -> Instruction { return inst_r_r_m(.ANDN, Register(dst), Register(src), src2.mem, 8) } -emit_andn_r32_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32, src2: GPR32) { emit_rrr(instructions, .ANDN, Register(dst), Register(src), Register(src2)) } -emit_andn_r32_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32, src2: Mem32) { emit_rrm(instructions, .ANDN, Register(dst), Register(src), src2.mem, 4) } -emit_andn_r64_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64, src2: GPR64) { emit_rrr(instructions, .ANDN, Register(dst), Register(src), Register(src2)) } -emit_andn_r64_r64_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64, src2: Mem64) { emit_rrm(instructions, .ANDN, Register(dst), Register(src), src2.mem, 8) } -inst_bextr_r32_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32, src2: GPR32) -> Instruction { return inst_r_r_r(.BEXTR, Register(dst), Register(src), Register(src2)) } -inst_bextr_r32_m32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32, src2: GPR32) -> Instruction { return Instruction{ mnemonic = .BEXTR, operand_count = 3, ops = {op_gpr32(dst), op_mem(src.mem, 4), op_gpr32(src2), {}} } } -inst_bextr_r64_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64, src2: GPR64) -> Instruction { return inst_r_r_r(.BEXTR, Register(dst), Register(src), Register(src2)) } -inst_bextr_r64_m64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64, src2: GPR64) -> Instruction { return Instruction{ mnemonic = .BEXTR, operand_count = 3, ops = {op_gpr64(dst), op_mem(src.mem, 8), op_gpr64(src2), {}} } } -emit_bextr_r32_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32, src2: GPR32) { emit_rrr(instructions, .BEXTR, Register(dst), Register(src), Register(src2)) } +inst_mov_r8_r8 :: #force_inline proc "contextless" (dst: GPR8, src: GPR8) -> Instruction { return with_hint(Instruction{ mnemonic = .MOV, operand_count = 2, ops = {op_gpr8(dst), op_gpr8(src), {}, {}} }, 1) } +inst_mov_m8_r8 :: #force_inline proc "contextless" (dst: Mem8, src: GPR8) -> Instruction { return with_hint(Instruction{ mnemonic = .MOV, operand_count = 2, ops = {op_mem(dst.mem, 1), op_gpr8(src), {}, {}} }, 1) } +inst_mov_r16_r16 :: #force_inline proc "contextless" (dst: GPR16, src: GPR16) -> Instruction { return with_hint(Instruction{ mnemonic = .MOV, operand_count = 2, ops = {op_gpr16(dst), op_gpr16(src), {}, {}} }, 2) } +inst_mov_m16_r16 :: #force_inline proc "contextless" (dst: Mem16, src: GPR16) -> Instruction { return with_hint(Instruction{ mnemonic = .MOV, operand_count = 2, ops = {op_mem(dst.mem, 2), op_gpr16(src), {}, {}} }, 2) } +inst_mov_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .MOV, operand_count = 2, ops = {op_gpr32(dst), op_gpr32(src), {}, {}} }, 3) } +inst_mov_m32_r32 :: #force_inline proc "contextless" (dst: Mem32, src: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .MOV, operand_count = 2, ops = {op_mem(dst.mem, 4), op_gpr32(src), {}, {}} }, 3) } +inst_mov_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .MOV, operand_count = 2, ops = {op_gpr64(dst), op_gpr64(src), {}, {}} }, 4) } +inst_mov_m64_r64 :: #force_inline proc "contextless" (dst: Mem64, src: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .MOV, operand_count = 2, ops = {op_mem(dst.mem, 8), op_gpr64(src), {}, {}} }, 4) } +inst_mov_r8_m8 :: #force_inline proc "contextless" (dst: GPR8, src: Mem8) -> Instruction { return with_hint(Instruction{ mnemonic = .MOV, operand_count = 2, ops = {op_gpr8(dst), op_mem(src.mem, 1), {}, {}} }, 5) } +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_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) } +inst_mov_m64_sreg :: #force_inline proc "contextless" (dst: Mem64, src: SREG) -> Instruction { return with_hint(Instruction{ mnemonic = .MOV, operand_count = 2, ops = {op_mem(dst.mem, 8), op_sreg(src), {}, {}} }, 26) } +inst_mov_sreg_r16 :: #force_inline proc "contextless" (dst: SREG, src: GPR16) -> Instruction { return with_hint(Instruction{ mnemonic = .MOV, operand_count = 2, ops = {op_sreg(dst), op_gpr16(src), {}, {}} }, 27) } +inst_mov_sreg_m16 :: #force_inline proc "contextless" (dst: SREG, src: Mem16) -> Instruction { return with_hint(Instruction{ mnemonic = .MOV, operand_count = 2, ops = {op_sreg(dst), op_mem(src.mem, 2), {}, {}} }, 27) } +inst_mov_sreg_r64 :: #force_inline proc "contextless" (dst: SREG, src: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .MOV, operand_count = 2, ops = {op_sreg(dst), op_gpr64(src), {}, {}} }, 28) } +inst_mov_sreg_m64 :: #force_inline proc "contextless" (dst: SREG, src: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .MOV, operand_count = 2, ops = {op_sreg(dst), op_mem(src.mem, 8), {}, {}} }, 28) } +inst_mov_r64_cr :: #force_inline proc "contextless" (dst: GPR64, src: CREG) -> Instruction { return with_hint(Instruction{ mnemonic = .MOV, operand_count = 2, ops = {op_gpr64(dst), op_creg(src), {}, {}} }, 29) } +inst_mov_cr_r64 :: #force_inline proc "contextless" (dst: CREG, src: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .MOV, operand_count = 2, ops = {op_creg(dst), op_gpr64(src), {}, {}} }, 30) } +inst_mov_r64_dr :: #force_inline proc "contextless" (dst: GPR64, src: DREG) -> Instruction { return with_hint(Instruction{ mnemonic = .MOV, operand_count = 2, ops = {op_gpr64(dst), op_dreg(src), {}, {}} }, 31) } +inst_mov_dr_r64 :: #force_inline proc "contextless" (dst: DREG, src: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .MOV, operand_count = 2, ops = {op_dreg(dst), op_gpr64(src), {}, {}} }, 32) } +emit_mov_r8_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8, src: GPR8) { append(instructions, inst_mov_r8_r8(dst, src)) } +emit_mov_m8_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8, src: GPR8) { append(instructions, inst_mov_m8_r8(dst, src)) } +emit_mov_r16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: GPR16) { append(instructions, inst_mov_r16_r16(dst, src)) } +emit_mov_m16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16, src: GPR16) { append(instructions, inst_mov_m16_r16(dst, src)) } +emit_mov_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { append(instructions, inst_mov_r32_r32(dst, src)) } +emit_mov_m32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, src: GPR32) { append(instructions, inst_mov_m32_r32(dst, src)) } +emit_mov_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { append(instructions, inst_mov_r64_r64(dst, src)) } +emit_mov_m64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, src: GPR64) { append(instructions, inst_mov_m64_r64(dst, src)) } +emit_mov_r8_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8, src: Mem8) { append(instructions, inst_mov_r8_m8(dst, src)) } +emit_mov_r16_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: Mem16) { append(instructions, inst_mov_r16_m16(dst, src)) } +emit_mov_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32) { append(instructions, inst_mov_r32_m32(dst, src)) } +emit_mov_r64_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem64) { append(instructions, inst_mov_r64_m64(dst, src)) } +emit_mov_r8_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8, imm: i8) { append(instructions, inst_mov_r8_imm8(dst, imm)) } +emit_mov_r16_imm16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, imm: i16) { append(instructions, inst_mov_r16_imm16(dst, imm)) } +emit_mov_r32_imm32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, imm: i32) { append(instructions, inst_mov_r32_imm32(dst, imm)) } +emit_mov_r64_imm64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, imm: i64) { append(instructions, inst_mov_r64_imm64(dst, imm)) } +emit_mov_m8_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8, imm: i8) { append(instructions, inst_mov_m8_imm8(dst, imm)) } +emit_mov_m16_imm16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16, imm: i16) { append(instructions, inst_mov_m16_imm16(dst, imm)) } +emit_mov_m32_imm32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, imm: i32) { append(instructions, inst_mov_m32_imm32(dst, imm)) } +emit_mov_r64_imm32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, imm: i32) { append(instructions, inst_mov_r64_imm32(dst, imm)) } +emit_mov_m64_imm32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, imm: i32) { append(instructions, inst_mov_m64_imm32(dst, imm)) } +emit_mov_r16_sreg :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: SREG) { append(instructions, inst_mov_r16_sreg(dst, src)) } +emit_mov_m16_sreg :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16, src: SREG) { append(instructions, inst_mov_m16_sreg(dst, src)) } +emit_mov_r64_sreg :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: SREG) { append(instructions, inst_mov_r64_sreg(dst, src)) } +emit_mov_m64_sreg :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, src: SREG) { append(instructions, inst_mov_m64_sreg(dst, src)) } +emit_mov_sreg_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: SREG, src: GPR16) { append(instructions, inst_mov_sreg_r16(dst, src)) } +emit_mov_sreg_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: SREG, src: Mem16) { append(instructions, inst_mov_sreg_m16(dst, src)) } +emit_mov_sreg_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: SREG, src: GPR64) { append(instructions, inst_mov_sreg_r64(dst, src)) } +emit_mov_sreg_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: SREG, src: Mem64) { append(instructions, inst_mov_sreg_m64(dst, src)) } +emit_mov_r64_cr :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: CREG) { append(instructions, inst_mov_r64_cr(dst, src)) } +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), {}, {}} } } +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) } +inst_movzx_r32_r8 :: #force_inline proc "contextless" (dst: GPR32, src: GPR8) -> Instruction { return with_hint(Instruction{ mnemonic = .MOVZX, operand_count = 2, ops = {op_gpr32(dst), op_gpr8(src), {}, {}} }, 43) } +inst_movzx_r32_m8 :: #force_inline proc "contextless" (dst: GPR32, src: Mem8) -> Instruction { return with_hint(Instruction{ mnemonic = .MOVZX, operand_count = 2, ops = {op_gpr32(dst), op_mem(src.mem, 1), {}, {}} }, 43) } +inst_movzx_r64_r8 :: #force_inline proc "contextless" (dst: GPR64, src: GPR8) -> Instruction { return with_hint(Instruction{ mnemonic = .MOVZX, operand_count = 2, ops = {op_gpr64(dst), op_gpr8(src), {}, {}} }, 44) } +inst_movzx_r64_m8 :: #force_inline proc "contextless" (dst: GPR64, src: Mem8) -> Instruction { return with_hint(Instruction{ mnemonic = .MOVZX, operand_count = 2, ops = {op_gpr64(dst), op_mem(src.mem, 1), {}, {}} }, 44) } +inst_movzx_r32_r16 :: #force_inline proc "contextless" (dst: GPR32, src: GPR16) -> Instruction { return with_hint(Instruction{ mnemonic = .MOVZX, operand_count = 2, ops = {op_gpr32(dst), op_gpr16(src), {}, {}} }, 45) } +inst_movzx_r32_m16 :: #force_inline proc "contextless" (dst: GPR32, src: Mem16) -> Instruction { return with_hint(Instruction{ mnemonic = .MOVZX, operand_count = 2, ops = {op_gpr32(dst), op_mem(src.mem, 2), {}, {}} }, 45) } +inst_movzx_r64_r16 :: #force_inline proc "contextless" (dst: GPR64, src: GPR16) -> Instruction { return with_hint(Instruction{ mnemonic = .MOVZX, operand_count = 2, ops = {op_gpr64(dst), op_gpr16(src), {}, {}} }, 46) } +inst_movzx_r64_m16 :: #force_inline proc "contextless" (dst: GPR64, src: Mem16) -> Instruction { return with_hint(Instruction{ mnemonic = .MOVZX, operand_count = 2, ops = {op_gpr64(dst), op_mem(src.mem, 2), {}, {}} }, 46) } +emit_movzx_r16_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: GPR8) { append(instructions, inst_movzx_r16_r8(dst, src)) } +emit_movzx_r16_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: Mem8) { append(instructions, inst_movzx_r16_m8(dst, src)) } +emit_movzx_r32_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR8) { append(instructions, inst_movzx_r32_r8(dst, src)) } +emit_movzx_r32_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem8) { append(instructions, inst_movzx_r32_m8(dst, src)) } +emit_movzx_r64_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR8) { append(instructions, inst_movzx_r64_r8(dst, src)) } +emit_movzx_r64_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem8) { append(instructions, inst_movzx_r64_m8(dst, src)) } +emit_movzx_r32_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR16) { append(instructions, inst_movzx_r32_r16(dst, src)) } +emit_movzx_r32_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem16) { append(instructions, inst_movzx_r32_m16(dst, src)) } +emit_movzx_r64_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR16) { append(instructions, inst_movzx_r64_r16(dst, src)) } +emit_movzx_r64_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem16) { append(instructions, inst_movzx_r64_m16(dst, src)) } +inst_movsx_r16_r8 :: #force_inline proc "contextless" (dst: GPR16, src: GPR8) -> Instruction { return with_hint(Instruction{ mnemonic = .MOVSX, operand_count = 2, ops = {op_gpr16(dst), op_gpr8(src), {}, {}} }, 47) } +inst_movsx_r16_m8 :: #force_inline proc "contextless" (dst: GPR16, src: Mem8) -> Instruction { return with_hint(Instruction{ mnemonic = .MOVSX, operand_count = 2, ops = {op_gpr16(dst), op_mem(src.mem, 1), {}, {}} }, 47) } +inst_movsx_r32_r8 :: #force_inline proc "contextless" (dst: GPR32, src: GPR8) -> Instruction { return with_hint(Instruction{ mnemonic = .MOVSX, operand_count = 2, ops = {op_gpr32(dst), op_gpr8(src), {}, {}} }, 48) } +inst_movsx_r32_m8 :: #force_inline proc "contextless" (dst: GPR32, src: Mem8) -> Instruction { return with_hint(Instruction{ mnemonic = .MOVSX, operand_count = 2, ops = {op_gpr32(dst), op_mem(src.mem, 1), {}, {}} }, 48) } +inst_movsx_r64_r8 :: #force_inline proc "contextless" (dst: GPR64, src: GPR8) -> Instruction { return with_hint(Instruction{ mnemonic = .MOVSX, operand_count = 2, ops = {op_gpr64(dst), op_gpr8(src), {}, {}} }, 49) } +inst_movsx_r64_m8 :: #force_inline proc "contextless" (dst: GPR64, src: Mem8) -> Instruction { return with_hint(Instruction{ mnemonic = .MOVSX, operand_count = 2, ops = {op_gpr64(dst), op_mem(src.mem, 1), {}, {}} }, 49) } +inst_movsx_r32_r16 :: #force_inline proc "contextless" (dst: GPR32, src: GPR16) -> Instruction { return with_hint(Instruction{ mnemonic = .MOVSX, operand_count = 2, ops = {op_gpr32(dst), op_gpr16(src), {}, {}} }, 50) } +inst_movsx_r32_m16 :: #force_inline proc "contextless" (dst: GPR32, src: Mem16) -> Instruction { return with_hint(Instruction{ mnemonic = .MOVSX, operand_count = 2, ops = {op_gpr32(dst), op_mem(src.mem, 2), {}, {}} }, 50) } +inst_movsx_r64_r16 :: #force_inline proc "contextless" (dst: GPR64, src: GPR16) -> Instruction { return with_hint(Instruction{ mnemonic = .MOVSX, operand_count = 2, ops = {op_gpr64(dst), op_gpr16(src), {}, {}} }, 51) } +inst_movsx_r64_m16 :: #force_inline proc "contextless" (dst: GPR64, src: Mem16) -> Instruction { return with_hint(Instruction{ mnemonic = .MOVSX, operand_count = 2, ops = {op_gpr64(dst), op_mem(src.mem, 2), {}, {}} }, 51) } +emit_movsx_r16_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: GPR8) { append(instructions, inst_movsx_r16_r8(dst, src)) } +emit_movsx_r16_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: Mem8) { append(instructions, inst_movsx_r16_m8(dst, src)) } +emit_movsx_r32_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR8) { append(instructions, inst_movsx_r32_r8(dst, src)) } +emit_movsx_r32_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem8) { append(instructions, inst_movsx_r32_m8(dst, src)) } +emit_movsx_r64_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR8) { append(instructions, inst_movsx_r64_r8(dst, src)) } +emit_movsx_r64_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem8) { append(instructions, inst_movsx_r64_m8(dst, src)) } +emit_movsx_r32_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR16) { append(instructions, inst_movsx_r32_r16(dst, src)) } +emit_movsx_r32_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem16) { append(instructions, inst_movsx_r32_m16(dst, src)) } +emit_movsx_r64_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR16) { append(instructions, inst_movsx_r64_r16(dst, src)) } +emit_movsx_r64_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem16) { append(instructions, inst_movsx_r64_m16(dst, src)) } +inst_movsxd_r64_r32 :: #force_inline proc "contextless" (dst: GPR64, src: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .MOVSXD, operand_count = 2, ops = {op_gpr64(dst), op_gpr32(src), {}, {}} }, 52) } +inst_movsxd_r64_m32 :: #force_inline proc "contextless" (dst: GPR64, src: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .MOVSXD, operand_count = 2, ops = {op_gpr64(dst), op_mem(src.mem, 4), {}, {}} }, 52) } +emit_movsxd_r64_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR32) { append(instructions, inst_movsxd_r64_r32(dst, src)) } +emit_movsxd_r64_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem32) { append(instructions, inst_movsxd_r64_m32(dst, src)) } +inst_xchg_r16 :: #force_inline proc "contextless" (dst: GPR16) -> Instruction { return with_hint(Instruction{ mnemonic = .XCHG, operand_count = 1, ops = {op_gpr16(dst), {}, {}, {}} }, 53) } +inst_xchg_r32 :: #force_inline proc "contextless" (dst: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .XCHG, operand_count = 1, ops = {op_gpr32(dst), {}, {}, {}} }, 54) } +inst_xchg_r64 :: #force_inline proc "contextless" (dst: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .XCHG, operand_count = 1, ops = {op_gpr64(dst), {}, {}, {}} }, 55) } +inst_xchg_r8_r8 :: #force_inline proc "contextless" (dst: GPR8, src: GPR8) -> Instruction { return with_hint(Instruction{ mnemonic = .XCHG, operand_count = 2, ops = {op_gpr8(dst), op_gpr8(src), {}, {}} }, 56) } +inst_xchg_m8_r8 :: #force_inline proc "contextless" (dst: Mem8, src: GPR8) -> Instruction { return with_hint(Instruction{ mnemonic = .XCHG, operand_count = 2, ops = {op_mem(dst.mem, 1), op_gpr8(src), {}, {}} }, 56) } +inst_xchg_r16_r16 :: #force_inline proc "contextless" (dst: GPR16, src: GPR16) -> Instruction { return with_hint(Instruction{ mnemonic = .XCHG, operand_count = 2, ops = {op_gpr16(dst), op_gpr16(src), {}, {}} }, 57) } +inst_xchg_m16_r16 :: #force_inline proc "contextless" (dst: Mem16, src: GPR16) -> Instruction { return with_hint(Instruction{ mnemonic = .XCHG, operand_count = 2, ops = {op_mem(dst.mem, 2), op_gpr16(src), {}, {}} }, 57) } +inst_xchg_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .XCHG, operand_count = 2, ops = {op_gpr32(dst), op_gpr32(src), {}, {}} }, 58) } +inst_xchg_m32_r32 :: #force_inline proc "contextless" (dst: Mem32, src: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .XCHG, operand_count = 2, ops = {op_mem(dst.mem, 4), op_gpr32(src), {}, {}} }, 58) } +inst_xchg_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .XCHG, operand_count = 2, ops = {op_gpr64(dst), op_gpr64(src), {}, {}} }, 59) } +inst_xchg_m64_r64 :: #force_inline proc "contextless" (dst: Mem64, src: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .XCHG, operand_count = 2, ops = {op_mem(dst.mem, 8), op_gpr64(src), {}, {}} }, 59) } +emit_xchg_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16) { append(instructions, inst_xchg_r16(dst)) } +emit_xchg_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32) { append(instructions, inst_xchg_r32(dst)) } +emit_xchg_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64) { append(instructions, inst_xchg_r64(dst)) } +emit_xchg_r8_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8, src: GPR8) { append(instructions, inst_xchg_r8_r8(dst, src)) } +emit_xchg_m8_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8, src: GPR8) { append(instructions, inst_xchg_m8_r8(dst, src)) } +emit_xchg_r16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: GPR16) { append(instructions, inst_xchg_r16_r16(dst, src)) } +emit_xchg_m16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16, src: GPR16) { append(instructions, inst_xchg_m16_r16(dst, src)) } +emit_xchg_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { append(instructions, inst_xchg_r32_r32(dst, src)) } +emit_xchg_m32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, src: GPR32) { append(instructions, inst_xchg_m32_r32(dst, src)) } +emit_xchg_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { append(instructions, inst_xchg_r64_r64(dst, src)) } +emit_xchg_m64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, src: GPR64) { append(instructions, inst_xchg_m64_r64(dst, src)) } +inst_push_r16 :: #force_inline proc "contextless" (dst: GPR16) -> Instruction { return with_hint(Instruction{ mnemonic = .PUSH, operand_count = 1, ops = {op_gpr16(dst), {}, {}, {}} }, 60) } +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_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)) } +emit_push_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16) { append(instructions, inst_push_m16(dst)) } +emit_push_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64) { append(instructions, inst_push_m64(dst)) } +emit_push_imm16 :: #force_inline proc(instructions: ^[dynamic]Instruction, imm: i16) { append(instructions, inst_push_imm16(imm)) } +emit_push_imm32 :: #force_inline proc(instructions: ^[dynamic]Instruction, imm: i32) { append(instructions, inst_push_imm32(imm)) } +emit_push_sreg :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: SREG) { append(instructions, inst_push_sreg(dst)) } +inst_pop_r16 :: #force_inline proc "contextless" (dst: GPR16) -> Instruction { return with_hint(Instruction{ mnemonic = .POP, operand_count = 1, ops = {op_gpr16(dst), {}, {}, {}} }, 69) } +inst_pop_r64 :: #force_inline proc "contextless" (dst: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .POP, operand_count = 1, ops = {op_gpr64(dst), {}, {}, {}} }, 70) } +inst_pop_m16 :: #force_inline proc "contextless" (dst: Mem16) -> Instruction { return with_hint(Instruction{ mnemonic = .POP, operand_count = 1, ops = {op_mem(dst.mem, 2), {}, {}, {}} }, 71) } +inst_pop_m64 :: #force_inline proc "contextless" (dst: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .POP, operand_count = 1, ops = {op_mem(dst.mem, 8), {}, {}, {}} }, 72) } +inst_pop_sreg :: #force_inline proc "contextless" (dst: SREG) -> Instruction { return with_hint(Instruction{ mnemonic = .POP, operand_count = 1, ops = {op_sreg(dst), {}, {}, {}} }, 73) } +emit_pop_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16) { append(instructions, inst_pop_r16(dst)) } +emit_pop_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64) { append(instructions, inst_pop_r64(dst)) } +emit_pop_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16) { append(instructions, inst_pop_m16(dst)) } +emit_pop_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64) { append(instructions, inst_pop_m64(dst)) } +emit_pop_sreg :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: SREG) { append(instructions, inst_pop_sreg(dst)) } +inst_lea_r16_m :: #force_inline proc "contextless" (dst: GPR16, src: Memory) -> Instruction { return with_hint(Instruction{ mnemonic = .LEA, operand_count = 2, ops = {op_gpr16(dst), op_mem(src, 0), {}, {}} }, 75) } +inst_lea_r32_m :: #force_inline proc "contextless" (dst: GPR32, src: Memory) -> Instruction { return with_hint(Instruction{ mnemonic = .LEA, operand_count = 2, ops = {op_gpr32(dst), op_mem(src, 0), {}, {}} }, 76) } +inst_lea_r64_m :: #force_inline proc "contextless" (dst: GPR64, src: Memory) -> Instruction { return with_hint(Instruction{ mnemonic = .LEA, operand_count = 2, ops = {op_gpr64(dst), op_mem(src, 0), {}, {}} }, 77) } +emit_lea_r16_m :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: Memory) { append(instructions, inst_lea_r16_m(dst, src)) } +emit_lea_r32_m :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Memory) { append(instructions, inst_lea_r32_m(dst, src)) } +emit_lea_r64_m :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Memory) { append(instructions, inst_lea_r64_m(dst, src)) } +inst_add_r8_r8 :: #force_inline proc "contextless" (dst: GPR8, src: GPR8) -> Instruction { return with_hint(Instruction{ mnemonic = .ADD, operand_count = 2, ops = {op_gpr8(dst), op_gpr8(src), {}, {}} }, 78) } +inst_add_m8_r8 :: #force_inline proc "contextless" (dst: Mem8, src: GPR8) -> Instruction { return with_hint(Instruction{ mnemonic = .ADD, operand_count = 2, ops = {op_mem(dst.mem, 1), op_gpr8(src), {}, {}} }, 78) } +inst_add_r16_r16 :: #force_inline proc "contextless" (dst: GPR16, src: GPR16) -> Instruction { return with_hint(Instruction{ mnemonic = .ADD, operand_count = 2, ops = {op_gpr16(dst), op_gpr16(src), {}, {}} }, 79) } +inst_add_m16_r16 :: #force_inline proc "contextless" (dst: Mem16, src: GPR16) -> Instruction { return with_hint(Instruction{ mnemonic = .ADD, operand_count = 2, ops = {op_mem(dst.mem, 2), op_gpr16(src), {}, {}} }, 79) } +inst_add_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .ADD, operand_count = 2, ops = {op_gpr32(dst), op_gpr32(src), {}, {}} }, 80) } +inst_add_m32_r32 :: #force_inline proc "contextless" (dst: Mem32, src: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .ADD, operand_count = 2, ops = {op_mem(dst.mem, 4), op_gpr32(src), {}, {}} }, 80) } +inst_add_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .ADD, operand_count = 2, ops = {op_gpr64(dst), op_gpr64(src), {}, {}} }, 81) } +inst_add_m64_r64 :: #force_inline proc "contextless" (dst: Mem64, src: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .ADD, operand_count = 2, ops = {op_mem(dst.mem, 8), op_gpr64(src), {}, {}} }, 81) } +inst_add_r8_m8 :: #force_inline proc "contextless" (dst: GPR8, src: Mem8) -> Instruction { return with_hint(Instruction{ mnemonic = .ADD, operand_count = 2, ops = {op_gpr8(dst), op_mem(src.mem, 1), {}, {}} }, 82) } +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), {}, {}} } } +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)) } +emit_add_m16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16, src: GPR16) { append(instructions, inst_add_m16_r16(dst, src)) } +emit_add_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { append(instructions, inst_add_r32_r32(dst, src)) } +emit_add_m32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, src: GPR32) { append(instructions, inst_add_m32_r32(dst, src)) } +emit_add_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { append(instructions, inst_add_r64_r64(dst, src)) } +emit_add_m64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, src: GPR64) { append(instructions, inst_add_m64_r64(dst, src)) } +emit_add_r8_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8, src: Mem8) { append(instructions, inst_add_r8_m8(dst, src)) } +emit_add_r16_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: Mem16) { append(instructions, inst_add_r16_m16(dst, src)) } +emit_add_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32) { append(instructions, inst_add_r32_m32(dst, src)) } +emit_add_r64_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem64) { append(instructions, inst_add_r64_m64(dst, src)) } +emit_add_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, imm: i8) { append(instructions, inst_add_imm8(imm)) } +emit_add_imm16 :: #force_inline proc(instructions: ^[dynamic]Instruction, imm: i16) { append(instructions, inst_add_imm16(imm)) } +emit_add_imm32 :: #force_inline proc(instructions: ^[dynamic]Instruction, imm: i32) { append(instructions, inst_add_imm32(imm)) } +emit_add_r8_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8, imm: i8) { append(instructions, inst_add_r8_imm8(dst, imm)) } +emit_add_m8_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8, imm: i8) { append(instructions, inst_add_m8_imm8(dst, imm)) } +emit_add_r16_imm16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, imm: i16) { append(instructions, inst_add_r16_imm16(dst, imm)) } +emit_add_m16_imm16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16, imm: i16) { append(instructions, inst_add_m16_imm16(dst, imm)) } +emit_add_r32_imm32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, imm: i32) { append(instructions, inst_add_r32_imm32(dst, imm)) } +emit_add_m32_imm32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, imm: i32) { append(instructions, inst_add_m32_imm32(dst, imm)) } +emit_add_r64_imm32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, imm: i32) { append(instructions, inst_add_r64_imm32(dst, imm)) } +emit_add_m64_imm32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, imm: i32) { append(instructions, inst_add_m64_imm32(dst, imm)) } +inst_adc_r8_r8 :: #force_inline proc "contextless" (dst: GPR8, src: GPR8) -> Instruction { return with_hint(Instruction{ mnemonic = .ADC, operand_count = 2, ops = {op_gpr8(dst), op_gpr8(src), {}, {}} }, 97) } +inst_adc_m8_r8 :: #force_inline proc "contextless" (dst: Mem8, src: GPR8) -> Instruction { return with_hint(Instruction{ mnemonic = .ADC, operand_count = 2, ops = {op_mem(dst.mem, 1), op_gpr8(src), {}, {}} }, 97) } +inst_adc_r16_r16 :: #force_inline proc "contextless" (dst: GPR16, src: GPR16) -> Instruction { return with_hint(Instruction{ mnemonic = .ADC, operand_count = 2, ops = {op_gpr16(dst), op_gpr16(src), {}, {}} }, 98) } +inst_adc_m16_r16 :: #force_inline proc "contextless" (dst: Mem16, src: GPR16) -> Instruction { return with_hint(Instruction{ mnemonic = .ADC, operand_count = 2, ops = {op_mem(dst.mem, 2), op_gpr16(src), {}, {}} }, 98) } +inst_adc_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .ADC, operand_count = 2, ops = {op_gpr32(dst), op_gpr32(src), {}, {}} }, 99) } +inst_adc_m32_r32 :: #force_inline proc "contextless" (dst: Mem32, src: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .ADC, operand_count = 2, ops = {op_mem(dst.mem, 4), op_gpr32(src), {}, {}} }, 99) } +inst_adc_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .ADC, operand_count = 2, ops = {op_gpr64(dst), op_gpr64(src), {}, {}} }, 100) } +inst_adc_m64_r64 :: #force_inline proc "contextless" (dst: Mem64, src: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .ADC, operand_count = 2, ops = {op_mem(dst.mem, 8), op_gpr64(src), {}, {}} }, 100) } +inst_adc_r8_m8 :: #force_inline proc "contextless" (dst: GPR8, src: Mem8) -> Instruction { return with_hint(Instruction{ mnemonic = .ADC, operand_count = 2, ops = {op_gpr8(dst), op_mem(src.mem, 1), {}, {}} }, 101) } +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), {}, {}} } } +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)) } +emit_adc_m16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16, src: GPR16) { append(instructions, inst_adc_m16_r16(dst, src)) } +emit_adc_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { append(instructions, inst_adc_r32_r32(dst, src)) } +emit_adc_m32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, src: GPR32) { append(instructions, inst_adc_m32_r32(dst, src)) } +emit_adc_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { append(instructions, inst_adc_r64_r64(dst, src)) } +emit_adc_m64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, src: GPR64) { append(instructions, inst_adc_m64_r64(dst, src)) } +emit_adc_r8_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8, src: Mem8) { append(instructions, inst_adc_r8_m8(dst, src)) } +emit_adc_r16_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: Mem16) { append(instructions, inst_adc_r16_m16(dst, src)) } +emit_adc_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32) { append(instructions, inst_adc_r32_m32(dst, src)) } +emit_adc_r64_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem64) { append(instructions, inst_adc_r64_m64(dst, src)) } +emit_adc_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, imm: i8) { append(instructions, inst_adc_imm8(imm)) } +emit_adc_imm16 :: #force_inline proc(instructions: ^[dynamic]Instruction, imm: i16) { append(instructions, inst_adc_imm16(imm)) } +emit_adc_imm32 :: #force_inline proc(instructions: ^[dynamic]Instruction, imm: i32) { append(instructions, inst_adc_imm32(imm)) } +emit_adc_r8_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8, imm: i8) { append(instructions, inst_adc_r8_imm8(dst, imm)) } +emit_adc_m8_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8, imm: i8) { append(instructions, inst_adc_m8_imm8(dst, imm)) } +emit_adc_r16_imm16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, imm: i16) { append(instructions, inst_adc_r16_imm16(dst, imm)) } +emit_adc_m16_imm16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16, imm: i16) { append(instructions, inst_adc_m16_imm16(dst, imm)) } +emit_adc_r32_imm32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, imm: i32) { append(instructions, inst_adc_r32_imm32(dst, imm)) } +emit_adc_m32_imm32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, imm: i32) { append(instructions, inst_adc_m32_imm32(dst, imm)) } +emit_adc_r64_imm32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, imm: i32) { append(instructions, inst_adc_r64_imm32(dst, imm)) } +emit_adc_m64_imm32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, imm: i32) { append(instructions, inst_adc_m64_imm32(dst, imm)) } +inst_sub_r8_r8 :: #force_inline proc "contextless" (dst: GPR8, src: GPR8) -> Instruction { return with_hint(Instruction{ mnemonic = .SUB, operand_count = 2, ops = {op_gpr8(dst), op_gpr8(src), {}, {}} }, 116) } +inst_sub_m8_r8 :: #force_inline proc "contextless" (dst: Mem8, src: GPR8) -> Instruction { return with_hint(Instruction{ mnemonic = .SUB, operand_count = 2, ops = {op_mem(dst.mem, 1), op_gpr8(src), {}, {}} }, 116) } +inst_sub_r16_r16 :: #force_inline proc "contextless" (dst: GPR16, src: GPR16) -> Instruction { return with_hint(Instruction{ mnemonic = .SUB, operand_count = 2, ops = {op_gpr16(dst), op_gpr16(src), {}, {}} }, 117) } +inst_sub_m16_r16 :: #force_inline proc "contextless" (dst: Mem16, src: GPR16) -> Instruction { return with_hint(Instruction{ mnemonic = .SUB, operand_count = 2, ops = {op_mem(dst.mem, 2), op_gpr16(src), {}, {}} }, 117) } +inst_sub_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .SUB, operand_count = 2, ops = {op_gpr32(dst), op_gpr32(src), {}, {}} }, 118) } +inst_sub_m32_r32 :: #force_inline proc "contextless" (dst: Mem32, src: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .SUB, operand_count = 2, ops = {op_mem(dst.mem, 4), op_gpr32(src), {}, {}} }, 118) } +inst_sub_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .SUB, operand_count = 2, ops = {op_gpr64(dst), op_gpr64(src), {}, {}} }, 119) } +inst_sub_m64_r64 :: #force_inline proc "contextless" (dst: Mem64, src: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .SUB, operand_count = 2, ops = {op_mem(dst.mem, 8), op_gpr64(src), {}, {}} }, 119) } +inst_sub_r8_m8 :: #force_inline proc "contextless" (dst: GPR8, src: Mem8) -> Instruction { return with_hint(Instruction{ mnemonic = .SUB, operand_count = 2, ops = {op_gpr8(dst), op_mem(src.mem, 1), {}, {}} }, 120) } +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), {}, {}} } } +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)) } +emit_sub_m16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16, src: GPR16) { append(instructions, inst_sub_m16_r16(dst, src)) } +emit_sub_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { append(instructions, inst_sub_r32_r32(dst, src)) } +emit_sub_m32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, src: GPR32) { append(instructions, inst_sub_m32_r32(dst, src)) } +emit_sub_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { append(instructions, inst_sub_r64_r64(dst, src)) } +emit_sub_m64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, src: GPR64) { append(instructions, inst_sub_m64_r64(dst, src)) } +emit_sub_r8_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8, src: Mem8) { append(instructions, inst_sub_r8_m8(dst, src)) } +emit_sub_r16_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: Mem16) { append(instructions, inst_sub_r16_m16(dst, src)) } +emit_sub_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32) { append(instructions, inst_sub_r32_m32(dst, src)) } +emit_sub_r64_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem64) { append(instructions, inst_sub_r64_m64(dst, src)) } +emit_sub_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, imm: i8) { append(instructions, inst_sub_imm8(imm)) } +emit_sub_imm16 :: #force_inline proc(instructions: ^[dynamic]Instruction, imm: i16) { append(instructions, inst_sub_imm16(imm)) } +emit_sub_imm32 :: #force_inline proc(instructions: ^[dynamic]Instruction, imm: i32) { append(instructions, inst_sub_imm32(imm)) } +emit_sub_r8_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8, imm: i8) { append(instructions, inst_sub_r8_imm8(dst, imm)) } +emit_sub_m8_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8, imm: i8) { append(instructions, inst_sub_m8_imm8(dst, imm)) } +emit_sub_r16_imm16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, imm: i16) { append(instructions, inst_sub_r16_imm16(dst, imm)) } +emit_sub_m16_imm16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16, imm: i16) { append(instructions, inst_sub_m16_imm16(dst, imm)) } +emit_sub_r32_imm32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, imm: i32) { append(instructions, inst_sub_r32_imm32(dst, imm)) } +emit_sub_m32_imm32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, imm: i32) { append(instructions, inst_sub_m32_imm32(dst, imm)) } +emit_sub_r64_imm32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, imm: i32) { append(instructions, inst_sub_r64_imm32(dst, imm)) } +emit_sub_m64_imm32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, imm: i32) { append(instructions, inst_sub_m64_imm32(dst, imm)) } +inst_sbb_r8_r8 :: #force_inline proc "contextless" (dst: GPR8, src: GPR8) -> Instruction { return with_hint(Instruction{ mnemonic = .SBB, operand_count = 2, ops = {op_gpr8(dst), op_gpr8(src), {}, {}} }, 135) } +inst_sbb_m8_r8 :: #force_inline proc "contextless" (dst: Mem8, src: GPR8) -> Instruction { return with_hint(Instruction{ mnemonic = .SBB, operand_count = 2, ops = {op_mem(dst.mem, 1), op_gpr8(src), {}, {}} }, 135) } +inst_sbb_r16_r16 :: #force_inline proc "contextless" (dst: GPR16, src: GPR16) -> Instruction { return with_hint(Instruction{ mnemonic = .SBB, operand_count = 2, ops = {op_gpr16(dst), op_gpr16(src), {}, {}} }, 136) } +inst_sbb_m16_r16 :: #force_inline proc "contextless" (dst: Mem16, src: GPR16) -> Instruction { return with_hint(Instruction{ mnemonic = .SBB, operand_count = 2, ops = {op_mem(dst.mem, 2), op_gpr16(src), {}, {}} }, 136) } +inst_sbb_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .SBB, operand_count = 2, ops = {op_gpr32(dst), op_gpr32(src), {}, {}} }, 137) } +inst_sbb_m32_r32 :: #force_inline proc "contextless" (dst: Mem32, src: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .SBB, operand_count = 2, ops = {op_mem(dst.mem, 4), op_gpr32(src), {}, {}} }, 137) } +inst_sbb_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .SBB, operand_count = 2, ops = {op_gpr64(dst), op_gpr64(src), {}, {}} }, 138) } +inst_sbb_m64_r64 :: #force_inline proc "contextless" (dst: Mem64, src: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .SBB, operand_count = 2, ops = {op_mem(dst.mem, 8), op_gpr64(src), {}, {}} }, 138) } +inst_sbb_r8_m8 :: #force_inline proc "contextless" (dst: GPR8, src: Mem8) -> Instruction { return with_hint(Instruction{ mnemonic = .SBB, operand_count = 2, ops = {op_gpr8(dst), op_mem(src.mem, 1), {}, {}} }, 139) } +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), {}, {}} } } +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)) } +emit_sbb_m16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16, src: GPR16) { append(instructions, inst_sbb_m16_r16(dst, src)) } +emit_sbb_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { append(instructions, inst_sbb_r32_r32(dst, src)) } +emit_sbb_m32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, src: GPR32) { append(instructions, inst_sbb_m32_r32(dst, src)) } +emit_sbb_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { append(instructions, inst_sbb_r64_r64(dst, src)) } +emit_sbb_m64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, src: GPR64) { append(instructions, inst_sbb_m64_r64(dst, src)) } +emit_sbb_r8_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8, src: Mem8) { append(instructions, inst_sbb_r8_m8(dst, src)) } +emit_sbb_r16_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: Mem16) { append(instructions, inst_sbb_r16_m16(dst, src)) } +emit_sbb_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32) { append(instructions, inst_sbb_r32_m32(dst, src)) } +emit_sbb_r64_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem64) { append(instructions, inst_sbb_r64_m64(dst, src)) } +emit_sbb_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, imm: i8) { append(instructions, inst_sbb_imm8(imm)) } +emit_sbb_imm16 :: #force_inline proc(instructions: ^[dynamic]Instruction, imm: i16) { append(instructions, inst_sbb_imm16(imm)) } +emit_sbb_imm32 :: #force_inline proc(instructions: ^[dynamic]Instruction, imm: i32) { append(instructions, inst_sbb_imm32(imm)) } +emit_sbb_r8_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8, imm: i8) { append(instructions, inst_sbb_r8_imm8(dst, imm)) } +emit_sbb_m8_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8, imm: i8) { append(instructions, inst_sbb_m8_imm8(dst, imm)) } +emit_sbb_r16_imm16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, imm: i16) { append(instructions, inst_sbb_r16_imm16(dst, imm)) } +emit_sbb_m16_imm16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16, imm: i16) { append(instructions, inst_sbb_m16_imm16(dst, imm)) } +emit_sbb_r32_imm32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, imm: i32) { append(instructions, inst_sbb_r32_imm32(dst, imm)) } +emit_sbb_m32_imm32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, imm: i32) { append(instructions, inst_sbb_m32_imm32(dst, imm)) } +emit_sbb_r64_imm32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, imm: i32) { append(instructions, inst_sbb_r64_imm32(dst, imm)) } +emit_sbb_m64_imm32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, imm: i32) { append(instructions, inst_sbb_m64_imm32(dst, imm)) } +inst_mul_r8 :: #force_inline proc "contextless" (dst: GPR8) -> Instruction { return with_hint(Instruction{ mnemonic = .MUL, operand_count = 1, ops = {op_gpr8(dst), {}, {}, {}} }, 154) } +inst_mul_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return with_hint(Instruction{ mnemonic = .MUL, operand_count = 1, ops = {op_mem(dst.mem, 1), {}, {}, {}} }, 154) } +inst_mul_r16 :: #force_inline proc "contextless" (dst: GPR16) -> Instruction { return with_hint(Instruction{ mnemonic = .MUL, operand_count = 1, ops = {op_gpr16(dst), {}, {}, {}} }, 155) } +inst_mul_m16 :: #force_inline proc "contextless" (dst: Mem16) -> Instruction { return with_hint(Instruction{ mnemonic = .MUL, operand_count = 1, ops = {op_mem(dst.mem, 2), {}, {}, {}} }, 155) } +inst_mul_r32 :: #force_inline proc "contextless" (dst: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .MUL, operand_count = 1, ops = {op_gpr32(dst), {}, {}, {}} }, 156) } +inst_mul_m32 :: #force_inline proc "contextless" (dst: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .MUL, operand_count = 1, ops = {op_mem(dst.mem, 4), {}, {}, {}} }, 156) } +inst_mul_r64 :: #force_inline proc "contextless" (dst: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .MUL, operand_count = 1, ops = {op_gpr64(dst), {}, {}, {}} }, 157) } +inst_mul_m64 :: #force_inline proc "contextless" (dst: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .MUL, operand_count = 1, ops = {op_mem(dst.mem, 8), {}, {}, {}} }, 157) } +emit_mul_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8) { append(instructions, inst_mul_r8(dst)) } +emit_mul_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { append(instructions, inst_mul_m8(dst)) } +emit_mul_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16) { append(instructions, inst_mul_r16(dst)) } +emit_mul_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16) { append(instructions, inst_mul_m16(dst)) } +emit_mul_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32) { append(instructions, inst_mul_r32(dst)) } +emit_mul_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32) { append(instructions, inst_mul_m32(dst)) } +emit_mul_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64) { append(instructions, inst_mul_r64(dst)) } +emit_mul_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64) { append(instructions, inst_mul_m64(dst)) } +inst_imul_r8 :: #force_inline proc "contextless" (dst: GPR8) -> Instruction { return with_hint(Instruction{ mnemonic = .IMUL, operand_count = 1, ops = {op_gpr8(dst), {}, {}, {}} }, 158) } +inst_imul_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return with_hint(Instruction{ mnemonic = .IMUL, operand_count = 1, ops = {op_mem(dst.mem, 1), {}, {}, {}} }, 158) } +inst_imul_r16 :: #force_inline proc "contextless" (dst: GPR16) -> Instruction { return with_hint(Instruction{ mnemonic = .IMUL, operand_count = 1, ops = {op_gpr16(dst), {}, {}, {}} }, 159) } +inst_imul_m16 :: #force_inline proc "contextless" (dst: Mem16) -> Instruction { return with_hint(Instruction{ mnemonic = .IMUL, operand_count = 1, ops = {op_mem(dst.mem, 2), {}, {}, {}} }, 159) } +inst_imul_r32 :: #force_inline proc "contextless" (dst: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .IMUL, operand_count = 1, ops = {op_gpr32(dst), {}, {}, {}} }, 160) } +inst_imul_m32 :: #force_inline proc "contextless" (dst: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .IMUL, operand_count = 1, ops = {op_mem(dst.mem, 4), {}, {}, {}} }, 160) } +inst_imul_r64 :: #force_inline proc "contextless" (dst: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .IMUL, operand_count = 1, ops = {op_gpr64(dst), {}, {}, {}} }, 161) } +inst_imul_m64 :: #force_inline proc "contextless" (dst: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .IMUL, operand_count = 1, ops = {op_mem(dst.mem, 8), {}, {}, {}} }, 161) } +inst_imul_r16_r16 :: #force_inline proc "contextless" (dst: GPR16, src: GPR16) -> Instruction { return with_hint(Instruction{ mnemonic = .IMUL, operand_count = 2, ops = {op_gpr16(dst), op_gpr16(src), {}, {}} }, 162) } +inst_imul_r16_m16 :: #force_inline proc "contextless" (dst: GPR16, src: Mem16) -> Instruction { return with_hint(Instruction{ mnemonic = .IMUL, operand_count = 2, ops = {op_gpr16(dst), op_mem(src.mem, 2), {}, {}} }, 162) } +inst_imul_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .IMUL, operand_count = 2, ops = {op_gpr32(dst), op_gpr32(src), {}, {}} }, 163) } +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), {}} } } +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)) } +emit_imul_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16) { append(instructions, inst_imul_m16(dst)) } +emit_imul_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32) { append(instructions, inst_imul_r32(dst)) } +emit_imul_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32) { append(instructions, inst_imul_m32(dst)) } +emit_imul_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64) { append(instructions, inst_imul_r64(dst)) } +emit_imul_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64) { append(instructions, inst_imul_m64(dst)) } +emit_imul_r16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: GPR16) { append(instructions, inst_imul_r16_r16(dst, src)) } +emit_imul_r16_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: Mem16) { append(instructions, inst_imul_r16_m16(dst, src)) } +emit_imul_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { append(instructions, inst_imul_r32_r32(dst, src)) } +emit_imul_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32) { append(instructions, inst_imul_r32_m32(dst, src)) } +emit_imul_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { append(instructions, inst_imul_r64_r64(dst, src)) } +emit_imul_r64_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem64) { append(instructions, inst_imul_r64_m64(dst, src)) } +emit_imul_r16_r16_imm16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: GPR16, imm: i16) { append(instructions, inst_imul_r16_r16_imm16(dst, src, imm)) } +emit_imul_r16_m16_imm16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: Mem16, imm: i16) { append(instructions, inst_imul_r16_m16_imm16(dst, src, imm)) } +emit_imul_r32_r32_imm32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32, imm: i32) { append(instructions, inst_imul_r32_r32_imm32(dst, src, imm)) } +emit_imul_r32_m32_imm32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32, imm: i32) { append(instructions, inst_imul_r32_m32_imm32(dst, src, imm)) } +emit_imul_r64_r64_imm32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64, imm: i32) { append(instructions, inst_imul_r64_r64_imm32(dst, src, imm)) } +emit_imul_r64_m64_imm32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem64, imm: i32) { append(instructions, inst_imul_r64_m64_imm32(dst, src, imm)) } +inst_div_r8 :: #force_inline proc "contextless" (dst: GPR8) -> Instruction { return with_hint(Instruction{ mnemonic = .DIV, operand_count = 1, ops = {op_gpr8(dst), {}, {}, {}} }, 171) } +inst_div_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return with_hint(Instruction{ mnemonic = .DIV, operand_count = 1, ops = {op_mem(dst.mem, 1), {}, {}, {}} }, 171) } +inst_div_r16 :: #force_inline proc "contextless" (dst: GPR16) -> Instruction { return with_hint(Instruction{ mnemonic = .DIV, operand_count = 1, ops = {op_gpr16(dst), {}, {}, {}} }, 172) } +inst_div_m16 :: #force_inline proc "contextless" (dst: Mem16) -> Instruction { return with_hint(Instruction{ mnemonic = .DIV, operand_count = 1, ops = {op_mem(dst.mem, 2), {}, {}, {}} }, 172) } +inst_div_r32 :: #force_inline proc "contextless" (dst: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .DIV, operand_count = 1, ops = {op_gpr32(dst), {}, {}, {}} }, 173) } +inst_div_m32 :: #force_inline proc "contextless" (dst: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .DIV, operand_count = 1, ops = {op_mem(dst.mem, 4), {}, {}, {}} }, 173) } +inst_div_r64 :: #force_inline proc "contextless" (dst: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .DIV, operand_count = 1, ops = {op_gpr64(dst), {}, {}, {}} }, 174) } +inst_div_m64 :: #force_inline proc "contextless" (dst: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .DIV, operand_count = 1, ops = {op_mem(dst.mem, 8), {}, {}, {}} }, 174) } +emit_div_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8) { append(instructions, inst_div_r8(dst)) } +emit_div_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { append(instructions, inst_div_m8(dst)) } +emit_div_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16) { append(instructions, inst_div_r16(dst)) } +emit_div_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16) { append(instructions, inst_div_m16(dst)) } +emit_div_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32) { append(instructions, inst_div_r32(dst)) } +emit_div_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32) { append(instructions, inst_div_m32(dst)) } +emit_div_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64) { append(instructions, inst_div_r64(dst)) } +emit_div_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64) { append(instructions, inst_div_m64(dst)) } +inst_idiv_r8 :: #force_inline proc "contextless" (dst: GPR8) -> Instruction { return with_hint(Instruction{ mnemonic = .IDIV, operand_count = 1, ops = {op_gpr8(dst), {}, {}, {}} }, 175) } +inst_idiv_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return with_hint(Instruction{ mnemonic = .IDIV, operand_count = 1, ops = {op_mem(dst.mem, 1), {}, {}, {}} }, 175) } +inst_idiv_r16 :: #force_inline proc "contextless" (dst: GPR16) -> Instruction { return with_hint(Instruction{ mnemonic = .IDIV, operand_count = 1, ops = {op_gpr16(dst), {}, {}, {}} }, 176) } +inst_idiv_m16 :: #force_inline proc "contextless" (dst: Mem16) -> Instruction { return with_hint(Instruction{ mnemonic = .IDIV, operand_count = 1, ops = {op_mem(dst.mem, 2), {}, {}, {}} }, 176) } +inst_idiv_r32 :: #force_inline proc "contextless" (dst: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .IDIV, operand_count = 1, ops = {op_gpr32(dst), {}, {}, {}} }, 177) } +inst_idiv_m32 :: #force_inline proc "contextless" (dst: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .IDIV, operand_count = 1, ops = {op_mem(dst.mem, 4), {}, {}, {}} }, 177) } +inst_idiv_r64 :: #force_inline proc "contextless" (dst: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .IDIV, operand_count = 1, ops = {op_gpr64(dst), {}, {}, {}} }, 178) } +inst_idiv_m64 :: #force_inline proc "contextless" (dst: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .IDIV, operand_count = 1, ops = {op_mem(dst.mem, 8), {}, {}, {}} }, 178) } +emit_idiv_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8) { append(instructions, inst_idiv_r8(dst)) } +emit_idiv_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { append(instructions, inst_idiv_m8(dst)) } +emit_idiv_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16) { append(instructions, inst_idiv_r16(dst)) } +emit_idiv_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16) { append(instructions, inst_idiv_m16(dst)) } +emit_idiv_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32) { append(instructions, inst_idiv_r32(dst)) } +emit_idiv_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32) { append(instructions, inst_idiv_m32(dst)) } +emit_idiv_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64) { append(instructions, inst_idiv_r64(dst)) } +emit_idiv_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64) { append(instructions, inst_idiv_m64(dst)) } +inst_inc_r16 :: #force_inline proc "contextless" (dst: GPR16) -> Instruction { return with_hint(Instruction{ mnemonic = .INC, operand_count = 1, ops = {op_gpr16(dst), {}, {}, {}} }, 179) } +inst_inc_r32 :: #force_inline proc "contextless" (dst: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .INC, operand_count = 1, ops = {op_gpr32(dst), {}, {}, {}} }, 180) } +inst_inc_r8 :: #force_inline proc "contextless" (dst: GPR8) -> Instruction { return with_hint(Instruction{ mnemonic = .INC, operand_count = 1, ops = {op_gpr8(dst), {}, {}, {}} }, 181) } +inst_inc_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return with_hint(Instruction{ mnemonic = .INC, operand_count = 1, ops = {op_mem(dst.mem, 1), {}, {}, {}} }, 181) } +inst_inc_m16 :: #force_inline proc "contextless" (dst: Mem16) -> Instruction { return with_hint(Instruction{ mnemonic = .INC, operand_count = 1, ops = {op_mem(dst.mem, 2), {}, {}, {}} }, 182) } +inst_inc_m32 :: #force_inline proc "contextless" (dst: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .INC, operand_count = 1, ops = {op_mem(dst.mem, 4), {}, {}, {}} }, 183) } +inst_inc_r64 :: #force_inline proc "contextless" (dst: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .INC, operand_count = 1, ops = {op_gpr64(dst), {}, {}, {}} }, 184) } +inst_inc_m64 :: #force_inline proc "contextless" (dst: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .INC, operand_count = 1, ops = {op_mem(dst.mem, 8), {}, {}, {}} }, 184) } +emit_inc_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16) { append(instructions, inst_inc_r16(dst)) } +emit_inc_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32) { append(instructions, inst_inc_r32(dst)) } +emit_inc_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8) { append(instructions, inst_inc_r8(dst)) } +emit_inc_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { append(instructions, inst_inc_m8(dst)) } +emit_inc_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16) { append(instructions, inst_inc_m16(dst)) } +emit_inc_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32) { append(instructions, inst_inc_m32(dst)) } +emit_inc_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64) { append(instructions, inst_inc_r64(dst)) } +emit_inc_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64) { append(instructions, inst_inc_m64(dst)) } +inst_dec_r16 :: #force_inline proc "contextless" (dst: GPR16) -> Instruction { return with_hint(Instruction{ mnemonic = .DEC, operand_count = 1, ops = {op_gpr16(dst), {}, {}, {}} }, 185) } +inst_dec_r32 :: #force_inline proc "contextless" (dst: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .DEC, operand_count = 1, ops = {op_gpr32(dst), {}, {}, {}} }, 186) } +inst_dec_r8 :: #force_inline proc "contextless" (dst: GPR8) -> Instruction { return with_hint(Instruction{ mnemonic = .DEC, operand_count = 1, ops = {op_gpr8(dst), {}, {}, {}} }, 187) } +inst_dec_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return with_hint(Instruction{ mnemonic = .DEC, operand_count = 1, ops = {op_mem(dst.mem, 1), {}, {}, {}} }, 187) } +inst_dec_m16 :: #force_inline proc "contextless" (dst: Mem16) -> Instruction { return with_hint(Instruction{ mnemonic = .DEC, operand_count = 1, ops = {op_mem(dst.mem, 2), {}, {}, {}} }, 188) } +inst_dec_m32 :: #force_inline proc "contextless" (dst: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .DEC, operand_count = 1, ops = {op_mem(dst.mem, 4), {}, {}, {}} }, 189) } +inst_dec_r64 :: #force_inline proc "contextless" (dst: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .DEC, operand_count = 1, ops = {op_gpr64(dst), {}, {}, {}} }, 190) } +inst_dec_m64 :: #force_inline proc "contextless" (dst: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .DEC, operand_count = 1, ops = {op_mem(dst.mem, 8), {}, {}, {}} }, 190) } +emit_dec_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16) { append(instructions, inst_dec_r16(dst)) } +emit_dec_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32) { append(instructions, inst_dec_r32(dst)) } +emit_dec_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8) { append(instructions, inst_dec_r8(dst)) } +emit_dec_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { append(instructions, inst_dec_m8(dst)) } +emit_dec_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16) { append(instructions, inst_dec_m16(dst)) } +emit_dec_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32) { append(instructions, inst_dec_m32(dst)) } +emit_dec_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64) { append(instructions, inst_dec_r64(dst)) } +emit_dec_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64) { append(instructions, inst_dec_m64(dst)) } +inst_neg_r8 :: #force_inline proc "contextless" (dst: GPR8) -> Instruction { return with_hint(Instruction{ mnemonic = .NEG, operand_count = 1, ops = {op_gpr8(dst), {}, {}, {}} }, 191) } +inst_neg_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return with_hint(Instruction{ mnemonic = .NEG, operand_count = 1, ops = {op_mem(dst.mem, 1), {}, {}, {}} }, 191) } +inst_neg_r16 :: #force_inline proc "contextless" (dst: GPR16) -> Instruction { return with_hint(Instruction{ mnemonic = .NEG, operand_count = 1, ops = {op_gpr16(dst), {}, {}, {}} }, 192) } +inst_neg_m16 :: #force_inline proc "contextless" (dst: Mem16) -> Instruction { return with_hint(Instruction{ mnemonic = .NEG, operand_count = 1, ops = {op_mem(dst.mem, 2), {}, {}, {}} }, 192) } +inst_neg_r32 :: #force_inline proc "contextless" (dst: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .NEG, operand_count = 1, ops = {op_gpr32(dst), {}, {}, {}} }, 193) } +inst_neg_m32 :: #force_inline proc "contextless" (dst: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .NEG, operand_count = 1, ops = {op_mem(dst.mem, 4), {}, {}, {}} }, 193) } +inst_neg_r64 :: #force_inline proc "contextless" (dst: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .NEG, operand_count = 1, ops = {op_gpr64(dst), {}, {}, {}} }, 194) } +inst_neg_m64 :: #force_inline proc "contextless" (dst: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .NEG, operand_count = 1, ops = {op_mem(dst.mem, 8), {}, {}, {}} }, 194) } +emit_neg_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8) { append(instructions, inst_neg_r8(dst)) } +emit_neg_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { append(instructions, inst_neg_m8(dst)) } +emit_neg_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16) { append(instructions, inst_neg_r16(dst)) } +emit_neg_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16) { append(instructions, inst_neg_m16(dst)) } +emit_neg_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32) { append(instructions, inst_neg_r32(dst)) } +emit_neg_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32) { append(instructions, inst_neg_m32(dst)) } +emit_neg_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64) { append(instructions, inst_neg_r64(dst)) } +emit_neg_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64) { append(instructions, inst_neg_m64(dst)) } +inst_cmp_r8_r8 :: #force_inline proc "contextless" (dst: GPR8, src: GPR8) -> Instruction { return with_hint(Instruction{ mnemonic = .CMP, operand_count = 2, ops = {op_gpr8(dst), op_gpr8(src), {}, {}} }, 195) } +inst_cmp_m8_r8 :: #force_inline proc "contextless" (dst: Mem8, src: GPR8) -> Instruction { return with_hint(Instruction{ mnemonic = .CMP, operand_count = 2, ops = {op_mem(dst.mem, 1), op_gpr8(src), {}, {}} }, 195) } +inst_cmp_r16_r16 :: #force_inline proc "contextless" (dst: GPR16, src: GPR16) -> Instruction { return with_hint(Instruction{ mnemonic = .CMP, operand_count = 2, ops = {op_gpr16(dst), op_gpr16(src), {}, {}} }, 196) } +inst_cmp_m16_r16 :: #force_inline proc "contextless" (dst: Mem16, src: GPR16) -> Instruction { return with_hint(Instruction{ mnemonic = .CMP, operand_count = 2, ops = {op_mem(dst.mem, 2), op_gpr16(src), {}, {}} }, 196) } +inst_cmp_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .CMP, operand_count = 2, ops = {op_gpr32(dst), op_gpr32(src), {}, {}} }, 197) } +inst_cmp_m32_r32 :: #force_inline proc "contextless" (dst: Mem32, src: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .CMP, operand_count = 2, ops = {op_mem(dst.mem, 4), op_gpr32(src), {}, {}} }, 197) } +inst_cmp_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .CMP, operand_count = 2, ops = {op_gpr64(dst), op_gpr64(src), {}, {}} }, 198) } +inst_cmp_m64_r64 :: #force_inline proc "contextless" (dst: Mem64, src: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .CMP, operand_count = 2, ops = {op_mem(dst.mem, 8), op_gpr64(src), {}, {}} }, 198) } +inst_cmp_r8_m8 :: #force_inline proc "contextless" (dst: GPR8, src: Mem8) -> Instruction { return with_hint(Instruction{ mnemonic = .CMP, operand_count = 2, ops = {op_gpr8(dst), op_mem(src.mem, 1), {}, {}} }, 199) } +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), {}, {}} } } +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)) } +emit_cmp_m16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16, src: GPR16) { append(instructions, inst_cmp_m16_r16(dst, src)) } +emit_cmp_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { append(instructions, inst_cmp_r32_r32(dst, src)) } +emit_cmp_m32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, src: GPR32) { append(instructions, inst_cmp_m32_r32(dst, src)) } +emit_cmp_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { append(instructions, inst_cmp_r64_r64(dst, src)) } +emit_cmp_m64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, src: GPR64) { append(instructions, inst_cmp_m64_r64(dst, src)) } +emit_cmp_r8_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8, src: Mem8) { append(instructions, inst_cmp_r8_m8(dst, src)) } +emit_cmp_r16_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: Mem16) { append(instructions, inst_cmp_r16_m16(dst, src)) } +emit_cmp_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32) { append(instructions, inst_cmp_r32_m32(dst, src)) } +emit_cmp_r64_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem64) { append(instructions, inst_cmp_r64_m64(dst, src)) } +emit_cmp_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, imm: i8) { append(instructions, inst_cmp_imm8(imm)) } +emit_cmp_imm16 :: #force_inline proc(instructions: ^[dynamic]Instruction, imm: i16) { append(instructions, inst_cmp_imm16(imm)) } +emit_cmp_imm32 :: #force_inline proc(instructions: ^[dynamic]Instruction, imm: i32) { append(instructions, inst_cmp_imm32(imm)) } +emit_cmp_r8_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8, imm: i8) { append(instructions, inst_cmp_r8_imm8(dst, imm)) } +emit_cmp_m8_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8, imm: i8) { append(instructions, inst_cmp_m8_imm8(dst, imm)) } +emit_cmp_r16_imm16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, imm: i16) { append(instructions, inst_cmp_r16_imm16(dst, imm)) } +emit_cmp_m16_imm16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16, imm: i16) { append(instructions, inst_cmp_m16_imm16(dst, imm)) } +emit_cmp_r32_imm32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, imm: i32) { append(instructions, inst_cmp_r32_imm32(dst, imm)) } +emit_cmp_m32_imm32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, imm: i32) { append(instructions, inst_cmp_m32_imm32(dst, imm)) } +emit_cmp_r64_imm32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, imm: i32) { append(instructions, inst_cmp_r64_imm32(dst, imm)) } +emit_cmp_m64_imm32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, imm: i32) { append(instructions, inst_cmp_m64_imm32(dst, imm)) } +inst_and_r8_r8 :: #force_inline proc "contextless" (dst: GPR8, src: GPR8) -> Instruction { return with_hint(Instruction{ mnemonic = .AND, operand_count = 2, ops = {op_gpr8(dst), op_gpr8(src), {}, {}} }, 214) } +inst_and_m8_r8 :: #force_inline proc "contextless" (dst: Mem8, src: GPR8) -> Instruction { return with_hint(Instruction{ mnemonic = .AND, operand_count = 2, ops = {op_mem(dst.mem, 1), op_gpr8(src), {}, {}} }, 214) } +inst_and_r16_r16 :: #force_inline proc "contextless" (dst: GPR16, src: GPR16) -> Instruction { return with_hint(Instruction{ mnemonic = .AND, operand_count = 2, ops = {op_gpr16(dst), op_gpr16(src), {}, {}} }, 215) } +inst_and_m16_r16 :: #force_inline proc "contextless" (dst: Mem16, src: GPR16) -> Instruction { return with_hint(Instruction{ mnemonic = .AND, operand_count = 2, ops = {op_mem(dst.mem, 2), op_gpr16(src), {}, {}} }, 215) } +inst_and_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .AND, operand_count = 2, ops = {op_gpr32(dst), op_gpr32(src), {}, {}} }, 216) } +inst_and_m32_r32 :: #force_inline proc "contextless" (dst: Mem32, src: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .AND, operand_count = 2, ops = {op_mem(dst.mem, 4), op_gpr32(src), {}, {}} }, 216) } +inst_and_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .AND, operand_count = 2, ops = {op_gpr64(dst), op_gpr64(src), {}, {}} }, 217) } +inst_and_m64_r64 :: #force_inline proc "contextless" (dst: Mem64, src: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .AND, operand_count = 2, ops = {op_mem(dst.mem, 8), op_gpr64(src), {}, {}} }, 217) } +inst_and_r8_m8 :: #force_inline proc "contextless" (dst: GPR8, src: Mem8) -> Instruction { return with_hint(Instruction{ mnemonic = .AND, operand_count = 2, ops = {op_gpr8(dst), op_mem(src.mem, 1), {}, {}} }, 218) } +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), {}, {}} } } +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)) } +emit_and_m16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16, src: GPR16) { append(instructions, inst_and_m16_r16(dst, src)) } +emit_and_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { append(instructions, inst_and_r32_r32(dst, src)) } +emit_and_m32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, src: GPR32) { append(instructions, inst_and_m32_r32(dst, src)) } +emit_and_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { append(instructions, inst_and_r64_r64(dst, src)) } +emit_and_m64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, src: GPR64) { append(instructions, inst_and_m64_r64(dst, src)) } +emit_and_r8_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8, src: Mem8) { append(instructions, inst_and_r8_m8(dst, src)) } +emit_and_r16_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: Mem16) { append(instructions, inst_and_r16_m16(dst, src)) } +emit_and_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32) { append(instructions, inst_and_r32_m32(dst, src)) } +emit_and_r64_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem64) { append(instructions, inst_and_r64_m64(dst, src)) } +emit_and_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, imm: i8) { append(instructions, inst_and_imm8(imm)) } +emit_and_imm16 :: #force_inline proc(instructions: ^[dynamic]Instruction, imm: i16) { append(instructions, inst_and_imm16(imm)) } +emit_and_imm32 :: #force_inline proc(instructions: ^[dynamic]Instruction, imm: i32) { append(instructions, inst_and_imm32(imm)) } +emit_and_r8_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8, imm: i8) { append(instructions, inst_and_r8_imm8(dst, imm)) } +emit_and_m8_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8, imm: i8) { append(instructions, inst_and_m8_imm8(dst, imm)) } +emit_and_r16_imm16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, imm: i16) { append(instructions, inst_and_r16_imm16(dst, imm)) } +emit_and_m16_imm16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16, imm: i16) { append(instructions, inst_and_m16_imm16(dst, imm)) } +emit_and_r32_imm32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, imm: i32) { append(instructions, inst_and_r32_imm32(dst, imm)) } +emit_and_m32_imm32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, imm: i32) { append(instructions, inst_and_m32_imm32(dst, imm)) } +emit_and_r64_imm32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, imm: i32) { append(instructions, inst_and_r64_imm32(dst, imm)) } +emit_and_m64_imm32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, imm: i32) { append(instructions, inst_and_m64_imm32(dst, imm)) } +inst_or_r8_r8 :: #force_inline proc "contextless" (dst: GPR8, src: GPR8) -> Instruction { return with_hint(Instruction{ mnemonic = .OR, operand_count = 2, ops = {op_gpr8(dst), op_gpr8(src), {}, {}} }, 233) } +inst_or_m8_r8 :: #force_inline proc "contextless" (dst: Mem8, src: GPR8) -> Instruction { return with_hint(Instruction{ mnemonic = .OR, operand_count = 2, ops = {op_mem(dst.mem, 1), op_gpr8(src), {}, {}} }, 233) } +inst_or_r16_r16 :: #force_inline proc "contextless" (dst: GPR16, src: GPR16) -> Instruction { return with_hint(Instruction{ mnemonic = .OR, operand_count = 2, ops = {op_gpr16(dst), op_gpr16(src), {}, {}} }, 234) } +inst_or_m16_r16 :: #force_inline proc "contextless" (dst: Mem16, src: GPR16) -> Instruction { return with_hint(Instruction{ mnemonic = .OR, operand_count = 2, ops = {op_mem(dst.mem, 2), op_gpr16(src), {}, {}} }, 234) } +inst_or_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .OR, operand_count = 2, ops = {op_gpr32(dst), op_gpr32(src), {}, {}} }, 235) } +inst_or_m32_r32 :: #force_inline proc "contextless" (dst: Mem32, src: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .OR, operand_count = 2, ops = {op_mem(dst.mem, 4), op_gpr32(src), {}, {}} }, 235) } +inst_or_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .OR, operand_count = 2, ops = {op_gpr64(dst), op_gpr64(src), {}, {}} }, 236) } +inst_or_m64_r64 :: #force_inline proc "contextless" (dst: Mem64, src: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .OR, operand_count = 2, ops = {op_mem(dst.mem, 8), op_gpr64(src), {}, {}} }, 236) } +inst_or_r8_m8 :: #force_inline proc "contextless" (dst: GPR8, src: Mem8) -> Instruction { return with_hint(Instruction{ mnemonic = .OR, operand_count = 2, ops = {op_gpr8(dst), op_mem(src.mem, 1), {}, {}} }, 237) } +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), {}, {}} } } +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)) } +emit_or_m16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16, src: GPR16) { append(instructions, inst_or_m16_r16(dst, src)) } +emit_or_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { append(instructions, inst_or_r32_r32(dst, src)) } +emit_or_m32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, src: GPR32) { append(instructions, inst_or_m32_r32(dst, src)) } +emit_or_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { append(instructions, inst_or_r64_r64(dst, src)) } +emit_or_m64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, src: GPR64) { append(instructions, inst_or_m64_r64(dst, src)) } +emit_or_r8_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8, src: Mem8) { append(instructions, inst_or_r8_m8(dst, src)) } +emit_or_r16_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: Mem16) { append(instructions, inst_or_r16_m16(dst, src)) } +emit_or_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32) { append(instructions, inst_or_r32_m32(dst, src)) } +emit_or_r64_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem64) { append(instructions, inst_or_r64_m64(dst, src)) } +emit_or_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, imm: i8) { append(instructions, inst_or_imm8(imm)) } +emit_or_imm16 :: #force_inline proc(instructions: ^[dynamic]Instruction, imm: i16) { append(instructions, inst_or_imm16(imm)) } +emit_or_imm32 :: #force_inline proc(instructions: ^[dynamic]Instruction, imm: i32) { append(instructions, inst_or_imm32(imm)) } +emit_or_r8_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8, imm: i8) { append(instructions, inst_or_r8_imm8(dst, imm)) } +emit_or_m8_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8, imm: i8) { append(instructions, inst_or_m8_imm8(dst, imm)) } +emit_or_r16_imm16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, imm: i16) { append(instructions, inst_or_r16_imm16(dst, imm)) } +emit_or_m16_imm16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16, imm: i16) { append(instructions, inst_or_m16_imm16(dst, imm)) } +emit_or_r32_imm32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, imm: i32) { append(instructions, inst_or_r32_imm32(dst, imm)) } +emit_or_m32_imm32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, imm: i32) { append(instructions, inst_or_m32_imm32(dst, imm)) } +emit_or_r64_imm32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, imm: i32) { append(instructions, inst_or_r64_imm32(dst, imm)) } +emit_or_m64_imm32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, imm: i32) { append(instructions, inst_or_m64_imm32(dst, imm)) } +inst_xor_r8_r8 :: #force_inline proc "contextless" (dst: GPR8, src: GPR8) -> Instruction { return with_hint(Instruction{ mnemonic = .XOR, operand_count = 2, ops = {op_gpr8(dst), op_gpr8(src), {}, {}} }, 252) } +inst_xor_m8_r8 :: #force_inline proc "contextless" (dst: Mem8, src: GPR8) -> Instruction { return with_hint(Instruction{ mnemonic = .XOR, operand_count = 2, ops = {op_mem(dst.mem, 1), op_gpr8(src), {}, {}} }, 252) } +inst_xor_r16_r16 :: #force_inline proc "contextless" (dst: GPR16, src: GPR16) -> Instruction { return with_hint(Instruction{ mnemonic = .XOR, operand_count = 2, ops = {op_gpr16(dst), op_gpr16(src), {}, {}} }, 253) } +inst_xor_m16_r16 :: #force_inline proc "contextless" (dst: Mem16, src: GPR16) -> Instruction { return with_hint(Instruction{ mnemonic = .XOR, operand_count = 2, ops = {op_mem(dst.mem, 2), op_gpr16(src), {}, {}} }, 253) } +inst_xor_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .XOR, operand_count = 2, ops = {op_gpr32(dst), op_gpr32(src), {}, {}} }, 254) } +inst_xor_m32_r32 :: #force_inline proc "contextless" (dst: Mem32, src: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .XOR, operand_count = 2, ops = {op_mem(dst.mem, 4), op_gpr32(src), {}, {}} }, 254) } +inst_xor_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .XOR, operand_count = 2, ops = {op_gpr64(dst), op_gpr64(src), {}, {}} }, 255) } +inst_xor_m64_r64 :: #force_inline proc "contextless" (dst: Mem64, src: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .XOR, operand_count = 2, ops = {op_mem(dst.mem, 8), op_gpr64(src), {}, {}} }, 255) } +inst_xor_r8_m8 :: #force_inline proc "contextless" (dst: GPR8, src: Mem8) -> Instruction { return with_hint(Instruction{ mnemonic = .XOR, operand_count = 2, ops = {op_gpr8(dst), op_mem(src.mem, 1), {}, {}} }, 256) } +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), {}, {}} } } +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)) } +emit_xor_m16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16, src: GPR16) { append(instructions, inst_xor_m16_r16(dst, src)) } +emit_xor_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { append(instructions, inst_xor_r32_r32(dst, src)) } +emit_xor_m32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, src: GPR32) { append(instructions, inst_xor_m32_r32(dst, src)) } +emit_xor_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { append(instructions, inst_xor_r64_r64(dst, src)) } +emit_xor_m64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, src: GPR64) { append(instructions, inst_xor_m64_r64(dst, src)) } +emit_xor_r8_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8, src: Mem8) { append(instructions, inst_xor_r8_m8(dst, src)) } +emit_xor_r16_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: Mem16) { append(instructions, inst_xor_r16_m16(dst, src)) } +emit_xor_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32) { append(instructions, inst_xor_r32_m32(dst, src)) } +emit_xor_r64_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem64) { append(instructions, inst_xor_r64_m64(dst, src)) } +emit_xor_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, imm: i8) { append(instructions, inst_xor_imm8(imm)) } +emit_xor_imm16 :: #force_inline proc(instructions: ^[dynamic]Instruction, imm: i16) { append(instructions, inst_xor_imm16(imm)) } +emit_xor_imm32 :: #force_inline proc(instructions: ^[dynamic]Instruction, imm: i32) { append(instructions, inst_xor_imm32(imm)) } +emit_xor_r8_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8, imm: i8) { append(instructions, inst_xor_r8_imm8(dst, imm)) } +emit_xor_m8_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8, imm: i8) { append(instructions, inst_xor_m8_imm8(dst, imm)) } +emit_xor_r16_imm16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, imm: i16) { append(instructions, inst_xor_r16_imm16(dst, imm)) } +emit_xor_m16_imm16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16, imm: i16) { append(instructions, inst_xor_m16_imm16(dst, imm)) } +emit_xor_r32_imm32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, imm: i32) { append(instructions, inst_xor_r32_imm32(dst, imm)) } +emit_xor_m32_imm32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, imm: i32) { append(instructions, inst_xor_m32_imm32(dst, imm)) } +emit_xor_r64_imm32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, imm: i32) { append(instructions, inst_xor_r64_imm32(dst, imm)) } +emit_xor_m64_imm32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, imm: i32) { append(instructions, inst_xor_m64_imm32(dst, imm)) } +inst_not_r8 :: #force_inline proc "contextless" (dst: GPR8) -> Instruction { return with_hint(Instruction{ mnemonic = .NOT, operand_count = 1, ops = {op_gpr8(dst), {}, {}, {}} }, 271) } +inst_not_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return with_hint(Instruction{ mnemonic = .NOT, operand_count = 1, ops = {op_mem(dst.mem, 1), {}, {}, {}} }, 271) } +inst_not_r16 :: #force_inline proc "contextless" (dst: GPR16) -> Instruction { return with_hint(Instruction{ mnemonic = .NOT, operand_count = 1, ops = {op_gpr16(dst), {}, {}, {}} }, 272) } +inst_not_m16 :: #force_inline proc "contextless" (dst: Mem16) -> Instruction { return with_hint(Instruction{ mnemonic = .NOT, operand_count = 1, ops = {op_mem(dst.mem, 2), {}, {}, {}} }, 272) } +inst_not_r32 :: #force_inline proc "contextless" (dst: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .NOT, operand_count = 1, ops = {op_gpr32(dst), {}, {}, {}} }, 273) } +inst_not_m32 :: #force_inline proc "contextless" (dst: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .NOT, operand_count = 1, ops = {op_mem(dst.mem, 4), {}, {}, {}} }, 273) } +inst_not_r64 :: #force_inline proc "contextless" (dst: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .NOT, operand_count = 1, ops = {op_gpr64(dst), {}, {}, {}} }, 274) } +inst_not_m64 :: #force_inline proc "contextless" (dst: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .NOT, operand_count = 1, ops = {op_mem(dst.mem, 8), {}, {}, {}} }, 274) } +emit_not_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8) { append(instructions, inst_not_r8(dst)) } +emit_not_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { append(instructions, inst_not_m8(dst)) } +emit_not_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16) { append(instructions, inst_not_r16(dst)) } +emit_not_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16) { append(instructions, inst_not_m16(dst)) } +emit_not_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32) { append(instructions, inst_not_r32(dst)) } +emit_not_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32) { append(instructions, inst_not_m32(dst)) } +emit_not_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64) { append(instructions, inst_not_r64(dst)) } +emit_not_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64) { append(instructions, inst_not_m64(dst)) } +inst_test_r8_r8 :: #force_inline proc "contextless" (dst: GPR8, src: GPR8) -> Instruction { return with_hint(Instruction{ mnemonic = .TEST, operand_count = 2, ops = {op_gpr8(dst), op_gpr8(src), {}, {}} }, 275) } +inst_test_m8_r8 :: #force_inline proc "contextless" (dst: Mem8, src: GPR8) -> Instruction { return with_hint(Instruction{ mnemonic = .TEST, operand_count = 2, ops = {op_mem(dst.mem, 1), op_gpr8(src), {}, {}} }, 275) } +inst_test_r16_r16 :: #force_inline proc "contextless" (dst: GPR16, src: GPR16) -> Instruction { return with_hint(Instruction{ mnemonic = .TEST, operand_count = 2, ops = {op_gpr16(dst), op_gpr16(src), {}, {}} }, 276) } +inst_test_m16_r16 :: #force_inline proc "contextless" (dst: Mem16, src: GPR16) -> Instruction { return with_hint(Instruction{ mnemonic = .TEST, operand_count = 2, ops = {op_mem(dst.mem, 2), op_gpr16(src), {}, {}} }, 276) } +inst_test_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .TEST, operand_count = 2, ops = {op_gpr32(dst), op_gpr32(src), {}, {}} }, 277) } +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), {}, {}} } } +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)) } +emit_test_m16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16, src: GPR16) { append(instructions, inst_test_m16_r16(dst, src)) } +emit_test_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { append(instructions, inst_test_r32_r32(dst, src)) } +emit_test_m32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, src: GPR32) { append(instructions, inst_test_m32_r32(dst, src)) } +emit_test_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { append(instructions, inst_test_r64_r64(dst, src)) } +emit_test_m64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, src: GPR64) { append(instructions, inst_test_m64_r64(dst, src)) } +emit_test_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, imm: i8) { append(instructions, inst_test_imm8(imm)) } +emit_test_imm16 :: #force_inline proc(instructions: ^[dynamic]Instruction, imm: i16) { append(instructions, inst_test_imm16(imm)) } +emit_test_imm32 :: #force_inline proc(instructions: ^[dynamic]Instruction, imm: i32) { append(instructions, inst_test_imm32(imm)) } +emit_test_r8_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8, imm: i8) { append(instructions, inst_test_r8_imm8(dst, imm)) } +emit_test_m8_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8, imm: i8) { append(instructions, inst_test_m8_imm8(dst, imm)) } +emit_test_r16_imm16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, imm: i16) { append(instructions, inst_test_r16_imm16(dst, imm)) } +emit_test_m16_imm16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16, imm: i16) { append(instructions, inst_test_m16_imm16(dst, imm)) } +emit_test_r32_imm32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, imm: i32) { append(instructions, inst_test_r32_imm32(dst, imm)) } +emit_test_m32_imm32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, imm: i32) { append(instructions, inst_test_m32_imm32(dst, imm)) } +emit_test_r64_imm32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, imm: i32) { append(instructions, inst_test_r64_imm32(dst, imm)) } +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_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_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_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), {}, {}} } } +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)) } +emit_shl_m8_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8, imm: i8) { append(instructions, inst_shl_m8_imm8(dst, imm)) } +emit_shl_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16) { append(instructions, inst_shl_r16(dst)) } +emit_shl_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16) { append(instructions, inst_shl_m16(dst)) } +emit_shl_r16_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, imm: i8) { append(instructions, inst_shl_r16_imm8(dst, imm)) } +emit_shl_m16_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16, imm: i8) { append(instructions, inst_shl_m16_imm8(dst, imm)) } +emit_shl_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32) { append(instructions, inst_shl_r32(dst)) } +emit_shl_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32) { append(instructions, inst_shl_m32(dst)) } +emit_shl_r32_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, imm: i8) { append(instructions, inst_shl_r32_imm8(dst, imm)) } +emit_shl_m32_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, imm: i8) { append(instructions, inst_shl_m32_imm8(dst, imm)) } +emit_shl_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64) { append(instructions, inst_shl_r64(dst)) } +emit_shl_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64) { append(instructions, inst_shl_m64(dst)) } +emit_shl_r64_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, imm: i8) { append(instructions, inst_shl_r64_imm8(dst, imm)) } +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_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_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_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), {}, {}} } } +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)) } +emit_shr_m8_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8, imm: i8) { append(instructions, inst_shr_m8_imm8(dst, imm)) } +emit_shr_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16) { append(instructions, inst_shr_r16(dst)) } +emit_shr_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16) { append(instructions, inst_shr_m16(dst)) } +emit_shr_r16_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, imm: i8) { append(instructions, inst_shr_r16_imm8(dst, imm)) } +emit_shr_m16_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16, imm: i8) { append(instructions, inst_shr_m16_imm8(dst, imm)) } +emit_shr_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32) { append(instructions, inst_shr_r32(dst)) } +emit_shr_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32) { append(instructions, inst_shr_m32(dst)) } +emit_shr_r32_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, imm: i8) { append(instructions, inst_shr_r32_imm8(dst, imm)) } +emit_shr_m32_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, imm: i8) { append(instructions, inst_shr_m32_imm8(dst, imm)) } +emit_shr_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64) { append(instructions, inst_shr_r64(dst)) } +emit_shr_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64) { append(instructions, inst_shr_m64(dst)) } +emit_shr_r64_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, imm: i8) { append(instructions, inst_shr_r64_imm8(dst, imm)) } +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_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_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_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), {}, {}} } } +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)) } +emit_sar_m8_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8, imm: i8) { append(instructions, inst_sar_m8_imm8(dst, imm)) } +emit_sar_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16) { append(instructions, inst_sar_r16(dst)) } +emit_sar_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16) { append(instructions, inst_sar_m16(dst)) } +emit_sar_r16_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, imm: i8) { append(instructions, inst_sar_r16_imm8(dst, imm)) } +emit_sar_m16_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16, imm: i8) { append(instructions, inst_sar_m16_imm8(dst, imm)) } +emit_sar_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32) { append(instructions, inst_sar_r32(dst)) } +emit_sar_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32) { append(instructions, inst_sar_m32(dst)) } +emit_sar_r32_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, imm: i8) { append(instructions, inst_sar_r32_imm8(dst, imm)) } +emit_sar_m32_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, imm: i8) { append(instructions, inst_sar_m32_imm8(dst, imm)) } +emit_sar_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64) { append(instructions, inst_sar_r64(dst)) } +emit_sar_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64) { append(instructions, inst_sar_m64(dst)) } +emit_sar_r64_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, imm: i8) { append(instructions, inst_sar_r64_imm8(dst, imm)) } +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_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_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_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), {}, {}} } } +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)) } +emit_rol_m8_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8, imm: i8) { append(instructions, inst_rol_m8_imm8(dst, imm)) } +emit_rol_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16) { append(instructions, inst_rol_r16(dst)) } +emit_rol_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16) { append(instructions, inst_rol_m16(dst)) } +emit_rol_r16_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, imm: i8) { append(instructions, inst_rol_r16_imm8(dst, imm)) } +emit_rol_m16_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16, imm: i8) { append(instructions, inst_rol_m16_imm8(dst, imm)) } +emit_rol_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32) { append(instructions, inst_rol_r32(dst)) } +emit_rol_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32) { append(instructions, inst_rol_m32(dst)) } +emit_rol_r32_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, imm: i8) { append(instructions, inst_rol_r32_imm8(dst, imm)) } +emit_rol_m32_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, imm: i8) { append(instructions, inst_rol_m32_imm8(dst, imm)) } +emit_rol_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64) { append(instructions, inst_rol_r64(dst)) } +emit_rol_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64) { append(instructions, inst_rol_m64(dst)) } +emit_rol_r64_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, imm: i8) { append(instructions, inst_rol_r64_imm8(dst, imm)) } +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_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_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_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), {}, {}} } } +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)) } +emit_ror_m8_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8, imm: i8) { append(instructions, inst_ror_m8_imm8(dst, imm)) } +emit_ror_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16) { append(instructions, inst_ror_r16(dst)) } +emit_ror_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16) { append(instructions, inst_ror_m16(dst)) } +emit_ror_r16_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, imm: i8) { append(instructions, inst_ror_r16_imm8(dst, imm)) } +emit_ror_m16_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16, imm: i8) { append(instructions, inst_ror_m16_imm8(dst, imm)) } +emit_ror_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32) { append(instructions, inst_ror_r32(dst)) } +emit_ror_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32) { append(instructions, inst_ror_m32(dst)) } +emit_ror_r32_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, imm: i8) { append(instructions, inst_ror_r32_imm8(dst, imm)) } +emit_ror_m32_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, imm: i8) { append(instructions, inst_ror_m32_imm8(dst, imm)) } +emit_ror_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64) { append(instructions, inst_ror_r64(dst)) } +emit_ror_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64) { append(instructions, inst_ror_m64(dst)) } +emit_ror_r64_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, imm: i8) { append(instructions, inst_ror_r64_imm8(dst, imm)) } +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_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_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_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), {}, {}} } } +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)) } +emit_rcl_m8_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8, imm: i8) { append(instructions, inst_rcl_m8_imm8(dst, imm)) } +emit_rcl_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16) { append(instructions, inst_rcl_r16(dst)) } +emit_rcl_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16) { append(instructions, inst_rcl_m16(dst)) } +emit_rcl_r16_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, imm: i8) { append(instructions, inst_rcl_r16_imm8(dst, imm)) } +emit_rcl_m16_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16, imm: i8) { append(instructions, inst_rcl_m16_imm8(dst, imm)) } +emit_rcl_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32) { append(instructions, inst_rcl_r32(dst)) } +emit_rcl_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32) { append(instructions, inst_rcl_m32(dst)) } +emit_rcl_r32_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, imm: i8) { append(instructions, inst_rcl_r32_imm8(dst, imm)) } +emit_rcl_m32_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, imm: i8) { append(instructions, inst_rcl_m32_imm8(dst, imm)) } +emit_rcl_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64) { append(instructions, inst_rcl_r64(dst)) } +emit_rcl_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64) { append(instructions, inst_rcl_m64(dst)) } +emit_rcl_r64_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, imm: i8) { append(instructions, inst_rcl_r64_imm8(dst, imm)) } +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_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_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_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), {}, {}} } } +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)) } +emit_rcr_m8_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8, imm: i8) { append(instructions, inst_rcr_m8_imm8(dst, imm)) } +emit_rcr_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16) { append(instructions, inst_rcr_r16(dst)) } +emit_rcr_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16) { append(instructions, inst_rcr_m16(dst)) } +emit_rcr_r16_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, imm: i8) { append(instructions, inst_rcr_r16_imm8(dst, imm)) } +emit_rcr_m16_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16, imm: i8) { append(instructions, inst_rcr_m16_imm8(dst, imm)) } +emit_rcr_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32) { append(instructions, inst_rcr_r32(dst)) } +emit_rcr_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32) { append(instructions, inst_rcr_m32(dst)) } +emit_rcr_r32_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, imm: i8) { append(instructions, inst_rcr_r32_imm8(dst, imm)) } +emit_rcr_m32_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, imm: i8) { append(instructions, inst_rcr_m32_imm8(dst, imm)) } +emit_rcr_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64) { append(instructions, inst_rcr_r64(dst)) } +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 :: #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) } +inst_shld_m32_r32 :: #force_inline proc "contextless" (dst: Mem32, src: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .SHLD, operand_count = 2, ops = {op_mem(dst.mem, 4), op_gpr32(src), {}, {}} }, 375) } +inst_shld_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .SHLD, operand_count = 2, ops = {op_gpr64(dst), op_gpr64(src), {}, {}} }, 376) } +inst_shld_m64_r64 :: #force_inline proc "contextless" (dst: Mem64, src: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .SHLD, operand_count = 2, ops = {op_mem(dst.mem, 8), op_gpr64(src), {}, {}} }, 376) } +emit_shld_r16_r16_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: GPR16, imm: i8) { append(instructions, inst_shld_r16_r16_imm8(dst, src, imm)) } +emit_shld_m16_r16_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16, src: GPR16, imm: i8) { append(instructions, inst_shld_m16_r16_imm8(dst, src, imm)) } +emit_shld_r32_r32_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32, imm: i8) { append(instructions, inst_shld_r32_r32_imm8(dst, src, imm)) } +emit_shld_m32_r32_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, src: GPR32, imm: i8) { append(instructions, inst_shld_m32_r32_imm8(dst, src, imm)) } +emit_shld_r64_r64_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64, imm: i8) { append(instructions, inst_shld_r64_r64_imm8(dst, src, imm)) } +emit_shld_m64_r64_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, src: GPR64, imm: i8) { append(instructions, inst_shld_m64_r64_imm8(dst, src, imm)) } +emit_shld_r16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: GPR16) { append(instructions, inst_shld_r16_r16(dst, src)) } +emit_shld_m16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16, src: GPR16) { append(instructions, inst_shld_m16_r16(dst, src)) } +emit_shld_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { append(instructions, inst_shld_r32_r32(dst, src)) } +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 :: #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) } +inst_shrd_m32_r32 :: #force_inline proc "contextless" (dst: Mem32, src: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .SHRD, operand_count = 2, ops = {op_mem(dst.mem, 4), op_gpr32(src), {}, {}} }, 381) } +inst_shrd_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .SHRD, operand_count = 2, ops = {op_gpr64(dst), op_gpr64(src), {}, {}} }, 382) } +inst_shrd_m64_r64 :: #force_inline proc "contextless" (dst: Mem64, src: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .SHRD, operand_count = 2, ops = {op_mem(dst.mem, 8), op_gpr64(src), {}, {}} }, 382) } +emit_shrd_r16_r16_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: GPR16, imm: i8) { append(instructions, inst_shrd_r16_r16_imm8(dst, src, imm)) } +emit_shrd_m16_r16_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16, src: GPR16, imm: i8) { append(instructions, inst_shrd_m16_r16_imm8(dst, src, imm)) } +emit_shrd_r32_r32_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32, imm: i8) { append(instructions, inst_shrd_r32_r32_imm8(dst, src, imm)) } +emit_shrd_m32_r32_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, src: GPR32, imm: i8) { append(instructions, inst_shrd_m32_r32_imm8(dst, src, imm)) } +emit_shrd_r64_r64_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64, imm: i8) { append(instructions, inst_shrd_r64_r64_imm8(dst, src, imm)) } +emit_shrd_m64_r64_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, src: GPR64, imm: i8) { append(instructions, inst_shrd_m64_r64_imm8(dst, src, imm)) } +emit_shrd_r16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: GPR16) { append(instructions, inst_shrd_r16_r16(dst, src)) } +emit_shrd_m16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16, src: GPR16) { append(instructions, inst_shrd_m16_r16(dst, src)) } +emit_shrd_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { append(instructions, inst_shrd_r32_r32(dst, src)) } +emit_shrd_m32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, src: GPR32) { append(instructions, inst_shrd_m32_r32(dst, src)) } +emit_shrd_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { append(instructions, inst_shrd_r64_r64(dst, src)) } +emit_shrd_m64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, src: GPR64) { append(instructions, inst_shrd_m64_r64(dst, src)) } +inst_bt_r16_r16 :: #force_inline proc "contextless" (dst: GPR16, src: GPR16) -> Instruction { return with_hint(Instruction{ mnemonic = .BT, operand_count = 2, ops = {op_gpr16(dst), op_gpr16(src), {}, {}} }, 383) } +inst_bt_m16_r16 :: #force_inline proc "contextless" (dst: Mem16, src: GPR16) -> Instruction { return with_hint(Instruction{ mnemonic = .BT, operand_count = 2, ops = {op_mem(dst.mem, 2), op_gpr16(src), {}, {}} }, 383) } +inst_bt_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .BT, operand_count = 2, ops = {op_gpr32(dst), op_gpr32(src), {}, {}} }, 384) } +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), {}, {}} } } +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)) } +emit_bt_m32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, src: GPR32) { append(instructions, inst_bt_m32_r32(dst, src)) } +emit_bt_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { append(instructions, inst_bt_r64_r64(dst, src)) } +emit_bt_m64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, src: GPR64) { append(instructions, inst_bt_m64_r64(dst, src)) } +emit_bt_r16_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, imm: i8) { append(instructions, inst_bt_r16_imm8(dst, imm)) } +emit_bt_m16_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16, imm: i8) { append(instructions, inst_bt_m16_imm8(dst, imm)) } +emit_bt_r32_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, imm: i8) { append(instructions, inst_bt_r32_imm8(dst, imm)) } +emit_bt_m32_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, imm: i8) { append(instructions, inst_bt_m32_imm8(dst, imm)) } +emit_bt_r64_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, imm: i8) { append(instructions, inst_bt_r64_imm8(dst, imm)) } +emit_bt_m64_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, imm: i8) { append(instructions, inst_bt_m64_imm8(dst, imm)) } +inst_bts_r16_r16 :: #force_inline proc "contextless" (dst: GPR16, src: GPR16) -> Instruction { return with_hint(Instruction{ mnemonic = .BTS, operand_count = 2, ops = {op_gpr16(dst), op_gpr16(src), {}, {}} }, 389) } +inst_bts_m16_r16 :: #force_inline proc "contextless" (dst: Mem16, src: GPR16) -> Instruction { return with_hint(Instruction{ mnemonic = .BTS, operand_count = 2, ops = {op_mem(dst.mem, 2), op_gpr16(src), {}, {}} }, 389) } +inst_bts_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .BTS, operand_count = 2, ops = {op_gpr32(dst), op_gpr32(src), {}, {}} }, 390) } +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), {}, {}} } } +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)) } +emit_bts_m32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, src: GPR32) { append(instructions, inst_bts_m32_r32(dst, src)) } +emit_bts_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { append(instructions, inst_bts_r64_r64(dst, src)) } +emit_bts_m64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, src: GPR64) { append(instructions, inst_bts_m64_r64(dst, src)) } +emit_bts_r16_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, imm: i8) { append(instructions, inst_bts_r16_imm8(dst, imm)) } +emit_bts_m16_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16, imm: i8) { append(instructions, inst_bts_m16_imm8(dst, imm)) } +emit_bts_r32_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, imm: i8) { append(instructions, inst_bts_r32_imm8(dst, imm)) } +emit_bts_m32_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, imm: i8) { append(instructions, inst_bts_m32_imm8(dst, imm)) } +emit_bts_r64_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, imm: i8) { append(instructions, inst_bts_r64_imm8(dst, imm)) } +emit_bts_m64_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, imm: i8) { append(instructions, inst_bts_m64_imm8(dst, imm)) } +inst_btr_r16_r16 :: #force_inline proc "contextless" (dst: GPR16, src: GPR16) -> Instruction { return with_hint(Instruction{ mnemonic = .BTR, operand_count = 2, ops = {op_gpr16(dst), op_gpr16(src), {}, {}} }, 395) } +inst_btr_m16_r16 :: #force_inline proc "contextless" (dst: Mem16, src: GPR16) -> Instruction { return with_hint(Instruction{ mnemonic = .BTR, operand_count = 2, ops = {op_mem(dst.mem, 2), op_gpr16(src), {}, {}} }, 395) } +inst_btr_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .BTR, operand_count = 2, ops = {op_gpr32(dst), op_gpr32(src), {}, {}} }, 396) } +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), {}, {}} } } +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)) } +emit_btr_m32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, src: GPR32) { append(instructions, inst_btr_m32_r32(dst, src)) } +emit_btr_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { append(instructions, inst_btr_r64_r64(dst, src)) } +emit_btr_m64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, src: GPR64) { append(instructions, inst_btr_m64_r64(dst, src)) } +emit_btr_r16_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, imm: i8) { append(instructions, inst_btr_r16_imm8(dst, imm)) } +emit_btr_m16_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16, imm: i8) { append(instructions, inst_btr_m16_imm8(dst, imm)) } +emit_btr_r32_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, imm: i8) { append(instructions, inst_btr_r32_imm8(dst, imm)) } +emit_btr_m32_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, imm: i8) { append(instructions, inst_btr_m32_imm8(dst, imm)) } +emit_btr_r64_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, imm: i8) { append(instructions, inst_btr_r64_imm8(dst, imm)) } +emit_btr_m64_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, imm: i8) { append(instructions, inst_btr_m64_imm8(dst, imm)) } +inst_btc_r16_r16 :: #force_inline proc "contextless" (dst: GPR16, src: GPR16) -> Instruction { return with_hint(Instruction{ mnemonic = .BTC, operand_count = 2, ops = {op_gpr16(dst), op_gpr16(src), {}, {}} }, 401) } +inst_btc_m16_r16 :: #force_inline proc "contextless" (dst: Mem16, src: GPR16) -> Instruction { return with_hint(Instruction{ mnemonic = .BTC, operand_count = 2, ops = {op_mem(dst.mem, 2), op_gpr16(src), {}, {}} }, 401) } +inst_btc_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .BTC, operand_count = 2, ops = {op_gpr32(dst), op_gpr32(src), {}, {}} }, 402) } +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), {}, {}} } } +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)) } +emit_btc_m32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, src: GPR32) { append(instructions, inst_btc_m32_r32(dst, src)) } +emit_btc_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { append(instructions, inst_btc_r64_r64(dst, src)) } +emit_btc_m64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, src: GPR64) { append(instructions, inst_btc_m64_r64(dst, src)) } +emit_btc_r16_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, imm: i8) { append(instructions, inst_btc_r16_imm8(dst, imm)) } +emit_btc_m16_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16, imm: i8) { append(instructions, inst_btc_m16_imm8(dst, imm)) } +emit_btc_r32_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, imm: i8) { append(instructions, inst_btc_r32_imm8(dst, imm)) } +emit_btc_m32_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, imm: i8) { append(instructions, inst_btc_m32_imm8(dst, imm)) } +emit_btc_r64_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, imm: i8) { append(instructions, inst_btc_r64_imm8(dst, imm)) } +emit_btc_m64_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, imm: i8) { append(instructions, inst_btc_m64_imm8(dst, imm)) } +inst_bsf_r16_r16 :: #force_inline proc "contextless" (dst: GPR16, src: GPR16) -> Instruction { return with_hint(Instruction{ mnemonic = .BSF, operand_count = 2, ops = {op_gpr16(dst), op_gpr16(src), {}, {}} }, 407) } +inst_bsf_r16_m16 :: #force_inline proc "contextless" (dst: GPR16, src: Mem16) -> Instruction { return with_hint(Instruction{ mnemonic = .BSF, operand_count = 2, ops = {op_gpr16(dst), op_mem(src.mem, 2), {}, {}} }, 407) } +inst_bsf_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .BSF, operand_count = 2, ops = {op_gpr32(dst), op_gpr32(src), {}, {}} }, 408) } +inst_bsf_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .BSF, operand_count = 2, ops = {op_gpr32(dst), op_mem(src.mem, 4), {}, {}} }, 408) } +inst_bsf_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .BSF, operand_count = 2, ops = {op_gpr64(dst), op_gpr64(src), {}, {}} }, 409) } +inst_bsf_r64_m64 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .BSF, operand_count = 2, ops = {op_gpr64(dst), op_mem(src.mem, 8), {}, {}} }, 409) } +emit_bsf_r16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: GPR16) { append(instructions, inst_bsf_r16_r16(dst, src)) } +emit_bsf_r16_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: Mem16) { append(instructions, inst_bsf_r16_m16(dst, src)) } +emit_bsf_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { append(instructions, inst_bsf_r32_r32(dst, src)) } +emit_bsf_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32) { append(instructions, inst_bsf_r32_m32(dst, src)) } +emit_bsf_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { append(instructions, inst_bsf_r64_r64(dst, src)) } +emit_bsf_r64_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem64) { append(instructions, inst_bsf_r64_m64(dst, src)) } +inst_bsr_r16_r16 :: #force_inline proc "contextless" (dst: GPR16, src: GPR16) -> Instruction { return with_hint(Instruction{ mnemonic = .BSR, operand_count = 2, ops = {op_gpr16(dst), op_gpr16(src), {}, {}} }, 410) } +inst_bsr_r16_m16 :: #force_inline proc "contextless" (dst: GPR16, src: Mem16) -> Instruction { return with_hint(Instruction{ mnemonic = .BSR, operand_count = 2, ops = {op_gpr16(dst), op_mem(src.mem, 2), {}, {}} }, 410) } +inst_bsr_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .BSR, operand_count = 2, ops = {op_gpr32(dst), op_gpr32(src), {}, {}} }, 411) } +inst_bsr_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .BSR, operand_count = 2, ops = {op_gpr32(dst), op_mem(src.mem, 4), {}, {}} }, 411) } +inst_bsr_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .BSR, operand_count = 2, ops = {op_gpr64(dst), op_gpr64(src), {}, {}} }, 412) } +inst_bsr_r64_m64 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .BSR, operand_count = 2, ops = {op_gpr64(dst), op_mem(src.mem, 8), {}, {}} }, 412) } +emit_bsr_r16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: GPR16) { append(instructions, inst_bsr_r16_r16(dst, src)) } +emit_bsr_r16_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: Mem16) { append(instructions, inst_bsr_r16_m16(dst, src)) } +emit_bsr_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { append(instructions, inst_bsr_r32_r32(dst, src)) } +emit_bsr_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32) { append(instructions, inst_bsr_r32_m32(dst, src)) } +emit_bsr_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { append(instructions, inst_bsr_r64_r64(dst, src)) } +emit_bsr_r64_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem64) { append(instructions, inst_bsr_r64_m64(dst, src)) } +inst_popcnt_r16_r16 :: #force_inline proc "contextless" (dst: GPR16, src: GPR16) -> Instruction { return with_hint(Instruction{ mnemonic = .POPCNT, operand_count = 2, ops = {op_gpr16(dst), op_gpr16(src), {}, {}} }, 413) } +inst_popcnt_r16_m16 :: #force_inline proc "contextless" (dst: GPR16, src: Mem16) -> Instruction { return with_hint(Instruction{ mnemonic = .POPCNT, operand_count = 2, ops = {op_gpr16(dst), op_mem(src.mem, 2), {}, {}} }, 413) } +inst_popcnt_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .POPCNT, operand_count = 2, ops = {op_gpr32(dst), op_gpr32(src), {}, {}} }, 414) } +inst_popcnt_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .POPCNT, operand_count = 2, ops = {op_gpr32(dst), op_mem(src.mem, 4), {}, {}} }, 414) } +inst_popcnt_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .POPCNT, operand_count = 2, ops = {op_gpr64(dst), op_gpr64(src), {}, {}} }, 415) } +inst_popcnt_r64_m64 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .POPCNT, operand_count = 2, ops = {op_gpr64(dst), op_mem(src.mem, 8), {}, {}} }, 415) } +emit_popcnt_r16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: GPR16) { append(instructions, inst_popcnt_r16_r16(dst, src)) } +emit_popcnt_r16_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: Mem16) { append(instructions, inst_popcnt_r16_m16(dst, src)) } +emit_popcnt_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { append(instructions, inst_popcnt_r32_r32(dst, src)) } +emit_popcnt_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32) { append(instructions, inst_popcnt_r32_m32(dst, src)) } +emit_popcnt_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { append(instructions, inst_popcnt_r64_r64(dst, src)) } +emit_popcnt_r64_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem64) { append(instructions, inst_popcnt_r64_m64(dst, src)) } +inst_lzcnt_r16_r16 :: #force_inline proc "contextless" (dst: GPR16, src: GPR16) -> Instruction { return with_hint(Instruction{ mnemonic = .LZCNT, operand_count = 2, ops = {op_gpr16(dst), op_gpr16(src), {}, {}} }, 416) } +inst_lzcnt_r16_m16 :: #force_inline proc "contextless" (dst: GPR16, src: Mem16) -> Instruction { return with_hint(Instruction{ mnemonic = .LZCNT, operand_count = 2, ops = {op_gpr16(dst), op_mem(src.mem, 2), {}, {}} }, 416) } +inst_lzcnt_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .LZCNT, operand_count = 2, ops = {op_gpr32(dst), op_gpr32(src), {}, {}} }, 417) } +inst_lzcnt_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .LZCNT, operand_count = 2, ops = {op_gpr32(dst), op_mem(src.mem, 4), {}, {}} }, 417) } +inst_lzcnt_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .LZCNT, operand_count = 2, ops = {op_gpr64(dst), op_gpr64(src), {}, {}} }, 418) } +inst_lzcnt_r64_m64 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .LZCNT, operand_count = 2, ops = {op_gpr64(dst), op_mem(src.mem, 8), {}, {}} }, 418) } +emit_lzcnt_r16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: GPR16) { append(instructions, inst_lzcnt_r16_r16(dst, src)) } +emit_lzcnt_r16_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: Mem16) { append(instructions, inst_lzcnt_r16_m16(dst, src)) } +emit_lzcnt_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { append(instructions, inst_lzcnt_r32_r32(dst, src)) } +emit_lzcnt_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32) { append(instructions, inst_lzcnt_r32_m32(dst, src)) } +emit_lzcnt_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { append(instructions, inst_lzcnt_r64_r64(dst, src)) } +emit_lzcnt_r64_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem64) { append(instructions, inst_lzcnt_r64_m64(dst, src)) } +inst_tzcnt_r16_r16 :: #force_inline proc "contextless" (dst: GPR16, src: GPR16) -> Instruction { return with_hint(Instruction{ mnemonic = .TZCNT, operand_count = 2, ops = {op_gpr16(dst), op_gpr16(src), {}, {}} }, 419) } +inst_tzcnt_r16_m16 :: #force_inline proc "contextless" (dst: GPR16, src: Mem16) -> Instruction { return with_hint(Instruction{ mnemonic = .TZCNT, operand_count = 2, ops = {op_gpr16(dst), op_mem(src.mem, 2), {}, {}} }, 419) } +inst_tzcnt_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .TZCNT, operand_count = 2, ops = {op_gpr32(dst), op_gpr32(src), {}, {}} }, 420) } +inst_tzcnt_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .TZCNT, operand_count = 2, ops = {op_gpr32(dst), op_mem(src.mem, 4), {}, {}} }, 420) } +inst_tzcnt_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .TZCNT, operand_count = 2, ops = {op_gpr64(dst), op_gpr64(src), {}, {}} }, 421) } +inst_tzcnt_r64_m64 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .TZCNT, operand_count = 2, ops = {op_gpr64(dst), op_mem(src.mem, 8), {}, {}} }, 421) } +emit_tzcnt_r16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: GPR16) { append(instructions, inst_tzcnt_r16_r16(dst, src)) } +emit_tzcnt_r16_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: Mem16) { append(instructions, inst_tzcnt_r16_m16(dst, src)) } +emit_tzcnt_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { append(instructions, inst_tzcnt_r32_r32(dst, src)) } +emit_tzcnt_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32) { append(instructions, inst_tzcnt_r32_m32(dst, src)) } +emit_tzcnt_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { append(instructions, inst_tzcnt_r64_r64(dst, src)) } +emit_tzcnt_r64_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem64) { append(instructions, inst_tzcnt_r64_m64(dst, src)) } +inst_jmp_rel8 :: #force_inline proc "contextless" (offset: i8) -> Instruction { return Instruction{ mnemonic = .JMP, operand_count = 1, ops = {op_rel8(offset), {}, {}, {}} } } +inst_jmp_rel32 :: #force_inline proc "contextless" (offset: i32) -> Instruction { return Instruction{ mnemonic = .JMP, operand_count = 1, ops = {op_rel32(offset), {}, {}, {}} } } +inst_jmp_r64 :: #force_inline proc "contextless" (dst: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .JMP, operand_count = 1, ops = {op_gpr64(dst), {}, {}, {}} }, 424) } +inst_jmp_m64 :: #force_inline proc "contextless" (dst: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .JMP, operand_count = 1, ops = {op_mem(dst.mem, 8), {}, {}, {}} }, 424) } +inst_jmp_m :: #force_inline proc "contextless" (dst: Memory) -> Instruction { return with_hint(Instruction{ mnemonic = .JMP, operand_count = 1, ops = {op_mem(dst, 0), {}, {}, {}} }, 425) } +emit_jmp_rel8 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i8) { append(instructions, inst_jmp_rel8(offset)) } +emit_jmp_rel32 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i32) { append(instructions, inst_jmp_rel32(offset)) } +emit_jmp_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64) { append(instructions, inst_jmp_r64(dst)) } +emit_jmp_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64) { append(instructions, inst_jmp_m64(dst)) } +emit_jmp_m :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Memory) { append(instructions, inst_jmp_m(dst)) } +inst_ja_rel8 :: #force_inline proc "contextless" (offset: i8) -> Instruction { return Instruction{ mnemonic = .JA, operand_count = 1, ops = {op_rel8(offset), {}, {}, {}} } } +inst_ja_rel32 :: #force_inline proc "contextless" (offset: i32) -> Instruction { return Instruction{ mnemonic = .JA, operand_count = 1, ops = {op_rel32(offset), {}, {}, {}} } } +emit_ja_rel8 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i8) { append(instructions, inst_ja_rel8(offset)) } +emit_ja_rel32 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i32) { append(instructions, inst_ja_rel32(offset)) } +inst_jae_rel8 :: #force_inline proc "contextless" (offset: i8) -> Instruction { return Instruction{ mnemonic = .JAE, operand_count = 1, ops = {op_rel8(offset), {}, {}, {}} } } +inst_jae_rel32 :: #force_inline proc "contextless" (offset: i32) -> Instruction { return Instruction{ mnemonic = .JAE, operand_count = 1, ops = {op_rel32(offset), {}, {}, {}} } } +emit_jae_rel8 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i8) { append(instructions, inst_jae_rel8(offset)) } +emit_jae_rel32 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i32) { append(instructions, inst_jae_rel32(offset)) } +inst_jb_rel8 :: #force_inline proc "contextless" (offset: i8) -> Instruction { return Instruction{ mnemonic = .JB, operand_count = 1, ops = {op_rel8(offset), {}, {}, {}} } } +inst_jb_rel32 :: #force_inline proc "contextless" (offset: i32) -> Instruction { return Instruction{ mnemonic = .JB, operand_count = 1, ops = {op_rel32(offset), {}, {}, {}} } } +emit_jb_rel8 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i8) { append(instructions, inst_jb_rel8(offset)) } +emit_jb_rel32 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i32) { append(instructions, inst_jb_rel32(offset)) } +inst_jbe_rel8 :: #force_inline proc "contextless" (offset: i8) -> Instruction { return Instruction{ mnemonic = .JBE, operand_count = 1, ops = {op_rel8(offset), {}, {}, {}} } } +inst_jbe_rel32 :: #force_inline proc "contextless" (offset: i32) -> Instruction { return Instruction{ mnemonic = .JBE, operand_count = 1, ops = {op_rel32(offset), {}, {}, {}} } } +emit_jbe_rel8 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i8) { append(instructions, inst_jbe_rel8(offset)) } +emit_jbe_rel32 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i32) { append(instructions, inst_jbe_rel32(offset)) } +inst_jc_rel8 :: #force_inline proc "contextless" (offset: i8) -> Instruction { return Instruction{ mnemonic = .JC, operand_count = 1, ops = {op_rel8(offset), {}, {}, {}} } } +inst_jc_rel32 :: #force_inline proc "contextless" (offset: i32) -> Instruction { return Instruction{ mnemonic = .JC, operand_count = 1, ops = {op_rel32(offset), {}, {}, {}} } } +emit_jc_rel8 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i8) { append(instructions, inst_jc_rel8(offset)) } +emit_jc_rel32 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i32) { append(instructions, inst_jc_rel32(offset)) } +inst_je_rel8 :: #force_inline proc "contextless" (offset: i8) -> Instruction { return Instruction{ mnemonic = .JE, operand_count = 1, ops = {op_rel8(offset), {}, {}, {}} } } +inst_je_rel32 :: #force_inline proc "contextless" (offset: i32) -> Instruction { return Instruction{ mnemonic = .JE, operand_count = 1, ops = {op_rel32(offset), {}, {}, {}} } } +emit_je_rel8 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i8) { append(instructions, inst_je_rel8(offset)) } +emit_je_rel32 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i32) { append(instructions, inst_je_rel32(offset)) } +inst_jz_rel8 :: #force_inline proc "contextless" (offset: i8) -> Instruction { return Instruction{ mnemonic = .JZ, operand_count = 1, ops = {op_rel8(offset), {}, {}, {}} } } +inst_jz_rel32 :: #force_inline proc "contextless" (offset: i32) -> Instruction { return Instruction{ mnemonic = .JZ, operand_count = 1, ops = {op_rel32(offset), {}, {}, {}} } } +emit_jz_rel8 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i8) { append(instructions, inst_jz_rel8(offset)) } +emit_jz_rel32 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i32) { append(instructions, inst_jz_rel32(offset)) } +inst_jg_rel8 :: #force_inline proc "contextless" (offset: i8) -> Instruction { return Instruction{ mnemonic = .JG, operand_count = 1, ops = {op_rel8(offset), {}, {}, {}} } } +inst_jg_rel32 :: #force_inline proc "contextless" (offset: i32) -> Instruction { return Instruction{ mnemonic = .JG, operand_count = 1, ops = {op_rel32(offset), {}, {}, {}} } } +emit_jg_rel8 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i8) { append(instructions, inst_jg_rel8(offset)) } +emit_jg_rel32 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i32) { append(instructions, inst_jg_rel32(offset)) } +inst_jge_rel8 :: #force_inline proc "contextless" (offset: i8) -> Instruction { return Instruction{ mnemonic = .JGE, operand_count = 1, ops = {op_rel8(offset), {}, {}, {}} } } +inst_jge_rel32 :: #force_inline proc "contextless" (offset: i32) -> Instruction { return Instruction{ mnemonic = .JGE, operand_count = 1, ops = {op_rel32(offset), {}, {}, {}} } } +emit_jge_rel8 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i8) { append(instructions, inst_jge_rel8(offset)) } +emit_jge_rel32 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i32) { append(instructions, inst_jge_rel32(offset)) } +inst_jl_rel8 :: #force_inline proc "contextless" (offset: i8) -> Instruction { return Instruction{ mnemonic = .JL, operand_count = 1, ops = {op_rel8(offset), {}, {}, {}} } } +inst_jl_rel32 :: #force_inline proc "contextless" (offset: i32) -> Instruction { return Instruction{ mnemonic = .JL, operand_count = 1, ops = {op_rel32(offset), {}, {}, {}} } } +emit_jl_rel8 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i8) { append(instructions, inst_jl_rel8(offset)) } +emit_jl_rel32 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i32) { append(instructions, inst_jl_rel32(offset)) } +inst_jle_rel8 :: #force_inline proc "contextless" (offset: i8) -> Instruction { return Instruction{ mnemonic = .JLE, operand_count = 1, ops = {op_rel8(offset), {}, {}, {}} } } +inst_jle_rel32 :: #force_inline proc "contextless" (offset: i32) -> Instruction { return Instruction{ mnemonic = .JLE, operand_count = 1, ops = {op_rel32(offset), {}, {}, {}} } } +emit_jle_rel8 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i8) { append(instructions, inst_jle_rel8(offset)) } +emit_jle_rel32 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i32) { append(instructions, inst_jle_rel32(offset)) } +inst_jna_rel8 :: #force_inline proc "contextless" (offset: i8) -> Instruction { return Instruction{ mnemonic = .JNA, operand_count = 1, ops = {op_rel8(offset), {}, {}, {}} } } +inst_jna_rel32 :: #force_inline proc "contextless" (offset: i32) -> Instruction { return Instruction{ mnemonic = .JNA, operand_count = 1, ops = {op_rel32(offset), {}, {}, {}} } } +emit_jna_rel8 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i8) { append(instructions, inst_jna_rel8(offset)) } +emit_jna_rel32 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i32) { append(instructions, inst_jna_rel32(offset)) } +inst_jnae_rel8 :: #force_inline proc "contextless" (offset: i8) -> Instruction { return Instruction{ mnemonic = .JNAE, operand_count = 1, ops = {op_rel8(offset), {}, {}, {}} } } +inst_jnae_rel32 :: #force_inline proc "contextless" (offset: i32) -> Instruction { return Instruction{ mnemonic = .JNAE, operand_count = 1, ops = {op_rel32(offset), {}, {}, {}} } } +emit_jnae_rel8 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i8) { append(instructions, inst_jnae_rel8(offset)) } +emit_jnae_rel32 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i32) { append(instructions, inst_jnae_rel32(offset)) } +inst_jnb_rel8 :: #force_inline proc "contextless" (offset: i8) -> Instruction { return Instruction{ mnemonic = .JNB, operand_count = 1, ops = {op_rel8(offset), {}, {}, {}} } } +inst_jnb_rel32 :: #force_inline proc "contextless" (offset: i32) -> Instruction { return Instruction{ mnemonic = .JNB, operand_count = 1, ops = {op_rel32(offset), {}, {}, {}} } } +emit_jnb_rel8 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i8) { append(instructions, inst_jnb_rel8(offset)) } +emit_jnb_rel32 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i32) { append(instructions, inst_jnb_rel32(offset)) } +inst_jnbe_rel8 :: #force_inline proc "contextless" (offset: i8) -> Instruction { return Instruction{ mnemonic = .JNBE, operand_count = 1, ops = {op_rel8(offset), {}, {}, {}} } } +inst_jnbe_rel32 :: #force_inline proc "contextless" (offset: i32) -> Instruction { return Instruction{ mnemonic = .JNBE, operand_count = 1, ops = {op_rel32(offset), {}, {}, {}} } } +emit_jnbe_rel8 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i8) { append(instructions, inst_jnbe_rel8(offset)) } +emit_jnbe_rel32 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i32) { append(instructions, inst_jnbe_rel32(offset)) } +inst_jnc_rel8 :: #force_inline proc "contextless" (offset: i8) -> Instruction { return Instruction{ mnemonic = .JNC, operand_count = 1, ops = {op_rel8(offset), {}, {}, {}} } } +inst_jnc_rel32 :: #force_inline proc "contextless" (offset: i32) -> Instruction { return Instruction{ mnemonic = .JNC, operand_count = 1, ops = {op_rel32(offset), {}, {}, {}} } } +emit_jnc_rel8 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i8) { append(instructions, inst_jnc_rel8(offset)) } +emit_jnc_rel32 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i32) { append(instructions, inst_jnc_rel32(offset)) } +inst_jne_rel8 :: #force_inline proc "contextless" (offset: i8) -> Instruction { return Instruction{ mnemonic = .JNE, operand_count = 1, ops = {op_rel8(offset), {}, {}, {}} } } +inst_jne_rel32 :: #force_inline proc "contextless" (offset: i32) -> Instruction { return Instruction{ mnemonic = .JNE, operand_count = 1, ops = {op_rel32(offset), {}, {}, {}} } } +emit_jne_rel8 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i8) { append(instructions, inst_jne_rel8(offset)) } +emit_jne_rel32 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i32) { append(instructions, inst_jne_rel32(offset)) } +inst_jnz_rel8 :: #force_inline proc "contextless" (offset: i8) -> Instruction { return Instruction{ mnemonic = .JNZ, operand_count = 1, ops = {op_rel8(offset), {}, {}, {}} } } +inst_jnz_rel32 :: #force_inline proc "contextless" (offset: i32) -> Instruction { return Instruction{ mnemonic = .JNZ, operand_count = 1, ops = {op_rel32(offset), {}, {}, {}} } } +emit_jnz_rel8 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i8) { append(instructions, inst_jnz_rel8(offset)) } +emit_jnz_rel32 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i32) { append(instructions, inst_jnz_rel32(offset)) } +inst_jng_rel8 :: #force_inline proc "contextless" (offset: i8) -> Instruction { return Instruction{ mnemonic = .JNG, operand_count = 1, ops = {op_rel8(offset), {}, {}, {}} } } +inst_jng_rel32 :: #force_inline proc "contextless" (offset: i32) -> Instruction { return Instruction{ mnemonic = .JNG, operand_count = 1, ops = {op_rel32(offset), {}, {}, {}} } } +emit_jng_rel8 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i8) { append(instructions, inst_jng_rel8(offset)) } +emit_jng_rel32 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i32) { append(instructions, inst_jng_rel32(offset)) } +inst_jnge_rel8 :: #force_inline proc "contextless" (offset: i8) -> Instruction { return Instruction{ mnemonic = .JNGE, operand_count = 1, ops = {op_rel8(offset), {}, {}, {}} } } +inst_jnge_rel32 :: #force_inline proc "contextless" (offset: i32) -> Instruction { return Instruction{ mnemonic = .JNGE, operand_count = 1, ops = {op_rel32(offset), {}, {}, {}} } } +emit_jnge_rel8 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i8) { append(instructions, inst_jnge_rel8(offset)) } +emit_jnge_rel32 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i32) { append(instructions, inst_jnge_rel32(offset)) } +inst_jnl_rel8 :: #force_inline proc "contextless" (offset: i8) -> Instruction { return Instruction{ mnemonic = .JNL, operand_count = 1, ops = {op_rel8(offset), {}, {}, {}} } } +inst_jnl_rel32 :: #force_inline proc "contextless" (offset: i32) -> Instruction { return Instruction{ mnemonic = .JNL, operand_count = 1, ops = {op_rel32(offset), {}, {}, {}} } } +emit_jnl_rel8 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i8) { append(instructions, inst_jnl_rel8(offset)) } +emit_jnl_rel32 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i32) { append(instructions, inst_jnl_rel32(offset)) } +inst_jnle_rel8 :: #force_inline proc "contextless" (offset: i8) -> Instruction { return Instruction{ mnemonic = .JNLE, operand_count = 1, ops = {op_rel8(offset), {}, {}, {}} } } +inst_jnle_rel32 :: #force_inline proc "contextless" (offset: i32) -> Instruction { return Instruction{ mnemonic = .JNLE, operand_count = 1, ops = {op_rel32(offset), {}, {}, {}} } } +emit_jnle_rel8 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i8) { append(instructions, inst_jnle_rel8(offset)) } +emit_jnle_rel32 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i32) { append(instructions, inst_jnle_rel32(offset)) } +inst_jno_rel8 :: #force_inline proc "contextless" (offset: i8) -> Instruction { return Instruction{ mnemonic = .JNO, operand_count = 1, ops = {op_rel8(offset), {}, {}, {}} } } +inst_jno_rel32 :: #force_inline proc "contextless" (offset: i32) -> Instruction { return Instruction{ mnemonic = .JNO, operand_count = 1, ops = {op_rel32(offset), {}, {}, {}} } } +emit_jno_rel8 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i8) { append(instructions, inst_jno_rel8(offset)) } +emit_jno_rel32 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i32) { append(instructions, inst_jno_rel32(offset)) } +inst_jnp_rel8 :: #force_inline proc "contextless" (offset: i8) -> Instruction { return Instruction{ mnemonic = .JNP, operand_count = 1, ops = {op_rel8(offset), {}, {}, {}} } } +inst_jnp_rel32 :: #force_inline proc "contextless" (offset: i32) -> Instruction { return Instruction{ mnemonic = .JNP, operand_count = 1, ops = {op_rel32(offset), {}, {}, {}} } } +emit_jnp_rel8 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i8) { append(instructions, inst_jnp_rel8(offset)) } +emit_jnp_rel32 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i32) { append(instructions, inst_jnp_rel32(offset)) } +inst_jns_rel8 :: #force_inline proc "contextless" (offset: i8) -> Instruction { return Instruction{ mnemonic = .JNS, operand_count = 1, ops = {op_rel8(offset), {}, {}, {}} } } +inst_jns_rel32 :: #force_inline proc "contextless" (offset: i32) -> Instruction { return Instruction{ mnemonic = .JNS, operand_count = 1, ops = {op_rel32(offset), {}, {}, {}} } } +emit_jns_rel8 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i8) { append(instructions, inst_jns_rel8(offset)) } +emit_jns_rel32 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i32) { append(instructions, inst_jns_rel32(offset)) } +inst_jo_rel8 :: #force_inline proc "contextless" (offset: i8) -> Instruction { return Instruction{ mnemonic = .JO, operand_count = 1, ops = {op_rel8(offset), {}, {}, {}} } } +inst_jo_rel32 :: #force_inline proc "contextless" (offset: i32) -> Instruction { return Instruction{ mnemonic = .JO, operand_count = 1, ops = {op_rel32(offset), {}, {}, {}} } } +emit_jo_rel8 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i8) { append(instructions, inst_jo_rel8(offset)) } +emit_jo_rel32 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i32) { append(instructions, inst_jo_rel32(offset)) } +inst_jp_rel8 :: #force_inline proc "contextless" (offset: i8) -> Instruction { return Instruction{ mnemonic = .JP, operand_count = 1, ops = {op_rel8(offset), {}, {}, {}} } } +inst_jp_rel32 :: #force_inline proc "contextless" (offset: i32) -> Instruction { return Instruction{ mnemonic = .JP, operand_count = 1, ops = {op_rel32(offset), {}, {}, {}} } } +emit_jp_rel8 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i8) { append(instructions, inst_jp_rel8(offset)) } +emit_jp_rel32 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i32) { append(instructions, inst_jp_rel32(offset)) } +inst_jpe_rel8 :: #force_inline proc "contextless" (offset: i8) -> Instruction { return Instruction{ mnemonic = .JPE, operand_count = 1, ops = {op_rel8(offset), {}, {}, {}} } } +inst_jpe_rel32 :: #force_inline proc "contextless" (offset: i32) -> Instruction { return Instruction{ mnemonic = .JPE, operand_count = 1, ops = {op_rel32(offset), {}, {}, {}} } } +emit_jpe_rel8 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i8) { append(instructions, inst_jpe_rel8(offset)) } +emit_jpe_rel32 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i32) { append(instructions, inst_jpe_rel32(offset)) } +inst_jpo_rel8 :: #force_inline proc "contextless" (offset: i8) -> Instruction { return Instruction{ mnemonic = .JPO, operand_count = 1, ops = {op_rel8(offset), {}, {}, {}} } } +inst_jpo_rel32 :: #force_inline proc "contextless" (offset: i32) -> Instruction { return Instruction{ mnemonic = .JPO, operand_count = 1, ops = {op_rel32(offset), {}, {}, {}} } } +emit_jpo_rel8 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i8) { append(instructions, inst_jpo_rel8(offset)) } +emit_jpo_rel32 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i32) { append(instructions, inst_jpo_rel32(offset)) } +inst_js_rel8 :: #force_inline proc "contextless" (offset: i8) -> Instruction { return Instruction{ mnemonic = .JS, operand_count = 1, ops = {op_rel8(offset), {}, {}, {}} } } +inst_js_rel32 :: #force_inline proc "contextless" (offset: i32) -> Instruction { return Instruction{ mnemonic = .JS, operand_count = 1, ops = {op_rel32(offset), {}, {}, {}} } } +emit_js_rel8 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i8) { append(instructions, inst_js_rel8(offset)) } +emit_js_rel32 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i32) { append(instructions, inst_js_rel32(offset)) } +inst_jcxz_rel8 :: #force_inline proc "contextless" (offset: i8) -> Instruction { return Instruction{ mnemonic = .JCXZ, operand_count = 1, ops = {op_rel8(offset), {}, {}, {}} } } +emit_jcxz_rel8 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i8) { append(instructions, inst_jcxz_rel8(offset)) } +inst_jecxz_rel8 :: #force_inline proc "contextless" (offset: i8) -> Instruction { return Instruction{ mnemonic = .JECXZ, operand_count = 1, ops = {op_rel8(offset), {}, {}, {}} } } +emit_jecxz_rel8 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i8) { append(instructions, inst_jecxz_rel8(offset)) } +inst_jrcxz_rel8 :: #force_inline proc "contextless" (offset: i8) -> Instruction { return Instruction{ mnemonic = .JRCXZ, operand_count = 1, ops = {op_rel8(offset), {}, {}, {}} } } +emit_jrcxz_rel8 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i8) { append(instructions, inst_jrcxz_rel8(offset)) } +inst_loop_rel8 :: #force_inline proc "contextless" (offset: i8) -> Instruction { return Instruction{ mnemonic = .LOOP, operand_count = 1, ops = {op_rel8(offset), {}, {}, {}} } } +emit_loop_rel8 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i8) { append(instructions, inst_loop_rel8(offset)) } +inst_loope_rel8 :: #force_inline proc "contextless" (offset: i8) -> Instruction { return Instruction{ mnemonic = .LOOPE, operand_count = 1, ops = {op_rel8(offset), {}, {}, {}} } } +emit_loope_rel8 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i8) { append(instructions, inst_loope_rel8(offset)) } +inst_loopne_rel8 :: #force_inline proc "contextless" (offset: i8) -> Instruction { return Instruction{ mnemonic = .LOOPNE, operand_count = 1, ops = {op_rel8(offset), {}, {}, {}} } } +emit_loopne_rel8 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i8) { append(instructions, inst_loopne_rel8(offset)) } +inst_call_rel32 :: #force_inline proc "contextless" (offset: i32) -> Instruction { return Instruction{ mnemonic = .CALL, operand_count = 1, ops = {op_rel32(offset), {}, {}, {}} } } +inst_call_r64 :: #force_inline proc "contextless" (dst: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .CALL, operand_count = 1, ops = {op_gpr64(dst), {}, {}, {}} }, 495) } +inst_call_m64 :: #force_inline proc "contextless" (dst: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .CALL, operand_count = 1, ops = {op_mem(dst.mem, 8), {}, {}, {}} }, 495) } +inst_call_m :: #force_inline proc "contextless" (dst: Memory) -> Instruction { return with_hint(Instruction{ mnemonic = .CALL, operand_count = 1, ops = {op_mem(dst, 0), {}, {}, {}} }, 496) } +emit_call_rel32 :: #force_inline proc(instructions: ^[dynamic]Instruction, offset: i32) { append(instructions, inst_call_rel32(offset)) } +emit_call_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64) { append(instructions, inst_call_r64(dst)) } +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), {}, {}, {}} } } +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) } +emit_iret_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_iret_none()) } +inst_iretd_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .IRETD, operand_count = 0, ops = {{}, {}, {}, {}} }, 502) } +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), {}, {}, {}} } } +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()) } +inst_into_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .INTO, operand_count = 0, ops = {{}, {}, {}, {}} }, 506) } +emit_into_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_into_none()) } +inst_syscall_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .SYSCALL, operand_count = 0, ops = {{}, {}, {}, {}} }, 507) } +emit_syscall_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_syscall_none()) } +inst_sysret_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .SYSRET, operand_count = 0, ops = {{}, {}, {}, {}} }, 508) } +emit_sysret_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_sysret_none()) } +inst_sysenter_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .SYSENTER, operand_count = 0, ops = {{}, {}, {}, {}} }, 509) } +emit_sysenter_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_sysenter_none()) } +inst_sysexit_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .SYSEXIT, operand_count = 0, ops = {{}, {}, {}, {}} }, 510) } +emit_sysexit_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_sysexit_none()) } +inst_seta_r8 :: #force_inline proc "contextless" (dst: GPR8) -> Instruction { return with_hint(Instruction{ mnemonic = .SETA, operand_count = 1, ops = {op_gpr8(dst), {}, {}, {}} }, 511) } +inst_seta_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return with_hint(Instruction{ mnemonic = .SETA, operand_count = 1, ops = {op_mem(dst.mem, 1), {}, {}, {}} }, 511) } +emit_seta_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8) { append(instructions, inst_seta_r8(dst)) } +emit_seta_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { append(instructions, inst_seta_m8(dst)) } +inst_setae_r8 :: #force_inline proc "contextless" (dst: GPR8) -> Instruction { return with_hint(Instruction{ mnemonic = .SETAE, operand_count = 1, ops = {op_gpr8(dst), {}, {}, {}} }, 512) } +inst_setae_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return with_hint(Instruction{ mnemonic = .SETAE, operand_count = 1, ops = {op_mem(dst.mem, 1), {}, {}, {}} }, 512) } +emit_setae_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8) { append(instructions, inst_setae_r8(dst)) } +emit_setae_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { append(instructions, inst_setae_m8(dst)) } +inst_setb_r8 :: #force_inline proc "contextless" (dst: GPR8) -> Instruction { return with_hint(Instruction{ mnemonic = .SETB, operand_count = 1, ops = {op_gpr8(dst), {}, {}, {}} }, 513) } +inst_setb_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return with_hint(Instruction{ mnemonic = .SETB, operand_count = 1, ops = {op_mem(dst.mem, 1), {}, {}, {}} }, 513) } +emit_setb_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8) { append(instructions, inst_setb_r8(dst)) } +emit_setb_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { append(instructions, inst_setb_m8(dst)) } +inst_setbe_r8 :: #force_inline proc "contextless" (dst: GPR8) -> Instruction { return with_hint(Instruction{ mnemonic = .SETBE, operand_count = 1, ops = {op_gpr8(dst), {}, {}, {}} }, 514) } +inst_setbe_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return with_hint(Instruction{ mnemonic = .SETBE, operand_count = 1, ops = {op_mem(dst.mem, 1), {}, {}, {}} }, 514) } +emit_setbe_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8) { append(instructions, inst_setbe_r8(dst)) } +emit_setbe_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { append(instructions, inst_setbe_m8(dst)) } +inst_setc_r8 :: #force_inline proc "contextless" (dst: GPR8) -> Instruction { return with_hint(Instruction{ mnemonic = .SETC, operand_count = 1, ops = {op_gpr8(dst), {}, {}, {}} }, 515) } +inst_setc_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return with_hint(Instruction{ mnemonic = .SETC, operand_count = 1, ops = {op_mem(dst.mem, 1), {}, {}, {}} }, 515) } +emit_setc_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8) { append(instructions, inst_setc_r8(dst)) } +emit_setc_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { append(instructions, inst_setc_m8(dst)) } +inst_sete_r8 :: #force_inline proc "contextless" (dst: GPR8) -> Instruction { return with_hint(Instruction{ mnemonic = .SETE, operand_count = 1, ops = {op_gpr8(dst), {}, {}, {}} }, 516) } +inst_sete_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return with_hint(Instruction{ mnemonic = .SETE, operand_count = 1, ops = {op_mem(dst.mem, 1), {}, {}, {}} }, 516) } +emit_sete_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8) { append(instructions, inst_sete_r8(dst)) } +emit_sete_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { append(instructions, inst_sete_m8(dst)) } +inst_setg_r8 :: #force_inline proc "contextless" (dst: GPR8) -> Instruction { return with_hint(Instruction{ mnemonic = .SETG, operand_count = 1, ops = {op_gpr8(dst), {}, {}, {}} }, 517) } +inst_setg_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return with_hint(Instruction{ mnemonic = .SETG, operand_count = 1, ops = {op_mem(dst.mem, 1), {}, {}, {}} }, 517) } +emit_setg_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8) { append(instructions, inst_setg_r8(dst)) } +emit_setg_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { append(instructions, inst_setg_m8(dst)) } +inst_setge_r8 :: #force_inline proc "contextless" (dst: GPR8) -> Instruction { return with_hint(Instruction{ mnemonic = .SETGE, operand_count = 1, ops = {op_gpr8(dst), {}, {}, {}} }, 518) } +inst_setge_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return with_hint(Instruction{ mnemonic = .SETGE, operand_count = 1, ops = {op_mem(dst.mem, 1), {}, {}, {}} }, 518) } +emit_setge_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8) { append(instructions, inst_setge_r8(dst)) } +emit_setge_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { append(instructions, inst_setge_m8(dst)) } +inst_setl_r8 :: #force_inline proc "contextless" (dst: GPR8) -> Instruction { return with_hint(Instruction{ mnemonic = .SETL, operand_count = 1, ops = {op_gpr8(dst), {}, {}, {}} }, 519) } +inst_setl_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return with_hint(Instruction{ mnemonic = .SETL, operand_count = 1, ops = {op_mem(dst.mem, 1), {}, {}, {}} }, 519) } +emit_setl_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8) { append(instructions, inst_setl_r8(dst)) } +emit_setl_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { append(instructions, inst_setl_m8(dst)) } +inst_setle_r8 :: #force_inline proc "contextless" (dst: GPR8) -> Instruction { return with_hint(Instruction{ mnemonic = .SETLE, operand_count = 1, ops = {op_gpr8(dst), {}, {}, {}} }, 520) } +inst_setle_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return with_hint(Instruction{ mnemonic = .SETLE, operand_count = 1, ops = {op_mem(dst.mem, 1), {}, {}, {}} }, 520) } +emit_setle_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8) { append(instructions, inst_setle_r8(dst)) } +emit_setle_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { append(instructions, inst_setle_m8(dst)) } +inst_setna_r8 :: #force_inline proc "contextless" (dst: GPR8) -> Instruction { return with_hint(Instruction{ mnemonic = .SETNA, operand_count = 1, ops = {op_gpr8(dst), {}, {}, {}} }, 521) } +inst_setna_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return with_hint(Instruction{ mnemonic = .SETNA, operand_count = 1, ops = {op_mem(dst.mem, 1), {}, {}, {}} }, 521) } +emit_setna_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8) { append(instructions, inst_setna_r8(dst)) } +emit_setna_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { append(instructions, inst_setna_m8(dst)) } +inst_setnae_r8 :: #force_inline proc "contextless" (dst: GPR8) -> Instruction { return with_hint(Instruction{ mnemonic = .SETNAE, operand_count = 1, ops = {op_gpr8(dst), {}, {}, {}} }, 522) } +inst_setnae_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return with_hint(Instruction{ mnemonic = .SETNAE, operand_count = 1, ops = {op_mem(dst.mem, 1), {}, {}, {}} }, 522) } +emit_setnae_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8) { append(instructions, inst_setnae_r8(dst)) } +emit_setnae_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { append(instructions, inst_setnae_m8(dst)) } +inst_setnb_r8 :: #force_inline proc "contextless" (dst: GPR8) -> Instruction { return with_hint(Instruction{ mnemonic = .SETNB, operand_count = 1, ops = {op_gpr8(dst), {}, {}, {}} }, 523) } +inst_setnb_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return with_hint(Instruction{ mnemonic = .SETNB, operand_count = 1, ops = {op_mem(dst.mem, 1), {}, {}, {}} }, 523) } +emit_setnb_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8) { append(instructions, inst_setnb_r8(dst)) } +emit_setnb_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { append(instructions, inst_setnb_m8(dst)) } +inst_setnbe_r8 :: #force_inline proc "contextless" (dst: GPR8) -> Instruction { return with_hint(Instruction{ mnemonic = .SETNBE, operand_count = 1, ops = {op_gpr8(dst), {}, {}, {}} }, 524) } +inst_setnbe_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return with_hint(Instruction{ mnemonic = .SETNBE, operand_count = 1, ops = {op_mem(dst.mem, 1), {}, {}, {}} }, 524) } +emit_setnbe_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8) { append(instructions, inst_setnbe_r8(dst)) } +emit_setnbe_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { append(instructions, inst_setnbe_m8(dst)) } +inst_setnc_r8 :: #force_inline proc "contextless" (dst: GPR8) -> Instruction { return with_hint(Instruction{ mnemonic = .SETNC, operand_count = 1, ops = {op_gpr8(dst), {}, {}, {}} }, 525) } +inst_setnc_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return with_hint(Instruction{ mnemonic = .SETNC, operand_count = 1, ops = {op_mem(dst.mem, 1), {}, {}, {}} }, 525) } +emit_setnc_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8) { append(instructions, inst_setnc_r8(dst)) } +emit_setnc_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { append(instructions, inst_setnc_m8(dst)) } +inst_setne_r8 :: #force_inline proc "contextless" (dst: GPR8) -> Instruction { return with_hint(Instruction{ mnemonic = .SETNE, operand_count = 1, ops = {op_gpr8(dst), {}, {}, {}} }, 526) } +inst_setne_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return with_hint(Instruction{ mnemonic = .SETNE, operand_count = 1, ops = {op_mem(dst.mem, 1), {}, {}, {}} }, 526) } +emit_setne_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8) { append(instructions, inst_setne_r8(dst)) } +emit_setne_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { append(instructions, inst_setne_m8(dst)) } +inst_setng_r8 :: #force_inline proc "contextless" (dst: GPR8) -> Instruction { return with_hint(Instruction{ mnemonic = .SETNG, operand_count = 1, ops = {op_gpr8(dst), {}, {}, {}} }, 527) } +inst_setng_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return with_hint(Instruction{ mnemonic = .SETNG, operand_count = 1, ops = {op_mem(dst.mem, 1), {}, {}, {}} }, 527) } +emit_setng_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8) { append(instructions, inst_setng_r8(dst)) } +emit_setng_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { append(instructions, inst_setng_m8(dst)) } +inst_setnge_r8 :: #force_inline proc "contextless" (dst: GPR8) -> Instruction { return with_hint(Instruction{ mnemonic = .SETNGE, operand_count = 1, ops = {op_gpr8(dst), {}, {}, {}} }, 528) } +inst_setnge_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return with_hint(Instruction{ mnemonic = .SETNGE, operand_count = 1, ops = {op_mem(dst.mem, 1), {}, {}, {}} }, 528) } +emit_setnge_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8) { append(instructions, inst_setnge_r8(dst)) } +emit_setnge_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { append(instructions, inst_setnge_m8(dst)) } +inst_setnl_r8 :: #force_inline proc "contextless" (dst: GPR8) -> Instruction { return with_hint(Instruction{ mnemonic = .SETNL, operand_count = 1, ops = {op_gpr8(dst), {}, {}, {}} }, 529) } +inst_setnl_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return with_hint(Instruction{ mnemonic = .SETNL, operand_count = 1, ops = {op_mem(dst.mem, 1), {}, {}, {}} }, 529) } +emit_setnl_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8) { append(instructions, inst_setnl_r8(dst)) } +emit_setnl_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { append(instructions, inst_setnl_m8(dst)) } +inst_setnle_r8 :: #force_inline proc "contextless" (dst: GPR8) -> Instruction { return with_hint(Instruction{ mnemonic = .SETNLE, operand_count = 1, ops = {op_gpr8(dst), {}, {}, {}} }, 530) } +inst_setnle_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return with_hint(Instruction{ mnemonic = .SETNLE, operand_count = 1, ops = {op_mem(dst.mem, 1), {}, {}, {}} }, 530) } +emit_setnle_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8) { append(instructions, inst_setnle_r8(dst)) } +emit_setnle_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { append(instructions, inst_setnle_m8(dst)) } +inst_setno_r8 :: #force_inline proc "contextless" (dst: GPR8) -> Instruction { return with_hint(Instruction{ mnemonic = .SETNO, operand_count = 1, ops = {op_gpr8(dst), {}, {}, {}} }, 531) } +inst_setno_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return with_hint(Instruction{ mnemonic = .SETNO, operand_count = 1, ops = {op_mem(dst.mem, 1), {}, {}, {}} }, 531) } +emit_setno_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8) { append(instructions, inst_setno_r8(dst)) } +emit_setno_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { append(instructions, inst_setno_m8(dst)) } +inst_setnp_r8 :: #force_inline proc "contextless" (dst: GPR8) -> Instruction { return with_hint(Instruction{ mnemonic = .SETNP, operand_count = 1, ops = {op_gpr8(dst), {}, {}, {}} }, 532) } +inst_setnp_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return with_hint(Instruction{ mnemonic = .SETNP, operand_count = 1, ops = {op_mem(dst.mem, 1), {}, {}, {}} }, 532) } +emit_setnp_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8) { append(instructions, inst_setnp_r8(dst)) } +emit_setnp_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { append(instructions, inst_setnp_m8(dst)) } +inst_setns_r8 :: #force_inline proc "contextless" (dst: GPR8) -> Instruction { return with_hint(Instruction{ mnemonic = .SETNS, operand_count = 1, ops = {op_gpr8(dst), {}, {}, {}} }, 533) } +inst_setns_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return with_hint(Instruction{ mnemonic = .SETNS, operand_count = 1, ops = {op_mem(dst.mem, 1), {}, {}, {}} }, 533) } +emit_setns_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8) { append(instructions, inst_setns_r8(dst)) } +emit_setns_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { append(instructions, inst_setns_m8(dst)) } +inst_setnz_r8 :: #force_inline proc "contextless" (dst: GPR8) -> Instruction { return with_hint(Instruction{ mnemonic = .SETNZ, operand_count = 1, ops = {op_gpr8(dst), {}, {}, {}} }, 534) } +inst_setnz_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return with_hint(Instruction{ mnemonic = .SETNZ, operand_count = 1, ops = {op_mem(dst.mem, 1), {}, {}, {}} }, 534) } +emit_setnz_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8) { append(instructions, inst_setnz_r8(dst)) } +emit_setnz_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { append(instructions, inst_setnz_m8(dst)) } +inst_seto_r8 :: #force_inline proc "contextless" (dst: GPR8) -> Instruction { return with_hint(Instruction{ mnemonic = .SETO, operand_count = 1, ops = {op_gpr8(dst), {}, {}, {}} }, 535) } +inst_seto_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return with_hint(Instruction{ mnemonic = .SETO, operand_count = 1, ops = {op_mem(dst.mem, 1), {}, {}, {}} }, 535) } +emit_seto_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8) { append(instructions, inst_seto_r8(dst)) } +emit_seto_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { append(instructions, inst_seto_m8(dst)) } +inst_setp_r8 :: #force_inline proc "contextless" (dst: GPR8) -> Instruction { return with_hint(Instruction{ mnemonic = .SETP, operand_count = 1, ops = {op_gpr8(dst), {}, {}, {}} }, 536) } +inst_setp_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return with_hint(Instruction{ mnemonic = .SETP, operand_count = 1, ops = {op_mem(dst.mem, 1), {}, {}, {}} }, 536) } +emit_setp_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8) { append(instructions, inst_setp_r8(dst)) } +emit_setp_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { append(instructions, inst_setp_m8(dst)) } +inst_setpe_r8 :: #force_inline proc "contextless" (dst: GPR8) -> Instruction { return with_hint(Instruction{ mnemonic = .SETPE, operand_count = 1, ops = {op_gpr8(dst), {}, {}, {}} }, 537) } +inst_setpe_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return with_hint(Instruction{ mnemonic = .SETPE, operand_count = 1, ops = {op_mem(dst.mem, 1), {}, {}, {}} }, 537) } +emit_setpe_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8) { append(instructions, inst_setpe_r8(dst)) } +emit_setpe_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { append(instructions, inst_setpe_m8(dst)) } +inst_setpo_r8 :: #force_inline proc "contextless" (dst: GPR8) -> Instruction { return with_hint(Instruction{ mnemonic = .SETPO, operand_count = 1, ops = {op_gpr8(dst), {}, {}, {}} }, 538) } +inst_setpo_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return with_hint(Instruction{ mnemonic = .SETPO, operand_count = 1, ops = {op_mem(dst.mem, 1), {}, {}, {}} }, 538) } +emit_setpo_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8) { append(instructions, inst_setpo_r8(dst)) } +emit_setpo_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { append(instructions, inst_setpo_m8(dst)) } +inst_sets_r8 :: #force_inline proc "contextless" (dst: GPR8) -> Instruction { return with_hint(Instruction{ mnemonic = .SETS, operand_count = 1, ops = {op_gpr8(dst), {}, {}, {}} }, 539) } +inst_sets_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return with_hint(Instruction{ mnemonic = .SETS, operand_count = 1, ops = {op_mem(dst.mem, 1), {}, {}, {}} }, 539) } +emit_sets_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8) { append(instructions, inst_sets_r8(dst)) } +emit_sets_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { append(instructions, inst_sets_m8(dst)) } +inst_setz_r8 :: #force_inline proc "contextless" (dst: GPR8) -> Instruction { return with_hint(Instruction{ mnemonic = .SETZ, operand_count = 1, ops = {op_gpr8(dst), {}, {}, {}} }, 540) } +inst_setz_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return with_hint(Instruction{ mnemonic = .SETZ, operand_count = 1, ops = {op_mem(dst.mem, 1), {}, {}, {}} }, 540) } +emit_setz_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8) { append(instructions, inst_setz_r8(dst)) } +emit_setz_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { append(instructions, inst_setz_m8(dst)) } +inst_cmova_r16_r16 :: #force_inline proc "contextless" (dst: GPR16, src: GPR16) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVA, operand_count = 2, ops = {op_gpr16(dst), op_gpr16(src), {}, {}} }, 541) } +inst_cmova_r16_m16 :: #force_inline proc "contextless" (dst: GPR16, src: Mem16) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVA, operand_count = 2, ops = {op_gpr16(dst), op_mem(src.mem, 2), {}, {}} }, 541) } +inst_cmova_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVA, operand_count = 2, ops = {op_gpr32(dst), op_gpr32(src), {}, {}} }, 542) } +inst_cmova_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVA, operand_count = 2, ops = {op_gpr32(dst), op_mem(src.mem, 4), {}, {}} }, 542) } +inst_cmova_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVA, operand_count = 2, ops = {op_gpr64(dst), op_gpr64(src), {}, {}} }, 543) } +inst_cmova_r64_m64 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVA, operand_count = 2, ops = {op_gpr64(dst), op_mem(src.mem, 8), {}, {}} }, 543) } +emit_cmova_r16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: GPR16) { append(instructions, inst_cmova_r16_r16(dst, src)) } +emit_cmova_r16_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: Mem16) { append(instructions, inst_cmova_r16_m16(dst, src)) } +emit_cmova_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { append(instructions, inst_cmova_r32_r32(dst, src)) } +emit_cmova_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32) { append(instructions, inst_cmova_r32_m32(dst, src)) } +emit_cmova_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { append(instructions, inst_cmova_r64_r64(dst, src)) } +emit_cmova_r64_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem64) { append(instructions, inst_cmova_r64_m64(dst, src)) } +inst_cmovae_r16_r16 :: #force_inline proc "contextless" (dst: GPR16, src: GPR16) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVAE, operand_count = 2, ops = {op_gpr16(dst), op_gpr16(src), {}, {}} }, 544) } +inst_cmovae_r16_m16 :: #force_inline proc "contextless" (dst: GPR16, src: Mem16) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVAE, operand_count = 2, ops = {op_gpr16(dst), op_mem(src.mem, 2), {}, {}} }, 544) } +inst_cmovae_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVAE, operand_count = 2, ops = {op_gpr32(dst), op_gpr32(src), {}, {}} }, 545) } +inst_cmovae_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVAE, operand_count = 2, ops = {op_gpr32(dst), op_mem(src.mem, 4), {}, {}} }, 545) } +inst_cmovae_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVAE, operand_count = 2, ops = {op_gpr64(dst), op_gpr64(src), {}, {}} }, 546) } +inst_cmovae_r64_m64 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVAE, operand_count = 2, ops = {op_gpr64(dst), op_mem(src.mem, 8), {}, {}} }, 546) } +emit_cmovae_r16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: GPR16) { append(instructions, inst_cmovae_r16_r16(dst, src)) } +emit_cmovae_r16_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: Mem16) { append(instructions, inst_cmovae_r16_m16(dst, src)) } +emit_cmovae_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { append(instructions, inst_cmovae_r32_r32(dst, src)) } +emit_cmovae_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32) { append(instructions, inst_cmovae_r32_m32(dst, src)) } +emit_cmovae_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { append(instructions, inst_cmovae_r64_r64(dst, src)) } +emit_cmovae_r64_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem64) { append(instructions, inst_cmovae_r64_m64(dst, src)) } +inst_cmovb_r16_r16 :: #force_inline proc "contextless" (dst: GPR16, src: GPR16) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVB, operand_count = 2, ops = {op_gpr16(dst), op_gpr16(src), {}, {}} }, 547) } +inst_cmovb_r16_m16 :: #force_inline proc "contextless" (dst: GPR16, src: Mem16) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVB, operand_count = 2, ops = {op_gpr16(dst), op_mem(src.mem, 2), {}, {}} }, 547) } +inst_cmovb_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVB, operand_count = 2, ops = {op_gpr32(dst), op_gpr32(src), {}, {}} }, 548) } +inst_cmovb_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVB, operand_count = 2, ops = {op_gpr32(dst), op_mem(src.mem, 4), {}, {}} }, 548) } +inst_cmovb_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVB, operand_count = 2, ops = {op_gpr64(dst), op_gpr64(src), {}, {}} }, 549) } +inst_cmovb_r64_m64 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVB, operand_count = 2, ops = {op_gpr64(dst), op_mem(src.mem, 8), {}, {}} }, 549) } +emit_cmovb_r16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: GPR16) { append(instructions, inst_cmovb_r16_r16(dst, src)) } +emit_cmovb_r16_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: Mem16) { append(instructions, inst_cmovb_r16_m16(dst, src)) } +emit_cmovb_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { append(instructions, inst_cmovb_r32_r32(dst, src)) } +emit_cmovb_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32) { append(instructions, inst_cmovb_r32_m32(dst, src)) } +emit_cmovb_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { append(instructions, inst_cmovb_r64_r64(dst, src)) } +emit_cmovb_r64_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem64) { append(instructions, inst_cmovb_r64_m64(dst, src)) } +inst_cmovbe_r16_r16 :: #force_inline proc "contextless" (dst: GPR16, src: GPR16) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVBE, operand_count = 2, ops = {op_gpr16(dst), op_gpr16(src), {}, {}} }, 550) } +inst_cmovbe_r16_m16 :: #force_inline proc "contextless" (dst: GPR16, src: Mem16) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVBE, operand_count = 2, ops = {op_gpr16(dst), op_mem(src.mem, 2), {}, {}} }, 550) } +inst_cmovbe_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVBE, operand_count = 2, ops = {op_gpr32(dst), op_gpr32(src), {}, {}} }, 551) } +inst_cmovbe_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVBE, operand_count = 2, ops = {op_gpr32(dst), op_mem(src.mem, 4), {}, {}} }, 551) } +inst_cmovbe_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVBE, operand_count = 2, ops = {op_gpr64(dst), op_gpr64(src), {}, {}} }, 552) } +inst_cmovbe_r64_m64 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVBE, operand_count = 2, ops = {op_gpr64(dst), op_mem(src.mem, 8), {}, {}} }, 552) } +emit_cmovbe_r16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: GPR16) { append(instructions, inst_cmovbe_r16_r16(dst, src)) } +emit_cmovbe_r16_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: Mem16) { append(instructions, inst_cmovbe_r16_m16(dst, src)) } +emit_cmovbe_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { append(instructions, inst_cmovbe_r32_r32(dst, src)) } +emit_cmovbe_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32) { append(instructions, inst_cmovbe_r32_m32(dst, src)) } +emit_cmovbe_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { append(instructions, inst_cmovbe_r64_r64(dst, src)) } +emit_cmovbe_r64_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem64) { append(instructions, inst_cmovbe_r64_m64(dst, src)) } +inst_cmovc_r16_r16 :: #force_inline proc "contextless" (dst: GPR16, src: GPR16) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVC, operand_count = 2, ops = {op_gpr16(dst), op_gpr16(src), {}, {}} }, 553) } +inst_cmovc_r16_m16 :: #force_inline proc "contextless" (dst: GPR16, src: Mem16) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVC, operand_count = 2, ops = {op_gpr16(dst), op_mem(src.mem, 2), {}, {}} }, 553) } +inst_cmovc_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVC, operand_count = 2, ops = {op_gpr32(dst), op_gpr32(src), {}, {}} }, 554) } +inst_cmovc_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVC, operand_count = 2, ops = {op_gpr32(dst), op_mem(src.mem, 4), {}, {}} }, 554) } +inst_cmovc_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVC, operand_count = 2, ops = {op_gpr64(dst), op_gpr64(src), {}, {}} }, 555) } +inst_cmovc_r64_m64 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVC, operand_count = 2, ops = {op_gpr64(dst), op_mem(src.mem, 8), {}, {}} }, 555) } +emit_cmovc_r16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: GPR16) { append(instructions, inst_cmovc_r16_r16(dst, src)) } +emit_cmovc_r16_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: Mem16) { append(instructions, inst_cmovc_r16_m16(dst, src)) } +emit_cmovc_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { append(instructions, inst_cmovc_r32_r32(dst, src)) } +emit_cmovc_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32) { append(instructions, inst_cmovc_r32_m32(dst, src)) } +emit_cmovc_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { append(instructions, inst_cmovc_r64_r64(dst, src)) } +emit_cmovc_r64_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem64) { append(instructions, inst_cmovc_r64_m64(dst, src)) } +inst_cmove_r16_r16 :: #force_inline proc "contextless" (dst: GPR16, src: GPR16) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVE, operand_count = 2, ops = {op_gpr16(dst), op_gpr16(src), {}, {}} }, 556) } +inst_cmove_r16_m16 :: #force_inline proc "contextless" (dst: GPR16, src: Mem16) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVE, operand_count = 2, ops = {op_gpr16(dst), op_mem(src.mem, 2), {}, {}} }, 556) } +inst_cmove_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVE, operand_count = 2, ops = {op_gpr32(dst), op_gpr32(src), {}, {}} }, 557) } +inst_cmove_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVE, operand_count = 2, ops = {op_gpr32(dst), op_mem(src.mem, 4), {}, {}} }, 557) } +inst_cmove_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVE, operand_count = 2, ops = {op_gpr64(dst), op_gpr64(src), {}, {}} }, 558) } +inst_cmove_r64_m64 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVE, operand_count = 2, ops = {op_gpr64(dst), op_mem(src.mem, 8), {}, {}} }, 558) } +emit_cmove_r16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: GPR16) { append(instructions, inst_cmove_r16_r16(dst, src)) } +emit_cmove_r16_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: Mem16) { append(instructions, inst_cmove_r16_m16(dst, src)) } +emit_cmove_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { append(instructions, inst_cmove_r32_r32(dst, src)) } +emit_cmove_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32) { append(instructions, inst_cmove_r32_m32(dst, src)) } +emit_cmove_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { append(instructions, inst_cmove_r64_r64(dst, src)) } +emit_cmove_r64_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem64) { append(instructions, inst_cmove_r64_m64(dst, src)) } +inst_cmovg_r16_r16 :: #force_inline proc "contextless" (dst: GPR16, src: GPR16) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVG, operand_count = 2, ops = {op_gpr16(dst), op_gpr16(src), {}, {}} }, 559) } +inst_cmovg_r16_m16 :: #force_inline proc "contextless" (dst: GPR16, src: Mem16) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVG, operand_count = 2, ops = {op_gpr16(dst), op_mem(src.mem, 2), {}, {}} }, 559) } +inst_cmovg_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVG, operand_count = 2, ops = {op_gpr32(dst), op_gpr32(src), {}, {}} }, 560) } +inst_cmovg_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVG, operand_count = 2, ops = {op_gpr32(dst), op_mem(src.mem, 4), {}, {}} }, 560) } +inst_cmovg_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVG, operand_count = 2, ops = {op_gpr64(dst), op_gpr64(src), {}, {}} }, 561) } +inst_cmovg_r64_m64 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVG, operand_count = 2, ops = {op_gpr64(dst), op_mem(src.mem, 8), {}, {}} }, 561) } +emit_cmovg_r16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: GPR16) { append(instructions, inst_cmovg_r16_r16(dst, src)) } +emit_cmovg_r16_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: Mem16) { append(instructions, inst_cmovg_r16_m16(dst, src)) } +emit_cmovg_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { append(instructions, inst_cmovg_r32_r32(dst, src)) } +emit_cmovg_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32) { append(instructions, inst_cmovg_r32_m32(dst, src)) } +emit_cmovg_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { append(instructions, inst_cmovg_r64_r64(dst, src)) } +emit_cmovg_r64_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem64) { append(instructions, inst_cmovg_r64_m64(dst, src)) } +inst_cmovge_r16_r16 :: #force_inline proc "contextless" (dst: GPR16, src: GPR16) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVGE, operand_count = 2, ops = {op_gpr16(dst), op_gpr16(src), {}, {}} }, 562) } +inst_cmovge_r16_m16 :: #force_inline proc "contextless" (dst: GPR16, src: Mem16) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVGE, operand_count = 2, ops = {op_gpr16(dst), op_mem(src.mem, 2), {}, {}} }, 562) } +inst_cmovge_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVGE, operand_count = 2, ops = {op_gpr32(dst), op_gpr32(src), {}, {}} }, 563) } +inst_cmovge_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVGE, operand_count = 2, ops = {op_gpr32(dst), op_mem(src.mem, 4), {}, {}} }, 563) } +inst_cmovge_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVGE, operand_count = 2, ops = {op_gpr64(dst), op_gpr64(src), {}, {}} }, 564) } +inst_cmovge_r64_m64 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVGE, operand_count = 2, ops = {op_gpr64(dst), op_mem(src.mem, 8), {}, {}} }, 564) } +emit_cmovge_r16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: GPR16) { append(instructions, inst_cmovge_r16_r16(dst, src)) } +emit_cmovge_r16_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: Mem16) { append(instructions, inst_cmovge_r16_m16(dst, src)) } +emit_cmovge_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { append(instructions, inst_cmovge_r32_r32(dst, src)) } +emit_cmovge_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32) { append(instructions, inst_cmovge_r32_m32(dst, src)) } +emit_cmovge_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { append(instructions, inst_cmovge_r64_r64(dst, src)) } +emit_cmovge_r64_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem64) { append(instructions, inst_cmovge_r64_m64(dst, src)) } +inst_cmovl_r16_r16 :: #force_inline proc "contextless" (dst: GPR16, src: GPR16) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVL, operand_count = 2, ops = {op_gpr16(dst), op_gpr16(src), {}, {}} }, 565) } +inst_cmovl_r16_m16 :: #force_inline proc "contextless" (dst: GPR16, src: Mem16) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVL, operand_count = 2, ops = {op_gpr16(dst), op_mem(src.mem, 2), {}, {}} }, 565) } +inst_cmovl_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVL, operand_count = 2, ops = {op_gpr32(dst), op_gpr32(src), {}, {}} }, 566) } +inst_cmovl_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVL, operand_count = 2, ops = {op_gpr32(dst), op_mem(src.mem, 4), {}, {}} }, 566) } +inst_cmovl_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVL, operand_count = 2, ops = {op_gpr64(dst), op_gpr64(src), {}, {}} }, 567) } +inst_cmovl_r64_m64 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVL, operand_count = 2, ops = {op_gpr64(dst), op_mem(src.mem, 8), {}, {}} }, 567) } +emit_cmovl_r16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: GPR16) { append(instructions, inst_cmovl_r16_r16(dst, src)) } +emit_cmovl_r16_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: Mem16) { append(instructions, inst_cmovl_r16_m16(dst, src)) } +emit_cmovl_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { append(instructions, inst_cmovl_r32_r32(dst, src)) } +emit_cmovl_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32) { append(instructions, inst_cmovl_r32_m32(dst, src)) } +emit_cmovl_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { append(instructions, inst_cmovl_r64_r64(dst, src)) } +emit_cmovl_r64_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem64) { append(instructions, inst_cmovl_r64_m64(dst, src)) } +inst_cmovle_r16_r16 :: #force_inline proc "contextless" (dst: GPR16, src: GPR16) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVLE, operand_count = 2, ops = {op_gpr16(dst), op_gpr16(src), {}, {}} }, 568) } +inst_cmovle_r16_m16 :: #force_inline proc "contextless" (dst: GPR16, src: Mem16) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVLE, operand_count = 2, ops = {op_gpr16(dst), op_mem(src.mem, 2), {}, {}} }, 568) } +inst_cmovle_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVLE, operand_count = 2, ops = {op_gpr32(dst), op_gpr32(src), {}, {}} }, 569) } +inst_cmovle_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVLE, operand_count = 2, ops = {op_gpr32(dst), op_mem(src.mem, 4), {}, {}} }, 569) } +inst_cmovle_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVLE, operand_count = 2, ops = {op_gpr64(dst), op_gpr64(src), {}, {}} }, 570) } +inst_cmovle_r64_m64 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVLE, operand_count = 2, ops = {op_gpr64(dst), op_mem(src.mem, 8), {}, {}} }, 570) } +emit_cmovle_r16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: GPR16) { append(instructions, inst_cmovle_r16_r16(dst, src)) } +emit_cmovle_r16_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: Mem16) { append(instructions, inst_cmovle_r16_m16(dst, src)) } +emit_cmovle_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { append(instructions, inst_cmovle_r32_r32(dst, src)) } +emit_cmovle_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32) { append(instructions, inst_cmovle_r32_m32(dst, src)) } +emit_cmovle_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { append(instructions, inst_cmovle_r64_r64(dst, src)) } +emit_cmovle_r64_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem64) { append(instructions, inst_cmovle_r64_m64(dst, src)) } +inst_cmovna_r16_r16 :: #force_inline proc "contextless" (dst: GPR16, src: GPR16) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVNA, operand_count = 2, ops = {op_gpr16(dst), op_gpr16(src), {}, {}} }, 571) } +inst_cmovna_r16_m16 :: #force_inline proc "contextless" (dst: GPR16, src: Mem16) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVNA, operand_count = 2, ops = {op_gpr16(dst), op_mem(src.mem, 2), {}, {}} }, 571) } +inst_cmovna_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVNA, operand_count = 2, ops = {op_gpr32(dst), op_gpr32(src), {}, {}} }, 572) } +inst_cmovna_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVNA, operand_count = 2, ops = {op_gpr32(dst), op_mem(src.mem, 4), {}, {}} }, 572) } +inst_cmovna_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVNA, operand_count = 2, ops = {op_gpr64(dst), op_gpr64(src), {}, {}} }, 573) } +inst_cmovna_r64_m64 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVNA, operand_count = 2, ops = {op_gpr64(dst), op_mem(src.mem, 8), {}, {}} }, 573) } +emit_cmovna_r16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: GPR16) { append(instructions, inst_cmovna_r16_r16(dst, src)) } +emit_cmovna_r16_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: Mem16) { append(instructions, inst_cmovna_r16_m16(dst, src)) } +emit_cmovna_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { append(instructions, inst_cmovna_r32_r32(dst, src)) } +emit_cmovna_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32) { append(instructions, inst_cmovna_r32_m32(dst, src)) } +emit_cmovna_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { append(instructions, inst_cmovna_r64_r64(dst, src)) } +emit_cmovna_r64_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem64) { append(instructions, inst_cmovna_r64_m64(dst, src)) } +inst_cmovnae_r16_r16 :: #force_inline proc "contextless" (dst: GPR16, src: GPR16) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVNAE, operand_count = 2, ops = {op_gpr16(dst), op_gpr16(src), {}, {}} }, 574) } +inst_cmovnae_r16_m16 :: #force_inline proc "contextless" (dst: GPR16, src: Mem16) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVNAE, operand_count = 2, ops = {op_gpr16(dst), op_mem(src.mem, 2), {}, {}} }, 574) } +inst_cmovnae_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVNAE, operand_count = 2, ops = {op_gpr32(dst), op_gpr32(src), {}, {}} }, 575) } +inst_cmovnae_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVNAE, operand_count = 2, ops = {op_gpr32(dst), op_mem(src.mem, 4), {}, {}} }, 575) } +inst_cmovnae_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVNAE, operand_count = 2, ops = {op_gpr64(dst), op_gpr64(src), {}, {}} }, 576) } +inst_cmovnae_r64_m64 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVNAE, operand_count = 2, ops = {op_gpr64(dst), op_mem(src.mem, 8), {}, {}} }, 576) } +emit_cmovnae_r16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: GPR16) { append(instructions, inst_cmovnae_r16_r16(dst, src)) } +emit_cmovnae_r16_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: Mem16) { append(instructions, inst_cmovnae_r16_m16(dst, src)) } +emit_cmovnae_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { append(instructions, inst_cmovnae_r32_r32(dst, src)) } +emit_cmovnae_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32) { append(instructions, inst_cmovnae_r32_m32(dst, src)) } +emit_cmovnae_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { append(instructions, inst_cmovnae_r64_r64(dst, src)) } +emit_cmovnae_r64_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem64) { append(instructions, inst_cmovnae_r64_m64(dst, src)) } +inst_cmovnb_r16_r16 :: #force_inline proc "contextless" (dst: GPR16, src: GPR16) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVNB, operand_count = 2, ops = {op_gpr16(dst), op_gpr16(src), {}, {}} }, 577) } +inst_cmovnb_r16_m16 :: #force_inline proc "contextless" (dst: GPR16, src: Mem16) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVNB, operand_count = 2, ops = {op_gpr16(dst), op_mem(src.mem, 2), {}, {}} }, 577) } +inst_cmovnb_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVNB, operand_count = 2, ops = {op_gpr32(dst), op_gpr32(src), {}, {}} }, 578) } +inst_cmovnb_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVNB, operand_count = 2, ops = {op_gpr32(dst), op_mem(src.mem, 4), {}, {}} }, 578) } +inst_cmovnb_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVNB, operand_count = 2, ops = {op_gpr64(dst), op_gpr64(src), {}, {}} }, 579) } +inst_cmovnb_r64_m64 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVNB, operand_count = 2, ops = {op_gpr64(dst), op_mem(src.mem, 8), {}, {}} }, 579) } +emit_cmovnb_r16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: GPR16) { append(instructions, inst_cmovnb_r16_r16(dst, src)) } +emit_cmovnb_r16_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: Mem16) { append(instructions, inst_cmovnb_r16_m16(dst, src)) } +emit_cmovnb_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { append(instructions, inst_cmovnb_r32_r32(dst, src)) } +emit_cmovnb_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32) { append(instructions, inst_cmovnb_r32_m32(dst, src)) } +emit_cmovnb_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { append(instructions, inst_cmovnb_r64_r64(dst, src)) } +emit_cmovnb_r64_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem64) { append(instructions, inst_cmovnb_r64_m64(dst, src)) } +inst_cmovnbe_r16_r16 :: #force_inline proc "contextless" (dst: GPR16, src: GPR16) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVNBE, operand_count = 2, ops = {op_gpr16(dst), op_gpr16(src), {}, {}} }, 580) } +inst_cmovnbe_r16_m16 :: #force_inline proc "contextless" (dst: GPR16, src: Mem16) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVNBE, operand_count = 2, ops = {op_gpr16(dst), op_mem(src.mem, 2), {}, {}} }, 580) } +inst_cmovnbe_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVNBE, operand_count = 2, ops = {op_gpr32(dst), op_gpr32(src), {}, {}} }, 581) } +inst_cmovnbe_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVNBE, operand_count = 2, ops = {op_gpr32(dst), op_mem(src.mem, 4), {}, {}} }, 581) } +inst_cmovnbe_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVNBE, operand_count = 2, ops = {op_gpr64(dst), op_gpr64(src), {}, {}} }, 582) } +inst_cmovnbe_r64_m64 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVNBE, operand_count = 2, ops = {op_gpr64(dst), op_mem(src.mem, 8), {}, {}} }, 582) } +emit_cmovnbe_r16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: GPR16) { append(instructions, inst_cmovnbe_r16_r16(dst, src)) } +emit_cmovnbe_r16_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: Mem16) { append(instructions, inst_cmovnbe_r16_m16(dst, src)) } +emit_cmovnbe_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { append(instructions, inst_cmovnbe_r32_r32(dst, src)) } +emit_cmovnbe_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32) { append(instructions, inst_cmovnbe_r32_m32(dst, src)) } +emit_cmovnbe_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { append(instructions, inst_cmovnbe_r64_r64(dst, src)) } +emit_cmovnbe_r64_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem64) { append(instructions, inst_cmovnbe_r64_m64(dst, src)) } +inst_cmovnc_r16_r16 :: #force_inline proc "contextless" (dst: GPR16, src: GPR16) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVNC, operand_count = 2, ops = {op_gpr16(dst), op_gpr16(src), {}, {}} }, 583) } +inst_cmovnc_r16_m16 :: #force_inline proc "contextless" (dst: GPR16, src: Mem16) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVNC, operand_count = 2, ops = {op_gpr16(dst), op_mem(src.mem, 2), {}, {}} }, 583) } +inst_cmovnc_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVNC, operand_count = 2, ops = {op_gpr32(dst), op_gpr32(src), {}, {}} }, 584) } +inst_cmovnc_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVNC, operand_count = 2, ops = {op_gpr32(dst), op_mem(src.mem, 4), {}, {}} }, 584) } +inst_cmovnc_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVNC, operand_count = 2, ops = {op_gpr64(dst), op_gpr64(src), {}, {}} }, 585) } +inst_cmovnc_r64_m64 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVNC, operand_count = 2, ops = {op_gpr64(dst), op_mem(src.mem, 8), {}, {}} }, 585) } +emit_cmovnc_r16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: GPR16) { append(instructions, inst_cmovnc_r16_r16(dst, src)) } +emit_cmovnc_r16_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: Mem16) { append(instructions, inst_cmovnc_r16_m16(dst, src)) } +emit_cmovnc_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { append(instructions, inst_cmovnc_r32_r32(dst, src)) } +emit_cmovnc_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32) { append(instructions, inst_cmovnc_r32_m32(dst, src)) } +emit_cmovnc_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { append(instructions, inst_cmovnc_r64_r64(dst, src)) } +emit_cmovnc_r64_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem64) { append(instructions, inst_cmovnc_r64_m64(dst, src)) } +inst_cmovne_r16_r16 :: #force_inline proc "contextless" (dst: GPR16, src: GPR16) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVNE, operand_count = 2, ops = {op_gpr16(dst), op_gpr16(src), {}, {}} }, 586) } +inst_cmovne_r16_m16 :: #force_inline proc "contextless" (dst: GPR16, src: Mem16) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVNE, operand_count = 2, ops = {op_gpr16(dst), op_mem(src.mem, 2), {}, {}} }, 586) } +inst_cmovne_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVNE, operand_count = 2, ops = {op_gpr32(dst), op_gpr32(src), {}, {}} }, 587) } +inst_cmovne_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVNE, operand_count = 2, ops = {op_gpr32(dst), op_mem(src.mem, 4), {}, {}} }, 587) } +inst_cmovne_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVNE, operand_count = 2, ops = {op_gpr64(dst), op_gpr64(src), {}, {}} }, 588) } +inst_cmovne_r64_m64 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVNE, operand_count = 2, ops = {op_gpr64(dst), op_mem(src.mem, 8), {}, {}} }, 588) } +emit_cmovne_r16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: GPR16) { append(instructions, inst_cmovne_r16_r16(dst, src)) } +emit_cmovne_r16_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: Mem16) { append(instructions, inst_cmovne_r16_m16(dst, src)) } +emit_cmovne_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { append(instructions, inst_cmovne_r32_r32(dst, src)) } +emit_cmovne_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32) { append(instructions, inst_cmovne_r32_m32(dst, src)) } +emit_cmovne_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { append(instructions, inst_cmovne_r64_r64(dst, src)) } +emit_cmovne_r64_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem64) { append(instructions, inst_cmovne_r64_m64(dst, src)) } +inst_cmovng_r16_r16 :: #force_inline proc "contextless" (dst: GPR16, src: GPR16) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVNG, operand_count = 2, ops = {op_gpr16(dst), op_gpr16(src), {}, {}} }, 589) } +inst_cmovng_r16_m16 :: #force_inline proc "contextless" (dst: GPR16, src: Mem16) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVNG, operand_count = 2, ops = {op_gpr16(dst), op_mem(src.mem, 2), {}, {}} }, 589) } +inst_cmovng_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVNG, operand_count = 2, ops = {op_gpr32(dst), op_gpr32(src), {}, {}} }, 590) } +inst_cmovng_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVNG, operand_count = 2, ops = {op_gpr32(dst), op_mem(src.mem, 4), {}, {}} }, 590) } +inst_cmovng_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVNG, operand_count = 2, ops = {op_gpr64(dst), op_gpr64(src), {}, {}} }, 591) } +inst_cmovng_r64_m64 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVNG, operand_count = 2, ops = {op_gpr64(dst), op_mem(src.mem, 8), {}, {}} }, 591) } +emit_cmovng_r16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: GPR16) { append(instructions, inst_cmovng_r16_r16(dst, src)) } +emit_cmovng_r16_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: Mem16) { append(instructions, inst_cmovng_r16_m16(dst, src)) } +emit_cmovng_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { append(instructions, inst_cmovng_r32_r32(dst, src)) } +emit_cmovng_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32) { append(instructions, inst_cmovng_r32_m32(dst, src)) } +emit_cmovng_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { append(instructions, inst_cmovng_r64_r64(dst, src)) } +emit_cmovng_r64_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem64) { append(instructions, inst_cmovng_r64_m64(dst, src)) } +inst_cmovnge_r16_r16 :: #force_inline proc "contextless" (dst: GPR16, src: GPR16) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVNGE, operand_count = 2, ops = {op_gpr16(dst), op_gpr16(src), {}, {}} }, 592) } +inst_cmovnge_r16_m16 :: #force_inline proc "contextless" (dst: GPR16, src: Mem16) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVNGE, operand_count = 2, ops = {op_gpr16(dst), op_mem(src.mem, 2), {}, {}} }, 592) } +inst_cmovnge_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVNGE, operand_count = 2, ops = {op_gpr32(dst), op_gpr32(src), {}, {}} }, 593) } +inst_cmovnge_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVNGE, operand_count = 2, ops = {op_gpr32(dst), op_mem(src.mem, 4), {}, {}} }, 593) } +inst_cmovnge_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVNGE, operand_count = 2, ops = {op_gpr64(dst), op_gpr64(src), {}, {}} }, 594) } +inst_cmovnge_r64_m64 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVNGE, operand_count = 2, ops = {op_gpr64(dst), op_mem(src.mem, 8), {}, {}} }, 594) } +emit_cmovnge_r16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: GPR16) { append(instructions, inst_cmovnge_r16_r16(dst, src)) } +emit_cmovnge_r16_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: Mem16) { append(instructions, inst_cmovnge_r16_m16(dst, src)) } +emit_cmovnge_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { append(instructions, inst_cmovnge_r32_r32(dst, src)) } +emit_cmovnge_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32) { append(instructions, inst_cmovnge_r32_m32(dst, src)) } +emit_cmovnge_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { append(instructions, inst_cmovnge_r64_r64(dst, src)) } +emit_cmovnge_r64_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem64) { append(instructions, inst_cmovnge_r64_m64(dst, src)) } +inst_cmovnl_r16_r16 :: #force_inline proc "contextless" (dst: GPR16, src: GPR16) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVNL, operand_count = 2, ops = {op_gpr16(dst), op_gpr16(src), {}, {}} }, 595) } +inst_cmovnl_r16_m16 :: #force_inline proc "contextless" (dst: GPR16, src: Mem16) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVNL, operand_count = 2, ops = {op_gpr16(dst), op_mem(src.mem, 2), {}, {}} }, 595) } +inst_cmovnl_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVNL, operand_count = 2, ops = {op_gpr32(dst), op_gpr32(src), {}, {}} }, 596) } +inst_cmovnl_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVNL, operand_count = 2, ops = {op_gpr32(dst), op_mem(src.mem, 4), {}, {}} }, 596) } +inst_cmovnl_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVNL, operand_count = 2, ops = {op_gpr64(dst), op_gpr64(src), {}, {}} }, 597) } +inst_cmovnl_r64_m64 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVNL, operand_count = 2, ops = {op_gpr64(dst), op_mem(src.mem, 8), {}, {}} }, 597) } +emit_cmovnl_r16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: GPR16) { append(instructions, inst_cmovnl_r16_r16(dst, src)) } +emit_cmovnl_r16_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: Mem16) { append(instructions, inst_cmovnl_r16_m16(dst, src)) } +emit_cmovnl_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { append(instructions, inst_cmovnl_r32_r32(dst, src)) } +emit_cmovnl_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32) { append(instructions, inst_cmovnl_r32_m32(dst, src)) } +emit_cmovnl_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { append(instructions, inst_cmovnl_r64_r64(dst, src)) } +emit_cmovnl_r64_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem64) { append(instructions, inst_cmovnl_r64_m64(dst, src)) } +inst_cmovnle_r16_r16 :: #force_inline proc "contextless" (dst: GPR16, src: GPR16) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVNLE, operand_count = 2, ops = {op_gpr16(dst), op_gpr16(src), {}, {}} }, 598) } +inst_cmovnle_r16_m16 :: #force_inline proc "contextless" (dst: GPR16, src: Mem16) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVNLE, operand_count = 2, ops = {op_gpr16(dst), op_mem(src.mem, 2), {}, {}} }, 598) } +inst_cmovnle_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVNLE, operand_count = 2, ops = {op_gpr32(dst), op_gpr32(src), {}, {}} }, 599) } +inst_cmovnle_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVNLE, operand_count = 2, ops = {op_gpr32(dst), op_mem(src.mem, 4), {}, {}} }, 599) } +inst_cmovnle_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVNLE, operand_count = 2, ops = {op_gpr64(dst), op_gpr64(src), {}, {}} }, 600) } +inst_cmovnle_r64_m64 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVNLE, operand_count = 2, ops = {op_gpr64(dst), op_mem(src.mem, 8), {}, {}} }, 600) } +emit_cmovnle_r16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: GPR16) { append(instructions, inst_cmovnle_r16_r16(dst, src)) } +emit_cmovnle_r16_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: Mem16) { append(instructions, inst_cmovnle_r16_m16(dst, src)) } +emit_cmovnle_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { append(instructions, inst_cmovnle_r32_r32(dst, src)) } +emit_cmovnle_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32) { append(instructions, inst_cmovnle_r32_m32(dst, src)) } +emit_cmovnle_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { append(instructions, inst_cmovnle_r64_r64(dst, src)) } +emit_cmovnle_r64_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem64) { append(instructions, inst_cmovnle_r64_m64(dst, src)) } +inst_cmovno_r16_r16 :: #force_inline proc "contextless" (dst: GPR16, src: GPR16) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVNO, operand_count = 2, ops = {op_gpr16(dst), op_gpr16(src), {}, {}} }, 601) } +inst_cmovno_r16_m16 :: #force_inline proc "contextless" (dst: GPR16, src: Mem16) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVNO, operand_count = 2, ops = {op_gpr16(dst), op_mem(src.mem, 2), {}, {}} }, 601) } +inst_cmovno_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVNO, operand_count = 2, ops = {op_gpr32(dst), op_gpr32(src), {}, {}} }, 602) } +inst_cmovno_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVNO, operand_count = 2, ops = {op_gpr32(dst), op_mem(src.mem, 4), {}, {}} }, 602) } +inst_cmovno_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVNO, operand_count = 2, ops = {op_gpr64(dst), op_gpr64(src), {}, {}} }, 603) } +inst_cmovno_r64_m64 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVNO, operand_count = 2, ops = {op_gpr64(dst), op_mem(src.mem, 8), {}, {}} }, 603) } +emit_cmovno_r16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: GPR16) { append(instructions, inst_cmovno_r16_r16(dst, src)) } +emit_cmovno_r16_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: Mem16) { append(instructions, inst_cmovno_r16_m16(dst, src)) } +emit_cmovno_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { append(instructions, inst_cmovno_r32_r32(dst, src)) } +emit_cmovno_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32) { append(instructions, inst_cmovno_r32_m32(dst, src)) } +emit_cmovno_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { append(instructions, inst_cmovno_r64_r64(dst, src)) } +emit_cmovno_r64_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem64) { append(instructions, inst_cmovno_r64_m64(dst, src)) } +inst_cmovnp_r16_r16 :: #force_inline proc "contextless" (dst: GPR16, src: GPR16) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVNP, operand_count = 2, ops = {op_gpr16(dst), op_gpr16(src), {}, {}} }, 604) } +inst_cmovnp_r16_m16 :: #force_inline proc "contextless" (dst: GPR16, src: Mem16) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVNP, operand_count = 2, ops = {op_gpr16(dst), op_mem(src.mem, 2), {}, {}} }, 604) } +inst_cmovnp_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVNP, operand_count = 2, ops = {op_gpr32(dst), op_gpr32(src), {}, {}} }, 605) } +inst_cmovnp_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVNP, operand_count = 2, ops = {op_gpr32(dst), op_mem(src.mem, 4), {}, {}} }, 605) } +inst_cmovnp_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVNP, operand_count = 2, ops = {op_gpr64(dst), op_gpr64(src), {}, {}} }, 606) } +inst_cmovnp_r64_m64 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVNP, operand_count = 2, ops = {op_gpr64(dst), op_mem(src.mem, 8), {}, {}} }, 606) } +emit_cmovnp_r16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: GPR16) { append(instructions, inst_cmovnp_r16_r16(dst, src)) } +emit_cmovnp_r16_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: Mem16) { append(instructions, inst_cmovnp_r16_m16(dst, src)) } +emit_cmovnp_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { append(instructions, inst_cmovnp_r32_r32(dst, src)) } +emit_cmovnp_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32) { append(instructions, inst_cmovnp_r32_m32(dst, src)) } +emit_cmovnp_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { append(instructions, inst_cmovnp_r64_r64(dst, src)) } +emit_cmovnp_r64_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem64) { append(instructions, inst_cmovnp_r64_m64(dst, src)) } +inst_cmovns_r16_r16 :: #force_inline proc "contextless" (dst: GPR16, src: GPR16) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVNS, operand_count = 2, ops = {op_gpr16(dst), op_gpr16(src), {}, {}} }, 607) } +inst_cmovns_r16_m16 :: #force_inline proc "contextless" (dst: GPR16, src: Mem16) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVNS, operand_count = 2, ops = {op_gpr16(dst), op_mem(src.mem, 2), {}, {}} }, 607) } +inst_cmovns_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVNS, operand_count = 2, ops = {op_gpr32(dst), op_gpr32(src), {}, {}} }, 608) } +inst_cmovns_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVNS, operand_count = 2, ops = {op_gpr32(dst), op_mem(src.mem, 4), {}, {}} }, 608) } +inst_cmovns_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVNS, operand_count = 2, ops = {op_gpr64(dst), op_gpr64(src), {}, {}} }, 609) } +inst_cmovns_r64_m64 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVNS, operand_count = 2, ops = {op_gpr64(dst), op_mem(src.mem, 8), {}, {}} }, 609) } +emit_cmovns_r16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: GPR16) { append(instructions, inst_cmovns_r16_r16(dst, src)) } +emit_cmovns_r16_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: Mem16) { append(instructions, inst_cmovns_r16_m16(dst, src)) } +emit_cmovns_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { append(instructions, inst_cmovns_r32_r32(dst, src)) } +emit_cmovns_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32) { append(instructions, inst_cmovns_r32_m32(dst, src)) } +emit_cmovns_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { append(instructions, inst_cmovns_r64_r64(dst, src)) } +emit_cmovns_r64_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem64) { append(instructions, inst_cmovns_r64_m64(dst, src)) } +inst_cmovnz_r16_r16 :: #force_inline proc "contextless" (dst: GPR16, src: GPR16) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVNZ, operand_count = 2, ops = {op_gpr16(dst), op_gpr16(src), {}, {}} }, 610) } +inst_cmovnz_r16_m16 :: #force_inline proc "contextless" (dst: GPR16, src: Mem16) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVNZ, operand_count = 2, ops = {op_gpr16(dst), op_mem(src.mem, 2), {}, {}} }, 610) } +inst_cmovnz_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVNZ, operand_count = 2, ops = {op_gpr32(dst), op_gpr32(src), {}, {}} }, 611) } +inst_cmovnz_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVNZ, operand_count = 2, ops = {op_gpr32(dst), op_mem(src.mem, 4), {}, {}} }, 611) } +inst_cmovnz_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVNZ, operand_count = 2, ops = {op_gpr64(dst), op_gpr64(src), {}, {}} }, 612) } +inst_cmovnz_r64_m64 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVNZ, operand_count = 2, ops = {op_gpr64(dst), op_mem(src.mem, 8), {}, {}} }, 612) } +emit_cmovnz_r16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: GPR16) { append(instructions, inst_cmovnz_r16_r16(dst, src)) } +emit_cmovnz_r16_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: Mem16) { append(instructions, inst_cmovnz_r16_m16(dst, src)) } +emit_cmovnz_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { append(instructions, inst_cmovnz_r32_r32(dst, src)) } +emit_cmovnz_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32) { append(instructions, inst_cmovnz_r32_m32(dst, src)) } +emit_cmovnz_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { append(instructions, inst_cmovnz_r64_r64(dst, src)) } +emit_cmovnz_r64_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem64) { append(instructions, inst_cmovnz_r64_m64(dst, src)) } +inst_cmovo_r16_r16 :: #force_inline proc "contextless" (dst: GPR16, src: GPR16) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVO, operand_count = 2, ops = {op_gpr16(dst), op_gpr16(src), {}, {}} }, 613) } +inst_cmovo_r16_m16 :: #force_inline proc "contextless" (dst: GPR16, src: Mem16) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVO, operand_count = 2, ops = {op_gpr16(dst), op_mem(src.mem, 2), {}, {}} }, 613) } +inst_cmovo_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVO, operand_count = 2, ops = {op_gpr32(dst), op_gpr32(src), {}, {}} }, 614) } +inst_cmovo_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVO, operand_count = 2, ops = {op_gpr32(dst), op_mem(src.mem, 4), {}, {}} }, 614) } +inst_cmovo_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVO, operand_count = 2, ops = {op_gpr64(dst), op_gpr64(src), {}, {}} }, 615) } +inst_cmovo_r64_m64 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVO, operand_count = 2, ops = {op_gpr64(dst), op_mem(src.mem, 8), {}, {}} }, 615) } +emit_cmovo_r16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: GPR16) { append(instructions, inst_cmovo_r16_r16(dst, src)) } +emit_cmovo_r16_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: Mem16) { append(instructions, inst_cmovo_r16_m16(dst, src)) } +emit_cmovo_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { append(instructions, inst_cmovo_r32_r32(dst, src)) } +emit_cmovo_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32) { append(instructions, inst_cmovo_r32_m32(dst, src)) } +emit_cmovo_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { append(instructions, inst_cmovo_r64_r64(dst, src)) } +emit_cmovo_r64_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem64) { append(instructions, inst_cmovo_r64_m64(dst, src)) } +inst_cmovp_r16_r16 :: #force_inline proc "contextless" (dst: GPR16, src: GPR16) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVP, operand_count = 2, ops = {op_gpr16(dst), op_gpr16(src), {}, {}} }, 616) } +inst_cmovp_r16_m16 :: #force_inline proc "contextless" (dst: GPR16, src: Mem16) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVP, operand_count = 2, ops = {op_gpr16(dst), op_mem(src.mem, 2), {}, {}} }, 616) } +inst_cmovp_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVP, operand_count = 2, ops = {op_gpr32(dst), op_gpr32(src), {}, {}} }, 617) } +inst_cmovp_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVP, operand_count = 2, ops = {op_gpr32(dst), op_mem(src.mem, 4), {}, {}} }, 617) } +inst_cmovp_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVP, operand_count = 2, ops = {op_gpr64(dst), op_gpr64(src), {}, {}} }, 618) } +inst_cmovp_r64_m64 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVP, operand_count = 2, ops = {op_gpr64(dst), op_mem(src.mem, 8), {}, {}} }, 618) } +emit_cmovp_r16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: GPR16) { append(instructions, inst_cmovp_r16_r16(dst, src)) } +emit_cmovp_r16_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: Mem16) { append(instructions, inst_cmovp_r16_m16(dst, src)) } +emit_cmovp_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { append(instructions, inst_cmovp_r32_r32(dst, src)) } +emit_cmovp_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32) { append(instructions, inst_cmovp_r32_m32(dst, src)) } +emit_cmovp_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { append(instructions, inst_cmovp_r64_r64(dst, src)) } +emit_cmovp_r64_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem64) { append(instructions, inst_cmovp_r64_m64(dst, src)) } +inst_cmovpe_r16_r16 :: #force_inline proc "contextless" (dst: GPR16, src: GPR16) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVPE, operand_count = 2, ops = {op_gpr16(dst), op_gpr16(src), {}, {}} }, 619) } +inst_cmovpe_r16_m16 :: #force_inline proc "contextless" (dst: GPR16, src: Mem16) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVPE, operand_count = 2, ops = {op_gpr16(dst), op_mem(src.mem, 2), {}, {}} }, 619) } +inst_cmovpe_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVPE, operand_count = 2, ops = {op_gpr32(dst), op_gpr32(src), {}, {}} }, 620) } +inst_cmovpe_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVPE, operand_count = 2, ops = {op_gpr32(dst), op_mem(src.mem, 4), {}, {}} }, 620) } +inst_cmovpe_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVPE, operand_count = 2, ops = {op_gpr64(dst), op_gpr64(src), {}, {}} }, 621) } +inst_cmovpe_r64_m64 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVPE, operand_count = 2, ops = {op_gpr64(dst), op_mem(src.mem, 8), {}, {}} }, 621) } +emit_cmovpe_r16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: GPR16) { append(instructions, inst_cmovpe_r16_r16(dst, src)) } +emit_cmovpe_r16_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: Mem16) { append(instructions, inst_cmovpe_r16_m16(dst, src)) } +emit_cmovpe_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { append(instructions, inst_cmovpe_r32_r32(dst, src)) } +emit_cmovpe_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32) { append(instructions, inst_cmovpe_r32_m32(dst, src)) } +emit_cmovpe_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { append(instructions, inst_cmovpe_r64_r64(dst, src)) } +emit_cmovpe_r64_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem64) { append(instructions, inst_cmovpe_r64_m64(dst, src)) } +inst_cmovpo_r16_r16 :: #force_inline proc "contextless" (dst: GPR16, src: GPR16) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVPO, operand_count = 2, ops = {op_gpr16(dst), op_gpr16(src), {}, {}} }, 622) } +inst_cmovpo_r16_m16 :: #force_inline proc "contextless" (dst: GPR16, src: Mem16) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVPO, operand_count = 2, ops = {op_gpr16(dst), op_mem(src.mem, 2), {}, {}} }, 622) } +inst_cmovpo_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVPO, operand_count = 2, ops = {op_gpr32(dst), op_gpr32(src), {}, {}} }, 623) } +inst_cmovpo_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVPO, operand_count = 2, ops = {op_gpr32(dst), op_mem(src.mem, 4), {}, {}} }, 623) } +inst_cmovpo_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVPO, operand_count = 2, ops = {op_gpr64(dst), op_gpr64(src), {}, {}} }, 624) } +inst_cmovpo_r64_m64 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVPO, operand_count = 2, ops = {op_gpr64(dst), op_mem(src.mem, 8), {}, {}} }, 624) } +emit_cmovpo_r16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: GPR16) { append(instructions, inst_cmovpo_r16_r16(dst, src)) } +emit_cmovpo_r16_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: Mem16) { append(instructions, inst_cmovpo_r16_m16(dst, src)) } +emit_cmovpo_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { append(instructions, inst_cmovpo_r32_r32(dst, src)) } +emit_cmovpo_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32) { append(instructions, inst_cmovpo_r32_m32(dst, src)) } +emit_cmovpo_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { append(instructions, inst_cmovpo_r64_r64(dst, src)) } +emit_cmovpo_r64_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem64) { append(instructions, inst_cmovpo_r64_m64(dst, src)) } +inst_cmovs_r16_r16 :: #force_inline proc "contextless" (dst: GPR16, src: GPR16) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVS, operand_count = 2, ops = {op_gpr16(dst), op_gpr16(src), {}, {}} }, 625) } +inst_cmovs_r16_m16 :: #force_inline proc "contextless" (dst: GPR16, src: Mem16) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVS, operand_count = 2, ops = {op_gpr16(dst), op_mem(src.mem, 2), {}, {}} }, 625) } +inst_cmovs_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVS, operand_count = 2, ops = {op_gpr32(dst), op_gpr32(src), {}, {}} }, 626) } +inst_cmovs_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVS, operand_count = 2, ops = {op_gpr32(dst), op_mem(src.mem, 4), {}, {}} }, 626) } +inst_cmovs_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVS, operand_count = 2, ops = {op_gpr64(dst), op_gpr64(src), {}, {}} }, 627) } +inst_cmovs_r64_m64 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVS, operand_count = 2, ops = {op_gpr64(dst), op_mem(src.mem, 8), {}, {}} }, 627) } +emit_cmovs_r16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: GPR16) { append(instructions, inst_cmovs_r16_r16(dst, src)) } +emit_cmovs_r16_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: Mem16) { append(instructions, inst_cmovs_r16_m16(dst, src)) } +emit_cmovs_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { append(instructions, inst_cmovs_r32_r32(dst, src)) } +emit_cmovs_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32) { append(instructions, inst_cmovs_r32_m32(dst, src)) } +emit_cmovs_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { append(instructions, inst_cmovs_r64_r64(dst, src)) } +emit_cmovs_r64_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem64) { append(instructions, inst_cmovs_r64_m64(dst, src)) } +inst_cmovz_r16_r16 :: #force_inline proc "contextless" (dst: GPR16, src: GPR16) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVZ, operand_count = 2, ops = {op_gpr16(dst), op_gpr16(src), {}, {}} }, 628) } +inst_cmovz_r16_m16 :: #force_inline proc "contextless" (dst: GPR16, src: Mem16) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVZ, operand_count = 2, ops = {op_gpr16(dst), op_mem(src.mem, 2), {}, {}} }, 628) } +inst_cmovz_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVZ, operand_count = 2, ops = {op_gpr32(dst), op_gpr32(src), {}, {}} }, 629) } +inst_cmovz_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVZ, operand_count = 2, ops = {op_gpr32(dst), op_mem(src.mem, 4), {}, {}} }, 629) } +inst_cmovz_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVZ, operand_count = 2, ops = {op_gpr64(dst), op_gpr64(src), {}, {}} }, 630) } +inst_cmovz_r64_m64 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .CMOVZ, operand_count = 2, ops = {op_gpr64(dst), op_mem(src.mem, 8), {}, {}} }, 630) } +emit_cmovz_r16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: GPR16) { append(instructions, inst_cmovz_r16_r16(dst, src)) } +emit_cmovz_r16_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: Mem16) { append(instructions, inst_cmovz_r16_m16(dst, src)) } +emit_cmovz_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { append(instructions, inst_cmovz_r32_r32(dst, src)) } +emit_cmovz_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32) { append(instructions, inst_cmovz_r32_m32(dst, src)) } +emit_cmovz_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { append(instructions, inst_cmovz_r64_r64(dst, src)) } +emit_cmovz_r64_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem64) { append(instructions, inst_cmovz_r64_m64(dst, src)) } +inst_movs_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .MOVS, operand_count = 0, ops = {{}, {}, {}, {}} }, 631) } +emit_movs_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_movs_none()) } +inst_movsb_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .MOVSB, operand_count = 0, ops = {{}, {}, {}, {}} }, 632) } +emit_movsb_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_movsb_none()) } +inst_movsw_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .MOVSW, operand_count = 0, ops = {{}, {}, {}, {}} }, 633) } +emit_movsw_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_movsw_none()) } +inst_movsd_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .MOVSD, operand_count = 0, ops = {{}, {}, {}, {}} }, 634) } +emit_movsd_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_movsd_none()) } +inst_movsq_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .MOVSQ, operand_count = 0, ops = {{}, {}, {}, {}} }, 635) } +emit_movsq_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_movsq_none()) } +inst_cmps_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .CMPS, operand_count = 0, ops = {{}, {}, {}, {}} }, 636) } +emit_cmps_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_cmps_none()) } +inst_cmpsb_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .CMPSB, operand_count = 0, ops = {{}, {}, {}, {}} }, 637) } +emit_cmpsb_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_cmpsb_none()) } +inst_cmpsw_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .CMPSW, operand_count = 0, ops = {{}, {}, {}, {}} }, 638) } +emit_cmpsw_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_cmpsw_none()) } +inst_cmpsd_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .CMPSD, operand_count = 0, ops = {{}, {}, {}, {}} }, 639) } +emit_cmpsd_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_cmpsd_none()) } +inst_cmpsq_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .CMPSQ, operand_count = 0, ops = {{}, {}, {}, {}} }, 640) } +emit_cmpsq_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_cmpsq_none()) } +inst_scas_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .SCAS, operand_count = 0, ops = {{}, {}, {}, {}} }, 641) } +emit_scas_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_scas_none()) } +inst_scasb_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .SCASB, operand_count = 0, ops = {{}, {}, {}, {}} }, 642) } +emit_scasb_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_scasb_none()) } +inst_scasw_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .SCASW, operand_count = 0, ops = {{}, {}, {}, {}} }, 643) } +emit_scasw_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_scasw_none()) } +inst_scasd_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .SCASD, operand_count = 0, ops = {{}, {}, {}, {}} }, 644) } +emit_scasd_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_scasd_none()) } +inst_scasq_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .SCASQ, operand_count = 0, ops = {{}, {}, {}, {}} }, 645) } +emit_scasq_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_scasq_none()) } +inst_lods_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .LODS, operand_count = 0, ops = {{}, {}, {}, {}} }, 646) } +emit_lods_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_lods_none()) } +inst_lodsb_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .LODSB, operand_count = 0, ops = {{}, {}, {}, {}} }, 647) } +emit_lodsb_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_lodsb_none()) } +inst_lodsw_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .LODSW, operand_count = 0, ops = {{}, {}, {}, {}} }, 648) } +emit_lodsw_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_lodsw_none()) } +inst_lodsd_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .LODSD, operand_count = 0, ops = {{}, {}, {}, {}} }, 649) } +emit_lodsd_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_lodsd_none()) } +inst_lodsq_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .LODSQ, operand_count = 0, ops = {{}, {}, {}, {}} }, 650) } +emit_lodsq_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_lodsq_none()) } +inst_stos_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .STOS, operand_count = 0, ops = {{}, {}, {}, {}} }, 651) } +emit_stos_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_stos_none()) } +inst_stosb_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .STOSB, operand_count = 0, ops = {{}, {}, {}, {}} }, 652) } +emit_stosb_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_stosb_none()) } +inst_stosw_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .STOSW, operand_count = 0, ops = {{}, {}, {}, {}} }, 653) } +emit_stosw_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_stosw_none()) } +inst_stosd_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .STOSD, operand_count = 0, ops = {{}, {}, {}, {}} }, 654) } +emit_stosd_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_stosd_none()) } +inst_stosq_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .STOSQ, operand_count = 0, ops = {{}, {}, {}, {}} }, 655) } +emit_stosq_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_stosq_none()) } +inst_clc_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .CLC, operand_count = 0, ops = {{}, {}, {}, {}} }, 656) } +emit_clc_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_clc_none()) } +inst_stc_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .STC, operand_count = 0, ops = {{}, {}, {}, {}} }, 657) } +emit_stc_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_stc_none()) } +inst_cmc_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .CMC, operand_count = 0, ops = {{}, {}, {}, {}} }, 658) } +emit_cmc_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_cmc_none()) } +inst_cld_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .CLD, operand_count = 0, ops = {{}, {}, {}, {}} }, 659) } +emit_cld_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_cld_none()) } +inst_std_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .STD, operand_count = 0, ops = {{}, {}, {}, {}} }, 660) } +emit_std_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_std_none()) } +inst_cli_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .CLI, operand_count = 0, ops = {{}, {}, {}, {}} }, 661) } +emit_cli_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_cli_none()) } +inst_sti_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .STI, operand_count = 0, ops = {{}, {}, {}, {}} }, 662) } +emit_sti_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_sti_none()) } +inst_lahf_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .LAHF, operand_count = 0, ops = {{}, {}, {}, {}} }, 663) } +emit_lahf_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_lahf_none()) } +inst_sahf_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .SAHF, operand_count = 0, ops = {{}, {}, {}, {}} }, 664) } +emit_sahf_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_sahf_none()) } +inst_pushf_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .PUSHF, operand_count = 0, ops = {{}, {}, {}, {}} }, 665) } +emit_pushf_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_pushf_none()) } +inst_pushfd_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .PUSHFD, operand_count = 0, ops = {{}, {}, {}, {}} }, 666) } +emit_pushfd_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_pushfd_none()) } +inst_pushfq_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .PUSHFQ, operand_count = 0, ops = {{}, {}, {}, {}} }, 667) } +emit_pushfq_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_pushfq_none()) } +inst_popf_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .POPF, operand_count = 0, ops = {{}, {}, {}, {}} }, 668) } +emit_popf_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_popf_none()) } +inst_popfd_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .POPFD, operand_count = 0, ops = {{}, {}, {}, {}} }, 669) } +emit_popfd_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_popfd_none()) } +inst_popfq_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .POPFQ, operand_count = 0, ops = {{}, {}, {}, {}} }, 670) } +emit_popfq_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_popfq_none()) } +inst_nop_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .NOP, operand_count = 0, ops = {{}, {}, {}, {}} }, 671) } +inst_nop_r16 :: #force_inline proc "contextless" (dst: GPR16) -> Instruction { return with_hint(Instruction{ mnemonic = .NOP, operand_count = 1, ops = {op_gpr16(dst), {}, {}, {}} }, 672) } +inst_nop_m16 :: #force_inline proc "contextless" (dst: Mem16) -> Instruction { return with_hint(Instruction{ mnemonic = .NOP, operand_count = 1, ops = {op_mem(dst.mem, 2), {}, {}, {}} }, 672) } +inst_nop_r32 :: #force_inline proc "contextless" (dst: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .NOP, operand_count = 1, ops = {op_gpr32(dst), {}, {}, {}} }, 673) } +inst_nop_m32 :: #force_inline proc "contextless" (dst: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .NOP, operand_count = 1, ops = {op_mem(dst.mem, 4), {}, {}, {}} }, 673) } +inst_nop_r64 :: #force_inline proc "contextless" (dst: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .NOP, operand_count = 1, ops = {op_gpr64(dst), {}, {}, {}} }, 674) } +inst_nop_m64 :: #force_inline proc "contextless" (dst: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .NOP, operand_count = 1, ops = {op_mem(dst.mem, 8), {}, {}, {}} }, 674) } +emit_nop_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_nop_none()) } +emit_nop_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16) { append(instructions, inst_nop_r16(dst)) } +emit_nop_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16) { append(instructions, inst_nop_m16(dst)) } +emit_nop_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32) { append(instructions, inst_nop_r32(dst)) } +emit_nop_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32) { append(instructions, inst_nop_m32(dst)) } +emit_nop_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64) { append(instructions, inst_nop_r64(dst)) } +emit_nop_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64) { append(instructions, inst_nop_m64(dst)) } +inst_hlt_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .HLT, operand_count = 0, ops = {{}, {}, {}, {}} }, 675) } +emit_hlt_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_hlt_none()) } +inst_wait_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .WAIT, operand_count = 0, ops = {{}, {}, {}, {}} }, 676) } +emit_wait_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_wait_none()) } +inst_lock_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .LOCK, operand_count = 0, ops = {{}, {}, {}, {}} }, 677) } +emit_lock_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_lock_none()) } +inst_ud0_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .UD0, operand_count = 2, ops = {op_gpr32(dst), op_gpr32(src), {}, {}} }, 678) } +inst_ud0_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .UD0, operand_count = 2, ops = {op_gpr32(dst), op_mem(src.mem, 4), {}, {}} }, 678) } +emit_ud0_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { append(instructions, inst_ud0_r32_r32(dst, src)) } +emit_ud0_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32) { append(instructions, inst_ud0_r32_m32(dst, src)) } +inst_ud1_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .UD1, operand_count = 2, ops = {op_gpr32(dst), op_gpr32(src), {}, {}} }, 679) } +inst_ud1_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .UD1, operand_count = 2, ops = {op_gpr32(dst), op_mem(src.mem, 4), {}, {}} }, 679) } +emit_ud1_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { append(instructions, inst_ud1_r32_r32(dst, src)) } +emit_ud1_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32) { append(instructions, inst_ud1_r32_m32(dst, src)) } +inst_ud2_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .UD2, operand_count = 0, ops = {{}, {}, {}, {}} }, 680) } +emit_ud2_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_ud2_none()) } +inst_cpuid_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .CPUID, operand_count = 0, ops = {{}, {}, {}, {}} }, 681) } +emit_cpuid_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_cpuid_none()) } +inst_rdtsc_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .RDTSC, operand_count = 0, ops = {{}, {}, {}, {}} }, 682) } +emit_rdtsc_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_rdtsc_none()) } +inst_rdtscp_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .RDTSCP, operand_count = 0, ops = {{}, {}, {}, {}} }, 683) } +emit_rdtscp_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_rdtscp_none()) } +inst_rdpmc_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .RDPMC, operand_count = 0, ops = {{}, {}, {}, {}} }, 684) } +emit_rdpmc_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_rdpmc_none()) } +inst_xgetbv_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .XGETBV, operand_count = 0, ops = {{}, {}, {}, {}} }, 685) } +emit_xgetbv_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_xgetbv_none()) } +inst_xsetbv_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .XSETBV, operand_count = 0, ops = {{}, {}, {}, {}} }, 686) } +emit_xsetbv_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_xsetbv_none()) } +inst_cbw_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .CBW, operand_count = 0, ops = {{}, {}, {}, {}} }, 687) } +emit_cbw_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_cbw_none()) } +inst_cwde_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .CWDE, operand_count = 0, ops = {{}, {}, {}, {}} }, 688) } +emit_cwde_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_cwde_none()) } +inst_cdqe_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .CDQE, operand_count = 0, ops = {{}, {}, {}, {}} }, 689) } +emit_cdqe_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_cdqe_none()) } +inst_cwd_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .CWD, operand_count = 0, ops = {{}, {}, {}, {}} }, 690) } +emit_cwd_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_cwd_none()) } +inst_cdq_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .CDQ, operand_count = 0, ops = {{}, {}, {}, {}} }, 691) } +emit_cdq_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_cdq_none()) } +inst_cqo_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .CQO, operand_count = 0, ops = {{}, {}, {}, {}} }, 692) } +emit_cqo_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_cqo_none()) } +inst_andn_r32_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32, src2: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .ANDN, operand_count = 3, ops = {op_gpr32(dst), op_gpr32(src), op_gpr32(src2), {}} }, 693) } +inst_andn_r32_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32, src2: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .ANDN, operand_count = 3, ops = {op_gpr32(dst), op_gpr32(src), op_mem(src2.mem, 4), {}} }, 693) } +inst_andn_r64_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64, src2: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .ANDN, operand_count = 3, ops = {op_gpr64(dst), op_gpr64(src), op_gpr64(src2), {}} }, 694) } +inst_andn_r64_r64_m64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64, src2: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .ANDN, operand_count = 3, ops = {op_gpr64(dst), op_gpr64(src), op_mem(src2.mem, 8), {}} }, 694) } +emit_andn_r32_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32, src2: GPR32) { append(instructions, inst_andn_r32_r32_r32(dst, src, src2)) } +emit_andn_r32_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32, src2: Mem32) { append(instructions, inst_andn_r32_r32_m32(dst, src, src2)) } +emit_andn_r64_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64, src2: GPR64) { append(instructions, inst_andn_r64_r64_r64(dst, src, src2)) } +emit_andn_r64_r64_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64, src2: Mem64) { append(instructions, inst_andn_r64_r64_m64(dst, src, src2)) } +inst_bextr_r32_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32, src2: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .BEXTR, operand_count = 3, ops = {op_gpr32(dst), op_gpr32(src), op_gpr32(src2), {}} }, 695) } +inst_bextr_r32_m32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32, src2: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .BEXTR, operand_count = 3, ops = {op_gpr32(dst), op_mem(src.mem, 4), op_gpr32(src2), {}} }, 695) } +inst_bextr_r64_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64, src2: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .BEXTR, operand_count = 3, ops = {op_gpr64(dst), op_gpr64(src), op_gpr64(src2), {}} }, 696) } +inst_bextr_r64_m64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64, src2: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .BEXTR, operand_count = 3, ops = {op_gpr64(dst), op_mem(src.mem, 8), op_gpr64(src2), {}} }, 696) } +emit_bextr_r32_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32, src2: GPR32) { append(instructions, inst_bextr_r32_r32_r32(dst, src, src2)) } emit_bextr_r32_m32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32, src2: GPR32) { append(instructions, inst_bextr_r32_m32_r32(dst, src, src2)) } -emit_bextr_r64_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64, src2: GPR64) { emit_rrr(instructions, .BEXTR, Register(dst), Register(src), Register(src2)) } +emit_bextr_r64_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64, src2: GPR64) { append(instructions, inst_bextr_r64_r64_r64(dst, src, src2)) } emit_bextr_r64_m64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem64, src2: GPR64) { append(instructions, inst_bextr_r64_m64_r64(dst, src, src2)) } -inst_blsi_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return inst_r_r(.BLSI, Register(dst), Register(src)) } -inst_blsi_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32) -> Instruction { return inst_r_m(.BLSI, Register(dst), src.mem, 4) } -inst_blsi_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return inst_r_r(.BLSI, Register(dst), Register(src)) } -inst_blsi_r64_m64 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64) -> Instruction { return inst_r_m(.BLSI, Register(dst), src.mem, 8) } -emit_blsi_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { emit_rr(instructions, .BLSI, Register(dst), Register(src)) } -emit_blsi_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32) { emit_rm(instructions, .BLSI, Register(dst), src.mem, 4) } -emit_blsi_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { emit_rr(instructions, .BLSI, Register(dst), Register(src)) } -emit_blsi_r64_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem64) { emit_rm(instructions, .BLSI, Register(dst), src.mem, 8) } -inst_blsmsk_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return inst_r_r(.BLSMSK, Register(dst), Register(src)) } -inst_blsmsk_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32) -> Instruction { return inst_r_m(.BLSMSK, Register(dst), src.mem, 4) } -inst_blsmsk_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return inst_r_r(.BLSMSK, Register(dst), Register(src)) } -inst_blsmsk_r64_m64 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64) -> Instruction { return inst_r_m(.BLSMSK, Register(dst), src.mem, 8) } -emit_blsmsk_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { emit_rr(instructions, .BLSMSK, Register(dst), Register(src)) } -emit_blsmsk_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32) { emit_rm(instructions, .BLSMSK, Register(dst), src.mem, 4) } -emit_blsmsk_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { emit_rr(instructions, .BLSMSK, Register(dst), Register(src)) } -emit_blsmsk_r64_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem64) { emit_rm(instructions, .BLSMSK, Register(dst), src.mem, 8) } -inst_blsr_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return inst_r_r(.BLSR, Register(dst), Register(src)) } -inst_blsr_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32) -> Instruction { return inst_r_m(.BLSR, Register(dst), src.mem, 4) } -inst_blsr_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return inst_r_r(.BLSR, Register(dst), Register(src)) } -inst_blsr_r64_m64 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64) -> Instruction { return inst_r_m(.BLSR, Register(dst), src.mem, 8) } -emit_blsr_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { emit_rr(instructions, .BLSR, Register(dst), Register(src)) } -emit_blsr_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32) { emit_rm(instructions, .BLSR, Register(dst), src.mem, 4) } -emit_blsr_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { emit_rr(instructions, .BLSR, Register(dst), Register(src)) } -emit_blsr_r64_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem64) { emit_rm(instructions, .BLSR, Register(dst), src.mem, 8) } -inst_bzhi_r32_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32, src2: GPR32) -> Instruction { return inst_r_r_r(.BZHI, Register(dst), Register(src), Register(src2)) } -inst_bzhi_r32_m32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32, src2: GPR32) -> Instruction { return Instruction{ mnemonic = .BZHI, operand_count = 3, ops = {op_gpr32(dst), op_mem(src.mem, 4), op_gpr32(src2), {}} } } -inst_bzhi_r64_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64, src2: GPR64) -> Instruction { return inst_r_r_r(.BZHI, Register(dst), Register(src), Register(src2)) } -inst_bzhi_r64_m64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64, src2: GPR64) -> Instruction { return Instruction{ mnemonic = .BZHI, operand_count = 3, ops = {op_gpr64(dst), op_mem(src.mem, 8), op_gpr64(src2), {}} } } -emit_bzhi_r32_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32, src2: GPR32) { emit_rrr(instructions, .BZHI, Register(dst), Register(src), Register(src2)) } +inst_blsi_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .BLSI, operand_count = 2, ops = {op_gpr32(dst), op_gpr32(src), {}, {}} }, 697) } +inst_blsi_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .BLSI, operand_count = 2, ops = {op_gpr32(dst), op_mem(src.mem, 4), {}, {}} }, 697) } +inst_blsi_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .BLSI, operand_count = 2, ops = {op_gpr64(dst), op_gpr64(src), {}, {}} }, 698) } +inst_blsi_r64_m64 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .BLSI, operand_count = 2, ops = {op_gpr64(dst), op_mem(src.mem, 8), {}, {}} }, 698) } +emit_blsi_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { append(instructions, inst_blsi_r32_r32(dst, src)) } +emit_blsi_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32) { append(instructions, inst_blsi_r32_m32(dst, src)) } +emit_blsi_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { append(instructions, inst_blsi_r64_r64(dst, src)) } +emit_blsi_r64_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem64) { append(instructions, inst_blsi_r64_m64(dst, src)) } +inst_blsmsk_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .BLSMSK, operand_count = 2, ops = {op_gpr32(dst), op_gpr32(src), {}, {}} }, 699) } +inst_blsmsk_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .BLSMSK, operand_count = 2, ops = {op_gpr32(dst), op_mem(src.mem, 4), {}, {}} }, 699) } +inst_blsmsk_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .BLSMSK, operand_count = 2, ops = {op_gpr64(dst), op_gpr64(src), {}, {}} }, 700) } +inst_blsmsk_r64_m64 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .BLSMSK, operand_count = 2, ops = {op_gpr64(dst), op_mem(src.mem, 8), {}, {}} }, 700) } +emit_blsmsk_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { append(instructions, inst_blsmsk_r32_r32(dst, src)) } +emit_blsmsk_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32) { append(instructions, inst_blsmsk_r32_m32(dst, src)) } +emit_blsmsk_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { append(instructions, inst_blsmsk_r64_r64(dst, src)) } +emit_blsmsk_r64_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem64) { append(instructions, inst_blsmsk_r64_m64(dst, src)) } +inst_blsr_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .BLSR, operand_count = 2, ops = {op_gpr32(dst), op_gpr32(src), {}, {}} }, 701) } +inst_blsr_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .BLSR, operand_count = 2, ops = {op_gpr32(dst), op_mem(src.mem, 4), {}, {}} }, 701) } +inst_blsr_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .BLSR, operand_count = 2, ops = {op_gpr64(dst), op_gpr64(src), {}, {}} }, 702) } +inst_blsr_r64_m64 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .BLSR, operand_count = 2, ops = {op_gpr64(dst), op_mem(src.mem, 8), {}, {}} }, 702) } +emit_blsr_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { append(instructions, inst_blsr_r32_r32(dst, src)) } +emit_blsr_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32) { append(instructions, inst_blsr_r32_m32(dst, src)) } +emit_blsr_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { append(instructions, inst_blsr_r64_r64(dst, src)) } +emit_blsr_r64_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem64) { append(instructions, inst_blsr_r64_m64(dst, src)) } +inst_bzhi_r32_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32, src2: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .BZHI, operand_count = 3, ops = {op_gpr32(dst), op_gpr32(src), op_gpr32(src2), {}} }, 703) } +inst_bzhi_r32_m32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32, src2: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .BZHI, operand_count = 3, ops = {op_gpr32(dst), op_mem(src.mem, 4), op_gpr32(src2), {}} }, 703) } +inst_bzhi_r64_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64, src2: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .BZHI, operand_count = 3, ops = {op_gpr64(dst), op_gpr64(src), op_gpr64(src2), {}} }, 704) } +inst_bzhi_r64_m64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64, src2: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .BZHI, operand_count = 3, ops = {op_gpr64(dst), op_mem(src.mem, 8), op_gpr64(src2), {}} }, 704) } +emit_bzhi_r32_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32, src2: GPR32) { append(instructions, inst_bzhi_r32_r32_r32(dst, src, src2)) } emit_bzhi_r32_m32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32, src2: GPR32) { append(instructions, inst_bzhi_r32_m32_r32(dst, src, src2)) } -emit_bzhi_r64_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64, src2: GPR64) { emit_rrr(instructions, .BZHI, Register(dst), Register(src), Register(src2)) } +emit_bzhi_r64_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64, src2: GPR64) { append(instructions, inst_bzhi_r64_r64_r64(dst, src, src2)) } emit_bzhi_r64_m64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem64, src2: GPR64) { append(instructions, inst_bzhi_r64_m64_r64(dst, src, src2)) } -inst_pdep_r32_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32, src2: GPR32) -> Instruction { return inst_r_r_r(.PDEP, Register(dst), Register(src), Register(src2)) } -inst_pdep_r32_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32, src2: Mem32) -> Instruction { return inst_r_r_m(.PDEP, Register(dst), Register(src), src2.mem, 4) } -inst_pdep_r64_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64, src2: GPR64) -> Instruction { return inst_r_r_r(.PDEP, Register(dst), Register(src), Register(src2)) } -inst_pdep_r64_r64_m64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64, src2: Mem64) -> Instruction { return inst_r_r_m(.PDEP, Register(dst), Register(src), src2.mem, 8) } -emit_pdep_r32_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32, src2: GPR32) { emit_rrr(instructions, .PDEP, Register(dst), Register(src), Register(src2)) } -emit_pdep_r32_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32, src2: Mem32) { emit_rrm(instructions, .PDEP, Register(dst), Register(src), src2.mem, 4) } -emit_pdep_r64_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64, src2: GPR64) { emit_rrr(instructions, .PDEP, Register(dst), Register(src), Register(src2)) } -emit_pdep_r64_r64_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64, src2: Mem64) { emit_rrm(instructions, .PDEP, Register(dst), Register(src), src2.mem, 8) } -inst_pext_r32_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32, src2: GPR32) -> Instruction { return inst_r_r_r(.PEXT, Register(dst), Register(src), Register(src2)) } -inst_pext_r32_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32, src2: Mem32) -> Instruction { return inst_r_r_m(.PEXT, Register(dst), Register(src), src2.mem, 4) } -inst_pext_r64_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64, src2: GPR64) -> Instruction { return inst_r_r_r(.PEXT, Register(dst), Register(src), Register(src2)) } -inst_pext_r64_r64_m64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64, src2: Mem64) -> Instruction { return inst_r_r_m(.PEXT, Register(dst), Register(src), src2.mem, 8) } -emit_pext_r32_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32, src2: GPR32) { emit_rrr(instructions, .PEXT, Register(dst), Register(src), Register(src2)) } -emit_pext_r32_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32, src2: Mem32) { emit_rrm(instructions, .PEXT, Register(dst), Register(src), src2.mem, 4) } -emit_pext_r64_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64, src2: GPR64) { emit_rrr(instructions, .PEXT, Register(dst), Register(src), Register(src2)) } -emit_pext_r64_r64_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64, src2: Mem64) { emit_rrm(instructions, .PEXT, Register(dst), Register(src), src2.mem, 8) } -inst_rorx_r32_r32_imm8 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32, imm: i8) -> Instruction { return inst_r_r_i(.RORX, Register(dst), Register(src), i64(imm), 1) } -inst_rorx_r32_m32_imm8 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32, imm: i8) -> Instruction { return inst_r_m_i(.RORX, Register(dst), src.mem, 4, i64(imm), 1) } -inst_rorx_r64_r64_imm8 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64, imm: i8) -> Instruction { return inst_r_r_i(.RORX, Register(dst), Register(src), i64(imm), 1) } -inst_rorx_r64_m64_imm8 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64, imm: i8) -> Instruction { return inst_r_m_i(.RORX, Register(dst), src.mem, 8, i64(imm), 1) } -emit_rorx_r32_r32_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32, imm: i8) { emit_rri(instructions, .RORX, Register(dst), Register(src), i64(imm), 1) } -emit_rorx_r32_m32_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32, imm: i8) { emit_rmi(instructions, .RORX, Register(dst), src.mem, 4, i64(imm), 1) } -emit_rorx_r64_r64_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64, imm: i8) { emit_rri(instructions, .RORX, Register(dst), Register(src), i64(imm), 1) } -emit_rorx_r64_m64_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem64, imm: i8) { emit_rmi(instructions, .RORX, Register(dst), src.mem, 8, i64(imm), 1) } -inst_sarx_r32_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32, src2: GPR32) -> Instruction { return inst_r_r_r(.SARX, Register(dst), Register(src), Register(src2)) } -inst_sarx_r32_m32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32, src2: GPR32) -> Instruction { return Instruction{ mnemonic = .SARX, operand_count = 3, ops = {op_gpr32(dst), op_mem(src.mem, 4), op_gpr32(src2), {}} } } -inst_sarx_r64_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64, src2: GPR64) -> Instruction { return inst_r_r_r(.SARX, Register(dst), Register(src), Register(src2)) } -inst_sarx_r64_m64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64, src2: GPR64) -> Instruction { return Instruction{ mnemonic = .SARX, operand_count = 3, ops = {op_gpr64(dst), op_mem(src.mem, 8), op_gpr64(src2), {}} } } -emit_sarx_r32_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32, src2: GPR32) { emit_rrr(instructions, .SARX, Register(dst), Register(src), Register(src2)) } +inst_pdep_r32_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32, src2: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .PDEP, operand_count = 3, ops = {op_gpr32(dst), op_gpr32(src), op_gpr32(src2), {}} }, 705) } +inst_pdep_r32_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32, src2: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .PDEP, operand_count = 3, ops = {op_gpr32(dst), op_gpr32(src), op_mem(src2.mem, 4), {}} }, 705) } +inst_pdep_r64_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64, src2: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .PDEP, operand_count = 3, ops = {op_gpr64(dst), op_gpr64(src), op_gpr64(src2), {}} }, 706) } +inst_pdep_r64_r64_m64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64, src2: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .PDEP, operand_count = 3, ops = {op_gpr64(dst), op_gpr64(src), op_mem(src2.mem, 8), {}} }, 706) } +emit_pdep_r32_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32, src2: GPR32) { append(instructions, inst_pdep_r32_r32_r32(dst, src, src2)) } +emit_pdep_r32_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32, src2: Mem32) { append(instructions, inst_pdep_r32_r32_m32(dst, src, src2)) } +emit_pdep_r64_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64, src2: GPR64) { append(instructions, inst_pdep_r64_r64_r64(dst, src, src2)) } +emit_pdep_r64_r64_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64, src2: Mem64) { append(instructions, inst_pdep_r64_r64_m64(dst, src, src2)) } +inst_pext_r32_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32, src2: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .PEXT, operand_count = 3, ops = {op_gpr32(dst), op_gpr32(src), op_gpr32(src2), {}} }, 707) } +inst_pext_r32_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32, src2: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .PEXT, operand_count = 3, ops = {op_gpr32(dst), op_gpr32(src), op_mem(src2.mem, 4), {}} }, 707) } +inst_pext_r64_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64, src2: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .PEXT, operand_count = 3, ops = {op_gpr64(dst), op_gpr64(src), op_gpr64(src2), {}} }, 708) } +inst_pext_r64_r64_m64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64, src2: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .PEXT, operand_count = 3, ops = {op_gpr64(dst), op_gpr64(src), op_mem(src2.mem, 8), {}} }, 708) } +emit_pext_r32_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32, src2: GPR32) { append(instructions, inst_pext_r32_r32_r32(dst, src, src2)) } +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), {}} } } +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)) } +emit_rorx_r64_m64_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem64, imm: i8) { append(instructions, inst_rorx_r64_m64_imm8(dst, src, imm)) } +inst_sarx_r32_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32, src2: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .SARX, operand_count = 3, ops = {op_gpr32(dst), op_gpr32(src), op_gpr32(src2), {}} }, 711) } +inst_sarx_r32_m32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32, src2: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .SARX, operand_count = 3, ops = {op_gpr32(dst), op_mem(src.mem, 4), op_gpr32(src2), {}} }, 711) } +inst_sarx_r64_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64, src2: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .SARX, operand_count = 3, ops = {op_gpr64(dst), op_gpr64(src), op_gpr64(src2), {}} }, 712) } +inst_sarx_r64_m64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64, src2: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .SARX, operand_count = 3, ops = {op_gpr64(dst), op_mem(src.mem, 8), op_gpr64(src2), {}} }, 712) } +emit_sarx_r32_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32, src2: GPR32) { append(instructions, inst_sarx_r32_r32_r32(dst, src, src2)) } emit_sarx_r32_m32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32, src2: GPR32) { append(instructions, inst_sarx_r32_m32_r32(dst, src, src2)) } -emit_sarx_r64_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64, src2: GPR64) { emit_rrr(instructions, .SARX, Register(dst), Register(src), Register(src2)) } +emit_sarx_r64_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64, src2: GPR64) { append(instructions, inst_sarx_r64_r64_r64(dst, src, src2)) } emit_sarx_r64_m64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem64, src2: GPR64) { append(instructions, inst_sarx_r64_m64_r64(dst, src, src2)) } -inst_shlx_r32_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32, src2: GPR32) -> Instruction { return inst_r_r_r(.SHLX, Register(dst), Register(src), Register(src2)) } -inst_shlx_r32_m32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32, src2: GPR32) -> Instruction { return Instruction{ mnemonic = .SHLX, operand_count = 3, ops = {op_gpr32(dst), op_mem(src.mem, 4), op_gpr32(src2), {}} } } -inst_shlx_r64_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64, src2: GPR64) -> Instruction { return inst_r_r_r(.SHLX, Register(dst), Register(src), Register(src2)) } -inst_shlx_r64_m64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64, src2: GPR64) -> Instruction { return Instruction{ mnemonic = .SHLX, operand_count = 3, ops = {op_gpr64(dst), op_mem(src.mem, 8), op_gpr64(src2), {}} } } -emit_shlx_r32_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32, src2: GPR32) { emit_rrr(instructions, .SHLX, Register(dst), Register(src), Register(src2)) } +inst_shlx_r32_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32, src2: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .SHLX, operand_count = 3, ops = {op_gpr32(dst), op_gpr32(src), op_gpr32(src2), {}} }, 713) } +inst_shlx_r32_m32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32, src2: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .SHLX, operand_count = 3, ops = {op_gpr32(dst), op_mem(src.mem, 4), op_gpr32(src2), {}} }, 713) } +inst_shlx_r64_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64, src2: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .SHLX, operand_count = 3, ops = {op_gpr64(dst), op_gpr64(src), op_gpr64(src2), {}} }, 714) } +inst_shlx_r64_m64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64, src2: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .SHLX, operand_count = 3, ops = {op_gpr64(dst), op_mem(src.mem, 8), op_gpr64(src2), {}} }, 714) } +emit_shlx_r32_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32, src2: GPR32) { append(instructions, inst_shlx_r32_r32_r32(dst, src, src2)) } emit_shlx_r32_m32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32, src2: GPR32) { append(instructions, inst_shlx_r32_m32_r32(dst, src, src2)) } -emit_shlx_r64_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64, src2: GPR64) { emit_rrr(instructions, .SHLX, Register(dst), Register(src), Register(src2)) } +emit_shlx_r64_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64, src2: GPR64) { append(instructions, inst_shlx_r64_r64_r64(dst, src, src2)) } emit_shlx_r64_m64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem64, src2: GPR64) { append(instructions, inst_shlx_r64_m64_r64(dst, src, src2)) } -inst_shrx_r32_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32, src2: GPR32) -> Instruction { return inst_r_r_r(.SHRX, Register(dst), Register(src), Register(src2)) } -inst_shrx_r32_m32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32, src2: GPR32) -> Instruction { return Instruction{ mnemonic = .SHRX, operand_count = 3, ops = {op_gpr32(dst), op_mem(src.mem, 4), op_gpr32(src2), {}} } } -inst_shrx_r64_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64, src2: GPR64) -> Instruction { return inst_r_r_r(.SHRX, Register(dst), Register(src), Register(src2)) } -inst_shrx_r64_m64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64, src2: GPR64) -> Instruction { return Instruction{ mnemonic = .SHRX, operand_count = 3, ops = {op_gpr64(dst), op_mem(src.mem, 8), op_gpr64(src2), {}} } } -emit_shrx_r32_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32, src2: GPR32) { emit_rrr(instructions, .SHRX, Register(dst), Register(src), Register(src2)) } +inst_shrx_r32_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32, src2: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .SHRX, operand_count = 3, ops = {op_gpr32(dst), op_gpr32(src), op_gpr32(src2), {}} }, 715) } +inst_shrx_r32_m32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32, src2: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .SHRX, operand_count = 3, ops = {op_gpr32(dst), op_mem(src.mem, 4), op_gpr32(src2), {}} }, 715) } +inst_shrx_r64_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64, src2: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .SHRX, operand_count = 3, ops = {op_gpr64(dst), op_gpr64(src), op_gpr64(src2), {}} }, 716) } +inst_shrx_r64_m64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64, src2: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .SHRX, operand_count = 3, ops = {op_gpr64(dst), op_mem(src.mem, 8), op_gpr64(src2), {}} }, 716) } +emit_shrx_r32_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32, src2: GPR32) { append(instructions, inst_shrx_r32_r32_r32(dst, src, src2)) } emit_shrx_r32_m32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32, src2: GPR32) { append(instructions, inst_shrx_r32_m32_r32(dst, src, src2)) } -emit_shrx_r64_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64, src2: GPR64) { emit_rrr(instructions, .SHRX, Register(dst), Register(src), Register(src2)) } +emit_shrx_r64_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64, src2: GPR64) { append(instructions, inst_shrx_r64_r64_r64(dst, src, src2)) } emit_shrx_r64_m64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem64, src2: GPR64) { append(instructions, inst_shrx_r64_m64_r64(dst, src, src2)) } -inst_mulx_r32_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32, src2: GPR32) -> Instruction { return inst_r_r_r(.MULX, Register(dst), Register(src), Register(src2)) } -inst_mulx_r32_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32, src2: Mem32) -> Instruction { return inst_r_r_m(.MULX, Register(dst), Register(src), src2.mem, 4) } -inst_mulx_r64_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64, src2: GPR64) -> Instruction { return inst_r_r_r(.MULX, Register(dst), Register(src), Register(src2)) } -inst_mulx_r64_r64_m64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64, src2: Mem64) -> Instruction { return inst_r_r_m(.MULX, Register(dst), Register(src), src2.mem, 8) } -emit_mulx_r32_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32, src2: GPR32) { emit_rrr(instructions, .MULX, Register(dst), Register(src), Register(src2)) } -emit_mulx_r32_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32, src2: Mem32) { emit_rrm(instructions, .MULX, Register(dst), Register(src), src2.mem, 4) } -emit_mulx_r64_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64, src2: GPR64) { emit_rrr(instructions, .MULX, Register(dst), Register(src), Register(src2)) } -emit_mulx_r64_r64_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64, src2: Mem64) { emit_rrm(instructions, .MULX, Register(dst), Register(src), src2.mem, 8) } -inst_adcx_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return inst_r_r(.ADCX, Register(dst), Register(src)) } -inst_adcx_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32) -> Instruction { return inst_r_m(.ADCX, Register(dst), src.mem, 4) } -inst_adcx_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return inst_r_r(.ADCX, Register(dst), Register(src)) } -inst_adcx_r64_m64 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64) -> Instruction { return inst_r_m(.ADCX, Register(dst), src.mem, 8) } -emit_adcx_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { emit_rr(instructions, .ADCX, Register(dst), Register(src)) } -emit_adcx_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32) { emit_rm(instructions, .ADCX, Register(dst), src.mem, 4) } -emit_adcx_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { emit_rr(instructions, .ADCX, Register(dst), Register(src)) } -emit_adcx_r64_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem64) { emit_rm(instructions, .ADCX, Register(dst), src.mem, 8) } -inst_adox_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return inst_r_r(.ADOX, Register(dst), Register(src)) } -inst_adox_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32) -> Instruction { return inst_r_m(.ADOX, Register(dst), src.mem, 4) } -inst_adox_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return inst_r_r(.ADOX, Register(dst), Register(src)) } -inst_adox_r64_m64 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64) -> Instruction { return inst_r_m(.ADOX, Register(dst), src.mem, 8) } -emit_adox_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { emit_rr(instructions, .ADOX, Register(dst), Register(src)) } -emit_adox_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32) { emit_rm(instructions, .ADOX, Register(dst), src.mem, 4) } -emit_adox_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { emit_rr(instructions, .ADOX, Register(dst), Register(src)) } -emit_adox_r64_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem64) { emit_rm(instructions, .ADOX, Register(dst), src.mem, 8) } -inst_movaps_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.MOVAPS, Register(dst), Register(src)) } -inst_movaps_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.MOVAPS, Register(dst), src.mem, 16) } -inst_movaps_m128_xmm :: #force_inline proc "contextless" (dst: Mem128, src: XMM) -> Instruction { return inst_m_r(.MOVAPS, dst.mem, 16, Register(src)) } -emit_movaps_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .MOVAPS, Register(dst), Register(src)) } -emit_movaps_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .MOVAPS, Register(dst), src.mem, 16) } -emit_movaps_m128_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem128, src: XMM) { emit_mr(instructions, .MOVAPS, dst.mem, 16, Register(src)) } -inst_movups_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.MOVUPS, Register(dst), Register(src)) } -inst_movups_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.MOVUPS, Register(dst), src.mem, 16) } -inst_movups_m128_xmm :: #force_inline proc "contextless" (dst: Mem128, src: XMM) -> Instruction { return inst_m_r(.MOVUPS, dst.mem, 16, Register(src)) } -emit_movups_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .MOVUPS, Register(dst), Register(src)) } -emit_movups_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .MOVUPS, Register(dst), src.mem, 16) } -emit_movups_m128_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem128, src: XMM) { emit_mr(instructions, .MOVUPS, dst.mem, 16, Register(src)) } -inst_movapd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.MOVAPD, Register(dst), Register(src)) } -inst_movapd_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.MOVAPD, Register(dst), src.mem, 16) } -inst_movapd_m128_xmm :: #force_inline proc "contextless" (dst: Mem128, src: XMM) -> Instruction { return inst_m_r(.MOVAPD, dst.mem, 16, Register(src)) } -emit_movapd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .MOVAPD, Register(dst), Register(src)) } -emit_movapd_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .MOVAPD, Register(dst), src.mem, 16) } -emit_movapd_m128_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem128, src: XMM) { emit_mr(instructions, .MOVAPD, dst.mem, 16, Register(src)) } -inst_movupd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.MOVUPD, Register(dst), Register(src)) } -inst_movupd_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.MOVUPD, Register(dst), src.mem, 16) } -inst_movupd_m128_xmm :: #force_inline proc "contextless" (dst: Mem128, src: XMM) -> Instruction { return inst_m_r(.MOVUPD, dst.mem, 16, Register(src)) } -emit_movupd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .MOVUPD, Register(dst), Register(src)) } -emit_movupd_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .MOVUPD, Register(dst), src.mem, 16) } -emit_movupd_m128_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem128, src: XMM) { emit_mr(instructions, .MOVUPD, dst.mem, 16, Register(src)) } -inst_movss_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.MOVSS, Register(dst), Register(src)) } -inst_movss_xmm_m32 :: #force_inline proc "contextless" (dst: XMM, src: Mem32) -> Instruction { return inst_r_m(.MOVSS, Register(dst), src.mem, 4) } -inst_movss_m32_xmm :: #force_inline proc "contextless" (dst: Mem32, src: XMM) -> Instruction { return inst_m_r(.MOVSS, dst.mem, 4, Register(src)) } -emit_movss_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .MOVSS, Register(dst), Register(src)) } -emit_movss_xmm_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem32) { emit_rm(instructions, .MOVSS, Register(dst), src.mem, 4) } -emit_movss_m32_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, src: XMM) { emit_mr(instructions, .MOVSS, dst.mem, 4, Register(src)) } -inst_movsd_sse_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.MOVSD_SSE, Register(dst), Register(src)) } -inst_movsd_sse_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: Mem64) -> Instruction { return inst_r_m(.MOVSD_SSE, Register(dst), src.mem, 8) } -inst_movsd_sse_m64_xmm :: #force_inline proc "contextless" (dst: Mem64, src: XMM) -> Instruction { return inst_m_r(.MOVSD_SSE, dst.mem, 8, Register(src)) } -emit_movsd_sse_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .MOVSD_SSE, Register(dst), Register(src)) } -emit_movsd_sse_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem64) { emit_rm(instructions, .MOVSD_SSE, Register(dst), src.mem, 8) } -emit_movsd_sse_m64_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, src: XMM) { emit_mr(instructions, .MOVSD_SSE, dst.mem, 8, Register(src)) } -inst_movdqa_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.MOVDQA, Register(dst), Register(src)) } -inst_movdqa_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.MOVDQA, Register(dst), src.mem, 16) } -inst_movdqa_m128_xmm :: #force_inline proc "contextless" (dst: Mem128, src: XMM) -> Instruction { return inst_m_r(.MOVDQA, dst.mem, 16, Register(src)) } -emit_movdqa_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .MOVDQA, Register(dst), Register(src)) } -emit_movdqa_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .MOVDQA, Register(dst), src.mem, 16) } -emit_movdqa_m128_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem128, src: XMM) { emit_mr(instructions, .MOVDQA, dst.mem, 16, Register(src)) } -inst_movdqu_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.MOVDQU, Register(dst), Register(src)) } -inst_movdqu_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.MOVDQU, Register(dst), src.mem, 16) } -inst_movdqu_m128_xmm :: #force_inline proc "contextless" (dst: Mem128, src: XMM) -> Instruction { return inst_m_r(.MOVDQU, dst.mem, 16, Register(src)) } -emit_movdqu_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .MOVDQU, Register(dst), Register(src)) } -emit_movdqu_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .MOVDQU, Register(dst), src.mem, 16) } -emit_movdqu_m128_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem128, src: XMM) { emit_mr(instructions, .MOVDQU, dst.mem, 16, Register(src)) } -inst_movq_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.MOVQ, Register(dst), Register(src)) } -inst_movq_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: Mem64) -> Instruction { return inst_r_m(.MOVQ, Register(dst), src.mem, 8) } -inst_movq_m64_xmm :: #force_inline proc "contextless" (dst: Mem64, src: XMM) -> Instruction { return inst_m_r(.MOVQ, dst.mem, 8, Register(src)) } -inst_movq_mm_mm :: #force_inline proc "contextless" (dst: MM, src: MM) -> Instruction { return inst_r_r(.MOVQ, Register(dst), Register(src)) } -inst_movq_mm_m64 :: #force_inline proc "contextless" (dst: MM, src: Mem64) -> Instruction { return inst_r_m(.MOVQ, Register(dst), src.mem, 8) } -inst_movq_m64_mm :: #force_inline proc "contextless" (dst: Mem64, src: MM) -> Instruction { return inst_m_r(.MOVQ, dst.mem, 8, Register(src)) } -inst_movq_r64_xmm :: #force_inline proc "contextless" (dst: GPR64, src: XMM) -> Instruction { return inst_r_r(.MOVQ, Register(dst), Register(src)) } -inst_movq_xmm_r64 :: #force_inline proc "contextless" (dst: XMM, src: GPR64) -> Instruction { return inst_r_r(.MOVQ, Register(dst), Register(src)) } -emit_movq_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .MOVQ, Register(dst), Register(src)) } -emit_movq_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem64) { emit_rm(instructions, .MOVQ, Register(dst), src.mem, 8) } -emit_movq_m64_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, src: XMM) { emit_mr(instructions, .MOVQ, dst.mem, 8, Register(src)) } -emit_movq_mm_mm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: MM, src: MM) { emit_rr(instructions, .MOVQ, Register(dst), Register(src)) } -emit_movq_mm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: MM, src: Mem64) { emit_rm(instructions, .MOVQ, Register(dst), src.mem, 8) } -emit_movq_m64_mm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, src: MM) { emit_mr(instructions, .MOVQ, dst.mem, 8, Register(src)) } -emit_movq_r64_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: XMM) { emit_rr(instructions, .MOVQ, Register(dst), Register(src)) } -emit_movq_xmm_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: GPR64) { emit_rr(instructions, .MOVQ, Register(dst), Register(src)) } -inst_movd_xmm_r32 :: #force_inline proc "contextless" (dst: XMM, src: GPR32) -> Instruction { return inst_r_r(.MOVD, Register(dst), Register(src)) } -inst_movd_xmm_m32 :: #force_inline proc "contextless" (dst: XMM, src: Mem32) -> Instruction { return inst_r_m(.MOVD, Register(dst), src.mem, 4) } -inst_movd_r32_xmm :: #force_inline proc "contextless" (dst: GPR32, src: XMM) -> Instruction { return inst_r_r(.MOVD, Register(dst), Register(src)) } -inst_movd_m32_xmm :: #force_inline proc "contextless" (dst: Mem32, src: XMM) -> Instruction { return inst_m_r(.MOVD, dst.mem, 4, Register(src)) } -inst_movd_mm_r32 :: #force_inline proc "contextless" (dst: MM, src: GPR32) -> Instruction { return inst_r_r(.MOVD, Register(dst), Register(src)) } -inst_movd_mm_m32 :: #force_inline proc "contextless" (dst: MM, src: Mem32) -> Instruction { return inst_r_m(.MOVD, Register(dst), src.mem, 4) } -inst_movd_r32_mm :: #force_inline proc "contextless" (dst: GPR32, src: MM) -> Instruction { return inst_r_r(.MOVD, Register(dst), Register(src)) } -inst_movd_m32_mm :: #force_inline proc "contextless" (dst: Mem32, src: MM) -> Instruction { return inst_m_r(.MOVD, dst.mem, 4, Register(src)) } -emit_movd_xmm_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: GPR32) { emit_rr(instructions, .MOVD, Register(dst), Register(src)) } -emit_movd_xmm_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem32) { emit_rm(instructions, .MOVD, Register(dst), src.mem, 4) } -emit_movd_r32_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: XMM) { emit_rr(instructions, .MOVD, Register(dst), Register(src)) } -emit_movd_m32_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, src: XMM) { emit_mr(instructions, .MOVD, dst.mem, 4, Register(src)) } -emit_movd_mm_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: MM, src: GPR32) { emit_rr(instructions, .MOVD, Register(dst), Register(src)) } -emit_movd_mm_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: MM, src: Mem32) { emit_rm(instructions, .MOVD, Register(dst), src.mem, 4) } -emit_movd_r32_mm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: MM) { emit_rr(instructions, .MOVD, Register(dst), Register(src)) } -emit_movd_m32_mm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, src: MM) { emit_mr(instructions, .MOVD, dst.mem, 4, Register(src)) } -inst_movlps_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: Mem64) -> Instruction { return inst_r_m(.MOVLPS, Register(dst), src.mem, 8) } -inst_movlps_m64_xmm :: #force_inline proc "contextless" (dst: Mem64, src: XMM) -> Instruction { return inst_m_r(.MOVLPS, dst.mem, 8, Register(src)) } -emit_movlps_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem64) { emit_rm(instructions, .MOVLPS, Register(dst), src.mem, 8) } -emit_movlps_m64_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, src: XMM) { emit_mr(instructions, .MOVLPS, dst.mem, 8, Register(src)) } -inst_movhps_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: Mem64) -> Instruction { return inst_r_m(.MOVHPS, Register(dst), src.mem, 8) } -inst_movhps_m64_xmm :: #force_inline proc "contextless" (dst: Mem64, src: XMM) -> Instruction { return inst_m_r(.MOVHPS, dst.mem, 8, Register(src)) } -emit_movhps_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem64) { emit_rm(instructions, .MOVHPS, Register(dst), src.mem, 8) } -emit_movhps_m64_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, src: XMM) { emit_mr(instructions, .MOVHPS, dst.mem, 8, Register(src)) } -inst_movlpd_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: Mem64) -> Instruction { return inst_r_m(.MOVLPD, Register(dst), src.mem, 8) } -inst_movlpd_m64_xmm :: #force_inline proc "contextless" (dst: Mem64, src: XMM) -> Instruction { return inst_m_r(.MOVLPD, dst.mem, 8, Register(src)) } -emit_movlpd_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem64) { emit_rm(instructions, .MOVLPD, Register(dst), src.mem, 8) } -emit_movlpd_m64_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, src: XMM) { emit_mr(instructions, .MOVLPD, dst.mem, 8, Register(src)) } -inst_movhpd_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: Mem64) -> Instruction { return inst_r_m(.MOVHPD, Register(dst), src.mem, 8) } -inst_movhpd_m64_xmm :: #force_inline proc "contextless" (dst: Mem64, src: XMM) -> Instruction { return inst_m_r(.MOVHPD, dst.mem, 8, Register(src)) } -emit_movhpd_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem64) { emit_rm(instructions, .MOVHPD, Register(dst), src.mem, 8) } -emit_movhpd_m64_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, src: XMM) { emit_mr(instructions, .MOVHPD, dst.mem, 8, Register(src)) } -inst_movlhps_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.MOVLHPS, Register(dst), Register(src)) } -emit_movlhps_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .MOVLHPS, Register(dst), Register(src)) } -inst_movhlps_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.MOVHLPS, Register(dst), Register(src)) } -emit_movhlps_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .MOVHLPS, Register(dst), Register(src)) } -inst_movmskps_r32_xmm :: #force_inline proc "contextless" (dst: GPR32, src: XMM) -> Instruction { return inst_r_r(.MOVMSKPS, Register(dst), Register(src)) } -inst_movmskps_r64_xmm :: #force_inline proc "contextless" (dst: GPR64, src: XMM) -> Instruction { return inst_r_r(.MOVMSKPS, Register(dst), Register(src)) } -emit_movmskps_r32_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: XMM) { emit_rr(instructions, .MOVMSKPS, Register(dst), Register(src)) } -emit_movmskps_r64_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: XMM) { emit_rr(instructions, .MOVMSKPS, Register(dst), Register(src)) } -inst_movmskpd_r32_xmm :: #force_inline proc "contextless" (dst: GPR32, src: XMM) -> Instruction { return inst_r_r(.MOVMSKPD, Register(dst), Register(src)) } -inst_movmskpd_r64_xmm :: #force_inline proc "contextless" (dst: GPR64, src: XMM) -> Instruction { return inst_r_r(.MOVMSKPD, Register(dst), Register(src)) } -emit_movmskpd_r32_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: XMM) { emit_rr(instructions, .MOVMSKPD, Register(dst), Register(src)) } -emit_movmskpd_r64_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: XMM) { emit_rr(instructions, .MOVMSKPD, Register(dst), Register(src)) } -inst_movntps_m128_xmm :: #force_inline proc "contextless" (dst: Mem128, src: XMM) -> Instruction { return inst_m_r(.MOVNTPS, dst.mem, 16, Register(src)) } -emit_movntps_m128_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem128, src: XMM) { emit_mr(instructions, .MOVNTPS, dst.mem, 16, Register(src)) } -inst_movntpd_m128_xmm :: #force_inline proc "contextless" (dst: Mem128, src: XMM) -> Instruction { return inst_m_r(.MOVNTPD, dst.mem, 16, Register(src)) } -emit_movntpd_m128_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem128, src: XMM) { emit_mr(instructions, .MOVNTPD, dst.mem, 16, Register(src)) } -inst_movntdq_m128_xmm :: #force_inline proc "contextless" (dst: Mem128, src: XMM) -> Instruction { return inst_m_r(.MOVNTDQ, dst.mem, 16, Register(src)) } -emit_movntdq_m128_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem128, src: XMM) { emit_mr(instructions, .MOVNTDQ, dst.mem, 16, Register(src)) } -inst_movntdqa_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.MOVNTDQA, Register(dst), src.mem, 16) } -emit_movntdqa_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .MOVNTDQA, Register(dst), src.mem, 16) } -inst_addps_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.ADDPS, Register(dst), Register(src)) } -inst_addps_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.ADDPS, Register(dst), src.mem, 16) } -emit_addps_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .ADDPS, Register(dst), Register(src)) } -emit_addps_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .ADDPS, Register(dst), src.mem, 16) } -inst_addpd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.ADDPD, Register(dst), Register(src)) } -inst_addpd_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.ADDPD, Register(dst), src.mem, 16) } -emit_addpd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .ADDPD, Register(dst), Register(src)) } -emit_addpd_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .ADDPD, Register(dst), src.mem, 16) } -inst_addss_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.ADDSS, Register(dst), Register(src)) } -inst_addss_xmm_m32 :: #force_inline proc "contextless" (dst: XMM, src: Mem32) -> Instruction { return inst_r_m(.ADDSS, Register(dst), src.mem, 4) } -emit_addss_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .ADDSS, Register(dst), Register(src)) } -emit_addss_xmm_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem32) { emit_rm(instructions, .ADDSS, Register(dst), src.mem, 4) } -inst_addsd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.ADDSD, Register(dst), Register(src)) } -inst_addsd_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: Mem64) -> Instruction { return inst_r_m(.ADDSD, Register(dst), src.mem, 8) } -emit_addsd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .ADDSD, Register(dst), Register(src)) } -emit_addsd_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem64) { emit_rm(instructions, .ADDSD, Register(dst), src.mem, 8) } -inst_subps_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.SUBPS, Register(dst), Register(src)) } -inst_subps_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.SUBPS, Register(dst), src.mem, 16) } -emit_subps_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .SUBPS, Register(dst), Register(src)) } -emit_subps_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .SUBPS, Register(dst), src.mem, 16) } -inst_subpd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.SUBPD, Register(dst), Register(src)) } -inst_subpd_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.SUBPD, Register(dst), src.mem, 16) } -emit_subpd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .SUBPD, Register(dst), Register(src)) } -emit_subpd_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .SUBPD, Register(dst), src.mem, 16) } -inst_subss_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.SUBSS, Register(dst), Register(src)) } -inst_subss_xmm_m32 :: #force_inline proc "contextless" (dst: XMM, src: Mem32) -> Instruction { return inst_r_m(.SUBSS, Register(dst), src.mem, 4) } -emit_subss_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .SUBSS, Register(dst), Register(src)) } -emit_subss_xmm_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem32) { emit_rm(instructions, .SUBSS, Register(dst), src.mem, 4) } -inst_subsd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.SUBSD, Register(dst), Register(src)) } -inst_subsd_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: Mem64) -> Instruction { return inst_r_m(.SUBSD, Register(dst), src.mem, 8) } -emit_subsd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .SUBSD, Register(dst), Register(src)) } -emit_subsd_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem64) { emit_rm(instructions, .SUBSD, Register(dst), src.mem, 8) } -inst_mulps_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.MULPS, Register(dst), Register(src)) } -inst_mulps_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.MULPS, Register(dst), src.mem, 16) } -emit_mulps_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .MULPS, Register(dst), Register(src)) } -emit_mulps_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .MULPS, Register(dst), src.mem, 16) } -inst_mulpd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.MULPD, Register(dst), Register(src)) } -inst_mulpd_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.MULPD, Register(dst), src.mem, 16) } -emit_mulpd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .MULPD, Register(dst), Register(src)) } -emit_mulpd_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .MULPD, Register(dst), src.mem, 16) } -inst_mulss_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.MULSS, Register(dst), Register(src)) } -inst_mulss_xmm_m32 :: #force_inline proc "contextless" (dst: XMM, src: Mem32) -> Instruction { return inst_r_m(.MULSS, Register(dst), src.mem, 4) } -emit_mulss_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .MULSS, Register(dst), Register(src)) } -emit_mulss_xmm_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem32) { emit_rm(instructions, .MULSS, Register(dst), src.mem, 4) } -inst_mulsd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.MULSD, Register(dst), Register(src)) } -inst_mulsd_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: Mem64) -> Instruction { return inst_r_m(.MULSD, Register(dst), src.mem, 8) } -emit_mulsd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .MULSD, Register(dst), Register(src)) } -emit_mulsd_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem64) { emit_rm(instructions, .MULSD, Register(dst), src.mem, 8) } -inst_divps_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.DIVPS, Register(dst), Register(src)) } -inst_divps_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.DIVPS, Register(dst), src.mem, 16) } -emit_divps_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .DIVPS, Register(dst), Register(src)) } -emit_divps_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .DIVPS, Register(dst), src.mem, 16) } -inst_divpd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.DIVPD, Register(dst), Register(src)) } -inst_divpd_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.DIVPD, Register(dst), src.mem, 16) } -emit_divpd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .DIVPD, Register(dst), Register(src)) } -emit_divpd_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .DIVPD, Register(dst), src.mem, 16) } -inst_divss_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.DIVSS, Register(dst), Register(src)) } -inst_divss_xmm_m32 :: #force_inline proc "contextless" (dst: XMM, src: Mem32) -> Instruction { return inst_r_m(.DIVSS, Register(dst), src.mem, 4) } -emit_divss_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .DIVSS, Register(dst), Register(src)) } -emit_divss_xmm_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem32) { emit_rm(instructions, .DIVSS, Register(dst), src.mem, 4) } -inst_divsd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.DIVSD, Register(dst), Register(src)) } -inst_divsd_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: Mem64) -> Instruction { return inst_r_m(.DIVSD, Register(dst), src.mem, 8) } -emit_divsd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .DIVSD, Register(dst), Register(src)) } -emit_divsd_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem64) { emit_rm(instructions, .DIVSD, Register(dst), src.mem, 8) } -inst_sqrtps_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.SQRTPS, Register(dst), Register(src)) } -inst_sqrtps_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.SQRTPS, Register(dst), src.mem, 16) } -emit_sqrtps_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .SQRTPS, Register(dst), Register(src)) } -emit_sqrtps_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .SQRTPS, Register(dst), src.mem, 16) } -inst_sqrtpd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.SQRTPD, Register(dst), Register(src)) } -inst_sqrtpd_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.SQRTPD, Register(dst), src.mem, 16) } -emit_sqrtpd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .SQRTPD, Register(dst), Register(src)) } -emit_sqrtpd_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .SQRTPD, Register(dst), src.mem, 16) } -inst_sqrtss_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.SQRTSS, Register(dst), Register(src)) } -inst_sqrtss_xmm_m32 :: #force_inline proc "contextless" (dst: XMM, src: Mem32) -> Instruction { return inst_r_m(.SQRTSS, Register(dst), src.mem, 4) } -emit_sqrtss_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .SQRTSS, Register(dst), Register(src)) } -emit_sqrtss_xmm_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem32) { emit_rm(instructions, .SQRTSS, Register(dst), src.mem, 4) } -inst_sqrtsd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.SQRTSD, Register(dst), Register(src)) } -inst_sqrtsd_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: Mem64) -> Instruction { return inst_r_m(.SQRTSD, Register(dst), src.mem, 8) } -emit_sqrtsd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .SQRTSD, Register(dst), Register(src)) } -emit_sqrtsd_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem64) { emit_rm(instructions, .SQRTSD, Register(dst), src.mem, 8) } -inst_rcpps_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.RCPPS, Register(dst), Register(src)) } -inst_rcpps_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.RCPPS, Register(dst), src.mem, 16) } -emit_rcpps_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .RCPPS, Register(dst), Register(src)) } -emit_rcpps_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .RCPPS, Register(dst), src.mem, 16) } -inst_rcpss_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.RCPSS, Register(dst), Register(src)) } -inst_rcpss_xmm_m32 :: #force_inline proc "contextless" (dst: XMM, src: Mem32) -> Instruction { return inst_r_m(.RCPSS, Register(dst), src.mem, 4) } -emit_rcpss_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .RCPSS, Register(dst), Register(src)) } -emit_rcpss_xmm_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem32) { emit_rm(instructions, .RCPSS, Register(dst), src.mem, 4) } -inst_rsqrtps_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.RSQRTPS, Register(dst), Register(src)) } -inst_rsqrtps_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.RSQRTPS, Register(dst), src.mem, 16) } -emit_rsqrtps_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .RSQRTPS, Register(dst), Register(src)) } -emit_rsqrtps_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .RSQRTPS, Register(dst), src.mem, 16) } -inst_rsqrtss_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.RSQRTSS, Register(dst), Register(src)) } -inst_rsqrtss_xmm_m32 :: #force_inline proc "contextless" (dst: XMM, src: Mem32) -> Instruction { return inst_r_m(.RSQRTSS, Register(dst), src.mem, 4) } -emit_rsqrtss_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .RSQRTSS, Register(dst), Register(src)) } -emit_rsqrtss_xmm_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem32) { emit_rm(instructions, .RSQRTSS, Register(dst), src.mem, 4) } -inst_maxps_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.MAXPS, Register(dst), Register(src)) } -inst_maxps_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.MAXPS, Register(dst), src.mem, 16) } -emit_maxps_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .MAXPS, Register(dst), Register(src)) } -emit_maxps_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .MAXPS, Register(dst), src.mem, 16) } -inst_maxpd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.MAXPD, Register(dst), Register(src)) } -inst_maxpd_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.MAXPD, Register(dst), src.mem, 16) } -emit_maxpd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .MAXPD, Register(dst), Register(src)) } -emit_maxpd_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .MAXPD, Register(dst), src.mem, 16) } -inst_maxss_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.MAXSS, Register(dst), Register(src)) } -inst_maxss_xmm_m32 :: #force_inline proc "contextless" (dst: XMM, src: Mem32) -> Instruction { return inst_r_m(.MAXSS, Register(dst), src.mem, 4) } -emit_maxss_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .MAXSS, Register(dst), Register(src)) } -emit_maxss_xmm_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem32) { emit_rm(instructions, .MAXSS, Register(dst), src.mem, 4) } -inst_maxsd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.MAXSD, Register(dst), Register(src)) } -inst_maxsd_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: Mem64) -> Instruction { return inst_r_m(.MAXSD, Register(dst), src.mem, 8) } -emit_maxsd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .MAXSD, Register(dst), Register(src)) } -emit_maxsd_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem64) { emit_rm(instructions, .MAXSD, Register(dst), src.mem, 8) } -inst_minps_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.MINPS, Register(dst), Register(src)) } -inst_minps_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.MINPS, Register(dst), src.mem, 16) } -emit_minps_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .MINPS, Register(dst), Register(src)) } -emit_minps_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .MINPS, Register(dst), src.mem, 16) } -inst_minpd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.MINPD, Register(dst), Register(src)) } -inst_minpd_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.MINPD, Register(dst), src.mem, 16) } -emit_minpd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .MINPD, Register(dst), Register(src)) } -emit_minpd_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .MINPD, Register(dst), src.mem, 16) } -inst_minss_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.MINSS, Register(dst), Register(src)) } -inst_minss_xmm_m32 :: #force_inline proc "contextless" (dst: XMM, src: Mem32) -> Instruction { return inst_r_m(.MINSS, Register(dst), src.mem, 4) } -emit_minss_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .MINSS, Register(dst), Register(src)) } -emit_minss_xmm_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem32) { emit_rm(instructions, .MINSS, Register(dst), src.mem, 4) } -inst_minsd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.MINSD, Register(dst), Register(src)) } -inst_minsd_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: Mem64) -> Instruction { return inst_r_m(.MINSD, Register(dst), src.mem, 8) } -emit_minsd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .MINSD, Register(dst), Register(src)) } -emit_minsd_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem64) { emit_rm(instructions, .MINSD, Register(dst), src.mem, 8) } -inst_andps_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.ANDPS, Register(dst), Register(src)) } -inst_andps_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.ANDPS, Register(dst), src.mem, 16) } -emit_andps_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .ANDPS, Register(dst), Register(src)) } -emit_andps_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .ANDPS, Register(dst), src.mem, 16) } -inst_andpd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.ANDPD, Register(dst), Register(src)) } -inst_andpd_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.ANDPD, Register(dst), src.mem, 16) } -emit_andpd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .ANDPD, Register(dst), Register(src)) } -emit_andpd_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .ANDPD, Register(dst), src.mem, 16) } -inst_andnps_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.ANDNPS, Register(dst), Register(src)) } -inst_andnps_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.ANDNPS, Register(dst), src.mem, 16) } -emit_andnps_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .ANDNPS, Register(dst), Register(src)) } -emit_andnps_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .ANDNPS, Register(dst), src.mem, 16) } -inst_andnpd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.ANDNPD, Register(dst), Register(src)) } -inst_andnpd_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.ANDNPD, Register(dst), src.mem, 16) } -emit_andnpd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .ANDNPD, Register(dst), Register(src)) } -emit_andnpd_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .ANDNPD, Register(dst), src.mem, 16) } -inst_orps_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.ORPS, Register(dst), Register(src)) } -inst_orps_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.ORPS, Register(dst), src.mem, 16) } -emit_orps_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .ORPS, Register(dst), Register(src)) } -emit_orps_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .ORPS, Register(dst), src.mem, 16) } -inst_orpd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.ORPD, Register(dst), Register(src)) } -inst_orpd_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.ORPD, Register(dst), src.mem, 16) } -emit_orpd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .ORPD, Register(dst), Register(src)) } -emit_orpd_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .ORPD, Register(dst), src.mem, 16) } -inst_xorps_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.XORPS, Register(dst), Register(src)) } -inst_xorps_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.XORPS, Register(dst), src.mem, 16) } -emit_xorps_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .XORPS, Register(dst), Register(src)) } -emit_xorps_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .XORPS, Register(dst), src.mem, 16) } -inst_xorpd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.XORPD, Register(dst), Register(src)) } -inst_xorpd_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.XORPD, Register(dst), src.mem, 16) } -emit_xorpd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .XORPD, Register(dst), Register(src)) } -emit_xorpd_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .XORPD, Register(dst), src.mem, 16) } -inst_cmpps_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return inst_r_r_i(.CMPPS, Register(dst), Register(src), i64(imm), 1) } -inst_cmpps_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem128, imm: i8) -> Instruction { return inst_r_m_i(.CMPPS, Register(dst), src.mem, 16, i64(imm), 1) } -emit_cmpps_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, imm: i8) { emit_rri(instructions, .CMPPS, Register(dst), Register(src), i64(imm), 1) } -emit_cmpps_xmm_m128_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128, imm: i8) { emit_rmi(instructions, .CMPPS, Register(dst), src.mem, 16, i64(imm), 1) } -inst_cmppd_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return inst_r_r_i(.CMPPD, Register(dst), Register(src), i64(imm), 1) } -inst_cmppd_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem128, imm: i8) -> Instruction { return inst_r_m_i(.CMPPD, Register(dst), src.mem, 16, i64(imm), 1) } -emit_cmppd_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, imm: i8) { emit_rri(instructions, .CMPPD, Register(dst), Register(src), i64(imm), 1) } -emit_cmppd_xmm_m128_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128, imm: i8) { emit_rmi(instructions, .CMPPD, Register(dst), src.mem, 16, i64(imm), 1) } -inst_cmpss_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return inst_r_r_i(.CMPSS, Register(dst), Register(src), i64(imm), 1) } -inst_cmpss_xmm_m32_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem32, imm: i8) -> Instruction { return inst_r_m_i(.CMPSS, Register(dst), src.mem, 4, i64(imm), 1) } -emit_cmpss_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, imm: i8) { emit_rri(instructions, .CMPSS, Register(dst), Register(src), i64(imm), 1) } -emit_cmpss_xmm_m32_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem32, imm: i8) { emit_rmi(instructions, .CMPSS, Register(dst), src.mem, 4, i64(imm), 1) } -inst_cmpsd_sse_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return inst_r_r_i(.CMPSD_SSE, Register(dst), Register(src), i64(imm), 1) } -inst_cmpsd_sse_xmm_m64_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem64, imm: i8) -> Instruction { return inst_r_m_i(.CMPSD_SSE, Register(dst), src.mem, 8, i64(imm), 1) } -emit_cmpsd_sse_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, imm: i8) { emit_rri(instructions, .CMPSD_SSE, Register(dst), Register(src), i64(imm), 1) } -emit_cmpsd_sse_xmm_m64_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem64, imm: i8) { emit_rmi(instructions, .CMPSD_SSE, Register(dst), src.mem, 8, i64(imm), 1) } -inst_comiss_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.COMISS, Register(dst), Register(src)) } -inst_comiss_xmm_m32 :: #force_inline proc "contextless" (dst: XMM, src: Mem32) -> Instruction { return inst_r_m(.COMISS, Register(dst), src.mem, 4) } -emit_comiss_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .COMISS, Register(dst), Register(src)) } -emit_comiss_xmm_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem32) { emit_rm(instructions, .COMISS, Register(dst), src.mem, 4) } -inst_comisd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.COMISD, Register(dst), Register(src)) } -inst_comisd_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: Mem64) -> Instruction { return inst_r_m(.COMISD, Register(dst), src.mem, 8) } -emit_comisd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .COMISD, Register(dst), Register(src)) } -emit_comisd_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem64) { emit_rm(instructions, .COMISD, Register(dst), src.mem, 8) } -inst_ucomiss_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.UCOMISS, Register(dst), Register(src)) } -inst_ucomiss_xmm_m32 :: #force_inline proc "contextless" (dst: XMM, src: Mem32) -> Instruction { return inst_r_m(.UCOMISS, Register(dst), src.mem, 4) } -emit_ucomiss_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .UCOMISS, Register(dst), Register(src)) } -emit_ucomiss_xmm_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem32) { emit_rm(instructions, .UCOMISS, Register(dst), src.mem, 4) } -inst_ucomisd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.UCOMISD, Register(dst), Register(src)) } -inst_ucomisd_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: Mem64) -> Instruction { return inst_r_m(.UCOMISD, Register(dst), src.mem, 8) } -emit_ucomisd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .UCOMISD, Register(dst), Register(src)) } -emit_ucomisd_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem64) { emit_rm(instructions, .UCOMISD, Register(dst), src.mem, 8) } -inst_shufps_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return inst_r_r_i(.SHUFPS, Register(dst), Register(src), i64(imm), 1) } -inst_shufps_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem128, imm: i8) -> Instruction { return inst_r_m_i(.SHUFPS, Register(dst), src.mem, 16, i64(imm), 1) } -emit_shufps_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, imm: i8) { emit_rri(instructions, .SHUFPS, Register(dst), Register(src), i64(imm), 1) } -emit_shufps_xmm_m128_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128, imm: i8) { emit_rmi(instructions, .SHUFPS, Register(dst), src.mem, 16, i64(imm), 1) } -inst_shufpd_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return inst_r_r_i(.SHUFPD, Register(dst), Register(src), i64(imm), 1) } -inst_shufpd_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem128, imm: i8) -> Instruction { return inst_r_m_i(.SHUFPD, Register(dst), src.mem, 16, i64(imm), 1) } -emit_shufpd_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, imm: i8) { emit_rri(instructions, .SHUFPD, Register(dst), Register(src), i64(imm), 1) } -emit_shufpd_xmm_m128_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128, imm: i8) { emit_rmi(instructions, .SHUFPD, Register(dst), src.mem, 16, i64(imm), 1) } -inst_unpcklps_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.UNPCKLPS, Register(dst), Register(src)) } -inst_unpcklps_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.UNPCKLPS, Register(dst), src.mem, 16) } -emit_unpcklps_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .UNPCKLPS, Register(dst), Register(src)) } -emit_unpcklps_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .UNPCKLPS, Register(dst), src.mem, 16) } -inst_unpckhps_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.UNPCKHPS, Register(dst), Register(src)) } -inst_unpckhps_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.UNPCKHPS, Register(dst), src.mem, 16) } -emit_unpckhps_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .UNPCKHPS, Register(dst), Register(src)) } -emit_unpckhps_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .UNPCKHPS, Register(dst), src.mem, 16) } -inst_unpcklpd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.UNPCKLPD, Register(dst), Register(src)) } -inst_unpcklpd_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.UNPCKLPD, Register(dst), src.mem, 16) } -emit_unpcklpd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .UNPCKLPD, Register(dst), Register(src)) } -emit_unpcklpd_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .UNPCKLPD, Register(dst), src.mem, 16) } -inst_unpckhpd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.UNPCKHPD, Register(dst), Register(src)) } -inst_unpckhpd_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.UNPCKHPD, Register(dst), src.mem, 16) } -emit_unpckhpd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .UNPCKHPD, Register(dst), Register(src)) } -emit_unpckhpd_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .UNPCKHPD, Register(dst), src.mem, 16) } -inst_cvtps2pd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.CVTPS2PD, Register(dst), Register(src)) } -inst_cvtps2pd_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: Mem64) -> Instruction { return inst_r_m(.CVTPS2PD, Register(dst), src.mem, 8) } -emit_cvtps2pd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .CVTPS2PD, Register(dst), Register(src)) } -emit_cvtps2pd_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem64) { emit_rm(instructions, .CVTPS2PD, Register(dst), src.mem, 8) } -inst_cvtpd2ps_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.CVTPD2PS, Register(dst), Register(src)) } -inst_cvtpd2ps_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.CVTPD2PS, Register(dst), src.mem, 16) } -emit_cvtpd2ps_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .CVTPD2PS, Register(dst), Register(src)) } -emit_cvtpd2ps_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .CVTPD2PS, Register(dst), src.mem, 16) } -inst_cvtss2sd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.CVTSS2SD, Register(dst), Register(src)) } -inst_cvtss2sd_xmm_m32 :: #force_inline proc "contextless" (dst: XMM, src: Mem32) -> Instruction { return inst_r_m(.CVTSS2SD, Register(dst), src.mem, 4) } -emit_cvtss2sd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .CVTSS2SD, Register(dst), Register(src)) } -emit_cvtss2sd_xmm_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem32) { emit_rm(instructions, .CVTSS2SD, Register(dst), src.mem, 4) } -inst_cvtsd2ss_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.CVTSD2SS, Register(dst), Register(src)) } -inst_cvtsd2ss_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: Mem64) -> Instruction { return inst_r_m(.CVTSD2SS, Register(dst), src.mem, 8) } -emit_cvtsd2ss_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .CVTSD2SS, Register(dst), Register(src)) } -emit_cvtsd2ss_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem64) { emit_rm(instructions, .CVTSD2SS, Register(dst), src.mem, 8) } -inst_cvtps2dq_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.CVTPS2DQ, Register(dst), Register(src)) } -inst_cvtps2dq_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.CVTPS2DQ, Register(dst), src.mem, 16) } -emit_cvtps2dq_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .CVTPS2DQ, Register(dst), Register(src)) } -emit_cvtps2dq_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .CVTPS2DQ, Register(dst), src.mem, 16) } -inst_cvtpd2dq_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.CVTPD2DQ, Register(dst), Register(src)) } -inst_cvtpd2dq_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.CVTPD2DQ, Register(dst), src.mem, 16) } -emit_cvtpd2dq_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .CVTPD2DQ, Register(dst), Register(src)) } -emit_cvtpd2dq_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .CVTPD2DQ, Register(dst), src.mem, 16) } -inst_cvtdq2ps_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.CVTDQ2PS, Register(dst), Register(src)) } -inst_cvtdq2ps_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.CVTDQ2PS, Register(dst), src.mem, 16) } -emit_cvtdq2ps_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .CVTDQ2PS, Register(dst), Register(src)) } -emit_cvtdq2ps_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .CVTDQ2PS, Register(dst), src.mem, 16) } -inst_cvtdq2pd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.CVTDQ2PD, Register(dst), Register(src)) } -inst_cvtdq2pd_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: Mem64) -> Instruction { return inst_r_m(.CVTDQ2PD, Register(dst), src.mem, 8) } -emit_cvtdq2pd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .CVTDQ2PD, Register(dst), Register(src)) } -emit_cvtdq2pd_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem64) { emit_rm(instructions, .CVTDQ2PD, Register(dst), src.mem, 8) } -inst_cvtss2si_r32_xmm :: #force_inline proc "contextless" (dst: GPR32, src: XMM) -> Instruction { return inst_r_r(.CVTSS2SI, Register(dst), Register(src)) } -inst_cvtss2si_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32) -> Instruction { return inst_r_m(.CVTSS2SI, Register(dst), src.mem, 4) } -inst_cvtss2si_r64_xmm :: #force_inline proc "contextless" (dst: GPR64, src: XMM) -> Instruction { return inst_r_r(.CVTSS2SI, Register(dst), Register(src)) } -inst_cvtss2si_r64_m32 :: #force_inline proc "contextless" (dst: GPR64, src: Mem32) -> Instruction { return inst_r_m(.CVTSS2SI, Register(dst), src.mem, 4) } -emit_cvtss2si_r32_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: XMM) { emit_rr(instructions, .CVTSS2SI, Register(dst), Register(src)) } -emit_cvtss2si_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32) { emit_rm(instructions, .CVTSS2SI, Register(dst), src.mem, 4) } -emit_cvtss2si_r64_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: XMM) { emit_rr(instructions, .CVTSS2SI, Register(dst), Register(src)) } -emit_cvtss2si_r64_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem32) { emit_rm(instructions, .CVTSS2SI, Register(dst), src.mem, 4) } -inst_cvtsd2si_r32_xmm :: #force_inline proc "contextless" (dst: GPR32, src: XMM) -> Instruction { return inst_r_r(.CVTSD2SI, Register(dst), Register(src)) } -inst_cvtsd2si_r32_m64 :: #force_inline proc "contextless" (dst: GPR32, src: Mem64) -> Instruction { return inst_r_m(.CVTSD2SI, Register(dst), src.mem, 8) } -inst_cvtsd2si_r64_xmm :: #force_inline proc "contextless" (dst: GPR64, src: XMM) -> Instruction { return inst_r_r(.CVTSD2SI, Register(dst), Register(src)) } -inst_cvtsd2si_r64_m64 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64) -> Instruction { return inst_r_m(.CVTSD2SI, Register(dst), src.mem, 8) } -emit_cvtsd2si_r32_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: XMM) { emit_rr(instructions, .CVTSD2SI, Register(dst), Register(src)) } -emit_cvtsd2si_r32_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem64) { emit_rm(instructions, .CVTSD2SI, Register(dst), src.mem, 8) } -emit_cvtsd2si_r64_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: XMM) { emit_rr(instructions, .CVTSD2SI, Register(dst), Register(src)) } -emit_cvtsd2si_r64_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem64) { emit_rm(instructions, .CVTSD2SI, Register(dst), src.mem, 8) } -inst_cvtsi2ss_xmm_r32 :: #force_inline proc "contextless" (dst: XMM, src: GPR32) -> Instruction { return inst_r_r(.CVTSI2SS, Register(dst), Register(src)) } -inst_cvtsi2ss_xmm_m32 :: #force_inline proc "contextless" (dst: XMM, src: Mem32) -> Instruction { return inst_r_m(.CVTSI2SS, Register(dst), src.mem, 4) } -inst_cvtsi2ss_xmm_r64 :: #force_inline proc "contextless" (dst: XMM, src: GPR64) -> Instruction { return inst_r_r(.CVTSI2SS, Register(dst), Register(src)) } -inst_cvtsi2ss_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: Mem64) -> Instruction { return inst_r_m(.CVTSI2SS, Register(dst), src.mem, 8) } -emit_cvtsi2ss_xmm_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: GPR32) { emit_rr(instructions, .CVTSI2SS, Register(dst), Register(src)) } -emit_cvtsi2ss_xmm_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem32) { emit_rm(instructions, .CVTSI2SS, Register(dst), src.mem, 4) } -emit_cvtsi2ss_xmm_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: GPR64) { emit_rr(instructions, .CVTSI2SS, Register(dst), Register(src)) } -emit_cvtsi2ss_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem64) { emit_rm(instructions, .CVTSI2SS, Register(dst), src.mem, 8) } -inst_cvtsi2sd_xmm_r32 :: #force_inline proc "contextless" (dst: XMM, src: GPR32) -> Instruction { return inst_r_r(.CVTSI2SD, Register(dst), Register(src)) } -inst_cvtsi2sd_xmm_m32 :: #force_inline proc "contextless" (dst: XMM, src: Mem32) -> Instruction { return inst_r_m(.CVTSI2SD, Register(dst), src.mem, 4) } -inst_cvtsi2sd_xmm_r64 :: #force_inline proc "contextless" (dst: XMM, src: GPR64) -> Instruction { return inst_r_r(.CVTSI2SD, Register(dst), Register(src)) } -inst_cvtsi2sd_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: Mem64) -> Instruction { return inst_r_m(.CVTSI2SD, Register(dst), src.mem, 8) } -emit_cvtsi2sd_xmm_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: GPR32) { emit_rr(instructions, .CVTSI2SD, Register(dst), Register(src)) } -emit_cvtsi2sd_xmm_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem32) { emit_rm(instructions, .CVTSI2SD, Register(dst), src.mem, 4) } -emit_cvtsi2sd_xmm_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: GPR64) { emit_rr(instructions, .CVTSI2SD, Register(dst), Register(src)) } -emit_cvtsi2sd_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem64) { emit_rm(instructions, .CVTSI2SD, Register(dst), src.mem, 8) } -inst_cvttps2dq_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.CVTTPS2DQ, Register(dst), Register(src)) } -inst_cvttps2dq_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.CVTTPS2DQ, Register(dst), src.mem, 16) } -emit_cvttps2dq_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .CVTTPS2DQ, Register(dst), Register(src)) } -emit_cvttps2dq_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .CVTTPS2DQ, Register(dst), src.mem, 16) } -inst_cvttpd2dq_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.CVTTPD2DQ, Register(dst), Register(src)) } -inst_cvttpd2dq_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.CVTTPD2DQ, Register(dst), src.mem, 16) } -emit_cvttpd2dq_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .CVTTPD2DQ, Register(dst), Register(src)) } -emit_cvttpd2dq_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .CVTTPD2DQ, Register(dst), src.mem, 16) } -inst_cvttss2si_r32_xmm :: #force_inline proc "contextless" (dst: GPR32, src: XMM) -> Instruction { return inst_r_r(.CVTTSS2SI, Register(dst), Register(src)) } -inst_cvttss2si_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32) -> Instruction { return inst_r_m(.CVTTSS2SI, Register(dst), src.mem, 4) } -inst_cvttss2si_r64_xmm :: #force_inline proc "contextless" (dst: GPR64, src: XMM) -> Instruction { return inst_r_r(.CVTTSS2SI, Register(dst), Register(src)) } -inst_cvttss2si_r64_m32 :: #force_inline proc "contextless" (dst: GPR64, src: Mem32) -> Instruction { return inst_r_m(.CVTTSS2SI, Register(dst), src.mem, 4) } -emit_cvttss2si_r32_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: XMM) { emit_rr(instructions, .CVTTSS2SI, Register(dst), Register(src)) } -emit_cvttss2si_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32) { emit_rm(instructions, .CVTTSS2SI, Register(dst), src.mem, 4) } -emit_cvttss2si_r64_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: XMM) { emit_rr(instructions, .CVTTSS2SI, Register(dst), Register(src)) } -emit_cvttss2si_r64_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem32) { emit_rm(instructions, .CVTTSS2SI, Register(dst), src.mem, 4) } -inst_cvttsd2si_r32_xmm :: #force_inline proc "contextless" (dst: GPR32, src: XMM) -> Instruction { return inst_r_r(.CVTTSD2SI, Register(dst), Register(src)) } -inst_cvttsd2si_r32_m64 :: #force_inline proc "contextless" (dst: GPR32, src: Mem64) -> Instruction { return inst_r_m(.CVTTSD2SI, Register(dst), src.mem, 8) } -inst_cvttsd2si_r64_xmm :: #force_inline proc "contextless" (dst: GPR64, src: XMM) -> Instruction { return inst_r_r(.CVTTSD2SI, Register(dst), Register(src)) } -inst_cvttsd2si_r64_m64 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64) -> Instruction { return inst_r_m(.CVTTSD2SI, Register(dst), src.mem, 8) } -emit_cvttsd2si_r32_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: XMM) { emit_rr(instructions, .CVTTSD2SI, Register(dst), Register(src)) } -emit_cvttsd2si_r32_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem64) { emit_rm(instructions, .CVTTSD2SI, Register(dst), src.mem, 8) } -emit_cvttsd2si_r64_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: XMM) { emit_rr(instructions, .CVTTSD2SI, Register(dst), Register(src)) } -emit_cvttsd2si_r64_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem64) { emit_rm(instructions, .CVTTSD2SI, Register(dst), src.mem, 8) } -inst_paddb_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.PADDB, Register(dst), Register(src)) } -inst_paddb_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.PADDB, Register(dst), src.mem, 16) } -emit_paddb_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .PADDB, Register(dst), Register(src)) } -emit_paddb_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .PADDB, Register(dst), src.mem, 16) } -inst_paddw_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.PADDW, Register(dst), Register(src)) } -inst_paddw_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.PADDW, Register(dst), src.mem, 16) } -emit_paddw_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .PADDW, Register(dst), Register(src)) } -emit_paddw_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .PADDW, Register(dst), src.mem, 16) } -inst_paddd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.PADDD, Register(dst), Register(src)) } -inst_paddd_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.PADDD, Register(dst), src.mem, 16) } -emit_paddd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .PADDD, Register(dst), Register(src)) } -emit_paddd_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .PADDD, Register(dst), src.mem, 16) } -inst_paddq_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.PADDQ, Register(dst), Register(src)) } -inst_paddq_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.PADDQ, Register(dst), src.mem, 16) } -emit_paddq_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .PADDQ, Register(dst), Register(src)) } -emit_paddq_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .PADDQ, Register(dst), src.mem, 16) } -inst_psubb_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.PSUBB, Register(dst), Register(src)) } -inst_psubb_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.PSUBB, Register(dst), src.mem, 16) } -emit_psubb_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .PSUBB, Register(dst), Register(src)) } -emit_psubb_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .PSUBB, Register(dst), src.mem, 16) } -inst_psubw_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.PSUBW, Register(dst), Register(src)) } -inst_psubw_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.PSUBW, Register(dst), src.mem, 16) } -emit_psubw_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .PSUBW, Register(dst), Register(src)) } -emit_psubw_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .PSUBW, Register(dst), src.mem, 16) } -inst_psubd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.PSUBD, Register(dst), Register(src)) } -inst_psubd_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.PSUBD, Register(dst), src.mem, 16) } -emit_psubd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .PSUBD, Register(dst), Register(src)) } -emit_psubd_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .PSUBD, Register(dst), src.mem, 16) } -inst_psubq_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.PSUBQ, Register(dst), Register(src)) } -inst_psubq_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.PSUBQ, Register(dst), src.mem, 16) } -emit_psubq_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .PSUBQ, Register(dst), Register(src)) } -emit_psubq_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .PSUBQ, Register(dst), src.mem, 16) } -inst_paddsb_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.PADDSB, Register(dst), Register(src)) } -inst_paddsb_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.PADDSB, Register(dst), src.mem, 16) } -emit_paddsb_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .PADDSB, Register(dst), Register(src)) } -emit_paddsb_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .PADDSB, Register(dst), src.mem, 16) } -inst_paddsw_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.PADDSW, Register(dst), Register(src)) } -inst_paddsw_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.PADDSW, Register(dst), src.mem, 16) } -emit_paddsw_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .PADDSW, Register(dst), Register(src)) } -emit_paddsw_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .PADDSW, Register(dst), src.mem, 16) } -inst_paddusb_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.PADDUSB, Register(dst), Register(src)) } -inst_paddusb_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.PADDUSB, Register(dst), src.mem, 16) } -emit_paddusb_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .PADDUSB, Register(dst), Register(src)) } -emit_paddusb_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .PADDUSB, Register(dst), src.mem, 16) } -inst_paddusw_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.PADDUSW, Register(dst), Register(src)) } -inst_paddusw_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.PADDUSW, Register(dst), src.mem, 16) } -emit_paddusw_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .PADDUSW, Register(dst), Register(src)) } -emit_paddusw_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .PADDUSW, Register(dst), src.mem, 16) } -inst_psubsb_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.PSUBSB, Register(dst), Register(src)) } -inst_psubsb_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.PSUBSB, Register(dst), src.mem, 16) } -emit_psubsb_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .PSUBSB, Register(dst), Register(src)) } -emit_psubsb_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .PSUBSB, Register(dst), src.mem, 16) } -inst_psubsw_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.PSUBSW, Register(dst), Register(src)) } -inst_psubsw_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.PSUBSW, Register(dst), src.mem, 16) } -emit_psubsw_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .PSUBSW, Register(dst), Register(src)) } -emit_psubsw_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .PSUBSW, Register(dst), src.mem, 16) } -inst_psubusb_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.PSUBUSB, Register(dst), Register(src)) } -inst_psubusb_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.PSUBUSB, Register(dst), src.mem, 16) } -emit_psubusb_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .PSUBUSB, Register(dst), Register(src)) } -emit_psubusb_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .PSUBUSB, Register(dst), src.mem, 16) } -inst_psubusw_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.PSUBUSW, Register(dst), Register(src)) } -inst_psubusw_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.PSUBUSW, Register(dst), src.mem, 16) } -emit_psubusw_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .PSUBUSW, Register(dst), Register(src)) } -emit_psubusw_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .PSUBUSW, Register(dst), src.mem, 16) } -inst_pmullw_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.PMULLW, Register(dst), Register(src)) } -inst_pmullw_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.PMULLW, Register(dst), src.mem, 16) } -emit_pmullw_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .PMULLW, Register(dst), Register(src)) } -emit_pmullw_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .PMULLW, Register(dst), src.mem, 16) } -inst_pmulhw_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.PMULHW, Register(dst), Register(src)) } -inst_pmulhw_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.PMULHW, Register(dst), src.mem, 16) } -emit_pmulhw_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .PMULHW, Register(dst), Register(src)) } -emit_pmulhw_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .PMULHW, Register(dst), src.mem, 16) } -inst_pmulhuw_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.PMULHUW, Register(dst), Register(src)) } -inst_pmulhuw_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.PMULHUW, Register(dst), src.mem, 16) } -emit_pmulhuw_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .PMULHUW, Register(dst), Register(src)) } -emit_pmulhuw_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .PMULHUW, Register(dst), src.mem, 16) } -inst_pmuludq_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.PMULUDQ, Register(dst), Register(src)) } -inst_pmuludq_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.PMULUDQ, Register(dst), src.mem, 16) } -emit_pmuludq_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .PMULUDQ, Register(dst), Register(src)) } -emit_pmuludq_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .PMULUDQ, Register(dst), src.mem, 16) } -inst_pmaddwd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.PMADDWD, Register(dst), Register(src)) } -inst_pmaddwd_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.PMADDWD, Register(dst), src.mem, 16) } -emit_pmaddwd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .PMADDWD, Register(dst), Register(src)) } -emit_pmaddwd_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .PMADDWD, Register(dst), src.mem, 16) } -inst_pand_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.PAND, Register(dst), Register(src)) } -inst_pand_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.PAND, Register(dst), src.mem, 16) } -emit_pand_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .PAND, Register(dst), Register(src)) } -emit_pand_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .PAND, Register(dst), src.mem, 16) } -inst_pandn_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.PANDN, Register(dst), Register(src)) } -inst_pandn_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.PANDN, Register(dst), src.mem, 16) } -emit_pandn_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .PANDN, Register(dst), Register(src)) } -emit_pandn_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .PANDN, Register(dst), src.mem, 16) } -inst_por_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.POR, Register(dst), Register(src)) } -inst_por_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.POR, Register(dst), src.mem, 16) } -emit_por_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .POR, Register(dst), Register(src)) } -emit_por_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .POR, Register(dst), src.mem, 16) } -inst_pxor_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.PXOR, Register(dst), Register(src)) } -inst_pxor_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.PXOR, Register(dst), src.mem, 16) } -emit_pxor_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .PXOR, Register(dst), Register(src)) } -emit_pxor_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .PXOR, Register(dst), src.mem, 16) } -inst_psllw_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.PSLLW, Register(dst), Register(src)) } -inst_psllw_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.PSLLW, Register(dst), src.mem, 16) } -inst_psllw_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, imm: i8) -> Instruction { return inst_r_i(.PSLLW, Register(dst), i64(imm), 1) } -emit_psllw_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .PSLLW, Register(dst), Register(src)) } -emit_psllw_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .PSLLW, Register(dst), src.mem, 16) } -emit_psllw_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, imm: i8) { emit_ri(instructions, .PSLLW, Register(dst), i64(imm), 1) } -inst_pslld_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.PSLLD, Register(dst), Register(src)) } -inst_pslld_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.PSLLD, Register(dst), src.mem, 16) } -inst_pslld_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, imm: i8) -> Instruction { return inst_r_i(.PSLLD, Register(dst), i64(imm), 1) } -emit_pslld_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .PSLLD, Register(dst), Register(src)) } -emit_pslld_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .PSLLD, Register(dst), src.mem, 16) } -emit_pslld_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, imm: i8) { emit_ri(instructions, .PSLLD, Register(dst), i64(imm), 1) } -inst_psllq_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.PSLLQ, Register(dst), Register(src)) } -inst_psllq_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.PSLLQ, Register(dst), src.mem, 16) } -inst_psllq_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, imm: i8) -> Instruction { return inst_r_i(.PSLLQ, Register(dst), i64(imm), 1) } -emit_psllq_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .PSLLQ, Register(dst), Register(src)) } -emit_psllq_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .PSLLQ, Register(dst), src.mem, 16) } -emit_psllq_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, imm: i8) { emit_ri(instructions, .PSLLQ, Register(dst), i64(imm), 1) } -inst_psrlw_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.PSRLW, Register(dst), Register(src)) } -inst_psrlw_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.PSRLW, Register(dst), src.mem, 16) } -inst_psrlw_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, imm: i8) -> Instruction { return inst_r_i(.PSRLW, Register(dst), i64(imm), 1) } -emit_psrlw_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .PSRLW, Register(dst), Register(src)) } -emit_psrlw_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .PSRLW, Register(dst), src.mem, 16) } -emit_psrlw_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, imm: i8) { emit_ri(instructions, .PSRLW, Register(dst), i64(imm), 1) } -inst_psrld_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.PSRLD, Register(dst), Register(src)) } -inst_psrld_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.PSRLD, Register(dst), src.mem, 16) } -inst_psrld_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, imm: i8) -> Instruction { return inst_r_i(.PSRLD, Register(dst), i64(imm), 1) } -emit_psrld_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .PSRLD, Register(dst), Register(src)) } -emit_psrld_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .PSRLD, Register(dst), src.mem, 16) } -emit_psrld_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, imm: i8) { emit_ri(instructions, .PSRLD, Register(dst), i64(imm), 1) } -inst_psrlq_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.PSRLQ, Register(dst), Register(src)) } -inst_psrlq_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.PSRLQ, Register(dst), src.mem, 16) } -inst_psrlq_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, imm: i8) -> Instruction { return inst_r_i(.PSRLQ, Register(dst), i64(imm), 1) } -emit_psrlq_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .PSRLQ, Register(dst), Register(src)) } -emit_psrlq_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .PSRLQ, Register(dst), src.mem, 16) } -emit_psrlq_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, imm: i8) { emit_ri(instructions, .PSRLQ, Register(dst), i64(imm), 1) } -inst_psraw_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.PSRAW, Register(dst), Register(src)) } -inst_psraw_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.PSRAW, Register(dst), src.mem, 16) } -inst_psraw_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, imm: i8) -> Instruction { return inst_r_i(.PSRAW, Register(dst), i64(imm), 1) } -emit_psraw_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .PSRAW, Register(dst), Register(src)) } -emit_psraw_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .PSRAW, Register(dst), src.mem, 16) } -emit_psraw_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, imm: i8) { emit_ri(instructions, .PSRAW, Register(dst), i64(imm), 1) } -inst_psrad_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.PSRAD, Register(dst), Register(src)) } -inst_psrad_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.PSRAD, Register(dst), src.mem, 16) } -inst_psrad_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, imm: i8) -> Instruction { return inst_r_i(.PSRAD, Register(dst), i64(imm), 1) } -emit_psrad_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .PSRAD, Register(dst), Register(src)) } -emit_psrad_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .PSRAD, Register(dst), src.mem, 16) } -emit_psrad_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, imm: i8) { emit_ri(instructions, .PSRAD, Register(dst), i64(imm), 1) } -inst_pcmpeqb_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.PCMPEQB, Register(dst), Register(src)) } -inst_pcmpeqb_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.PCMPEQB, Register(dst), src.mem, 16) } -emit_pcmpeqb_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .PCMPEQB, Register(dst), Register(src)) } -emit_pcmpeqb_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .PCMPEQB, Register(dst), src.mem, 16) } -inst_pcmpeqw_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.PCMPEQW, Register(dst), Register(src)) } -inst_pcmpeqw_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.PCMPEQW, Register(dst), src.mem, 16) } -emit_pcmpeqw_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .PCMPEQW, Register(dst), Register(src)) } -emit_pcmpeqw_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .PCMPEQW, Register(dst), src.mem, 16) } -inst_pcmpeqd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.PCMPEQD, Register(dst), Register(src)) } -inst_pcmpeqd_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.PCMPEQD, Register(dst), src.mem, 16) } -emit_pcmpeqd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .PCMPEQD, Register(dst), Register(src)) } -emit_pcmpeqd_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .PCMPEQD, Register(dst), src.mem, 16) } -inst_pcmpgtb_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.PCMPGTB, Register(dst), Register(src)) } -inst_pcmpgtb_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.PCMPGTB, Register(dst), src.mem, 16) } -emit_pcmpgtb_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .PCMPGTB, Register(dst), Register(src)) } -emit_pcmpgtb_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .PCMPGTB, Register(dst), src.mem, 16) } -inst_pcmpgtw_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.PCMPGTW, Register(dst), Register(src)) } -inst_pcmpgtw_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.PCMPGTW, Register(dst), src.mem, 16) } -emit_pcmpgtw_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .PCMPGTW, Register(dst), Register(src)) } -emit_pcmpgtw_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .PCMPGTW, Register(dst), src.mem, 16) } -inst_pcmpgtd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.PCMPGTD, Register(dst), Register(src)) } -inst_pcmpgtd_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.PCMPGTD, Register(dst), src.mem, 16) } -emit_pcmpgtd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .PCMPGTD, Register(dst), Register(src)) } -emit_pcmpgtd_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .PCMPGTD, Register(dst), src.mem, 16) } -inst_packsswb_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.PACKSSWB, Register(dst), Register(src)) } -inst_packsswb_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.PACKSSWB, Register(dst), src.mem, 16) } -emit_packsswb_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .PACKSSWB, Register(dst), Register(src)) } -emit_packsswb_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .PACKSSWB, Register(dst), src.mem, 16) } -inst_packssdw_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.PACKSSDW, Register(dst), Register(src)) } -inst_packssdw_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.PACKSSDW, Register(dst), src.mem, 16) } -emit_packssdw_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .PACKSSDW, Register(dst), Register(src)) } -emit_packssdw_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .PACKSSDW, Register(dst), src.mem, 16) } -inst_packuswb_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.PACKUSWB, Register(dst), Register(src)) } -inst_packuswb_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.PACKUSWB, Register(dst), src.mem, 16) } -emit_packuswb_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .PACKUSWB, Register(dst), Register(src)) } -emit_packuswb_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .PACKUSWB, Register(dst), src.mem, 16) } -inst_punpcklbw_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.PUNPCKLBW, Register(dst), Register(src)) } -inst_punpcklbw_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.PUNPCKLBW, Register(dst), src.mem, 16) } -emit_punpcklbw_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .PUNPCKLBW, Register(dst), Register(src)) } -emit_punpcklbw_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .PUNPCKLBW, Register(dst), src.mem, 16) } -inst_punpcklwd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.PUNPCKLWD, Register(dst), Register(src)) } -inst_punpcklwd_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.PUNPCKLWD, Register(dst), src.mem, 16) } -emit_punpcklwd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .PUNPCKLWD, Register(dst), Register(src)) } -emit_punpcklwd_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .PUNPCKLWD, Register(dst), src.mem, 16) } -inst_punpckldq_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.PUNPCKLDQ, Register(dst), Register(src)) } -inst_punpckldq_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.PUNPCKLDQ, Register(dst), src.mem, 16) } -emit_punpckldq_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .PUNPCKLDQ, Register(dst), Register(src)) } -emit_punpckldq_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .PUNPCKLDQ, Register(dst), src.mem, 16) } -inst_punpcklqdq_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.PUNPCKLQDQ, Register(dst), Register(src)) } -inst_punpcklqdq_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.PUNPCKLQDQ, Register(dst), src.mem, 16) } -emit_punpcklqdq_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .PUNPCKLQDQ, Register(dst), Register(src)) } -emit_punpcklqdq_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .PUNPCKLQDQ, Register(dst), src.mem, 16) } -inst_punpckhbw_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.PUNPCKHBW, Register(dst), Register(src)) } -inst_punpckhbw_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.PUNPCKHBW, Register(dst), src.mem, 16) } -emit_punpckhbw_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .PUNPCKHBW, Register(dst), Register(src)) } -emit_punpckhbw_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .PUNPCKHBW, Register(dst), src.mem, 16) } -inst_punpckhwd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.PUNPCKHWD, Register(dst), Register(src)) } -inst_punpckhwd_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.PUNPCKHWD, Register(dst), src.mem, 16) } -emit_punpckhwd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .PUNPCKHWD, Register(dst), Register(src)) } -emit_punpckhwd_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .PUNPCKHWD, Register(dst), src.mem, 16) } -inst_punpckhdq_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.PUNPCKHDQ, Register(dst), Register(src)) } -inst_punpckhdq_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.PUNPCKHDQ, Register(dst), src.mem, 16) } -emit_punpckhdq_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .PUNPCKHDQ, Register(dst), Register(src)) } -emit_punpckhdq_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .PUNPCKHDQ, Register(dst), src.mem, 16) } -inst_punpckhqdq_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.PUNPCKHQDQ, Register(dst), Register(src)) } -inst_punpckhqdq_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.PUNPCKHQDQ, Register(dst), src.mem, 16) } -emit_punpckhqdq_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .PUNPCKHQDQ, Register(dst), Register(src)) } -emit_punpckhqdq_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .PUNPCKHQDQ, Register(dst), src.mem, 16) } -inst_pshufd_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return inst_r_r_i(.PSHUFD, Register(dst), Register(src), i64(imm), 1) } -inst_pshufd_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem128, imm: i8) -> Instruction { return inst_r_m_i(.PSHUFD, Register(dst), src.mem, 16, i64(imm), 1) } -emit_pshufd_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, imm: i8) { emit_rri(instructions, .PSHUFD, Register(dst), Register(src), i64(imm), 1) } -emit_pshufd_xmm_m128_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128, imm: i8) { emit_rmi(instructions, .PSHUFD, Register(dst), src.mem, 16, i64(imm), 1) } -inst_pshufhw_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return inst_r_r_i(.PSHUFHW, Register(dst), Register(src), i64(imm), 1) } -inst_pshufhw_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem128, imm: i8) -> Instruction { return inst_r_m_i(.PSHUFHW, Register(dst), src.mem, 16, i64(imm), 1) } -emit_pshufhw_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, imm: i8) { emit_rri(instructions, .PSHUFHW, Register(dst), Register(src), i64(imm), 1) } -emit_pshufhw_xmm_m128_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128, imm: i8) { emit_rmi(instructions, .PSHUFHW, Register(dst), src.mem, 16, i64(imm), 1) } -inst_pshuflw_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return inst_r_r_i(.PSHUFLW, Register(dst), Register(src), i64(imm), 1) } -inst_pshuflw_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem128, imm: i8) -> Instruction { return inst_r_m_i(.PSHUFLW, Register(dst), src.mem, 16, i64(imm), 1) } -emit_pshuflw_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, imm: i8) { emit_rri(instructions, .PSHUFLW, Register(dst), Register(src), i64(imm), 1) } -emit_pshuflw_xmm_m128_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128, imm: i8) { emit_rmi(instructions, .PSHUFLW, Register(dst), src.mem, 16, i64(imm), 1) } -inst_pshufw_mm_mm_imm8 :: #force_inline proc "contextless" (dst: MM, src: MM, imm: i8) -> Instruction { return inst_r_r_i(.PSHUFW, Register(dst), Register(src), i64(imm), 1) } -inst_pshufw_mm_m64_imm8 :: #force_inline proc "contextless" (dst: MM, src: Mem64, imm: i8) -> Instruction { return inst_r_m_i(.PSHUFW, Register(dst), src.mem, 8, i64(imm), 1) } -emit_pshufw_mm_mm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: MM, src: MM, imm: i8) { emit_rri(instructions, .PSHUFW, Register(dst), Register(src), i64(imm), 1) } -emit_pshufw_mm_m64_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: MM, src: Mem64, imm: i8) { emit_rmi(instructions, .PSHUFW, Register(dst), src.mem, 8, i64(imm), 1) } -inst_pextrw_r32_xmm_imm8 :: #force_inline proc "contextless" (dst: GPR32, src: XMM, imm: i8) -> Instruction { return inst_r_r_i(.PEXTRW, Register(dst), Register(src), i64(imm), 1) } -inst_pextrw_r64_xmm_imm8 :: #force_inline proc "contextless" (dst: GPR64, src: XMM, imm: i8) -> Instruction { return inst_r_r_i(.PEXTRW, Register(dst), Register(src), i64(imm), 1) } -emit_pextrw_r32_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: XMM, imm: i8) { emit_rri(instructions, .PEXTRW, Register(dst), Register(src), i64(imm), 1) } -emit_pextrw_r64_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: XMM, imm: i8) { emit_rri(instructions, .PEXTRW, Register(dst), Register(src), i64(imm), 1) } -inst_pinsrw_xmm_r32_imm8 :: #force_inline proc "contextless" (dst: XMM, src: GPR32, imm: i8) -> Instruction { return inst_r_r_i(.PINSRW, Register(dst), Register(src), i64(imm), 1) } -inst_pinsrw_xmm_m16_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem16, imm: i8) -> Instruction { return inst_r_m_i(.PINSRW, Register(dst), src.mem, 2, i64(imm), 1) } -emit_pinsrw_xmm_r32_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: GPR32, imm: i8) { emit_rri(instructions, .PINSRW, Register(dst), Register(src), i64(imm), 1) } -emit_pinsrw_xmm_m16_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem16, imm: i8) { emit_rmi(instructions, .PINSRW, Register(dst), src.mem, 2, i64(imm), 1) } -inst_pmovmskb_r32_xmm :: #force_inline proc "contextless" (dst: GPR32, src: XMM) -> Instruction { return inst_r_r(.PMOVMSKB, Register(dst), Register(src)) } -inst_pmovmskb_r64_xmm :: #force_inline proc "contextless" (dst: GPR64, src: XMM) -> Instruction { return inst_r_r(.PMOVMSKB, Register(dst), Register(src)) } -emit_pmovmskb_r32_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: XMM) { emit_rr(instructions, .PMOVMSKB, Register(dst), Register(src)) } -emit_pmovmskb_r64_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: XMM) { emit_rr(instructions, .PMOVMSKB, Register(dst), Register(src)) } -inst_pavgb_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.PAVGB, Register(dst), Register(src)) } -inst_pavgb_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.PAVGB, Register(dst), src.mem, 16) } -emit_pavgb_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .PAVGB, Register(dst), Register(src)) } -emit_pavgb_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .PAVGB, Register(dst), src.mem, 16) } -inst_pavgw_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.PAVGW, Register(dst), Register(src)) } -inst_pavgw_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.PAVGW, Register(dst), src.mem, 16) } -emit_pavgw_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .PAVGW, Register(dst), Register(src)) } -emit_pavgw_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .PAVGW, Register(dst), src.mem, 16) } -inst_pmaxub_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.PMAXUB, Register(dst), Register(src)) } -inst_pmaxub_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.PMAXUB, Register(dst), src.mem, 16) } -emit_pmaxub_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .PMAXUB, Register(dst), Register(src)) } -emit_pmaxub_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .PMAXUB, Register(dst), src.mem, 16) } -inst_pmaxsw_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.PMAXSW, Register(dst), Register(src)) } -inst_pmaxsw_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.PMAXSW, Register(dst), src.mem, 16) } -emit_pmaxsw_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .PMAXSW, Register(dst), Register(src)) } -emit_pmaxsw_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .PMAXSW, Register(dst), src.mem, 16) } -inst_pminub_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.PMINUB, Register(dst), Register(src)) } -inst_pminub_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.PMINUB, Register(dst), src.mem, 16) } -emit_pminub_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .PMINUB, Register(dst), Register(src)) } -emit_pminub_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .PMINUB, Register(dst), src.mem, 16) } -inst_pminsw_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.PMINSW, Register(dst), Register(src)) } -inst_pminsw_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.PMINSW, Register(dst), src.mem, 16) } -emit_pminsw_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .PMINSW, Register(dst), Register(src)) } -emit_pminsw_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .PMINSW, Register(dst), src.mem, 16) } -inst_psadbw_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.PSADBW, Register(dst), Register(src)) } -inst_psadbw_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.PSADBW, Register(dst), src.mem, 16) } -emit_psadbw_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .PSADBW, Register(dst), Register(src)) } -emit_psadbw_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .PSADBW, Register(dst), src.mem, 16) } -inst_maskmovdqu_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.MASKMOVDQU, Register(dst), Register(src)) } -emit_maskmovdqu_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .MASKMOVDQU, Register(dst), Register(src)) } -inst_lfence_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.LFENCE) } -emit_lfence_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .LFENCE) } -inst_sfence_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.SFENCE) } -emit_sfence_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .SFENCE) } -inst_mfence_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.MFENCE) } -emit_mfence_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .MFENCE) } -inst_pause_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.PAUSE) } -emit_pause_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .PAUSE) } -inst_clflush_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return inst_m(.CLFLUSH, dst.mem, 1) } -emit_clflush_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { emit_m(instructions, .CLFLUSH, dst.mem, 1) } -inst_addsubps_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.ADDSUBPS, Register(dst), Register(src)) } -inst_addsubps_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.ADDSUBPS, Register(dst), src.mem, 16) } -emit_addsubps_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .ADDSUBPS, Register(dst), Register(src)) } -emit_addsubps_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .ADDSUBPS, Register(dst), src.mem, 16) } -inst_addsubpd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.ADDSUBPD, Register(dst), Register(src)) } -inst_addsubpd_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.ADDSUBPD, Register(dst), src.mem, 16) } -emit_addsubpd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .ADDSUBPD, Register(dst), Register(src)) } -emit_addsubpd_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .ADDSUBPD, Register(dst), src.mem, 16) } -inst_haddps_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.HADDPS, Register(dst), Register(src)) } -inst_haddps_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.HADDPS, Register(dst), src.mem, 16) } -emit_haddps_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .HADDPS, Register(dst), Register(src)) } -emit_haddps_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .HADDPS, Register(dst), src.mem, 16) } -inst_haddpd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.HADDPD, Register(dst), Register(src)) } -inst_haddpd_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.HADDPD, Register(dst), src.mem, 16) } -emit_haddpd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .HADDPD, Register(dst), Register(src)) } -emit_haddpd_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .HADDPD, Register(dst), src.mem, 16) } -inst_hsubps_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.HSUBPS, Register(dst), Register(src)) } -inst_hsubps_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.HSUBPS, Register(dst), src.mem, 16) } -emit_hsubps_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .HSUBPS, Register(dst), Register(src)) } -emit_hsubps_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .HSUBPS, Register(dst), src.mem, 16) } -inst_hsubpd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.HSUBPD, Register(dst), Register(src)) } -inst_hsubpd_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.HSUBPD, Register(dst), src.mem, 16) } -emit_hsubpd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .HSUBPD, Register(dst), Register(src)) } -emit_hsubpd_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .HSUBPD, Register(dst), src.mem, 16) } -inst_movddup_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.MOVDDUP, Register(dst), Register(src)) } -inst_movddup_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: Mem64) -> Instruction { return inst_r_m(.MOVDDUP, Register(dst), src.mem, 8) } -emit_movddup_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .MOVDDUP, Register(dst), Register(src)) } -emit_movddup_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem64) { emit_rm(instructions, .MOVDDUP, Register(dst), src.mem, 8) } -inst_movsldup_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.MOVSLDUP, Register(dst), Register(src)) } -inst_movsldup_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.MOVSLDUP, Register(dst), src.mem, 16) } -emit_movsldup_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .MOVSLDUP, Register(dst), Register(src)) } -emit_movsldup_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .MOVSLDUP, Register(dst), src.mem, 16) } -inst_movshdup_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.MOVSHDUP, Register(dst), Register(src)) } -inst_movshdup_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.MOVSHDUP, Register(dst), src.mem, 16) } -emit_movshdup_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .MOVSHDUP, Register(dst), Register(src)) } -emit_movshdup_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .MOVSHDUP, Register(dst), src.mem, 16) } -inst_lddqu_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.LDDQU, Register(dst), src.mem, 16) } -emit_lddqu_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .LDDQU, Register(dst), src.mem, 16) } -inst_pshufb_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.PSHUFB, Register(dst), Register(src)) } -inst_pshufb_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.PSHUFB, Register(dst), src.mem, 16) } -emit_pshufb_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .PSHUFB, Register(dst), Register(src)) } -emit_pshufb_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .PSHUFB, Register(dst), src.mem, 16) } -inst_phaddw_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.PHADDW, Register(dst), Register(src)) } -inst_phaddw_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.PHADDW, Register(dst), src.mem, 16) } -emit_phaddw_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .PHADDW, Register(dst), Register(src)) } -emit_phaddw_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .PHADDW, Register(dst), src.mem, 16) } -inst_phaddd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.PHADDD, Register(dst), Register(src)) } -inst_phaddd_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.PHADDD, Register(dst), src.mem, 16) } -emit_phaddd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .PHADDD, Register(dst), Register(src)) } -emit_phaddd_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .PHADDD, Register(dst), src.mem, 16) } -inst_phaddsw_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.PHADDSW, Register(dst), Register(src)) } -inst_phaddsw_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.PHADDSW, Register(dst), src.mem, 16) } -emit_phaddsw_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .PHADDSW, Register(dst), Register(src)) } -emit_phaddsw_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .PHADDSW, Register(dst), src.mem, 16) } -inst_phsubw_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.PHSUBW, Register(dst), Register(src)) } -inst_phsubw_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.PHSUBW, Register(dst), src.mem, 16) } -emit_phsubw_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .PHSUBW, Register(dst), Register(src)) } -emit_phsubw_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .PHSUBW, Register(dst), src.mem, 16) } -inst_phsubd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.PHSUBD, Register(dst), Register(src)) } -inst_phsubd_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.PHSUBD, Register(dst), src.mem, 16) } -emit_phsubd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .PHSUBD, Register(dst), Register(src)) } -emit_phsubd_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .PHSUBD, Register(dst), src.mem, 16) } -inst_phsubsw_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.PHSUBSW, Register(dst), Register(src)) } -inst_phsubsw_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.PHSUBSW, Register(dst), src.mem, 16) } -emit_phsubsw_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .PHSUBSW, Register(dst), Register(src)) } -emit_phsubsw_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .PHSUBSW, Register(dst), src.mem, 16) } -inst_pmaddubsw_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.PMADDUBSW, Register(dst), Register(src)) } -inst_pmaddubsw_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.PMADDUBSW, Register(dst), src.mem, 16) } -emit_pmaddubsw_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .PMADDUBSW, Register(dst), Register(src)) } -emit_pmaddubsw_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .PMADDUBSW, Register(dst), src.mem, 16) } -inst_pmulhrsw_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.PMULHRSW, Register(dst), Register(src)) } -inst_pmulhrsw_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.PMULHRSW, Register(dst), src.mem, 16) } -emit_pmulhrsw_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .PMULHRSW, Register(dst), Register(src)) } -emit_pmulhrsw_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .PMULHRSW, Register(dst), src.mem, 16) } -inst_psignb_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.PSIGNB, Register(dst), Register(src)) } -inst_psignb_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.PSIGNB, Register(dst), src.mem, 16) } -emit_psignb_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .PSIGNB, Register(dst), Register(src)) } -emit_psignb_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .PSIGNB, Register(dst), src.mem, 16) } -inst_psignw_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.PSIGNW, Register(dst), Register(src)) } -inst_psignw_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.PSIGNW, Register(dst), src.mem, 16) } -emit_psignw_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .PSIGNW, Register(dst), Register(src)) } -emit_psignw_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .PSIGNW, Register(dst), src.mem, 16) } -inst_psignd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.PSIGND, Register(dst), Register(src)) } -inst_psignd_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.PSIGND, Register(dst), src.mem, 16) } -emit_psignd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .PSIGND, Register(dst), Register(src)) } -emit_psignd_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .PSIGND, Register(dst), src.mem, 16) } -inst_pabsb_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.PABSB, Register(dst), Register(src)) } -inst_pabsb_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.PABSB, Register(dst), src.mem, 16) } -emit_pabsb_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .PABSB, Register(dst), Register(src)) } -emit_pabsb_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .PABSB, Register(dst), src.mem, 16) } -inst_pabsw_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.PABSW, Register(dst), Register(src)) } -inst_pabsw_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.PABSW, Register(dst), src.mem, 16) } -emit_pabsw_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .PABSW, Register(dst), Register(src)) } -emit_pabsw_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .PABSW, Register(dst), src.mem, 16) } -inst_pabsd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.PABSD, Register(dst), Register(src)) } -inst_pabsd_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.PABSD, Register(dst), src.mem, 16) } -emit_pabsd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .PABSD, Register(dst), Register(src)) } -emit_pabsd_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .PABSD, Register(dst), src.mem, 16) } -inst_palignr_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return inst_r_r_i(.PALIGNR, Register(dst), Register(src), i64(imm), 1) } -inst_palignr_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem128, imm: i8) -> Instruction { return inst_r_m_i(.PALIGNR, Register(dst), src.mem, 16, i64(imm), 1) } -emit_palignr_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, imm: i8) { emit_rri(instructions, .PALIGNR, Register(dst), Register(src), i64(imm), 1) } -emit_palignr_xmm_m128_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128, imm: i8) { emit_rmi(instructions, .PALIGNR, Register(dst), src.mem, 16, i64(imm), 1) } -inst_blendps_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return inst_r_r_i(.BLENDPS, Register(dst), Register(src), i64(imm), 1) } -inst_blendps_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem128, imm: i8) -> Instruction { return inst_r_m_i(.BLENDPS, Register(dst), src.mem, 16, i64(imm), 1) } -emit_blendps_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, imm: i8) { emit_rri(instructions, .BLENDPS, Register(dst), Register(src), i64(imm), 1) } -emit_blendps_xmm_m128_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128, imm: i8) { emit_rmi(instructions, .BLENDPS, Register(dst), src.mem, 16, i64(imm), 1) } -inst_blendpd_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return inst_r_r_i(.BLENDPD, Register(dst), Register(src), i64(imm), 1) } -inst_blendpd_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem128, imm: i8) -> Instruction { return inst_r_m_i(.BLENDPD, Register(dst), src.mem, 16, i64(imm), 1) } -emit_blendpd_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, imm: i8) { emit_rri(instructions, .BLENDPD, Register(dst), Register(src), i64(imm), 1) } -emit_blendpd_xmm_m128_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128, imm: i8) { emit_rmi(instructions, .BLENDPD, Register(dst), src.mem, 16, i64(imm), 1) } -inst_blendvps_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.BLENDVPS, Register(dst), Register(src)) } -inst_blendvps_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.BLENDVPS, Register(dst), src.mem, 16) } -emit_blendvps_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .BLENDVPS, Register(dst), Register(src)) } -emit_blendvps_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .BLENDVPS, Register(dst), src.mem, 16) } -inst_blendvpd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.BLENDVPD, Register(dst), Register(src)) } -inst_blendvpd_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.BLENDVPD, Register(dst), src.mem, 16) } -emit_blendvpd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .BLENDVPD, Register(dst), Register(src)) } -emit_blendvpd_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .BLENDVPD, Register(dst), src.mem, 16) } -inst_pblendw_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return inst_r_r_i(.PBLENDW, Register(dst), Register(src), i64(imm), 1) } -inst_pblendw_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem128, imm: i8) -> Instruction { return inst_r_m_i(.PBLENDW, Register(dst), src.mem, 16, i64(imm), 1) } -emit_pblendw_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, imm: i8) { emit_rri(instructions, .PBLENDW, Register(dst), Register(src), i64(imm), 1) } -emit_pblendw_xmm_m128_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128, imm: i8) { emit_rmi(instructions, .PBLENDW, Register(dst), src.mem, 16, i64(imm), 1) } -inst_pblendvb_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.PBLENDVB, Register(dst), Register(src)) } -inst_pblendvb_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.PBLENDVB, Register(dst), src.mem, 16) } -emit_pblendvb_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .PBLENDVB, Register(dst), Register(src)) } -emit_pblendvb_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .PBLENDVB, Register(dst), src.mem, 16) } -inst_dpps_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return inst_r_r_i(.DPPS, Register(dst), Register(src), i64(imm), 1) } -inst_dpps_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem128, imm: i8) -> Instruction { return inst_r_m_i(.DPPS, Register(dst), src.mem, 16, i64(imm), 1) } -emit_dpps_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, imm: i8) { emit_rri(instructions, .DPPS, Register(dst), Register(src), i64(imm), 1) } -emit_dpps_xmm_m128_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128, imm: i8) { emit_rmi(instructions, .DPPS, Register(dst), src.mem, 16, i64(imm), 1) } -inst_dppd_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return inst_r_r_i(.DPPD, Register(dst), Register(src), i64(imm), 1) } -inst_dppd_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem128, imm: i8) -> Instruction { return inst_r_m_i(.DPPD, Register(dst), src.mem, 16, i64(imm), 1) } -emit_dppd_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, imm: i8) { emit_rri(instructions, .DPPD, Register(dst), Register(src), i64(imm), 1) } -emit_dppd_xmm_m128_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128, imm: i8) { emit_rmi(instructions, .DPPD, Register(dst), src.mem, 16, i64(imm), 1) } -inst_extractps_r32_xmm_imm8 :: #force_inline proc "contextless" (dst: GPR32, src: XMM, imm: i8) -> Instruction { return inst_r_r_i(.EXTRACTPS, Register(dst), Register(src), i64(imm), 1) } -inst_extractps_m32_xmm_imm8 :: #force_inline proc "contextless" (dst: Mem32, src: XMM, imm: i8) -> Instruction { return inst_m_r_i(.EXTRACTPS, dst.mem, 4, Register(src), i64(imm), 1) } -emit_extractps_r32_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: XMM, imm: i8) { emit_rri(instructions, .EXTRACTPS, Register(dst), Register(src), i64(imm), 1) } -emit_extractps_m32_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, src: XMM, imm: i8) { emit_mri(instructions, .EXTRACTPS, dst.mem, 4, Register(src), i64(imm), 1) } -inst_insertps_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return inst_r_r_i(.INSERTPS, Register(dst), Register(src), i64(imm), 1) } -inst_insertps_xmm_m32_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem32, imm: i8) -> Instruction { return inst_r_m_i(.INSERTPS, Register(dst), src.mem, 4, i64(imm), 1) } -emit_insertps_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, imm: i8) { emit_rri(instructions, .INSERTPS, Register(dst), Register(src), i64(imm), 1) } -emit_insertps_xmm_m32_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem32, imm: i8) { emit_rmi(instructions, .INSERTPS, Register(dst), src.mem, 4, i64(imm), 1) } -inst_mpsadbw_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return inst_r_r_i(.MPSADBW, Register(dst), Register(src), i64(imm), 1) } -inst_mpsadbw_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem128, imm: i8) -> Instruction { return inst_r_m_i(.MPSADBW, Register(dst), src.mem, 16, i64(imm), 1) } -emit_mpsadbw_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, imm: i8) { emit_rri(instructions, .MPSADBW, Register(dst), Register(src), i64(imm), 1) } -emit_mpsadbw_xmm_m128_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128, imm: i8) { emit_rmi(instructions, .MPSADBW, Register(dst), src.mem, 16, i64(imm), 1) } -inst_packusdw_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.PACKUSDW, Register(dst), Register(src)) } -inst_packusdw_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.PACKUSDW, Register(dst), src.mem, 16) } -emit_packusdw_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .PACKUSDW, Register(dst), Register(src)) } -emit_packusdw_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .PACKUSDW, Register(dst), src.mem, 16) } -inst_pextrb_r8_xmm_imm8 :: #force_inline proc "contextless" (dst: GPR8, src: XMM, imm: i8) -> Instruction { return inst_r_r_i(.PEXTRB, Register(dst), Register(src), i64(imm), 1) } -inst_pextrb_m8_xmm_imm8 :: #force_inline proc "contextless" (dst: Mem8, src: XMM, imm: i8) -> Instruction { return inst_m_r_i(.PEXTRB, dst.mem, 1, Register(src), i64(imm), 1) } -emit_pextrb_r8_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8, src: XMM, imm: i8) { emit_rri(instructions, .PEXTRB, Register(dst), Register(src), i64(imm), 1) } -emit_pextrb_m8_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8, src: XMM, imm: i8) { emit_mri(instructions, .PEXTRB, dst.mem, 1, Register(src), i64(imm), 1) } -inst_pextrd_r32_xmm_imm8 :: #force_inline proc "contextless" (dst: GPR32, src: XMM, imm: i8) -> Instruction { return inst_r_r_i(.PEXTRD, Register(dst), Register(src), i64(imm), 1) } -inst_pextrd_m32_xmm_imm8 :: #force_inline proc "contextless" (dst: Mem32, src: XMM, imm: i8) -> Instruction { return inst_m_r_i(.PEXTRD, dst.mem, 4, Register(src), i64(imm), 1) } -emit_pextrd_r32_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: XMM, imm: i8) { emit_rri(instructions, .PEXTRD, Register(dst), Register(src), i64(imm), 1) } -emit_pextrd_m32_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, src: XMM, imm: i8) { emit_mri(instructions, .PEXTRD, dst.mem, 4, Register(src), i64(imm), 1) } -inst_pextrq_r64_xmm_imm8 :: #force_inline proc "contextless" (dst: GPR64, src: XMM, imm: i8) -> Instruction { return inst_r_r_i(.PEXTRQ, Register(dst), Register(src), i64(imm), 1) } -inst_pextrq_m64_xmm_imm8 :: #force_inline proc "contextless" (dst: Mem64, src: XMM, imm: i8) -> Instruction { return inst_m_r_i(.PEXTRQ, dst.mem, 8, Register(src), i64(imm), 1) } -emit_pextrq_r64_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: XMM, imm: i8) { emit_rri(instructions, .PEXTRQ, Register(dst), Register(src), i64(imm), 1) } -emit_pextrq_m64_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, src: XMM, imm: i8) { emit_mri(instructions, .PEXTRQ, dst.mem, 8, Register(src), i64(imm), 1) } -inst_phminposuw_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.PHMINPOSUW, Register(dst), Register(src)) } -inst_phminposuw_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.PHMINPOSUW, Register(dst), src.mem, 16) } -emit_phminposuw_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .PHMINPOSUW, Register(dst), Register(src)) } -emit_phminposuw_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .PHMINPOSUW, Register(dst), src.mem, 16) } -inst_pinsrb_xmm_r8_imm8 :: #force_inline proc "contextless" (dst: XMM, src: GPR8, imm: i8) -> Instruction { return inst_r_r_i(.PINSRB, Register(dst), Register(src), i64(imm), 1) } -inst_pinsrb_xmm_m8_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem8, imm: i8) -> Instruction { return inst_r_m_i(.PINSRB, Register(dst), src.mem, 1, i64(imm), 1) } -emit_pinsrb_xmm_r8_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: GPR8, imm: i8) { emit_rri(instructions, .PINSRB, Register(dst), Register(src), i64(imm), 1) } -emit_pinsrb_xmm_m8_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem8, imm: i8) { emit_rmi(instructions, .PINSRB, Register(dst), src.mem, 1, i64(imm), 1) } -inst_pinsrd_xmm_r32_imm8 :: #force_inline proc "contextless" (dst: XMM, src: GPR32, imm: i8) -> Instruction { return inst_r_r_i(.PINSRD, Register(dst), Register(src), i64(imm), 1) } -inst_pinsrd_xmm_m32_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem32, imm: i8) -> Instruction { return inst_r_m_i(.PINSRD, Register(dst), src.mem, 4, i64(imm), 1) } -emit_pinsrd_xmm_r32_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: GPR32, imm: i8) { emit_rri(instructions, .PINSRD, Register(dst), Register(src), i64(imm), 1) } -emit_pinsrd_xmm_m32_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem32, imm: i8) { emit_rmi(instructions, .PINSRD, Register(dst), src.mem, 4, i64(imm), 1) } -inst_pinsrq_xmm_r64_imm8 :: #force_inline proc "contextless" (dst: XMM, src: GPR64, imm: i8) -> Instruction { return inst_r_r_i(.PINSRQ, Register(dst), Register(src), i64(imm), 1) } -inst_pinsrq_xmm_m64_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem64, imm: i8) -> Instruction { return inst_r_m_i(.PINSRQ, Register(dst), src.mem, 8, i64(imm), 1) } -emit_pinsrq_xmm_r64_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: GPR64, imm: i8) { emit_rri(instructions, .PINSRQ, Register(dst), Register(src), i64(imm), 1) } -emit_pinsrq_xmm_m64_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem64, imm: i8) { emit_rmi(instructions, .PINSRQ, Register(dst), src.mem, 8, i64(imm), 1) } -inst_pmaxsb_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.PMAXSB, Register(dst), Register(src)) } -inst_pmaxsb_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.PMAXSB, Register(dst), src.mem, 16) } -emit_pmaxsb_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .PMAXSB, Register(dst), Register(src)) } -emit_pmaxsb_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .PMAXSB, Register(dst), src.mem, 16) } -inst_pmaxsd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.PMAXSD, Register(dst), Register(src)) } -inst_pmaxsd_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.PMAXSD, Register(dst), src.mem, 16) } -emit_pmaxsd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .PMAXSD, Register(dst), Register(src)) } -emit_pmaxsd_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .PMAXSD, Register(dst), src.mem, 16) } -inst_pmaxuw_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.PMAXUW, Register(dst), Register(src)) } -inst_pmaxuw_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.PMAXUW, Register(dst), src.mem, 16) } -emit_pmaxuw_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .PMAXUW, Register(dst), Register(src)) } -emit_pmaxuw_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .PMAXUW, Register(dst), src.mem, 16) } -inst_pmaxud_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.PMAXUD, Register(dst), Register(src)) } -inst_pmaxud_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.PMAXUD, Register(dst), src.mem, 16) } -emit_pmaxud_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .PMAXUD, Register(dst), Register(src)) } -emit_pmaxud_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .PMAXUD, Register(dst), src.mem, 16) } -inst_pminsb_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.PMINSB, Register(dst), Register(src)) } -inst_pminsb_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.PMINSB, Register(dst), src.mem, 16) } -emit_pminsb_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .PMINSB, Register(dst), Register(src)) } -emit_pminsb_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .PMINSB, Register(dst), src.mem, 16) } -inst_pminsd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.PMINSD, Register(dst), Register(src)) } -inst_pminsd_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.PMINSD, Register(dst), src.mem, 16) } -emit_pminsd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .PMINSD, Register(dst), Register(src)) } -emit_pminsd_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .PMINSD, Register(dst), src.mem, 16) } -inst_pminuw_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.PMINUW, Register(dst), Register(src)) } -inst_pminuw_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.PMINUW, Register(dst), src.mem, 16) } -emit_pminuw_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .PMINUW, Register(dst), Register(src)) } -emit_pminuw_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .PMINUW, Register(dst), src.mem, 16) } -inst_pminud_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.PMINUD, Register(dst), Register(src)) } -inst_pminud_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.PMINUD, Register(dst), src.mem, 16) } -emit_pminud_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .PMINUD, Register(dst), Register(src)) } -emit_pminud_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .PMINUD, Register(dst), src.mem, 16) } -inst_pmovsxbw_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.PMOVSXBW, Register(dst), Register(src)) } -inst_pmovsxbw_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: Mem64) -> Instruction { return inst_r_m(.PMOVSXBW, Register(dst), src.mem, 8) } -emit_pmovsxbw_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .PMOVSXBW, Register(dst), Register(src)) } -emit_pmovsxbw_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem64) { emit_rm(instructions, .PMOVSXBW, Register(dst), src.mem, 8) } -inst_pmovsxbd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.PMOVSXBD, Register(dst), Register(src)) } -inst_pmovsxbd_xmm_m32 :: #force_inline proc "contextless" (dst: XMM, src: Mem32) -> Instruction { return inst_r_m(.PMOVSXBD, Register(dst), src.mem, 4) } -emit_pmovsxbd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .PMOVSXBD, Register(dst), Register(src)) } -emit_pmovsxbd_xmm_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem32) { emit_rm(instructions, .PMOVSXBD, Register(dst), src.mem, 4) } -inst_pmovsxbq_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.PMOVSXBQ, Register(dst), Register(src)) } -inst_pmovsxbq_xmm_m32 :: #force_inline proc "contextless" (dst: XMM, src: Mem32) -> Instruction { return inst_r_m(.PMOVSXBQ, Register(dst), src.mem, 4) } -emit_pmovsxbq_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .PMOVSXBQ, Register(dst), Register(src)) } -emit_pmovsxbq_xmm_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem32) { emit_rm(instructions, .PMOVSXBQ, Register(dst), src.mem, 4) } -inst_pmovsxwd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.PMOVSXWD, Register(dst), Register(src)) } -inst_pmovsxwd_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: Mem64) -> Instruction { return inst_r_m(.PMOVSXWD, Register(dst), src.mem, 8) } -emit_pmovsxwd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .PMOVSXWD, Register(dst), Register(src)) } -emit_pmovsxwd_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem64) { emit_rm(instructions, .PMOVSXWD, Register(dst), src.mem, 8) } -inst_pmovsxwq_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.PMOVSXWQ, Register(dst), Register(src)) } -inst_pmovsxwq_xmm_m32 :: #force_inline proc "contextless" (dst: XMM, src: Mem32) -> Instruction { return inst_r_m(.PMOVSXWQ, Register(dst), src.mem, 4) } -emit_pmovsxwq_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .PMOVSXWQ, Register(dst), Register(src)) } -emit_pmovsxwq_xmm_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem32) { emit_rm(instructions, .PMOVSXWQ, Register(dst), src.mem, 4) } -inst_pmovsxdq_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.PMOVSXDQ, Register(dst), Register(src)) } -inst_pmovsxdq_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: Mem64) -> Instruction { return inst_r_m(.PMOVSXDQ, Register(dst), src.mem, 8) } -emit_pmovsxdq_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .PMOVSXDQ, Register(dst), Register(src)) } -emit_pmovsxdq_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem64) { emit_rm(instructions, .PMOVSXDQ, Register(dst), src.mem, 8) } -inst_pmovzxbw_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.PMOVZXBW, Register(dst), Register(src)) } -inst_pmovzxbw_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: Mem64) -> Instruction { return inst_r_m(.PMOVZXBW, Register(dst), src.mem, 8) } -emit_pmovzxbw_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .PMOVZXBW, Register(dst), Register(src)) } -emit_pmovzxbw_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem64) { emit_rm(instructions, .PMOVZXBW, Register(dst), src.mem, 8) } -inst_pmovzxbd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.PMOVZXBD, Register(dst), Register(src)) } -inst_pmovzxbd_xmm_m32 :: #force_inline proc "contextless" (dst: XMM, src: Mem32) -> Instruction { return inst_r_m(.PMOVZXBD, Register(dst), src.mem, 4) } -emit_pmovzxbd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .PMOVZXBD, Register(dst), Register(src)) } -emit_pmovzxbd_xmm_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem32) { emit_rm(instructions, .PMOVZXBD, Register(dst), src.mem, 4) } -inst_pmovzxbq_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.PMOVZXBQ, Register(dst), Register(src)) } -inst_pmovzxbq_xmm_m32 :: #force_inline proc "contextless" (dst: XMM, src: Mem32) -> Instruction { return inst_r_m(.PMOVZXBQ, Register(dst), src.mem, 4) } -emit_pmovzxbq_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .PMOVZXBQ, Register(dst), Register(src)) } -emit_pmovzxbq_xmm_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem32) { emit_rm(instructions, .PMOVZXBQ, Register(dst), src.mem, 4) } -inst_pmovzxwd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.PMOVZXWD, Register(dst), Register(src)) } -inst_pmovzxwd_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: Mem64) -> Instruction { return inst_r_m(.PMOVZXWD, Register(dst), src.mem, 8) } -emit_pmovzxwd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .PMOVZXWD, Register(dst), Register(src)) } -emit_pmovzxwd_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem64) { emit_rm(instructions, .PMOVZXWD, Register(dst), src.mem, 8) } -inst_pmovzxwq_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.PMOVZXWQ, Register(dst), Register(src)) } -inst_pmovzxwq_xmm_m32 :: #force_inline proc "contextless" (dst: XMM, src: Mem32) -> Instruction { return inst_r_m(.PMOVZXWQ, Register(dst), src.mem, 4) } -emit_pmovzxwq_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .PMOVZXWQ, Register(dst), Register(src)) } -emit_pmovzxwq_xmm_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem32) { emit_rm(instructions, .PMOVZXWQ, Register(dst), src.mem, 4) } -inst_pmovzxdq_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.PMOVZXDQ, Register(dst), Register(src)) } -inst_pmovzxdq_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: Mem64) -> Instruction { return inst_r_m(.PMOVZXDQ, Register(dst), src.mem, 8) } -emit_pmovzxdq_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .PMOVZXDQ, Register(dst), Register(src)) } -emit_pmovzxdq_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem64) { emit_rm(instructions, .PMOVZXDQ, Register(dst), src.mem, 8) } -inst_pmuldq_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.PMULDQ, Register(dst), Register(src)) } -inst_pmuldq_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.PMULDQ, Register(dst), src.mem, 16) } -emit_pmuldq_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .PMULDQ, Register(dst), Register(src)) } -emit_pmuldq_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .PMULDQ, Register(dst), src.mem, 16) } -inst_pmulld_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.PMULLD, Register(dst), Register(src)) } -inst_pmulld_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.PMULLD, Register(dst), src.mem, 16) } -emit_pmulld_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .PMULLD, Register(dst), Register(src)) } -emit_pmulld_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .PMULLD, Register(dst), src.mem, 16) } -inst_ptest_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.PTEST, Register(dst), Register(src)) } -inst_ptest_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.PTEST, Register(dst), src.mem, 16) } -emit_ptest_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .PTEST, Register(dst), Register(src)) } -emit_ptest_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .PTEST, Register(dst), src.mem, 16) } -inst_roundps_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return inst_r_r_i(.ROUNDPS, Register(dst), Register(src), i64(imm), 1) } -inst_roundps_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem128, imm: i8) -> Instruction { return inst_r_m_i(.ROUNDPS, Register(dst), src.mem, 16, i64(imm), 1) } -emit_roundps_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, imm: i8) { emit_rri(instructions, .ROUNDPS, Register(dst), Register(src), i64(imm), 1) } -emit_roundps_xmm_m128_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128, imm: i8) { emit_rmi(instructions, .ROUNDPS, Register(dst), src.mem, 16, i64(imm), 1) } -inst_roundpd_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return inst_r_r_i(.ROUNDPD, Register(dst), Register(src), i64(imm), 1) } -inst_roundpd_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem128, imm: i8) -> Instruction { return inst_r_m_i(.ROUNDPD, Register(dst), src.mem, 16, i64(imm), 1) } -emit_roundpd_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, imm: i8) { emit_rri(instructions, .ROUNDPD, Register(dst), Register(src), i64(imm), 1) } -emit_roundpd_xmm_m128_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128, imm: i8) { emit_rmi(instructions, .ROUNDPD, Register(dst), src.mem, 16, i64(imm), 1) } -inst_roundss_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return inst_r_r_i(.ROUNDSS, Register(dst), Register(src), i64(imm), 1) } -inst_roundss_xmm_m32_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem32, imm: i8) -> Instruction { return inst_r_m_i(.ROUNDSS, Register(dst), src.mem, 4, i64(imm), 1) } -emit_roundss_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, imm: i8) { emit_rri(instructions, .ROUNDSS, Register(dst), Register(src), i64(imm), 1) } -emit_roundss_xmm_m32_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem32, imm: i8) { emit_rmi(instructions, .ROUNDSS, Register(dst), src.mem, 4, i64(imm), 1) } -inst_roundsd_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return inst_r_r_i(.ROUNDSD, Register(dst), Register(src), i64(imm), 1) } -inst_roundsd_xmm_m64_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem64, imm: i8) -> Instruction { return inst_r_m_i(.ROUNDSD, Register(dst), src.mem, 8, i64(imm), 1) } -emit_roundsd_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, imm: i8) { emit_rri(instructions, .ROUNDSD, Register(dst), Register(src), i64(imm), 1) } -emit_roundsd_xmm_m64_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem64, imm: i8) { emit_rmi(instructions, .ROUNDSD, Register(dst), src.mem, 8, i64(imm), 1) } -inst_pcmpeqq_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.PCMPEQQ, Register(dst), Register(src)) } -inst_pcmpeqq_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.PCMPEQQ, Register(dst), src.mem, 16) } -emit_pcmpeqq_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .PCMPEQQ, Register(dst), Register(src)) } -emit_pcmpeqq_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .PCMPEQQ, Register(dst), src.mem, 16) } -inst_crc32_r32_r8 :: #force_inline proc "contextless" (dst: GPR32, src: GPR8) -> Instruction { return inst_r_r(.CRC32, Register(dst), Register(src)) } -inst_crc32_r32_m8 :: #force_inline proc "contextless" (dst: GPR32, src: Mem8) -> Instruction { return inst_r_m(.CRC32, Register(dst), src.mem, 1) } -inst_crc32_r32_r16 :: #force_inline proc "contextless" (dst: GPR32, src: GPR16) -> Instruction { return inst_r_r(.CRC32, Register(dst), Register(src)) } -inst_crc32_r32_m16 :: #force_inline proc "contextless" (dst: GPR32, src: Mem16) -> Instruction { return inst_r_m(.CRC32, Register(dst), src.mem, 2) } -inst_crc32_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return inst_r_r(.CRC32, Register(dst), Register(src)) } -inst_crc32_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32) -> Instruction { return inst_r_m(.CRC32, Register(dst), src.mem, 4) } -inst_crc32_r64_r8 :: #force_inline proc "contextless" (dst: GPR64, src: GPR8) -> Instruction { return inst_r_r(.CRC32, Register(dst), Register(src)) } -inst_crc32_r64_m8 :: #force_inline proc "contextless" (dst: GPR64, src: Mem8) -> Instruction { return inst_r_m(.CRC32, Register(dst), src.mem, 1) } -inst_crc32_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return inst_r_r(.CRC32, Register(dst), Register(src)) } -inst_crc32_r64_m64 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64) -> Instruction { return inst_r_m(.CRC32, Register(dst), src.mem, 8) } -emit_crc32_r32_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR8) { emit_rr(instructions, .CRC32, Register(dst), Register(src)) } -emit_crc32_r32_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem8) { emit_rm(instructions, .CRC32, Register(dst), src.mem, 1) } -emit_crc32_r32_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR16) { emit_rr(instructions, .CRC32, Register(dst), Register(src)) } -emit_crc32_r32_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem16) { emit_rm(instructions, .CRC32, Register(dst), src.mem, 2) } -emit_crc32_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { emit_rr(instructions, .CRC32, Register(dst), Register(src)) } -emit_crc32_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32) { emit_rm(instructions, .CRC32, Register(dst), src.mem, 4) } -emit_crc32_r64_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR8) { emit_rr(instructions, .CRC32, Register(dst), Register(src)) } -emit_crc32_r64_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem8) { emit_rm(instructions, .CRC32, Register(dst), src.mem, 1) } -emit_crc32_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { emit_rr(instructions, .CRC32, Register(dst), Register(src)) } -emit_crc32_r64_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem64) { emit_rm(instructions, .CRC32, Register(dst), src.mem, 8) } -inst_pcmpestri_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return inst_r_r_i(.PCMPESTRI, Register(dst), Register(src), i64(imm), 1) } -inst_pcmpestri_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem128, imm: i8) -> Instruction { return inst_r_m_i(.PCMPESTRI, Register(dst), src.mem, 16, i64(imm), 1) } -emit_pcmpestri_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, imm: i8) { emit_rri(instructions, .PCMPESTRI, Register(dst), Register(src), i64(imm), 1) } -emit_pcmpestri_xmm_m128_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128, imm: i8) { emit_rmi(instructions, .PCMPESTRI, Register(dst), src.mem, 16, i64(imm), 1) } -inst_pcmpestrm_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return inst_r_r_i(.PCMPESTRM, Register(dst), Register(src), i64(imm), 1) } -inst_pcmpestrm_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem128, imm: i8) -> Instruction { return inst_r_m_i(.PCMPESTRM, Register(dst), src.mem, 16, i64(imm), 1) } -emit_pcmpestrm_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, imm: i8) { emit_rri(instructions, .PCMPESTRM, Register(dst), Register(src), i64(imm), 1) } -emit_pcmpestrm_xmm_m128_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128, imm: i8) { emit_rmi(instructions, .PCMPESTRM, Register(dst), src.mem, 16, i64(imm), 1) } -inst_pcmpistri_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return inst_r_r_i(.PCMPISTRI, Register(dst), Register(src), i64(imm), 1) } -inst_pcmpistri_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem128, imm: i8) -> Instruction { return inst_r_m_i(.PCMPISTRI, Register(dst), src.mem, 16, i64(imm), 1) } -emit_pcmpistri_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, imm: i8) { emit_rri(instructions, .PCMPISTRI, Register(dst), Register(src), i64(imm), 1) } -emit_pcmpistri_xmm_m128_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128, imm: i8) { emit_rmi(instructions, .PCMPISTRI, Register(dst), src.mem, 16, i64(imm), 1) } -inst_pcmpistrm_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return inst_r_r_i(.PCMPISTRM, Register(dst), Register(src), i64(imm), 1) } -inst_pcmpistrm_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem128, imm: i8) -> Instruction { return inst_r_m_i(.PCMPISTRM, Register(dst), src.mem, 16, i64(imm), 1) } -emit_pcmpistrm_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, imm: i8) { emit_rri(instructions, .PCMPISTRM, Register(dst), Register(src), i64(imm), 1) } -emit_pcmpistrm_xmm_m128_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128, imm: i8) { emit_rmi(instructions, .PCMPISTRM, Register(dst), src.mem, 16, i64(imm), 1) } -inst_pcmpgtq_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.PCMPGTQ, Register(dst), Register(src)) } -inst_pcmpgtq_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.PCMPGTQ, Register(dst), src.mem, 16) } -emit_pcmpgtq_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .PCMPGTQ, Register(dst), Register(src)) } -emit_pcmpgtq_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .PCMPGTQ, Register(dst), src.mem, 16) } -inst_pclmulqdq_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return inst_r_r_i(.PCLMULQDQ, Register(dst), Register(src), i64(imm), 1) } -inst_pclmulqdq_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem128, imm: i8) -> Instruction { return inst_r_m_i(.PCLMULQDQ, Register(dst), src.mem, 16, i64(imm), 1) } -emit_pclmulqdq_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, imm: i8) { emit_rri(instructions, .PCLMULQDQ, Register(dst), Register(src), i64(imm), 1) } -emit_pclmulqdq_xmm_m128_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128, imm: i8) { emit_rmi(instructions, .PCLMULQDQ, Register(dst), src.mem, 16, i64(imm), 1) } -inst_aesdec_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.AESDEC, Register(dst), Register(src)) } -inst_aesdec_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.AESDEC, Register(dst), src.mem, 16) } -emit_aesdec_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .AESDEC, Register(dst), Register(src)) } -emit_aesdec_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .AESDEC, Register(dst), src.mem, 16) } -inst_aesdeclast_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.AESDECLAST, Register(dst), Register(src)) } -inst_aesdeclast_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.AESDECLAST, Register(dst), src.mem, 16) } -emit_aesdeclast_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .AESDECLAST, Register(dst), Register(src)) } -emit_aesdeclast_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .AESDECLAST, Register(dst), src.mem, 16) } -inst_aesenc_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.AESENC, Register(dst), Register(src)) } -inst_aesenc_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.AESENC, Register(dst), src.mem, 16) } -emit_aesenc_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .AESENC, Register(dst), Register(src)) } -emit_aesenc_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .AESENC, Register(dst), src.mem, 16) } -inst_aesenclast_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.AESENCLAST, Register(dst), Register(src)) } -inst_aesenclast_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.AESENCLAST, Register(dst), src.mem, 16) } -emit_aesenclast_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .AESENCLAST, Register(dst), Register(src)) } -emit_aesenclast_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .AESENCLAST, Register(dst), src.mem, 16) } -inst_aesimc_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.AESIMC, Register(dst), Register(src)) } -inst_aesimc_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.AESIMC, Register(dst), src.mem, 16) } -emit_aesimc_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .AESIMC, Register(dst), Register(src)) } -emit_aesimc_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .AESIMC, Register(dst), src.mem, 16) } -inst_aeskeygenassist_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return inst_r_r_i(.AESKEYGENASSIST, Register(dst), Register(src), i64(imm), 1) } -inst_aeskeygenassist_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem128, imm: i8) -> Instruction { return inst_r_m_i(.AESKEYGENASSIST, Register(dst), src.mem, 16, i64(imm), 1) } -emit_aeskeygenassist_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, imm: i8) { emit_rri(instructions, .AESKEYGENASSIST, Register(dst), Register(src), i64(imm), 1) } -emit_aeskeygenassist_xmm_m128_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128, imm: i8) { emit_rmi(instructions, .AESKEYGENASSIST, Register(dst), src.mem, 16, i64(imm), 1) } -inst_sha1msg1_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.SHA1MSG1, Register(dst), Register(src)) } -inst_sha1msg1_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.SHA1MSG1, Register(dst), src.mem, 16) } -emit_sha1msg1_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .SHA1MSG1, Register(dst), Register(src)) } -emit_sha1msg1_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .SHA1MSG1, Register(dst), src.mem, 16) } -inst_sha1msg2_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.SHA1MSG2, Register(dst), Register(src)) } -inst_sha1msg2_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.SHA1MSG2, Register(dst), src.mem, 16) } -emit_sha1msg2_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .SHA1MSG2, Register(dst), Register(src)) } -emit_sha1msg2_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .SHA1MSG2, Register(dst), src.mem, 16) } -inst_sha1nexte_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.SHA1NEXTE, Register(dst), Register(src)) } -inst_sha1nexte_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.SHA1NEXTE, Register(dst), src.mem, 16) } -emit_sha1nexte_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .SHA1NEXTE, Register(dst), Register(src)) } -emit_sha1nexte_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .SHA1NEXTE, Register(dst), src.mem, 16) } -inst_sha1rnds4_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return inst_r_r_i(.SHA1RNDS4, Register(dst), Register(src), i64(imm), 1) } -inst_sha1rnds4_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem128, imm: i8) -> Instruction { return inst_r_m_i(.SHA1RNDS4, Register(dst), src.mem, 16, i64(imm), 1) } -emit_sha1rnds4_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, imm: i8) { emit_rri(instructions, .SHA1RNDS4, Register(dst), Register(src), i64(imm), 1) } -emit_sha1rnds4_xmm_m128_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128, imm: i8) { emit_rmi(instructions, .SHA1RNDS4, Register(dst), src.mem, 16, i64(imm), 1) } -inst_sha256msg1_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.SHA256MSG1, Register(dst), Register(src)) } -inst_sha256msg1_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.SHA256MSG1, Register(dst), src.mem, 16) } -emit_sha256msg1_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .SHA256MSG1, Register(dst), Register(src)) } -emit_sha256msg1_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .SHA256MSG1, Register(dst), src.mem, 16) } -inst_sha256msg2_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.SHA256MSG2, Register(dst), Register(src)) } -inst_sha256msg2_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.SHA256MSG2, Register(dst), src.mem, 16) } -emit_sha256msg2_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .SHA256MSG2, Register(dst), Register(src)) } -emit_sha256msg2_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .SHA256MSG2, Register(dst), src.mem, 16) } -inst_sha256rnds2_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.SHA256RNDS2, Register(dst), Register(src)) } -inst_sha256rnds2_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.SHA256RNDS2, Register(dst), src.mem, 16) } -emit_sha256rnds2_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .SHA256RNDS2, Register(dst), Register(src)) } -emit_sha256rnds2_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .SHA256RNDS2, Register(dst), src.mem, 16) } -inst_vaddps_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VADDPS, Register(dst), Register(src), Register(src2)) } -inst_vaddps_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VADDPS, Register(dst), Register(src), src2.mem, 16) } -inst_vaddps_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VADDPS, Register(dst), Register(src), Register(src2)) } -inst_vaddps_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VADDPS, Register(dst), Register(src), src2.mem, 32) } -emit_vaddps_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VADDPS, Register(dst), Register(src), Register(src2)) } -emit_vaddps_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VADDPS, Register(dst), Register(src), src2.mem, 16) } -emit_vaddps_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VADDPS, Register(dst), Register(src), Register(src2)) } -emit_vaddps_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VADDPS, Register(dst), Register(src), src2.mem, 32) } -inst_vaddpd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VADDPD, Register(dst), Register(src), Register(src2)) } -inst_vaddpd_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VADDPD, Register(dst), Register(src), src2.mem, 16) } -inst_vaddpd_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VADDPD, Register(dst), Register(src), Register(src2)) } -inst_vaddpd_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VADDPD, Register(dst), Register(src), src2.mem, 32) } -emit_vaddpd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VADDPD, Register(dst), Register(src), Register(src2)) } -emit_vaddpd_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VADDPD, Register(dst), Register(src), src2.mem, 16) } -emit_vaddpd_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VADDPD, Register(dst), Register(src), Register(src2)) } -emit_vaddpd_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VADDPD, Register(dst), Register(src), src2.mem, 32) } -inst_vaddss_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VADDSS, Register(dst), Register(src), Register(src2)) } -inst_vaddss_xmm_xmm_m32 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem32) -> Instruction { return inst_r_r_m(.VADDSS, Register(dst), Register(src), src2.mem, 4) } -emit_vaddss_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VADDSS, Register(dst), Register(src), Register(src2)) } -emit_vaddss_xmm_xmm_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem32) { emit_rrm(instructions, .VADDSS, Register(dst), Register(src), src2.mem, 4) } -inst_vaddsd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VADDSD, Register(dst), Register(src), Register(src2)) } -inst_vaddsd_xmm_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem64) -> Instruction { return inst_r_r_m(.VADDSD, Register(dst), Register(src), src2.mem, 8) } -emit_vaddsd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VADDSD, Register(dst), Register(src), Register(src2)) } -emit_vaddsd_xmm_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem64) { emit_rrm(instructions, .VADDSD, Register(dst), Register(src), src2.mem, 8) } -inst_vsubps_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VSUBPS, Register(dst), Register(src), Register(src2)) } -inst_vsubps_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VSUBPS, Register(dst), Register(src), src2.mem, 16) } -inst_vsubps_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VSUBPS, Register(dst), Register(src), Register(src2)) } -inst_vsubps_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VSUBPS, Register(dst), Register(src), src2.mem, 32) } -emit_vsubps_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VSUBPS, Register(dst), Register(src), Register(src2)) } -emit_vsubps_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VSUBPS, Register(dst), Register(src), src2.mem, 16) } -emit_vsubps_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VSUBPS, Register(dst), Register(src), Register(src2)) } -emit_vsubps_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VSUBPS, Register(dst), Register(src), src2.mem, 32) } -inst_vsubpd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VSUBPD, Register(dst), Register(src), Register(src2)) } -inst_vsubpd_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VSUBPD, Register(dst), Register(src), src2.mem, 16) } -inst_vsubpd_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VSUBPD, Register(dst), Register(src), Register(src2)) } -inst_vsubpd_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VSUBPD, Register(dst), Register(src), src2.mem, 32) } -emit_vsubpd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VSUBPD, Register(dst), Register(src), Register(src2)) } -emit_vsubpd_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VSUBPD, Register(dst), Register(src), src2.mem, 16) } -emit_vsubpd_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VSUBPD, Register(dst), Register(src), Register(src2)) } -emit_vsubpd_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VSUBPD, Register(dst), Register(src), src2.mem, 32) } -inst_vsubss_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VSUBSS, Register(dst), Register(src), Register(src2)) } -inst_vsubss_xmm_xmm_m32 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem32) -> Instruction { return inst_r_r_m(.VSUBSS, Register(dst), Register(src), src2.mem, 4) } -emit_vsubss_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VSUBSS, Register(dst), Register(src), Register(src2)) } -emit_vsubss_xmm_xmm_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem32) { emit_rrm(instructions, .VSUBSS, Register(dst), Register(src), src2.mem, 4) } -inst_vsubsd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VSUBSD, Register(dst), Register(src), Register(src2)) } -inst_vsubsd_xmm_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem64) -> Instruction { return inst_r_r_m(.VSUBSD, Register(dst), Register(src), src2.mem, 8) } -emit_vsubsd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VSUBSD, Register(dst), Register(src), Register(src2)) } -emit_vsubsd_xmm_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem64) { emit_rrm(instructions, .VSUBSD, Register(dst), Register(src), src2.mem, 8) } -inst_vmulps_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VMULPS, Register(dst), Register(src), Register(src2)) } -inst_vmulps_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VMULPS, Register(dst), Register(src), src2.mem, 16) } -inst_vmulps_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VMULPS, Register(dst), Register(src), Register(src2)) } -inst_vmulps_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VMULPS, Register(dst), Register(src), src2.mem, 32) } -emit_vmulps_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VMULPS, Register(dst), Register(src), Register(src2)) } -emit_vmulps_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VMULPS, Register(dst), Register(src), src2.mem, 16) } -emit_vmulps_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VMULPS, Register(dst), Register(src), Register(src2)) } -emit_vmulps_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VMULPS, Register(dst), Register(src), src2.mem, 32) } -inst_vmulpd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VMULPD, Register(dst), Register(src), Register(src2)) } -inst_vmulpd_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VMULPD, Register(dst), Register(src), src2.mem, 16) } -inst_vmulpd_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VMULPD, Register(dst), Register(src), Register(src2)) } -inst_vmulpd_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VMULPD, Register(dst), Register(src), src2.mem, 32) } -emit_vmulpd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VMULPD, Register(dst), Register(src), Register(src2)) } -emit_vmulpd_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VMULPD, Register(dst), Register(src), src2.mem, 16) } -emit_vmulpd_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VMULPD, Register(dst), Register(src), Register(src2)) } -emit_vmulpd_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VMULPD, Register(dst), Register(src), src2.mem, 32) } -inst_vmulss_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VMULSS, Register(dst), Register(src), Register(src2)) } -inst_vmulss_xmm_xmm_m32 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem32) -> Instruction { return inst_r_r_m(.VMULSS, Register(dst), Register(src), src2.mem, 4) } -emit_vmulss_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VMULSS, Register(dst), Register(src), Register(src2)) } -emit_vmulss_xmm_xmm_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem32) { emit_rrm(instructions, .VMULSS, Register(dst), Register(src), src2.mem, 4) } -inst_vmulsd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VMULSD, Register(dst), Register(src), Register(src2)) } -inst_vmulsd_xmm_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem64) -> Instruction { return inst_r_r_m(.VMULSD, Register(dst), Register(src), src2.mem, 8) } -emit_vmulsd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VMULSD, Register(dst), Register(src), Register(src2)) } -emit_vmulsd_xmm_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem64) { emit_rrm(instructions, .VMULSD, Register(dst), Register(src), src2.mem, 8) } -inst_vdivps_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VDIVPS, Register(dst), Register(src), Register(src2)) } -inst_vdivps_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VDIVPS, Register(dst), Register(src), src2.mem, 16) } -inst_vdivps_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VDIVPS, Register(dst), Register(src), Register(src2)) } -inst_vdivps_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VDIVPS, Register(dst), Register(src), src2.mem, 32) } -emit_vdivps_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VDIVPS, Register(dst), Register(src), Register(src2)) } -emit_vdivps_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VDIVPS, Register(dst), Register(src), src2.mem, 16) } -emit_vdivps_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VDIVPS, Register(dst), Register(src), Register(src2)) } -emit_vdivps_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VDIVPS, Register(dst), Register(src), src2.mem, 32) } -inst_vdivpd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VDIVPD, Register(dst), Register(src), Register(src2)) } -inst_vdivpd_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VDIVPD, Register(dst), Register(src), src2.mem, 16) } -inst_vdivpd_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VDIVPD, Register(dst), Register(src), Register(src2)) } -inst_vdivpd_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VDIVPD, Register(dst), Register(src), src2.mem, 32) } -emit_vdivpd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VDIVPD, Register(dst), Register(src), Register(src2)) } -emit_vdivpd_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VDIVPD, Register(dst), Register(src), src2.mem, 16) } -emit_vdivpd_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VDIVPD, Register(dst), Register(src), Register(src2)) } -emit_vdivpd_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VDIVPD, Register(dst), Register(src), src2.mem, 32) } -inst_vdivss_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VDIVSS, Register(dst), Register(src), Register(src2)) } -inst_vdivss_xmm_xmm_m32 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem32) -> Instruction { return inst_r_r_m(.VDIVSS, Register(dst), Register(src), src2.mem, 4) } -emit_vdivss_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VDIVSS, Register(dst), Register(src), Register(src2)) } -emit_vdivss_xmm_xmm_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem32) { emit_rrm(instructions, .VDIVSS, Register(dst), Register(src), src2.mem, 4) } -inst_vdivsd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VDIVSD, Register(dst), Register(src), Register(src2)) } -inst_vdivsd_xmm_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem64) -> Instruction { return inst_r_r_m(.VDIVSD, Register(dst), Register(src), src2.mem, 8) } -emit_vdivsd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VDIVSD, Register(dst), Register(src), Register(src2)) } -emit_vdivsd_xmm_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem64) { emit_rrm(instructions, .VDIVSD, Register(dst), Register(src), src2.mem, 8) } -inst_vsqrtps_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.VSQRTPS, Register(dst), Register(src)) } -inst_vsqrtps_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.VSQRTPS, Register(dst), src.mem, 16) } -inst_vsqrtps_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM) -> Instruction { return inst_r_r(.VSQRTPS, Register(dst), Register(src)) } -inst_vsqrtps_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: Mem256) -> Instruction { return inst_r_m(.VSQRTPS, Register(dst), src.mem, 32) } -emit_vsqrtps_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .VSQRTPS, Register(dst), Register(src)) } -emit_vsqrtps_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .VSQRTPS, Register(dst), src.mem, 16) } -emit_vsqrtps_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM) { emit_rr(instructions, .VSQRTPS, Register(dst), Register(src)) } -emit_vsqrtps_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem256) { emit_rm(instructions, .VSQRTPS, Register(dst), src.mem, 32) } -inst_vsqrtpd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.VSQRTPD, Register(dst), Register(src)) } -inst_vsqrtpd_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.VSQRTPD, Register(dst), src.mem, 16) } -inst_vsqrtpd_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM) -> Instruction { return inst_r_r(.VSQRTPD, Register(dst), Register(src)) } -inst_vsqrtpd_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: Mem256) -> Instruction { return inst_r_m(.VSQRTPD, Register(dst), src.mem, 32) } -emit_vsqrtpd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .VSQRTPD, Register(dst), Register(src)) } -emit_vsqrtpd_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .VSQRTPD, Register(dst), src.mem, 16) } -emit_vsqrtpd_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM) { emit_rr(instructions, .VSQRTPD, Register(dst), Register(src)) } -emit_vsqrtpd_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem256) { emit_rm(instructions, .VSQRTPD, Register(dst), src.mem, 32) } -inst_vsqrtss_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VSQRTSS, Register(dst), Register(src), Register(src2)) } -inst_vsqrtss_xmm_xmm_m32 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem32) -> Instruction { return inst_r_r_m(.VSQRTSS, Register(dst), Register(src), src2.mem, 4) } -emit_vsqrtss_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VSQRTSS, Register(dst), Register(src), Register(src2)) } -emit_vsqrtss_xmm_xmm_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem32) { emit_rrm(instructions, .VSQRTSS, Register(dst), Register(src), src2.mem, 4) } -inst_vsqrtsd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VSQRTSD, Register(dst), Register(src), Register(src2)) } -inst_vsqrtsd_xmm_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem64) -> Instruction { return inst_r_r_m(.VSQRTSD, Register(dst), Register(src), src2.mem, 8) } -emit_vsqrtsd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VSQRTSD, Register(dst), Register(src), Register(src2)) } -emit_vsqrtsd_xmm_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem64) { emit_rrm(instructions, .VSQRTSD, Register(dst), Register(src), src2.mem, 8) } -inst_vrcpps_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.VRCPPS, Register(dst), Register(src)) } -inst_vrcpps_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.VRCPPS, Register(dst), src.mem, 16) } -inst_vrcpps_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM) -> Instruction { return inst_r_r(.VRCPPS, Register(dst), Register(src)) } -inst_vrcpps_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: Mem256) -> Instruction { return inst_r_m(.VRCPPS, Register(dst), src.mem, 32) } -emit_vrcpps_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .VRCPPS, Register(dst), Register(src)) } -emit_vrcpps_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .VRCPPS, Register(dst), src.mem, 16) } -emit_vrcpps_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM) { emit_rr(instructions, .VRCPPS, Register(dst), Register(src)) } -emit_vrcpps_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem256) { emit_rm(instructions, .VRCPPS, Register(dst), src.mem, 32) } -inst_vrcpss_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VRCPSS, Register(dst), Register(src), Register(src2)) } -inst_vrcpss_xmm_xmm_m32 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem32) -> Instruction { return inst_r_r_m(.VRCPSS, Register(dst), Register(src), src2.mem, 4) } -emit_vrcpss_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VRCPSS, Register(dst), Register(src), Register(src2)) } -emit_vrcpss_xmm_xmm_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem32) { emit_rrm(instructions, .VRCPSS, Register(dst), Register(src), src2.mem, 4) } -inst_vrsqrtps_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.VRSQRTPS, Register(dst), Register(src)) } -inst_vrsqrtps_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.VRSQRTPS, Register(dst), src.mem, 16) } -inst_vrsqrtps_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM) -> Instruction { return inst_r_r(.VRSQRTPS, Register(dst), Register(src)) } -inst_vrsqrtps_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: Mem256) -> Instruction { return inst_r_m(.VRSQRTPS, Register(dst), src.mem, 32) } -emit_vrsqrtps_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .VRSQRTPS, Register(dst), Register(src)) } -emit_vrsqrtps_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .VRSQRTPS, Register(dst), src.mem, 16) } -emit_vrsqrtps_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM) { emit_rr(instructions, .VRSQRTPS, Register(dst), Register(src)) } -emit_vrsqrtps_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem256) { emit_rm(instructions, .VRSQRTPS, Register(dst), src.mem, 32) } -inst_vrsqrtss_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VRSQRTSS, Register(dst), Register(src), Register(src2)) } -inst_vrsqrtss_xmm_xmm_m32 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem32) -> Instruction { return inst_r_r_m(.VRSQRTSS, Register(dst), Register(src), src2.mem, 4) } -emit_vrsqrtss_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VRSQRTSS, Register(dst), Register(src), Register(src2)) } -emit_vrsqrtss_xmm_xmm_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem32) { emit_rrm(instructions, .VRSQRTSS, Register(dst), Register(src), src2.mem, 4) } -inst_vmaxps_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VMAXPS, Register(dst), Register(src), Register(src2)) } -inst_vmaxps_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VMAXPS, Register(dst), Register(src), src2.mem, 16) } -inst_vmaxps_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VMAXPS, Register(dst), Register(src), Register(src2)) } -inst_vmaxps_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VMAXPS, Register(dst), Register(src), src2.mem, 32) } -emit_vmaxps_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VMAXPS, Register(dst), Register(src), Register(src2)) } -emit_vmaxps_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VMAXPS, Register(dst), Register(src), src2.mem, 16) } -emit_vmaxps_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VMAXPS, Register(dst), Register(src), Register(src2)) } -emit_vmaxps_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VMAXPS, Register(dst), Register(src), src2.mem, 32) } -inst_vmaxpd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VMAXPD, Register(dst), Register(src), Register(src2)) } -inst_vmaxpd_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VMAXPD, Register(dst), Register(src), src2.mem, 16) } -inst_vmaxpd_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VMAXPD, Register(dst), Register(src), Register(src2)) } -inst_vmaxpd_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VMAXPD, Register(dst), Register(src), src2.mem, 32) } -emit_vmaxpd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VMAXPD, Register(dst), Register(src), Register(src2)) } -emit_vmaxpd_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VMAXPD, Register(dst), Register(src), src2.mem, 16) } -emit_vmaxpd_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VMAXPD, Register(dst), Register(src), Register(src2)) } -emit_vmaxpd_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VMAXPD, Register(dst), Register(src), src2.mem, 32) } -inst_vmaxss_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VMAXSS, Register(dst), Register(src), Register(src2)) } -inst_vmaxss_xmm_xmm_m32 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem32) -> Instruction { return inst_r_r_m(.VMAXSS, Register(dst), Register(src), src2.mem, 4) } -emit_vmaxss_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VMAXSS, Register(dst), Register(src), Register(src2)) } -emit_vmaxss_xmm_xmm_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem32) { emit_rrm(instructions, .VMAXSS, Register(dst), Register(src), src2.mem, 4) } -inst_vmaxsd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VMAXSD, Register(dst), Register(src), Register(src2)) } -inst_vmaxsd_xmm_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem64) -> Instruction { return inst_r_r_m(.VMAXSD, Register(dst), Register(src), src2.mem, 8) } -emit_vmaxsd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VMAXSD, Register(dst), Register(src), Register(src2)) } -emit_vmaxsd_xmm_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem64) { emit_rrm(instructions, .VMAXSD, Register(dst), Register(src), src2.mem, 8) } -inst_vminps_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VMINPS, Register(dst), Register(src), Register(src2)) } -inst_vminps_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VMINPS, Register(dst), Register(src), src2.mem, 16) } -inst_vminps_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VMINPS, Register(dst), Register(src), Register(src2)) } -inst_vminps_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VMINPS, Register(dst), Register(src), src2.mem, 32) } -emit_vminps_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VMINPS, Register(dst), Register(src), Register(src2)) } -emit_vminps_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VMINPS, Register(dst), Register(src), src2.mem, 16) } -emit_vminps_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VMINPS, Register(dst), Register(src), Register(src2)) } -emit_vminps_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VMINPS, Register(dst), Register(src), src2.mem, 32) } -inst_vminpd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VMINPD, Register(dst), Register(src), Register(src2)) } -inst_vminpd_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VMINPD, Register(dst), Register(src), src2.mem, 16) } -inst_vminpd_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VMINPD, Register(dst), Register(src), Register(src2)) } -inst_vminpd_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VMINPD, Register(dst), Register(src), src2.mem, 32) } -emit_vminpd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VMINPD, Register(dst), Register(src), Register(src2)) } -emit_vminpd_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VMINPD, Register(dst), Register(src), src2.mem, 16) } -emit_vminpd_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VMINPD, Register(dst), Register(src), Register(src2)) } -emit_vminpd_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VMINPD, Register(dst), Register(src), src2.mem, 32) } -inst_vminss_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VMINSS, Register(dst), Register(src), Register(src2)) } -inst_vminss_xmm_xmm_m32 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem32) -> Instruction { return inst_r_r_m(.VMINSS, Register(dst), Register(src), src2.mem, 4) } -emit_vminss_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VMINSS, Register(dst), Register(src), Register(src2)) } -emit_vminss_xmm_xmm_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem32) { emit_rrm(instructions, .VMINSS, Register(dst), Register(src), src2.mem, 4) } -inst_vminsd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VMINSD, Register(dst), Register(src), Register(src2)) } -inst_vminsd_xmm_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem64) -> Instruction { return inst_r_r_m(.VMINSD, Register(dst), Register(src), src2.mem, 8) } -emit_vminsd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VMINSD, Register(dst), Register(src), Register(src2)) } -emit_vminsd_xmm_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem64) { emit_rrm(instructions, .VMINSD, Register(dst), Register(src), src2.mem, 8) } -inst_vandps_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VANDPS, Register(dst), Register(src), Register(src2)) } -inst_vandps_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VANDPS, Register(dst), Register(src), src2.mem, 16) } -inst_vandps_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VANDPS, Register(dst), Register(src), Register(src2)) } -inst_vandps_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VANDPS, Register(dst), Register(src), src2.mem, 32) } -emit_vandps_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VANDPS, Register(dst), Register(src), Register(src2)) } -emit_vandps_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VANDPS, Register(dst), Register(src), src2.mem, 16) } -emit_vandps_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VANDPS, Register(dst), Register(src), Register(src2)) } -emit_vandps_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VANDPS, Register(dst), Register(src), src2.mem, 32) } -inst_vandpd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VANDPD, Register(dst), Register(src), Register(src2)) } -inst_vandpd_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VANDPD, Register(dst), Register(src), src2.mem, 16) } -inst_vandpd_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VANDPD, Register(dst), Register(src), Register(src2)) } -inst_vandpd_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VANDPD, Register(dst), Register(src), src2.mem, 32) } -emit_vandpd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VANDPD, Register(dst), Register(src), Register(src2)) } -emit_vandpd_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VANDPD, Register(dst), Register(src), src2.mem, 16) } -emit_vandpd_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VANDPD, Register(dst), Register(src), Register(src2)) } -emit_vandpd_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VANDPD, Register(dst), Register(src), src2.mem, 32) } -inst_vandnps_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VANDNPS, Register(dst), Register(src), Register(src2)) } -inst_vandnps_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VANDNPS, Register(dst), Register(src), src2.mem, 16) } -inst_vandnps_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VANDNPS, Register(dst), Register(src), Register(src2)) } -inst_vandnps_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VANDNPS, Register(dst), Register(src), src2.mem, 32) } -emit_vandnps_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VANDNPS, Register(dst), Register(src), Register(src2)) } -emit_vandnps_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VANDNPS, Register(dst), Register(src), src2.mem, 16) } -emit_vandnps_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VANDNPS, Register(dst), Register(src), Register(src2)) } -emit_vandnps_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VANDNPS, Register(dst), Register(src), src2.mem, 32) } -inst_vandnpd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VANDNPD, Register(dst), Register(src), Register(src2)) } -inst_vandnpd_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VANDNPD, Register(dst), Register(src), src2.mem, 16) } -inst_vandnpd_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VANDNPD, Register(dst), Register(src), Register(src2)) } -inst_vandnpd_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VANDNPD, Register(dst), Register(src), src2.mem, 32) } -emit_vandnpd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VANDNPD, Register(dst), Register(src), Register(src2)) } -emit_vandnpd_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VANDNPD, Register(dst), Register(src), src2.mem, 16) } -emit_vandnpd_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VANDNPD, Register(dst), Register(src), Register(src2)) } -emit_vandnpd_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VANDNPD, Register(dst), Register(src), src2.mem, 32) } -inst_vorps_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VORPS, Register(dst), Register(src), Register(src2)) } -inst_vorps_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VORPS, Register(dst), Register(src), src2.mem, 16) } -inst_vorps_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VORPS, Register(dst), Register(src), Register(src2)) } -inst_vorps_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VORPS, Register(dst), Register(src), src2.mem, 32) } -emit_vorps_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VORPS, Register(dst), Register(src), Register(src2)) } -emit_vorps_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VORPS, Register(dst), Register(src), src2.mem, 16) } -emit_vorps_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VORPS, Register(dst), Register(src), Register(src2)) } -emit_vorps_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VORPS, Register(dst), Register(src), src2.mem, 32) } -inst_vorpd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VORPD, Register(dst), Register(src), Register(src2)) } -inst_vorpd_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VORPD, Register(dst), Register(src), src2.mem, 16) } -inst_vorpd_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VORPD, Register(dst), Register(src), Register(src2)) } -inst_vorpd_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VORPD, Register(dst), Register(src), src2.mem, 32) } -emit_vorpd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VORPD, Register(dst), Register(src), Register(src2)) } -emit_vorpd_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VORPD, Register(dst), Register(src), src2.mem, 16) } -emit_vorpd_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VORPD, Register(dst), Register(src), Register(src2)) } -emit_vorpd_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VORPD, Register(dst), Register(src), src2.mem, 32) } -inst_vxorps_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VXORPS, Register(dst), Register(src), Register(src2)) } -inst_vxorps_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VXORPS, Register(dst), Register(src), src2.mem, 16) } -inst_vxorps_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VXORPS, Register(dst), Register(src), Register(src2)) } -inst_vxorps_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VXORPS, Register(dst), Register(src), src2.mem, 32) } -emit_vxorps_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VXORPS, Register(dst), Register(src), Register(src2)) } -emit_vxorps_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VXORPS, Register(dst), Register(src), src2.mem, 16) } -emit_vxorps_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VXORPS, Register(dst), Register(src), Register(src2)) } -emit_vxorps_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VXORPS, Register(dst), Register(src), src2.mem, 32) } -inst_vxorpd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VXORPD, Register(dst), Register(src), Register(src2)) } -inst_vxorpd_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VXORPD, Register(dst), Register(src), src2.mem, 16) } -inst_vxorpd_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VXORPD, Register(dst), Register(src), Register(src2)) } -inst_vxorpd_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VXORPD, Register(dst), Register(src), src2.mem, 32) } -emit_vxorpd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VXORPD, Register(dst), Register(src), Register(src2)) } -emit_vxorpd_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VXORPD, Register(dst), Register(src), src2.mem, 16) } -emit_vxorpd_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VXORPD, Register(dst), Register(src), Register(src2)) } -emit_vxorpd_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VXORPD, Register(dst), Register(src), src2.mem, 32) } +inst_mulx_r32_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32, src2: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .MULX, operand_count = 3, ops = {op_gpr32(dst), op_gpr32(src), op_gpr32(src2), {}} }, 717) } +inst_mulx_r32_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32, src2: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .MULX, operand_count = 3, ops = {op_gpr32(dst), op_gpr32(src), op_mem(src2.mem, 4), {}} }, 717) } +inst_mulx_r64_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64, src2: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .MULX, operand_count = 3, ops = {op_gpr64(dst), op_gpr64(src), op_gpr64(src2), {}} }, 718) } +inst_mulx_r64_r64_m64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64, src2: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .MULX, operand_count = 3, ops = {op_gpr64(dst), op_gpr64(src), op_mem(src2.mem, 8), {}} }, 718) } +emit_mulx_r32_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32, src2: GPR32) { append(instructions, inst_mulx_r32_r32_r32(dst, src, src2)) } +emit_mulx_r32_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32, src2: Mem32) { append(instructions, inst_mulx_r32_r32_m32(dst, src, src2)) } +emit_mulx_r64_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64, src2: GPR64) { append(instructions, inst_mulx_r64_r64_r64(dst, src, src2)) } +emit_mulx_r64_r64_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64, src2: Mem64) { append(instructions, inst_mulx_r64_r64_m64(dst, src, src2)) } +inst_adcx_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .ADCX, operand_count = 2, ops = {op_gpr32(dst), op_gpr32(src), {}, {}} }, 719) } +inst_adcx_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .ADCX, operand_count = 2, ops = {op_gpr32(dst), op_mem(src.mem, 4), {}, {}} }, 719) } +inst_adcx_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .ADCX, operand_count = 2, ops = {op_gpr64(dst), op_gpr64(src), {}, {}} }, 720) } +inst_adcx_r64_m64 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .ADCX, operand_count = 2, ops = {op_gpr64(dst), op_mem(src.mem, 8), {}, {}} }, 720) } +emit_adcx_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { append(instructions, inst_adcx_r32_r32(dst, src)) } +emit_adcx_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32) { append(instructions, inst_adcx_r32_m32(dst, src)) } +emit_adcx_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { append(instructions, inst_adcx_r64_r64(dst, src)) } +emit_adcx_r64_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem64) { append(instructions, inst_adcx_r64_m64(dst, src)) } +inst_adox_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .ADOX, operand_count = 2, ops = {op_gpr32(dst), op_gpr32(src), {}, {}} }, 721) } +inst_adox_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .ADOX, operand_count = 2, ops = {op_gpr32(dst), op_mem(src.mem, 4), {}, {}} }, 721) } +inst_adox_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .ADOX, operand_count = 2, ops = {op_gpr64(dst), op_gpr64(src), {}, {}} }, 722) } +inst_adox_r64_m64 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .ADOX, operand_count = 2, ops = {op_gpr64(dst), op_mem(src.mem, 8), {}, {}} }, 722) } +emit_adox_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { append(instructions, inst_adox_r32_r32(dst, src)) } +emit_adox_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32) { append(instructions, inst_adox_r32_m32(dst, src)) } +emit_adox_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { append(instructions, inst_adox_r64_r64(dst, src)) } +emit_adox_r64_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem64) { append(instructions, inst_adox_r64_m64(dst, src)) } +inst_movaps_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .MOVAPS, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 723) } +inst_movaps_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .MOVAPS, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 723) } +inst_movaps_m128_xmm :: #force_inline proc "contextless" (dst: Mem128, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .MOVAPS, operand_count = 2, ops = {op_mem(dst.mem, 16), op_xmm(src), {}, {}} }, 724) } +emit_movaps_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_movaps_xmm_xmm(dst, src)) } +emit_movaps_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_movaps_xmm_m128(dst, src)) } +emit_movaps_m128_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem128, src: XMM) { append(instructions, inst_movaps_m128_xmm(dst, src)) } +inst_movups_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .MOVUPS, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 725) } +inst_movups_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .MOVUPS, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 725) } +inst_movups_m128_xmm :: #force_inline proc "contextless" (dst: Mem128, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .MOVUPS, operand_count = 2, ops = {op_mem(dst.mem, 16), op_xmm(src), {}, {}} }, 726) } +emit_movups_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_movups_xmm_xmm(dst, src)) } +emit_movups_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_movups_xmm_m128(dst, src)) } +emit_movups_m128_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem128, src: XMM) { append(instructions, inst_movups_m128_xmm(dst, src)) } +inst_movapd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .MOVAPD, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 727) } +inst_movapd_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .MOVAPD, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 727) } +inst_movapd_m128_xmm :: #force_inline proc "contextless" (dst: Mem128, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .MOVAPD, operand_count = 2, ops = {op_mem(dst.mem, 16), op_xmm(src), {}, {}} }, 728) } +emit_movapd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_movapd_xmm_xmm(dst, src)) } +emit_movapd_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_movapd_xmm_m128(dst, src)) } +emit_movapd_m128_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem128, src: XMM) { append(instructions, inst_movapd_m128_xmm(dst, src)) } +inst_movupd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .MOVUPD, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 729) } +inst_movupd_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .MOVUPD, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 729) } +inst_movupd_m128_xmm :: #force_inline proc "contextless" (dst: Mem128, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .MOVUPD, operand_count = 2, ops = {op_mem(dst.mem, 16), op_xmm(src), {}, {}} }, 730) } +emit_movupd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_movupd_xmm_xmm(dst, src)) } +emit_movupd_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_movupd_xmm_m128(dst, src)) } +emit_movupd_m128_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem128, src: XMM) { append(instructions, inst_movupd_m128_xmm(dst, src)) } +inst_movss_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .MOVSS, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 731) } +inst_movss_xmm_m32 :: #force_inline proc "contextless" (dst: XMM, src: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .MOVSS, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 4), {}, {}} }, 731) } +inst_movss_m32_xmm :: #force_inline proc "contextless" (dst: Mem32, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .MOVSS, operand_count = 2, ops = {op_mem(dst.mem, 4), op_xmm(src), {}, {}} }, 732) } +emit_movss_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_movss_xmm_xmm(dst, src)) } +emit_movss_xmm_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem32) { append(instructions, inst_movss_xmm_m32(dst, src)) } +emit_movss_m32_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, src: XMM) { append(instructions, inst_movss_m32_xmm(dst, src)) } +inst_movsd_sse_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .MOVSD_SSE, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 733) } +inst_movsd_sse_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .MOVSD_SSE, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 8), {}, {}} }, 733) } +inst_movsd_sse_m64_xmm :: #force_inline proc "contextless" (dst: Mem64, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .MOVSD_SSE, operand_count = 2, ops = {op_mem(dst.mem, 8), op_xmm(src), {}, {}} }, 734) } +emit_movsd_sse_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_movsd_sse_xmm_xmm(dst, src)) } +emit_movsd_sse_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem64) { append(instructions, inst_movsd_sse_xmm_m64(dst, src)) } +emit_movsd_sse_m64_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, src: XMM) { append(instructions, inst_movsd_sse_m64_xmm(dst, src)) } +inst_movdqa_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .MOVDQA, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 735) } +inst_movdqa_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .MOVDQA, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 735) } +inst_movdqa_m128_xmm :: #force_inline proc "contextless" (dst: Mem128, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .MOVDQA, operand_count = 2, ops = {op_mem(dst.mem, 16), op_xmm(src), {}, {}} }, 736) } +emit_movdqa_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_movdqa_xmm_xmm(dst, src)) } +emit_movdqa_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_movdqa_xmm_m128(dst, src)) } +emit_movdqa_m128_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem128, src: XMM) { append(instructions, inst_movdqa_m128_xmm(dst, src)) } +inst_movdqu_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .MOVDQU, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 737) } +inst_movdqu_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .MOVDQU, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 737) } +inst_movdqu_m128_xmm :: #force_inline proc "contextless" (dst: Mem128, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .MOVDQU, operand_count = 2, ops = {op_mem(dst.mem, 16), op_xmm(src), {}, {}} }, 738) } +emit_movdqu_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_movdqu_xmm_xmm(dst, src)) } +emit_movdqu_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_movdqu_xmm_m128(dst, src)) } +emit_movdqu_m128_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem128, src: XMM) { append(instructions, inst_movdqu_m128_xmm(dst, src)) } +inst_movq_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .MOVQ, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 739) } +inst_movq_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .MOVQ, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 8), {}, {}} }, 739) } +inst_movq_m64_xmm :: #force_inline proc "contextless" (dst: Mem64, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .MOVQ, operand_count = 2, ops = {op_mem(dst.mem, 8), op_xmm(src), {}, {}} }, 740) } +inst_movq_mm_mm :: #force_inline proc "contextless" (dst: MM, src: MM) -> Instruction { return with_hint(Instruction{ mnemonic = .MOVQ, operand_count = 2, ops = {op_mm(dst), op_mm(src), {}, {}} }, 741) } +inst_movq_mm_m64 :: #force_inline proc "contextless" (dst: MM, src: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .MOVQ, operand_count = 2, ops = {op_mm(dst), op_mem(src.mem, 8), {}, {}} }, 741) } +inst_movq_m64_mm :: #force_inline proc "contextless" (dst: Mem64, src: MM) -> Instruction { return with_hint(Instruction{ mnemonic = .MOVQ, operand_count = 2, ops = {op_mem(dst.mem, 8), op_mm(src), {}, {}} }, 742) } +inst_movq_r64_xmm :: #force_inline proc "contextless" (dst: GPR64, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .MOVQ, operand_count = 2, ops = {op_gpr64(dst), op_xmm(src), {}, {}} }, 743) } +inst_movq_xmm_r64 :: #force_inline proc "contextless" (dst: XMM, src: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .MOVQ, operand_count = 2, ops = {op_xmm(dst), op_gpr64(src), {}, {}} }, 744) } +emit_movq_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_movq_xmm_xmm(dst, src)) } +emit_movq_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem64) { append(instructions, inst_movq_xmm_m64(dst, src)) } +emit_movq_m64_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, src: XMM) { append(instructions, inst_movq_m64_xmm(dst, src)) } +emit_movq_mm_mm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: MM, src: MM) { append(instructions, inst_movq_mm_mm(dst, src)) } +emit_movq_mm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: MM, src: Mem64) { append(instructions, inst_movq_mm_m64(dst, src)) } +emit_movq_m64_mm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, src: MM) { append(instructions, inst_movq_m64_mm(dst, src)) } +emit_movq_r64_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: XMM) { append(instructions, inst_movq_r64_xmm(dst, src)) } +emit_movq_xmm_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: GPR64) { append(instructions, inst_movq_xmm_r64(dst, src)) } +inst_movd_xmm_r32 :: #force_inline proc "contextless" (dst: XMM, src: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .MOVD, operand_count = 2, ops = {op_xmm(dst), op_gpr32(src), {}, {}} }, 745) } +inst_movd_xmm_m32 :: #force_inline proc "contextless" (dst: XMM, src: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .MOVD, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 4), {}, {}} }, 745) } +inst_movd_r32_xmm :: #force_inline proc "contextless" (dst: GPR32, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .MOVD, operand_count = 2, ops = {op_gpr32(dst), op_xmm(src), {}, {}} }, 746) } +inst_movd_m32_xmm :: #force_inline proc "contextless" (dst: Mem32, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .MOVD, operand_count = 2, ops = {op_mem(dst.mem, 4), op_xmm(src), {}, {}} }, 746) } +inst_movd_mm_r32 :: #force_inline proc "contextless" (dst: MM, src: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .MOVD, operand_count = 2, ops = {op_mm(dst), op_gpr32(src), {}, {}} }, 747) } +inst_movd_mm_m32 :: #force_inline proc "contextless" (dst: MM, src: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .MOVD, operand_count = 2, ops = {op_mm(dst), op_mem(src.mem, 4), {}, {}} }, 747) } +inst_movd_r32_mm :: #force_inline proc "contextless" (dst: GPR32, src: MM) -> Instruction { return with_hint(Instruction{ mnemonic = .MOVD, operand_count = 2, ops = {op_gpr32(dst), op_mm(src), {}, {}} }, 748) } +inst_movd_m32_mm :: #force_inline proc "contextless" (dst: Mem32, src: MM) -> Instruction { return with_hint(Instruction{ mnemonic = .MOVD, operand_count = 2, ops = {op_mem(dst.mem, 4), op_mm(src), {}, {}} }, 748) } +emit_movd_xmm_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: GPR32) { append(instructions, inst_movd_xmm_r32(dst, src)) } +emit_movd_xmm_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem32) { append(instructions, inst_movd_xmm_m32(dst, src)) } +emit_movd_r32_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: XMM) { append(instructions, inst_movd_r32_xmm(dst, src)) } +emit_movd_m32_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, src: XMM) { append(instructions, inst_movd_m32_xmm(dst, src)) } +emit_movd_mm_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: MM, src: GPR32) { append(instructions, inst_movd_mm_r32(dst, src)) } +emit_movd_mm_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: MM, src: Mem32) { append(instructions, inst_movd_mm_m32(dst, src)) } +emit_movd_r32_mm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: MM) { append(instructions, inst_movd_r32_mm(dst, src)) } +emit_movd_m32_mm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, src: MM) { append(instructions, inst_movd_m32_mm(dst, src)) } +inst_movlps_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .MOVLPS, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 8), {}, {}} }, 749) } +inst_movlps_m64_xmm :: #force_inline proc "contextless" (dst: Mem64, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .MOVLPS, operand_count = 2, ops = {op_mem(dst.mem, 8), op_xmm(src), {}, {}} }, 750) } +emit_movlps_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem64) { append(instructions, inst_movlps_xmm_m64(dst, src)) } +emit_movlps_m64_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, src: XMM) { append(instructions, inst_movlps_m64_xmm(dst, src)) } +inst_movhps_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .MOVHPS, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 8), {}, {}} }, 751) } +inst_movhps_m64_xmm :: #force_inline proc "contextless" (dst: Mem64, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .MOVHPS, operand_count = 2, ops = {op_mem(dst.mem, 8), op_xmm(src), {}, {}} }, 752) } +emit_movhps_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem64) { append(instructions, inst_movhps_xmm_m64(dst, src)) } +emit_movhps_m64_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, src: XMM) { append(instructions, inst_movhps_m64_xmm(dst, src)) } +inst_movlpd_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .MOVLPD, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 8), {}, {}} }, 753) } +inst_movlpd_m64_xmm :: #force_inline proc "contextless" (dst: Mem64, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .MOVLPD, operand_count = 2, ops = {op_mem(dst.mem, 8), op_xmm(src), {}, {}} }, 754) } +emit_movlpd_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem64) { append(instructions, inst_movlpd_xmm_m64(dst, src)) } +emit_movlpd_m64_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, src: XMM) { append(instructions, inst_movlpd_m64_xmm(dst, src)) } +inst_movhpd_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .MOVHPD, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 8), {}, {}} }, 755) } +inst_movhpd_m64_xmm :: #force_inline proc "contextless" (dst: Mem64, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .MOVHPD, operand_count = 2, ops = {op_mem(dst.mem, 8), op_xmm(src), {}, {}} }, 756) } +emit_movhpd_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem64) { append(instructions, inst_movhpd_xmm_m64(dst, src)) } +emit_movhpd_m64_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, src: XMM) { append(instructions, inst_movhpd_m64_xmm(dst, src)) } +inst_movlhps_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .MOVLHPS, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 757) } +emit_movlhps_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_movlhps_xmm_xmm(dst, src)) } +inst_movhlps_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .MOVHLPS, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 758) } +emit_movhlps_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_movhlps_xmm_xmm(dst, src)) } +inst_movmskps_r32_xmm :: #force_inline proc "contextless" (dst: GPR32, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .MOVMSKPS, operand_count = 2, ops = {op_gpr32(dst), op_xmm(src), {}, {}} }, 759) } +inst_movmskps_r64_xmm :: #force_inline proc "contextless" (dst: GPR64, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .MOVMSKPS, operand_count = 2, ops = {op_gpr64(dst), op_xmm(src), {}, {}} }, 760) } +emit_movmskps_r32_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: XMM) { append(instructions, inst_movmskps_r32_xmm(dst, src)) } +emit_movmskps_r64_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: XMM) { append(instructions, inst_movmskps_r64_xmm(dst, src)) } +inst_movmskpd_r32_xmm :: #force_inline proc "contextless" (dst: GPR32, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .MOVMSKPD, operand_count = 2, ops = {op_gpr32(dst), op_xmm(src), {}, {}} }, 761) } +inst_movmskpd_r64_xmm :: #force_inline proc "contextless" (dst: GPR64, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .MOVMSKPD, operand_count = 2, ops = {op_gpr64(dst), op_xmm(src), {}, {}} }, 762) } +emit_movmskpd_r32_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: XMM) { append(instructions, inst_movmskpd_r32_xmm(dst, src)) } +emit_movmskpd_r64_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: XMM) { append(instructions, inst_movmskpd_r64_xmm(dst, src)) } +inst_movntps_m128_xmm :: #force_inline proc "contextless" (dst: Mem128, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .MOVNTPS, operand_count = 2, ops = {op_mem(dst.mem, 16), op_xmm(src), {}, {}} }, 763) } +emit_movntps_m128_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem128, src: XMM) { append(instructions, inst_movntps_m128_xmm(dst, src)) } +inst_movntpd_m128_xmm :: #force_inline proc "contextless" (dst: Mem128, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .MOVNTPD, operand_count = 2, ops = {op_mem(dst.mem, 16), op_xmm(src), {}, {}} }, 764) } +emit_movntpd_m128_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem128, src: XMM) { append(instructions, inst_movntpd_m128_xmm(dst, src)) } +inst_movntdq_m128_xmm :: #force_inline proc "contextless" (dst: Mem128, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .MOVNTDQ, operand_count = 2, ops = {op_mem(dst.mem, 16), op_xmm(src), {}, {}} }, 765) } +emit_movntdq_m128_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem128, src: XMM) { append(instructions, inst_movntdq_m128_xmm(dst, src)) } +inst_movntdqa_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .MOVNTDQA, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 766) } +emit_movntdqa_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_movntdqa_xmm_m128(dst, src)) } +inst_addps_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .ADDPS, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 767) } +inst_addps_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .ADDPS, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 767) } +emit_addps_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_addps_xmm_xmm(dst, src)) } +emit_addps_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_addps_xmm_m128(dst, src)) } +inst_addpd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .ADDPD, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 768) } +inst_addpd_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .ADDPD, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 768) } +emit_addpd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_addpd_xmm_xmm(dst, src)) } +emit_addpd_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_addpd_xmm_m128(dst, src)) } +inst_addss_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .ADDSS, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 769) } +inst_addss_xmm_m32 :: #force_inline proc "contextless" (dst: XMM, src: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .ADDSS, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 4), {}, {}} }, 769) } +emit_addss_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_addss_xmm_xmm(dst, src)) } +emit_addss_xmm_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem32) { append(instructions, inst_addss_xmm_m32(dst, src)) } +inst_addsd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .ADDSD, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 770) } +inst_addsd_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .ADDSD, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 8), {}, {}} }, 770) } +emit_addsd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_addsd_xmm_xmm(dst, src)) } +emit_addsd_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem64) { append(instructions, inst_addsd_xmm_m64(dst, src)) } +inst_subps_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .SUBPS, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 771) } +inst_subps_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .SUBPS, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 771) } +emit_subps_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_subps_xmm_xmm(dst, src)) } +emit_subps_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_subps_xmm_m128(dst, src)) } +inst_subpd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .SUBPD, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 772) } +inst_subpd_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .SUBPD, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 772) } +emit_subpd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_subpd_xmm_xmm(dst, src)) } +emit_subpd_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_subpd_xmm_m128(dst, src)) } +inst_subss_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .SUBSS, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 773) } +inst_subss_xmm_m32 :: #force_inline proc "contextless" (dst: XMM, src: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .SUBSS, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 4), {}, {}} }, 773) } +emit_subss_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_subss_xmm_xmm(dst, src)) } +emit_subss_xmm_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem32) { append(instructions, inst_subss_xmm_m32(dst, src)) } +inst_subsd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .SUBSD, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 774) } +inst_subsd_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .SUBSD, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 8), {}, {}} }, 774) } +emit_subsd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_subsd_xmm_xmm(dst, src)) } +emit_subsd_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem64) { append(instructions, inst_subsd_xmm_m64(dst, src)) } +inst_mulps_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .MULPS, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 775) } +inst_mulps_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .MULPS, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 775) } +emit_mulps_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_mulps_xmm_xmm(dst, src)) } +emit_mulps_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_mulps_xmm_m128(dst, src)) } +inst_mulpd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .MULPD, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 776) } +inst_mulpd_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .MULPD, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 776) } +emit_mulpd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_mulpd_xmm_xmm(dst, src)) } +emit_mulpd_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_mulpd_xmm_m128(dst, src)) } +inst_mulss_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .MULSS, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 777) } +inst_mulss_xmm_m32 :: #force_inline proc "contextless" (dst: XMM, src: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .MULSS, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 4), {}, {}} }, 777) } +emit_mulss_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_mulss_xmm_xmm(dst, src)) } +emit_mulss_xmm_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem32) { append(instructions, inst_mulss_xmm_m32(dst, src)) } +inst_mulsd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .MULSD, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 778) } +inst_mulsd_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .MULSD, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 8), {}, {}} }, 778) } +emit_mulsd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_mulsd_xmm_xmm(dst, src)) } +emit_mulsd_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem64) { append(instructions, inst_mulsd_xmm_m64(dst, src)) } +inst_divps_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .DIVPS, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 779) } +inst_divps_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .DIVPS, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 779) } +emit_divps_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_divps_xmm_xmm(dst, src)) } +emit_divps_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_divps_xmm_m128(dst, src)) } +inst_divpd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .DIVPD, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 780) } +inst_divpd_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .DIVPD, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 780) } +emit_divpd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_divpd_xmm_xmm(dst, src)) } +emit_divpd_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_divpd_xmm_m128(dst, src)) } +inst_divss_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .DIVSS, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 781) } +inst_divss_xmm_m32 :: #force_inline proc "contextless" (dst: XMM, src: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .DIVSS, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 4), {}, {}} }, 781) } +emit_divss_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_divss_xmm_xmm(dst, src)) } +emit_divss_xmm_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem32) { append(instructions, inst_divss_xmm_m32(dst, src)) } +inst_divsd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .DIVSD, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 782) } +inst_divsd_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .DIVSD, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 8), {}, {}} }, 782) } +emit_divsd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_divsd_xmm_xmm(dst, src)) } +emit_divsd_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem64) { append(instructions, inst_divsd_xmm_m64(dst, src)) } +inst_sqrtps_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .SQRTPS, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 783) } +inst_sqrtps_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .SQRTPS, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 783) } +emit_sqrtps_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_sqrtps_xmm_xmm(dst, src)) } +emit_sqrtps_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_sqrtps_xmm_m128(dst, src)) } +inst_sqrtpd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .SQRTPD, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 784) } +inst_sqrtpd_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .SQRTPD, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 784) } +emit_sqrtpd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_sqrtpd_xmm_xmm(dst, src)) } +emit_sqrtpd_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_sqrtpd_xmm_m128(dst, src)) } +inst_sqrtss_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .SQRTSS, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 785) } +inst_sqrtss_xmm_m32 :: #force_inline proc "contextless" (dst: XMM, src: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .SQRTSS, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 4), {}, {}} }, 785) } +emit_sqrtss_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_sqrtss_xmm_xmm(dst, src)) } +emit_sqrtss_xmm_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem32) { append(instructions, inst_sqrtss_xmm_m32(dst, src)) } +inst_sqrtsd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .SQRTSD, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 786) } +inst_sqrtsd_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .SQRTSD, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 8), {}, {}} }, 786) } +emit_sqrtsd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_sqrtsd_xmm_xmm(dst, src)) } +emit_sqrtsd_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem64) { append(instructions, inst_sqrtsd_xmm_m64(dst, src)) } +inst_rcpps_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .RCPPS, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 787) } +inst_rcpps_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .RCPPS, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 787) } +emit_rcpps_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_rcpps_xmm_xmm(dst, src)) } +emit_rcpps_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_rcpps_xmm_m128(dst, src)) } +inst_rcpss_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .RCPSS, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 788) } +inst_rcpss_xmm_m32 :: #force_inline proc "contextless" (dst: XMM, src: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .RCPSS, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 4), {}, {}} }, 788) } +emit_rcpss_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_rcpss_xmm_xmm(dst, src)) } +emit_rcpss_xmm_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem32) { append(instructions, inst_rcpss_xmm_m32(dst, src)) } +inst_rsqrtps_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .RSQRTPS, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 789) } +inst_rsqrtps_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .RSQRTPS, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 789) } +emit_rsqrtps_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_rsqrtps_xmm_xmm(dst, src)) } +emit_rsqrtps_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_rsqrtps_xmm_m128(dst, src)) } +inst_rsqrtss_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .RSQRTSS, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 790) } +inst_rsqrtss_xmm_m32 :: #force_inline proc "contextless" (dst: XMM, src: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .RSQRTSS, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 4), {}, {}} }, 790) } +emit_rsqrtss_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_rsqrtss_xmm_xmm(dst, src)) } +emit_rsqrtss_xmm_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem32) { append(instructions, inst_rsqrtss_xmm_m32(dst, src)) } +inst_maxps_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .MAXPS, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 791) } +inst_maxps_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .MAXPS, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 791) } +emit_maxps_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_maxps_xmm_xmm(dst, src)) } +emit_maxps_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_maxps_xmm_m128(dst, src)) } +inst_maxpd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .MAXPD, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 792) } +inst_maxpd_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .MAXPD, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 792) } +emit_maxpd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_maxpd_xmm_xmm(dst, src)) } +emit_maxpd_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_maxpd_xmm_m128(dst, src)) } +inst_maxss_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .MAXSS, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 793) } +inst_maxss_xmm_m32 :: #force_inline proc "contextless" (dst: XMM, src: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .MAXSS, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 4), {}, {}} }, 793) } +emit_maxss_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_maxss_xmm_xmm(dst, src)) } +emit_maxss_xmm_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem32) { append(instructions, inst_maxss_xmm_m32(dst, src)) } +inst_maxsd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .MAXSD, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 794) } +inst_maxsd_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .MAXSD, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 8), {}, {}} }, 794) } +emit_maxsd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_maxsd_xmm_xmm(dst, src)) } +emit_maxsd_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem64) { append(instructions, inst_maxsd_xmm_m64(dst, src)) } +inst_minps_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .MINPS, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 795) } +inst_minps_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .MINPS, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 795) } +emit_minps_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_minps_xmm_xmm(dst, src)) } +emit_minps_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_minps_xmm_m128(dst, src)) } +inst_minpd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .MINPD, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 796) } +inst_minpd_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .MINPD, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 796) } +emit_minpd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_minpd_xmm_xmm(dst, src)) } +emit_minpd_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_minpd_xmm_m128(dst, src)) } +inst_minss_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .MINSS, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 797) } +inst_minss_xmm_m32 :: #force_inline proc "contextless" (dst: XMM, src: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .MINSS, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 4), {}, {}} }, 797) } +emit_minss_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_minss_xmm_xmm(dst, src)) } +emit_minss_xmm_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem32) { append(instructions, inst_minss_xmm_m32(dst, src)) } +inst_minsd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .MINSD, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 798) } +inst_minsd_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .MINSD, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 8), {}, {}} }, 798) } +emit_minsd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_minsd_xmm_xmm(dst, src)) } +emit_minsd_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem64) { append(instructions, inst_minsd_xmm_m64(dst, src)) } +inst_andps_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .ANDPS, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 799) } +inst_andps_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .ANDPS, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 799) } +emit_andps_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_andps_xmm_xmm(dst, src)) } +emit_andps_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_andps_xmm_m128(dst, src)) } +inst_andpd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .ANDPD, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 800) } +inst_andpd_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .ANDPD, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 800) } +emit_andpd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_andpd_xmm_xmm(dst, src)) } +emit_andpd_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_andpd_xmm_m128(dst, src)) } +inst_andnps_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .ANDNPS, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 801) } +inst_andnps_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .ANDNPS, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 801) } +emit_andnps_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_andnps_xmm_xmm(dst, src)) } +emit_andnps_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_andnps_xmm_m128(dst, src)) } +inst_andnpd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .ANDNPD, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 802) } +inst_andnpd_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .ANDNPD, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 802) } +emit_andnpd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_andnpd_xmm_xmm(dst, src)) } +emit_andnpd_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_andnpd_xmm_m128(dst, src)) } +inst_orps_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .ORPS, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 803) } +inst_orps_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .ORPS, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 803) } +emit_orps_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_orps_xmm_xmm(dst, src)) } +emit_orps_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_orps_xmm_m128(dst, src)) } +inst_orpd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .ORPD, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 804) } +inst_orpd_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .ORPD, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 804) } +emit_orpd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_orpd_xmm_xmm(dst, src)) } +emit_orpd_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_orpd_xmm_m128(dst, src)) } +inst_xorps_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .XORPS, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 805) } +inst_xorps_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .XORPS, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 805) } +emit_xorps_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_xorps_xmm_xmm(dst, src)) } +emit_xorps_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_xorps_xmm_m128(dst, src)) } +inst_xorpd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .XORPD, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 806) } +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), {}} } } +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), {}} } } +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), {}} } } +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), {}} } } +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) } +inst_comiss_xmm_m32 :: #force_inline proc "contextless" (dst: XMM, src: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .COMISS, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 4), {}, {}} }, 811) } +emit_comiss_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_comiss_xmm_xmm(dst, src)) } +emit_comiss_xmm_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem32) { append(instructions, inst_comiss_xmm_m32(dst, src)) } +inst_comisd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .COMISD, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 812) } +inst_comisd_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .COMISD, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 8), {}, {}} }, 812) } +emit_comisd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_comisd_xmm_xmm(dst, src)) } +emit_comisd_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem64) { append(instructions, inst_comisd_xmm_m64(dst, src)) } +inst_ucomiss_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .UCOMISS, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 813) } +inst_ucomiss_xmm_m32 :: #force_inline proc "contextless" (dst: XMM, src: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .UCOMISS, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 4), {}, {}} }, 813) } +emit_ucomiss_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_ucomiss_xmm_xmm(dst, src)) } +emit_ucomiss_xmm_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem32) { append(instructions, inst_ucomiss_xmm_m32(dst, src)) } +inst_ucomisd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .UCOMISD, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 814) } +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), {}} } } +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), {}} } } +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) } +inst_unpcklps_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .UNPCKLPS, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 817) } +emit_unpcklps_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_unpcklps_xmm_xmm(dst, src)) } +emit_unpcklps_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_unpcklps_xmm_m128(dst, src)) } +inst_unpckhps_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .UNPCKHPS, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 818) } +inst_unpckhps_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .UNPCKHPS, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 818) } +emit_unpckhps_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_unpckhps_xmm_xmm(dst, src)) } +emit_unpckhps_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_unpckhps_xmm_m128(dst, src)) } +inst_unpcklpd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .UNPCKLPD, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 819) } +inst_unpcklpd_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .UNPCKLPD, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 819) } +emit_unpcklpd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_unpcklpd_xmm_xmm(dst, src)) } +emit_unpcklpd_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_unpcklpd_xmm_m128(dst, src)) } +inst_unpckhpd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .UNPCKHPD, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 820) } +inst_unpckhpd_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .UNPCKHPD, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 820) } +emit_unpckhpd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_unpckhpd_xmm_xmm(dst, src)) } +emit_unpckhpd_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_unpckhpd_xmm_m128(dst, src)) } +inst_cvtps2pd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .CVTPS2PD, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 821) } +inst_cvtps2pd_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .CVTPS2PD, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 8), {}, {}} }, 821) } +emit_cvtps2pd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_cvtps2pd_xmm_xmm(dst, src)) } +emit_cvtps2pd_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem64) { append(instructions, inst_cvtps2pd_xmm_m64(dst, src)) } +inst_cvtpd2ps_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .CVTPD2PS, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 822) } +inst_cvtpd2ps_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .CVTPD2PS, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 822) } +emit_cvtpd2ps_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_cvtpd2ps_xmm_xmm(dst, src)) } +emit_cvtpd2ps_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_cvtpd2ps_xmm_m128(dst, src)) } +inst_cvtss2sd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .CVTSS2SD, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 823) } +inst_cvtss2sd_xmm_m32 :: #force_inline proc "contextless" (dst: XMM, src: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .CVTSS2SD, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 4), {}, {}} }, 823) } +emit_cvtss2sd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_cvtss2sd_xmm_xmm(dst, src)) } +emit_cvtss2sd_xmm_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem32) { append(instructions, inst_cvtss2sd_xmm_m32(dst, src)) } +inst_cvtsd2ss_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .CVTSD2SS, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 824) } +inst_cvtsd2ss_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .CVTSD2SS, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 8), {}, {}} }, 824) } +emit_cvtsd2ss_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_cvtsd2ss_xmm_xmm(dst, src)) } +emit_cvtsd2ss_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem64) { append(instructions, inst_cvtsd2ss_xmm_m64(dst, src)) } +inst_cvtps2dq_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .CVTPS2DQ, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 825) } +inst_cvtps2dq_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .CVTPS2DQ, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 825) } +emit_cvtps2dq_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_cvtps2dq_xmm_xmm(dst, src)) } +emit_cvtps2dq_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_cvtps2dq_xmm_m128(dst, src)) } +inst_cvtpd2dq_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .CVTPD2DQ, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 826) } +inst_cvtpd2dq_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .CVTPD2DQ, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 826) } +emit_cvtpd2dq_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_cvtpd2dq_xmm_xmm(dst, src)) } +emit_cvtpd2dq_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_cvtpd2dq_xmm_m128(dst, src)) } +inst_cvtdq2ps_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .CVTDQ2PS, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 827) } +inst_cvtdq2ps_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .CVTDQ2PS, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 827) } +emit_cvtdq2ps_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_cvtdq2ps_xmm_xmm(dst, src)) } +emit_cvtdq2ps_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_cvtdq2ps_xmm_m128(dst, src)) } +inst_cvtdq2pd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .CVTDQ2PD, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 828) } +inst_cvtdq2pd_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .CVTDQ2PD, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 8), {}, {}} }, 828) } +emit_cvtdq2pd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_cvtdq2pd_xmm_xmm(dst, src)) } +emit_cvtdq2pd_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem64) { append(instructions, inst_cvtdq2pd_xmm_m64(dst, src)) } +inst_cvtss2si_r32_xmm :: #force_inline proc "contextless" (dst: GPR32, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .CVTSS2SI, operand_count = 2, ops = {op_gpr32(dst), op_xmm(src), {}, {}} }, 829) } +inst_cvtss2si_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .CVTSS2SI, operand_count = 2, ops = {op_gpr32(dst), op_mem(src.mem, 4), {}, {}} }, 829) } +inst_cvtss2si_r64_xmm :: #force_inline proc "contextless" (dst: GPR64, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .CVTSS2SI, operand_count = 2, ops = {op_gpr64(dst), op_xmm(src), {}, {}} }, 830) } +inst_cvtss2si_r64_m32 :: #force_inline proc "contextless" (dst: GPR64, src: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .CVTSS2SI, operand_count = 2, ops = {op_gpr64(dst), op_mem(src.mem, 4), {}, {}} }, 830) } +emit_cvtss2si_r32_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: XMM) { append(instructions, inst_cvtss2si_r32_xmm(dst, src)) } +emit_cvtss2si_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32) { append(instructions, inst_cvtss2si_r32_m32(dst, src)) } +emit_cvtss2si_r64_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: XMM) { append(instructions, inst_cvtss2si_r64_xmm(dst, src)) } +emit_cvtss2si_r64_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem32) { append(instructions, inst_cvtss2si_r64_m32(dst, src)) } +inst_cvtsd2si_r32_xmm :: #force_inline proc "contextless" (dst: GPR32, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .CVTSD2SI, operand_count = 2, ops = {op_gpr32(dst), op_xmm(src), {}, {}} }, 831) } +inst_cvtsd2si_r32_m64 :: #force_inline proc "contextless" (dst: GPR32, src: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .CVTSD2SI, operand_count = 2, ops = {op_gpr32(dst), op_mem(src.mem, 8), {}, {}} }, 831) } +inst_cvtsd2si_r64_xmm :: #force_inline proc "contextless" (dst: GPR64, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .CVTSD2SI, operand_count = 2, ops = {op_gpr64(dst), op_xmm(src), {}, {}} }, 832) } +inst_cvtsd2si_r64_m64 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .CVTSD2SI, operand_count = 2, ops = {op_gpr64(dst), op_mem(src.mem, 8), {}, {}} }, 832) } +emit_cvtsd2si_r32_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: XMM) { append(instructions, inst_cvtsd2si_r32_xmm(dst, src)) } +emit_cvtsd2si_r32_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem64) { append(instructions, inst_cvtsd2si_r32_m64(dst, src)) } +emit_cvtsd2si_r64_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: XMM) { append(instructions, inst_cvtsd2si_r64_xmm(dst, src)) } +emit_cvtsd2si_r64_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem64) { append(instructions, inst_cvtsd2si_r64_m64(dst, src)) } +inst_cvtsi2ss_xmm_r32 :: #force_inline proc "contextless" (dst: XMM, src: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .CVTSI2SS, operand_count = 2, ops = {op_xmm(dst), op_gpr32(src), {}, {}} }, 833) } +inst_cvtsi2ss_xmm_m32 :: #force_inline proc "contextless" (dst: XMM, src: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .CVTSI2SS, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 4), {}, {}} }, 833) } +inst_cvtsi2ss_xmm_r64 :: #force_inline proc "contextless" (dst: XMM, src: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .CVTSI2SS, operand_count = 2, ops = {op_xmm(dst), op_gpr64(src), {}, {}} }, 834) } +inst_cvtsi2ss_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .CVTSI2SS, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 8), {}, {}} }, 834) } +emit_cvtsi2ss_xmm_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: GPR32) { append(instructions, inst_cvtsi2ss_xmm_r32(dst, src)) } +emit_cvtsi2ss_xmm_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem32) { append(instructions, inst_cvtsi2ss_xmm_m32(dst, src)) } +emit_cvtsi2ss_xmm_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: GPR64) { append(instructions, inst_cvtsi2ss_xmm_r64(dst, src)) } +emit_cvtsi2ss_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem64) { append(instructions, inst_cvtsi2ss_xmm_m64(dst, src)) } +inst_cvtsi2sd_xmm_r32 :: #force_inline proc "contextless" (dst: XMM, src: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .CVTSI2SD, operand_count = 2, ops = {op_xmm(dst), op_gpr32(src), {}, {}} }, 835) } +inst_cvtsi2sd_xmm_m32 :: #force_inline proc "contextless" (dst: XMM, src: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .CVTSI2SD, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 4), {}, {}} }, 835) } +inst_cvtsi2sd_xmm_r64 :: #force_inline proc "contextless" (dst: XMM, src: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .CVTSI2SD, operand_count = 2, ops = {op_xmm(dst), op_gpr64(src), {}, {}} }, 836) } +inst_cvtsi2sd_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .CVTSI2SD, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 8), {}, {}} }, 836) } +emit_cvtsi2sd_xmm_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: GPR32) { append(instructions, inst_cvtsi2sd_xmm_r32(dst, src)) } +emit_cvtsi2sd_xmm_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem32) { append(instructions, inst_cvtsi2sd_xmm_m32(dst, src)) } +emit_cvtsi2sd_xmm_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: GPR64) { append(instructions, inst_cvtsi2sd_xmm_r64(dst, src)) } +emit_cvtsi2sd_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem64) { append(instructions, inst_cvtsi2sd_xmm_m64(dst, src)) } +inst_cvttps2dq_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .CVTTPS2DQ, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 837) } +inst_cvttps2dq_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .CVTTPS2DQ, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 837) } +emit_cvttps2dq_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_cvttps2dq_xmm_xmm(dst, src)) } +emit_cvttps2dq_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_cvttps2dq_xmm_m128(dst, src)) } +inst_cvttpd2dq_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .CVTTPD2DQ, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 838) } +inst_cvttpd2dq_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .CVTTPD2DQ, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 838) } +emit_cvttpd2dq_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_cvttpd2dq_xmm_xmm(dst, src)) } +emit_cvttpd2dq_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_cvttpd2dq_xmm_m128(dst, src)) } +inst_cvttss2si_r32_xmm :: #force_inline proc "contextless" (dst: GPR32, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .CVTTSS2SI, operand_count = 2, ops = {op_gpr32(dst), op_xmm(src), {}, {}} }, 839) } +inst_cvttss2si_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .CVTTSS2SI, operand_count = 2, ops = {op_gpr32(dst), op_mem(src.mem, 4), {}, {}} }, 839) } +inst_cvttss2si_r64_xmm :: #force_inline proc "contextless" (dst: GPR64, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .CVTTSS2SI, operand_count = 2, ops = {op_gpr64(dst), op_xmm(src), {}, {}} }, 840) } +inst_cvttss2si_r64_m32 :: #force_inline proc "contextless" (dst: GPR64, src: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .CVTTSS2SI, operand_count = 2, ops = {op_gpr64(dst), op_mem(src.mem, 4), {}, {}} }, 840) } +emit_cvttss2si_r32_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: XMM) { append(instructions, inst_cvttss2si_r32_xmm(dst, src)) } +emit_cvttss2si_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32) { append(instructions, inst_cvttss2si_r32_m32(dst, src)) } +emit_cvttss2si_r64_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: XMM) { append(instructions, inst_cvttss2si_r64_xmm(dst, src)) } +emit_cvttss2si_r64_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem32) { append(instructions, inst_cvttss2si_r64_m32(dst, src)) } +inst_cvttsd2si_r32_xmm :: #force_inline proc "contextless" (dst: GPR32, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .CVTTSD2SI, operand_count = 2, ops = {op_gpr32(dst), op_xmm(src), {}, {}} }, 841) } +inst_cvttsd2si_r32_m64 :: #force_inline proc "contextless" (dst: GPR32, src: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .CVTTSD2SI, operand_count = 2, ops = {op_gpr32(dst), op_mem(src.mem, 8), {}, {}} }, 841) } +inst_cvttsd2si_r64_xmm :: #force_inline proc "contextless" (dst: GPR64, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .CVTTSD2SI, operand_count = 2, ops = {op_gpr64(dst), op_xmm(src), {}, {}} }, 842) } +inst_cvttsd2si_r64_m64 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .CVTTSD2SI, operand_count = 2, ops = {op_gpr64(dst), op_mem(src.mem, 8), {}, {}} }, 842) } +emit_cvttsd2si_r32_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: XMM) { append(instructions, inst_cvttsd2si_r32_xmm(dst, src)) } +emit_cvttsd2si_r32_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem64) { append(instructions, inst_cvttsd2si_r32_m64(dst, src)) } +emit_cvttsd2si_r64_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: XMM) { append(instructions, inst_cvttsd2si_r64_xmm(dst, src)) } +emit_cvttsd2si_r64_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem64) { append(instructions, inst_cvttsd2si_r64_m64(dst, src)) } +inst_paddb_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .PADDB, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 843) } +inst_paddb_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .PADDB, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 843) } +emit_paddb_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_paddb_xmm_xmm(dst, src)) } +emit_paddb_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_paddb_xmm_m128(dst, src)) } +inst_paddw_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .PADDW, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 844) } +inst_paddw_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .PADDW, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 844) } +emit_paddw_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_paddw_xmm_xmm(dst, src)) } +emit_paddw_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_paddw_xmm_m128(dst, src)) } +inst_paddd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .PADDD, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 845) } +inst_paddd_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .PADDD, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 845) } +emit_paddd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_paddd_xmm_xmm(dst, src)) } +emit_paddd_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_paddd_xmm_m128(dst, src)) } +inst_paddq_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .PADDQ, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 846) } +inst_paddq_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .PADDQ, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 846) } +emit_paddq_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_paddq_xmm_xmm(dst, src)) } +emit_paddq_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_paddq_xmm_m128(dst, src)) } +inst_psubb_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .PSUBB, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 847) } +inst_psubb_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .PSUBB, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 847) } +emit_psubb_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_psubb_xmm_xmm(dst, src)) } +emit_psubb_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_psubb_xmm_m128(dst, src)) } +inst_psubw_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .PSUBW, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 848) } +inst_psubw_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .PSUBW, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 848) } +emit_psubw_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_psubw_xmm_xmm(dst, src)) } +emit_psubw_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_psubw_xmm_m128(dst, src)) } +inst_psubd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .PSUBD, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 849) } +inst_psubd_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .PSUBD, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 849) } +emit_psubd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_psubd_xmm_xmm(dst, src)) } +emit_psubd_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_psubd_xmm_m128(dst, src)) } +inst_psubq_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .PSUBQ, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 850) } +inst_psubq_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .PSUBQ, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 850) } +emit_psubq_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_psubq_xmm_xmm(dst, src)) } +emit_psubq_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_psubq_xmm_m128(dst, src)) } +inst_paddsb_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .PADDSB, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 851) } +inst_paddsb_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .PADDSB, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 851) } +emit_paddsb_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_paddsb_xmm_xmm(dst, src)) } +emit_paddsb_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_paddsb_xmm_m128(dst, src)) } +inst_paddsw_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .PADDSW, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 852) } +inst_paddsw_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .PADDSW, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 852) } +emit_paddsw_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_paddsw_xmm_xmm(dst, src)) } +emit_paddsw_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_paddsw_xmm_m128(dst, src)) } +inst_paddusb_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .PADDUSB, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 853) } +inst_paddusb_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .PADDUSB, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 853) } +emit_paddusb_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_paddusb_xmm_xmm(dst, src)) } +emit_paddusb_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_paddusb_xmm_m128(dst, src)) } +inst_paddusw_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .PADDUSW, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 854) } +inst_paddusw_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .PADDUSW, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 854) } +emit_paddusw_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_paddusw_xmm_xmm(dst, src)) } +emit_paddusw_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_paddusw_xmm_m128(dst, src)) } +inst_psubsb_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .PSUBSB, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 855) } +inst_psubsb_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .PSUBSB, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 855) } +emit_psubsb_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_psubsb_xmm_xmm(dst, src)) } +emit_psubsb_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_psubsb_xmm_m128(dst, src)) } +inst_psubsw_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .PSUBSW, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 856) } +inst_psubsw_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .PSUBSW, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 856) } +emit_psubsw_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_psubsw_xmm_xmm(dst, src)) } +emit_psubsw_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_psubsw_xmm_m128(dst, src)) } +inst_psubusb_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .PSUBUSB, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 857) } +inst_psubusb_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .PSUBUSB, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 857) } +emit_psubusb_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_psubusb_xmm_xmm(dst, src)) } +emit_psubusb_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_psubusb_xmm_m128(dst, src)) } +inst_psubusw_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .PSUBUSW, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 858) } +inst_psubusw_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .PSUBUSW, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 858) } +emit_psubusw_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_psubusw_xmm_xmm(dst, src)) } +emit_psubusw_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_psubusw_xmm_m128(dst, src)) } +inst_pmullw_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .PMULLW, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 859) } +inst_pmullw_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .PMULLW, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 859) } +emit_pmullw_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_pmullw_xmm_xmm(dst, src)) } +emit_pmullw_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_pmullw_xmm_m128(dst, src)) } +inst_pmulhw_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .PMULHW, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 860) } +inst_pmulhw_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .PMULHW, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 860) } +emit_pmulhw_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_pmulhw_xmm_xmm(dst, src)) } +emit_pmulhw_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_pmulhw_xmm_m128(dst, src)) } +inst_pmulhuw_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .PMULHUW, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 861) } +inst_pmulhuw_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .PMULHUW, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 861) } +emit_pmulhuw_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_pmulhuw_xmm_xmm(dst, src)) } +emit_pmulhuw_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_pmulhuw_xmm_m128(dst, src)) } +inst_pmuludq_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .PMULUDQ, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 862) } +inst_pmuludq_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .PMULUDQ, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 862) } +emit_pmuludq_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_pmuludq_xmm_xmm(dst, src)) } +emit_pmuludq_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_pmuludq_xmm_m128(dst, src)) } +inst_pmaddwd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .PMADDWD, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 863) } +inst_pmaddwd_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .PMADDWD, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 863) } +emit_pmaddwd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_pmaddwd_xmm_xmm(dst, src)) } +emit_pmaddwd_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_pmaddwd_xmm_m128(dst, src)) } +inst_pand_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .PAND, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 864) } +inst_pand_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .PAND, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 864) } +emit_pand_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_pand_xmm_xmm(dst, src)) } +emit_pand_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_pand_xmm_m128(dst, src)) } +inst_pandn_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .PANDN, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 865) } +inst_pandn_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .PANDN, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 865) } +emit_pandn_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_pandn_xmm_xmm(dst, src)) } +emit_pandn_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_pandn_xmm_m128(dst, src)) } +inst_por_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .POR, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 866) } +inst_por_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .POR, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 866) } +emit_por_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_por_xmm_xmm(dst, src)) } +emit_por_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_por_xmm_m128(dst, src)) } +inst_pxor_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .PXOR, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 867) } +inst_pxor_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .PXOR, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 867) } +emit_pxor_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_pxor_xmm_xmm(dst, src)) } +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), {}, {}} } } +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), {}, {}} } } +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), {}, {}} } } +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), {}, {}} } } +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), {}, {}} } } +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), {}, {}} } } +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), {}, {}} } } +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), {}, {}} } } +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)) } +inst_pcmpeqb_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .PCMPEQB, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 884) } +inst_pcmpeqb_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .PCMPEQB, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 884) } +emit_pcmpeqb_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_pcmpeqb_xmm_xmm(dst, src)) } +emit_pcmpeqb_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_pcmpeqb_xmm_m128(dst, src)) } +inst_pcmpeqw_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .PCMPEQW, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 885) } +inst_pcmpeqw_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .PCMPEQW, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 885) } +emit_pcmpeqw_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_pcmpeqw_xmm_xmm(dst, src)) } +emit_pcmpeqw_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_pcmpeqw_xmm_m128(dst, src)) } +inst_pcmpeqd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .PCMPEQD, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 886) } +inst_pcmpeqd_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .PCMPEQD, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 886) } +emit_pcmpeqd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_pcmpeqd_xmm_xmm(dst, src)) } +emit_pcmpeqd_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_pcmpeqd_xmm_m128(dst, src)) } +inst_pcmpgtb_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .PCMPGTB, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 887) } +inst_pcmpgtb_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .PCMPGTB, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 887) } +emit_pcmpgtb_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_pcmpgtb_xmm_xmm(dst, src)) } +emit_pcmpgtb_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_pcmpgtb_xmm_m128(dst, src)) } +inst_pcmpgtw_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .PCMPGTW, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 888) } +inst_pcmpgtw_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .PCMPGTW, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 888) } +emit_pcmpgtw_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_pcmpgtw_xmm_xmm(dst, src)) } +emit_pcmpgtw_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_pcmpgtw_xmm_m128(dst, src)) } +inst_pcmpgtd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .PCMPGTD, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 889) } +inst_pcmpgtd_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .PCMPGTD, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 889) } +emit_pcmpgtd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_pcmpgtd_xmm_xmm(dst, src)) } +emit_pcmpgtd_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_pcmpgtd_xmm_m128(dst, src)) } +inst_packsswb_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .PACKSSWB, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 890) } +inst_packsswb_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .PACKSSWB, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 890) } +emit_packsswb_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_packsswb_xmm_xmm(dst, src)) } +emit_packsswb_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_packsswb_xmm_m128(dst, src)) } +inst_packssdw_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .PACKSSDW, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 891) } +inst_packssdw_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .PACKSSDW, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 891) } +emit_packssdw_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_packssdw_xmm_xmm(dst, src)) } +emit_packssdw_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_packssdw_xmm_m128(dst, src)) } +inst_packuswb_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .PACKUSWB, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 892) } +inst_packuswb_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .PACKUSWB, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 892) } +emit_packuswb_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_packuswb_xmm_xmm(dst, src)) } +emit_packuswb_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_packuswb_xmm_m128(dst, src)) } +inst_punpcklbw_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .PUNPCKLBW, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 893) } +inst_punpcklbw_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .PUNPCKLBW, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 893) } +emit_punpcklbw_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_punpcklbw_xmm_xmm(dst, src)) } +emit_punpcklbw_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_punpcklbw_xmm_m128(dst, src)) } +inst_punpcklwd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .PUNPCKLWD, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 894) } +inst_punpcklwd_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .PUNPCKLWD, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 894) } +emit_punpcklwd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_punpcklwd_xmm_xmm(dst, src)) } +emit_punpcklwd_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_punpcklwd_xmm_m128(dst, src)) } +inst_punpckldq_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .PUNPCKLDQ, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 895) } +inst_punpckldq_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .PUNPCKLDQ, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 895) } +emit_punpckldq_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_punpckldq_xmm_xmm(dst, src)) } +emit_punpckldq_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_punpckldq_xmm_m128(dst, src)) } +inst_punpcklqdq_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .PUNPCKLQDQ, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 896) } +inst_punpcklqdq_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .PUNPCKLQDQ, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 896) } +emit_punpcklqdq_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_punpcklqdq_xmm_xmm(dst, src)) } +emit_punpcklqdq_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_punpcklqdq_xmm_m128(dst, src)) } +inst_punpckhbw_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .PUNPCKHBW, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 897) } +inst_punpckhbw_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .PUNPCKHBW, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 897) } +emit_punpckhbw_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_punpckhbw_xmm_xmm(dst, src)) } +emit_punpckhbw_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_punpckhbw_xmm_m128(dst, src)) } +inst_punpckhwd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .PUNPCKHWD, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 898) } +inst_punpckhwd_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .PUNPCKHWD, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 898) } +emit_punpckhwd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_punpckhwd_xmm_xmm(dst, src)) } +emit_punpckhwd_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_punpckhwd_xmm_m128(dst, src)) } +inst_punpckhdq_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .PUNPCKHDQ, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 899) } +inst_punpckhdq_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .PUNPCKHDQ, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 899) } +emit_punpckhdq_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_punpckhdq_xmm_xmm(dst, src)) } +emit_punpckhdq_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_punpckhdq_xmm_m128(dst, src)) } +inst_punpckhqdq_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .PUNPCKHQDQ, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 900) } +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), {}} } } +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), {}} } } +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), {}} } } +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), {}} } } +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), {}} } } +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), {}} } } +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) } +inst_pmovmskb_r64_xmm :: #force_inline proc "contextless" (dst: GPR64, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .PMOVMSKB, operand_count = 2, ops = {op_gpr64(dst), op_xmm(src), {}, {}} }, 910) } +emit_pmovmskb_r32_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: XMM) { append(instructions, inst_pmovmskb_r32_xmm(dst, src)) } +emit_pmovmskb_r64_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: XMM) { append(instructions, inst_pmovmskb_r64_xmm(dst, src)) } +inst_pavgb_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .PAVGB, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 911) } +inst_pavgb_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .PAVGB, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 911) } +emit_pavgb_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_pavgb_xmm_xmm(dst, src)) } +emit_pavgb_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_pavgb_xmm_m128(dst, src)) } +inst_pavgw_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .PAVGW, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 912) } +inst_pavgw_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .PAVGW, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 912) } +emit_pavgw_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_pavgw_xmm_xmm(dst, src)) } +emit_pavgw_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_pavgw_xmm_m128(dst, src)) } +inst_pmaxub_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .PMAXUB, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 913) } +inst_pmaxub_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .PMAXUB, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 913) } +emit_pmaxub_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_pmaxub_xmm_xmm(dst, src)) } +emit_pmaxub_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_pmaxub_xmm_m128(dst, src)) } +inst_pmaxsw_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .PMAXSW, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 914) } +inst_pmaxsw_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .PMAXSW, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 914) } +emit_pmaxsw_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_pmaxsw_xmm_xmm(dst, src)) } +emit_pmaxsw_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_pmaxsw_xmm_m128(dst, src)) } +inst_pminub_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .PMINUB, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 915) } +inst_pminub_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .PMINUB, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 915) } +emit_pminub_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_pminub_xmm_xmm(dst, src)) } +emit_pminub_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_pminub_xmm_m128(dst, src)) } +inst_pminsw_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .PMINSW, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 916) } +inst_pminsw_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .PMINSW, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 916) } +emit_pminsw_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_pminsw_xmm_xmm(dst, src)) } +emit_pminsw_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_pminsw_xmm_m128(dst, src)) } +inst_psadbw_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .PSADBW, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 917) } +inst_psadbw_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .PSADBW, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 917) } +emit_psadbw_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_psadbw_xmm_xmm(dst, src)) } +emit_psadbw_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_psadbw_xmm_m128(dst, src)) } +inst_maskmovdqu_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .MASKMOVDQU, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 918) } +emit_maskmovdqu_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_maskmovdqu_xmm_xmm(dst, src)) } +inst_lfence_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .LFENCE, operand_count = 0, ops = {{}, {}, {}, {}} }, 919) } +emit_lfence_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_lfence_none()) } +inst_sfence_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .SFENCE, operand_count = 0, ops = {{}, {}, {}, {}} }, 920) } +emit_sfence_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_sfence_none()) } +inst_mfence_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .MFENCE, operand_count = 0, ops = {{}, {}, {}, {}} }, 921) } +emit_mfence_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_mfence_none()) } +inst_pause_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .PAUSE, operand_count = 0, ops = {{}, {}, {}, {}} }, 922) } +emit_pause_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_pause_none()) } +inst_clflush_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return with_hint(Instruction{ mnemonic = .CLFLUSH, operand_count = 1, ops = {op_mem(dst.mem, 1), {}, {}, {}} }, 923) } +emit_clflush_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { append(instructions, inst_clflush_m8(dst)) } +inst_addsubps_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .ADDSUBPS, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 924) } +inst_addsubps_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .ADDSUBPS, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 924) } +emit_addsubps_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_addsubps_xmm_xmm(dst, src)) } +emit_addsubps_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_addsubps_xmm_m128(dst, src)) } +inst_addsubpd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .ADDSUBPD, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 925) } +inst_addsubpd_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .ADDSUBPD, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 925) } +emit_addsubpd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_addsubpd_xmm_xmm(dst, src)) } +emit_addsubpd_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_addsubpd_xmm_m128(dst, src)) } +inst_haddps_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .HADDPS, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 926) } +inst_haddps_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .HADDPS, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 926) } +emit_haddps_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_haddps_xmm_xmm(dst, src)) } +emit_haddps_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_haddps_xmm_m128(dst, src)) } +inst_haddpd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .HADDPD, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 927) } +inst_haddpd_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .HADDPD, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 927) } +emit_haddpd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_haddpd_xmm_xmm(dst, src)) } +emit_haddpd_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_haddpd_xmm_m128(dst, src)) } +inst_hsubps_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .HSUBPS, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 928) } +inst_hsubps_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .HSUBPS, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 928) } +emit_hsubps_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_hsubps_xmm_xmm(dst, src)) } +emit_hsubps_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_hsubps_xmm_m128(dst, src)) } +inst_hsubpd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .HSUBPD, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 929) } +inst_hsubpd_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .HSUBPD, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 929) } +emit_hsubpd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_hsubpd_xmm_xmm(dst, src)) } +emit_hsubpd_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_hsubpd_xmm_m128(dst, src)) } +inst_movddup_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .MOVDDUP, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 930) } +inst_movddup_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .MOVDDUP, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 8), {}, {}} }, 930) } +emit_movddup_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_movddup_xmm_xmm(dst, src)) } +emit_movddup_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem64) { append(instructions, inst_movddup_xmm_m64(dst, src)) } +inst_movsldup_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .MOVSLDUP, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 931) } +inst_movsldup_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .MOVSLDUP, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 931) } +emit_movsldup_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_movsldup_xmm_xmm(dst, src)) } +emit_movsldup_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_movsldup_xmm_m128(dst, src)) } +inst_movshdup_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .MOVSHDUP, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 932) } +inst_movshdup_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .MOVSHDUP, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 932) } +emit_movshdup_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_movshdup_xmm_xmm(dst, src)) } +emit_movshdup_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_movshdup_xmm_m128(dst, src)) } +inst_lddqu_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .LDDQU, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 933) } +emit_lddqu_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_lddqu_xmm_m128(dst, src)) } +inst_pshufb_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .PSHUFB, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 934) } +inst_pshufb_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .PSHUFB, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 934) } +emit_pshufb_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_pshufb_xmm_xmm(dst, src)) } +emit_pshufb_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_pshufb_xmm_m128(dst, src)) } +inst_phaddw_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .PHADDW, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 935) } +inst_phaddw_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .PHADDW, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 935) } +emit_phaddw_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_phaddw_xmm_xmm(dst, src)) } +emit_phaddw_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_phaddw_xmm_m128(dst, src)) } +inst_phaddd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .PHADDD, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 936) } +inst_phaddd_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .PHADDD, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 936) } +emit_phaddd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_phaddd_xmm_xmm(dst, src)) } +emit_phaddd_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_phaddd_xmm_m128(dst, src)) } +inst_phaddsw_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .PHADDSW, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 937) } +inst_phaddsw_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .PHADDSW, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 937) } +emit_phaddsw_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_phaddsw_xmm_xmm(dst, src)) } +emit_phaddsw_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_phaddsw_xmm_m128(dst, src)) } +inst_phsubw_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .PHSUBW, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 938) } +inst_phsubw_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .PHSUBW, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 938) } +emit_phsubw_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_phsubw_xmm_xmm(dst, src)) } +emit_phsubw_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_phsubw_xmm_m128(dst, src)) } +inst_phsubd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .PHSUBD, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 939) } +inst_phsubd_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .PHSUBD, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 939) } +emit_phsubd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_phsubd_xmm_xmm(dst, src)) } +emit_phsubd_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_phsubd_xmm_m128(dst, src)) } +inst_phsubsw_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .PHSUBSW, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 940) } +inst_phsubsw_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .PHSUBSW, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 940) } +emit_phsubsw_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_phsubsw_xmm_xmm(dst, src)) } +emit_phsubsw_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_phsubsw_xmm_m128(dst, src)) } +inst_pmaddubsw_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .PMADDUBSW, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 941) } +inst_pmaddubsw_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .PMADDUBSW, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 941) } +emit_pmaddubsw_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_pmaddubsw_xmm_xmm(dst, src)) } +emit_pmaddubsw_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_pmaddubsw_xmm_m128(dst, src)) } +inst_pmulhrsw_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .PMULHRSW, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 942) } +inst_pmulhrsw_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .PMULHRSW, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 942) } +emit_pmulhrsw_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_pmulhrsw_xmm_xmm(dst, src)) } +emit_pmulhrsw_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_pmulhrsw_xmm_m128(dst, src)) } +inst_psignb_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .PSIGNB, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 943) } +inst_psignb_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .PSIGNB, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 943) } +emit_psignb_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_psignb_xmm_xmm(dst, src)) } +emit_psignb_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_psignb_xmm_m128(dst, src)) } +inst_psignw_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .PSIGNW, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 944) } +inst_psignw_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .PSIGNW, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 944) } +emit_psignw_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_psignw_xmm_xmm(dst, src)) } +emit_psignw_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_psignw_xmm_m128(dst, src)) } +inst_psignd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .PSIGND, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 945) } +inst_psignd_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .PSIGND, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 945) } +emit_psignd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_psignd_xmm_xmm(dst, src)) } +emit_psignd_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_psignd_xmm_m128(dst, src)) } +inst_pabsb_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .PABSB, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 946) } +inst_pabsb_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .PABSB, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 946) } +emit_pabsb_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_pabsb_xmm_xmm(dst, src)) } +emit_pabsb_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_pabsb_xmm_m128(dst, src)) } +inst_pabsw_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .PABSW, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 947) } +inst_pabsw_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .PABSW, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 947) } +emit_pabsw_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_pabsw_xmm_xmm(dst, src)) } +emit_pabsw_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_pabsw_xmm_m128(dst, src)) } +inst_pabsd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .PABSD, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 948) } +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), {}} } } +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), {}} } } +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), {}} } } +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) } +inst_blendvps_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .BLENDVPS, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 952) } +emit_blendvps_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_blendvps_xmm_xmm(dst, src)) } +emit_blendvps_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_blendvps_xmm_m128(dst, src)) } +inst_blendvpd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .BLENDVPD, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 953) } +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), {}} } } +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), {}} } } +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), {}} } } +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), {}} } } +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), {}} } } +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), {}} } } +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), {}} } } +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), {}} } } +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), {}} } } +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), {}} } } +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), {}} } } +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), {}} } } +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) } +inst_pmaxsb_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .PMAXSB, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 969) } +emit_pmaxsb_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_pmaxsb_xmm_xmm(dst, src)) } +emit_pmaxsb_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_pmaxsb_xmm_m128(dst, src)) } +inst_pmaxsd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .PMAXSD, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 970) } +inst_pmaxsd_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .PMAXSD, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 970) } +emit_pmaxsd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_pmaxsd_xmm_xmm(dst, src)) } +emit_pmaxsd_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_pmaxsd_xmm_m128(dst, src)) } +inst_pmaxuw_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .PMAXUW, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 971) } +inst_pmaxuw_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .PMAXUW, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 971) } +emit_pmaxuw_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_pmaxuw_xmm_xmm(dst, src)) } +emit_pmaxuw_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_pmaxuw_xmm_m128(dst, src)) } +inst_pmaxud_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .PMAXUD, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 972) } +inst_pmaxud_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .PMAXUD, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 972) } +emit_pmaxud_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_pmaxud_xmm_xmm(dst, src)) } +emit_pmaxud_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_pmaxud_xmm_m128(dst, src)) } +inst_pminsb_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .PMINSB, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 973) } +inst_pminsb_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .PMINSB, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 973) } +emit_pminsb_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_pminsb_xmm_xmm(dst, src)) } +emit_pminsb_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_pminsb_xmm_m128(dst, src)) } +inst_pminsd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .PMINSD, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 974) } +inst_pminsd_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .PMINSD, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 974) } +emit_pminsd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_pminsd_xmm_xmm(dst, src)) } +emit_pminsd_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_pminsd_xmm_m128(dst, src)) } +inst_pminuw_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .PMINUW, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 975) } +inst_pminuw_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .PMINUW, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 975) } +emit_pminuw_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_pminuw_xmm_xmm(dst, src)) } +emit_pminuw_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_pminuw_xmm_m128(dst, src)) } +inst_pminud_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .PMINUD, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 976) } +inst_pminud_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .PMINUD, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 976) } +emit_pminud_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_pminud_xmm_xmm(dst, src)) } +emit_pminud_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_pminud_xmm_m128(dst, src)) } +inst_pmovsxbw_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .PMOVSXBW, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 977) } +inst_pmovsxbw_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .PMOVSXBW, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 8), {}, {}} }, 977) } +emit_pmovsxbw_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_pmovsxbw_xmm_xmm(dst, src)) } +emit_pmovsxbw_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem64) { append(instructions, inst_pmovsxbw_xmm_m64(dst, src)) } +inst_pmovsxbd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .PMOVSXBD, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 978) } +inst_pmovsxbd_xmm_m32 :: #force_inline proc "contextless" (dst: XMM, src: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .PMOVSXBD, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 4), {}, {}} }, 978) } +emit_pmovsxbd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_pmovsxbd_xmm_xmm(dst, src)) } +emit_pmovsxbd_xmm_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem32) { append(instructions, inst_pmovsxbd_xmm_m32(dst, src)) } +inst_pmovsxbq_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .PMOVSXBQ, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 979) } +inst_pmovsxbq_xmm_m32 :: #force_inline proc "contextless" (dst: XMM, src: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .PMOVSXBQ, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 4), {}, {}} }, 979) } +emit_pmovsxbq_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_pmovsxbq_xmm_xmm(dst, src)) } +emit_pmovsxbq_xmm_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem32) { append(instructions, inst_pmovsxbq_xmm_m32(dst, src)) } +inst_pmovsxwd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .PMOVSXWD, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 980) } +inst_pmovsxwd_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .PMOVSXWD, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 8), {}, {}} }, 980) } +emit_pmovsxwd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_pmovsxwd_xmm_xmm(dst, src)) } +emit_pmovsxwd_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem64) { append(instructions, inst_pmovsxwd_xmm_m64(dst, src)) } +inst_pmovsxwq_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .PMOVSXWQ, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 981) } +inst_pmovsxwq_xmm_m32 :: #force_inline proc "contextless" (dst: XMM, src: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .PMOVSXWQ, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 4), {}, {}} }, 981) } +emit_pmovsxwq_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_pmovsxwq_xmm_xmm(dst, src)) } +emit_pmovsxwq_xmm_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem32) { append(instructions, inst_pmovsxwq_xmm_m32(dst, src)) } +inst_pmovsxdq_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .PMOVSXDQ, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 982) } +inst_pmovsxdq_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .PMOVSXDQ, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 8), {}, {}} }, 982) } +emit_pmovsxdq_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_pmovsxdq_xmm_xmm(dst, src)) } +emit_pmovsxdq_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem64) { append(instructions, inst_pmovsxdq_xmm_m64(dst, src)) } +inst_pmovzxbw_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .PMOVZXBW, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 983) } +inst_pmovzxbw_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .PMOVZXBW, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 8), {}, {}} }, 983) } +emit_pmovzxbw_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_pmovzxbw_xmm_xmm(dst, src)) } +emit_pmovzxbw_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem64) { append(instructions, inst_pmovzxbw_xmm_m64(dst, src)) } +inst_pmovzxbd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .PMOVZXBD, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 984) } +inst_pmovzxbd_xmm_m32 :: #force_inline proc "contextless" (dst: XMM, src: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .PMOVZXBD, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 4), {}, {}} }, 984) } +emit_pmovzxbd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_pmovzxbd_xmm_xmm(dst, src)) } +emit_pmovzxbd_xmm_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem32) { append(instructions, inst_pmovzxbd_xmm_m32(dst, src)) } +inst_pmovzxbq_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .PMOVZXBQ, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 985) } +inst_pmovzxbq_xmm_m32 :: #force_inline proc "contextless" (dst: XMM, src: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .PMOVZXBQ, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 4), {}, {}} }, 985) } +emit_pmovzxbq_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_pmovzxbq_xmm_xmm(dst, src)) } +emit_pmovzxbq_xmm_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem32) { append(instructions, inst_pmovzxbq_xmm_m32(dst, src)) } +inst_pmovzxwd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .PMOVZXWD, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 986) } +inst_pmovzxwd_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .PMOVZXWD, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 8), {}, {}} }, 986) } +emit_pmovzxwd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_pmovzxwd_xmm_xmm(dst, src)) } +emit_pmovzxwd_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem64) { append(instructions, inst_pmovzxwd_xmm_m64(dst, src)) } +inst_pmovzxwq_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .PMOVZXWQ, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 987) } +inst_pmovzxwq_xmm_m32 :: #force_inline proc "contextless" (dst: XMM, src: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .PMOVZXWQ, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 4), {}, {}} }, 987) } +emit_pmovzxwq_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_pmovzxwq_xmm_xmm(dst, src)) } +emit_pmovzxwq_xmm_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem32) { append(instructions, inst_pmovzxwq_xmm_m32(dst, src)) } +inst_pmovzxdq_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .PMOVZXDQ, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 988) } +inst_pmovzxdq_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .PMOVZXDQ, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 8), {}, {}} }, 988) } +emit_pmovzxdq_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_pmovzxdq_xmm_xmm(dst, src)) } +emit_pmovzxdq_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem64) { append(instructions, inst_pmovzxdq_xmm_m64(dst, src)) } +inst_pmuldq_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .PMULDQ, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 989) } +inst_pmuldq_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .PMULDQ, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 989) } +emit_pmuldq_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_pmuldq_xmm_xmm(dst, src)) } +emit_pmuldq_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_pmuldq_xmm_m128(dst, src)) } +inst_pmulld_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .PMULLD, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 990) } +inst_pmulld_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .PMULLD, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 990) } +emit_pmulld_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_pmulld_xmm_xmm(dst, src)) } +emit_pmulld_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_pmulld_xmm_m128(dst, src)) } +inst_ptest_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .PTEST, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 991) } +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), {}} } } +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), {}} } } +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), {}} } } +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), {}} } } +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) } +inst_pcmpeqq_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .PCMPEQQ, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 996) } +emit_pcmpeqq_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_pcmpeqq_xmm_xmm(dst, src)) } +emit_pcmpeqq_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_pcmpeqq_xmm_m128(dst, src)) } +inst_crc32_r32_r8 :: #force_inline proc "contextless" (dst: GPR32, src: GPR8) -> Instruction { return with_hint(Instruction{ mnemonic = .CRC32, operand_count = 2, ops = {op_gpr32(dst), op_gpr8(src), {}, {}} }, 997) } +inst_crc32_r32_m8 :: #force_inline proc "contextless" (dst: GPR32, src: Mem8) -> Instruction { return with_hint(Instruction{ mnemonic = .CRC32, operand_count = 2, ops = {op_gpr32(dst), op_mem(src.mem, 1), {}, {}} }, 997) } +inst_crc32_r32_r16 :: #force_inline proc "contextless" (dst: GPR32, src: GPR16) -> Instruction { return with_hint(Instruction{ mnemonic = .CRC32, operand_count = 2, ops = {op_gpr32(dst), op_gpr16(src), {}, {}} }, 998) } +inst_crc32_r32_m16 :: #force_inline proc "contextless" (dst: GPR32, src: Mem16) -> Instruction { return with_hint(Instruction{ mnemonic = .CRC32, operand_count = 2, ops = {op_gpr32(dst), op_mem(src.mem, 2), {}, {}} }, 998) } +inst_crc32_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .CRC32, operand_count = 2, ops = {op_gpr32(dst), op_gpr32(src), {}, {}} }, 999) } +inst_crc32_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .CRC32, operand_count = 2, ops = {op_gpr32(dst), op_mem(src.mem, 4), {}, {}} }, 999) } +inst_crc32_r64_r8 :: #force_inline proc "contextless" (dst: GPR64, src: GPR8) -> Instruction { return with_hint(Instruction{ mnemonic = .CRC32, operand_count = 2, ops = {op_gpr64(dst), op_gpr8(src), {}, {}} }, 1000) } +inst_crc32_r64_m8 :: #force_inline proc "contextless" (dst: GPR64, src: Mem8) -> Instruction { return with_hint(Instruction{ mnemonic = .CRC32, operand_count = 2, ops = {op_gpr64(dst), op_mem(src.mem, 1), {}, {}} }, 1000) } +inst_crc32_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .CRC32, operand_count = 2, ops = {op_gpr64(dst), op_gpr64(src), {}, {}} }, 1001) } +inst_crc32_r64_m64 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .CRC32, operand_count = 2, ops = {op_gpr64(dst), op_mem(src.mem, 8), {}, {}} }, 1001) } +emit_crc32_r32_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR8) { append(instructions, inst_crc32_r32_r8(dst, src)) } +emit_crc32_r32_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem8) { append(instructions, inst_crc32_r32_m8(dst, src)) } +emit_crc32_r32_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR16) { append(instructions, inst_crc32_r32_r16(dst, src)) } +emit_crc32_r32_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem16) { append(instructions, inst_crc32_r32_m16(dst, src)) } +emit_crc32_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { append(instructions, inst_crc32_r32_r32(dst, src)) } +emit_crc32_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32) { append(instructions, inst_crc32_r32_m32(dst, src)) } +emit_crc32_r64_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR8) { append(instructions, inst_crc32_r64_r8(dst, src)) } +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), {}} } } +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), {}} } } +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), {}} } } +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), {}} } } +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), {}} } } +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) } +inst_aesdec_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .AESDEC, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 1008) } +emit_aesdec_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_aesdec_xmm_xmm(dst, src)) } +emit_aesdec_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_aesdec_xmm_m128(dst, src)) } +inst_aesdeclast_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .AESDECLAST, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 1009) } +inst_aesdeclast_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .AESDECLAST, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 1009) } +emit_aesdeclast_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_aesdeclast_xmm_xmm(dst, src)) } +emit_aesdeclast_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_aesdeclast_xmm_m128(dst, src)) } +inst_aesenc_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .AESENC, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 1010) } +inst_aesenc_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .AESENC, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 1010) } +emit_aesenc_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_aesenc_xmm_xmm(dst, src)) } +emit_aesenc_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_aesenc_xmm_m128(dst, src)) } +inst_aesenclast_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .AESENCLAST, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 1011) } +inst_aesenclast_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .AESENCLAST, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 1011) } +emit_aesenclast_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_aesenclast_xmm_xmm(dst, src)) } +emit_aesenclast_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_aesenclast_xmm_m128(dst, src)) } +inst_aesimc_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .AESIMC, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 1012) } +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), {}} } } +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) } +inst_sha1msg1_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .SHA1MSG1, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 1014) } +emit_sha1msg1_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_sha1msg1_xmm_xmm(dst, src)) } +emit_sha1msg1_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_sha1msg1_xmm_m128(dst, src)) } +inst_sha1msg2_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .SHA1MSG2, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 1015) } +inst_sha1msg2_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .SHA1MSG2, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 1015) } +emit_sha1msg2_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_sha1msg2_xmm_xmm(dst, src)) } +emit_sha1msg2_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_sha1msg2_xmm_m128(dst, src)) } +inst_sha1nexte_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .SHA1NEXTE, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 1016) } +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), {}} } } +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) } +inst_sha256msg1_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .SHA256MSG1, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 1018) } +emit_sha256msg1_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_sha256msg1_xmm_xmm(dst, src)) } +emit_sha256msg1_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_sha256msg1_xmm_m128(dst, src)) } +inst_sha256msg2_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .SHA256MSG2, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 1019) } +inst_sha256msg2_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .SHA256MSG2, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 1019) } +emit_sha256msg2_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_sha256msg2_xmm_xmm(dst, src)) } +emit_sha256msg2_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_sha256msg2_xmm_m128(dst, src)) } +inst_sha256rnds2_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .SHA256RNDS2, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 1020) } +inst_sha256rnds2_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .SHA256RNDS2, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 1020) } +emit_sha256rnds2_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_sha256rnds2_xmm_xmm(dst, src)) } +emit_sha256rnds2_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_sha256rnds2_xmm_m128(dst, src)) } +inst_vaddps_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VADDPS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1021) } +inst_vaddps_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VADDPS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1021) } +inst_vaddps_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VADDPS, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1022) } +inst_vaddps_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VADDPS, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1022) } +emit_vaddps_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vaddps_xmm_xmm_xmm(dst, src, src2)) } +emit_vaddps_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vaddps_xmm_xmm_m128(dst, src, src2)) } +emit_vaddps_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vaddps_ymm_ymm_ymm(dst, src, src2)) } +emit_vaddps_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vaddps_ymm_ymm_m256(dst, src, src2)) } +inst_vaddpd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VADDPD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1023) } +inst_vaddpd_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VADDPD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1023) } +inst_vaddpd_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VADDPD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1024) } +inst_vaddpd_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VADDPD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1024) } +emit_vaddpd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vaddpd_xmm_xmm_xmm(dst, src, src2)) } +emit_vaddpd_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vaddpd_xmm_xmm_m128(dst, src, src2)) } +emit_vaddpd_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vaddpd_ymm_ymm_ymm(dst, src, src2)) } +emit_vaddpd_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vaddpd_ymm_ymm_m256(dst, src, src2)) } +inst_vaddss_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VADDSS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1025) } +inst_vaddss_xmm_xmm_m32 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .VADDSS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 4), {}} }, 1025) } +emit_vaddss_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vaddss_xmm_xmm_xmm(dst, src, src2)) } +emit_vaddss_xmm_xmm_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem32) { append(instructions, inst_vaddss_xmm_xmm_m32(dst, src, src2)) } +inst_vaddsd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VADDSD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1026) } +inst_vaddsd_xmm_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .VADDSD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 8), {}} }, 1026) } +emit_vaddsd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vaddsd_xmm_xmm_xmm(dst, src, src2)) } +emit_vaddsd_xmm_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem64) { append(instructions, inst_vaddsd_xmm_xmm_m64(dst, src, src2)) } +inst_vsubps_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VSUBPS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1027) } +inst_vsubps_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VSUBPS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1027) } +inst_vsubps_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VSUBPS, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1028) } +inst_vsubps_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VSUBPS, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1028) } +emit_vsubps_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vsubps_xmm_xmm_xmm(dst, src, src2)) } +emit_vsubps_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vsubps_xmm_xmm_m128(dst, src, src2)) } +emit_vsubps_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vsubps_ymm_ymm_ymm(dst, src, src2)) } +emit_vsubps_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vsubps_ymm_ymm_m256(dst, src, src2)) } +inst_vsubpd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VSUBPD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1029) } +inst_vsubpd_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VSUBPD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1029) } +inst_vsubpd_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VSUBPD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1030) } +inst_vsubpd_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VSUBPD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1030) } +emit_vsubpd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vsubpd_xmm_xmm_xmm(dst, src, src2)) } +emit_vsubpd_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vsubpd_xmm_xmm_m128(dst, src, src2)) } +emit_vsubpd_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vsubpd_ymm_ymm_ymm(dst, src, src2)) } +emit_vsubpd_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vsubpd_ymm_ymm_m256(dst, src, src2)) } +inst_vsubss_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VSUBSS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1031) } +inst_vsubss_xmm_xmm_m32 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .VSUBSS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 4), {}} }, 1031) } +emit_vsubss_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vsubss_xmm_xmm_xmm(dst, src, src2)) } +emit_vsubss_xmm_xmm_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem32) { append(instructions, inst_vsubss_xmm_xmm_m32(dst, src, src2)) } +inst_vsubsd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VSUBSD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1032) } +inst_vsubsd_xmm_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .VSUBSD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 8), {}} }, 1032) } +emit_vsubsd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vsubsd_xmm_xmm_xmm(dst, src, src2)) } +emit_vsubsd_xmm_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem64) { append(instructions, inst_vsubsd_xmm_xmm_m64(dst, src, src2)) } +inst_vmulps_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VMULPS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1033) } +inst_vmulps_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VMULPS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1033) } +inst_vmulps_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VMULPS, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1034) } +inst_vmulps_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VMULPS, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1034) } +emit_vmulps_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vmulps_xmm_xmm_xmm(dst, src, src2)) } +emit_vmulps_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vmulps_xmm_xmm_m128(dst, src, src2)) } +emit_vmulps_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vmulps_ymm_ymm_ymm(dst, src, src2)) } +emit_vmulps_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vmulps_ymm_ymm_m256(dst, src, src2)) } +inst_vmulpd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VMULPD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1035) } +inst_vmulpd_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VMULPD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1035) } +inst_vmulpd_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VMULPD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1036) } +inst_vmulpd_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VMULPD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1036) } +emit_vmulpd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vmulpd_xmm_xmm_xmm(dst, src, src2)) } +emit_vmulpd_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vmulpd_xmm_xmm_m128(dst, src, src2)) } +emit_vmulpd_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vmulpd_ymm_ymm_ymm(dst, src, src2)) } +emit_vmulpd_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vmulpd_ymm_ymm_m256(dst, src, src2)) } +inst_vmulss_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VMULSS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1037) } +inst_vmulss_xmm_xmm_m32 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .VMULSS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 4), {}} }, 1037) } +emit_vmulss_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vmulss_xmm_xmm_xmm(dst, src, src2)) } +emit_vmulss_xmm_xmm_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem32) { append(instructions, inst_vmulss_xmm_xmm_m32(dst, src, src2)) } +inst_vmulsd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VMULSD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1038) } +inst_vmulsd_xmm_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .VMULSD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 8), {}} }, 1038) } +emit_vmulsd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vmulsd_xmm_xmm_xmm(dst, src, src2)) } +emit_vmulsd_xmm_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem64) { append(instructions, inst_vmulsd_xmm_xmm_m64(dst, src, src2)) } +inst_vdivps_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VDIVPS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1039) } +inst_vdivps_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VDIVPS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1039) } +inst_vdivps_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VDIVPS, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1040) } +inst_vdivps_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VDIVPS, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1040) } +emit_vdivps_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vdivps_xmm_xmm_xmm(dst, src, src2)) } +emit_vdivps_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vdivps_xmm_xmm_m128(dst, src, src2)) } +emit_vdivps_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vdivps_ymm_ymm_ymm(dst, src, src2)) } +emit_vdivps_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vdivps_ymm_ymm_m256(dst, src, src2)) } +inst_vdivpd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VDIVPD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1041) } +inst_vdivpd_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VDIVPD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1041) } +inst_vdivpd_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VDIVPD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1042) } +inst_vdivpd_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VDIVPD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1042) } +emit_vdivpd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vdivpd_xmm_xmm_xmm(dst, src, src2)) } +emit_vdivpd_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vdivpd_xmm_xmm_m128(dst, src, src2)) } +emit_vdivpd_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vdivpd_ymm_ymm_ymm(dst, src, src2)) } +emit_vdivpd_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vdivpd_ymm_ymm_m256(dst, src, src2)) } +inst_vdivss_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VDIVSS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1043) } +inst_vdivss_xmm_xmm_m32 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .VDIVSS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 4), {}} }, 1043) } +emit_vdivss_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vdivss_xmm_xmm_xmm(dst, src, src2)) } +emit_vdivss_xmm_xmm_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem32) { append(instructions, inst_vdivss_xmm_xmm_m32(dst, src, src2)) } +inst_vdivsd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VDIVSD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1044) } +inst_vdivsd_xmm_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .VDIVSD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 8), {}} }, 1044) } +emit_vdivsd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vdivsd_xmm_xmm_xmm(dst, src, src2)) } +emit_vdivsd_xmm_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem64) { append(instructions, inst_vdivsd_xmm_xmm_m64(dst, src, src2)) } +inst_vsqrtps_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VSQRTPS, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 1045) } +inst_vsqrtps_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VSQRTPS, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 1045) } +inst_vsqrtps_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VSQRTPS, operand_count = 2, ops = {op_ymm(dst), op_ymm(src), {}, {}} }, 1046) } +inst_vsqrtps_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VSQRTPS, operand_count = 2, ops = {op_ymm(dst), op_mem(src.mem, 32), {}, {}} }, 1046) } +emit_vsqrtps_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_vsqrtps_xmm_xmm(dst, src)) } +emit_vsqrtps_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_vsqrtps_xmm_m128(dst, src)) } +emit_vsqrtps_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM) { append(instructions, inst_vsqrtps_ymm_ymm(dst, src)) } +emit_vsqrtps_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem256) { append(instructions, inst_vsqrtps_ymm_m256(dst, src)) } +inst_vsqrtpd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VSQRTPD, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 1047) } +inst_vsqrtpd_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VSQRTPD, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 1047) } +inst_vsqrtpd_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VSQRTPD, operand_count = 2, ops = {op_ymm(dst), op_ymm(src), {}, {}} }, 1048) } +inst_vsqrtpd_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VSQRTPD, operand_count = 2, ops = {op_ymm(dst), op_mem(src.mem, 32), {}, {}} }, 1048) } +emit_vsqrtpd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_vsqrtpd_xmm_xmm(dst, src)) } +emit_vsqrtpd_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_vsqrtpd_xmm_m128(dst, src)) } +emit_vsqrtpd_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM) { append(instructions, inst_vsqrtpd_ymm_ymm(dst, src)) } +emit_vsqrtpd_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem256) { append(instructions, inst_vsqrtpd_ymm_m256(dst, src)) } +inst_vsqrtss_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VSQRTSS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1049) } +inst_vsqrtss_xmm_xmm_m32 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .VSQRTSS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 4), {}} }, 1049) } +emit_vsqrtss_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vsqrtss_xmm_xmm_xmm(dst, src, src2)) } +emit_vsqrtss_xmm_xmm_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem32) { append(instructions, inst_vsqrtss_xmm_xmm_m32(dst, src, src2)) } +inst_vsqrtsd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VSQRTSD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1050) } +inst_vsqrtsd_xmm_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .VSQRTSD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 8), {}} }, 1050) } +emit_vsqrtsd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vsqrtsd_xmm_xmm_xmm(dst, src, src2)) } +emit_vsqrtsd_xmm_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem64) { append(instructions, inst_vsqrtsd_xmm_xmm_m64(dst, src, src2)) } +inst_vrcpps_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VRCPPS, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 1051) } +inst_vrcpps_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VRCPPS, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 1051) } +inst_vrcpps_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VRCPPS, operand_count = 2, ops = {op_ymm(dst), op_ymm(src), {}, {}} }, 1052) } +inst_vrcpps_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VRCPPS, operand_count = 2, ops = {op_ymm(dst), op_mem(src.mem, 32), {}, {}} }, 1052) } +emit_vrcpps_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_vrcpps_xmm_xmm(dst, src)) } +emit_vrcpps_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_vrcpps_xmm_m128(dst, src)) } +emit_vrcpps_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM) { append(instructions, inst_vrcpps_ymm_ymm(dst, src)) } +emit_vrcpps_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem256) { append(instructions, inst_vrcpps_ymm_m256(dst, src)) } +inst_vrcpss_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VRCPSS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1053) } +inst_vrcpss_xmm_xmm_m32 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .VRCPSS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 4), {}} }, 1053) } +emit_vrcpss_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vrcpss_xmm_xmm_xmm(dst, src, src2)) } +emit_vrcpss_xmm_xmm_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem32) { append(instructions, inst_vrcpss_xmm_xmm_m32(dst, src, src2)) } +inst_vrsqrtps_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VRSQRTPS, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 1054) } +inst_vrsqrtps_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VRSQRTPS, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 1054) } +inst_vrsqrtps_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VRSQRTPS, operand_count = 2, ops = {op_ymm(dst), op_ymm(src), {}, {}} }, 1055) } +inst_vrsqrtps_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VRSQRTPS, operand_count = 2, ops = {op_ymm(dst), op_mem(src.mem, 32), {}, {}} }, 1055) } +emit_vrsqrtps_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_vrsqrtps_xmm_xmm(dst, src)) } +emit_vrsqrtps_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_vrsqrtps_xmm_m128(dst, src)) } +emit_vrsqrtps_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM) { append(instructions, inst_vrsqrtps_ymm_ymm(dst, src)) } +emit_vrsqrtps_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem256) { append(instructions, inst_vrsqrtps_ymm_m256(dst, src)) } +inst_vrsqrtss_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VRSQRTSS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1056) } +inst_vrsqrtss_xmm_xmm_m32 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .VRSQRTSS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 4), {}} }, 1056) } +emit_vrsqrtss_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vrsqrtss_xmm_xmm_xmm(dst, src, src2)) } +emit_vrsqrtss_xmm_xmm_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem32) { append(instructions, inst_vrsqrtss_xmm_xmm_m32(dst, src, src2)) } +inst_vmaxps_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VMAXPS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1057) } +inst_vmaxps_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VMAXPS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1057) } +inst_vmaxps_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VMAXPS, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1058) } +inst_vmaxps_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VMAXPS, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1058) } +emit_vmaxps_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vmaxps_xmm_xmm_xmm(dst, src, src2)) } +emit_vmaxps_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vmaxps_xmm_xmm_m128(dst, src, src2)) } +emit_vmaxps_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vmaxps_ymm_ymm_ymm(dst, src, src2)) } +emit_vmaxps_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vmaxps_ymm_ymm_m256(dst, src, src2)) } +inst_vmaxpd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VMAXPD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1059) } +inst_vmaxpd_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VMAXPD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1059) } +inst_vmaxpd_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VMAXPD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1060) } +inst_vmaxpd_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VMAXPD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1060) } +emit_vmaxpd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vmaxpd_xmm_xmm_xmm(dst, src, src2)) } +emit_vmaxpd_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vmaxpd_xmm_xmm_m128(dst, src, src2)) } +emit_vmaxpd_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vmaxpd_ymm_ymm_ymm(dst, src, src2)) } +emit_vmaxpd_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vmaxpd_ymm_ymm_m256(dst, src, src2)) } +inst_vmaxss_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VMAXSS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1061) } +inst_vmaxss_xmm_xmm_m32 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .VMAXSS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 4), {}} }, 1061) } +emit_vmaxss_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vmaxss_xmm_xmm_xmm(dst, src, src2)) } +emit_vmaxss_xmm_xmm_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem32) { append(instructions, inst_vmaxss_xmm_xmm_m32(dst, src, src2)) } +inst_vmaxsd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VMAXSD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1062) } +inst_vmaxsd_xmm_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .VMAXSD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 8), {}} }, 1062) } +emit_vmaxsd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vmaxsd_xmm_xmm_xmm(dst, src, src2)) } +emit_vmaxsd_xmm_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem64) { append(instructions, inst_vmaxsd_xmm_xmm_m64(dst, src, src2)) } +inst_vminps_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VMINPS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1063) } +inst_vminps_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VMINPS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1063) } +inst_vminps_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VMINPS, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1064) } +inst_vminps_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VMINPS, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1064) } +emit_vminps_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vminps_xmm_xmm_xmm(dst, src, src2)) } +emit_vminps_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vminps_xmm_xmm_m128(dst, src, src2)) } +emit_vminps_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vminps_ymm_ymm_ymm(dst, src, src2)) } +emit_vminps_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vminps_ymm_ymm_m256(dst, src, src2)) } +inst_vminpd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VMINPD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1065) } +inst_vminpd_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VMINPD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1065) } +inst_vminpd_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VMINPD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1066) } +inst_vminpd_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VMINPD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1066) } +emit_vminpd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vminpd_xmm_xmm_xmm(dst, src, src2)) } +emit_vminpd_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vminpd_xmm_xmm_m128(dst, src, src2)) } +emit_vminpd_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vminpd_ymm_ymm_ymm(dst, src, src2)) } +emit_vminpd_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vminpd_ymm_ymm_m256(dst, src, src2)) } +inst_vminss_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VMINSS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1067) } +inst_vminss_xmm_xmm_m32 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .VMINSS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 4), {}} }, 1067) } +emit_vminss_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vminss_xmm_xmm_xmm(dst, src, src2)) } +emit_vminss_xmm_xmm_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem32) { append(instructions, inst_vminss_xmm_xmm_m32(dst, src, src2)) } +inst_vminsd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VMINSD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1068) } +inst_vminsd_xmm_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .VMINSD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 8), {}} }, 1068) } +emit_vminsd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vminsd_xmm_xmm_xmm(dst, src, src2)) } +emit_vminsd_xmm_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem64) { append(instructions, inst_vminsd_xmm_xmm_m64(dst, src, src2)) } +inst_vandps_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VANDPS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1069) } +inst_vandps_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VANDPS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1069) } +inst_vandps_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VANDPS, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1070) } +inst_vandps_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VANDPS, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1070) } +emit_vandps_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vandps_xmm_xmm_xmm(dst, src, src2)) } +emit_vandps_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vandps_xmm_xmm_m128(dst, src, src2)) } +emit_vandps_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vandps_ymm_ymm_ymm(dst, src, src2)) } +emit_vandps_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vandps_ymm_ymm_m256(dst, src, src2)) } +inst_vandpd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VANDPD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1071) } +inst_vandpd_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VANDPD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1071) } +inst_vandpd_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VANDPD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1072) } +inst_vandpd_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VANDPD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1072) } +emit_vandpd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vandpd_xmm_xmm_xmm(dst, src, src2)) } +emit_vandpd_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vandpd_xmm_xmm_m128(dst, src, src2)) } +emit_vandpd_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vandpd_ymm_ymm_ymm(dst, src, src2)) } +emit_vandpd_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vandpd_ymm_ymm_m256(dst, src, src2)) } +inst_vandnps_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VANDNPS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1073) } +inst_vandnps_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VANDNPS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1073) } +inst_vandnps_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VANDNPS, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1074) } +inst_vandnps_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VANDNPS, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1074) } +emit_vandnps_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vandnps_xmm_xmm_xmm(dst, src, src2)) } +emit_vandnps_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vandnps_xmm_xmm_m128(dst, src, src2)) } +emit_vandnps_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vandnps_ymm_ymm_ymm(dst, src, src2)) } +emit_vandnps_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vandnps_ymm_ymm_m256(dst, src, src2)) } +inst_vandnpd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VANDNPD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1075) } +inst_vandnpd_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VANDNPD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1075) } +inst_vandnpd_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VANDNPD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1076) } +inst_vandnpd_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VANDNPD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1076) } +emit_vandnpd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vandnpd_xmm_xmm_xmm(dst, src, src2)) } +emit_vandnpd_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vandnpd_xmm_xmm_m128(dst, src, src2)) } +emit_vandnpd_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vandnpd_ymm_ymm_ymm(dst, src, src2)) } +emit_vandnpd_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vandnpd_ymm_ymm_m256(dst, src, src2)) } +inst_vorps_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VORPS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1077) } +inst_vorps_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VORPS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1077) } +inst_vorps_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VORPS, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1078) } +inst_vorps_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VORPS, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1078) } +emit_vorps_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vorps_xmm_xmm_xmm(dst, src, src2)) } +emit_vorps_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vorps_xmm_xmm_m128(dst, src, src2)) } +emit_vorps_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vorps_ymm_ymm_ymm(dst, src, src2)) } +emit_vorps_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vorps_ymm_ymm_m256(dst, src, src2)) } +inst_vorpd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VORPD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1079) } +inst_vorpd_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VORPD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1079) } +inst_vorpd_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VORPD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1080) } +inst_vorpd_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VORPD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1080) } +emit_vorpd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vorpd_xmm_xmm_xmm(dst, src, src2)) } +emit_vorpd_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vorpd_xmm_xmm_m128(dst, src, src2)) } +emit_vorpd_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vorpd_ymm_ymm_ymm(dst, src, src2)) } +emit_vorpd_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vorpd_ymm_ymm_m256(dst, src, src2)) } +inst_vxorps_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VXORPS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1081) } +inst_vxorps_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VXORPS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1081) } +inst_vxorps_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VXORPS, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1082) } +inst_vxorps_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VXORPS, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1082) } +emit_vxorps_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vxorps_xmm_xmm_xmm(dst, src, src2)) } +emit_vxorps_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vxorps_xmm_xmm_m128(dst, src, src2)) } +emit_vxorps_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vxorps_ymm_ymm_ymm(dst, src, src2)) } +emit_vxorps_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vxorps_ymm_ymm_m256(dst, src, src2)) } +inst_vxorpd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VXORPD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1083) } +inst_vxorpd_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VXORPD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1083) } +inst_vxorpd_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VXORPD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1084) } +inst_vxorpd_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VXORPD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1084) } +emit_vxorpd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vxorpd_xmm_xmm_xmm(dst, src, src2)) } +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)} } } @@ -3499,22 +3499,22 @@ inst_vcmpsd_xmm_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XM 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)} } } 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 inst_r_r(.VCOMISS, Register(dst), Register(src)) } -inst_vcomiss_xmm_m32 :: #force_inline proc "contextless" (dst: XMM, src: Mem32) -> Instruction { return inst_r_m(.VCOMISS, Register(dst), src.mem, 4) } -emit_vcomiss_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .VCOMISS, Register(dst), Register(src)) } -emit_vcomiss_xmm_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem32) { emit_rm(instructions, .VCOMISS, Register(dst), src.mem, 4) } -inst_vcomisd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.VCOMISD, Register(dst), Register(src)) } -inst_vcomisd_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: Mem64) -> Instruction { return inst_r_m(.VCOMISD, Register(dst), src.mem, 8) } -emit_vcomisd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .VCOMISD, Register(dst), Register(src)) } -emit_vcomisd_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem64) { emit_rm(instructions, .VCOMISD, Register(dst), src.mem, 8) } -inst_vucomiss_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.VUCOMISS, Register(dst), Register(src)) } -inst_vucomiss_xmm_m32 :: #force_inline proc "contextless" (dst: XMM, src: Mem32) -> Instruction { return inst_r_m(.VUCOMISS, Register(dst), src.mem, 4) } -emit_vucomiss_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .VUCOMISS, Register(dst), Register(src)) } -emit_vucomiss_xmm_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem32) { emit_rm(instructions, .VUCOMISS, Register(dst), src.mem, 4) } -inst_vucomisd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.VUCOMISD, Register(dst), Register(src)) } -inst_vucomisd_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: Mem64) -> Instruction { return inst_r_m(.VUCOMISD, Register(dst), src.mem, 8) } -emit_vucomisd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .VUCOMISD, Register(dst), Register(src)) } -emit_vucomisd_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem64) { emit_rm(instructions, .VUCOMISD, Register(dst), src.mem, 8) } +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) } +inst_vcomiss_xmm_m32 :: #force_inline proc "contextless" (dst: XMM, src: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .VCOMISS, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 4), {}, {}} }, 1091) } +emit_vcomiss_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_vcomiss_xmm_xmm(dst, src)) } +emit_vcomiss_xmm_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem32) { append(instructions, inst_vcomiss_xmm_m32(dst, src)) } +inst_vcomisd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VCOMISD, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 1092) } +inst_vcomisd_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .VCOMISD, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 8), {}, {}} }, 1092) } +emit_vcomisd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_vcomisd_xmm_xmm(dst, src)) } +emit_vcomisd_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem64) { append(instructions, inst_vcomisd_xmm_m64(dst, src)) } +inst_vucomiss_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VUCOMISS, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 1093) } +inst_vucomiss_xmm_m32 :: #force_inline proc "contextless" (dst: XMM, src: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .VUCOMISS, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 4), {}, {}} }, 1093) } +emit_vucomiss_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_vucomiss_xmm_xmm(dst, src)) } +emit_vucomiss_xmm_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem32) { append(instructions, inst_vucomiss_xmm_m32(dst, src)) } +inst_vucomisd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VUCOMISD, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 1094) } +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)} } } @@ -3531,38 +3531,38 @@ emit_vshufpd_xmm_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynami 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)) } emit_vshufpd_ymm_ymm_m256_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256, imm: i8) { append(instructions, inst_vshufpd_ymm_ymm_m256_imm8(dst, src, src2, imm)) } -inst_vunpcklps_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VUNPCKLPS, Register(dst), Register(src), Register(src2)) } -inst_vunpcklps_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VUNPCKLPS, Register(dst), Register(src), src2.mem, 16) } -inst_vunpcklps_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VUNPCKLPS, Register(dst), Register(src), Register(src2)) } -inst_vunpcklps_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VUNPCKLPS, Register(dst), Register(src), src2.mem, 32) } -emit_vunpcklps_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VUNPCKLPS, Register(dst), Register(src), Register(src2)) } -emit_vunpcklps_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VUNPCKLPS, Register(dst), Register(src), src2.mem, 16) } -emit_vunpcklps_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VUNPCKLPS, Register(dst), Register(src), Register(src2)) } -emit_vunpcklps_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VUNPCKLPS, Register(dst), Register(src), src2.mem, 32) } -inst_vunpckhps_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VUNPCKHPS, Register(dst), Register(src), Register(src2)) } -inst_vunpckhps_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VUNPCKHPS, Register(dst), Register(src), src2.mem, 16) } -inst_vunpckhps_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VUNPCKHPS, Register(dst), Register(src), Register(src2)) } -inst_vunpckhps_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VUNPCKHPS, Register(dst), Register(src), src2.mem, 32) } -emit_vunpckhps_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VUNPCKHPS, Register(dst), Register(src), Register(src2)) } -emit_vunpckhps_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VUNPCKHPS, Register(dst), Register(src), src2.mem, 16) } -emit_vunpckhps_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VUNPCKHPS, Register(dst), Register(src), Register(src2)) } -emit_vunpckhps_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VUNPCKHPS, Register(dst), Register(src), src2.mem, 32) } -inst_vunpcklpd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VUNPCKLPD, Register(dst), Register(src), Register(src2)) } -inst_vunpcklpd_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VUNPCKLPD, Register(dst), Register(src), src2.mem, 16) } -inst_vunpcklpd_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VUNPCKLPD, Register(dst), Register(src), Register(src2)) } -inst_vunpcklpd_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VUNPCKLPD, Register(dst), Register(src), src2.mem, 32) } -emit_vunpcklpd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VUNPCKLPD, Register(dst), Register(src), Register(src2)) } -emit_vunpcklpd_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VUNPCKLPD, Register(dst), Register(src), src2.mem, 16) } -emit_vunpcklpd_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VUNPCKLPD, Register(dst), Register(src), Register(src2)) } -emit_vunpcklpd_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VUNPCKLPD, Register(dst), Register(src), src2.mem, 32) } -inst_vunpckhpd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VUNPCKHPD, Register(dst), Register(src), Register(src2)) } -inst_vunpckhpd_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VUNPCKHPD, Register(dst), Register(src), src2.mem, 16) } -inst_vunpckhpd_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VUNPCKHPD, Register(dst), Register(src), Register(src2)) } -inst_vunpckhpd_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VUNPCKHPD, Register(dst), Register(src), src2.mem, 32) } -emit_vunpckhpd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VUNPCKHPD, Register(dst), Register(src), Register(src2)) } -emit_vunpckhpd_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VUNPCKHPD, Register(dst), Register(src), src2.mem, 16) } -emit_vunpckhpd_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VUNPCKHPD, Register(dst), Register(src), Register(src2)) } -emit_vunpckhpd_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VUNPCKHPD, Register(dst), Register(src), src2.mem, 32) } +inst_vunpcklps_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VUNPCKLPS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1099) } +inst_vunpcklps_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VUNPCKLPS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1099) } +inst_vunpcklps_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VUNPCKLPS, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1100) } +inst_vunpcklps_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VUNPCKLPS, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1100) } +emit_vunpcklps_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vunpcklps_xmm_xmm_xmm(dst, src, src2)) } +emit_vunpcklps_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vunpcklps_xmm_xmm_m128(dst, src, src2)) } +emit_vunpcklps_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vunpcklps_ymm_ymm_ymm(dst, src, src2)) } +emit_vunpcklps_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vunpcklps_ymm_ymm_m256(dst, src, src2)) } +inst_vunpckhps_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VUNPCKHPS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1101) } +inst_vunpckhps_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VUNPCKHPS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1101) } +inst_vunpckhps_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VUNPCKHPS, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1102) } +inst_vunpckhps_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VUNPCKHPS, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1102) } +emit_vunpckhps_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vunpckhps_xmm_xmm_xmm(dst, src, src2)) } +emit_vunpckhps_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vunpckhps_xmm_xmm_m128(dst, src, src2)) } +emit_vunpckhps_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vunpckhps_ymm_ymm_ymm(dst, src, src2)) } +emit_vunpckhps_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vunpckhps_ymm_ymm_m256(dst, src, src2)) } +inst_vunpcklpd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VUNPCKLPD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1103) } +inst_vunpcklpd_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VUNPCKLPD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1103) } +inst_vunpcklpd_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VUNPCKLPD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1104) } +inst_vunpcklpd_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VUNPCKLPD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1104) } +emit_vunpcklpd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vunpcklpd_xmm_xmm_xmm(dst, src, src2)) } +emit_vunpcklpd_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vunpcklpd_xmm_xmm_m128(dst, src, src2)) } +emit_vunpcklpd_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vunpcklpd_ymm_ymm_ymm(dst, src, src2)) } +emit_vunpcklpd_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vunpcklpd_ymm_ymm_m256(dst, src, src2)) } +inst_vunpckhpd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VUNPCKHPD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1105) } +inst_vunpckhpd_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VUNPCKHPD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1105) } +inst_vunpckhpd_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VUNPCKHPD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1106) } +inst_vunpckhpd_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VUNPCKHPD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1106) } +emit_vunpckhpd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vunpckhpd_xmm_xmm_xmm(dst, src, src2)) } +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)} } } @@ -3579,21 +3579,21 @@ emit_vblendpd_xmm_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynami 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)) } emit_vblendpd_ymm_ymm_m256_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256, imm: i8) { append(instructions, inst_vblendpd_ymm_ymm_m256_imm8(dst, src, src2, imm)) } -inst_vblendvps_xmm_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM, src3: XMM) -> Instruction { return inst_r_r_r_r(.VBLENDVPS, Register(dst), Register(src), Register(src2), Register(src3)) } -inst_vblendvps_xmm_xmm_m128_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128, src3: XMM) -> Instruction { return Instruction{ mnemonic = .VBLENDVPS, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), op_xmm(src3)} } } -inst_vblendvps_ymm_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM, src3: YMM) -> Instruction { return inst_r_r_r_r(.VBLENDVPS, Register(dst), Register(src), Register(src2), Register(src3)) } -inst_vblendvps_ymm_ymm_m256_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256, src3: YMM) -> Instruction { return Instruction{ mnemonic = .VBLENDVPS, operand_count = 4, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), op_ymm(src3)} } } -emit_vblendvps_xmm_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM, src3: XMM) { emit_rrrr(instructions, .VBLENDVPS, Register(dst), Register(src), Register(src2), Register(src3)) } +inst_vblendvps_xmm_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM, src3: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VBLENDVPS, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), op_xmm(src3)} }, 1111) } +inst_vblendvps_xmm_xmm_m128_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128, src3: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VBLENDVPS, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), op_xmm(src3)} }, 1111) } +inst_vblendvps_ymm_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM, src3: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VBLENDVPS, operand_count = 4, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), op_ymm(src3)} }, 1112) } +inst_vblendvps_ymm_ymm_m256_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256, src3: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VBLENDVPS, operand_count = 4, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), op_ymm(src3)} }, 1112) } +emit_vblendvps_xmm_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM, src3: XMM) { append(instructions, inst_vblendvps_xmm_xmm_xmm_xmm(dst, src, src2, src3)) } emit_vblendvps_xmm_xmm_m128_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128, src3: XMM) { append(instructions, inst_vblendvps_xmm_xmm_m128_xmm(dst, src, src2, src3)) } -emit_vblendvps_ymm_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM, src3: YMM) { emit_rrrr(instructions, .VBLENDVPS, Register(dst), Register(src), Register(src2), Register(src3)) } +emit_vblendvps_ymm_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM, src3: YMM) { append(instructions, inst_vblendvps_ymm_ymm_ymm_ymm(dst, src, src2, src3)) } emit_vblendvps_ymm_ymm_m256_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256, src3: YMM) { append(instructions, inst_vblendvps_ymm_ymm_m256_ymm(dst, src, src2, src3)) } -inst_vblendvpd_xmm_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM, src3: XMM) -> Instruction { return inst_r_r_r_r(.VBLENDVPD, Register(dst), Register(src), Register(src2), Register(src3)) } -inst_vblendvpd_xmm_xmm_m128_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128, src3: XMM) -> Instruction { return Instruction{ mnemonic = .VBLENDVPD, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), op_xmm(src3)} } } -inst_vblendvpd_ymm_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM, src3: YMM) -> Instruction { return inst_r_r_r_r(.VBLENDVPD, Register(dst), Register(src), Register(src2), Register(src3)) } -inst_vblendvpd_ymm_ymm_m256_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256, src3: YMM) -> Instruction { return Instruction{ mnemonic = .VBLENDVPD, operand_count = 4, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), op_ymm(src3)} } } -emit_vblendvpd_xmm_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM, src3: XMM) { emit_rrrr(instructions, .VBLENDVPD, Register(dst), Register(src), Register(src2), Register(src3)) } +inst_vblendvpd_xmm_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM, src3: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VBLENDVPD, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), op_xmm(src3)} }, 1113) } +inst_vblendvpd_xmm_xmm_m128_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128, src3: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VBLENDVPD, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), op_xmm(src3)} }, 1113) } +inst_vblendvpd_ymm_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM, src3: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VBLENDVPD, operand_count = 4, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), op_ymm(src3)} }, 1114) } +inst_vblendvpd_ymm_ymm_m256_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256, src3: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VBLENDVPD, operand_count = 4, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), op_ymm(src3)} }, 1114) } +emit_vblendvpd_xmm_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM, src3: XMM) { append(instructions, inst_vblendvpd_xmm_xmm_xmm_xmm(dst, src, src2, src3)) } 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) { emit_rrrr(instructions, .VBLENDVPD, Register(dst), Register(src), Register(src2), Register(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)} } } @@ -3607,22 +3607,22 @@ inst_vdppd_xmm_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XM 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)} } } 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 inst_r_r_i(.VROUNDPS, Register(dst), Register(src), i64(imm), 1) } -inst_vroundps_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem128, imm: i8) -> Instruction { return inst_r_m_i(.VROUNDPS, Register(dst), src.mem, 16, i64(imm), 1) } -inst_vroundps_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, imm: i8) -> Instruction { return inst_r_r_i(.VROUNDPS, Register(dst), Register(src), i64(imm), 1) } -inst_vroundps_ymm_m256_imm8 :: #force_inline proc "contextless" (dst: YMM, src: Mem256, imm: i8) -> Instruction { return inst_r_m_i(.VROUNDPS, Register(dst), src.mem, 32, i64(imm), 1) } -emit_vroundps_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, imm: i8) { emit_rri(instructions, .VROUNDPS, Register(dst), Register(src), i64(imm), 1) } -emit_vroundps_xmm_m128_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128, imm: i8) { emit_rmi(instructions, .VROUNDPS, Register(dst), src.mem, 16, i64(imm), 1) } -emit_vroundps_ymm_ymm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, imm: i8) { emit_rri(instructions, .VROUNDPS, Register(dst), Register(src), i64(imm), 1) } -emit_vroundps_ymm_m256_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem256, imm: i8) { emit_rmi(instructions, .VROUNDPS, Register(dst), src.mem, 32, i64(imm), 1) } -inst_vroundpd_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return inst_r_r_i(.VROUNDPD, Register(dst), Register(src), i64(imm), 1) } -inst_vroundpd_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem128, imm: i8) -> Instruction { return inst_r_m_i(.VROUNDPD, Register(dst), src.mem, 16, i64(imm), 1) } -inst_vroundpd_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, imm: i8) -> Instruction { return inst_r_r_i(.VROUNDPD, Register(dst), Register(src), i64(imm), 1) } -inst_vroundpd_ymm_m256_imm8 :: #force_inline proc "contextless" (dst: YMM, src: Mem256, imm: i8) -> Instruction { return inst_r_m_i(.VROUNDPD, Register(dst), src.mem, 32, i64(imm), 1) } -emit_vroundpd_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, imm: i8) { emit_rri(instructions, .VROUNDPD, Register(dst), Register(src), i64(imm), 1) } -emit_vroundpd_xmm_m128_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128, imm: i8) { emit_rmi(instructions, .VROUNDPD, Register(dst), src.mem, 16, i64(imm), 1) } -emit_vroundpd_ymm_ymm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, imm: i8) { emit_rri(instructions, .VROUNDPD, Register(dst), Register(src), i64(imm), 1) } -emit_vroundpd_ymm_m256_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem256, imm: i8) { emit_rmi(instructions, .VROUNDPD, Register(dst), src.mem, 32, i64(imm), 1) } +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), {}} } } +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), {}} } } +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)} } } 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)) } @@ -3631,714 +3631,714 @@ inst_vroundsd_xmm_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XM 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)} } } 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 inst_r_r_i(.VEXTRACTPS, Register(dst), Register(src), i64(imm), 1) } -inst_vextractps_m32_xmm_imm8 :: #force_inline proc "contextless" (dst: Mem32, src: XMM, imm: i8) -> Instruction { return inst_m_r_i(.VEXTRACTPS, dst.mem, 4, Register(src), i64(imm), 1) } -emit_vextractps_r32_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: XMM, imm: i8) { emit_rri(instructions, .VEXTRACTPS, Register(dst), Register(src), i64(imm), 1) } -emit_vextractps_m32_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, src: XMM, imm: i8) { emit_mri(instructions, .VEXTRACTPS, dst.mem, 4, Register(src), i64(imm), 1) } +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), {}} } } +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)} } } 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 inst_r_r(.VMOVAPS, Register(dst), Register(src)) } -inst_vmovaps_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.VMOVAPS, Register(dst), src.mem, 16) } -inst_vmovaps_m128_xmm :: #force_inline proc "contextless" (dst: Mem128, src: XMM) -> Instruction { return inst_m_r(.VMOVAPS, dst.mem, 16, Register(src)) } -inst_vmovaps_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM) -> Instruction { return inst_r_r(.VMOVAPS, Register(dst), Register(src)) } -inst_vmovaps_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: Mem256) -> Instruction { return inst_r_m(.VMOVAPS, Register(dst), src.mem, 32) } -inst_vmovaps_m256_ymm :: #force_inline proc "contextless" (dst: Mem256, src: YMM) -> Instruction { return inst_m_r(.VMOVAPS, dst.mem, 32, Register(src)) } -emit_vmovaps_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .VMOVAPS, Register(dst), Register(src)) } -emit_vmovaps_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .VMOVAPS, Register(dst), src.mem, 16) } -emit_vmovaps_m128_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem128, src: XMM) { emit_mr(instructions, .VMOVAPS, dst.mem, 16, Register(src)) } -emit_vmovaps_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM) { emit_rr(instructions, .VMOVAPS, Register(dst), Register(src)) } -emit_vmovaps_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem256) { emit_rm(instructions, .VMOVAPS, Register(dst), src.mem, 32) } -emit_vmovaps_m256_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem256, src: YMM) { emit_mr(instructions, .VMOVAPS, dst.mem, 32, Register(src)) } -inst_vmovups_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.VMOVUPS, Register(dst), Register(src)) } -inst_vmovups_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.VMOVUPS, Register(dst), src.mem, 16) } -inst_vmovups_m128_xmm :: #force_inline proc "contextless" (dst: Mem128, src: XMM) -> Instruction { return inst_m_r(.VMOVUPS, dst.mem, 16, Register(src)) } -inst_vmovups_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM) -> Instruction { return inst_r_r(.VMOVUPS, Register(dst), Register(src)) } -inst_vmovups_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: Mem256) -> Instruction { return inst_r_m(.VMOVUPS, Register(dst), src.mem, 32) } -inst_vmovups_m256_ymm :: #force_inline proc "contextless" (dst: Mem256, src: YMM) -> Instruction { return inst_m_r(.VMOVUPS, dst.mem, 32, Register(src)) } -emit_vmovups_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .VMOVUPS, Register(dst), Register(src)) } -emit_vmovups_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .VMOVUPS, Register(dst), src.mem, 16) } -emit_vmovups_m128_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem128, src: XMM) { emit_mr(instructions, .VMOVUPS, dst.mem, 16, Register(src)) } -emit_vmovups_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM) { emit_rr(instructions, .VMOVUPS, Register(dst), Register(src)) } -emit_vmovups_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem256) { emit_rm(instructions, .VMOVUPS, Register(dst), src.mem, 32) } -emit_vmovups_m256_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem256, src: YMM) { emit_mr(instructions, .VMOVUPS, dst.mem, 32, Register(src)) } -inst_vmovapd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.VMOVAPD, Register(dst), Register(src)) } -inst_vmovapd_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.VMOVAPD, Register(dst), src.mem, 16) } -inst_vmovapd_m128_xmm :: #force_inline proc "contextless" (dst: Mem128, src: XMM) -> Instruction { return inst_m_r(.VMOVAPD, dst.mem, 16, Register(src)) } -inst_vmovapd_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM) -> Instruction { return inst_r_r(.VMOVAPD, Register(dst), Register(src)) } -inst_vmovapd_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: Mem256) -> Instruction { return inst_r_m(.VMOVAPD, Register(dst), src.mem, 32) } -inst_vmovapd_m256_ymm :: #force_inline proc "contextless" (dst: Mem256, src: YMM) -> Instruction { return inst_m_r(.VMOVAPD, dst.mem, 32, Register(src)) } -emit_vmovapd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .VMOVAPD, Register(dst), Register(src)) } -emit_vmovapd_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .VMOVAPD, Register(dst), src.mem, 16) } -emit_vmovapd_m128_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem128, src: XMM) { emit_mr(instructions, .VMOVAPD, dst.mem, 16, Register(src)) } -emit_vmovapd_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM) { emit_rr(instructions, .VMOVAPD, Register(dst), Register(src)) } -emit_vmovapd_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem256) { emit_rm(instructions, .VMOVAPD, Register(dst), src.mem, 32) } -emit_vmovapd_m256_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem256, src: YMM) { emit_mr(instructions, .VMOVAPD, dst.mem, 32, Register(src)) } -inst_vmovupd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.VMOVUPD, Register(dst), Register(src)) } -inst_vmovupd_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.VMOVUPD, Register(dst), src.mem, 16) } -inst_vmovupd_m128_xmm :: #force_inline proc "contextless" (dst: Mem128, src: XMM) -> Instruction { return inst_m_r(.VMOVUPD, dst.mem, 16, Register(src)) } -inst_vmovupd_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM) -> Instruction { return inst_r_r(.VMOVUPD, Register(dst), Register(src)) } -inst_vmovupd_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: Mem256) -> Instruction { return inst_r_m(.VMOVUPD, Register(dst), src.mem, 32) } -inst_vmovupd_m256_ymm :: #force_inline proc "contextless" (dst: Mem256, src: YMM) -> Instruction { return inst_m_r(.VMOVUPD, dst.mem, 32, Register(src)) } -emit_vmovupd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .VMOVUPD, Register(dst), Register(src)) } -emit_vmovupd_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .VMOVUPD, Register(dst), src.mem, 16) } -emit_vmovupd_m128_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem128, src: XMM) { emit_mr(instructions, .VMOVUPD, dst.mem, 16, Register(src)) } -emit_vmovupd_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM) { emit_rr(instructions, .VMOVUPD, Register(dst), Register(src)) } -emit_vmovupd_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem256) { emit_rm(instructions, .VMOVUPD, Register(dst), src.mem, 32) } -emit_vmovupd_m256_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem256, src: YMM) { emit_mr(instructions, .VMOVUPD, dst.mem, 32, Register(src)) } -inst_vmovss_xmm_m32 :: #force_inline proc "contextless" (dst: XMM, src: Mem32) -> Instruction { return inst_r_m(.VMOVSS, Register(dst), src.mem, 4) } -inst_vmovss_m32_xmm :: #force_inline proc "contextless" (dst: Mem32, src: XMM) -> Instruction { return inst_m_r(.VMOVSS, dst.mem, 4, Register(src)) } -inst_vmovss_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VMOVSS, Register(dst), Register(src), Register(src2)) } -emit_vmovss_xmm_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem32) { emit_rm(instructions, .VMOVSS, Register(dst), src.mem, 4) } -emit_vmovss_m32_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, src: XMM) { emit_mr(instructions, .VMOVSS, dst.mem, 4, Register(src)) } -emit_vmovss_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VMOVSS, Register(dst), Register(src), Register(src2)) } -inst_vmovsd_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: Mem64) -> Instruction { return inst_r_m(.VMOVSD, Register(dst), src.mem, 8) } -inst_vmovsd_m64_xmm :: #force_inline proc "contextless" (dst: Mem64, src: XMM) -> Instruction { return inst_m_r(.VMOVSD, dst.mem, 8, Register(src)) } -inst_vmovsd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VMOVSD, Register(dst), Register(src), Register(src2)) } -emit_vmovsd_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem64) { emit_rm(instructions, .VMOVSD, Register(dst), src.mem, 8) } -emit_vmovsd_m64_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, src: XMM) { emit_mr(instructions, .VMOVSD, dst.mem, 8, Register(src)) } -emit_vmovsd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VMOVSD, Register(dst), Register(src), Register(src2)) } -inst_vmovdqa_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.VMOVDQA, Register(dst), Register(src)) } -inst_vmovdqa_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.VMOVDQA, Register(dst), src.mem, 16) } -inst_vmovdqa_m128_xmm :: #force_inline proc "contextless" (dst: Mem128, src: XMM) -> Instruction { return inst_m_r(.VMOVDQA, dst.mem, 16, Register(src)) } -inst_vmovdqa_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM) -> Instruction { return inst_r_r(.VMOVDQA, Register(dst), Register(src)) } -inst_vmovdqa_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: Mem256) -> Instruction { return inst_r_m(.VMOVDQA, Register(dst), src.mem, 32) } -inst_vmovdqa_m256_ymm :: #force_inline proc "contextless" (dst: Mem256, src: YMM) -> Instruction { return inst_m_r(.VMOVDQA, dst.mem, 32, Register(src)) } -emit_vmovdqa_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .VMOVDQA, Register(dst), Register(src)) } -emit_vmovdqa_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .VMOVDQA, Register(dst), src.mem, 16) } -emit_vmovdqa_m128_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem128, src: XMM) { emit_mr(instructions, .VMOVDQA, dst.mem, 16, Register(src)) } -emit_vmovdqa_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM) { emit_rr(instructions, .VMOVDQA, Register(dst), Register(src)) } -emit_vmovdqa_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem256) { emit_rm(instructions, .VMOVDQA, Register(dst), src.mem, 32) } -emit_vmovdqa_m256_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem256, src: YMM) { emit_mr(instructions, .VMOVDQA, dst.mem, 32, Register(src)) } -inst_vmovdqu_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.VMOVDQU, Register(dst), Register(src)) } -inst_vmovdqu_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.VMOVDQU, Register(dst), src.mem, 16) } -inst_vmovdqu_m128_xmm :: #force_inline proc "contextless" (dst: Mem128, src: XMM) -> Instruction { return inst_m_r(.VMOVDQU, dst.mem, 16, Register(src)) } -inst_vmovdqu_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM) -> Instruction { return inst_r_r(.VMOVDQU, Register(dst), Register(src)) } -inst_vmovdqu_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: Mem256) -> Instruction { return inst_r_m(.VMOVDQU, Register(dst), src.mem, 32) } -inst_vmovdqu_m256_ymm :: #force_inline proc "contextless" (dst: Mem256, src: YMM) -> Instruction { return inst_m_r(.VMOVDQU, dst.mem, 32, Register(src)) } -emit_vmovdqu_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .VMOVDQU, Register(dst), Register(src)) } -emit_vmovdqu_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .VMOVDQU, Register(dst), src.mem, 16) } -emit_vmovdqu_m128_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem128, src: XMM) { emit_mr(instructions, .VMOVDQU, dst.mem, 16, Register(src)) } -emit_vmovdqu_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM) { emit_rr(instructions, .VMOVDQU, Register(dst), Register(src)) } -emit_vmovdqu_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem256) { emit_rm(instructions, .VMOVDQU, Register(dst), src.mem, 32) } -emit_vmovdqu_m256_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem256, src: YMM) { emit_mr(instructions, .VMOVDQU, dst.mem, 32, Register(src)) } -inst_vmovq_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.VMOVQ, Register(dst), Register(src)) } -inst_vmovq_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: Mem64) -> Instruction { return inst_r_m(.VMOVQ, Register(dst), src.mem, 8) } -inst_vmovq_m64_xmm :: #force_inline proc "contextless" (dst: Mem64, src: XMM) -> Instruction { return inst_m_r(.VMOVQ, dst.mem, 8, Register(src)) } -inst_vmovq_xmm_r64 :: #force_inline proc "contextless" (dst: XMM, src: GPR64) -> Instruction { return inst_r_r(.VMOVQ, Register(dst), Register(src)) } -inst_vmovq_r64_xmm :: #force_inline proc "contextless" (dst: GPR64, src: XMM) -> Instruction { return inst_r_r(.VMOVQ, Register(dst), Register(src)) } -emit_vmovq_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .VMOVQ, Register(dst), Register(src)) } -emit_vmovq_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem64) { emit_rm(instructions, .VMOVQ, Register(dst), src.mem, 8) } -emit_vmovq_m64_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, src: XMM) { emit_mr(instructions, .VMOVQ, dst.mem, 8, Register(src)) } -emit_vmovq_xmm_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: GPR64) { emit_rr(instructions, .VMOVQ, Register(dst), Register(src)) } -emit_vmovq_r64_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: XMM) { emit_rr(instructions, .VMOVQ, Register(dst), Register(src)) } -inst_vmovd_xmm_r32 :: #force_inline proc "contextless" (dst: XMM, src: GPR32) -> Instruction { return inst_r_r(.VMOVD, Register(dst), Register(src)) } -inst_vmovd_xmm_m32 :: #force_inline proc "contextless" (dst: XMM, src: Mem32) -> Instruction { return inst_r_m(.VMOVD, Register(dst), src.mem, 4) } -inst_vmovd_r32_xmm :: #force_inline proc "contextless" (dst: GPR32, src: XMM) -> Instruction { return inst_r_r(.VMOVD, Register(dst), Register(src)) } -inst_vmovd_m32_xmm :: #force_inline proc "contextless" (dst: Mem32, src: XMM) -> Instruction { return inst_m_r(.VMOVD, dst.mem, 4, Register(src)) } -emit_vmovd_xmm_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: GPR32) { emit_rr(instructions, .VMOVD, Register(dst), Register(src)) } -emit_vmovd_xmm_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem32) { emit_rm(instructions, .VMOVD, Register(dst), src.mem, 4) } -emit_vmovd_r32_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: XMM) { emit_rr(instructions, .VMOVD, Register(dst), Register(src)) } -emit_vmovd_m32_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, src: XMM) { emit_mr(instructions, .VMOVD, dst.mem, 4, Register(src)) } -inst_vmovlps_xmm_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem64) -> Instruction { return inst_r_r_m(.VMOVLPS, Register(dst), Register(src), src2.mem, 8) } -inst_vmovlps_m64_xmm :: #force_inline proc "contextless" (dst: Mem64, src: XMM) -> Instruction { return inst_m_r(.VMOVLPS, dst.mem, 8, Register(src)) } -emit_vmovlps_xmm_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem64) { emit_rrm(instructions, .VMOVLPS, Register(dst), Register(src), src2.mem, 8) } -emit_vmovlps_m64_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, src: XMM) { emit_mr(instructions, .VMOVLPS, dst.mem, 8, Register(src)) } -inst_vmovhps_xmm_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem64) -> Instruction { return inst_r_r_m(.VMOVHPS, Register(dst), Register(src), src2.mem, 8) } -inst_vmovhps_m64_xmm :: #force_inline proc "contextless" (dst: Mem64, src: XMM) -> Instruction { return inst_m_r(.VMOVHPS, dst.mem, 8, Register(src)) } -emit_vmovhps_xmm_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem64) { emit_rrm(instructions, .VMOVHPS, Register(dst), Register(src), src2.mem, 8) } -emit_vmovhps_m64_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, src: XMM) { emit_mr(instructions, .VMOVHPS, dst.mem, 8, Register(src)) } -inst_vmovlpd_xmm_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem64) -> Instruction { return inst_r_r_m(.VMOVLPD, Register(dst), Register(src), src2.mem, 8) } -inst_vmovlpd_m64_xmm :: #force_inline proc "contextless" (dst: Mem64, src: XMM) -> Instruction { return inst_m_r(.VMOVLPD, dst.mem, 8, Register(src)) } -emit_vmovlpd_xmm_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem64) { emit_rrm(instructions, .VMOVLPD, Register(dst), Register(src), src2.mem, 8) } -emit_vmovlpd_m64_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, src: XMM) { emit_mr(instructions, .VMOVLPD, dst.mem, 8, Register(src)) } -inst_vmovhpd_xmm_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem64) -> Instruction { return inst_r_r_m(.VMOVHPD, Register(dst), Register(src), src2.mem, 8) } -inst_vmovhpd_m64_xmm :: #force_inline proc "contextless" (dst: Mem64, src: XMM) -> Instruction { return inst_m_r(.VMOVHPD, dst.mem, 8, Register(src)) } -emit_vmovhpd_xmm_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem64) { emit_rrm(instructions, .VMOVHPD, Register(dst), Register(src), src2.mem, 8) } -emit_vmovhpd_m64_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, src: XMM) { emit_mr(instructions, .VMOVHPD, dst.mem, 8, Register(src)) } -inst_vmovlhps_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VMOVLHPS, Register(dst), Register(src), Register(src2)) } -emit_vmovlhps_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VMOVLHPS, Register(dst), Register(src), Register(src2)) } -inst_vmovhlps_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VMOVHLPS, Register(dst), Register(src), Register(src2)) } -emit_vmovhlps_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VMOVHLPS, Register(dst), Register(src), Register(src2)) } -inst_vmovmskps_r32_xmm :: #force_inline proc "contextless" (dst: GPR32, src: XMM) -> Instruction { return inst_r_r(.VMOVMSKPS, Register(dst), Register(src)) } -inst_vmovmskps_r32_ymm :: #force_inline proc "contextless" (dst: GPR32, src: YMM) -> Instruction { return inst_r_r(.VMOVMSKPS, Register(dst), Register(src)) } -emit_vmovmskps_r32_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: XMM) { emit_rr(instructions, .VMOVMSKPS, Register(dst), Register(src)) } -emit_vmovmskps_r32_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: YMM) { emit_rr(instructions, .VMOVMSKPS, Register(dst), Register(src)) } -inst_vmovmskpd_r32_xmm :: #force_inline proc "contextless" (dst: GPR32, src: XMM) -> Instruction { return inst_r_r(.VMOVMSKPD, Register(dst), Register(src)) } -inst_vmovmskpd_r32_ymm :: #force_inline proc "contextless" (dst: GPR32, src: YMM) -> Instruction { return inst_r_r(.VMOVMSKPD, Register(dst), Register(src)) } -emit_vmovmskpd_r32_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: XMM) { emit_rr(instructions, .VMOVMSKPD, Register(dst), Register(src)) } -emit_vmovmskpd_r32_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: YMM) { emit_rr(instructions, .VMOVMSKPD, Register(dst), Register(src)) } -inst_vmovntps_m128_xmm :: #force_inline proc "contextless" (dst: Mem128, src: XMM) -> Instruction { return inst_m_r(.VMOVNTPS, dst.mem, 16, Register(src)) } -inst_vmovntps_m256_ymm :: #force_inline proc "contextless" (dst: Mem256, src: YMM) -> Instruction { return inst_m_r(.VMOVNTPS, dst.mem, 32, Register(src)) } -emit_vmovntps_m128_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem128, src: XMM) { emit_mr(instructions, .VMOVNTPS, dst.mem, 16, Register(src)) } -emit_vmovntps_m256_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem256, src: YMM) { emit_mr(instructions, .VMOVNTPS, dst.mem, 32, Register(src)) } -inst_vmovntpd_m128_xmm :: #force_inline proc "contextless" (dst: Mem128, src: XMM) -> Instruction { return inst_m_r(.VMOVNTPD, dst.mem, 16, Register(src)) } -inst_vmovntpd_m256_ymm :: #force_inline proc "contextless" (dst: Mem256, src: YMM) -> Instruction { return inst_m_r(.VMOVNTPD, dst.mem, 32, Register(src)) } -emit_vmovntpd_m128_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem128, src: XMM) { emit_mr(instructions, .VMOVNTPD, dst.mem, 16, Register(src)) } -emit_vmovntpd_m256_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem256, src: YMM) { emit_mr(instructions, .VMOVNTPD, dst.mem, 32, Register(src)) } -inst_vmovntdq_m128_xmm :: #force_inline proc "contextless" (dst: Mem128, src: XMM) -> Instruction { return inst_m_r(.VMOVNTDQ, dst.mem, 16, Register(src)) } -inst_vmovntdq_m256_ymm :: #force_inline proc "contextless" (dst: Mem256, src: YMM) -> Instruction { return inst_m_r(.VMOVNTDQ, dst.mem, 32, Register(src)) } -emit_vmovntdq_m128_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem128, src: XMM) { emit_mr(instructions, .VMOVNTDQ, dst.mem, 16, Register(src)) } -emit_vmovntdq_m256_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem256, src: YMM) { emit_mr(instructions, .VMOVNTDQ, dst.mem, 32, Register(src)) } -inst_vmovntdqa_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.VMOVNTDQA, Register(dst), src.mem, 16) } -inst_vmovntdqa_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: Mem256) -> Instruction { return inst_r_m(.VMOVNTDQA, Register(dst), src.mem, 32) } -emit_vmovntdqa_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .VMOVNTDQA, Register(dst), src.mem, 16) } -emit_vmovntdqa_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem256) { emit_rm(instructions, .VMOVNTDQA, Register(dst), src.mem, 32) } -inst_vcvtps2pd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.VCVTPS2PD, Register(dst), Register(src)) } -inst_vcvtps2pd_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: Mem64) -> Instruction { return inst_r_m(.VCVTPS2PD, Register(dst), src.mem, 8) } -inst_vcvtps2pd_ymm_xmm :: #force_inline proc "contextless" (dst: YMM, src: XMM) -> Instruction { return inst_r_r(.VCVTPS2PD, Register(dst), Register(src)) } -inst_vcvtps2pd_ymm_m128 :: #force_inline proc "contextless" (dst: YMM, src: Mem128) -> Instruction { return inst_r_m(.VCVTPS2PD, Register(dst), src.mem, 16) } -emit_vcvtps2pd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .VCVTPS2PD, Register(dst), Register(src)) } -emit_vcvtps2pd_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem64) { emit_rm(instructions, .VCVTPS2PD, Register(dst), src.mem, 8) } -emit_vcvtps2pd_ymm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: XMM) { emit_rr(instructions, .VCVTPS2PD, Register(dst), Register(src)) } -emit_vcvtps2pd_ymm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem128) { emit_rm(instructions, .VCVTPS2PD, Register(dst), src.mem, 16) } -inst_vcvtpd2ps_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.VCVTPD2PS, Register(dst), Register(src)) } -inst_vcvtpd2ps_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.VCVTPD2PS, Register(dst), src.mem, 16) } -inst_vcvtpd2ps_xmm_ymm :: #force_inline proc "contextless" (dst: XMM, src: YMM) -> Instruction { return inst_r_r(.VCVTPD2PS, Register(dst), Register(src)) } -inst_vcvtpd2ps_xmm_m256 :: #force_inline proc "contextless" (dst: XMM, src: Mem256) -> Instruction { return inst_r_m(.VCVTPD2PS, Register(dst), src.mem, 32) } -emit_vcvtpd2ps_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .VCVTPD2PS, Register(dst), Register(src)) } -emit_vcvtpd2ps_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .VCVTPD2PS, Register(dst), src.mem, 16) } -emit_vcvtpd2ps_xmm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: YMM) { emit_rr(instructions, .VCVTPD2PS, Register(dst), Register(src)) } -emit_vcvtpd2ps_xmm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem256) { emit_rm(instructions, .VCVTPD2PS, Register(dst), src.mem, 32) } -inst_vcvtss2sd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VCVTSS2SD, Register(dst), Register(src), Register(src2)) } -inst_vcvtss2sd_xmm_xmm_m32 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem32) -> Instruction { return inst_r_r_m(.VCVTSS2SD, Register(dst), Register(src), src2.mem, 4) } -emit_vcvtss2sd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VCVTSS2SD, Register(dst), Register(src), Register(src2)) } -emit_vcvtss2sd_xmm_xmm_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem32) { emit_rrm(instructions, .VCVTSS2SD, Register(dst), Register(src), src2.mem, 4) } -inst_vcvtsd2ss_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VCVTSD2SS, Register(dst), Register(src), Register(src2)) } -inst_vcvtsd2ss_xmm_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem64) -> Instruction { return inst_r_r_m(.VCVTSD2SS, Register(dst), Register(src), src2.mem, 8) } -emit_vcvtsd2ss_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VCVTSD2SS, Register(dst), Register(src), Register(src2)) } -emit_vcvtsd2ss_xmm_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem64) { emit_rrm(instructions, .VCVTSD2SS, Register(dst), Register(src), src2.mem, 8) } -inst_vcvtps2dq_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.VCVTPS2DQ, Register(dst), Register(src)) } -inst_vcvtps2dq_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.VCVTPS2DQ, Register(dst), src.mem, 16) } -inst_vcvtps2dq_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM) -> Instruction { return inst_r_r(.VCVTPS2DQ, Register(dst), Register(src)) } -inst_vcvtps2dq_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: Mem256) -> Instruction { return inst_r_m(.VCVTPS2DQ, Register(dst), src.mem, 32) } -emit_vcvtps2dq_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .VCVTPS2DQ, Register(dst), Register(src)) } -emit_vcvtps2dq_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .VCVTPS2DQ, Register(dst), src.mem, 16) } -emit_vcvtps2dq_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM) { emit_rr(instructions, .VCVTPS2DQ, Register(dst), Register(src)) } -emit_vcvtps2dq_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem256) { emit_rm(instructions, .VCVTPS2DQ, Register(dst), src.mem, 32) } -inst_vcvtpd2dq_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.VCVTPD2DQ, Register(dst), Register(src)) } -inst_vcvtpd2dq_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.VCVTPD2DQ, Register(dst), src.mem, 16) } -inst_vcvtpd2dq_xmm_ymm :: #force_inline proc "contextless" (dst: XMM, src: YMM) -> Instruction { return inst_r_r(.VCVTPD2DQ, Register(dst), Register(src)) } -inst_vcvtpd2dq_xmm_m256 :: #force_inline proc "contextless" (dst: XMM, src: Mem256) -> Instruction { return inst_r_m(.VCVTPD2DQ, Register(dst), src.mem, 32) } -emit_vcvtpd2dq_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .VCVTPD2DQ, Register(dst), Register(src)) } -emit_vcvtpd2dq_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .VCVTPD2DQ, Register(dst), src.mem, 16) } -emit_vcvtpd2dq_xmm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: YMM) { emit_rr(instructions, .VCVTPD2DQ, Register(dst), Register(src)) } -emit_vcvtpd2dq_xmm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem256) { emit_rm(instructions, .VCVTPD2DQ, Register(dst), src.mem, 32) } -inst_vcvtdq2ps_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.VCVTDQ2PS, Register(dst), Register(src)) } -inst_vcvtdq2ps_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.VCVTDQ2PS, Register(dst), src.mem, 16) } -inst_vcvtdq2ps_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM) -> Instruction { return inst_r_r(.VCVTDQ2PS, Register(dst), Register(src)) } -inst_vcvtdq2ps_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: Mem256) -> Instruction { return inst_r_m(.VCVTDQ2PS, Register(dst), src.mem, 32) } -emit_vcvtdq2ps_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .VCVTDQ2PS, Register(dst), Register(src)) } -emit_vcvtdq2ps_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .VCVTDQ2PS, Register(dst), src.mem, 16) } -emit_vcvtdq2ps_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM) { emit_rr(instructions, .VCVTDQ2PS, Register(dst), Register(src)) } -emit_vcvtdq2ps_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem256) { emit_rm(instructions, .VCVTDQ2PS, Register(dst), src.mem, 32) } -inst_vcvtdq2pd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.VCVTDQ2PD, Register(dst), Register(src)) } -inst_vcvtdq2pd_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: Mem64) -> Instruction { return inst_r_m(.VCVTDQ2PD, Register(dst), src.mem, 8) } -inst_vcvtdq2pd_ymm_xmm :: #force_inline proc "contextless" (dst: YMM, src: XMM) -> Instruction { return inst_r_r(.VCVTDQ2PD, Register(dst), Register(src)) } -inst_vcvtdq2pd_ymm_m128 :: #force_inline proc "contextless" (dst: YMM, src: Mem128) -> Instruction { return inst_r_m(.VCVTDQ2PD, Register(dst), src.mem, 16) } -emit_vcvtdq2pd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .VCVTDQ2PD, Register(dst), Register(src)) } -emit_vcvtdq2pd_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem64) { emit_rm(instructions, .VCVTDQ2PD, Register(dst), src.mem, 8) } -emit_vcvtdq2pd_ymm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: XMM) { emit_rr(instructions, .VCVTDQ2PD, Register(dst), Register(src)) } -emit_vcvtdq2pd_ymm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem128) { emit_rm(instructions, .VCVTDQ2PD, Register(dst), src.mem, 16) } -inst_vcvtss2si_r32_xmm :: #force_inline proc "contextless" (dst: GPR32, src: XMM) -> Instruction { return inst_r_r(.VCVTSS2SI, Register(dst), Register(src)) } -inst_vcvtss2si_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32) -> Instruction { return inst_r_m(.VCVTSS2SI, Register(dst), src.mem, 4) } -inst_vcvtss2si_r64_xmm :: #force_inline proc "contextless" (dst: GPR64, src: XMM) -> Instruction { return inst_r_r(.VCVTSS2SI, Register(dst), Register(src)) } -inst_vcvtss2si_r64_m32 :: #force_inline proc "contextless" (dst: GPR64, src: Mem32) -> Instruction { return inst_r_m(.VCVTSS2SI, Register(dst), src.mem, 4) } -emit_vcvtss2si_r32_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: XMM) { emit_rr(instructions, .VCVTSS2SI, Register(dst), Register(src)) } -emit_vcvtss2si_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32) { emit_rm(instructions, .VCVTSS2SI, Register(dst), src.mem, 4) } -emit_vcvtss2si_r64_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: XMM) { emit_rr(instructions, .VCVTSS2SI, Register(dst), Register(src)) } -emit_vcvtss2si_r64_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem32) { emit_rm(instructions, .VCVTSS2SI, Register(dst), src.mem, 4) } -inst_vcvtsd2si_r32_xmm :: #force_inline proc "contextless" (dst: GPR32, src: XMM) -> Instruction { return inst_r_r(.VCVTSD2SI, Register(dst), Register(src)) } -inst_vcvtsd2si_r32_m64 :: #force_inline proc "contextless" (dst: GPR32, src: Mem64) -> Instruction { return inst_r_m(.VCVTSD2SI, Register(dst), src.mem, 8) } -inst_vcvtsd2si_r64_xmm :: #force_inline proc "contextless" (dst: GPR64, src: XMM) -> Instruction { return inst_r_r(.VCVTSD2SI, Register(dst), Register(src)) } -inst_vcvtsd2si_r64_m64 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64) -> Instruction { return inst_r_m(.VCVTSD2SI, Register(dst), src.mem, 8) } -emit_vcvtsd2si_r32_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: XMM) { emit_rr(instructions, .VCVTSD2SI, Register(dst), Register(src)) } -emit_vcvtsd2si_r32_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem64) { emit_rm(instructions, .VCVTSD2SI, Register(dst), src.mem, 8) } -emit_vcvtsd2si_r64_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: XMM) { emit_rr(instructions, .VCVTSD2SI, Register(dst), Register(src)) } -emit_vcvtsd2si_r64_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem64) { emit_rm(instructions, .VCVTSD2SI, Register(dst), src.mem, 8) } -inst_vcvtsi2ss_xmm_xmm_r32 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: GPR32) -> Instruction { return inst_r_r_r(.VCVTSI2SS, Register(dst), Register(src), Register(src2)) } -inst_vcvtsi2ss_xmm_xmm_m32 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem32) -> Instruction { return inst_r_r_m(.VCVTSI2SS, Register(dst), Register(src), src2.mem, 4) } -inst_vcvtsi2ss_xmm_xmm_r64 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: GPR64) -> Instruction { return inst_r_r_r(.VCVTSI2SS, Register(dst), Register(src), Register(src2)) } -inst_vcvtsi2ss_xmm_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem64) -> Instruction { return inst_r_r_m(.VCVTSI2SS, Register(dst), Register(src), src2.mem, 8) } -emit_vcvtsi2ss_xmm_xmm_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: GPR32) { emit_rrr(instructions, .VCVTSI2SS, Register(dst), Register(src), Register(src2)) } -emit_vcvtsi2ss_xmm_xmm_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem32) { emit_rrm(instructions, .VCVTSI2SS, Register(dst), Register(src), src2.mem, 4) } -emit_vcvtsi2ss_xmm_xmm_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: GPR64) { emit_rrr(instructions, .VCVTSI2SS, Register(dst), Register(src), Register(src2)) } -emit_vcvtsi2ss_xmm_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem64) { emit_rrm(instructions, .VCVTSI2SS, Register(dst), Register(src), src2.mem, 8) } -inst_vcvtsi2sd_xmm_xmm_r32 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: GPR32) -> Instruction { return inst_r_r_r(.VCVTSI2SD, Register(dst), Register(src), Register(src2)) } -inst_vcvtsi2sd_xmm_xmm_m32 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem32) -> Instruction { return inst_r_r_m(.VCVTSI2SD, Register(dst), Register(src), src2.mem, 4) } -inst_vcvtsi2sd_xmm_xmm_r64 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: GPR64) -> Instruction { return inst_r_r_r(.VCVTSI2SD, Register(dst), Register(src), Register(src2)) } -inst_vcvtsi2sd_xmm_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem64) -> Instruction { return inst_r_r_m(.VCVTSI2SD, Register(dst), Register(src), src2.mem, 8) } -emit_vcvtsi2sd_xmm_xmm_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: GPR32) { emit_rrr(instructions, .VCVTSI2SD, Register(dst), Register(src), Register(src2)) } -emit_vcvtsi2sd_xmm_xmm_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem32) { emit_rrm(instructions, .VCVTSI2SD, Register(dst), Register(src), src2.mem, 4) } -emit_vcvtsi2sd_xmm_xmm_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: GPR64) { emit_rrr(instructions, .VCVTSI2SD, Register(dst), Register(src), Register(src2)) } -emit_vcvtsi2sd_xmm_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem64) { emit_rrm(instructions, .VCVTSI2SD, Register(dst), Register(src), src2.mem, 8) } -inst_vcvttps2dq_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.VCVTTPS2DQ, Register(dst), Register(src)) } -inst_vcvttps2dq_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.VCVTTPS2DQ, Register(dst), src.mem, 16) } -inst_vcvttps2dq_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM) -> Instruction { return inst_r_r(.VCVTTPS2DQ, Register(dst), Register(src)) } -inst_vcvttps2dq_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: Mem256) -> Instruction { return inst_r_m(.VCVTTPS2DQ, Register(dst), src.mem, 32) } -emit_vcvttps2dq_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .VCVTTPS2DQ, Register(dst), Register(src)) } -emit_vcvttps2dq_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .VCVTTPS2DQ, Register(dst), src.mem, 16) } -emit_vcvttps2dq_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM) { emit_rr(instructions, .VCVTTPS2DQ, Register(dst), Register(src)) } -emit_vcvttps2dq_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem256) { emit_rm(instructions, .VCVTTPS2DQ, Register(dst), src.mem, 32) } -inst_vcvttpd2dq_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.VCVTTPD2DQ, Register(dst), Register(src)) } -inst_vcvttpd2dq_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.VCVTTPD2DQ, Register(dst), src.mem, 16) } -inst_vcvttpd2dq_xmm_ymm :: #force_inline proc "contextless" (dst: XMM, src: YMM) -> Instruction { return inst_r_r(.VCVTTPD2DQ, Register(dst), Register(src)) } -inst_vcvttpd2dq_xmm_m256 :: #force_inline proc "contextless" (dst: XMM, src: Mem256) -> Instruction { return inst_r_m(.VCVTTPD2DQ, Register(dst), src.mem, 32) } -emit_vcvttpd2dq_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .VCVTTPD2DQ, Register(dst), Register(src)) } -emit_vcvttpd2dq_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .VCVTTPD2DQ, Register(dst), src.mem, 16) } -emit_vcvttpd2dq_xmm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: YMM) { emit_rr(instructions, .VCVTTPD2DQ, Register(dst), Register(src)) } -emit_vcvttpd2dq_xmm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem256) { emit_rm(instructions, .VCVTTPD2DQ, Register(dst), src.mem, 32) } -inst_vcvttss2si_r32_xmm :: #force_inline proc "contextless" (dst: GPR32, src: XMM) -> Instruction { return inst_r_r(.VCVTTSS2SI, Register(dst), Register(src)) } -inst_vcvttss2si_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32) -> Instruction { return inst_r_m(.VCVTTSS2SI, Register(dst), src.mem, 4) } -inst_vcvttss2si_r64_xmm :: #force_inline proc "contextless" (dst: GPR64, src: XMM) -> Instruction { return inst_r_r(.VCVTTSS2SI, Register(dst), Register(src)) } -inst_vcvttss2si_r64_m32 :: #force_inline proc "contextless" (dst: GPR64, src: Mem32) -> Instruction { return inst_r_m(.VCVTTSS2SI, Register(dst), src.mem, 4) } -emit_vcvttss2si_r32_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: XMM) { emit_rr(instructions, .VCVTTSS2SI, Register(dst), Register(src)) } -emit_vcvttss2si_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32) { emit_rm(instructions, .VCVTTSS2SI, Register(dst), src.mem, 4) } -emit_vcvttss2si_r64_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: XMM) { emit_rr(instructions, .VCVTTSS2SI, Register(dst), Register(src)) } -emit_vcvttss2si_r64_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem32) { emit_rm(instructions, .VCVTTSS2SI, Register(dst), src.mem, 4) } -inst_vcvttsd2si_r32_xmm :: #force_inline proc "contextless" (dst: GPR32, src: XMM) -> Instruction { return inst_r_r(.VCVTTSD2SI, Register(dst), Register(src)) } -inst_vcvttsd2si_r32_m64 :: #force_inline proc "contextless" (dst: GPR32, src: Mem64) -> Instruction { return inst_r_m(.VCVTTSD2SI, Register(dst), src.mem, 8) } -inst_vcvttsd2si_r64_xmm :: #force_inline proc "contextless" (dst: GPR64, src: XMM) -> Instruction { return inst_r_r(.VCVTTSD2SI, Register(dst), Register(src)) } -inst_vcvttsd2si_r64_m64 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64) -> Instruction { return inst_r_m(.VCVTTSD2SI, Register(dst), src.mem, 8) } -emit_vcvttsd2si_r32_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: XMM) { emit_rr(instructions, .VCVTTSD2SI, Register(dst), Register(src)) } -emit_vcvttsd2si_r32_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem64) { emit_rm(instructions, .VCVTTSD2SI, Register(dst), src.mem, 8) } -emit_vcvttsd2si_r64_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: XMM) { emit_rr(instructions, .VCVTTSD2SI, Register(dst), Register(src)) } -emit_vcvttsd2si_r64_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem64) { emit_rm(instructions, .VCVTTSD2SI, Register(dst), src.mem, 8) } -inst_vpaddb_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VPADDB, Register(dst), Register(src), Register(src2)) } -inst_vpaddb_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VPADDB, Register(dst), Register(src), src2.mem, 16) } -inst_vpaddb_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VPADDB, Register(dst), Register(src), Register(src2)) } -inst_vpaddb_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VPADDB, Register(dst), Register(src), src2.mem, 32) } -emit_vpaddb_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VPADDB, Register(dst), Register(src), Register(src2)) } -emit_vpaddb_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VPADDB, Register(dst), Register(src), src2.mem, 16) } -emit_vpaddb_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VPADDB, Register(dst), Register(src), Register(src2)) } -emit_vpaddb_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VPADDB, Register(dst), Register(src), src2.mem, 32) } -inst_vpaddw_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VPADDW, Register(dst), Register(src), Register(src2)) } -inst_vpaddw_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VPADDW, Register(dst), Register(src), src2.mem, 16) } -inst_vpaddw_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VPADDW, Register(dst), Register(src), Register(src2)) } -inst_vpaddw_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VPADDW, Register(dst), Register(src), src2.mem, 32) } -emit_vpaddw_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VPADDW, Register(dst), Register(src), Register(src2)) } -emit_vpaddw_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VPADDW, Register(dst), Register(src), src2.mem, 16) } -emit_vpaddw_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VPADDW, Register(dst), Register(src), Register(src2)) } -emit_vpaddw_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VPADDW, Register(dst), Register(src), src2.mem, 32) } -inst_vpaddd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VPADDD, Register(dst), Register(src), Register(src2)) } -inst_vpaddd_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VPADDD, Register(dst), Register(src), src2.mem, 16) } -inst_vpaddd_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VPADDD, Register(dst), Register(src), Register(src2)) } -inst_vpaddd_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VPADDD, Register(dst), Register(src), src2.mem, 32) } -emit_vpaddd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VPADDD, Register(dst), Register(src), Register(src2)) } -emit_vpaddd_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VPADDD, Register(dst), Register(src), src2.mem, 16) } -emit_vpaddd_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VPADDD, Register(dst), Register(src), Register(src2)) } -emit_vpaddd_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VPADDD, Register(dst), Register(src), src2.mem, 32) } -inst_vpaddq_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VPADDQ, Register(dst), Register(src), Register(src2)) } -inst_vpaddq_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VPADDQ, Register(dst), Register(src), src2.mem, 16) } -inst_vpaddq_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VPADDQ, Register(dst), Register(src), Register(src2)) } -inst_vpaddq_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VPADDQ, Register(dst), Register(src), src2.mem, 32) } -emit_vpaddq_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VPADDQ, Register(dst), Register(src), Register(src2)) } -emit_vpaddq_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VPADDQ, Register(dst), Register(src), src2.mem, 16) } -emit_vpaddq_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VPADDQ, Register(dst), Register(src), Register(src2)) } -emit_vpaddq_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VPADDQ, Register(dst), Register(src), src2.mem, 32) } -inst_vpsubb_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VPSUBB, Register(dst), Register(src), Register(src2)) } -inst_vpsubb_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VPSUBB, Register(dst), Register(src), src2.mem, 16) } -inst_vpsubb_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VPSUBB, Register(dst), Register(src), Register(src2)) } -inst_vpsubb_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VPSUBB, Register(dst), Register(src), src2.mem, 32) } -emit_vpsubb_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VPSUBB, Register(dst), Register(src), Register(src2)) } -emit_vpsubb_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VPSUBB, Register(dst), Register(src), src2.mem, 16) } -emit_vpsubb_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VPSUBB, Register(dst), Register(src), Register(src2)) } -emit_vpsubb_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VPSUBB, Register(dst), Register(src), src2.mem, 32) } -inst_vpsubw_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VPSUBW, Register(dst), Register(src), Register(src2)) } -inst_vpsubw_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VPSUBW, Register(dst), Register(src), src2.mem, 16) } -inst_vpsubw_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VPSUBW, Register(dst), Register(src), Register(src2)) } -inst_vpsubw_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VPSUBW, Register(dst), Register(src), src2.mem, 32) } -emit_vpsubw_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VPSUBW, Register(dst), Register(src), Register(src2)) } -emit_vpsubw_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VPSUBW, Register(dst), Register(src), src2.mem, 16) } -emit_vpsubw_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VPSUBW, Register(dst), Register(src), Register(src2)) } -emit_vpsubw_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VPSUBW, Register(dst), Register(src), src2.mem, 32) } -inst_vpsubd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VPSUBD, Register(dst), Register(src), Register(src2)) } -inst_vpsubd_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VPSUBD, Register(dst), Register(src), src2.mem, 16) } -inst_vpsubd_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VPSUBD, Register(dst), Register(src), Register(src2)) } -inst_vpsubd_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VPSUBD, Register(dst), Register(src), src2.mem, 32) } -emit_vpsubd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VPSUBD, Register(dst), Register(src), Register(src2)) } -emit_vpsubd_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VPSUBD, Register(dst), Register(src), src2.mem, 16) } -emit_vpsubd_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VPSUBD, Register(dst), Register(src), Register(src2)) } -emit_vpsubd_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VPSUBD, Register(dst), Register(src), src2.mem, 32) } -inst_vpsubq_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VPSUBQ, Register(dst), Register(src), Register(src2)) } -inst_vpsubq_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VPSUBQ, Register(dst), Register(src), src2.mem, 16) } -inst_vpsubq_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VPSUBQ, Register(dst), Register(src), Register(src2)) } -inst_vpsubq_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VPSUBQ, Register(dst), Register(src), src2.mem, 32) } -emit_vpsubq_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VPSUBQ, Register(dst), Register(src), Register(src2)) } -emit_vpsubq_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VPSUBQ, Register(dst), Register(src), src2.mem, 16) } -emit_vpsubq_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VPSUBQ, Register(dst), Register(src), Register(src2)) } -emit_vpsubq_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VPSUBQ, Register(dst), Register(src), src2.mem, 32) } -inst_vpmullw_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VPMULLW, Register(dst), Register(src), Register(src2)) } -inst_vpmullw_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VPMULLW, Register(dst), Register(src), src2.mem, 16) } -inst_vpmullw_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VPMULLW, Register(dst), Register(src), Register(src2)) } -inst_vpmullw_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VPMULLW, Register(dst), Register(src), src2.mem, 32) } -emit_vpmullw_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VPMULLW, Register(dst), Register(src), Register(src2)) } -emit_vpmullw_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VPMULLW, Register(dst), Register(src), src2.mem, 16) } -emit_vpmullw_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VPMULLW, Register(dst), Register(src), Register(src2)) } -emit_vpmullw_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VPMULLW, Register(dst), Register(src), src2.mem, 32) } -inst_vpmulhw_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VPMULHW, Register(dst), Register(src), Register(src2)) } -inst_vpmulhw_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VPMULHW, Register(dst), Register(src), src2.mem, 16) } -inst_vpmulhw_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VPMULHW, Register(dst), Register(src), Register(src2)) } -inst_vpmulhw_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VPMULHW, Register(dst), Register(src), src2.mem, 32) } -emit_vpmulhw_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VPMULHW, Register(dst), Register(src), Register(src2)) } -emit_vpmulhw_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VPMULHW, Register(dst), Register(src), src2.mem, 16) } -emit_vpmulhw_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VPMULHW, Register(dst), Register(src), Register(src2)) } -emit_vpmulhw_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VPMULHW, Register(dst), Register(src), src2.mem, 32) } -inst_vpmulhuw_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VPMULHUW, Register(dst), Register(src), Register(src2)) } -inst_vpmulhuw_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VPMULHUW, Register(dst), Register(src), src2.mem, 16) } -inst_vpmulhuw_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VPMULHUW, Register(dst), Register(src), Register(src2)) } -inst_vpmulhuw_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VPMULHUW, Register(dst), Register(src), src2.mem, 32) } -emit_vpmulhuw_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VPMULHUW, Register(dst), Register(src), Register(src2)) } -emit_vpmulhuw_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VPMULHUW, Register(dst), Register(src), src2.mem, 16) } -emit_vpmulhuw_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VPMULHUW, Register(dst), Register(src), Register(src2)) } -emit_vpmulhuw_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VPMULHUW, Register(dst), Register(src), src2.mem, 32) } -inst_vpmuludq_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VPMULUDQ, Register(dst), Register(src), Register(src2)) } -inst_vpmuludq_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VPMULUDQ, Register(dst), Register(src), src2.mem, 16) } -inst_vpmuludq_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VPMULUDQ, Register(dst), Register(src), Register(src2)) } -inst_vpmuludq_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VPMULUDQ, Register(dst), Register(src), src2.mem, 32) } -emit_vpmuludq_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VPMULUDQ, Register(dst), Register(src), Register(src2)) } -emit_vpmuludq_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VPMULUDQ, Register(dst), Register(src), src2.mem, 16) } -emit_vpmuludq_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VPMULUDQ, Register(dst), Register(src), Register(src2)) } -emit_vpmuludq_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VPMULUDQ, Register(dst), Register(src), src2.mem, 32) } -inst_vpmaddwd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VPMADDWD, Register(dst), Register(src), Register(src2)) } -inst_vpmaddwd_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VPMADDWD, Register(dst), Register(src), src2.mem, 16) } -inst_vpmaddwd_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VPMADDWD, Register(dst), Register(src), Register(src2)) } -inst_vpmaddwd_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VPMADDWD, Register(dst), Register(src), src2.mem, 32) } -emit_vpmaddwd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VPMADDWD, Register(dst), Register(src), Register(src2)) } -emit_vpmaddwd_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VPMADDWD, Register(dst), Register(src), src2.mem, 16) } -emit_vpmaddwd_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VPMADDWD, Register(dst), Register(src), Register(src2)) } -emit_vpmaddwd_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VPMADDWD, Register(dst), Register(src), src2.mem, 32) } -inst_vpand_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VPAND, Register(dst), Register(src), Register(src2)) } -inst_vpand_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VPAND, Register(dst), Register(src), src2.mem, 16) } -inst_vpand_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VPAND, Register(dst), Register(src), Register(src2)) } -inst_vpand_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VPAND, Register(dst), Register(src), src2.mem, 32) } -emit_vpand_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VPAND, Register(dst), Register(src), Register(src2)) } -emit_vpand_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VPAND, Register(dst), Register(src), src2.mem, 16) } -emit_vpand_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VPAND, Register(dst), Register(src), Register(src2)) } -emit_vpand_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VPAND, Register(dst), Register(src), src2.mem, 32) } -inst_vpandn_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VPANDN, Register(dst), Register(src), Register(src2)) } -inst_vpandn_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VPANDN, Register(dst), Register(src), src2.mem, 16) } -inst_vpandn_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VPANDN, Register(dst), Register(src), Register(src2)) } -inst_vpandn_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VPANDN, Register(dst), Register(src), src2.mem, 32) } -emit_vpandn_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VPANDN, Register(dst), Register(src), Register(src2)) } -emit_vpandn_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VPANDN, Register(dst), Register(src), src2.mem, 16) } -emit_vpandn_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VPANDN, Register(dst), Register(src), Register(src2)) } -emit_vpandn_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VPANDN, Register(dst), Register(src), src2.mem, 32) } -inst_vpor_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VPOR, Register(dst), Register(src), Register(src2)) } -inst_vpor_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VPOR, Register(dst), Register(src), src2.mem, 16) } -inst_vpor_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VPOR, Register(dst), Register(src), Register(src2)) } -inst_vpor_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VPOR, Register(dst), Register(src), src2.mem, 32) } -emit_vpor_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VPOR, Register(dst), Register(src), Register(src2)) } -emit_vpor_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VPOR, Register(dst), Register(src), src2.mem, 16) } -emit_vpor_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VPOR, Register(dst), Register(src), Register(src2)) } -emit_vpor_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VPOR, Register(dst), Register(src), src2.mem, 32) } -inst_vpxor_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VPXOR, Register(dst), Register(src), Register(src2)) } -inst_vpxor_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VPXOR, Register(dst), Register(src), src2.mem, 16) } -inst_vpxor_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VPXOR, Register(dst), Register(src), Register(src2)) } -inst_vpxor_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VPXOR, Register(dst), Register(src), src2.mem, 32) } -emit_vpxor_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VPXOR, Register(dst), Register(src), Register(src2)) } -emit_vpxor_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VPXOR, Register(dst), Register(src), src2.mem, 16) } -emit_vpxor_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VPXOR, Register(dst), Register(src), Register(src2)) } -emit_vpxor_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VPXOR, Register(dst), Register(src), src2.mem, 32) } -inst_vpsllw_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VPSLLW, Register(dst), Register(src), Register(src2)) } -inst_vpsllw_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VPSLLW, Register(dst), Register(src), src2.mem, 16) } -inst_vpsllw_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return inst_r_r_i(.VPSLLW, Register(dst), Register(src), i64(imm), 1) } -inst_vpsllw_ymm_ymm_xmm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: XMM) -> Instruction { return inst_r_r_r(.VPSLLW, Register(dst), Register(src), Register(src2)) } -inst_vpsllw_ymm_ymm_m128 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VPSLLW, Register(dst), Register(src), src2.mem, 16) } -inst_vpsllw_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, imm: i8) -> Instruction { return inst_r_r_i(.VPSLLW, Register(dst), Register(src), i64(imm), 1) } -emit_vpsllw_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VPSLLW, Register(dst), Register(src), Register(src2)) } -emit_vpsllw_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VPSLLW, Register(dst), Register(src), src2.mem, 16) } -emit_vpsllw_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, imm: i8) { emit_rri(instructions, .VPSLLW, Register(dst), Register(src), i64(imm), 1) } -emit_vpsllw_ymm_ymm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: XMM) { emit_rrr(instructions, .VPSLLW, Register(dst), Register(src), Register(src2)) } -emit_vpsllw_ymm_ymm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem128) { emit_rrm(instructions, .VPSLLW, Register(dst), Register(src), src2.mem, 16) } -emit_vpsllw_ymm_ymm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, imm: i8) { emit_rri(instructions, .VPSLLW, Register(dst), Register(src), i64(imm), 1) } -inst_vpslld_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VPSLLD, Register(dst), Register(src), Register(src2)) } -inst_vpslld_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VPSLLD, Register(dst), Register(src), src2.mem, 16) } -inst_vpslld_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return inst_r_r_i(.VPSLLD, Register(dst), Register(src), i64(imm), 1) } -inst_vpslld_ymm_ymm_xmm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: XMM) -> Instruction { return inst_r_r_r(.VPSLLD, Register(dst), Register(src), Register(src2)) } -inst_vpslld_ymm_ymm_m128 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VPSLLD, Register(dst), Register(src), src2.mem, 16) } -inst_vpslld_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, imm: i8) -> Instruction { return inst_r_r_i(.VPSLLD, Register(dst), Register(src), i64(imm), 1) } -emit_vpslld_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VPSLLD, Register(dst), Register(src), Register(src2)) } -emit_vpslld_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VPSLLD, Register(dst), Register(src), src2.mem, 16) } -emit_vpslld_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, imm: i8) { emit_rri(instructions, .VPSLLD, Register(dst), Register(src), i64(imm), 1) } -emit_vpslld_ymm_ymm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: XMM) { emit_rrr(instructions, .VPSLLD, Register(dst), Register(src), Register(src2)) } -emit_vpslld_ymm_ymm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem128) { emit_rrm(instructions, .VPSLLD, Register(dst), Register(src), src2.mem, 16) } -emit_vpslld_ymm_ymm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, imm: i8) { emit_rri(instructions, .VPSLLD, Register(dst), Register(src), i64(imm), 1) } -inst_vpsllq_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VPSLLQ, Register(dst), Register(src), Register(src2)) } -inst_vpsllq_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VPSLLQ, Register(dst), Register(src), src2.mem, 16) } -inst_vpsllq_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return inst_r_r_i(.VPSLLQ, Register(dst), Register(src), i64(imm), 1) } -inst_vpsllq_ymm_ymm_xmm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: XMM) -> Instruction { return inst_r_r_r(.VPSLLQ, Register(dst), Register(src), Register(src2)) } -inst_vpsllq_ymm_ymm_m128 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VPSLLQ, Register(dst), Register(src), src2.mem, 16) } -inst_vpsllq_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, imm: i8) -> Instruction { return inst_r_r_i(.VPSLLQ, Register(dst), Register(src), i64(imm), 1) } -emit_vpsllq_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VPSLLQ, Register(dst), Register(src), Register(src2)) } -emit_vpsllq_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VPSLLQ, Register(dst), Register(src), src2.mem, 16) } -emit_vpsllq_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, imm: i8) { emit_rri(instructions, .VPSLLQ, Register(dst), Register(src), i64(imm), 1) } -emit_vpsllq_ymm_ymm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: XMM) { emit_rrr(instructions, .VPSLLQ, Register(dst), Register(src), Register(src2)) } -emit_vpsllq_ymm_ymm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem128) { emit_rrm(instructions, .VPSLLQ, Register(dst), Register(src), src2.mem, 16) } -emit_vpsllq_ymm_ymm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, imm: i8) { emit_rri(instructions, .VPSLLQ, Register(dst), Register(src), i64(imm), 1) } -inst_vpsrlw_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VPSRLW, Register(dst), Register(src), Register(src2)) } -inst_vpsrlw_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VPSRLW, Register(dst), Register(src), src2.mem, 16) } -inst_vpsrlw_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return inst_r_r_i(.VPSRLW, Register(dst), Register(src), i64(imm), 1) } -inst_vpsrlw_ymm_ymm_xmm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: XMM) -> Instruction { return inst_r_r_r(.VPSRLW, Register(dst), Register(src), Register(src2)) } -inst_vpsrlw_ymm_ymm_m128 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VPSRLW, Register(dst), Register(src), src2.mem, 16) } -inst_vpsrlw_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, imm: i8) -> Instruction { return inst_r_r_i(.VPSRLW, Register(dst), Register(src), i64(imm), 1) } -emit_vpsrlw_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VPSRLW, Register(dst), Register(src), Register(src2)) } -emit_vpsrlw_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VPSRLW, Register(dst), Register(src), src2.mem, 16) } -emit_vpsrlw_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, imm: i8) { emit_rri(instructions, .VPSRLW, Register(dst), Register(src), i64(imm), 1) } -emit_vpsrlw_ymm_ymm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: XMM) { emit_rrr(instructions, .VPSRLW, Register(dst), Register(src), Register(src2)) } -emit_vpsrlw_ymm_ymm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem128) { emit_rrm(instructions, .VPSRLW, Register(dst), Register(src), src2.mem, 16) } -emit_vpsrlw_ymm_ymm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, imm: i8) { emit_rri(instructions, .VPSRLW, Register(dst), Register(src), i64(imm), 1) } -inst_vpsrld_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VPSRLD, Register(dst), Register(src), Register(src2)) } -inst_vpsrld_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VPSRLD, Register(dst), Register(src), src2.mem, 16) } -inst_vpsrld_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return inst_r_r_i(.VPSRLD, Register(dst), Register(src), i64(imm), 1) } -inst_vpsrld_ymm_ymm_xmm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: XMM) -> Instruction { return inst_r_r_r(.VPSRLD, Register(dst), Register(src), Register(src2)) } -inst_vpsrld_ymm_ymm_m128 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VPSRLD, Register(dst), Register(src), src2.mem, 16) } -inst_vpsrld_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, imm: i8) -> Instruction { return inst_r_r_i(.VPSRLD, Register(dst), Register(src), i64(imm), 1) } -emit_vpsrld_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VPSRLD, Register(dst), Register(src), Register(src2)) } -emit_vpsrld_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VPSRLD, Register(dst), Register(src), src2.mem, 16) } -emit_vpsrld_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, imm: i8) { emit_rri(instructions, .VPSRLD, Register(dst), Register(src), i64(imm), 1) } -emit_vpsrld_ymm_ymm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: XMM) { emit_rrr(instructions, .VPSRLD, Register(dst), Register(src), Register(src2)) } -emit_vpsrld_ymm_ymm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem128) { emit_rrm(instructions, .VPSRLD, Register(dst), Register(src), src2.mem, 16) } -emit_vpsrld_ymm_ymm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, imm: i8) { emit_rri(instructions, .VPSRLD, Register(dst), Register(src), i64(imm), 1) } -inst_vpsrlq_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VPSRLQ, Register(dst), Register(src), Register(src2)) } -inst_vpsrlq_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VPSRLQ, Register(dst), Register(src), src2.mem, 16) } -inst_vpsrlq_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return inst_r_r_i(.VPSRLQ, Register(dst), Register(src), i64(imm), 1) } -inst_vpsrlq_ymm_ymm_xmm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: XMM) -> Instruction { return inst_r_r_r(.VPSRLQ, Register(dst), Register(src), Register(src2)) } -inst_vpsrlq_ymm_ymm_m128 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VPSRLQ, Register(dst), Register(src), src2.mem, 16) } -inst_vpsrlq_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, imm: i8) -> Instruction { return inst_r_r_i(.VPSRLQ, Register(dst), Register(src), i64(imm), 1) } -emit_vpsrlq_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VPSRLQ, Register(dst), Register(src), Register(src2)) } -emit_vpsrlq_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VPSRLQ, Register(dst), Register(src), src2.mem, 16) } -emit_vpsrlq_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, imm: i8) { emit_rri(instructions, .VPSRLQ, Register(dst), Register(src), i64(imm), 1) } -emit_vpsrlq_ymm_ymm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: XMM) { emit_rrr(instructions, .VPSRLQ, Register(dst), Register(src), Register(src2)) } -emit_vpsrlq_ymm_ymm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem128) { emit_rrm(instructions, .VPSRLQ, Register(dst), Register(src), src2.mem, 16) } -emit_vpsrlq_ymm_ymm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, imm: i8) { emit_rri(instructions, .VPSRLQ, Register(dst), Register(src), i64(imm), 1) } -inst_vpsraw_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VPSRAW, Register(dst), Register(src), Register(src2)) } -inst_vpsraw_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VPSRAW, Register(dst), Register(src), src2.mem, 16) } -inst_vpsraw_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return inst_r_r_i(.VPSRAW, Register(dst), Register(src), i64(imm), 1) } -inst_vpsraw_ymm_ymm_xmm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: XMM) -> Instruction { return inst_r_r_r(.VPSRAW, Register(dst), Register(src), Register(src2)) } -inst_vpsraw_ymm_ymm_m128 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VPSRAW, Register(dst), Register(src), src2.mem, 16) } -inst_vpsraw_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, imm: i8) -> Instruction { return inst_r_r_i(.VPSRAW, Register(dst), Register(src), i64(imm), 1) } -emit_vpsraw_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VPSRAW, Register(dst), Register(src), Register(src2)) } -emit_vpsraw_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VPSRAW, Register(dst), Register(src), src2.mem, 16) } -emit_vpsraw_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, imm: i8) { emit_rri(instructions, .VPSRAW, Register(dst), Register(src), i64(imm), 1) } -emit_vpsraw_ymm_ymm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: XMM) { emit_rrr(instructions, .VPSRAW, Register(dst), Register(src), Register(src2)) } -emit_vpsraw_ymm_ymm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem128) { emit_rrm(instructions, .VPSRAW, Register(dst), Register(src), src2.mem, 16) } -emit_vpsraw_ymm_ymm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, imm: i8) { emit_rri(instructions, .VPSRAW, Register(dst), Register(src), i64(imm), 1) } -inst_vpsrad_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VPSRAD, Register(dst), Register(src), Register(src2)) } -inst_vpsrad_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VPSRAD, Register(dst), Register(src), src2.mem, 16) } -inst_vpsrad_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return inst_r_r_i(.VPSRAD, Register(dst), Register(src), i64(imm), 1) } -inst_vpsrad_ymm_ymm_xmm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: XMM) -> Instruction { return inst_r_r_r(.VPSRAD, Register(dst), Register(src), Register(src2)) } -inst_vpsrad_ymm_ymm_m128 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VPSRAD, Register(dst), Register(src), src2.mem, 16) } -inst_vpsrad_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, imm: i8) -> Instruction { return inst_r_r_i(.VPSRAD, Register(dst), Register(src), i64(imm), 1) } -emit_vpsrad_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VPSRAD, Register(dst), Register(src), Register(src2)) } -emit_vpsrad_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VPSRAD, Register(dst), Register(src), src2.mem, 16) } -emit_vpsrad_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, imm: i8) { emit_rri(instructions, .VPSRAD, Register(dst), Register(src), i64(imm), 1) } -emit_vpsrad_ymm_ymm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: XMM) { emit_rrr(instructions, .VPSRAD, Register(dst), Register(src), Register(src2)) } -emit_vpsrad_ymm_ymm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem128) { emit_rrm(instructions, .VPSRAD, Register(dst), Register(src), src2.mem, 16) } -emit_vpsrad_ymm_ymm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, imm: i8) { emit_rri(instructions, .VPSRAD, Register(dst), Register(src), i64(imm), 1) } -inst_vpcmpeqb_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VPCMPEQB, Register(dst), Register(src), Register(src2)) } -inst_vpcmpeqb_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VPCMPEQB, Register(dst), Register(src), src2.mem, 16) } -inst_vpcmpeqb_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VPCMPEQB, Register(dst), Register(src), Register(src2)) } -inst_vpcmpeqb_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VPCMPEQB, Register(dst), Register(src), src2.mem, 32) } -emit_vpcmpeqb_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VPCMPEQB, Register(dst), Register(src), Register(src2)) } -emit_vpcmpeqb_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VPCMPEQB, Register(dst), Register(src), src2.mem, 16) } -emit_vpcmpeqb_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VPCMPEQB, Register(dst), Register(src), Register(src2)) } -emit_vpcmpeqb_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VPCMPEQB, Register(dst), Register(src), src2.mem, 32) } -inst_vpcmpeqw_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VPCMPEQW, Register(dst), Register(src), Register(src2)) } -inst_vpcmpeqw_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VPCMPEQW, Register(dst), Register(src), src2.mem, 16) } -inst_vpcmpeqw_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VPCMPEQW, Register(dst), Register(src), Register(src2)) } -inst_vpcmpeqw_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VPCMPEQW, Register(dst), Register(src), src2.mem, 32) } -emit_vpcmpeqw_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VPCMPEQW, Register(dst), Register(src), Register(src2)) } -emit_vpcmpeqw_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VPCMPEQW, Register(dst), Register(src), src2.mem, 16) } -emit_vpcmpeqw_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VPCMPEQW, Register(dst), Register(src), Register(src2)) } -emit_vpcmpeqw_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VPCMPEQW, Register(dst), Register(src), src2.mem, 32) } -inst_vpcmpeqd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VPCMPEQD, Register(dst), Register(src), Register(src2)) } -inst_vpcmpeqd_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VPCMPEQD, Register(dst), Register(src), src2.mem, 16) } -inst_vpcmpeqd_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VPCMPEQD, Register(dst), Register(src), Register(src2)) } -inst_vpcmpeqd_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VPCMPEQD, Register(dst), Register(src), src2.mem, 32) } -emit_vpcmpeqd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VPCMPEQD, Register(dst), Register(src), Register(src2)) } -emit_vpcmpeqd_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VPCMPEQD, Register(dst), Register(src), src2.mem, 16) } -emit_vpcmpeqd_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VPCMPEQD, Register(dst), Register(src), Register(src2)) } -emit_vpcmpeqd_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VPCMPEQD, Register(dst), Register(src), src2.mem, 32) } -inst_vpcmpeqq_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VPCMPEQQ, Register(dst), Register(src), Register(src2)) } -inst_vpcmpeqq_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VPCMPEQQ, Register(dst), Register(src), src2.mem, 16) } -inst_vpcmpeqq_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VPCMPEQQ, Register(dst), Register(src), Register(src2)) } -inst_vpcmpeqq_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VPCMPEQQ, Register(dst), Register(src), src2.mem, 32) } -emit_vpcmpeqq_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VPCMPEQQ, Register(dst), Register(src), Register(src2)) } -emit_vpcmpeqq_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VPCMPEQQ, Register(dst), Register(src), src2.mem, 16) } -emit_vpcmpeqq_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VPCMPEQQ, Register(dst), Register(src), Register(src2)) } -emit_vpcmpeqq_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VPCMPEQQ, Register(dst), Register(src), src2.mem, 32) } -inst_vpcmpgtb_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VPCMPGTB, Register(dst), Register(src), Register(src2)) } -inst_vpcmpgtb_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VPCMPGTB, Register(dst), Register(src), src2.mem, 16) } -inst_vpcmpgtb_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VPCMPGTB, Register(dst), Register(src), Register(src2)) } -inst_vpcmpgtb_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VPCMPGTB, Register(dst), Register(src), src2.mem, 32) } -emit_vpcmpgtb_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VPCMPGTB, Register(dst), Register(src), Register(src2)) } -emit_vpcmpgtb_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VPCMPGTB, Register(dst), Register(src), src2.mem, 16) } -emit_vpcmpgtb_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VPCMPGTB, Register(dst), Register(src), Register(src2)) } -emit_vpcmpgtb_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VPCMPGTB, Register(dst), Register(src), src2.mem, 32) } -inst_vpcmpgtw_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VPCMPGTW, Register(dst), Register(src), Register(src2)) } -inst_vpcmpgtw_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VPCMPGTW, Register(dst), Register(src), src2.mem, 16) } -inst_vpcmpgtw_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VPCMPGTW, Register(dst), Register(src), Register(src2)) } -inst_vpcmpgtw_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VPCMPGTW, Register(dst), Register(src), src2.mem, 32) } -emit_vpcmpgtw_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VPCMPGTW, Register(dst), Register(src), Register(src2)) } -emit_vpcmpgtw_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VPCMPGTW, Register(dst), Register(src), src2.mem, 16) } -emit_vpcmpgtw_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VPCMPGTW, Register(dst), Register(src), Register(src2)) } -emit_vpcmpgtw_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VPCMPGTW, Register(dst), Register(src), src2.mem, 32) } -inst_vpcmpgtd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VPCMPGTD, Register(dst), Register(src), Register(src2)) } -inst_vpcmpgtd_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VPCMPGTD, Register(dst), Register(src), src2.mem, 16) } -inst_vpcmpgtd_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VPCMPGTD, Register(dst), Register(src), Register(src2)) } -inst_vpcmpgtd_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VPCMPGTD, Register(dst), Register(src), src2.mem, 32) } -emit_vpcmpgtd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VPCMPGTD, Register(dst), Register(src), Register(src2)) } -emit_vpcmpgtd_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VPCMPGTD, Register(dst), Register(src), src2.mem, 16) } -emit_vpcmpgtd_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VPCMPGTD, Register(dst), Register(src), Register(src2)) } -emit_vpcmpgtd_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VPCMPGTD, Register(dst), Register(src), src2.mem, 32) } -inst_vpcmpgtq_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VPCMPGTQ, Register(dst), Register(src), Register(src2)) } -inst_vpcmpgtq_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VPCMPGTQ, Register(dst), Register(src), src2.mem, 16) } -inst_vpcmpgtq_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VPCMPGTQ, Register(dst), Register(src), Register(src2)) } -inst_vpcmpgtq_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VPCMPGTQ, Register(dst), Register(src), src2.mem, 32) } -emit_vpcmpgtq_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VPCMPGTQ, Register(dst), Register(src), Register(src2)) } -emit_vpcmpgtq_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VPCMPGTQ, Register(dst), Register(src), src2.mem, 16) } -emit_vpcmpgtq_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VPCMPGTQ, Register(dst), Register(src), Register(src2)) } -emit_vpcmpgtq_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VPCMPGTQ, Register(dst), Register(src), src2.mem, 32) } -inst_vpacksswb_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VPACKSSWB, Register(dst), Register(src), Register(src2)) } -inst_vpacksswb_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VPACKSSWB, Register(dst), Register(src), src2.mem, 16) } -inst_vpacksswb_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VPACKSSWB, Register(dst), Register(src), Register(src2)) } -inst_vpacksswb_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VPACKSSWB, Register(dst), Register(src), src2.mem, 32) } -emit_vpacksswb_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VPACKSSWB, Register(dst), Register(src), Register(src2)) } -emit_vpacksswb_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VPACKSSWB, Register(dst), Register(src), src2.mem, 16) } -emit_vpacksswb_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VPACKSSWB, Register(dst), Register(src), Register(src2)) } -emit_vpacksswb_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VPACKSSWB, Register(dst), Register(src), src2.mem, 32) } -inst_vpackssdw_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VPACKSSDW, Register(dst), Register(src), Register(src2)) } -inst_vpackssdw_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VPACKSSDW, Register(dst), Register(src), src2.mem, 16) } -inst_vpackssdw_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VPACKSSDW, Register(dst), Register(src), Register(src2)) } -inst_vpackssdw_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VPACKSSDW, Register(dst), Register(src), src2.mem, 32) } -emit_vpackssdw_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VPACKSSDW, Register(dst), Register(src), Register(src2)) } -emit_vpackssdw_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VPACKSSDW, Register(dst), Register(src), src2.mem, 16) } -emit_vpackssdw_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VPACKSSDW, Register(dst), Register(src), Register(src2)) } -emit_vpackssdw_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VPACKSSDW, Register(dst), Register(src), src2.mem, 32) } -inst_vpackuswb_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VPACKUSWB, Register(dst), Register(src), Register(src2)) } -inst_vpackuswb_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VPACKUSWB, Register(dst), Register(src), src2.mem, 16) } -inst_vpackuswb_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VPACKUSWB, Register(dst), Register(src), Register(src2)) } -inst_vpackuswb_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VPACKUSWB, Register(dst), Register(src), src2.mem, 32) } -emit_vpackuswb_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VPACKUSWB, Register(dst), Register(src), Register(src2)) } -emit_vpackuswb_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VPACKUSWB, Register(dst), Register(src), src2.mem, 16) } -emit_vpackuswb_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VPACKUSWB, Register(dst), Register(src), Register(src2)) } -emit_vpackuswb_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VPACKUSWB, Register(dst), Register(src), src2.mem, 32) } -inst_vpackusdw_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VPACKUSDW, Register(dst), Register(src), Register(src2)) } -inst_vpackusdw_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VPACKUSDW, Register(dst), Register(src), src2.mem, 16) } -inst_vpackusdw_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VPACKUSDW, Register(dst), Register(src), Register(src2)) } -inst_vpackusdw_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VPACKUSDW, Register(dst), Register(src), src2.mem, 32) } -emit_vpackusdw_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VPACKUSDW, Register(dst), Register(src), Register(src2)) } -emit_vpackusdw_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VPACKUSDW, Register(dst), Register(src), src2.mem, 16) } -emit_vpackusdw_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VPACKUSDW, Register(dst), Register(src), Register(src2)) } -emit_vpackusdw_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VPACKUSDW, Register(dst), Register(src), src2.mem, 32) } -inst_vpunpcklbw_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VPUNPCKLBW, Register(dst), Register(src), Register(src2)) } -inst_vpunpcklbw_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VPUNPCKLBW, Register(dst), Register(src), src2.mem, 16) } -inst_vpunpcklbw_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VPUNPCKLBW, Register(dst), Register(src), Register(src2)) } -inst_vpunpcklbw_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VPUNPCKLBW, Register(dst), Register(src), src2.mem, 32) } -emit_vpunpcklbw_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VPUNPCKLBW, Register(dst), Register(src), Register(src2)) } -emit_vpunpcklbw_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VPUNPCKLBW, Register(dst), Register(src), src2.mem, 16) } -emit_vpunpcklbw_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VPUNPCKLBW, Register(dst), Register(src), Register(src2)) } -emit_vpunpcklbw_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VPUNPCKLBW, Register(dst), Register(src), src2.mem, 32) } -inst_vpunpcklwd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VPUNPCKLWD, Register(dst), Register(src), Register(src2)) } -inst_vpunpcklwd_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VPUNPCKLWD, Register(dst), Register(src), src2.mem, 16) } -inst_vpunpcklwd_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VPUNPCKLWD, Register(dst), Register(src), Register(src2)) } -inst_vpunpcklwd_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VPUNPCKLWD, Register(dst), Register(src), src2.mem, 32) } -emit_vpunpcklwd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VPUNPCKLWD, Register(dst), Register(src), Register(src2)) } -emit_vpunpcklwd_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VPUNPCKLWD, Register(dst), Register(src), src2.mem, 16) } -emit_vpunpcklwd_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VPUNPCKLWD, Register(dst), Register(src), Register(src2)) } -emit_vpunpcklwd_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VPUNPCKLWD, Register(dst), Register(src), src2.mem, 32) } -inst_vpunpckldq_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VPUNPCKLDQ, Register(dst), Register(src), Register(src2)) } -inst_vpunpckldq_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VPUNPCKLDQ, Register(dst), Register(src), src2.mem, 16) } -inst_vpunpckldq_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VPUNPCKLDQ, Register(dst), Register(src), Register(src2)) } -inst_vpunpckldq_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VPUNPCKLDQ, Register(dst), Register(src), src2.mem, 32) } -emit_vpunpckldq_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VPUNPCKLDQ, Register(dst), Register(src), Register(src2)) } -emit_vpunpckldq_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VPUNPCKLDQ, Register(dst), Register(src), src2.mem, 16) } -emit_vpunpckldq_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VPUNPCKLDQ, Register(dst), Register(src), Register(src2)) } -emit_vpunpckldq_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VPUNPCKLDQ, Register(dst), Register(src), src2.mem, 32) } -inst_vpunpcklqdq_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VPUNPCKLQDQ, Register(dst), Register(src), Register(src2)) } -inst_vpunpcklqdq_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VPUNPCKLQDQ, Register(dst), Register(src), src2.mem, 16) } -inst_vpunpcklqdq_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VPUNPCKLQDQ, Register(dst), Register(src), Register(src2)) } -inst_vpunpcklqdq_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VPUNPCKLQDQ, Register(dst), Register(src), src2.mem, 32) } -emit_vpunpcklqdq_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VPUNPCKLQDQ, Register(dst), Register(src), Register(src2)) } -emit_vpunpcklqdq_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VPUNPCKLQDQ, Register(dst), Register(src), src2.mem, 16) } -emit_vpunpcklqdq_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VPUNPCKLQDQ, Register(dst), Register(src), Register(src2)) } -emit_vpunpcklqdq_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VPUNPCKLQDQ, Register(dst), Register(src), src2.mem, 32) } -inst_vpunpckhbw_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VPUNPCKHBW, Register(dst), Register(src), Register(src2)) } -inst_vpunpckhbw_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VPUNPCKHBW, Register(dst), Register(src), src2.mem, 16) } -inst_vpunpckhbw_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VPUNPCKHBW, Register(dst), Register(src), Register(src2)) } -inst_vpunpckhbw_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VPUNPCKHBW, Register(dst), Register(src), src2.mem, 32) } -emit_vpunpckhbw_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VPUNPCKHBW, Register(dst), Register(src), Register(src2)) } -emit_vpunpckhbw_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VPUNPCKHBW, Register(dst), Register(src), src2.mem, 16) } -emit_vpunpckhbw_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VPUNPCKHBW, Register(dst), Register(src), Register(src2)) } -emit_vpunpckhbw_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VPUNPCKHBW, Register(dst), Register(src), src2.mem, 32) } -inst_vpunpckhwd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VPUNPCKHWD, Register(dst), Register(src), Register(src2)) } -inst_vpunpckhwd_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VPUNPCKHWD, Register(dst), Register(src), src2.mem, 16) } -inst_vpunpckhwd_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VPUNPCKHWD, Register(dst), Register(src), Register(src2)) } -inst_vpunpckhwd_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VPUNPCKHWD, Register(dst), Register(src), src2.mem, 32) } -emit_vpunpckhwd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VPUNPCKHWD, Register(dst), Register(src), Register(src2)) } -emit_vpunpckhwd_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VPUNPCKHWD, Register(dst), Register(src), src2.mem, 16) } -emit_vpunpckhwd_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VPUNPCKHWD, Register(dst), Register(src), Register(src2)) } -emit_vpunpckhwd_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VPUNPCKHWD, Register(dst), Register(src), src2.mem, 32) } -inst_vpunpckhdq_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VPUNPCKHDQ, Register(dst), Register(src), Register(src2)) } -inst_vpunpckhdq_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VPUNPCKHDQ, Register(dst), Register(src), src2.mem, 16) } -inst_vpunpckhdq_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VPUNPCKHDQ, Register(dst), Register(src), Register(src2)) } -inst_vpunpckhdq_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VPUNPCKHDQ, Register(dst), Register(src), src2.mem, 32) } -emit_vpunpckhdq_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VPUNPCKHDQ, Register(dst), Register(src), Register(src2)) } -emit_vpunpckhdq_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VPUNPCKHDQ, Register(dst), Register(src), src2.mem, 16) } -emit_vpunpckhdq_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VPUNPCKHDQ, Register(dst), Register(src), Register(src2)) } -emit_vpunpckhdq_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VPUNPCKHDQ, Register(dst), Register(src), src2.mem, 32) } -inst_vpunpckhqdq_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VPUNPCKHQDQ, Register(dst), Register(src), Register(src2)) } -inst_vpunpckhqdq_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VPUNPCKHQDQ, Register(dst), Register(src), src2.mem, 16) } -inst_vpunpckhqdq_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VPUNPCKHQDQ, Register(dst), Register(src), Register(src2)) } -inst_vpunpckhqdq_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VPUNPCKHQDQ, Register(dst), Register(src), src2.mem, 32) } -emit_vpunpckhqdq_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VPUNPCKHQDQ, Register(dst), Register(src), Register(src2)) } -emit_vpunpckhqdq_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VPUNPCKHQDQ, Register(dst), Register(src), src2.mem, 16) } -emit_vpunpckhqdq_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VPUNPCKHQDQ, Register(dst), Register(src), Register(src2)) } -emit_vpunpckhqdq_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VPUNPCKHQDQ, Register(dst), Register(src), src2.mem, 32) } -inst_vpshufd_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return inst_r_r_i(.VPSHUFD, Register(dst), Register(src), i64(imm), 1) } -inst_vpshufd_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem128, imm: i8) -> Instruction { return inst_r_m_i(.VPSHUFD, Register(dst), src.mem, 16, i64(imm), 1) } -inst_vpshufd_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, imm: i8) -> Instruction { return inst_r_r_i(.VPSHUFD, Register(dst), Register(src), i64(imm), 1) } -inst_vpshufd_ymm_m256_imm8 :: #force_inline proc "contextless" (dst: YMM, src: Mem256, imm: i8) -> Instruction { return inst_r_m_i(.VPSHUFD, Register(dst), src.mem, 32, i64(imm), 1) } -emit_vpshufd_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, imm: i8) { emit_rri(instructions, .VPSHUFD, Register(dst), Register(src), i64(imm), 1) } -emit_vpshufd_xmm_m128_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128, imm: i8) { emit_rmi(instructions, .VPSHUFD, Register(dst), src.mem, 16, i64(imm), 1) } -emit_vpshufd_ymm_ymm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, imm: i8) { emit_rri(instructions, .VPSHUFD, Register(dst), Register(src), i64(imm), 1) } -emit_vpshufd_ymm_m256_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem256, imm: i8) { emit_rmi(instructions, .VPSHUFD, Register(dst), src.mem, 32, i64(imm), 1) } -inst_vpshufhw_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return inst_r_r_i(.VPSHUFHW, Register(dst), Register(src), i64(imm), 1) } -inst_vpshufhw_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem128, imm: i8) -> Instruction { return inst_r_m_i(.VPSHUFHW, Register(dst), src.mem, 16, i64(imm), 1) } -inst_vpshufhw_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, imm: i8) -> Instruction { return inst_r_r_i(.VPSHUFHW, Register(dst), Register(src), i64(imm), 1) } -inst_vpshufhw_ymm_m256_imm8 :: #force_inline proc "contextless" (dst: YMM, src: Mem256, imm: i8) -> Instruction { return inst_r_m_i(.VPSHUFHW, Register(dst), src.mem, 32, i64(imm), 1) } -emit_vpshufhw_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, imm: i8) { emit_rri(instructions, .VPSHUFHW, Register(dst), Register(src), i64(imm), 1) } -emit_vpshufhw_xmm_m128_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128, imm: i8) { emit_rmi(instructions, .VPSHUFHW, Register(dst), src.mem, 16, i64(imm), 1) } -emit_vpshufhw_ymm_ymm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, imm: i8) { emit_rri(instructions, .VPSHUFHW, Register(dst), Register(src), i64(imm), 1) } -emit_vpshufhw_ymm_m256_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem256, imm: i8) { emit_rmi(instructions, .VPSHUFHW, Register(dst), src.mem, 32, i64(imm), 1) } -inst_vpshuflw_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return inst_r_r_i(.VPSHUFLW, Register(dst), Register(src), i64(imm), 1) } -inst_vpshuflw_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem128, imm: i8) -> Instruction { return inst_r_m_i(.VPSHUFLW, Register(dst), src.mem, 16, i64(imm), 1) } -inst_vpshuflw_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, imm: i8) -> Instruction { return inst_r_r_i(.VPSHUFLW, Register(dst), Register(src), i64(imm), 1) } -inst_vpshuflw_ymm_m256_imm8 :: #force_inline proc "contextless" (dst: YMM, src: Mem256, imm: i8) -> Instruction { return inst_r_m_i(.VPSHUFLW, Register(dst), src.mem, 32, i64(imm), 1) } -emit_vpshuflw_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, imm: i8) { emit_rri(instructions, .VPSHUFLW, Register(dst), Register(src), i64(imm), 1) } -emit_vpshuflw_xmm_m128_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128, imm: i8) { emit_rmi(instructions, .VPSHUFLW, Register(dst), src.mem, 16, i64(imm), 1) } -emit_vpshuflw_ymm_ymm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, imm: i8) { emit_rri(instructions, .VPSHUFLW, Register(dst), Register(src), i64(imm), 1) } -emit_vpshuflw_ymm_m256_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem256, imm: i8) { emit_rmi(instructions, .VPSHUFLW, Register(dst), src.mem, 32, i64(imm), 1) } -inst_vpextrb_r8_xmm_imm8 :: #force_inline proc "contextless" (dst: GPR8, src: XMM, imm: i8) -> Instruction { return inst_r_r_i(.VPEXTRB, Register(dst), Register(src), i64(imm), 1) } -inst_vpextrb_m8_xmm_imm8 :: #force_inline proc "contextless" (dst: Mem8, src: XMM, imm: i8) -> Instruction { return inst_m_r_i(.VPEXTRB, dst.mem, 1, Register(src), i64(imm), 1) } -emit_vpextrb_r8_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8, src: XMM, imm: i8) { emit_rri(instructions, .VPEXTRB, Register(dst), Register(src), i64(imm), 1) } -emit_vpextrb_m8_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8, src: XMM, imm: i8) { emit_mri(instructions, .VPEXTRB, dst.mem, 1, Register(src), i64(imm), 1) } -inst_vpextrw_r32_xmm_imm8 :: #force_inline proc "contextless" (dst: GPR32, src: XMM, imm: i8) -> Instruction { return inst_r_r_i(.VPEXTRW, Register(dst), Register(src), i64(imm), 1) } -inst_vpextrw_r16_xmm_imm8 :: #force_inline proc "contextless" (dst: GPR16, src: XMM, imm: i8) -> Instruction { return inst_r_r_i(.VPEXTRW, Register(dst), Register(src), i64(imm), 1) } -inst_vpextrw_m16_xmm_imm8 :: #force_inline proc "contextless" (dst: Mem16, src: XMM, imm: i8) -> Instruction { return inst_m_r_i(.VPEXTRW, dst.mem, 2, Register(src), i64(imm), 1) } -emit_vpextrw_r32_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: XMM, imm: i8) { emit_rri(instructions, .VPEXTRW, Register(dst), Register(src), i64(imm), 1) } -emit_vpextrw_r16_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: XMM, imm: i8) { emit_rri(instructions, .VPEXTRW, Register(dst), Register(src), i64(imm), 1) } -emit_vpextrw_m16_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16, src: XMM, imm: i8) { emit_mri(instructions, .VPEXTRW, dst.mem, 2, Register(src), i64(imm), 1) } -inst_vpextrd_r32_xmm_imm8 :: #force_inline proc "contextless" (dst: GPR32, src: XMM, imm: i8) -> Instruction { return inst_r_r_i(.VPEXTRD, Register(dst), Register(src), i64(imm), 1) } -inst_vpextrd_m32_xmm_imm8 :: #force_inline proc "contextless" (dst: Mem32, src: XMM, imm: i8) -> Instruction { return inst_m_r_i(.VPEXTRD, dst.mem, 4, Register(src), i64(imm), 1) } -emit_vpextrd_r32_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: XMM, imm: i8) { emit_rri(instructions, .VPEXTRD, Register(dst), Register(src), i64(imm), 1) } -emit_vpextrd_m32_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, src: XMM, imm: i8) { emit_mri(instructions, .VPEXTRD, dst.mem, 4, Register(src), i64(imm), 1) } -inst_vpextrq_r64_xmm_imm8 :: #force_inline proc "contextless" (dst: GPR64, src: XMM, imm: i8) -> Instruction { return inst_r_r_i(.VPEXTRQ, Register(dst), Register(src), i64(imm), 1) } -inst_vpextrq_m64_xmm_imm8 :: #force_inline proc "contextless" (dst: Mem64, src: XMM, imm: i8) -> Instruction { return inst_m_r_i(.VPEXTRQ, dst.mem, 8, Register(src), i64(imm), 1) } -emit_vpextrq_r64_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: XMM, imm: i8) { emit_rri(instructions, .VPEXTRQ, Register(dst), Register(src), i64(imm), 1) } -emit_vpextrq_m64_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, src: XMM, imm: i8) { emit_mri(instructions, .VPEXTRQ, dst.mem, 8, Register(src), i64(imm), 1) } +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) } +inst_vmovaps_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VMOVAPS, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 1126) } +inst_vmovaps_m128_xmm :: #force_inline proc "contextless" (dst: Mem128, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VMOVAPS, operand_count = 2, ops = {op_mem(dst.mem, 16), op_xmm(src), {}, {}} }, 1127) } +inst_vmovaps_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VMOVAPS, operand_count = 2, ops = {op_ymm(dst), op_ymm(src), {}, {}} }, 1128) } +inst_vmovaps_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VMOVAPS, operand_count = 2, ops = {op_ymm(dst), op_mem(src.mem, 32), {}, {}} }, 1128) } +inst_vmovaps_m256_ymm :: #force_inline proc "contextless" (dst: Mem256, src: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VMOVAPS, operand_count = 2, ops = {op_mem(dst.mem, 32), op_ymm(src), {}, {}} }, 1129) } +emit_vmovaps_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_vmovaps_xmm_xmm(dst, src)) } +emit_vmovaps_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_vmovaps_xmm_m128(dst, src)) } +emit_vmovaps_m128_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem128, src: XMM) { append(instructions, inst_vmovaps_m128_xmm(dst, src)) } +emit_vmovaps_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM) { append(instructions, inst_vmovaps_ymm_ymm(dst, src)) } +emit_vmovaps_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem256) { append(instructions, inst_vmovaps_ymm_m256(dst, src)) } +emit_vmovaps_m256_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem256, src: YMM) { append(instructions, inst_vmovaps_m256_ymm(dst, src)) } +inst_vmovups_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VMOVUPS, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 1130) } +inst_vmovups_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VMOVUPS, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 1130) } +inst_vmovups_m128_xmm :: #force_inline proc "contextless" (dst: Mem128, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VMOVUPS, operand_count = 2, ops = {op_mem(dst.mem, 16), op_xmm(src), {}, {}} }, 1131) } +inst_vmovups_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VMOVUPS, operand_count = 2, ops = {op_ymm(dst), op_ymm(src), {}, {}} }, 1132) } +inst_vmovups_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VMOVUPS, operand_count = 2, ops = {op_ymm(dst), op_mem(src.mem, 32), {}, {}} }, 1132) } +inst_vmovups_m256_ymm :: #force_inline proc "contextless" (dst: Mem256, src: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VMOVUPS, operand_count = 2, ops = {op_mem(dst.mem, 32), op_ymm(src), {}, {}} }, 1133) } +emit_vmovups_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_vmovups_xmm_xmm(dst, src)) } +emit_vmovups_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_vmovups_xmm_m128(dst, src)) } +emit_vmovups_m128_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem128, src: XMM) { append(instructions, inst_vmovups_m128_xmm(dst, src)) } +emit_vmovups_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM) { append(instructions, inst_vmovups_ymm_ymm(dst, src)) } +emit_vmovups_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem256) { append(instructions, inst_vmovups_ymm_m256(dst, src)) } +emit_vmovups_m256_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem256, src: YMM) { append(instructions, inst_vmovups_m256_ymm(dst, src)) } +inst_vmovapd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VMOVAPD, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 1134) } +inst_vmovapd_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VMOVAPD, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 1134) } +inst_vmovapd_m128_xmm :: #force_inline proc "contextless" (dst: Mem128, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VMOVAPD, operand_count = 2, ops = {op_mem(dst.mem, 16), op_xmm(src), {}, {}} }, 1135) } +inst_vmovapd_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VMOVAPD, operand_count = 2, ops = {op_ymm(dst), op_ymm(src), {}, {}} }, 1136) } +inst_vmovapd_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VMOVAPD, operand_count = 2, ops = {op_ymm(dst), op_mem(src.mem, 32), {}, {}} }, 1136) } +inst_vmovapd_m256_ymm :: #force_inline proc "contextless" (dst: Mem256, src: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VMOVAPD, operand_count = 2, ops = {op_mem(dst.mem, 32), op_ymm(src), {}, {}} }, 1137) } +emit_vmovapd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_vmovapd_xmm_xmm(dst, src)) } +emit_vmovapd_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_vmovapd_xmm_m128(dst, src)) } +emit_vmovapd_m128_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem128, src: XMM) { append(instructions, inst_vmovapd_m128_xmm(dst, src)) } +emit_vmovapd_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM) { append(instructions, inst_vmovapd_ymm_ymm(dst, src)) } +emit_vmovapd_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem256) { append(instructions, inst_vmovapd_ymm_m256(dst, src)) } +emit_vmovapd_m256_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem256, src: YMM) { append(instructions, inst_vmovapd_m256_ymm(dst, src)) } +inst_vmovupd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VMOVUPD, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 1138) } +inst_vmovupd_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VMOVUPD, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 1138) } +inst_vmovupd_m128_xmm :: #force_inline proc "contextless" (dst: Mem128, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VMOVUPD, operand_count = 2, ops = {op_mem(dst.mem, 16), op_xmm(src), {}, {}} }, 1139) } +inst_vmovupd_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VMOVUPD, operand_count = 2, ops = {op_ymm(dst), op_ymm(src), {}, {}} }, 1140) } +inst_vmovupd_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VMOVUPD, operand_count = 2, ops = {op_ymm(dst), op_mem(src.mem, 32), {}, {}} }, 1140) } +inst_vmovupd_m256_ymm :: #force_inline proc "contextless" (dst: Mem256, src: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VMOVUPD, operand_count = 2, ops = {op_mem(dst.mem, 32), op_ymm(src), {}, {}} }, 1141) } +emit_vmovupd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_vmovupd_xmm_xmm(dst, src)) } +emit_vmovupd_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_vmovupd_xmm_m128(dst, src)) } +emit_vmovupd_m128_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem128, src: XMM) { append(instructions, inst_vmovupd_m128_xmm(dst, src)) } +emit_vmovupd_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM) { append(instructions, inst_vmovupd_ymm_ymm(dst, src)) } +emit_vmovupd_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem256) { append(instructions, inst_vmovupd_ymm_m256(dst, src)) } +emit_vmovupd_m256_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem256, src: YMM) { append(instructions, inst_vmovupd_m256_ymm(dst, src)) } +inst_vmovss_xmm_m32 :: #force_inline proc "contextless" (dst: XMM, src: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .VMOVSS, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 4), {}, {}} }, 1142) } +inst_vmovss_m32_xmm :: #force_inline proc "contextless" (dst: Mem32, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VMOVSS, operand_count = 2, ops = {op_mem(dst.mem, 4), op_xmm(src), {}, {}} }, 1143) } +inst_vmovss_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VMOVSS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1144) } +emit_vmovss_xmm_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem32) { append(instructions, inst_vmovss_xmm_m32(dst, src)) } +emit_vmovss_m32_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, src: XMM) { append(instructions, inst_vmovss_m32_xmm(dst, src)) } +emit_vmovss_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vmovss_xmm_xmm_xmm(dst, src, src2)) } +inst_vmovsd_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .VMOVSD, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 8), {}, {}} }, 1145) } +inst_vmovsd_m64_xmm :: #force_inline proc "contextless" (dst: Mem64, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VMOVSD, operand_count = 2, ops = {op_mem(dst.mem, 8), op_xmm(src), {}, {}} }, 1146) } +inst_vmovsd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VMOVSD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1147) } +emit_vmovsd_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem64) { append(instructions, inst_vmovsd_xmm_m64(dst, src)) } +emit_vmovsd_m64_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, src: XMM) { append(instructions, inst_vmovsd_m64_xmm(dst, src)) } +emit_vmovsd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vmovsd_xmm_xmm_xmm(dst, src, src2)) } +inst_vmovdqa_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VMOVDQA, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 1148) } +inst_vmovdqa_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VMOVDQA, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 1148) } +inst_vmovdqa_m128_xmm :: #force_inline proc "contextless" (dst: Mem128, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VMOVDQA, operand_count = 2, ops = {op_mem(dst.mem, 16), op_xmm(src), {}, {}} }, 1149) } +inst_vmovdqa_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VMOVDQA, operand_count = 2, ops = {op_ymm(dst), op_ymm(src), {}, {}} }, 1150) } +inst_vmovdqa_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VMOVDQA, operand_count = 2, ops = {op_ymm(dst), op_mem(src.mem, 32), {}, {}} }, 1150) } +inst_vmovdqa_m256_ymm :: #force_inline proc "contextless" (dst: Mem256, src: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VMOVDQA, operand_count = 2, ops = {op_mem(dst.mem, 32), op_ymm(src), {}, {}} }, 1151) } +emit_vmovdqa_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_vmovdqa_xmm_xmm(dst, src)) } +emit_vmovdqa_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_vmovdqa_xmm_m128(dst, src)) } +emit_vmovdqa_m128_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem128, src: XMM) { append(instructions, inst_vmovdqa_m128_xmm(dst, src)) } +emit_vmovdqa_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM) { append(instructions, inst_vmovdqa_ymm_ymm(dst, src)) } +emit_vmovdqa_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem256) { append(instructions, inst_vmovdqa_ymm_m256(dst, src)) } +emit_vmovdqa_m256_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem256, src: YMM) { append(instructions, inst_vmovdqa_m256_ymm(dst, src)) } +inst_vmovdqu_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VMOVDQU, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 1152) } +inst_vmovdqu_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VMOVDQU, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 1152) } +inst_vmovdqu_m128_xmm :: #force_inline proc "contextless" (dst: Mem128, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VMOVDQU, operand_count = 2, ops = {op_mem(dst.mem, 16), op_xmm(src), {}, {}} }, 1153) } +inst_vmovdqu_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VMOVDQU, operand_count = 2, ops = {op_ymm(dst), op_ymm(src), {}, {}} }, 1154) } +inst_vmovdqu_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VMOVDQU, operand_count = 2, ops = {op_ymm(dst), op_mem(src.mem, 32), {}, {}} }, 1154) } +inst_vmovdqu_m256_ymm :: #force_inline proc "contextless" (dst: Mem256, src: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VMOVDQU, operand_count = 2, ops = {op_mem(dst.mem, 32), op_ymm(src), {}, {}} }, 1155) } +emit_vmovdqu_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_vmovdqu_xmm_xmm(dst, src)) } +emit_vmovdqu_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_vmovdqu_xmm_m128(dst, src)) } +emit_vmovdqu_m128_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem128, src: XMM) { append(instructions, inst_vmovdqu_m128_xmm(dst, src)) } +emit_vmovdqu_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM) { append(instructions, inst_vmovdqu_ymm_ymm(dst, src)) } +emit_vmovdqu_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem256) { append(instructions, inst_vmovdqu_ymm_m256(dst, src)) } +emit_vmovdqu_m256_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem256, src: YMM) { append(instructions, inst_vmovdqu_m256_ymm(dst, src)) } +inst_vmovq_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VMOVQ, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 1156) } +inst_vmovq_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .VMOVQ, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 8), {}, {}} }, 1156) } +inst_vmovq_m64_xmm :: #force_inline proc "contextless" (dst: Mem64, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VMOVQ, operand_count = 2, ops = {op_mem(dst.mem, 8), op_xmm(src), {}, {}} }, 1157) } +inst_vmovq_xmm_r64 :: #force_inline proc "contextless" (dst: XMM, src: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .VMOVQ, operand_count = 2, ops = {op_xmm(dst), op_gpr64(src), {}, {}} }, 1158) } +inst_vmovq_r64_xmm :: #force_inline proc "contextless" (dst: GPR64, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VMOVQ, operand_count = 2, ops = {op_gpr64(dst), op_xmm(src), {}, {}} }, 1159) } +emit_vmovq_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_vmovq_xmm_xmm(dst, src)) } +emit_vmovq_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem64) { append(instructions, inst_vmovq_xmm_m64(dst, src)) } +emit_vmovq_m64_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, src: XMM) { append(instructions, inst_vmovq_m64_xmm(dst, src)) } +emit_vmovq_xmm_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: GPR64) { append(instructions, inst_vmovq_xmm_r64(dst, src)) } +emit_vmovq_r64_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: XMM) { append(instructions, inst_vmovq_r64_xmm(dst, src)) } +inst_vmovd_xmm_r32 :: #force_inline proc "contextless" (dst: XMM, src: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .VMOVD, operand_count = 2, ops = {op_xmm(dst), op_gpr32(src), {}, {}} }, 1160) } +inst_vmovd_xmm_m32 :: #force_inline proc "contextless" (dst: XMM, src: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .VMOVD, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 4), {}, {}} }, 1160) } +inst_vmovd_r32_xmm :: #force_inline proc "contextless" (dst: GPR32, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VMOVD, operand_count = 2, ops = {op_gpr32(dst), op_xmm(src), {}, {}} }, 1161) } +inst_vmovd_m32_xmm :: #force_inline proc "contextless" (dst: Mem32, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VMOVD, operand_count = 2, ops = {op_mem(dst.mem, 4), op_xmm(src), {}, {}} }, 1161) } +emit_vmovd_xmm_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: GPR32) { append(instructions, inst_vmovd_xmm_r32(dst, src)) } +emit_vmovd_xmm_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem32) { append(instructions, inst_vmovd_xmm_m32(dst, src)) } +emit_vmovd_r32_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: XMM) { append(instructions, inst_vmovd_r32_xmm(dst, src)) } +emit_vmovd_m32_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, src: XMM) { append(instructions, inst_vmovd_m32_xmm(dst, src)) } +inst_vmovlps_xmm_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .VMOVLPS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 8), {}} }, 1162) } +inst_vmovlps_m64_xmm :: #force_inline proc "contextless" (dst: Mem64, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VMOVLPS, operand_count = 2, ops = {op_mem(dst.mem, 8), op_xmm(src), {}, {}} }, 1163) } +emit_vmovlps_xmm_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem64) { append(instructions, inst_vmovlps_xmm_xmm_m64(dst, src, src2)) } +emit_vmovlps_m64_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, src: XMM) { append(instructions, inst_vmovlps_m64_xmm(dst, src)) } +inst_vmovhps_xmm_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .VMOVHPS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 8), {}} }, 1164) } +inst_vmovhps_m64_xmm :: #force_inline proc "contextless" (dst: Mem64, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VMOVHPS, operand_count = 2, ops = {op_mem(dst.mem, 8), op_xmm(src), {}, {}} }, 1165) } +emit_vmovhps_xmm_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem64) { append(instructions, inst_vmovhps_xmm_xmm_m64(dst, src, src2)) } +emit_vmovhps_m64_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, src: XMM) { append(instructions, inst_vmovhps_m64_xmm(dst, src)) } +inst_vmovlpd_xmm_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .VMOVLPD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 8), {}} }, 1166) } +inst_vmovlpd_m64_xmm :: #force_inline proc "contextless" (dst: Mem64, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VMOVLPD, operand_count = 2, ops = {op_mem(dst.mem, 8), op_xmm(src), {}, {}} }, 1167) } +emit_vmovlpd_xmm_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem64) { append(instructions, inst_vmovlpd_xmm_xmm_m64(dst, src, src2)) } +emit_vmovlpd_m64_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, src: XMM) { append(instructions, inst_vmovlpd_m64_xmm(dst, src)) } +inst_vmovhpd_xmm_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .VMOVHPD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 8), {}} }, 1168) } +inst_vmovhpd_m64_xmm :: #force_inline proc "contextless" (dst: Mem64, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VMOVHPD, operand_count = 2, ops = {op_mem(dst.mem, 8), op_xmm(src), {}, {}} }, 1169) } +emit_vmovhpd_xmm_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem64) { append(instructions, inst_vmovhpd_xmm_xmm_m64(dst, src, src2)) } +emit_vmovhpd_m64_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, src: XMM) { append(instructions, inst_vmovhpd_m64_xmm(dst, src)) } +inst_vmovlhps_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VMOVLHPS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1170) } +emit_vmovlhps_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vmovlhps_xmm_xmm_xmm(dst, src, src2)) } +inst_vmovhlps_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VMOVHLPS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1171) } +emit_vmovhlps_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vmovhlps_xmm_xmm_xmm(dst, src, src2)) } +inst_vmovmskps_r32_xmm :: #force_inline proc "contextless" (dst: GPR32, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VMOVMSKPS, operand_count = 2, ops = {op_gpr32(dst), op_xmm(src), {}, {}} }, 1172) } +inst_vmovmskps_r32_ymm :: #force_inline proc "contextless" (dst: GPR32, src: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VMOVMSKPS, operand_count = 2, ops = {op_gpr32(dst), op_ymm(src), {}, {}} }, 1173) } +emit_vmovmskps_r32_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: XMM) { append(instructions, inst_vmovmskps_r32_xmm(dst, src)) } +emit_vmovmskps_r32_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: YMM) { append(instructions, inst_vmovmskps_r32_ymm(dst, src)) } +inst_vmovmskpd_r32_xmm :: #force_inline proc "contextless" (dst: GPR32, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VMOVMSKPD, operand_count = 2, ops = {op_gpr32(dst), op_xmm(src), {}, {}} }, 1174) } +inst_vmovmskpd_r32_ymm :: #force_inline proc "contextless" (dst: GPR32, src: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VMOVMSKPD, operand_count = 2, ops = {op_gpr32(dst), op_ymm(src), {}, {}} }, 1175) } +emit_vmovmskpd_r32_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: XMM) { append(instructions, inst_vmovmskpd_r32_xmm(dst, src)) } +emit_vmovmskpd_r32_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: YMM) { append(instructions, inst_vmovmskpd_r32_ymm(dst, src)) } +inst_vmovntps_m128_xmm :: #force_inline proc "contextless" (dst: Mem128, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VMOVNTPS, operand_count = 2, ops = {op_mem(dst.mem, 16), op_xmm(src), {}, {}} }, 1176) } +inst_vmovntps_m256_ymm :: #force_inline proc "contextless" (dst: Mem256, src: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VMOVNTPS, operand_count = 2, ops = {op_mem(dst.mem, 32), op_ymm(src), {}, {}} }, 1177) } +emit_vmovntps_m128_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem128, src: XMM) { append(instructions, inst_vmovntps_m128_xmm(dst, src)) } +emit_vmovntps_m256_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem256, src: YMM) { append(instructions, inst_vmovntps_m256_ymm(dst, src)) } +inst_vmovntpd_m128_xmm :: #force_inline proc "contextless" (dst: Mem128, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VMOVNTPD, operand_count = 2, ops = {op_mem(dst.mem, 16), op_xmm(src), {}, {}} }, 1178) } +inst_vmovntpd_m256_ymm :: #force_inline proc "contextless" (dst: Mem256, src: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VMOVNTPD, operand_count = 2, ops = {op_mem(dst.mem, 32), op_ymm(src), {}, {}} }, 1179) } +emit_vmovntpd_m128_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem128, src: XMM) { append(instructions, inst_vmovntpd_m128_xmm(dst, src)) } +emit_vmovntpd_m256_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem256, src: YMM) { append(instructions, inst_vmovntpd_m256_ymm(dst, src)) } +inst_vmovntdq_m128_xmm :: #force_inline proc "contextless" (dst: Mem128, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VMOVNTDQ, operand_count = 2, ops = {op_mem(dst.mem, 16), op_xmm(src), {}, {}} }, 1180) } +inst_vmovntdq_m256_ymm :: #force_inline proc "contextless" (dst: Mem256, src: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VMOVNTDQ, operand_count = 2, ops = {op_mem(dst.mem, 32), op_ymm(src), {}, {}} }, 1181) } +emit_vmovntdq_m128_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem128, src: XMM) { append(instructions, inst_vmovntdq_m128_xmm(dst, src)) } +emit_vmovntdq_m256_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem256, src: YMM) { append(instructions, inst_vmovntdq_m256_ymm(dst, src)) } +inst_vmovntdqa_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VMOVNTDQA, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 1182) } +inst_vmovntdqa_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VMOVNTDQA, operand_count = 2, ops = {op_ymm(dst), op_mem(src.mem, 32), {}, {}} }, 1183) } +emit_vmovntdqa_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_vmovntdqa_xmm_m128(dst, src)) } +emit_vmovntdqa_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem256) { append(instructions, inst_vmovntdqa_ymm_m256(dst, src)) } +inst_vcvtps2pd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VCVTPS2PD, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 1184) } +inst_vcvtps2pd_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .VCVTPS2PD, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 8), {}, {}} }, 1184) } +inst_vcvtps2pd_ymm_xmm :: #force_inline proc "contextless" (dst: YMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VCVTPS2PD, operand_count = 2, ops = {op_ymm(dst), op_xmm(src), {}, {}} }, 1185) } +inst_vcvtps2pd_ymm_m128 :: #force_inline proc "contextless" (dst: YMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VCVTPS2PD, operand_count = 2, ops = {op_ymm(dst), op_mem(src.mem, 16), {}, {}} }, 1185) } +emit_vcvtps2pd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_vcvtps2pd_xmm_xmm(dst, src)) } +emit_vcvtps2pd_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem64) { append(instructions, inst_vcvtps2pd_xmm_m64(dst, src)) } +emit_vcvtps2pd_ymm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: XMM) { append(instructions, inst_vcvtps2pd_ymm_xmm(dst, src)) } +emit_vcvtps2pd_ymm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem128) { append(instructions, inst_vcvtps2pd_ymm_m128(dst, src)) } +inst_vcvtpd2ps_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VCVTPD2PS, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 1186) } +inst_vcvtpd2ps_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VCVTPD2PS, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 1186) } +inst_vcvtpd2ps_xmm_ymm :: #force_inline proc "contextless" (dst: XMM, src: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VCVTPD2PS, operand_count = 2, ops = {op_xmm(dst), op_ymm(src), {}, {}} }, 1187) } +inst_vcvtpd2ps_xmm_m256 :: #force_inline proc "contextless" (dst: XMM, src: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VCVTPD2PS, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 32), {}, {}} }, 1187) } +emit_vcvtpd2ps_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_vcvtpd2ps_xmm_xmm(dst, src)) } +emit_vcvtpd2ps_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_vcvtpd2ps_xmm_m128(dst, src)) } +emit_vcvtpd2ps_xmm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: YMM) { append(instructions, inst_vcvtpd2ps_xmm_ymm(dst, src)) } +emit_vcvtpd2ps_xmm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem256) { append(instructions, inst_vcvtpd2ps_xmm_m256(dst, src)) } +inst_vcvtss2sd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VCVTSS2SD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1188) } +inst_vcvtss2sd_xmm_xmm_m32 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .VCVTSS2SD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 4), {}} }, 1188) } +emit_vcvtss2sd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vcvtss2sd_xmm_xmm_xmm(dst, src, src2)) } +emit_vcvtss2sd_xmm_xmm_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem32) { append(instructions, inst_vcvtss2sd_xmm_xmm_m32(dst, src, src2)) } +inst_vcvtsd2ss_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VCVTSD2SS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1189) } +inst_vcvtsd2ss_xmm_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .VCVTSD2SS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 8), {}} }, 1189) } +emit_vcvtsd2ss_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vcvtsd2ss_xmm_xmm_xmm(dst, src, src2)) } +emit_vcvtsd2ss_xmm_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem64) { append(instructions, inst_vcvtsd2ss_xmm_xmm_m64(dst, src, src2)) } +inst_vcvtps2dq_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VCVTPS2DQ, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 1190) } +inst_vcvtps2dq_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VCVTPS2DQ, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 1190) } +inst_vcvtps2dq_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VCVTPS2DQ, operand_count = 2, ops = {op_ymm(dst), op_ymm(src), {}, {}} }, 1191) } +inst_vcvtps2dq_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VCVTPS2DQ, operand_count = 2, ops = {op_ymm(dst), op_mem(src.mem, 32), {}, {}} }, 1191) } +emit_vcvtps2dq_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_vcvtps2dq_xmm_xmm(dst, src)) } +emit_vcvtps2dq_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_vcvtps2dq_xmm_m128(dst, src)) } +emit_vcvtps2dq_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM) { append(instructions, inst_vcvtps2dq_ymm_ymm(dst, src)) } +emit_vcvtps2dq_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem256) { append(instructions, inst_vcvtps2dq_ymm_m256(dst, src)) } +inst_vcvtpd2dq_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VCVTPD2DQ, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 1192) } +inst_vcvtpd2dq_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VCVTPD2DQ, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 1192) } +inst_vcvtpd2dq_xmm_ymm :: #force_inline proc "contextless" (dst: XMM, src: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VCVTPD2DQ, operand_count = 2, ops = {op_xmm(dst), op_ymm(src), {}, {}} }, 1193) } +inst_vcvtpd2dq_xmm_m256 :: #force_inline proc "contextless" (dst: XMM, src: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VCVTPD2DQ, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 32), {}, {}} }, 1193) } +emit_vcvtpd2dq_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_vcvtpd2dq_xmm_xmm(dst, src)) } +emit_vcvtpd2dq_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_vcvtpd2dq_xmm_m128(dst, src)) } +emit_vcvtpd2dq_xmm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: YMM) { append(instructions, inst_vcvtpd2dq_xmm_ymm(dst, src)) } +emit_vcvtpd2dq_xmm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem256) { append(instructions, inst_vcvtpd2dq_xmm_m256(dst, src)) } +inst_vcvtdq2ps_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VCVTDQ2PS, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 1194) } +inst_vcvtdq2ps_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VCVTDQ2PS, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 1194) } +inst_vcvtdq2ps_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VCVTDQ2PS, operand_count = 2, ops = {op_ymm(dst), op_ymm(src), {}, {}} }, 1195) } +inst_vcvtdq2ps_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VCVTDQ2PS, operand_count = 2, ops = {op_ymm(dst), op_mem(src.mem, 32), {}, {}} }, 1195) } +emit_vcvtdq2ps_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_vcvtdq2ps_xmm_xmm(dst, src)) } +emit_vcvtdq2ps_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_vcvtdq2ps_xmm_m128(dst, src)) } +emit_vcvtdq2ps_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM) { append(instructions, inst_vcvtdq2ps_ymm_ymm(dst, src)) } +emit_vcvtdq2ps_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem256) { append(instructions, inst_vcvtdq2ps_ymm_m256(dst, src)) } +inst_vcvtdq2pd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VCVTDQ2PD, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 1196) } +inst_vcvtdq2pd_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .VCVTDQ2PD, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 8), {}, {}} }, 1196) } +inst_vcvtdq2pd_ymm_xmm :: #force_inline proc "contextless" (dst: YMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VCVTDQ2PD, operand_count = 2, ops = {op_ymm(dst), op_xmm(src), {}, {}} }, 1197) } +inst_vcvtdq2pd_ymm_m128 :: #force_inline proc "contextless" (dst: YMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VCVTDQ2PD, operand_count = 2, ops = {op_ymm(dst), op_mem(src.mem, 16), {}, {}} }, 1197) } +emit_vcvtdq2pd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_vcvtdq2pd_xmm_xmm(dst, src)) } +emit_vcvtdq2pd_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem64) { append(instructions, inst_vcvtdq2pd_xmm_m64(dst, src)) } +emit_vcvtdq2pd_ymm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: XMM) { append(instructions, inst_vcvtdq2pd_ymm_xmm(dst, src)) } +emit_vcvtdq2pd_ymm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem128) { append(instructions, inst_vcvtdq2pd_ymm_m128(dst, src)) } +inst_vcvtss2si_r32_xmm :: #force_inline proc "contextless" (dst: GPR32, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VCVTSS2SI, operand_count = 2, ops = {op_gpr32(dst), op_xmm(src), {}, {}} }, 1198) } +inst_vcvtss2si_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .VCVTSS2SI, operand_count = 2, ops = {op_gpr32(dst), op_mem(src.mem, 4), {}, {}} }, 1198) } +inst_vcvtss2si_r64_xmm :: #force_inline proc "contextless" (dst: GPR64, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VCVTSS2SI, operand_count = 2, ops = {op_gpr64(dst), op_xmm(src), {}, {}} }, 1199) } +inst_vcvtss2si_r64_m32 :: #force_inline proc "contextless" (dst: GPR64, src: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .VCVTSS2SI, operand_count = 2, ops = {op_gpr64(dst), op_mem(src.mem, 4), {}, {}} }, 1199) } +emit_vcvtss2si_r32_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: XMM) { append(instructions, inst_vcvtss2si_r32_xmm(dst, src)) } +emit_vcvtss2si_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32) { append(instructions, inst_vcvtss2si_r32_m32(dst, src)) } +emit_vcvtss2si_r64_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: XMM) { append(instructions, inst_vcvtss2si_r64_xmm(dst, src)) } +emit_vcvtss2si_r64_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem32) { append(instructions, inst_vcvtss2si_r64_m32(dst, src)) } +inst_vcvtsd2si_r32_xmm :: #force_inline proc "contextless" (dst: GPR32, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VCVTSD2SI, operand_count = 2, ops = {op_gpr32(dst), op_xmm(src), {}, {}} }, 1200) } +inst_vcvtsd2si_r32_m64 :: #force_inline proc "contextless" (dst: GPR32, src: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .VCVTSD2SI, operand_count = 2, ops = {op_gpr32(dst), op_mem(src.mem, 8), {}, {}} }, 1200) } +inst_vcvtsd2si_r64_xmm :: #force_inline proc "contextless" (dst: GPR64, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VCVTSD2SI, operand_count = 2, ops = {op_gpr64(dst), op_xmm(src), {}, {}} }, 1201) } +inst_vcvtsd2si_r64_m64 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .VCVTSD2SI, operand_count = 2, ops = {op_gpr64(dst), op_mem(src.mem, 8), {}, {}} }, 1201) } +emit_vcvtsd2si_r32_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: XMM) { append(instructions, inst_vcvtsd2si_r32_xmm(dst, src)) } +emit_vcvtsd2si_r32_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem64) { append(instructions, inst_vcvtsd2si_r32_m64(dst, src)) } +emit_vcvtsd2si_r64_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: XMM) { append(instructions, inst_vcvtsd2si_r64_xmm(dst, src)) } +emit_vcvtsd2si_r64_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem64) { append(instructions, inst_vcvtsd2si_r64_m64(dst, src)) } +inst_vcvtsi2ss_xmm_xmm_r32 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .VCVTSI2SS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_gpr32(src2), {}} }, 1202) } +inst_vcvtsi2ss_xmm_xmm_m32 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .VCVTSI2SS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 4), {}} }, 1202) } +inst_vcvtsi2ss_xmm_xmm_r64 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .VCVTSI2SS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_gpr64(src2), {}} }, 1203) } +inst_vcvtsi2ss_xmm_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .VCVTSI2SS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 8), {}} }, 1203) } +emit_vcvtsi2ss_xmm_xmm_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: GPR32) { append(instructions, inst_vcvtsi2ss_xmm_xmm_r32(dst, src, src2)) } +emit_vcvtsi2ss_xmm_xmm_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem32) { append(instructions, inst_vcvtsi2ss_xmm_xmm_m32(dst, src, src2)) } +emit_vcvtsi2ss_xmm_xmm_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: GPR64) { append(instructions, inst_vcvtsi2ss_xmm_xmm_r64(dst, src, src2)) } +emit_vcvtsi2ss_xmm_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem64) { append(instructions, inst_vcvtsi2ss_xmm_xmm_m64(dst, src, src2)) } +inst_vcvtsi2sd_xmm_xmm_r32 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .VCVTSI2SD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_gpr32(src2), {}} }, 1204) } +inst_vcvtsi2sd_xmm_xmm_m32 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .VCVTSI2SD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 4), {}} }, 1204) } +inst_vcvtsi2sd_xmm_xmm_r64 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .VCVTSI2SD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_gpr64(src2), {}} }, 1205) } +inst_vcvtsi2sd_xmm_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .VCVTSI2SD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 8), {}} }, 1205) } +emit_vcvtsi2sd_xmm_xmm_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: GPR32) { append(instructions, inst_vcvtsi2sd_xmm_xmm_r32(dst, src, src2)) } +emit_vcvtsi2sd_xmm_xmm_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem32) { append(instructions, inst_vcvtsi2sd_xmm_xmm_m32(dst, src, src2)) } +emit_vcvtsi2sd_xmm_xmm_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: GPR64) { append(instructions, inst_vcvtsi2sd_xmm_xmm_r64(dst, src, src2)) } +emit_vcvtsi2sd_xmm_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem64) { append(instructions, inst_vcvtsi2sd_xmm_xmm_m64(dst, src, src2)) } +inst_vcvttps2dq_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VCVTTPS2DQ, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 1206) } +inst_vcvttps2dq_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VCVTTPS2DQ, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 1206) } +inst_vcvttps2dq_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VCVTTPS2DQ, operand_count = 2, ops = {op_ymm(dst), op_ymm(src), {}, {}} }, 1207) } +inst_vcvttps2dq_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VCVTTPS2DQ, operand_count = 2, ops = {op_ymm(dst), op_mem(src.mem, 32), {}, {}} }, 1207) } +emit_vcvttps2dq_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_vcvttps2dq_xmm_xmm(dst, src)) } +emit_vcvttps2dq_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_vcvttps2dq_xmm_m128(dst, src)) } +emit_vcvttps2dq_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM) { append(instructions, inst_vcvttps2dq_ymm_ymm(dst, src)) } +emit_vcvttps2dq_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem256) { append(instructions, inst_vcvttps2dq_ymm_m256(dst, src)) } +inst_vcvttpd2dq_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VCVTTPD2DQ, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 1208) } +inst_vcvttpd2dq_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VCVTTPD2DQ, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 1208) } +inst_vcvttpd2dq_xmm_ymm :: #force_inline proc "contextless" (dst: XMM, src: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VCVTTPD2DQ, operand_count = 2, ops = {op_xmm(dst), op_ymm(src), {}, {}} }, 1209) } +inst_vcvttpd2dq_xmm_m256 :: #force_inline proc "contextless" (dst: XMM, src: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VCVTTPD2DQ, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 32), {}, {}} }, 1209) } +emit_vcvttpd2dq_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_vcvttpd2dq_xmm_xmm(dst, src)) } +emit_vcvttpd2dq_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_vcvttpd2dq_xmm_m128(dst, src)) } +emit_vcvttpd2dq_xmm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: YMM) { append(instructions, inst_vcvttpd2dq_xmm_ymm(dst, src)) } +emit_vcvttpd2dq_xmm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem256) { append(instructions, inst_vcvttpd2dq_xmm_m256(dst, src)) } +inst_vcvttss2si_r32_xmm :: #force_inline proc "contextless" (dst: GPR32, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VCVTTSS2SI, operand_count = 2, ops = {op_gpr32(dst), op_xmm(src), {}, {}} }, 1210) } +inst_vcvttss2si_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .VCVTTSS2SI, operand_count = 2, ops = {op_gpr32(dst), op_mem(src.mem, 4), {}, {}} }, 1210) } +inst_vcvttss2si_r64_xmm :: #force_inline proc "contextless" (dst: GPR64, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VCVTTSS2SI, operand_count = 2, ops = {op_gpr64(dst), op_xmm(src), {}, {}} }, 1211) } +inst_vcvttss2si_r64_m32 :: #force_inline proc "contextless" (dst: GPR64, src: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .VCVTTSS2SI, operand_count = 2, ops = {op_gpr64(dst), op_mem(src.mem, 4), {}, {}} }, 1211) } +emit_vcvttss2si_r32_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: XMM) { append(instructions, inst_vcvttss2si_r32_xmm(dst, src)) } +emit_vcvttss2si_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32) { append(instructions, inst_vcvttss2si_r32_m32(dst, src)) } +emit_vcvttss2si_r64_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: XMM) { append(instructions, inst_vcvttss2si_r64_xmm(dst, src)) } +emit_vcvttss2si_r64_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem32) { append(instructions, inst_vcvttss2si_r64_m32(dst, src)) } +inst_vcvttsd2si_r32_xmm :: #force_inline proc "contextless" (dst: GPR32, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VCVTTSD2SI, operand_count = 2, ops = {op_gpr32(dst), op_xmm(src), {}, {}} }, 1212) } +inst_vcvttsd2si_r32_m64 :: #force_inline proc "contextless" (dst: GPR32, src: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .VCVTTSD2SI, operand_count = 2, ops = {op_gpr32(dst), op_mem(src.mem, 8), {}, {}} }, 1212) } +inst_vcvttsd2si_r64_xmm :: #force_inline proc "contextless" (dst: GPR64, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VCVTTSD2SI, operand_count = 2, ops = {op_gpr64(dst), op_xmm(src), {}, {}} }, 1213) } +inst_vcvttsd2si_r64_m64 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .VCVTTSD2SI, operand_count = 2, ops = {op_gpr64(dst), op_mem(src.mem, 8), {}, {}} }, 1213) } +emit_vcvttsd2si_r32_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: XMM) { append(instructions, inst_vcvttsd2si_r32_xmm(dst, src)) } +emit_vcvttsd2si_r32_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem64) { append(instructions, inst_vcvttsd2si_r32_m64(dst, src)) } +emit_vcvttsd2si_r64_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: XMM) { append(instructions, inst_vcvttsd2si_r64_xmm(dst, src)) } +emit_vcvttsd2si_r64_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem64) { append(instructions, inst_vcvttsd2si_r64_m64(dst, src)) } +inst_vpaddb_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPADDB, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1214) } +inst_vpaddb_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPADDB, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1214) } +inst_vpaddb_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPADDB, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1215) } +inst_vpaddb_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VPADDB, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1215) } +emit_vpaddb_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vpaddb_xmm_xmm_xmm(dst, src, src2)) } +emit_vpaddb_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vpaddb_xmm_xmm_m128(dst, src, src2)) } +emit_vpaddb_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vpaddb_ymm_ymm_ymm(dst, src, src2)) } +emit_vpaddb_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vpaddb_ymm_ymm_m256(dst, src, src2)) } +inst_vpaddw_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPADDW, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1216) } +inst_vpaddw_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPADDW, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1216) } +inst_vpaddw_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPADDW, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1217) } +inst_vpaddw_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VPADDW, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1217) } +emit_vpaddw_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vpaddw_xmm_xmm_xmm(dst, src, src2)) } +emit_vpaddw_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vpaddw_xmm_xmm_m128(dst, src, src2)) } +emit_vpaddw_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vpaddw_ymm_ymm_ymm(dst, src, src2)) } +emit_vpaddw_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vpaddw_ymm_ymm_m256(dst, src, src2)) } +inst_vpaddd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPADDD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1218) } +inst_vpaddd_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPADDD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1218) } +inst_vpaddd_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPADDD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1219) } +inst_vpaddd_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VPADDD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1219) } +emit_vpaddd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vpaddd_xmm_xmm_xmm(dst, src, src2)) } +emit_vpaddd_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vpaddd_xmm_xmm_m128(dst, src, src2)) } +emit_vpaddd_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vpaddd_ymm_ymm_ymm(dst, src, src2)) } +emit_vpaddd_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vpaddd_ymm_ymm_m256(dst, src, src2)) } +inst_vpaddq_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPADDQ, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1220) } +inst_vpaddq_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPADDQ, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1220) } +inst_vpaddq_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPADDQ, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1221) } +inst_vpaddq_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VPADDQ, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1221) } +emit_vpaddq_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vpaddq_xmm_xmm_xmm(dst, src, src2)) } +emit_vpaddq_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vpaddq_xmm_xmm_m128(dst, src, src2)) } +emit_vpaddq_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vpaddq_ymm_ymm_ymm(dst, src, src2)) } +emit_vpaddq_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vpaddq_ymm_ymm_m256(dst, src, src2)) } +inst_vpsubb_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSUBB, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1222) } +inst_vpsubb_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSUBB, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1222) } +inst_vpsubb_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSUBB, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1223) } +inst_vpsubb_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSUBB, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1223) } +emit_vpsubb_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vpsubb_xmm_xmm_xmm(dst, src, src2)) } +emit_vpsubb_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vpsubb_xmm_xmm_m128(dst, src, src2)) } +emit_vpsubb_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vpsubb_ymm_ymm_ymm(dst, src, src2)) } +emit_vpsubb_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vpsubb_ymm_ymm_m256(dst, src, src2)) } +inst_vpsubw_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSUBW, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1224) } +inst_vpsubw_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSUBW, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1224) } +inst_vpsubw_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSUBW, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1225) } +inst_vpsubw_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSUBW, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1225) } +emit_vpsubw_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vpsubw_xmm_xmm_xmm(dst, src, src2)) } +emit_vpsubw_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vpsubw_xmm_xmm_m128(dst, src, src2)) } +emit_vpsubw_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vpsubw_ymm_ymm_ymm(dst, src, src2)) } +emit_vpsubw_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vpsubw_ymm_ymm_m256(dst, src, src2)) } +inst_vpsubd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSUBD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1226) } +inst_vpsubd_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSUBD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1226) } +inst_vpsubd_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSUBD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1227) } +inst_vpsubd_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSUBD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1227) } +emit_vpsubd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vpsubd_xmm_xmm_xmm(dst, src, src2)) } +emit_vpsubd_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vpsubd_xmm_xmm_m128(dst, src, src2)) } +emit_vpsubd_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vpsubd_ymm_ymm_ymm(dst, src, src2)) } +emit_vpsubd_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vpsubd_ymm_ymm_m256(dst, src, src2)) } +inst_vpsubq_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSUBQ, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1228) } +inst_vpsubq_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSUBQ, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1228) } +inst_vpsubq_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSUBQ, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1229) } +inst_vpsubq_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSUBQ, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1229) } +emit_vpsubq_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vpsubq_xmm_xmm_xmm(dst, src, src2)) } +emit_vpsubq_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vpsubq_xmm_xmm_m128(dst, src, src2)) } +emit_vpsubq_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vpsubq_ymm_ymm_ymm(dst, src, src2)) } +emit_vpsubq_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vpsubq_ymm_ymm_m256(dst, src, src2)) } +inst_vpmullw_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMULLW, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1230) } +inst_vpmullw_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMULLW, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1230) } +inst_vpmullw_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMULLW, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1231) } +inst_vpmullw_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMULLW, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1231) } +emit_vpmullw_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vpmullw_xmm_xmm_xmm(dst, src, src2)) } +emit_vpmullw_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vpmullw_xmm_xmm_m128(dst, src, src2)) } +emit_vpmullw_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vpmullw_ymm_ymm_ymm(dst, src, src2)) } +emit_vpmullw_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vpmullw_ymm_ymm_m256(dst, src, src2)) } +inst_vpmulhw_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMULHW, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1232) } +inst_vpmulhw_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMULHW, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1232) } +inst_vpmulhw_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMULHW, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1233) } +inst_vpmulhw_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMULHW, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1233) } +emit_vpmulhw_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vpmulhw_xmm_xmm_xmm(dst, src, src2)) } +emit_vpmulhw_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vpmulhw_xmm_xmm_m128(dst, src, src2)) } +emit_vpmulhw_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vpmulhw_ymm_ymm_ymm(dst, src, src2)) } +emit_vpmulhw_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vpmulhw_ymm_ymm_m256(dst, src, src2)) } +inst_vpmulhuw_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMULHUW, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1234) } +inst_vpmulhuw_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMULHUW, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1234) } +inst_vpmulhuw_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMULHUW, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1235) } +inst_vpmulhuw_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMULHUW, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1235) } +emit_vpmulhuw_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vpmulhuw_xmm_xmm_xmm(dst, src, src2)) } +emit_vpmulhuw_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vpmulhuw_xmm_xmm_m128(dst, src, src2)) } +emit_vpmulhuw_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vpmulhuw_ymm_ymm_ymm(dst, src, src2)) } +emit_vpmulhuw_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vpmulhuw_ymm_ymm_m256(dst, src, src2)) } +inst_vpmuludq_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMULUDQ, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1236) } +inst_vpmuludq_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMULUDQ, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1236) } +inst_vpmuludq_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMULUDQ, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1237) } +inst_vpmuludq_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMULUDQ, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1237) } +emit_vpmuludq_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vpmuludq_xmm_xmm_xmm(dst, src, src2)) } +emit_vpmuludq_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vpmuludq_xmm_xmm_m128(dst, src, src2)) } +emit_vpmuludq_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vpmuludq_ymm_ymm_ymm(dst, src, src2)) } +emit_vpmuludq_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vpmuludq_ymm_ymm_m256(dst, src, src2)) } +inst_vpmaddwd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMADDWD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1238) } +inst_vpmaddwd_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMADDWD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1238) } +inst_vpmaddwd_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMADDWD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1239) } +inst_vpmaddwd_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMADDWD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1239) } +emit_vpmaddwd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vpmaddwd_xmm_xmm_xmm(dst, src, src2)) } +emit_vpmaddwd_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vpmaddwd_xmm_xmm_m128(dst, src, src2)) } +emit_vpmaddwd_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vpmaddwd_ymm_ymm_ymm(dst, src, src2)) } +emit_vpmaddwd_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vpmaddwd_ymm_ymm_m256(dst, src, src2)) } +inst_vpand_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPAND, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1240) } +inst_vpand_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPAND, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1240) } +inst_vpand_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPAND, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1241) } +inst_vpand_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VPAND, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1241) } +emit_vpand_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vpand_xmm_xmm_xmm(dst, src, src2)) } +emit_vpand_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vpand_xmm_xmm_m128(dst, src, src2)) } +emit_vpand_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vpand_ymm_ymm_ymm(dst, src, src2)) } +emit_vpand_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vpand_ymm_ymm_m256(dst, src, src2)) } +inst_vpandn_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPANDN, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1242) } +inst_vpandn_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPANDN, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1242) } +inst_vpandn_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPANDN, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1243) } +inst_vpandn_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VPANDN, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1243) } +emit_vpandn_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vpandn_xmm_xmm_xmm(dst, src, src2)) } +emit_vpandn_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vpandn_xmm_xmm_m128(dst, src, src2)) } +emit_vpandn_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vpandn_ymm_ymm_ymm(dst, src, src2)) } +emit_vpandn_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vpandn_ymm_ymm_m256(dst, src, src2)) } +inst_vpor_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPOR, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1244) } +inst_vpor_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPOR, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1244) } +inst_vpor_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPOR, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1245) } +inst_vpor_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VPOR, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1245) } +emit_vpor_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vpor_xmm_xmm_xmm(dst, src, src2)) } +emit_vpor_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vpor_xmm_xmm_m128(dst, src, src2)) } +emit_vpor_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vpor_ymm_ymm_ymm(dst, src, src2)) } +emit_vpor_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vpor_ymm_ymm_m256(dst, src, src2)) } +inst_vpxor_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPXOR, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1246) } +inst_vpxor_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPXOR, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1246) } +inst_vpxor_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPXOR, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1247) } +inst_vpxor_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VPXOR, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1247) } +emit_vpxor_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vpxor_xmm_xmm_xmm(dst, src, src2)) } +emit_vpxor_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vpxor_xmm_xmm_m128(dst, src, src2)) } +emit_vpxor_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vpxor_ymm_ymm_ymm(dst, src, src2)) } +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_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), {}} } } +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)) } +emit_vpsllw_ymm_ymm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: XMM) { append(instructions, inst_vpsllw_ymm_ymm_xmm(dst, src, src2)) } +emit_vpsllw_ymm_ymm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem128) { append(instructions, inst_vpsllw_ymm_ymm_m128(dst, src, src2)) } +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_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), {}} } } +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)) } +emit_vpslld_ymm_ymm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: XMM) { append(instructions, inst_vpslld_ymm_ymm_xmm(dst, src, src2)) } +emit_vpslld_ymm_ymm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem128) { append(instructions, inst_vpslld_ymm_ymm_m128(dst, src, src2)) } +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_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), {}} } } +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)) } +emit_vpsllq_ymm_ymm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: XMM) { append(instructions, inst_vpsllq_ymm_ymm_xmm(dst, src, src2)) } +emit_vpsllq_ymm_ymm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem128) { append(instructions, inst_vpsllq_ymm_ymm_m128(dst, src, src2)) } +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_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), {}} } } +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)) } +emit_vpsrlw_ymm_ymm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: XMM) { append(instructions, inst_vpsrlw_ymm_ymm_xmm(dst, src, src2)) } +emit_vpsrlw_ymm_ymm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem128) { append(instructions, inst_vpsrlw_ymm_ymm_m128(dst, src, src2)) } +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_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), {}} } } +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)) } +emit_vpsrld_ymm_ymm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: XMM) { append(instructions, inst_vpsrld_ymm_ymm_xmm(dst, src, src2)) } +emit_vpsrld_ymm_ymm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem128) { append(instructions, inst_vpsrld_ymm_ymm_m128(dst, src, src2)) } +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_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), {}} } } +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)) } +emit_vpsrlq_ymm_ymm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: XMM) { append(instructions, inst_vpsrlq_ymm_ymm_xmm(dst, src, src2)) } +emit_vpsrlq_ymm_ymm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem128) { append(instructions, inst_vpsrlq_ymm_ymm_m128(dst, src, src2)) } +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_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), {}} } } +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)) } +emit_vpsraw_ymm_ymm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: XMM) { append(instructions, inst_vpsraw_ymm_ymm_xmm(dst, src, src2)) } +emit_vpsraw_ymm_ymm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem128) { append(instructions, inst_vpsraw_ymm_ymm_m128(dst, src, src2)) } +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_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), {}} } } +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)) } +emit_vpsrad_ymm_ymm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: XMM) { append(instructions, inst_vpsrad_ymm_ymm_xmm(dst, src, src2)) } +emit_vpsrad_ymm_ymm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem128) { append(instructions, inst_vpsrad_ymm_ymm_m128(dst, src, src2)) } +emit_vpsrad_ymm_ymm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, imm: i8) { append(instructions, inst_vpsrad_ymm_ymm_imm8(dst, src, imm)) } +inst_vpcmpeqb_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPCMPEQB, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1280) } +inst_vpcmpeqb_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPCMPEQB, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1280) } +inst_vpcmpeqb_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPCMPEQB, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1281) } +inst_vpcmpeqb_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VPCMPEQB, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1281) } +emit_vpcmpeqb_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vpcmpeqb_xmm_xmm_xmm(dst, src, src2)) } +emit_vpcmpeqb_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vpcmpeqb_xmm_xmm_m128(dst, src, src2)) } +emit_vpcmpeqb_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vpcmpeqb_ymm_ymm_ymm(dst, src, src2)) } +emit_vpcmpeqb_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vpcmpeqb_ymm_ymm_m256(dst, src, src2)) } +inst_vpcmpeqw_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPCMPEQW, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1282) } +inst_vpcmpeqw_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPCMPEQW, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1282) } +inst_vpcmpeqw_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPCMPEQW, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1283) } +inst_vpcmpeqw_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VPCMPEQW, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1283) } +emit_vpcmpeqw_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vpcmpeqw_xmm_xmm_xmm(dst, src, src2)) } +emit_vpcmpeqw_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vpcmpeqw_xmm_xmm_m128(dst, src, src2)) } +emit_vpcmpeqw_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vpcmpeqw_ymm_ymm_ymm(dst, src, src2)) } +emit_vpcmpeqw_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vpcmpeqw_ymm_ymm_m256(dst, src, src2)) } +inst_vpcmpeqd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPCMPEQD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1284) } +inst_vpcmpeqd_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPCMPEQD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1284) } +inst_vpcmpeqd_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPCMPEQD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1285) } +inst_vpcmpeqd_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VPCMPEQD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1285) } +emit_vpcmpeqd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vpcmpeqd_xmm_xmm_xmm(dst, src, src2)) } +emit_vpcmpeqd_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vpcmpeqd_xmm_xmm_m128(dst, src, src2)) } +emit_vpcmpeqd_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vpcmpeqd_ymm_ymm_ymm(dst, src, src2)) } +emit_vpcmpeqd_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vpcmpeqd_ymm_ymm_m256(dst, src, src2)) } +inst_vpcmpeqq_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPCMPEQQ, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1286) } +inst_vpcmpeqq_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPCMPEQQ, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1286) } +inst_vpcmpeqq_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPCMPEQQ, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1287) } +inst_vpcmpeqq_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VPCMPEQQ, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1287) } +emit_vpcmpeqq_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vpcmpeqq_xmm_xmm_xmm(dst, src, src2)) } +emit_vpcmpeqq_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vpcmpeqq_xmm_xmm_m128(dst, src, src2)) } +emit_vpcmpeqq_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vpcmpeqq_ymm_ymm_ymm(dst, src, src2)) } +emit_vpcmpeqq_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vpcmpeqq_ymm_ymm_m256(dst, src, src2)) } +inst_vpcmpgtb_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPCMPGTB, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1288) } +inst_vpcmpgtb_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPCMPGTB, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1288) } +inst_vpcmpgtb_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPCMPGTB, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1289) } +inst_vpcmpgtb_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VPCMPGTB, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1289) } +emit_vpcmpgtb_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vpcmpgtb_xmm_xmm_xmm(dst, src, src2)) } +emit_vpcmpgtb_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vpcmpgtb_xmm_xmm_m128(dst, src, src2)) } +emit_vpcmpgtb_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vpcmpgtb_ymm_ymm_ymm(dst, src, src2)) } +emit_vpcmpgtb_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vpcmpgtb_ymm_ymm_m256(dst, src, src2)) } +inst_vpcmpgtw_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPCMPGTW, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1290) } +inst_vpcmpgtw_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPCMPGTW, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1290) } +inst_vpcmpgtw_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPCMPGTW, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1291) } +inst_vpcmpgtw_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VPCMPGTW, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1291) } +emit_vpcmpgtw_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vpcmpgtw_xmm_xmm_xmm(dst, src, src2)) } +emit_vpcmpgtw_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vpcmpgtw_xmm_xmm_m128(dst, src, src2)) } +emit_vpcmpgtw_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vpcmpgtw_ymm_ymm_ymm(dst, src, src2)) } +emit_vpcmpgtw_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vpcmpgtw_ymm_ymm_m256(dst, src, src2)) } +inst_vpcmpgtd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPCMPGTD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1292) } +inst_vpcmpgtd_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPCMPGTD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1292) } +inst_vpcmpgtd_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPCMPGTD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1293) } +inst_vpcmpgtd_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VPCMPGTD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1293) } +emit_vpcmpgtd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vpcmpgtd_xmm_xmm_xmm(dst, src, src2)) } +emit_vpcmpgtd_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vpcmpgtd_xmm_xmm_m128(dst, src, src2)) } +emit_vpcmpgtd_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vpcmpgtd_ymm_ymm_ymm(dst, src, src2)) } +emit_vpcmpgtd_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vpcmpgtd_ymm_ymm_m256(dst, src, src2)) } +inst_vpcmpgtq_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPCMPGTQ, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1294) } +inst_vpcmpgtq_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPCMPGTQ, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1294) } +inst_vpcmpgtq_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPCMPGTQ, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1295) } +inst_vpcmpgtq_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VPCMPGTQ, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1295) } +emit_vpcmpgtq_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vpcmpgtq_xmm_xmm_xmm(dst, src, src2)) } +emit_vpcmpgtq_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vpcmpgtq_xmm_xmm_m128(dst, src, src2)) } +emit_vpcmpgtq_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vpcmpgtq_ymm_ymm_ymm(dst, src, src2)) } +emit_vpcmpgtq_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vpcmpgtq_ymm_ymm_m256(dst, src, src2)) } +inst_vpacksswb_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPACKSSWB, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1296) } +inst_vpacksswb_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPACKSSWB, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1296) } +inst_vpacksswb_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPACKSSWB, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1297) } +inst_vpacksswb_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VPACKSSWB, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1297) } +emit_vpacksswb_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vpacksswb_xmm_xmm_xmm(dst, src, src2)) } +emit_vpacksswb_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vpacksswb_xmm_xmm_m128(dst, src, src2)) } +emit_vpacksswb_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vpacksswb_ymm_ymm_ymm(dst, src, src2)) } +emit_vpacksswb_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vpacksswb_ymm_ymm_m256(dst, src, src2)) } +inst_vpackssdw_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPACKSSDW, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1298) } +inst_vpackssdw_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPACKSSDW, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1298) } +inst_vpackssdw_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPACKSSDW, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1299) } +inst_vpackssdw_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VPACKSSDW, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1299) } +emit_vpackssdw_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vpackssdw_xmm_xmm_xmm(dst, src, src2)) } +emit_vpackssdw_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vpackssdw_xmm_xmm_m128(dst, src, src2)) } +emit_vpackssdw_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vpackssdw_ymm_ymm_ymm(dst, src, src2)) } +emit_vpackssdw_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vpackssdw_ymm_ymm_m256(dst, src, src2)) } +inst_vpackuswb_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPACKUSWB, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1300) } +inst_vpackuswb_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPACKUSWB, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1300) } +inst_vpackuswb_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPACKUSWB, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1301) } +inst_vpackuswb_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VPACKUSWB, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1301) } +emit_vpackuswb_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vpackuswb_xmm_xmm_xmm(dst, src, src2)) } +emit_vpackuswb_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vpackuswb_xmm_xmm_m128(dst, src, src2)) } +emit_vpackuswb_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vpackuswb_ymm_ymm_ymm(dst, src, src2)) } +emit_vpackuswb_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vpackuswb_ymm_ymm_m256(dst, src, src2)) } +inst_vpackusdw_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPACKUSDW, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1302) } +inst_vpackusdw_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPACKUSDW, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1302) } +inst_vpackusdw_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPACKUSDW, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1303) } +inst_vpackusdw_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VPACKUSDW, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1303) } +emit_vpackusdw_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vpackusdw_xmm_xmm_xmm(dst, src, src2)) } +emit_vpackusdw_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vpackusdw_xmm_xmm_m128(dst, src, src2)) } +emit_vpackusdw_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vpackusdw_ymm_ymm_ymm(dst, src, src2)) } +emit_vpackusdw_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vpackusdw_ymm_ymm_m256(dst, src, src2)) } +inst_vpunpcklbw_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPUNPCKLBW, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1304) } +inst_vpunpcklbw_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPUNPCKLBW, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1304) } +inst_vpunpcklbw_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPUNPCKLBW, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1305) } +inst_vpunpcklbw_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VPUNPCKLBW, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1305) } +emit_vpunpcklbw_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vpunpcklbw_xmm_xmm_xmm(dst, src, src2)) } +emit_vpunpcklbw_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vpunpcklbw_xmm_xmm_m128(dst, src, src2)) } +emit_vpunpcklbw_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vpunpcklbw_ymm_ymm_ymm(dst, src, src2)) } +emit_vpunpcklbw_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vpunpcklbw_ymm_ymm_m256(dst, src, src2)) } +inst_vpunpcklwd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPUNPCKLWD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1306) } +inst_vpunpcklwd_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPUNPCKLWD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1306) } +inst_vpunpcklwd_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPUNPCKLWD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1307) } +inst_vpunpcklwd_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VPUNPCKLWD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1307) } +emit_vpunpcklwd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vpunpcklwd_xmm_xmm_xmm(dst, src, src2)) } +emit_vpunpcklwd_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vpunpcklwd_xmm_xmm_m128(dst, src, src2)) } +emit_vpunpcklwd_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vpunpcklwd_ymm_ymm_ymm(dst, src, src2)) } +emit_vpunpcklwd_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vpunpcklwd_ymm_ymm_m256(dst, src, src2)) } +inst_vpunpckldq_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPUNPCKLDQ, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1308) } +inst_vpunpckldq_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPUNPCKLDQ, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1308) } +inst_vpunpckldq_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPUNPCKLDQ, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1309) } +inst_vpunpckldq_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VPUNPCKLDQ, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1309) } +emit_vpunpckldq_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vpunpckldq_xmm_xmm_xmm(dst, src, src2)) } +emit_vpunpckldq_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vpunpckldq_xmm_xmm_m128(dst, src, src2)) } +emit_vpunpckldq_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vpunpckldq_ymm_ymm_ymm(dst, src, src2)) } +emit_vpunpckldq_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vpunpckldq_ymm_ymm_m256(dst, src, src2)) } +inst_vpunpcklqdq_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPUNPCKLQDQ, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1310) } +inst_vpunpcklqdq_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPUNPCKLQDQ, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1310) } +inst_vpunpcklqdq_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPUNPCKLQDQ, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1311) } +inst_vpunpcklqdq_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VPUNPCKLQDQ, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1311) } +emit_vpunpcklqdq_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vpunpcklqdq_xmm_xmm_xmm(dst, src, src2)) } +emit_vpunpcklqdq_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vpunpcklqdq_xmm_xmm_m128(dst, src, src2)) } +emit_vpunpcklqdq_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vpunpcklqdq_ymm_ymm_ymm(dst, src, src2)) } +emit_vpunpcklqdq_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vpunpcklqdq_ymm_ymm_m256(dst, src, src2)) } +inst_vpunpckhbw_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPUNPCKHBW, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1312) } +inst_vpunpckhbw_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPUNPCKHBW, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1312) } +inst_vpunpckhbw_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPUNPCKHBW, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1313) } +inst_vpunpckhbw_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VPUNPCKHBW, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1313) } +emit_vpunpckhbw_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vpunpckhbw_xmm_xmm_xmm(dst, src, src2)) } +emit_vpunpckhbw_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vpunpckhbw_xmm_xmm_m128(dst, src, src2)) } +emit_vpunpckhbw_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vpunpckhbw_ymm_ymm_ymm(dst, src, src2)) } +emit_vpunpckhbw_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vpunpckhbw_ymm_ymm_m256(dst, src, src2)) } +inst_vpunpckhwd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPUNPCKHWD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1314) } +inst_vpunpckhwd_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPUNPCKHWD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1314) } +inst_vpunpckhwd_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPUNPCKHWD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1315) } +inst_vpunpckhwd_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VPUNPCKHWD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1315) } +emit_vpunpckhwd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vpunpckhwd_xmm_xmm_xmm(dst, src, src2)) } +emit_vpunpckhwd_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vpunpckhwd_xmm_xmm_m128(dst, src, src2)) } +emit_vpunpckhwd_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vpunpckhwd_ymm_ymm_ymm(dst, src, src2)) } +emit_vpunpckhwd_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vpunpckhwd_ymm_ymm_m256(dst, src, src2)) } +inst_vpunpckhdq_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPUNPCKHDQ, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1316) } +inst_vpunpckhdq_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPUNPCKHDQ, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1316) } +inst_vpunpckhdq_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPUNPCKHDQ, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1317) } +inst_vpunpckhdq_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VPUNPCKHDQ, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1317) } +emit_vpunpckhdq_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vpunpckhdq_xmm_xmm_xmm(dst, src, src2)) } +emit_vpunpckhdq_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vpunpckhdq_xmm_xmm_m128(dst, src, src2)) } +emit_vpunpckhdq_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vpunpckhdq_ymm_ymm_ymm(dst, src, src2)) } +emit_vpunpckhdq_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vpunpckhdq_ymm_ymm_m256(dst, src, src2)) } +inst_vpunpckhqdq_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPUNPCKHQDQ, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1318) } +inst_vpunpckhqdq_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPUNPCKHQDQ, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1318) } +inst_vpunpckhqdq_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPUNPCKHQDQ, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1319) } +inst_vpunpckhqdq_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VPUNPCKHQDQ, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1319) } +emit_vpunpckhqdq_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vpunpckhqdq_xmm_xmm_xmm(dst, src, src2)) } +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), {}} } } +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), {}} } } +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), {}} } } +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), {}} } } +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), {}} } } +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), {}} } } +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), {}} } } +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)} } } 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)) } @@ -4355,138 +4355,138 @@ inst_vpinsrq_xmm_xmm_r64_imm8 :: #force_inline proc "contextless" (dst: XM 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)} } } 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 inst_r_r(.VPMOVMSKB, Register(dst), Register(src)) } -inst_vpmovmskb_r32_ymm :: #force_inline proc "contextless" (dst: GPR32, src: YMM) -> Instruction { return inst_r_r(.VPMOVMSKB, Register(dst), Register(src)) } -emit_vpmovmskb_r32_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: XMM) { emit_rr(instructions, .VPMOVMSKB, Register(dst), Register(src)) } -emit_vpmovmskb_r32_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: YMM) { emit_rr(instructions, .VPMOVMSKB, Register(dst), Register(src)) } -inst_vptest_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.VPTEST, Register(dst), Register(src)) } -inst_vptest_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.VPTEST, Register(dst), src.mem, 16) } -inst_vptest_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM) -> Instruction { return inst_r_r(.VPTEST, Register(dst), Register(src)) } -inst_vptest_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: Mem256) -> Instruction { return inst_r_m(.VPTEST, Register(dst), src.mem, 32) } -emit_vptest_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .VPTEST, Register(dst), Register(src)) } -emit_vptest_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .VPTEST, Register(dst), src.mem, 16) } -emit_vptest_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM) { emit_rr(instructions, .VPTEST, Register(dst), Register(src)) } -emit_vptest_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem256) { emit_rm(instructions, .VPTEST, Register(dst), src.mem, 32) } -inst_vpshufb_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VPSHUFB, Register(dst), Register(src), Register(src2)) } -inst_vpshufb_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VPSHUFB, Register(dst), Register(src), src2.mem, 16) } -inst_vpshufb_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VPSHUFB, Register(dst), Register(src), Register(src2)) } -inst_vpshufb_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VPSHUFB, Register(dst), Register(src), src2.mem, 32) } -emit_vpshufb_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VPSHUFB, Register(dst), Register(src), Register(src2)) } -emit_vpshufb_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VPSHUFB, Register(dst), Register(src), src2.mem, 16) } -emit_vpshufb_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VPSHUFB, Register(dst), Register(src), Register(src2)) } -emit_vpshufb_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VPSHUFB, Register(dst), Register(src), src2.mem, 32) } -inst_vphaddw_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VPHADDW, Register(dst), Register(src), Register(src2)) } -inst_vphaddw_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VPHADDW, Register(dst), Register(src), src2.mem, 16) } -inst_vphaddw_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VPHADDW, Register(dst), Register(src), Register(src2)) } -inst_vphaddw_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VPHADDW, Register(dst), Register(src), src2.mem, 32) } -emit_vphaddw_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VPHADDW, Register(dst), Register(src), Register(src2)) } -emit_vphaddw_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VPHADDW, Register(dst), Register(src), src2.mem, 16) } -emit_vphaddw_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VPHADDW, Register(dst), Register(src), Register(src2)) } -emit_vphaddw_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VPHADDW, Register(dst), Register(src), src2.mem, 32) } -inst_vphaddd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VPHADDD, Register(dst), Register(src), Register(src2)) } -inst_vphaddd_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VPHADDD, Register(dst), Register(src), src2.mem, 16) } -inst_vphaddd_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VPHADDD, Register(dst), Register(src), Register(src2)) } -inst_vphaddd_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VPHADDD, Register(dst), Register(src), src2.mem, 32) } -emit_vphaddd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VPHADDD, Register(dst), Register(src), Register(src2)) } -emit_vphaddd_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VPHADDD, Register(dst), Register(src), src2.mem, 16) } -emit_vphaddd_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VPHADDD, Register(dst), Register(src), Register(src2)) } -emit_vphaddd_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VPHADDD, Register(dst), Register(src), src2.mem, 32) } -inst_vphaddsw_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VPHADDSW, Register(dst), Register(src), Register(src2)) } -inst_vphaddsw_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VPHADDSW, Register(dst), Register(src), src2.mem, 16) } -inst_vphaddsw_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VPHADDSW, Register(dst), Register(src), Register(src2)) } -inst_vphaddsw_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VPHADDSW, Register(dst), Register(src), src2.mem, 32) } -emit_vphaddsw_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VPHADDSW, Register(dst), Register(src), Register(src2)) } -emit_vphaddsw_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VPHADDSW, Register(dst), Register(src), src2.mem, 16) } -emit_vphaddsw_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VPHADDSW, Register(dst), Register(src), Register(src2)) } -emit_vphaddsw_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VPHADDSW, Register(dst), Register(src), src2.mem, 32) } -inst_vphsubw_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VPHSUBW, Register(dst), Register(src), Register(src2)) } -inst_vphsubw_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VPHSUBW, Register(dst), Register(src), src2.mem, 16) } -inst_vphsubw_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VPHSUBW, Register(dst), Register(src), Register(src2)) } -inst_vphsubw_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VPHSUBW, Register(dst), Register(src), src2.mem, 32) } -emit_vphsubw_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VPHSUBW, Register(dst), Register(src), Register(src2)) } -emit_vphsubw_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VPHSUBW, Register(dst), Register(src), src2.mem, 16) } -emit_vphsubw_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VPHSUBW, Register(dst), Register(src), Register(src2)) } -emit_vphsubw_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VPHSUBW, Register(dst), Register(src), src2.mem, 32) } -inst_vphsubd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VPHSUBD, Register(dst), Register(src), Register(src2)) } -inst_vphsubd_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VPHSUBD, Register(dst), Register(src), src2.mem, 16) } -inst_vphsubd_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VPHSUBD, Register(dst), Register(src), Register(src2)) } -inst_vphsubd_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VPHSUBD, Register(dst), Register(src), src2.mem, 32) } -emit_vphsubd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VPHSUBD, Register(dst), Register(src), Register(src2)) } -emit_vphsubd_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VPHSUBD, Register(dst), Register(src), src2.mem, 16) } -emit_vphsubd_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VPHSUBD, Register(dst), Register(src), Register(src2)) } -emit_vphsubd_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VPHSUBD, Register(dst), Register(src), src2.mem, 32) } -inst_vphsubsw_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VPHSUBSW, Register(dst), Register(src), Register(src2)) } -inst_vphsubsw_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VPHSUBSW, Register(dst), Register(src), src2.mem, 16) } -inst_vphsubsw_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VPHSUBSW, Register(dst), Register(src), Register(src2)) } -inst_vphsubsw_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VPHSUBSW, Register(dst), Register(src), src2.mem, 32) } -emit_vphsubsw_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VPHSUBSW, Register(dst), Register(src), Register(src2)) } -emit_vphsubsw_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VPHSUBSW, Register(dst), Register(src), src2.mem, 16) } -emit_vphsubsw_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VPHSUBSW, Register(dst), Register(src), Register(src2)) } -emit_vphsubsw_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VPHSUBSW, Register(dst), Register(src), src2.mem, 32) } -inst_vpmaddubsw_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VPMADDUBSW, Register(dst), Register(src), Register(src2)) } -inst_vpmaddubsw_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VPMADDUBSW, Register(dst), Register(src), src2.mem, 16) } -inst_vpmaddubsw_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VPMADDUBSW, Register(dst), Register(src), Register(src2)) } -inst_vpmaddubsw_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VPMADDUBSW, Register(dst), Register(src), src2.mem, 32) } -emit_vpmaddubsw_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VPMADDUBSW, Register(dst), Register(src), Register(src2)) } -emit_vpmaddubsw_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VPMADDUBSW, Register(dst), Register(src), src2.mem, 16) } -emit_vpmaddubsw_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VPMADDUBSW, Register(dst), Register(src), Register(src2)) } -emit_vpmaddubsw_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VPMADDUBSW, Register(dst), Register(src), src2.mem, 32) } -inst_vpmulhrsw_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VPMULHRSW, Register(dst), Register(src), Register(src2)) } -inst_vpmulhrsw_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VPMULHRSW, Register(dst), Register(src), src2.mem, 16) } -inst_vpmulhrsw_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VPMULHRSW, Register(dst), Register(src), Register(src2)) } -inst_vpmulhrsw_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VPMULHRSW, Register(dst), Register(src), src2.mem, 32) } -emit_vpmulhrsw_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VPMULHRSW, Register(dst), Register(src), Register(src2)) } -emit_vpmulhrsw_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VPMULHRSW, Register(dst), Register(src), src2.mem, 16) } -emit_vpmulhrsw_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VPMULHRSW, Register(dst), Register(src), Register(src2)) } -emit_vpmulhrsw_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VPMULHRSW, Register(dst), Register(src), src2.mem, 32) } -inst_vpsignb_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VPSIGNB, Register(dst), Register(src), Register(src2)) } -inst_vpsignb_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VPSIGNB, Register(dst), Register(src), src2.mem, 16) } -inst_vpsignb_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VPSIGNB, Register(dst), Register(src), Register(src2)) } -inst_vpsignb_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VPSIGNB, Register(dst), Register(src), src2.mem, 32) } -emit_vpsignb_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VPSIGNB, Register(dst), Register(src), Register(src2)) } -emit_vpsignb_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VPSIGNB, Register(dst), Register(src), src2.mem, 16) } -emit_vpsignb_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VPSIGNB, Register(dst), Register(src), Register(src2)) } -emit_vpsignb_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VPSIGNB, Register(dst), Register(src), src2.mem, 32) } -inst_vpsignw_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VPSIGNW, Register(dst), Register(src), Register(src2)) } -inst_vpsignw_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VPSIGNW, Register(dst), Register(src), src2.mem, 16) } -inst_vpsignw_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VPSIGNW, Register(dst), Register(src), Register(src2)) } -inst_vpsignw_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VPSIGNW, Register(dst), Register(src), src2.mem, 32) } -emit_vpsignw_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VPSIGNW, Register(dst), Register(src), Register(src2)) } -emit_vpsignw_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VPSIGNW, Register(dst), Register(src), src2.mem, 16) } -emit_vpsignw_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VPSIGNW, Register(dst), Register(src), Register(src2)) } -emit_vpsignw_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VPSIGNW, Register(dst), Register(src), src2.mem, 32) } -inst_vpsignd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VPSIGND, Register(dst), Register(src), Register(src2)) } -inst_vpsignd_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VPSIGND, Register(dst), Register(src), src2.mem, 16) } -inst_vpsignd_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VPSIGND, Register(dst), Register(src), Register(src2)) } -inst_vpsignd_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VPSIGND, Register(dst), Register(src), src2.mem, 32) } -emit_vpsignd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VPSIGND, Register(dst), Register(src), Register(src2)) } -emit_vpsignd_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VPSIGND, Register(dst), Register(src), src2.mem, 16) } -emit_vpsignd_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VPSIGND, Register(dst), Register(src), Register(src2)) } -emit_vpsignd_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VPSIGND, Register(dst), Register(src), src2.mem, 32) } -inst_vpabsb_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.VPABSB, Register(dst), Register(src)) } -inst_vpabsb_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.VPABSB, Register(dst), src.mem, 16) } -inst_vpabsb_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM) -> Instruction { return inst_r_r(.VPABSB, Register(dst), Register(src)) } -inst_vpabsb_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: Mem256) -> Instruction { return inst_r_m(.VPABSB, Register(dst), src.mem, 32) } -emit_vpabsb_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .VPABSB, Register(dst), Register(src)) } -emit_vpabsb_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .VPABSB, Register(dst), src.mem, 16) } -emit_vpabsb_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM) { emit_rr(instructions, .VPABSB, Register(dst), Register(src)) } -emit_vpabsb_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem256) { emit_rm(instructions, .VPABSB, Register(dst), src.mem, 32) } -inst_vpabsw_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.VPABSW, Register(dst), Register(src)) } -inst_vpabsw_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.VPABSW, Register(dst), src.mem, 16) } -inst_vpabsw_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM) -> Instruction { return inst_r_r(.VPABSW, Register(dst), Register(src)) } -inst_vpabsw_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: Mem256) -> Instruction { return inst_r_m(.VPABSW, Register(dst), src.mem, 32) } -emit_vpabsw_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .VPABSW, Register(dst), Register(src)) } -emit_vpabsw_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .VPABSW, Register(dst), src.mem, 16) } -emit_vpabsw_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM) { emit_rr(instructions, .VPABSW, Register(dst), Register(src)) } -emit_vpabsw_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem256) { emit_rm(instructions, .VPABSW, Register(dst), src.mem, 32) } -inst_vpabsd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.VPABSD, Register(dst), Register(src)) } -inst_vpabsd_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.VPABSD, Register(dst), src.mem, 16) } -inst_vpabsd_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM) -> Instruction { return inst_r_r(.VPABSD, Register(dst), Register(src)) } -inst_vpabsd_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: Mem256) -> Instruction { return inst_r_m(.VPABSD, Register(dst), src.mem, 32) } -emit_vpabsd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .VPABSD, Register(dst), Register(src)) } -emit_vpabsd_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .VPABSD, Register(dst), src.mem, 16) } -emit_vpabsd_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM) { emit_rr(instructions, .VPABSD, Register(dst), Register(src)) } -emit_vpabsd_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem256) { emit_rm(instructions, .VPABSD, Register(dst), src.mem, 32) } +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) } +inst_vpmovmskb_r32_ymm :: #force_inline proc "contextless" (dst: GPR32, src: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVMSKB, operand_count = 2, ops = {op_gpr32(dst), op_ymm(src), {}, {}} }, 1336) } +emit_vpmovmskb_r32_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: XMM) { append(instructions, inst_vpmovmskb_r32_xmm(dst, src)) } +emit_vpmovmskb_r32_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: YMM) { append(instructions, inst_vpmovmskb_r32_ymm(dst, src)) } +inst_vptest_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPTEST, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 1337) } +inst_vptest_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPTEST, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 1337) } +inst_vptest_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPTEST, operand_count = 2, ops = {op_ymm(dst), op_ymm(src), {}, {}} }, 1338) } +inst_vptest_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VPTEST, operand_count = 2, ops = {op_ymm(dst), op_mem(src.mem, 32), {}, {}} }, 1338) } +emit_vptest_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_vptest_xmm_xmm(dst, src)) } +emit_vptest_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_vptest_xmm_m128(dst, src)) } +emit_vptest_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM) { append(instructions, inst_vptest_ymm_ymm(dst, src)) } +emit_vptest_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem256) { append(instructions, inst_vptest_ymm_m256(dst, src)) } +inst_vpshufb_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSHUFB, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1339) } +inst_vpshufb_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSHUFB, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1339) } +inst_vpshufb_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSHUFB, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1340) } +inst_vpshufb_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSHUFB, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1340) } +emit_vpshufb_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vpshufb_xmm_xmm_xmm(dst, src, src2)) } +emit_vpshufb_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vpshufb_xmm_xmm_m128(dst, src, src2)) } +emit_vpshufb_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vpshufb_ymm_ymm_ymm(dst, src, src2)) } +emit_vpshufb_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vpshufb_ymm_ymm_m256(dst, src, src2)) } +inst_vphaddw_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPHADDW, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1341) } +inst_vphaddw_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPHADDW, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1341) } +inst_vphaddw_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPHADDW, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1342) } +inst_vphaddw_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VPHADDW, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1342) } +emit_vphaddw_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vphaddw_xmm_xmm_xmm(dst, src, src2)) } +emit_vphaddw_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vphaddw_xmm_xmm_m128(dst, src, src2)) } +emit_vphaddw_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vphaddw_ymm_ymm_ymm(dst, src, src2)) } +emit_vphaddw_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vphaddw_ymm_ymm_m256(dst, src, src2)) } +inst_vphaddd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPHADDD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1343) } +inst_vphaddd_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPHADDD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1343) } +inst_vphaddd_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPHADDD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1344) } +inst_vphaddd_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VPHADDD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1344) } +emit_vphaddd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vphaddd_xmm_xmm_xmm(dst, src, src2)) } +emit_vphaddd_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vphaddd_xmm_xmm_m128(dst, src, src2)) } +emit_vphaddd_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vphaddd_ymm_ymm_ymm(dst, src, src2)) } +emit_vphaddd_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vphaddd_ymm_ymm_m256(dst, src, src2)) } +inst_vphaddsw_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPHADDSW, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1345) } +inst_vphaddsw_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPHADDSW, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1345) } +inst_vphaddsw_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPHADDSW, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1346) } +inst_vphaddsw_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VPHADDSW, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1346) } +emit_vphaddsw_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vphaddsw_xmm_xmm_xmm(dst, src, src2)) } +emit_vphaddsw_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vphaddsw_xmm_xmm_m128(dst, src, src2)) } +emit_vphaddsw_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vphaddsw_ymm_ymm_ymm(dst, src, src2)) } +emit_vphaddsw_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vphaddsw_ymm_ymm_m256(dst, src, src2)) } +inst_vphsubw_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPHSUBW, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1347) } +inst_vphsubw_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPHSUBW, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1347) } +inst_vphsubw_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPHSUBW, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1348) } +inst_vphsubw_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VPHSUBW, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1348) } +emit_vphsubw_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vphsubw_xmm_xmm_xmm(dst, src, src2)) } +emit_vphsubw_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vphsubw_xmm_xmm_m128(dst, src, src2)) } +emit_vphsubw_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vphsubw_ymm_ymm_ymm(dst, src, src2)) } +emit_vphsubw_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vphsubw_ymm_ymm_m256(dst, src, src2)) } +inst_vphsubd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPHSUBD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1349) } +inst_vphsubd_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPHSUBD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1349) } +inst_vphsubd_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPHSUBD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1350) } +inst_vphsubd_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VPHSUBD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1350) } +emit_vphsubd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vphsubd_xmm_xmm_xmm(dst, src, src2)) } +emit_vphsubd_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vphsubd_xmm_xmm_m128(dst, src, src2)) } +emit_vphsubd_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vphsubd_ymm_ymm_ymm(dst, src, src2)) } +emit_vphsubd_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vphsubd_ymm_ymm_m256(dst, src, src2)) } +inst_vphsubsw_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPHSUBSW, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1351) } +inst_vphsubsw_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPHSUBSW, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1351) } +inst_vphsubsw_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPHSUBSW, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1352) } +inst_vphsubsw_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VPHSUBSW, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1352) } +emit_vphsubsw_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vphsubsw_xmm_xmm_xmm(dst, src, src2)) } +emit_vphsubsw_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vphsubsw_xmm_xmm_m128(dst, src, src2)) } +emit_vphsubsw_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vphsubsw_ymm_ymm_ymm(dst, src, src2)) } +emit_vphsubsw_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vphsubsw_ymm_ymm_m256(dst, src, src2)) } +inst_vpmaddubsw_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMADDUBSW, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1353) } +inst_vpmaddubsw_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMADDUBSW, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1353) } +inst_vpmaddubsw_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMADDUBSW, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1354) } +inst_vpmaddubsw_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMADDUBSW, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1354) } +emit_vpmaddubsw_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vpmaddubsw_xmm_xmm_xmm(dst, src, src2)) } +emit_vpmaddubsw_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vpmaddubsw_xmm_xmm_m128(dst, src, src2)) } +emit_vpmaddubsw_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vpmaddubsw_ymm_ymm_ymm(dst, src, src2)) } +emit_vpmaddubsw_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vpmaddubsw_ymm_ymm_m256(dst, src, src2)) } +inst_vpmulhrsw_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMULHRSW, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1355) } +inst_vpmulhrsw_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMULHRSW, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1355) } +inst_vpmulhrsw_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMULHRSW, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1356) } +inst_vpmulhrsw_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMULHRSW, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1356) } +emit_vpmulhrsw_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vpmulhrsw_xmm_xmm_xmm(dst, src, src2)) } +emit_vpmulhrsw_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vpmulhrsw_xmm_xmm_m128(dst, src, src2)) } +emit_vpmulhrsw_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vpmulhrsw_ymm_ymm_ymm(dst, src, src2)) } +emit_vpmulhrsw_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vpmulhrsw_ymm_ymm_m256(dst, src, src2)) } +inst_vpsignb_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSIGNB, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1357) } +inst_vpsignb_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSIGNB, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1357) } +inst_vpsignb_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSIGNB, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1358) } +inst_vpsignb_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSIGNB, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1358) } +emit_vpsignb_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vpsignb_xmm_xmm_xmm(dst, src, src2)) } +emit_vpsignb_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vpsignb_xmm_xmm_m128(dst, src, src2)) } +emit_vpsignb_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vpsignb_ymm_ymm_ymm(dst, src, src2)) } +emit_vpsignb_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vpsignb_ymm_ymm_m256(dst, src, src2)) } +inst_vpsignw_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSIGNW, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1359) } +inst_vpsignw_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSIGNW, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1359) } +inst_vpsignw_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSIGNW, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1360) } +inst_vpsignw_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSIGNW, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1360) } +emit_vpsignw_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vpsignw_xmm_xmm_xmm(dst, src, src2)) } +emit_vpsignw_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vpsignw_xmm_xmm_m128(dst, src, src2)) } +emit_vpsignw_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vpsignw_ymm_ymm_ymm(dst, src, src2)) } +emit_vpsignw_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vpsignw_ymm_ymm_m256(dst, src, src2)) } +inst_vpsignd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSIGND, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1361) } +inst_vpsignd_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSIGND, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1361) } +inst_vpsignd_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSIGND, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1362) } +inst_vpsignd_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSIGND, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1362) } +emit_vpsignd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vpsignd_xmm_xmm_xmm(dst, src, src2)) } +emit_vpsignd_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vpsignd_xmm_xmm_m128(dst, src, src2)) } +emit_vpsignd_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vpsignd_ymm_ymm_ymm(dst, src, src2)) } +emit_vpsignd_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vpsignd_ymm_ymm_m256(dst, src, src2)) } +inst_vpabsb_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPABSB, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 1363) } +inst_vpabsb_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPABSB, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 1363) } +inst_vpabsb_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPABSB, operand_count = 2, ops = {op_ymm(dst), op_ymm(src), {}, {}} }, 1364) } +inst_vpabsb_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VPABSB, operand_count = 2, ops = {op_ymm(dst), op_mem(src.mem, 32), {}, {}} }, 1364) } +emit_vpabsb_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_vpabsb_xmm_xmm(dst, src)) } +emit_vpabsb_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_vpabsb_xmm_m128(dst, src)) } +emit_vpabsb_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM) { append(instructions, inst_vpabsb_ymm_ymm(dst, src)) } +emit_vpabsb_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem256) { append(instructions, inst_vpabsb_ymm_m256(dst, src)) } +inst_vpabsw_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPABSW, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 1365) } +inst_vpabsw_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPABSW, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 1365) } +inst_vpabsw_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPABSW, operand_count = 2, ops = {op_ymm(dst), op_ymm(src), {}, {}} }, 1366) } +inst_vpabsw_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VPABSW, operand_count = 2, ops = {op_ymm(dst), op_mem(src.mem, 32), {}, {}} }, 1366) } +emit_vpabsw_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_vpabsw_xmm_xmm(dst, src)) } +emit_vpabsw_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_vpabsw_xmm_m128(dst, src)) } +emit_vpabsw_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM) { append(instructions, inst_vpabsw_ymm_ymm(dst, src)) } +emit_vpabsw_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem256) { append(instructions, inst_vpabsw_ymm_m256(dst, src)) } +inst_vpabsd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPABSD, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 1367) } +inst_vpabsd_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPABSD, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 1367) } +inst_vpabsd_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPABSD, operand_count = 2, ops = {op_ymm(dst), op_ymm(src), {}, {}} }, 1368) } +inst_vpabsd_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VPABSD, operand_count = 2, ops = {op_ymm(dst), op_mem(src.mem, 32), {}, {}} }, 1368) } +emit_vpabsd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_vpabsd_xmm_xmm(dst, src)) } +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)} } } @@ -4503,13 +4503,13 @@ emit_vpblendw_xmm_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynami 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)) } emit_vpblendw_ymm_ymm_m256_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256, imm: i8) { append(instructions, inst_vpblendw_ymm_ymm_m256_imm8(dst, src, src2, imm)) } -inst_vpblendvb_xmm_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM, src3: XMM) -> Instruction { return inst_r_r_r_r(.VPBLENDVB, Register(dst), Register(src), Register(src2), Register(src3)) } -inst_vpblendvb_xmm_xmm_m128_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128, src3: XMM) -> Instruction { return Instruction{ mnemonic = .VPBLENDVB, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), op_xmm(src3)} } } -inst_vpblendvb_ymm_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM, src3: YMM) -> Instruction { return inst_r_r_r_r(.VPBLENDVB, Register(dst), Register(src), Register(src2), Register(src3)) } -inst_vpblendvb_ymm_ymm_m256_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256, src3: YMM) -> Instruction { return Instruction{ mnemonic = .VPBLENDVB, operand_count = 4, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), op_ymm(src3)} } } -emit_vpblendvb_xmm_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM, src3: XMM) { emit_rrrr(instructions, .VPBLENDVB, Register(dst), Register(src), Register(src2), Register(src3)) } +inst_vpblendvb_xmm_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM, src3: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPBLENDVB, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), op_xmm(src3)} }, 1373) } +inst_vpblendvb_xmm_xmm_m128_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128, src3: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPBLENDVB, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), op_xmm(src3)} }, 1373) } +inst_vpblendvb_ymm_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM, src3: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPBLENDVB, operand_count = 4, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), op_ymm(src3)} }, 1374) } +inst_vpblendvb_ymm_ymm_m256_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256, src3: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPBLENDVB, operand_count = 4, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), op_ymm(src3)} }, 1374) } +emit_vpblendvb_xmm_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM, src3: XMM) { append(instructions, inst_vpblendvb_xmm_xmm_xmm_xmm(dst, src, src2, src3)) } 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) { emit_rrrr(instructions, .VPBLENDVB, Register(dst), Register(src), Register(src2), Register(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)} } } @@ -4519,184 +4519,184 @@ emit_vmpsadbw_xmm_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynami 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)) } emit_vmpsadbw_ymm_ymm_m256_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256, imm: i8) { append(instructions, inst_vmpsadbw_ymm_ymm_m256_imm8(dst, src, src2, imm)) } -inst_vphminposuw_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.VPHMINPOSUW, Register(dst), Register(src)) } -inst_vphminposuw_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.VPHMINPOSUW, Register(dst), src.mem, 16) } -emit_vphminposuw_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .VPHMINPOSUW, Register(dst), Register(src)) } -emit_vphminposuw_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .VPHMINPOSUW, Register(dst), src.mem, 16) } -inst_vpmaxsb_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VPMAXSB, Register(dst), Register(src), Register(src2)) } -inst_vpmaxsb_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VPMAXSB, Register(dst), Register(src), src2.mem, 16) } -inst_vpmaxsb_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VPMAXSB, Register(dst), Register(src), Register(src2)) } -inst_vpmaxsb_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VPMAXSB, Register(dst), Register(src), src2.mem, 32) } -emit_vpmaxsb_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VPMAXSB, Register(dst), Register(src), Register(src2)) } -emit_vpmaxsb_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VPMAXSB, Register(dst), Register(src), src2.mem, 16) } -emit_vpmaxsb_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VPMAXSB, Register(dst), Register(src), Register(src2)) } -emit_vpmaxsb_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VPMAXSB, Register(dst), Register(src), src2.mem, 32) } -inst_vpmaxsd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VPMAXSD, Register(dst), Register(src), Register(src2)) } -inst_vpmaxsd_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VPMAXSD, Register(dst), Register(src), src2.mem, 16) } -inst_vpmaxsd_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VPMAXSD, Register(dst), Register(src), Register(src2)) } -inst_vpmaxsd_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VPMAXSD, Register(dst), Register(src), src2.mem, 32) } -emit_vpmaxsd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VPMAXSD, Register(dst), Register(src), Register(src2)) } -emit_vpmaxsd_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VPMAXSD, Register(dst), Register(src), src2.mem, 16) } -emit_vpmaxsd_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VPMAXSD, Register(dst), Register(src), Register(src2)) } -emit_vpmaxsd_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VPMAXSD, Register(dst), Register(src), src2.mem, 32) } -inst_vpmaxuw_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VPMAXUW, Register(dst), Register(src), Register(src2)) } -inst_vpmaxuw_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VPMAXUW, Register(dst), Register(src), src2.mem, 16) } -inst_vpmaxuw_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VPMAXUW, Register(dst), Register(src), Register(src2)) } -inst_vpmaxuw_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VPMAXUW, Register(dst), Register(src), src2.mem, 32) } -emit_vpmaxuw_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VPMAXUW, Register(dst), Register(src), Register(src2)) } -emit_vpmaxuw_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VPMAXUW, Register(dst), Register(src), src2.mem, 16) } -emit_vpmaxuw_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VPMAXUW, Register(dst), Register(src), Register(src2)) } -emit_vpmaxuw_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VPMAXUW, Register(dst), Register(src), src2.mem, 32) } -inst_vpmaxud_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VPMAXUD, Register(dst), Register(src), Register(src2)) } -inst_vpmaxud_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VPMAXUD, Register(dst), Register(src), src2.mem, 16) } -inst_vpmaxud_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VPMAXUD, Register(dst), Register(src), Register(src2)) } -inst_vpmaxud_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VPMAXUD, Register(dst), Register(src), src2.mem, 32) } -emit_vpmaxud_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VPMAXUD, Register(dst), Register(src), Register(src2)) } -emit_vpmaxud_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VPMAXUD, Register(dst), Register(src), src2.mem, 16) } -emit_vpmaxud_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VPMAXUD, Register(dst), Register(src), Register(src2)) } -emit_vpmaxud_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VPMAXUD, Register(dst), Register(src), src2.mem, 32) } -inst_vpminsb_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VPMINSB, Register(dst), Register(src), Register(src2)) } -inst_vpminsb_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VPMINSB, Register(dst), Register(src), src2.mem, 16) } -inst_vpminsb_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VPMINSB, Register(dst), Register(src), Register(src2)) } -inst_vpminsb_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VPMINSB, Register(dst), Register(src), src2.mem, 32) } -emit_vpminsb_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VPMINSB, Register(dst), Register(src), Register(src2)) } -emit_vpminsb_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VPMINSB, Register(dst), Register(src), src2.mem, 16) } -emit_vpminsb_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VPMINSB, Register(dst), Register(src), Register(src2)) } -emit_vpminsb_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VPMINSB, Register(dst), Register(src), src2.mem, 32) } -inst_vpminsd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VPMINSD, Register(dst), Register(src), Register(src2)) } -inst_vpminsd_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VPMINSD, Register(dst), Register(src), src2.mem, 16) } -inst_vpminsd_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VPMINSD, Register(dst), Register(src), Register(src2)) } -inst_vpminsd_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VPMINSD, Register(dst), Register(src), src2.mem, 32) } -emit_vpminsd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VPMINSD, Register(dst), Register(src), Register(src2)) } -emit_vpminsd_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VPMINSD, Register(dst), Register(src), src2.mem, 16) } -emit_vpminsd_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VPMINSD, Register(dst), Register(src), Register(src2)) } -emit_vpminsd_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VPMINSD, Register(dst), Register(src), src2.mem, 32) } -inst_vpminuw_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VPMINUW, Register(dst), Register(src), Register(src2)) } -inst_vpminuw_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VPMINUW, Register(dst), Register(src), src2.mem, 16) } -inst_vpminuw_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VPMINUW, Register(dst), Register(src), Register(src2)) } -inst_vpminuw_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VPMINUW, Register(dst), Register(src), src2.mem, 32) } -emit_vpminuw_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VPMINUW, Register(dst), Register(src), Register(src2)) } -emit_vpminuw_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VPMINUW, Register(dst), Register(src), src2.mem, 16) } -emit_vpminuw_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VPMINUW, Register(dst), Register(src), Register(src2)) } -emit_vpminuw_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VPMINUW, Register(dst), Register(src), src2.mem, 32) } -inst_vpminud_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VPMINUD, Register(dst), Register(src), Register(src2)) } -inst_vpminud_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VPMINUD, Register(dst), Register(src), src2.mem, 16) } -inst_vpminud_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VPMINUD, Register(dst), Register(src), Register(src2)) } -inst_vpminud_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VPMINUD, Register(dst), Register(src), src2.mem, 32) } -emit_vpminud_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VPMINUD, Register(dst), Register(src), Register(src2)) } -emit_vpminud_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VPMINUD, Register(dst), Register(src), src2.mem, 16) } -emit_vpminud_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VPMINUD, Register(dst), Register(src), Register(src2)) } -emit_vpminud_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VPMINUD, Register(dst), Register(src), src2.mem, 32) } -inst_vpmovsxbw_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.VPMOVSXBW, Register(dst), Register(src)) } -inst_vpmovsxbw_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: Mem64) -> Instruction { return inst_r_m(.VPMOVSXBW, Register(dst), src.mem, 8) } -inst_vpmovsxbw_ymm_xmm :: #force_inline proc "contextless" (dst: YMM, src: XMM) -> Instruction { return inst_r_r(.VPMOVSXBW, Register(dst), Register(src)) } -inst_vpmovsxbw_ymm_m128 :: #force_inline proc "contextless" (dst: YMM, src: Mem128) -> Instruction { return inst_r_m(.VPMOVSXBW, Register(dst), src.mem, 16) } -emit_vpmovsxbw_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .VPMOVSXBW, Register(dst), Register(src)) } -emit_vpmovsxbw_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem64) { emit_rm(instructions, .VPMOVSXBW, Register(dst), src.mem, 8) } -emit_vpmovsxbw_ymm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: XMM) { emit_rr(instructions, .VPMOVSXBW, Register(dst), Register(src)) } -emit_vpmovsxbw_ymm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem128) { emit_rm(instructions, .VPMOVSXBW, Register(dst), src.mem, 16) } -inst_vpmovsxbd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.VPMOVSXBD, Register(dst), Register(src)) } -inst_vpmovsxbd_xmm_m32 :: #force_inline proc "contextless" (dst: XMM, src: Mem32) -> Instruction { return inst_r_m(.VPMOVSXBD, Register(dst), src.mem, 4) } -inst_vpmovsxbd_ymm_xmm :: #force_inline proc "contextless" (dst: YMM, src: XMM) -> Instruction { return inst_r_r(.VPMOVSXBD, Register(dst), Register(src)) } -inst_vpmovsxbd_ymm_m64 :: #force_inline proc "contextless" (dst: YMM, src: Mem64) -> Instruction { return inst_r_m(.VPMOVSXBD, Register(dst), src.mem, 8) } -emit_vpmovsxbd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .VPMOVSXBD, Register(dst), Register(src)) } -emit_vpmovsxbd_xmm_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem32) { emit_rm(instructions, .VPMOVSXBD, Register(dst), src.mem, 4) } -emit_vpmovsxbd_ymm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: XMM) { emit_rr(instructions, .VPMOVSXBD, Register(dst), Register(src)) } -emit_vpmovsxbd_ymm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem64) { emit_rm(instructions, .VPMOVSXBD, Register(dst), src.mem, 8) } -inst_vpmovsxbq_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.VPMOVSXBQ, Register(dst), Register(src)) } -inst_vpmovsxbq_ymm_xmm :: #force_inline proc "contextless" (dst: YMM, src: XMM) -> Instruction { return inst_r_r(.VPMOVSXBQ, Register(dst), Register(src)) } -inst_vpmovsxbq_ymm_m32 :: #force_inline proc "contextless" (dst: YMM, src: Mem32) -> Instruction { return inst_r_m(.VPMOVSXBQ, Register(dst), src.mem, 4) } -emit_vpmovsxbq_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .VPMOVSXBQ, Register(dst), Register(src)) } -emit_vpmovsxbq_ymm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: XMM) { emit_rr(instructions, .VPMOVSXBQ, Register(dst), Register(src)) } -emit_vpmovsxbq_ymm_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem32) { emit_rm(instructions, .VPMOVSXBQ, Register(dst), src.mem, 4) } -inst_vpmovsxwd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.VPMOVSXWD, Register(dst), Register(src)) } -inst_vpmovsxwd_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: Mem64) -> Instruction { return inst_r_m(.VPMOVSXWD, Register(dst), src.mem, 8) } -inst_vpmovsxwd_ymm_xmm :: #force_inline proc "contextless" (dst: YMM, src: XMM) -> Instruction { return inst_r_r(.VPMOVSXWD, Register(dst), Register(src)) } -inst_vpmovsxwd_ymm_m128 :: #force_inline proc "contextless" (dst: YMM, src: Mem128) -> Instruction { return inst_r_m(.VPMOVSXWD, Register(dst), src.mem, 16) } -emit_vpmovsxwd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .VPMOVSXWD, Register(dst), Register(src)) } -emit_vpmovsxwd_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem64) { emit_rm(instructions, .VPMOVSXWD, Register(dst), src.mem, 8) } -emit_vpmovsxwd_ymm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: XMM) { emit_rr(instructions, .VPMOVSXWD, Register(dst), Register(src)) } -emit_vpmovsxwd_ymm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem128) { emit_rm(instructions, .VPMOVSXWD, Register(dst), src.mem, 16) } -inst_vpmovsxwq_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.VPMOVSXWQ, Register(dst), Register(src)) } -inst_vpmovsxwq_xmm_m32 :: #force_inline proc "contextless" (dst: XMM, src: Mem32) -> Instruction { return inst_r_m(.VPMOVSXWQ, Register(dst), src.mem, 4) } -inst_vpmovsxwq_ymm_xmm :: #force_inline proc "contextless" (dst: YMM, src: XMM) -> Instruction { return inst_r_r(.VPMOVSXWQ, Register(dst), Register(src)) } -inst_vpmovsxwq_ymm_m64 :: #force_inline proc "contextless" (dst: YMM, src: Mem64) -> Instruction { return inst_r_m(.VPMOVSXWQ, Register(dst), src.mem, 8) } -emit_vpmovsxwq_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .VPMOVSXWQ, Register(dst), Register(src)) } -emit_vpmovsxwq_xmm_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem32) { emit_rm(instructions, .VPMOVSXWQ, Register(dst), src.mem, 4) } -emit_vpmovsxwq_ymm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: XMM) { emit_rr(instructions, .VPMOVSXWQ, Register(dst), Register(src)) } -emit_vpmovsxwq_ymm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem64) { emit_rm(instructions, .VPMOVSXWQ, Register(dst), src.mem, 8) } -inst_vpmovsxdq_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.VPMOVSXDQ, Register(dst), Register(src)) } -inst_vpmovsxdq_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: Mem64) -> Instruction { return inst_r_m(.VPMOVSXDQ, Register(dst), src.mem, 8) } -inst_vpmovsxdq_ymm_xmm :: #force_inline proc "contextless" (dst: YMM, src: XMM) -> Instruction { return inst_r_r(.VPMOVSXDQ, Register(dst), Register(src)) } -inst_vpmovsxdq_ymm_m128 :: #force_inline proc "contextless" (dst: YMM, src: Mem128) -> Instruction { return inst_r_m(.VPMOVSXDQ, Register(dst), src.mem, 16) } -emit_vpmovsxdq_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .VPMOVSXDQ, Register(dst), Register(src)) } -emit_vpmovsxdq_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem64) { emit_rm(instructions, .VPMOVSXDQ, Register(dst), src.mem, 8) } -emit_vpmovsxdq_ymm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: XMM) { emit_rr(instructions, .VPMOVSXDQ, Register(dst), Register(src)) } -emit_vpmovsxdq_ymm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem128) { emit_rm(instructions, .VPMOVSXDQ, Register(dst), src.mem, 16) } -inst_vpmovzxbw_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.VPMOVZXBW, Register(dst), Register(src)) } -inst_vpmovzxbw_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: Mem64) -> Instruction { return inst_r_m(.VPMOVZXBW, Register(dst), src.mem, 8) } -inst_vpmovzxbw_ymm_xmm :: #force_inline proc "contextless" (dst: YMM, src: XMM) -> Instruction { return inst_r_r(.VPMOVZXBW, Register(dst), Register(src)) } -inst_vpmovzxbw_ymm_m128 :: #force_inline proc "contextless" (dst: YMM, src: Mem128) -> Instruction { return inst_r_m(.VPMOVZXBW, Register(dst), src.mem, 16) } -emit_vpmovzxbw_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .VPMOVZXBW, Register(dst), Register(src)) } -emit_vpmovzxbw_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem64) { emit_rm(instructions, .VPMOVZXBW, Register(dst), src.mem, 8) } -emit_vpmovzxbw_ymm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: XMM) { emit_rr(instructions, .VPMOVZXBW, Register(dst), Register(src)) } -emit_vpmovzxbw_ymm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem128) { emit_rm(instructions, .VPMOVZXBW, Register(dst), src.mem, 16) } -inst_vpmovzxbd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.VPMOVZXBD, Register(dst), Register(src)) } -inst_vpmovzxbd_xmm_m32 :: #force_inline proc "contextless" (dst: XMM, src: Mem32) -> Instruction { return inst_r_m(.VPMOVZXBD, Register(dst), src.mem, 4) } -inst_vpmovzxbd_ymm_xmm :: #force_inline proc "contextless" (dst: YMM, src: XMM) -> Instruction { return inst_r_r(.VPMOVZXBD, Register(dst), Register(src)) } -inst_vpmovzxbd_ymm_m64 :: #force_inline proc "contextless" (dst: YMM, src: Mem64) -> Instruction { return inst_r_m(.VPMOVZXBD, Register(dst), src.mem, 8) } -emit_vpmovzxbd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .VPMOVZXBD, Register(dst), Register(src)) } -emit_vpmovzxbd_xmm_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem32) { emit_rm(instructions, .VPMOVZXBD, Register(dst), src.mem, 4) } -emit_vpmovzxbd_ymm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: XMM) { emit_rr(instructions, .VPMOVZXBD, Register(dst), Register(src)) } -emit_vpmovzxbd_ymm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem64) { emit_rm(instructions, .VPMOVZXBD, Register(dst), src.mem, 8) } -inst_vpmovzxbq_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.VPMOVZXBQ, Register(dst), Register(src)) } -inst_vpmovzxbq_ymm_xmm :: #force_inline proc "contextless" (dst: YMM, src: XMM) -> Instruction { return inst_r_r(.VPMOVZXBQ, Register(dst), Register(src)) } -inst_vpmovzxbq_ymm_m32 :: #force_inline proc "contextless" (dst: YMM, src: Mem32) -> Instruction { return inst_r_m(.VPMOVZXBQ, Register(dst), src.mem, 4) } -emit_vpmovzxbq_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .VPMOVZXBQ, Register(dst), Register(src)) } -emit_vpmovzxbq_ymm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: XMM) { emit_rr(instructions, .VPMOVZXBQ, Register(dst), Register(src)) } -emit_vpmovzxbq_ymm_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem32) { emit_rm(instructions, .VPMOVZXBQ, Register(dst), src.mem, 4) } -inst_vpmovzxwd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.VPMOVZXWD, Register(dst), Register(src)) } -inst_vpmovzxwd_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: Mem64) -> Instruction { return inst_r_m(.VPMOVZXWD, Register(dst), src.mem, 8) } -inst_vpmovzxwd_ymm_xmm :: #force_inline proc "contextless" (dst: YMM, src: XMM) -> Instruction { return inst_r_r(.VPMOVZXWD, Register(dst), Register(src)) } -inst_vpmovzxwd_ymm_m128 :: #force_inline proc "contextless" (dst: YMM, src: Mem128) -> Instruction { return inst_r_m(.VPMOVZXWD, Register(dst), src.mem, 16) } -emit_vpmovzxwd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .VPMOVZXWD, Register(dst), Register(src)) } -emit_vpmovzxwd_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem64) { emit_rm(instructions, .VPMOVZXWD, Register(dst), src.mem, 8) } -emit_vpmovzxwd_ymm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: XMM) { emit_rr(instructions, .VPMOVZXWD, Register(dst), Register(src)) } -emit_vpmovzxwd_ymm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem128) { emit_rm(instructions, .VPMOVZXWD, Register(dst), src.mem, 16) } -inst_vpmovzxwq_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.VPMOVZXWQ, Register(dst), Register(src)) } -inst_vpmovzxwq_xmm_m32 :: #force_inline proc "contextless" (dst: XMM, src: Mem32) -> Instruction { return inst_r_m(.VPMOVZXWQ, Register(dst), src.mem, 4) } -inst_vpmovzxwq_ymm_xmm :: #force_inline proc "contextless" (dst: YMM, src: XMM) -> Instruction { return inst_r_r(.VPMOVZXWQ, Register(dst), Register(src)) } -inst_vpmovzxwq_ymm_m64 :: #force_inline proc "contextless" (dst: YMM, src: Mem64) -> Instruction { return inst_r_m(.VPMOVZXWQ, Register(dst), src.mem, 8) } -emit_vpmovzxwq_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .VPMOVZXWQ, Register(dst), Register(src)) } -emit_vpmovzxwq_xmm_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem32) { emit_rm(instructions, .VPMOVZXWQ, Register(dst), src.mem, 4) } -emit_vpmovzxwq_ymm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: XMM) { emit_rr(instructions, .VPMOVZXWQ, Register(dst), Register(src)) } -emit_vpmovzxwq_ymm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem64) { emit_rm(instructions, .VPMOVZXWQ, Register(dst), src.mem, 8) } -inst_vpmovzxdq_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.VPMOVZXDQ, Register(dst), Register(src)) } -inst_vpmovzxdq_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: Mem64) -> Instruction { return inst_r_m(.VPMOVZXDQ, Register(dst), src.mem, 8) } -inst_vpmovzxdq_ymm_xmm :: #force_inline proc "contextless" (dst: YMM, src: XMM) -> Instruction { return inst_r_r(.VPMOVZXDQ, Register(dst), Register(src)) } -inst_vpmovzxdq_ymm_m128 :: #force_inline proc "contextless" (dst: YMM, src: Mem128) -> Instruction { return inst_r_m(.VPMOVZXDQ, Register(dst), src.mem, 16) } -emit_vpmovzxdq_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .VPMOVZXDQ, Register(dst), Register(src)) } -emit_vpmovzxdq_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem64) { emit_rm(instructions, .VPMOVZXDQ, Register(dst), src.mem, 8) } -emit_vpmovzxdq_ymm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: XMM) { emit_rr(instructions, .VPMOVZXDQ, Register(dst), Register(src)) } -emit_vpmovzxdq_ymm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem128) { emit_rm(instructions, .VPMOVZXDQ, Register(dst), src.mem, 16) } -inst_vpmuldq_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VPMULDQ, Register(dst), Register(src), Register(src2)) } -inst_vpmuldq_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VPMULDQ, Register(dst), Register(src), src2.mem, 16) } -inst_vpmuldq_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VPMULDQ, Register(dst), Register(src), Register(src2)) } -inst_vpmuldq_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VPMULDQ, Register(dst), Register(src), src2.mem, 32) } -emit_vpmuldq_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VPMULDQ, Register(dst), Register(src), Register(src2)) } -emit_vpmuldq_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VPMULDQ, Register(dst), Register(src), src2.mem, 16) } -emit_vpmuldq_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VPMULDQ, Register(dst), Register(src), Register(src2)) } -emit_vpmuldq_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VPMULDQ, Register(dst), Register(src), src2.mem, 32) } -inst_vpmulld_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VPMULLD, Register(dst), Register(src), Register(src2)) } -inst_vpmulld_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VPMULLD, Register(dst), Register(src), src2.mem, 16) } -inst_vpmulld_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VPMULLD, Register(dst), Register(src), Register(src2)) } -inst_vpmulld_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VPMULLD, Register(dst), Register(src), src2.mem, 32) } -emit_vpmulld_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VPMULLD, Register(dst), Register(src), Register(src2)) } -emit_vpmulld_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VPMULLD, Register(dst), Register(src), src2.mem, 16) } -emit_vpmulld_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VPMULLD, Register(dst), Register(src), Register(src2)) } -emit_vpmulld_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VPMULLD, Register(dst), Register(src), src2.mem, 32) } -inst_vmaskmovdqu_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.VMASKMOVDQU, Register(dst), Register(src)) } -emit_vmaskmovdqu_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .VMASKMOVDQU, Register(dst), Register(src)) } +inst_vphminposuw_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPHMINPOSUW, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 1377) } +inst_vphminposuw_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPHMINPOSUW, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 1377) } +emit_vphminposuw_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_vphminposuw_xmm_xmm(dst, src)) } +emit_vphminposuw_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_vphminposuw_xmm_m128(dst, src)) } +inst_vpmaxsb_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMAXSB, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1378) } +inst_vpmaxsb_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMAXSB, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1378) } +inst_vpmaxsb_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMAXSB, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1379) } +inst_vpmaxsb_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMAXSB, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1379) } +emit_vpmaxsb_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vpmaxsb_xmm_xmm_xmm(dst, src, src2)) } +emit_vpmaxsb_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vpmaxsb_xmm_xmm_m128(dst, src, src2)) } +emit_vpmaxsb_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vpmaxsb_ymm_ymm_ymm(dst, src, src2)) } +emit_vpmaxsb_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vpmaxsb_ymm_ymm_m256(dst, src, src2)) } +inst_vpmaxsd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMAXSD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1380) } +inst_vpmaxsd_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMAXSD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1380) } +inst_vpmaxsd_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMAXSD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1381) } +inst_vpmaxsd_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMAXSD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1381) } +emit_vpmaxsd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vpmaxsd_xmm_xmm_xmm(dst, src, src2)) } +emit_vpmaxsd_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vpmaxsd_xmm_xmm_m128(dst, src, src2)) } +emit_vpmaxsd_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vpmaxsd_ymm_ymm_ymm(dst, src, src2)) } +emit_vpmaxsd_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vpmaxsd_ymm_ymm_m256(dst, src, src2)) } +inst_vpmaxuw_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMAXUW, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1382) } +inst_vpmaxuw_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMAXUW, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1382) } +inst_vpmaxuw_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMAXUW, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1383) } +inst_vpmaxuw_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMAXUW, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1383) } +emit_vpmaxuw_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vpmaxuw_xmm_xmm_xmm(dst, src, src2)) } +emit_vpmaxuw_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vpmaxuw_xmm_xmm_m128(dst, src, src2)) } +emit_vpmaxuw_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vpmaxuw_ymm_ymm_ymm(dst, src, src2)) } +emit_vpmaxuw_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vpmaxuw_ymm_ymm_m256(dst, src, src2)) } +inst_vpmaxud_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMAXUD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1384) } +inst_vpmaxud_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMAXUD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1384) } +inst_vpmaxud_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMAXUD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1385) } +inst_vpmaxud_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMAXUD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1385) } +emit_vpmaxud_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vpmaxud_xmm_xmm_xmm(dst, src, src2)) } +emit_vpmaxud_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vpmaxud_xmm_xmm_m128(dst, src, src2)) } +emit_vpmaxud_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vpmaxud_ymm_ymm_ymm(dst, src, src2)) } +emit_vpmaxud_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vpmaxud_ymm_ymm_m256(dst, src, src2)) } +inst_vpminsb_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMINSB, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1386) } +inst_vpminsb_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMINSB, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1386) } +inst_vpminsb_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMINSB, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1387) } +inst_vpminsb_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMINSB, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1387) } +emit_vpminsb_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vpminsb_xmm_xmm_xmm(dst, src, src2)) } +emit_vpminsb_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vpminsb_xmm_xmm_m128(dst, src, src2)) } +emit_vpminsb_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vpminsb_ymm_ymm_ymm(dst, src, src2)) } +emit_vpminsb_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vpminsb_ymm_ymm_m256(dst, src, src2)) } +inst_vpminsd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMINSD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1388) } +inst_vpminsd_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMINSD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1388) } +inst_vpminsd_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMINSD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1389) } +inst_vpminsd_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMINSD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1389) } +emit_vpminsd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vpminsd_xmm_xmm_xmm(dst, src, src2)) } +emit_vpminsd_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vpminsd_xmm_xmm_m128(dst, src, src2)) } +emit_vpminsd_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vpminsd_ymm_ymm_ymm(dst, src, src2)) } +emit_vpminsd_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vpminsd_ymm_ymm_m256(dst, src, src2)) } +inst_vpminuw_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMINUW, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1390) } +inst_vpminuw_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMINUW, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1390) } +inst_vpminuw_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMINUW, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1391) } +inst_vpminuw_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMINUW, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1391) } +emit_vpminuw_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vpminuw_xmm_xmm_xmm(dst, src, src2)) } +emit_vpminuw_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vpminuw_xmm_xmm_m128(dst, src, src2)) } +emit_vpminuw_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vpminuw_ymm_ymm_ymm(dst, src, src2)) } +emit_vpminuw_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vpminuw_ymm_ymm_m256(dst, src, src2)) } +inst_vpminud_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMINUD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1392) } +inst_vpminud_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMINUD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1392) } +inst_vpminud_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMINUD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1393) } +inst_vpminud_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMINUD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1393) } +emit_vpminud_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vpminud_xmm_xmm_xmm(dst, src, src2)) } +emit_vpminud_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vpminud_xmm_xmm_m128(dst, src, src2)) } +emit_vpminud_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vpminud_ymm_ymm_ymm(dst, src, src2)) } +emit_vpminud_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vpminud_ymm_ymm_m256(dst, src, src2)) } +inst_vpmovsxbw_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVSXBW, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 1394) } +inst_vpmovsxbw_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVSXBW, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 8), {}, {}} }, 1394) } +inst_vpmovsxbw_ymm_xmm :: #force_inline proc "contextless" (dst: YMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVSXBW, operand_count = 2, ops = {op_ymm(dst), op_xmm(src), {}, {}} }, 1395) } +inst_vpmovsxbw_ymm_m128 :: #force_inline proc "contextless" (dst: YMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVSXBW, operand_count = 2, ops = {op_ymm(dst), op_mem(src.mem, 16), {}, {}} }, 1395) } +emit_vpmovsxbw_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_vpmovsxbw_xmm_xmm(dst, src)) } +emit_vpmovsxbw_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem64) { append(instructions, inst_vpmovsxbw_xmm_m64(dst, src)) } +emit_vpmovsxbw_ymm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: XMM) { append(instructions, inst_vpmovsxbw_ymm_xmm(dst, src)) } +emit_vpmovsxbw_ymm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem128) { append(instructions, inst_vpmovsxbw_ymm_m128(dst, src)) } +inst_vpmovsxbd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVSXBD, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 1396) } +inst_vpmovsxbd_xmm_m32 :: #force_inline proc "contextless" (dst: XMM, src: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVSXBD, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 4), {}, {}} }, 1396) } +inst_vpmovsxbd_ymm_xmm :: #force_inline proc "contextless" (dst: YMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVSXBD, operand_count = 2, ops = {op_ymm(dst), op_xmm(src), {}, {}} }, 1397) } +inst_vpmovsxbd_ymm_m64 :: #force_inline proc "contextless" (dst: YMM, src: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVSXBD, operand_count = 2, ops = {op_ymm(dst), op_mem(src.mem, 8), {}, {}} }, 1397) } +emit_vpmovsxbd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_vpmovsxbd_xmm_xmm(dst, src)) } +emit_vpmovsxbd_xmm_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem32) { append(instructions, inst_vpmovsxbd_xmm_m32(dst, src)) } +emit_vpmovsxbd_ymm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: XMM) { append(instructions, inst_vpmovsxbd_ymm_xmm(dst, src)) } +emit_vpmovsxbd_ymm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem64) { append(instructions, inst_vpmovsxbd_ymm_m64(dst, src)) } +inst_vpmovsxbq_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVSXBQ, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 1398) } +inst_vpmovsxbq_ymm_xmm :: #force_inline proc "contextless" (dst: YMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVSXBQ, operand_count = 2, ops = {op_ymm(dst), op_xmm(src), {}, {}} }, 1399) } +inst_vpmovsxbq_ymm_m32 :: #force_inline proc "contextless" (dst: YMM, src: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVSXBQ, operand_count = 2, ops = {op_ymm(dst), op_mem(src.mem, 4), {}, {}} }, 1399) } +emit_vpmovsxbq_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_vpmovsxbq_xmm_xmm(dst, src)) } +emit_vpmovsxbq_ymm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: XMM) { append(instructions, inst_vpmovsxbq_ymm_xmm(dst, src)) } +emit_vpmovsxbq_ymm_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem32) { append(instructions, inst_vpmovsxbq_ymm_m32(dst, src)) } +inst_vpmovsxwd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVSXWD, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 1400) } +inst_vpmovsxwd_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVSXWD, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 8), {}, {}} }, 1400) } +inst_vpmovsxwd_ymm_xmm :: #force_inline proc "contextless" (dst: YMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVSXWD, operand_count = 2, ops = {op_ymm(dst), op_xmm(src), {}, {}} }, 1401) } +inst_vpmovsxwd_ymm_m128 :: #force_inline proc "contextless" (dst: YMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVSXWD, operand_count = 2, ops = {op_ymm(dst), op_mem(src.mem, 16), {}, {}} }, 1401) } +emit_vpmovsxwd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_vpmovsxwd_xmm_xmm(dst, src)) } +emit_vpmovsxwd_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem64) { append(instructions, inst_vpmovsxwd_xmm_m64(dst, src)) } +emit_vpmovsxwd_ymm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: XMM) { append(instructions, inst_vpmovsxwd_ymm_xmm(dst, src)) } +emit_vpmovsxwd_ymm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem128) { append(instructions, inst_vpmovsxwd_ymm_m128(dst, src)) } +inst_vpmovsxwq_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVSXWQ, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 1402) } +inst_vpmovsxwq_xmm_m32 :: #force_inline proc "contextless" (dst: XMM, src: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVSXWQ, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 4), {}, {}} }, 1402) } +inst_vpmovsxwq_ymm_xmm :: #force_inline proc "contextless" (dst: YMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVSXWQ, operand_count = 2, ops = {op_ymm(dst), op_xmm(src), {}, {}} }, 1403) } +inst_vpmovsxwq_ymm_m64 :: #force_inline proc "contextless" (dst: YMM, src: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVSXWQ, operand_count = 2, ops = {op_ymm(dst), op_mem(src.mem, 8), {}, {}} }, 1403) } +emit_vpmovsxwq_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_vpmovsxwq_xmm_xmm(dst, src)) } +emit_vpmovsxwq_xmm_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem32) { append(instructions, inst_vpmovsxwq_xmm_m32(dst, src)) } +emit_vpmovsxwq_ymm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: XMM) { append(instructions, inst_vpmovsxwq_ymm_xmm(dst, src)) } +emit_vpmovsxwq_ymm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem64) { append(instructions, inst_vpmovsxwq_ymm_m64(dst, src)) } +inst_vpmovsxdq_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVSXDQ, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 1404) } +inst_vpmovsxdq_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVSXDQ, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 8), {}, {}} }, 1404) } +inst_vpmovsxdq_ymm_xmm :: #force_inline proc "contextless" (dst: YMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVSXDQ, operand_count = 2, ops = {op_ymm(dst), op_xmm(src), {}, {}} }, 1405) } +inst_vpmovsxdq_ymm_m128 :: #force_inline proc "contextless" (dst: YMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVSXDQ, operand_count = 2, ops = {op_ymm(dst), op_mem(src.mem, 16), {}, {}} }, 1405) } +emit_vpmovsxdq_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_vpmovsxdq_xmm_xmm(dst, src)) } +emit_vpmovsxdq_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem64) { append(instructions, inst_vpmovsxdq_xmm_m64(dst, src)) } +emit_vpmovsxdq_ymm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: XMM) { append(instructions, inst_vpmovsxdq_ymm_xmm(dst, src)) } +emit_vpmovsxdq_ymm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem128) { append(instructions, inst_vpmovsxdq_ymm_m128(dst, src)) } +inst_vpmovzxbw_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVZXBW, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 1406) } +inst_vpmovzxbw_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVZXBW, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 8), {}, {}} }, 1406) } +inst_vpmovzxbw_ymm_xmm :: #force_inline proc "contextless" (dst: YMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVZXBW, operand_count = 2, ops = {op_ymm(dst), op_xmm(src), {}, {}} }, 1407) } +inst_vpmovzxbw_ymm_m128 :: #force_inline proc "contextless" (dst: YMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVZXBW, operand_count = 2, ops = {op_ymm(dst), op_mem(src.mem, 16), {}, {}} }, 1407) } +emit_vpmovzxbw_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_vpmovzxbw_xmm_xmm(dst, src)) } +emit_vpmovzxbw_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem64) { append(instructions, inst_vpmovzxbw_xmm_m64(dst, src)) } +emit_vpmovzxbw_ymm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: XMM) { append(instructions, inst_vpmovzxbw_ymm_xmm(dst, src)) } +emit_vpmovzxbw_ymm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem128) { append(instructions, inst_vpmovzxbw_ymm_m128(dst, src)) } +inst_vpmovzxbd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVZXBD, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 1408) } +inst_vpmovzxbd_xmm_m32 :: #force_inline proc "contextless" (dst: XMM, src: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVZXBD, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 4), {}, {}} }, 1408) } +inst_vpmovzxbd_ymm_xmm :: #force_inline proc "contextless" (dst: YMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVZXBD, operand_count = 2, ops = {op_ymm(dst), op_xmm(src), {}, {}} }, 1409) } +inst_vpmovzxbd_ymm_m64 :: #force_inline proc "contextless" (dst: YMM, src: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVZXBD, operand_count = 2, ops = {op_ymm(dst), op_mem(src.mem, 8), {}, {}} }, 1409) } +emit_vpmovzxbd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_vpmovzxbd_xmm_xmm(dst, src)) } +emit_vpmovzxbd_xmm_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem32) { append(instructions, inst_vpmovzxbd_xmm_m32(dst, src)) } +emit_vpmovzxbd_ymm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: XMM) { append(instructions, inst_vpmovzxbd_ymm_xmm(dst, src)) } +emit_vpmovzxbd_ymm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem64) { append(instructions, inst_vpmovzxbd_ymm_m64(dst, src)) } +inst_vpmovzxbq_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVZXBQ, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 1410) } +inst_vpmovzxbq_ymm_xmm :: #force_inline proc "contextless" (dst: YMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVZXBQ, operand_count = 2, ops = {op_ymm(dst), op_xmm(src), {}, {}} }, 1411) } +inst_vpmovzxbq_ymm_m32 :: #force_inline proc "contextless" (dst: YMM, src: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVZXBQ, operand_count = 2, ops = {op_ymm(dst), op_mem(src.mem, 4), {}, {}} }, 1411) } +emit_vpmovzxbq_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_vpmovzxbq_xmm_xmm(dst, src)) } +emit_vpmovzxbq_ymm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: XMM) { append(instructions, inst_vpmovzxbq_ymm_xmm(dst, src)) } +emit_vpmovzxbq_ymm_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem32) { append(instructions, inst_vpmovzxbq_ymm_m32(dst, src)) } +inst_vpmovzxwd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVZXWD, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 1412) } +inst_vpmovzxwd_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVZXWD, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 8), {}, {}} }, 1412) } +inst_vpmovzxwd_ymm_xmm :: #force_inline proc "contextless" (dst: YMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVZXWD, operand_count = 2, ops = {op_ymm(dst), op_xmm(src), {}, {}} }, 1413) } +inst_vpmovzxwd_ymm_m128 :: #force_inline proc "contextless" (dst: YMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVZXWD, operand_count = 2, ops = {op_ymm(dst), op_mem(src.mem, 16), {}, {}} }, 1413) } +emit_vpmovzxwd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_vpmovzxwd_xmm_xmm(dst, src)) } +emit_vpmovzxwd_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem64) { append(instructions, inst_vpmovzxwd_xmm_m64(dst, src)) } +emit_vpmovzxwd_ymm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: XMM) { append(instructions, inst_vpmovzxwd_ymm_xmm(dst, src)) } +emit_vpmovzxwd_ymm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem128) { append(instructions, inst_vpmovzxwd_ymm_m128(dst, src)) } +inst_vpmovzxwq_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVZXWQ, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 1414) } +inst_vpmovzxwq_xmm_m32 :: #force_inline proc "contextless" (dst: XMM, src: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVZXWQ, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 4), {}, {}} }, 1414) } +inst_vpmovzxwq_ymm_xmm :: #force_inline proc "contextless" (dst: YMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVZXWQ, operand_count = 2, ops = {op_ymm(dst), op_xmm(src), {}, {}} }, 1415) } +inst_vpmovzxwq_ymm_m64 :: #force_inline proc "contextless" (dst: YMM, src: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVZXWQ, operand_count = 2, ops = {op_ymm(dst), op_mem(src.mem, 8), {}, {}} }, 1415) } +emit_vpmovzxwq_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_vpmovzxwq_xmm_xmm(dst, src)) } +emit_vpmovzxwq_xmm_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem32) { append(instructions, inst_vpmovzxwq_xmm_m32(dst, src)) } +emit_vpmovzxwq_ymm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: XMM) { append(instructions, inst_vpmovzxwq_ymm_xmm(dst, src)) } +emit_vpmovzxwq_ymm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem64) { append(instructions, inst_vpmovzxwq_ymm_m64(dst, src)) } +inst_vpmovzxdq_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVZXDQ, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 1416) } +inst_vpmovzxdq_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVZXDQ, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 8), {}, {}} }, 1416) } +inst_vpmovzxdq_ymm_xmm :: #force_inline proc "contextless" (dst: YMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVZXDQ, operand_count = 2, ops = {op_ymm(dst), op_xmm(src), {}, {}} }, 1417) } +inst_vpmovzxdq_ymm_m128 :: #force_inline proc "contextless" (dst: YMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVZXDQ, operand_count = 2, ops = {op_ymm(dst), op_mem(src.mem, 16), {}, {}} }, 1417) } +emit_vpmovzxdq_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_vpmovzxdq_xmm_xmm(dst, src)) } +emit_vpmovzxdq_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem64) { append(instructions, inst_vpmovzxdq_xmm_m64(dst, src)) } +emit_vpmovzxdq_ymm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: XMM) { append(instructions, inst_vpmovzxdq_ymm_xmm(dst, src)) } +emit_vpmovzxdq_ymm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem128) { append(instructions, inst_vpmovzxdq_ymm_m128(dst, src)) } +inst_vpmuldq_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMULDQ, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1418) } +inst_vpmuldq_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMULDQ, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1418) } +inst_vpmuldq_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMULDQ, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1419) } +inst_vpmuldq_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMULDQ, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1419) } +emit_vpmuldq_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vpmuldq_xmm_xmm_xmm(dst, src, src2)) } +emit_vpmuldq_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vpmuldq_xmm_xmm_m128(dst, src, src2)) } +emit_vpmuldq_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vpmuldq_ymm_ymm_ymm(dst, src, src2)) } +emit_vpmuldq_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vpmuldq_ymm_ymm_m256(dst, src, src2)) } +inst_vpmulld_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMULLD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1420) } +inst_vpmulld_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMULLD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1420) } +inst_vpmulld_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMULLD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1421) } +inst_vpmulld_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMULLD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1421) } +emit_vpmulld_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vpmulld_xmm_xmm_xmm(dst, src, src2)) } +emit_vpmulld_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vpmulld_xmm_xmm_m128(dst, src, src2)) } +emit_vpmulld_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vpmulld_ymm_ymm_ymm(dst, src, src2)) } +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)} } } @@ -4705,48 +4705,48 @@ emit_vpclmulqdq_xmm_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynami 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)) } emit_vpclmulqdq_ymm_ymm_m256_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256, imm: i8) { append(instructions, inst_vpclmulqdq_ymm_ymm_m256_imm8(dst, src, src2, imm)) } -inst_vaesdec_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VAESDEC, Register(dst), Register(src), Register(src2)) } -inst_vaesdec_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VAESDEC, Register(dst), Register(src), src2.mem, 16) } -emit_vaesdec_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VAESDEC, Register(dst), Register(src), Register(src2)) } -emit_vaesdec_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VAESDEC, Register(dst), Register(src), src2.mem, 16) } -inst_vaesdeclast_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VAESDECLAST, Register(dst), Register(src), Register(src2)) } -inst_vaesdeclast_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VAESDECLAST, Register(dst), Register(src), src2.mem, 16) } -emit_vaesdeclast_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VAESDECLAST, Register(dst), Register(src), Register(src2)) } -emit_vaesdeclast_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VAESDECLAST, Register(dst), Register(src), src2.mem, 16) } -inst_vaesenc_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VAESENC, Register(dst), Register(src), Register(src2)) } -inst_vaesenc_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VAESENC, Register(dst), Register(src), src2.mem, 16) } -emit_vaesenc_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VAESENC, Register(dst), Register(src), Register(src2)) } -emit_vaesenc_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VAESENC, Register(dst), Register(src), src2.mem, 16) } -inst_vaesenclast_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VAESENCLAST, Register(dst), Register(src), Register(src2)) } -inst_vaesenclast_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VAESENCLAST, Register(dst), Register(src), src2.mem, 16) } -emit_vaesenclast_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VAESENCLAST, Register(dst), Register(src), Register(src2)) } -emit_vaesenclast_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VAESENCLAST, Register(dst), Register(src), src2.mem, 16) } -inst_vaesimc_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.VAESIMC, Register(dst), Register(src)) } -inst_vaesimc_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.VAESIMC, Register(dst), src.mem, 16) } -emit_vaesimc_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .VAESIMC, Register(dst), Register(src)) } -emit_vaesimc_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .VAESIMC, Register(dst), src.mem, 16) } -inst_vaeskeygenassist_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return inst_r_r_i(.VAESKEYGENASSIST, Register(dst), Register(src), i64(imm), 1) } -inst_vaeskeygenassist_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem128, imm: i8) -> Instruction { return inst_r_m_i(.VAESKEYGENASSIST, Register(dst), src.mem, 16, i64(imm), 1) } -emit_vaeskeygenassist_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, imm: i8) { emit_rri(instructions, .VAESKEYGENASSIST, Register(dst), Register(src), i64(imm), 1) } -emit_vaeskeygenassist_xmm_m128_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128, imm: i8) { emit_rmi(instructions, .VAESKEYGENASSIST, Register(dst), src.mem, 16, i64(imm), 1) } -inst_vbroadcastss_xmm_m32 :: #force_inline proc "contextless" (dst: XMM, src: Mem32) -> Instruction { return inst_r_m(.VBROADCASTSS, Register(dst), src.mem, 4) } -inst_vbroadcastss_ymm_m32 :: #force_inline proc "contextless" (dst: YMM, src: Mem32) -> Instruction { return inst_r_m(.VBROADCASTSS, Register(dst), src.mem, 4) } -inst_vbroadcastss_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.VBROADCASTSS, Register(dst), Register(src)) } -inst_vbroadcastss_ymm_xmm :: #force_inline proc "contextless" (dst: YMM, src: XMM) -> Instruction { return inst_r_r(.VBROADCASTSS, Register(dst), Register(src)) } -emit_vbroadcastss_xmm_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem32) { emit_rm(instructions, .VBROADCASTSS, Register(dst), src.mem, 4) } -emit_vbroadcastss_ymm_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem32) { emit_rm(instructions, .VBROADCASTSS, Register(dst), src.mem, 4) } -emit_vbroadcastss_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .VBROADCASTSS, Register(dst), Register(src)) } -emit_vbroadcastss_ymm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: XMM) { emit_rr(instructions, .VBROADCASTSS, Register(dst), Register(src)) } -inst_vbroadcastsd_ymm_m64 :: #force_inline proc "contextless" (dst: YMM, src: Mem64) -> Instruction { return inst_r_m(.VBROADCASTSD, Register(dst), src.mem, 8) } -inst_vbroadcastsd_ymm_xmm :: #force_inline proc "contextless" (dst: YMM, src: XMM) -> Instruction { return inst_r_r(.VBROADCASTSD, Register(dst), Register(src)) } -emit_vbroadcastsd_ymm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem64) { emit_rm(instructions, .VBROADCASTSD, Register(dst), src.mem, 8) } -emit_vbroadcastsd_ymm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: XMM) { emit_rr(instructions, .VBROADCASTSD, Register(dst), Register(src)) } -inst_vbroadcastf128_ymm_m128 :: #force_inline proc "contextless" (dst: YMM, src: Mem128) -> Instruction { return inst_r_m(.VBROADCASTF128, Register(dst), src.mem, 16) } -emit_vbroadcastf128_ymm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem128) { emit_rm(instructions, .VBROADCASTF128, Register(dst), src.mem, 16) } -inst_vextractf128_xmm_ymm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: YMM, imm: i8) -> Instruction { return inst_r_r_i(.VEXTRACTF128, Register(dst), Register(src), i64(imm), 1) } -inst_vextractf128_m128_ymm_imm8 :: #force_inline proc "contextless" (dst: Mem128, src: YMM, imm: i8) -> Instruction { return inst_m_r_i(.VEXTRACTF128, dst.mem, 16, Register(src), i64(imm), 1) } -emit_vextractf128_xmm_ymm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: YMM, imm: i8) { emit_rri(instructions, .VEXTRACTF128, Register(dst), Register(src), i64(imm), 1) } -emit_vextractf128_m128_ymm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem128, src: YMM, imm: i8) { emit_mri(instructions, .VEXTRACTF128, dst.mem, 16, Register(src), i64(imm), 1) } +inst_vaesdec_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VAESDEC, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1425) } +inst_vaesdec_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VAESDEC, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1425) } +emit_vaesdec_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vaesdec_xmm_xmm_xmm(dst, src, src2)) } +emit_vaesdec_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vaesdec_xmm_xmm_m128(dst, src, src2)) } +inst_vaesdeclast_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VAESDECLAST, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1426) } +inst_vaesdeclast_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VAESDECLAST, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1426) } +emit_vaesdeclast_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vaesdeclast_xmm_xmm_xmm(dst, src, src2)) } +emit_vaesdeclast_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vaesdeclast_xmm_xmm_m128(dst, src, src2)) } +inst_vaesenc_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VAESENC, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1427) } +inst_vaesenc_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VAESENC, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1427) } +emit_vaesenc_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vaesenc_xmm_xmm_xmm(dst, src, src2)) } +emit_vaesenc_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vaesenc_xmm_xmm_m128(dst, src, src2)) } +inst_vaesenclast_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VAESENCLAST, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1428) } +inst_vaesenclast_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VAESENCLAST, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1428) } +emit_vaesenclast_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vaesenclast_xmm_xmm_xmm(dst, src, src2)) } +emit_vaesenclast_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vaesenclast_xmm_xmm_m128(dst, src, src2)) } +inst_vaesimc_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VAESIMC, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 1429) } +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), {}} } } +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) } +inst_vbroadcastss_ymm_m32 :: #force_inline proc "contextless" (dst: YMM, src: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .VBROADCASTSS, operand_count = 2, ops = {op_ymm(dst), op_mem(src.mem, 4), {}, {}} }, 1432) } +inst_vbroadcastss_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VBROADCASTSS, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 1433) } +inst_vbroadcastss_ymm_xmm :: #force_inline proc "contextless" (dst: YMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VBROADCASTSS, operand_count = 2, ops = {op_ymm(dst), op_xmm(src), {}, {}} }, 1434) } +emit_vbroadcastss_xmm_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem32) { append(instructions, inst_vbroadcastss_xmm_m32(dst, src)) } +emit_vbroadcastss_ymm_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem32) { append(instructions, inst_vbroadcastss_ymm_m32(dst, src)) } +emit_vbroadcastss_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_vbroadcastss_xmm_xmm(dst, src)) } +emit_vbroadcastss_ymm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: XMM) { append(instructions, inst_vbroadcastss_ymm_xmm(dst, src)) } +inst_vbroadcastsd_ymm_m64 :: #force_inline proc "contextless" (dst: YMM, src: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .VBROADCASTSD, operand_count = 2, ops = {op_ymm(dst), op_mem(src.mem, 8), {}, {}} }, 1435) } +inst_vbroadcastsd_ymm_xmm :: #force_inline proc "contextless" (dst: YMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VBROADCASTSD, operand_count = 2, ops = {op_ymm(dst), op_xmm(src), {}, {}} }, 1436) } +emit_vbroadcastsd_ymm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem64) { append(instructions, inst_vbroadcastsd_ymm_m64(dst, src)) } +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), {}} } } +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)} } } 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)) } @@ -4755,48 +4755,48 @@ inst_vperm2f128_ymm_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: YM 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)} } } 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 inst_r_r_m(.VMASKMOVPS, Register(dst), Register(src), src2.mem, 16) } -inst_vmaskmovps_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VMASKMOVPS, Register(dst), Register(src), src2.mem, 32) } -inst_vmaskmovps_m128_xmm_xmm :: #force_inline proc "contextless" (dst: Mem128, src: XMM, src2: XMM) -> Instruction { return Instruction{ mnemonic = .VMASKMOVPS, operand_count = 3, ops = {op_mem(dst.mem, 16), op_xmm(src), op_xmm(src2), {}} } } -inst_vmaskmovps_m256_ymm_ymm :: #force_inline proc "contextless" (dst: Mem256, src: YMM, src2: YMM) -> Instruction { return Instruction{ mnemonic = .VMASKMOVPS, operand_count = 3, ops = {op_mem(dst.mem, 32), op_ymm(src), op_ymm(src2), {}} } } -emit_vmaskmovps_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VMASKMOVPS, Register(dst), Register(src), src2.mem, 16) } -emit_vmaskmovps_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VMASKMOVPS, Register(dst), Register(src), src2.mem, 32) } +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) } +inst_vmaskmovps_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VMASKMOVPS, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1442) } +inst_vmaskmovps_m128_xmm_xmm :: #force_inline proc "contextless" (dst: Mem128, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VMASKMOVPS, operand_count = 3, ops = {op_mem(dst.mem, 16), op_xmm(src), op_xmm(src2), {}} }, 1443) } +inst_vmaskmovps_m256_ymm_ymm :: #force_inline proc "contextless" (dst: Mem256, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VMASKMOVPS, operand_count = 3, ops = {op_mem(dst.mem, 32), op_ymm(src), op_ymm(src2), {}} }, 1444) } +emit_vmaskmovps_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vmaskmovps_xmm_xmm_m128(dst, src, src2)) } +emit_vmaskmovps_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vmaskmovps_ymm_ymm_m256(dst, src, src2)) } emit_vmaskmovps_m128_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem128, src: XMM, src2: XMM) { append(instructions, inst_vmaskmovps_m128_xmm_xmm(dst, src, src2)) } emit_vmaskmovps_m256_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem256, src: YMM, src2: YMM) { append(instructions, inst_vmaskmovps_m256_ymm_ymm(dst, src, src2)) } -inst_vmaskmovpd_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VMASKMOVPD, Register(dst), Register(src), src2.mem, 16) } -inst_vmaskmovpd_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VMASKMOVPD, Register(dst), Register(src), src2.mem, 32) } -inst_vmaskmovpd_m128_xmm_xmm :: #force_inline proc "contextless" (dst: Mem128, src: XMM, src2: XMM) -> Instruction { return Instruction{ mnemonic = .VMASKMOVPD, operand_count = 3, ops = {op_mem(dst.mem, 16), op_xmm(src), op_xmm(src2), {}} } } -inst_vmaskmovpd_m256_ymm_ymm :: #force_inline proc "contextless" (dst: Mem256, src: YMM, src2: YMM) -> Instruction { return Instruction{ mnemonic = .VMASKMOVPD, operand_count = 3, ops = {op_mem(dst.mem, 32), op_ymm(src), op_ymm(src2), {}} } } -emit_vmaskmovpd_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VMASKMOVPD, Register(dst), Register(src), src2.mem, 16) } -emit_vmaskmovpd_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VMASKMOVPD, Register(dst), Register(src), src2.mem, 32) } +inst_vmaskmovpd_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VMASKMOVPD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1445) } +inst_vmaskmovpd_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VMASKMOVPD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1446) } +inst_vmaskmovpd_m128_xmm_xmm :: #force_inline proc "contextless" (dst: Mem128, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VMASKMOVPD, operand_count = 3, ops = {op_mem(dst.mem, 16), op_xmm(src), op_xmm(src2), {}} }, 1447) } +inst_vmaskmovpd_m256_ymm_ymm :: #force_inline proc "contextless" (dst: Mem256, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VMASKMOVPD, operand_count = 3, ops = {op_mem(dst.mem, 32), op_ymm(src), op_ymm(src2), {}} }, 1448) } +emit_vmaskmovpd_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vmaskmovpd_xmm_xmm_m128(dst, src, src2)) } +emit_vmaskmovpd_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vmaskmovpd_ymm_ymm_m256(dst, src, src2)) } emit_vmaskmovpd_m128_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem128, src: XMM, src2: XMM) { append(instructions, inst_vmaskmovpd_m128_xmm_xmm(dst, src, src2)) } emit_vmaskmovpd_m256_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem256, src: YMM, src2: YMM) { append(instructions, inst_vmaskmovpd_m256_ymm_ymm(dst, src, src2)) } -inst_vtestps_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.VTESTPS, Register(dst), Register(src)) } -inst_vtestps_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.VTESTPS, Register(dst), src.mem, 16) } -inst_vtestps_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM) -> Instruction { return inst_r_r(.VTESTPS, Register(dst), Register(src)) } -inst_vtestps_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: Mem256) -> Instruction { return inst_r_m(.VTESTPS, Register(dst), src.mem, 32) } -emit_vtestps_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .VTESTPS, Register(dst), Register(src)) } -emit_vtestps_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .VTESTPS, Register(dst), src.mem, 16) } -emit_vtestps_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM) { emit_rr(instructions, .VTESTPS, Register(dst), Register(src)) } -emit_vtestps_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem256) { emit_rm(instructions, .VTESTPS, Register(dst), src.mem, 32) } -inst_vtestpd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.VTESTPD, Register(dst), Register(src)) } -inst_vtestpd_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.VTESTPD, Register(dst), src.mem, 16) } -inst_vtestpd_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM) -> Instruction { return inst_r_r(.VTESTPD, Register(dst), Register(src)) } -inst_vtestpd_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: Mem256) -> Instruction { return inst_r_m(.VTESTPD, Register(dst), src.mem, 32) } -emit_vtestpd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .VTESTPD, Register(dst), Register(src)) } -emit_vtestpd_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .VTESTPD, Register(dst), src.mem, 16) } -emit_vtestpd_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM) { emit_rr(instructions, .VTESTPD, Register(dst), Register(src)) } -emit_vtestpd_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem256) { emit_rm(instructions, .VTESTPD, Register(dst), src.mem, 32) } -inst_vzeroall_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.VZEROALL) } -emit_vzeroall_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .VZEROALL) } -inst_vzeroupper_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.VZEROUPPER) } -emit_vzeroupper_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .VZEROUPPER) } -inst_vbroadcasti128_ymm_m128 :: #force_inline proc "contextless" (dst: YMM, src: Mem128) -> Instruction { return inst_r_m(.VBROADCASTI128, Register(dst), src.mem, 16) } -emit_vbroadcasti128_ymm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem128) { emit_rm(instructions, .VBROADCASTI128, Register(dst), src.mem, 16) } -inst_vextracti128_xmm_ymm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: YMM, imm: i8) -> Instruction { return inst_r_r_i(.VEXTRACTI128, Register(dst), Register(src), i64(imm), 1) } -inst_vextracti128_m128_ymm_imm8 :: #force_inline proc "contextless" (dst: Mem128, src: YMM, imm: i8) -> Instruction { return inst_m_r_i(.VEXTRACTI128, dst.mem, 16, Register(src), i64(imm), 1) } -emit_vextracti128_xmm_ymm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: YMM, imm: i8) { emit_rri(instructions, .VEXTRACTI128, Register(dst), Register(src), i64(imm), 1) } -emit_vextracti128_m128_ymm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem128, src: YMM, imm: i8) { emit_mri(instructions, .VEXTRACTI128, dst.mem, 16, Register(src), i64(imm), 1) } +inst_vtestps_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VTESTPS, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 1449) } +inst_vtestps_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VTESTPS, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 1449) } +inst_vtestps_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VTESTPS, operand_count = 2, ops = {op_ymm(dst), op_ymm(src), {}, {}} }, 1450) } +inst_vtestps_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VTESTPS, operand_count = 2, ops = {op_ymm(dst), op_mem(src.mem, 32), {}, {}} }, 1450) } +emit_vtestps_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_vtestps_xmm_xmm(dst, src)) } +emit_vtestps_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_vtestps_xmm_m128(dst, src)) } +emit_vtestps_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM) { append(instructions, inst_vtestps_ymm_ymm(dst, src)) } +emit_vtestps_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem256) { append(instructions, inst_vtestps_ymm_m256(dst, src)) } +inst_vtestpd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VTESTPD, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 1451) } +inst_vtestpd_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VTESTPD, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 1451) } +inst_vtestpd_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VTESTPD, operand_count = 2, ops = {op_ymm(dst), op_ymm(src), {}, {}} }, 1452) } +inst_vtestpd_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VTESTPD, operand_count = 2, ops = {op_ymm(dst), op_mem(src.mem, 32), {}, {}} }, 1452) } +emit_vtestpd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_vtestpd_xmm_xmm(dst, src)) } +emit_vtestpd_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_vtestpd_xmm_m128(dst, src)) } +emit_vtestpd_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM) { append(instructions, inst_vtestpd_ymm_ymm(dst, src)) } +emit_vtestpd_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem256) { append(instructions, inst_vtestpd_ymm_m256(dst, src)) } +inst_vzeroall_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .VZEROALL, operand_count = 0, ops = {{}, {}, {}, {}} }, 1453) } +emit_vzeroall_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_vzeroall_none()) } +inst_vzeroupper_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .VZEROUPPER, operand_count = 0, ops = {{}, {}, {}, {}} }, 1454) } +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), {}} } } +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)} } } 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)) } @@ -4805,22 +4805,22 @@ inst_vperm2i128_ymm_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: YM 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)} } } 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 inst_r_r_r(.VPERMD, Register(dst), Register(src), Register(src2)) } -inst_vpermd_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VPERMD, Register(dst), Register(src), src2.mem, 32) } -emit_vpermd_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VPERMD, Register(dst), Register(src), Register(src2)) } -emit_vpermd_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VPERMD, Register(dst), Register(src), src2.mem, 32) } -inst_vpermps_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VPERMPS, Register(dst), Register(src), Register(src2)) } -inst_vpermps_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VPERMPS, Register(dst), Register(src), src2.mem, 32) } -emit_vpermps_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VPERMPS, Register(dst), Register(src), Register(src2)) } -emit_vpermps_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VPERMPS, Register(dst), Register(src), src2.mem, 32) } -inst_vpermq_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, imm: i8) -> Instruction { return inst_r_r_i(.VPERMQ, Register(dst), Register(src), i64(imm), 1) } -inst_vpermq_ymm_m256_imm8 :: #force_inline proc "contextless" (dst: YMM, src: Mem256, imm: i8) -> Instruction { return inst_r_m_i(.VPERMQ, Register(dst), src.mem, 32, i64(imm), 1) } -emit_vpermq_ymm_ymm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, imm: i8) { emit_rri(instructions, .VPERMQ, Register(dst), Register(src), i64(imm), 1) } -emit_vpermq_ymm_m256_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem256, imm: i8) { emit_rmi(instructions, .VPERMQ, Register(dst), src.mem, 32, i64(imm), 1) } -inst_vpermpd_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, imm: i8) -> Instruction { return inst_r_r_i(.VPERMPD, Register(dst), Register(src), i64(imm), 1) } -inst_vpermpd_ymm_m256_imm8 :: #force_inline proc "contextless" (dst: YMM, src: Mem256, imm: i8) -> Instruction { return inst_r_m_i(.VPERMPD, Register(dst), src.mem, 32, i64(imm), 1) } -emit_vpermpd_ymm_ymm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, imm: i8) { emit_rri(instructions, .VPERMPD, Register(dst), Register(src), i64(imm), 1) } -emit_vpermpd_ymm_m256_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem256, imm: i8) { emit_rmi(instructions, .VPERMPD, Register(dst), src.mem, 32, i64(imm), 1) } +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) } +inst_vpermd_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VPERMD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1459) } +emit_vpermd_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vpermd_ymm_ymm_ymm(dst, src, src2)) } +emit_vpermd_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vpermd_ymm_ymm_m256(dst, src, src2)) } +inst_vpermps_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPERMPS, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1460) } +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), {}} } } +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), {}} } } +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)} } } @@ -4829,678 +4829,678 @@ emit_vpblendd_xmm_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynami 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)) } emit_vpblendd_ymm_ymm_m256_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256, imm: i8) { append(instructions, inst_vpblendd_ymm_ymm_m256_imm8(dst, src, src2, imm)) } -inst_vpsllvd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VPSLLVD, Register(dst), Register(src), Register(src2)) } -inst_vpsllvd_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VPSLLVD, Register(dst), Register(src), src2.mem, 16) } -inst_vpsllvd_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VPSLLVD, Register(dst), Register(src), Register(src2)) } -inst_vpsllvd_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VPSLLVD, Register(dst), Register(src), src2.mem, 32) } -emit_vpsllvd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VPSLLVD, Register(dst), Register(src), Register(src2)) } -emit_vpsllvd_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VPSLLVD, Register(dst), Register(src), src2.mem, 16) } -emit_vpsllvd_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VPSLLVD, Register(dst), Register(src), Register(src2)) } -emit_vpsllvd_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VPSLLVD, Register(dst), Register(src), src2.mem, 32) } -inst_vpsllvq_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VPSLLVQ, Register(dst), Register(src), Register(src2)) } -inst_vpsllvq_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VPSLLVQ, Register(dst), Register(src), src2.mem, 16) } -inst_vpsllvq_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VPSLLVQ, Register(dst), Register(src), Register(src2)) } -inst_vpsllvq_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VPSLLVQ, Register(dst), Register(src), src2.mem, 32) } -emit_vpsllvq_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VPSLLVQ, Register(dst), Register(src), Register(src2)) } -emit_vpsllvq_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VPSLLVQ, Register(dst), Register(src), src2.mem, 16) } -emit_vpsllvq_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VPSLLVQ, Register(dst), Register(src), Register(src2)) } -emit_vpsllvq_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VPSLLVQ, Register(dst), Register(src), src2.mem, 32) } -inst_vpsrlvd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VPSRLVD, Register(dst), Register(src), Register(src2)) } -inst_vpsrlvd_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VPSRLVD, Register(dst), Register(src), src2.mem, 16) } -inst_vpsrlvd_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VPSRLVD, Register(dst), Register(src), Register(src2)) } -inst_vpsrlvd_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VPSRLVD, Register(dst), Register(src), src2.mem, 32) } -emit_vpsrlvd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VPSRLVD, Register(dst), Register(src), Register(src2)) } -emit_vpsrlvd_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VPSRLVD, Register(dst), Register(src), src2.mem, 16) } -emit_vpsrlvd_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VPSRLVD, Register(dst), Register(src), Register(src2)) } -emit_vpsrlvd_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VPSRLVD, Register(dst), Register(src), src2.mem, 32) } -inst_vpsrlvq_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VPSRLVQ, Register(dst), Register(src), Register(src2)) } -inst_vpsrlvq_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VPSRLVQ, Register(dst), Register(src), src2.mem, 16) } -inst_vpsrlvq_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VPSRLVQ, Register(dst), Register(src), Register(src2)) } -inst_vpsrlvq_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VPSRLVQ, Register(dst), Register(src), src2.mem, 32) } -emit_vpsrlvq_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VPSRLVQ, Register(dst), Register(src), Register(src2)) } -emit_vpsrlvq_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VPSRLVQ, Register(dst), Register(src), src2.mem, 16) } -emit_vpsrlvq_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VPSRLVQ, Register(dst), Register(src), Register(src2)) } -emit_vpsrlvq_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VPSRLVQ, Register(dst), Register(src), src2.mem, 32) } -inst_vpsravd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VPSRAVD, Register(dst), Register(src), Register(src2)) } -inst_vpsravd_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VPSRAVD, Register(dst), Register(src), src2.mem, 16) } -inst_vpsravd_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VPSRAVD, Register(dst), Register(src), Register(src2)) } -inst_vpsravd_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VPSRAVD, Register(dst), Register(src), src2.mem, 32) } -emit_vpsravd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VPSRAVD, Register(dst), Register(src), Register(src2)) } -emit_vpsravd_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VPSRAVD, Register(dst), Register(src), src2.mem, 16) } -emit_vpsravd_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VPSRAVD, Register(dst), Register(src), Register(src2)) } -emit_vpsravd_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VPSRAVD, Register(dst), Register(src), src2.mem, 32) } -inst_vpmaskmovd_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VPMASKMOVD, Register(dst), Register(src), src2.mem, 16) } -inst_vpmaskmovd_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VPMASKMOVD, Register(dst), Register(src), src2.mem, 32) } -inst_vpmaskmovd_m128_xmm_xmm :: #force_inline proc "contextless" (dst: Mem128, src: XMM, src2: XMM) -> Instruction { return Instruction{ mnemonic = .VPMASKMOVD, operand_count = 3, ops = {op_mem(dst.mem, 16), op_xmm(src), op_xmm(src2), {}} } } -inst_vpmaskmovd_m256_ymm_ymm :: #force_inline proc "contextless" (dst: Mem256, src: YMM, src2: YMM) -> Instruction { return Instruction{ mnemonic = .VPMASKMOVD, operand_count = 3, ops = {op_mem(dst.mem, 32), op_ymm(src), op_ymm(src2), {}} } } -emit_vpmaskmovd_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VPMASKMOVD, Register(dst), Register(src), src2.mem, 16) } -emit_vpmaskmovd_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VPMASKMOVD, Register(dst), Register(src), src2.mem, 32) } +inst_vpsllvd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSLLVD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1465) } +inst_vpsllvd_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSLLVD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1465) } +inst_vpsllvd_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSLLVD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1466) } +inst_vpsllvd_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSLLVD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1466) } +emit_vpsllvd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vpsllvd_xmm_xmm_xmm(dst, src, src2)) } +emit_vpsllvd_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vpsllvd_xmm_xmm_m128(dst, src, src2)) } +emit_vpsllvd_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vpsllvd_ymm_ymm_ymm(dst, src, src2)) } +emit_vpsllvd_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vpsllvd_ymm_ymm_m256(dst, src, src2)) } +inst_vpsllvq_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSLLVQ, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1467) } +inst_vpsllvq_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSLLVQ, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1467) } +inst_vpsllvq_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSLLVQ, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1468) } +inst_vpsllvq_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSLLVQ, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1468) } +emit_vpsllvq_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vpsllvq_xmm_xmm_xmm(dst, src, src2)) } +emit_vpsllvq_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vpsllvq_xmm_xmm_m128(dst, src, src2)) } +emit_vpsllvq_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vpsllvq_ymm_ymm_ymm(dst, src, src2)) } +emit_vpsllvq_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vpsllvq_ymm_ymm_m256(dst, src, src2)) } +inst_vpsrlvd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSRLVD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1469) } +inst_vpsrlvd_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSRLVD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1469) } +inst_vpsrlvd_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSRLVD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1470) } +inst_vpsrlvd_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSRLVD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1470) } +emit_vpsrlvd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vpsrlvd_xmm_xmm_xmm(dst, src, src2)) } +emit_vpsrlvd_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vpsrlvd_xmm_xmm_m128(dst, src, src2)) } +emit_vpsrlvd_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vpsrlvd_ymm_ymm_ymm(dst, src, src2)) } +emit_vpsrlvd_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vpsrlvd_ymm_ymm_m256(dst, src, src2)) } +inst_vpsrlvq_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSRLVQ, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1471) } +inst_vpsrlvq_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSRLVQ, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1471) } +inst_vpsrlvq_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSRLVQ, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1472) } +inst_vpsrlvq_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSRLVQ, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1472) } +emit_vpsrlvq_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vpsrlvq_xmm_xmm_xmm(dst, src, src2)) } +emit_vpsrlvq_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vpsrlvq_xmm_xmm_m128(dst, src, src2)) } +emit_vpsrlvq_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vpsrlvq_ymm_ymm_ymm(dst, src, src2)) } +emit_vpsrlvq_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vpsrlvq_ymm_ymm_m256(dst, src, src2)) } +inst_vpsravd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSRAVD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1473) } +inst_vpsravd_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSRAVD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1473) } +inst_vpsravd_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSRAVD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1474) } +inst_vpsravd_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSRAVD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1474) } +emit_vpsravd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vpsravd_xmm_xmm_xmm(dst, src, src2)) } +emit_vpsravd_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vpsravd_xmm_xmm_m128(dst, src, src2)) } +emit_vpsravd_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vpsravd_ymm_ymm_ymm(dst, src, src2)) } +emit_vpsravd_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vpsravd_ymm_ymm_m256(dst, src, src2)) } +inst_vpmaskmovd_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMASKMOVD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1475) } +inst_vpmaskmovd_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMASKMOVD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1476) } +inst_vpmaskmovd_m128_xmm_xmm :: #force_inline proc "contextless" (dst: Mem128, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMASKMOVD, operand_count = 3, ops = {op_mem(dst.mem, 16), op_xmm(src), op_xmm(src2), {}} }, 1477) } +inst_vpmaskmovd_m256_ymm_ymm :: #force_inline proc "contextless" (dst: Mem256, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMASKMOVD, operand_count = 3, ops = {op_mem(dst.mem, 32), op_ymm(src), op_ymm(src2), {}} }, 1478) } +emit_vpmaskmovd_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vpmaskmovd_xmm_xmm_m128(dst, src, src2)) } +emit_vpmaskmovd_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vpmaskmovd_ymm_ymm_m256(dst, src, src2)) } emit_vpmaskmovd_m128_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem128, src: XMM, src2: XMM) { append(instructions, inst_vpmaskmovd_m128_xmm_xmm(dst, src, src2)) } emit_vpmaskmovd_m256_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem256, src: YMM, src2: YMM) { append(instructions, inst_vpmaskmovd_m256_ymm_ymm(dst, src, src2)) } -inst_vpmaskmovq_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VPMASKMOVQ, Register(dst), Register(src), src2.mem, 16) } -inst_vpmaskmovq_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VPMASKMOVQ, Register(dst), Register(src), src2.mem, 32) } -inst_vpmaskmovq_m128_xmm_xmm :: #force_inline proc "contextless" (dst: Mem128, src: XMM, src2: XMM) -> Instruction { return Instruction{ mnemonic = .VPMASKMOVQ, operand_count = 3, ops = {op_mem(dst.mem, 16), op_xmm(src), op_xmm(src2), {}} } } -inst_vpmaskmovq_m256_ymm_ymm :: #force_inline proc "contextless" (dst: Mem256, src: YMM, src2: YMM) -> Instruction { return Instruction{ mnemonic = .VPMASKMOVQ, operand_count = 3, ops = {op_mem(dst.mem, 32), op_ymm(src), op_ymm(src2), {}} } } -emit_vpmaskmovq_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VPMASKMOVQ, Register(dst), Register(src), src2.mem, 16) } -emit_vpmaskmovq_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VPMASKMOVQ, Register(dst), Register(src), src2.mem, 32) } +inst_vpmaskmovq_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMASKMOVQ, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1479) } +inst_vpmaskmovq_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMASKMOVQ, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1480) } +inst_vpmaskmovq_m128_xmm_xmm :: #force_inline proc "contextless" (dst: Mem128, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMASKMOVQ, operand_count = 3, ops = {op_mem(dst.mem, 16), op_xmm(src), op_xmm(src2), {}} }, 1481) } +inst_vpmaskmovq_m256_ymm_ymm :: #force_inline proc "contextless" (dst: Mem256, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMASKMOVQ, operand_count = 3, ops = {op_mem(dst.mem, 32), op_ymm(src), op_ymm(src2), {}} }, 1482) } +emit_vpmaskmovq_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vpmaskmovq_xmm_xmm_m128(dst, src, src2)) } +emit_vpmaskmovq_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vpmaskmovq_ymm_ymm_m256(dst, src, src2)) } emit_vpmaskmovq_m128_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem128, src: XMM, src2: XMM) { append(instructions, inst_vpmaskmovq_m128_xmm_xmm(dst, src, src2)) } emit_vpmaskmovq_m256_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem256, src: YMM, src2: YMM) { append(instructions, inst_vpmaskmovq_m256_ymm_ymm(dst, src, src2)) } -inst_vgatherdps_xmm_m_xmm :: #force_inline proc "contextless" (dst: XMM, src: Memory, src2: XMM) -> Instruction { return Instruction{ mnemonic = .VGATHERDPS, operand_count = 3, ops = {op_xmm(dst), op_mem(src, 0), op_xmm(src2), {}} } } -inst_vgatherdps_ymm_m_ymm :: #force_inline proc "contextless" (dst: YMM, src: Memory, src2: YMM) -> Instruction { return Instruction{ mnemonic = .VGATHERDPS, operand_count = 3, ops = {op_ymm(dst), op_mem(src, 0), op_ymm(src2), {}} } } +inst_vgatherdps_xmm_m_xmm :: #force_inline proc "contextless" (dst: XMM, src: Memory, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VGATHERDPS, operand_count = 3, ops = {op_xmm(dst), op_mem(src, 0), op_xmm(src2), {}} }, 1483) } +inst_vgatherdps_ymm_m_ymm :: #force_inline proc "contextless" (dst: YMM, src: Memory, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VGATHERDPS, operand_count = 3, ops = {op_ymm(dst), op_mem(src, 0), op_ymm(src2), {}} }, 1484) } emit_vgatherdps_xmm_m_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Memory, src2: XMM) { append(instructions, inst_vgatherdps_xmm_m_xmm(dst, src, src2)) } emit_vgatherdps_ymm_m_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Memory, src2: YMM) { append(instructions, inst_vgatherdps_ymm_m_ymm(dst, src, src2)) } -inst_vgatherdpd_xmm_m_xmm :: #force_inline proc "contextless" (dst: XMM, src: Memory, src2: XMM) -> Instruction { return Instruction{ mnemonic = .VGATHERDPD, operand_count = 3, ops = {op_xmm(dst), op_mem(src, 0), op_xmm(src2), {}} } } -inst_vgatherdpd_ymm_m_ymm :: #force_inline proc "contextless" (dst: YMM, src: Memory, src2: YMM) -> Instruction { return Instruction{ mnemonic = .VGATHERDPD, operand_count = 3, ops = {op_ymm(dst), op_mem(src, 0), op_ymm(src2), {}} } } +inst_vgatherdpd_xmm_m_xmm :: #force_inline proc "contextless" (dst: XMM, src: Memory, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VGATHERDPD, operand_count = 3, ops = {op_xmm(dst), op_mem(src, 0), op_xmm(src2), {}} }, 1485) } +inst_vgatherdpd_ymm_m_ymm :: #force_inline proc "contextless" (dst: YMM, src: Memory, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VGATHERDPD, operand_count = 3, ops = {op_ymm(dst), op_mem(src, 0), op_ymm(src2), {}} }, 1486) } emit_vgatherdpd_xmm_m_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Memory, src2: XMM) { append(instructions, inst_vgatherdpd_xmm_m_xmm(dst, src, src2)) } emit_vgatherdpd_ymm_m_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Memory, src2: YMM) { append(instructions, inst_vgatherdpd_ymm_m_ymm(dst, src, src2)) } -inst_vgatherqps_xmm_m_xmm :: #force_inline proc "contextless" (dst: XMM, src: Memory, src2: XMM) -> Instruction { return Instruction{ mnemonic = .VGATHERQPS, operand_count = 3, ops = {op_xmm(dst), op_mem(src, 0), op_xmm(src2), {}} } } +inst_vgatherqps_xmm_m_xmm :: #force_inline proc "contextless" (dst: XMM, src: Memory, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VGATHERQPS, operand_count = 3, ops = {op_xmm(dst), op_mem(src, 0), op_xmm(src2), {}} }, 1487) } emit_vgatherqps_xmm_m_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Memory, src2: XMM) { append(instructions, inst_vgatherqps_xmm_m_xmm(dst, src, src2)) } -inst_vgatherqpd_xmm_m_xmm :: #force_inline proc "contextless" (dst: XMM, src: Memory, src2: XMM) -> Instruction { return Instruction{ mnemonic = .VGATHERQPD, operand_count = 3, ops = {op_xmm(dst), op_mem(src, 0), op_xmm(src2), {}} } } -inst_vgatherqpd_ymm_m_ymm :: #force_inline proc "contextless" (dst: YMM, src: Memory, src2: YMM) -> Instruction { return Instruction{ mnemonic = .VGATHERQPD, operand_count = 3, ops = {op_ymm(dst), op_mem(src, 0), op_ymm(src2), {}} } } +inst_vgatherqpd_xmm_m_xmm :: #force_inline proc "contextless" (dst: XMM, src: Memory, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VGATHERQPD, operand_count = 3, ops = {op_xmm(dst), op_mem(src, 0), op_xmm(src2), {}} }, 1489) } +inst_vgatherqpd_ymm_m_ymm :: #force_inline proc "contextless" (dst: YMM, src: Memory, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VGATHERQPD, operand_count = 3, ops = {op_ymm(dst), op_mem(src, 0), op_ymm(src2), {}} }, 1490) } emit_vgatherqpd_xmm_m_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Memory, src2: XMM) { append(instructions, inst_vgatherqpd_xmm_m_xmm(dst, src, src2)) } emit_vgatherqpd_ymm_m_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Memory, src2: YMM) { append(instructions, inst_vgatherqpd_ymm_m_ymm(dst, src, src2)) } -inst_vpgatherdd_xmm_m_xmm :: #force_inline proc "contextless" (dst: XMM, src: Memory, src2: XMM) -> Instruction { return Instruction{ mnemonic = .VPGATHERDD, operand_count = 3, ops = {op_xmm(dst), op_mem(src, 0), op_xmm(src2), {}} } } -inst_vpgatherdd_ymm_m_ymm :: #force_inline proc "contextless" (dst: YMM, src: Memory, src2: YMM) -> Instruction { return Instruction{ mnemonic = .VPGATHERDD, operand_count = 3, ops = {op_ymm(dst), op_mem(src, 0), op_ymm(src2), {}} } } +inst_vpgatherdd_xmm_m_xmm :: #force_inline proc "contextless" (dst: XMM, src: Memory, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPGATHERDD, operand_count = 3, ops = {op_xmm(dst), op_mem(src, 0), op_xmm(src2), {}} }, 1491) } +inst_vpgatherdd_ymm_m_ymm :: #force_inline proc "contextless" (dst: YMM, src: Memory, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPGATHERDD, operand_count = 3, ops = {op_ymm(dst), op_mem(src, 0), op_ymm(src2), {}} }, 1492) } emit_vpgatherdd_xmm_m_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Memory, src2: XMM) { append(instructions, inst_vpgatherdd_xmm_m_xmm(dst, src, src2)) } emit_vpgatherdd_ymm_m_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Memory, src2: YMM) { append(instructions, inst_vpgatherdd_ymm_m_ymm(dst, src, src2)) } -inst_vpgatherdq_xmm_m_xmm :: #force_inline proc "contextless" (dst: XMM, src: Memory, src2: XMM) -> Instruction { return Instruction{ mnemonic = .VPGATHERDQ, operand_count = 3, ops = {op_xmm(dst), op_mem(src, 0), op_xmm(src2), {}} } } -inst_vpgatherdq_ymm_m_ymm :: #force_inline proc "contextless" (dst: YMM, src: Memory, src2: YMM) -> Instruction { return Instruction{ mnemonic = .VPGATHERDQ, operand_count = 3, ops = {op_ymm(dst), op_mem(src, 0), op_ymm(src2), {}} } } +inst_vpgatherdq_xmm_m_xmm :: #force_inline proc "contextless" (dst: XMM, src: Memory, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPGATHERDQ, operand_count = 3, ops = {op_xmm(dst), op_mem(src, 0), op_xmm(src2), {}} }, 1493) } +inst_vpgatherdq_ymm_m_ymm :: #force_inline proc "contextless" (dst: YMM, src: Memory, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPGATHERDQ, operand_count = 3, ops = {op_ymm(dst), op_mem(src, 0), op_ymm(src2), {}} }, 1494) } emit_vpgatherdq_xmm_m_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Memory, src2: XMM) { append(instructions, inst_vpgatherdq_xmm_m_xmm(dst, src, src2)) } emit_vpgatherdq_ymm_m_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Memory, src2: YMM) { append(instructions, inst_vpgatherdq_ymm_m_ymm(dst, src, src2)) } -inst_vpgatherqd_xmm_m_xmm :: #force_inline proc "contextless" (dst: XMM, src: Memory, src2: XMM) -> Instruction { return Instruction{ mnemonic = .VPGATHERQD, operand_count = 3, ops = {op_xmm(dst), op_mem(src, 0), op_xmm(src2), {}} } } +inst_vpgatherqd_xmm_m_xmm :: #force_inline proc "contextless" (dst: XMM, src: Memory, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPGATHERQD, operand_count = 3, ops = {op_xmm(dst), op_mem(src, 0), op_xmm(src2), {}} }, 1495) } emit_vpgatherqd_xmm_m_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Memory, src2: XMM) { append(instructions, inst_vpgatherqd_xmm_m_xmm(dst, src, src2)) } -inst_vpgatherqq_xmm_m_xmm :: #force_inline proc "contextless" (dst: XMM, src: Memory, src2: XMM) -> Instruction { return Instruction{ mnemonic = .VPGATHERQQ, operand_count = 3, ops = {op_xmm(dst), op_mem(src, 0), op_xmm(src2), {}} } } -inst_vpgatherqq_ymm_m_ymm :: #force_inline proc "contextless" (dst: YMM, src: Memory, src2: YMM) -> Instruction { return Instruction{ mnemonic = .VPGATHERQQ, operand_count = 3, ops = {op_ymm(dst), op_mem(src, 0), op_ymm(src2), {}} } } +inst_vpgatherqq_xmm_m_xmm :: #force_inline proc "contextless" (dst: XMM, src: Memory, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPGATHERQQ, operand_count = 3, ops = {op_xmm(dst), op_mem(src, 0), op_xmm(src2), {}} }, 1497) } +inst_vpgatherqq_ymm_m_ymm :: #force_inline proc "contextless" (dst: YMM, src: Memory, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPGATHERQQ, operand_count = 3, ops = {op_ymm(dst), op_mem(src, 0), op_ymm(src2), {}} }, 1498) } emit_vpgatherqq_xmm_m_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Memory, src2: XMM) { append(instructions, inst_vpgatherqq_xmm_m_xmm(dst, src, src2)) } emit_vpgatherqq_ymm_m_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Memory, src2: YMM) { append(instructions, inst_vpgatherqq_ymm_m_ymm(dst, src, src2)) } -inst_vfmadd132ps_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VFMADD132PS, Register(dst), Register(src), Register(src2)) } -inst_vfmadd132ps_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VFMADD132PS, Register(dst), Register(src), src2.mem, 16) } -inst_vfmadd132ps_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VFMADD132PS, Register(dst), Register(src), Register(src2)) } -inst_vfmadd132ps_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VFMADD132PS, Register(dst), Register(src), src2.mem, 32) } -emit_vfmadd132ps_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VFMADD132PS, Register(dst), Register(src), Register(src2)) } -emit_vfmadd132ps_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VFMADD132PS, Register(dst), Register(src), src2.mem, 16) } -emit_vfmadd132ps_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VFMADD132PS, Register(dst), Register(src), Register(src2)) } -emit_vfmadd132ps_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VFMADD132PS, Register(dst), Register(src), src2.mem, 32) } -inst_vfmadd213ps_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VFMADD213PS, Register(dst), Register(src), Register(src2)) } -inst_vfmadd213ps_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VFMADD213PS, Register(dst), Register(src), src2.mem, 16) } -inst_vfmadd213ps_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VFMADD213PS, Register(dst), Register(src), Register(src2)) } -inst_vfmadd213ps_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VFMADD213PS, Register(dst), Register(src), src2.mem, 32) } -emit_vfmadd213ps_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VFMADD213PS, Register(dst), Register(src), Register(src2)) } -emit_vfmadd213ps_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VFMADD213PS, Register(dst), Register(src), src2.mem, 16) } -emit_vfmadd213ps_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VFMADD213PS, Register(dst), Register(src), Register(src2)) } -emit_vfmadd213ps_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VFMADD213PS, Register(dst), Register(src), src2.mem, 32) } -inst_vfmadd231ps_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VFMADD231PS, Register(dst), Register(src), Register(src2)) } -inst_vfmadd231ps_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VFMADD231PS, Register(dst), Register(src), src2.mem, 16) } -inst_vfmadd231ps_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VFMADD231PS, Register(dst), Register(src), Register(src2)) } -inst_vfmadd231ps_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VFMADD231PS, Register(dst), Register(src), src2.mem, 32) } -emit_vfmadd231ps_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VFMADD231PS, Register(dst), Register(src), Register(src2)) } -emit_vfmadd231ps_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VFMADD231PS, Register(dst), Register(src), src2.mem, 16) } -emit_vfmadd231ps_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VFMADD231PS, Register(dst), Register(src), Register(src2)) } -emit_vfmadd231ps_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VFMADD231PS, Register(dst), Register(src), src2.mem, 32) } -inst_vfmadd132pd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VFMADD132PD, Register(dst), Register(src), Register(src2)) } -inst_vfmadd132pd_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VFMADD132PD, Register(dst), Register(src), src2.mem, 16) } -inst_vfmadd132pd_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VFMADD132PD, Register(dst), Register(src), Register(src2)) } -inst_vfmadd132pd_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VFMADD132PD, Register(dst), Register(src), src2.mem, 32) } -emit_vfmadd132pd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VFMADD132PD, Register(dst), Register(src), Register(src2)) } -emit_vfmadd132pd_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VFMADD132PD, Register(dst), Register(src), src2.mem, 16) } -emit_vfmadd132pd_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VFMADD132PD, Register(dst), Register(src), Register(src2)) } -emit_vfmadd132pd_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VFMADD132PD, Register(dst), Register(src), src2.mem, 32) } -inst_vfmadd213pd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VFMADD213PD, Register(dst), Register(src), Register(src2)) } -inst_vfmadd213pd_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VFMADD213PD, Register(dst), Register(src), src2.mem, 16) } -inst_vfmadd213pd_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VFMADD213PD, Register(dst), Register(src), Register(src2)) } -inst_vfmadd213pd_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VFMADD213PD, Register(dst), Register(src), src2.mem, 32) } -emit_vfmadd213pd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VFMADD213PD, Register(dst), Register(src), Register(src2)) } -emit_vfmadd213pd_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VFMADD213PD, Register(dst), Register(src), src2.mem, 16) } -emit_vfmadd213pd_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VFMADD213PD, Register(dst), Register(src), Register(src2)) } -emit_vfmadd213pd_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VFMADD213PD, Register(dst), Register(src), src2.mem, 32) } -inst_vfmadd231pd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VFMADD231PD, Register(dst), Register(src), Register(src2)) } -inst_vfmadd231pd_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VFMADD231PD, Register(dst), Register(src), src2.mem, 16) } -inst_vfmadd231pd_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VFMADD231PD, Register(dst), Register(src), Register(src2)) } -inst_vfmadd231pd_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VFMADD231PD, Register(dst), Register(src), src2.mem, 32) } -emit_vfmadd231pd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VFMADD231PD, Register(dst), Register(src), Register(src2)) } -emit_vfmadd231pd_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VFMADD231PD, Register(dst), Register(src), src2.mem, 16) } -emit_vfmadd231pd_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VFMADD231PD, Register(dst), Register(src), Register(src2)) } -emit_vfmadd231pd_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VFMADD231PD, Register(dst), Register(src), src2.mem, 32) } -inst_vfmadd132ss_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VFMADD132SS, Register(dst), Register(src), Register(src2)) } -inst_vfmadd132ss_xmm_xmm_m32 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem32) -> Instruction { return inst_r_r_m(.VFMADD132SS, Register(dst), Register(src), src2.mem, 4) } -emit_vfmadd132ss_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VFMADD132SS, Register(dst), Register(src), Register(src2)) } -emit_vfmadd132ss_xmm_xmm_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem32) { emit_rrm(instructions, .VFMADD132SS, Register(dst), Register(src), src2.mem, 4) } -inst_vfmadd213ss_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VFMADD213SS, Register(dst), Register(src), Register(src2)) } -inst_vfmadd213ss_xmm_xmm_m32 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem32) -> Instruction { return inst_r_r_m(.VFMADD213SS, Register(dst), Register(src), src2.mem, 4) } -emit_vfmadd213ss_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VFMADD213SS, Register(dst), Register(src), Register(src2)) } -emit_vfmadd213ss_xmm_xmm_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem32) { emit_rrm(instructions, .VFMADD213SS, Register(dst), Register(src), src2.mem, 4) } -inst_vfmadd231ss_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VFMADD231SS, Register(dst), Register(src), Register(src2)) } -inst_vfmadd231ss_xmm_xmm_m32 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem32) -> Instruction { return inst_r_r_m(.VFMADD231SS, Register(dst), Register(src), src2.mem, 4) } -emit_vfmadd231ss_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VFMADD231SS, Register(dst), Register(src), Register(src2)) } -emit_vfmadd231ss_xmm_xmm_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem32) { emit_rrm(instructions, .VFMADD231SS, Register(dst), Register(src), src2.mem, 4) } -inst_vfmadd132sd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VFMADD132SD, Register(dst), Register(src), Register(src2)) } -inst_vfmadd132sd_xmm_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem64) -> Instruction { return inst_r_r_m(.VFMADD132SD, Register(dst), Register(src), src2.mem, 8) } -emit_vfmadd132sd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VFMADD132SD, Register(dst), Register(src), Register(src2)) } -emit_vfmadd132sd_xmm_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem64) { emit_rrm(instructions, .VFMADD132SD, Register(dst), Register(src), src2.mem, 8) } -inst_vfmadd213sd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VFMADD213SD, Register(dst), Register(src), Register(src2)) } -inst_vfmadd213sd_xmm_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem64) -> Instruction { return inst_r_r_m(.VFMADD213SD, Register(dst), Register(src), src2.mem, 8) } -emit_vfmadd213sd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VFMADD213SD, Register(dst), Register(src), Register(src2)) } -emit_vfmadd213sd_xmm_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem64) { emit_rrm(instructions, .VFMADD213SD, Register(dst), Register(src), src2.mem, 8) } -inst_vfmadd231sd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VFMADD231SD, Register(dst), Register(src), Register(src2)) } -inst_vfmadd231sd_xmm_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem64) -> Instruction { return inst_r_r_m(.VFMADD231SD, Register(dst), Register(src), src2.mem, 8) } -emit_vfmadd231sd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VFMADD231SD, Register(dst), Register(src), Register(src2)) } -emit_vfmadd231sd_xmm_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem64) { emit_rrm(instructions, .VFMADD231SD, Register(dst), Register(src), src2.mem, 8) } -inst_vfmsub132ps_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VFMSUB132PS, Register(dst), Register(src), Register(src2)) } -inst_vfmsub132ps_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VFMSUB132PS, Register(dst), Register(src), src2.mem, 16) } -inst_vfmsub132ps_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VFMSUB132PS, Register(dst), Register(src), Register(src2)) } -inst_vfmsub132ps_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VFMSUB132PS, Register(dst), Register(src), src2.mem, 32) } -emit_vfmsub132ps_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VFMSUB132PS, Register(dst), Register(src), Register(src2)) } -emit_vfmsub132ps_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VFMSUB132PS, Register(dst), Register(src), src2.mem, 16) } -emit_vfmsub132ps_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VFMSUB132PS, Register(dst), Register(src), Register(src2)) } -emit_vfmsub132ps_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VFMSUB132PS, Register(dst), Register(src), src2.mem, 32) } -inst_vfmsub213ps_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VFMSUB213PS, Register(dst), Register(src), Register(src2)) } -inst_vfmsub213ps_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VFMSUB213PS, Register(dst), Register(src), src2.mem, 16) } -inst_vfmsub213ps_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VFMSUB213PS, Register(dst), Register(src), Register(src2)) } -inst_vfmsub213ps_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VFMSUB213PS, Register(dst), Register(src), src2.mem, 32) } -emit_vfmsub213ps_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VFMSUB213PS, Register(dst), Register(src), Register(src2)) } -emit_vfmsub213ps_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VFMSUB213PS, Register(dst), Register(src), src2.mem, 16) } -emit_vfmsub213ps_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VFMSUB213PS, Register(dst), Register(src), Register(src2)) } -emit_vfmsub213ps_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VFMSUB213PS, Register(dst), Register(src), src2.mem, 32) } -inst_vfmsub231ps_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VFMSUB231PS, Register(dst), Register(src), Register(src2)) } -inst_vfmsub231ps_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VFMSUB231PS, Register(dst), Register(src), src2.mem, 16) } -inst_vfmsub231ps_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VFMSUB231PS, Register(dst), Register(src), Register(src2)) } -inst_vfmsub231ps_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VFMSUB231PS, Register(dst), Register(src), src2.mem, 32) } -emit_vfmsub231ps_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VFMSUB231PS, Register(dst), Register(src), Register(src2)) } -emit_vfmsub231ps_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VFMSUB231PS, Register(dst), Register(src), src2.mem, 16) } -emit_vfmsub231ps_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VFMSUB231PS, Register(dst), Register(src), Register(src2)) } -emit_vfmsub231ps_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VFMSUB231PS, Register(dst), Register(src), src2.mem, 32) } -inst_vfmsub132pd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VFMSUB132PD, Register(dst), Register(src), Register(src2)) } -inst_vfmsub132pd_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VFMSUB132PD, Register(dst), Register(src), src2.mem, 16) } -inst_vfmsub132pd_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VFMSUB132PD, Register(dst), Register(src), Register(src2)) } -inst_vfmsub132pd_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VFMSUB132PD, Register(dst), Register(src), src2.mem, 32) } -emit_vfmsub132pd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VFMSUB132PD, Register(dst), Register(src), Register(src2)) } -emit_vfmsub132pd_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VFMSUB132PD, Register(dst), Register(src), src2.mem, 16) } -emit_vfmsub132pd_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VFMSUB132PD, Register(dst), Register(src), Register(src2)) } -emit_vfmsub132pd_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VFMSUB132PD, Register(dst), Register(src), src2.mem, 32) } -inst_vfmsub213pd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VFMSUB213PD, Register(dst), Register(src), Register(src2)) } -inst_vfmsub213pd_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VFMSUB213PD, Register(dst), Register(src), src2.mem, 16) } -inst_vfmsub213pd_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VFMSUB213PD, Register(dst), Register(src), Register(src2)) } -inst_vfmsub213pd_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VFMSUB213PD, Register(dst), Register(src), src2.mem, 32) } -emit_vfmsub213pd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VFMSUB213PD, Register(dst), Register(src), Register(src2)) } -emit_vfmsub213pd_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VFMSUB213PD, Register(dst), Register(src), src2.mem, 16) } -emit_vfmsub213pd_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VFMSUB213PD, Register(dst), Register(src), Register(src2)) } -emit_vfmsub213pd_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VFMSUB213PD, Register(dst), Register(src), src2.mem, 32) } -inst_vfmsub231pd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VFMSUB231PD, Register(dst), Register(src), Register(src2)) } -inst_vfmsub231pd_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VFMSUB231PD, Register(dst), Register(src), src2.mem, 16) } -inst_vfmsub231pd_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VFMSUB231PD, Register(dst), Register(src), Register(src2)) } -inst_vfmsub231pd_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VFMSUB231PD, Register(dst), Register(src), src2.mem, 32) } -emit_vfmsub231pd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VFMSUB231PD, Register(dst), Register(src), Register(src2)) } -emit_vfmsub231pd_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VFMSUB231PD, Register(dst), Register(src), src2.mem, 16) } -emit_vfmsub231pd_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VFMSUB231PD, Register(dst), Register(src), Register(src2)) } -emit_vfmsub231pd_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VFMSUB231PD, Register(dst), Register(src), src2.mem, 32) } -inst_vfmsub132ss_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VFMSUB132SS, Register(dst), Register(src), Register(src2)) } -inst_vfmsub132ss_xmm_xmm_m32 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem32) -> Instruction { return inst_r_r_m(.VFMSUB132SS, Register(dst), Register(src), src2.mem, 4) } -emit_vfmsub132ss_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VFMSUB132SS, Register(dst), Register(src), Register(src2)) } -emit_vfmsub132ss_xmm_xmm_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem32) { emit_rrm(instructions, .VFMSUB132SS, Register(dst), Register(src), src2.mem, 4) } -inst_vfmsub213ss_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VFMSUB213SS, Register(dst), Register(src), Register(src2)) } -inst_vfmsub213ss_xmm_xmm_m32 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem32) -> Instruction { return inst_r_r_m(.VFMSUB213SS, Register(dst), Register(src), src2.mem, 4) } -emit_vfmsub213ss_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VFMSUB213SS, Register(dst), Register(src), Register(src2)) } -emit_vfmsub213ss_xmm_xmm_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem32) { emit_rrm(instructions, .VFMSUB213SS, Register(dst), Register(src), src2.mem, 4) } -inst_vfmsub231ss_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VFMSUB231SS, Register(dst), Register(src), Register(src2)) } -inst_vfmsub231ss_xmm_xmm_m32 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem32) -> Instruction { return inst_r_r_m(.VFMSUB231SS, Register(dst), Register(src), src2.mem, 4) } -emit_vfmsub231ss_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VFMSUB231SS, Register(dst), Register(src), Register(src2)) } -emit_vfmsub231ss_xmm_xmm_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem32) { emit_rrm(instructions, .VFMSUB231SS, Register(dst), Register(src), src2.mem, 4) } -inst_vfmsub132sd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VFMSUB132SD, Register(dst), Register(src), Register(src2)) } -inst_vfmsub132sd_xmm_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem64) -> Instruction { return inst_r_r_m(.VFMSUB132SD, Register(dst), Register(src), src2.mem, 8) } -emit_vfmsub132sd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VFMSUB132SD, Register(dst), Register(src), Register(src2)) } -emit_vfmsub132sd_xmm_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem64) { emit_rrm(instructions, .VFMSUB132SD, Register(dst), Register(src), src2.mem, 8) } -inst_vfmsub213sd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VFMSUB213SD, Register(dst), Register(src), Register(src2)) } -inst_vfmsub213sd_xmm_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem64) -> Instruction { return inst_r_r_m(.VFMSUB213SD, Register(dst), Register(src), src2.mem, 8) } -emit_vfmsub213sd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VFMSUB213SD, Register(dst), Register(src), Register(src2)) } -emit_vfmsub213sd_xmm_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem64) { emit_rrm(instructions, .VFMSUB213SD, Register(dst), Register(src), src2.mem, 8) } -inst_vfmsub231sd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VFMSUB231SD, Register(dst), Register(src), Register(src2)) } -inst_vfmsub231sd_xmm_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem64) -> Instruction { return inst_r_r_m(.VFMSUB231SD, Register(dst), Register(src), src2.mem, 8) } -emit_vfmsub231sd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VFMSUB231SD, Register(dst), Register(src), Register(src2)) } -emit_vfmsub231sd_xmm_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem64) { emit_rrm(instructions, .VFMSUB231SD, Register(dst), Register(src), src2.mem, 8) } -inst_vfnmadd132ps_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VFNMADD132PS, Register(dst), Register(src), Register(src2)) } -inst_vfnmadd132ps_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VFNMADD132PS, Register(dst), Register(src), src2.mem, 16) } -inst_vfnmadd132ps_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VFNMADD132PS, Register(dst), Register(src), Register(src2)) } -inst_vfnmadd132ps_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VFNMADD132PS, Register(dst), Register(src), src2.mem, 32) } -emit_vfnmadd132ps_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VFNMADD132PS, Register(dst), Register(src), Register(src2)) } -emit_vfnmadd132ps_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VFNMADD132PS, Register(dst), Register(src), src2.mem, 16) } -emit_vfnmadd132ps_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VFNMADD132PS, Register(dst), Register(src), Register(src2)) } -emit_vfnmadd132ps_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VFNMADD132PS, Register(dst), Register(src), src2.mem, 32) } -inst_vfnmadd213ps_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VFNMADD213PS, Register(dst), Register(src), Register(src2)) } -inst_vfnmadd213ps_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VFNMADD213PS, Register(dst), Register(src), src2.mem, 16) } -inst_vfnmadd213ps_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VFNMADD213PS, Register(dst), Register(src), Register(src2)) } -inst_vfnmadd213ps_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VFNMADD213PS, Register(dst), Register(src), src2.mem, 32) } -emit_vfnmadd213ps_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VFNMADD213PS, Register(dst), Register(src), Register(src2)) } -emit_vfnmadd213ps_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VFNMADD213PS, Register(dst), Register(src), src2.mem, 16) } -emit_vfnmadd213ps_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VFNMADD213PS, Register(dst), Register(src), Register(src2)) } -emit_vfnmadd213ps_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VFNMADD213PS, Register(dst), Register(src), src2.mem, 32) } -inst_vfnmadd231ps_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VFNMADD231PS, Register(dst), Register(src), Register(src2)) } -inst_vfnmadd231ps_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VFNMADD231PS, Register(dst), Register(src), src2.mem, 16) } -inst_vfnmadd231ps_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VFNMADD231PS, Register(dst), Register(src), Register(src2)) } -inst_vfnmadd231ps_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VFNMADD231PS, Register(dst), Register(src), src2.mem, 32) } -emit_vfnmadd231ps_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VFNMADD231PS, Register(dst), Register(src), Register(src2)) } -emit_vfnmadd231ps_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VFNMADD231PS, Register(dst), Register(src), src2.mem, 16) } -emit_vfnmadd231ps_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VFNMADD231PS, Register(dst), Register(src), Register(src2)) } -emit_vfnmadd231ps_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VFNMADD231PS, Register(dst), Register(src), src2.mem, 32) } -inst_vfnmadd132pd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VFNMADD132PD, Register(dst), Register(src), Register(src2)) } -inst_vfnmadd132pd_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VFNMADD132PD, Register(dst), Register(src), src2.mem, 16) } -inst_vfnmadd132pd_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VFNMADD132PD, Register(dst), Register(src), Register(src2)) } -inst_vfnmadd132pd_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VFNMADD132PD, Register(dst), Register(src), src2.mem, 32) } -emit_vfnmadd132pd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VFNMADD132PD, Register(dst), Register(src), Register(src2)) } -emit_vfnmadd132pd_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VFNMADD132PD, Register(dst), Register(src), src2.mem, 16) } -emit_vfnmadd132pd_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VFNMADD132PD, Register(dst), Register(src), Register(src2)) } -emit_vfnmadd132pd_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VFNMADD132PD, Register(dst), Register(src), src2.mem, 32) } -inst_vfnmadd213pd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VFNMADD213PD, Register(dst), Register(src), Register(src2)) } -inst_vfnmadd213pd_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VFNMADD213PD, Register(dst), Register(src), src2.mem, 16) } -inst_vfnmadd213pd_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VFNMADD213PD, Register(dst), Register(src), Register(src2)) } -inst_vfnmadd213pd_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VFNMADD213PD, Register(dst), Register(src), src2.mem, 32) } -emit_vfnmadd213pd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VFNMADD213PD, Register(dst), Register(src), Register(src2)) } -emit_vfnmadd213pd_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VFNMADD213PD, Register(dst), Register(src), src2.mem, 16) } -emit_vfnmadd213pd_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VFNMADD213PD, Register(dst), Register(src), Register(src2)) } -emit_vfnmadd213pd_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VFNMADD213PD, Register(dst), Register(src), src2.mem, 32) } -inst_vfnmadd231pd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VFNMADD231PD, Register(dst), Register(src), Register(src2)) } -inst_vfnmadd231pd_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VFNMADD231PD, Register(dst), Register(src), src2.mem, 16) } -inst_vfnmadd231pd_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VFNMADD231PD, Register(dst), Register(src), Register(src2)) } -inst_vfnmadd231pd_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VFNMADD231PD, Register(dst), Register(src), src2.mem, 32) } -emit_vfnmadd231pd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VFNMADD231PD, Register(dst), Register(src), Register(src2)) } -emit_vfnmadd231pd_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VFNMADD231PD, Register(dst), Register(src), src2.mem, 16) } -emit_vfnmadd231pd_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VFNMADD231PD, Register(dst), Register(src), Register(src2)) } -emit_vfnmadd231pd_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VFNMADD231PD, Register(dst), Register(src), src2.mem, 32) } -inst_vfnmadd132ss_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VFNMADD132SS, Register(dst), Register(src), Register(src2)) } -inst_vfnmadd132ss_xmm_xmm_m32 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem32) -> Instruction { return inst_r_r_m(.VFNMADD132SS, Register(dst), Register(src), src2.mem, 4) } -emit_vfnmadd132ss_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VFNMADD132SS, Register(dst), Register(src), Register(src2)) } -emit_vfnmadd132ss_xmm_xmm_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem32) { emit_rrm(instructions, .VFNMADD132SS, Register(dst), Register(src), src2.mem, 4) } -inst_vfnmadd213ss_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VFNMADD213SS, Register(dst), Register(src), Register(src2)) } -inst_vfnmadd213ss_xmm_xmm_m32 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem32) -> Instruction { return inst_r_r_m(.VFNMADD213SS, Register(dst), Register(src), src2.mem, 4) } -emit_vfnmadd213ss_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VFNMADD213SS, Register(dst), Register(src), Register(src2)) } -emit_vfnmadd213ss_xmm_xmm_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem32) { emit_rrm(instructions, .VFNMADD213SS, Register(dst), Register(src), src2.mem, 4) } -inst_vfnmadd231ss_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VFNMADD231SS, Register(dst), Register(src), Register(src2)) } -inst_vfnmadd231ss_xmm_xmm_m32 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem32) -> Instruction { return inst_r_r_m(.VFNMADD231SS, Register(dst), Register(src), src2.mem, 4) } -emit_vfnmadd231ss_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VFNMADD231SS, Register(dst), Register(src), Register(src2)) } -emit_vfnmadd231ss_xmm_xmm_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem32) { emit_rrm(instructions, .VFNMADD231SS, Register(dst), Register(src), src2.mem, 4) } -inst_vfnmadd132sd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VFNMADD132SD, Register(dst), Register(src), Register(src2)) } -inst_vfnmadd132sd_xmm_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem64) -> Instruction { return inst_r_r_m(.VFNMADD132SD, Register(dst), Register(src), src2.mem, 8) } -emit_vfnmadd132sd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VFNMADD132SD, Register(dst), Register(src), Register(src2)) } -emit_vfnmadd132sd_xmm_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem64) { emit_rrm(instructions, .VFNMADD132SD, Register(dst), Register(src), src2.mem, 8) } -inst_vfnmadd213sd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VFNMADD213SD, Register(dst), Register(src), Register(src2)) } -inst_vfnmadd213sd_xmm_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem64) -> Instruction { return inst_r_r_m(.VFNMADD213SD, Register(dst), Register(src), src2.mem, 8) } -emit_vfnmadd213sd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VFNMADD213SD, Register(dst), Register(src), Register(src2)) } -emit_vfnmadd213sd_xmm_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem64) { emit_rrm(instructions, .VFNMADD213SD, Register(dst), Register(src), src2.mem, 8) } -inst_vfnmadd231sd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VFNMADD231SD, Register(dst), Register(src), Register(src2)) } -inst_vfnmadd231sd_xmm_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem64) -> Instruction { return inst_r_r_m(.VFNMADD231SD, Register(dst), Register(src), src2.mem, 8) } -emit_vfnmadd231sd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VFNMADD231SD, Register(dst), Register(src), Register(src2)) } -emit_vfnmadd231sd_xmm_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem64) { emit_rrm(instructions, .VFNMADD231SD, Register(dst), Register(src), src2.mem, 8) } -inst_vfnmsub132ps_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VFNMSUB132PS, Register(dst), Register(src), Register(src2)) } -inst_vfnmsub132ps_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VFNMSUB132PS, Register(dst), Register(src), src2.mem, 16) } -inst_vfnmsub132ps_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VFNMSUB132PS, Register(dst), Register(src), Register(src2)) } -inst_vfnmsub132ps_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VFNMSUB132PS, Register(dst), Register(src), src2.mem, 32) } -emit_vfnmsub132ps_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VFNMSUB132PS, Register(dst), Register(src), Register(src2)) } -emit_vfnmsub132ps_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VFNMSUB132PS, Register(dst), Register(src), src2.mem, 16) } -emit_vfnmsub132ps_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VFNMSUB132PS, Register(dst), Register(src), Register(src2)) } -emit_vfnmsub132ps_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VFNMSUB132PS, Register(dst), Register(src), src2.mem, 32) } -inst_vfnmsub213ps_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VFNMSUB213PS, Register(dst), Register(src), Register(src2)) } -inst_vfnmsub213ps_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VFNMSUB213PS, Register(dst), Register(src), src2.mem, 16) } -inst_vfnmsub213ps_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VFNMSUB213PS, Register(dst), Register(src), Register(src2)) } -inst_vfnmsub213ps_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VFNMSUB213PS, Register(dst), Register(src), src2.mem, 32) } -emit_vfnmsub213ps_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VFNMSUB213PS, Register(dst), Register(src), Register(src2)) } -emit_vfnmsub213ps_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VFNMSUB213PS, Register(dst), Register(src), src2.mem, 16) } -emit_vfnmsub213ps_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VFNMSUB213PS, Register(dst), Register(src), Register(src2)) } -emit_vfnmsub213ps_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VFNMSUB213PS, Register(dst), Register(src), src2.mem, 32) } -inst_vfnmsub231ps_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VFNMSUB231PS, Register(dst), Register(src), Register(src2)) } -inst_vfnmsub231ps_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VFNMSUB231PS, Register(dst), Register(src), src2.mem, 16) } -inst_vfnmsub231ps_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VFNMSUB231PS, Register(dst), Register(src), Register(src2)) } -inst_vfnmsub231ps_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VFNMSUB231PS, Register(dst), Register(src), src2.mem, 32) } -emit_vfnmsub231ps_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VFNMSUB231PS, Register(dst), Register(src), Register(src2)) } -emit_vfnmsub231ps_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VFNMSUB231PS, Register(dst), Register(src), src2.mem, 16) } -emit_vfnmsub231ps_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VFNMSUB231PS, Register(dst), Register(src), Register(src2)) } -emit_vfnmsub231ps_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VFNMSUB231PS, Register(dst), Register(src), src2.mem, 32) } -inst_vfnmsub132pd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VFNMSUB132PD, Register(dst), Register(src), Register(src2)) } -inst_vfnmsub132pd_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VFNMSUB132PD, Register(dst), Register(src), src2.mem, 16) } -inst_vfnmsub132pd_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VFNMSUB132PD, Register(dst), Register(src), Register(src2)) } -inst_vfnmsub132pd_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VFNMSUB132PD, Register(dst), Register(src), src2.mem, 32) } -emit_vfnmsub132pd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VFNMSUB132PD, Register(dst), Register(src), Register(src2)) } -emit_vfnmsub132pd_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VFNMSUB132PD, Register(dst), Register(src), src2.mem, 16) } -emit_vfnmsub132pd_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VFNMSUB132PD, Register(dst), Register(src), Register(src2)) } -emit_vfnmsub132pd_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VFNMSUB132PD, Register(dst), Register(src), src2.mem, 32) } -inst_vfnmsub213pd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VFNMSUB213PD, Register(dst), Register(src), Register(src2)) } -inst_vfnmsub213pd_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VFNMSUB213PD, Register(dst), Register(src), src2.mem, 16) } -inst_vfnmsub213pd_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VFNMSUB213PD, Register(dst), Register(src), Register(src2)) } -inst_vfnmsub213pd_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VFNMSUB213PD, Register(dst), Register(src), src2.mem, 32) } -emit_vfnmsub213pd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VFNMSUB213PD, Register(dst), Register(src), Register(src2)) } -emit_vfnmsub213pd_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VFNMSUB213PD, Register(dst), Register(src), src2.mem, 16) } -emit_vfnmsub213pd_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VFNMSUB213PD, Register(dst), Register(src), Register(src2)) } -emit_vfnmsub213pd_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VFNMSUB213PD, Register(dst), Register(src), src2.mem, 32) } -inst_vfnmsub231pd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VFNMSUB231PD, Register(dst), Register(src), Register(src2)) } -inst_vfnmsub231pd_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VFNMSUB231PD, Register(dst), Register(src), src2.mem, 16) } -inst_vfnmsub231pd_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VFNMSUB231PD, Register(dst), Register(src), Register(src2)) } -inst_vfnmsub231pd_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VFNMSUB231PD, Register(dst), Register(src), src2.mem, 32) } -emit_vfnmsub231pd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VFNMSUB231PD, Register(dst), Register(src), Register(src2)) } -emit_vfnmsub231pd_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VFNMSUB231PD, Register(dst), Register(src), src2.mem, 16) } -emit_vfnmsub231pd_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VFNMSUB231PD, Register(dst), Register(src), Register(src2)) } -emit_vfnmsub231pd_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VFNMSUB231PD, Register(dst), Register(src), src2.mem, 32) } -inst_vfnmsub132ss_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VFNMSUB132SS, Register(dst), Register(src), Register(src2)) } -inst_vfnmsub132ss_xmm_xmm_m32 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem32) -> Instruction { return inst_r_r_m(.VFNMSUB132SS, Register(dst), Register(src), src2.mem, 4) } -emit_vfnmsub132ss_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VFNMSUB132SS, Register(dst), Register(src), Register(src2)) } -emit_vfnmsub132ss_xmm_xmm_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem32) { emit_rrm(instructions, .VFNMSUB132SS, Register(dst), Register(src), src2.mem, 4) } -inst_vfnmsub213ss_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VFNMSUB213SS, Register(dst), Register(src), Register(src2)) } -inst_vfnmsub213ss_xmm_xmm_m32 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem32) -> Instruction { return inst_r_r_m(.VFNMSUB213SS, Register(dst), Register(src), src2.mem, 4) } -emit_vfnmsub213ss_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VFNMSUB213SS, Register(dst), Register(src), Register(src2)) } -emit_vfnmsub213ss_xmm_xmm_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem32) { emit_rrm(instructions, .VFNMSUB213SS, Register(dst), Register(src), src2.mem, 4) } -inst_vfnmsub231ss_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VFNMSUB231SS, Register(dst), Register(src), Register(src2)) } -inst_vfnmsub231ss_xmm_xmm_m32 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem32) -> Instruction { return inst_r_r_m(.VFNMSUB231SS, Register(dst), Register(src), src2.mem, 4) } -emit_vfnmsub231ss_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VFNMSUB231SS, Register(dst), Register(src), Register(src2)) } -emit_vfnmsub231ss_xmm_xmm_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem32) { emit_rrm(instructions, .VFNMSUB231SS, Register(dst), Register(src), src2.mem, 4) } -inst_vfnmsub132sd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VFNMSUB132SD, Register(dst), Register(src), Register(src2)) } -inst_vfnmsub132sd_xmm_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem64) -> Instruction { return inst_r_r_m(.VFNMSUB132SD, Register(dst), Register(src), src2.mem, 8) } -emit_vfnmsub132sd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VFNMSUB132SD, Register(dst), Register(src), Register(src2)) } -emit_vfnmsub132sd_xmm_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem64) { emit_rrm(instructions, .VFNMSUB132SD, Register(dst), Register(src), src2.mem, 8) } -inst_vfnmsub213sd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VFNMSUB213SD, Register(dst), Register(src), Register(src2)) } -inst_vfnmsub213sd_xmm_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem64) -> Instruction { return inst_r_r_m(.VFNMSUB213SD, Register(dst), Register(src), src2.mem, 8) } -emit_vfnmsub213sd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VFNMSUB213SD, Register(dst), Register(src), Register(src2)) } -emit_vfnmsub213sd_xmm_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem64) { emit_rrm(instructions, .VFNMSUB213SD, Register(dst), Register(src), src2.mem, 8) } -inst_vfnmsub231sd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VFNMSUB231SD, Register(dst), Register(src), Register(src2)) } -inst_vfnmsub231sd_xmm_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem64) -> Instruction { return inst_r_r_m(.VFNMSUB231SD, Register(dst), Register(src), src2.mem, 8) } -emit_vfnmsub231sd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VFNMSUB231SD, Register(dst), Register(src), Register(src2)) } -emit_vfnmsub231sd_xmm_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem64) { emit_rrm(instructions, .VFNMSUB231SD, Register(dst), Register(src), src2.mem, 8) } -inst_vfmaddsub132ps_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VFMADDSUB132PS, Register(dst), Register(src), Register(src2)) } -inst_vfmaddsub132ps_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VFMADDSUB132PS, Register(dst), Register(src), src2.mem, 16) } -inst_vfmaddsub132ps_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VFMADDSUB132PS, Register(dst), Register(src), Register(src2)) } -inst_vfmaddsub132ps_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VFMADDSUB132PS, Register(dst), Register(src), src2.mem, 32) } -emit_vfmaddsub132ps_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VFMADDSUB132PS, Register(dst), Register(src), Register(src2)) } -emit_vfmaddsub132ps_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VFMADDSUB132PS, Register(dst), Register(src), src2.mem, 16) } -emit_vfmaddsub132ps_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VFMADDSUB132PS, Register(dst), Register(src), Register(src2)) } -emit_vfmaddsub132ps_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VFMADDSUB132PS, Register(dst), Register(src), src2.mem, 32) } -inst_vfmaddsub213ps_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VFMADDSUB213PS, Register(dst), Register(src), Register(src2)) } -inst_vfmaddsub213ps_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VFMADDSUB213PS, Register(dst), Register(src), src2.mem, 16) } -inst_vfmaddsub213ps_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VFMADDSUB213PS, Register(dst), Register(src), Register(src2)) } -inst_vfmaddsub213ps_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VFMADDSUB213PS, Register(dst), Register(src), src2.mem, 32) } -emit_vfmaddsub213ps_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VFMADDSUB213PS, Register(dst), Register(src), Register(src2)) } -emit_vfmaddsub213ps_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VFMADDSUB213PS, Register(dst), Register(src), src2.mem, 16) } -emit_vfmaddsub213ps_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VFMADDSUB213PS, Register(dst), Register(src), Register(src2)) } -emit_vfmaddsub213ps_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VFMADDSUB213PS, Register(dst), Register(src), src2.mem, 32) } -inst_vfmaddsub231ps_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VFMADDSUB231PS, Register(dst), Register(src), Register(src2)) } -inst_vfmaddsub231ps_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VFMADDSUB231PS, Register(dst), Register(src), src2.mem, 16) } -inst_vfmaddsub231ps_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VFMADDSUB231PS, Register(dst), Register(src), Register(src2)) } -inst_vfmaddsub231ps_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VFMADDSUB231PS, Register(dst), Register(src), src2.mem, 32) } -emit_vfmaddsub231ps_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VFMADDSUB231PS, Register(dst), Register(src), Register(src2)) } -emit_vfmaddsub231ps_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VFMADDSUB231PS, Register(dst), Register(src), src2.mem, 16) } -emit_vfmaddsub231ps_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VFMADDSUB231PS, Register(dst), Register(src), Register(src2)) } -emit_vfmaddsub231ps_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VFMADDSUB231PS, Register(dst), Register(src), src2.mem, 32) } -inst_vfmaddsub132pd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VFMADDSUB132PD, Register(dst), Register(src), Register(src2)) } -inst_vfmaddsub132pd_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VFMADDSUB132PD, Register(dst), Register(src), src2.mem, 16) } -inst_vfmaddsub132pd_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VFMADDSUB132PD, Register(dst), Register(src), Register(src2)) } -inst_vfmaddsub132pd_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VFMADDSUB132PD, Register(dst), Register(src), src2.mem, 32) } -emit_vfmaddsub132pd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VFMADDSUB132PD, Register(dst), Register(src), Register(src2)) } -emit_vfmaddsub132pd_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VFMADDSUB132PD, Register(dst), Register(src), src2.mem, 16) } -emit_vfmaddsub132pd_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VFMADDSUB132PD, Register(dst), Register(src), Register(src2)) } -emit_vfmaddsub132pd_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VFMADDSUB132PD, Register(dst), Register(src), src2.mem, 32) } -inst_vfmaddsub213pd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VFMADDSUB213PD, Register(dst), Register(src), Register(src2)) } -inst_vfmaddsub213pd_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VFMADDSUB213PD, Register(dst), Register(src), src2.mem, 16) } -inst_vfmaddsub213pd_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VFMADDSUB213PD, Register(dst), Register(src), Register(src2)) } -inst_vfmaddsub213pd_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VFMADDSUB213PD, Register(dst), Register(src), src2.mem, 32) } -emit_vfmaddsub213pd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VFMADDSUB213PD, Register(dst), Register(src), Register(src2)) } -emit_vfmaddsub213pd_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VFMADDSUB213PD, Register(dst), Register(src), src2.mem, 16) } -emit_vfmaddsub213pd_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VFMADDSUB213PD, Register(dst), Register(src), Register(src2)) } -emit_vfmaddsub213pd_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VFMADDSUB213PD, Register(dst), Register(src), src2.mem, 32) } -inst_vfmaddsub231pd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VFMADDSUB231PD, Register(dst), Register(src), Register(src2)) } -inst_vfmaddsub231pd_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VFMADDSUB231PD, Register(dst), Register(src), src2.mem, 16) } -inst_vfmaddsub231pd_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VFMADDSUB231PD, Register(dst), Register(src), Register(src2)) } -inst_vfmaddsub231pd_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VFMADDSUB231PD, Register(dst), Register(src), src2.mem, 32) } -emit_vfmaddsub231pd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VFMADDSUB231PD, Register(dst), Register(src), Register(src2)) } -emit_vfmaddsub231pd_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VFMADDSUB231PD, Register(dst), Register(src), src2.mem, 16) } -emit_vfmaddsub231pd_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VFMADDSUB231PD, Register(dst), Register(src), Register(src2)) } -emit_vfmaddsub231pd_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VFMADDSUB231PD, Register(dst), Register(src), src2.mem, 32) } -inst_vfmsubadd132ps_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VFMSUBADD132PS, Register(dst), Register(src), Register(src2)) } -inst_vfmsubadd132ps_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VFMSUBADD132PS, Register(dst), Register(src), src2.mem, 16) } -inst_vfmsubadd132ps_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VFMSUBADD132PS, Register(dst), Register(src), Register(src2)) } -inst_vfmsubadd132ps_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VFMSUBADD132PS, Register(dst), Register(src), src2.mem, 32) } -emit_vfmsubadd132ps_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VFMSUBADD132PS, Register(dst), Register(src), Register(src2)) } -emit_vfmsubadd132ps_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VFMSUBADD132PS, Register(dst), Register(src), src2.mem, 16) } -emit_vfmsubadd132ps_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VFMSUBADD132PS, Register(dst), Register(src), Register(src2)) } -emit_vfmsubadd132ps_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VFMSUBADD132PS, Register(dst), Register(src), src2.mem, 32) } -inst_vfmsubadd213ps_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VFMSUBADD213PS, Register(dst), Register(src), Register(src2)) } -inst_vfmsubadd213ps_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VFMSUBADD213PS, Register(dst), Register(src), src2.mem, 16) } -inst_vfmsubadd213ps_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VFMSUBADD213PS, Register(dst), Register(src), Register(src2)) } -inst_vfmsubadd213ps_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VFMSUBADD213PS, Register(dst), Register(src), src2.mem, 32) } -emit_vfmsubadd213ps_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VFMSUBADD213PS, Register(dst), Register(src), Register(src2)) } -emit_vfmsubadd213ps_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VFMSUBADD213PS, Register(dst), Register(src), src2.mem, 16) } -emit_vfmsubadd213ps_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VFMSUBADD213PS, Register(dst), Register(src), Register(src2)) } -emit_vfmsubadd213ps_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VFMSUBADD213PS, Register(dst), Register(src), src2.mem, 32) } -inst_vfmsubadd231ps_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VFMSUBADD231PS, Register(dst), Register(src), Register(src2)) } -inst_vfmsubadd231ps_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VFMSUBADD231PS, Register(dst), Register(src), src2.mem, 16) } -inst_vfmsubadd231ps_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VFMSUBADD231PS, Register(dst), Register(src), Register(src2)) } -inst_vfmsubadd231ps_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VFMSUBADD231PS, Register(dst), Register(src), src2.mem, 32) } -emit_vfmsubadd231ps_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VFMSUBADD231PS, Register(dst), Register(src), Register(src2)) } -emit_vfmsubadd231ps_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VFMSUBADD231PS, Register(dst), Register(src), src2.mem, 16) } -emit_vfmsubadd231ps_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VFMSUBADD231PS, Register(dst), Register(src), Register(src2)) } -emit_vfmsubadd231ps_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VFMSUBADD231PS, Register(dst), Register(src), src2.mem, 32) } -inst_vfmsubadd132pd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VFMSUBADD132PD, Register(dst), Register(src), Register(src2)) } -inst_vfmsubadd132pd_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VFMSUBADD132PD, Register(dst), Register(src), src2.mem, 16) } -inst_vfmsubadd132pd_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VFMSUBADD132PD, Register(dst), Register(src), Register(src2)) } -inst_vfmsubadd132pd_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VFMSUBADD132PD, Register(dst), Register(src), src2.mem, 32) } -emit_vfmsubadd132pd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VFMSUBADD132PD, Register(dst), Register(src), Register(src2)) } -emit_vfmsubadd132pd_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VFMSUBADD132PD, Register(dst), Register(src), src2.mem, 16) } -emit_vfmsubadd132pd_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VFMSUBADD132PD, Register(dst), Register(src), Register(src2)) } -emit_vfmsubadd132pd_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VFMSUBADD132PD, Register(dst), Register(src), src2.mem, 32) } -inst_vfmsubadd213pd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VFMSUBADD213PD, Register(dst), Register(src), Register(src2)) } -inst_vfmsubadd213pd_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VFMSUBADD213PD, Register(dst), Register(src), src2.mem, 16) } -inst_vfmsubadd213pd_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VFMSUBADD213PD, Register(dst), Register(src), Register(src2)) } -inst_vfmsubadd213pd_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VFMSUBADD213PD, Register(dst), Register(src), src2.mem, 32) } -emit_vfmsubadd213pd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VFMSUBADD213PD, Register(dst), Register(src), Register(src2)) } -emit_vfmsubadd213pd_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VFMSUBADD213PD, Register(dst), Register(src), src2.mem, 16) } -emit_vfmsubadd213pd_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VFMSUBADD213PD, Register(dst), Register(src), Register(src2)) } -emit_vfmsubadd213pd_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VFMSUBADD213PD, Register(dst), Register(src), src2.mem, 32) } -inst_vfmsubadd231pd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VFMSUBADD231PD, Register(dst), Register(src), Register(src2)) } -inst_vfmsubadd231pd_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VFMSUBADD231PD, Register(dst), Register(src), src2.mem, 16) } -inst_vfmsubadd231pd_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VFMSUBADD231PD, Register(dst), Register(src), Register(src2)) } -inst_vfmsubadd231pd_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VFMSUBADD231PD, Register(dst), Register(src), src2.mem, 32) } -emit_vfmsubadd231pd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VFMSUBADD231PD, Register(dst), Register(src), Register(src2)) } -emit_vfmsubadd231pd_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VFMSUBADD231PD, Register(dst), Register(src), src2.mem, 16) } -emit_vfmsubadd231pd_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VFMSUBADD231PD, Register(dst), Register(src), Register(src2)) } -emit_vfmsubadd231pd_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VFMSUBADD231PD, Register(dst), Register(src), src2.mem, 32) } -inst_vcvtph2ps_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.VCVTPH2PS, Register(dst), Register(src)) } -inst_vcvtph2ps_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: Mem64) -> Instruction { return inst_r_m(.VCVTPH2PS, Register(dst), src.mem, 8) } -inst_vcvtph2ps_ymm_xmm :: #force_inline proc "contextless" (dst: YMM, src: XMM) -> Instruction { return inst_r_r(.VCVTPH2PS, Register(dst), Register(src)) } -inst_vcvtph2ps_ymm_m128 :: #force_inline proc "contextless" (dst: YMM, src: Mem128) -> Instruction { return inst_r_m(.VCVTPH2PS, Register(dst), src.mem, 16) } -inst_vcvtph2ps_zmm_ymm :: #force_inline proc "contextless" (dst: ZMM, src: YMM) -> Instruction { return inst_r_r(.VCVTPH2PS, Register(dst), Register(src)) } -inst_vcvtph2ps_zmm_m256 :: #force_inline proc "contextless" (dst: ZMM, src: Mem256) -> Instruction { return inst_r_m(.VCVTPH2PS, Register(dst), src.mem, 32) } -emit_vcvtph2ps_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .VCVTPH2PS, Register(dst), Register(src)) } -emit_vcvtph2ps_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem64) { emit_rm(instructions, .VCVTPH2PS, Register(dst), src.mem, 8) } -emit_vcvtph2ps_ymm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: XMM) { emit_rr(instructions, .VCVTPH2PS, Register(dst), Register(src)) } -emit_vcvtph2ps_ymm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem128) { emit_rm(instructions, .VCVTPH2PS, Register(dst), src.mem, 16) } -emit_vcvtph2ps_zmm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: YMM) { emit_rr(instructions, .VCVTPH2PS, Register(dst), Register(src)) } -emit_vcvtph2ps_zmm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: Mem256) { emit_rm(instructions, .VCVTPH2PS, Register(dst), src.mem, 32) } -inst_vcvtps2ph_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return inst_r_r_i(.VCVTPS2PH, Register(dst), Register(src), i64(imm), 1) } -inst_vcvtps2ph_m64_xmm_imm8 :: #force_inline proc "contextless" (dst: Mem64, src: XMM, imm: i8) -> Instruction { return inst_m_r_i(.VCVTPS2PH, dst.mem, 8, Register(src), i64(imm), 1) } -inst_vcvtps2ph_xmm_ymm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: YMM, imm: i8) -> Instruction { return inst_r_r_i(.VCVTPS2PH, Register(dst), Register(src), i64(imm), 1) } -inst_vcvtps2ph_m128_ymm_imm8 :: #force_inline proc "contextless" (dst: Mem128, src: YMM, imm: i8) -> Instruction { return inst_m_r_i(.VCVTPS2PH, dst.mem, 16, Register(src), i64(imm), 1) } -inst_vcvtps2ph_ymm_zmm_imm8 :: #force_inline proc "contextless" (dst: YMM, src: ZMM, imm: i8) -> Instruction { return inst_r_r_i(.VCVTPS2PH, Register(dst), Register(src), i64(imm), 1) } -inst_vcvtps2ph_m256_zmm_imm8 :: #force_inline proc "contextless" (dst: Mem256, src: ZMM, imm: i8) -> Instruction { return inst_m_r_i(.VCVTPS2PH, dst.mem, 32, Register(src), i64(imm), 1) } -emit_vcvtps2ph_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, imm: i8) { emit_rri(instructions, .VCVTPS2PH, Register(dst), Register(src), i64(imm), 1) } -emit_vcvtps2ph_m64_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, src: XMM, imm: i8) { emit_mri(instructions, .VCVTPS2PH, dst.mem, 8, Register(src), i64(imm), 1) } -emit_vcvtps2ph_xmm_ymm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: YMM, imm: i8) { emit_rri(instructions, .VCVTPS2PH, Register(dst), Register(src), i64(imm), 1) } -emit_vcvtps2ph_m128_ymm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem128, src: YMM, imm: i8) { emit_mri(instructions, .VCVTPS2PH, dst.mem, 16, Register(src), i64(imm), 1) } -emit_vcvtps2ph_ymm_zmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: ZMM, imm: i8) { emit_rri(instructions, .VCVTPS2PH, Register(dst), Register(src), i64(imm), 1) } -emit_vcvtps2ph_m256_zmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem256, src: ZMM, imm: i8) { emit_mri(instructions, .VCVTPS2PH, dst.mem, 32, Register(src), i64(imm), 1) } -inst_vmovdqa32_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.VMOVDQA32, Register(dst), Register(src)) } -inst_vmovdqa32_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.VMOVDQA32, Register(dst), src.mem, 16) } -inst_vmovdqa32_m128_xmm :: #force_inline proc "contextless" (dst: Mem128, src: XMM) -> Instruction { return inst_m_r(.VMOVDQA32, dst.mem, 16, Register(src)) } -inst_vmovdqa32_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM) -> Instruction { return inst_r_r(.VMOVDQA32, Register(dst), Register(src)) } -inst_vmovdqa32_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: Mem256) -> Instruction { return inst_r_m(.VMOVDQA32, Register(dst), src.mem, 32) } -inst_vmovdqa32_m256_ymm :: #force_inline proc "contextless" (dst: Mem256, src: YMM) -> Instruction { return inst_m_r(.VMOVDQA32, dst.mem, 32, Register(src)) } -inst_vmovdqa32_zmm_zmm :: #force_inline proc "contextless" (dst: ZMM, src: ZMM) -> Instruction { return inst_r_r(.VMOVDQA32, Register(dst), Register(src)) } -inst_vmovdqa32_zmm_m512 :: #force_inline proc "contextless" (dst: ZMM, src: Mem512) -> Instruction { return inst_r_m(.VMOVDQA32, Register(dst), src.mem, 64) } -inst_vmovdqa32_m512_zmm :: #force_inline proc "contextless" (dst: Mem512, src: ZMM) -> Instruction { return inst_m_r(.VMOVDQA32, dst.mem, 64, Register(src)) } -emit_vmovdqa32_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .VMOVDQA32, Register(dst), Register(src)) } -emit_vmovdqa32_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .VMOVDQA32, Register(dst), src.mem, 16) } -emit_vmovdqa32_m128_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem128, src: XMM) { emit_mr(instructions, .VMOVDQA32, dst.mem, 16, Register(src)) } -emit_vmovdqa32_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM) { emit_rr(instructions, .VMOVDQA32, Register(dst), Register(src)) } -emit_vmovdqa32_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem256) { emit_rm(instructions, .VMOVDQA32, Register(dst), src.mem, 32) } -emit_vmovdqa32_m256_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem256, src: YMM) { emit_mr(instructions, .VMOVDQA32, dst.mem, 32, Register(src)) } -emit_vmovdqa32_zmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM) { emit_rr(instructions, .VMOVDQA32, Register(dst), Register(src)) } -emit_vmovdqa32_zmm_m512 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: Mem512) { emit_rm(instructions, .VMOVDQA32, Register(dst), src.mem, 64) } -emit_vmovdqa32_m512_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem512, src: ZMM) { emit_mr(instructions, .VMOVDQA32, dst.mem, 64, Register(src)) } -inst_vmovdqa64_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.VMOVDQA64, Register(dst), Register(src)) } -inst_vmovdqa64_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.VMOVDQA64, Register(dst), src.mem, 16) } -inst_vmovdqa64_m128_xmm :: #force_inline proc "contextless" (dst: Mem128, src: XMM) -> Instruction { return inst_m_r(.VMOVDQA64, dst.mem, 16, Register(src)) } -inst_vmovdqa64_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM) -> Instruction { return inst_r_r(.VMOVDQA64, Register(dst), Register(src)) } -inst_vmovdqa64_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: Mem256) -> Instruction { return inst_r_m(.VMOVDQA64, Register(dst), src.mem, 32) } -inst_vmovdqa64_m256_ymm :: #force_inline proc "contextless" (dst: Mem256, src: YMM) -> Instruction { return inst_m_r(.VMOVDQA64, dst.mem, 32, Register(src)) } -inst_vmovdqa64_zmm_zmm :: #force_inline proc "contextless" (dst: ZMM, src: ZMM) -> Instruction { return inst_r_r(.VMOVDQA64, Register(dst), Register(src)) } -inst_vmovdqa64_zmm_m512 :: #force_inline proc "contextless" (dst: ZMM, src: Mem512) -> Instruction { return inst_r_m(.VMOVDQA64, Register(dst), src.mem, 64) } -inst_vmovdqa64_m512_zmm :: #force_inline proc "contextless" (dst: Mem512, src: ZMM) -> Instruction { return inst_m_r(.VMOVDQA64, dst.mem, 64, Register(src)) } -emit_vmovdqa64_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .VMOVDQA64, Register(dst), Register(src)) } -emit_vmovdqa64_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .VMOVDQA64, Register(dst), src.mem, 16) } -emit_vmovdqa64_m128_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem128, src: XMM) { emit_mr(instructions, .VMOVDQA64, dst.mem, 16, Register(src)) } -emit_vmovdqa64_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM) { emit_rr(instructions, .VMOVDQA64, Register(dst), Register(src)) } -emit_vmovdqa64_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem256) { emit_rm(instructions, .VMOVDQA64, Register(dst), src.mem, 32) } -emit_vmovdqa64_m256_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem256, src: YMM) { emit_mr(instructions, .VMOVDQA64, dst.mem, 32, Register(src)) } -emit_vmovdqa64_zmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM) { emit_rr(instructions, .VMOVDQA64, Register(dst), Register(src)) } -emit_vmovdqa64_zmm_m512 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: Mem512) { emit_rm(instructions, .VMOVDQA64, Register(dst), src.mem, 64) } -emit_vmovdqa64_m512_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem512, src: ZMM) { emit_mr(instructions, .VMOVDQA64, dst.mem, 64, Register(src)) } -inst_vmovdqu8_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.VMOVDQU8, Register(dst), Register(src)) } -inst_vmovdqu8_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.VMOVDQU8, Register(dst), src.mem, 16) } -inst_vmovdqu8_m128_xmm :: #force_inline proc "contextless" (dst: Mem128, src: XMM) -> Instruction { return inst_m_r(.VMOVDQU8, dst.mem, 16, Register(src)) } -inst_vmovdqu8_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM) -> Instruction { return inst_r_r(.VMOVDQU8, Register(dst), Register(src)) } -inst_vmovdqu8_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: Mem256) -> Instruction { return inst_r_m(.VMOVDQU8, Register(dst), src.mem, 32) } -inst_vmovdqu8_m256_ymm :: #force_inline proc "contextless" (dst: Mem256, src: YMM) -> Instruction { return inst_m_r(.VMOVDQU8, dst.mem, 32, Register(src)) } -inst_vmovdqu8_zmm_zmm :: #force_inline proc "contextless" (dst: ZMM, src: ZMM) -> Instruction { return inst_r_r(.VMOVDQU8, Register(dst), Register(src)) } -inst_vmovdqu8_zmm_m512 :: #force_inline proc "contextless" (dst: ZMM, src: Mem512) -> Instruction { return inst_r_m(.VMOVDQU8, Register(dst), src.mem, 64) } -inst_vmovdqu8_m512_zmm :: #force_inline proc "contextless" (dst: Mem512, src: ZMM) -> Instruction { return inst_m_r(.VMOVDQU8, dst.mem, 64, Register(src)) } -emit_vmovdqu8_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .VMOVDQU8, Register(dst), Register(src)) } -emit_vmovdqu8_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .VMOVDQU8, Register(dst), src.mem, 16) } -emit_vmovdqu8_m128_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem128, src: XMM) { emit_mr(instructions, .VMOVDQU8, dst.mem, 16, Register(src)) } -emit_vmovdqu8_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM) { emit_rr(instructions, .VMOVDQU8, Register(dst), Register(src)) } -emit_vmovdqu8_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem256) { emit_rm(instructions, .VMOVDQU8, Register(dst), src.mem, 32) } -emit_vmovdqu8_m256_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem256, src: YMM) { emit_mr(instructions, .VMOVDQU8, dst.mem, 32, Register(src)) } -emit_vmovdqu8_zmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM) { emit_rr(instructions, .VMOVDQU8, Register(dst), Register(src)) } -emit_vmovdqu8_zmm_m512 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: Mem512) { emit_rm(instructions, .VMOVDQU8, Register(dst), src.mem, 64) } -emit_vmovdqu8_m512_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem512, src: ZMM) { emit_mr(instructions, .VMOVDQU8, dst.mem, 64, Register(src)) } -inst_vmovdqu16_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.VMOVDQU16, Register(dst), Register(src)) } -inst_vmovdqu16_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.VMOVDQU16, Register(dst), src.mem, 16) } -inst_vmovdqu16_m128_xmm :: #force_inline proc "contextless" (dst: Mem128, src: XMM) -> Instruction { return inst_m_r(.VMOVDQU16, dst.mem, 16, Register(src)) } -inst_vmovdqu16_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM) -> Instruction { return inst_r_r(.VMOVDQU16, Register(dst), Register(src)) } -inst_vmovdqu16_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: Mem256) -> Instruction { return inst_r_m(.VMOVDQU16, Register(dst), src.mem, 32) } -inst_vmovdqu16_m256_ymm :: #force_inline proc "contextless" (dst: Mem256, src: YMM) -> Instruction { return inst_m_r(.VMOVDQU16, dst.mem, 32, Register(src)) } -inst_vmovdqu16_zmm_zmm :: #force_inline proc "contextless" (dst: ZMM, src: ZMM) -> Instruction { return inst_r_r(.VMOVDQU16, Register(dst), Register(src)) } -inst_vmovdqu16_zmm_m512 :: #force_inline proc "contextless" (dst: ZMM, src: Mem512) -> Instruction { return inst_r_m(.VMOVDQU16, Register(dst), src.mem, 64) } -inst_vmovdqu16_m512_zmm :: #force_inline proc "contextless" (dst: Mem512, src: ZMM) -> Instruction { return inst_m_r(.VMOVDQU16, dst.mem, 64, Register(src)) } -emit_vmovdqu16_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .VMOVDQU16, Register(dst), Register(src)) } -emit_vmovdqu16_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .VMOVDQU16, Register(dst), src.mem, 16) } -emit_vmovdqu16_m128_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem128, src: XMM) { emit_mr(instructions, .VMOVDQU16, dst.mem, 16, Register(src)) } -emit_vmovdqu16_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM) { emit_rr(instructions, .VMOVDQU16, Register(dst), Register(src)) } -emit_vmovdqu16_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem256) { emit_rm(instructions, .VMOVDQU16, Register(dst), src.mem, 32) } -emit_vmovdqu16_m256_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem256, src: YMM) { emit_mr(instructions, .VMOVDQU16, dst.mem, 32, Register(src)) } -emit_vmovdqu16_zmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM) { emit_rr(instructions, .VMOVDQU16, Register(dst), Register(src)) } -emit_vmovdqu16_zmm_m512 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: Mem512) { emit_rm(instructions, .VMOVDQU16, Register(dst), src.mem, 64) } -emit_vmovdqu16_m512_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem512, src: ZMM) { emit_mr(instructions, .VMOVDQU16, dst.mem, 64, Register(src)) } -inst_vmovdqu32_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.VMOVDQU32, Register(dst), Register(src)) } -inst_vmovdqu32_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.VMOVDQU32, Register(dst), src.mem, 16) } -inst_vmovdqu32_m128_xmm :: #force_inline proc "contextless" (dst: Mem128, src: XMM) -> Instruction { return inst_m_r(.VMOVDQU32, dst.mem, 16, Register(src)) } -inst_vmovdqu32_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM) -> Instruction { return inst_r_r(.VMOVDQU32, Register(dst), Register(src)) } -inst_vmovdqu32_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: Mem256) -> Instruction { return inst_r_m(.VMOVDQU32, Register(dst), src.mem, 32) } -inst_vmovdqu32_m256_ymm :: #force_inline proc "contextless" (dst: Mem256, src: YMM) -> Instruction { return inst_m_r(.VMOVDQU32, dst.mem, 32, Register(src)) } -inst_vmovdqu32_zmm_zmm :: #force_inline proc "contextless" (dst: ZMM, src: ZMM) -> Instruction { return inst_r_r(.VMOVDQU32, Register(dst), Register(src)) } -inst_vmovdqu32_zmm_m512 :: #force_inline proc "contextless" (dst: ZMM, src: Mem512) -> Instruction { return inst_r_m(.VMOVDQU32, Register(dst), src.mem, 64) } -inst_vmovdqu32_m512_zmm :: #force_inline proc "contextless" (dst: Mem512, src: ZMM) -> Instruction { return inst_m_r(.VMOVDQU32, dst.mem, 64, Register(src)) } -emit_vmovdqu32_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .VMOVDQU32, Register(dst), Register(src)) } -emit_vmovdqu32_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .VMOVDQU32, Register(dst), src.mem, 16) } -emit_vmovdqu32_m128_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem128, src: XMM) { emit_mr(instructions, .VMOVDQU32, dst.mem, 16, Register(src)) } -emit_vmovdqu32_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM) { emit_rr(instructions, .VMOVDQU32, Register(dst), Register(src)) } -emit_vmovdqu32_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem256) { emit_rm(instructions, .VMOVDQU32, Register(dst), src.mem, 32) } -emit_vmovdqu32_m256_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem256, src: YMM) { emit_mr(instructions, .VMOVDQU32, dst.mem, 32, Register(src)) } -emit_vmovdqu32_zmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM) { emit_rr(instructions, .VMOVDQU32, Register(dst), Register(src)) } -emit_vmovdqu32_zmm_m512 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: Mem512) { emit_rm(instructions, .VMOVDQU32, Register(dst), src.mem, 64) } -emit_vmovdqu32_m512_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem512, src: ZMM) { emit_mr(instructions, .VMOVDQU32, dst.mem, 64, Register(src)) } -inst_vmovdqu64_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.VMOVDQU64, Register(dst), Register(src)) } -inst_vmovdqu64_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.VMOVDQU64, Register(dst), src.mem, 16) } -inst_vmovdqu64_m128_xmm :: #force_inline proc "contextless" (dst: Mem128, src: XMM) -> Instruction { return inst_m_r(.VMOVDQU64, dst.mem, 16, Register(src)) } -inst_vmovdqu64_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM) -> Instruction { return inst_r_r(.VMOVDQU64, Register(dst), Register(src)) } -inst_vmovdqu64_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: Mem256) -> Instruction { return inst_r_m(.VMOVDQU64, Register(dst), src.mem, 32) } -inst_vmovdqu64_m256_ymm :: #force_inline proc "contextless" (dst: Mem256, src: YMM) -> Instruction { return inst_m_r(.VMOVDQU64, dst.mem, 32, Register(src)) } -inst_vmovdqu64_zmm_zmm :: #force_inline proc "contextless" (dst: ZMM, src: ZMM) -> Instruction { return inst_r_r(.VMOVDQU64, Register(dst), Register(src)) } -inst_vmovdqu64_zmm_m512 :: #force_inline proc "contextless" (dst: ZMM, src: Mem512) -> Instruction { return inst_r_m(.VMOVDQU64, Register(dst), src.mem, 64) } -inst_vmovdqu64_m512_zmm :: #force_inline proc "contextless" (dst: Mem512, src: ZMM) -> Instruction { return inst_m_r(.VMOVDQU64, dst.mem, 64, Register(src)) } -emit_vmovdqu64_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .VMOVDQU64, Register(dst), Register(src)) } -emit_vmovdqu64_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .VMOVDQU64, Register(dst), src.mem, 16) } -emit_vmovdqu64_m128_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem128, src: XMM) { emit_mr(instructions, .VMOVDQU64, dst.mem, 16, Register(src)) } -emit_vmovdqu64_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM) { emit_rr(instructions, .VMOVDQU64, Register(dst), Register(src)) } -emit_vmovdqu64_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem256) { emit_rm(instructions, .VMOVDQU64, Register(dst), src.mem, 32) } -emit_vmovdqu64_m256_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem256, src: YMM) { emit_mr(instructions, .VMOVDQU64, dst.mem, 32, Register(src)) } -emit_vmovdqu64_zmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM) { emit_rr(instructions, .VMOVDQU64, Register(dst), Register(src)) } -emit_vmovdqu64_zmm_m512 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: Mem512) { emit_rm(instructions, .VMOVDQU64, Register(dst), src.mem, 64) } -emit_vmovdqu64_m512_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem512, src: ZMM) { emit_mr(instructions, .VMOVDQU64, dst.mem, 64, Register(src)) } -inst_vpblendmb_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VPBLENDMB, Register(dst), Register(src), Register(src2)) } -inst_vpblendmb_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VPBLENDMB, Register(dst), Register(src), src2.mem, 16) } -inst_vpblendmb_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VPBLENDMB, Register(dst), Register(src), Register(src2)) } -inst_vpblendmb_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VPBLENDMB, Register(dst), Register(src), src2.mem, 32) } -inst_vpblendmb_zmm_zmm_zmm :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: ZMM) -> Instruction { return inst_r_r_r(.VPBLENDMB, Register(dst), Register(src), Register(src2)) } -inst_vpblendmb_zmm_zmm_m512 :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: Mem512) -> Instruction { return inst_r_r_m(.VPBLENDMB, Register(dst), Register(src), src2.mem, 64) } -emit_vpblendmb_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VPBLENDMB, Register(dst), Register(src), Register(src2)) } -emit_vpblendmb_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VPBLENDMB, Register(dst), Register(src), src2.mem, 16) } -emit_vpblendmb_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VPBLENDMB, Register(dst), Register(src), Register(src2)) } -emit_vpblendmb_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VPBLENDMB, Register(dst), Register(src), src2.mem, 32) } -emit_vpblendmb_zmm_zmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: ZMM) { emit_rrr(instructions, .VPBLENDMB, Register(dst), Register(src), Register(src2)) } -emit_vpblendmb_zmm_zmm_m512 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: Mem512) { emit_rrm(instructions, .VPBLENDMB, Register(dst), Register(src), src2.mem, 64) } -inst_vpblendmw_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VPBLENDMW, Register(dst), Register(src), Register(src2)) } -inst_vpblendmw_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VPBLENDMW, Register(dst), Register(src), src2.mem, 16) } -inst_vpblendmw_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VPBLENDMW, Register(dst), Register(src), Register(src2)) } -inst_vpblendmw_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VPBLENDMW, Register(dst), Register(src), src2.mem, 32) } -inst_vpblendmw_zmm_zmm_zmm :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: ZMM) -> Instruction { return inst_r_r_r(.VPBLENDMW, Register(dst), Register(src), Register(src2)) } -inst_vpblendmw_zmm_zmm_m512 :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: Mem512) -> Instruction { return inst_r_r_m(.VPBLENDMW, Register(dst), Register(src), src2.mem, 64) } -emit_vpblendmw_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VPBLENDMW, Register(dst), Register(src), Register(src2)) } -emit_vpblendmw_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VPBLENDMW, Register(dst), Register(src), src2.mem, 16) } -emit_vpblendmw_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VPBLENDMW, Register(dst), Register(src), Register(src2)) } -emit_vpblendmw_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VPBLENDMW, Register(dst), Register(src), src2.mem, 32) } -emit_vpblendmw_zmm_zmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: ZMM) { emit_rrr(instructions, .VPBLENDMW, Register(dst), Register(src), Register(src2)) } -emit_vpblendmw_zmm_zmm_m512 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: Mem512) { emit_rrm(instructions, .VPBLENDMW, Register(dst), Register(src), src2.mem, 64) } -inst_vpblendmd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VPBLENDMD, Register(dst), Register(src), Register(src2)) } -inst_vpblendmd_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VPBLENDMD, Register(dst), Register(src), src2.mem, 16) } -inst_vpblendmd_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VPBLENDMD, Register(dst), Register(src), Register(src2)) } -inst_vpblendmd_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VPBLENDMD, Register(dst), Register(src), src2.mem, 32) } -inst_vpblendmd_zmm_zmm_zmm :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: ZMM) -> Instruction { return inst_r_r_r(.VPBLENDMD, Register(dst), Register(src), Register(src2)) } -inst_vpblendmd_zmm_zmm_m512 :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: Mem512) -> Instruction { return inst_r_r_m(.VPBLENDMD, Register(dst), Register(src), src2.mem, 64) } -emit_vpblendmd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VPBLENDMD, Register(dst), Register(src), Register(src2)) } -emit_vpblendmd_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VPBLENDMD, Register(dst), Register(src), src2.mem, 16) } -emit_vpblendmd_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VPBLENDMD, Register(dst), Register(src), Register(src2)) } -emit_vpblendmd_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VPBLENDMD, Register(dst), Register(src), src2.mem, 32) } -emit_vpblendmd_zmm_zmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: ZMM) { emit_rrr(instructions, .VPBLENDMD, Register(dst), Register(src), Register(src2)) } -emit_vpblendmd_zmm_zmm_m512 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: Mem512) { emit_rrm(instructions, .VPBLENDMD, Register(dst), Register(src), src2.mem, 64) } -inst_vpblendmq_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VPBLENDMQ, Register(dst), Register(src), Register(src2)) } -inst_vpblendmq_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VPBLENDMQ, Register(dst), Register(src), src2.mem, 16) } -inst_vpblendmq_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VPBLENDMQ, Register(dst), Register(src), Register(src2)) } -inst_vpblendmq_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VPBLENDMQ, Register(dst), Register(src), src2.mem, 32) } -inst_vpblendmq_zmm_zmm_zmm :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: ZMM) -> Instruction { return inst_r_r_r(.VPBLENDMQ, Register(dst), Register(src), Register(src2)) } -inst_vpblendmq_zmm_zmm_m512 :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: Mem512) -> Instruction { return inst_r_r_m(.VPBLENDMQ, Register(dst), Register(src), src2.mem, 64) } -emit_vpblendmq_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VPBLENDMQ, Register(dst), Register(src), Register(src2)) } -emit_vpblendmq_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VPBLENDMQ, Register(dst), Register(src), src2.mem, 16) } -emit_vpblendmq_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VPBLENDMQ, Register(dst), Register(src), Register(src2)) } -emit_vpblendmq_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VPBLENDMQ, Register(dst), Register(src), src2.mem, 32) } -emit_vpblendmq_zmm_zmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: ZMM) { emit_rrr(instructions, .VPBLENDMQ, Register(dst), Register(src), Register(src2)) } -emit_vpblendmq_zmm_zmm_m512 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: Mem512) { emit_rrm(instructions, .VPBLENDMQ, Register(dst), Register(src), src2.mem, 64) } -inst_vblendmps_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VBLENDMPS, Register(dst), Register(src), Register(src2)) } -inst_vblendmps_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VBLENDMPS, Register(dst), Register(src), src2.mem, 16) } -inst_vblendmps_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VBLENDMPS, Register(dst), Register(src), Register(src2)) } -inst_vblendmps_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VBLENDMPS, Register(dst), Register(src), src2.mem, 32) } -inst_vblendmps_zmm_zmm_zmm :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: ZMM) -> Instruction { return inst_r_r_r(.VBLENDMPS, Register(dst), Register(src), Register(src2)) } -inst_vblendmps_zmm_zmm_m512 :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: Mem512) -> Instruction { return inst_r_r_m(.VBLENDMPS, Register(dst), Register(src), src2.mem, 64) } -emit_vblendmps_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VBLENDMPS, Register(dst), Register(src), Register(src2)) } -emit_vblendmps_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VBLENDMPS, Register(dst), Register(src), src2.mem, 16) } -emit_vblendmps_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VBLENDMPS, Register(dst), Register(src), Register(src2)) } -emit_vblendmps_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VBLENDMPS, Register(dst), Register(src), src2.mem, 32) } -emit_vblendmps_zmm_zmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: ZMM) { emit_rrr(instructions, .VBLENDMPS, Register(dst), Register(src), Register(src2)) } -emit_vblendmps_zmm_zmm_m512 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: Mem512) { emit_rrm(instructions, .VBLENDMPS, Register(dst), Register(src), src2.mem, 64) } -inst_vblendmpd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VBLENDMPD, Register(dst), Register(src), Register(src2)) } -inst_vblendmpd_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VBLENDMPD, Register(dst), Register(src), src2.mem, 16) } -inst_vblendmpd_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VBLENDMPD, Register(dst), Register(src), Register(src2)) } -inst_vblendmpd_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VBLENDMPD, Register(dst), Register(src), src2.mem, 32) } -inst_vblendmpd_zmm_zmm_zmm :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: ZMM) -> Instruction { return inst_r_r_r(.VBLENDMPD, Register(dst), Register(src), Register(src2)) } -inst_vblendmpd_zmm_zmm_m512 :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: Mem512) -> Instruction { return inst_r_r_m(.VBLENDMPD, Register(dst), Register(src), src2.mem, 64) } -emit_vblendmpd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VBLENDMPD, Register(dst), Register(src), Register(src2)) } -emit_vblendmpd_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VBLENDMPD, Register(dst), Register(src), src2.mem, 16) } -emit_vblendmpd_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VBLENDMPD, Register(dst), Register(src), Register(src2)) } -emit_vblendmpd_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VBLENDMPD, Register(dst), Register(src), src2.mem, 32) } -emit_vblendmpd_zmm_zmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: ZMM) { emit_rrr(instructions, .VBLENDMPD, Register(dst), Register(src), Register(src2)) } -emit_vblendmpd_zmm_zmm_m512 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: Mem512) { emit_rrm(instructions, .VBLENDMPD, Register(dst), Register(src), src2.mem, 64) } +inst_vfmadd132ps_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VFMADD132PS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1499) } +inst_vfmadd132ps_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VFMADD132PS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1499) } +inst_vfmadd132ps_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VFMADD132PS, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1500) } +inst_vfmadd132ps_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VFMADD132PS, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1500) } +emit_vfmadd132ps_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vfmadd132ps_xmm_xmm_xmm(dst, src, src2)) } +emit_vfmadd132ps_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vfmadd132ps_xmm_xmm_m128(dst, src, src2)) } +emit_vfmadd132ps_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vfmadd132ps_ymm_ymm_ymm(dst, src, src2)) } +emit_vfmadd132ps_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vfmadd132ps_ymm_ymm_m256(dst, src, src2)) } +inst_vfmadd213ps_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VFMADD213PS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1501) } +inst_vfmadd213ps_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VFMADD213PS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1501) } +inst_vfmadd213ps_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VFMADD213PS, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1502) } +inst_vfmadd213ps_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VFMADD213PS, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1502) } +emit_vfmadd213ps_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vfmadd213ps_xmm_xmm_xmm(dst, src, src2)) } +emit_vfmadd213ps_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vfmadd213ps_xmm_xmm_m128(dst, src, src2)) } +emit_vfmadd213ps_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vfmadd213ps_ymm_ymm_ymm(dst, src, src2)) } +emit_vfmadd213ps_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vfmadd213ps_ymm_ymm_m256(dst, src, src2)) } +inst_vfmadd231ps_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VFMADD231PS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1503) } +inst_vfmadd231ps_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VFMADD231PS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1503) } +inst_vfmadd231ps_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VFMADD231PS, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1504) } +inst_vfmadd231ps_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VFMADD231PS, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1504) } +emit_vfmadd231ps_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vfmadd231ps_xmm_xmm_xmm(dst, src, src2)) } +emit_vfmadd231ps_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vfmadd231ps_xmm_xmm_m128(dst, src, src2)) } +emit_vfmadd231ps_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vfmadd231ps_ymm_ymm_ymm(dst, src, src2)) } +emit_vfmadd231ps_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vfmadd231ps_ymm_ymm_m256(dst, src, src2)) } +inst_vfmadd132pd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VFMADD132PD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1505) } +inst_vfmadd132pd_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VFMADD132PD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1505) } +inst_vfmadd132pd_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VFMADD132PD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1506) } +inst_vfmadd132pd_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VFMADD132PD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1506) } +emit_vfmadd132pd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vfmadd132pd_xmm_xmm_xmm(dst, src, src2)) } +emit_vfmadd132pd_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vfmadd132pd_xmm_xmm_m128(dst, src, src2)) } +emit_vfmadd132pd_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vfmadd132pd_ymm_ymm_ymm(dst, src, src2)) } +emit_vfmadd132pd_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vfmadd132pd_ymm_ymm_m256(dst, src, src2)) } +inst_vfmadd213pd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VFMADD213PD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1507) } +inst_vfmadd213pd_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VFMADD213PD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1507) } +inst_vfmadd213pd_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VFMADD213PD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1508) } +inst_vfmadd213pd_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VFMADD213PD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1508) } +emit_vfmadd213pd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vfmadd213pd_xmm_xmm_xmm(dst, src, src2)) } +emit_vfmadd213pd_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vfmadd213pd_xmm_xmm_m128(dst, src, src2)) } +emit_vfmadd213pd_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vfmadd213pd_ymm_ymm_ymm(dst, src, src2)) } +emit_vfmadd213pd_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vfmadd213pd_ymm_ymm_m256(dst, src, src2)) } +inst_vfmadd231pd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VFMADD231PD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1509) } +inst_vfmadd231pd_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VFMADD231PD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1509) } +inst_vfmadd231pd_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VFMADD231PD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1510) } +inst_vfmadd231pd_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VFMADD231PD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1510) } +emit_vfmadd231pd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vfmadd231pd_xmm_xmm_xmm(dst, src, src2)) } +emit_vfmadd231pd_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vfmadd231pd_xmm_xmm_m128(dst, src, src2)) } +emit_vfmadd231pd_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vfmadd231pd_ymm_ymm_ymm(dst, src, src2)) } +emit_vfmadd231pd_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vfmadd231pd_ymm_ymm_m256(dst, src, src2)) } +inst_vfmadd132ss_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VFMADD132SS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1511) } +inst_vfmadd132ss_xmm_xmm_m32 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .VFMADD132SS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 4), {}} }, 1511) } +emit_vfmadd132ss_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vfmadd132ss_xmm_xmm_xmm(dst, src, src2)) } +emit_vfmadd132ss_xmm_xmm_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem32) { append(instructions, inst_vfmadd132ss_xmm_xmm_m32(dst, src, src2)) } +inst_vfmadd213ss_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VFMADD213SS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1512) } +inst_vfmadd213ss_xmm_xmm_m32 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .VFMADD213SS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 4), {}} }, 1512) } +emit_vfmadd213ss_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vfmadd213ss_xmm_xmm_xmm(dst, src, src2)) } +emit_vfmadd213ss_xmm_xmm_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem32) { append(instructions, inst_vfmadd213ss_xmm_xmm_m32(dst, src, src2)) } +inst_vfmadd231ss_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VFMADD231SS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1513) } +inst_vfmadd231ss_xmm_xmm_m32 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .VFMADD231SS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 4), {}} }, 1513) } +emit_vfmadd231ss_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vfmadd231ss_xmm_xmm_xmm(dst, src, src2)) } +emit_vfmadd231ss_xmm_xmm_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem32) { append(instructions, inst_vfmadd231ss_xmm_xmm_m32(dst, src, src2)) } +inst_vfmadd132sd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VFMADD132SD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1514) } +inst_vfmadd132sd_xmm_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .VFMADD132SD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 8), {}} }, 1514) } +emit_vfmadd132sd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vfmadd132sd_xmm_xmm_xmm(dst, src, src2)) } +emit_vfmadd132sd_xmm_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem64) { append(instructions, inst_vfmadd132sd_xmm_xmm_m64(dst, src, src2)) } +inst_vfmadd213sd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VFMADD213SD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1515) } +inst_vfmadd213sd_xmm_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .VFMADD213SD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 8), {}} }, 1515) } +emit_vfmadd213sd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vfmadd213sd_xmm_xmm_xmm(dst, src, src2)) } +emit_vfmadd213sd_xmm_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem64) { append(instructions, inst_vfmadd213sd_xmm_xmm_m64(dst, src, src2)) } +inst_vfmadd231sd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VFMADD231SD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1516) } +inst_vfmadd231sd_xmm_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .VFMADD231SD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 8), {}} }, 1516) } +emit_vfmadd231sd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vfmadd231sd_xmm_xmm_xmm(dst, src, src2)) } +emit_vfmadd231sd_xmm_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem64) { append(instructions, inst_vfmadd231sd_xmm_xmm_m64(dst, src, src2)) } +inst_vfmsub132ps_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VFMSUB132PS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1517) } +inst_vfmsub132ps_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VFMSUB132PS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1517) } +inst_vfmsub132ps_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VFMSUB132PS, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1518) } +inst_vfmsub132ps_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VFMSUB132PS, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1518) } +emit_vfmsub132ps_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vfmsub132ps_xmm_xmm_xmm(dst, src, src2)) } +emit_vfmsub132ps_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vfmsub132ps_xmm_xmm_m128(dst, src, src2)) } +emit_vfmsub132ps_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vfmsub132ps_ymm_ymm_ymm(dst, src, src2)) } +emit_vfmsub132ps_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vfmsub132ps_ymm_ymm_m256(dst, src, src2)) } +inst_vfmsub213ps_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VFMSUB213PS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1519) } +inst_vfmsub213ps_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VFMSUB213PS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1519) } +inst_vfmsub213ps_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VFMSUB213PS, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1520) } +inst_vfmsub213ps_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VFMSUB213PS, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1520) } +emit_vfmsub213ps_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vfmsub213ps_xmm_xmm_xmm(dst, src, src2)) } +emit_vfmsub213ps_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vfmsub213ps_xmm_xmm_m128(dst, src, src2)) } +emit_vfmsub213ps_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vfmsub213ps_ymm_ymm_ymm(dst, src, src2)) } +emit_vfmsub213ps_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vfmsub213ps_ymm_ymm_m256(dst, src, src2)) } +inst_vfmsub231ps_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VFMSUB231PS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1521) } +inst_vfmsub231ps_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VFMSUB231PS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1521) } +inst_vfmsub231ps_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VFMSUB231PS, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1522) } +inst_vfmsub231ps_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VFMSUB231PS, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1522) } +emit_vfmsub231ps_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vfmsub231ps_xmm_xmm_xmm(dst, src, src2)) } +emit_vfmsub231ps_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vfmsub231ps_xmm_xmm_m128(dst, src, src2)) } +emit_vfmsub231ps_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vfmsub231ps_ymm_ymm_ymm(dst, src, src2)) } +emit_vfmsub231ps_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vfmsub231ps_ymm_ymm_m256(dst, src, src2)) } +inst_vfmsub132pd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VFMSUB132PD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1523) } +inst_vfmsub132pd_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VFMSUB132PD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1523) } +inst_vfmsub132pd_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VFMSUB132PD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1524) } +inst_vfmsub132pd_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VFMSUB132PD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1524) } +emit_vfmsub132pd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vfmsub132pd_xmm_xmm_xmm(dst, src, src2)) } +emit_vfmsub132pd_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vfmsub132pd_xmm_xmm_m128(dst, src, src2)) } +emit_vfmsub132pd_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vfmsub132pd_ymm_ymm_ymm(dst, src, src2)) } +emit_vfmsub132pd_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vfmsub132pd_ymm_ymm_m256(dst, src, src2)) } +inst_vfmsub213pd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VFMSUB213PD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1525) } +inst_vfmsub213pd_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VFMSUB213PD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1525) } +inst_vfmsub213pd_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VFMSUB213PD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1526) } +inst_vfmsub213pd_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VFMSUB213PD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1526) } +emit_vfmsub213pd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vfmsub213pd_xmm_xmm_xmm(dst, src, src2)) } +emit_vfmsub213pd_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vfmsub213pd_xmm_xmm_m128(dst, src, src2)) } +emit_vfmsub213pd_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vfmsub213pd_ymm_ymm_ymm(dst, src, src2)) } +emit_vfmsub213pd_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vfmsub213pd_ymm_ymm_m256(dst, src, src2)) } +inst_vfmsub231pd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VFMSUB231PD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1527) } +inst_vfmsub231pd_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VFMSUB231PD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1527) } +inst_vfmsub231pd_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VFMSUB231PD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1528) } +inst_vfmsub231pd_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VFMSUB231PD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1528) } +emit_vfmsub231pd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vfmsub231pd_xmm_xmm_xmm(dst, src, src2)) } +emit_vfmsub231pd_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vfmsub231pd_xmm_xmm_m128(dst, src, src2)) } +emit_vfmsub231pd_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vfmsub231pd_ymm_ymm_ymm(dst, src, src2)) } +emit_vfmsub231pd_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vfmsub231pd_ymm_ymm_m256(dst, src, src2)) } +inst_vfmsub132ss_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VFMSUB132SS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1529) } +inst_vfmsub132ss_xmm_xmm_m32 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .VFMSUB132SS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 4), {}} }, 1529) } +emit_vfmsub132ss_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vfmsub132ss_xmm_xmm_xmm(dst, src, src2)) } +emit_vfmsub132ss_xmm_xmm_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem32) { append(instructions, inst_vfmsub132ss_xmm_xmm_m32(dst, src, src2)) } +inst_vfmsub213ss_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VFMSUB213SS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1530) } +inst_vfmsub213ss_xmm_xmm_m32 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .VFMSUB213SS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 4), {}} }, 1530) } +emit_vfmsub213ss_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vfmsub213ss_xmm_xmm_xmm(dst, src, src2)) } +emit_vfmsub213ss_xmm_xmm_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem32) { append(instructions, inst_vfmsub213ss_xmm_xmm_m32(dst, src, src2)) } +inst_vfmsub231ss_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VFMSUB231SS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1531) } +inst_vfmsub231ss_xmm_xmm_m32 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .VFMSUB231SS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 4), {}} }, 1531) } +emit_vfmsub231ss_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vfmsub231ss_xmm_xmm_xmm(dst, src, src2)) } +emit_vfmsub231ss_xmm_xmm_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem32) { append(instructions, inst_vfmsub231ss_xmm_xmm_m32(dst, src, src2)) } +inst_vfmsub132sd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VFMSUB132SD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1532) } +inst_vfmsub132sd_xmm_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .VFMSUB132SD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 8), {}} }, 1532) } +emit_vfmsub132sd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vfmsub132sd_xmm_xmm_xmm(dst, src, src2)) } +emit_vfmsub132sd_xmm_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem64) { append(instructions, inst_vfmsub132sd_xmm_xmm_m64(dst, src, src2)) } +inst_vfmsub213sd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VFMSUB213SD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1533) } +inst_vfmsub213sd_xmm_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .VFMSUB213SD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 8), {}} }, 1533) } +emit_vfmsub213sd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vfmsub213sd_xmm_xmm_xmm(dst, src, src2)) } +emit_vfmsub213sd_xmm_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem64) { append(instructions, inst_vfmsub213sd_xmm_xmm_m64(dst, src, src2)) } +inst_vfmsub231sd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VFMSUB231SD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1534) } +inst_vfmsub231sd_xmm_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .VFMSUB231SD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 8), {}} }, 1534) } +emit_vfmsub231sd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vfmsub231sd_xmm_xmm_xmm(dst, src, src2)) } +emit_vfmsub231sd_xmm_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem64) { append(instructions, inst_vfmsub231sd_xmm_xmm_m64(dst, src, src2)) } +inst_vfnmadd132ps_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VFNMADD132PS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1535) } +inst_vfnmadd132ps_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VFNMADD132PS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1535) } +inst_vfnmadd132ps_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VFNMADD132PS, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1536) } +inst_vfnmadd132ps_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VFNMADD132PS, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1536) } +emit_vfnmadd132ps_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vfnmadd132ps_xmm_xmm_xmm(dst, src, src2)) } +emit_vfnmadd132ps_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vfnmadd132ps_xmm_xmm_m128(dst, src, src2)) } +emit_vfnmadd132ps_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vfnmadd132ps_ymm_ymm_ymm(dst, src, src2)) } +emit_vfnmadd132ps_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vfnmadd132ps_ymm_ymm_m256(dst, src, src2)) } +inst_vfnmadd213ps_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VFNMADD213PS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1537) } +inst_vfnmadd213ps_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VFNMADD213PS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1537) } +inst_vfnmadd213ps_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VFNMADD213PS, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1538) } +inst_vfnmadd213ps_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VFNMADD213PS, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1538) } +emit_vfnmadd213ps_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vfnmadd213ps_xmm_xmm_xmm(dst, src, src2)) } +emit_vfnmadd213ps_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vfnmadd213ps_xmm_xmm_m128(dst, src, src2)) } +emit_vfnmadd213ps_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vfnmadd213ps_ymm_ymm_ymm(dst, src, src2)) } +emit_vfnmadd213ps_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vfnmadd213ps_ymm_ymm_m256(dst, src, src2)) } +inst_vfnmadd231ps_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VFNMADD231PS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1539) } +inst_vfnmadd231ps_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VFNMADD231PS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1539) } +inst_vfnmadd231ps_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VFNMADD231PS, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1540) } +inst_vfnmadd231ps_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VFNMADD231PS, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1540) } +emit_vfnmadd231ps_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vfnmadd231ps_xmm_xmm_xmm(dst, src, src2)) } +emit_vfnmadd231ps_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vfnmadd231ps_xmm_xmm_m128(dst, src, src2)) } +emit_vfnmadd231ps_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vfnmadd231ps_ymm_ymm_ymm(dst, src, src2)) } +emit_vfnmadd231ps_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vfnmadd231ps_ymm_ymm_m256(dst, src, src2)) } +inst_vfnmadd132pd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VFNMADD132PD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1541) } +inst_vfnmadd132pd_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VFNMADD132PD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1541) } +inst_vfnmadd132pd_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VFNMADD132PD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1542) } +inst_vfnmadd132pd_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VFNMADD132PD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1542) } +emit_vfnmadd132pd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vfnmadd132pd_xmm_xmm_xmm(dst, src, src2)) } +emit_vfnmadd132pd_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vfnmadd132pd_xmm_xmm_m128(dst, src, src2)) } +emit_vfnmadd132pd_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vfnmadd132pd_ymm_ymm_ymm(dst, src, src2)) } +emit_vfnmadd132pd_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vfnmadd132pd_ymm_ymm_m256(dst, src, src2)) } +inst_vfnmadd213pd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VFNMADD213PD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1543) } +inst_vfnmadd213pd_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VFNMADD213PD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1543) } +inst_vfnmadd213pd_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VFNMADD213PD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1544) } +inst_vfnmadd213pd_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VFNMADD213PD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1544) } +emit_vfnmadd213pd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vfnmadd213pd_xmm_xmm_xmm(dst, src, src2)) } +emit_vfnmadd213pd_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vfnmadd213pd_xmm_xmm_m128(dst, src, src2)) } +emit_vfnmadd213pd_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vfnmadd213pd_ymm_ymm_ymm(dst, src, src2)) } +emit_vfnmadd213pd_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vfnmadd213pd_ymm_ymm_m256(dst, src, src2)) } +inst_vfnmadd231pd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VFNMADD231PD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1545) } +inst_vfnmadd231pd_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VFNMADD231PD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1545) } +inst_vfnmadd231pd_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VFNMADD231PD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1546) } +inst_vfnmadd231pd_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VFNMADD231PD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1546) } +emit_vfnmadd231pd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vfnmadd231pd_xmm_xmm_xmm(dst, src, src2)) } +emit_vfnmadd231pd_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vfnmadd231pd_xmm_xmm_m128(dst, src, src2)) } +emit_vfnmadd231pd_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vfnmadd231pd_ymm_ymm_ymm(dst, src, src2)) } +emit_vfnmadd231pd_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vfnmadd231pd_ymm_ymm_m256(dst, src, src2)) } +inst_vfnmadd132ss_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VFNMADD132SS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1547) } +inst_vfnmadd132ss_xmm_xmm_m32 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .VFNMADD132SS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 4), {}} }, 1547) } +emit_vfnmadd132ss_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vfnmadd132ss_xmm_xmm_xmm(dst, src, src2)) } +emit_vfnmadd132ss_xmm_xmm_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem32) { append(instructions, inst_vfnmadd132ss_xmm_xmm_m32(dst, src, src2)) } +inst_vfnmadd213ss_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VFNMADD213SS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1548) } +inst_vfnmadd213ss_xmm_xmm_m32 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .VFNMADD213SS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 4), {}} }, 1548) } +emit_vfnmadd213ss_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vfnmadd213ss_xmm_xmm_xmm(dst, src, src2)) } +emit_vfnmadd213ss_xmm_xmm_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem32) { append(instructions, inst_vfnmadd213ss_xmm_xmm_m32(dst, src, src2)) } +inst_vfnmadd231ss_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VFNMADD231SS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1549) } +inst_vfnmadd231ss_xmm_xmm_m32 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .VFNMADD231SS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 4), {}} }, 1549) } +emit_vfnmadd231ss_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vfnmadd231ss_xmm_xmm_xmm(dst, src, src2)) } +emit_vfnmadd231ss_xmm_xmm_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem32) { append(instructions, inst_vfnmadd231ss_xmm_xmm_m32(dst, src, src2)) } +inst_vfnmadd132sd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VFNMADD132SD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1550) } +inst_vfnmadd132sd_xmm_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .VFNMADD132SD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 8), {}} }, 1550) } +emit_vfnmadd132sd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vfnmadd132sd_xmm_xmm_xmm(dst, src, src2)) } +emit_vfnmadd132sd_xmm_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem64) { append(instructions, inst_vfnmadd132sd_xmm_xmm_m64(dst, src, src2)) } +inst_vfnmadd213sd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VFNMADD213SD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1551) } +inst_vfnmadd213sd_xmm_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .VFNMADD213SD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 8), {}} }, 1551) } +emit_vfnmadd213sd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vfnmadd213sd_xmm_xmm_xmm(dst, src, src2)) } +emit_vfnmadd213sd_xmm_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem64) { append(instructions, inst_vfnmadd213sd_xmm_xmm_m64(dst, src, src2)) } +inst_vfnmadd231sd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VFNMADD231SD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1552) } +inst_vfnmadd231sd_xmm_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .VFNMADD231SD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 8), {}} }, 1552) } +emit_vfnmadd231sd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vfnmadd231sd_xmm_xmm_xmm(dst, src, src2)) } +emit_vfnmadd231sd_xmm_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem64) { append(instructions, inst_vfnmadd231sd_xmm_xmm_m64(dst, src, src2)) } +inst_vfnmsub132ps_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VFNMSUB132PS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1553) } +inst_vfnmsub132ps_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VFNMSUB132PS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1553) } +inst_vfnmsub132ps_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VFNMSUB132PS, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1554) } +inst_vfnmsub132ps_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VFNMSUB132PS, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1554) } +emit_vfnmsub132ps_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vfnmsub132ps_xmm_xmm_xmm(dst, src, src2)) } +emit_vfnmsub132ps_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vfnmsub132ps_xmm_xmm_m128(dst, src, src2)) } +emit_vfnmsub132ps_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vfnmsub132ps_ymm_ymm_ymm(dst, src, src2)) } +emit_vfnmsub132ps_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vfnmsub132ps_ymm_ymm_m256(dst, src, src2)) } +inst_vfnmsub213ps_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VFNMSUB213PS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1555) } +inst_vfnmsub213ps_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VFNMSUB213PS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1555) } +inst_vfnmsub213ps_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VFNMSUB213PS, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1556) } +inst_vfnmsub213ps_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VFNMSUB213PS, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1556) } +emit_vfnmsub213ps_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vfnmsub213ps_xmm_xmm_xmm(dst, src, src2)) } +emit_vfnmsub213ps_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vfnmsub213ps_xmm_xmm_m128(dst, src, src2)) } +emit_vfnmsub213ps_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vfnmsub213ps_ymm_ymm_ymm(dst, src, src2)) } +emit_vfnmsub213ps_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vfnmsub213ps_ymm_ymm_m256(dst, src, src2)) } +inst_vfnmsub231ps_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VFNMSUB231PS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1557) } +inst_vfnmsub231ps_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VFNMSUB231PS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1557) } +inst_vfnmsub231ps_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VFNMSUB231PS, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1558) } +inst_vfnmsub231ps_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VFNMSUB231PS, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1558) } +emit_vfnmsub231ps_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vfnmsub231ps_xmm_xmm_xmm(dst, src, src2)) } +emit_vfnmsub231ps_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vfnmsub231ps_xmm_xmm_m128(dst, src, src2)) } +emit_vfnmsub231ps_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vfnmsub231ps_ymm_ymm_ymm(dst, src, src2)) } +emit_vfnmsub231ps_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vfnmsub231ps_ymm_ymm_m256(dst, src, src2)) } +inst_vfnmsub132pd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VFNMSUB132PD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1559) } +inst_vfnmsub132pd_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VFNMSUB132PD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1559) } +inst_vfnmsub132pd_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VFNMSUB132PD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1560) } +inst_vfnmsub132pd_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VFNMSUB132PD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1560) } +emit_vfnmsub132pd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vfnmsub132pd_xmm_xmm_xmm(dst, src, src2)) } +emit_vfnmsub132pd_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vfnmsub132pd_xmm_xmm_m128(dst, src, src2)) } +emit_vfnmsub132pd_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vfnmsub132pd_ymm_ymm_ymm(dst, src, src2)) } +emit_vfnmsub132pd_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vfnmsub132pd_ymm_ymm_m256(dst, src, src2)) } +inst_vfnmsub213pd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VFNMSUB213PD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1561) } +inst_vfnmsub213pd_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VFNMSUB213PD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1561) } +inst_vfnmsub213pd_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VFNMSUB213PD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1562) } +inst_vfnmsub213pd_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VFNMSUB213PD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1562) } +emit_vfnmsub213pd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vfnmsub213pd_xmm_xmm_xmm(dst, src, src2)) } +emit_vfnmsub213pd_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vfnmsub213pd_xmm_xmm_m128(dst, src, src2)) } +emit_vfnmsub213pd_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vfnmsub213pd_ymm_ymm_ymm(dst, src, src2)) } +emit_vfnmsub213pd_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vfnmsub213pd_ymm_ymm_m256(dst, src, src2)) } +inst_vfnmsub231pd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VFNMSUB231PD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1563) } +inst_vfnmsub231pd_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VFNMSUB231PD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1563) } +inst_vfnmsub231pd_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VFNMSUB231PD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1564) } +inst_vfnmsub231pd_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VFNMSUB231PD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1564) } +emit_vfnmsub231pd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vfnmsub231pd_xmm_xmm_xmm(dst, src, src2)) } +emit_vfnmsub231pd_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vfnmsub231pd_xmm_xmm_m128(dst, src, src2)) } +emit_vfnmsub231pd_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vfnmsub231pd_ymm_ymm_ymm(dst, src, src2)) } +emit_vfnmsub231pd_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vfnmsub231pd_ymm_ymm_m256(dst, src, src2)) } +inst_vfnmsub132ss_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VFNMSUB132SS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1565) } +inst_vfnmsub132ss_xmm_xmm_m32 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .VFNMSUB132SS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 4), {}} }, 1565) } +emit_vfnmsub132ss_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vfnmsub132ss_xmm_xmm_xmm(dst, src, src2)) } +emit_vfnmsub132ss_xmm_xmm_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem32) { append(instructions, inst_vfnmsub132ss_xmm_xmm_m32(dst, src, src2)) } +inst_vfnmsub213ss_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VFNMSUB213SS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1566) } +inst_vfnmsub213ss_xmm_xmm_m32 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .VFNMSUB213SS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 4), {}} }, 1566) } +emit_vfnmsub213ss_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vfnmsub213ss_xmm_xmm_xmm(dst, src, src2)) } +emit_vfnmsub213ss_xmm_xmm_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem32) { append(instructions, inst_vfnmsub213ss_xmm_xmm_m32(dst, src, src2)) } +inst_vfnmsub231ss_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VFNMSUB231SS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1567) } +inst_vfnmsub231ss_xmm_xmm_m32 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .VFNMSUB231SS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 4), {}} }, 1567) } +emit_vfnmsub231ss_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vfnmsub231ss_xmm_xmm_xmm(dst, src, src2)) } +emit_vfnmsub231ss_xmm_xmm_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem32) { append(instructions, inst_vfnmsub231ss_xmm_xmm_m32(dst, src, src2)) } +inst_vfnmsub132sd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VFNMSUB132SD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1568) } +inst_vfnmsub132sd_xmm_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .VFNMSUB132SD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 8), {}} }, 1568) } +emit_vfnmsub132sd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vfnmsub132sd_xmm_xmm_xmm(dst, src, src2)) } +emit_vfnmsub132sd_xmm_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem64) { append(instructions, inst_vfnmsub132sd_xmm_xmm_m64(dst, src, src2)) } +inst_vfnmsub213sd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VFNMSUB213SD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1569) } +inst_vfnmsub213sd_xmm_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .VFNMSUB213SD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 8), {}} }, 1569) } +emit_vfnmsub213sd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vfnmsub213sd_xmm_xmm_xmm(dst, src, src2)) } +emit_vfnmsub213sd_xmm_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem64) { append(instructions, inst_vfnmsub213sd_xmm_xmm_m64(dst, src, src2)) } +inst_vfnmsub231sd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VFNMSUB231SD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1570) } +inst_vfnmsub231sd_xmm_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .VFNMSUB231SD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 8), {}} }, 1570) } +emit_vfnmsub231sd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vfnmsub231sd_xmm_xmm_xmm(dst, src, src2)) } +emit_vfnmsub231sd_xmm_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem64) { append(instructions, inst_vfnmsub231sd_xmm_xmm_m64(dst, src, src2)) } +inst_vfmaddsub132ps_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VFMADDSUB132PS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1571) } +inst_vfmaddsub132ps_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VFMADDSUB132PS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1571) } +inst_vfmaddsub132ps_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VFMADDSUB132PS, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1572) } +inst_vfmaddsub132ps_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VFMADDSUB132PS, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1572) } +emit_vfmaddsub132ps_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vfmaddsub132ps_xmm_xmm_xmm(dst, src, src2)) } +emit_vfmaddsub132ps_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vfmaddsub132ps_xmm_xmm_m128(dst, src, src2)) } +emit_vfmaddsub132ps_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vfmaddsub132ps_ymm_ymm_ymm(dst, src, src2)) } +emit_vfmaddsub132ps_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vfmaddsub132ps_ymm_ymm_m256(dst, src, src2)) } +inst_vfmaddsub213ps_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VFMADDSUB213PS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1573) } +inst_vfmaddsub213ps_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VFMADDSUB213PS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1573) } +inst_vfmaddsub213ps_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VFMADDSUB213PS, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1574) } +inst_vfmaddsub213ps_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VFMADDSUB213PS, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1574) } +emit_vfmaddsub213ps_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vfmaddsub213ps_xmm_xmm_xmm(dst, src, src2)) } +emit_vfmaddsub213ps_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vfmaddsub213ps_xmm_xmm_m128(dst, src, src2)) } +emit_vfmaddsub213ps_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vfmaddsub213ps_ymm_ymm_ymm(dst, src, src2)) } +emit_vfmaddsub213ps_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vfmaddsub213ps_ymm_ymm_m256(dst, src, src2)) } +inst_vfmaddsub231ps_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VFMADDSUB231PS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1575) } +inst_vfmaddsub231ps_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VFMADDSUB231PS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1575) } +inst_vfmaddsub231ps_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VFMADDSUB231PS, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1576) } +inst_vfmaddsub231ps_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VFMADDSUB231PS, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1576) } +emit_vfmaddsub231ps_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vfmaddsub231ps_xmm_xmm_xmm(dst, src, src2)) } +emit_vfmaddsub231ps_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vfmaddsub231ps_xmm_xmm_m128(dst, src, src2)) } +emit_vfmaddsub231ps_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vfmaddsub231ps_ymm_ymm_ymm(dst, src, src2)) } +emit_vfmaddsub231ps_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vfmaddsub231ps_ymm_ymm_m256(dst, src, src2)) } +inst_vfmaddsub132pd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VFMADDSUB132PD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1577) } +inst_vfmaddsub132pd_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VFMADDSUB132PD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1577) } +inst_vfmaddsub132pd_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VFMADDSUB132PD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1578) } +inst_vfmaddsub132pd_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VFMADDSUB132PD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1578) } +emit_vfmaddsub132pd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vfmaddsub132pd_xmm_xmm_xmm(dst, src, src2)) } +emit_vfmaddsub132pd_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vfmaddsub132pd_xmm_xmm_m128(dst, src, src2)) } +emit_vfmaddsub132pd_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vfmaddsub132pd_ymm_ymm_ymm(dst, src, src2)) } +emit_vfmaddsub132pd_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vfmaddsub132pd_ymm_ymm_m256(dst, src, src2)) } +inst_vfmaddsub213pd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VFMADDSUB213PD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1579) } +inst_vfmaddsub213pd_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VFMADDSUB213PD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1579) } +inst_vfmaddsub213pd_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VFMADDSUB213PD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1580) } +inst_vfmaddsub213pd_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VFMADDSUB213PD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1580) } +emit_vfmaddsub213pd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vfmaddsub213pd_xmm_xmm_xmm(dst, src, src2)) } +emit_vfmaddsub213pd_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vfmaddsub213pd_xmm_xmm_m128(dst, src, src2)) } +emit_vfmaddsub213pd_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vfmaddsub213pd_ymm_ymm_ymm(dst, src, src2)) } +emit_vfmaddsub213pd_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vfmaddsub213pd_ymm_ymm_m256(dst, src, src2)) } +inst_vfmaddsub231pd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VFMADDSUB231PD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1581) } +inst_vfmaddsub231pd_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VFMADDSUB231PD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1581) } +inst_vfmaddsub231pd_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VFMADDSUB231PD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1582) } +inst_vfmaddsub231pd_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VFMADDSUB231PD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1582) } +emit_vfmaddsub231pd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vfmaddsub231pd_xmm_xmm_xmm(dst, src, src2)) } +emit_vfmaddsub231pd_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vfmaddsub231pd_xmm_xmm_m128(dst, src, src2)) } +emit_vfmaddsub231pd_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vfmaddsub231pd_ymm_ymm_ymm(dst, src, src2)) } +emit_vfmaddsub231pd_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vfmaddsub231pd_ymm_ymm_m256(dst, src, src2)) } +inst_vfmsubadd132ps_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VFMSUBADD132PS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1583) } +inst_vfmsubadd132ps_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VFMSUBADD132PS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1583) } +inst_vfmsubadd132ps_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VFMSUBADD132PS, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1584) } +inst_vfmsubadd132ps_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VFMSUBADD132PS, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1584) } +emit_vfmsubadd132ps_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vfmsubadd132ps_xmm_xmm_xmm(dst, src, src2)) } +emit_vfmsubadd132ps_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vfmsubadd132ps_xmm_xmm_m128(dst, src, src2)) } +emit_vfmsubadd132ps_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vfmsubadd132ps_ymm_ymm_ymm(dst, src, src2)) } +emit_vfmsubadd132ps_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vfmsubadd132ps_ymm_ymm_m256(dst, src, src2)) } +inst_vfmsubadd213ps_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VFMSUBADD213PS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1585) } +inst_vfmsubadd213ps_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VFMSUBADD213PS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1585) } +inst_vfmsubadd213ps_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VFMSUBADD213PS, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1586) } +inst_vfmsubadd213ps_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VFMSUBADD213PS, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1586) } +emit_vfmsubadd213ps_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vfmsubadd213ps_xmm_xmm_xmm(dst, src, src2)) } +emit_vfmsubadd213ps_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vfmsubadd213ps_xmm_xmm_m128(dst, src, src2)) } +emit_vfmsubadd213ps_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vfmsubadd213ps_ymm_ymm_ymm(dst, src, src2)) } +emit_vfmsubadd213ps_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vfmsubadd213ps_ymm_ymm_m256(dst, src, src2)) } +inst_vfmsubadd231ps_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VFMSUBADD231PS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1587) } +inst_vfmsubadd231ps_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VFMSUBADD231PS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1587) } +inst_vfmsubadd231ps_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VFMSUBADD231PS, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1588) } +inst_vfmsubadd231ps_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VFMSUBADD231PS, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1588) } +emit_vfmsubadd231ps_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vfmsubadd231ps_xmm_xmm_xmm(dst, src, src2)) } +emit_vfmsubadd231ps_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vfmsubadd231ps_xmm_xmm_m128(dst, src, src2)) } +emit_vfmsubadd231ps_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vfmsubadd231ps_ymm_ymm_ymm(dst, src, src2)) } +emit_vfmsubadd231ps_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vfmsubadd231ps_ymm_ymm_m256(dst, src, src2)) } +inst_vfmsubadd132pd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VFMSUBADD132PD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1589) } +inst_vfmsubadd132pd_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VFMSUBADD132PD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1589) } +inst_vfmsubadd132pd_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VFMSUBADD132PD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1590) } +inst_vfmsubadd132pd_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VFMSUBADD132PD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1590) } +emit_vfmsubadd132pd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vfmsubadd132pd_xmm_xmm_xmm(dst, src, src2)) } +emit_vfmsubadd132pd_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vfmsubadd132pd_xmm_xmm_m128(dst, src, src2)) } +emit_vfmsubadd132pd_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vfmsubadd132pd_ymm_ymm_ymm(dst, src, src2)) } +emit_vfmsubadd132pd_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vfmsubadd132pd_ymm_ymm_m256(dst, src, src2)) } +inst_vfmsubadd213pd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VFMSUBADD213PD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1591) } +inst_vfmsubadd213pd_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VFMSUBADD213PD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1591) } +inst_vfmsubadd213pd_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VFMSUBADD213PD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1592) } +inst_vfmsubadd213pd_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VFMSUBADD213PD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1592) } +emit_vfmsubadd213pd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vfmsubadd213pd_xmm_xmm_xmm(dst, src, src2)) } +emit_vfmsubadd213pd_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vfmsubadd213pd_xmm_xmm_m128(dst, src, src2)) } +emit_vfmsubadd213pd_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vfmsubadd213pd_ymm_ymm_ymm(dst, src, src2)) } +emit_vfmsubadd213pd_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vfmsubadd213pd_ymm_ymm_m256(dst, src, src2)) } +inst_vfmsubadd231pd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VFMSUBADD231PD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1593) } +inst_vfmsubadd231pd_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VFMSUBADD231PD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1593) } +inst_vfmsubadd231pd_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VFMSUBADD231PD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1594) } +inst_vfmsubadd231pd_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VFMSUBADD231PD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1594) } +emit_vfmsubadd231pd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vfmsubadd231pd_xmm_xmm_xmm(dst, src, src2)) } +emit_vfmsubadd231pd_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vfmsubadd231pd_xmm_xmm_m128(dst, src, src2)) } +emit_vfmsubadd231pd_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vfmsubadd231pd_ymm_ymm_ymm(dst, src, src2)) } +emit_vfmsubadd231pd_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vfmsubadd231pd_ymm_ymm_m256(dst, src, src2)) } +inst_vcvtph2ps_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VCVTPH2PS, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 1595) } +inst_vcvtph2ps_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .VCVTPH2PS, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 8), {}, {}} }, 1595) } +inst_vcvtph2ps_ymm_xmm :: #force_inline proc "contextless" (dst: YMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VCVTPH2PS, operand_count = 2, ops = {op_ymm(dst), op_xmm(src), {}, {}} }, 1596) } +inst_vcvtph2ps_ymm_m128 :: #force_inline proc "contextless" (dst: YMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VCVTPH2PS, operand_count = 2, ops = {op_ymm(dst), op_mem(src.mem, 16), {}, {}} }, 1596) } +inst_vcvtph2ps_zmm_ymm :: #force_inline proc "contextless" (dst: ZMM, src: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VCVTPH2PS, operand_count = 2, ops = {op_zmm(dst), op_ymm(src), {}, {}} }, 1597) } +inst_vcvtph2ps_zmm_m256 :: #force_inline proc "contextless" (dst: ZMM, src: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VCVTPH2PS, operand_count = 2, ops = {op_zmm(dst), op_mem(src.mem, 32), {}, {}} }, 1597) } +emit_vcvtph2ps_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_vcvtph2ps_xmm_xmm(dst, src)) } +emit_vcvtph2ps_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem64) { append(instructions, inst_vcvtph2ps_xmm_m64(dst, src)) } +emit_vcvtph2ps_ymm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: XMM) { append(instructions, inst_vcvtph2ps_ymm_xmm(dst, src)) } +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), {}} } } +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)) } +emit_vcvtps2ph_m128_ymm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem128, src: YMM, imm: i8) { append(instructions, inst_vcvtps2ph_m128_ymm_imm8(dst, src, imm)) } +emit_vcvtps2ph_ymm_zmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: ZMM, imm: i8) { append(instructions, inst_vcvtps2ph_ymm_zmm_imm8(dst, src, imm)) } +emit_vcvtps2ph_m256_zmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem256, src: ZMM, imm: i8) { append(instructions, inst_vcvtps2ph_m256_zmm_imm8(dst, src, imm)) } +inst_vmovdqa32_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VMOVDQA32, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 1601) } +inst_vmovdqa32_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VMOVDQA32, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 1601) } +inst_vmovdqa32_m128_xmm :: #force_inline proc "contextless" (dst: Mem128, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VMOVDQA32, operand_count = 2, ops = {op_mem(dst.mem, 16), op_xmm(src), {}, {}} }, 1602) } +inst_vmovdqa32_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VMOVDQA32, operand_count = 2, ops = {op_ymm(dst), op_ymm(src), {}, {}} }, 1603) } +inst_vmovdqa32_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VMOVDQA32, operand_count = 2, ops = {op_ymm(dst), op_mem(src.mem, 32), {}, {}} }, 1603) } +inst_vmovdqa32_m256_ymm :: #force_inline proc "contextless" (dst: Mem256, src: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VMOVDQA32, operand_count = 2, ops = {op_mem(dst.mem, 32), op_ymm(src), {}, {}} }, 1604) } +inst_vmovdqa32_zmm_zmm :: #force_inline proc "contextless" (dst: ZMM, src: ZMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VMOVDQA32, operand_count = 2, ops = {op_zmm(dst), op_zmm(src), {}, {}} }, 1605) } +inst_vmovdqa32_zmm_m512 :: #force_inline proc "contextless" (dst: ZMM, src: Mem512) -> Instruction { return with_hint(Instruction{ mnemonic = .VMOVDQA32, operand_count = 2, ops = {op_zmm(dst), op_mem(src.mem, 64), {}, {}} }, 1605) } +inst_vmovdqa32_m512_zmm :: #force_inline proc "contextless" (dst: Mem512, src: ZMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VMOVDQA32, operand_count = 2, ops = {op_mem(dst.mem, 64), op_zmm(src), {}, {}} }, 1606) } +emit_vmovdqa32_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_vmovdqa32_xmm_xmm(dst, src)) } +emit_vmovdqa32_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_vmovdqa32_xmm_m128(dst, src)) } +emit_vmovdqa32_m128_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem128, src: XMM) { append(instructions, inst_vmovdqa32_m128_xmm(dst, src)) } +emit_vmovdqa32_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM) { append(instructions, inst_vmovdqa32_ymm_ymm(dst, src)) } +emit_vmovdqa32_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem256) { append(instructions, inst_vmovdqa32_ymm_m256(dst, src)) } +emit_vmovdqa32_m256_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem256, src: YMM) { append(instructions, inst_vmovdqa32_m256_ymm(dst, src)) } +emit_vmovdqa32_zmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM) { append(instructions, inst_vmovdqa32_zmm_zmm(dst, src)) } +emit_vmovdqa32_zmm_m512 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: Mem512) { append(instructions, inst_vmovdqa32_zmm_m512(dst, src)) } +emit_vmovdqa32_m512_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem512, src: ZMM) { append(instructions, inst_vmovdqa32_m512_zmm(dst, src)) } +inst_vmovdqa64_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VMOVDQA64, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 1607) } +inst_vmovdqa64_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VMOVDQA64, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 1607) } +inst_vmovdqa64_m128_xmm :: #force_inline proc "contextless" (dst: Mem128, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VMOVDQA64, operand_count = 2, ops = {op_mem(dst.mem, 16), op_xmm(src), {}, {}} }, 1608) } +inst_vmovdqa64_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VMOVDQA64, operand_count = 2, ops = {op_ymm(dst), op_ymm(src), {}, {}} }, 1609) } +inst_vmovdqa64_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VMOVDQA64, operand_count = 2, ops = {op_ymm(dst), op_mem(src.mem, 32), {}, {}} }, 1609) } +inst_vmovdqa64_m256_ymm :: #force_inline proc "contextless" (dst: Mem256, src: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VMOVDQA64, operand_count = 2, ops = {op_mem(dst.mem, 32), op_ymm(src), {}, {}} }, 1610) } +inst_vmovdqa64_zmm_zmm :: #force_inline proc "contextless" (dst: ZMM, src: ZMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VMOVDQA64, operand_count = 2, ops = {op_zmm(dst), op_zmm(src), {}, {}} }, 1611) } +inst_vmovdqa64_zmm_m512 :: #force_inline proc "contextless" (dst: ZMM, src: Mem512) -> Instruction { return with_hint(Instruction{ mnemonic = .VMOVDQA64, operand_count = 2, ops = {op_zmm(dst), op_mem(src.mem, 64), {}, {}} }, 1611) } +inst_vmovdqa64_m512_zmm :: #force_inline proc "contextless" (dst: Mem512, src: ZMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VMOVDQA64, operand_count = 2, ops = {op_mem(dst.mem, 64), op_zmm(src), {}, {}} }, 1612) } +emit_vmovdqa64_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_vmovdqa64_xmm_xmm(dst, src)) } +emit_vmovdqa64_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_vmovdqa64_xmm_m128(dst, src)) } +emit_vmovdqa64_m128_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem128, src: XMM) { append(instructions, inst_vmovdqa64_m128_xmm(dst, src)) } +emit_vmovdqa64_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM) { append(instructions, inst_vmovdqa64_ymm_ymm(dst, src)) } +emit_vmovdqa64_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem256) { append(instructions, inst_vmovdqa64_ymm_m256(dst, src)) } +emit_vmovdqa64_m256_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem256, src: YMM) { append(instructions, inst_vmovdqa64_m256_ymm(dst, src)) } +emit_vmovdqa64_zmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM) { append(instructions, inst_vmovdqa64_zmm_zmm(dst, src)) } +emit_vmovdqa64_zmm_m512 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: Mem512) { append(instructions, inst_vmovdqa64_zmm_m512(dst, src)) } +emit_vmovdqa64_m512_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem512, src: ZMM) { append(instructions, inst_vmovdqa64_m512_zmm(dst, src)) } +inst_vmovdqu8_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VMOVDQU8, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 1613) } +inst_vmovdqu8_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VMOVDQU8, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 1613) } +inst_vmovdqu8_m128_xmm :: #force_inline proc "contextless" (dst: Mem128, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VMOVDQU8, operand_count = 2, ops = {op_mem(dst.mem, 16), op_xmm(src), {}, {}} }, 1614) } +inst_vmovdqu8_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VMOVDQU8, operand_count = 2, ops = {op_ymm(dst), op_ymm(src), {}, {}} }, 1615) } +inst_vmovdqu8_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VMOVDQU8, operand_count = 2, ops = {op_ymm(dst), op_mem(src.mem, 32), {}, {}} }, 1615) } +inst_vmovdqu8_m256_ymm :: #force_inline proc "contextless" (dst: Mem256, src: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VMOVDQU8, operand_count = 2, ops = {op_mem(dst.mem, 32), op_ymm(src), {}, {}} }, 1616) } +inst_vmovdqu8_zmm_zmm :: #force_inline proc "contextless" (dst: ZMM, src: ZMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VMOVDQU8, operand_count = 2, ops = {op_zmm(dst), op_zmm(src), {}, {}} }, 1617) } +inst_vmovdqu8_zmm_m512 :: #force_inline proc "contextless" (dst: ZMM, src: Mem512) -> Instruction { return with_hint(Instruction{ mnemonic = .VMOVDQU8, operand_count = 2, ops = {op_zmm(dst), op_mem(src.mem, 64), {}, {}} }, 1617) } +inst_vmovdqu8_m512_zmm :: #force_inline proc "contextless" (dst: Mem512, src: ZMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VMOVDQU8, operand_count = 2, ops = {op_mem(dst.mem, 64), op_zmm(src), {}, {}} }, 1618) } +emit_vmovdqu8_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_vmovdqu8_xmm_xmm(dst, src)) } +emit_vmovdqu8_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_vmovdqu8_xmm_m128(dst, src)) } +emit_vmovdqu8_m128_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem128, src: XMM) { append(instructions, inst_vmovdqu8_m128_xmm(dst, src)) } +emit_vmovdqu8_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM) { append(instructions, inst_vmovdqu8_ymm_ymm(dst, src)) } +emit_vmovdqu8_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem256) { append(instructions, inst_vmovdqu8_ymm_m256(dst, src)) } +emit_vmovdqu8_m256_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem256, src: YMM) { append(instructions, inst_vmovdqu8_m256_ymm(dst, src)) } +emit_vmovdqu8_zmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM) { append(instructions, inst_vmovdqu8_zmm_zmm(dst, src)) } +emit_vmovdqu8_zmm_m512 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: Mem512) { append(instructions, inst_vmovdqu8_zmm_m512(dst, src)) } +emit_vmovdqu8_m512_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem512, src: ZMM) { append(instructions, inst_vmovdqu8_m512_zmm(dst, src)) } +inst_vmovdqu16_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VMOVDQU16, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 1619) } +inst_vmovdqu16_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VMOVDQU16, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 1619) } +inst_vmovdqu16_m128_xmm :: #force_inline proc "contextless" (dst: Mem128, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VMOVDQU16, operand_count = 2, ops = {op_mem(dst.mem, 16), op_xmm(src), {}, {}} }, 1620) } +inst_vmovdqu16_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VMOVDQU16, operand_count = 2, ops = {op_ymm(dst), op_ymm(src), {}, {}} }, 1621) } +inst_vmovdqu16_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VMOVDQU16, operand_count = 2, ops = {op_ymm(dst), op_mem(src.mem, 32), {}, {}} }, 1621) } +inst_vmovdqu16_m256_ymm :: #force_inline proc "contextless" (dst: Mem256, src: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VMOVDQU16, operand_count = 2, ops = {op_mem(dst.mem, 32), op_ymm(src), {}, {}} }, 1622) } +inst_vmovdqu16_zmm_zmm :: #force_inline proc "contextless" (dst: ZMM, src: ZMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VMOVDQU16, operand_count = 2, ops = {op_zmm(dst), op_zmm(src), {}, {}} }, 1623) } +inst_vmovdqu16_zmm_m512 :: #force_inline proc "contextless" (dst: ZMM, src: Mem512) -> Instruction { return with_hint(Instruction{ mnemonic = .VMOVDQU16, operand_count = 2, ops = {op_zmm(dst), op_mem(src.mem, 64), {}, {}} }, 1623) } +inst_vmovdqu16_m512_zmm :: #force_inline proc "contextless" (dst: Mem512, src: ZMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VMOVDQU16, operand_count = 2, ops = {op_mem(dst.mem, 64), op_zmm(src), {}, {}} }, 1624) } +emit_vmovdqu16_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_vmovdqu16_xmm_xmm(dst, src)) } +emit_vmovdqu16_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_vmovdqu16_xmm_m128(dst, src)) } +emit_vmovdqu16_m128_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem128, src: XMM) { append(instructions, inst_vmovdqu16_m128_xmm(dst, src)) } +emit_vmovdqu16_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM) { append(instructions, inst_vmovdqu16_ymm_ymm(dst, src)) } +emit_vmovdqu16_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem256) { append(instructions, inst_vmovdqu16_ymm_m256(dst, src)) } +emit_vmovdqu16_m256_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem256, src: YMM) { append(instructions, inst_vmovdqu16_m256_ymm(dst, src)) } +emit_vmovdqu16_zmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM) { append(instructions, inst_vmovdqu16_zmm_zmm(dst, src)) } +emit_vmovdqu16_zmm_m512 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: Mem512) { append(instructions, inst_vmovdqu16_zmm_m512(dst, src)) } +emit_vmovdqu16_m512_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem512, src: ZMM) { append(instructions, inst_vmovdqu16_m512_zmm(dst, src)) } +inst_vmovdqu32_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VMOVDQU32, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 1625) } +inst_vmovdqu32_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VMOVDQU32, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 1625) } +inst_vmovdqu32_m128_xmm :: #force_inline proc "contextless" (dst: Mem128, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VMOVDQU32, operand_count = 2, ops = {op_mem(dst.mem, 16), op_xmm(src), {}, {}} }, 1626) } +inst_vmovdqu32_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VMOVDQU32, operand_count = 2, ops = {op_ymm(dst), op_ymm(src), {}, {}} }, 1627) } +inst_vmovdqu32_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VMOVDQU32, operand_count = 2, ops = {op_ymm(dst), op_mem(src.mem, 32), {}, {}} }, 1627) } +inst_vmovdqu32_m256_ymm :: #force_inline proc "contextless" (dst: Mem256, src: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VMOVDQU32, operand_count = 2, ops = {op_mem(dst.mem, 32), op_ymm(src), {}, {}} }, 1628) } +inst_vmovdqu32_zmm_zmm :: #force_inline proc "contextless" (dst: ZMM, src: ZMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VMOVDQU32, operand_count = 2, ops = {op_zmm(dst), op_zmm(src), {}, {}} }, 1629) } +inst_vmovdqu32_zmm_m512 :: #force_inline proc "contextless" (dst: ZMM, src: Mem512) -> Instruction { return with_hint(Instruction{ mnemonic = .VMOVDQU32, operand_count = 2, ops = {op_zmm(dst), op_mem(src.mem, 64), {}, {}} }, 1629) } +inst_vmovdqu32_m512_zmm :: #force_inline proc "contextless" (dst: Mem512, src: ZMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VMOVDQU32, operand_count = 2, ops = {op_mem(dst.mem, 64), op_zmm(src), {}, {}} }, 1630) } +emit_vmovdqu32_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_vmovdqu32_xmm_xmm(dst, src)) } +emit_vmovdqu32_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_vmovdqu32_xmm_m128(dst, src)) } +emit_vmovdqu32_m128_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem128, src: XMM) { append(instructions, inst_vmovdqu32_m128_xmm(dst, src)) } +emit_vmovdqu32_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM) { append(instructions, inst_vmovdqu32_ymm_ymm(dst, src)) } +emit_vmovdqu32_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem256) { append(instructions, inst_vmovdqu32_ymm_m256(dst, src)) } +emit_vmovdqu32_m256_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem256, src: YMM) { append(instructions, inst_vmovdqu32_m256_ymm(dst, src)) } +emit_vmovdqu32_zmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM) { append(instructions, inst_vmovdqu32_zmm_zmm(dst, src)) } +emit_vmovdqu32_zmm_m512 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: Mem512) { append(instructions, inst_vmovdqu32_zmm_m512(dst, src)) } +emit_vmovdqu32_m512_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem512, src: ZMM) { append(instructions, inst_vmovdqu32_m512_zmm(dst, src)) } +inst_vmovdqu64_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VMOVDQU64, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 1631) } +inst_vmovdqu64_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VMOVDQU64, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 1631) } +inst_vmovdqu64_m128_xmm :: #force_inline proc "contextless" (dst: Mem128, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VMOVDQU64, operand_count = 2, ops = {op_mem(dst.mem, 16), op_xmm(src), {}, {}} }, 1632) } +inst_vmovdqu64_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VMOVDQU64, operand_count = 2, ops = {op_ymm(dst), op_ymm(src), {}, {}} }, 1633) } +inst_vmovdqu64_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VMOVDQU64, operand_count = 2, ops = {op_ymm(dst), op_mem(src.mem, 32), {}, {}} }, 1633) } +inst_vmovdqu64_m256_ymm :: #force_inline proc "contextless" (dst: Mem256, src: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VMOVDQU64, operand_count = 2, ops = {op_mem(dst.mem, 32), op_ymm(src), {}, {}} }, 1634) } +inst_vmovdqu64_zmm_zmm :: #force_inline proc "contextless" (dst: ZMM, src: ZMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VMOVDQU64, operand_count = 2, ops = {op_zmm(dst), op_zmm(src), {}, {}} }, 1635) } +inst_vmovdqu64_zmm_m512 :: #force_inline proc "contextless" (dst: ZMM, src: Mem512) -> Instruction { return with_hint(Instruction{ mnemonic = .VMOVDQU64, operand_count = 2, ops = {op_zmm(dst), op_mem(src.mem, 64), {}, {}} }, 1635) } +inst_vmovdqu64_m512_zmm :: #force_inline proc "contextless" (dst: Mem512, src: ZMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VMOVDQU64, operand_count = 2, ops = {op_mem(dst.mem, 64), op_zmm(src), {}, {}} }, 1636) } +emit_vmovdqu64_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_vmovdqu64_xmm_xmm(dst, src)) } +emit_vmovdqu64_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_vmovdqu64_xmm_m128(dst, src)) } +emit_vmovdqu64_m128_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem128, src: XMM) { append(instructions, inst_vmovdqu64_m128_xmm(dst, src)) } +emit_vmovdqu64_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM) { append(instructions, inst_vmovdqu64_ymm_ymm(dst, src)) } +emit_vmovdqu64_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem256) { append(instructions, inst_vmovdqu64_ymm_m256(dst, src)) } +emit_vmovdqu64_m256_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem256, src: YMM) { append(instructions, inst_vmovdqu64_m256_ymm(dst, src)) } +emit_vmovdqu64_zmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM) { append(instructions, inst_vmovdqu64_zmm_zmm(dst, src)) } +emit_vmovdqu64_zmm_m512 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: Mem512) { append(instructions, inst_vmovdqu64_zmm_m512(dst, src)) } +emit_vmovdqu64_m512_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem512, src: ZMM) { append(instructions, inst_vmovdqu64_m512_zmm(dst, src)) } +inst_vpblendmb_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPBLENDMB, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1637) } +inst_vpblendmb_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPBLENDMB, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1637) } +inst_vpblendmb_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPBLENDMB, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1638) } +inst_vpblendmb_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VPBLENDMB, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1638) } +inst_vpblendmb_zmm_zmm_zmm :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: ZMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPBLENDMB, operand_count = 3, ops = {op_zmm(dst), op_zmm(src), op_zmm(src2), {}} }, 1639) } +inst_vpblendmb_zmm_zmm_m512 :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: Mem512) -> Instruction { return with_hint(Instruction{ mnemonic = .VPBLENDMB, operand_count = 3, ops = {op_zmm(dst), op_zmm(src), op_mem(src2.mem, 64), {}} }, 1639) } +emit_vpblendmb_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vpblendmb_xmm_xmm_xmm(dst, src, src2)) } +emit_vpblendmb_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vpblendmb_xmm_xmm_m128(dst, src, src2)) } +emit_vpblendmb_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vpblendmb_ymm_ymm_ymm(dst, src, src2)) } +emit_vpblendmb_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vpblendmb_ymm_ymm_m256(dst, src, src2)) } +emit_vpblendmb_zmm_zmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: ZMM) { append(instructions, inst_vpblendmb_zmm_zmm_zmm(dst, src, src2)) } +emit_vpblendmb_zmm_zmm_m512 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: Mem512) { append(instructions, inst_vpblendmb_zmm_zmm_m512(dst, src, src2)) } +inst_vpblendmw_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPBLENDMW, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1640) } +inst_vpblendmw_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPBLENDMW, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1640) } +inst_vpblendmw_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPBLENDMW, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1641) } +inst_vpblendmw_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VPBLENDMW, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1641) } +inst_vpblendmw_zmm_zmm_zmm :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: ZMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPBLENDMW, operand_count = 3, ops = {op_zmm(dst), op_zmm(src), op_zmm(src2), {}} }, 1642) } +inst_vpblendmw_zmm_zmm_m512 :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: Mem512) -> Instruction { return with_hint(Instruction{ mnemonic = .VPBLENDMW, operand_count = 3, ops = {op_zmm(dst), op_zmm(src), op_mem(src2.mem, 64), {}} }, 1642) } +emit_vpblendmw_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vpblendmw_xmm_xmm_xmm(dst, src, src2)) } +emit_vpblendmw_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vpblendmw_xmm_xmm_m128(dst, src, src2)) } +emit_vpblendmw_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vpblendmw_ymm_ymm_ymm(dst, src, src2)) } +emit_vpblendmw_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vpblendmw_ymm_ymm_m256(dst, src, src2)) } +emit_vpblendmw_zmm_zmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: ZMM) { append(instructions, inst_vpblendmw_zmm_zmm_zmm(dst, src, src2)) } +emit_vpblendmw_zmm_zmm_m512 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: Mem512) { append(instructions, inst_vpblendmw_zmm_zmm_m512(dst, src, src2)) } +inst_vpblendmd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPBLENDMD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1643) } +inst_vpblendmd_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPBLENDMD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1643) } +inst_vpblendmd_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPBLENDMD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1644) } +inst_vpblendmd_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VPBLENDMD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1644) } +inst_vpblendmd_zmm_zmm_zmm :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: ZMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPBLENDMD, operand_count = 3, ops = {op_zmm(dst), op_zmm(src), op_zmm(src2), {}} }, 1645) } +inst_vpblendmd_zmm_zmm_m512 :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: Mem512) -> Instruction { return with_hint(Instruction{ mnemonic = .VPBLENDMD, operand_count = 3, ops = {op_zmm(dst), op_zmm(src), op_mem(src2.mem, 64), {}} }, 1645) } +emit_vpblendmd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vpblendmd_xmm_xmm_xmm(dst, src, src2)) } +emit_vpblendmd_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vpblendmd_xmm_xmm_m128(dst, src, src2)) } +emit_vpblendmd_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vpblendmd_ymm_ymm_ymm(dst, src, src2)) } +emit_vpblendmd_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vpblendmd_ymm_ymm_m256(dst, src, src2)) } +emit_vpblendmd_zmm_zmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: ZMM) { append(instructions, inst_vpblendmd_zmm_zmm_zmm(dst, src, src2)) } +emit_vpblendmd_zmm_zmm_m512 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: Mem512) { append(instructions, inst_vpblendmd_zmm_zmm_m512(dst, src, src2)) } +inst_vpblendmq_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPBLENDMQ, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1646) } +inst_vpblendmq_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPBLENDMQ, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1646) } +inst_vpblendmq_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPBLENDMQ, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1647) } +inst_vpblendmq_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VPBLENDMQ, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1647) } +inst_vpblendmq_zmm_zmm_zmm :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: ZMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPBLENDMQ, operand_count = 3, ops = {op_zmm(dst), op_zmm(src), op_zmm(src2), {}} }, 1648) } +inst_vpblendmq_zmm_zmm_m512 :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: Mem512) -> Instruction { return with_hint(Instruction{ mnemonic = .VPBLENDMQ, operand_count = 3, ops = {op_zmm(dst), op_zmm(src), op_mem(src2.mem, 64), {}} }, 1648) } +emit_vpblendmq_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vpblendmq_xmm_xmm_xmm(dst, src, src2)) } +emit_vpblendmq_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vpblendmq_xmm_xmm_m128(dst, src, src2)) } +emit_vpblendmq_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vpblendmq_ymm_ymm_ymm(dst, src, src2)) } +emit_vpblendmq_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vpblendmq_ymm_ymm_m256(dst, src, src2)) } +emit_vpblendmq_zmm_zmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: ZMM) { append(instructions, inst_vpblendmq_zmm_zmm_zmm(dst, src, src2)) } +emit_vpblendmq_zmm_zmm_m512 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: Mem512) { append(instructions, inst_vpblendmq_zmm_zmm_m512(dst, src, src2)) } +inst_vblendmps_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VBLENDMPS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1649) } +inst_vblendmps_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VBLENDMPS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1649) } +inst_vblendmps_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VBLENDMPS, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1650) } +inst_vblendmps_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VBLENDMPS, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1650) } +inst_vblendmps_zmm_zmm_zmm :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: ZMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VBLENDMPS, operand_count = 3, ops = {op_zmm(dst), op_zmm(src), op_zmm(src2), {}} }, 1651) } +inst_vblendmps_zmm_zmm_m512 :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: Mem512) -> Instruction { return with_hint(Instruction{ mnemonic = .VBLENDMPS, operand_count = 3, ops = {op_zmm(dst), op_zmm(src), op_mem(src2.mem, 64), {}} }, 1651) } +emit_vblendmps_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vblendmps_xmm_xmm_xmm(dst, src, src2)) } +emit_vblendmps_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vblendmps_xmm_xmm_m128(dst, src, src2)) } +emit_vblendmps_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vblendmps_ymm_ymm_ymm(dst, src, src2)) } +emit_vblendmps_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vblendmps_ymm_ymm_m256(dst, src, src2)) } +emit_vblendmps_zmm_zmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: ZMM) { append(instructions, inst_vblendmps_zmm_zmm_zmm(dst, src, src2)) } +emit_vblendmps_zmm_zmm_m512 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: Mem512) { append(instructions, inst_vblendmps_zmm_zmm_m512(dst, src, src2)) } +inst_vblendmpd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VBLENDMPD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1652) } +inst_vblendmpd_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VBLENDMPD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1652) } +inst_vblendmpd_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VBLENDMPD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1653) } +inst_vblendmpd_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VBLENDMPD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1653) } +inst_vblendmpd_zmm_zmm_zmm :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: ZMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VBLENDMPD, operand_count = 3, ops = {op_zmm(dst), op_zmm(src), op_zmm(src2), {}} }, 1654) } +inst_vblendmpd_zmm_zmm_m512 :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: Mem512) -> Instruction { return with_hint(Instruction{ mnemonic = .VBLENDMPD, operand_count = 3, ops = {op_zmm(dst), op_zmm(src), op_mem(src2.mem, 64), {}} }, 1654) } +emit_vblendmpd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vblendmpd_xmm_xmm_xmm(dst, src, src2)) } +emit_vblendmpd_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vblendmpd_xmm_xmm_m128(dst, src, src2)) } +emit_vblendmpd_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vblendmpd_ymm_ymm_ymm(dst, src, src2)) } +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)} } } @@ -5597,866 +5597,866 @@ emit_vpcmpuq_k_ymm_ymm_imm8 :: #force_inline proc(instructions: ^[dynami emit_vpcmpuq_k_ymm_m256_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: YMM, src2: Mem256, imm: i8) { append(instructions, inst_vpcmpuq_k_ymm_m256_imm8(dst, src, src2, imm)) } emit_vpcmpuq_k_zmm_zmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: ZMM, src2: ZMM, imm: i8) { append(instructions, inst_vpcmpuq_k_zmm_zmm_imm8(dst, src, src2, imm)) } emit_vpcmpuq_k_zmm_m512_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: ZMM, src2: Mem512, imm: i8) { append(instructions, inst_vpcmpuq_k_zmm_m512_imm8(dst, src, src2, imm)) } -inst_vptestmb_k_xmm_xmm :: #force_inline proc "contextless" (dst: KREG, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VPTESTMB, Register(dst), Register(src), Register(src2)) } -inst_vptestmb_k_xmm_m128 :: #force_inline proc "contextless" (dst: KREG, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VPTESTMB, Register(dst), Register(src), src2.mem, 16) } -inst_vptestmb_k_ymm_ymm :: #force_inline proc "contextless" (dst: KREG, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VPTESTMB, Register(dst), Register(src), Register(src2)) } -inst_vptestmb_k_ymm_m256 :: #force_inline proc "contextless" (dst: KREG, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VPTESTMB, Register(dst), Register(src), src2.mem, 32) } -inst_vptestmb_k_zmm_zmm :: #force_inline proc "contextless" (dst: KREG, src: ZMM, src2: ZMM) -> Instruction { return inst_r_r_r(.VPTESTMB, Register(dst), Register(src), Register(src2)) } -inst_vptestmb_k_zmm_m512 :: #force_inline proc "contextless" (dst: KREG, src: ZMM, src2: Mem512) -> Instruction { return inst_r_r_m(.VPTESTMB, Register(dst), Register(src), src2.mem, 64) } -emit_vptestmb_k_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: XMM, src2: XMM) { emit_rrr(instructions, .VPTESTMB, Register(dst), Register(src), Register(src2)) } -emit_vptestmb_k_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: XMM, src2: Mem128) { emit_rrm(instructions, .VPTESTMB, Register(dst), Register(src), src2.mem, 16) } -emit_vptestmb_k_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: YMM, src2: YMM) { emit_rrr(instructions, .VPTESTMB, Register(dst), Register(src), Register(src2)) } -emit_vptestmb_k_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: YMM, src2: Mem256) { emit_rrm(instructions, .VPTESTMB, Register(dst), Register(src), src2.mem, 32) } -emit_vptestmb_k_zmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: ZMM, src2: ZMM) { emit_rrr(instructions, .VPTESTMB, Register(dst), Register(src), Register(src2)) } -emit_vptestmb_k_zmm_m512 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: ZMM, src2: Mem512) { emit_rrm(instructions, .VPTESTMB, Register(dst), Register(src), src2.mem, 64) } -inst_vptestmw_k_xmm_xmm :: #force_inline proc "contextless" (dst: KREG, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VPTESTMW, Register(dst), Register(src), Register(src2)) } -inst_vptestmw_k_xmm_m128 :: #force_inline proc "contextless" (dst: KREG, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VPTESTMW, Register(dst), Register(src), src2.mem, 16) } -inst_vptestmw_k_ymm_ymm :: #force_inline proc "contextless" (dst: KREG, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VPTESTMW, Register(dst), Register(src), Register(src2)) } -inst_vptestmw_k_ymm_m256 :: #force_inline proc "contextless" (dst: KREG, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VPTESTMW, Register(dst), Register(src), src2.mem, 32) } -inst_vptestmw_k_zmm_zmm :: #force_inline proc "contextless" (dst: KREG, src: ZMM, src2: ZMM) -> Instruction { return inst_r_r_r(.VPTESTMW, Register(dst), Register(src), Register(src2)) } -inst_vptestmw_k_zmm_m512 :: #force_inline proc "contextless" (dst: KREG, src: ZMM, src2: Mem512) -> Instruction { return inst_r_r_m(.VPTESTMW, Register(dst), Register(src), src2.mem, 64) } -emit_vptestmw_k_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: XMM, src2: XMM) { emit_rrr(instructions, .VPTESTMW, Register(dst), Register(src), Register(src2)) } -emit_vptestmw_k_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: XMM, src2: Mem128) { emit_rrm(instructions, .VPTESTMW, Register(dst), Register(src), src2.mem, 16) } -emit_vptestmw_k_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: YMM, src2: YMM) { emit_rrr(instructions, .VPTESTMW, Register(dst), Register(src), Register(src2)) } -emit_vptestmw_k_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: YMM, src2: Mem256) { emit_rrm(instructions, .VPTESTMW, Register(dst), Register(src), src2.mem, 32) } -emit_vptestmw_k_zmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: ZMM, src2: ZMM) { emit_rrr(instructions, .VPTESTMW, Register(dst), Register(src), Register(src2)) } -emit_vptestmw_k_zmm_m512 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: ZMM, src2: Mem512) { emit_rrm(instructions, .VPTESTMW, Register(dst), Register(src), src2.mem, 64) } -inst_vptestmd_k_xmm_xmm :: #force_inline proc "contextless" (dst: KREG, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VPTESTMD, Register(dst), Register(src), Register(src2)) } -inst_vptestmd_k_xmm_m128 :: #force_inline proc "contextless" (dst: KREG, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VPTESTMD, Register(dst), Register(src), src2.mem, 16) } -inst_vptestmd_k_ymm_ymm :: #force_inline proc "contextless" (dst: KREG, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VPTESTMD, Register(dst), Register(src), Register(src2)) } -inst_vptestmd_k_ymm_m256 :: #force_inline proc "contextless" (dst: KREG, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VPTESTMD, Register(dst), Register(src), src2.mem, 32) } -inst_vptestmd_k_zmm_zmm :: #force_inline proc "contextless" (dst: KREG, src: ZMM, src2: ZMM) -> Instruction { return inst_r_r_r(.VPTESTMD, Register(dst), Register(src), Register(src2)) } -inst_vptestmd_k_zmm_m512 :: #force_inline proc "contextless" (dst: KREG, src: ZMM, src2: Mem512) -> Instruction { return inst_r_r_m(.VPTESTMD, Register(dst), Register(src), src2.mem, 64) } -emit_vptestmd_k_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: XMM, src2: XMM) { emit_rrr(instructions, .VPTESTMD, Register(dst), Register(src), Register(src2)) } -emit_vptestmd_k_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: XMM, src2: Mem128) { emit_rrm(instructions, .VPTESTMD, Register(dst), Register(src), src2.mem, 16) } -emit_vptestmd_k_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: YMM, src2: YMM) { emit_rrr(instructions, .VPTESTMD, Register(dst), Register(src), Register(src2)) } -emit_vptestmd_k_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: YMM, src2: Mem256) { emit_rrm(instructions, .VPTESTMD, Register(dst), Register(src), src2.mem, 32) } -emit_vptestmd_k_zmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: ZMM, src2: ZMM) { emit_rrr(instructions, .VPTESTMD, Register(dst), Register(src), Register(src2)) } -emit_vptestmd_k_zmm_m512 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: ZMM, src2: Mem512) { emit_rrm(instructions, .VPTESTMD, Register(dst), Register(src), src2.mem, 64) } -inst_vptestmq_k_xmm_xmm :: #force_inline proc "contextless" (dst: KREG, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VPTESTMQ, Register(dst), Register(src), Register(src2)) } -inst_vptestmq_k_xmm_m128 :: #force_inline proc "contextless" (dst: KREG, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VPTESTMQ, Register(dst), Register(src), src2.mem, 16) } -inst_vptestmq_k_ymm_ymm :: #force_inline proc "contextless" (dst: KREG, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VPTESTMQ, Register(dst), Register(src), Register(src2)) } -inst_vptestmq_k_ymm_m256 :: #force_inline proc "contextless" (dst: KREG, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VPTESTMQ, Register(dst), Register(src), src2.mem, 32) } -inst_vptestmq_k_zmm_zmm :: #force_inline proc "contextless" (dst: KREG, src: ZMM, src2: ZMM) -> Instruction { return inst_r_r_r(.VPTESTMQ, Register(dst), Register(src), Register(src2)) } -inst_vptestmq_k_zmm_m512 :: #force_inline proc "contextless" (dst: KREG, src: ZMM, src2: Mem512) -> Instruction { return inst_r_r_m(.VPTESTMQ, Register(dst), Register(src), src2.mem, 64) } -emit_vptestmq_k_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: XMM, src2: XMM) { emit_rrr(instructions, .VPTESTMQ, Register(dst), Register(src), Register(src2)) } -emit_vptestmq_k_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: XMM, src2: Mem128) { emit_rrm(instructions, .VPTESTMQ, Register(dst), Register(src), src2.mem, 16) } -emit_vptestmq_k_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: YMM, src2: YMM) { emit_rrr(instructions, .VPTESTMQ, Register(dst), Register(src), Register(src2)) } -emit_vptestmq_k_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: YMM, src2: Mem256) { emit_rrm(instructions, .VPTESTMQ, Register(dst), Register(src), src2.mem, 32) } -emit_vptestmq_k_zmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: ZMM, src2: ZMM) { emit_rrr(instructions, .VPTESTMQ, Register(dst), Register(src), Register(src2)) } -emit_vptestmq_k_zmm_m512 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: ZMM, src2: Mem512) { emit_rrm(instructions, .VPTESTMQ, Register(dst), Register(src), src2.mem, 64) } -inst_vptestnmb_k_xmm_xmm :: #force_inline proc "contextless" (dst: KREG, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VPTESTNMB, Register(dst), Register(src), Register(src2)) } -inst_vptestnmb_k_xmm_m128 :: #force_inline proc "contextless" (dst: KREG, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VPTESTNMB, Register(dst), Register(src), src2.mem, 16) } -inst_vptestnmb_k_ymm_ymm :: #force_inline proc "contextless" (dst: KREG, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VPTESTNMB, Register(dst), Register(src), Register(src2)) } -inst_vptestnmb_k_ymm_m256 :: #force_inline proc "contextless" (dst: KREG, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VPTESTNMB, Register(dst), Register(src), src2.mem, 32) } -inst_vptestnmb_k_zmm_zmm :: #force_inline proc "contextless" (dst: KREG, src: ZMM, src2: ZMM) -> Instruction { return inst_r_r_r(.VPTESTNMB, Register(dst), Register(src), Register(src2)) } -inst_vptestnmb_k_zmm_m512 :: #force_inline proc "contextless" (dst: KREG, src: ZMM, src2: Mem512) -> Instruction { return inst_r_r_m(.VPTESTNMB, Register(dst), Register(src), src2.mem, 64) } -emit_vptestnmb_k_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: XMM, src2: XMM) { emit_rrr(instructions, .VPTESTNMB, Register(dst), Register(src), Register(src2)) } -emit_vptestnmb_k_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: XMM, src2: Mem128) { emit_rrm(instructions, .VPTESTNMB, Register(dst), Register(src), src2.mem, 16) } -emit_vptestnmb_k_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: YMM, src2: YMM) { emit_rrr(instructions, .VPTESTNMB, Register(dst), Register(src), Register(src2)) } -emit_vptestnmb_k_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: YMM, src2: Mem256) { emit_rrm(instructions, .VPTESTNMB, Register(dst), Register(src), src2.mem, 32) } -emit_vptestnmb_k_zmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: ZMM, src2: ZMM) { emit_rrr(instructions, .VPTESTNMB, Register(dst), Register(src), Register(src2)) } -emit_vptestnmb_k_zmm_m512 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: ZMM, src2: Mem512) { emit_rrm(instructions, .VPTESTNMB, Register(dst), Register(src), src2.mem, 64) } -inst_vptestnmw_k_xmm_xmm :: #force_inline proc "contextless" (dst: KREG, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VPTESTNMW, Register(dst), Register(src), Register(src2)) } -inst_vptestnmw_k_xmm_m128 :: #force_inline proc "contextless" (dst: KREG, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VPTESTNMW, Register(dst), Register(src), src2.mem, 16) } -inst_vptestnmw_k_ymm_ymm :: #force_inline proc "contextless" (dst: KREG, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VPTESTNMW, Register(dst), Register(src), Register(src2)) } -inst_vptestnmw_k_ymm_m256 :: #force_inline proc "contextless" (dst: KREG, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VPTESTNMW, Register(dst), Register(src), src2.mem, 32) } -inst_vptestnmw_k_zmm_zmm :: #force_inline proc "contextless" (dst: KREG, src: ZMM, src2: ZMM) -> Instruction { return inst_r_r_r(.VPTESTNMW, Register(dst), Register(src), Register(src2)) } -inst_vptestnmw_k_zmm_m512 :: #force_inline proc "contextless" (dst: KREG, src: ZMM, src2: Mem512) -> Instruction { return inst_r_r_m(.VPTESTNMW, Register(dst), Register(src), src2.mem, 64) } -emit_vptestnmw_k_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: XMM, src2: XMM) { emit_rrr(instructions, .VPTESTNMW, Register(dst), Register(src), Register(src2)) } -emit_vptestnmw_k_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: XMM, src2: Mem128) { emit_rrm(instructions, .VPTESTNMW, Register(dst), Register(src), src2.mem, 16) } -emit_vptestnmw_k_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: YMM, src2: YMM) { emit_rrr(instructions, .VPTESTNMW, Register(dst), Register(src), Register(src2)) } -emit_vptestnmw_k_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: YMM, src2: Mem256) { emit_rrm(instructions, .VPTESTNMW, Register(dst), Register(src), src2.mem, 32) } -emit_vptestnmw_k_zmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: ZMM, src2: ZMM) { emit_rrr(instructions, .VPTESTNMW, Register(dst), Register(src), Register(src2)) } -emit_vptestnmw_k_zmm_m512 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: ZMM, src2: Mem512) { emit_rrm(instructions, .VPTESTNMW, Register(dst), Register(src), src2.mem, 64) } -inst_vptestnmd_k_xmm_xmm :: #force_inline proc "contextless" (dst: KREG, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VPTESTNMD, Register(dst), Register(src), Register(src2)) } -inst_vptestnmd_k_xmm_m128 :: #force_inline proc "contextless" (dst: KREG, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VPTESTNMD, Register(dst), Register(src), src2.mem, 16) } -inst_vptestnmd_k_ymm_ymm :: #force_inline proc "contextless" (dst: KREG, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VPTESTNMD, Register(dst), Register(src), Register(src2)) } -inst_vptestnmd_k_ymm_m256 :: #force_inline proc "contextless" (dst: KREG, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VPTESTNMD, Register(dst), Register(src), src2.mem, 32) } -inst_vptestnmd_k_zmm_zmm :: #force_inline proc "contextless" (dst: KREG, src: ZMM, src2: ZMM) -> Instruction { return inst_r_r_r(.VPTESTNMD, Register(dst), Register(src), Register(src2)) } -inst_vptestnmd_k_zmm_m512 :: #force_inline proc "contextless" (dst: KREG, src: ZMM, src2: Mem512) -> Instruction { return inst_r_r_m(.VPTESTNMD, Register(dst), Register(src), src2.mem, 64) } -emit_vptestnmd_k_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: XMM, src2: XMM) { emit_rrr(instructions, .VPTESTNMD, Register(dst), Register(src), Register(src2)) } -emit_vptestnmd_k_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: XMM, src2: Mem128) { emit_rrm(instructions, .VPTESTNMD, Register(dst), Register(src), src2.mem, 16) } -emit_vptestnmd_k_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: YMM, src2: YMM) { emit_rrr(instructions, .VPTESTNMD, Register(dst), Register(src), Register(src2)) } -emit_vptestnmd_k_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: YMM, src2: Mem256) { emit_rrm(instructions, .VPTESTNMD, Register(dst), Register(src), src2.mem, 32) } -emit_vptestnmd_k_zmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: ZMM, src2: ZMM) { emit_rrr(instructions, .VPTESTNMD, Register(dst), Register(src), Register(src2)) } -emit_vptestnmd_k_zmm_m512 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: ZMM, src2: Mem512) { emit_rrm(instructions, .VPTESTNMD, Register(dst), Register(src), src2.mem, 64) } -inst_vptestnmq_k_xmm_xmm :: #force_inline proc "contextless" (dst: KREG, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VPTESTNMQ, Register(dst), Register(src), Register(src2)) } -inst_vptestnmq_k_xmm_m128 :: #force_inline proc "contextless" (dst: KREG, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VPTESTNMQ, Register(dst), Register(src), src2.mem, 16) } -inst_vptestnmq_k_ymm_ymm :: #force_inline proc "contextless" (dst: KREG, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VPTESTNMQ, Register(dst), Register(src), Register(src2)) } -inst_vptestnmq_k_ymm_m256 :: #force_inline proc "contextless" (dst: KREG, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VPTESTNMQ, Register(dst), Register(src), src2.mem, 32) } -inst_vptestnmq_k_zmm_zmm :: #force_inline proc "contextless" (dst: KREG, src: ZMM, src2: ZMM) -> Instruction { return inst_r_r_r(.VPTESTNMQ, Register(dst), Register(src), Register(src2)) } -inst_vptestnmq_k_zmm_m512 :: #force_inline proc "contextless" (dst: KREG, src: ZMM, src2: Mem512) -> Instruction { return inst_r_r_m(.VPTESTNMQ, Register(dst), Register(src), src2.mem, 64) } -emit_vptestnmq_k_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: XMM, src2: XMM) { emit_rrr(instructions, .VPTESTNMQ, Register(dst), Register(src), Register(src2)) } -emit_vptestnmq_k_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: XMM, src2: Mem128) { emit_rrm(instructions, .VPTESTNMQ, Register(dst), Register(src), src2.mem, 16) } -emit_vptestnmq_k_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: YMM, src2: YMM) { emit_rrr(instructions, .VPTESTNMQ, Register(dst), Register(src), Register(src2)) } -emit_vptestnmq_k_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: YMM, src2: Mem256) { emit_rrm(instructions, .VPTESTNMQ, Register(dst), Register(src), src2.mem, 32) } -emit_vptestnmq_k_zmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: ZMM, src2: ZMM) { emit_rrr(instructions, .VPTESTNMQ, Register(dst), Register(src), Register(src2)) } -emit_vptestnmq_k_zmm_m512 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: ZMM, src2: Mem512) { emit_rrm(instructions, .VPTESTNMQ, Register(dst), Register(src), src2.mem, 64) } -inst_vpcompressd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.VPCOMPRESSD, Register(dst), Register(src)) } -inst_vpcompressd_m128_xmm :: #force_inline proc "contextless" (dst: Mem128, src: XMM) -> Instruction { return inst_m_r(.VPCOMPRESSD, dst.mem, 16, Register(src)) } -inst_vpcompressd_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM) -> Instruction { return inst_r_r(.VPCOMPRESSD, Register(dst), Register(src)) } -inst_vpcompressd_m256_ymm :: #force_inline proc "contextless" (dst: Mem256, src: YMM) -> Instruction { return inst_m_r(.VPCOMPRESSD, dst.mem, 32, Register(src)) } -inst_vpcompressd_zmm_zmm :: #force_inline proc "contextless" (dst: ZMM, src: ZMM) -> Instruction { return inst_r_r(.VPCOMPRESSD, Register(dst), Register(src)) } -inst_vpcompressd_m512_zmm :: #force_inline proc "contextless" (dst: Mem512, src: ZMM) -> Instruction { return inst_m_r(.VPCOMPRESSD, dst.mem, 64, Register(src)) } -emit_vpcompressd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .VPCOMPRESSD, Register(dst), Register(src)) } -emit_vpcompressd_m128_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem128, src: XMM) { emit_mr(instructions, .VPCOMPRESSD, dst.mem, 16, Register(src)) } -emit_vpcompressd_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM) { emit_rr(instructions, .VPCOMPRESSD, Register(dst), Register(src)) } -emit_vpcompressd_m256_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem256, src: YMM) { emit_mr(instructions, .VPCOMPRESSD, dst.mem, 32, Register(src)) } -emit_vpcompressd_zmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM) { emit_rr(instructions, .VPCOMPRESSD, Register(dst), Register(src)) } -emit_vpcompressd_m512_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem512, src: ZMM) { emit_mr(instructions, .VPCOMPRESSD, dst.mem, 64, Register(src)) } -inst_vpcompressq_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.VPCOMPRESSQ, Register(dst), Register(src)) } -inst_vpcompressq_m128_xmm :: #force_inline proc "contextless" (dst: Mem128, src: XMM) -> Instruction { return inst_m_r(.VPCOMPRESSQ, dst.mem, 16, Register(src)) } -inst_vpcompressq_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM) -> Instruction { return inst_r_r(.VPCOMPRESSQ, Register(dst), Register(src)) } -inst_vpcompressq_m256_ymm :: #force_inline proc "contextless" (dst: Mem256, src: YMM) -> Instruction { return inst_m_r(.VPCOMPRESSQ, dst.mem, 32, Register(src)) } -inst_vpcompressq_zmm_zmm :: #force_inline proc "contextless" (dst: ZMM, src: ZMM) -> Instruction { return inst_r_r(.VPCOMPRESSQ, Register(dst), Register(src)) } -inst_vpcompressq_m512_zmm :: #force_inline proc "contextless" (dst: Mem512, src: ZMM) -> Instruction { return inst_m_r(.VPCOMPRESSQ, dst.mem, 64, Register(src)) } -emit_vpcompressq_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .VPCOMPRESSQ, Register(dst), Register(src)) } -emit_vpcompressq_m128_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem128, src: XMM) { emit_mr(instructions, .VPCOMPRESSQ, dst.mem, 16, Register(src)) } -emit_vpcompressq_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM) { emit_rr(instructions, .VPCOMPRESSQ, Register(dst), Register(src)) } -emit_vpcompressq_m256_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem256, src: YMM) { emit_mr(instructions, .VPCOMPRESSQ, dst.mem, 32, Register(src)) } -emit_vpcompressq_zmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM) { emit_rr(instructions, .VPCOMPRESSQ, Register(dst), Register(src)) } -emit_vpcompressq_m512_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem512, src: ZMM) { emit_mr(instructions, .VPCOMPRESSQ, dst.mem, 64, Register(src)) } -inst_vcompressps_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.VCOMPRESSPS, Register(dst), Register(src)) } -inst_vcompressps_m128_xmm :: #force_inline proc "contextless" (dst: Mem128, src: XMM) -> Instruction { return inst_m_r(.VCOMPRESSPS, dst.mem, 16, Register(src)) } -inst_vcompressps_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM) -> Instruction { return inst_r_r(.VCOMPRESSPS, Register(dst), Register(src)) } -inst_vcompressps_m256_ymm :: #force_inline proc "contextless" (dst: Mem256, src: YMM) -> Instruction { return inst_m_r(.VCOMPRESSPS, dst.mem, 32, Register(src)) } -inst_vcompressps_zmm_zmm :: #force_inline proc "contextless" (dst: ZMM, src: ZMM) -> Instruction { return inst_r_r(.VCOMPRESSPS, Register(dst), Register(src)) } -inst_vcompressps_m512_zmm :: #force_inline proc "contextless" (dst: Mem512, src: ZMM) -> Instruction { return inst_m_r(.VCOMPRESSPS, dst.mem, 64, Register(src)) } -emit_vcompressps_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .VCOMPRESSPS, Register(dst), Register(src)) } -emit_vcompressps_m128_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem128, src: XMM) { emit_mr(instructions, .VCOMPRESSPS, dst.mem, 16, Register(src)) } -emit_vcompressps_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM) { emit_rr(instructions, .VCOMPRESSPS, Register(dst), Register(src)) } -emit_vcompressps_m256_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem256, src: YMM) { emit_mr(instructions, .VCOMPRESSPS, dst.mem, 32, Register(src)) } -emit_vcompressps_zmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM) { emit_rr(instructions, .VCOMPRESSPS, Register(dst), Register(src)) } -emit_vcompressps_m512_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem512, src: ZMM) { emit_mr(instructions, .VCOMPRESSPS, dst.mem, 64, Register(src)) } -inst_vcompresspd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.VCOMPRESSPD, Register(dst), Register(src)) } -inst_vcompresspd_m128_xmm :: #force_inline proc "contextless" (dst: Mem128, src: XMM) -> Instruction { return inst_m_r(.VCOMPRESSPD, dst.mem, 16, Register(src)) } -inst_vcompresspd_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM) -> Instruction { return inst_r_r(.VCOMPRESSPD, Register(dst), Register(src)) } -inst_vcompresspd_m256_ymm :: #force_inline proc "contextless" (dst: Mem256, src: YMM) -> Instruction { return inst_m_r(.VCOMPRESSPD, dst.mem, 32, Register(src)) } -inst_vcompresspd_zmm_zmm :: #force_inline proc "contextless" (dst: ZMM, src: ZMM) -> Instruction { return inst_r_r(.VCOMPRESSPD, Register(dst), Register(src)) } -inst_vcompresspd_m512_zmm :: #force_inline proc "contextless" (dst: Mem512, src: ZMM) -> Instruction { return inst_m_r(.VCOMPRESSPD, dst.mem, 64, Register(src)) } -emit_vcompresspd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .VCOMPRESSPD, Register(dst), Register(src)) } -emit_vcompresspd_m128_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem128, src: XMM) { emit_mr(instructions, .VCOMPRESSPD, dst.mem, 16, Register(src)) } -emit_vcompresspd_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM) { emit_rr(instructions, .VCOMPRESSPD, Register(dst), Register(src)) } -emit_vcompresspd_m256_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem256, src: YMM) { emit_mr(instructions, .VCOMPRESSPD, dst.mem, 32, Register(src)) } -emit_vcompresspd_zmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM) { emit_rr(instructions, .VCOMPRESSPD, Register(dst), Register(src)) } -emit_vcompresspd_m512_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem512, src: ZMM) { emit_mr(instructions, .VCOMPRESSPD, dst.mem, 64, Register(src)) } -inst_vpexpandd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.VPEXPANDD, Register(dst), Register(src)) } -inst_vpexpandd_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.VPEXPANDD, Register(dst), src.mem, 16) } -inst_vpexpandd_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM) -> Instruction { return inst_r_r(.VPEXPANDD, Register(dst), Register(src)) } -inst_vpexpandd_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: Mem256) -> Instruction { return inst_r_m(.VPEXPANDD, Register(dst), src.mem, 32) } -inst_vpexpandd_zmm_zmm :: #force_inline proc "contextless" (dst: ZMM, src: ZMM) -> Instruction { return inst_r_r(.VPEXPANDD, Register(dst), Register(src)) } -inst_vpexpandd_zmm_m512 :: #force_inline proc "contextless" (dst: ZMM, src: Mem512) -> Instruction { return inst_r_m(.VPEXPANDD, Register(dst), src.mem, 64) } -emit_vpexpandd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .VPEXPANDD, Register(dst), Register(src)) } -emit_vpexpandd_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .VPEXPANDD, Register(dst), src.mem, 16) } -emit_vpexpandd_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM) { emit_rr(instructions, .VPEXPANDD, Register(dst), Register(src)) } -emit_vpexpandd_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem256) { emit_rm(instructions, .VPEXPANDD, Register(dst), src.mem, 32) } -emit_vpexpandd_zmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM) { emit_rr(instructions, .VPEXPANDD, Register(dst), Register(src)) } -emit_vpexpandd_zmm_m512 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: Mem512) { emit_rm(instructions, .VPEXPANDD, Register(dst), src.mem, 64) } -inst_vpexpandq_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.VPEXPANDQ, Register(dst), Register(src)) } -inst_vpexpandq_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.VPEXPANDQ, Register(dst), src.mem, 16) } -inst_vpexpandq_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM) -> Instruction { return inst_r_r(.VPEXPANDQ, Register(dst), Register(src)) } -inst_vpexpandq_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: Mem256) -> Instruction { return inst_r_m(.VPEXPANDQ, Register(dst), src.mem, 32) } -inst_vpexpandq_zmm_zmm :: #force_inline proc "contextless" (dst: ZMM, src: ZMM) -> Instruction { return inst_r_r(.VPEXPANDQ, Register(dst), Register(src)) } -inst_vpexpandq_zmm_m512 :: #force_inline proc "contextless" (dst: ZMM, src: Mem512) -> Instruction { return inst_r_m(.VPEXPANDQ, Register(dst), src.mem, 64) } -emit_vpexpandq_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .VPEXPANDQ, Register(dst), Register(src)) } -emit_vpexpandq_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .VPEXPANDQ, Register(dst), src.mem, 16) } -emit_vpexpandq_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM) { emit_rr(instructions, .VPEXPANDQ, Register(dst), Register(src)) } -emit_vpexpandq_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem256) { emit_rm(instructions, .VPEXPANDQ, Register(dst), src.mem, 32) } -emit_vpexpandq_zmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM) { emit_rr(instructions, .VPEXPANDQ, Register(dst), Register(src)) } -emit_vpexpandq_zmm_m512 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: Mem512) { emit_rm(instructions, .VPEXPANDQ, Register(dst), src.mem, 64) } -inst_vexpandps_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.VEXPANDPS, Register(dst), Register(src)) } -inst_vexpandps_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.VEXPANDPS, Register(dst), src.mem, 16) } -inst_vexpandps_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM) -> Instruction { return inst_r_r(.VEXPANDPS, Register(dst), Register(src)) } -inst_vexpandps_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: Mem256) -> Instruction { return inst_r_m(.VEXPANDPS, Register(dst), src.mem, 32) } -inst_vexpandps_zmm_zmm :: #force_inline proc "contextless" (dst: ZMM, src: ZMM) -> Instruction { return inst_r_r(.VEXPANDPS, Register(dst), Register(src)) } -inst_vexpandps_zmm_m512 :: #force_inline proc "contextless" (dst: ZMM, src: Mem512) -> Instruction { return inst_r_m(.VEXPANDPS, Register(dst), src.mem, 64) } -emit_vexpandps_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .VEXPANDPS, Register(dst), Register(src)) } -emit_vexpandps_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .VEXPANDPS, Register(dst), src.mem, 16) } -emit_vexpandps_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM) { emit_rr(instructions, .VEXPANDPS, Register(dst), Register(src)) } -emit_vexpandps_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem256) { emit_rm(instructions, .VEXPANDPS, Register(dst), src.mem, 32) } -emit_vexpandps_zmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM) { emit_rr(instructions, .VEXPANDPS, Register(dst), Register(src)) } -emit_vexpandps_zmm_m512 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: Mem512) { emit_rm(instructions, .VEXPANDPS, Register(dst), src.mem, 64) } -inst_vexpandpd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.VEXPANDPD, Register(dst), Register(src)) } -inst_vexpandpd_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.VEXPANDPD, Register(dst), src.mem, 16) } -inst_vexpandpd_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM) -> Instruction { return inst_r_r(.VEXPANDPD, Register(dst), Register(src)) } -inst_vexpandpd_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: Mem256) -> Instruction { return inst_r_m(.VEXPANDPD, Register(dst), src.mem, 32) } -inst_vexpandpd_zmm_zmm :: #force_inline proc "contextless" (dst: ZMM, src: ZMM) -> Instruction { return inst_r_r(.VEXPANDPD, Register(dst), Register(src)) } -inst_vexpandpd_zmm_m512 :: #force_inline proc "contextless" (dst: ZMM, src: Mem512) -> Instruction { return inst_r_m(.VEXPANDPD, Register(dst), src.mem, 64) } -emit_vexpandpd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .VEXPANDPD, Register(dst), Register(src)) } -emit_vexpandpd_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .VEXPANDPD, Register(dst), src.mem, 16) } -emit_vexpandpd_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM) { emit_rr(instructions, .VEXPANDPD, Register(dst), Register(src)) } -emit_vexpandpd_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem256) { emit_rm(instructions, .VEXPANDPD, Register(dst), src.mem, 32) } -emit_vexpandpd_zmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM) { emit_rr(instructions, .VEXPANDPD, Register(dst), Register(src)) } -emit_vexpandpd_zmm_m512 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: Mem512) { emit_rm(instructions, .VEXPANDPD, Register(dst), src.mem, 64) } -inst_vpconflictd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.VPCONFLICTD, Register(dst), Register(src)) } -inst_vpconflictd_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.VPCONFLICTD, Register(dst), src.mem, 16) } -inst_vpconflictd_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM) -> Instruction { return inst_r_r(.VPCONFLICTD, Register(dst), Register(src)) } -inst_vpconflictd_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: Mem256) -> Instruction { return inst_r_m(.VPCONFLICTD, Register(dst), src.mem, 32) } -inst_vpconflictd_zmm_zmm :: #force_inline proc "contextless" (dst: ZMM, src: ZMM) -> Instruction { return inst_r_r(.VPCONFLICTD, Register(dst), Register(src)) } -inst_vpconflictd_zmm_m512 :: #force_inline proc "contextless" (dst: ZMM, src: Mem512) -> Instruction { return inst_r_m(.VPCONFLICTD, Register(dst), src.mem, 64) } -emit_vpconflictd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .VPCONFLICTD, Register(dst), Register(src)) } -emit_vpconflictd_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .VPCONFLICTD, Register(dst), src.mem, 16) } -emit_vpconflictd_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM) { emit_rr(instructions, .VPCONFLICTD, Register(dst), Register(src)) } -emit_vpconflictd_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem256) { emit_rm(instructions, .VPCONFLICTD, Register(dst), src.mem, 32) } -emit_vpconflictd_zmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM) { emit_rr(instructions, .VPCONFLICTD, Register(dst), Register(src)) } -emit_vpconflictd_zmm_m512 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: Mem512) { emit_rm(instructions, .VPCONFLICTD, Register(dst), src.mem, 64) } -inst_vpconflictq_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.VPCONFLICTQ, Register(dst), Register(src)) } -inst_vpconflictq_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.VPCONFLICTQ, Register(dst), src.mem, 16) } -inst_vpconflictq_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM) -> Instruction { return inst_r_r(.VPCONFLICTQ, Register(dst), Register(src)) } -inst_vpconflictq_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: Mem256) -> Instruction { return inst_r_m(.VPCONFLICTQ, Register(dst), src.mem, 32) } -inst_vpconflictq_zmm_zmm :: #force_inline proc "contextless" (dst: ZMM, src: ZMM) -> Instruction { return inst_r_r(.VPCONFLICTQ, Register(dst), Register(src)) } -inst_vpconflictq_zmm_m512 :: #force_inline proc "contextless" (dst: ZMM, src: Mem512) -> Instruction { return inst_r_m(.VPCONFLICTQ, Register(dst), src.mem, 64) } -emit_vpconflictq_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .VPCONFLICTQ, Register(dst), Register(src)) } -emit_vpconflictq_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .VPCONFLICTQ, Register(dst), src.mem, 16) } -emit_vpconflictq_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM) { emit_rr(instructions, .VPCONFLICTQ, Register(dst), Register(src)) } -emit_vpconflictq_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem256) { emit_rm(instructions, .VPCONFLICTQ, Register(dst), src.mem, 32) } -emit_vpconflictq_zmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM) { emit_rr(instructions, .VPCONFLICTQ, Register(dst), Register(src)) } -emit_vpconflictq_zmm_m512 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: Mem512) { emit_rm(instructions, .VPCONFLICTQ, Register(dst), src.mem, 64) } -inst_vplzcntd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.VPLZCNTD, Register(dst), Register(src)) } -inst_vplzcntd_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.VPLZCNTD, Register(dst), src.mem, 16) } -inst_vplzcntd_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM) -> Instruction { return inst_r_r(.VPLZCNTD, Register(dst), Register(src)) } -inst_vplzcntd_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: Mem256) -> Instruction { return inst_r_m(.VPLZCNTD, Register(dst), src.mem, 32) } -inst_vplzcntd_zmm_zmm :: #force_inline proc "contextless" (dst: ZMM, src: ZMM) -> Instruction { return inst_r_r(.VPLZCNTD, Register(dst), Register(src)) } -inst_vplzcntd_zmm_m512 :: #force_inline proc "contextless" (dst: ZMM, src: Mem512) -> Instruction { return inst_r_m(.VPLZCNTD, Register(dst), src.mem, 64) } -emit_vplzcntd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .VPLZCNTD, Register(dst), Register(src)) } -emit_vplzcntd_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .VPLZCNTD, Register(dst), src.mem, 16) } -emit_vplzcntd_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM) { emit_rr(instructions, .VPLZCNTD, Register(dst), Register(src)) } -emit_vplzcntd_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem256) { emit_rm(instructions, .VPLZCNTD, Register(dst), src.mem, 32) } -emit_vplzcntd_zmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM) { emit_rr(instructions, .VPLZCNTD, Register(dst), Register(src)) } -emit_vplzcntd_zmm_m512 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: Mem512) { emit_rm(instructions, .VPLZCNTD, Register(dst), src.mem, 64) } -inst_vplzcntq_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.VPLZCNTQ, Register(dst), Register(src)) } -inst_vplzcntq_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.VPLZCNTQ, Register(dst), src.mem, 16) } -inst_vplzcntq_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM) -> Instruction { return inst_r_r(.VPLZCNTQ, Register(dst), Register(src)) } -inst_vplzcntq_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: Mem256) -> Instruction { return inst_r_m(.VPLZCNTQ, Register(dst), src.mem, 32) } -inst_vplzcntq_zmm_zmm :: #force_inline proc "contextless" (dst: ZMM, src: ZMM) -> Instruction { return inst_r_r(.VPLZCNTQ, Register(dst), Register(src)) } -inst_vplzcntq_zmm_m512 :: #force_inline proc "contextless" (dst: ZMM, src: Mem512) -> Instruction { return inst_r_m(.VPLZCNTQ, Register(dst), src.mem, 64) } -emit_vplzcntq_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .VPLZCNTQ, Register(dst), Register(src)) } -emit_vplzcntq_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .VPLZCNTQ, Register(dst), src.mem, 16) } -emit_vplzcntq_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM) { emit_rr(instructions, .VPLZCNTQ, Register(dst), Register(src)) } -emit_vplzcntq_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem256) { emit_rm(instructions, .VPLZCNTQ, Register(dst), src.mem, 32) } -emit_vplzcntq_zmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM) { emit_rr(instructions, .VPLZCNTQ, Register(dst), Register(src)) } -emit_vplzcntq_zmm_m512 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: Mem512) { emit_rm(instructions, .VPLZCNTQ, Register(dst), src.mem, 64) } -inst_vpermi2b_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VPERMI2B, Register(dst), Register(src), Register(src2)) } -inst_vpermi2b_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VPERMI2B, Register(dst), Register(src), src2.mem, 16) } -inst_vpermi2b_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VPERMI2B, Register(dst), Register(src), Register(src2)) } -inst_vpermi2b_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VPERMI2B, Register(dst), Register(src), src2.mem, 32) } -inst_vpermi2b_zmm_zmm_zmm :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: ZMM) -> Instruction { return inst_r_r_r(.VPERMI2B, Register(dst), Register(src), Register(src2)) } -inst_vpermi2b_zmm_zmm_m512 :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: Mem512) -> Instruction { return inst_r_r_m(.VPERMI2B, Register(dst), Register(src), src2.mem, 64) } -emit_vpermi2b_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VPERMI2B, Register(dst), Register(src), Register(src2)) } -emit_vpermi2b_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VPERMI2B, Register(dst), Register(src), src2.mem, 16) } -emit_vpermi2b_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VPERMI2B, Register(dst), Register(src), Register(src2)) } -emit_vpermi2b_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VPERMI2B, Register(dst), Register(src), src2.mem, 32) } -emit_vpermi2b_zmm_zmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: ZMM) { emit_rrr(instructions, .VPERMI2B, Register(dst), Register(src), Register(src2)) } -emit_vpermi2b_zmm_zmm_m512 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: Mem512) { emit_rrm(instructions, .VPERMI2B, Register(dst), Register(src), src2.mem, 64) } -inst_vpermi2w_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VPERMI2W, Register(dst), Register(src), Register(src2)) } -inst_vpermi2w_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VPERMI2W, Register(dst), Register(src), src2.mem, 16) } -inst_vpermi2w_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VPERMI2W, Register(dst), Register(src), Register(src2)) } -inst_vpermi2w_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VPERMI2W, Register(dst), Register(src), src2.mem, 32) } -inst_vpermi2w_zmm_zmm_zmm :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: ZMM) -> Instruction { return inst_r_r_r(.VPERMI2W, Register(dst), Register(src), Register(src2)) } -inst_vpermi2w_zmm_zmm_m512 :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: Mem512) -> Instruction { return inst_r_r_m(.VPERMI2W, Register(dst), Register(src), src2.mem, 64) } -emit_vpermi2w_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VPERMI2W, Register(dst), Register(src), Register(src2)) } -emit_vpermi2w_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VPERMI2W, Register(dst), Register(src), src2.mem, 16) } -emit_vpermi2w_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VPERMI2W, Register(dst), Register(src), Register(src2)) } -emit_vpermi2w_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VPERMI2W, Register(dst), Register(src), src2.mem, 32) } -emit_vpermi2w_zmm_zmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: ZMM) { emit_rrr(instructions, .VPERMI2W, Register(dst), Register(src), Register(src2)) } -emit_vpermi2w_zmm_zmm_m512 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: Mem512) { emit_rrm(instructions, .VPERMI2W, Register(dst), Register(src), src2.mem, 64) } -inst_vpermi2d_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VPERMI2D, Register(dst), Register(src), Register(src2)) } -inst_vpermi2d_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VPERMI2D, Register(dst), Register(src), src2.mem, 16) } -inst_vpermi2d_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VPERMI2D, Register(dst), Register(src), Register(src2)) } -inst_vpermi2d_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VPERMI2D, Register(dst), Register(src), src2.mem, 32) } -inst_vpermi2d_zmm_zmm_zmm :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: ZMM) -> Instruction { return inst_r_r_r(.VPERMI2D, Register(dst), Register(src), Register(src2)) } -inst_vpermi2d_zmm_zmm_m512 :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: Mem512) -> Instruction { return inst_r_r_m(.VPERMI2D, Register(dst), Register(src), src2.mem, 64) } -emit_vpermi2d_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VPERMI2D, Register(dst), Register(src), Register(src2)) } -emit_vpermi2d_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VPERMI2D, Register(dst), Register(src), src2.mem, 16) } -emit_vpermi2d_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VPERMI2D, Register(dst), Register(src), Register(src2)) } -emit_vpermi2d_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VPERMI2D, Register(dst), Register(src), src2.mem, 32) } -emit_vpermi2d_zmm_zmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: ZMM) { emit_rrr(instructions, .VPERMI2D, Register(dst), Register(src), Register(src2)) } -emit_vpermi2d_zmm_zmm_m512 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: Mem512) { emit_rrm(instructions, .VPERMI2D, Register(dst), Register(src), src2.mem, 64) } -inst_vpermi2q_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VPERMI2Q, Register(dst), Register(src), Register(src2)) } -inst_vpermi2q_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VPERMI2Q, Register(dst), Register(src), src2.mem, 16) } -inst_vpermi2q_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VPERMI2Q, Register(dst), Register(src), Register(src2)) } -inst_vpermi2q_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VPERMI2Q, Register(dst), Register(src), src2.mem, 32) } -inst_vpermi2q_zmm_zmm_zmm :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: ZMM) -> Instruction { return inst_r_r_r(.VPERMI2Q, Register(dst), Register(src), Register(src2)) } -inst_vpermi2q_zmm_zmm_m512 :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: Mem512) -> Instruction { return inst_r_r_m(.VPERMI2Q, Register(dst), Register(src), src2.mem, 64) } -emit_vpermi2q_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VPERMI2Q, Register(dst), Register(src), Register(src2)) } -emit_vpermi2q_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VPERMI2Q, Register(dst), Register(src), src2.mem, 16) } -emit_vpermi2q_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VPERMI2Q, Register(dst), Register(src), Register(src2)) } -emit_vpermi2q_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VPERMI2Q, Register(dst), Register(src), src2.mem, 32) } -emit_vpermi2q_zmm_zmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: ZMM) { emit_rrr(instructions, .VPERMI2Q, Register(dst), Register(src), Register(src2)) } -emit_vpermi2q_zmm_zmm_m512 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: Mem512) { emit_rrm(instructions, .VPERMI2Q, Register(dst), Register(src), src2.mem, 64) } -inst_vpermi2ps_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VPERMI2PS, Register(dst), Register(src), Register(src2)) } -inst_vpermi2ps_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VPERMI2PS, Register(dst), Register(src), src2.mem, 16) } -inst_vpermi2ps_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VPERMI2PS, Register(dst), Register(src), Register(src2)) } -inst_vpermi2ps_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VPERMI2PS, Register(dst), Register(src), src2.mem, 32) } -inst_vpermi2ps_zmm_zmm_zmm :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: ZMM) -> Instruction { return inst_r_r_r(.VPERMI2PS, Register(dst), Register(src), Register(src2)) } -inst_vpermi2ps_zmm_zmm_m512 :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: Mem512) -> Instruction { return inst_r_r_m(.VPERMI2PS, Register(dst), Register(src), src2.mem, 64) } -emit_vpermi2ps_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VPERMI2PS, Register(dst), Register(src), Register(src2)) } -emit_vpermi2ps_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VPERMI2PS, Register(dst), Register(src), src2.mem, 16) } -emit_vpermi2ps_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VPERMI2PS, Register(dst), Register(src), Register(src2)) } -emit_vpermi2ps_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VPERMI2PS, Register(dst), Register(src), src2.mem, 32) } -emit_vpermi2ps_zmm_zmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: ZMM) { emit_rrr(instructions, .VPERMI2PS, Register(dst), Register(src), Register(src2)) } -emit_vpermi2ps_zmm_zmm_m512 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: Mem512) { emit_rrm(instructions, .VPERMI2PS, Register(dst), Register(src), src2.mem, 64) } -inst_vpermi2pd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VPERMI2PD, Register(dst), Register(src), Register(src2)) } -inst_vpermi2pd_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VPERMI2PD, Register(dst), Register(src), src2.mem, 16) } -inst_vpermi2pd_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VPERMI2PD, Register(dst), Register(src), Register(src2)) } -inst_vpermi2pd_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VPERMI2PD, Register(dst), Register(src), src2.mem, 32) } -inst_vpermi2pd_zmm_zmm_zmm :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: ZMM) -> Instruction { return inst_r_r_r(.VPERMI2PD, Register(dst), Register(src), Register(src2)) } -inst_vpermi2pd_zmm_zmm_m512 :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: Mem512) -> Instruction { return inst_r_r_m(.VPERMI2PD, Register(dst), Register(src), src2.mem, 64) } -emit_vpermi2pd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VPERMI2PD, Register(dst), Register(src), Register(src2)) } -emit_vpermi2pd_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VPERMI2PD, Register(dst), Register(src), src2.mem, 16) } -emit_vpermi2pd_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VPERMI2PD, Register(dst), Register(src), Register(src2)) } -emit_vpermi2pd_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VPERMI2PD, Register(dst), Register(src), src2.mem, 32) } -emit_vpermi2pd_zmm_zmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: ZMM) { emit_rrr(instructions, .VPERMI2PD, Register(dst), Register(src), Register(src2)) } -emit_vpermi2pd_zmm_zmm_m512 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: Mem512) { emit_rrm(instructions, .VPERMI2PD, Register(dst), Register(src), src2.mem, 64) } -inst_vpermt2b_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VPERMT2B, Register(dst), Register(src), Register(src2)) } -inst_vpermt2b_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VPERMT2B, Register(dst), Register(src), src2.mem, 16) } -inst_vpermt2b_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VPERMT2B, Register(dst), Register(src), Register(src2)) } -inst_vpermt2b_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VPERMT2B, Register(dst), Register(src), src2.mem, 32) } -inst_vpermt2b_zmm_zmm_zmm :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: ZMM) -> Instruction { return inst_r_r_r(.VPERMT2B, Register(dst), Register(src), Register(src2)) } -inst_vpermt2b_zmm_zmm_m512 :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: Mem512) -> Instruction { return inst_r_r_m(.VPERMT2B, Register(dst), Register(src), src2.mem, 64) } -emit_vpermt2b_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VPERMT2B, Register(dst), Register(src), Register(src2)) } -emit_vpermt2b_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VPERMT2B, Register(dst), Register(src), src2.mem, 16) } -emit_vpermt2b_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VPERMT2B, Register(dst), Register(src), Register(src2)) } -emit_vpermt2b_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VPERMT2B, Register(dst), Register(src), src2.mem, 32) } -emit_vpermt2b_zmm_zmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: ZMM) { emit_rrr(instructions, .VPERMT2B, Register(dst), Register(src), Register(src2)) } -emit_vpermt2b_zmm_zmm_m512 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: Mem512) { emit_rrm(instructions, .VPERMT2B, Register(dst), Register(src), src2.mem, 64) } -inst_vpermt2w_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VPERMT2W, Register(dst), Register(src), Register(src2)) } -inst_vpermt2w_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VPERMT2W, Register(dst), Register(src), src2.mem, 16) } -inst_vpermt2w_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VPERMT2W, Register(dst), Register(src), Register(src2)) } -inst_vpermt2w_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VPERMT2W, Register(dst), Register(src), src2.mem, 32) } -inst_vpermt2w_zmm_zmm_zmm :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: ZMM) -> Instruction { return inst_r_r_r(.VPERMT2W, Register(dst), Register(src), Register(src2)) } -inst_vpermt2w_zmm_zmm_m512 :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: Mem512) -> Instruction { return inst_r_r_m(.VPERMT2W, Register(dst), Register(src), src2.mem, 64) } -emit_vpermt2w_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VPERMT2W, Register(dst), Register(src), Register(src2)) } -emit_vpermt2w_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VPERMT2W, Register(dst), Register(src), src2.mem, 16) } -emit_vpermt2w_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VPERMT2W, Register(dst), Register(src), Register(src2)) } -emit_vpermt2w_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VPERMT2W, Register(dst), Register(src), src2.mem, 32) } -emit_vpermt2w_zmm_zmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: ZMM) { emit_rrr(instructions, .VPERMT2W, Register(dst), Register(src), Register(src2)) } -emit_vpermt2w_zmm_zmm_m512 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: Mem512) { emit_rrm(instructions, .VPERMT2W, Register(dst), Register(src), src2.mem, 64) } -inst_vpermt2d_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VPERMT2D, Register(dst), Register(src), Register(src2)) } -inst_vpermt2d_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VPERMT2D, Register(dst), Register(src), src2.mem, 16) } -inst_vpermt2d_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VPERMT2D, Register(dst), Register(src), Register(src2)) } -inst_vpermt2d_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VPERMT2D, Register(dst), Register(src), src2.mem, 32) } -inst_vpermt2d_zmm_zmm_zmm :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: ZMM) -> Instruction { return inst_r_r_r(.VPERMT2D, Register(dst), Register(src), Register(src2)) } -inst_vpermt2d_zmm_zmm_m512 :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: Mem512) -> Instruction { return inst_r_r_m(.VPERMT2D, Register(dst), Register(src), src2.mem, 64) } -emit_vpermt2d_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VPERMT2D, Register(dst), Register(src), Register(src2)) } -emit_vpermt2d_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VPERMT2D, Register(dst), Register(src), src2.mem, 16) } -emit_vpermt2d_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VPERMT2D, Register(dst), Register(src), Register(src2)) } -emit_vpermt2d_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VPERMT2D, Register(dst), Register(src), src2.mem, 32) } -emit_vpermt2d_zmm_zmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: ZMM) { emit_rrr(instructions, .VPERMT2D, Register(dst), Register(src), Register(src2)) } -emit_vpermt2d_zmm_zmm_m512 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: Mem512) { emit_rrm(instructions, .VPERMT2D, Register(dst), Register(src), src2.mem, 64) } -inst_vpermt2q_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VPERMT2Q, Register(dst), Register(src), Register(src2)) } -inst_vpermt2q_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VPERMT2Q, Register(dst), Register(src), src2.mem, 16) } -inst_vpermt2q_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VPERMT2Q, Register(dst), Register(src), Register(src2)) } -inst_vpermt2q_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VPERMT2Q, Register(dst), Register(src), src2.mem, 32) } -inst_vpermt2q_zmm_zmm_zmm :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: ZMM) -> Instruction { return inst_r_r_r(.VPERMT2Q, Register(dst), Register(src), Register(src2)) } -inst_vpermt2q_zmm_zmm_m512 :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: Mem512) -> Instruction { return inst_r_r_m(.VPERMT2Q, Register(dst), Register(src), src2.mem, 64) } -emit_vpermt2q_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VPERMT2Q, Register(dst), Register(src), Register(src2)) } -emit_vpermt2q_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VPERMT2Q, Register(dst), Register(src), src2.mem, 16) } -emit_vpermt2q_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VPERMT2Q, Register(dst), Register(src), Register(src2)) } -emit_vpermt2q_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VPERMT2Q, Register(dst), Register(src), src2.mem, 32) } -emit_vpermt2q_zmm_zmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: ZMM) { emit_rrr(instructions, .VPERMT2Q, Register(dst), Register(src), Register(src2)) } -emit_vpermt2q_zmm_zmm_m512 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: Mem512) { emit_rrm(instructions, .VPERMT2Q, Register(dst), Register(src), src2.mem, 64) } -inst_vpermt2ps_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VPERMT2PS, Register(dst), Register(src), Register(src2)) } -inst_vpermt2ps_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VPERMT2PS, Register(dst), Register(src), src2.mem, 16) } -inst_vpermt2ps_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VPERMT2PS, Register(dst), Register(src), Register(src2)) } -inst_vpermt2ps_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VPERMT2PS, Register(dst), Register(src), src2.mem, 32) } -inst_vpermt2ps_zmm_zmm_zmm :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: ZMM) -> Instruction { return inst_r_r_r(.VPERMT2PS, Register(dst), Register(src), Register(src2)) } -inst_vpermt2ps_zmm_zmm_m512 :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: Mem512) -> Instruction { return inst_r_r_m(.VPERMT2PS, Register(dst), Register(src), src2.mem, 64) } -emit_vpermt2ps_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VPERMT2PS, Register(dst), Register(src), Register(src2)) } -emit_vpermt2ps_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VPERMT2PS, Register(dst), Register(src), src2.mem, 16) } -emit_vpermt2ps_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VPERMT2PS, Register(dst), Register(src), Register(src2)) } -emit_vpermt2ps_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VPERMT2PS, Register(dst), Register(src), src2.mem, 32) } -emit_vpermt2ps_zmm_zmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: ZMM) { emit_rrr(instructions, .VPERMT2PS, Register(dst), Register(src), Register(src2)) } -emit_vpermt2ps_zmm_zmm_m512 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: Mem512) { emit_rrm(instructions, .VPERMT2PS, Register(dst), Register(src), src2.mem, 64) } -inst_vpermt2pd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VPERMT2PD, Register(dst), Register(src), Register(src2)) } -inst_vpermt2pd_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VPERMT2PD, Register(dst), Register(src), src2.mem, 16) } -inst_vpermt2pd_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VPERMT2PD, Register(dst), Register(src), Register(src2)) } -inst_vpermt2pd_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VPERMT2PD, Register(dst), Register(src), src2.mem, 32) } -inst_vpermt2pd_zmm_zmm_zmm :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: ZMM) -> Instruction { return inst_r_r_r(.VPERMT2PD, Register(dst), Register(src), Register(src2)) } -inst_vpermt2pd_zmm_zmm_m512 :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: Mem512) -> Instruction { return inst_r_r_m(.VPERMT2PD, Register(dst), Register(src), src2.mem, 64) } -emit_vpermt2pd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VPERMT2PD, Register(dst), Register(src), Register(src2)) } -emit_vpermt2pd_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VPERMT2PD, Register(dst), Register(src), src2.mem, 16) } -emit_vpermt2pd_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VPERMT2PD, Register(dst), Register(src), Register(src2)) } -emit_vpermt2pd_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VPERMT2PD, Register(dst), Register(src), src2.mem, 32) } -emit_vpermt2pd_zmm_zmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: ZMM) { emit_rrr(instructions, .VPERMT2PD, Register(dst), Register(src), Register(src2)) } -emit_vpermt2pd_zmm_zmm_m512 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: Mem512) { emit_rrm(instructions, .VPERMT2PD, Register(dst), Register(src), src2.mem, 64) } -inst_vpermb_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VPERMB, Register(dst), Register(src), Register(src2)) } -inst_vpermb_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VPERMB, Register(dst), Register(src), src2.mem, 16) } -inst_vpermb_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VPERMB, Register(dst), Register(src), Register(src2)) } -inst_vpermb_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VPERMB, Register(dst), Register(src), src2.mem, 32) } -inst_vpermb_zmm_zmm_zmm :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: ZMM) -> Instruction { return inst_r_r_r(.VPERMB, Register(dst), Register(src), Register(src2)) } -inst_vpermb_zmm_zmm_m512 :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: Mem512) -> Instruction { return inst_r_r_m(.VPERMB, Register(dst), Register(src), src2.mem, 64) } -emit_vpermb_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VPERMB, Register(dst), Register(src), Register(src2)) } -emit_vpermb_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VPERMB, Register(dst), Register(src), src2.mem, 16) } -emit_vpermb_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VPERMB, Register(dst), Register(src), Register(src2)) } -emit_vpermb_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VPERMB, Register(dst), Register(src), src2.mem, 32) } -emit_vpermb_zmm_zmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: ZMM) { emit_rrr(instructions, .VPERMB, Register(dst), Register(src), Register(src2)) } -emit_vpermb_zmm_zmm_m512 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: Mem512) { emit_rrm(instructions, .VPERMB, Register(dst), Register(src), src2.mem, 64) } -inst_vpermw_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VPERMW, Register(dst), Register(src), Register(src2)) } -inst_vpermw_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VPERMW, Register(dst), Register(src), src2.mem, 16) } -inst_vpermw_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VPERMW, Register(dst), Register(src), Register(src2)) } -inst_vpermw_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VPERMW, Register(dst), Register(src), src2.mem, 32) } -inst_vpermw_zmm_zmm_zmm :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: ZMM) -> Instruction { return inst_r_r_r(.VPERMW, Register(dst), Register(src), Register(src2)) } -inst_vpermw_zmm_zmm_m512 :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: Mem512) -> Instruction { return inst_r_r_m(.VPERMW, Register(dst), Register(src), src2.mem, 64) } -emit_vpermw_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VPERMW, Register(dst), Register(src), Register(src2)) } -emit_vpermw_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VPERMW, Register(dst), Register(src), src2.mem, 16) } -emit_vpermw_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VPERMW, Register(dst), Register(src), Register(src2)) } -emit_vpermw_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VPERMW, Register(dst), Register(src), src2.mem, 32) } -emit_vpermw_zmm_zmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: ZMM) { emit_rrr(instructions, .VPERMW, Register(dst), Register(src), Register(src2)) } -emit_vpermw_zmm_zmm_m512 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: Mem512) { emit_rrm(instructions, .VPERMW, Register(dst), Register(src), src2.mem, 64) } -inst_vpmovb2m_k_xmm :: #force_inline proc "contextless" (dst: KREG, src: XMM) -> Instruction { return inst_r_r(.VPMOVB2M, Register(dst), Register(src)) } -inst_vpmovb2m_k_ymm :: #force_inline proc "contextless" (dst: KREG, src: YMM) -> Instruction { return inst_r_r(.VPMOVB2M, Register(dst), Register(src)) } -inst_vpmovb2m_k_zmm :: #force_inline proc "contextless" (dst: KREG, src: ZMM) -> Instruction { return inst_r_r(.VPMOVB2M, Register(dst), Register(src)) } -emit_vpmovb2m_k_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: XMM) { emit_rr(instructions, .VPMOVB2M, Register(dst), Register(src)) } -emit_vpmovb2m_k_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: YMM) { emit_rr(instructions, .VPMOVB2M, Register(dst), Register(src)) } -emit_vpmovb2m_k_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: ZMM) { emit_rr(instructions, .VPMOVB2M, Register(dst), Register(src)) } -inst_vpmovw2m_k_xmm :: #force_inline proc "contextless" (dst: KREG, src: XMM) -> Instruction { return inst_r_r(.VPMOVW2M, Register(dst), Register(src)) } -inst_vpmovw2m_k_ymm :: #force_inline proc "contextless" (dst: KREG, src: YMM) -> Instruction { return inst_r_r(.VPMOVW2M, Register(dst), Register(src)) } -inst_vpmovw2m_k_zmm :: #force_inline proc "contextless" (dst: KREG, src: ZMM) -> Instruction { return inst_r_r(.VPMOVW2M, Register(dst), Register(src)) } -emit_vpmovw2m_k_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: XMM) { emit_rr(instructions, .VPMOVW2M, Register(dst), Register(src)) } -emit_vpmovw2m_k_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: YMM) { emit_rr(instructions, .VPMOVW2M, Register(dst), Register(src)) } -emit_vpmovw2m_k_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: ZMM) { emit_rr(instructions, .VPMOVW2M, Register(dst), Register(src)) } -inst_vpmovd2m_k_xmm :: #force_inline proc "contextless" (dst: KREG, src: XMM) -> Instruction { return inst_r_r(.VPMOVD2M, Register(dst), Register(src)) } -inst_vpmovd2m_k_ymm :: #force_inline proc "contextless" (dst: KREG, src: YMM) -> Instruction { return inst_r_r(.VPMOVD2M, Register(dst), Register(src)) } -inst_vpmovd2m_k_zmm :: #force_inline proc "contextless" (dst: KREG, src: ZMM) -> Instruction { return inst_r_r(.VPMOVD2M, Register(dst), Register(src)) } -emit_vpmovd2m_k_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: XMM) { emit_rr(instructions, .VPMOVD2M, Register(dst), Register(src)) } -emit_vpmovd2m_k_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: YMM) { emit_rr(instructions, .VPMOVD2M, Register(dst), Register(src)) } -emit_vpmovd2m_k_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: ZMM) { emit_rr(instructions, .VPMOVD2M, Register(dst), Register(src)) } -inst_vpmovq2m_k_xmm :: #force_inline proc "contextless" (dst: KREG, src: XMM) -> Instruction { return inst_r_r(.VPMOVQ2M, Register(dst), Register(src)) } -inst_vpmovq2m_k_ymm :: #force_inline proc "contextless" (dst: KREG, src: YMM) -> Instruction { return inst_r_r(.VPMOVQ2M, Register(dst), Register(src)) } -inst_vpmovq2m_k_zmm :: #force_inline proc "contextless" (dst: KREG, src: ZMM) -> Instruction { return inst_r_r(.VPMOVQ2M, Register(dst), Register(src)) } -emit_vpmovq2m_k_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: XMM) { emit_rr(instructions, .VPMOVQ2M, Register(dst), Register(src)) } -emit_vpmovq2m_k_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: YMM) { emit_rr(instructions, .VPMOVQ2M, Register(dst), Register(src)) } -emit_vpmovq2m_k_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: ZMM) { emit_rr(instructions, .VPMOVQ2M, Register(dst), Register(src)) } -inst_vpmovm2b_xmm_k :: #force_inline proc "contextless" (dst: XMM, src: KREG) -> Instruction { return inst_r_r(.VPMOVM2B, Register(dst), Register(src)) } -inst_vpmovm2b_ymm_k :: #force_inline proc "contextless" (dst: YMM, src: KREG) -> Instruction { return inst_r_r(.VPMOVM2B, Register(dst), Register(src)) } -inst_vpmovm2b_zmm_k :: #force_inline proc "contextless" (dst: ZMM, src: KREG) -> Instruction { return inst_r_r(.VPMOVM2B, Register(dst), Register(src)) } -emit_vpmovm2b_xmm_k :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: KREG) { emit_rr(instructions, .VPMOVM2B, Register(dst), Register(src)) } -emit_vpmovm2b_ymm_k :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: KREG) { emit_rr(instructions, .VPMOVM2B, Register(dst), Register(src)) } -emit_vpmovm2b_zmm_k :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: KREG) { emit_rr(instructions, .VPMOVM2B, Register(dst), Register(src)) } -inst_vpmovm2w_xmm_k :: #force_inline proc "contextless" (dst: XMM, src: KREG) -> Instruction { return inst_r_r(.VPMOVM2W, Register(dst), Register(src)) } -inst_vpmovm2w_ymm_k :: #force_inline proc "contextless" (dst: YMM, src: KREG) -> Instruction { return inst_r_r(.VPMOVM2W, Register(dst), Register(src)) } -inst_vpmovm2w_zmm_k :: #force_inline proc "contextless" (dst: ZMM, src: KREG) -> Instruction { return inst_r_r(.VPMOVM2W, Register(dst), Register(src)) } -emit_vpmovm2w_xmm_k :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: KREG) { emit_rr(instructions, .VPMOVM2W, Register(dst), Register(src)) } -emit_vpmovm2w_ymm_k :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: KREG) { emit_rr(instructions, .VPMOVM2W, Register(dst), Register(src)) } -emit_vpmovm2w_zmm_k :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: KREG) { emit_rr(instructions, .VPMOVM2W, Register(dst), Register(src)) } -inst_vpmovm2d_xmm_k :: #force_inline proc "contextless" (dst: XMM, src: KREG) -> Instruction { return inst_r_r(.VPMOVM2D, Register(dst), Register(src)) } -inst_vpmovm2d_ymm_k :: #force_inline proc "contextless" (dst: YMM, src: KREG) -> Instruction { return inst_r_r(.VPMOVM2D, Register(dst), Register(src)) } -inst_vpmovm2d_zmm_k :: #force_inline proc "contextless" (dst: ZMM, src: KREG) -> Instruction { return inst_r_r(.VPMOVM2D, Register(dst), Register(src)) } -emit_vpmovm2d_xmm_k :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: KREG) { emit_rr(instructions, .VPMOVM2D, Register(dst), Register(src)) } -emit_vpmovm2d_ymm_k :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: KREG) { emit_rr(instructions, .VPMOVM2D, Register(dst), Register(src)) } -emit_vpmovm2d_zmm_k :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: KREG) { emit_rr(instructions, .VPMOVM2D, Register(dst), Register(src)) } -inst_vpmovm2q_xmm_k :: #force_inline proc "contextless" (dst: XMM, src: KREG) -> Instruction { return inst_r_r(.VPMOVM2Q, Register(dst), Register(src)) } -inst_vpmovm2q_ymm_k :: #force_inline proc "contextless" (dst: YMM, src: KREG) -> Instruction { return inst_r_r(.VPMOVM2Q, Register(dst), Register(src)) } -inst_vpmovm2q_zmm_k :: #force_inline proc "contextless" (dst: ZMM, src: KREG) -> Instruction { return inst_r_r(.VPMOVM2Q, Register(dst), Register(src)) } -emit_vpmovm2q_xmm_k :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: KREG) { emit_rr(instructions, .VPMOVM2Q, Register(dst), Register(src)) } -emit_vpmovm2q_ymm_k :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: KREG) { emit_rr(instructions, .VPMOVM2Q, Register(dst), Register(src)) } -emit_vpmovm2q_zmm_k :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: KREG) { emit_rr(instructions, .VPMOVM2Q, Register(dst), Register(src)) } -inst_vpmovqb_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.VPMOVQB, Register(dst), Register(src)) } -inst_vpmovqb_m32_xmm :: #force_inline proc "contextless" (dst: Mem32, src: XMM) -> Instruction { return inst_m_r(.VPMOVQB, dst.mem, 4, Register(src)) } -inst_vpmovqb_xmm_ymm :: #force_inline proc "contextless" (dst: XMM, src: YMM) -> Instruction { return inst_r_r(.VPMOVQB, Register(dst), Register(src)) } -inst_vpmovqb_m32_ymm :: #force_inline proc "contextless" (dst: Mem32, src: YMM) -> Instruction { return inst_m_r(.VPMOVQB, dst.mem, 4, Register(src)) } -inst_vpmovqb_xmm_zmm :: #force_inline proc "contextless" (dst: XMM, src: ZMM) -> Instruction { return inst_r_r(.VPMOVQB, Register(dst), Register(src)) } -inst_vpmovqb_m64_zmm :: #force_inline proc "contextless" (dst: Mem64, src: ZMM) -> Instruction { return inst_m_r(.VPMOVQB, dst.mem, 8, Register(src)) } -emit_vpmovqb_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .VPMOVQB, Register(dst), Register(src)) } -emit_vpmovqb_m32_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, src: XMM) { emit_mr(instructions, .VPMOVQB, dst.mem, 4, Register(src)) } -emit_vpmovqb_xmm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: YMM) { emit_rr(instructions, .VPMOVQB, Register(dst), Register(src)) } -emit_vpmovqb_m32_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, src: YMM) { emit_mr(instructions, .VPMOVQB, dst.mem, 4, Register(src)) } -emit_vpmovqb_xmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: ZMM) { emit_rr(instructions, .VPMOVQB, Register(dst), Register(src)) } -emit_vpmovqb_m64_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, src: ZMM) { emit_mr(instructions, .VPMOVQB, dst.mem, 8, Register(src)) } -inst_vpmovsqb_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.VPMOVSQB, Register(dst), Register(src)) } -inst_vpmovsqb_m32_xmm :: #force_inline proc "contextless" (dst: Mem32, src: XMM) -> Instruction { return inst_m_r(.VPMOVSQB, dst.mem, 4, Register(src)) } -inst_vpmovsqb_xmm_ymm :: #force_inline proc "contextless" (dst: XMM, src: YMM) -> Instruction { return inst_r_r(.VPMOVSQB, Register(dst), Register(src)) } -inst_vpmovsqb_m32_ymm :: #force_inline proc "contextless" (dst: Mem32, src: YMM) -> Instruction { return inst_m_r(.VPMOVSQB, dst.mem, 4, Register(src)) } -inst_vpmovsqb_xmm_zmm :: #force_inline proc "contextless" (dst: XMM, src: ZMM) -> Instruction { return inst_r_r(.VPMOVSQB, Register(dst), Register(src)) } -inst_vpmovsqb_m64_zmm :: #force_inline proc "contextless" (dst: Mem64, src: ZMM) -> Instruction { return inst_m_r(.VPMOVSQB, dst.mem, 8, Register(src)) } -emit_vpmovsqb_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .VPMOVSQB, Register(dst), Register(src)) } -emit_vpmovsqb_m32_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, src: XMM) { emit_mr(instructions, .VPMOVSQB, dst.mem, 4, Register(src)) } -emit_vpmovsqb_xmm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: YMM) { emit_rr(instructions, .VPMOVSQB, Register(dst), Register(src)) } -emit_vpmovsqb_m32_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, src: YMM) { emit_mr(instructions, .VPMOVSQB, dst.mem, 4, Register(src)) } -emit_vpmovsqb_xmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: ZMM) { emit_rr(instructions, .VPMOVSQB, Register(dst), Register(src)) } -emit_vpmovsqb_m64_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, src: ZMM) { emit_mr(instructions, .VPMOVSQB, dst.mem, 8, Register(src)) } -inst_vpmovusqb_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.VPMOVUSQB, Register(dst), Register(src)) } -inst_vpmovusqb_m32_xmm :: #force_inline proc "contextless" (dst: Mem32, src: XMM) -> Instruction { return inst_m_r(.VPMOVUSQB, dst.mem, 4, Register(src)) } -inst_vpmovusqb_xmm_ymm :: #force_inline proc "contextless" (dst: XMM, src: YMM) -> Instruction { return inst_r_r(.VPMOVUSQB, Register(dst), Register(src)) } -inst_vpmovusqb_m32_ymm :: #force_inline proc "contextless" (dst: Mem32, src: YMM) -> Instruction { return inst_m_r(.VPMOVUSQB, dst.mem, 4, Register(src)) } -inst_vpmovusqb_xmm_zmm :: #force_inline proc "contextless" (dst: XMM, src: ZMM) -> Instruction { return inst_r_r(.VPMOVUSQB, Register(dst), Register(src)) } -inst_vpmovusqb_m64_zmm :: #force_inline proc "contextless" (dst: Mem64, src: ZMM) -> Instruction { return inst_m_r(.VPMOVUSQB, dst.mem, 8, Register(src)) } -emit_vpmovusqb_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .VPMOVUSQB, Register(dst), Register(src)) } -emit_vpmovusqb_m32_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, src: XMM) { emit_mr(instructions, .VPMOVUSQB, dst.mem, 4, Register(src)) } -emit_vpmovusqb_xmm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: YMM) { emit_rr(instructions, .VPMOVUSQB, Register(dst), Register(src)) } -emit_vpmovusqb_m32_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, src: YMM) { emit_mr(instructions, .VPMOVUSQB, dst.mem, 4, Register(src)) } -emit_vpmovusqb_xmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: ZMM) { emit_rr(instructions, .VPMOVUSQB, Register(dst), Register(src)) } -emit_vpmovusqb_m64_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, src: ZMM) { emit_mr(instructions, .VPMOVUSQB, dst.mem, 8, Register(src)) } -inst_vpmovqw_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.VPMOVQW, Register(dst), Register(src)) } -inst_vpmovqw_m32_xmm :: #force_inline proc "contextless" (dst: Mem32, src: XMM) -> Instruction { return inst_m_r(.VPMOVQW, dst.mem, 4, Register(src)) } -inst_vpmovqw_xmm_ymm :: #force_inline proc "contextless" (dst: XMM, src: YMM) -> Instruction { return inst_r_r(.VPMOVQW, Register(dst), Register(src)) } -inst_vpmovqw_m64_ymm :: #force_inline proc "contextless" (dst: Mem64, src: YMM) -> Instruction { return inst_m_r(.VPMOVQW, dst.mem, 8, Register(src)) } -inst_vpmovqw_xmm_zmm :: #force_inline proc "contextless" (dst: XMM, src: ZMM) -> Instruction { return inst_r_r(.VPMOVQW, Register(dst), Register(src)) } -inst_vpmovqw_m128_zmm :: #force_inline proc "contextless" (dst: Mem128, src: ZMM) -> Instruction { return inst_m_r(.VPMOVQW, dst.mem, 16, Register(src)) } -emit_vpmovqw_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .VPMOVQW, Register(dst), Register(src)) } -emit_vpmovqw_m32_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, src: XMM) { emit_mr(instructions, .VPMOVQW, dst.mem, 4, Register(src)) } -emit_vpmovqw_xmm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: YMM) { emit_rr(instructions, .VPMOVQW, Register(dst), Register(src)) } -emit_vpmovqw_m64_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, src: YMM) { emit_mr(instructions, .VPMOVQW, dst.mem, 8, Register(src)) } -emit_vpmovqw_xmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: ZMM) { emit_rr(instructions, .VPMOVQW, Register(dst), Register(src)) } -emit_vpmovqw_m128_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem128, src: ZMM) { emit_mr(instructions, .VPMOVQW, dst.mem, 16, Register(src)) } -inst_vpmovsqw_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.VPMOVSQW, Register(dst), Register(src)) } -inst_vpmovsqw_m32_xmm :: #force_inline proc "contextless" (dst: Mem32, src: XMM) -> Instruction { return inst_m_r(.VPMOVSQW, dst.mem, 4, Register(src)) } -inst_vpmovsqw_xmm_ymm :: #force_inline proc "contextless" (dst: XMM, src: YMM) -> Instruction { return inst_r_r(.VPMOVSQW, Register(dst), Register(src)) } -inst_vpmovsqw_m64_ymm :: #force_inline proc "contextless" (dst: Mem64, src: YMM) -> Instruction { return inst_m_r(.VPMOVSQW, dst.mem, 8, Register(src)) } -inst_vpmovsqw_xmm_zmm :: #force_inline proc "contextless" (dst: XMM, src: ZMM) -> Instruction { return inst_r_r(.VPMOVSQW, Register(dst), Register(src)) } -inst_vpmovsqw_m128_zmm :: #force_inline proc "contextless" (dst: Mem128, src: ZMM) -> Instruction { return inst_m_r(.VPMOVSQW, dst.mem, 16, Register(src)) } -emit_vpmovsqw_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .VPMOVSQW, Register(dst), Register(src)) } -emit_vpmovsqw_m32_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, src: XMM) { emit_mr(instructions, .VPMOVSQW, dst.mem, 4, Register(src)) } -emit_vpmovsqw_xmm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: YMM) { emit_rr(instructions, .VPMOVSQW, Register(dst), Register(src)) } -emit_vpmovsqw_m64_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, src: YMM) { emit_mr(instructions, .VPMOVSQW, dst.mem, 8, Register(src)) } -emit_vpmovsqw_xmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: ZMM) { emit_rr(instructions, .VPMOVSQW, Register(dst), Register(src)) } -emit_vpmovsqw_m128_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem128, src: ZMM) { emit_mr(instructions, .VPMOVSQW, dst.mem, 16, Register(src)) } -inst_vpmovusqw_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.VPMOVUSQW, Register(dst), Register(src)) } -inst_vpmovusqw_m32_xmm :: #force_inline proc "contextless" (dst: Mem32, src: XMM) -> Instruction { return inst_m_r(.VPMOVUSQW, dst.mem, 4, Register(src)) } -inst_vpmovusqw_xmm_ymm :: #force_inline proc "contextless" (dst: XMM, src: YMM) -> Instruction { return inst_r_r(.VPMOVUSQW, Register(dst), Register(src)) } -inst_vpmovusqw_m64_ymm :: #force_inline proc "contextless" (dst: Mem64, src: YMM) -> Instruction { return inst_m_r(.VPMOVUSQW, dst.mem, 8, Register(src)) } -inst_vpmovusqw_xmm_zmm :: #force_inline proc "contextless" (dst: XMM, src: ZMM) -> Instruction { return inst_r_r(.VPMOVUSQW, Register(dst), Register(src)) } -inst_vpmovusqw_m128_zmm :: #force_inline proc "contextless" (dst: Mem128, src: ZMM) -> Instruction { return inst_m_r(.VPMOVUSQW, dst.mem, 16, Register(src)) } -emit_vpmovusqw_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .VPMOVUSQW, Register(dst), Register(src)) } -emit_vpmovusqw_m32_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, src: XMM) { emit_mr(instructions, .VPMOVUSQW, dst.mem, 4, Register(src)) } -emit_vpmovusqw_xmm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: YMM) { emit_rr(instructions, .VPMOVUSQW, Register(dst), Register(src)) } -emit_vpmovusqw_m64_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, src: YMM) { emit_mr(instructions, .VPMOVUSQW, dst.mem, 8, Register(src)) } -emit_vpmovusqw_xmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: ZMM) { emit_rr(instructions, .VPMOVUSQW, Register(dst), Register(src)) } -emit_vpmovusqw_m128_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem128, src: ZMM) { emit_mr(instructions, .VPMOVUSQW, dst.mem, 16, Register(src)) } -inst_vpmovqd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.VPMOVQD, Register(dst), Register(src)) } -inst_vpmovqd_m64_xmm :: #force_inline proc "contextless" (dst: Mem64, src: XMM) -> Instruction { return inst_m_r(.VPMOVQD, dst.mem, 8, Register(src)) } -inst_vpmovqd_xmm_ymm :: #force_inline proc "contextless" (dst: XMM, src: YMM) -> Instruction { return inst_r_r(.VPMOVQD, Register(dst), Register(src)) } -inst_vpmovqd_m128_ymm :: #force_inline proc "contextless" (dst: Mem128, src: YMM) -> Instruction { return inst_m_r(.VPMOVQD, dst.mem, 16, Register(src)) } -inst_vpmovqd_ymm_zmm :: #force_inline proc "contextless" (dst: YMM, src: ZMM) -> Instruction { return inst_r_r(.VPMOVQD, Register(dst), Register(src)) } -inst_vpmovqd_m256_zmm :: #force_inline proc "contextless" (dst: Mem256, src: ZMM) -> Instruction { return inst_m_r(.VPMOVQD, dst.mem, 32, Register(src)) } -emit_vpmovqd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .VPMOVQD, Register(dst), Register(src)) } -emit_vpmovqd_m64_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, src: XMM) { emit_mr(instructions, .VPMOVQD, dst.mem, 8, Register(src)) } -emit_vpmovqd_xmm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: YMM) { emit_rr(instructions, .VPMOVQD, Register(dst), Register(src)) } -emit_vpmovqd_m128_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem128, src: YMM) { emit_mr(instructions, .VPMOVQD, dst.mem, 16, Register(src)) } -emit_vpmovqd_ymm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: ZMM) { emit_rr(instructions, .VPMOVQD, Register(dst), Register(src)) } -emit_vpmovqd_m256_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem256, src: ZMM) { emit_mr(instructions, .VPMOVQD, dst.mem, 32, Register(src)) } -inst_vpmovsqd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.VPMOVSQD, Register(dst), Register(src)) } -inst_vpmovsqd_m64_xmm :: #force_inline proc "contextless" (dst: Mem64, src: XMM) -> Instruction { return inst_m_r(.VPMOVSQD, dst.mem, 8, Register(src)) } -inst_vpmovsqd_xmm_ymm :: #force_inline proc "contextless" (dst: XMM, src: YMM) -> Instruction { return inst_r_r(.VPMOVSQD, Register(dst), Register(src)) } -inst_vpmovsqd_m128_ymm :: #force_inline proc "contextless" (dst: Mem128, src: YMM) -> Instruction { return inst_m_r(.VPMOVSQD, dst.mem, 16, Register(src)) } -inst_vpmovsqd_ymm_zmm :: #force_inline proc "contextless" (dst: YMM, src: ZMM) -> Instruction { return inst_r_r(.VPMOVSQD, Register(dst), Register(src)) } -inst_vpmovsqd_m256_zmm :: #force_inline proc "contextless" (dst: Mem256, src: ZMM) -> Instruction { return inst_m_r(.VPMOVSQD, dst.mem, 32, Register(src)) } -emit_vpmovsqd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .VPMOVSQD, Register(dst), Register(src)) } -emit_vpmovsqd_m64_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, src: XMM) { emit_mr(instructions, .VPMOVSQD, dst.mem, 8, Register(src)) } -emit_vpmovsqd_xmm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: YMM) { emit_rr(instructions, .VPMOVSQD, Register(dst), Register(src)) } -emit_vpmovsqd_m128_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem128, src: YMM) { emit_mr(instructions, .VPMOVSQD, dst.mem, 16, Register(src)) } -emit_vpmovsqd_ymm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: ZMM) { emit_rr(instructions, .VPMOVSQD, Register(dst), Register(src)) } -emit_vpmovsqd_m256_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem256, src: ZMM) { emit_mr(instructions, .VPMOVSQD, dst.mem, 32, Register(src)) } -inst_vpmovusqd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.VPMOVUSQD, Register(dst), Register(src)) } -inst_vpmovusqd_m64_xmm :: #force_inline proc "contextless" (dst: Mem64, src: XMM) -> Instruction { return inst_m_r(.VPMOVUSQD, dst.mem, 8, Register(src)) } -inst_vpmovusqd_xmm_ymm :: #force_inline proc "contextless" (dst: XMM, src: YMM) -> Instruction { return inst_r_r(.VPMOVUSQD, Register(dst), Register(src)) } -inst_vpmovusqd_m128_ymm :: #force_inline proc "contextless" (dst: Mem128, src: YMM) -> Instruction { return inst_m_r(.VPMOVUSQD, dst.mem, 16, Register(src)) } -inst_vpmovusqd_ymm_zmm :: #force_inline proc "contextless" (dst: YMM, src: ZMM) -> Instruction { return inst_r_r(.VPMOVUSQD, Register(dst), Register(src)) } -inst_vpmovusqd_m256_zmm :: #force_inline proc "contextless" (dst: Mem256, src: ZMM) -> Instruction { return inst_m_r(.VPMOVUSQD, dst.mem, 32, Register(src)) } -emit_vpmovusqd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .VPMOVUSQD, Register(dst), Register(src)) } -emit_vpmovusqd_m64_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, src: XMM) { emit_mr(instructions, .VPMOVUSQD, dst.mem, 8, Register(src)) } -emit_vpmovusqd_xmm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: YMM) { emit_rr(instructions, .VPMOVUSQD, Register(dst), Register(src)) } -emit_vpmovusqd_m128_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem128, src: YMM) { emit_mr(instructions, .VPMOVUSQD, dst.mem, 16, Register(src)) } -emit_vpmovusqd_ymm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: ZMM) { emit_rr(instructions, .VPMOVUSQD, Register(dst), Register(src)) } -emit_vpmovusqd_m256_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem256, src: ZMM) { emit_mr(instructions, .VPMOVUSQD, dst.mem, 32, Register(src)) } -inst_vpmovdb_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.VPMOVDB, Register(dst), Register(src)) } -inst_vpmovdb_m32_xmm :: #force_inline proc "contextless" (dst: Mem32, src: XMM) -> Instruction { return inst_m_r(.VPMOVDB, dst.mem, 4, Register(src)) } -inst_vpmovdb_xmm_ymm :: #force_inline proc "contextless" (dst: XMM, src: YMM) -> Instruction { return inst_r_r(.VPMOVDB, Register(dst), Register(src)) } -inst_vpmovdb_m64_ymm :: #force_inline proc "contextless" (dst: Mem64, src: YMM) -> Instruction { return inst_m_r(.VPMOVDB, dst.mem, 8, Register(src)) } -inst_vpmovdb_xmm_zmm :: #force_inline proc "contextless" (dst: XMM, src: ZMM) -> Instruction { return inst_r_r(.VPMOVDB, Register(dst), Register(src)) } -inst_vpmovdb_m128_zmm :: #force_inline proc "contextless" (dst: Mem128, src: ZMM) -> Instruction { return inst_m_r(.VPMOVDB, dst.mem, 16, Register(src)) } -emit_vpmovdb_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .VPMOVDB, Register(dst), Register(src)) } -emit_vpmovdb_m32_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, src: XMM) { emit_mr(instructions, .VPMOVDB, dst.mem, 4, Register(src)) } -emit_vpmovdb_xmm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: YMM) { emit_rr(instructions, .VPMOVDB, Register(dst), Register(src)) } -emit_vpmovdb_m64_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, src: YMM) { emit_mr(instructions, .VPMOVDB, dst.mem, 8, Register(src)) } -emit_vpmovdb_xmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: ZMM) { emit_rr(instructions, .VPMOVDB, Register(dst), Register(src)) } -emit_vpmovdb_m128_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem128, src: ZMM) { emit_mr(instructions, .VPMOVDB, dst.mem, 16, Register(src)) } -inst_vpmovsdb_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.VPMOVSDB, Register(dst), Register(src)) } -inst_vpmovsdb_m32_xmm :: #force_inline proc "contextless" (dst: Mem32, src: XMM) -> Instruction { return inst_m_r(.VPMOVSDB, dst.mem, 4, Register(src)) } -inst_vpmovsdb_xmm_ymm :: #force_inline proc "contextless" (dst: XMM, src: YMM) -> Instruction { return inst_r_r(.VPMOVSDB, Register(dst), Register(src)) } -inst_vpmovsdb_m64_ymm :: #force_inline proc "contextless" (dst: Mem64, src: YMM) -> Instruction { return inst_m_r(.VPMOVSDB, dst.mem, 8, Register(src)) } -inst_vpmovsdb_xmm_zmm :: #force_inline proc "contextless" (dst: XMM, src: ZMM) -> Instruction { return inst_r_r(.VPMOVSDB, Register(dst), Register(src)) } -inst_vpmovsdb_m128_zmm :: #force_inline proc "contextless" (dst: Mem128, src: ZMM) -> Instruction { return inst_m_r(.VPMOVSDB, dst.mem, 16, Register(src)) } -emit_vpmovsdb_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .VPMOVSDB, Register(dst), Register(src)) } -emit_vpmovsdb_m32_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, src: XMM) { emit_mr(instructions, .VPMOVSDB, dst.mem, 4, Register(src)) } -emit_vpmovsdb_xmm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: YMM) { emit_rr(instructions, .VPMOVSDB, Register(dst), Register(src)) } -emit_vpmovsdb_m64_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, src: YMM) { emit_mr(instructions, .VPMOVSDB, dst.mem, 8, Register(src)) } -emit_vpmovsdb_xmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: ZMM) { emit_rr(instructions, .VPMOVSDB, Register(dst), Register(src)) } -emit_vpmovsdb_m128_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem128, src: ZMM) { emit_mr(instructions, .VPMOVSDB, dst.mem, 16, Register(src)) } -inst_vpmovusdb_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.VPMOVUSDB, Register(dst), Register(src)) } -inst_vpmovusdb_m32_xmm :: #force_inline proc "contextless" (dst: Mem32, src: XMM) -> Instruction { return inst_m_r(.VPMOVUSDB, dst.mem, 4, Register(src)) } -inst_vpmovusdb_xmm_ymm :: #force_inline proc "contextless" (dst: XMM, src: YMM) -> Instruction { return inst_r_r(.VPMOVUSDB, Register(dst), Register(src)) } -inst_vpmovusdb_m64_ymm :: #force_inline proc "contextless" (dst: Mem64, src: YMM) -> Instruction { return inst_m_r(.VPMOVUSDB, dst.mem, 8, Register(src)) } -inst_vpmovusdb_xmm_zmm :: #force_inline proc "contextless" (dst: XMM, src: ZMM) -> Instruction { return inst_r_r(.VPMOVUSDB, Register(dst), Register(src)) } -inst_vpmovusdb_m128_zmm :: #force_inline proc "contextless" (dst: Mem128, src: ZMM) -> Instruction { return inst_m_r(.VPMOVUSDB, dst.mem, 16, Register(src)) } -emit_vpmovusdb_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .VPMOVUSDB, Register(dst), Register(src)) } -emit_vpmovusdb_m32_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, src: XMM) { emit_mr(instructions, .VPMOVUSDB, dst.mem, 4, Register(src)) } -emit_vpmovusdb_xmm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: YMM) { emit_rr(instructions, .VPMOVUSDB, Register(dst), Register(src)) } -emit_vpmovusdb_m64_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, src: YMM) { emit_mr(instructions, .VPMOVUSDB, dst.mem, 8, Register(src)) } -emit_vpmovusdb_xmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: ZMM) { emit_rr(instructions, .VPMOVUSDB, Register(dst), Register(src)) } -emit_vpmovusdb_m128_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem128, src: ZMM) { emit_mr(instructions, .VPMOVUSDB, dst.mem, 16, Register(src)) } -inst_vpmovdw_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.VPMOVDW, Register(dst), Register(src)) } -inst_vpmovdw_m64_xmm :: #force_inline proc "contextless" (dst: Mem64, src: XMM) -> Instruction { return inst_m_r(.VPMOVDW, dst.mem, 8, Register(src)) } -inst_vpmovdw_xmm_ymm :: #force_inline proc "contextless" (dst: XMM, src: YMM) -> Instruction { return inst_r_r(.VPMOVDW, Register(dst), Register(src)) } -inst_vpmovdw_m128_ymm :: #force_inline proc "contextless" (dst: Mem128, src: YMM) -> Instruction { return inst_m_r(.VPMOVDW, dst.mem, 16, Register(src)) } -inst_vpmovdw_ymm_zmm :: #force_inline proc "contextless" (dst: YMM, src: ZMM) -> Instruction { return inst_r_r(.VPMOVDW, Register(dst), Register(src)) } -inst_vpmovdw_m256_zmm :: #force_inline proc "contextless" (dst: Mem256, src: ZMM) -> Instruction { return inst_m_r(.VPMOVDW, dst.mem, 32, Register(src)) } -emit_vpmovdw_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .VPMOVDW, Register(dst), Register(src)) } -emit_vpmovdw_m64_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, src: XMM) { emit_mr(instructions, .VPMOVDW, dst.mem, 8, Register(src)) } -emit_vpmovdw_xmm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: YMM) { emit_rr(instructions, .VPMOVDW, Register(dst), Register(src)) } -emit_vpmovdw_m128_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem128, src: YMM) { emit_mr(instructions, .VPMOVDW, dst.mem, 16, Register(src)) } -emit_vpmovdw_ymm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: ZMM) { emit_rr(instructions, .VPMOVDW, Register(dst), Register(src)) } -emit_vpmovdw_m256_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem256, src: ZMM) { emit_mr(instructions, .VPMOVDW, dst.mem, 32, Register(src)) } -inst_vpmovsdw_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.VPMOVSDW, Register(dst), Register(src)) } -inst_vpmovsdw_m64_xmm :: #force_inline proc "contextless" (dst: Mem64, src: XMM) -> Instruction { return inst_m_r(.VPMOVSDW, dst.mem, 8, Register(src)) } -inst_vpmovsdw_xmm_ymm :: #force_inline proc "contextless" (dst: XMM, src: YMM) -> Instruction { return inst_r_r(.VPMOVSDW, Register(dst), Register(src)) } -inst_vpmovsdw_m128_ymm :: #force_inline proc "contextless" (dst: Mem128, src: YMM) -> Instruction { return inst_m_r(.VPMOVSDW, dst.mem, 16, Register(src)) } -inst_vpmovsdw_ymm_zmm :: #force_inline proc "contextless" (dst: YMM, src: ZMM) -> Instruction { return inst_r_r(.VPMOVSDW, Register(dst), Register(src)) } -inst_vpmovsdw_m256_zmm :: #force_inline proc "contextless" (dst: Mem256, src: ZMM) -> Instruction { return inst_m_r(.VPMOVSDW, dst.mem, 32, Register(src)) } -emit_vpmovsdw_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .VPMOVSDW, Register(dst), Register(src)) } -emit_vpmovsdw_m64_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, src: XMM) { emit_mr(instructions, .VPMOVSDW, dst.mem, 8, Register(src)) } -emit_vpmovsdw_xmm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: YMM) { emit_rr(instructions, .VPMOVSDW, Register(dst), Register(src)) } -emit_vpmovsdw_m128_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem128, src: YMM) { emit_mr(instructions, .VPMOVSDW, dst.mem, 16, Register(src)) } -emit_vpmovsdw_ymm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: ZMM) { emit_rr(instructions, .VPMOVSDW, Register(dst), Register(src)) } -emit_vpmovsdw_m256_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem256, src: ZMM) { emit_mr(instructions, .VPMOVSDW, dst.mem, 32, Register(src)) } -inst_vpmovusdw_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.VPMOVUSDW, Register(dst), Register(src)) } -inst_vpmovusdw_m64_xmm :: #force_inline proc "contextless" (dst: Mem64, src: XMM) -> Instruction { return inst_m_r(.VPMOVUSDW, dst.mem, 8, Register(src)) } -inst_vpmovusdw_xmm_ymm :: #force_inline proc "contextless" (dst: XMM, src: YMM) -> Instruction { return inst_r_r(.VPMOVUSDW, Register(dst), Register(src)) } -inst_vpmovusdw_m128_ymm :: #force_inline proc "contextless" (dst: Mem128, src: YMM) -> Instruction { return inst_m_r(.VPMOVUSDW, dst.mem, 16, Register(src)) } -inst_vpmovusdw_ymm_zmm :: #force_inline proc "contextless" (dst: YMM, src: ZMM) -> Instruction { return inst_r_r(.VPMOVUSDW, Register(dst), Register(src)) } -inst_vpmovusdw_m256_zmm :: #force_inline proc "contextless" (dst: Mem256, src: ZMM) -> Instruction { return inst_m_r(.VPMOVUSDW, dst.mem, 32, Register(src)) } -emit_vpmovusdw_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .VPMOVUSDW, Register(dst), Register(src)) } -emit_vpmovusdw_m64_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, src: XMM) { emit_mr(instructions, .VPMOVUSDW, dst.mem, 8, Register(src)) } -emit_vpmovusdw_xmm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: YMM) { emit_rr(instructions, .VPMOVUSDW, Register(dst), Register(src)) } -emit_vpmovusdw_m128_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem128, src: YMM) { emit_mr(instructions, .VPMOVUSDW, dst.mem, 16, Register(src)) } -emit_vpmovusdw_ymm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: ZMM) { emit_rr(instructions, .VPMOVUSDW, Register(dst), Register(src)) } -emit_vpmovusdw_m256_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem256, src: ZMM) { emit_mr(instructions, .VPMOVUSDW, dst.mem, 32, Register(src)) } -inst_vpmovwb_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.VPMOVWB, Register(dst), Register(src)) } -inst_vpmovwb_m64_xmm :: #force_inline proc "contextless" (dst: Mem64, src: XMM) -> Instruction { return inst_m_r(.VPMOVWB, dst.mem, 8, Register(src)) } -inst_vpmovwb_xmm_ymm :: #force_inline proc "contextless" (dst: XMM, src: YMM) -> Instruction { return inst_r_r(.VPMOVWB, Register(dst), Register(src)) } -inst_vpmovwb_m128_ymm :: #force_inline proc "contextless" (dst: Mem128, src: YMM) -> Instruction { return inst_m_r(.VPMOVWB, dst.mem, 16, Register(src)) } -inst_vpmovwb_ymm_zmm :: #force_inline proc "contextless" (dst: YMM, src: ZMM) -> Instruction { return inst_r_r(.VPMOVWB, Register(dst), Register(src)) } -inst_vpmovwb_m256_zmm :: #force_inline proc "contextless" (dst: Mem256, src: ZMM) -> Instruction { return inst_m_r(.VPMOVWB, dst.mem, 32, Register(src)) } -emit_vpmovwb_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .VPMOVWB, Register(dst), Register(src)) } -emit_vpmovwb_m64_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, src: XMM) { emit_mr(instructions, .VPMOVWB, dst.mem, 8, Register(src)) } -emit_vpmovwb_xmm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: YMM) { emit_rr(instructions, .VPMOVWB, Register(dst), Register(src)) } -emit_vpmovwb_m128_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem128, src: YMM) { emit_mr(instructions, .VPMOVWB, dst.mem, 16, Register(src)) } -emit_vpmovwb_ymm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: ZMM) { emit_rr(instructions, .VPMOVWB, Register(dst), Register(src)) } -emit_vpmovwb_m256_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem256, src: ZMM) { emit_mr(instructions, .VPMOVWB, dst.mem, 32, Register(src)) } -inst_vpmovswb_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.VPMOVSWB, Register(dst), Register(src)) } -inst_vpmovswb_m64_xmm :: #force_inline proc "contextless" (dst: Mem64, src: XMM) -> Instruction { return inst_m_r(.VPMOVSWB, dst.mem, 8, Register(src)) } -inst_vpmovswb_xmm_ymm :: #force_inline proc "contextless" (dst: XMM, src: YMM) -> Instruction { return inst_r_r(.VPMOVSWB, Register(dst), Register(src)) } -inst_vpmovswb_m128_ymm :: #force_inline proc "contextless" (dst: Mem128, src: YMM) -> Instruction { return inst_m_r(.VPMOVSWB, dst.mem, 16, Register(src)) } -inst_vpmovswb_ymm_zmm :: #force_inline proc "contextless" (dst: YMM, src: ZMM) -> Instruction { return inst_r_r(.VPMOVSWB, Register(dst), Register(src)) } -inst_vpmovswb_m256_zmm :: #force_inline proc "contextless" (dst: Mem256, src: ZMM) -> Instruction { return inst_m_r(.VPMOVSWB, dst.mem, 32, Register(src)) } -emit_vpmovswb_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .VPMOVSWB, Register(dst), Register(src)) } -emit_vpmovswb_m64_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, src: XMM) { emit_mr(instructions, .VPMOVSWB, dst.mem, 8, Register(src)) } -emit_vpmovswb_xmm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: YMM) { emit_rr(instructions, .VPMOVSWB, Register(dst), Register(src)) } -emit_vpmovswb_m128_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem128, src: YMM) { emit_mr(instructions, .VPMOVSWB, dst.mem, 16, Register(src)) } -emit_vpmovswb_ymm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: ZMM) { emit_rr(instructions, .VPMOVSWB, Register(dst), Register(src)) } -emit_vpmovswb_m256_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem256, src: ZMM) { emit_mr(instructions, .VPMOVSWB, dst.mem, 32, Register(src)) } -inst_vpmovuswb_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.VPMOVUSWB, Register(dst), Register(src)) } -inst_vpmovuswb_m64_xmm :: #force_inline proc "contextless" (dst: Mem64, src: XMM) -> Instruction { return inst_m_r(.VPMOVUSWB, dst.mem, 8, Register(src)) } -inst_vpmovuswb_xmm_ymm :: #force_inline proc "contextless" (dst: XMM, src: YMM) -> Instruction { return inst_r_r(.VPMOVUSWB, Register(dst), Register(src)) } -inst_vpmovuswb_m128_ymm :: #force_inline proc "contextless" (dst: Mem128, src: YMM) -> Instruction { return inst_m_r(.VPMOVUSWB, dst.mem, 16, Register(src)) } -inst_vpmovuswb_ymm_zmm :: #force_inline proc "contextless" (dst: YMM, src: ZMM) -> Instruction { return inst_r_r(.VPMOVUSWB, Register(dst), Register(src)) } -inst_vpmovuswb_m256_zmm :: #force_inline proc "contextless" (dst: Mem256, src: ZMM) -> Instruction { return inst_m_r(.VPMOVUSWB, dst.mem, 32, Register(src)) } -emit_vpmovuswb_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .VPMOVUSWB, Register(dst), Register(src)) } -emit_vpmovuswb_m64_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, src: XMM) { emit_mr(instructions, .VPMOVUSWB, dst.mem, 8, Register(src)) } -emit_vpmovuswb_xmm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: YMM) { emit_rr(instructions, .VPMOVUSWB, Register(dst), Register(src)) } -emit_vpmovuswb_m128_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem128, src: YMM) { emit_mr(instructions, .VPMOVUSWB, dst.mem, 16, Register(src)) } -emit_vpmovuswb_ymm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: ZMM) { emit_rr(instructions, .VPMOVUSWB, Register(dst), Register(src)) } -emit_vpmovuswb_m256_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem256, src: ZMM) { emit_mr(instructions, .VPMOVUSWB, dst.mem, 32, Register(src)) } -inst_vprold_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return inst_r_r_i(.VPROLD, Register(dst), Register(src), i64(imm), 1) } -inst_vprold_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem128, imm: i8) -> Instruction { return inst_r_m_i(.VPROLD, Register(dst), src.mem, 16, i64(imm), 1) } -inst_vprold_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, imm: i8) -> Instruction { return inst_r_r_i(.VPROLD, Register(dst), Register(src), i64(imm), 1) } -inst_vprold_ymm_m256_imm8 :: #force_inline proc "contextless" (dst: YMM, src: Mem256, imm: i8) -> Instruction { return inst_r_m_i(.VPROLD, Register(dst), src.mem, 32, i64(imm), 1) } -inst_vprold_zmm_zmm_imm8 :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, imm: i8) -> Instruction { return inst_r_r_i(.VPROLD, Register(dst), Register(src), i64(imm), 1) } -inst_vprold_zmm_m512_imm8 :: #force_inline proc "contextless" (dst: ZMM, src: Mem512, imm: i8) -> Instruction { return inst_r_m_i(.VPROLD, Register(dst), src.mem, 64, i64(imm), 1) } -emit_vprold_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, imm: i8) { emit_rri(instructions, .VPROLD, Register(dst), Register(src), i64(imm), 1) } -emit_vprold_xmm_m128_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128, imm: i8) { emit_rmi(instructions, .VPROLD, Register(dst), src.mem, 16, i64(imm), 1) } -emit_vprold_ymm_ymm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, imm: i8) { emit_rri(instructions, .VPROLD, Register(dst), Register(src), i64(imm), 1) } -emit_vprold_ymm_m256_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem256, imm: i8) { emit_rmi(instructions, .VPROLD, Register(dst), src.mem, 32, i64(imm), 1) } -emit_vprold_zmm_zmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, imm: i8) { emit_rri(instructions, .VPROLD, Register(dst), Register(src), i64(imm), 1) } -emit_vprold_zmm_m512_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: Mem512, imm: i8) { emit_rmi(instructions, .VPROLD, Register(dst), src.mem, 64, i64(imm), 1) } -inst_vprolq_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return inst_r_r_i(.VPROLQ, Register(dst), Register(src), i64(imm), 1) } -inst_vprolq_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem128, imm: i8) -> Instruction { return inst_r_m_i(.VPROLQ, Register(dst), src.mem, 16, i64(imm), 1) } -inst_vprolq_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, imm: i8) -> Instruction { return inst_r_r_i(.VPROLQ, Register(dst), Register(src), i64(imm), 1) } -inst_vprolq_ymm_m256_imm8 :: #force_inline proc "contextless" (dst: YMM, src: Mem256, imm: i8) -> Instruction { return inst_r_m_i(.VPROLQ, Register(dst), src.mem, 32, i64(imm), 1) } -inst_vprolq_zmm_zmm_imm8 :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, imm: i8) -> Instruction { return inst_r_r_i(.VPROLQ, Register(dst), Register(src), i64(imm), 1) } -inst_vprolq_zmm_m512_imm8 :: #force_inline proc "contextless" (dst: ZMM, src: Mem512, imm: i8) -> Instruction { return inst_r_m_i(.VPROLQ, Register(dst), src.mem, 64, i64(imm), 1) } -emit_vprolq_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, imm: i8) { emit_rri(instructions, .VPROLQ, Register(dst), Register(src), i64(imm), 1) } -emit_vprolq_xmm_m128_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128, imm: i8) { emit_rmi(instructions, .VPROLQ, Register(dst), src.mem, 16, i64(imm), 1) } -emit_vprolq_ymm_ymm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, imm: i8) { emit_rri(instructions, .VPROLQ, Register(dst), Register(src), i64(imm), 1) } -emit_vprolq_ymm_m256_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem256, imm: i8) { emit_rmi(instructions, .VPROLQ, Register(dst), src.mem, 32, i64(imm), 1) } -emit_vprolq_zmm_zmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, imm: i8) { emit_rri(instructions, .VPROLQ, Register(dst), Register(src), i64(imm), 1) } -emit_vprolq_zmm_m512_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: Mem512, imm: i8) { emit_rmi(instructions, .VPROLQ, Register(dst), src.mem, 64, i64(imm), 1) } -inst_vprolvd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VPROLVD, Register(dst), Register(src), Register(src2)) } -inst_vprolvd_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VPROLVD, Register(dst), Register(src), src2.mem, 16) } -inst_vprolvd_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VPROLVD, Register(dst), Register(src), Register(src2)) } -inst_vprolvd_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VPROLVD, Register(dst), Register(src), src2.mem, 32) } -inst_vprolvd_zmm_zmm_zmm :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: ZMM) -> Instruction { return inst_r_r_r(.VPROLVD, Register(dst), Register(src), Register(src2)) } -inst_vprolvd_zmm_zmm_m512 :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: Mem512) -> Instruction { return inst_r_r_m(.VPROLVD, Register(dst), Register(src), src2.mem, 64) } -emit_vprolvd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VPROLVD, Register(dst), Register(src), Register(src2)) } -emit_vprolvd_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VPROLVD, Register(dst), Register(src), src2.mem, 16) } -emit_vprolvd_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VPROLVD, Register(dst), Register(src), Register(src2)) } -emit_vprolvd_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VPROLVD, Register(dst), Register(src), src2.mem, 32) } -emit_vprolvd_zmm_zmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: ZMM) { emit_rrr(instructions, .VPROLVD, Register(dst), Register(src), Register(src2)) } -emit_vprolvd_zmm_zmm_m512 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: Mem512) { emit_rrm(instructions, .VPROLVD, Register(dst), Register(src), src2.mem, 64) } -inst_vprolvq_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VPROLVQ, Register(dst), Register(src), Register(src2)) } -inst_vprolvq_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VPROLVQ, Register(dst), Register(src), src2.mem, 16) } -inst_vprolvq_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VPROLVQ, Register(dst), Register(src), Register(src2)) } -inst_vprolvq_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VPROLVQ, Register(dst), Register(src), src2.mem, 32) } -inst_vprolvq_zmm_zmm_zmm :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: ZMM) -> Instruction { return inst_r_r_r(.VPROLVQ, Register(dst), Register(src), Register(src2)) } -inst_vprolvq_zmm_zmm_m512 :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: Mem512) -> Instruction { return inst_r_r_m(.VPROLVQ, Register(dst), Register(src), src2.mem, 64) } -emit_vprolvq_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VPROLVQ, Register(dst), Register(src), Register(src2)) } -emit_vprolvq_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VPROLVQ, Register(dst), Register(src), src2.mem, 16) } -emit_vprolvq_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VPROLVQ, Register(dst), Register(src), Register(src2)) } -emit_vprolvq_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VPROLVQ, Register(dst), Register(src), src2.mem, 32) } -emit_vprolvq_zmm_zmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: ZMM) { emit_rrr(instructions, .VPROLVQ, Register(dst), Register(src), Register(src2)) } -emit_vprolvq_zmm_zmm_m512 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: Mem512) { emit_rrm(instructions, .VPROLVQ, Register(dst), Register(src), src2.mem, 64) } -inst_vprord_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return inst_r_r_i(.VPRORD, Register(dst), Register(src), i64(imm), 1) } -inst_vprord_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem128, imm: i8) -> Instruction { return inst_r_m_i(.VPRORD, Register(dst), src.mem, 16, i64(imm), 1) } -inst_vprord_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, imm: i8) -> Instruction { return inst_r_r_i(.VPRORD, Register(dst), Register(src), i64(imm), 1) } -inst_vprord_ymm_m256_imm8 :: #force_inline proc "contextless" (dst: YMM, src: Mem256, imm: i8) -> Instruction { return inst_r_m_i(.VPRORD, Register(dst), src.mem, 32, i64(imm), 1) } -inst_vprord_zmm_zmm_imm8 :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, imm: i8) -> Instruction { return inst_r_r_i(.VPRORD, Register(dst), Register(src), i64(imm), 1) } -inst_vprord_zmm_m512_imm8 :: #force_inline proc "contextless" (dst: ZMM, src: Mem512, imm: i8) -> Instruction { return inst_r_m_i(.VPRORD, Register(dst), src.mem, 64, i64(imm), 1) } -emit_vprord_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, imm: i8) { emit_rri(instructions, .VPRORD, Register(dst), Register(src), i64(imm), 1) } -emit_vprord_xmm_m128_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128, imm: i8) { emit_rmi(instructions, .VPRORD, Register(dst), src.mem, 16, i64(imm), 1) } -emit_vprord_ymm_ymm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, imm: i8) { emit_rri(instructions, .VPRORD, Register(dst), Register(src), i64(imm), 1) } -emit_vprord_ymm_m256_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem256, imm: i8) { emit_rmi(instructions, .VPRORD, Register(dst), src.mem, 32, i64(imm), 1) } -emit_vprord_zmm_zmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, imm: i8) { emit_rri(instructions, .VPRORD, Register(dst), Register(src), i64(imm), 1) } -emit_vprord_zmm_m512_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: Mem512, imm: i8) { emit_rmi(instructions, .VPRORD, Register(dst), src.mem, 64, i64(imm), 1) } -inst_vprorq_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return inst_r_r_i(.VPRORQ, Register(dst), Register(src), i64(imm), 1) } -inst_vprorq_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem128, imm: i8) -> Instruction { return inst_r_m_i(.VPRORQ, Register(dst), src.mem, 16, i64(imm), 1) } -inst_vprorq_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, imm: i8) -> Instruction { return inst_r_r_i(.VPRORQ, Register(dst), Register(src), i64(imm), 1) } -inst_vprorq_ymm_m256_imm8 :: #force_inline proc "contextless" (dst: YMM, src: Mem256, imm: i8) -> Instruction { return inst_r_m_i(.VPRORQ, Register(dst), src.mem, 32, i64(imm), 1) } -inst_vprorq_zmm_zmm_imm8 :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, imm: i8) -> Instruction { return inst_r_r_i(.VPRORQ, Register(dst), Register(src), i64(imm), 1) } -inst_vprorq_zmm_m512_imm8 :: #force_inline proc "contextless" (dst: ZMM, src: Mem512, imm: i8) -> Instruction { return inst_r_m_i(.VPRORQ, Register(dst), src.mem, 64, i64(imm), 1) } -emit_vprorq_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, imm: i8) { emit_rri(instructions, .VPRORQ, Register(dst), Register(src), i64(imm), 1) } -emit_vprorq_xmm_m128_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128, imm: i8) { emit_rmi(instructions, .VPRORQ, Register(dst), src.mem, 16, i64(imm), 1) } -emit_vprorq_ymm_ymm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, imm: i8) { emit_rri(instructions, .VPRORQ, Register(dst), Register(src), i64(imm), 1) } -emit_vprorq_ymm_m256_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem256, imm: i8) { emit_rmi(instructions, .VPRORQ, Register(dst), src.mem, 32, i64(imm), 1) } -emit_vprorq_zmm_zmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, imm: i8) { emit_rri(instructions, .VPRORQ, Register(dst), Register(src), i64(imm), 1) } -emit_vprorq_zmm_m512_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: Mem512, imm: i8) { emit_rmi(instructions, .VPRORQ, Register(dst), src.mem, 64, i64(imm), 1) } -inst_vprorvd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VPRORVD, Register(dst), Register(src), Register(src2)) } -inst_vprorvd_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VPRORVD, Register(dst), Register(src), src2.mem, 16) } -inst_vprorvd_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VPRORVD, Register(dst), Register(src), Register(src2)) } -inst_vprorvd_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VPRORVD, Register(dst), Register(src), src2.mem, 32) } -inst_vprorvd_zmm_zmm_zmm :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: ZMM) -> Instruction { return inst_r_r_r(.VPRORVD, Register(dst), Register(src), Register(src2)) } -inst_vprorvd_zmm_zmm_m512 :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: Mem512) -> Instruction { return inst_r_r_m(.VPRORVD, Register(dst), Register(src), src2.mem, 64) } -emit_vprorvd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VPRORVD, Register(dst), Register(src), Register(src2)) } -emit_vprorvd_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VPRORVD, Register(dst), Register(src), src2.mem, 16) } -emit_vprorvd_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VPRORVD, Register(dst), Register(src), Register(src2)) } -emit_vprorvd_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VPRORVD, Register(dst), Register(src), src2.mem, 32) } -emit_vprorvd_zmm_zmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: ZMM) { emit_rrr(instructions, .VPRORVD, Register(dst), Register(src), Register(src2)) } -emit_vprorvd_zmm_zmm_m512 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: Mem512) { emit_rrm(instructions, .VPRORVD, Register(dst), Register(src), src2.mem, 64) } -inst_vprorvq_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VPRORVQ, Register(dst), Register(src), Register(src2)) } -inst_vprorvq_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VPRORVQ, Register(dst), Register(src), src2.mem, 16) } -inst_vprorvq_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VPRORVQ, Register(dst), Register(src), Register(src2)) } -inst_vprorvq_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VPRORVQ, Register(dst), Register(src), src2.mem, 32) } -inst_vprorvq_zmm_zmm_zmm :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: ZMM) -> Instruction { return inst_r_r_r(.VPRORVQ, Register(dst), Register(src), Register(src2)) } -inst_vprorvq_zmm_zmm_m512 :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: Mem512) -> Instruction { return inst_r_r_m(.VPRORVQ, Register(dst), Register(src), src2.mem, 64) } -emit_vprorvq_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VPRORVQ, Register(dst), Register(src), Register(src2)) } -emit_vprorvq_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VPRORVQ, Register(dst), Register(src), src2.mem, 16) } -emit_vprorvq_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VPRORVQ, Register(dst), Register(src), Register(src2)) } -emit_vprorvq_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VPRORVQ, Register(dst), Register(src), src2.mem, 32) } -emit_vprorvq_zmm_zmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: ZMM) { emit_rrr(instructions, .VPRORVQ, Register(dst), Register(src), Register(src2)) } -emit_vprorvq_zmm_zmm_m512 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: Mem512) { emit_rrm(instructions, .VPRORVQ, Register(dst), Register(src), src2.mem, 64) } -inst_vpscatterdd_m_xmm :: #force_inline proc "contextless" (dst: Memory, src: XMM) -> Instruction { return inst_m_r(.VPSCATTERDD, dst, 0, Register(src)) } -inst_vpscatterdd_m_ymm :: #force_inline proc "contextless" (dst: Memory, src: YMM) -> Instruction { return inst_m_r(.VPSCATTERDD, dst, 0, Register(src)) } -inst_vpscatterdd_m_zmm :: #force_inline proc "contextless" (dst: Memory, src: ZMM) -> Instruction { return inst_m_r(.VPSCATTERDD, dst, 0, Register(src)) } -emit_vpscatterdd_m_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Memory, src: XMM) { emit_mr(instructions, .VPSCATTERDD, dst, 0, Register(src)) } -emit_vpscatterdd_m_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Memory, src: YMM) { emit_mr(instructions, .VPSCATTERDD, dst, 0, Register(src)) } -emit_vpscatterdd_m_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Memory, src: ZMM) { emit_mr(instructions, .VPSCATTERDD, dst, 0, Register(src)) } -inst_vpscatterdq_m_xmm :: #force_inline proc "contextless" (dst: Memory, src: XMM) -> Instruction { return inst_m_r(.VPSCATTERDQ, dst, 0, Register(src)) } -inst_vpscatterdq_m_ymm :: #force_inline proc "contextless" (dst: Memory, src: YMM) -> Instruction { return inst_m_r(.VPSCATTERDQ, dst, 0, Register(src)) } -inst_vpscatterdq_m_zmm :: #force_inline proc "contextless" (dst: Memory, src: ZMM) -> Instruction { return inst_m_r(.VPSCATTERDQ, dst, 0, Register(src)) } -emit_vpscatterdq_m_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Memory, src: XMM) { emit_mr(instructions, .VPSCATTERDQ, dst, 0, Register(src)) } -emit_vpscatterdq_m_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Memory, src: YMM) { emit_mr(instructions, .VPSCATTERDQ, dst, 0, Register(src)) } -emit_vpscatterdq_m_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Memory, src: ZMM) { emit_mr(instructions, .VPSCATTERDQ, dst, 0, Register(src)) } -inst_vpscatterqd_m_xmm :: #force_inline proc "contextless" (dst: Memory, src: XMM) -> Instruction { return inst_m_r(.VPSCATTERQD, dst, 0, Register(src)) } -inst_vpscatterqd_m_ymm :: #force_inline proc "contextless" (dst: Memory, src: YMM) -> Instruction { return inst_m_r(.VPSCATTERQD, dst, 0, Register(src)) } -emit_vpscatterqd_m_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Memory, src: XMM) { emit_mr(instructions, .VPSCATTERQD, dst, 0, Register(src)) } -emit_vpscatterqd_m_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Memory, src: YMM) { emit_mr(instructions, .VPSCATTERQD, dst, 0, Register(src)) } -inst_vpscatterqq_m_xmm :: #force_inline proc "contextless" (dst: Memory, src: XMM) -> Instruction { return inst_m_r(.VPSCATTERQQ, dst, 0, Register(src)) } -inst_vpscatterqq_m_ymm :: #force_inline proc "contextless" (dst: Memory, src: YMM) -> Instruction { return inst_m_r(.VPSCATTERQQ, dst, 0, Register(src)) } -inst_vpscatterqq_m_zmm :: #force_inline proc "contextless" (dst: Memory, src: ZMM) -> Instruction { return inst_m_r(.VPSCATTERQQ, dst, 0, Register(src)) } -emit_vpscatterqq_m_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Memory, src: XMM) { emit_mr(instructions, .VPSCATTERQQ, dst, 0, Register(src)) } -emit_vpscatterqq_m_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Memory, src: YMM) { emit_mr(instructions, .VPSCATTERQQ, dst, 0, Register(src)) } -emit_vpscatterqq_m_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Memory, src: ZMM) { emit_mr(instructions, .VPSCATTERQQ, dst, 0, Register(src)) } -inst_vscatterdps_m_xmm :: #force_inline proc "contextless" (dst: Memory, src: XMM) -> Instruction { return inst_m_r(.VSCATTERDPS, dst, 0, Register(src)) } -inst_vscatterdps_m_ymm :: #force_inline proc "contextless" (dst: Memory, src: YMM) -> Instruction { return inst_m_r(.VSCATTERDPS, dst, 0, Register(src)) } -inst_vscatterdps_m_zmm :: #force_inline proc "contextless" (dst: Memory, src: ZMM) -> Instruction { return inst_m_r(.VSCATTERDPS, dst, 0, Register(src)) } -emit_vscatterdps_m_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Memory, src: XMM) { emit_mr(instructions, .VSCATTERDPS, dst, 0, Register(src)) } -emit_vscatterdps_m_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Memory, src: YMM) { emit_mr(instructions, .VSCATTERDPS, dst, 0, Register(src)) } -emit_vscatterdps_m_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Memory, src: ZMM) { emit_mr(instructions, .VSCATTERDPS, dst, 0, Register(src)) } -inst_vscatterdpd_m_xmm :: #force_inline proc "contextless" (dst: Memory, src: XMM) -> Instruction { return inst_m_r(.VSCATTERDPD, dst, 0, Register(src)) } -inst_vscatterdpd_m_ymm :: #force_inline proc "contextless" (dst: Memory, src: YMM) -> Instruction { return inst_m_r(.VSCATTERDPD, dst, 0, Register(src)) } -inst_vscatterdpd_m_zmm :: #force_inline proc "contextless" (dst: Memory, src: ZMM) -> Instruction { return inst_m_r(.VSCATTERDPD, dst, 0, Register(src)) } -emit_vscatterdpd_m_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Memory, src: XMM) { emit_mr(instructions, .VSCATTERDPD, dst, 0, Register(src)) } -emit_vscatterdpd_m_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Memory, src: YMM) { emit_mr(instructions, .VSCATTERDPD, dst, 0, Register(src)) } -emit_vscatterdpd_m_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Memory, src: ZMM) { emit_mr(instructions, .VSCATTERDPD, dst, 0, Register(src)) } -inst_vscatterqps_m_xmm :: #force_inline proc "contextless" (dst: Memory, src: XMM) -> Instruction { return inst_m_r(.VSCATTERQPS, dst, 0, Register(src)) } -inst_vscatterqps_m_ymm :: #force_inline proc "contextless" (dst: Memory, src: YMM) -> Instruction { return inst_m_r(.VSCATTERQPS, dst, 0, Register(src)) } -emit_vscatterqps_m_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Memory, src: XMM) { emit_mr(instructions, .VSCATTERQPS, dst, 0, Register(src)) } -emit_vscatterqps_m_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Memory, src: YMM) { emit_mr(instructions, .VSCATTERQPS, dst, 0, Register(src)) } -inst_vscatterqpd_m_xmm :: #force_inline proc "contextless" (dst: Memory, src: XMM) -> Instruction { return inst_m_r(.VSCATTERQPD, dst, 0, Register(src)) } -inst_vscatterqpd_m_ymm :: #force_inline proc "contextless" (dst: Memory, src: YMM) -> Instruction { return inst_m_r(.VSCATTERQPD, dst, 0, Register(src)) } -inst_vscatterqpd_m_zmm :: #force_inline proc "contextless" (dst: Memory, src: ZMM) -> Instruction { return inst_m_r(.VSCATTERQPD, dst, 0, Register(src)) } -emit_vscatterqpd_m_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Memory, src: XMM) { emit_mr(instructions, .VSCATTERQPD, dst, 0, Register(src)) } -emit_vscatterqpd_m_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Memory, src: YMM) { emit_mr(instructions, .VSCATTERQPD, dst, 0, Register(src)) } -emit_vscatterqpd_m_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Memory, src: ZMM) { emit_mr(instructions, .VSCATTERQPD, dst, 0, Register(src)) } -inst_vpsravq_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VPSRAVQ, Register(dst), Register(src), Register(src2)) } -inst_vpsravq_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VPSRAVQ, Register(dst), Register(src), src2.mem, 16) } -inst_vpsravq_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VPSRAVQ, Register(dst), Register(src), Register(src2)) } -inst_vpsravq_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VPSRAVQ, Register(dst), Register(src), src2.mem, 32) } -inst_vpsravq_zmm_zmm_zmm :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: ZMM) -> Instruction { return inst_r_r_r(.VPSRAVQ, Register(dst), Register(src), Register(src2)) } -inst_vpsravq_zmm_zmm_m512 :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: Mem512) -> Instruction { return inst_r_r_m(.VPSRAVQ, Register(dst), Register(src), src2.mem, 64) } -emit_vpsravq_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VPSRAVQ, Register(dst), Register(src), Register(src2)) } -emit_vpsravq_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VPSRAVQ, Register(dst), Register(src), src2.mem, 16) } -emit_vpsravq_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VPSRAVQ, Register(dst), Register(src), Register(src2)) } -emit_vpsravq_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VPSRAVQ, Register(dst), Register(src), src2.mem, 32) } -emit_vpsravq_zmm_zmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: ZMM) { emit_rrr(instructions, .VPSRAVQ, Register(dst), Register(src), Register(src2)) } -emit_vpsravq_zmm_zmm_m512 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: Mem512) { emit_rrm(instructions, .VPSRAVQ, Register(dst), Register(src), src2.mem, 64) } -inst_vpsravw_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VPSRAVW, Register(dst), Register(src), Register(src2)) } -inst_vpsravw_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VPSRAVW, Register(dst), Register(src), src2.mem, 16) } -inst_vpsravw_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VPSRAVW, Register(dst), Register(src), Register(src2)) } -inst_vpsravw_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VPSRAVW, Register(dst), Register(src), src2.mem, 32) } -inst_vpsravw_zmm_zmm_zmm :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: ZMM) -> Instruction { return inst_r_r_r(.VPSRAVW, Register(dst), Register(src), Register(src2)) } -inst_vpsravw_zmm_zmm_m512 :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: Mem512) -> Instruction { return inst_r_r_m(.VPSRAVW, Register(dst), Register(src), src2.mem, 64) } -emit_vpsravw_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VPSRAVW, Register(dst), Register(src), Register(src2)) } -emit_vpsravw_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VPSRAVW, Register(dst), Register(src), src2.mem, 16) } -emit_vpsravw_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VPSRAVW, Register(dst), Register(src), Register(src2)) } -emit_vpsravw_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VPSRAVW, Register(dst), Register(src), src2.mem, 32) } -emit_vpsravw_zmm_zmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: ZMM) { emit_rrr(instructions, .VPSRAVW, Register(dst), Register(src), Register(src2)) } -emit_vpsravw_zmm_zmm_m512 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: Mem512) { emit_rrm(instructions, .VPSRAVW, Register(dst), Register(src), src2.mem, 64) } -inst_vpsllvw_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VPSLLVW, Register(dst), Register(src), Register(src2)) } -inst_vpsllvw_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VPSLLVW, Register(dst), Register(src), src2.mem, 16) } -inst_vpsllvw_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VPSLLVW, Register(dst), Register(src), Register(src2)) } -inst_vpsllvw_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VPSLLVW, Register(dst), Register(src), src2.mem, 32) } -inst_vpsllvw_zmm_zmm_zmm :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: ZMM) -> Instruction { return inst_r_r_r(.VPSLLVW, Register(dst), Register(src), Register(src2)) } -inst_vpsllvw_zmm_zmm_m512 :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: Mem512) -> Instruction { return inst_r_r_m(.VPSLLVW, Register(dst), Register(src), src2.mem, 64) } -emit_vpsllvw_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VPSLLVW, Register(dst), Register(src), Register(src2)) } -emit_vpsllvw_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VPSLLVW, Register(dst), Register(src), src2.mem, 16) } -emit_vpsllvw_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VPSLLVW, Register(dst), Register(src), Register(src2)) } -emit_vpsllvw_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VPSLLVW, Register(dst), Register(src), src2.mem, 32) } -emit_vpsllvw_zmm_zmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: ZMM) { emit_rrr(instructions, .VPSLLVW, Register(dst), Register(src), Register(src2)) } -emit_vpsllvw_zmm_zmm_m512 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: Mem512) { emit_rrm(instructions, .VPSLLVW, Register(dst), Register(src), src2.mem, 64) } -inst_vpsrlvw_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VPSRLVW, Register(dst), Register(src), Register(src2)) } -inst_vpsrlvw_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VPSRLVW, Register(dst), Register(src), src2.mem, 16) } -inst_vpsrlvw_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VPSRLVW, Register(dst), Register(src), Register(src2)) } -inst_vpsrlvw_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VPSRLVW, Register(dst), Register(src), src2.mem, 32) } -inst_vpsrlvw_zmm_zmm_zmm :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: ZMM) -> Instruction { return inst_r_r_r(.VPSRLVW, Register(dst), Register(src), Register(src2)) } -inst_vpsrlvw_zmm_zmm_m512 :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: Mem512) -> Instruction { return inst_r_r_m(.VPSRLVW, Register(dst), Register(src), src2.mem, 64) } -emit_vpsrlvw_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VPSRLVW, Register(dst), Register(src), Register(src2)) } -emit_vpsrlvw_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VPSRLVW, Register(dst), Register(src), src2.mem, 16) } -emit_vpsrlvw_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VPSRLVW, Register(dst), Register(src), Register(src2)) } -emit_vpsrlvw_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VPSRLVW, Register(dst), Register(src), src2.mem, 32) } -emit_vpsrlvw_zmm_zmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: ZMM) { emit_rrr(instructions, .VPSRLVW, Register(dst), Register(src), Register(src2)) } -emit_vpsrlvw_zmm_zmm_m512 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: Mem512) { emit_rrm(instructions, .VPSRLVW, Register(dst), Register(src), src2.mem, 64) } +inst_vptestmb_k_xmm_xmm :: #force_inline proc "contextless" (dst: KREG, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPTESTMB, operand_count = 3, ops = {op_kreg(dst), op_xmm(src), op_xmm(src2), {}} }, 1679) } +inst_vptestmb_k_xmm_m128 :: #force_inline proc "contextless" (dst: KREG, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPTESTMB, operand_count = 3, ops = {op_kreg(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1679) } +inst_vptestmb_k_ymm_ymm :: #force_inline proc "contextless" (dst: KREG, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPTESTMB, operand_count = 3, ops = {op_kreg(dst), op_ymm(src), op_ymm(src2), {}} }, 1680) } +inst_vptestmb_k_ymm_m256 :: #force_inline proc "contextless" (dst: KREG, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VPTESTMB, operand_count = 3, ops = {op_kreg(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1680) } +inst_vptestmb_k_zmm_zmm :: #force_inline proc "contextless" (dst: KREG, src: ZMM, src2: ZMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPTESTMB, operand_count = 3, ops = {op_kreg(dst), op_zmm(src), op_zmm(src2), {}} }, 1681) } +inst_vptestmb_k_zmm_m512 :: #force_inline proc "contextless" (dst: KREG, src: ZMM, src2: Mem512) -> Instruction { return with_hint(Instruction{ mnemonic = .VPTESTMB, operand_count = 3, ops = {op_kreg(dst), op_zmm(src), op_mem(src2.mem, 64), {}} }, 1681) } +emit_vptestmb_k_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: XMM, src2: XMM) { append(instructions, inst_vptestmb_k_xmm_xmm(dst, src, src2)) } +emit_vptestmb_k_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: XMM, src2: Mem128) { append(instructions, inst_vptestmb_k_xmm_m128(dst, src, src2)) } +emit_vptestmb_k_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: YMM, src2: YMM) { append(instructions, inst_vptestmb_k_ymm_ymm(dst, src, src2)) } +emit_vptestmb_k_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: YMM, src2: Mem256) { append(instructions, inst_vptestmb_k_ymm_m256(dst, src, src2)) } +emit_vptestmb_k_zmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: ZMM, src2: ZMM) { append(instructions, inst_vptestmb_k_zmm_zmm(dst, src, src2)) } +emit_vptestmb_k_zmm_m512 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: ZMM, src2: Mem512) { append(instructions, inst_vptestmb_k_zmm_m512(dst, src, src2)) } +inst_vptestmw_k_xmm_xmm :: #force_inline proc "contextless" (dst: KREG, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPTESTMW, operand_count = 3, ops = {op_kreg(dst), op_xmm(src), op_xmm(src2), {}} }, 1682) } +inst_vptestmw_k_xmm_m128 :: #force_inline proc "contextless" (dst: KREG, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPTESTMW, operand_count = 3, ops = {op_kreg(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1682) } +inst_vptestmw_k_ymm_ymm :: #force_inline proc "contextless" (dst: KREG, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPTESTMW, operand_count = 3, ops = {op_kreg(dst), op_ymm(src), op_ymm(src2), {}} }, 1683) } +inst_vptestmw_k_ymm_m256 :: #force_inline proc "contextless" (dst: KREG, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VPTESTMW, operand_count = 3, ops = {op_kreg(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1683) } +inst_vptestmw_k_zmm_zmm :: #force_inline proc "contextless" (dst: KREG, src: ZMM, src2: ZMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPTESTMW, operand_count = 3, ops = {op_kreg(dst), op_zmm(src), op_zmm(src2), {}} }, 1684) } +inst_vptestmw_k_zmm_m512 :: #force_inline proc "contextless" (dst: KREG, src: ZMM, src2: Mem512) -> Instruction { return with_hint(Instruction{ mnemonic = .VPTESTMW, operand_count = 3, ops = {op_kreg(dst), op_zmm(src), op_mem(src2.mem, 64), {}} }, 1684) } +emit_vptestmw_k_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: XMM, src2: XMM) { append(instructions, inst_vptestmw_k_xmm_xmm(dst, src, src2)) } +emit_vptestmw_k_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: XMM, src2: Mem128) { append(instructions, inst_vptestmw_k_xmm_m128(dst, src, src2)) } +emit_vptestmw_k_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: YMM, src2: YMM) { append(instructions, inst_vptestmw_k_ymm_ymm(dst, src, src2)) } +emit_vptestmw_k_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: YMM, src2: Mem256) { append(instructions, inst_vptestmw_k_ymm_m256(dst, src, src2)) } +emit_vptestmw_k_zmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: ZMM, src2: ZMM) { append(instructions, inst_vptestmw_k_zmm_zmm(dst, src, src2)) } +emit_vptestmw_k_zmm_m512 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: ZMM, src2: Mem512) { append(instructions, inst_vptestmw_k_zmm_m512(dst, src, src2)) } +inst_vptestmd_k_xmm_xmm :: #force_inline proc "contextless" (dst: KREG, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPTESTMD, operand_count = 3, ops = {op_kreg(dst), op_xmm(src), op_xmm(src2), {}} }, 1685) } +inst_vptestmd_k_xmm_m128 :: #force_inline proc "contextless" (dst: KREG, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPTESTMD, operand_count = 3, ops = {op_kreg(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1685) } +inst_vptestmd_k_ymm_ymm :: #force_inline proc "contextless" (dst: KREG, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPTESTMD, operand_count = 3, ops = {op_kreg(dst), op_ymm(src), op_ymm(src2), {}} }, 1686) } +inst_vptestmd_k_ymm_m256 :: #force_inline proc "contextless" (dst: KREG, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VPTESTMD, operand_count = 3, ops = {op_kreg(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1686) } +inst_vptestmd_k_zmm_zmm :: #force_inline proc "contextless" (dst: KREG, src: ZMM, src2: ZMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPTESTMD, operand_count = 3, ops = {op_kreg(dst), op_zmm(src), op_zmm(src2), {}} }, 1687) } +inst_vptestmd_k_zmm_m512 :: #force_inline proc "contextless" (dst: KREG, src: ZMM, src2: Mem512) -> Instruction { return with_hint(Instruction{ mnemonic = .VPTESTMD, operand_count = 3, ops = {op_kreg(dst), op_zmm(src), op_mem(src2.mem, 64), {}} }, 1687) } +emit_vptestmd_k_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: XMM, src2: XMM) { append(instructions, inst_vptestmd_k_xmm_xmm(dst, src, src2)) } +emit_vptestmd_k_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: XMM, src2: Mem128) { append(instructions, inst_vptestmd_k_xmm_m128(dst, src, src2)) } +emit_vptestmd_k_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: YMM, src2: YMM) { append(instructions, inst_vptestmd_k_ymm_ymm(dst, src, src2)) } +emit_vptestmd_k_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: YMM, src2: Mem256) { append(instructions, inst_vptestmd_k_ymm_m256(dst, src, src2)) } +emit_vptestmd_k_zmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: ZMM, src2: ZMM) { append(instructions, inst_vptestmd_k_zmm_zmm(dst, src, src2)) } +emit_vptestmd_k_zmm_m512 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: ZMM, src2: Mem512) { append(instructions, inst_vptestmd_k_zmm_m512(dst, src, src2)) } +inst_vptestmq_k_xmm_xmm :: #force_inline proc "contextless" (dst: KREG, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPTESTMQ, operand_count = 3, ops = {op_kreg(dst), op_xmm(src), op_xmm(src2), {}} }, 1688) } +inst_vptestmq_k_xmm_m128 :: #force_inline proc "contextless" (dst: KREG, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPTESTMQ, operand_count = 3, ops = {op_kreg(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1688) } +inst_vptestmq_k_ymm_ymm :: #force_inline proc "contextless" (dst: KREG, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPTESTMQ, operand_count = 3, ops = {op_kreg(dst), op_ymm(src), op_ymm(src2), {}} }, 1689) } +inst_vptestmq_k_ymm_m256 :: #force_inline proc "contextless" (dst: KREG, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VPTESTMQ, operand_count = 3, ops = {op_kreg(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1689) } +inst_vptestmq_k_zmm_zmm :: #force_inline proc "contextless" (dst: KREG, src: ZMM, src2: ZMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPTESTMQ, operand_count = 3, ops = {op_kreg(dst), op_zmm(src), op_zmm(src2), {}} }, 1690) } +inst_vptestmq_k_zmm_m512 :: #force_inline proc "contextless" (dst: KREG, src: ZMM, src2: Mem512) -> Instruction { return with_hint(Instruction{ mnemonic = .VPTESTMQ, operand_count = 3, ops = {op_kreg(dst), op_zmm(src), op_mem(src2.mem, 64), {}} }, 1690) } +emit_vptestmq_k_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: XMM, src2: XMM) { append(instructions, inst_vptestmq_k_xmm_xmm(dst, src, src2)) } +emit_vptestmq_k_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: XMM, src2: Mem128) { append(instructions, inst_vptestmq_k_xmm_m128(dst, src, src2)) } +emit_vptestmq_k_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: YMM, src2: YMM) { append(instructions, inst_vptestmq_k_ymm_ymm(dst, src, src2)) } +emit_vptestmq_k_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: YMM, src2: Mem256) { append(instructions, inst_vptestmq_k_ymm_m256(dst, src, src2)) } +emit_vptestmq_k_zmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: ZMM, src2: ZMM) { append(instructions, inst_vptestmq_k_zmm_zmm(dst, src, src2)) } +emit_vptestmq_k_zmm_m512 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: ZMM, src2: Mem512) { append(instructions, inst_vptestmq_k_zmm_m512(dst, src, src2)) } +inst_vptestnmb_k_xmm_xmm :: #force_inline proc "contextless" (dst: KREG, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPTESTNMB, operand_count = 3, ops = {op_kreg(dst), op_xmm(src), op_xmm(src2), {}} }, 1691) } +inst_vptestnmb_k_xmm_m128 :: #force_inline proc "contextless" (dst: KREG, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPTESTNMB, operand_count = 3, ops = {op_kreg(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1691) } +inst_vptestnmb_k_ymm_ymm :: #force_inline proc "contextless" (dst: KREG, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPTESTNMB, operand_count = 3, ops = {op_kreg(dst), op_ymm(src), op_ymm(src2), {}} }, 1692) } +inst_vptestnmb_k_ymm_m256 :: #force_inline proc "contextless" (dst: KREG, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VPTESTNMB, operand_count = 3, ops = {op_kreg(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1692) } +inst_vptestnmb_k_zmm_zmm :: #force_inline proc "contextless" (dst: KREG, src: ZMM, src2: ZMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPTESTNMB, operand_count = 3, ops = {op_kreg(dst), op_zmm(src), op_zmm(src2), {}} }, 1693) } +inst_vptestnmb_k_zmm_m512 :: #force_inline proc "contextless" (dst: KREG, src: ZMM, src2: Mem512) -> Instruction { return with_hint(Instruction{ mnemonic = .VPTESTNMB, operand_count = 3, ops = {op_kreg(dst), op_zmm(src), op_mem(src2.mem, 64), {}} }, 1693) } +emit_vptestnmb_k_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: XMM, src2: XMM) { append(instructions, inst_vptestnmb_k_xmm_xmm(dst, src, src2)) } +emit_vptestnmb_k_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: XMM, src2: Mem128) { append(instructions, inst_vptestnmb_k_xmm_m128(dst, src, src2)) } +emit_vptestnmb_k_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: YMM, src2: YMM) { append(instructions, inst_vptestnmb_k_ymm_ymm(dst, src, src2)) } +emit_vptestnmb_k_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: YMM, src2: Mem256) { append(instructions, inst_vptestnmb_k_ymm_m256(dst, src, src2)) } +emit_vptestnmb_k_zmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: ZMM, src2: ZMM) { append(instructions, inst_vptestnmb_k_zmm_zmm(dst, src, src2)) } +emit_vptestnmb_k_zmm_m512 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: ZMM, src2: Mem512) { append(instructions, inst_vptestnmb_k_zmm_m512(dst, src, src2)) } +inst_vptestnmw_k_xmm_xmm :: #force_inline proc "contextless" (dst: KREG, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPTESTNMW, operand_count = 3, ops = {op_kreg(dst), op_xmm(src), op_xmm(src2), {}} }, 1694) } +inst_vptestnmw_k_xmm_m128 :: #force_inline proc "contextless" (dst: KREG, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPTESTNMW, operand_count = 3, ops = {op_kreg(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1694) } +inst_vptestnmw_k_ymm_ymm :: #force_inline proc "contextless" (dst: KREG, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPTESTNMW, operand_count = 3, ops = {op_kreg(dst), op_ymm(src), op_ymm(src2), {}} }, 1695) } +inst_vptestnmw_k_ymm_m256 :: #force_inline proc "contextless" (dst: KREG, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VPTESTNMW, operand_count = 3, ops = {op_kreg(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1695) } +inst_vptestnmw_k_zmm_zmm :: #force_inline proc "contextless" (dst: KREG, src: ZMM, src2: ZMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPTESTNMW, operand_count = 3, ops = {op_kreg(dst), op_zmm(src), op_zmm(src2), {}} }, 1696) } +inst_vptestnmw_k_zmm_m512 :: #force_inline proc "contextless" (dst: KREG, src: ZMM, src2: Mem512) -> Instruction { return with_hint(Instruction{ mnemonic = .VPTESTNMW, operand_count = 3, ops = {op_kreg(dst), op_zmm(src), op_mem(src2.mem, 64), {}} }, 1696) } +emit_vptestnmw_k_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: XMM, src2: XMM) { append(instructions, inst_vptestnmw_k_xmm_xmm(dst, src, src2)) } +emit_vptestnmw_k_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: XMM, src2: Mem128) { append(instructions, inst_vptestnmw_k_xmm_m128(dst, src, src2)) } +emit_vptestnmw_k_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: YMM, src2: YMM) { append(instructions, inst_vptestnmw_k_ymm_ymm(dst, src, src2)) } +emit_vptestnmw_k_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: YMM, src2: Mem256) { append(instructions, inst_vptestnmw_k_ymm_m256(dst, src, src2)) } +emit_vptestnmw_k_zmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: ZMM, src2: ZMM) { append(instructions, inst_vptestnmw_k_zmm_zmm(dst, src, src2)) } +emit_vptestnmw_k_zmm_m512 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: ZMM, src2: Mem512) { append(instructions, inst_vptestnmw_k_zmm_m512(dst, src, src2)) } +inst_vptestnmd_k_xmm_xmm :: #force_inline proc "contextless" (dst: KREG, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPTESTNMD, operand_count = 3, ops = {op_kreg(dst), op_xmm(src), op_xmm(src2), {}} }, 1697) } +inst_vptestnmd_k_xmm_m128 :: #force_inline proc "contextless" (dst: KREG, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPTESTNMD, operand_count = 3, ops = {op_kreg(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1697) } +inst_vptestnmd_k_ymm_ymm :: #force_inline proc "contextless" (dst: KREG, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPTESTNMD, operand_count = 3, ops = {op_kreg(dst), op_ymm(src), op_ymm(src2), {}} }, 1698) } +inst_vptestnmd_k_ymm_m256 :: #force_inline proc "contextless" (dst: KREG, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VPTESTNMD, operand_count = 3, ops = {op_kreg(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1698) } +inst_vptestnmd_k_zmm_zmm :: #force_inline proc "contextless" (dst: KREG, src: ZMM, src2: ZMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPTESTNMD, operand_count = 3, ops = {op_kreg(dst), op_zmm(src), op_zmm(src2), {}} }, 1699) } +inst_vptestnmd_k_zmm_m512 :: #force_inline proc "contextless" (dst: KREG, src: ZMM, src2: Mem512) -> Instruction { return with_hint(Instruction{ mnemonic = .VPTESTNMD, operand_count = 3, ops = {op_kreg(dst), op_zmm(src), op_mem(src2.mem, 64), {}} }, 1699) } +emit_vptestnmd_k_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: XMM, src2: XMM) { append(instructions, inst_vptestnmd_k_xmm_xmm(dst, src, src2)) } +emit_vptestnmd_k_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: XMM, src2: Mem128) { append(instructions, inst_vptestnmd_k_xmm_m128(dst, src, src2)) } +emit_vptestnmd_k_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: YMM, src2: YMM) { append(instructions, inst_vptestnmd_k_ymm_ymm(dst, src, src2)) } +emit_vptestnmd_k_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: YMM, src2: Mem256) { append(instructions, inst_vptestnmd_k_ymm_m256(dst, src, src2)) } +emit_vptestnmd_k_zmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: ZMM, src2: ZMM) { append(instructions, inst_vptestnmd_k_zmm_zmm(dst, src, src2)) } +emit_vptestnmd_k_zmm_m512 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: ZMM, src2: Mem512) { append(instructions, inst_vptestnmd_k_zmm_m512(dst, src, src2)) } +inst_vptestnmq_k_xmm_xmm :: #force_inline proc "contextless" (dst: KREG, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPTESTNMQ, operand_count = 3, ops = {op_kreg(dst), op_xmm(src), op_xmm(src2), {}} }, 1700) } +inst_vptestnmq_k_xmm_m128 :: #force_inline proc "contextless" (dst: KREG, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPTESTNMQ, operand_count = 3, ops = {op_kreg(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1700) } +inst_vptestnmq_k_ymm_ymm :: #force_inline proc "contextless" (dst: KREG, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPTESTNMQ, operand_count = 3, ops = {op_kreg(dst), op_ymm(src), op_ymm(src2), {}} }, 1701) } +inst_vptestnmq_k_ymm_m256 :: #force_inline proc "contextless" (dst: KREG, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VPTESTNMQ, operand_count = 3, ops = {op_kreg(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1701) } +inst_vptestnmq_k_zmm_zmm :: #force_inline proc "contextless" (dst: KREG, src: ZMM, src2: ZMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPTESTNMQ, operand_count = 3, ops = {op_kreg(dst), op_zmm(src), op_zmm(src2), {}} }, 1702) } +inst_vptestnmq_k_zmm_m512 :: #force_inline proc "contextless" (dst: KREG, src: ZMM, src2: Mem512) -> Instruction { return with_hint(Instruction{ mnemonic = .VPTESTNMQ, operand_count = 3, ops = {op_kreg(dst), op_zmm(src), op_mem(src2.mem, 64), {}} }, 1702) } +emit_vptestnmq_k_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: XMM, src2: XMM) { append(instructions, inst_vptestnmq_k_xmm_xmm(dst, src, src2)) } +emit_vptestnmq_k_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: XMM, src2: Mem128) { append(instructions, inst_vptestnmq_k_xmm_m128(dst, src, src2)) } +emit_vptestnmq_k_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: YMM, src2: YMM) { append(instructions, inst_vptestnmq_k_ymm_ymm(dst, src, src2)) } +emit_vptestnmq_k_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: YMM, src2: Mem256) { append(instructions, inst_vptestnmq_k_ymm_m256(dst, src, src2)) } +emit_vptestnmq_k_zmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: ZMM, src2: ZMM) { append(instructions, inst_vptestnmq_k_zmm_zmm(dst, src, src2)) } +emit_vptestnmq_k_zmm_m512 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: ZMM, src2: Mem512) { append(instructions, inst_vptestnmq_k_zmm_m512(dst, src, src2)) } +inst_vpcompressd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPCOMPRESSD, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 1703) } +inst_vpcompressd_m128_xmm :: #force_inline proc "contextless" (dst: Mem128, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPCOMPRESSD, operand_count = 2, ops = {op_mem(dst.mem, 16), op_xmm(src), {}, {}} }, 1703) } +inst_vpcompressd_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPCOMPRESSD, operand_count = 2, ops = {op_ymm(dst), op_ymm(src), {}, {}} }, 1704) } +inst_vpcompressd_m256_ymm :: #force_inline proc "contextless" (dst: Mem256, src: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPCOMPRESSD, operand_count = 2, ops = {op_mem(dst.mem, 32), op_ymm(src), {}, {}} }, 1704) } +inst_vpcompressd_zmm_zmm :: #force_inline proc "contextless" (dst: ZMM, src: ZMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPCOMPRESSD, operand_count = 2, ops = {op_zmm(dst), op_zmm(src), {}, {}} }, 1705) } +inst_vpcompressd_m512_zmm :: #force_inline proc "contextless" (dst: Mem512, src: ZMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPCOMPRESSD, operand_count = 2, ops = {op_mem(dst.mem, 64), op_zmm(src), {}, {}} }, 1705) } +emit_vpcompressd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_vpcompressd_xmm_xmm(dst, src)) } +emit_vpcompressd_m128_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem128, src: XMM) { append(instructions, inst_vpcompressd_m128_xmm(dst, src)) } +emit_vpcompressd_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM) { append(instructions, inst_vpcompressd_ymm_ymm(dst, src)) } +emit_vpcompressd_m256_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem256, src: YMM) { append(instructions, inst_vpcompressd_m256_ymm(dst, src)) } +emit_vpcompressd_zmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM) { append(instructions, inst_vpcompressd_zmm_zmm(dst, src)) } +emit_vpcompressd_m512_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem512, src: ZMM) { append(instructions, inst_vpcompressd_m512_zmm(dst, src)) } +inst_vpcompressq_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPCOMPRESSQ, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 1706) } +inst_vpcompressq_m128_xmm :: #force_inline proc "contextless" (dst: Mem128, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPCOMPRESSQ, operand_count = 2, ops = {op_mem(dst.mem, 16), op_xmm(src), {}, {}} }, 1706) } +inst_vpcompressq_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPCOMPRESSQ, operand_count = 2, ops = {op_ymm(dst), op_ymm(src), {}, {}} }, 1707) } +inst_vpcompressq_m256_ymm :: #force_inline proc "contextless" (dst: Mem256, src: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPCOMPRESSQ, operand_count = 2, ops = {op_mem(dst.mem, 32), op_ymm(src), {}, {}} }, 1707) } +inst_vpcompressq_zmm_zmm :: #force_inline proc "contextless" (dst: ZMM, src: ZMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPCOMPRESSQ, operand_count = 2, ops = {op_zmm(dst), op_zmm(src), {}, {}} }, 1708) } +inst_vpcompressq_m512_zmm :: #force_inline proc "contextless" (dst: Mem512, src: ZMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPCOMPRESSQ, operand_count = 2, ops = {op_mem(dst.mem, 64), op_zmm(src), {}, {}} }, 1708) } +emit_vpcompressq_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_vpcompressq_xmm_xmm(dst, src)) } +emit_vpcompressq_m128_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem128, src: XMM) { append(instructions, inst_vpcompressq_m128_xmm(dst, src)) } +emit_vpcompressq_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM) { append(instructions, inst_vpcompressq_ymm_ymm(dst, src)) } +emit_vpcompressq_m256_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem256, src: YMM) { append(instructions, inst_vpcompressq_m256_ymm(dst, src)) } +emit_vpcompressq_zmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM) { append(instructions, inst_vpcompressq_zmm_zmm(dst, src)) } +emit_vpcompressq_m512_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem512, src: ZMM) { append(instructions, inst_vpcompressq_m512_zmm(dst, src)) } +inst_vcompressps_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VCOMPRESSPS, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 1709) } +inst_vcompressps_m128_xmm :: #force_inline proc "contextless" (dst: Mem128, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VCOMPRESSPS, operand_count = 2, ops = {op_mem(dst.mem, 16), op_xmm(src), {}, {}} }, 1709) } +inst_vcompressps_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VCOMPRESSPS, operand_count = 2, ops = {op_ymm(dst), op_ymm(src), {}, {}} }, 1710) } +inst_vcompressps_m256_ymm :: #force_inline proc "contextless" (dst: Mem256, src: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VCOMPRESSPS, operand_count = 2, ops = {op_mem(dst.mem, 32), op_ymm(src), {}, {}} }, 1710) } +inst_vcompressps_zmm_zmm :: #force_inline proc "contextless" (dst: ZMM, src: ZMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VCOMPRESSPS, operand_count = 2, ops = {op_zmm(dst), op_zmm(src), {}, {}} }, 1711) } +inst_vcompressps_m512_zmm :: #force_inline proc "contextless" (dst: Mem512, src: ZMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VCOMPRESSPS, operand_count = 2, ops = {op_mem(dst.mem, 64), op_zmm(src), {}, {}} }, 1711) } +emit_vcompressps_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_vcompressps_xmm_xmm(dst, src)) } +emit_vcompressps_m128_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem128, src: XMM) { append(instructions, inst_vcompressps_m128_xmm(dst, src)) } +emit_vcompressps_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM) { append(instructions, inst_vcompressps_ymm_ymm(dst, src)) } +emit_vcompressps_m256_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem256, src: YMM) { append(instructions, inst_vcompressps_m256_ymm(dst, src)) } +emit_vcompressps_zmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM) { append(instructions, inst_vcompressps_zmm_zmm(dst, src)) } +emit_vcompressps_m512_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem512, src: ZMM) { append(instructions, inst_vcompressps_m512_zmm(dst, src)) } +inst_vcompresspd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VCOMPRESSPD, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 1712) } +inst_vcompresspd_m128_xmm :: #force_inline proc "contextless" (dst: Mem128, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VCOMPRESSPD, operand_count = 2, ops = {op_mem(dst.mem, 16), op_xmm(src), {}, {}} }, 1712) } +inst_vcompresspd_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VCOMPRESSPD, operand_count = 2, ops = {op_ymm(dst), op_ymm(src), {}, {}} }, 1713) } +inst_vcompresspd_m256_ymm :: #force_inline proc "contextless" (dst: Mem256, src: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VCOMPRESSPD, operand_count = 2, ops = {op_mem(dst.mem, 32), op_ymm(src), {}, {}} }, 1713) } +inst_vcompresspd_zmm_zmm :: #force_inline proc "contextless" (dst: ZMM, src: ZMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VCOMPRESSPD, operand_count = 2, ops = {op_zmm(dst), op_zmm(src), {}, {}} }, 1714) } +inst_vcompresspd_m512_zmm :: #force_inline proc "contextless" (dst: Mem512, src: ZMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VCOMPRESSPD, operand_count = 2, ops = {op_mem(dst.mem, 64), op_zmm(src), {}, {}} }, 1714) } +emit_vcompresspd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_vcompresspd_xmm_xmm(dst, src)) } +emit_vcompresspd_m128_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem128, src: XMM) { append(instructions, inst_vcompresspd_m128_xmm(dst, src)) } +emit_vcompresspd_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM) { append(instructions, inst_vcompresspd_ymm_ymm(dst, src)) } +emit_vcompresspd_m256_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem256, src: YMM) { append(instructions, inst_vcompresspd_m256_ymm(dst, src)) } +emit_vcompresspd_zmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM) { append(instructions, inst_vcompresspd_zmm_zmm(dst, src)) } +emit_vcompresspd_m512_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem512, src: ZMM) { append(instructions, inst_vcompresspd_m512_zmm(dst, src)) } +inst_vpexpandd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPEXPANDD, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 1715) } +inst_vpexpandd_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPEXPANDD, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 1715) } +inst_vpexpandd_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPEXPANDD, operand_count = 2, ops = {op_ymm(dst), op_ymm(src), {}, {}} }, 1716) } +inst_vpexpandd_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VPEXPANDD, operand_count = 2, ops = {op_ymm(dst), op_mem(src.mem, 32), {}, {}} }, 1716) } +inst_vpexpandd_zmm_zmm :: #force_inline proc "contextless" (dst: ZMM, src: ZMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPEXPANDD, operand_count = 2, ops = {op_zmm(dst), op_zmm(src), {}, {}} }, 1717) } +inst_vpexpandd_zmm_m512 :: #force_inline proc "contextless" (dst: ZMM, src: Mem512) -> Instruction { return with_hint(Instruction{ mnemonic = .VPEXPANDD, operand_count = 2, ops = {op_zmm(dst), op_mem(src.mem, 64), {}, {}} }, 1717) } +emit_vpexpandd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_vpexpandd_xmm_xmm(dst, src)) } +emit_vpexpandd_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_vpexpandd_xmm_m128(dst, src)) } +emit_vpexpandd_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM) { append(instructions, inst_vpexpandd_ymm_ymm(dst, src)) } +emit_vpexpandd_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem256) { append(instructions, inst_vpexpandd_ymm_m256(dst, src)) } +emit_vpexpandd_zmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM) { append(instructions, inst_vpexpandd_zmm_zmm(dst, src)) } +emit_vpexpandd_zmm_m512 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: Mem512) { append(instructions, inst_vpexpandd_zmm_m512(dst, src)) } +inst_vpexpandq_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPEXPANDQ, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 1718) } +inst_vpexpandq_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPEXPANDQ, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 1718) } +inst_vpexpandq_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPEXPANDQ, operand_count = 2, ops = {op_ymm(dst), op_ymm(src), {}, {}} }, 1719) } +inst_vpexpandq_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VPEXPANDQ, operand_count = 2, ops = {op_ymm(dst), op_mem(src.mem, 32), {}, {}} }, 1719) } +inst_vpexpandq_zmm_zmm :: #force_inline proc "contextless" (dst: ZMM, src: ZMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPEXPANDQ, operand_count = 2, ops = {op_zmm(dst), op_zmm(src), {}, {}} }, 1720) } +inst_vpexpandq_zmm_m512 :: #force_inline proc "contextless" (dst: ZMM, src: Mem512) -> Instruction { return with_hint(Instruction{ mnemonic = .VPEXPANDQ, operand_count = 2, ops = {op_zmm(dst), op_mem(src.mem, 64), {}, {}} }, 1720) } +emit_vpexpandq_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_vpexpandq_xmm_xmm(dst, src)) } +emit_vpexpandq_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_vpexpandq_xmm_m128(dst, src)) } +emit_vpexpandq_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM) { append(instructions, inst_vpexpandq_ymm_ymm(dst, src)) } +emit_vpexpandq_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem256) { append(instructions, inst_vpexpandq_ymm_m256(dst, src)) } +emit_vpexpandq_zmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM) { append(instructions, inst_vpexpandq_zmm_zmm(dst, src)) } +emit_vpexpandq_zmm_m512 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: Mem512) { append(instructions, inst_vpexpandq_zmm_m512(dst, src)) } +inst_vexpandps_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VEXPANDPS, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 1721) } +inst_vexpandps_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VEXPANDPS, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 1721) } +inst_vexpandps_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VEXPANDPS, operand_count = 2, ops = {op_ymm(dst), op_ymm(src), {}, {}} }, 1722) } +inst_vexpandps_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VEXPANDPS, operand_count = 2, ops = {op_ymm(dst), op_mem(src.mem, 32), {}, {}} }, 1722) } +inst_vexpandps_zmm_zmm :: #force_inline proc "contextless" (dst: ZMM, src: ZMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VEXPANDPS, operand_count = 2, ops = {op_zmm(dst), op_zmm(src), {}, {}} }, 1723) } +inst_vexpandps_zmm_m512 :: #force_inline proc "contextless" (dst: ZMM, src: Mem512) -> Instruction { return with_hint(Instruction{ mnemonic = .VEXPANDPS, operand_count = 2, ops = {op_zmm(dst), op_mem(src.mem, 64), {}, {}} }, 1723) } +emit_vexpandps_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_vexpandps_xmm_xmm(dst, src)) } +emit_vexpandps_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_vexpandps_xmm_m128(dst, src)) } +emit_vexpandps_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM) { append(instructions, inst_vexpandps_ymm_ymm(dst, src)) } +emit_vexpandps_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem256) { append(instructions, inst_vexpandps_ymm_m256(dst, src)) } +emit_vexpandps_zmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM) { append(instructions, inst_vexpandps_zmm_zmm(dst, src)) } +emit_vexpandps_zmm_m512 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: Mem512) { append(instructions, inst_vexpandps_zmm_m512(dst, src)) } +inst_vexpandpd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VEXPANDPD, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 1724) } +inst_vexpandpd_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VEXPANDPD, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 1724) } +inst_vexpandpd_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VEXPANDPD, operand_count = 2, ops = {op_ymm(dst), op_ymm(src), {}, {}} }, 1725) } +inst_vexpandpd_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VEXPANDPD, operand_count = 2, ops = {op_ymm(dst), op_mem(src.mem, 32), {}, {}} }, 1725) } +inst_vexpandpd_zmm_zmm :: #force_inline proc "contextless" (dst: ZMM, src: ZMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VEXPANDPD, operand_count = 2, ops = {op_zmm(dst), op_zmm(src), {}, {}} }, 1726) } +inst_vexpandpd_zmm_m512 :: #force_inline proc "contextless" (dst: ZMM, src: Mem512) -> Instruction { return with_hint(Instruction{ mnemonic = .VEXPANDPD, operand_count = 2, ops = {op_zmm(dst), op_mem(src.mem, 64), {}, {}} }, 1726) } +emit_vexpandpd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_vexpandpd_xmm_xmm(dst, src)) } +emit_vexpandpd_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_vexpandpd_xmm_m128(dst, src)) } +emit_vexpandpd_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM) { append(instructions, inst_vexpandpd_ymm_ymm(dst, src)) } +emit_vexpandpd_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem256) { append(instructions, inst_vexpandpd_ymm_m256(dst, src)) } +emit_vexpandpd_zmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM) { append(instructions, inst_vexpandpd_zmm_zmm(dst, src)) } +emit_vexpandpd_zmm_m512 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: Mem512) { append(instructions, inst_vexpandpd_zmm_m512(dst, src)) } +inst_vpconflictd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPCONFLICTD, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 1727) } +inst_vpconflictd_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPCONFLICTD, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 1727) } +inst_vpconflictd_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPCONFLICTD, operand_count = 2, ops = {op_ymm(dst), op_ymm(src), {}, {}} }, 1728) } +inst_vpconflictd_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VPCONFLICTD, operand_count = 2, ops = {op_ymm(dst), op_mem(src.mem, 32), {}, {}} }, 1728) } +inst_vpconflictd_zmm_zmm :: #force_inline proc "contextless" (dst: ZMM, src: ZMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPCONFLICTD, operand_count = 2, ops = {op_zmm(dst), op_zmm(src), {}, {}} }, 1729) } +inst_vpconflictd_zmm_m512 :: #force_inline proc "contextless" (dst: ZMM, src: Mem512) -> Instruction { return with_hint(Instruction{ mnemonic = .VPCONFLICTD, operand_count = 2, ops = {op_zmm(dst), op_mem(src.mem, 64), {}, {}} }, 1729) } +emit_vpconflictd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_vpconflictd_xmm_xmm(dst, src)) } +emit_vpconflictd_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_vpconflictd_xmm_m128(dst, src)) } +emit_vpconflictd_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM) { append(instructions, inst_vpconflictd_ymm_ymm(dst, src)) } +emit_vpconflictd_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem256) { append(instructions, inst_vpconflictd_ymm_m256(dst, src)) } +emit_vpconflictd_zmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM) { append(instructions, inst_vpconflictd_zmm_zmm(dst, src)) } +emit_vpconflictd_zmm_m512 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: Mem512) { append(instructions, inst_vpconflictd_zmm_m512(dst, src)) } +inst_vpconflictq_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPCONFLICTQ, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 1730) } +inst_vpconflictq_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPCONFLICTQ, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 1730) } +inst_vpconflictq_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPCONFLICTQ, operand_count = 2, ops = {op_ymm(dst), op_ymm(src), {}, {}} }, 1731) } +inst_vpconflictq_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VPCONFLICTQ, operand_count = 2, ops = {op_ymm(dst), op_mem(src.mem, 32), {}, {}} }, 1731) } +inst_vpconflictq_zmm_zmm :: #force_inline proc "contextless" (dst: ZMM, src: ZMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPCONFLICTQ, operand_count = 2, ops = {op_zmm(dst), op_zmm(src), {}, {}} }, 1732) } +inst_vpconflictq_zmm_m512 :: #force_inline proc "contextless" (dst: ZMM, src: Mem512) -> Instruction { return with_hint(Instruction{ mnemonic = .VPCONFLICTQ, operand_count = 2, ops = {op_zmm(dst), op_mem(src.mem, 64), {}, {}} }, 1732) } +emit_vpconflictq_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_vpconflictq_xmm_xmm(dst, src)) } +emit_vpconflictq_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_vpconflictq_xmm_m128(dst, src)) } +emit_vpconflictq_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM) { append(instructions, inst_vpconflictq_ymm_ymm(dst, src)) } +emit_vpconflictq_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem256) { append(instructions, inst_vpconflictq_ymm_m256(dst, src)) } +emit_vpconflictq_zmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM) { append(instructions, inst_vpconflictq_zmm_zmm(dst, src)) } +emit_vpconflictq_zmm_m512 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: Mem512) { append(instructions, inst_vpconflictq_zmm_m512(dst, src)) } +inst_vplzcntd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPLZCNTD, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 1733) } +inst_vplzcntd_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPLZCNTD, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 1733) } +inst_vplzcntd_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPLZCNTD, operand_count = 2, ops = {op_ymm(dst), op_ymm(src), {}, {}} }, 1734) } +inst_vplzcntd_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VPLZCNTD, operand_count = 2, ops = {op_ymm(dst), op_mem(src.mem, 32), {}, {}} }, 1734) } +inst_vplzcntd_zmm_zmm :: #force_inline proc "contextless" (dst: ZMM, src: ZMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPLZCNTD, operand_count = 2, ops = {op_zmm(dst), op_zmm(src), {}, {}} }, 1735) } +inst_vplzcntd_zmm_m512 :: #force_inline proc "contextless" (dst: ZMM, src: Mem512) -> Instruction { return with_hint(Instruction{ mnemonic = .VPLZCNTD, operand_count = 2, ops = {op_zmm(dst), op_mem(src.mem, 64), {}, {}} }, 1735) } +emit_vplzcntd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_vplzcntd_xmm_xmm(dst, src)) } +emit_vplzcntd_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_vplzcntd_xmm_m128(dst, src)) } +emit_vplzcntd_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM) { append(instructions, inst_vplzcntd_ymm_ymm(dst, src)) } +emit_vplzcntd_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem256) { append(instructions, inst_vplzcntd_ymm_m256(dst, src)) } +emit_vplzcntd_zmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM) { append(instructions, inst_vplzcntd_zmm_zmm(dst, src)) } +emit_vplzcntd_zmm_m512 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: Mem512) { append(instructions, inst_vplzcntd_zmm_m512(dst, src)) } +inst_vplzcntq_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPLZCNTQ, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 1736) } +inst_vplzcntq_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPLZCNTQ, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 1736) } +inst_vplzcntq_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPLZCNTQ, operand_count = 2, ops = {op_ymm(dst), op_ymm(src), {}, {}} }, 1737) } +inst_vplzcntq_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VPLZCNTQ, operand_count = 2, ops = {op_ymm(dst), op_mem(src.mem, 32), {}, {}} }, 1737) } +inst_vplzcntq_zmm_zmm :: #force_inline proc "contextless" (dst: ZMM, src: ZMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPLZCNTQ, operand_count = 2, ops = {op_zmm(dst), op_zmm(src), {}, {}} }, 1738) } +inst_vplzcntq_zmm_m512 :: #force_inline proc "contextless" (dst: ZMM, src: Mem512) -> Instruction { return with_hint(Instruction{ mnemonic = .VPLZCNTQ, operand_count = 2, ops = {op_zmm(dst), op_mem(src.mem, 64), {}, {}} }, 1738) } +emit_vplzcntq_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_vplzcntq_xmm_xmm(dst, src)) } +emit_vplzcntq_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_vplzcntq_xmm_m128(dst, src)) } +emit_vplzcntq_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM) { append(instructions, inst_vplzcntq_ymm_ymm(dst, src)) } +emit_vplzcntq_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem256) { append(instructions, inst_vplzcntq_ymm_m256(dst, src)) } +emit_vplzcntq_zmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM) { append(instructions, inst_vplzcntq_zmm_zmm(dst, src)) } +emit_vplzcntq_zmm_m512 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: Mem512) { append(instructions, inst_vplzcntq_zmm_m512(dst, src)) } +inst_vpermi2b_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPERMI2B, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1739) } +inst_vpermi2b_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPERMI2B, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1739) } +inst_vpermi2b_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPERMI2B, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1740) } +inst_vpermi2b_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VPERMI2B, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1740) } +inst_vpermi2b_zmm_zmm_zmm :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: ZMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPERMI2B, operand_count = 3, ops = {op_zmm(dst), op_zmm(src), op_zmm(src2), {}} }, 1741) } +inst_vpermi2b_zmm_zmm_m512 :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: Mem512) -> Instruction { return with_hint(Instruction{ mnemonic = .VPERMI2B, operand_count = 3, ops = {op_zmm(dst), op_zmm(src), op_mem(src2.mem, 64), {}} }, 1741) } +emit_vpermi2b_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vpermi2b_xmm_xmm_xmm(dst, src, src2)) } +emit_vpermi2b_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vpermi2b_xmm_xmm_m128(dst, src, src2)) } +emit_vpermi2b_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vpermi2b_ymm_ymm_ymm(dst, src, src2)) } +emit_vpermi2b_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vpermi2b_ymm_ymm_m256(dst, src, src2)) } +emit_vpermi2b_zmm_zmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: ZMM) { append(instructions, inst_vpermi2b_zmm_zmm_zmm(dst, src, src2)) } +emit_vpermi2b_zmm_zmm_m512 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: Mem512) { append(instructions, inst_vpermi2b_zmm_zmm_m512(dst, src, src2)) } +inst_vpermi2w_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPERMI2W, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1742) } +inst_vpermi2w_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPERMI2W, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1742) } +inst_vpermi2w_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPERMI2W, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1743) } +inst_vpermi2w_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VPERMI2W, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1743) } +inst_vpermi2w_zmm_zmm_zmm :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: ZMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPERMI2W, operand_count = 3, ops = {op_zmm(dst), op_zmm(src), op_zmm(src2), {}} }, 1744) } +inst_vpermi2w_zmm_zmm_m512 :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: Mem512) -> Instruction { return with_hint(Instruction{ mnemonic = .VPERMI2W, operand_count = 3, ops = {op_zmm(dst), op_zmm(src), op_mem(src2.mem, 64), {}} }, 1744) } +emit_vpermi2w_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vpermi2w_xmm_xmm_xmm(dst, src, src2)) } +emit_vpermi2w_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vpermi2w_xmm_xmm_m128(dst, src, src2)) } +emit_vpermi2w_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vpermi2w_ymm_ymm_ymm(dst, src, src2)) } +emit_vpermi2w_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vpermi2w_ymm_ymm_m256(dst, src, src2)) } +emit_vpermi2w_zmm_zmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: ZMM) { append(instructions, inst_vpermi2w_zmm_zmm_zmm(dst, src, src2)) } +emit_vpermi2w_zmm_zmm_m512 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: Mem512) { append(instructions, inst_vpermi2w_zmm_zmm_m512(dst, src, src2)) } +inst_vpermi2d_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPERMI2D, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1745) } +inst_vpermi2d_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPERMI2D, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1745) } +inst_vpermi2d_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPERMI2D, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1746) } +inst_vpermi2d_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VPERMI2D, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1746) } +inst_vpermi2d_zmm_zmm_zmm :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: ZMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPERMI2D, operand_count = 3, ops = {op_zmm(dst), op_zmm(src), op_zmm(src2), {}} }, 1747) } +inst_vpermi2d_zmm_zmm_m512 :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: Mem512) -> Instruction { return with_hint(Instruction{ mnemonic = .VPERMI2D, operand_count = 3, ops = {op_zmm(dst), op_zmm(src), op_mem(src2.mem, 64), {}} }, 1747) } +emit_vpermi2d_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vpermi2d_xmm_xmm_xmm(dst, src, src2)) } +emit_vpermi2d_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vpermi2d_xmm_xmm_m128(dst, src, src2)) } +emit_vpermi2d_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vpermi2d_ymm_ymm_ymm(dst, src, src2)) } +emit_vpermi2d_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vpermi2d_ymm_ymm_m256(dst, src, src2)) } +emit_vpermi2d_zmm_zmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: ZMM) { append(instructions, inst_vpermi2d_zmm_zmm_zmm(dst, src, src2)) } +emit_vpermi2d_zmm_zmm_m512 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: Mem512) { append(instructions, inst_vpermi2d_zmm_zmm_m512(dst, src, src2)) } +inst_vpermi2q_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPERMI2Q, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1748) } +inst_vpermi2q_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPERMI2Q, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1748) } +inst_vpermi2q_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPERMI2Q, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1749) } +inst_vpermi2q_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VPERMI2Q, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1749) } +inst_vpermi2q_zmm_zmm_zmm :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: ZMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPERMI2Q, operand_count = 3, ops = {op_zmm(dst), op_zmm(src), op_zmm(src2), {}} }, 1750) } +inst_vpermi2q_zmm_zmm_m512 :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: Mem512) -> Instruction { return with_hint(Instruction{ mnemonic = .VPERMI2Q, operand_count = 3, ops = {op_zmm(dst), op_zmm(src), op_mem(src2.mem, 64), {}} }, 1750) } +emit_vpermi2q_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vpermi2q_xmm_xmm_xmm(dst, src, src2)) } +emit_vpermi2q_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vpermi2q_xmm_xmm_m128(dst, src, src2)) } +emit_vpermi2q_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vpermi2q_ymm_ymm_ymm(dst, src, src2)) } +emit_vpermi2q_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vpermi2q_ymm_ymm_m256(dst, src, src2)) } +emit_vpermi2q_zmm_zmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: ZMM) { append(instructions, inst_vpermi2q_zmm_zmm_zmm(dst, src, src2)) } +emit_vpermi2q_zmm_zmm_m512 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: Mem512) { append(instructions, inst_vpermi2q_zmm_zmm_m512(dst, src, src2)) } +inst_vpermi2ps_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPERMI2PS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1751) } +inst_vpermi2ps_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPERMI2PS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1751) } +inst_vpermi2ps_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPERMI2PS, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1752) } +inst_vpermi2ps_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VPERMI2PS, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1752) } +inst_vpermi2ps_zmm_zmm_zmm :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: ZMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPERMI2PS, operand_count = 3, ops = {op_zmm(dst), op_zmm(src), op_zmm(src2), {}} }, 1753) } +inst_vpermi2ps_zmm_zmm_m512 :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: Mem512) -> Instruction { return with_hint(Instruction{ mnemonic = .VPERMI2PS, operand_count = 3, ops = {op_zmm(dst), op_zmm(src), op_mem(src2.mem, 64), {}} }, 1753) } +emit_vpermi2ps_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vpermi2ps_xmm_xmm_xmm(dst, src, src2)) } +emit_vpermi2ps_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vpermi2ps_xmm_xmm_m128(dst, src, src2)) } +emit_vpermi2ps_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vpermi2ps_ymm_ymm_ymm(dst, src, src2)) } +emit_vpermi2ps_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vpermi2ps_ymm_ymm_m256(dst, src, src2)) } +emit_vpermi2ps_zmm_zmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: ZMM) { append(instructions, inst_vpermi2ps_zmm_zmm_zmm(dst, src, src2)) } +emit_vpermi2ps_zmm_zmm_m512 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: Mem512) { append(instructions, inst_vpermi2ps_zmm_zmm_m512(dst, src, src2)) } +inst_vpermi2pd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPERMI2PD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1754) } +inst_vpermi2pd_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPERMI2PD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1754) } +inst_vpermi2pd_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPERMI2PD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1755) } +inst_vpermi2pd_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VPERMI2PD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1755) } +inst_vpermi2pd_zmm_zmm_zmm :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: ZMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPERMI2PD, operand_count = 3, ops = {op_zmm(dst), op_zmm(src), op_zmm(src2), {}} }, 1756) } +inst_vpermi2pd_zmm_zmm_m512 :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: Mem512) -> Instruction { return with_hint(Instruction{ mnemonic = .VPERMI2PD, operand_count = 3, ops = {op_zmm(dst), op_zmm(src), op_mem(src2.mem, 64), {}} }, 1756) } +emit_vpermi2pd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vpermi2pd_xmm_xmm_xmm(dst, src, src2)) } +emit_vpermi2pd_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vpermi2pd_xmm_xmm_m128(dst, src, src2)) } +emit_vpermi2pd_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vpermi2pd_ymm_ymm_ymm(dst, src, src2)) } +emit_vpermi2pd_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vpermi2pd_ymm_ymm_m256(dst, src, src2)) } +emit_vpermi2pd_zmm_zmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: ZMM) { append(instructions, inst_vpermi2pd_zmm_zmm_zmm(dst, src, src2)) } +emit_vpermi2pd_zmm_zmm_m512 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: Mem512) { append(instructions, inst_vpermi2pd_zmm_zmm_m512(dst, src, src2)) } +inst_vpermt2b_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPERMT2B, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1757) } +inst_vpermt2b_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPERMT2B, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1757) } +inst_vpermt2b_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPERMT2B, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1758) } +inst_vpermt2b_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VPERMT2B, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1758) } +inst_vpermt2b_zmm_zmm_zmm :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: ZMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPERMT2B, operand_count = 3, ops = {op_zmm(dst), op_zmm(src), op_zmm(src2), {}} }, 1759) } +inst_vpermt2b_zmm_zmm_m512 :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: Mem512) -> Instruction { return with_hint(Instruction{ mnemonic = .VPERMT2B, operand_count = 3, ops = {op_zmm(dst), op_zmm(src), op_mem(src2.mem, 64), {}} }, 1759) } +emit_vpermt2b_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vpermt2b_xmm_xmm_xmm(dst, src, src2)) } +emit_vpermt2b_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vpermt2b_xmm_xmm_m128(dst, src, src2)) } +emit_vpermt2b_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vpermt2b_ymm_ymm_ymm(dst, src, src2)) } +emit_vpermt2b_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vpermt2b_ymm_ymm_m256(dst, src, src2)) } +emit_vpermt2b_zmm_zmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: ZMM) { append(instructions, inst_vpermt2b_zmm_zmm_zmm(dst, src, src2)) } +emit_vpermt2b_zmm_zmm_m512 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: Mem512) { append(instructions, inst_vpermt2b_zmm_zmm_m512(dst, src, src2)) } +inst_vpermt2w_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPERMT2W, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1760) } +inst_vpermt2w_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPERMT2W, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1760) } +inst_vpermt2w_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPERMT2W, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1761) } +inst_vpermt2w_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VPERMT2W, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1761) } +inst_vpermt2w_zmm_zmm_zmm :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: ZMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPERMT2W, operand_count = 3, ops = {op_zmm(dst), op_zmm(src), op_zmm(src2), {}} }, 1762) } +inst_vpermt2w_zmm_zmm_m512 :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: Mem512) -> Instruction { return with_hint(Instruction{ mnemonic = .VPERMT2W, operand_count = 3, ops = {op_zmm(dst), op_zmm(src), op_mem(src2.mem, 64), {}} }, 1762) } +emit_vpermt2w_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vpermt2w_xmm_xmm_xmm(dst, src, src2)) } +emit_vpermt2w_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vpermt2w_xmm_xmm_m128(dst, src, src2)) } +emit_vpermt2w_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vpermt2w_ymm_ymm_ymm(dst, src, src2)) } +emit_vpermt2w_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vpermt2w_ymm_ymm_m256(dst, src, src2)) } +emit_vpermt2w_zmm_zmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: ZMM) { append(instructions, inst_vpermt2w_zmm_zmm_zmm(dst, src, src2)) } +emit_vpermt2w_zmm_zmm_m512 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: Mem512) { append(instructions, inst_vpermt2w_zmm_zmm_m512(dst, src, src2)) } +inst_vpermt2d_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPERMT2D, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1763) } +inst_vpermt2d_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPERMT2D, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1763) } +inst_vpermt2d_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPERMT2D, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1764) } +inst_vpermt2d_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VPERMT2D, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1764) } +inst_vpermt2d_zmm_zmm_zmm :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: ZMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPERMT2D, operand_count = 3, ops = {op_zmm(dst), op_zmm(src), op_zmm(src2), {}} }, 1765) } +inst_vpermt2d_zmm_zmm_m512 :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: Mem512) -> Instruction { return with_hint(Instruction{ mnemonic = .VPERMT2D, operand_count = 3, ops = {op_zmm(dst), op_zmm(src), op_mem(src2.mem, 64), {}} }, 1765) } +emit_vpermt2d_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vpermt2d_xmm_xmm_xmm(dst, src, src2)) } +emit_vpermt2d_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vpermt2d_xmm_xmm_m128(dst, src, src2)) } +emit_vpermt2d_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vpermt2d_ymm_ymm_ymm(dst, src, src2)) } +emit_vpermt2d_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vpermt2d_ymm_ymm_m256(dst, src, src2)) } +emit_vpermt2d_zmm_zmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: ZMM) { append(instructions, inst_vpermt2d_zmm_zmm_zmm(dst, src, src2)) } +emit_vpermt2d_zmm_zmm_m512 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: Mem512) { append(instructions, inst_vpermt2d_zmm_zmm_m512(dst, src, src2)) } +inst_vpermt2q_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPERMT2Q, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1766) } +inst_vpermt2q_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPERMT2Q, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1766) } +inst_vpermt2q_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPERMT2Q, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1767) } +inst_vpermt2q_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VPERMT2Q, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1767) } +inst_vpermt2q_zmm_zmm_zmm :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: ZMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPERMT2Q, operand_count = 3, ops = {op_zmm(dst), op_zmm(src), op_zmm(src2), {}} }, 1768) } +inst_vpermt2q_zmm_zmm_m512 :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: Mem512) -> Instruction { return with_hint(Instruction{ mnemonic = .VPERMT2Q, operand_count = 3, ops = {op_zmm(dst), op_zmm(src), op_mem(src2.mem, 64), {}} }, 1768) } +emit_vpermt2q_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vpermt2q_xmm_xmm_xmm(dst, src, src2)) } +emit_vpermt2q_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vpermt2q_xmm_xmm_m128(dst, src, src2)) } +emit_vpermt2q_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vpermt2q_ymm_ymm_ymm(dst, src, src2)) } +emit_vpermt2q_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vpermt2q_ymm_ymm_m256(dst, src, src2)) } +emit_vpermt2q_zmm_zmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: ZMM) { append(instructions, inst_vpermt2q_zmm_zmm_zmm(dst, src, src2)) } +emit_vpermt2q_zmm_zmm_m512 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: Mem512) { append(instructions, inst_vpermt2q_zmm_zmm_m512(dst, src, src2)) } +inst_vpermt2ps_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPERMT2PS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1769) } +inst_vpermt2ps_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPERMT2PS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1769) } +inst_vpermt2ps_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPERMT2PS, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1770) } +inst_vpermt2ps_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VPERMT2PS, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1770) } +inst_vpermt2ps_zmm_zmm_zmm :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: ZMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPERMT2PS, operand_count = 3, ops = {op_zmm(dst), op_zmm(src), op_zmm(src2), {}} }, 1771) } +inst_vpermt2ps_zmm_zmm_m512 :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: Mem512) -> Instruction { return with_hint(Instruction{ mnemonic = .VPERMT2PS, operand_count = 3, ops = {op_zmm(dst), op_zmm(src), op_mem(src2.mem, 64), {}} }, 1771) } +emit_vpermt2ps_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vpermt2ps_xmm_xmm_xmm(dst, src, src2)) } +emit_vpermt2ps_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vpermt2ps_xmm_xmm_m128(dst, src, src2)) } +emit_vpermt2ps_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vpermt2ps_ymm_ymm_ymm(dst, src, src2)) } +emit_vpermt2ps_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vpermt2ps_ymm_ymm_m256(dst, src, src2)) } +emit_vpermt2ps_zmm_zmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: ZMM) { append(instructions, inst_vpermt2ps_zmm_zmm_zmm(dst, src, src2)) } +emit_vpermt2ps_zmm_zmm_m512 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: Mem512) { append(instructions, inst_vpermt2ps_zmm_zmm_m512(dst, src, src2)) } +inst_vpermt2pd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPERMT2PD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1772) } +inst_vpermt2pd_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPERMT2PD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1772) } +inst_vpermt2pd_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPERMT2PD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1773) } +inst_vpermt2pd_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VPERMT2PD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1773) } +inst_vpermt2pd_zmm_zmm_zmm :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: ZMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPERMT2PD, operand_count = 3, ops = {op_zmm(dst), op_zmm(src), op_zmm(src2), {}} }, 1774) } +inst_vpermt2pd_zmm_zmm_m512 :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: Mem512) -> Instruction { return with_hint(Instruction{ mnemonic = .VPERMT2PD, operand_count = 3, ops = {op_zmm(dst), op_zmm(src), op_mem(src2.mem, 64), {}} }, 1774) } +emit_vpermt2pd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vpermt2pd_xmm_xmm_xmm(dst, src, src2)) } +emit_vpermt2pd_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vpermt2pd_xmm_xmm_m128(dst, src, src2)) } +emit_vpermt2pd_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vpermt2pd_ymm_ymm_ymm(dst, src, src2)) } +emit_vpermt2pd_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vpermt2pd_ymm_ymm_m256(dst, src, src2)) } +emit_vpermt2pd_zmm_zmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: ZMM) { append(instructions, inst_vpermt2pd_zmm_zmm_zmm(dst, src, src2)) } +emit_vpermt2pd_zmm_zmm_m512 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: Mem512) { append(instructions, inst_vpermt2pd_zmm_zmm_m512(dst, src, src2)) } +inst_vpermb_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPERMB, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1775) } +inst_vpermb_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPERMB, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1775) } +inst_vpermb_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPERMB, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1776) } +inst_vpermb_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VPERMB, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1776) } +inst_vpermb_zmm_zmm_zmm :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: ZMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPERMB, operand_count = 3, ops = {op_zmm(dst), op_zmm(src), op_zmm(src2), {}} }, 1777) } +inst_vpermb_zmm_zmm_m512 :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: Mem512) -> Instruction { return with_hint(Instruction{ mnemonic = .VPERMB, operand_count = 3, ops = {op_zmm(dst), op_zmm(src), op_mem(src2.mem, 64), {}} }, 1777) } +emit_vpermb_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vpermb_xmm_xmm_xmm(dst, src, src2)) } +emit_vpermb_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vpermb_xmm_xmm_m128(dst, src, src2)) } +emit_vpermb_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vpermb_ymm_ymm_ymm(dst, src, src2)) } +emit_vpermb_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vpermb_ymm_ymm_m256(dst, src, src2)) } +emit_vpermb_zmm_zmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: ZMM) { append(instructions, inst_vpermb_zmm_zmm_zmm(dst, src, src2)) } +emit_vpermb_zmm_zmm_m512 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: Mem512) { append(instructions, inst_vpermb_zmm_zmm_m512(dst, src, src2)) } +inst_vpermw_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPERMW, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1778) } +inst_vpermw_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPERMW, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1778) } +inst_vpermw_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPERMW, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1779) } +inst_vpermw_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VPERMW, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1779) } +inst_vpermw_zmm_zmm_zmm :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: ZMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPERMW, operand_count = 3, ops = {op_zmm(dst), op_zmm(src), op_zmm(src2), {}} }, 1780) } +inst_vpermw_zmm_zmm_m512 :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: Mem512) -> Instruction { return with_hint(Instruction{ mnemonic = .VPERMW, operand_count = 3, ops = {op_zmm(dst), op_zmm(src), op_mem(src2.mem, 64), {}} }, 1780) } +emit_vpermw_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vpermw_xmm_xmm_xmm(dst, src, src2)) } +emit_vpermw_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vpermw_xmm_xmm_m128(dst, src, src2)) } +emit_vpermw_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vpermw_ymm_ymm_ymm(dst, src, src2)) } +emit_vpermw_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vpermw_ymm_ymm_m256(dst, src, src2)) } +emit_vpermw_zmm_zmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: ZMM) { append(instructions, inst_vpermw_zmm_zmm_zmm(dst, src, src2)) } +emit_vpermw_zmm_zmm_m512 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: Mem512) { append(instructions, inst_vpermw_zmm_zmm_m512(dst, src, src2)) } +inst_vpmovb2m_k_xmm :: #force_inline proc "contextless" (dst: KREG, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVB2M, operand_count = 2, ops = {op_kreg(dst), op_xmm(src), {}, {}} }, 1781) } +inst_vpmovb2m_k_ymm :: #force_inline proc "contextless" (dst: KREG, src: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVB2M, operand_count = 2, ops = {op_kreg(dst), op_ymm(src), {}, {}} }, 1782) } +inst_vpmovb2m_k_zmm :: #force_inline proc "contextless" (dst: KREG, src: ZMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVB2M, operand_count = 2, ops = {op_kreg(dst), op_zmm(src), {}, {}} }, 1783) } +emit_vpmovb2m_k_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: XMM) { append(instructions, inst_vpmovb2m_k_xmm(dst, src)) } +emit_vpmovb2m_k_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: YMM) { append(instructions, inst_vpmovb2m_k_ymm(dst, src)) } +emit_vpmovb2m_k_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: ZMM) { append(instructions, inst_vpmovb2m_k_zmm(dst, src)) } +inst_vpmovw2m_k_xmm :: #force_inline proc "contextless" (dst: KREG, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVW2M, operand_count = 2, ops = {op_kreg(dst), op_xmm(src), {}, {}} }, 1784) } +inst_vpmovw2m_k_ymm :: #force_inline proc "contextless" (dst: KREG, src: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVW2M, operand_count = 2, ops = {op_kreg(dst), op_ymm(src), {}, {}} }, 1785) } +inst_vpmovw2m_k_zmm :: #force_inline proc "contextless" (dst: KREG, src: ZMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVW2M, operand_count = 2, ops = {op_kreg(dst), op_zmm(src), {}, {}} }, 1786) } +emit_vpmovw2m_k_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: XMM) { append(instructions, inst_vpmovw2m_k_xmm(dst, src)) } +emit_vpmovw2m_k_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: YMM) { append(instructions, inst_vpmovw2m_k_ymm(dst, src)) } +emit_vpmovw2m_k_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: ZMM) { append(instructions, inst_vpmovw2m_k_zmm(dst, src)) } +inst_vpmovd2m_k_xmm :: #force_inline proc "contextless" (dst: KREG, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVD2M, operand_count = 2, ops = {op_kreg(dst), op_xmm(src), {}, {}} }, 1787) } +inst_vpmovd2m_k_ymm :: #force_inline proc "contextless" (dst: KREG, src: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVD2M, operand_count = 2, ops = {op_kreg(dst), op_ymm(src), {}, {}} }, 1788) } +inst_vpmovd2m_k_zmm :: #force_inline proc "contextless" (dst: KREG, src: ZMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVD2M, operand_count = 2, ops = {op_kreg(dst), op_zmm(src), {}, {}} }, 1789) } +emit_vpmovd2m_k_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: XMM) { append(instructions, inst_vpmovd2m_k_xmm(dst, src)) } +emit_vpmovd2m_k_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: YMM) { append(instructions, inst_vpmovd2m_k_ymm(dst, src)) } +emit_vpmovd2m_k_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: ZMM) { append(instructions, inst_vpmovd2m_k_zmm(dst, src)) } +inst_vpmovq2m_k_xmm :: #force_inline proc "contextless" (dst: KREG, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVQ2M, operand_count = 2, ops = {op_kreg(dst), op_xmm(src), {}, {}} }, 1790) } +inst_vpmovq2m_k_ymm :: #force_inline proc "contextless" (dst: KREG, src: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVQ2M, operand_count = 2, ops = {op_kreg(dst), op_ymm(src), {}, {}} }, 1791) } +inst_vpmovq2m_k_zmm :: #force_inline proc "contextless" (dst: KREG, src: ZMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVQ2M, operand_count = 2, ops = {op_kreg(dst), op_zmm(src), {}, {}} }, 1792) } +emit_vpmovq2m_k_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: XMM) { append(instructions, inst_vpmovq2m_k_xmm(dst, src)) } +emit_vpmovq2m_k_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: YMM) { append(instructions, inst_vpmovq2m_k_ymm(dst, src)) } +emit_vpmovq2m_k_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: ZMM) { append(instructions, inst_vpmovq2m_k_zmm(dst, src)) } +inst_vpmovm2b_xmm_k :: #force_inline proc "contextless" (dst: XMM, src: KREG) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVM2B, operand_count = 2, ops = {op_xmm(dst), op_kreg(src), {}, {}} }, 1793) } +inst_vpmovm2b_ymm_k :: #force_inline proc "contextless" (dst: YMM, src: KREG) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVM2B, operand_count = 2, ops = {op_ymm(dst), op_kreg(src), {}, {}} }, 1794) } +inst_vpmovm2b_zmm_k :: #force_inline proc "contextless" (dst: ZMM, src: KREG) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVM2B, operand_count = 2, ops = {op_zmm(dst), op_kreg(src), {}, {}} }, 1795) } +emit_vpmovm2b_xmm_k :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: KREG) { append(instructions, inst_vpmovm2b_xmm_k(dst, src)) } +emit_vpmovm2b_ymm_k :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: KREG) { append(instructions, inst_vpmovm2b_ymm_k(dst, src)) } +emit_vpmovm2b_zmm_k :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: KREG) { append(instructions, inst_vpmovm2b_zmm_k(dst, src)) } +inst_vpmovm2w_xmm_k :: #force_inline proc "contextless" (dst: XMM, src: KREG) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVM2W, operand_count = 2, ops = {op_xmm(dst), op_kreg(src), {}, {}} }, 1796) } +inst_vpmovm2w_ymm_k :: #force_inline proc "contextless" (dst: YMM, src: KREG) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVM2W, operand_count = 2, ops = {op_ymm(dst), op_kreg(src), {}, {}} }, 1797) } +inst_vpmovm2w_zmm_k :: #force_inline proc "contextless" (dst: ZMM, src: KREG) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVM2W, operand_count = 2, ops = {op_zmm(dst), op_kreg(src), {}, {}} }, 1798) } +emit_vpmovm2w_xmm_k :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: KREG) { append(instructions, inst_vpmovm2w_xmm_k(dst, src)) } +emit_vpmovm2w_ymm_k :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: KREG) { append(instructions, inst_vpmovm2w_ymm_k(dst, src)) } +emit_vpmovm2w_zmm_k :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: KREG) { append(instructions, inst_vpmovm2w_zmm_k(dst, src)) } +inst_vpmovm2d_xmm_k :: #force_inline proc "contextless" (dst: XMM, src: KREG) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVM2D, operand_count = 2, ops = {op_xmm(dst), op_kreg(src), {}, {}} }, 1799) } +inst_vpmovm2d_ymm_k :: #force_inline proc "contextless" (dst: YMM, src: KREG) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVM2D, operand_count = 2, ops = {op_ymm(dst), op_kreg(src), {}, {}} }, 1800) } +inst_vpmovm2d_zmm_k :: #force_inline proc "contextless" (dst: ZMM, src: KREG) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVM2D, operand_count = 2, ops = {op_zmm(dst), op_kreg(src), {}, {}} }, 1801) } +emit_vpmovm2d_xmm_k :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: KREG) { append(instructions, inst_vpmovm2d_xmm_k(dst, src)) } +emit_vpmovm2d_ymm_k :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: KREG) { append(instructions, inst_vpmovm2d_ymm_k(dst, src)) } +emit_vpmovm2d_zmm_k :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: KREG) { append(instructions, inst_vpmovm2d_zmm_k(dst, src)) } +inst_vpmovm2q_xmm_k :: #force_inline proc "contextless" (dst: XMM, src: KREG) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVM2Q, operand_count = 2, ops = {op_xmm(dst), op_kreg(src), {}, {}} }, 1802) } +inst_vpmovm2q_ymm_k :: #force_inline proc "contextless" (dst: YMM, src: KREG) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVM2Q, operand_count = 2, ops = {op_ymm(dst), op_kreg(src), {}, {}} }, 1803) } +inst_vpmovm2q_zmm_k :: #force_inline proc "contextless" (dst: ZMM, src: KREG) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVM2Q, operand_count = 2, ops = {op_zmm(dst), op_kreg(src), {}, {}} }, 1804) } +emit_vpmovm2q_xmm_k :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: KREG) { append(instructions, inst_vpmovm2q_xmm_k(dst, src)) } +emit_vpmovm2q_ymm_k :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: KREG) { append(instructions, inst_vpmovm2q_ymm_k(dst, src)) } +emit_vpmovm2q_zmm_k :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: KREG) { append(instructions, inst_vpmovm2q_zmm_k(dst, src)) } +inst_vpmovqb_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVQB, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 1805) } +inst_vpmovqb_m32_xmm :: #force_inline proc "contextless" (dst: Mem32, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVQB, operand_count = 2, ops = {op_mem(dst.mem, 4), op_xmm(src), {}, {}} }, 1805) } +inst_vpmovqb_xmm_ymm :: #force_inline proc "contextless" (dst: XMM, src: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVQB, operand_count = 2, ops = {op_xmm(dst), op_ymm(src), {}, {}} }, 1806) } +inst_vpmovqb_m32_ymm :: #force_inline proc "contextless" (dst: Mem32, src: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVQB, operand_count = 2, ops = {op_mem(dst.mem, 4), op_ymm(src), {}, {}} }, 1806) } +inst_vpmovqb_xmm_zmm :: #force_inline proc "contextless" (dst: XMM, src: ZMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVQB, operand_count = 2, ops = {op_xmm(dst), op_zmm(src), {}, {}} }, 1807) } +inst_vpmovqb_m64_zmm :: #force_inline proc "contextless" (dst: Mem64, src: ZMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVQB, operand_count = 2, ops = {op_mem(dst.mem, 8), op_zmm(src), {}, {}} }, 1807) } +emit_vpmovqb_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_vpmovqb_xmm_xmm(dst, src)) } +emit_vpmovqb_m32_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, src: XMM) { append(instructions, inst_vpmovqb_m32_xmm(dst, src)) } +emit_vpmovqb_xmm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: YMM) { append(instructions, inst_vpmovqb_xmm_ymm(dst, src)) } +emit_vpmovqb_m32_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, src: YMM) { append(instructions, inst_vpmovqb_m32_ymm(dst, src)) } +emit_vpmovqb_xmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: ZMM) { append(instructions, inst_vpmovqb_xmm_zmm(dst, src)) } +emit_vpmovqb_m64_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, src: ZMM) { append(instructions, inst_vpmovqb_m64_zmm(dst, src)) } +inst_vpmovsqb_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVSQB, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 1808) } +inst_vpmovsqb_m32_xmm :: #force_inline proc "contextless" (dst: Mem32, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVSQB, operand_count = 2, ops = {op_mem(dst.mem, 4), op_xmm(src), {}, {}} }, 1808) } +inst_vpmovsqb_xmm_ymm :: #force_inline proc "contextless" (dst: XMM, src: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVSQB, operand_count = 2, ops = {op_xmm(dst), op_ymm(src), {}, {}} }, 1809) } +inst_vpmovsqb_m32_ymm :: #force_inline proc "contextless" (dst: Mem32, src: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVSQB, operand_count = 2, ops = {op_mem(dst.mem, 4), op_ymm(src), {}, {}} }, 1809) } +inst_vpmovsqb_xmm_zmm :: #force_inline proc "contextless" (dst: XMM, src: ZMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVSQB, operand_count = 2, ops = {op_xmm(dst), op_zmm(src), {}, {}} }, 1810) } +inst_vpmovsqb_m64_zmm :: #force_inline proc "contextless" (dst: Mem64, src: ZMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVSQB, operand_count = 2, ops = {op_mem(dst.mem, 8), op_zmm(src), {}, {}} }, 1810) } +emit_vpmovsqb_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_vpmovsqb_xmm_xmm(dst, src)) } +emit_vpmovsqb_m32_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, src: XMM) { append(instructions, inst_vpmovsqb_m32_xmm(dst, src)) } +emit_vpmovsqb_xmm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: YMM) { append(instructions, inst_vpmovsqb_xmm_ymm(dst, src)) } +emit_vpmovsqb_m32_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, src: YMM) { append(instructions, inst_vpmovsqb_m32_ymm(dst, src)) } +emit_vpmovsqb_xmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: ZMM) { append(instructions, inst_vpmovsqb_xmm_zmm(dst, src)) } +emit_vpmovsqb_m64_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, src: ZMM) { append(instructions, inst_vpmovsqb_m64_zmm(dst, src)) } +inst_vpmovusqb_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVUSQB, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 1811) } +inst_vpmovusqb_m32_xmm :: #force_inline proc "contextless" (dst: Mem32, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVUSQB, operand_count = 2, ops = {op_mem(dst.mem, 4), op_xmm(src), {}, {}} }, 1811) } +inst_vpmovusqb_xmm_ymm :: #force_inline proc "contextless" (dst: XMM, src: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVUSQB, operand_count = 2, ops = {op_xmm(dst), op_ymm(src), {}, {}} }, 1812) } +inst_vpmovusqb_m32_ymm :: #force_inline proc "contextless" (dst: Mem32, src: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVUSQB, operand_count = 2, ops = {op_mem(dst.mem, 4), op_ymm(src), {}, {}} }, 1812) } +inst_vpmovusqb_xmm_zmm :: #force_inline proc "contextless" (dst: XMM, src: ZMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVUSQB, operand_count = 2, ops = {op_xmm(dst), op_zmm(src), {}, {}} }, 1813) } +inst_vpmovusqb_m64_zmm :: #force_inline proc "contextless" (dst: Mem64, src: ZMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVUSQB, operand_count = 2, ops = {op_mem(dst.mem, 8), op_zmm(src), {}, {}} }, 1813) } +emit_vpmovusqb_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_vpmovusqb_xmm_xmm(dst, src)) } +emit_vpmovusqb_m32_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, src: XMM) { append(instructions, inst_vpmovusqb_m32_xmm(dst, src)) } +emit_vpmovusqb_xmm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: YMM) { append(instructions, inst_vpmovusqb_xmm_ymm(dst, src)) } +emit_vpmovusqb_m32_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, src: YMM) { append(instructions, inst_vpmovusqb_m32_ymm(dst, src)) } +emit_vpmovusqb_xmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: ZMM) { append(instructions, inst_vpmovusqb_xmm_zmm(dst, src)) } +emit_vpmovusqb_m64_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, src: ZMM) { append(instructions, inst_vpmovusqb_m64_zmm(dst, src)) } +inst_vpmovqw_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVQW, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 1814) } +inst_vpmovqw_m32_xmm :: #force_inline proc "contextless" (dst: Mem32, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVQW, operand_count = 2, ops = {op_mem(dst.mem, 4), op_xmm(src), {}, {}} }, 1814) } +inst_vpmovqw_xmm_ymm :: #force_inline proc "contextless" (dst: XMM, src: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVQW, operand_count = 2, ops = {op_xmm(dst), op_ymm(src), {}, {}} }, 1815) } +inst_vpmovqw_m64_ymm :: #force_inline proc "contextless" (dst: Mem64, src: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVQW, operand_count = 2, ops = {op_mem(dst.mem, 8), op_ymm(src), {}, {}} }, 1815) } +inst_vpmovqw_xmm_zmm :: #force_inline proc "contextless" (dst: XMM, src: ZMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVQW, operand_count = 2, ops = {op_xmm(dst), op_zmm(src), {}, {}} }, 1816) } +inst_vpmovqw_m128_zmm :: #force_inline proc "contextless" (dst: Mem128, src: ZMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVQW, operand_count = 2, ops = {op_mem(dst.mem, 16), op_zmm(src), {}, {}} }, 1816) } +emit_vpmovqw_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_vpmovqw_xmm_xmm(dst, src)) } +emit_vpmovqw_m32_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, src: XMM) { append(instructions, inst_vpmovqw_m32_xmm(dst, src)) } +emit_vpmovqw_xmm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: YMM) { append(instructions, inst_vpmovqw_xmm_ymm(dst, src)) } +emit_vpmovqw_m64_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, src: YMM) { append(instructions, inst_vpmovqw_m64_ymm(dst, src)) } +emit_vpmovqw_xmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: ZMM) { append(instructions, inst_vpmovqw_xmm_zmm(dst, src)) } +emit_vpmovqw_m128_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem128, src: ZMM) { append(instructions, inst_vpmovqw_m128_zmm(dst, src)) } +inst_vpmovsqw_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVSQW, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 1817) } +inst_vpmovsqw_m32_xmm :: #force_inline proc "contextless" (dst: Mem32, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVSQW, operand_count = 2, ops = {op_mem(dst.mem, 4), op_xmm(src), {}, {}} }, 1817) } +inst_vpmovsqw_xmm_ymm :: #force_inline proc "contextless" (dst: XMM, src: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVSQW, operand_count = 2, ops = {op_xmm(dst), op_ymm(src), {}, {}} }, 1818) } +inst_vpmovsqw_m64_ymm :: #force_inline proc "contextless" (dst: Mem64, src: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVSQW, operand_count = 2, ops = {op_mem(dst.mem, 8), op_ymm(src), {}, {}} }, 1818) } +inst_vpmovsqw_xmm_zmm :: #force_inline proc "contextless" (dst: XMM, src: ZMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVSQW, operand_count = 2, ops = {op_xmm(dst), op_zmm(src), {}, {}} }, 1819) } +inst_vpmovsqw_m128_zmm :: #force_inline proc "contextless" (dst: Mem128, src: ZMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVSQW, operand_count = 2, ops = {op_mem(dst.mem, 16), op_zmm(src), {}, {}} }, 1819) } +emit_vpmovsqw_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_vpmovsqw_xmm_xmm(dst, src)) } +emit_vpmovsqw_m32_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, src: XMM) { append(instructions, inst_vpmovsqw_m32_xmm(dst, src)) } +emit_vpmovsqw_xmm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: YMM) { append(instructions, inst_vpmovsqw_xmm_ymm(dst, src)) } +emit_vpmovsqw_m64_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, src: YMM) { append(instructions, inst_vpmovsqw_m64_ymm(dst, src)) } +emit_vpmovsqw_xmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: ZMM) { append(instructions, inst_vpmovsqw_xmm_zmm(dst, src)) } +emit_vpmovsqw_m128_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem128, src: ZMM) { append(instructions, inst_vpmovsqw_m128_zmm(dst, src)) } +inst_vpmovusqw_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVUSQW, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 1820) } +inst_vpmovusqw_m32_xmm :: #force_inline proc "contextless" (dst: Mem32, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVUSQW, operand_count = 2, ops = {op_mem(dst.mem, 4), op_xmm(src), {}, {}} }, 1820) } +inst_vpmovusqw_xmm_ymm :: #force_inline proc "contextless" (dst: XMM, src: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVUSQW, operand_count = 2, ops = {op_xmm(dst), op_ymm(src), {}, {}} }, 1821) } +inst_vpmovusqw_m64_ymm :: #force_inline proc "contextless" (dst: Mem64, src: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVUSQW, operand_count = 2, ops = {op_mem(dst.mem, 8), op_ymm(src), {}, {}} }, 1821) } +inst_vpmovusqw_xmm_zmm :: #force_inline proc "contextless" (dst: XMM, src: ZMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVUSQW, operand_count = 2, ops = {op_xmm(dst), op_zmm(src), {}, {}} }, 1822) } +inst_vpmovusqw_m128_zmm :: #force_inline proc "contextless" (dst: Mem128, src: ZMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVUSQW, operand_count = 2, ops = {op_mem(dst.mem, 16), op_zmm(src), {}, {}} }, 1822) } +emit_vpmovusqw_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_vpmovusqw_xmm_xmm(dst, src)) } +emit_vpmovusqw_m32_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, src: XMM) { append(instructions, inst_vpmovusqw_m32_xmm(dst, src)) } +emit_vpmovusqw_xmm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: YMM) { append(instructions, inst_vpmovusqw_xmm_ymm(dst, src)) } +emit_vpmovusqw_m64_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, src: YMM) { append(instructions, inst_vpmovusqw_m64_ymm(dst, src)) } +emit_vpmovusqw_xmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: ZMM) { append(instructions, inst_vpmovusqw_xmm_zmm(dst, src)) } +emit_vpmovusqw_m128_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem128, src: ZMM) { append(instructions, inst_vpmovusqw_m128_zmm(dst, src)) } +inst_vpmovqd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVQD, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 1823) } +inst_vpmovqd_m64_xmm :: #force_inline proc "contextless" (dst: Mem64, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVQD, operand_count = 2, ops = {op_mem(dst.mem, 8), op_xmm(src), {}, {}} }, 1823) } +inst_vpmovqd_xmm_ymm :: #force_inline proc "contextless" (dst: XMM, src: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVQD, operand_count = 2, ops = {op_xmm(dst), op_ymm(src), {}, {}} }, 1824) } +inst_vpmovqd_m128_ymm :: #force_inline proc "contextless" (dst: Mem128, src: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVQD, operand_count = 2, ops = {op_mem(dst.mem, 16), op_ymm(src), {}, {}} }, 1824) } +inst_vpmovqd_ymm_zmm :: #force_inline proc "contextless" (dst: YMM, src: ZMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVQD, operand_count = 2, ops = {op_ymm(dst), op_zmm(src), {}, {}} }, 1825) } +inst_vpmovqd_m256_zmm :: #force_inline proc "contextless" (dst: Mem256, src: ZMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVQD, operand_count = 2, ops = {op_mem(dst.mem, 32), op_zmm(src), {}, {}} }, 1825) } +emit_vpmovqd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_vpmovqd_xmm_xmm(dst, src)) } +emit_vpmovqd_m64_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, src: XMM) { append(instructions, inst_vpmovqd_m64_xmm(dst, src)) } +emit_vpmovqd_xmm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: YMM) { append(instructions, inst_vpmovqd_xmm_ymm(dst, src)) } +emit_vpmovqd_m128_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem128, src: YMM) { append(instructions, inst_vpmovqd_m128_ymm(dst, src)) } +emit_vpmovqd_ymm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: ZMM) { append(instructions, inst_vpmovqd_ymm_zmm(dst, src)) } +emit_vpmovqd_m256_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem256, src: ZMM) { append(instructions, inst_vpmovqd_m256_zmm(dst, src)) } +inst_vpmovsqd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVSQD, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 1826) } +inst_vpmovsqd_m64_xmm :: #force_inline proc "contextless" (dst: Mem64, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVSQD, operand_count = 2, ops = {op_mem(dst.mem, 8), op_xmm(src), {}, {}} }, 1826) } +inst_vpmovsqd_xmm_ymm :: #force_inline proc "contextless" (dst: XMM, src: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVSQD, operand_count = 2, ops = {op_xmm(dst), op_ymm(src), {}, {}} }, 1827) } +inst_vpmovsqd_m128_ymm :: #force_inline proc "contextless" (dst: Mem128, src: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVSQD, operand_count = 2, ops = {op_mem(dst.mem, 16), op_ymm(src), {}, {}} }, 1827) } +inst_vpmovsqd_ymm_zmm :: #force_inline proc "contextless" (dst: YMM, src: ZMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVSQD, operand_count = 2, ops = {op_ymm(dst), op_zmm(src), {}, {}} }, 1828) } +inst_vpmovsqd_m256_zmm :: #force_inline proc "contextless" (dst: Mem256, src: ZMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVSQD, operand_count = 2, ops = {op_mem(dst.mem, 32), op_zmm(src), {}, {}} }, 1828) } +emit_vpmovsqd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_vpmovsqd_xmm_xmm(dst, src)) } +emit_vpmovsqd_m64_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, src: XMM) { append(instructions, inst_vpmovsqd_m64_xmm(dst, src)) } +emit_vpmovsqd_xmm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: YMM) { append(instructions, inst_vpmovsqd_xmm_ymm(dst, src)) } +emit_vpmovsqd_m128_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem128, src: YMM) { append(instructions, inst_vpmovsqd_m128_ymm(dst, src)) } +emit_vpmovsqd_ymm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: ZMM) { append(instructions, inst_vpmovsqd_ymm_zmm(dst, src)) } +emit_vpmovsqd_m256_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem256, src: ZMM) { append(instructions, inst_vpmovsqd_m256_zmm(dst, src)) } +inst_vpmovusqd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVUSQD, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 1829) } +inst_vpmovusqd_m64_xmm :: #force_inline proc "contextless" (dst: Mem64, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVUSQD, operand_count = 2, ops = {op_mem(dst.mem, 8), op_xmm(src), {}, {}} }, 1829) } +inst_vpmovusqd_xmm_ymm :: #force_inline proc "contextless" (dst: XMM, src: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVUSQD, operand_count = 2, ops = {op_xmm(dst), op_ymm(src), {}, {}} }, 1830) } +inst_vpmovusqd_m128_ymm :: #force_inline proc "contextless" (dst: Mem128, src: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVUSQD, operand_count = 2, ops = {op_mem(dst.mem, 16), op_ymm(src), {}, {}} }, 1830) } +inst_vpmovusqd_ymm_zmm :: #force_inline proc "contextless" (dst: YMM, src: ZMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVUSQD, operand_count = 2, ops = {op_ymm(dst), op_zmm(src), {}, {}} }, 1831) } +inst_vpmovusqd_m256_zmm :: #force_inline proc "contextless" (dst: Mem256, src: ZMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVUSQD, operand_count = 2, ops = {op_mem(dst.mem, 32), op_zmm(src), {}, {}} }, 1831) } +emit_vpmovusqd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_vpmovusqd_xmm_xmm(dst, src)) } +emit_vpmovusqd_m64_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, src: XMM) { append(instructions, inst_vpmovusqd_m64_xmm(dst, src)) } +emit_vpmovusqd_xmm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: YMM) { append(instructions, inst_vpmovusqd_xmm_ymm(dst, src)) } +emit_vpmovusqd_m128_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem128, src: YMM) { append(instructions, inst_vpmovusqd_m128_ymm(dst, src)) } +emit_vpmovusqd_ymm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: ZMM) { append(instructions, inst_vpmovusqd_ymm_zmm(dst, src)) } +emit_vpmovusqd_m256_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem256, src: ZMM) { append(instructions, inst_vpmovusqd_m256_zmm(dst, src)) } +inst_vpmovdb_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVDB, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 1832) } +inst_vpmovdb_m32_xmm :: #force_inline proc "contextless" (dst: Mem32, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVDB, operand_count = 2, ops = {op_mem(dst.mem, 4), op_xmm(src), {}, {}} }, 1832) } +inst_vpmovdb_xmm_ymm :: #force_inline proc "contextless" (dst: XMM, src: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVDB, operand_count = 2, ops = {op_xmm(dst), op_ymm(src), {}, {}} }, 1833) } +inst_vpmovdb_m64_ymm :: #force_inline proc "contextless" (dst: Mem64, src: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVDB, operand_count = 2, ops = {op_mem(dst.mem, 8), op_ymm(src), {}, {}} }, 1833) } +inst_vpmovdb_xmm_zmm :: #force_inline proc "contextless" (dst: XMM, src: ZMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVDB, operand_count = 2, ops = {op_xmm(dst), op_zmm(src), {}, {}} }, 1834) } +inst_vpmovdb_m128_zmm :: #force_inline proc "contextless" (dst: Mem128, src: ZMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVDB, operand_count = 2, ops = {op_mem(dst.mem, 16), op_zmm(src), {}, {}} }, 1834) } +emit_vpmovdb_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_vpmovdb_xmm_xmm(dst, src)) } +emit_vpmovdb_m32_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, src: XMM) { append(instructions, inst_vpmovdb_m32_xmm(dst, src)) } +emit_vpmovdb_xmm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: YMM) { append(instructions, inst_vpmovdb_xmm_ymm(dst, src)) } +emit_vpmovdb_m64_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, src: YMM) { append(instructions, inst_vpmovdb_m64_ymm(dst, src)) } +emit_vpmovdb_xmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: ZMM) { append(instructions, inst_vpmovdb_xmm_zmm(dst, src)) } +emit_vpmovdb_m128_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem128, src: ZMM) { append(instructions, inst_vpmovdb_m128_zmm(dst, src)) } +inst_vpmovsdb_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVSDB, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 1835) } +inst_vpmovsdb_m32_xmm :: #force_inline proc "contextless" (dst: Mem32, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVSDB, operand_count = 2, ops = {op_mem(dst.mem, 4), op_xmm(src), {}, {}} }, 1835) } +inst_vpmovsdb_xmm_ymm :: #force_inline proc "contextless" (dst: XMM, src: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVSDB, operand_count = 2, ops = {op_xmm(dst), op_ymm(src), {}, {}} }, 1836) } +inst_vpmovsdb_m64_ymm :: #force_inline proc "contextless" (dst: Mem64, src: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVSDB, operand_count = 2, ops = {op_mem(dst.mem, 8), op_ymm(src), {}, {}} }, 1836) } +inst_vpmovsdb_xmm_zmm :: #force_inline proc "contextless" (dst: XMM, src: ZMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVSDB, operand_count = 2, ops = {op_xmm(dst), op_zmm(src), {}, {}} }, 1837) } +inst_vpmovsdb_m128_zmm :: #force_inline proc "contextless" (dst: Mem128, src: ZMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVSDB, operand_count = 2, ops = {op_mem(dst.mem, 16), op_zmm(src), {}, {}} }, 1837) } +emit_vpmovsdb_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_vpmovsdb_xmm_xmm(dst, src)) } +emit_vpmovsdb_m32_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, src: XMM) { append(instructions, inst_vpmovsdb_m32_xmm(dst, src)) } +emit_vpmovsdb_xmm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: YMM) { append(instructions, inst_vpmovsdb_xmm_ymm(dst, src)) } +emit_vpmovsdb_m64_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, src: YMM) { append(instructions, inst_vpmovsdb_m64_ymm(dst, src)) } +emit_vpmovsdb_xmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: ZMM) { append(instructions, inst_vpmovsdb_xmm_zmm(dst, src)) } +emit_vpmovsdb_m128_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem128, src: ZMM) { append(instructions, inst_vpmovsdb_m128_zmm(dst, src)) } +inst_vpmovusdb_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVUSDB, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 1838) } +inst_vpmovusdb_m32_xmm :: #force_inline proc "contextless" (dst: Mem32, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVUSDB, operand_count = 2, ops = {op_mem(dst.mem, 4), op_xmm(src), {}, {}} }, 1838) } +inst_vpmovusdb_xmm_ymm :: #force_inline proc "contextless" (dst: XMM, src: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVUSDB, operand_count = 2, ops = {op_xmm(dst), op_ymm(src), {}, {}} }, 1839) } +inst_vpmovusdb_m64_ymm :: #force_inline proc "contextless" (dst: Mem64, src: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVUSDB, operand_count = 2, ops = {op_mem(dst.mem, 8), op_ymm(src), {}, {}} }, 1839) } +inst_vpmovusdb_xmm_zmm :: #force_inline proc "contextless" (dst: XMM, src: ZMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVUSDB, operand_count = 2, ops = {op_xmm(dst), op_zmm(src), {}, {}} }, 1840) } +inst_vpmovusdb_m128_zmm :: #force_inline proc "contextless" (dst: Mem128, src: ZMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVUSDB, operand_count = 2, ops = {op_mem(dst.mem, 16), op_zmm(src), {}, {}} }, 1840) } +emit_vpmovusdb_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_vpmovusdb_xmm_xmm(dst, src)) } +emit_vpmovusdb_m32_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, src: XMM) { append(instructions, inst_vpmovusdb_m32_xmm(dst, src)) } +emit_vpmovusdb_xmm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: YMM) { append(instructions, inst_vpmovusdb_xmm_ymm(dst, src)) } +emit_vpmovusdb_m64_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, src: YMM) { append(instructions, inst_vpmovusdb_m64_ymm(dst, src)) } +emit_vpmovusdb_xmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: ZMM) { append(instructions, inst_vpmovusdb_xmm_zmm(dst, src)) } +emit_vpmovusdb_m128_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem128, src: ZMM) { append(instructions, inst_vpmovusdb_m128_zmm(dst, src)) } +inst_vpmovdw_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVDW, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 1841) } +inst_vpmovdw_m64_xmm :: #force_inline proc "contextless" (dst: Mem64, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVDW, operand_count = 2, ops = {op_mem(dst.mem, 8), op_xmm(src), {}, {}} }, 1841) } +inst_vpmovdw_xmm_ymm :: #force_inline proc "contextless" (dst: XMM, src: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVDW, operand_count = 2, ops = {op_xmm(dst), op_ymm(src), {}, {}} }, 1842) } +inst_vpmovdw_m128_ymm :: #force_inline proc "contextless" (dst: Mem128, src: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVDW, operand_count = 2, ops = {op_mem(dst.mem, 16), op_ymm(src), {}, {}} }, 1842) } +inst_vpmovdw_ymm_zmm :: #force_inline proc "contextless" (dst: YMM, src: ZMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVDW, operand_count = 2, ops = {op_ymm(dst), op_zmm(src), {}, {}} }, 1843) } +inst_vpmovdw_m256_zmm :: #force_inline proc "contextless" (dst: Mem256, src: ZMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVDW, operand_count = 2, ops = {op_mem(dst.mem, 32), op_zmm(src), {}, {}} }, 1843) } +emit_vpmovdw_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_vpmovdw_xmm_xmm(dst, src)) } +emit_vpmovdw_m64_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, src: XMM) { append(instructions, inst_vpmovdw_m64_xmm(dst, src)) } +emit_vpmovdw_xmm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: YMM) { append(instructions, inst_vpmovdw_xmm_ymm(dst, src)) } +emit_vpmovdw_m128_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem128, src: YMM) { append(instructions, inst_vpmovdw_m128_ymm(dst, src)) } +emit_vpmovdw_ymm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: ZMM) { append(instructions, inst_vpmovdw_ymm_zmm(dst, src)) } +emit_vpmovdw_m256_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem256, src: ZMM) { append(instructions, inst_vpmovdw_m256_zmm(dst, src)) } +inst_vpmovsdw_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVSDW, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 1844) } +inst_vpmovsdw_m64_xmm :: #force_inline proc "contextless" (dst: Mem64, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVSDW, operand_count = 2, ops = {op_mem(dst.mem, 8), op_xmm(src), {}, {}} }, 1844) } +inst_vpmovsdw_xmm_ymm :: #force_inline proc "contextless" (dst: XMM, src: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVSDW, operand_count = 2, ops = {op_xmm(dst), op_ymm(src), {}, {}} }, 1845) } +inst_vpmovsdw_m128_ymm :: #force_inline proc "contextless" (dst: Mem128, src: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVSDW, operand_count = 2, ops = {op_mem(dst.mem, 16), op_ymm(src), {}, {}} }, 1845) } +inst_vpmovsdw_ymm_zmm :: #force_inline proc "contextless" (dst: YMM, src: ZMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVSDW, operand_count = 2, ops = {op_ymm(dst), op_zmm(src), {}, {}} }, 1846) } +inst_vpmovsdw_m256_zmm :: #force_inline proc "contextless" (dst: Mem256, src: ZMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVSDW, operand_count = 2, ops = {op_mem(dst.mem, 32), op_zmm(src), {}, {}} }, 1846) } +emit_vpmovsdw_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_vpmovsdw_xmm_xmm(dst, src)) } +emit_vpmovsdw_m64_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, src: XMM) { append(instructions, inst_vpmovsdw_m64_xmm(dst, src)) } +emit_vpmovsdw_xmm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: YMM) { append(instructions, inst_vpmovsdw_xmm_ymm(dst, src)) } +emit_vpmovsdw_m128_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem128, src: YMM) { append(instructions, inst_vpmovsdw_m128_ymm(dst, src)) } +emit_vpmovsdw_ymm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: ZMM) { append(instructions, inst_vpmovsdw_ymm_zmm(dst, src)) } +emit_vpmovsdw_m256_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem256, src: ZMM) { append(instructions, inst_vpmovsdw_m256_zmm(dst, src)) } +inst_vpmovusdw_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVUSDW, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 1847) } +inst_vpmovusdw_m64_xmm :: #force_inline proc "contextless" (dst: Mem64, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVUSDW, operand_count = 2, ops = {op_mem(dst.mem, 8), op_xmm(src), {}, {}} }, 1847) } +inst_vpmovusdw_xmm_ymm :: #force_inline proc "contextless" (dst: XMM, src: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVUSDW, operand_count = 2, ops = {op_xmm(dst), op_ymm(src), {}, {}} }, 1848) } +inst_vpmovusdw_m128_ymm :: #force_inline proc "contextless" (dst: Mem128, src: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVUSDW, operand_count = 2, ops = {op_mem(dst.mem, 16), op_ymm(src), {}, {}} }, 1848) } +inst_vpmovusdw_ymm_zmm :: #force_inline proc "contextless" (dst: YMM, src: ZMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVUSDW, operand_count = 2, ops = {op_ymm(dst), op_zmm(src), {}, {}} }, 1849) } +inst_vpmovusdw_m256_zmm :: #force_inline proc "contextless" (dst: Mem256, src: ZMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVUSDW, operand_count = 2, ops = {op_mem(dst.mem, 32), op_zmm(src), {}, {}} }, 1849) } +emit_vpmovusdw_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_vpmovusdw_xmm_xmm(dst, src)) } +emit_vpmovusdw_m64_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, src: XMM) { append(instructions, inst_vpmovusdw_m64_xmm(dst, src)) } +emit_vpmovusdw_xmm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: YMM) { append(instructions, inst_vpmovusdw_xmm_ymm(dst, src)) } +emit_vpmovusdw_m128_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem128, src: YMM) { append(instructions, inst_vpmovusdw_m128_ymm(dst, src)) } +emit_vpmovusdw_ymm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: ZMM) { append(instructions, inst_vpmovusdw_ymm_zmm(dst, src)) } +emit_vpmovusdw_m256_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem256, src: ZMM) { append(instructions, inst_vpmovusdw_m256_zmm(dst, src)) } +inst_vpmovwb_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVWB, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 1850) } +inst_vpmovwb_m64_xmm :: #force_inline proc "contextless" (dst: Mem64, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVWB, operand_count = 2, ops = {op_mem(dst.mem, 8), op_xmm(src), {}, {}} }, 1850) } +inst_vpmovwb_xmm_ymm :: #force_inline proc "contextless" (dst: XMM, src: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVWB, operand_count = 2, ops = {op_xmm(dst), op_ymm(src), {}, {}} }, 1851) } +inst_vpmovwb_m128_ymm :: #force_inline proc "contextless" (dst: Mem128, src: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVWB, operand_count = 2, ops = {op_mem(dst.mem, 16), op_ymm(src), {}, {}} }, 1851) } +inst_vpmovwb_ymm_zmm :: #force_inline proc "contextless" (dst: YMM, src: ZMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVWB, operand_count = 2, ops = {op_ymm(dst), op_zmm(src), {}, {}} }, 1852) } +inst_vpmovwb_m256_zmm :: #force_inline proc "contextless" (dst: Mem256, src: ZMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVWB, operand_count = 2, ops = {op_mem(dst.mem, 32), op_zmm(src), {}, {}} }, 1852) } +emit_vpmovwb_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_vpmovwb_xmm_xmm(dst, src)) } +emit_vpmovwb_m64_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, src: XMM) { append(instructions, inst_vpmovwb_m64_xmm(dst, src)) } +emit_vpmovwb_xmm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: YMM) { append(instructions, inst_vpmovwb_xmm_ymm(dst, src)) } +emit_vpmovwb_m128_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem128, src: YMM) { append(instructions, inst_vpmovwb_m128_ymm(dst, src)) } +emit_vpmovwb_ymm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: ZMM) { append(instructions, inst_vpmovwb_ymm_zmm(dst, src)) } +emit_vpmovwb_m256_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem256, src: ZMM) { append(instructions, inst_vpmovwb_m256_zmm(dst, src)) } +inst_vpmovswb_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVSWB, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 1853) } +inst_vpmovswb_m64_xmm :: #force_inline proc "contextless" (dst: Mem64, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVSWB, operand_count = 2, ops = {op_mem(dst.mem, 8), op_xmm(src), {}, {}} }, 1853) } +inst_vpmovswb_xmm_ymm :: #force_inline proc "contextless" (dst: XMM, src: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVSWB, operand_count = 2, ops = {op_xmm(dst), op_ymm(src), {}, {}} }, 1854) } +inst_vpmovswb_m128_ymm :: #force_inline proc "contextless" (dst: Mem128, src: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVSWB, operand_count = 2, ops = {op_mem(dst.mem, 16), op_ymm(src), {}, {}} }, 1854) } +inst_vpmovswb_ymm_zmm :: #force_inline proc "contextless" (dst: YMM, src: ZMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVSWB, operand_count = 2, ops = {op_ymm(dst), op_zmm(src), {}, {}} }, 1855) } +inst_vpmovswb_m256_zmm :: #force_inline proc "contextless" (dst: Mem256, src: ZMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVSWB, operand_count = 2, ops = {op_mem(dst.mem, 32), op_zmm(src), {}, {}} }, 1855) } +emit_vpmovswb_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_vpmovswb_xmm_xmm(dst, src)) } +emit_vpmovswb_m64_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, src: XMM) { append(instructions, inst_vpmovswb_m64_xmm(dst, src)) } +emit_vpmovswb_xmm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: YMM) { append(instructions, inst_vpmovswb_xmm_ymm(dst, src)) } +emit_vpmovswb_m128_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem128, src: YMM) { append(instructions, inst_vpmovswb_m128_ymm(dst, src)) } +emit_vpmovswb_ymm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: ZMM) { append(instructions, inst_vpmovswb_ymm_zmm(dst, src)) } +emit_vpmovswb_m256_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem256, src: ZMM) { append(instructions, inst_vpmovswb_m256_zmm(dst, src)) } +inst_vpmovuswb_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVUSWB, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 1856) } +inst_vpmovuswb_m64_xmm :: #force_inline proc "contextless" (dst: Mem64, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVUSWB, operand_count = 2, ops = {op_mem(dst.mem, 8), op_xmm(src), {}, {}} }, 1856) } +inst_vpmovuswb_xmm_ymm :: #force_inline proc "contextless" (dst: XMM, src: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVUSWB, operand_count = 2, ops = {op_xmm(dst), op_ymm(src), {}, {}} }, 1857) } +inst_vpmovuswb_m128_ymm :: #force_inline proc "contextless" (dst: Mem128, src: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVUSWB, operand_count = 2, ops = {op_mem(dst.mem, 16), op_ymm(src), {}, {}} }, 1857) } +inst_vpmovuswb_ymm_zmm :: #force_inline proc "contextless" (dst: YMM, src: ZMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVUSWB, operand_count = 2, ops = {op_ymm(dst), op_zmm(src), {}, {}} }, 1858) } +inst_vpmovuswb_m256_zmm :: #force_inline proc "contextless" (dst: Mem256, src: ZMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVUSWB, operand_count = 2, ops = {op_mem(dst.mem, 32), op_zmm(src), {}, {}} }, 1858) } +emit_vpmovuswb_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_vpmovuswb_xmm_xmm(dst, src)) } +emit_vpmovuswb_m64_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, src: XMM) { append(instructions, inst_vpmovuswb_m64_xmm(dst, src)) } +emit_vpmovuswb_xmm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: YMM) { append(instructions, inst_vpmovuswb_xmm_ymm(dst, src)) } +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), {}} } } +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), {}} } } +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)) } +emit_vprolq_ymm_m256_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem256, imm: i8) { append(instructions, inst_vprolq_ymm_m256_imm8(dst, src, imm)) } +emit_vprolq_zmm_zmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, imm: i8) { append(instructions, inst_vprolq_zmm_zmm_imm8(dst, src, imm)) } +emit_vprolq_zmm_m512_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: Mem512, imm: i8) { append(instructions, inst_vprolq_zmm_m512_imm8(dst, src, imm)) } +inst_vprolvd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPROLVD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1865) } +inst_vprolvd_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPROLVD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1865) } +inst_vprolvd_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPROLVD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1866) } +inst_vprolvd_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VPROLVD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1866) } +inst_vprolvd_zmm_zmm_zmm :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: ZMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPROLVD, operand_count = 3, ops = {op_zmm(dst), op_zmm(src), op_zmm(src2), {}} }, 1867) } +inst_vprolvd_zmm_zmm_m512 :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: Mem512) -> Instruction { return with_hint(Instruction{ mnemonic = .VPROLVD, operand_count = 3, ops = {op_zmm(dst), op_zmm(src), op_mem(src2.mem, 64), {}} }, 1867) } +emit_vprolvd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vprolvd_xmm_xmm_xmm(dst, src, src2)) } +emit_vprolvd_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vprolvd_xmm_xmm_m128(dst, src, src2)) } +emit_vprolvd_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vprolvd_ymm_ymm_ymm(dst, src, src2)) } +emit_vprolvd_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vprolvd_ymm_ymm_m256(dst, src, src2)) } +emit_vprolvd_zmm_zmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: ZMM) { append(instructions, inst_vprolvd_zmm_zmm_zmm(dst, src, src2)) } +emit_vprolvd_zmm_zmm_m512 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: Mem512) { append(instructions, inst_vprolvd_zmm_zmm_m512(dst, src, src2)) } +inst_vprolvq_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPROLVQ, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1868) } +inst_vprolvq_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPROLVQ, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1868) } +inst_vprolvq_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPROLVQ, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1869) } +inst_vprolvq_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VPROLVQ, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1869) } +inst_vprolvq_zmm_zmm_zmm :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: ZMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPROLVQ, operand_count = 3, ops = {op_zmm(dst), op_zmm(src), op_zmm(src2), {}} }, 1870) } +inst_vprolvq_zmm_zmm_m512 :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: Mem512) -> Instruction { return with_hint(Instruction{ mnemonic = .VPROLVQ, operand_count = 3, ops = {op_zmm(dst), op_zmm(src), op_mem(src2.mem, 64), {}} }, 1870) } +emit_vprolvq_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vprolvq_xmm_xmm_xmm(dst, src, src2)) } +emit_vprolvq_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vprolvq_xmm_xmm_m128(dst, src, src2)) } +emit_vprolvq_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vprolvq_ymm_ymm_ymm(dst, src, src2)) } +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), {}} } } +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), {}} } } +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)) } +emit_vprorq_ymm_m256_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem256, imm: i8) { append(instructions, inst_vprorq_ymm_m256_imm8(dst, src, imm)) } +emit_vprorq_zmm_zmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, imm: i8) { append(instructions, inst_vprorq_zmm_zmm_imm8(dst, src, imm)) } +emit_vprorq_zmm_m512_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: Mem512, imm: i8) { append(instructions, inst_vprorq_zmm_m512_imm8(dst, src, imm)) } +inst_vprorvd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPRORVD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1877) } +inst_vprorvd_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPRORVD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1877) } +inst_vprorvd_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPRORVD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1878) } +inst_vprorvd_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VPRORVD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1878) } +inst_vprorvd_zmm_zmm_zmm :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: ZMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPRORVD, operand_count = 3, ops = {op_zmm(dst), op_zmm(src), op_zmm(src2), {}} }, 1879) } +inst_vprorvd_zmm_zmm_m512 :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: Mem512) -> Instruction { return with_hint(Instruction{ mnemonic = .VPRORVD, operand_count = 3, ops = {op_zmm(dst), op_zmm(src), op_mem(src2.mem, 64), {}} }, 1879) } +emit_vprorvd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vprorvd_xmm_xmm_xmm(dst, src, src2)) } +emit_vprorvd_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vprorvd_xmm_xmm_m128(dst, src, src2)) } +emit_vprorvd_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vprorvd_ymm_ymm_ymm(dst, src, src2)) } +emit_vprorvd_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vprorvd_ymm_ymm_m256(dst, src, src2)) } +emit_vprorvd_zmm_zmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: ZMM) { append(instructions, inst_vprorvd_zmm_zmm_zmm(dst, src, src2)) } +emit_vprorvd_zmm_zmm_m512 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: Mem512) { append(instructions, inst_vprorvd_zmm_zmm_m512(dst, src, src2)) } +inst_vprorvq_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPRORVQ, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1880) } +inst_vprorvq_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPRORVQ, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1880) } +inst_vprorvq_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPRORVQ, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1881) } +inst_vprorvq_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VPRORVQ, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1881) } +inst_vprorvq_zmm_zmm_zmm :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: ZMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPRORVQ, operand_count = 3, ops = {op_zmm(dst), op_zmm(src), op_zmm(src2), {}} }, 1882) } +inst_vprorvq_zmm_zmm_m512 :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: Mem512) -> Instruction { return with_hint(Instruction{ mnemonic = .VPRORVQ, operand_count = 3, ops = {op_zmm(dst), op_zmm(src), op_mem(src2.mem, 64), {}} }, 1882) } +emit_vprorvq_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vprorvq_xmm_xmm_xmm(dst, src, src2)) } +emit_vprorvq_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vprorvq_xmm_xmm_m128(dst, src, src2)) } +emit_vprorvq_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vprorvq_ymm_ymm_ymm(dst, src, src2)) } +emit_vprorvq_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vprorvq_ymm_ymm_m256(dst, src, src2)) } +emit_vprorvq_zmm_zmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: ZMM) { append(instructions, inst_vprorvq_zmm_zmm_zmm(dst, src, src2)) } +emit_vprorvq_zmm_zmm_m512 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: Mem512) { append(instructions, inst_vprorvq_zmm_zmm_m512(dst, src, src2)) } +inst_vpscatterdd_m_xmm :: #force_inline proc "contextless" (dst: Memory, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSCATTERDD, operand_count = 2, ops = {op_mem(dst, 0), op_xmm(src), {}, {}} }, 1883) } +inst_vpscatterdd_m_ymm :: #force_inline proc "contextless" (dst: Memory, src: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSCATTERDD, operand_count = 2, ops = {op_mem(dst, 0), op_ymm(src), {}, {}} }, 1884) } +inst_vpscatterdd_m_zmm :: #force_inline proc "contextless" (dst: Memory, src: ZMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSCATTERDD, operand_count = 2, ops = {op_mem(dst, 0), op_zmm(src), {}, {}} }, 1885) } +emit_vpscatterdd_m_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Memory, src: XMM) { append(instructions, inst_vpscatterdd_m_xmm(dst, src)) } +emit_vpscatterdd_m_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Memory, src: YMM) { append(instructions, inst_vpscatterdd_m_ymm(dst, src)) } +emit_vpscatterdd_m_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Memory, src: ZMM) { append(instructions, inst_vpscatterdd_m_zmm(dst, src)) } +inst_vpscatterdq_m_xmm :: #force_inline proc "contextless" (dst: Memory, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSCATTERDQ, operand_count = 2, ops = {op_mem(dst, 0), op_xmm(src), {}, {}} }, 1886) } +inst_vpscatterdq_m_ymm :: #force_inline proc "contextless" (dst: Memory, src: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSCATTERDQ, operand_count = 2, ops = {op_mem(dst, 0), op_ymm(src), {}, {}} }, 1887) } +inst_vpscatterdq_m_zmm :: #force_inline proc "contextless" (dst: Memory, src: ZMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSCATTERDQ, operand_count = 2, ops = {op_mem(dst, 0), op_zmm(src), {}, {}} }, 1888) } +emit_vpscatterdq_m_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Memory, src: XMM) { append(instructions, inst_vpscatterdq_m_xmm(dst, src)) } +emit_vpscatterdq_m_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Memory, src: YMM) { append(instructions, inst_vpscatterdq_m_ymm(dst, src)) } +emit_vpscatterdq_m_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Memory, src: ZMM) { append(instructions, inst_vpscatterdq_m_zmm(dst, src)) } +inst_vpscatterqd_m_xmm :: #force_inline proc "contextless" (dst: Memory, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSCATTERQD, operand_count = 2, ops = {op_mem(dst, 0), op_xmm(src), {}, {}} }, 1889) } +inst_vpscatterqd_m_ymm :: #force_inline proc "contextless" (dst: Memory, src: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSCATTERQD, operand_count = 2, ops = {op_mem(dst, 0), op_ymm(src), {}, {}} }, 1891) } +emit_vpscatterqd_m_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Memory, src: XMM) { append(instructions, inst_vpscatterqd_m_xmm(dst, src)) } +emit_vpscatterqd_m_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Memory, src: YMM) { append(instructions, inst_vpscatterqd_m_ymm(dst, src)) } +inst_vpscatterqq_m_xmm :: #force_inline proc "contextless" (dst: Memory, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSCATTERQQ, operand_count = 2, ops = {op_mem(dst, 0), op_xmm(src), {}, {}} }, 1892) } +inst_vpscatterqq_m_ymm :: #force_inline proc "contextless" (dst: Memory, src: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSCATTERQQ, operand_count = 2, ops = {op_mem(dst, 0), op_ymm(src), {}, {}} }, 1893) } +inst_vpscatterqq_m_zmm :: #force_inline proc "contextless" (dst: Memory, src: ZMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSCATTERQQ, operand_count = 2, ops = {op_mem(dst, 0), op_zmm(src), {}, {}} }, 1894) } +emit_vpscatterqq_m_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Memory, src: XMM) { append(instructions, inst_vpscatterqq_m_xmm(dst, src)) } +emit_vpscatterqq_m_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Memory, src: YMM) { append(instructions, inst_vpscatterqq_m_ymm(dst, src)) } +emit_vpscatterqq_m_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Memory, src: ZMM) { append(instructions, inst_vpscatterqq_m_zmm(dst, src)) } +inst_vscatterdps_m_xmm :: #force_inline proc "contextless" (dst: Memory, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VSCATTERDPS, operand_count = 2, ops = {op_mem(dst, 0), op_xmm(src), {}, {}} }, 1895) } +inst_vscatterdps_m_ymm :: #force_inline proc "contextless" (dst: Memory, src: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VSCATTERDPS, operand_count = 2, ops = {op_mem(dst, 0), op_ymm(src), {}, {}} }, 1896) } +inst_vscatterdps_m_zmm :: #force_inline proc "contextless" (dst: Memory, src: ZMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VSCATTERDPS, operand_count = 2, ops = {op_mem(dst, 0), op_zmm(src), {}, {}} }, 1897) } +emit_vscatterdps_m_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Memory, src: XMM) { append(instructions, inst_vscatterdps_m_xmm(dst, src)) } +emit_vscatterdps_m_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Memory, src: YMM) { append(instructions, inst_vscatterdps_m_ymm(dst, src)) } +emit_vscatterdps_m_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Memory, src: ZMM) { append(instructions, inst_vscatterdps_m_zmm(dst, src)) } +inst_vscatterdpd_m_xmm :: #force_inline proc "contextless" (dst: Memory, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VSCATTERDPD, operand_count = 2, ops = {op_mem(dst, 0), op_xmm(src), {}, {}} }, 1898) } +inst_vscatterdpd_m_ymm :: #force_inline proc "contextless" (dst: Memory, src: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VSCATTERDPD, operand_count = 2, ops = {op_mem(dst, 0), op_ymm(src), {}, {}} }, 1899) } +inst_vscatterdpd_m_zmm :: #force_inline proc "contextless" (dst: Memory, src: ZMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VSCATTERDPD, operand_count = 2, ops = {op_mem(dst, 0), op_zmm(src), {}, {}} }, 1900) } +emit_vscatterdpd_m_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Memory, src: XMM) { append(instructions, inst_vscatterdpd_m_xmm(dst, src)) } +emit_vscatterdpd_m_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Memory, src: YMM) { append(instructions, inst_vscatterdpd_m_ymm(dst, src)) } +emit_vscatterdpd_m_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Memory, src: ZMM) { append(instructions, inst_vscatterdpd_m_zmm(dst, src)) } +inst_vscatterqps_m_xmm :: #force_inline proc "contextless" (dst: Memory, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VSCATTERQPS, operand_count = 2, ops = {op_mem(dst, 0), op_xmm(src), {}, {}} }, 1901) } +inst_vscatterqps_m_ymm :: #force_inline proc "contextless" (dst: Memory, src: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VSCATTERQPS, operand_count = 2, ops = {op_mem(dst, 0), op_ymm(src), {}, {}} }, 1903) } +emit_vscatterqps_m_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Memory, src: XMM) { append(instructions, inst_vscatterqps_m_xmm(dst, src)) } +emit_vscatterqps_m_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Memory, src: YMM) { append(instructions, inst_vscatterqps_m_ymm(dst, src)) } +inst_vscatterqpd_m_xmm :: #force_inline proc "contextless" (dst: Memory, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VSCATTERQPD, operand_count = 2, ops = {op_mem(dst, 0), op_xmm(src), {}, {}} }, 1904) } +inst_vscatterqpd_m_ymm :: #force_inline proc "contextless" (dst: Memory, src: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VSCATTERQPD, operand_count = 2, ops = {op_mem(dst, 0), op_ymm(src), {}, {}} }, 1905) } +inst_vscatterqpd_m_zmm :: #force_inline proc "contextless" (dst: Memory, src: ZMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VSCATTERQPD, operand_count = 2, ops = {op_mem(dst, 0), op_zmm(src), {}, {}} }, 1906) } +emit_vscatterqpd_m_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Memory, src: XMM) { append(instructions, inst_vscatterqpd_m_xmm(dst, src)) } +emit_vscatterqpd_m_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Memory, src: YMM) { append(instructions, inst_vscatterqpd_m_ymm(dst, src)) } +emit_vscatterqpd_m_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Memory, src: ZMM) { append(instructions, inst_vscatterqpd_m_zmm(dst, src)) } +inst_vpsravq_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSRAVQ, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1907) } +inst_vpsravq_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSRAVQ, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1907) } +inst_vpsravq_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSRAVQ, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1908) } +inst_vpsravq_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSRAVQ, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1908) } +inst_vpsravq_zmm_zmm_zmm :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: ZMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSRAVQ, operand_count = 3, ops = {op_zmm(dst), op_zmm(src), op_zmm(src2), {}} }, 1909) } +inst_vpsravq_zmm_zmm_m512 :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: Mem512) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSRAVQ, operand_count = 3, ops = {op_zmm(dst), op_zmm(src), op_mem(src2.mem, 64), {}} }, 1909) } +emit_vpsravq_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vpsravq_xmm_xmm_xmm(dst, src, src2)) } +emit_vpsravq_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vpsravq_xmm_xmm_m128(dst, src, src2)) } +emit_vpsravq_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vpsravq_ymm_ymm_ymm(dst, src, src2)) } +emit_vpsravq_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vpsravq_ymm_ymm_m256(dst, src, src2)) } +emit_vpsravq_zmm_zmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: ZMM) { append(instructions, inst_vpsravq_zmm_zmm_zmm(dst, src, src2)) } +emit_vpsravq_zmm_zmm_m512 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: Mem512) { append(instructions, inst_vpsravq_zmm_zmm_m512(dst, src, src2)) } +inst_vpsravw_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSRAVW, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1910) } +inst_vpsravw_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSRAVW, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1910) } +inst_vpsravw_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSRAVW, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1911) } +inst_vpsravw_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSRAVW, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1911) } +inst_vpsravw_zmm_zmm_zmm :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: ZMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSRAVW, operand_count = 3, ops = {op_zmm(dst), op_zmm(src), op_zmm(src2), {}} }, 1912) } +inst_vpsravw_zmm_zmm_m512 :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: Mem512) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSRAVW, operand_count = 3, ops = {op_zmm(dst), op_zmm(src), op_mem(src2.mem, 64), {}} }, 1912) } +emit_vpsravw_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vpsravw_xmm_xmm_xmm(dst, src, src2)) } +emit_vpsravw_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vpsravw_xmm_xmm_m128(dst, src, src2)) } +emit_vpsravw_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vpsravw_ymm_ymm_ymm(dst, src, src2)) } +emit_vpsravw_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vpsravw_ymm_ymm_m256(dst, src, src2)) } +emit_vpsravw_zmm_zmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: ZMM) { append(instructions, inst_vpsravw_zmm_zmm_zmm(dst, src, src2)) } +emit_vpsravw_zmm_zmm_m512 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: Mem512) { append(instructions, inst_vpsravw_zmm_zmm_m512(dst, src, src2)) } +inst_vpsllvw_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSLLVW, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1913) } +inst_vpsllvw_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSLLVW, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1913) } +inst_vpsllvw_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSLLVW, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1914) } +inst_vpsllvw_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSLLVW, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1914) } +inst_vpsllvw_zmm_zmm_zmm :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: ZMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSLLVW, operand_count = 3, ops = {op_zmm(dst), op_zmm(src), op_zmm(src2), {}} }, 1915) } +inst_vpsllvw_zmm_zmm_m512 :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: Mem512) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSLLVW, operand_count = 3, ops = {op_zmm(dst), op_zmm(src), op_mem(src2.mem, 64), {}} }, 1915) } +emit_vpsllvw_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vpsllvw_xmm_xmm_xmm(dst, src, src2)) } +emit_vpsllvw_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vpsllvw_xmm_xmm_m128(dst, src, src2)) } +emit_vpsllvw_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vpsllvw_ymm_ymm_ymm(dst, src, src2)) } +emit_vpsllvw_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vpsllvw_ymm_ymm_m256(dst, src, src2)) } +emit_vpsllvw_zmm_zmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: ZMM) { append(instructions, inst_vpsllvw_zmm_zmm_zmm(dst, src, src2)) } +emit_vpsllvw_zmm_zmm_m512 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: Mem512) { append(instructions, inst_vpsllvw_zmm_zmm_m512(dst, src, src2)) } +inst_vpsrlvw_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSRLVW, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1916) } +inst_vpsrlvw_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSRLVW, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1916) } +inst_vpsrlvw_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSRLVW, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1917) } +inst_vpsrlvw_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSRLVW, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1917) } +inst_vpsrlvw_zmm_zmm_zmm :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: ZMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSRLVW, operand_count = 3, ops = {op_zmm(dst), op_zmm(src), op_zmm(src2), {}} }, 1918) } +inst_vpsrlvw_zmm_zmm_m512 :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: Mem512) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSRLVW, operand_count = 3, ops = {op_zmm(dst), op_zmm(src), op_mem(src2.mem, 64), {}} }, 1918) } +emit_vpsrlvw_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vpsrlvw_xmm_xmm_xmm(dst, src, src2)) } +emit_vpsrlvw_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vpsrlvw_xmm_xmm_m128(dst, src, src2)) } +emit_vpsrlvw_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vpsrlvw_ymm_ymm_ymm(dst, src, src2)) } +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)} } } @@ -6489,30 +6489,30 @@ inst_vrangesd_xmm_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XM 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)} } } 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 inst_r_r_i(.VREDUCEPS, Register(dst), Register(src), i64(imm), 1) } -inst_vreduceps_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem128, imm: i8) -> Instruction { return inst_r_m_i(.VREDUCEPS, Register(dst), src.mem, 16, i64(imm), 1) } -inst_vreduceps_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, imm: i8) -> Instruction { return inst_r_r_i(.VREDUCEPS, Register(dst), Register(src), i64(imm), 1) } -inst_vreduceps_ymm_m256_imm8 :: #force_inline proc "contextless" (dst: YMM, src: Mem256, imm: i8) -> Instruction { return inst_r_m_i(.VREDUCEPS, Register(dst), src.mem, 32, i64(imm), 1) } -inst_vreduceps_zmm_zmm_imm8 :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, imm: i8) -> Instruction { return inst_r_r_i(.VREDUCEPS, Register(dst), Register(src), i64(imm), 1) } -inst_vreduceps_zmm_m512_imm8 :: #force_inline proc "contextless" (dst: ZMM, src: Mem512, imm: i8) -> Instruction { return inst_r_m_i(.VREDUCEPS, Register(dst), src.mem, 64, i64(imm), 1) } -emit_vreduceps_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, imm: i8) { emit_rri(instructions, .VREDUCEPS, Register(dst), Register(src), i64(imm), 1) } -emit_vreduceps_xmm_m128_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128, imm: i8) { emit_rmi(instructions, .VREDUCEPS, Register(dst), src.mem, 16, i64(imm), 1) } -emit_vreduceps_ymm_ymm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, imm: i8) { emit_rri(instructions, .VREDUCEPS, Register(dst), Register(src), i64(imm), 1) } -emit_vreduceps_ymm_m256_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem256, imm: i8) { emit_rmi(instructions, .VREDUCEPS, Register(dst), src.mem, 32, i64(imm), 1) } -emit_vreduceps_zmm_zmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, imm: i8) { emit_rri(instructions, .VREDUCEPS, Register(dst), Register(src), i64(imm), 1) } -emit_vreduceps_zmm_m512_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: Mem512, imm: i8) { emit_rmi(instructions, .VREDUCEPS, Register(dst), src.mem, 64, i64(imm), 1) } -inst_vreducepd_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return inst_r_r_i(.VREDUCEPD, Register(dst), Register(src), i64(imm), 1) } -inst_vreducepd_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem128, imm: i8) -> Instruction { return inst_r_m_i(.VREDUCEPD, Register(dst), src.mem, 16, i64(imm), 1) } -inst_vreducepd_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, imm: i8) -> Instruction { return inst_r_r_i(.VREDUCEPD, Register(dst), Register(src), i64(imm), 1) } -inst_vreducepd_ymm_m256_imm8 :: #force_inline proc "contextless" (dst: YMM, src: Mem256, imm: i8) -> Instruction { return inst_r_m_i(.VREDUCEPD, Register(dst), src.mem, 32, i64(imm), 1) } -inst_vreducepd_zmm_zmm_imm8 :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, imm: i8) -> Instruction { return inst_r_r_i(.VREDUCEPD, Register(dst), Register(src), i64(imm), 1) } -inst_vreducepd_zmm_m512_imm8 :: #force_inline proc "contextless" (dst: ZMM, src: Mem512, imm: i8) -> Instruction { return inst_r_m_i(.VREDUCEPD, Register(dst), src.mem, 64, i64(imm), 1) } -emit_vreducepd_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, imm: i8) { emit_rri(instructions, .VREDUCEPD, Register(dst), Register(src), i64(imm), 1) } -emit_vreducepd_xmm_m128_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128, imm: i8) { emit_rmi(instructions, .VREDUCEPD, Register(dst), src.mem, 16, i64(imm), 1) } -emit_vreducepd_ymm_ymm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, imm: i8) { emit_rri(instructions, .VREDUCEPD, Register(dst), Register(src), i64(imm), 1) } -emit_vreducepd_ymm_m256_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem256, imm: i8) { emit_rmi(instructions, .VREDUCEPD, Register(dst), src.mem, 32, i64(imm), 1) } -emit_vreducepd_zmm_zmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, imm: i8) { emit_rri(instructions, .VREDUCEPD, Register(dst), Register(src), i64(imm), 1) } -emit_vreducepd_zmm_m512_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: Mem512, imm: i8) { emit_rmi(instructions, .VREDUCEPD, Register(dst), src.mem, 64, i64(imm), 1) } +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), {}} } } +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), {}} } } +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)} } } 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)) } @@ -6521,30 +6521,30 @@ inst_vreducesd_xmm_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XM 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)} } } 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 inst_r_r_i(.VRNDSCALEPS, Register(dst), Register(src), i64(imm), 1) } -inst_vrndscaleps_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem128, imm: i8) -> Instruction { return inst_r_m_i(.VRNDSCALEPS, Register(dst), src.mem, 16, i64(imm), 1) } -inst_vrndscaleps_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, imm: i8) -> Instruction { return inst_r_r_i(.VRNDSCALEPS, Register(dst), Register(src), i64(imm), 1) } -inst_vrndscaleps_ymm_m256_imm8 :: #force_inline proc "contextless" (dst: YMM, src: Mem256, imm: i8) -> Instruction { return inst_r_m_i(.VRNDSCALEPS, Register(dst), src.mem, 32, i64(imm), 1) } -inst_vrndscaleps_zmm_zmm_imm8 :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, imm: i8) -> Instruction { return inst_r_r_i(.VRNDSCALEPS, Register(dst), Register(src), i64(imm), 1) } -inst_vrndscaleps_zmm_m512_imm8 :: #force_inline proc "contextless" (dst: ZMM, src: Mem512, imm: i8) -> Instruction { return inst_r_m_i(.VRNDSCALEPS, Register(dst), src.mem, 64, i64(imm), 1) } -emit_vrndscaleps_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, imm: i8) { emit_rri(instructions, .VRNDSCALEPS, Register(dst), Register(src), i64(imm), 1) } -emit_vrndscaleps_xmm_m128_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128, imm: i8) { emit_rmi(instructions, .VRNDSCALEPS, Register(dst), src.mem, 16, i64(imm), 1) } -emit_vrndscaleps_ymm_ymm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, imm: i8) { emit_rri(instructions, .VRNDSCALEPS, Register(dst), Register(src), i64(imm), 1) } -emit_vrndscaleps_ymm_m256_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem256, imm: i8) { emit_rmi(instructions, .VRNDSCALEPS, Register(dst), src.mem, 32, i64(imm), 1) } -emit_vrndscaleps_zmm_zmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, imm: i8) { emit_rri(instructions, .VRNDSCALEPS, Register(dst), Register(src), i64(imm), 1) } -emit_vrndscaleps_zmm_m512_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: Mem512, imm: i8) { emit_rmi(instructions, .VRNDSCALEPS, Register(dst), src.mem, 64, i64(imm), 1) } -inst_vrndscalepd_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return inst_r_r_i(.VRNDSCALEPD, Register(dst), Register(src), i64(imm), 1) } -inst_vrndscalepd_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem128, imm: i8) -> Instruction { return inst_r_m_i(.VRNDSCALEPD, Register(dst), src.mem, 16, i64(imm), 1) } -inst_vrndscalepd_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, imm: i8) -> Instruction { return inst_r_r_i(.VRNDSCALEPD, Register(dst), Register(src), i64(imm), 1) } -inst_vrndscalepd_ymm_m256_imm8 :: #force_inline proc "contextless" (dst: YMM, src: Mem256, imm: i8) -> Instruction { return inst_r_m_i(.VRNDSCALEPD, Register(dst), src.mem, 32, i64(imm), 1) } -inst_vrndscalepd_zmm_zmm_imm8 :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, imm: i8) -> Instruction { return inst_r_r_i(.VRNDSCALEPD, Register(dst), Register(src), i64(imm), 1) } -inst_vrndscalepd_zmm_m512_imm8 :: #force_inline proc "contextless" (dst: ZMM, src: Mem512, imm: i8) -> Instruction { return inst_r_m_i(.VRNDSCALEPD, Register(dst), src.mem, 64, i64(imm), 1) } -emit_vrndscalepd_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, imm: i8) { emit_rri(instructions, .VRNDSCALEPD, Register(dst), Register(src), i64(imm), 1) } -emit_vrndscalepd_xmm_m128_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128, imm: i8) { emit_rmi(instructions, .VRNDSCALEPD, Register(dst), src.mem, 16, i64(imm), 1) } -emit_vrndscalepd_ymm_ymm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, imm: i8) { emit_rri(instructions, .VRNDSCALEPD, Register(dst), Register(src), i64(imm), 1) } -emit_vrndscalepd_ymm_m256_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem256, imm: i8) { emit_rmi(instructions, .VRNDSCALEPD, Register(dst), src.mem, 32, i64(imm), 1) } -emit_vrndscalepd_zmm_zmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, imm: i8) { emit_rri(instructions, .VRNDSCALEPD, Register(dst), Register(src), i64(imm), 1) } -emit_vrndscalepd_zmm_m512_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: Mem512, imm: i8) { emit_rmi(instructions, .VRNDSCALEPD, Register(dst), src.mem, 64, i64(imm), 1) } +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), {}} } } +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), {}} } } +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)} } } 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)) } @@ -6553,158 +6553,158 @@ inst_vrndscalesd_xmm_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XM 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)} } } 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 inst_r_r(.VRSQRT14PS, Register(dst), Register(src)) } -inst_vrsqrt14ps_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.VRSQRT14PS, Register(dst), src.mem, 16) } -inst_vrsqrt14ps_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM) -> Instruction { return inst_r_r(.VRSQRT14PS, Register(dst), Register(src)) } -inst_vrsqrt14ps_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: Mem256) -> Instruction { return inst_r_m(.VRSQRT14PS, Register(dst), src.mem, 32) } -inst_vrsqrt14ps_zmm_zmm :: #force_inline proc "contextless" (dst: ZMM, src: ZMM) -> Instruction { return inst_r_r(.VRSQRT14PS, Register(dst), Register(src)) } -inst_vrsqrt14ps_zmm_m512 :: #force_inline proc "contextless" (dst: ZMM, src: Mem512) -> Instruction { return inst_r_m(.VRSQRT14PS, Register(dst), src.mem, 64) } -emit_vrsqrt14ps_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .VRSQRT14PS, Register(dst), Register(src)) } -emit_vrsqrt14ps_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .VRSQRT14PS, Register(dst), src.mem, 16) } -emit_vrsqrt14ps_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM) { emit_rr(instructions, .VRSQRT14PS, Register(dst), Register(src)) } -emit_vrsqrt14ps_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem256) { emit_rm(instructions, .VRSQRT14PS, Register(dst), src.mem, 32) } -emit_vrsqrt14ps_zmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM) { emit_rr(instructions, .VRSQRT14PS, Register(dst), Register(src)) } -emit_vrsqrt14ps_zmm_m512 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: Mem512) { emit_rm(instructions, .VRSQRT14PS, Register(dst), src.mem, 64) } -inst_vrsqrt14pd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.VRSQRT14PD, Register(dst), Register(src)) } -inst_vrsqrt14pd_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.VRSQRT14PD, Register(dst), src.mem, 16) } -inst_vrsqrt14pd_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM) -> Instruction { return inst_r_r(.VRSQRT14PD, Register(dst), Register(src)) } -inst_vrsqrt14pd_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: Mem256) -> Instruction { return inst_r_m(.VRSQRT14PD, Register(dst), src.mem, 32) } -inst_vrsqrt14pd_zmm_zmm :: #force_inline proc "contextless" (dst: ZMM, src: ZMM) -> Instruction { return inst_r_r(.VRSQRT14PD, Register(dst), Register(src)) } -inst_vrsqrt14pd_zmm_m512 :: #force_inline proc "contextless" (dst: ZMM, src: Mem512) -> Instruction { return inst_r_m(.VRSQRT14PD, Register(dst), src.mem, 64) } -emit_vrsqrt14pd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .VRSQRT14PD, Register(dst), Register(src)) } -emit_vrsqrt14pd_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .VRSQRT14PD, Register(dst), src.mem, 16) } -emit_vrsqrt14pd_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM) { emit_rr(instructions, .VRSQRT14PD, Register(dst), Register(src)) } -emit_vrsqrt14pd_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem256) { emit_rm(instructions, .VRSQRT14PD, Register(dst), src.mem, 32) } -emit_vrsqrt14pd_zmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM) { emit_rr(instructions, .VRSQRT14PD, Register(dst), Register(src)) } -emit_vrsqrt14pd_zmm_m512 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: Mem512) { emit_rm(instructions, .VRSQRT14PD, Register(dst), src.mem, 64) } -inst_vrsqrt14ss_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VRSQRT14SS, Register(dst), Register(src), Register(src2)) } -inst_vrsqrt14ss_xmm_xmm_m32 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem32) -> Instruction { return inst_r_r_m(.VRSQRT14SS, Register(dst), Register(src), src2.mem, 4) } -emit_vrsqrt14ss_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VRSQRT14SS, Register(dst), Register(src), Register(src2)) } -emit_vrsqrt14ss_xmm_xmm_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem32) { emit_rrm(instructions, .VRSQRT14SS, Register(dst), Register(src), src2.mem, 4) } -inst_vrsqrt14sd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VRSQRT14SD, Register(dst), Register(src), Register(src2)) } -inst_vrsqrt14sd_xmm_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem64) -> Instruction { return inst_r_r_m(.VRSQRT14SD, Register(dst), Register(src), src2.mem, 8) } -emit_vrsqrt14sd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VRSQRT14SD, Register(dst), Register(src), Register(src2)) } -emit_vrsqrt14sd_xmm_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem64) { emit_rrm(instructions, .VRSQRT14SD, Register(dst), Register(src), src2.mem, 8) } -inst_vrcp14ps_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.VRCP14PS, Register(dst), Register(src)) } -inst_vrcp14ps_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.VRCP14PS, Register(dst), src.mem, 16) } -inst_vrcp14ps_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM) -> Instruction { return inst_r_r(.VRCP14PS, Register(dst), Register(src)) } -inst_vrcp14ps_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: Mem256) -> Instruction { return inst_r_m(.VRCP14PS, Register(dst), src.mem, 32) } -inst_vrcp14ps_zmm_zmm :: #force_inline proc "contextless" (dst: ZMM, src: ZMM) -> Instruction { return inst_r_r(.VRCP14PS, Register(dst), Register(src)) } -inst_vrcp14ps_zmm_m512 :: #force_inline proc "contextless" (dst: ZMM, src: Mem512) -> Instruction { return inst_r_m(.VRCP14PS, Register(dst), src.mem, 64) } -emit_vrcp14ps_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .VRCP14PS, Register(dst), Register(src)) } -emit_vrcp14ps_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .VRCP14PS, Register(dst), src.mem, 16) } -emit_vrcp14ps_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM) { emit_rr(instructions, .VRCP14PS, Register(dst), Register(src)) } -emit_vrcp14ps_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem256) { emit_rm(instructions, .VRCP14PS, Register(dst), src.mem, 32) } -emit_vrcp14ps_zmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM) { emit_rr(instructions, .VRCP14PS, Register(dst), Register(src)) } -emit_vrcp14ps_zmm_m512 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: Mem512) { emit_rm(instructions, .VRCP14PS, Register(dst), src.mem, 64) } -inst_vrcp14pd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.VRCP14PD, Register(dst), Register(src)) } -inst_vrcp14pd_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.VRCP14PD, Register(dst), src.mem, 16) } -inst_vrcp14pd_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM) -> Instruction { return inst_r_r(.VRCP14PD, Register(dst), Register(src)) } -inst_vrcp14pd_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: Mem256) -> Instruction { return inst_r_m(.VRCP14PD, Register(dst), src.mem, 32) } -inst_vrcp14pd_zmm_zmm :: #force_inline proc "contextless" (dst: ZMM, src: ZMM) -> Instruction { return inst_r_r(.VRCP14PD, Register(dst), Register(src)) } -inst_vrcp14pd_zmm_m512 :: #force_inline proc "contextless" (dst: ZMM, src: Mem512) -> Instruction { return inst_r_m(.VRCP14PD, Register(dst), src.mem, 64) } -emit_vrcp14pd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .VRCP14PD, Register(dst), Register(src)) } -emit_vrcp14pd_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .VRCP14PD, Register(dst), src.mem, 16) } -emit_vrcp14pd_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM) { emit_rr(instructions, .VRCP14PD, Register(dst), Register(src)) } -emit_vrcp14pd_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem256) { emit_rm(instructions, .VRCP14PD, Register(dst), src.mem, 32) } -emit_vrcp14pd_zmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM) { emit_rr(instructions, .VRCP14PD, Register(dst), Register(src)) } -emit_vrcp14pd_zmm_m512 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: Mem512) { emit_rm(instructions, .VRCP14PD, Register(dst), src.mem, 64) } -inst_vrcp14ss_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VRCP14SS, Register(dst), Register(src), Register(src2)) } -inst_vrcp14ss_xmm_xmm_m32 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem32) -> Instruction { return inst_r_r_m(.VRCP14SS, Register(dst), Register(src), src2.mem, 4) } -emit_vrcp14ss_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VRCP14SS, Register(dst), Register(src), Register(src2)) } -emit_vrcp14ss_xmm_xmm_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem32) { emit_rrm(instructions, .VRCP14SS, Register(dst), Register(src), src2.mem, 4) } -inst_vrcp14sd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VRCP14SD, Register(dst), Register(src), Register(src2)) } -inst_vrcp14sd_xmm_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem64) -> Instruction { return inst_r_r_m(.VRCP14SD, Register(dst), Register(src), src2.mem, 8) } -emit_vrcp14sd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VRCP14SD, Register(dst), Register(src), Register(src2)) } -emit_vrcp14sd_xmm_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem64) { emit_rrm(instructions, .VRCP14SD, Register(dst), Register(src), src2.mem, 8) } -inst_vscalefps_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VSCALEFPS, Register(dst), Register(src), Register(src2)) } -inst_vscalefps_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VSCALEFPS, Register(dst), Register(src), src2.mem, 16) } -inst_vscalefps_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VSCALEFPS, Register(dst), Register(src), Register(src2)) } -inst_vscalefps_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VSCALEFPS, Register(dst), Register(src), src2.mem, 32) } -inst_vscalefps_zmm_zmm_zmm :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: ZMM) -> Instruction { return inst_r_r_r(.VSCALEFPS, Register(dst), Register(src), Register(src2)) } -inst_vscalefps_zmm_zmm_m512 :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: Mem512) -> Instruction { return inst_r_r_m(.VSCALEFPS, Register(dst), Register(src), src2.mem, 64) } -emit_vscalefps_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VSCALEFPS, Register(dst), Register(src), Register(src2)) } -emit_vscalefps_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VSCALEFPS, Register(dst), Register(src), src2.mem, 16) } -emit_vscalefps_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VSCALEFPS, Register(dst), Register(src), Register(src2)) } -emit_vscalefps_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VSCALEFPS, Register(dst), Register(src), src2.mem, 32) } -emit_vscalefps_zmm_zmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: ZMM) { emit_rrr(instructions, .VSCALEFPS, Register(dst), Register(src), Register(src2)) } -emit_vscalefps_zmm_zmm_m512 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: Mem512) { emit_rrm(instructions, .VSCALEFPS, Register(dst), Register(src), src2.mem, 64) } -inst_vscalefpd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VSCALEFPD, Register(dst), Register(src), Register(src2)) } -inst_vscalefpd_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VSCALEFPD, Register(dst), Register(src), src2.mem, 16) } -inst_vscalefpd_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VSCALEFPD, Register(dst), Register(src), Register(src2)) } -inst_vscalefpd_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VSCALEFPD, Register(dst), Register(src), src2.mem, 32) } -inst_vscalefpd_zmm_zmm_zmm :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: ZMM) -> Instruction { return inst_r_r_r(.VSCALEFPD, Register(dst), Register(src), Register(src2)) } -inst_vscalefpd_zmm_zmm_m512 :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: Mem512) -> Instruction { return inst_r_r_m(.VSCALEFPD, Register(dst), Register(src), src2.mem, 64) } -emit_vscalefpd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VSCALEFPD, Register(dst), Register(src), Register(src2)) } -emit_vscalefpd_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VSCALEFPD, Register(dst), Register(src), src2.mem, 16) } -emit_vscalefpd_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VSCALEFPD, Register(dst), Register(src), Register(src2)) } -emit_vscalefpd_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VSCALEFPD, Register(dst), Register(src), src2.mem, 32) } -emit_vscalefpd_zmm_zmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: ZMM) { emit_rrr(instructions, .VSCALEFPD, Register(dst), Register(src), Register(src2)) } -emit_vscalefpd_zmm_zmm_m512 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: Mem512) { emit_rrm(instructions, .VSCALEFPD, Register(dst), Register(src), src2.mem, 64) } -inst_vscalefss_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VSCALEFSS, Register(dst), Register(src), Register(src2)) } -inst_vscalefss_xmm_xmm_m32 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem32) -> Instruction { return inst_r_r_m(.VSCALEFSS, Register(dst), Register(src), src2.mem, 4) } -emit_vscalefss_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VSCALEFSS, Register(dst), Register(src), Register(src2)) } -emit_vscalefss_xmm_xmm_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem32) { emit_rrm(instructions, .VSCALEFSS, Register(dst), Register(src), src2.mem, 4) } -inst_vscalefsd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VSCALEFSD, Register(dst), Register(src), Register(src2)) } -inst_vscalefsd_xmm_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem64) -> Instruction { return inst_r_r_m(.VSCALEFSD, Register(dst), Register(src), src2.mem, 8) } -emit_vscalefsd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VSCALEFSD, Register(dst), Register(src), Register(src2)) } -emit_vscalefsd_xmm_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem64) { emit_rrm(instructions, .VSCALEFSD, Register(dst), Register(src), src2.mem, 8) } -inst_vgetexpps_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.VGETEXPPS, Register(dst), Register(src)) } -inst_vgetexpps_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.VGETEXPPS, Register(dst), src.mem, 16) } -inst_vgetexpps_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM) -> Instruction { return inst_r_r(.VGETEXPPS, Register(dst), Register(src)) } -inst_vgetexpps_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: Mem256) -> Instruction { return inst_r_m(.VGETEXPPS, Register(dst), src.mem, 32) } -inst_vgetexpps_zmm_zmm :: #force_inline proc "contextless" (dst: ZMM, src: ZMM) -> Instruction { return inst_r_r(.VGETEXPPS, Register(dst), Register(src)) } -inst_vgetexpps_zmm_m512 :: #force_inline proc "contextless" (dst: ZMM, src: Mem512) -> Instruction { return inst_r_m(.VGETEXPPS, Register(dst), src.mem, 64) } -emit_vgetexpps_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .VGETEXPPS, Register(dst), Register(src)) } -emit_vgetexpps_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .VGETEXPPS, Register(dst), src.mem, 16) } -emit_vgetexpps_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM) { emit_rr(instructions, .VGETEXPPS, Register(dst), Register(src)) } -emit_vgetexpps_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem256) { emit_rm(instructions, .VGETEXPPS, Register(dst), src.mem, 32) } -emit_vgetexpps_zmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM) { emit_rr(instructions, .VGETEXPPS, Register(dst), Register(src)) } -emit_vgetexpps_zmm_m512 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: Mem512) { emit_rm(instructions, .VGETEXPPS, Register(dst), src.mem, 64) } -inst_vgetexppd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return inst_r_r(.VGETEXPPD, Register(dst), Register(src)) } -inst_vgetexppd_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return inst_r_m(.VGETEXPPD, Register(dst), src.mem, 16) } -inst_vgetexppd_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM) -> Instruction { return inst_r_r(.VGETEXPPD, Register(dst), Register(src)) } -inst_vgetexppd_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: Mem256) -> Instruction { return inst_r_m(.VGETEXPPD, Register(dst), src.mem, 32) } -inst_vgetexppd_zmm_zmm :: #force_inline proc "contextless" (dst: ZMM, src: ZMM) -> Instruction { return inst_r_r(.VGETEXPPD, Register(dst), Register(src)) } -inst_vgetexppd_zmm_m512 :: #force_inline proc "contextless" (dst: ZMM, src: Mem512) -> Instruction { return inst_r_m(.VGETEXPPD, Register(dst), src.mem, 64) } -emit_vgetexppd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { emit_rr(instructions, .VGETEXPPD, Register(dst), Register(src)) } -emit_vgetexppd_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { emit_rm(instructions, .VGETEXPPD, Register(dst), src.mem, 16) } -emit_vgetexppd_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM) { emit_rr(instructions, .VGETEXPPD, Register(dst), Register(src)) } -emit_vgetexppd_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem256) { emit_rm(instructions, .VGETEXPPD, Register(dst), src.mem, 32) } -emit_vgetexppd_zmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM) { emit_rr(instructions, .VGETEXPPD, Register(dst), Register(src)) } -emit_vgetexppd_zmm_m512 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: Mem512) { emit_rm(instructions, .VGETEXPPD, Register(dst), src.mem, 64) } -inst_vgetexpss_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VGETEXPSS, Register(dst), Register(src), Register(src2)) } -inst_vgetexpss_xmm_xmm_m32 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem32) -> Instruction { return inst_r_r_m(.VGETEXPSS, Register(dst), Register(src), src2.mem, 4) } -emit_vgetexpss_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VGETEXPSS, Register(dst), Register(src), Register(src2)) } -emit_vgetexpss_xmm_xmm_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem32) { emit_rrm(instructions, .VGETEXPSS, Register(dst), Register(src), src2.mem, 4) } -inst_vgetexpsd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VGETEXPSD, Register(dst), Register(src), Register(src2)) } -inst_vgetexpsd_xmm_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem64) -> Instruction { return inst_r_r_m(.VGETEXPSD, Register(dst), Register(src), src2.mem, 8) } -emit_vgetexpsd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VGETEXPSD, Register(dst), Register(src), Register(src2)) } -emit_vgetexpsd_xmm_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem64) { emit_rrm(instructions, .VGETEXPSD, Register(dst), Register(src), src2.mem, 8) } -inst_vgetmantps_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return inst_r_r_i(.VGETMANTPS, Register(dst), Register(src), i64(imm), 1) } -inst_vgetmantps_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem128, imm: i8) -> Instruction { return inst_r_m_i(.VGETMANTPS, Register(dst), src.mem, 16, i64(imm), 1) } -inst_vgetmantps_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, imm: i8) -> Instruction { return inst_r_r_i(.VGETMANTPS, Register(dst), Register(src), i64(imm), 1) } -inst_vgetmantps_ymm_m256_imm8 :: #force_inline proc "contextless" (dst: YMM, src: Mem256, imm: i8) -> Instruction { return inst_r_m_i(.VGETMANTPS, Register(dst), src.mem, 32, i64(imm), 1) } -inst_vgetmantps_zmm_zmm_imm8 :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, imm: i8) -> Instruction { return inst_r_r_i(.VGETMANTPS, Register(dst), Register(src), i64(imm), 1) } -inst_vgetmantps_zmm_m512_imm8 :: #force_inline proc "contextless" (dst: ZMM, src: Mem512, imm: i8) -> Instruction { return inst_r_m_i(.VGETMANTPS, Register(dst), src.mem, 64, i64(imm), 1) } -emit_vgetmantps_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, imm: i8) { emit_rri(instructions, .VGETMANTPS, Register(dst), Register(src), i64(imm), 1) } -emit_vgetmantps_xmm_m128_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128, imm: i8) { emit_rmi(instructions, .VGETMANTPS, Register(dst), src.mem, 16, i64(imm), 1) } -emit_vgetmantps_ymm_ymm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, imm: i8) { emit_rri(instructions, .VGETMANTPS, Register(dst), Register(src), i64(imm), 1) } -emit_vgetmantps_ymm_m256_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem256, imm: i8) { emit_rmi(instructions, .VGETMANTPS, Register(dst), src.mem, 32, i64(imm), 1) } -emit_vgetmantps_zmm_zmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, imm: i8) { emit_rri(instructions, .VGETMANTPS, Register(dst), Register(src), i64(imm), 1) } -emit_vgetmantps_zmm_m512_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: Mem512, imm: i8) { emit_rmi(instructions, .VGETMANTPS, Register(dst), src.mem, 64, i64(imm), 1) } -inst_vgetmantpd_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return inst_r_r_i(.VGETMANTPD, Register(dst), Register(src), i64(imm), 1) } -inst_vgetmantpd_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem128, imm: i8) -> Instruction { return inst_r_m_i(.VGETMANTPD, Register(dst), src.mem, 16, i64(imm), 1) } -inst_vgetmantpd_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, imm: i8) -> Instruction { return inst_r_r_i(.VGETMANTPD, Register(dst), Register(src), i64(imm), 1) } -inst_vgetmantpd_ymm_m256_imm8 :: #force_inline proc "contextless" (dst: YMM, src: Mem256, imm: i8) -> Instruction { return inst_r_m_i(.VGETMANTPD, Register(dst), src.mem, 32, i64(imm), 1) } -inst_vgetmantpd_zmm_zmm_imm8 :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, imm: i8) -> Instruction { return inst_r_r_i(.VGETMANTPD, Register(dst), Register(src), i64(imm), 1) } -inst_vgetmantpd_zmm_m512_imm8 :: #force_inline proc "contextless" (dst: ZMM, src: Mem512, imm: i8) -> Instruction { return inst_r_m_i(.VGETMANTPD, Register(dst), src.mem, 64, i64(imm), 1) } -emit_vgetmantpd_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, imm: i8) { emit_rri(instructions, .VGETMANTPD, Register(dst), Register(src), i64(imm), 1) } -emit_vgetmantpd_xmm_m128_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128, imm: i8) { emit_rmi(instructions, .VGETMANTPD, Register(dst), src.mem, 16, i64(imm), 1) } -emit_vgetmantpd_ymm_ymm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, imm: i8) { emit_rri(instructions, .VGETMANTPD, Register(dst), Register(src), i64(imm), 1) } -emit_vgetmantpd_ymm_m256_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem256, imm: i8) { emit_rmi(instructions, .VGETMANTPD, Register(dst), src.mem, 32, i64(imm), 1) } -emit_vgetmantpd_zmm_zmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, imm: i8) { emit_rri(instructions, .VGETMANTPD, Register(dst), Register(src), i64(imm), 1) } -emit_vgetmantpd_zmm_m512_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: Mem512, imm: i8) { emit_rmi(instructions, .VGETMANTPD, Register(dst), src.mem, 64, i64(imm), 1) } +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) } +inst_vrsqrt14ps_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VRSQRT14PS, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 1943) } +inst_vrsqrt14ps_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VRSQRT14PS, operand_count = 2, ops = {op_ymm(dst), op_ymm(src), {}, {}} }, 1944) } +inst_vrsqrt14ps_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VRSQRT14PS, operand_count = 2, ops = {op_ymm(dst), op_mem(src.mem, 32), {}, {}} }, 1944) } +inst_vrsqrt14ps_zmm_zmm :: #force_inline proc "contextless" (dst: ZMM, src: ZMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VRSQRT14PS, operand_count = 2, ops = {op_zmm(dst), op_zmm(src), {}, {}} }, 1945) } +inst_vrsqrt14ps_zmm_m512 :: #force_inline proc "contextless" (dst: ZMM, src: Mem512) -> Instruction { return with_hint(Instruction{ mnemonic = .VRSQRT14PS, operand_count = 2, ops = {op_zmm(dst), op_mem(src.mem, 64), {}, {}} }, 1945) } +emit_vrsqrt14ps_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_vrsqrt14ps_xmm_xmm(dst, src)) } +emit_vrsqrt14ps_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_vrsqrt14ps_xmm_m128(dst, src)) } +emit_vrsqrt14ps_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM) { append(instructions, inst_vrsqrt14ps_ymm_ymm(dst, src)) } +emit_vrsqrt14ps_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem256) { append(instructions, inst_vrsqrt14ps_ymm_m256(dst, src)) } +emit_vrsqrt14ps_zmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM) { append(instructions, inst_vrsqrt14ps_zmm_zmm(dst, src)) } +emit_vrsqrt14ps_zmm_m512 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: Mem512) { append(instructions, inst_vrsqrt14ps_zmm_m512(dst, src)) } +inst_vrsqrt14pd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VRSQRT14PD, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 1946) } +inst_vrsqrt14pd_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VRSQRT14PD, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 1946) } +inst_vrsqrt14pd_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VRSQRT14PD, operand_count = 2, ops = {op_ymm(dst), op_ymm(src), {}, {}} }, 1947) } +inst_vrsqrt14pd_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VRSQRT14PD, operand_count = 2, ops = {op_ymm(dst), op_mem(src.mem, 32), {}, {}} }, 1947) } +inst_vrsqrt14pd_zmm_zmm :: #force_inline proc "contextless" (dst: ZMM, src: ZMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VRSQRT14PD, operand_count = 2, ops = {op_zmm(dst), op_zmm(src), {}, {}} }, 1948) } +inst_vrsqrt14pd_zmm_m512 :: #force_inline proc "contextless" (dst: ZMM, src: Mem512) -> Instruction { return with_hint(Instruction{ mnemonic = .VRSQRT14PD, operand_count = 2, ops = {op_zmm(dst), op_mem(src.mem, 64), {}, {}} }, 1948) } +emit_vrsqrt14pd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_vrsqrt14pd_xmm_xmm(dst, src)) } +emit_vrsqrt14pd_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_vrsqrt14pd_xmm_m128(dst, src)) } +emit_vrsqrt14pd_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM) { append(instructions, inst_vrsqrt14pd_ymm_ymm(dst, src)) } +emit_vrsqrt14pd_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem256) { append(instructions, inst_vrsqrt14pd_ymm_m256(dst, src)) } +emit_vrsqrt14pd_zmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM) { append(instructions, inst_vrsqrt14pd_zmm_zmm(dst, src)) } +emit_vrsqrt14pd_zmm_m512 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: Mem512) { append(instructions, inst_vrsqrt14pd_zmm_m512(dst, src)) } +inst_vrsqrt14ss_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VRSQRT14SS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1949) } +inst_vrsqrt14ss_xmm_xmm_m32 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .VRSQRT14SS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 4), {}} }, 1949) } +emit_vrsqrt14ss_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vrsqrt14ss_xmm_xmm_xmm(dst, src, src2)) } +emit_vrsqrt14ss_xmm_xmm_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem32) { append(instructions, inst_vrsqrt14ss_xmm_xmm_m32(dst, src, src2)) } +inst_vrsqrt14sd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VRSQRT14SD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1950) } +inst_vrsqrt14sd_xmm_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .VRSQRT14SD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 8), {}} }, 1950) } +emit_vrsqrt14sd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vrsqrt14sd_xmm_xmm_xmm(dst, src, src2)) } +emit_vrsqrt14sd_xmm_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem64) { append(instructions, inst_vrsqrt14sd_xmm_xmm_m64(dst, src, src2)) } +inst_vrcp14ps_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VRCP14PS, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 1951) } +inst_vrcp14ps_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VRCP14PS, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 1951) } +inst_vrcp14ps_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VRCP14PS, operand_count = 2, ops = {op_ymm(dst), op_ymm(src), {}, {}} }, 1952) } +inst_vrcp14ps_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VRCP14PS, operand_count = 2, ops = {op_ymm(dst), op_mem(src.mem, 32), {}, {}} }, 1952) } +inst_vrcp14ps_zmm_zmm :: #force_inline proc "contextless" (dst: ZMM, src: ZMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VRCP14PS, operand_count = 2, ops = {op_zmm(dst), op_zmm(src), {}, {}} }, 1953) } +inst_vrcp14ps_zmm_m512 :: #force_inline proc "contextless" (dst: ZMM, src: Mem512) -> Instruction { return with_hint(Instruction{ mnemonic = .VRCP14PS, operand_count = 2, ops = {op_zmm(dst), op_mem(src.mem, 64), {}, {}} }, 1953) } +emit_vrcp14ps_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_vrcp14ps_xmm_xmm(dst, src)) } +emit_vrcp14ps_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_vrcp14ps_xmm_m128(dst, src)) } +emit_vrcp14ps_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM) { append(instructions, inst_vrcp14ps_ymm_ymm(dst, src)) } +emit_vrcp14ps_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem256) { append(instructions, inst_vrcp14ps_ymm_m256(dst, src)) } +emit_vrcp14ps_zmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM) { append(instructions, inst_vrcp14ps_zmm_zmm(dst, src)) } +emit_vrcp14ps_zmm_m512 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: Mem512) { append(instructions, inst_vrcp14ps_zmm_m512(dst, src)) } +inst_vrcp14pd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VRCP14PD, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 1954) } +inst_vrcp14pd_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VRCP14PD, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 1954) } +inst_vrcp14pd_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VRCP14PD, operand_count = 2, ops = {op_ymm(dst), op_ymm(src), {}, {}} }, 1955) } +inst_vrcp14pd_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VRCP14PD, operand_count = 2, ops = {op_ymm(dst), op_mem(src.mem, 32), {}, {}} }, 1955) } +inst_vrcp14pd_zmm_zmm :: #force_inline proc "contextless" (dst: ZMM, src: ZMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VRCP14PD, operand_count = 2, ops = {op_zmm(dst), op_zmm(src), {}, {}} }, 1956) } +inst_vrcp14pd_zmm_m512 :: #force_inline proc "contextless" (dst: ZMM, src: Mem512) -> Instruction { return with_hint(Instruction{ mnemonic = .VRCP14PD, operand_count = 2, ops = {op_zmm(dst), op_mem(src.mem, 64), {}, {}} }, 1956) } +emit_vrcp14pd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_vrcp14pd_xmm_xmm(dst, src)) } +emit_vrcp14pd_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_vrcp14pd_xmm_m128(dst, src)) } +emit_vrcp14pd_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM) { append(instructions, inst_vrcp14pd_ymm_ymm(dst, src)) } +emit_vrcp14pd_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem256) { append(instructions, inst_vrcp14pd_ymm_m256(dst, src)) } +emit_vrcp14pd_zmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM) { append(instructions, inst_vrcp14pd_zmm_zmm(dst, src)) } +emit_vrcp14pd_zmm_m512 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: Mem512) { append(instructions, inst_vrcp14pd_zmm_m512(dst, src)) } +inst_vrcp14ss_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VRCP14SS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1957) } +inst_vrcp14ss_xmm_xmm_m32 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .VRCP14SS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 4), {}} }, 1957) } +emit_vrcp14ss_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vrcp14ss_xmm_xmm_xmm(dst, src, src2)) } +emit_vrcp14ss_xmm_xmm_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem32) { append(instructions, inst_vrcp14ss_xmm_xmm_m32(dst, src, src2)) } +inst_vrcp14sd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VRCP14SD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1958) } +inst_vrcp14sd_xmm_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .VRCP14SD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 8), {}} }, 1958) } +emit_vrcp14sd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vrcp14sd_xmm_xmm_xmm(dst, src, src2)) } +emit_vrcp14sd_xmm_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem64) { append(instructions, inst_vrcp14sd_xmm_xmm_m64(dst, src, src2)) } +inst_vscalefps_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VSCALEFPS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1959) } +inst_vscalefps_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VSCALEFPS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1959) } +inst_vscalefps_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VSCALEFPS, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1960) } +inst_vscalefps_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VSCALEFPS, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1960) } +inst_vscalefps_zmm_zmm_zmm :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: ZMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VSCALEFPS, operand_count = 3, ops = {op_zmm(dst), op_zmm(src), op_zmm(src2), {}} }, 1961) } +inst_vscalefps_zmm_zmm_m512 :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: Mem512) -> Instruction { return with_hint(Instruction{ mnemonic = .VSCALEFPS, operand_count = 3, ops = {op_zmm(dst), op_zmm(src), op_mem(src2.mem, 64), {}} }, 1961) } +emit_vscalefps_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vscalefps_xmm_xmm_xmm(dst, src, src2)) } +emit_vscalefps_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vscalefps_xmm_xmm_m128(dst, src, src2)) } +emit_vscalefps_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vscalefps_ymm_ymm_ymm(dst, src, src2)) } +emit_vscalefps_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vscalefps_ymm_ymm_m256(dst, src, src2)) } +emit_vscalefps_zmm_zmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: ZMM) { append(instructions, inst_vscalefps_zmm_zmm_zmm(dst, src, src2)) } +emit_vscalefps_zmm_zmm_m512 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: Mem512) { append(instructions, inst_vscalefps_zmm_zmm_m512(dst, src, src2)) } +inst_vscalefpd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VSCALEFPD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1962) } +inst_vscalefpd_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VSCALEFPD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1962) } +inst_vscalefpd_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VSCALEFPD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1963) } +inst_vscalefpd_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VSCALEFPD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1963) } +inst_vscalefpd_zmm_zmm_zmm :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: ZMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VSCALEFPD, operand_count = 3, ops = {op_zmm(dst), op_zmm(src), op_zmm(src2), {}} }, 1964) } +inst_vscalefpd_zmm_zmm_m512 :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: Mem512) -> Instruction { return with_hint(Instruction{ mnemonic = .VSCALEFPD, operand_count = 3, ops = {op_zmm(dst), op_zmm(src), op_mem(src2.mem, 64), {}} }, 1964) } +emit_vscalefpd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vscalefpd_xmm_xmm_xmm(dst, src, src2)) } +emit_vscalefpd_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vscalefpd_xmm_xmm_m128(dst, src, src2)) } +emit_vscalefpd_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vscalefpd_ymm_ymm_ymm(dst, src, src2)) } +emit_vscalefpd_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vscalefpd_ymm_ymm_m256(dst, src, src2)) } +emit_vscalefpd_zmm_zmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: ZMM) { append(instructions, inst_vscalefpd_zmm_zmm_zmm(dst, src, src2)) } +emit_vscalefpd_zmm_zmm_m512 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: Mem512) { append(instructions, inst_vscalefpd_zmm_zmm_m512(dst, src, src2)) } +inst_vscalefss_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VSCALEFSS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1965) } +inst_vscalefss_xmm_xmm_m32 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .VSCALEFSS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 4), {}} }, 1965) } +emit_vscalefss_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vscalefss_xmm_xmm_xmm(dst, src, src2)) } +emit_vscalefss_xmm_xmm_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem32) { append(instructions, inst_vscalefss_xmm_xmm_m32(dst, src, src2)) } +inst_vscalefsd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VSCALEFSD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1966) } +inst_vscalefsd_xmm_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .VSCALEFSD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 8), {}} }, 1966) } +emit_vscalefsd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vscalefsd_xmm_xmm_xmm(dst, src, src2)) } +emit_vscalefsd_xmm_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem64) { append(instructions, inst_vscalefsd_xmm_xmm_m64(dst, src, src2)) } +inst_vgetexpps_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VGETEXPPS, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 1967) } +inst_vgetexpps_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VGETEXPPS, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 1967) } +inst_vgetexpps_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VGETEXPPS, operand_count = 2, ops = {op_ymm(dst), op_ymm(src), {}, {}} }, 1968) } +inst_vgetexpps_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VGETEXPPS, operand_count = 2, ops = {op_ymm(dst), op_mem(src.mem, 32), {}, {}} }, 1968) } +inst_vgetexpps_zmm_zmm :: #force_inline proc "contextless" (dst: ZMM, src: ZMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VGETEXPPS, operand_count = 2, ops = {op_zmm(dst), op_zmm(src), {}, {}} }, 1969) } +inst_vgetexpps_zmm_m512 :: #force_inline proc "contextless" (dst: ZMM, src: Mem512) -> Instruction { return with_hint(Instruction{ mnemonic = .VGETEXPPS, operand_count = 2, ops = {op_zmm(dst), op_mem(src.mem, 64), {}, {}} }, 1969) } +emit_vgetexpps_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_vgetexpps_xmm_xmm(dst, src)) } +emit_vgetexpps_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_vgetexpps_xmm_m128(dst, src)) } +emit_vgetexpps_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM) { append(instructions, inst_vgetexpps_ymm_ymm(dst, src)) } +emit_vgetexpps_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem256) { append(instructions, inst_vgetexpps_ymm_m256(dst, src)) } +emit_vgetexpps_zmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM) { append(instructions, inst_vgetexpps_zmm_zmm(dst, src)) } +emit_vgetexpps_zmm_m512 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: Mem512) { append(instructions, inst_vgetexpps_zmm_m512(dst, src)) } +inst_vgetexppd_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VGETEXPPD, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 1970) } +inst_vgetexppd_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VGETEXPPD, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 1970) } +inst_vgetexppd_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VGETEXPPD, operand_count = 2, ops = {op_ymm(dst), op_ymm(src), {}, {}} }, 1971) } +inst_vgetexppd_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VGETEXPPD, operand_count = 2, ops = {op_ymm(dst), op_mem(src.mem, 32), {}, {}} }, 1971) } +inst_vgetexppd_zmm_zmm :: #force_inline proc "contextless" (dst: ZMM, src: ZMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VGETEXPPD, operand_count = 2, ops = {op_zmm(dst), op_zmm(src), {}, {}} }, 1972) } +inst_vgetexppd_zmm_m512 :: #force_inline proc "contextless" (dst: ZMM, src: Mem512) -> Instruction { return with_hint(Instruction{ mnemonic = .VGETEXPPD, operand_count = 2, ops = {op_zmm(dst), op_mem(src.mem, 64), {}, {}} }, 1972) } +emit_vgetexppd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_vgetexppd_xmm_xmm(dst, src)) } +emit_vgetexppd_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_vgetexppd_xmm_m128(dst, src)) } +emit_vgetexppd_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM) { append(instructions, inst_vgetexppd_ymm_ymm(dst, src)) } +emit_vgetexppd_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem256) { append(instructions, inst_vgetexppd_ymm_m256(dst, src)) } +emit_vgetexppd_zmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM) { append(instructions, inst_vgetexppd_zmm_zmm(dst, src)) } +emit_vgetexppd_zmm_m512 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: Mem512) { append(instructions, inst_vgetexppd_zmm_m512(dst, src)) } +inst_vgetexpss_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VGETEXPSS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1973) } +inst_vgetexpss_xmm_xmm_m32 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .VGETEXPSS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 4), {}} }, 1973) } +emit_vgetexpss_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vgetexpss_xmm_xmm_xmm(dst, src, src2)) } +emit_vgetexpss_xmm_xmm_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem32) { append(instructions, inst_vgetexpss_xmm_xmm_m32(dst, src, src2)) } +inst_vgetexpsd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VGETEXPSD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1974) } +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), {}} } } +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), {}} } } +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)} } } 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)) } @@ -6745,38 +6745,38 @@ inst_vfixupimmsd_xmm_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XM 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)} } } 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 inst_r_r_i(.VFPCLASSPS, Register(dst), Register(src), i64(imm), 1) } -inst_vfpclassps_k_m128_imm8 :: #force_inline proc "contextless" (dst: KREG, src: Mem128, imm: i8) -> Instruction { return inst_r_m_i(.VFPCLASSPS, Register(dst), src.mem, 16, i64(imm), 1) } -inst_vfpclassps_k_ymm_imm8 :: #force_inline proc "contextless" (dst: KREG, src: YMM, imm: i8) -> Instruction { return inst_r_r_i(.VFPCLASSPS, Register(dst), Register(src), i64(imm), 1) } -inst_vfpclassps_k_m256_imm8 :: #force_inline proc "contextless" (dst: KREG, src: Mem256, imm: i8) -> Instruction { return inst_r_m_i(.VFPCLASSPS, Register(dst), src.mem, 32, i64(imm), 1) } -inst_vfpclassps_k_zmm_imm8 :: #force_inline proc "contextless" (dst: KREG, src: ZMM, imm: i8) -> Instruction { return inst_r_r_i(.VFPCLASSPS, Register(dst), Register(src), i64(imm), 1) } -inst_vfpclassps_k_m512_imm8 :: #force_inline proc "contextless" (dst: KREG, src: Mem512, imm: i8) -> Instruction { return inst_r_m_i(.VFPCLASSPS, Register(dst), src.mem, 64, i64(imm), 1) } -emit_vfpclassps_k_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: XMM, imm: i8) { emit_rri(instructions, .VFPCLASSPS, Register(dst), Register(src), i64(imm), 1) } -emit_vfpclassps_k_m128_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: Mem128, imm: i8) { emit_rmi(instructions, .VFPCLASSPS, Register(dst), src.mem, 16, i64(imm), 1) } -emit_vfpclassps_k_ymm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: YMM, imm: i8) { emit_rri(instructions, .VFPCLASSPS, Register(dst), Register(src), i64(imm), 1) } -emit_vfpclassps_k_m256_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: Mem256, imm: i8) { emit_rmi(instructions, .VFPCLASSPS, Register(dst), src.mem, 32, i64(imm), 1) } -emit_vfpclassps_k_zmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: ZMM, imm: i8) { emit_rri(instructions, .VFPCLASSPS, Register(dst), Register(src), i64(imm), 1) } -emit_vfpclassps_k_m512_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: Mem512, imm: i8) { emit_rmi(instructions, .VFPCLASSPS, Register(dst), src.mem, 64, i64(imm), 1) } -inst_vfpclasspd_k_xmm_imm8 :: #force_inline proc "contextless" (dst: KREG, src: XMM, imm: i8) -> Instruction { return inst_r_r_i(.VFPCLASSPD, Register(dst), Register(src), i64(imm), 1) } -inst_vfpclasspd_k_m128_imm8 :: #force_inline proc "contextless" (dst: KREG, src: Mem128, imm: i8) -> Instruction { return inst_r_m_i(.VFPCLASSPD, Register(dst), src.mem, 16, i64(imm), 1) } -inst_vfpclasspd_k_ymm_imm8 :: #force_inline proc "contextless" (dst: KREG, src: YMM, imm: i8) -> Instruction { return inst_r_r_i(.VFPCLASSPD, Register(dst), Register(src), i64(imm), 1) } -inst_vfpclasspd_k_m256_imm8 :: #force_inline proc "contextless" (dst: KREG, src: Mem256, imm: i8) -> Instruction { return inst_r_m_i(.VFPCLASSPD, Register(dst), src.mem, 32, i64(imm), 1) } -inst_vfpclasspd_k_zmm_imm8 :: #force_inline proc "contextless" (dst: KREG, src: ZMM, imm: i8) -> Instruction { return inst_r_r_i(.VFPCLASSPD, Register(dst), Register(src), i64(imm), 1) } -inst_vfpclasspd_k_m512_imm8 :: #force_inline proc "contextless" (dst: KREG, src: Mem512, imm: i8) -> Instruction { return inst_r_m_i(.VFPCLASSPD, Register(dst), src.mem, 64, i64(imm), 1) } -emit_vfpclasspd_k_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: XMM, imm: i8) { emit_rri(instructions, .VFPCLASSPD, Register(dst), Register(src), i64(imm), 1) } -emit_vfpclasspd_k_m128_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: Mem128, imm: i8) { emit_rmi(instructions, .VFPCLASSPD, Register(dst), src.mem, 16, i64(imm), 1) } -emit_vfpclasspd_k_ymm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: YMM, imm: i8) { emit_rri(instructions, .VFPCLASSPD, Register(dst), Register(src), i64(imm), 1) } -emit_vfpclasspd_k_m256_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: Mem256, imm: i8) { emit_rmi(instructions, .VFPCLASSPD, Register(dst), src.mem, 32, i64(imm), 1) } -emit_vfpclasspd_k_zmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: ZMM, imm: i8) { emit_rri(instructions, .VFPCLASSPD, Register(dst), Register(src), i64(imm), 1) } -emit_vfpclasspd_k_m512_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: Mem512, imm: i8) { emit_rmi(instructions, .VFPCLASSPD, Register(dst), src.mem, 64, i64(imm), 1) } -inst_vfpclassss_k_xmm_imm8 :: #force_inline proc "contextless" (dst: KREG, src: XMM, imm: i8) -> Instruction { return inst_r_r_i(.VFPCLASSSS, Register(dst), Register(src), i64(imm), 1) } -inst_vfpclassss_k_m32_imm8 :: #force_inline proc "contextless" (dst: KREG, src: Mem32, imm: i8) -> Instruction { return inst_r_m_i(.VFPCLASSSS, Register(dst), src.mem, 4, i64(imm), 1) } -emit_vfpclassss_k_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: XMM, imm: i8) { emit_rri(instructions, .VFPCLASSSS, Register(dst), Register(src), i64(imm), 1) } -emit_vfpclassss_k_m32_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: Mem32, imm: i8) { emit_rmi(instructions, .VFPCLASSSS, Register(dst), src.mem, 4, i64(imm), 1) } -inst_vfpclasssd_k_xmm_imm8 :: #force_inline proc "contextless" (dst: KREG, src: XMM, imm: i8) -> Instruction { return inst_r_r_i(.VFPCLASSSD, Register(dst), Register(src), i64(imm), 1) } -inst_vfpclasssd_k_m64_imm8 :: #force_inline proc "contextless" (dst: KREG, src: Mem64, imm: i8) -> Instruction { return inst_r_m_i(.VFPCLASSSD, Register(dst), src.mem, 8, i64(imm), 1) } -emit_vfpclasssd_k_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: XMM, imm: i8) { emit_rri(instructions, .VFPCLASSSD, Register(dst), Register(src), i64(imm), 1) } -emit_vfpclasssd_k_m64_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: Mem64, imm: i8) { emit_rmi(instructions, .VFPCLASSSD, Register(dst), src.mem, 8, i64(imm), 1) } +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), {}} } } +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), {}} } } +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), {}} } } +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), {}} } } +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)} } } @@ -6837,730 +6837,730 @@ emit_vpternlogq_ymm_ymm_ymm_imm8 :: #force_inline proc(instructions: ^[dynami emit_vpternlogq_ymm_ymm_m256_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256, imm: i8) { append(instructions, inst_vpternlogq_ymm_ymm_m256_imm8(dst, src, src2, imm)) } emit_vpternlogq_zmm_zmm_zmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: ZMM, imm: i8) { append(instructions, inst_vpternlogq_zmm_zmm_zmm_imm8(dst, src, src2, imm)) } emit_vpternlogq_zmm_zmm_m512_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: Mem512, imm: i8) { append(instructions, inst_vpternlogq_zmm_zmm_m512_imm8(dst, src, src2, imm)) } -inst_vpmultishiftqb_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return inst_r_r_r(.VPMULTISHIFTQB, Register(dst), Register(src), Register(src2)) } -inst_vpmultishiftqb_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return inst_r_r_m(.VPMULTISHIFTQB, Register(dst), Register(src), src2.mem, 16) } -inst_vpmultishiftqb_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return inst_r_r_r(.VPMULTISHIFTQB, Register(dst), Register(src), Register(src2)) } -inst_vpmultishiftqb_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return inst_r_r_m(.VPMULTISHIFTQB, Register(dst), Register(src), src2.mem, 32) } -inst_vpmultishiftqb_zmm_zmm_zmm :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: ZMM) -> Instruction { return inst_r_r_r(.VPMULTISHIFTQB, Register(dst), Register(src), Register(src2)) } -inst_vpmultishiftqb_zmm_zmm_m512 :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: Mem512) -> Instruction { return inst_r_r_m(.VPMULTISHIFTQB, Register(dst), Register(src), src2.mem, 64) } -emit_vpmultishiftqb_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { emit_rrr(instructions, .VPMULTISHIFTQB, Register(dst), Register(src), Register(src2)) } -emit_vpmultishiftqb_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { emit_rrm(instructions, .VPMULTISHIFTQB, Register(dst), Register(src), src2.mem, 16) } -emit_vpmultishiftqb_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { emit_rrr(instructions, .VPMULTISHIFTQB, Register(dst), Register(src), Register(src2)) } -emit_vpmultishiftqb_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { emit_rrm(instructions, .VPMULTISHIFTQB, Register(dst), Register(src), src2.mem, 32) } -emit_vpmultishiftqb_zmm_zmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: ZMM) { emit_rrr(instructions, .VPMULTISHIFTQB, Register(dst), Register(src), Register(src2)) } -emit_vpmultishiftqb_zmm_zmm_m512 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: Mem512) { emit_rrm(instructions, .VPMULTISHIFTQB, Register(dst), Register(src), src2.mem, 64) } -inst_kaddw_k_k_k :: #force_inline proc "contextless" (dst: KREG, src: KREG, src2: KREG) -> Instruction { return inst_r_r_r(.KADDW, Register(dst), Register(src), Register(src2)) } -emit_kaddw_k_k_k :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: KREG, src2: KREG) { emit_rrr(instructions, .KADDW, Register(dst), Register(src), Register(src2)) } -inst_kaddb_k_k_k :: #force_inline proc "contextless" (dst: KREG, src: KREG, src2: KREG) -> Instruction { return inst_r_r_r(.KADDB, Register(dst), Register(src), Register(src2)) } -emit_kaddb_k_k_k :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: KREG, src2: KREG) { emit_rrr(instructions, .KADDB, Register(dst), Register(src), Register(src2)) } -inst_kaddq_k_k_k :: #force_inline proc "contextless" (dst: KREG, src: KREG, src2: KREG) -> Instruction { return inst_r_r_r(.KADDQ, Register(dst), Register(src), Register(src2)) } -emit_kaddq_k_k_k :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: KREG, src2: KREG) { emit_rrr(instructions, .KADDQ, Register(dst), Register(src), Register(src2)) } -inst_kaddd_k_k_k :: #force_inline proc "contextless" (dst: KREG, src: KREG, src2: KREG) -> Instruction { return inst_r_r_r(.KADDD, Register(dst), Register(src), Register(src2)) } -emit_kaddd_k_k_k :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: KREG, src2: KREG) { emit_rrr(instructions, .KADDD, Register(dst), Register(src), Register(src2)) } -inst_kandw_k_k_k :: #force_inline proc "contextless" (dst: KREG, src: KREG, src2: KREG) -> Instruction { return inst_r_r_r(.KANDW, Register(dst), Register(src), Register(src2)) } -emit_kandw_k_k_k :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: KREG, src2: KREG) { emit_rrr(instructions, .KANDW, Register(dst), Register(src), Register(src2)) } -inst_kandb_k_k_k :: #force_inline proc "contextless" (dst: KREG, src: KREG, src2: KREG) -> Instruction { return inst_r_r_r(.KANDB, Register(dst), Register(src), Register(src2)) } -emit_kandb_k_k_k :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: KREG, src2: KREG) { emit_rrr(instructions, .KANDB, Register(dst), Register(src), Register(src2)) } -inst_kandq_k_k_k :: #force_inline proc "contextless" (dst: KREG, src: KREG, src2: KREG) -> Instruction { return inst_r_r_r(.KANDQ, Register(dst), Register(src), Register(src2)) } -emit_kandq_k_k_k :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: KREG, src2: KREG) { emit_rrr(instructions, .KANDQ, Register(dst), Register(src), Register(src2)) } -inst_kandd_k_k_k :: #force_inline proc "contextless" (dst: KREG, src: KREG, src2: KREG) -> Instruction { return inst_r_r_r(.KANDD, Register(dst), Register(src), Register(src2)) } -emit_kandd_k_k_k :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: KREG, src2: KREG) { emit_rrr(instructions, .KANDD, Register(dst), Register(src), Register(src2)) } -inst_kandnw_k_k_k :: #force_inline proc "contextless" (dst: KREG, src: KREG, src2: KREG) -> Instruction { return inst_r_r_r(.KANDNW, Register(dst), Register(src), Register(src2)) } -emit_kandnw_k_k_k :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: KREG, src2: KREG) { emit_rrr(instructions, .KANDNW, Register(dst), Register(src), Register(src2)) } -inst_kandnb_k_k_k :: #force_inline proc "contextless" (dst: KREG, src: KREG, src2: KREG) -> Instruction { return inst_r_r_r(.KANDNB, Register(dst), Register(src), Register(src2)) } -emit_kandnb_k_k_k :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: KREG, src2: KREG) { emit_rrr(instructions, .KANDNB, Register(dst), Register(src), Register(src2)) } -inst_kandnq_k_k_k :: #force_inline proc "contextless" (dst: KREG, src: KREG, src2: KREG) -> Instruction { return inst_r_r_r(.KANDNQ, Register(dst), Register(src), Register(src2)) } -emit_kandnq_k_k_k :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: KREG, src2: KREG) { emit_rrr(instructions, .KANDNQ, Register(dst), Register(src), Register(src2)) } -inst_kandnd_k_k_k :: #force_inline proc "contextless" (dst: KREG, src: KREG, src2: KREG) -> Instruction { return inst_r_r_r(.KANDND, Register(dst), Register(src), Register(src2)) } -emit_kandnd_k_k_k :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: KREG, src2: KREG) { emit_rrr(instructions, .KANDND, Register(dst), Register(src), Register(src2)) } -inst_kmovw_k_k :: #force_inline proc "contextless" (dst: KREG, src: KREG) -> Instruction { return inst_r_r(.KMOVW, Register(dst), Register(src)) } -inst_kmovw_k_m16 :: #force_inline proc "contextless" (dst: KREG, src: Mem16) -> Instruction { return inst_r_m(.KMOVW, Register(dst), src.mem, 2) } -inst_kmovw_m16_k :: #force_inline proc "contextless" (dst: Mem16, src: KREG) -> Instruction { return inst_m_r(.KMOVW, dst.mem, 2, Register(src)) } -inst_kmovw_k_r32 :: #force_inline proc "contextless" (dst: KREG, src: GPR32) -> Instruction { return inst_r_r(.KMOVW, Register(dst), Register(src)) } -inst_kmovw_r32_k :: #force_inline proc "contextless" (dst: GPR32, src: KREG) -> Instruction { return inst_r_r(.KMOVW, Register(dst), Register(src)) } -emit_kmovw_k_k :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: KREG) { emit_rr(instructions, .KMOVW, Register(dst), Register(src)) } -emit_kmovw_k_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: Mem16) { emit_rm(instructions, .KMOVW, Register(dst), src.mem, 2) } -emit_kmovw_m16_k :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16, src: KREG) { emit_mr(instructions, .KMOVW, dst.mem, 2, Register(src)) } -emit_kmovw_k_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: GPR32) { emit_rr(instructions, .KMOVW, Register(dst), Register(src)) } -emit_kmovw_r32_k :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: KREG) { emit_rr(instructions, .KMOVW, Register(dst), Register(src)) } -inst_kmovb_k_k :: #force_inline proc "contextless" (dst: KREG, src: KREG) -> Instruction { return inst_r_r(.KMOVB, Register(dst), Register(src)) } -inst_kmovb_k_m8 :: #force_inline proc "contextless" (dst: KREG, src: Mem8) -> Instruction { return inst_r_m(.KMOVB, Register(dst), src.mem, 1) } -inst_kmovb_m8_k :: #force_inline proc "contextless" (dst: Mem8, src: KREG) -> Instruction { return inst_m_r(.KMOVB, dst.mem, 1, Register(src)) } -inst_kmovb_k_r32 :: #force_inline proc "contextless" (dst: KREG, src: GPR32) -> Instruction { return inst_r_r(.KMOVB, Register(dst), Register(src)) } -inst_kmovb_r32_k :: #force_inline proc "contextless" (dst: GPR32, src: KREG) -> Instruction { return inst_r_r(.KMOVB, Register(dst), Register(src)) } -emit_kmovb_k_k :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: KREG) { emit_rr(instructions, .KMOVB, Register(dst), Register(src)) } -emit_kmovb_k_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: Mem8) { emit_rm(instructions, .KMOVB, Register(dst), src.mem, 1) } -emit_kmovb_m8_k :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8, src: KREG) { emit_mr(instructions, .KMOVB, dst.mem, 1, Register(src)) } -emit_kmovb_k_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: GPR32) { emit_rr(instructions, .KMOVB, Register(dst), Register(src)) } -emit_kmovb_r32_k :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: KREG) { emit_rr(instructions, .KMOVB, Register(dst), Register(src)) } -inst_kmovq_k_k :: #force_inline proc "contextless" (dst: KREG, src: KREG) -> Instruction { return inst_r_r(.KMOVQ, Register(dst), Register(src)) } -inst_kmovq_k_m64 :: #force_inline proc "contextless" (dst: KREG, src: Mem64) -> Instruction { return inst_r_m(.KMOVQ, Register(dst), src.mem, 8) } -inst_kmovq_m64_k :: #force_inline proc "contextless" (dst: Mem64, src: KREG) -> Instruction { return inst_m_r(.KMOVQ, dst.mem, 8, Register(src)) } -inst_kmovq_k_r64 :: #force_inline proc "contextless" (dst: KREG, src: GPR64) -> Instruction { return inst_r_r(.KMOVQ, Register(dst), Register(src)) } -inst_kmovq_r64_k :: #force_inline proc "contextless" (dst: GPR64, src: KREG) -> Instruction { return inst_r_r(.KMOVQ, Register(dst), Register(src)) } -emit_kmovq_k_k :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: KREG) { emit_rr(instructions, .KMOVQ, Register(dst), Register(src)) } -emit_kmovq_k_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: Mem64) { emit_rm(instructions, .KMOVQ, Register(dst), src.mem, 8) } -emit_kmovq_m64_k :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, src: KREG) { emit_mr(instructions, .KMOVQ, dst.mem, 8, Register(src)) } -emit_kmovq_k_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: GPR64) { emit_rr(instructions, .KMOVQ, Register(dst), Register(src)) } -emit_kmovq_r64_k :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: KREG) { emit_rr(instructions, .KMOVQ, Register(dst), Register(src)) } -inst_kmovd_k_k :: #force_inline proc "contextless" (dst: KREG, src: KREG) -> Instruction { return inst_r_r(.KMOVD, Register(dst), Register(src)) } -inst_kmovd_k_m32 :: #force_inline proc "contextless" (dst: KREG, src: Mem32) -> Instruction { return inst_r_m(.KMOVD, Register(dst), src.mem, 4) } -inst_kmovd_m32_k :: #force_inline proc "contextless" (dst: Mem32, src: KREG) -> Instruction { return inst_m_r(.KMOVD, dst.mem, 4, Register(src)) } -inst_kmovd_k_r32 :: #force_inline proc "contextless" (dst: KREG, src: GPR32) -> Instruction { return inst_r_r(.KMOVD, Register(dst), Register(src)) } -inst_kmovd_r32_k :: #force_inline proc "contextless" (dst: GPR32, src: KREG) -> Instruction { return inst_r_r(.KMOVD, Register(dst), Register(src)) } -emit_kmovd_k_k :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: KREG) { emit_rr(instructions, .KMOVD, Register(dst), Register(src)) } -emit_kmovd_k_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: Mem32) { emit_rm(instructions, .KMOVD, Register(dst), src.mem, 4) } -emit_kmovd_m32_k :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, src: KREG) { emit_mr(instructions, .KMOVD, dst.mem, 4, Register(src)) } -emit_kmovd_k_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: GPR32) { emit_rr(instructions, .KMOVD, Register(dst), Register(src)) } -emit_kmovd_r32_k :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: KREG) { emit_rr(instructions, .KMOVD, Register(dst), Register(src)) } -inst_knotw_k_k :: #force_inline proc "contextless" (dst: KREG, src: KREG) -> Instruction { return inst_r_r(.KNOTW, Register(dst), Register(src)) } -emit_knotw_k_k :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: KREG) { emit_rr(instructions, .KNOTW, Register(dst), Register(src)) } -inst_knotb_k_k :: #force_inline proc "contextless" (dst: KREG, src: KREG) -> Instruction { return inst_r_r(.KNOTB, Register(dst), Register(src)) } -emit_knotb_k_k :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: KREG) { emit_rr(instructions, .KNOTB, Register(dst), Register(src)) } -inst_knotq_k_k :: #force_inline proc "contextless" (dst: KREG, src: KREG) -> Instruction { return inst_r_r(.KNOTQ, Register(dst), Register(src)) } -emit_knotq_k_k :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: KREG) { emit_rr(instructions, .KNOTQ, Register(dst), Register(src)) } -inst_knotd_k_k :: #force_inline proc "contextless" (dst: KREG, src: KREG) -> Instruction { return inst_r_r(.KNOTD, Register(dst), Register(src)) } -emit_knotd_k_k :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: KREG) { emit_rr(instructions, .KNOTD, Register(dst), Register(src)) } -inst_korw_k_k_k :: #force_inline proc "contextless" (dst: KREG, src: KREG, src2: KREG) -> Instruction { return inst_r_r_r(.KORW, Register(dst), Register(src), Register(src2)) } -emit_korw_k_k_k :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: KREG, src2: KREG) { emit_rrr(instructions, .KORW, Register(dst), Register(src), Register(src2)) } -inst_korb_k_k_k :: #force_inline proc "contextless" (dst: KREG, src: KREG, src2: KREG) -> Instruction { return inst_r_r_r(.KORB, Register(dst), Register(src), Register(src2)) } -emit_korb_k_k_k :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: KREG, src2: KREG) { emit_rrr(instructions, .KORB, Register(dst), Register(src), Register(src2)) } -inst_korq_k_k_k :: #force_inline proc "contextless" (dst: KREG, src: KREG, src2: KREG) -> Instruction { return inst_r_r_r(.KORQ, Register(dst), Register(src), Register(src2)) } -emit_korq_k_k_k :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: KREG, src2: KREG) { emit_rrr(instructions, .KORQ, Register(dst), Register(src), Register(src2)) } -inst_kord_k_k_k :: #force_inline proc "contextless" (dst: KREG, src: KREG, src2: KREG) -> Instruction { return inst_r_r_r(.KORD, Register(dst), Register(src), Register(src2)) } -emit_kord_k_k_k :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: KREG, src2: KREG) { emit_rrr(instructions, .KORD, Register(dst), Register(src), Register(src2)) } -inst_kortestw_k_k :: #force_inline proc "contextless" (dst: KREG, src: KREG) -> Instruction { return inst_r_r(.KORTESTW, Register(dst), Register(src)) } -emit_kortestw_k_k :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: KREG) { emit_rr(instructions, .KORTESTW, Register(dst), Register(src)) } -inst_kortestb_k_k :: #force_inline proc "contextless" (dst: KREG, src: KREG) -> Instruction { return inst_r_r(.KORTESTB, Register(dst), Register(src)) } -emit_kortestb_k_k :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: KREG) { emit_rr(instructions, .KORTESTB, Register(dst), Register(src)) } -inst_kortestq_k_k :: #force_inline proc "contextless" (dst: KREG, src: KREG) -> Instruction { return inst_r_r(.KORTESTQ, Register(dst), Register(src)) } -emit_kortestq_k_k :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: KREG) { emit_rr(instructions, .KORTESTQ, Register(dst), Register(src)) } -inst_kortestd_k_k :: #force_inline proc "contextless" (dst: KREG, src: KREG) -> Instruction { return inst_r_r(.KORTESTD, Register(dst), Register(src)) } -emit_kortestd_k_k :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: KREG) { emit_rr(instructions, .KORTESTD, Register(dst), Register(src)) } -inst_kshiftlw_k_k_imm8 :: #force_inline proc "contextless" (dst: KREG, src: KREG, imm: i8) -> Instruction { return inst_r_r_i(.KSHIFTLW, Register(dst), Register(src), i64(imm), 1) } -emit_kshiftlw_k_k_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: KREG, imm: i8) { emit_rri(instructions, .KSHIFTLW, Register(dst), Register(src), i64(imm), 1) } -inst_kshiftlb_k_k_imm8 :: #force_inline proc "contextless" (dst: KREG, src: KREG, imm: i8) -> Instruction { return inst_r_r_i(.KSHIFTLB, Register(dst), Register(src), i64(imm), 1) } -emit_kshiftlb_k_k_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: KREG, imm: i8) { emit_rri(instructions, .KSHIFTLB, Register(dst), Register(src), i64(imm), 1) } -inst_kshiftlq_k_k_imm8 :: #force_inline proc "contextless" (dst: KREG, src: KREG, imm: i8) -> Instruction { return inst_r_r_i(.KSHIFTLQ, Register(dst), Register(src), i64(imm), 1) } -emit_kshiftlq_k_k_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: KREG, imm: i8) { emit_rri(instructions, .KSHIFTLQ, Register(dst), Register(src), i64(imm), 1) } -inst_kshiftld_k_k_imm8 :: #force_inline proc "contextless" (dst: KREG, src: KREG, imm: i8) -> Instruction { return inst_r_r_i(.KSHIFTLD, Register(dst), Register(src), i64(imm), 1) } -emit_kshiftld_k_k_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: KREG, imm: i8) { emit_rri(instructions, .KSHIFTLD, Register(dst), Register(src), i64(imm), 1) } -inst_kshiftrw_k_k_imm8 :: #force_inline proc "contextless" (dst: KREG, src: KREG, imm: i8) -> Instruction { return inst_r_r_i(.KSHIFTRW, Register(dst), Register(src), i64(imm), 1) } -emit_kshiftrw_k_k_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: KREG, imm: i8) { emit_rri(instructions, .KSHIFTRW, Register(dst), Register(src), i64(imm), 1) } -inst_kshiftrb_k_k_imm8 :: #force_inline proc "contextless" (dst: KREG, src: KREG, imm: i8) -> Instruction { return inst_r_r_i(.KSHIFTRB, Register(dst), Register(src), i64(imm), 1) } -emit_kshiftrb_k_k_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: KREG, imm: i8) { emit_rri(instructions, .KSHIFTRB, Register(dst), Register(src), i64(imm), 1) } -inst_kshiftrq_k_k_imm8 :: #force_inline proc "contextless" (dst: KREG, src: KREG, imm: i8) -> Instruction { return inst_r_r_i(.KSHIFTRQ, Register(dst), Register(src), i64(imm), 1) } -emit_kshiftrq_k_k_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: KREG, imm: i8) { emit_rri(instructions, .KSHIFTRQ, Register(dst), Register(src), i64(imm), 1) } -inst_kshiftrd_k_k_imm8 :: #force_inline proc "contextless" (dst: KREG, src: KREG, imm: i8) -> Instruction { return inst_r_r_i(.KSHIFTRD, Register(dst), Register(src), i64(imm), 1) } -emit_kshiftrd_k_k_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: KREG, imm: i8) { emit_rri(instructions, .KSHIFTRD, Register(dst), Register(src), i64(imm), 1) } -inst_ktestw_k_k :: #force_inline proc "contextless" (dst: KREG, src: KREG) -> Instruction { return inst_r_r(.KTESTW, Register(dst), Register(src)) } -emit_ktestw_k_k :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: KREG) { emit_rr(instructions, .KTESTW, Register(dst), Register(src)) } -inst_ktestb_k_k :: #force_inline proc "contextless" (dst: KREG, src: KREG) -> Instruction { return inst_r_r(.KTESTB, Register(dst), Register(src)) } -emit_ktestb_k_k :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: KREG) { emit_rr(instructions, .KTESTB, Register(dst), Register(src)) } -inst_ktestq_k_k :: #force_inline proc "contextless" (dst: KREG, src: KREG) -> Instruction { return inst_r_r(.KTESTQ, Register(dst), Register(src)) } -emit_ktestq_k_k :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: KREG) { emit_rr(instructions, .KTESTQ, Register(dst), Register(src)) } -inst_ktestd_k_k :: #force_inline proc "contextless" (dst: KREG, src: KREG) -> Instruction { return inst_r_r(.KTESTD, Register(dst), Register(src)) } -emit_ktestd_k_k :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: KREG) { emit_rr(instructions, .KTESTD, Register(dst), Register(src)) } -inst_kunpckbw_k_k_k :: #force_inline proc "contextless" (dst: KREG, src: KREG, src2: KREG) -> Instruction { return inst_r_r_r(.KUNPCKBW, Register(dst), Register(src), Register(src2)) } -emit_kunpckbw_k_k_k :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: KREG, src2: KREG) { emit_rrr(instructions, .KUNPCKBW, Register(dst), Register(src), Register(src2)) } -inst_kunpckwd_k_k_k :: #force_inline proc "contextless" (dst: KREG, src: KREG, src2: KREG) -> Instruction { return inst_r_r_r(.KUNPCKWD, Register(dst), Register(src), Register(src2)) } -emit_kunpckwd_k_k_k :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: KREG, src2: KREG) { emit_rrr(instructions, .KUNPCKWD, Register(dst), Register(src), Register(src2)) } -inst_kunpckdq_k_k_k :: #force_inline proc "contextless" (dst: KREG, src: KREG, src2: KREG) -> Instruction { return inst_r_r_r(.KUNPCKDQ, Register(dst), Register(src), Register(src2)) } -emit_kunpckdq_k_k_k :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: KREG, src2: KREG) { emit_rrr(instructions, .KUNPCKDQ, Register(dst), Register(src), Register(src2)) } -inst_kxnorw_k_k_k :: #force_inline proc "contextless" (dst: KREG, src: KREG, src2: KREG) -> Instruction { return inst_r_r_r(.KXNORW, Register(dst), Register(src), Register(src2)) } -emit_kxnorw_k_k_k :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: KREG, src2: KREG) { emit_rrr(instructions, .KXNORW, Register(dst), Register(src), Register(src2)) } -inst_kxnorb_k_k_k :: #force_inline proc "contextless" (dst: KREG, src: KREG, src2: KREG) -> Instruction { return inst_r_r_r(.KXNORB, Register(dst), Register(src), Register(src2)) } -emit_kxnorb_k_k_k :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: KREG, src2: KREG) { emit_rrr(instructions, .KXNORB, Register(dst), Register(src), Register(src2)) } -inst_kxnorq_k_k_k :: #force_inline proc "contextless" (dst: KREG, src: KREG, src2: KREG) -> Instruction { return inst_r_r_r(.KXNORQ, Register(dst), Register(src), Register(src2)) } -emit_kxnorq_k_k_k :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: KREG, src2: KREG) { emit_rrr(instructions, .KXNORQ, Register(dst), Register(src), Register(src2)) } -inst_kxnord_k_k_k :: #force_inline proc "contextless" (dst: KREG, src: KREG, src2: KREG) -> Instruction { return inst_r_r_r(.KXNORD, Register(dst), Register(src), Register(src2)) } -emit_kxnord_k_k_k :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: KREG, src2: KREG) { emit_rrr(instructions, .KXNORD, Register(dst), Register(src), Register(src2)) } -inst_kxorw_k_k_k :: #force_inline proc "contextless" (dst: KREG, src: KREG, src2: KREG) -> Instruction { return inst_r_r_r(.KXORW, Register(dst), Register(src), Register(src2)) } -emit_kxorw_k_k_k :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: KREG, src2: KREG) { emit_rrr(instructions, .KXORW, Register(dst), Register(src), Register(src2)) } -inst_kxorb_k_k_k :: #force_inline proc "contextless" (dst: KREG, src: KREG, src2: KREG) -> Instruction { return inst_r_r_r(.KXORB, Register(dst), Register(src), Register(src2)) } -emit_kxorb_k_k_k :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: KREG, src2: KREG) { emit_rrr(instructions, .KXORB, Register(dst), Register(src), Register(src2)) } -inst_kxorq_k_k_k :: #force_inline proc "contextless" (dst: KREG, src: KREG, src2: KREG) -> Instruction { return inst_r_r_r(.KXORQ, Register(dst), Register(src), Register(src2)) } -emit_kxorq_k_k_k :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: KREG, src2: KREG) { emit_rrr(instructions, .KXORQ, Register(dst), Register(src), Register(src2)) } -inst_kxord_k_k_k :: #force_inline proc "contextless" (dst: KREG, src: KREG, src2: KREG) -> Instruction { return inst_r_r_r(.KXORD, Register(dst), Register(src), Register(src2)) } -emit_kxord_k_k_k :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: KREG, src2: KREG) { emit_rrr(instructions, .KXORD, Register(dst), Register(src), Register(src2)) } -inst_fadd_m32 :: #force_inline proc "contextless" (dst: Mem32) -> Instruction { return inst_m(.FADD, dst.mem, 4) } -inst_fadd_m64 :: #force_inline proc "contextless" (dst: Mem64) -> Instruction { return inst_m(.FADD, dst.mem, 8) } -inst_fadd_st :: #force_inline proc "contextless" (dst: ST) -> Instruction { return inst_r(.FADD, Register(dst)) } -emit_fadd_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32) { emit_m(instructions, .FADD, dst.mem, 4) } -emit_fadd_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64) { emit_m(instructions, .FADD, dst.mem, 8) } -emit_fadd_st :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ST) { emit_r(instructions, .FADD, Register(dst)) } -inst_faddp_st :: #force_inline proc "contextless" (dst: ST) -> Instruction { return inst_r(.FADDP, Register(dst)) } -inst_faddp_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.FADDP) } -emit_faddp_st :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ST) { emit_r(instructions, .FADDP, Register(dst)) } -emit_faddp_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .FADDP) } -inst_fiadd_m16 :: #force_inline proc "contextless" (dst: Mem16) -> Instruction { return inst_m(.FIADD, dst.mem, 2) } -inst_fiadd_m32 :: #force_inline proc "contextless" (dst: Mem32) -> Instruction { return inst_m(.FIADD, dst.mem, 4) } -emit_fiadd_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16) { emit_m(instructions, .FIADD, dst.mem, 2) } -emit_fiadd_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32) { emit_m(instructions, .FIADD, dst.mem, 4) } -inst_fsub_m32 :: #force_inline proc "contextless" (dst: Mem32) -> Instruction { return inst_m(.FSUB, dst.mem, 4) } -inst_fsub_m64 :: #force_inline proc "contextless" (dst: Mem64) -> Instruction { return inst_m(.FSUB, dst.mem, 8) } -inst_fsub_st :: #force_inline proc "contextless" (dst: ST) -> Instruction { return inst_r(.FSUB, Register(dst)) } -emit_fsub_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32) { emit_m(instructions, .FSUB, dst.mem, 4) } -emit_fsub_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64) { emit_m(instructions, .FSUB, dst.mem, 8) } -emit_fsub_st :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ST) { emit_r(instructions, .FSUB, Register(dst)) } -inst_fsubp_st :: #force_inline proc "contextless" (dst: ST) -> Instruction { return inst_r(.FSUBP, Register(dst)) } -inst_fsubp_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.FSUBP) } -emit_fsubp_st :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ST) { emit_r(instructions, .FSUBP, Register(dst)) } -emit_fsubp_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .FSUBP) } -inst_fisub_m16 :: #force_inline proc "contextless" (dst: Mem16) -> Instruction { return inst_m(.FISUB, dst.mem, 2) } -inst_fisub_m32 :: #force_inline proc "contextless" (dst: Mem32) -> Instruction { return inst_m(.FISUB, dst.mem, 4) } -emit_fisub_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16) { emit_m(instructions, .FISUB, dst.mem, 2) } -emit_fisub_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32) { emit_m(instructions, .FISUB, dst.mem, 4) } -inst_fsubr_m32 :: #force_inline proc "contextless" (dst: Mem32) -> Instruction { return inst_m(.FSUBR, dst.mem, 4) } -inst_fsubr_m64 :: #force_inline proc "contextless" (dst: Mem64) -> Instruction { return inst_m(.FSUBR, dst.mem, 8) } -inst_fsubr_st :: #force_inline proc "contextless" (dst: ST) -> Instruction { return inst_r(.FSUBR, Register(dst)) } -emit_fsubr_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32) { emit_m(instructions, .FSUBR, dst.mem, 4) } -emit_fsubr_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64) { emit_m(instructions, .FSUBR, dst.mem, 8) } -emit_fsubr_st :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ST) { emit_r(instructions, .FSUBR, Register(dst)) } -inst_fsubrp_st :: #force_inline proc "contextless" (dst: ST) -> Instruction { return inst_r(.FSUBRP, Register(dst)) } -inst_fsubrp_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.FSUBRP) } -emit_fsubrp_st :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ST) { emit_r(instructions, .FSUBRP, Register(dst)) } -emit_fsubrp_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .FSUBRP) } -inst_fisubr_m16 :: #force_inline proc "contextless" (dst: Mem16) -> Instruction { return inst_m(.FISUBR, dst.mem, 2) } -inst_fisubr_m32 :: #force_inline proc "contextless" (dst: Mem32) -> Instruction { return inst_m(.FISUBR, dst.mem, 4) } -emit_fisubr_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16) { emit_m(instructions, .FISUBR, dst.mem, 2) } -emit_fisubr_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32) { emit_m(instructions, .FISUBR, dst.mem, 4) } -inst_fmul_m32 :: #force_inline proc "contextless" (dst: Mem32) -> Instruction { return inst_m(.FMUL, dst.mem, 4) } -inst_fmul_m64 :: #force_inline proc "contextless" (dst: Mem64) -> Instruction { return inst_m(.FMUL, dst.mem, 8) } -inst_fmul_st :: #force_inline proc "contextless" (dst: ST) -> Instruction { return inst_r(.FMUL, Register(dst)) } -emit_fmul_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32) { emit_m(instructions, .FMUL, dst.mem, 4) } -emit_fmul_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64) { emit_m(instructions, .FMUL, dst.mem, 8) } -emit_fmul_st :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ST) { emit_r(instructions, .FMUL, Register(dst)) } -inst_fmulp_st :: #force_inline proc "contextless" (dst: ST) -> Instruction { return inst_r(.FMULP, Register(dst)) } -inst_fmulp_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.FMULP) } -emit_fmulp_st :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ST) { emit_r(instructions, .FMULP, Register(dst)) } -emit_fmulp_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .FMULP) } -inst_fimul_m16 :: #force_inline proc "contextless" (dst: Mem16) -> Instruction { return inst_m(.FIMUL, dst.mem, 2) } -inst_fimul_m32 :: #force_inline proc "contextless" (dst: Mem32) -> Instruction { return inst_m(.FIMUL, dst.mem, 4) } -emit_fimul_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16) { emit_m(instructions, .FIMUL, dst.mem, 2) } -emit_fimul_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32) { emit_m(instructions, .FIMUL, dst.mem, 4) } -inst_fdiv_m32 :: #force_inline proc "contextless" (dst: Mem32) -> Instruction { return inst_m(.FDIV, dst.mem, 4) } -inst_fdiv_m64 :: #force_inline proc "contextless" (dst: Mem64) -> Instruction { return inst_m(.FDIV, dst.mem, 8) } -inst_fdiv_st :: #force_inline proc "contextless" (dst: ST) -> Instruction { return inst_r(.FDIV, Register(dst)) } -emit_fdiv_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32) { emit_m(instructions, .FDIV, dst.mem, 4) } -emit_fdiv_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64) { emit_m(instructions, .FDIV, dst.mem, 8) } -emit_fdiv_st :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ST) { emit_r(instructions, .FDIV, Register(dst)) } -inst_fdivp_st :: #force_inline proc "contextless" (dst: ST) -> Instruction { return inst_r(.FDIVP, Register(dst)) } -inst_fdivp_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.FDIVP) } -emit_fdivp_st :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ST) { emit_r(instructions, .FDIVP, Register(dst)) } -emit_fdivp_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .FDIVP) } -inst_fidiv_m16 :: #force_inline proc "contextless" (dst: Mem16) -> Instruction { return inst_m(.FIDIV, dst.mem, 2) } -inst_fidiv_m32 :: #force_inline proc "contextless" (dst: Mem32) -> Instruction { return inst_m(.FIDIV, dst.mem, 4) } -emit_fidiv_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16) { emit_m(instructions, .FIDIV, dst.mem, 2) } -emit_fidiv_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32) { emit_m(instructions, .FIDIV, dst.mem, 4) } -inst_fdivr_m32 :: #force_inline proc "contextless" (dst: Mem32) -> Instruction { return inst_m(.FDIVR, dst.mem, 4) } -inst_fdivr_m64 :: #force_inline proc "contextless" (dst: Mem64) -> Instruction { return inst_m(.FDIVR, dst.mem, 8) } -inst_fdivr_st :: #force_inline proc "contextless" (dst: ST) -> Instruction { return inst_r(.FDIVR, Register(dst)) } -emit_fdivr_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32) { emit_m(instructions, .FDIVR, dst.mem, 4) } -emit_fdivr_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64) { emit_m(instructions, .FDIVR, dst.mem, 8) } -emit_fdivr_st :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ST) { emit_r(instructions, .FDIVR, Register(dst)) } -inst_fdivrp_st :: #force_inline proc "contextless" (dst: ST) -> Instruction { return inst_r(.FDIVRP, Register(dst)) } -inst_fdivrp_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.FDIVRP) } -emit_fdivrp_st :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ST) { emit_r(instructions, .FDIVRP, Register(dst)) } -emit_fdivrp_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .FDIVRP) } -inst_fidivr_m16 :: #force_inline proc "contextless" (dst: Mem16) -> Instruction { return inst_m(.FIDIVR, dst.mem, 2) } -inst_fidivr_m32 :: #force_inline proc "contextless" (dst: Mem32) -> Instruction { return inst_m(.FIDIVR, dst.mem, 4) } -emit_fidivr_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16) { emit_m(instructions, .FIDIVR, dst.mem, 2) } -emit_fidivr_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32) { emit_m(instructions, .FIDIVR, dst.mem, 4) } -inst_fsqrt_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.FSQRT) } -emit_fsqrt_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .FSQRT) } -inst_fabs_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.FABS) } -emit_fabs_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .FABS) } -inst_fchs_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.FCHS) } -emit_fchs_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .FCHS) } -inst_fprem_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.FPREM) } -emit_fprem_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .FPREM) } -inst_fprem1_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.FPREM1) } -emit_fprem1_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .FPREM1) } -inst_frndint_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.FRNDINT) } -emit_frndint_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .FRNDINT) } -inst_fscale_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.FSCALE) } -emit_fscale_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .FSCALE) } -inst_fxtract_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.FXTRACT) } -emit_fxtract_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .FXTRACT) } -inst_fxam_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.FXAM) } -emit_fxam_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .FXAM) } -inst_fld_m32 :: #force_inline proc "contextless" (dst: Mem32) -> Instruction { return inst_m(.FLD, dst.mem, 4) } -inst_fld_m64 :: #force_inline proc "contextless" (dst: Mem64) -> Instruction { return inst_m(.FLD, dst.mem, 8) } -inst_fld_m80 :: #force_inline proc "contextless" (dst: Mem80) -> Instruction { return inst_m(.FLD, dst.mem, 10) } -inst_fld_st :: #force_inline proc "contextless" (dst: ST) -> Instruction { return inst_r(.FLD, Register(dst)) } -emit_fld_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32) { emit_m(instructions, .FLD, dst.mem, 4) } -emit_fld_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64) { emit_m(instructions, .FLD, dst.mem, 8) } -emit_fld_m80 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem80) { emit_m(instructions, .FLD, dst.mem, 10) } -emit_fld_st :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ST) { emit_r(instructions, .FLD, Register(dst)) } -inst_fild_m16 :: #force_inline proc "contextless" (dst: Mem16) -> Instruction { return inst_m(.FILD, dst.mem, 2) } -inst_fild_m32 :: #force_inline proc "contextless" (dst: Mem32) -> Instruction { return inst_m(.FILD, dst.mem, 4) } -inst_fild_m64 :: #force_inline proc "contextless" (dst: Mem64) -> Instruction { return inst_m(.FILD, dst.mem, 8) } -emit_fild_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16) { emit_m(instructions, .FILD, dst.mem, 2) } -emit_fild_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32) { emit_m(instructions, .FILD, dst.mem, 4) } -emit_fild_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64) { emit_m(instructions, .FILD, dst.mem, 8) } -inst_fbld_m80 :: #force_inline proc "contextless" (dst: Mem80) -> Instruction { return inst_m(.FBLD, dst.mem, 10) } -emit_fbld_m80 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem80) { emit_m(instructions, .FBLD, dst.mem, 10) } -inst_fst_m32 :: #force_inline proc "contextless" (dst: Mem32) -> Instruction { return inst_m(.FST, dst.mem, 4) } -inst_fst_m64 :: #force_inline proc "contextless" (dst: Mem64) -> Instruction { return inst_m(.FST, dst.mem, 8) } -inst_fst_st :: #force_inline proc "contextless" (dst: ST) -> Instruction { return inst_r(.FST, Register(dst)) } -emit_fst_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32) { emit_m(instructions, .FST, dst.mem, 4) } -emit_fst_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64) { emit_m(instructions, .FST, dst.mem, 8) } -emit_fst_st :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ST) { emit_r(instructions, .FST, Register(dst)) } -inst_fstp_m32 :: #force_inline proc "contextless" (dst: Mem32) -> Instruction { return inst_m(.FSTP, dst.mem, 4) } -inst_fstp_m64 :: #force_inline proc "contextless" (dst: Mem64) -> Instruction { return inst_m(.FSTP, dst.mem, 8) } -inst_fstp_m80 :: #force_inline proc "contextless" (dst: Mem80) -> Instruction { return inst_m(.FSTP, dst.mem, 10) } -inst_fstp_st :: #force_inline proc "contextless" (dst: ST) -> Instruction { return inst_r(.FSTP, Register(dst)) } -emit_fstp_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32) { emit_m(instructions, .FSTP, dst.mem, 4) } -emit_fstp_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64) { emit_m(instructions, .FSTP, dst.mem, 8) } -emit_fstp_m80 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem80) { emit_m(instructions, .FSTP, dst.mem, 10) } -emit_fstp_st :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ST) { emit_r(instructions, .FSTP, Register(dst)) } -inst_fist_m16 :: #force_inline proc "contextless" (dst: Mem16) -> Instruction { return inst_m(.FIST, dst.mem, 2) } -inst_fist_m32 :: #force_inline proc "contextless" (dst: Mem32) -> Instruction { return inst_m(.FIST, dst.mem, 4) } -emit_fist_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16) { emit_m(instructions, .FIST, dst.mem, 2) } -emit_fist_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32) { emit_m(instructions, .FIST, dst.mem, 4) } -inst_fistp_m16 :: #force_inline proc "contextless" (dst: Mem16) -> Instruction { return inst_m(.FISTP, dst.mem, 2) } -inst_fistp_m32 :: #force_inline proc "contextless" (dst: Mem32) -> Instruction { return inst_m(.FISTP, dst.mem, 4) } -inst_fistp_m64 :: #force_inline proc "contextless" (dst: Mem64) -> Instruction { return inst_m(.FISTP, dst.mem, 8) } -emit_fistp_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16) { emit_m(instructions, .FISTP, dst.mem, 2) } -emit_fistp_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32) { emit_m(instructions, .FISTP, dst.mem, 4) } -emit_fistp_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64) { emit_m(instructions, .FISTP, dst.mem, 8) } -inst_fisttp_m16 :: #force_inline proc "contextless" (dst: Mem16) -> Instruction { return inst_m(.FISTTP, dst.mem, 2) } -inst_fisttp_m32 :: #force_inline proc "contextless" (dst: Mem32) -> Instruction { return inst_m(.FISTTP, dst.mem, 4) } -inst_fisttp_m64 :: #force_inline proc "contextless" (dst: Mem64) -> Instruction { return inst_m(.FISTTP, dst.mem, 8) } -emit_fisttp_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16) { emit_m(instructions, .FISTTP, dst.mem, 2) } -emit_fisttp_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32) { emit_m(instructions, .FISTTP, dst.mem, 4) } -emit_fisttp_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64) { emit_m(instructions, .FISTTP, dst.mem, 8) } -inst_fbstp_m80 :: #force_inline proc "contextless" (dst: Mem80) -> Instruction { return inst_m(.FBSTP, dst.mem, 10) } -emit_fbstp_m80 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem80) { emit_m(instructions, .FBSTP, dst.mem, 10) } -inst_fxch_st :: #force_inline proc "contextless" (dst: ST) -> Instruction { return inst_r(.FXCH, Register(dst)) } -inst_fxch_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.FXCH) } -emit_fxch_st :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ST) { emit_r(instructions, .FXCH, Register(dst)) } -emit_fxch_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .FXCH) } -inst_fcmovb_st :: #force_inline proc "contextless" (dst: ST) -> Instruction { return inst_r(.FCMOVB, Register(dst)) } -emit_fcmovb_st :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ST) { emit_r(instructions, .FCMOVB, Register(dst)) } -inst_fcmove_st :: #force_inline proc "contextless" (dst: ST) -> Instruction { return inst_r(.FCMOVE, Register(dst)) } -emit_fcmove_st :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ST) { emit_r(instructions, .FCMOVE, Register(dst)) } -inst_fcmovbe_st :: #force_inline proc "contextless" (dst: ST) -> Instruction { return inst_r(.FCMOVBE, Register(dst)) } -emit_fcmovbe_st :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ST) { emit_r(instructions, .FCMOVBE, Register(dst)) } -inst_fcmovu_st :: #force_inline proc "contextless" (dst: ST) -> Instruction { return inst_r(.FCMOVU, Register(dst)) } -emit_fcmovu_st :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ST) { emit_r(instructions, .FCMOVU, Register(dst)) } -inst_fcmovnb_st :: #force_inline proc "contextless" (dst: ST) -> Instruction { return inst_r(.FCMOVNB, Register(dst)) } -emit_fcmovnb_st :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ST) { emit_r(instructions, .FCMOVNB, Register(dst)) } -inst_fcmovne_st :: #force_inline proc "contextless" (dst: ST) -> Instruction { return inst_r(.FCMOVNE, Register(dst)) } -emit_fcmovne_st :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ST) { emit_r(instructions, .FCMOVNE, Register(dst)) } -inst_fcmovnbe_st :: #force_inline proc "contextless" (dst: ST) -> Instruction { return inst_r(.FCMOVNBE, Register(dst)) } -emit_fcmovnbe_st :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ST) { emit_r(instructions, .FCMOVNBE, Register(dst)) } -inst_fcmovnu_st :: #force_inline proc "contextless" (dst: ST) -> Instruction { return inst_r(.FCMOVNU, Register(dst)) } -emit_fcmovnu_st :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ST) { emit_r(instructions, .FCMOVNU, Register(dst)) } -inst_fcom_m32 :: #force_inline proc "contextless" (dst: Mem32) -> Instruction { return inst_m(.FCOM, dst.mem, 4) } -inst_fcom_m64 :: #force_inline proc "contextless" (dst: Mem64) -> Instruction { return inst_m(.FCOM, dst.mem, 8) } -inst_fcom_st :: #force_inline proc "contextless" (dst: ST) -> Instruction { return inst_r(.FCOM, Register(dst)) } -inst_fcom_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.FCOM) } -emit_fcom_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32) { emit_m(instructions, .FCOM, dst.mem, 4) } -emit_fcom_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64) { emit_m(instructions, .FCOM, dst.mem, 8) } -emit_fcom_st :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ST) { emit_r(instructions, .FCOM, Register(dst)) } -emit_fcom_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .FCOM) } -inst_fcomp_m32 :: #force_inline proc "contextless" (dst: Mem32) -> Instruction { return inst_m(.FCOMP, dst.mem, 4) } -inst_fcomp_m64 :: #force_inline proc "contextless" (dst: Mem64) -> Instruction { return inst_m(.FCOMP, dst.mem, 8) } -inst_fcomp_st :: #force_inline proc "contextless" (dst: ST) -> Instruction { return inst_r(.FCOMP, Register(dst)) } -inst_fcomp_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.FCOMP) } -emit_fcomp_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32) { emit_m(instructions, .FCOMP, dst.mem, 4) } -emit_fcomp_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64) { emit_m(instructions, .FCOMP, dst.mem, 8) } -emit_fcomp_st :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ST) { emit_r(instructions, .FCOMP, Register(dst)) } -emit_fcomp_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .FCOMP) } -inst_fcompp_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.FCOMPP) } -emit_fcompp_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .FCOMPP) } -inst_ficom_m16 :: #force_inline proc "contextless" (dst: Mem16) -> Instruction { return inst_m(.FICOM, dst.mem, 2) } -inst_ficom_m32 :: #force_inline proc "contextless" (dst: Mem32) -> Instruction { return inst_m(.FICOM, dst.mem, 4) } -emit_ficom_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16) { emit_m(instructions, .FICOM, dst.mem, 2) } -emit_ficom_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32) { emit_m(instructions, .FICOM, dst.mem, 4) } -inst_ficomp_m16 :: #force_inline proc "contextless" (dst: Mem16) -> Instruction { return inst_m(.FICOMP, dst.mem, 2) } -inst_ficomp_m32 :: #force_inline proc "contextless" (dst: Mem32) -> Instruction { return inst_m(.FICOMP, dst.mem, 4) } -emit_ficomp_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16) { emit_m(instructions, .FICOMP, dst.mem, 2) } -emit_ficomp_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32) { emit_m(instructions, .FICOMP, dst.mem, 4) } -inst_fcomi_st :: #force_inline proc "contextless" (dst: ST) -> Instruction { return inst_r(.FCOMI, Register(dst)) } -emit_fcomi_st :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ST) { emit_r(instructions, .FCOMI, Register(dst)) } -inst_fcomip_st :: #force_inline proc "contextless" (dst: ST) -> Instruction { return inst_r(.FCOMIP, Register(dst)) } -emit_fcomip_st :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ST) { emit_r(instructions, .FCOMIP, Register(dst)) } -inst_fucomi_st :: #force_inline proc "contextless" (dst: ST) -> Instruction { return inst_r(.FUCOMI, Register(dst)) } -emit_fucomi_st :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ST) { emit_r(instructions, .FUCOMI, Register(dst)) } -inst_fucomip_st :: #force_inline proc "contextless" (dst: ST) -> Instruction { return inst_r(.FUCOMIP, Register(dst)) } -emit_fucomip_st :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ST) { emit_r(instructions, .FUCOMIP, Register(dst)) } -inst_fucom_st :: #force_inline proc "contextless" (dst: ST) -> Instruction { return inst_r(.FUCOM, Register(dst)) } -inst_fucom_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.FUCOM) } -emit_fucom_st :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ST) { emit_r(instructions, .FUCOM, Register(dst)) } -emit_fucom_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .FUCOM) } -inst_fucomp_st :: #force_inline proc "contextless" (dst: ST) -> Instruction { return inst_r(.FUCOMP, Register(dst)) } -inst_fucomp_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.FUCOMP) } -emit_fucomp_st :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ST) { emit_r(instructions, .FUCOMP, Register(dst)) } -emit_fucomp_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .FUCOMP) } -inst_fucompp_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.FUCOMPP) } -emit_fucompp_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .FUCOMPP) } -inst_ftst_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.FTST) } -emit_ftst_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .FTST) } -inst_fldz_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.FLDZ) } -emit_fldz_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .FLDZ) } -inst_fld1_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.FLD1) } -emit_fld1_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .FLD1) } -inst_fldpi_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.FLDPI) } -emit_fldpi_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .FLDPI) } -inst_fldl2t_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.FLDL2T) } -emit_fldl2t_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .FLDL2T) } -inst_fldl2e_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.FLDL2E) } -emit_fldl2e_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .FLDL2E) } -inst_fldlg2_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.FLDLG2) } -emit_fldlg2_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .FLDLG2) } -inst_fldln2_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.FLDLN2) } -emit_fldln2_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .FLDLN2) } -inst_fsin_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.FSIN) } -emit_fsin_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .FSIN) } -inst_fcos_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.FCOS) } -emit_fcos_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .FCOS) } -inst_fsincos_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.FSINCOS) } -emit_fsincos_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .FSINCOS) } -inst_fptan_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.FPTAN) } -emit_fptan_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .FPTAN) } -inst_fpatan_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.FPATAN) } -emit_fpatan_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .FPATAN) } -inst_f2xm1_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.F2XM1) } -emit_f2xm1_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .F2XM1) } -inst_fyl2x_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.FYL2X) } -emit_fyl2x_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .FYL2X) } -inst_fyl2xp1_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.FYL2XP1) } -emit_fyl2xp1_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .FYL2XP1) } -inst_finit_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.FINIT) } -emit_finit_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .FINIT) } -inst_fninit_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.FNINIT) } -emit_fninit_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .FNINIT) } -inst_fincstp_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.FINCSTP) } -emit_fincstp_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .FINCSTP) } -inst_fdecstp_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.FDECSTP) } -emit_fdecstp_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .FDECSTP) } -inst_ffree_st :: #force_inline proc "contextless" (dst: ST) -> Instruction { return inst_r(.FFREE, Register(dst)) } -emit_ffree_st :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ST) { emit_r(instructions, .FFREE, Register(dst)) } -inst_ffreep_st :: #force_inline proc "contextless" (dst: ST) -> Instruction { return inst_r(.FFREEP, Register(dst)) } -emit_ffreep_st :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ST) { emit_r(instructions, .FFREEP, Register(dst)) } -inst_fnop_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.FNOP) } -emit_fnop_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .FNOP) } -inst_fwait_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.FWAIT) } -emit_fwait_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .FWAIT) } -inst_fclex_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.FCLEX) } -emit_fclex_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .FCLEX) } -inst_fnclex_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.FNCLEX) } -emit_fnclex_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .FNCLEX) } -inst_fstcw_m16 :: #force_inline proc "contextless" (dst: Mem16) -> Instruction { return inst_m(.FSTCW, dst.mem, 2) } -emit_fstcw_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16) { emit_m(instructions, .FSTCW, dst.mem, 2) } -inst_fnstcw_m16 :: #force_inline proc "contextless" (dst: Mem16) -> Instruction { return inst_m(.FNSTCW, dst.mem, 2) } -emit_fnstcw_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16) { emit_m(instructions, .FNSTCW, dst.mem, 2) } -inst_fldcw_m16 :: #force_inline proc "contextless" (dst: Mem16) -> Instruction { return inst_m(.FLDCW, dst.mem, 2) } -emit_fldcw_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16) { emit_m(instructions, .FLDCW, dst.mem, 2) } -inst_fstenv_m :: #force_inline proc "contextless" (dst: Memory) -> Instruction { return inst_m(.FSTENV, dst, 0) } -emit_fstenv_m :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Memory) { emit_m(instructions, .FSTENV, dst, 0) } -inst_fnstenv_m :: #force_inline proc "contextless" (dst: Memory) -> Instruction { return inst_m(.FNSTENV, dst, 0) } -emit_fnstenv_m :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Memory) { emit_m(instructions, .FNSTENV, dst, 0) } -inst_fldenv_m :: #force_inline proc "contextless" (dst: Memory) -> Instruction { return inst_m(.FLDENV, dst, 0) } -emit_fldenv_m :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Memory) { emit_m(instructions, .FLDENV, dst, 0) } -inst_fsave_m :: #force_inline proc "contextless" (dst: Memory) -> Instruction { return inst_m(.FSAVE, dst, 0) } -emit_fsave_m :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Memory) { emit_m(instructions, .FSAVE, dst, 0) } -inst_fnsave_m :: #force_inline proc "contextless" (dst: Memory) -> Instruction { return inst_m(.FNSAVE, dst, 0) } -emit_fnsave_m :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Memory) { emit_m(instructions, .FNSAVE, dst, 0) } -inst_frstor_m :: #force_inline proc "contextless" (dst: Memory) -> Instruction { return inst_m(.FRSTOR, dst, 0) } -emit_frstor_m :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Memory) { emit_m(instructions, .FRSTOR, dst, 0) } -inst_fstsw_m16 :: #force_inline proc "contextless" (dst: Mem16) -> Instruction { return inst_m(.FSTSW, dst.mem, 2) } -emit_fstsw_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16) { emit_m(instructions, .FSTSW, dst.mem, 2) } -inst_fnstsw_m16 :: #force_inline proc "contextless" (dst: Mem16) -> Instruction { return inst_m(.FNSTSW, dst.mem, 2) } -emit_fnstsw_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16) { emit_m(instructions, .FNSTSW, dst.mem, 2) } -inst_fxsave_m512 :: #force_inline proc "contextless" (dst: Mem512) -> Instruction { return inst_m(.FXSAVE, dst.mem, 64) } -emit_fxsave_m512 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem512) { emit_m(instructions, .FXSAVE, dst.mem, 64) } -inst_fxsave64_m512 :: #force_inline proc "contextless" (dst: Mem512) -> Instruction { return inst_m(.FXSAVE64, dst.mem, 64) } -emit_fxsave64_m512 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem512) { emit_m(instructions, .FXSAVE64, dst.mem, 64) } -inst_fxrstor_m512 :: #force_inline proc "contextless" (dst: Mem512) -> Instruction { return inst_m(.FXRSTOR, dst.mem, 64) } -emit_fxrstor_m512 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem512) { emit_m(instructions, .FXRSTOR, dst.mem, 64) } -inst_fxrstor64_m512 :: #force_inline proc "contextless" (dst: Mem512) -> Instruction { return inst_m(.FXRSTOR64, dst.mem, 64) } -emit_fxrstor64_m512 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem512) { emit_m(instructions, .FXRSTOR64, dst.mem, 64) } -inst_lgdt_m :: #force_inline proc "contextless" (dst: Memory) -> Instruction { return inst_m(.LGDT, dst, 0) } -emit_lgdt_m :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Memory) { emit_m(instructions, .LGDT, dst, 0) } -inst_sgdt_m :: #force_inline proc "contextless" (dst: Memory) -> Instruction { return inst_m(.SGDT, dst, 0) } -emit_sgdt_m :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Memory) { emit_m(instructions, .SGDT, dst, 0) } -inst_lidt_m :: #force_inline proc "contextless" (dst: Memory) -> Instruction { return inst_m(.LIDT, dst, 0) } -emit_lidt_m :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Memory) { emit_m(instructions, .LIDT, dst, 0) } -inst_sidt_m :: #force_inline proc "contextless" (dst: Memory) -> Instruction { return inst_m(.SIDT, dst, 0) } -emit_sidt_m :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Memory) { emit_m(instructions, .SIDT, dst, 0) } -inst_lldt_r16 :: #force_inline proc "contextless" (dst: GPR16) -> Instruction { return inst_r(.LLDT, Register(dst)) } -inst_lldt_m16 :: #force_inline proc "contextless" (dst: Mem16) -> Instruction { return inst_m(.LLDT, dst.mem, 2) } -emit_lldt_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16) { emit_r(instructions, .LLDT, Register(dst)) } -emit_lldt_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16) { emit_m(instructions, .LLDT, dst.mem, 2) } -inst_sldt_r16 :: #force_inline proc "contextless" (dst: GPR16) -> Instruction { return inst_r(.SLDT, Register(dst)) } -inst_sldt_m16 :: #force_inline proc "contextless" (dst: Mem16) -> Instruction { return inst_m(.SLDT, dst.mem, 2) } -inst_sldt_r32 :: #force_inline proc "contextless" (dst: GPR32) -> Instruction { return inst_r(.SLDT, Register(dst)) } -inst_sldt_r64 :: #force_inline proc "contextless" (dst: GPR64) -> Instruction { return inst_r(.SLDT, Register(dst)) } -emit_sldt_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16) { emit_r(instructions, .SLDT, Register(dst)) } -emit_sldt_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16) { emit_m(instructions, .SLDT, dst.mem, 2) } -emit_sldt_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32) { emit_r(instructions, .SLDT, Register(dst)) } -emit_sldt_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64) { emit_r(instructions, .SLDT, Register(dst)) } -inst_ltr_r16 :: #force_inline proc "contextless" (dst: GPR16) -> Instruction { return inst_r(.LTR, Register(dst)) } -inst_ltr_m16 :: #force_inline proc "contextless" (dst: Mem16) -> Instruction { return inst_m(.LTR, dst.mem, 2) } -emit_ltr_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16) { emit_r(instructions, .LTR, Register(dst)) } -emit_ltr_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16) { emit_m(instructions, .LTR, dst.mem, 2) } -inst_str_r16 :: #force_inline proc "contextless" (dst: GPR16) -> Instruction { return inst_r(.STR, Register(dst)) } -inst_str_m16 :: #force_inline proc "contextless" (dst: Mem16) -> Instruction { return inst_m(.STR, dst.mem, 2) } -inst_str_r32 :: #force_inline proc "contextless" (dst: GPR32) -> Instruction { return inst_r(.STR, Register(dst)) } -inst_str_r64 :: #force_inline proc "contextless" (dst: GPR64) -> Instruction { return inst_r(.STR, Register(dst)) } -emit_str_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16) { emit_r(instructions, .STR, Register(dst)) } -emit_str_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16) { emit_m(instructions, .STR, dst.mem, 2) } -emit_str_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32) { emit_r(instructions, .STR, Register(dst)) } -emit_str_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64) { emit_r(instructions, .STR, Register(dst)) } -inst_lmsw_r16 :: #force_inline proc "contextless" (dst: GPR16) -> Instruction { return inst_r(.LMSW, Register(dst)) } -inst_lmsw_m16 :: #force_inline proc "contextless" (dst: Mem16) -> Instruction { return inst_m(.LMSW, dst.mem, 2) } -emit_lmsw_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16) { emit_r(instructions, .LMSW, Register(dst)) } -emit_lmsw_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16) { emit_m(instructions, .LMSW, dst.mem, 2) } -inst_smsw_r16 :: #force_inline proc "contextless" (dst: GPR16) -> Instruction { return inst_r(.SMSW, Register(dst)) } -inst_smsw_m16 :: #force_inline proc "contextless" (dst: Mem16) -> Instruction { return inst_m(.SMSW, dst.mem, 2) } -inst_smsw_r32 :: #force_inline proc "contextless" (dst: GPR32) -> Instruction { return inst_r(.SMSW, Register(dst)) } -inst_smsw_r64 :: #force_inline proc "contextless" (dst: GPR64) -> Instruction { return inst_r(.SMSW, Register(dst)) } -emit_smsw_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16) { emit_r(instructions, .SMSW, Register(dst)) } -emit_smsw_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16) { emit_m(instructions, .SMSW, dst.mem, 2) } -emit_smsw_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32) { emit_r(instructions, .SMSW, Register(dst)) } -emit_smsw_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64) { emit_r(instructions, .SMSW, Register(dst)) } -inst_clts_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.CLTS) } -emit_clts_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .CLTS) } -inst_arpl_r16_r16 :: #force_inline proc "contextless" (dst: GPR16, src: GPR16) -> Instruction { return inst_r_r(.ARPL, Register(dst), Register(src)) } -inst_arpl_m16_r16 :: #force_inline proc "contextless" (dst: Mem16, src: GPR16) -> Instruction { return inst_m_r(.ARPL, dst.mem, 2, Register(src)) } -emit_arpl_r16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: GPR16) { emit_rr(instructions, .ARPL, Register(dst), Register(src)) } -emit_arpl_m16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16, src: GPR16) { emit_mr(instructions, .ARPL, dst.mem, 2, Register(src)) } -inst_lar_r16_r16 :: #force_inline proc "contextless" (dst: GPR16, src: GPR16) -> Instruction { return inst_r_r(.LAR, Register(dst), Register(src)) } -inst_lar_r16_m16 :: #force_inline proc "contextless" (dst: GPR16, src: Mem16) -> Instruction { return inst_r_m(.LAR, Register(dst), src.mem, 2) } -inst_lar_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return inst_r_r(.LAR, Register(dst), Register(src)) } -inst_lar_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32) -> Instruction { return inst_r_m(.LAR, Register(dst), src.mem, 4) } -inst_lar_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return inst_r_r(.LAR, Register(dst), Register(src)) } -inst_lar_r64_m64 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64) -> Instruction { return inst_r_m(.LAR, Register(dst), src.mem, 8) } -emit_lar_r16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: GPR16) { emit_rr(instructions, .LAR, Register(dst), Register(src)) } -emit_lar_r16_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: Mem16) { emit_rm(instructions, .LAR, Register(dst), src.mem, 2) } -emit_lar_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { emit_rr(instructions, .LAR, Register(dst), Register(src)) } -emit_lar_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32) { emit_rm(instructions, .LAR, Register(dst), src.mem, 4) } -emit_lar_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { emit_rr(instructions, .LAR, Register(dst), Register(src)) } -emit_lar_r64_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem64) { emit_rm(instructions, .LAR, Register(dst), src.mem, 8) } -inst_lsl_r16_r16 :: #force_inline proc "contextless" (dst: GPR16, src: GPR16) -> Instruction { return inst_r_r(.LSL, Register(dst), Register(src)) } -inst_lsl_r16_m16 :: #force_inline proc "contextless" (dst: GPR16, src: Mem16) -> Instruction { return inst_r_m(.LSL, Register(dst), src.mem, 2) } -inst_lsl_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return inst_r_r(.LSL, Register(dst), Register(src)) } -inst_lsl_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32) -> Instruction { return inst_r_m(.LSL, Register(dst), src.mem, 4) } -inst_lsl_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return inst_r_r(.LSL, Register(dst), Register(src)) } -inst_lsl_r64_m64 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64) -> Instruction { return inst_r_m(.LSL, Register(dst), src.mem, 8) } -emit_lsl_r16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: GPR16) { emit_rr(instructions, .LSL, Register(dst), Register(src)) } -emit_lsl_r16_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: Mem16) { emit_rm(instructions, .LSL, Register(dst), src.mem, 2) } -emit_lsl_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { emit_rr(instructions, .LSL, Register(dst), Register(src)) } -emit_lsl_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32) { emit_rm(instructions, .LSL, Register(dst), src.mem, 4) } -emit_lsl_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { emit_rr(instructions, .LSL, Register(dst), Register(src)) } -emit_lsl_r64_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem64) { emit_rm(instructions, .LSL, Register(dst), src.mem, 8) } -inst_verr_r16 :: #force_inline proc "contextless" (dst: GPR16) -> Instruction { return inst_r(.VERR, Register(dst)) } -inst_verr_m16 :: #force_inline proc "contextless" (dst: Mem16) -> Instruction { return inst_m(.VERR, dst.mem, 2) } -emit_verr_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16) { emit_r(instructions, .VERR, Register(dst)) } -emit_verr_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16) { emit_m(instructions, .VERR, dst.mem, 2) } -inst_verw_r16 :: #force_inline proc "contextless" (dst: GPR16) -> Instruction { return inst_r(.VERW, Register(dst)) } -inst_verw_m16 :: #force_inline proc "contextless" (dst: Mem16) -> Instruction { return inst_m(.VERW, dst.mem, 2) } -emit_verw_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16) { emit_r(instructions, .VERW, Register(dst)) } -emit_verw_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16) { emit_m(instructions, .VERW, dst.mem, 2) } -inst_invd_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.INVD) } -emit_invd_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .INVD) } -inst_wbinvd_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.WBINVD) } -emit_wbinvd_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .WBINVD) } -inst_invlpg_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return inst_m(.INVLPG, dst.mem, 1) } -emit_invlpg_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { emit_m(instructions, .INVLPG, dst.mem, 1) } -inst_invpcid_r32_m128 :: #force_inline proc "contextless" (dst: GPR32, src: Mem128) -> Instruction { return inst_r_m(.INVPCID, Register(dst), src.mem, 16) } -inst_invpcid_r64_m128 :: #force_inline proc "contextless" (dst: GPR64, src: Mem128) -> Instruction { return inst_r_m(.INVPCID, Register(dst), src.mem, 16) } -emit_invpcid_r32_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem128) { emit_rm(instructions, .INVPCID, Register(dst), src.mem, 16) } -emit_invpcid_r64_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem128) { emit_rm(instructions, .INVPCID, Register(dst), src.mem, 16) } -inst_rsm_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.RSM) } -emit_rsm_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .RSM) } -inst_rdmsr_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.RDMSR) } -emit_rdmsr_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .RDMSR) } -inst_wrmsr_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.WRMSR) } -emit_wrmsr_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .WRMSR) } -inst_vmcall_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.VMCALL) } -emit_vmcall_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .VMCALL) } -inst_vmlaunch_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.VMLAUNCH) } -emit_vmlaunch_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .VMLAUNCH) } -inst_vmresume_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.VMRESUME) } -emit_vmresume_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .VMRESUME) } -inst_vmxoff_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.VMXOFF) } -emit_vmxoff_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .VMXOFF) } -inst_vmxon_m64 :: #force_inline proc "contextless" (dst: Mem64) -> Instruction { return inst_m(.VMXON, dst.mem, 8) } -emit_vmxon_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64) { emit_m(instructions, .VMXON, dst.mem, 8) } -inst_vmclear_m64 :: #force_inline proc "contextless" (dst: Mem64) -> Instruction { return inst_m(.VMCLEAR, dst.mem, 8) } -emit_vmclear_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64) { emit_m(instructions, .VMCLEAR, dst.mem, 8) } -inst_vmptrld_m64 :: #force_inline proc "contextless" (dst: Mem64) -> Instruction { return inst_m(.VMPTRLD, dst.mem, 8) } -emit_vmptrld_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64) { emit_m(instructions, .VMPTRLD, dst.mem, 8) } -inst_vmptrst_m64 :: #force_inline proc "contextless" (dst: Mem64) -> Instruction { return inst_m(.VMPTRST, dst.mem, 8) } -emit_vmptrst_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64) { emit_m(instructions, .VMPTRST, dst.mem, 8) } -inst_vmread_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return inst_r_r(.VMREAD, Register(dst), Register(src)) } -inst_vmread_m64_r64 :: #force_inline proc "contextless" (dst: Mem64, src: GPR64) -> Instruction { return inst_m_r(.VMREAD, dst.mem, 8, Register(src)) } -emit_vmread_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { emit_rr(instructions, .VMREAD, Register(dst), Register(src)) } -emit_vmread_m64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, src: GPR64) { emit_mr(instructions, .VMREAD, dst.mem, 8, Register(src)) } -inst_vmwrite_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return inst_r_r(.VMWRITE, Register(dst), Register(src)) } -inst_vmwrite_r64_m64 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64) -> Instruction { return inst_r_m(.VMWRITE, Register(dst), src.mem, 8) } -emit_vmwrite_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { emit_rr(instructions, .VMWRITE, Register(dst), Register(src)) } -emit_vmwrite_r64_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem64) { emit_rm(instructions, .VMWRITE, Register(dst), src.mem, 8) } -inst_vmfunc_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.VMFUNC) } -emit_vmfunc_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .VMFUNC) } -inst_invept_r64_m128 :: #force_inline proc "contextless" (dst: GPR64, src: Mem128) -> Instruction { return inst_r_m(.INVEPT, Register(dst), src.mem, 16) } -emit_invept_r64_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem128) { emit_rm(instructions, .INVEPT, Register(dst), src.mem, 16) } -inst_invvpid_r64_m128 :: #force_inline proc "contextless" (dst: GPR64, src: Mem128) -> Instruction { return inst_r_m(.INVVPID, Register(dst), src.mem, 16) } -emit_invvpid_r64_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem128) { emit_rm(instructions, .INVVPID, Register(dst), src.mem, 16) } -inst_encls_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.ENCLS) } -emit_encls_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .ENCLS) } -inst_enclu_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.ENCLU) } -emit_enclu_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .ENCLU) } -inst_enclv_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.ENCLV) } -emit_enclv_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .ENCLV) } -inst_rdpkru_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.RDPKRU) } -emit_rdpkru_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .RDPKRU) } -inst_wrpkru_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.WRPKRU) } -emit_wrpkru_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .WRPKRU) } -inst_incsspd_r32 :: #force_inline proc "contextless" (dst: GPR32) -> Instruction { return inst_r(.INCSSPD, Register(dst)) } -emit_incsspd_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32) { emit_r(instructions, .INCSSPD, Register(dst)) } -inst_incsspq_r64 :: #force_inline proc "contextless" (dst: GPR64) -> Instruction { return inst_r(.INCSSPQ, Register(dst)) } -emit_incsspq_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64) { emit_r(instructions, .INCSSPQ, Register(dst)) } -inst_rdsspd_r32 :: #force_inline proc "contextless" (dst: GPR32) -> Instruction { return inst_r(.RDSSPD, Register(dst)) } -emit_rdsspd_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32) { emit_r(instructions, .RDSSPD, Register(dst)) } -inst_rdsspq_r64 :: #force_inline proc "contextless" (dst: GPR64) -> Instruction { return inst_r(.RDSSPQ, Register(dst)) } -emit_rdsspq_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64) { emit_r(instructions, .RDSSPQ, Register(dst)) } -inst_saveprevssp_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.SAVEPREVSSP) } -emit_saveprevssp_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .SAVEPREVSSP) } -inst_rstorssp_m64 :: #force_inline proc "contextless" (dst: Mem64) -> Instruction { return inst_m(.RSTORSSP, dst.mem, 8) } -emit_rstorssp_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64) { emit_m(instructions, .RSTORSSP, dst.mem, 8) } -inst_wrssd_m32_r32 :: #force_inline proc "contextless" (dst: Mem32, src: GPR32) -> Instruction { return inst_m_r(.WRSSD, dst.mem, 4, Register(src)) } -emit_wrssd_m32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, src: GPR32) { emit_mr(instructions, .WRSSD, dst.mem, 4, Register(src)) } -inst_wrssq_m64_r64 :: #force_inline proc "contextless" (dst: Mem64, src: GPR64) -> Instruction { return inst_m_r(.WRSSQ, dst.mem, 8, Register(src)) } -emit_wrssq_m64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, src: GPR64) { emit_mr(instructions, .WRSSQ, dst.mem, 8, Register(src)) } -inst_wrussd_m32_r32 :: #force_inline proc "contextless" (dst: Mem32, src: GPR32) -> Instruction { return inst_m_r(.WRUSSD, dst.mem, 4, Register(src)) } -emit_wrussd_m32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, src: GPR32) { emit_mr(instructions, .WRUSSD, dst.mem, 4, Register(src)) } -inst_wrussq_m64_r64 :: #force_inline proc "contextless" (dst: Mem64, src: GPR64) -> Instruction { return inst_m_r(.WRUSSQ, dst.mem, 8, Register(src)) } -emit_wrussq_m64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, src: GPR64) { emit_mr(instructions, .WRUSSQ, dst.mem, 8, Register(src)) } -inst_setssbsy_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.SETSSBSY) } -emit_setssbsy_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .SETSSBSY) } -inst_clrssbsy_m64 :: #force_inline proc "contextless" (dst: Mem64) -> Instruction { return inst_m(.CLRSSBSY, dst.mem, 8) } -emit_clrssbsy_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64) { emit_m(instructions, .CLRSSBSY, dst.mem, 8) } -inst_endbr64_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.ENDBR64) } -emit_endbr64_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .ENDBR64) } -inst_endbr32_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.ENDBR32) } -emit_endbr32_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .ENDBR32) } -inst_xsave_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return inst_m(.XSAVE, dst.mem, 1) } -emit_xsave_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { emit_m(instructions, .XSAVE, dst.mem, 1) } -inst_xsave64_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return inst_m(.XSAVE64, dst.mem, 1) } -emit_xsave64_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { emit_m(instructions, .XSAVE64, dst.mem, 1) } -inst_xrstor_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return inst_m(.XRSTOR, dst.mem, 1) } -emit_xrstor_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { emit_m(instructions, .XRSTOR, dst.mem, 1) } -inst_xrstor64_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return inst_m(.XRSTOR64, dst.mem, 1) } -emit_xrstor64_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { emit_m(instructions, .XRSTOR64, dst.mem, 1) } -inst_xsaveopt_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return inst_m(.XSAVEOPT, dst.mem, 1) } -emit_xsaveopt_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { emit_m(instructions, .XSAVEOPT, dst.mem, 1) } -inst_xsaveopt64_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return inst_m(.XSAVEOPT64, dst.mem, 1) } -emit_xsaveopt64_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { emit_m(instructions, .XSAVEOPT64, dst.mem, 1) } -inst_xsavec_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return inst_m(.XSAVEC, dst.mem, 1) } -emit_xsavec_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { emit_m(instructions, .XSAVEC, dst.mem, 1) } -inst_xsavec64_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return inst_m(.XSAVEC64, dst.mem, 1) } -emit_xsavec64_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { emit_m(instructions, .XSAVEC64, dst.mem, 1) } -inst_xsaves_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return inst_m(.XSAVES, dst.mem, 1) } -emit_xsaves_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { emit_m(instructions, .XSAVES, dst.mem, 1) } -inst_xsaves64_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return inst_m(.XSAVES64, dst.mem, 1) } -emit_xsaves64_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { emit_m(instructions, .XSAVES64, dst.mem, 1) } -inst_xrstors_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return inst_m(.XRSTORS, dst.mem, 1) } -emit_xrstors_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { emit_m(instructions, .XRSTORS, dst.mem, 1) } -inst_xrstors64_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return inst_m(.XRSTORS64, dst.mem, 1) } -emit_xrstors64_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { emit_m(instructions, .XRSTORS64, dst.mem, 1) } -inst_prefetcht0_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return inst_m(.PREFETCHT0, dst.mem, 1) } -emit_prefetcht0_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { emit_m(instructions, .PREFETCHT0, dst.mem, 1) } -inst_prefetcht1_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return inst_m(.PREFETCHT1, dst.mem, 1) } -emit_prefetcht1_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { emit_m(instructions, .PREFETCHT1, dst.mem, 1) } -inst_prefetcht2_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return inst_m(.PREFETCHT2, dst.mem, 1) } -emit_prefetcht2_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { emit_m(instructions, .PREFETCHT2, dst.mem, 1) } -inst_prefetchnta_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return inst_m(.PREFETCHNTA, dst.mem, 1) } -emit_prefetchnta_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { emit_m(instructions, .PREFETCHNTA, dst.mem, 1) } -inst_prefetchw_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return inst_m(.PREFETCHW, dst.mem, 1) } -emit_prefetchw_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { emit_m(instructions, .PREFETCHW, dst.mem, 1) } -inst_clflushopt_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return inst_m(.CLFLUSHOPT, dst.mem, 1) } -emit_clflushopt_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { emit_m(instructions, .CLFLUSHOPT, dst.mem, 1) } -inst_clwb_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return inst_m(.CLWB, dst.mem, 1) } -emit_clwb_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { emit_m(instructions, .CLWB, dst.mem, 1) } -inst_cldemote_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return inst_m(.CLDEMOTE, dst.mem, 1) } -emit_cldemote_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { emit_m(instructions, .CLDEMOTE, dst.mem, 1) } -inst_bswap_r32 :: #force_inline proc "contextless" (dst: GPR32) -> Instruction { return inst_r(.BSWAP, Register(dst)) } -inst_bswap_r64 :: #force_inline proc "contextless" (dst: GPR64) -> Instruction { return inst_r(.BSWAP, Register(dst)) } -emit_bswap_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32) { emit_r(instructions, .BSWAP, Register(dst)) } -emit_bswap_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64) { emit_r(instructions, .BSWAP, Register(dst)) } -inst_cmpxchg_r8_r8 :: #force_inline proc "contextless" (dst: GPR8, src: GPR8) -> Instruction { return inst_r_r(.CMPXCHG, Register(dst), Register(src)) } -inst_cmpxchg_m8_r8 :: #force_inline proc "contextless" (dst: Mem8, src: GPR8) -> Instruction { return inst_m_r(.CMPXCHG, dst.mem, 1, Register(src)) } -inst_cmpxchg_r16_r16 :: #force_inline proc "contextless" (dst: GPR16, src: GPR16) -> Instruction { return inst_r_r(.CMPXCHG, Register(dst), Register(src)) } -inst_cmpxchg_m16_r16 :: #force_inline proc "contextless" (dst: Mem16, src: GPR16) -> Instruction { return inst_m_r(.CMPXCHG, dst.mem, 2, Register(src)) } -inst_cmpxchg_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return inst_r_r(.CMPXCHG, Register(dst), Register(src)) } -inst_cmpxchg_m32_r32 :: #force_inline proc "contextless" (dst: Mem32, src: GPR32) -> Instruction { return inst_m_r(.CMPXCHG, dst.mem, 4, Register(src)) } -inst_cmpxchg_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return inst_r_r(.CMPXCHG, Register(dst), Register(src)) } -inst_cmpxchg_m64_r64 :: #force_inline proc "contextless" (dst: Mem64, src: GPR64) -> Instruction { return inst_m_r(.CMPXCHG, dst.mem, 8, Register(src)) } -emit_cmpxchg_r8_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8, src: GPR8) { emit_rr(instructions, .CMPXCHG, Register(dst), Register(src)) } -emit_cmpxchg_m8_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8, src: GPR8) { emit_mr(instructions, .CMPXCHG, dst.mem, 1, Register(src)) } -emit_cmpxchg_r16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: GPR16) { emit_rr(instructions, .CMPXCHG, Register(dst), Register(src)) } -emit_cmpxchg_m16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16, src: GPR16) { emit_mr(instructions, .CMPXCHG, dst.mem, 2, Register(src)) } -emit_cmpxchg_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { emit_rr(instructions, .CMPXCHG, Register(dst), Register(src)) } -emit_cmpxchg_m32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, src: GPR32) { emit_mr(instructions, .CMPXCHG, dst.mem, 4, Register(src)) } -emit_cmpxchg_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { emit_rr(instructions, .CMPXCHG, Register(dst), Register(src)) } -emit_cmpxchg_m64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, src: GPR64) { emit_mr(instructions, .CMPXCHG, dst.mem, 8, Register(src)) } -inst_cmpxchg8b_m64 :: #force_inline proc "contextless" (dst: Mem64) -> Instruction { return inst_m(.CMPXCHG8B, dst.mem, 8) } -emit_cmpxchg8b_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64) { emit_m(instructions, .CMPXCHG8B, dst.mem, 8) } -inst_cmpxchg16b_m128 :: #force_inline proc "contextless" (dst: Mem128) -> Instruction { return inst_m(.CMPXCHG16B, dst.mem, 16) } -emit_cmpxchg16b_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem128) { emit_m(instructions, .CMPXCHG16B, dst.mem, 16) } -inst_xadd_r8_r8 :: #force_inline proc "contextless" (dst: GPR8, src: GPR8) -> Instruction { return inst_r_r(.XADD, Register(dst), Register(src)) } -inst_xadd_m8_r8 :: #force_inline proc "contextless" (dst: Mem8, src: GPR8) -> Instruction { return inst_m_r(.XADD, dst.mem, 1, Register(src)) } -inst_xadd_r16_r16 :: #force_inline proc "contextless" (dst: GPR16, src: GPR16) -> Instruction { return inst_r_r(.XADD, Register(dst), Register(src)) } -inst_xadd_m16_r16 :: #force_inline proc "contextless" (dst: Mem16, src: GPR16) -> Instruction { return inst_m_r(.XADD, dst.mem, 2, Register(src)) } -inst_xadd_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return inst_r_r(.XADD, Register(dst), Register(src)) } -inst_xadd_m32_r32 :: #force_inline proc "contextless" (dst: Mem32, src: GPR32) -> Instruction { return inst_m_r(.XADD, dst.mem, 4, Register(src)) } -inst_xadd_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return inst_r_r(.XADD, Register(dst), Register(src)) } -inst_xadd_m64_r64 :: #force_inline proc "contextless" (dst: Mem64, src: GPR64) -> Instruction { return inst_m_r(.XADD, dst.mem, 8, Register(src)) } -emit_xadd_r8_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8, src: GPR8) { emit_rr(instructions, .XADD, Register(dst), Register(src)) } -emit_xadd_m8_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8, src: GPR8) { emit_mr(instructions, .XADD, dst.mem, 1, Register(src)) } -emit_xadd_r16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: GPR16) { emit_rr(instructions, .XADD, Register(dst), Register(src)) } -emit_xadd_m16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16, src: GPR16) { emit_mr(instructions, .XADD, dst.mem, 2, Register(src)) } -emit_xadd_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { emit_rr(instructions, .XADD, Register(dst), Register(src)) } -emit_xadd_m32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, src: GPR32) { emit_mr(instructions, .XADD, dst.mem, 4, Register(src)) } -emit_xadd_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { emit_rr(instructions, .XADD, Register(dst), Register(src)) } -emit_xadd_m64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, src: GPR64) { emit_mr(instructions, .XADD, dst.mem, 8, Register(src)) } -inst_bound_r16_m :: #force_inline proc "contextless" (dst: GPR16, src: Memory) -> Instruction { return inst_r_m(.BOUND, Register(dst), src, 0) } -inst_bound_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32) -> Instruction { return inst_r_m(.BOUND, Register(dst), src.mem, 4) } -emit_bound_r16_m :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: Memory) { emit_rm(instructions, .BOUND, Register(dst), src, 0) } -emit_bound_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32) { emit_rm(instructions, .BOUND, Register(dst), src.mem, 4) } +inst_vpmultishiftqb_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMULTISHIFTQB, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 2014) } +inst_vpmultishiftqb_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMULTISHIFTQB, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 2014) } +inst_vpmultishiftqb_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMULTISHIFTQB, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 2015) } +inst_vpmultishiftqb_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMULTISHIFTQB, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 2015) } +inst_vpmultishiftqb_zmm_zmm_zmm :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: ZMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMULTISHIFTQB, operand_count = 3, ops = {op_zmm(dst), op_zmm(src), op_zmm(src2), {}} }, 2016) } +inst_vpmultishiftqb_zmm_zmm_m512 :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: Mem512) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMULTISHIFTQB, operand_count = 3, ops = {op_zmm(dst), op_zmm(src), op_mem(src2.mem, 64), {}} }, 2016) } +emit_vpmultishiftqb_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vpmultishiftqb_xmm_xmm_xmm(dst, src, src2)) } +emit_vpmultishiftqb_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vpmultishiftqb_xmm_xmm_m128(dst, src, src2)) } +emit_vpmultishiftqb_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vpmultishiftqb_ymm_ymm_ymm(dst, src, src2)) } +emit_vpmultishiftqb_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vpmultishiftqb_ymm_ymm_m256(dst, src, src2)) } +emit_vpmultishiftqb_zmm_zmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: ZMM) { append(instructions, inst_vpmultishiftqb_zmm_zmm_zmm(dst, src, src2)) } +emit_vpmultishiftqb_zmm_zmm_m512 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: Mem512) { append(instructions, inst_vpmultishiftqb_zmm_zmm_m512(dst, src, src2)) } +inst_kaddw_k_k_k :: #force_inline proc "contextless" (dst: KREG, src: KREG, src2: KREG) -> Instruction { return with_hint(Instruction{ mnemonic = .KADDW, operand_count = 3, ops = {op_kreg(dst), op_kreg(src), op_kreg(src2), {}} }, 2017) } +emit_kaddw_k_k_k :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: KREG, src2: KREG) { append(instructions, inst_kaddw_k_k_k(dst, src, src2)) } +inst_kaddb_k_k_k :: #force_inline proc "contextless" (dst: KREG, src: KREG, src2: KREG) -> Instruction { return with_hint(Instruction{ mnemonic = .KADDB, operand_count = 3, ops = {op_kreg(dst), op_kreg(src), op_kreg(src2), {}} }, 2018) } +emit_kaddb_k_k_k :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: KREG, src2: KREG) { append(instructions, inst_kaddb_k_k_k(dst, src, src2)) } +inst_kaddq_k_k_k :: #force_inline proc "contextless" (dst: KREG, src: KREG, src2: KREG) -> Instruction { return with_hint(Instruction{ mnemonic = .KADDQ, operand_count = 3, ops = {op_kreg(dst), op_kreg(src), op_kreg(src2), {}} }, 2019) } +emit_kaddq_k_k_k :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: KREG, src2: KREG) { append(instructions, inst_kaddq_k_k_k(dst, src, src2)) } +inst_kaddd_k_k_k :: #force_inline proc "contextless" (dst: KREG, src: KREG, src2: KREG) -> Instruction { return with_hint(Instruction{ mnemonic = .KADDD, operand_count = 3, ops = {op_kreg(dst), op_kreg(src), op_kreg(src2), {}} }, 2020) } +emit_kaddd_k_k_k :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: KREG, src2: KREG) { append(instructions, inst_kaddd_k_k_k(dst, src, src2)) } +inst_kandw_k_k_k :: #force_inline proc "contextless" (dst: KREG, src: KREG, src2: KREG) -> Instruction { return with_hint(Instruction{ mnemonic = .KANDW, operand_count = 3, ops = {op_kreg(dst), op_kreg(src), op_kreg(src2), {}} }, 2021) } +emit_kandw_k_k_k :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: KREG, src2: KREG) { append(instructions, inst_kandw_k_k_k(dst, src, src2)) } +inst_kandb_k_k_k :: #force_inline proc "contextless" (dst: KREG, src: KREG, src2: KREG) -> Instruction { return with_hint(Instruction{ mnemonic = .KANDB, operand_count = 3, ops = {op_kreg(dst), op_kreg(src), op_kreg(src2), {}} }, 2022) } +emit_kandb_k_k_k :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: KREG, src2: KREG) { append(instructions, inst_kandb_k_k_k(dst, src, src2)) } +inst_kandq_k_k_k :: #force_inline proc "contextless" (dst: KREG, src: KREG, src2: KREG) -> Instruction { return with_hint(Instruction{ mnemonic = .KANDQ, operand_count = 3, ops = {op_kreg(dst), op_kreg(src), op_kreg(src2), {}} }, 2023) } +emit_kandq_k_k_k :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: KREG, src2: KREG) { append(instructions, inst_kandq_k_k_k(dst, src, src2)) } +inst_kandd_k_k_k :: #force_inline proc "contextless" (dst: KREG, src: KREG, src2: KREG) -> Instruction { return with_hint(Instruction{ mnemonic = .KANDD, operand_count = 3, ops = {op_kreg(dst), op_kreg(src), op_kreg(src2), {}} }, 2024) } +emit_kandd_k_k_k :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: KREG, src2: KREG) { append(instructions, inst_kandd_k_k_k(dst, src, src2)) } +inst_kandnw_k_k_k :: #force_inline proc "contextless" (dst: KREG, src: KREG, src2: KREG) -> Instruction { return with_hint(Instruction{ mnemonic = .KANDNW, operand_count = 3, ops = {op_kreg(dst), op_kreg(src), op_kreg(src2), {}} }, 2025) } +emit_kandnw_k_k_k :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: KREG, src2: KREG) { append(instructions, inst_kandnw_k_k_k(dst, src, src2)) } +inst_kandnb_k_k_k :: #force_inline proc "contextless" (dst: KREG, src: KREG, src2: KREG) -> Instruction { return with_hint(Instruction{ mnemonic = .KANDNB, operand_count = 3, ops = {op_kreg(dst), op_kreg(src), op_kreg(src2), {}} }, 2026) } +emit_kandnb_k_k_k :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: KREG, src2: KREG) { append(instructions, inst_kandnb_k_k_k(dst, src, src2)) } +inst_kandnq_k_k_k :: #force_inline proc "contextless" (dst: KREG, src: KREG, src2: KREG) -> Instruction { return with_hint(Instruction{ mnemonic = .KANDNQ, operand_count = 3, ops = {op_kreg(dst), op_kreg(src), op_kreg(src2), {}} }, 2027) } +emit_kandnq_k_k_k :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: KREG, src2: KREG) { append(instructions, inst_kandnq_k_k_k(dst, src, src2)) } +inst_kandnd_k_k_k :: #force_inline proc "contextless" (dst: KREG, src: KREG, src2: KREG) -> Instruction { return with_hint(Instruction{ mnemonic = .KANDND, operand_count = 3, ops = {op_kreg(dst), op_kreg(src), op_kreg(src2), {}} }, 2028) } +emit_kandnd_k_k_k :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: KREG, src2: KREG) { append(instructions, inst_kandnd_k_k_k(dst, src, src2)) } +inst_kmovw_k_k :: #force_inline proc "contextless" (dst: KREG, src: KREG) -> Instruction { return with_hint(Instruction{ mnemonic = .KMOVW, operand_count = 2, ops = {op_kreg(dst), op_kreg(src), {}, {}} }, 2029) } +inst_kmovw_k_m16 :: #force_inline proc "contextless" (dst: KREG, src: Mem16) -> Instruction { return with_hint(Instruction{ mnemonic = .KMOVW, operand_count = 2, ops = {op_kreg(dst), op_mem(src.mem, 2), {}, {}} }, 2029) } +inst_kmovw_m16_k :: #force_inline proc "contextless" (dst: Mem16, src: KREG) -> Instruction { return with_hint(Instruction{ mnemonic = .KMOVW, operand_count = 2, ops = {op_mem(dst.mem, 2), op_kreg(src), {}, {}} }, 2030) } +inst_kmovw_k_r32 :: #force_inline proc "contextless" (dst: KREG, src: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .KMOVW, operand_count = 2, ops = {op_kreg(dst), op_gpr32(src), {}, {}} }, 2031) } +inst_kmovw_r32_k :: #force_inline proc "contextless" (dst: GPR32, src: KREG) -> Instruction { return with_hint(Instruction{ mnemonic = .KMOVW, operand_count = 2, ops = {op_gpr32(dst), op_kreg(src), {}, {}} }, 2032) } +emit_kmovw_k_k :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: KREG) { append(instructions, inst_kmovw_k_k(dst, src)) } +emit_kmovw_k_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: Mem16) { append(instructions, inst_kmovw_k_m16(dst, src)) } +emit_kmovw_m16_k :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16, src: KREG) { append(instructions, inst_kmovw_m16_k(dst, src)) } +emit_kmovw_k_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: GPR32) { append(instructions, inst_kmovw_k_r32(dst, src)) } +emit_kmovw_r32_k :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: KREG) { append(instructions, inst_kmovw_r32_k(dst, src)) } +inst_kmovb_k_k :: #force_inline proc "contextless" (dst: KREG, src: KREG) -> Instruction { return with_hint(Instruction{ mnemonic = .KMOVB, operand_count = 2, ops = {op_kreg(dst), op_kreg(src), {}, {}} }, 2033) } +inst_kmovb_k_m8 :: #force_inline proc "contextless" (dst: KREG, src: Mem8) -> Instruction { return with_hint(Instruction{ mnemonic = .KMOVB, operand_count = 2, ops = {op_kreg(dst), op_mem(src.mem, 1), {}, {}} }, 2033) } +inst_kmovb_m8_k :: #force_inline proc "contextless" (dst: Mem8, src: KREG) -> Instruction { return with_hint(Instruction{ mnemonic = .KMOVB, operand_count = 2, ops = {op_mem(dst.mem, 1), op_kreg(src), {}, {}} }, 2034) } +inst_kmovb_k_r32 :: #force_inline proc "contextless" (dst: KREG, src: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .KMOVB, operand_count = 2, ops = {op_kreg(dst), op_gpr32(src), {}, {}} }, 2035) } +inst_kmovb_r32_k :: #force_inline proc "contextless" (dst: GPR32, src: KREG) -> Instruction { return with_hint(Instruction{ mnemonic = .KMOVB, operand_count = 2, ops = {op_gpr32(dst), op_kreg(src), {}, {}} }, 2036) } +emit_kmovb_k_k :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: KREG) { append(instructions, inst_kmovb_k_k(dst, src)) } +emit_kmovb_k_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: Mem8) { append(instructions, inst_kmovb_k_m8(dst, src)) } +emit_kmovb_m8_k :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8, src: KREG) { append(instructions, inst_kmovb_m8_k(dst, src)) } +emit_kmovb_k_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: GPR32) { append(instructions, inst_kmovb_k_r32(dst, src)) } +emit_kmovb_r32_k :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: KREG) { append(instructions, inst_kmovb_r32_k(dst, src)) } +inst_kmovq_k_k :: #force_inline proc "contextless" (dst: KREG, src: KREG) -> Instruction { return with_hint(Instruction{ mnemonic = .KMOVQ, operand_count = 2, ops = {op_kreg(dst), op_kreg(src), {}, {}} }, 2037) } +inst_kmovq_k_m64 :: #force_inline proc "contextless" (dst: KREG, src: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .KMOVQ, operand_count = 2, ops = {op_kreg(dst), op_mem(src.mem, 8), {}, {}} }, 2037) } +inst_kmovq_m64_k :: #force_inline proc "contextless" (dst: Mem64, src: KREG) -> Instruction { return with_hint(Instruction{ mnemonic = .KMOVQ, operand_count = 2, ops = {op_mem(dst.mem, 8), op_kreg(src), {}, {}} }, 2038) } +inst_kmovq_k_r64 :: #force_inline proc "contextless" (dst: KREG, src: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .KMOVQ, operand_count = 2, ops = {op_kreg(dst), op_gpr64(src), {}, {}} }, 2039) } +inst_kmovq_r64_k :: #force_inline proc "contextless" (dst: GPR64, src: KREG) -> Instruction { return with_hint(Instruction{ mnemonic = .KMOVQ, operand_count = 2, ops = {op_gpr64(dst), op_kreg(src), {}, {}} }, 2040) } +emit_kmovq_k_k :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: KREG) { append(instructions, inst_kmovq_k_k(dst, src)) } +emit_kmovq_k_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: Mem64) { append(instructions, inst_kmovq_k_m64(dst, src)) } +emit_kmovq_m64_k :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, src: KREG) { append(instructions, inst_kmovq_m64_k(dst, src)) } +emit_kmovq_k_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: GPR64) { append(instructions, inst_kmovq_k_r64(dst, src)) } +emit_kmovq_r64_k :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: KREG) { append(instructions, inst_kmovq_r64_k(dst, src)) } +inst_kmovd_k_k :: #force_inline proc "contextless" (dst: KREG, src: KREG) -> Instruction { return with_hint(Instruction{ mnemonic = .KMOVD, operand_count = 2, ops = {op_kreg(dst), op_kreg(src), {}, {}} }, 2041) } +inst_kmovd_k_m32 :: #force_inline proc "contextless" (dst: KREG, src: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .KMOVD, operand_count = 2, ops = {op_kreg(dst), op_mem(src.mem, 4), {}, {}} }, 2041) } +inst_kmovd_m32_k :: #force_inline proc "contextless" (dst: Mem32, src: KREG) -> Instruction { return with_hint(Instruction{ mnemonic = .KMOVD, operand_count = 2, ops = {op_mem(dst.mem, 4), op_kreg(src), {}, {}} }, 2042) } +inst_kmovd_k_r32 :: #force_inline proc "contextless" (dst: KREG, src: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .KMOVD, operand_count = 2, ops = {op_kreg(dst), op_gpr32(src), {}, {}} }, 2043) } +inst_kmovd_r32_k :: #force_inline proc "contextless" (dst: GPR32, src: KREG) -> Instruction { return with_hint(Instruction{ mnemonic = .KMOVD, operand_count = 2, ops = {op_gpr32(dst), op_kreg(src), {}, {}} }, 2044) } +emit_kmovd_k_k :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: KREG) { append(instructions, inst_kmovd_k_k(dst, src)) } +emit_kmovd_k_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: Mem32) { append(instructions, inst_kmovd_k_m32(dst, src)) } +emit_kmovd_m32_k :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, src: KREG) { append(instructions, inst_kmovd_m32_k(dst, src)) } +emit_kmovd_k_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: GPR32) { append(instructions, inst_kmovd_k_r32(dst, src)) } +emit_kmovd_r32_k :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: KREG) { append(instructions, inst_kmovd_r32_k(dst, src)) } +inst_knotw_k_k :: #force_inline proc "contextless" (dst: KREG, src: KREG) -> Instruction { return with_hint(Instruction{ mnemonic = .KNOTW, operand_count = 2, ops = {op_kreg(dst), op_kreg(src), {}, {}} }, 2045) } +emit_knotw_k_k :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: KREG) { append(instructions, inst_knotw_k_k(dst, src)) } +inst_knotb_k_k :: #force_inline proc "contextless" (dst: KREG, src: KREG) -> Instruction { return with_hint(Instruction{ mnemonic = .KNOTB, operand_count = 2, ops = {op_kreg(dst), op_kreg(src), {}, {}} }, 2046) } +emit_knotb_k_k :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: KREG) { append(instructions, inst_knotb_k_k(dst, src)) } +inst_knotq_k_k :: #force_inline proc "contextless" (dst: KREG, src: KREG) -> Instruction { return with_hint(Instruction{ mnemonic = .KNOTQ, operand_count = 2, ops = {op_kreg(dst), op_kreg(src), {}, {}} }, 2047) } +emit_knotq_k_k :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: KREG) { append(instructions, inst_knotq_k_k(dst, src)) } +inst_knotd_k_k :: #force_inline proc "contextless" (dst: KREG, src: KREG) -> Instruction { return with_hint(Instruction{ mnemonic = .KNOTD, operand_count = 2, ops = {op_kreg(dst), op_kreg(src), {}, {}} }, 2048) } +emit_knotd_k_k :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: KREG) { append(instructions, inst_knotd_k_k(dst, src)) } +inst_korw_k_k_k :: #force_inline proc "contextless" (dst: KREG, src: KREG, src2: KREG) -> Instruction { return with_hint(Instruction{ mnemonic = .KORW, operand_count = 3, ops = {op_kreg(dst), op_kreg(src), op_kreg(src2), {}} }, 2049) } +emit_korw_k_k_k :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: KREG, src2: KREG) { append(instructions, inst_korw_k_k_k(dst, src, src2)) } +inst_korb_k_k_k :: #force_inline proc "contextless" (dst: KREG, src: KREG, src2: KREG) -> Instruction { return with_hint(Instruction{ mnemonic = .KORB, operand_count = 3, ops = {op_kreg(dst), op_kreg(src), op_kreg(src2), {}} }, 2050) } +emit_korb_k_k_k :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: KREG, src2: KREG) { append(instructions, inst_korb_k_k_k(dst, src, src2)) } +inst_korq_k_k_k :: #force_inline proc "contextless" (dst: KREG, src: KREG, src2: KREG) -> Instruction { return with_hint(Instruction{ mnemonic = .KORQ, operand_count = 3, ops = {op_kreg(dst), op_kreg(src), op_kreg(src2), {}} }, 2051) } +emit_korq_k_k_k :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: KREG, src2: KREG) { append(instructions, inst_korq_k_k_k(dst, src, src2)) } +inst_kord_k_k_k :: #force_inline proc "contextless" (dst: KREG, src: KREG, src2: KREG) -> Instruction { return with_hint(Instruction{ mnemonic = .KORD, operand_count = 3, ops = {op_kreg(dst), op_kreg(src), op_kreg(src2), {}} }, 2052) } +emit_kord_k_k_k :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: KREG, src2: KREG) { append(instructions, inst_kord_k_k_k(dst, src, src2)) } +inst_kortestw_k_k :: #force_inline proc "contextless" (dst: KREG, src: KREG) -> Instruction { return with_hint(Instruction{ mnemonic = .KORTESTW, operand_count = 2, ops = {op_kreg(dst), op_kreg(src), {}, {}} }, 2053) } +emit_kortestw_k_k :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: KREG) { append(instructions, inst_kortestw_k_k(dst, src)) } +inst_kortestb_k_k :: #force_inline proc "contextless" (dst: KREG, src: KREG) -> Instruction { return with_hint(Instruction{ mnemonic = .KORTESTB, operand_count = 2, ops = {op_kreg(dst), op_kreg(src), {}, {}} }, 2054) } +emit_kortestb_k_k :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: KREG) { append(instructions, inst_kortestb_k_k(dst, src)) } +inst_kortestq_k_k :: #force_inline proc "contextless" (dst: KREG, src: KREG) -> Instruction { return with_hint(Instruction{ mnemonic = .KORTESTQ, operand_count = 2, ops = {op_kreg(dst), op_kreg(src), {}, {}} }, 2055) } +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), {}} } } +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), {}} } } +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), {}} } } +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), {}} } } +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), {}} } } +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), {}} } } +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), {}} } } +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), {}} } } +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)) } +inst_ktestb_k_k :: #force_inline proc "contextless" (dst: KREG, src: KREG) -> Instruction { return with_hint(Instruction{ mnemonic = .KTESTB, operand_count = 2, ops = {op_kreg(dst), op_kreg(src), {}, {}} }, 2066) } +emit_ktestb_k_k :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: KREG) { append(instructions, inst_ktestb_k_k(dst, src)) } +inst_ktestq_k_k :: #force_inline proc "contextless" (dst: KREG, src: KREG) -> Instruction { return with_hint(Instruction{ mnemonic = .KTESTQ, operand_count = 2, ops = {op_kreg(dst), op_kreg(src), {}, {}} }, 2067) } +emit_ktestq_k_k :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: KREG) { append(instructions, inst_ktestq_k_k(dst, src)) } +inst_ktestd_k_k :: #force_inline proc "contextless" (dst: KREG, src: KREG) -> Instruction { return with_hint(Instruction{ mnemonic = .KTESTD, operand_count = 2, ops = {op_kreg(dst), op_kreg(src), {}, {}} }, 2068) } +emit_ktestd_k_k :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: KREG) { append(instructions, inst_ktestd_k_k(dst, src)) } +inst_kunpckbw_k_k_k :: #force_inline proc "contextless" (dst: KREG, src: KREG, src2: KREG) -> Instruction { return with_hint(Instruction{ mnemonic = .KUNPCKBW, operand_count = 3, ops = {op_kreg(dst), op_kreg(src), op_kreg(src2), {}} }, 2069) } +emit_kunpckbw_k_k_k :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: KREG, src2: KREG) { append(instructions, inst_kunpckbw_k_k_k(dst, src, src2)) } +inst_kunpckwd_k_k_k :: #force_inline proc "contextless" (dst: KREG, src: KREG, src2: KREG) -> Instruction { return with_hint(Instruction{ mnemonic = .KUNPCKWD, operand_count = 3, ops = {op_kreg(dst), op_kreg(src), op_kreg(src2), {}} }, 2070) } +emit_kunpckwd_k_k_k :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: KREG, src2: KREG) { append(instructions, inst_kunpckwd_k_k_k(dst, src, src2)) } +inst_kunpckdq_k_k_k :: #force_inline proc "contextless" (dst: KREG, src: KREG, src2: KREG) -> Instruction { return with_hint(Instruction{ mnemonic = .KUNPCKDQ, operand_count = 3, ops = {op_kreg(dst), op_kreg(src), op_kreg(src2), {}} }, 2071) } +emit_kunpckdq_k_k_k :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: KREG, src2: KREG) { append(instructions, inst_kunpckdq_k_k_k(dst, src, src2)) } +inst_kxnorw_k_k_k :: #force_inline proc "contextless" (dst: KREG, src: KREG, src2: KREG) -> Instruction { return with_hint(Instruction{ mnemonic = .KXNORW, operand_count = 3, ops = {op_kreg(dst), op_kreg(src), op_kreg(src2), {}} }, 2072) } +emit_kxnorw_k_k_k :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: KREG, src2: KREG) { append(instructions, inst_kxnorw_k_k_k(dst, src, src2)) } +inst_kxnorb_k_k_k :: #force_inline proc "contextless" (dst: KREG, src: KREG, src2: KREG) -> Instruction { return with_hint(Instruction{ mnemonic = .KXNORB, operand_count = 3, ops = {op_kreg(dst), op_kreg(src), op_kreg(src2), {}} }, 2073) } +emit_kxnorb_k_k_k :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: KREG, src2: KREG) { append(instructions, inst_kxnorb_k_k_k(dst, src, src2)) } +inst_kxnorq_k_k_k :: #force_inline proc "contextless" (dst: KREG, src: KREG, src2: KREG) -> Instruction { return with_hint(Instruction{ mnemonic = .KXNORQ, operand_count = 3, ops = {op_kreg(dst), op_kreg(src), op_kreg(src2), {}} }, 2074) } +emit_kxnorq_k_k_k :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: KREG, src2: KREG) { append(instructions, inst_kxnorq_k_k_k(dst, src, src2)) } +inst_kxnord_k_k_k :: #force_inline proc "contextless" (dst: KREG, src: KREG, src2: KREG) -> Instruction { return with_hint(Instruction{ mnemonic = .KXNORD, operand_count = 3, ops = {op_kreg(dst), op_kreg(src), op_kreg(src2), {}} }, 2075) } +emit_kxnord_k_k_k :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: KREG, src2: KREG) { append(instructions, inst_kxnord_k_k_k(dst, src, src2)) } +inst_kxorw_k_k_k :: #force_inline proc "contextless" (dst: KREG, src: KREG, src2: KREG) -> Instruction { return with_hint(Instruction{ mnemonic = .KXORW, operand_count = 3, ops = {op_kreg(dst), op_kreg(src), op_kreg(src2), {}} }, 2076) } +emit_kxorw_k_k_k :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: KREG, src2: KREG) { append(instructions, inst_kxorw_k_k_k(dst, src, src2)) } +inst_kxorb_k_k_k :: #force_inline proc "contextless" (dst: KREG, src: KREG, src2: KREG) -> Instruction { return with_hint(Instruction{ mnemonic = .KXORB, operand_count = 3, ops = {op_kreg(dst), op_kreg(src), op_kreg(src2), {}} }, 2077) } +emit_kxorb_k_k_k :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: KREG, src2: KREG) { append(instructions, inst_kxorb_k_k_k(dst, src, src2)) } +inst_kxorq_k_k_k :: #force_inline proc "contextless" (dst: KREG, src: KREG, src2: KREG) -> Instruction { return with_hint(Instruction{ mnemonic = .KXORQ, operand_count = 3, ops = {op_kreg(dst), op_kreg(src), op_kreg(src2), {}} }, 2078) } +emit_kxorq_k_k_k :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: KREG, src2: KREG) { append(instructions, inst_kxorq_k_k_k(dst, src, src2)) } +inst_kxord_k_k_k :: #force_inline proc "contextless" (dst: KREG, src: KREG, src2: KREG) -> Instruction { return with_hint(Instruction{ mnemonic = .KXORD, operand_count = 3, ops = {op_kreg(dst), op_kreg(src), op_kreg(src2), {}} }, 2079) } +emit_kxord_k_k_k :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: KREG, src2: KREG) { append(instructions, inst_kxord_k_k_k(dst, src, src2)) } +inst_fadd_m32 :: #force_inline proc "contextless" (dst: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .FADD, operand_count = 1, ops = {op_mem(dst.mem, 4), {}, {}, {}} }, 2080) } +inst_fadd_m64 :: #force_inline proc "contextless" (dst: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .FADD, operand_count = 1, ops = {op_mem(dst.mem, 8), {}, {}, {}} }, 2081) } +inst_fadd_st :: #force_inline proc "contextless" (dst: ST) -> Instruction { return with_hint(Instruction{ mnemonic = .FADD, operand_count = 1, ops = {op_st(dst), {}, {}, {}} }, 2082) } +emit_fadd_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32) { append(instructions, inst_fadd_m32(dst)) } +emit_fadd_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64) { append(instructions, inst_fadd_m64(dst)) } +emit_fadd_st :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ST) { append(instructions, inst_fadd_st(dst)) } +inst_faddp_st :: #force_inline proc "contextless" (dst: ST) -> Instruction { return with_hint(Instruction{ mnemonic = .FADDP, operand_count = 1, ops = {op_st(dst), {}, {}, {}} }, 2084) } +inst_faddp_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .FADDP, operand_count = 0, ops = {{}, {}, {}, {}} }, 2085) } +emit_faddp_st :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ST) { append(instructions, inst_faddp_st(dst)) } +emit_faddp_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_faddp_none()) } +inst_fiadd_m16 :: #force_inline proc "contextless" (dst: Mem16) -> Instruction { return with_hint(Instruction{ mnemonic = .FIADD, operand_count = 1, ops = {op_mem(dst.mem, 2), {}, {}, {}} }, 2086) } +inst_fiadd_m32 :: #force_inline proc "contextless" (dst: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .FIADD, operand_count = 1, ops = {op_mem(dst.mem, 4), {}, {}, {}} }, 2087) } +emit_fiadd_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16) { append(instructions, inst_fiadd_m16(dst)) } +emit_fiadd_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32) { append(instructions, inst_fiadd_m32(dst)) } +inst_fsub_m32 :: #force_inline proc "contextless" (dst: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .FSUB, operand_count = 1, ops = {op_mem(dst.mem, 4), {}, {}, {}} }, 2088) } +inst_fsub_m64 :: #force_inline proc "contextless" (dst: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .FSUB, operand_count = 1, ops = {op_mem(dst.mem, 8), {}, {}, {}} }, 2089) } +inst_fsub_st :: #force_inline proc "contextless" (dst: ST) -> Instruction { return with_hint(Instruction{ mnemonic = .FSUB, operand_count = 1, ops = {op_st(dst), {}, {}, {}} }, 2090) } +emit_fsub_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32) { append(instructions, inst_fsub_m32(dst)) } +emit_fsub_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64) { append(instructions, inst_fsub_m64(dst)) } +emit_fsub_st :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ST) { append(instructions, inst_fsub_st(dst)) } +inst_fsubp_st :: #force_inline proc "contextless" (dst: ST) -> Instruction { return with_hint(Instruction{ mnemonic = .FSUBP, operand_count = 1, ops = {op_st(dst), {}, {}, {}} }, 2092) } +inst_fsubp_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .FSUBP, operand_count = 0, ops = {{}, {}, {}, {}} }, 2093) } +emit_fsubp_st :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ST) { append(instructions, inst_fsubp_st(dst)) } +emit_fsubp_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_fsubp_none()) } +inst_fisub_m16 :: #force_inline proc "contextless" (dst: Mem16) -> Instruction { return with_hint(Instruction{ mnemonic = .FISUB, operand_count = 1, ops = {op_mem(dst.mem, 2), {}, {}, {}} }, 2094) } +inst_fisub_m32 :: #force_inline proc "contextless" (dst: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .FISUB, operand_count = 1, ops = {op_mem(dst.mem, 4), {}, {}, {}} }, 2095) } +emit_fisub_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16) { append(instructions, inst_fisub_m16(dst)) } +emit_fisub_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32) { append(instructions, inst_fisub_m32(dst)) } +inst_fsubr_m32 :: #force_inline proc "contextless" (dst: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .FSUBR, operand_count = 1, ops = {op_mem(dst.mem, 4), {}, {}, {}} }, 2096) } +inst_fsubr_m64 :: #force_inline proc "contextless" (dst: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .FSUBR, operand_count = 1, ops = {op_mem(dst.mem, 8), {}, {}, {}} }, 2097) } +inst_fsubr_st :: #force_inline proc "contextless" (dst: ST) -> Instruction { return with_hint(Instruction{ mnemonic = .FSUBR, operand_count = 1, ops = {op_st(dst), {}, {}, {}} }, 2098) } +emit_fsubr_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32) { append(instructions, inst_fsubr_m32(dst)) } +emit_fsubr_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64) { append(instructions, inst_fsubr_m64(dst)) } +emit_fsubr_st :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ST) { append(instructions, inst_fsubr_st(dst)) } +inst_fsubrp_st :: #force_inline proc "contextless" (dst: ST) -> Instruction { return with_hint(Instruction{ mnemonic = .FSUBRP, operand_count = 1, ops = {op_st(dst), {}, {}, {}} }, 2100) } +inst_fsubrp_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .FSUBRP, operand_count = 0, ops = {{}, {}, {}, {}} }, 2101) } +emit_fsubrp_st :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ST) { append(instructions, inst_fsubrp_st(dst)) } +emit_fsubrp_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_fsubrp_none()) } +inst_fisubr_m16 :: #force_inline proc "contextless" (dst: Mem16) -> Instruction { return with_hint(Instruction{ mnemonic = .FISUBR, operand_count = 1, ops = {op_mem(dst.mem, 2), {}, {}, {}} }, 2102) } +inst_fisubr_m32 :: #force_inline proc "contextless" (dst: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .FISUBR, operand_count = 1, ops = {op_mem(dst.mem, 4), {}, {}, {}} }, 2103) } +emit_fisubr_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16) { append(instructions, inst_fisubr_m16(dst)) } +emit_fisubr_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32) { append(instructions, inst_fisubr_m32(dst)) } +inst_fmul_m32 :: #force_inline proc "contextless" (dst: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .FMUL, operand_count = 1, ops = {op_mem(dst.mem, 4), {}, {}, {}} }, 2104) } +inst_fmul_m64 :: #force_inline proc "contextless" (dst: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .FMUL, operand_count = 1, ops = {op_mem(dst.mem, 8), {}, {}, {}} }, 2105) } +inst_fmul_st :: #force_inline proc "contextless" (dst: ST) -> Instruction { return with_hint(Instruction{ mnemonic = .FMUL, operand_count = 1, ops = {op_st(dst), {}, {}, {}} }, 2106) } +emit_fmul_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32) { append(instructions, inst_fmul_m32(dst)) } +emit_fmul_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64) { append(instructions, inst_fmul_m64(dst)) } +emit_fmul_st :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ST) { append(instructions, inst_fmul_st(dst)) } +inst_fmulp_st :: #force_inline proc "contextless" (dst: ST) -> Instruction { return with_hint(Instruction{ mnemonic = .FMULP, operand_count = 1, ops = {op_st(dst), {}, {}, {}} }, 2108) } +inst_fmulp_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .FMULP, operand_count = 0, ops = {{}, {}, {}, {}} }, 2109) } +emit_fmulp_st :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ST) { append(instructions, inst_fmulp_st(dst)) } +emit_fmulp_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_fmulp_none()) } +inst_fimul_m16 :: #force_inline proc "contextless" (dst: Mem16) -> Instruction { return with_hint(Instruction{ mnemonic = .FIMUL, operand_count = 1, ops = {op_mem(dst.mem, 2), {}, {}, {}} }, 2110) } +inst_fimul_m32 :: #force_inline proc "contextless" (dst: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .FIMUL, operand_count = 1, ops = {op_mem(dst.mem, 4), {}, {}, {}} }, 2111) } +emit_fimul_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16) { append(instructions, inst_fimul_m16(dst)) } +emit_fimul_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32) { append(instructions, inst_fimul_m32(dst)) } +inst_fdiv_m32 :: #force_inline proc "contextless" (dst: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .FDIV, operand_count = 1, ops = {op_mem(dst.mem, 4), {}, {}, {}} }, 2112) } +inst_fdiv_m64 :: #force_inline proc "contextless" (dst: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .FDIV, operand_count = 1, ops = {op_mem(dst.mem, 8), {}, {}, {}} }, 2113) } +inst_fdiv_st :: #force_inline proc "contextless" (dst: ST) -> Instruction { return with_hint(Instruction{ mnemonic = .FDIV, operand_count = 1, ops = {op_st(dst), {}, {}, {}} }, 2114) } +emit_fdiv_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32) { append(instructions, inst_fdiv_m32(dst)) } +emit_fdiv_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64) { append(instructions, inst_fdiv_m64(dst)) } +emit_fdiv_st :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ST) { append(instructions, inst_fdiv_st(dst)) } +inst_fdivp_st :: #force_inline proc "contextless" (dst: ST) -> Instruction { return with_hint(Instruction{ mnemonic = .FDIVP, operand_count = 1, ops = {op_st(dst), {}, {}, {}} }, 2116) } +inst_fdivp_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .FDIVP, operand_count = 0, ops = {{}, {}, {}, {}} }, 2117) } +emit_fdivp_st :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ST) { append(instructions, inst_fdivp_st(dst)) } +emit_fdivp_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_fdivp_none()) } +inst_fidiv_m16 :: #force_inline proc "contextless" (dst: Mem16) -> Instruction { return with_hint(Instruction{ mnemonic = .FIDIV, operand_count = 1, ops = {op_mem(dst.mem, 2), {}, {}, {}} }, 2118) } +inst_fidiv_m32 :: #force_inline proc "contextless" (dst: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .FIDIV, operand_count = 1, ops = {op_mem(dst.mem, 4), {}, {}, {}} }, 2119) } +emit_fidiv_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16) { append(instructions, inst_fidiv_m16(dst)) } +emit_fidiv_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32) { append(instructions, inst_fidiv_m32(dst)) } +inst_fdivr_m32 :: #force_inline proc "contextless" (dst: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .FDIVR, operand_count = 1, ops = {op_mem(dst.mem, 4), {}, {}, {}} }, 2120) } +inst_fdivr_m64 :: #force_inline proc "contextless" (dst: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .FDIVR, operand_count = 1, ops = {op_mem(dst.mem, 8), {}, {}, {}} }, 2121) } +inst_fdivr_st :: #force_inline proc "contextless" (dst: ST) -> Instruction { return with_hint(Instruction{ mnemonic = .FDIVR, operand_count = 1, ops = {op_st(dst), {}, {}, {}} }, 2122) } +emit_fdivr_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32) { append(instructions, inst_fdivr_m32(dst)) } +emit_fdivr_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64) { append(instructions, inst_fdivr_m64(dst)) } +emit_fdivr_st :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ST) { append(instructions, inst_fdivr_st(dst)) } +inst_fdivrp_st :: #force_inline proc "contextless" (dst: ST) -> Instruction { return with_hint(Instruction{ mnemonic = .FDIVRP, operand_count = 1, ops = {op_st(dst), {}, {}, {}} }, 2124) } +inst_fdivrp_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .FDIVRP, operand_count = 0, ops = {{}, {}, {}, {}} }, 2125) } +emit_fdivrp_st :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ST) { append(instructions, inst_fdivrp_st(dst)) } +emit_fdivrp_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_fdivrp_none()) } +inst_fidivr_m16 :: #force_inline proc "contextless" (dst: Mem16) -> Instruction { return with_hint(Instruction{ mnemonic = .FIDIVR, operand_count = 1, ops = {op_mem(dst.mem, 2), {}, {}, {}} }, 2126) } +inst_fidivr_m32 :: #force_inline proc "contextless" (dst: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .FIDIVR, operand_count = 1, ops = {op_mem(dst.mem, 4), {}, {}, {}} }, 2127) } +emit_fidivr_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16) { append(instructions, inst_fidivr_m16(dst)) } +emit_fidivr_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32) { append(instructions, inst_fidivr_m32(dst)) } +inst_fsqrt_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .FSQRT, operand_count = 0, ops = {{}, {}, {}, {}} }, 2128) } +emit_fsqrt_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_fsqrt_none()) } +inst_fabs_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .FABS, operand_count = 0, ops = {{}, {}, {}, {}} }, 2129) } +emit_fabs_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_fabs_none()) } +inst_fchs_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .FCHS, operand_count = 0, ops = {{}, {}, {}, {}} }, 2130) } +emit_fchs_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_fchs_none()) } +inst_fprem_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .FPREM, operand_count = 0, ops = {{}, {}, {}, {}} }, 2131) } +emit_fprem_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_fprem_none()) } +inst_fprem1_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .FPREM1, operand_count = 0, ops = {{}, {}, {}, {}} }, 2132) } +emit_fprem1_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_fprem1_none()) } +inst_frndint_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .FRNDINT, operand_count = 0, ops = {{}, {}, {}, {}} }, 2133) } +emit_frndint_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_frndint_none()) } +inst_fscale_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .FSCALE, operand_count = 0, ops = {{}, {}, {}, {}} }, 2134) } +emit_fscale_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_fscale_none()) } +inst_fxtract_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .FXTRACT, operand_count = 0, ops = {{}, {}, {}, {}} }, 2135) } +emit_fxtract_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_fxtract_none()) } +inst_fxam_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .FXAM, operand_count = 0, ops = {{}, {}, {}, {}} }, 2136) } +emit_fxam_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_fxam_none()) } +inst_fld_m32 :: #force_inline proc "contextless" (dst: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .FLD, operand_count = 1, ops = {op_mem(dst.mem, 4), {}, {}, {}} }, 2137) } +inst_fld_m64 :: #force_inline proc "contextless" (dst: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .FLD, operand_count = 1, ops = {op_mem(dst.mem, 8), {}, {}, {}} }, 2138) } +inst_fld_m80 :: #force_inline proc "contextless" (dst: Mem80) -> Instruction { return with_hint(Instruction{ mnemonic = .FLD, operand_count = 1, ops = {op_mem(dst.mem, 10), {}, {}, {}} }, 2139) } +inst_fld_st :: #force_inline proc "contextless" (dst: ST) -> Instruction { return with_hint(Instruction{ mnemonic = .FLD, operand_count = 1, ops = {op_st(dst), {}, {}, {}} }, 2140) } +emit_fld_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32) { append(instructions, inst_fld_m32(dst)) } +emit_fld_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64) { append(instructions, inst_fld_m64(dst)) } +emit_fld_m80 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem80) { append(instructions, inst_fld_m80(dst)) } +emit_fld_st :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ST) { append(instructions, inst_fld_st(dst)) } +inst_fild_m16 :: #force_inline proc "contextless" (dst: Mem16) -> Instruction { return with_hint(Instruction{ mnemonic = .FILD, operand_count = 1, ops = {op_mem(dst.mem, 2), {}, {}, {}} }, 2141) } +inst_fild_m32 :: #force_inline proc "contextless" (dst: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .FILD, operand_count = 1, ops = {op_mem(dst.mem, 4), {}, {}, {}} }, 2142) } +inst_fild_m64 :: #force_inline proc "contextless" (dst: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .FILD, operand_count = 1, ops = {op_mem(dst.mem, 8), {}, {}, {}} }, 2143) } +emit_fild_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16) { append(instructions, inst_fild_m16(dst)) } +emit_fild_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32) { append(instructions, inst_fild_m32(dst)) } +emit_fild_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64) { append(instructions, inst_fild_m64(dst)) } +inst_fbld_m80 :: #force_inline proc "contextless" (dst: Mem80) -> Instruction { return with_hint(Instruction{ mnemonic = .FBLD, operand_count = 1, ops = {op_mem(dst.mem, 10), {}, {}, {}} }, 2144) } +emit_fbld_m80 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem80) { append(instructions, inst_fbld_m80(dst)) } +inst_fst_m32 :: #force_inline proc "contextless" (dst: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .FST, operand_count = 1, ops = {op_mem(dst.mem, 4), {}, {}, {}} }, 2145) } +inst_fst_m64 :: #force_inline proc "contextless" (dst: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .FST, operand_count = 1, ops = {op_mem(dst.mem, 8), {}, {}, {}} }, 2146) } +inst_fst_st :: #force_inline proc "contextless" (dst: ST) -> Instruction { return with_hint(Instruction{ mnemonic = .FST, operand_count = 1, ops = {op_st(dst), {}, {}, {}} }, 2147) } +emit_fst_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32) { append(instructions, inst_fst_m32(dst)) } +emit_fst_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64) { append(instructions, inst_fst_m64(dst)) } +emit_fst_st :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ST) { append(instructions, inst_fst_st(dst)) } +inst_fstp_m32 :: #force_inline proc "contextless" (dst: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .FSTP, operand_count = 1, ops = {op_mem(dst.mem, 4), {}, {}, {}} }, 2148) } +inst_fstp_m64 :: #force_inline proc "contextless" (dst: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .FSTP, operand_count = 1, ops = {op_mem(dst.mem, 8), {}, {}, {}} }, 2149) } +inst_fstp_m80 :: #force_inline proc "contextless" (dst: Mem80) -> Instruction { return with_hint(Instruction{ mnemonic = .FSTP, operand_count = 1, ops = {op_mem(dst.mem, 10), {}, {}, {}} }, 2150) } +inst_fstp_st :: #force_inline proc "contextless" (dst: ST) -> Instruction { return with_hint(Instruction{ mnemonic = .FSTP, operand_count = 1, ops = {op_st(dst), {}, {}, {}} }, 2151) } +emit_fstp_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32) { append(instructions, inst_fstp_m32(dst)) } +emit_fstp_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64) { append(instructions, inst_fstp_m64(dst)) } +emit_fstp_m80 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem80) { append(instructions, inst_fstp_m80(dst)) } +emit_fstp_st :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ST) { append(instructions, inst_fstp_st(dst)) } +inst_fist_m16 :: #force_inline proc "contextless" (dst: Mem16) -> Instruction { return with_hint(Instruction{ mnemonic = .FIST, operand_count = 1, ops = {op_mem(dst.mem, 2), {}, {}, {}} }, 2152) } +inst_fist_m32 :: #force_inline proc "contextless" (dst: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .FIST, operand_count = 1, ops = {op_mem(dst.mem, 4), {}, {}, {}} }, 2153) } +emit_fist_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16) { append(instructions, inst_fist_m16(dst)) } +emit_fist_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32) { append(instructions, inst_fist_m32(dst)) } +inst_fistp_m16 :: #force_inline proc "contextless" (dst: Mem16) -> Instruction { return with_hint(Instruction{ mnemonic = .FISTP, operand_count = 1, ops = {op_mem(dst.mem, 2), {}, {}, {}} }, 2154) } +inst_fistp_m32 :: #force_inline proc "contextless" (dst: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .FISTP, operand_count = 1, ops = {op_mem(dst.mem, 4), {}, {}, {}} }, 2155) } +inst_fistp_m64 :: #force_inline proc "contextless" (dst: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .FISTP, operand_count = 1, ops = {op_mem(dst.mem, 8), {}, {}, {}} }, 2156) } +emit_fistp_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16) { append(instructions, inst_fistp_m16(dst)) } +emit_fistp_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32) { append(instructions, inst_fistp_m32(dst)) } +emit_fistp_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64) { append(instructions, inst_fistp_m64(dst)) } +inst_fisttp_m16 :: #force_inline proc "contextless" (dst: Mem16) -> Instruction { return with_hint(Instruction{ mnemonic = .FISTTP, operand_count = 1, ops = {op_mem(dst.mem, 2), {}, {}, {}} }, 2157) } +inst_fisttp_m32 :: #force_inline proc "contextless" (dst: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .FISTTP, operand_count = 1, ops = {op_mem(dst.mem, 4), {}, {}, {}} }, 2158) } +inst_fisttp_m64 :: #force_inline proc "contextless" (dst: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .FISTTP, operand_count = 1, ops = {op_mem(dst.mem, 8), {}, {}, {}} }, 2159) } +emit_fisttp_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16) { append(instructions, inst_fisttp_m16(dst)) } +emit_fisttp_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32) { append(instructions, inst_fisttp_m32(dst)) } +emit_fisttp_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64) { append(instructions, inst_fisttp_m64(dst)) } +inst_fbstp_m80 :: #force_inline proc "contextless" (dst: Mem80) -> Instruction { return with_hint(Instruction{ mnemonic = .FBSTP, operand_count = 1, ops = {op_mem(dst.mem, 10), {}, {}, {}} }, 2160) } +emit_fbstp_m80 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem80) { append(instructions, inst_fbstp_m80(dst)) } +inst_fxch_st :: #force_inline proc "contextless" (dst: ST) -> Instruction { return with_hint(Instruction{ mnemonic = .FXCH, operand_count = 1, ops = {op_st(dst), {}, {}, {}} }, 2161) } +inst_fxch_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .FXCH, operand_count = 0, ops = {{}, {}, {}, {}} }, 2162) } +emit_fxch_st :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ST) { append(instructions, inst_fxch_st(dst)) } +emit_fxch_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_fxch_none()) } +inst_fcmovb_st :: #force_inline proc "contextless" (dst: ST) -> Instruction { return with_hint(Instruction{ mnemonic = .FCMOVB, operand_count = 1, ops = {op_st(dst), {}, {}, {}} }, 2163) } +emit_fcmovb_st :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ST) { append(instructions, inst_fcmovb_st(dst)) } +inst_fcmove_st :: #force_inline proc "contextless" (dst: ST) -> Instruction { return with_hint(Instruction{ mnemonic = .FCMOVE, operand_count = 1, ops = {op_st(dst), {}, {}, {}} }, 2164) } +emit_fcmove_st :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ST) { append(instructions, inst_fcmove_st(dst)) } +inst_fcmovbe_st :: #force_inline proc "contextless" (dst: ST) -> Instruction { return with_hint(Instruction{ mnemonic = .FCMOVBE, operand_count = 1, ops = {op_st(dst), {}, {}, {}} }, 2165) } +emit_fcmovbe_st :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ST) { append(instructions, inst_fcmovbe_st(dst)) } +inst_fcmovu_st :: #force_inline proc "contextless" (dst: ST) -> Instruction { return with_hint(Instruction{ mnemonic = .FCMOVU, operand_count = 1, ops = {op_st(dst), {}, {}, {}} }, 2166) } +emit_fcmovu_st :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ST) { append(instructions, inst_fcmovu_st(dst)) } +inst_fcmovnb_st :: #force_inline proc "contextless" (dst: ST) -> Instruction { return with_hint(Instruction{ mnemonic = .FCMOVNB, operand_count = 1, ops = {op_st(dst), {}, {}, {}} }, 2167) } +emit_fcmovnb_st :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ST) { append(instructions, inst_fcmovnb_st(dst)) } +inst_fcmovne_st :: #force_inline proc "contextless" (dst: ST) -> Instruction { return with_hint(Instruction{ mnemonic = .FCMOVNE, operand_count = 1, ops = {op_st(dst), {}, {}, {}} }, 2168) } +emit_fcmovne_st :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ST) { append(instructions, inst_fcmovne_st(dst)) } +inst_fcmovnbe_st :: #force_inline proc "contextless" (dst: ST) -> Instruction { return with_hint(Instruction{ mnemonic = .FCMOVNBE, operand_count = 1, ops = {op_st(dst), {}, {}, {}} }, 2169) } +emit_fcmovnbe_st :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ST) { append(instructions, inst_fcmovnbe_st(dst)) } +inst_fcmovnu_st :: #force_inline proc "contextless" (dst: ST) -> Instruction { return with_hint(Instruction{ mnemonic = .FCMOVNU, operand_count = 1, ops = {op_st(dst), {}, {}, {}} }, 2170) } +emit_fcmovnu_st :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ST) { append(instructions, inst_fcmovnu_st(dst)) } +inst_fcom_m32 :: #force_inline proc "contextless" (dst: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .FCOM, operand_count = 1, ops = {op_mem(dst.mem, 4), {}, {}, {}} }, 2171) } +inst_fcom_m64 :: #force_inline proc "contextless" (dst: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .FCOM, operand_count = 1, ops = {op_mem(dst.mem, 8), {}, {}, {}} }, 2172) } +inst_fcom_st :: #force_inline proc "contextless" (dst: ST) -> Instruction { return with_hint(Instruction{ mnemonic = .FCOM, operand_count = 1, ops = {op_st(dst), {}, {}, {}} }, 2173) } +inst_fcom_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .FCOM, operand_count = 0, ops = {{}, {}, {}, {}} }, 2174) } +emit_fcom_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32) { append(instructions, inst_fcom_m32(dst)) } +emit_fcom_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64) { append(instructions, inst_fcom_m64(dst)) } +emit_fcom_st :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ST) { append(instructions, inst_fcom_st(dst)) } +emit_fcom_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_fcom_none()) } +inst_fcomp_m32 :: #force_inline proc "contextless" (dst: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .FCOMP, operand_count = 1, ops = {op_mem(dst.mem, 4), {}, {}, {}} }, 2175) } +inst_fcomp_m64 :: #force_inline proc "contextless" (dst: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .FCOMP, operand_count = 1, ops = {op_mem(dst.mem, 8), {}, {}, {}} }, 2176) } +inst_fcomp_st :: #force_inline proc "contextless" (dst: ST) -> Instruction { return with_hint(Instruction{ mnemonic = .FCOMP, operand_count = 1, ops = {op_st(dst), {}, {}, {}} }, 2177) } +inst_fcomp_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .FCOMP, operand_count = 0, ops = {{}, {}, {}, {}} }, 2178) } +emit_fcomp_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32) { append(instructions, inst_fcomp_m32(dst)) } +emit_fcomp_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64) { append(instructions, inst_fcomp_m64(dst)) } +emit_fcomp_st :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ST) { append(instructions, inst_fcomp_st(dst)) } +emit_fcomp_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_fcomp_none()) } +inst_fcompp_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .FCOMPP, operand_count = 0, ops = {{}, {}, {}, {}} }, 2179) } +emit_fcompp_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_fcompp_none()) } +inst_ficom_m16 :: #force_inline proc "contextless" (dst: Mem16) -> Instruction { return with_hint(Instruction{ mnemonic = .FICOM, operand_count = 1, ops = {op_mem(dst.mem, 2), {}, {}, {}} }, 2180) } +inst_ficom_m32 :: #force_inline proc "contextless" (dst: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .FICOM, operand_count = 1, ops = {op_mem(dst.mem, 4), {}, {}, {}} }, 2181) } +emit_ficom_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16) { append(instructions, inst_ficom_m16(dst)) } +emit_ficom_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32) { append(instructions, inst_ficom_m32(dst)) } +inst_ficomp_m16 :: #force_inline proc "contextless" (dst: Mem16) -> Instruction { return with_hint(Instruction{ mnemonic = .FICOMP, operand_count = 1, ops = {op_mem(dst.mem, 2), {}, {}, {}} }, 2182) } +inst_ficomp_m32 :: #force_inline proc "contextless" (dst: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .FICOMP, operand_count = 1, ops = {op_mem(dst.mem, 4), {}, {}, {}} }, 2183) } +emit_ficomp_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16) { append(instructions, inst_ficomp_m16(dst)) } +emit_ficomp_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32) { append(instructions, inst_ficomp_m32(dst)) } +inst_fcomi_st :: #force_inline proc "contextless" (dst: ST) -> Instruction { return with_hint(Instruction{ mnemonic = .FCOMI, operand_count = 1, ops = {op_st(dst), {}, {}, {}} }, 2184) } +emit_fcomi_st :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ST) { append(instructions, inst_fcomi_st(dst)) } +inst_fcomip_st :: #force_inline proc "contextless" (dst: ST) -> Instruction { return with_hint(Instruction{ mnemonic = .FCOMIP, operand_count = 1, ops = {op_st(dst), {}, {}, {}} }, 2185) } +emit_fcomip_st :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ST) { append(instructions, inst_fcomip_st(dst)) } +inst_fucomi_st :: #force_inline proc "contextless" (dst: ST) -> Instruction { return with_hint(Instruction{ mnemonic = .FUCOMI, operand_count = 1, ops = {op_st(dst), {}, {}, {}} }, 2186) } +emit_fucomi_st :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ST) { append(instructions, inst_fucomi_st(dst)) } +inst_fucomip_st :: #force_inline proc "contextless" (dst: ST) -> Instruction { return with_hint(Instruction{ mnemonic = .FUCOMIP, operand_count = 1, ops = {op_st(dst), {}, {}, {}} }, 2187) } +emit_fucomip_st :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ST) { append(instructions, inst_fucomip_st(dst)) } +inst_fucom_st :: #force_inline proc "contextless" (dst: ST) -> Instruction { return with_hint(Instruction{ mnemonic = .FUCOM, operand_count = 1, ops = {op_st(dst), {}, {}, {}} }, 2188) } +inst_fucom_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .FUCOM, operand_count = 0, ops = {{}, {}, {}, {}} }, 2189) } +emit_fucom_st :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ST) { append(instructions, inst_fucom_st(dst)) } +emit_fucom_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_fucom_none()) } +inst_fucomp_st :: #force_inline proc "contextless" (dst: ST) -> Instruction { return with_hint(Instruction{ mnemonic = .FUCOMP, operand_count = 1, ops = {op_st(dst), {}, {}, {}} }, 2190) } +inst_fucomp_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .FUCOMP, operand_count = 0, ops = {{}, {}, {}, {}} }, 2191) } +emit_fucomp_st :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ST) { append(instructions, inst_fucomp_st(dst)) } +emit_fucomp_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_fucomp_none()) } +inst_fucompp_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .FUCOMPP, operand_count = 0, ops = {{}, {}, {}, {}} }, 2192) } +emit_fucompp_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_fucompp_none()) } +inst_ftst_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .FTST, operand_count = 0, ops = {{}, {}, {}, {}} }, 2193) } +emit_ftst_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_ftst_none()) } +inst_fldz_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .FLDZ, operand_count = 0, ops = {{}, {}, {}, {}} }, 2194) } +emit_fldz_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_fldz_none()) } +inst_fld1_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .FLD1, operand_count = 0, ops = {{}, {}, {}, {}} }, 2195) } +emit_fld1_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_fld1_none()) } +inst_fldpi_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .FLDPI, operand_count = 0, ops = {{}, {}, {}, {}} }, 2196) } +emit_fldpi_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_fldpi_none()) } +inst_fldl2t_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .FLDL2T, operand_count = 0, ops = {{}, {}, {}, {}} }, 2197) } +emit_fldl2t_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_fldl2t_none()) } +inst_fldl2e_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .FLDL2E, operand_count = 0, ops = {{}, {}, {}, {}} }, 2198) } +emit_fldl2e_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_fldl2e_none()) } +inst_fldlg2_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .FLDLG2, operand_count = 0, ops = {{}, {}, {}, {}} }, 2199) } +emit_fldlg2_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_fldlg2_none()) } +inst_fldln2_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .FLDLN2, operand_count = 0, ops = {{}, {}, {}, {}} }, 2200) } +emit_fldln2_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_fldln2_none()) } +inst_fsin_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .FSIN, operand_count = 0, ops = {{}, {}, {}, {}} }, 2201) } +emit_fsin_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_fsin_none()) } +inst_fcos_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .FCOS, operand_count = 0, ops = {{}, {}, {}, {}} }, 2202) } +emit_fcos_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_fcos_none()) } +inst_fsincos_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .FSINCOS, operand_count = 0, ops = {{}, {}, {}, {}} }, 2203) } +emit_fsincos_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_fsincos_none()) } +inst_fptan_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .FPTAN, operand_count = 0, ops = {{}, {}, {}, {}} }, 2204) } +emit_fptan_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_fptan_none()) } +inst_fpatan_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .FPATAN, operand_count = 0, ops = {{}, {}, {}, {}} }, 2205) } +emit_fpatan_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_fpatan_none()) } +inst_f2xm1_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .F2XM1, operand_count = 0, ops = {{}, {}, {}, {}} }, 2206) } +emit_f2xm1_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_f2xm1_none()) } +inst_fyl2x_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .FYL2X, operand_count = 0, ops = {{}, {}, {}, {}} }, 2207) } +emit_fyl2x_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_fyl2x_none()) } +inst_fyl2xp1_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .FYL2XP1, operand_count = 0, ops = {{}, {}, {}, {}} }, 2208) } +emit_fyl2xp1_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_fyl2xp1_none()) } +inst_finit_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .FINIT, operand_count = 0, ops = {{}, {}, {}, {}} }, 2209) } +emit_finit_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_finit_none()) } +inst_fninit_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .FNINIT, operand_count = 0, ops = {{}, {}, {}, {}} }, 2210) } +emit_fninit_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_fninit_none()) } +inst_fincstp_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .FINCSTP, operand_count = 0, ops = {{}, {}, {}, {}} }, 2211) } +emit_fincstp_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_fincstp_none()) } +inst_fdecstp_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .FDECSTP, operand_count = 0, ops = {{}, {}, {}, {}} }, 2212) } +emit_fdecstp_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_fdecstp_none()) } +inst_ffree_st :: #force_inline proc "contextless" (dst: ST) -> Instruction { return with_hint(Instruction{ mnemonic = .FFREE, operand_count = 1, ops = {op_st(dst), {}, {}, {}} }, 2213) } +emit_ffree_st :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ST) { append(instructions, inst_ffree_st(dst)) } +inst_ffreep_st :: #force_inline proc "contextless" (dst: ST) -> Instruction { return with_hint(Instruction{ mnemonic = .FFREEP, operand_count = 1, ops = {op_st(dst), {}, {}, {}} }, 2214) } +emit_ffreep_st :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ST) { append(instructions, inst_ffreep_st(dst)) } +inst_fnop_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .FNOP, operand_count = 0, ops = {{}, {}, {}, {}} }, 2215) } +emit_fnop_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_fnop_none()) } +inst_fwait_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .FWAIT, operand_count = 0, ops = {{}, {}, {}, {}} }, 2216) } +emit_fwait_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_fwait_none()) } +inst_fclex_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .FCLEX, operand_count = 0, ops = {{}, {}, {}, {}} }, 2217) } +emit_fclex_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_fclex_none()) } +inst_fnclex_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .FNCLEX, operand_count = 0, ops = {{}, {}, {}, {}} }, 2218) } +emit_fnclex_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_fnclex_none()) } +inst_fstcw_m16 :: #force_inline proc "contextless" (dst: Mem16) -> Instruction { return with_hint(Instruction{ mnemonic = .FSTCW, operand_count = 1, ops = {op_mem(dst.mem, 2), {}, {}, {}} }, 2219) } +emit_fstcw_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16) { append(instructions, inst_fstcw_m16(dst)) } +inst_fnstcw_m16 :: #force_inline proc "contextless" (dst: Mem16) -> Instruction { return with_hint(Instruction{ mnemonic = .FNSTCW, operand_count = 1, ops = {op_mem(dst.mem, 2), {}, {}, {}} }, 2220) } +emit_fnstcw_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16) { append(instructions, inst_fnstcw_m16(dst)) } +inst_fldcw_m16 :: #force_inline proc "contextless" (dst: Mem16) -> Instruction { return with_hint(Instruction{ mnemonic = .FLDCW, operand_count = 1, ops = {op_mem(dst.mem, 2), {}, {}, {}} }, 2221) } +emit_fldcw_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16) { append(instructions, inst_fldcw_m16(dst)) } +inst_fstenv_m :: #force_inline proc "contextless" (dst: Memory) -> Instruction { return with_hint(Instruction{ mnemonic = .FSTENV, operand_count = 1, ops = {op_mem(dst, 0), {}, {}, {}} }, 2222) } +emit_fstenv_m :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Memory) { append(instructions, inst_fstenv_m(dst)) } +inst_fnstenv_m :: #force_inline proc "contextless" (dst: Memory) -> Instruction { return with_hint(Instruction{ mnemonic = .FNSTENV, operand_count = 1, ops = {op_mem(dst, 0), {}, {}, {}} }, 2223) } +emit_fnstenv_m :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Memory) { append(instructions, inst_fnstenv_m(dst)) } +inst_fldenv_m :: #force_inline proc "contextless" (dst: Memory) -> Instruction { return with_hint(Instruction{ mnemonic = .FLDENV, operand_count = 1, ops = {op_mem(dst, 0), {}, {}, {}} }, 2224) } +emit_fldenv_m :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Memory) { append(instructions, inst_fldenv_m(dst)) } +inst_fsave_m :: #force_inline proc "contextless" (dst: Memory) -> Instruction { return with_hint(Instruction{ mnemonic = .FSAVE, operand_count = 1, ops = {op_mem(dst, 0), {}, {}, {}} }, 2225) } +emit_fsave_m :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Memory) { append(instructions, inst_fsave_m(dst)) } +inst_fnsave_m :: #force_inline proc "contextless" (dst: Memory) -> Instruction { return with_hint(Instruction{ mnemonic = .FNSAVE, operand_count = 1, ops = {op_mem(dst, 0), {}, {}, {}} }, 2226) } +emit_fnsave_m :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Memory) { append(instructions, inst_fnsave_m(dst)) } +inst_frstor_m :: #force_inline proc "contextless" (dst: Memory) -> Instruction { return with_hint(Instruction{ mnemonic = .FRSTOR, operand_count = 1, ops = {op_mem(dst, 0), {}, {}, {}} }, 2227) } +emit_frstor_m :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Memory) { append(instructions, inst_frstor_m(dst)) } +inst_fstsw_m16 :: #force_inline proc "contextless" (dst: Mem16) -> Instruction { return with_hint(Instruction{ mnemonic = .FSTSW, operand_count = 1, ops = {op_mem(dst.mem, 2), {}, {}, {}} }, 2228) } +emit_fstsw_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16) { append(instructions, inst_fstsw_m16(dst)) } +inst_fnstsw_m16 :: #force_inline proc "contextless" (dst: Mem16) -> Instruction { return with_hint(Instruction{ mnemonic = .FNSTSW, operand_count = 1, ops = {op_mem(dst.mem, 2), {}, {}, {}} }, 2230) } +emit_fnstsw_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16) { append(instructions, inst_fnstsw_m16(dst)) } +inst_fxsave_m512 :: #force_inline proc "contextless" (dst: Mem512) -> Instruction { return with_hint(Instruction{ mnemonic = .FXSAVE, operand_count = 1, ops = {op_mem(dst.mem, 64), {}, {}, {}} }, 2232) } +emit_fxsave_m512 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem512) { append(instructions, inst_fxsave_m512(dst)) } +inst_fxsave64_m512 :: #force_inline proc "contextless" (dst: Mem512) -> Instruction { return with_hint(Instruction{ mnemonic = .FXSAVE64, operand_count = 1, ops = {op_mem(dst.mem, 64), {}, {}, {}} }, 2233) } +emit_fxsave64_m512 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem512) { append(instructions, inst_fxsave64_m512(dst)) } +inst_fxrstor_m512 :: #force_inline proc "contextless" (dst: Mem512) -> Instruction { return with_hint(Instruction{ mnemonic = .FXRSTOR, operand_count = 1, ops = {op_mem(dst.mem, 64), {}, {}, {}} }, 2234) } +emit_fxrstor_m512 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem512) { append(instructions, inst_fxrstor_m512(dst)) } +inst_fxrstor64_m512 :: #force_inline proc "contextless" (dst: Mem512) -> Instruction { return with_hint(Instruction{ mnemonic = .FXRSTOR64, operand_count = 1, ops = {op_mem(dst.mem, 64), {}, {}, {}} }, 2235) } +emit_fxrstor64_m512 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem512) { append(instructions, inst_fxrstor64_m512(dst)) } +inst_lgdt_m :: #force_inline proc "contextless" (dst: Memory) -> Instruction { return with_hint(Instruction{ mnemonic = .LGDT, operand_count = 1, ops = {op_mem(dst, 0), {}, {}, {}} }, 2236) } +emit_lgdt_m :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Memory) { append(instructions, inst_lgdt_m(dst)) } +inst_sgdt_m :: #force_inline proc "contextless" (dst: Memory) -> Instruction { return with_hint(Instruction{ mnemonic = .SGDT, operand_count = 1, ops = {op_mem(dst, 0), {}, {}, {}} }, 2238) } +emit_sgdt_m :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Memory) { append(instructions, inst_sgdt_m(dst)) } +inst_lidt_m :: #force_inline proc "contextless" (dst: Memory) -> Instruction { return with_hint(Instruction{ mnemonic = .LIDT, operand_count = 1, ops = {op_mem(dst, 0), {}, {}, {}} }, 2240) } +emit_lidt_m :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Memory) { append(instructions, inst_lidt_m(dst)) } +inst_sidt_m :: #force_inline proc "contextless" (dst: Memory) -> Instruction { return with_hint(Instruction{ mnemonic = .SIDT, operand_count = 1, ops = {op_mem(dst, 0), {}, {}, {}} }, 2242) } +emit_sidt_m :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Memory) { append(instructions, inst_sidt_m(dst)) } +inst_lldt_r16 :: #force_inline proc "contextless" (dst: GPR16) -> Instruction { return with_hint(Instruction{ mnemonic = .LLDT, operand_count = 1, ops = {op_gpr16(dst), {}, {}, {}} }, 2244) } +inst_lldt_m16 :: #force_inline proc "contextless" (dst: Mem16) -> Instruction { return with_hint(Instruction{ mnemonic = .LLDT, operand_count = 1, ops = {op_mem(dst.mem, 2), {}, {}, {}} }, 2244) } +emit_lldt_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16) { append(instructions, inst_lldt_r16(dst)) } +emit_lldt_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16) { append(instructions, inst_lldt_m16(dst)) } +inst_sldt_r16 :: #force_inline proc "contextless" (dst: GPR16) -> Instruction { return with_hint(Instruction{ mnemonic = .SLDT, operand_count = 1, ops = {op_gpr16(dst), {}, {}, {}} }, 2245) } +inst_sldt_m16 :: #force_inline proc "contextless" (dst: Mem16) -> Instruction { return with_hint(Instruction{ mnemonic = .SLDT, operand_count = 1, ops = {op_mem(dst.mem, 2), {}, {}, {}} }, 2245) } +inst_sldt_r32 :: #force_inline proc "contextless" (dst: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .SLDT, operand_count = 1, ops = {op_gpr32(dst), {}, {}, {}} }, 2246) } +inst_sldt_r64 :: #force_inline proc "contextless" (dst: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .SLDT, operand_count = 1, ops = {op_gpr64(dst), {}, {}, {}} }, 2247) } +emit_sldt_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16) { append(instructions, inst_sldt_r16(dst)) } +emit_sldt_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16) { append(instructions, inst_sldt_m16(dst)) } +emit_sldt_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32) { append(instructions, inst_sldt_r32(dst)) } +emit_sldt_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64) { append(instructions, inst_sldt_r64(dst)) } +inst_ltr_r16 :: #force_inline proc "contextless" (dst: GPR16) -> Instruction { return with_hint(Instruction{ mnemonic = .LTR, operand_count = 1, ops = {op_gpr16(dst), {}, {}, {}} }, 2248) } +inst_ltr_m16 :: #force_inline proc "contextless" (dst: Mem16) -> Instruction { return with_hint(Instruction{ mnemonic = .LTR, operand_count = 1, ops = {op_mem(dst.mem, 2), {}, {}, {}} }, 2248) } +emit_ltr_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16) { append(instructions, inst_ltr_r16(dst)) } +emit_ltr_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16) { append(instructions, inst_ltr_m16(dst)) } +inst_str_r16 :: #force_inline proc "contextless" (dst: GPR16) -> Instruction { return with_hint(Instruction{ mnemonic = .STR, operand_count = 1, ops = {op_gpr16(dst), {}, {}, {}} }, 2249) } +inst_str_m16 :: #force_inline proc "contextless" (dst: Mem16) -> Instruction { return with_hint(Instruction{ mnemonic = .STR, operand_count = 1, ops = {op_mem(dst.mem, 2), {}, {}, {}} }, 2249) } +inst_str_r32 :: #force_inline proc "contextless" (dst: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .STR, operand_count = 1, ops = {op_gpr32(dst), {}, {}, {}} }, 2250) } +inst_str_r64 :: #force_inline proc "contextless" (dst: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .STR, operand_count = 1, ops = {op_gpr64(dst), {}, {}, {}} }, 2251) } +emit_str_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16) { append(instructions, inst_str_r16(dst)) } +emit_str_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16) { append(instructions, inst_str_m16(dst)) } +emit_str_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32) { append(instructions, inst_str_r32(dst)) } +emit_str_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64) { append(instructions, inst_str_r64(dst)) } +inst_lmsw_r16 :: #force_inline proc "contextless" (dst: GPR16) -> Instruction { return with_hint(Instruction{ mnemonic = .LMSW, operand_count = 1, ops = {op_gpr16(dst), {}, {}, {}} }, 2252) } +inst_lmsw_m16 :: #force_inline proc "contextless" (dst: Mem16) -> Instruction { return with_hint(Instruction{ mnemonic = .LMSW, operand_count = 1, ops = {op_mem(dst.mem, 2), {}, {}, {}} }, 2252) } +emit_lmsw_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16) { append(instructions, inst_lmsw_r16(dst)) } +emit_lmsw_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16) { append(instructions, inst_lmsw_m16(dst)) } +inst_smsw_r16 :: #force_inline proc "contextless" (dst: GPR16) -> Instruction { return with_hint(Instruction{ mnemonic = .SMSW, operand_count = 1, ops = {op_gpr16(dst), {}, {}, {}} }, 2253) } +inst_smsw_m16 :: #force_inline proc "contextless" (dst: Mem16) -> Instruction { return with_hint(Instruction{ mnemonic = .SMSW, operand_count = 1, ops = {op_mem(dst.mem, 2), {}, {}, {}} }, 2253) } +inst_smsw_r32 :: #force_inline proc "contextless" (dst: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .SMSW, operand_count = 1, ops = {op_gpr32(dst), {}, {}, {}} }, 2254) } +inst_smsw_r64 :: #force_inline proc "contextless" (dst: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .SMSW, operand_count = 1, ops = {op_gpr64(dst), {}, {}, {}} }, 2255) } +emit_smsw_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16) { append(instructions, inst_smsw_r16(dst)) } +emit_smsw_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16) { append(instructions, inst_smsw_m16(dst)) } +emit_smsw_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32) { append(instructions, inst_smsw_r32(dst)) } +emit_smsw_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64) { append(instructions, inst_smsw_r64(dst)) } +inst_clts_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .CLTS, operand_count = 0, ops = {{}, {}, {}, {}} }, 2256) } +emit_clts_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_clts_none()) } +inst_arpl_r16_r16 :: #force_inline proc "contextless" (dst: GPR16, src: GPR16) -> Instruction { return with_hint(Instruction{ mnemonic = .ARPL, operand_count = 2, ops = {op_gpr16(dst), op_gpr16(src), {}, {}} }, 2257) } +inst_arpl_m16_r16 :: #force_inline proc "contextless" (dst: Mem16, src: GPR16) -> Instruction { return with_hint(Instruction{ mnemonic = .ARPL, operand_count = 2, ops = {op_mem(dst.mem, 2), op_gpr16(src), {}, {}} }, 2257) } +emit_arpl_r16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: GPR16) { append(instructions, inst_arpl_r16_r16(dst, src)) } +emit_arpl_m16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16, src: GPR16) { append(instructions, inst_arpl_m16_r16(dst, src)) } +inst_lar_r16_r16 :: #force_inline proc "contextless" (dst: GPR16, src: GPR16) -> Instruction { return with_hint(Instruction{ mnemonic = .LAR, operand_count = 2, ops = {op_gpr16(dst), op_gpr16(src), {}, {}} }, 2258) } +inst_lar_r16_m16 :: #force_inline proc "contextless" (dst: GPR16, src: Mem16) -> Instruction { return with_hint(Instruction{ mnemonic = .LAR, operand_count = 2, ops = {op_gpr16(dst), op_mem(src.mem, 2), {}, {}} }, 2258) } +inst_lar_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .LAR, operand_count = 2, ops = {op_gpr32(dst), op_gpr32(src), {}, {}} }, 2259) } +inst_lar_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .LAR, operand_count = 2, ops = {op_gpr32(dst), op_mem(src.mem, 4), {}, {}} }, 2259) } +inst_lar_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .LAR, operand_count = 2, ops = {op_gpr64(dst), op_gpr64(src), {}, {}} }, 2260) } +inst_lar_r64_m64 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .LAR, operand_count = 2, ops = {op_gpr64(dst), op_mem(src.mem, 8), {}, {}} }, 2260) } +emit_lar_r16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: GPR16) { append(instructions, inst_lar_r16_r16(dst, src)) } +emit_lar_r16_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: Mem16) { append(instructions, inst_lar_r16_m16(dst, src)) } +emit_lar_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { append(instructions, inst_lar_r32_r32(dst, src)) } +emit_lar_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32) { append(instructions, inst_lar_r32_m32(dst, src)) } +emit_lar_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { append(instructions, inst_lar_r64_r64(dst, src)) } +emit_lar_r64_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem64) { append(instructions, inst_lar_r64_m64(dst, src)) } +inst_lsl_r16_r16 :: #force_inline proc "contextless" (dst: GPR16, src: GPR16) -> Instruction { return with_hint(Instruction{ mnemonic = .LSL, operand_count = 2, ops = {op_gpr16(dst), op_gpr16(src), {}, {}} }, 2261) } +inst_lsl_r16_m16 :: #force_inline proc "contextless" (dst: GPR16, src: Mem16) -> Instruction { return with_hint(Instruction{ mnemonic = .LSL, operand_count = 2, ops = {op_gpr16(dst), op_mem(src.mem, 2), {}, {}} }, 2261) } +inst_lsl_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .LSL, operand_count = 2, ops = {op_gpr32(dst), op_gpr32(src), {}, {}} }, 2262) } +inst_lsl_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .LSL, operand_count = 2, ops = {op_gpr32(dst), op_mem(src.mem, 4), {}, {}} }, 2262) } +inst_lsl_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .LSL, operand_count = 2, ops = {op_gpr64(dst), op_gpr64(src), {}, {}} }, 2263) } +inst_lsl_r64_m64 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .LSL, operand_count = 2, ops = {op_gpr64(dst), op_mem(src.mem, 8), {}, {}} }, 2263) } +emit_lsl_r16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: GPR16) { append(instructions, inst_lsl_r16_r16(dst, src)) } +emit_lsl_r16_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: Mem16) { append(instructions, inst_lsl_r16_m16(dst, src)) } +emit_lsl_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { append(instructions, inst_lsl_r32_r32(dst, src)) } +emit_lsl_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32) { append(instructions, inst_lsl_r32_m32(dst, src)) } +emit_lsl_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { append(instructions, inst_lsl_r64_r64(dst, src)) } +emit_lsl_r64_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem64) { append(instructions, inst_lsl_r64_m64(dst, src)) } +inst_verr_r16 :: #force_inline proc "contextless" (dst: GPR16) -> Instruction { return with_hint(Instruction{ mnemonic = .VERR, operand_count = 1, ops = {op_gpr16(dst), {}, {}, {}} }, 2264) } +inst_verr_m16 :: #force_inline proc "contextless" (dst: Mem16) -> Instruction { return with_hint(Instruction{ mnemonic = .VERR, operand_count = 1, ops = {op_mem(dst.mem, 2), {}, {}, {}} }, 2264) } +emit_verr_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16) { append(instructions, inst_verr_r16(dst)) } +emit_verr_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16) { append(instructions, inst_verr_m16(dst)) } +inst_verw_r16 :: #force_inline proc "contextless" (dst: GPR16) -> Instruction { return with_hint(Instruction{ mnemonic = .VERW, operand_count = 1, ops = {op_gpr16(dst), {}, {}, {}} }, 2265) } +inst_verw_m16 :: #force_inline proc "contextless" (dst: Mem16) -> Instruction { return with_hint(Instruction{ mnemonic = .VERW, operand_count = 1, ops = {op_mem(dst.mem, 2), {}, {}, {}} }, 2265) } +emit_verw_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16) { append(instructions, inst_verw_r16(dst)) } +emit_verw_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16) { append(instructions, inst_verw_m16(dst)) } +inst_invd_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .INVD, operand_count = 0, ops = {{}, {}, {}, {}} }, 2266) } +emit_invd_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_invd_none()) } +inst_wbinvd_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .WBINVD, operand_count = 0, ops = {{}, {}, {}, {}} }, 2267) } +emit_wbinvd_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_wbinvd_none()) } +inst_invlpg_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return with_hint(Instruction{ mnemonic = .INVLPG, operand_count = 1, ops = {op_mem(dst.mem, 1), {}, {}, {}} }, 2268) } +emit_invlpg_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { append(instructions, inst_invlpg_m8(dst)) } +inst_invpcid_r32_m128 :: #force_inline proc "contextless" (dst: GPR32, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .INVPCID, operand_count = 2, ops = {op_gpr32(dst), op_mem(src.mem, 16), {}, {}} }, 2269) } +inst_invpcid_r64_m128 :: #force_inline proc "contextless" (dst: GPR64, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .INVPCID, operand_count = 2, ops = {op_gpr64(dst), op_mem(src.mem, 16), {}, {}} }, 2270) } +emit_invpcid_r32_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem128) { append(instructions, inst_invpcid_r32_m128(dst, src)) } +emit_invpcid_r64_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem128) { append(instructions, inst_invpcid_r64_m128(dst, src)) } +inst_rsm_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .RSM, operand_count = 0, ops = {{}, {}, {}, {}} }, 2271) } +emit_rsm_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_rsm_none()) } +inst_rdmsr_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .RDMSR, operand_count = 0, ops = {{}, {}, {}, {}} }, 2272) } +emit_rdmsr_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_rdmsr_none()) } +inst_wrmsr_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .WRMSR, operand_count = 0, ops = {{}, {}, {}, {}} }, 2273) } +emit_wrmsr_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_wrmsr_none()) } +inst_vmcall_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .VMCALL, operand_count = 0, ops = {{}, {}, {}, {}} }, 2274) } +emit_vmcall_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_vmcall_none()) } +inst_vmlaunch_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .VMLAUNCH, operand_count = 0, ops = {{}, {}, {}, {}} }, 2275) } +emit_vmlaunch_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_vmlaunch_none()) } +inst_vmresume_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .VMRESUME, operand_count = 0, ops = {{}, {}, {}, {}} }, 2276) } +emit_vmresume_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_vmresume_none()) } +inst_vmxoff_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .VMXOFF, operand_count = 0, ops = {{}, {}, {}, {}} }, 2277) } +emit_vmxoff_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_vmxoff_none()) } +inst_vmxon_m64 :: #force_inline proc "contextless" (dst: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .VMXON, operand_count = 1, ops = {op_mem(dst.mem, 8), {}, {}, {}} }, 2278) } +emit_vmxon_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64) { append(instructions, inst_vmxon_m64(dst)) } +inst_vmclear_m64 :: #force_inline proc "contextless" (dst: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .VMCLEAR, operand_count = 1, ops = {op_mem(dst.mem, 8), {}, {}, {}} }, 2279) } +emit_vmclear_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64) { append(instructions, inst_vmclear_m64(dst)) } +inst_vmptrld_m64 :: #force_inline proc "contextless" (dst: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .VMPTRLD, operand_count = 1, ops = {op_mem(dst.mem, 8), {}, {}, {}} }, 2280) } +emit_vmptrld_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64) { append(instructions, inst_vmptrld_m64(dst)) } +inst_vmptrst_m64 :: #force_inline proc "contextless" (dst: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .VMPTRST, operand_count = 1, ops = {op_mem(dst.mem, 8), {}, {}, {}} }, 2281) } +emit_vmptrst_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64) { append(instructions, inst_vmptrst_m64(dst)) } +inst_vmread_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .VMREAD, operand_count = 2, ops = {op_gpr64(dst), op_gpr64(src), {}, {}} }, 2282) } +inst_vmread_m64_r64 :: #force_inline proc "contextless" (dst: Mem64, src: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .VMREAD, operand_count = 2, ops = {op_mem(dst.mem, 8), op_gpr64(src), {}, {}} }, 2282) } +emit_vmread_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { append(instructions, inst_vmread_r64_r64(dst, src)) } +emit_vmread_m64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, src: GPR64) { append(instructions, inst_vmread_m64_r64(dst, src)) } +inst_vmwrite_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .VMWRITE, operand_count = 2, ops = {op_gpr64(dst), op_gpr64(src), {}, {}} }, 2283) } +inst_vmwrite_r64_m64 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .VMWRITE, operand_count = 2, ops = {op_gpr64(dst), op_mem(src.mem, 8), {}, {}} }, 2283) } +emit_vmwrite_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { append(instructions, inst_vmwrite_r64_r64(dst, src)) } +emit_vmwrite_r64_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem64) { append(instructions, inst_vmwrite_r64_m64(dst, src)) } +inst_vmfunc_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .VMFUNC, operand_count = 0, ops = {{}, {}, {}, {}} }, 2284) } +emit_vmfunc_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_vmfunc_none()) } +inst_invept_r64_m128 :: #force_inline proc "contextless" (dst: GPR64, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .INVEPT, operand_count = 2, ops = {op_gpr64(dst), op_mem(src.mem, 16), {}, {}} }, 2285) } +emit_invept_r64_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem128) { append(instructions, inst_invept_r64_m128(dst, src)) } +inst_invvpid_r64_m128 :: #force_inline proc "contextless" (dst: GPR64, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .INVVPID, operand_count = 2, ops = {op_gpr64(dst), op_mem(src.mem, 16), {}, {}} }, 2286) } +emit_invvpid_r64_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem128) { append(instructions, inst_invvpid_r64_m128(dst, src)) } +inst_encls_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .ENCLS, operand_count = 0, ops = {{}, {}, {}, {}} }, 2287) } +emit_encls_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_encls_none()) } +inst_enclu_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .ENCLU, operand_count = 0, ops = {{}, {}, {}, {}} }, 2288) } +emit_enclu_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_enclu_none()) } +inst_enclv_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .ENCLV, operand_count = 0, ops = {{}, {}, {}, {}} }, 2289) } +emit_enclv_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_enclv_none()) } +inst_rdpkru_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .RDPKRU, operand_count = 0, ops = {{}, {}, {}, {}} }, 2290) } +emit_rdpkru_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_rdpkru_none()) } +inst_wrpkru_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .WRPKRU, operand_count = 0, ops = {{}, {}, {}, {}} }, 2291) } +emit_wrpkru_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_wrpkru_none()) } +inst_incsspd_r32 :: #force_inline proc "contextless" (dst: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .INCSSPD, operand_count = 1, ops = {op_gpr32(dst), {}, {}, {}} }, 2292) } +emit_incsspd_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32) { append(instructions, inst_incsspd_r32(dst)) } +inst_incsspq_r64 :: #force_inline proc "contextless" (dst: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .INCSSPQ, operand_count = 1, ops = {op_gpr64(dst), {}, {}, {}} }, 2293) } +emit_incsspq_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64) { append(instructions, inst_incsspq_r64(dst)) } +inst_rdsspd_r32 :: #force_inline proc "contextless" (dst: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .RDSSPD, operand_count = 1, ops = {op_gpr32(dst), {}, {}, {}} }, 2294) } +emit_rdsspd_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32) { append(instructions, inst_rdsspd_r32(dst)) } +inst_rdsspq_r64 :: #force_inline proc "contextless" (dst: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .RDSSPQ, operand_count = 1, ops = {op_gpr64(dst), {}, {}, {}} }, 2295) } +emit_rdsspq_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64) { append(instructions, inst_rdsspq_r64(dst)) } +inst_saveprevssp_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .SAVEPREVSSP, operand_count = 0, ops = {{}, {}, {}, {}} }, 2296) } +emit_saveprevssp_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_saveprevssp_none()) } +inst_rstorssp_m64 :: #force_inline proc "contextless" (dst: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .RSTORSSP, operand_count = 1, ops = {op_mem(dst.mem, 8), {}, {}, {}} }, 2297) } +emit_rstorssp_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64) { append(instructions, inst_rstorssp_m64(dst)) } +inst_wrssd_m32_r32 :: #force_inline proc "contextless" (dst: Mem32, src: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .WRSSD, operand_count = 2, ops = {op_mem(dst.mem, 4), op_gpr32(src), {}, {}} }, 2298) } +emit_wrssd_m32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, src: GPR32) { append(instructions, inst_wrssd_m32_r32(dst, src)) } +inst_wrssq_m64_r64 :: #force_inline proc "contextless" (dst: Mem64, src: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .WRSSQ, operand_count = 2, ops = {op_mem(dst.mem, 8), op_gpr64(src), {}, {}} }, 2299) } +emit_wrssq_m64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, src: GPR64) { append(instructions, inst_wrssq_m64_r64(dst, src)) } +inst_wrussd_m32_r32 :: #force_inline proc "contextless" (dst: Mem32, src: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .WRUSSD, operand_count = 2, ops = {op_mem(dst.mem, 4), op_gpr32(src), {}, {}} }, 2300) } +emit_wrussd_m32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, src: GPR32) { append(instructions, inst_wrussd_m32_r32(dst, src)) } +inst_wrussq_m64_r64 :: #force_inline proc "contextless" (dst: Mem64, src: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .WRUSSQ, operand_count = 2, ops = {op_mem(dst.mem, 8), op_gpr64(src), {}, {}} }, 2301) } +emit_wrussq_m64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, src: GPR64) { append(instructions, inst_wrussq_m64_r64(dst, src)) } +inst_setssbsy_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .SETSSBSY, operand_count = 0, ops = {{}, {}, {}, {}} }, 2302) } +emit_setssbsy_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_setssbsy_none()) } +inst_clrssbsy_m64 :: #force_inline proc "contextless" (dst: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .CLRSSBSY, operand_count = 1, ops = {op_mem(dst.mem, 8), {}, {}, {}} }, 2303) } +emit_clrssbsy_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64) { append(instructions, inst_clrssbsy_m64(dst)) } +inst_endbr64_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .ENDBR64, operand_count = 0, ops = {{}, {}, {}, {}} }, 2304) } +emit_endbr64_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_endbr64_none()) } +inst_endbr32_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .ENDBR32, operand_count = 0, ops = {{}, {}, {}, {}} }, 2305) } +emit_endbr32_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_endbr32_none()) } +inst_xsave_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return with_hint(Instruction{ mnemonic = .XSAVE, operand_count = 1, ops = {op_mem(dst.mem, 1), {}, {}, {}} }, 2306) } +emit_xsave_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { append(instructions, inst_xsave_m8(dst)) } +inst_xsave64_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return with_hint(Instruction{ mnemonic = .XSAVE64, operand_count = 1, ops = {op_mem(dst.mem, 1), {}, {}, {}} }, 2307) } +emit_xsave64_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { append(instructions, inst_xsave64_m8(dst)) } +inst_xrstor_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return with_hint(Instruction{ mnemonic = .XRSTOR, operand_count = 1, ops = {op_mem(dst.mem, 1), {}, {}, {}} }, 2308) } +emit_xrstor_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { append(instructions, inst_xrstor_m8(dst)) } +inst_xrstor64_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return with_hint(Instruction{ mnemonic = .XRSTOR64, operand_count = 1, ops = {op_mem(dst.mem, 1), {}, {}, {}} }, 2309) } +emit_xrstor64_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { append(instructions, inst_xrstor64_m8(dst)) } +inst_xsaveopt_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return with_hint(Instruction{ mnemonic = .XSAVEOPT, operand_count = 1, ops = {op_mem(dst.mem, 1), {}, {}, {}} }, 2310) } +emit_xsaveopt_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { append(instructions, inst_xsaveopt_m8(dst)) } +inst_xsaveopt64_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return with_hint(Instruction{ mnemonic = .XSAVEOPT64, operand_count = 1, ops = {op_mem(dst.mem, 1), {}, {}, {}} }, 2311) } +emit_xsaveopt64_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { append(instructions, inst_xsaveopt64_m8(dst)) } +inst_xsavec_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return with_hint(Instruction{ mnemonic = .XSAVEC, operand_count = 1, ops = {op_mem(dst.mem, 1), {}, {}, {}} }, 2312) } +emit_xsavec_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { append(instructions, inst_xsavec_m8(dst)) } +inst_xsavec64_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return with_hint(Instruction{ mnemonic = .XSAVEC64, operand_count = 1, ops = {op_mem(dst.mem, 1), {}, {}, {}} }, 2313) } +emit_xsavec64_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { append(instructions, inst_xsavec64_m8(dst)) } +inst_xsaves_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return with_hint(Instruction{ mnemonic = .XSAVES, operand_count = 1, ops = {op_mem(dst.mem, 1), {}, {}, {}} }, 2314) } +emit_xsaves_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { append(instructions, inst_xsaves_m8(dst)) } +inst_xsaves64_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return with_hint(Instruction{ mnemonic = .XSAVES64, operand_count = 1, ops = {op_mem(dst.mem, 1), {}, {}, {}} }, 2315) } +emit_xsaves64_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { append(instructions, inst_xsaves64_m8(dst)) } +inst_xrstors_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return with_hint(Instruction{ mnemonic = .XRSTORS, operand_count = 1, ops = {op_mem(dst.mem, 1), {}, {}, {}} }, 2316) } +emit_xrstors_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { append(instructions, inst_xrstors_m8(dst)) } +inst_xrstors64_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return with_hint(Instruction{ mnemonic = .XRSTORS64, operand_count = 1, ops = {op_mem(dst.mem, 1), {}, {}, {}} }, 2317) } +emit_xrstors64_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { append(instructions, inst_xrstors64_m8(dst)) } +inst_prefetcht0_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return with_hint(Instruction{ mnemonic = .PREFETCHT0, operand_count = 1, ops = {op_mem(dst.mem, 1), {}, {}, {}} }, 2318) } +emit_prefetcht0_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { append(instructions, inst_prefetcht0_m8(dst)) } +inst_prefetcht1_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return with_hint(Instruction{ mnemonic = .PREFETCHT1, operand_count = 1, ops = {op_mem(dst.mem, 1), {}, {}, {}} }, 2319) } +emit_prefetcht1_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { append(instructions, inst_prefetcht1_m8(dst)) } +inst_prefetcht2_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return with_hint(Instruction{ mnemonic = .PREFETCHT2, operand_count = 1, ops = {op_mem(dst.mem, 1), {}, {}, {}} }, 2320) } +emit_prefetcht2_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { append(instructions, inst_prefetcht2_m8(dst)) } +inst_prefetchnta_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return with_hint(Instruction{ mnemonic = .PREFETCHNTA, operand_count = 1, ops = {op_mem(dst.mem, 1), {}, {}, {}} }, 2321) } +emit_prefetchnta_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { append(instructions, inst_prefetchnta_m8(dst)) } +inst_prefetchw_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return with_hint(Instruction{ mnemonic = .PREFETCHW, operand_count = 1, ops = {op_mem(dst.mem, 1), {}, {}, {}} }, 2322) } +emit_prefetchw_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { append(instructions, inst_prefetchw_m8(dst)) } +inst_clflushopt_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return with_hint(Instruction{ mnemonic = .CLFLUSHOPT, operand_count = 1, ops = {op_mem(dst.mem, 1), {}, {}, {}} }, 2323) } +emit_clflushopt_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { append(instructions, inst_clflushopt_m8(dst)) } +inst_clwb_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return with_hint(Instruction{ mnemonic = .CLWB, operand_count = 1, ops = {op_mem(dst.mem, 1), {}, {}, {}} }, 2324) } +emit_clwb_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { append(instructions, inst_clwb_m8(dst)) } +inst_cldemote_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return with_hint(Instruction{ mnemonic = .CLDEMOTE, operand_count = 1, ops = {op_mem(dst.mem, 1), {}, {}, {}} }, 2325) } +emit_cldemote_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { append(instructions, inst_cldemote_m8(dst)) } +inst_bswap_r32 :: #force_inline proc "contextless" (dst: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .BSWAP, operand_count = 1, ops = {op_gpr32(dst), {}, {}, {}} }, 2326) } +inst_bswap_r64 :: #force_inline proc "contextless" (dst: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .BSWAP, operand_count = 1, ops = {op_gpr64(dst), {}, {}, {}} }, 2327) } +emit_bswap_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32) { append(instructions, inst_bswap_r32(dst)) } +emit_bswap_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64) { append(instructions, inst_bswap_r64(dst)) } +inst_cmpxchg_r8_r8 :: #force_inline proc "contextless" (dst: GPR8, src: GPR8) -> Instruction { return with_hint(Instruction{ mnemonic = .CMPXCHG, operand_count = 2, ops = {op_gpr8(dst), op_gpr8(src), {}, {}} }, 2328) } +inst_cmpxchg_m8_r8 :: #force_inline proc "contextless" (dst: Mem8, src: GPR8) -> Instruction { return with_hint(Instruction{ mnemonic = .CMPXCHG, operand_count = 2, ops = {op_mem(dst.mem, 1), op_gpr8(src), {}, {}} }, 2328) } +inst_cmpxchg_r16_r16 :: #force_inline proc "contextless" (dst: GPR16, src: GPR16) -> Instruction { return with_hint(Instruction{ mnemonic = .CMPXCHG, operand_count = 2, ops = {op_gpr16(dst), op_gpr16(src), {}, {}} }, 2329) } +inst_cmpxchg_m16_r16 :: #force_inline proc "contextless" (dst: Mem16, src: GPR16) -> Instruction { return with_hint(Instruction{ mnemonic = .CMPXCHG, operand_count = 2, ops = {op_mem(dst.mem, 2), op_gpr16(src), {}, {}} }, 2329) } +inst_cmpxchg_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .CMPXCHG, operand_count = 2, ops = {op_gpr32(dst), op_gpr32(src), {}, {}} }, 2330) } +inst_cmpxchg_m32_r32 :: #force_inline proc "contextless" (dst: Mem32, src: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .CMPXCHG, operand_count = 2, ops = {op_mem(dst.mem, 4), op_gpr32(src), {}, {}} }, 2330) } +inst_cmpxchg_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .CMPXCHG, operand_count = 2, ops = {op_gpr64(dst), op_gpr64(src), {}, {}} }, 2331) } +inst_cmpxchg_m64_r64 :: #force_inline proc "contextless" (dst: Mem64, src: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .CMPXCHG, operand_count = 2, ops = {op_mem(dst.mem, 8), op_gpr64(src), {}, {}} }, 2331) } +emit_cmpxchg_r8_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8, src: GPR8) { append(instructions, inst_cmpxchg_r8_r8(dst, src)) } +emit_cmpxchg_m8_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8, src: GPR8) { append(instructions, inst_cmpxchg_m8_r8(dst, src)) } +emit_cmpxchg_r16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: GPR16) { append(instructions, inst_cmpxchg_r16_r16(dst, src)) } +emit_cmpxchg_m16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16, src: GPR16) { append(instructions, inst_cmpxchg_m16_r16(dst, src)) } +emit_cmpxchg_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { append(instructions, inst_cmpxchg_r32_r32(dst, src)) } +emit_cmpxchg_m32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, src: GPR32) { append(instructions, inst_cmpxchg_m32_r32(dst, src)) } +emit_cmpxchg_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { append(instructions, inst_cmpxchg_r64_r64(dst, src)) } +emit_cmpxchg_m64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, src: GPR64) { append(instructions, inst_cmpxchg_m64_r64(dst, src)) } +inst_cmpxchg8b_m64 :: #force_inline proc "contextless" (dst: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .CMPXCHG8B, operand_count = 1, ops = {op_mem(dst.mem, 8), {}, {}, {}} }, 2332) } +emit_cmpxchg8b_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64) { append(instructions, inst_cmpxchg8b_m64(dst)) } +inst_cmpxchg16b_m128 :: #force_inline proc "contextless" (dst: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .CMPXCHG16B, operand_count = 1, ops = {op_mem(dst.mem, 16), {}, {}, {}} }, 2333) } +emit_cmpxchg16b_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem128) { append(instructions, inst_cmpxchg16b_m128(dst)) } +inst_xadd_r8_r8 :: #force_inline proc "contextless" (dst: GPR8, src: GPR8) -> Instruction { return with_hint(Instruction{ mnemonic = .XADD, operand_count = 2, ops = {op_gpr8(dst), op_gpr8(src), {}, {}} }, 2334) } +inst_xadd_m8_r8 :: #force_inline proc "contextless" (dst: Mem8, src: GPR8) -> Instruction { return with_hint(Instruction{ mnemonic = .XADD, operand_count = 2, ops = {op_mem(dst.mem, 1), op_gpr8(src), {}, {}} }, 2334) } +inst_xadd_r16_r16 :: #force_inline proc "contextless" (dst: GPR16, src: GPR16) -> Instruction { return with_hint(Instruction{ mnemonic = .XADD, operand_count = 2, ops = {op_gpr16(dst), op_gpr16(src), {}, {}} }, 2335) } +inst_xadd_m16_r16 :: #force_inline proc "contextless" (dst: Mem16, src: GPR16) -> Instruction { return with_hint(Instruction{ mnemonic = .XADD, operand_count = 2, ops = {op_mem(dst.mem, 2), op_gpr16(src), {}, {}} }, 2335) } +inst_xadd_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .XADD, operand_count = 2, ops = {op_gpr32(dst), op_gpr32(src), {}, {}} }, 2336) } +inst_xadd_m32_r32 :: #force_inline proc "contextless" (dst: Mem32, src: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .XADD, operand_count = 2, ops = {op_mem(dst.mem, 4), op_gpr32(src), {}, {}} }, 2336) } +inst_xadd_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .XADD, operand_count = 2, ops = {op_gpr64(dst), op_gpr64(src), {}, {}} }, 2337) } +inst_xadd_m64_r64 :: #force_inline proc "contextless" (dst: Mem64, src: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .XADD, operand_count = 2, ops = {op_mem(dst.mem, 8), op_gpr64(src), {}, {}} }, 2337) } +emit_xadd_r8_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8, src: GPR8) { append(instructions, inst_xadd_r8_r8(dst, src)) } +emit_xadd_m8_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8, src: GPR8) { append(instructions, inst_xadd_m8_r8(dst, src)) } +emit_xadd_r16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: GPR16) { append(instructions, inst_xadd_r16_r16(dst, src)) } +emit_xadd_m16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16, src: GPR16) { append(instructions, inst_xadd_m16_r16(dst, src)) } +emit_xadd_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { append(instructions, inst_xadd_r32_r32(dst, src)) } +emit_xadd_m32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, src: GPR32) { append(instructions, inst_xadd_m32_r32(dst, src)) } +emit_xadd_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { append(instructions, inst_xadd_r64_r64(dst, src)) } +emit_xadd_m64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, src: GPR64) { append(instructions, inst_xadd_m64_r64(dst, src)) } +inst_bound_r16_m :: #force_inline proc "contextless" (dst: GPR16, src: Memory) -> Instruction { return with_hint(Instruction{ mnemonic = .BOUND, operand_count = 2, ops = {op_gpr16(dst), op_mem(src, 0), {}, {}} }, 2338) } +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), {}, {}} } } 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 inst_none(.LEAVE) } -emit_leave_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .LEAVE) } -inst_xlat_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.XLAT) } -emit_xlat_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .XLAT) } -inst_xlatb_none :: #force_inline proc "contextless" () -> Instruction { return inst_none(.XLATB) } -emit_xlatb_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { emit_none(instructions, .XLATB) } -inst_movbe_r16_m16 :: #force_inline proc "contextless" (dst: GPR16, src: Mem16) -> Instruction { return inst_r_m(.MOVBE, Register(dst), src.mem, 2) } -inst_movbe_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32) -> Instruction { return inst_r_m(.MOVBE, Register(dst), src.mem, 4) } -inst_movbe_r64_m64 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64) -> Instruction { return inst_r_m(.MOVBE, Register(dst), src.mem, 8) } -inst_movbe_m16_r16 :: #force_inline proc "contextless" (dst: Mem16, src: GPR16) -> Instruction { return inst_m_r(.MOVBE, dst.mem, 2, Register(src)) } -inst_movbe_m32_r32 :: #force_inline proc "contextless" (dst: Mem32, src: GPR32) -> Instruction { return inst_m_r(.MOVBE, dst.mem, 4, Register(src)) } -inst_movbe_m64_r64 :: #force_inline proc "contextless" (dst: Mem64, src: GPR64) -> Instruction { return inst_m_r(.MOVBE, dst.mem, 8, Register(src)) } -emit_movbe_r16_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: Mem16) { emit_rm(instructions, .MOVBE, Register(dst), src.mem, 2) } -emit_movbe_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32) { emit_rm(instructions, .MOVBE, Register(dst), src.mem, 4) } -emit_movbe_r64_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem64) { emit_rm(instructions, .MOVBE, Register(dst), src.mem, 8) } -emit_movbe_m16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16, src: GPR16) { emit_mr(instructions, .MOVBE, dst.mem, 2, Register(src)) } -emit_movbe_m32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, src: GPR32) { emit_mr(instructions, .MOVBE, dst.mem, 4, Register(src)) } -emit_movbe_m64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, src: GPR64) { emit_mr(instructions, .MOVBE, dst.mem, 8, Register(src)) } -inst_rdrand_r16 :: #force_inline proc "contextless" (dst: GPR16) -> Instruction { return inst_r(.RDRAND, Register(dst)) } -inst_rdrand_r32 :: #force_inline proc "contextless" (dst: GPR32) -> Instruction { return inst_r(.RDRAND, Register(dst)) } -inst_rdrand_r64 :: #force_inline proc "contextless" (dst: GPR64) -> Instruction { return inst_r(.RDRAND, Register(dst)) } -emit_rdrand_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16) { emit_r(instructions, .RDRAND, Register(dst)) } -emit_rdrand_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32) { emit_r(instructions, .RDRAND, Register(dst)) } -emit_rdrand_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64) { emit_r(instructions, .RDRAND, Register(dst)) } -inst_rdseed_r16 :: #force_inline proc "contextless" (dst: GPR16) -> Instruction { return inst_r(.RDSEED, Register(dst)) } -inst_rdseed_r32 :: #force_inline proc "contextless" (dst: GPR32) -> Instruction { return inst_r(.RDSEED, Register(dst)) } -inst_rdseed_r64 :: #force_inline proc "contextless" (dst: GPR64) -> Instruction { return inst_r(.RDSEED, Register(dst)) } -emit_rdseed_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16) { emit_r(instructions, .RDSEED, Register(dst)) } -emit_rdseed_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32) { emit_r(instructions, .RDSEED, Register(dst)) } -emit_rdseed_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64) { emit_r(instructions, .RDSEED, Register(dst)) } +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()) } +inst_xlat_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .XLAT, operand_count = 0, ops = {{}, {}, {}, {}} }, 2342) } +emit_xlat_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_xlat_none()) } +inst_xlatb_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .XLATB, operand_count = 0, ops = {{}, {}, {}, {}} }, 2343) } +emit_xlatb_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_xlatb_none()) } +inst_movbe_r16_m16 :: #force_inline proc "contextless" (dst: GPR16, src: Mem16) -> Instruction { return with_hint(Instruction{ mnemonic = .MOVBE, operand_count = 2, ops = {op_gpr16(dst), op_mem(src.mem, 2), {}, {}} }, 2344) } +inst_movbe_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .MOVBE, operand_count = 2, ops = {op_gpr32(dst), op_mem(src.mem, 4), {}, {}} }, 2345) } +inst_movbe_r64_m64 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .MOVBE, operand_count = 2, ops = {op_gpr64(dst), op_mem(src.mem, 8), {}, {}} }, 2346) } +inst_movbe_m16_r16 :: #force_inline proc "contextless" (dst: Mem16, src: GPR16) -> Instruction { return with_hint(Instruction{ mnemonic = .MOVBE, operand_count = 2, ops = {op_mem(dst.mem, 2), op_gpr16(src), {}, {}} }, 2347) } +inst_movbe_m32_r32 :: #force_inline proc "contextless" (dst: Mem32, src: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .MOVBE, operand_count = 2, ops = {op_mem(dst.mem, 4), op_gpr32(src), {}, {}} }, 2348) } +inst_movbe_m64_r64 :: #force_inline proc "contextless" (dst: Mem64, src: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .MOVBE, operand_count = 2, ops = {op_mem(dst.mem, 8), op_gpr64(src), {}, {}} }, 2349) } +emit_movbe_r16_m16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: Mem16) { append(instructions, inst_movbe_r16_m16(dst, src)) } +emit_movbe_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32) { append(instructions, inst_movbe_r32_m32(dst, src)) } +emit_movbe_r64_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem64) { append(instructions, inst_movbe_r64_m64(dst, src)) } +emit_movbe_m16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16, src: GPR16) { append(instructions, inst_movbe_m16_r16(dst, src)) } +emit_movbe_m32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, src: GPR32) { append(instructions, inst_movbe_m32_r32(dst, src)) } +emit_movbe_m64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, src: GPR64) { append(instructions, inst_movbe_m64_r64(dst, src)) } +inst_rdrand_r16 :: #force_inline proc "contextless" (dst: GPR16) -> Instruction { return with_hint(Instruction{ mnemonic = .RDRAND, operand_count = 1, ops = {op_gpr16(dst), {}, {}, {}} }, 2350) } +inst_rdrand_r32 :: #force_inline proc "contextless" (dst: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .RDRAND, operand_count = 1, ops = {op_gpr32(dst), {}, {}, {}} }, 2351) } +inst_rdrand_r64 :: #force_inline proc "contextless" (dst: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .RDRAND, operand_count = 1, ops = {op_gpr64(dst), {}, {}, {}} }, 2352) } +emit_rdrand_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16) { append(instructions, inst_rdrand_r16(dst)) } +emit_rdrand_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32) { append(instructions, inst_rdrand_r32(dst)) } +emit_rdrand_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64) { append(instructions, inst_rdrand_r64(dst)) } +inst_rdseed_r16 :: #force_inline proc "contextless" (dst: GPR16) -> Instruction { return with_hint(Instruction{ mnemonic = .RDSEED, operand_count = 1, ops = {op_gpr16(dst), {}, {}, {}} }, 2353) } +inst_rdseed_r32 :: #force_inline proc "contextless" (dst: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .RDSEED, operand_count = 1, ops = {op_gpr32(dst), {}, {}, {}} }, 2354) } +inst_rdseed_r64 :: #force_inline proc "contextless" (dst: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .RDSEED, operand_count = 1, ops = {op_gpr64(dst), {}, {}, {}} }, 2355) } +emit_rdseed_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16) { append(instructions, inst_rdseed_r16(dst)) } +emit_rdseed_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32) { append(instructions, inst_rdseed_r32(dst)) } +emit_rdseed_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64) { append(instructions, inst_rdseed_r64(dst)) } // ============================================================================= // Overload Groups diff --git a/core/rexcode/isa/x86/tests/test.odin b/core/rexcode/isa/x86/tests/test.odin index 204014038..a0c65339c 100644 --- a/core/rexcode/isa/x86/tests/test.odin +++ b/core/rexcode/isa/x86/tests/test.odin @@ -3139,6 +3139,101 @@ print_summary :: proc() { fmt.printf("%s======================================================================%s\n", BOLD, RESET) } +// ============================================================================= +// TYPED BUILDER CONSISTENCY +// ============================================================================= +// +// The generated typed builders (inst_/emit_) were previously +// untested. A class-dropping register cast made every one of them encode to +// nothing, and the pre-matched enc_hint fast path needs guarding. Each case +// asserts the typed builder is byte-identical to the llvm-verified generic +// builder AND that the baked enc_hint matches the matcher path (hint cleared). + +@(private="file") tb_a: [64]u8 +@(private="file") tb_b: [64]u8 + +@(private="file") +tb_enc :: proc(inst: x86.Instruction, buf: []u8) -> []u8 { + relocs: [dynamic]x86.Relocation; errors: [dynamic]x86.Error + defer { delete(relocs); delete(errors) } + n, _ := x86.encode({inst}, nil, buf, &relocs, &errors) + return buf[:n] +} + +@(private="file") +tb_eq :: proc(a, b: []u8) -> bool { + if len(a) != len(b) || len(a) == 0 { return false } + for x, i in a { if x != b[i] { return false } } + return true +} + +@(private="file") +tb_check :: proc(name: string, typed, generic: x86.Instruction) { + t := tb_enc(typed, tb_a[:]) + g := tb_enc(generic, tb_b[:]) + typed_ok := tb_eq(t, g) + // hint path must equal the matcher path for the very same instruction + cleared := typed; cleared.enc_hint = 0 + hint_ok := tb_eq(t, tb_enc(cleared, tb_b[:])) + if typed_ok && hint_ok { + g_stats.passed += 1 + g_stats.cases_validated += 1 + } else { + g_stats.failed += 1 + fmt.printf(" %sFAIL%s %s: typed=% x generic=% x (typed_ok=%v hint_ok=%v)\n", + RED, RESET, name, t, g, typed_ok, hint_ok) + } +} + +run_typed_builder_tests :: proc() { + md8 := x86.mem_base_disp(x86.RBP, -16) + md32 := x86.mem_base_disp(x86.RCX, 100000) + mbi := x86.mem_base_index_disp(x86.R8, x86.RDX, 4, 32) + mrip := x86.mem_rip_disp(0) + + // GPR reg-reg, every size (r16 exercises the 66h class-dependent prefix) + tb_check("mov r8,r8", x86.inst_mov_r8_r8(.AL,.BL), x86.inst_r_r(.MOV, x86.AL, x86.BL)) + tb_check("mov r16,r16", x86.inst_mov_r16_r16(.AX,.BX), x86.inst_r_r(.MOV, x86.AX, x86.BX)) + tb_check("mov r32,r32", x86.inst_mov_r32_r32(.EAX,.EDX), x86.inst_r_r(.MOV, x86.EAX, x86.EDX)) + tb_check("mov r64,r64", x86.inst_mov_r64_r64(.RAX,.RBX), x86.inst_r_r(.MOV, x86.RAX, x86.RBX)) + tb_check("mov r64 ext", x86.inst_mov_r64_r64(.R8,.R15), x86.inst_r_r(.MOV, x86.R8, x86.R15)) + tb_check("mov r32 ext", x86.inst_mov_r32_r32(.R9D,.R10D),x86.inst_r_r(.MOV, x86.R9D, x86.R10D)) + + // GPR arithmetic/logical reg-reg + tb_check("add r64,r64", x86.inst_add_r64_r64(.RAX,.RCX), x86.inst_r_r(.ADD, x86.RAX, x86.RCX)) + tb_check("sub r64,r64", x86.inst_sub_r64_r64(.RSI,.RDI), x86.inst_r_r(.SUB, x86.RSI, x86.RDI)) + tb_check("and r64,r64", x86.inst_and_r64_r64(.RBX,.RAX), x86.inst_r_r(.AND, x86.RBX, x86.RAX)) + tb_check("or r64,r64", x86.inst_or_r64_r64(.RBX,.RAX), x86.inst_r_r(.OR, x86.RBX, x86.RAX)) + tb_check("xor r64,r64", x86.inst_xor_r64_r64(.R8,.R8), x86.inst_r_r(.XOR, x86.R8, x86.R8)) + tb_check("cmp r64,r64", x86.inst_cmp_r64_r64(.RAX,.RDX), x86.inst_r_r(.CMP, x86.RAX, x86.RDX)) + tb_check("add r32,r32", x86.inst_add_r32_r32(.EAX,.ECX), x86.inst_r_r(.ADD, x86.EAX, x86.ECX)) + + // GPR reg-mem / mem-reg across addressing modes + tb_check("mov r64,[d8]", x86.inst_mov_r64_m64(.RDX, x86.Mem64{md8}), x86.inst_r_m(.MOV, x86.RDX, md8, 8)) + tb_check("mov r64,[d32]", x86.inst_mov_r64_m64(.RAX, x86.Mem64{md32}), x86.inst_r_m(.MOV, x86.RAX, md32, 8)) + tb_check("mov r64,[b+i]", x86.inst_mov_r64_m64(.RAX, x86.Mem64{mbi}), x86.inst_r_m(.MOV, x86.RAX, mbi, 8)) + tb_check("mov r64,[rip]", x86.inst_mov_r64_m64(.RAX, x86.Mem64{mrip}), x86.inst_r_m(.MOV, x86.RAX, mrip, 8)) + tb_check("mov [b+i],r64", x86.inst_mov_m64_r64(x86.Mem64{mbi}, .R9), x86.inst_m_r(.MOV, mbi, 8, x86.R9)) + tb_check("add r64,[d8]", x86.inst_add_r64_m64(.RAX, x86.Mem64{md8}), x86.inst_r_m(.ADD, x86.RAX, md8, 8)) + + // SSE (legacy) + VEX vector + tb_check("movaps x,x", x86.inst_movaps_xmm_xmm(.XMM0,.XMM1), x86.inst_r_r(.MOVAPS, x86.XMM0, x86.XMM1)) + tb_check("movaps x,m", x86.inst_movaps_xmm_m128(.XMM3, x86.Mem128{mbi}), x86.inst_r_m(.MOVAPS, x86.XMM3, mbi, 16)) + tb_check("movaps m,x", x86.inst_movaps_m128_xmm(x86.Mem128{mbi}, .XMM8), x86.inst_m_r(.MOVAPS, mbi, 16, x86.XMM8)) + tb_check("addps x,x", x86.inst_addps_xmm_xmm(.XMM2,.XMM4), x86.inst_r_r(.ADDPS, x86.XMM2, x86.XMM4)) + tb_check("vaddps y,y,y", x86.inst_vaddps_ymm_ymm_ymm(.YMM0,.YMM1,.YMM2), x86.inst_r_r_r(.VADDPS, x86.YMM0, x86.YMM1, x86.YMM2)) + tb_check("vaddps y ext", x86.inst_vaddps_ymm_ymm_ymm(.YMM8,.YMM12,.YMM15), x86.inst_r_r_r(.VADDPS, x86.YMM8, x86.YMM12, x86.YMM15)) + tb_check("vmulps x,x,x", x86.inst_vmulps_xmm_xmm_xmm(.XMM0,.XMM1,.XMM2), x86.inst_r_r_r(.VMULPS, x86.XMM0, x86.XMM1, x86.XMM2)) + + // opcode+reg + 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)) +} + // ============================================================================= // MAIN // ============================================================================= @@ -3187,6 +3282,9 @@ main :: proc() { log_header("LABEL_MAP TESTS") run_label_map_tests() + log_header("TYPED BUILDER CONSISTENCY") + run_typed_builder_tests() + log_header("PERFORMANCE BENCHMARKS") run_benchmarks() diff --git a/core/rexcode/isa/x86/tools/gen_mnemonic_builders.odin b/core/rexcode/isa/x86/tools/gen_mnemonic_builders.odin index df9a655bb..6e7992d22 100644 --- a/core/rexcode/isa/x86/tools/gen_mnemonic_builders.odin +++ b/core/rexcode/isa/x86/tools/gen_mnemonic_builders.odin @@ -42,6 +42,7 @@ Proc_Entry :: struct { mnemonic: x86.Mnemonic, sig: Operand_Signature, proc_name: string, + enc_hint: u16, // biased global form index (idx+1) for the pre-match fast path; 0 = none } GEN_ATTRIB :: "// rexcode ยท Brendan Punsky (dotbmp@github), original author\n\n" @@ -74,10 +75,21 @@ main :: proc() { encodings := x86.ENCODE_FORMS[_run.start:][:_run.count] if len(encodings) == 0 { continue } - for enc in encodings { + for enc, enc_idx in encodings { // Skip encodings we can't generate builders for (implicit-only operands, etc.) can_generate_builder(enc) or_continue + // A typed builder may bake a pre-matched form hint only when the + // matcher's pick is value-INDEPENDENT (no immediate/relative size + // selection); otherwise the matcher might choose a shorter form for + // some values, so we leave enc_hint=0 (matcher path). The first form + // in run order that produces a given proc_name wins the dedup below, + // which mirrors the matcher's first-match-in-run-order pick. + hint: u16 = 0 + if form_is_hintable(enc) { + hint = u16(int(_run.start) + enc_idx + 1) + } + // For RM operands, generate both register and memory variants variants := get_operand_variants(enc) @@ -95,6 +107,7 @@ main :: proc() { mnemonic = mnemonic, sig = sig, proc_name = proc_name, + enc_hint = hint, } if mnemonic not_in procs_by_mnemonic { @@ -328,6 +341,21 @@ 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). +form_is_hintable :: proc(enc: x86.Encoding) -> bool { + for op in enc.ops { + #partial switch op { + case .IMM8, .IMM16, .IMM32, .IMM64, .IMM8SX, .REL8, .REL32: + return false + } + } + return true +} + // Get all variants for an encoding (expands RM operands into reg and mem variants) get_operand_variants :: proc(enc: x86.Encoding) -> []Operand_Signature { result: [dynamic]Operand_Signature @@ -1366,7 +1394,18 @@ generate_proc :: proc(sb: ^strings.Builder, entry: Proc_Entry, max_name_padding: strings.write_string(sb, " :: #force_inline proc \"contextless\" (") strings.write_string(sb, params) strings.write_string(sb, ") -> Instruction { return ") - generate_helper_call(sb, entry) + // Build via the typed op_* constructors (op_gpr64/op_xmm/...), which carry + // the register CLASS. The older inst_r_r(.., Register(dst), ..) shortcut cast + // the hw-only typed enum straight to Register and dropped the class, so every + // typed builder produced a class-0 operand the matcher rejected (encode -> empty). + if entry.enc_hint != 0 { + // Pre-matched form: bake the biased global index so encode() skips the scan. + strings.write_string(sb, "with_hint(") + generate_fallback_instruction(sb, entry) + fmt.sbprintf(sb, ", %d)", entry.enc_hint) + } else { + generate_fallback_instruction(sb, entry) + } strings.write_string(sb, " }\n") } @@ -1402,7 +1441,14 @@ generate_emit_proc :: proc(sb: ^strings.Builder, entry: Proc_Entry, max_name_pad } strings.write_string(sb, " :: #force_inline proc(") strings.write_string(sb, params) - strings.write_string(sb, ") { ") - generate_emit_helper_call(sb, entry) - strings.write_string(sb, " }\n") + // Reuse the (class-correct, hint-baked) inst_ builder rather than re-emitting + // the operands -- keeps emit_ in lockstep with inst_ and inherits the hint. + strings.write_string(sb, ") { append(instructions, ") + strings.write_string(sb, entry.proc_name) + strings.write_string(sb, "(") + for i in 0.. 0 { strings.write_string(sb, ", ") } + strings.write_string(sb, names[i]) + } + strings.write_string(sb, ")) }\n") }