2 * This file is part of the Palacios Virtual Machine Monitor developed
3 * by the V3VEE Project with funding from the United States National
4 * Science Foundation and the Department of Energy.
6 * The V3VEE Project is a joint project between Northwestern University
7 * and the University of New Mexico. You can find out more at
10 * Copyright (c) 2008, Jack Lange <jarusl@cs.northwestern.edu>
11 * Copyright (c) 2008, The V3VEE Project <http://www.v3vee.org>
12 * All rights reserved.
14 * Author: Jack Lange <jarusl@cs.northwestern.edu>
16 * This is free software. You are permitted to use,
17 * redistribute, and modify it as specified in the file "V3VEE_LICENSE".
20 #ifdef __DECODER_TEST__
21 #include "vmm_decoder.h"
23 #include <xed/xed-interface.h>
29 #include <palacios/vmm_decoder.h>
30 #include <palacios/vmm_xed.h>
31 #include <xed/xed-interface.h>
32 #include <palacios/vm_guest.h>
33 #include <palacios/vmm.h>
40 #define PrintDebug(fmt, args...)
46 static uint_t tables_inited = 0;
49 #define GPR_REGISTER 0
50 #define SEGMENT_REGISTER 1
51 #define CTRL_REGISTER 2
52 #define DEBUG_REGISTER 3
56 /* Disgusting mask hack...
57 I can't think right now, so we'll do it this way...
59 static const ullong_t mask_1 = 0x00000000000000ffLL;
60 static const ullong_t mask_2 = 0x000000000000ffffLL;
61 static const ullong_t mask_4 = 0x00000000ffffffffLL;
62 static const ullong_t mask_8 = 0xffffffffffffffffLL;
65 #define MASK(val, length) ({ \
66 ullong_t mask = 0x0LL; \
83 struct memory_operand {
91 uint_t displacement_size;
92 ullong_t displacement;
98 static v3_op_type_t get_opcode(xed_iform_enum_t iform);
100 static int xed_reg_to_v3_reg(struct guest_info * info, xed_reg_enum_t xed_reg, addr_t * v3_reg, uint_t * reg_len);
101 static int get_memory_operand(struct guest_info * info, xed_decoded_inst_t * xed_instr, uint_t index, struct x86_operand * operand);
103 static int set_decoder_mode(struct guest_info * info, xed_state_t * state) {
104 switch (info->cpu_mode) {
106 if (state->mmode != XED_MACHINE_MODE_LEGACY_16) {
107 xed_state_init(state,
108 XED_MACHINE_MODE_LEGACY_16,
109 XED_ADDRESS_WIDTH_16b,
110 XED_ADDRESS_WIDTH_16b);
116 if (state->mmode != XED_MACHINE_MODE_LEGACY_32) {
117 xed_state_init(state,
118 XED_MACHINE_MODE_LEGACY_32,
119 XED_ADDRESS_WIDTH_32b,
120 XED_ADDRESS_WIDTH_32b);
124 if (state->mmode != XED_MACHINE_MODE_LONG_64) {
125 state->mmode = XED_MACHINE_MODE_LONG_64;
129 PrintError("Unsupported CPU mode: %d\n", info->cpu_mode);
135 static int is_flags_reg(xed_reg_enum_t xed_reg) {
148 int v3_init_decoder(struct guest_info * info) {
149 // Global library initialization, only do it once
150 if (tables_inited == 0) {
155 xed_state_t * decoder_state = (xed_state_t *)V3_Malloc(sizeof(xed_state_t));
156 xed_state_zero(decoder_state);
158 info->decoder_state = decoder_state;
165 int v3_basic_mem_decode(struct guest_info * info, addr_t instr_ptr, struct basic_instr_info * instr_info) {
166 xed_decoded_inst_t xed_instr;
167 xed_error_enum_t xed_error;
170 if (set_decoder_mode(info, info->decoder_state) == -1) {
171 PrintError("Could not set decoder mode\n");
176 xed_decoded_inst_zero_set_mode(&xed_instr, info->decoder_state);
178 xed_error = xed_decode(&xed_instr,
179 REINTERPRET_CAST(const xed_uint8_t *, instr_ptr),
180 XED_MAX_INSTRUCTION_BYTES);
182 if (xed_error != XED_ERROR_NONE) {
183 PrintError("Xed error: %s\n", xed_error_enum_t2str(xed_error));
187 instr_info->instr_length = xed_decoded_inst_get_length(&xed_instr);
190 if (xed_decoded_inst_number_of_memory_operands(&xed_instr) == 0) {
191 PrintError("Tried to decode memory operation with no memory operands\n");
195 instr_info->op_size = xed_decoded_inst_get_memory_operand_length(&xed_instr, 0);
198 xed_category_enum_t cat = xed_decoded_inst_get_category(&xed_instr);
199 if (cat == XED_CATEGORY_STRINGOP) {
200 instr_info->str_op = 1;
202 instr_info->str_op = 0;
205 xed_operand_values_t * operands = xed_decoded_inst_operands(&xed_instr);
206 if (xed_operand_values_has_real_rep(operands)) {
207 instr_info->has_rep = 1;
209 instr_info->has_rep = 0;
216 static int decode_string_op(struct guest_info * info,
217 xed_decoded_inst_t * xed_instr, const xed_inst_t * xi,
218 struct x86_instr * instr) {
220 PrintDebug("String operation\n");
222 if (instr->op_type == V3_OP_MOVS) {
223 instr->num_operands = 2;
225 if (get_memory_operand(info, xed_instr, 0, &(instr->dst_operand)) == -1) {
226 PrintError("Could not get Destination memory operand\n");
230 if (get_memory_operand(info, xed_instr, 1, &(instr->src_operand)) == -1) {
231 PrintError("Could not get Source memory operand\n");
235 if (instr->prefixes.rep == 1) {
237 uint_t reg_length = 0;
239 xed_reg_to_v3_reg(info, xed_decoded_inst_get_reg(xed_instr, XED_OPERAND_REG0), ®_addr, ®_length);
240 instr->str_op_length = MASK(*(addr_t *)reg_addr, reg_length);
242 instr->str_op_length = 1;
252 int v3_decode(struct guest_info * info, addr_t instr_ptr, struct x86_instr * instr) {
253 xed_decoded_inst_t xed_instr;
254 xed_error_enum_t xed_error;
257 v3_get_prefixes((uchar_t *)instr_ptr, &(instr->prefixes));
259 if (set_decoder_mode(info, info->decoder_state) == -1) {
260 PrintError("Could not set decoder mode\n");
264 xed_decoded_inst_zero_set_mode(&xed_instr, info->decoder_state);
266 xed_error = xed_decode(&xed_instr,
267 REINTERPRET_CAST(const xed_uint8_t *, instr_ptr),
268 XED_MAX_INSTRUCTION_BYTES);
271 if (xed_error != XED_ERROR_NONE) {
272 PrintError("Xed error: %s\n", xed_error_enum_t2str(xed_error));
276 const xed_inst_t * xi = xed_decoded_inst_inst(&xed_instr);
278 instr->instr_length = xed_decoded_inst_get_length(&xed_instr);
281 xed_iform_enum_t iform = xed_decoded_inst_get_iform_enum(&xed_instr);
284 xed_iclass_enum_t iclass = xed_decoded_inst_get_iclass(&xed_instr);
286 PrintDebug("iform=%s, iclass=%s\n", xed_iform_enum_t2str(iform), xed_iclass_enum_t2str(iclass));
290 if ((instr->op_type = get_opcode(iform)) == V3_INVALID_OP) {
291 PrintError("Could not get opcode. (iform=%s)\n", xed_iform_enum_t2str(iform));
296 // We special case the string operations...
297 if (xed_decoded_inst_get_category(&xed_instr) == XED_CATEGORY_STRINGOP) {
298 instr->is_str_op = 1;
299 return decode_string_op(info, &xed_instr, xi, instr);
301 instr->is_str_op = 0;
302 instr->str_op_length = 0;
306 instr->num_operands = xed_decoded_inst_noperands(&xed_instr);
308 if (instr->num_operands > 3) {
309 PrintDebug("Special Case Not Handled\n");
312 } else if (instr->num_operands == 3) {
313 const xed_operand_t * op = xed_inst_operand(xi, 2);
314 xed_operand_enum_t op_enum = xed_operand_name(op);
316 if ((!xed_operand_is_register(op_enum)) ||
317 (!is_flags_reg(xed_decoded_inst_get_reg(&xed_instr, op_enum)))) {
319 PrintError("Special Case not handled\n");
326 //PrintDebug("Number of operands: %d\n", instr->num_operands);
327 //PrintDebug("INSTR length: %d\n", instr->instr_length);
330 if (instr->num_operands >= 1) {
331 const xed_operand_t * op = xed_inst_operand(xi, 0);
332 xed_operand_enum_t op_enum = xed_operand_name(op);
334 struct x86_operand * v3_op = NULL;
336 if (xed_operand_written(op)) {
337 v3_op = &(instr->dst_operand);
339 v3_op = &(instr->src_operand);
343 if (xed_operand_is_register(op_enum)) {
344 xed_reg_enum_t xed_reg = xed_decoded_inst_get_reg(&xed_instr, op_enum);
345 int v3_reg_type = xed_reg_to_v3_reg(info,
350 if (v3_reg_type == -1) {
351 PrintError("First operand is an Unhandled Operand: %s\n", xed_reg_enum_t2str(xed_reg));
352 v3_op->type = INVALID_OPERAND;
354 } else if (v3_reg_type == SEGMENT_REGISTER) {
355 struct v3_segment * seg_reg = (struct v3_segment *)(v3_op->operand);
356 v3_op->operand = (addr_t)&(seg_reg->selector);
359 v3_op->type = REG_OPERAND;
364 case XED_OPERAND_MEM0:
366 if (get_memory_operand(info, &xed_instr, 0, v3_op) == -1) {
367 PrintError("Could not get first memory operand\n");
373 case XED_OPERAND_MEM1:
374 case XED_OPERAND_IMM1:
376 PrintError("Illegal Operand Order\n");
380 case XED_OPERAND_IMM0:
381 case XED_OPERAND_AGEN:
382 case XED_OPERAND_PTR:
383 case XED_OPERAND_RELBR:
385 PrintError("Unhandled Operand Type\n");
393 // set second operand
394 if (instr->num_operands >= 2) {
395 const xed_operand_t * op = xed_inst_operand(xi, 1);
396 // xed_operand_type_enum_t op_type = xed_operand_type(op);
397 xed_operand_enum_t op_enum = xed_operand_name(op);
399 struct x86_operand * v3_op;
401 if (xed_operand_written(op)) {
402 v3_op = &(instr->dst_operand);
404 v3_op = &(instr->src_operand);
408 if (xed_operand_is_register(op_enum)) {
409 xed_reg_enum_t xed_reg = xed_decoded_inst_get_reg(&xed_instr, op_enum);
410 int v3_reg_type = xed_reg_to_v3_reg(info,
414 if (v3_reg_type == -1) {
415 PrintError("Second operand is an Unhandled Operand: %s\n", xed_reg_enum_t2str(xed_reg));
416 v3_op->type = INVALID_OPERAND;
418 } else if (v3_reg_type == SEGMENT_REGISTER) {
419 struct v3_segment * seg_reg = (struct v3_segment *)(v3_op->operand);
420 v3_op->operand = (addr_t)&(seg_reg->selector);
423 v3_op->type = REG_OPERAND;
430 case XED_OPERAND_MEM0:
432 if (get_memory_operand(info, &xed_instr, 0, v3_op) == -1) {
433 PrintError("Could not get first memory operand\n");
439 case XED_OPERAND_IMM0:
441 instr->src_operand.size = xed_decoded_inst_get_immediate_width(&xed_instr);
443 if (instr->src_operand.size > 4) {
444 PrintError("Unhandled 64 bit immediates\n");
447 instr->src_operand.operand = xed_decoded_inst_get_unsigned_immediate(&xed_instr);
449 instr->src_operand.type = IMM_OPERAND;
454 case XED_OPERAND_MEM1:
455 case XED_OPERAND_IMM1:
457 PrintError("Illegal Operand Order\n");
460 case XED_OPERAND_AGEN:
461 case XED_OPERAND_PTR:
462 case XED_OPERAND_RELBR:
464 PrintError("Unhandled Operand Type\n");
472 if (instr->num_operands >= 3) {
473 const xed_operand_t * op = xed_inst_operand(xi, 2);
474 xed_operand_type_enum_t op_type = xed_operand_type(op);
475 xed_operand_enum_t op_enum = xed_operand_name(op);
477 if (xed_operand_is_register(op_enum)) {
478 xed_reg_enum_t xed_reg = xed_decoded_inst_get_reg(&xed_instr, op_enum);
479 int v3_reg_type = xed_reg_to_v3_reg(info,
481 &(instr->third_operand.operand),
482 &(instr->third_operand.size));
484 if (v3_reg_type == -1) {
485 PrintError("Third operand is an Unhandled Operand: %s\n", xed_reg_enum_t2str(xed_reg));
486 instr->third_operand.type = INVALID_OPERAND;
488 } else if (v3_reg_type == SEGMENT_REGISTER) {
489 struct v3_segment * seg_reg = (struct v3_segment *)(instr->third_operand.operand);
490 instr->third_operand.operand = (addr_t)&(seg_reg->selector);
494 instr->third_operand.type = REG_OPERAND;
498 PrintError("Unhandled third operand type %s\n", xed_operand_type_enum_t2str(op_type));
511 int v3_encode(struct guest_info * info, struct x86_instr * instr, char * instr_buf) {
520 static int get_memory_operand(struct guest_info * info, xed_decoded_inst_t * xed_instr, uint_t op_index, struct x86_operand * operand) {
521 struct memory_operand mem_op;
527 ullong_t displacement;
528 // struct v3_segment * seg_reg;
533 memset((void*)&mem_op, '\0', sizeof(struct memory_operand));
535 xed_reg_enum_t xed_seg = xed_decoded_inst_get_seg_reg(xed_instr, op_index);
536 if (xed_seg != XED_REG_INVALID) {
537 struct v3_segment *tmp_segment;
538 if (xed_reg_to_v3_reg(info, xed_seg, (addr_t *)&tmp_segment, &(mem_op.segment_size)) == -1) {
539 PrintError("Unhandled Segment Register\n");
542 mem_op.segment = tmp_segment->base;
545 xed_reg_enum_t xed_base = xed_decoded_inst_get_base_reg(xed_instr, op_index);
546 if (xed_base != XED_REG_INVALID) {
548 if (xed_reg_to_v3_reg(info, xed_base, &base_reg, &(mem_op.base_size)) == -1) {
549 PrintError("Unhandled Base register\n");
552 mem_op.base = *(addr_t *)base_reg;
557 xed_reg_enum_t xed_idx = xed_decoded_inst_get_index_reg(xed_instr, op_index);
558 if ((op_index == 0) && (xed_idx != XED_REG_INVALID)) {
561 if (xed_reg_to_v3_reg(info, xed_idx, &index_reg, &(mem_op.index_size)) == -1) {
562 PrintError("Unhandled Index Register\n");
566 mem_op.index= *(addr_t *)index_reg;
568 xed_uint_t xed_scale = xed_decoded_inst_get_scale(xed_instr, op_index);
569 if (xed_scale != 0) {
570 mem_op.scale = xed_scale;
575 xed_uint_t disp_bits = xed_decoded_inst_get_memory_displacement_width(xed_instr, op_index);
577 xed_int64_t xed_disp = xed_decoded_inst_get_memory_displacement(xed_instr, op_index);
579 mem_op.displacement_size = disp_bits;
580 mem_op.displacement = xed_disp;
583 operand->type = MEM_OPERAND;
584 operand->size = xed_decoded_inst_get_memory_operand_length(xed_instr, op_index);
588 PrintDebug("Struct: Seg=%p, base=%p, index=%p, scale=%p, displacement=%p (size=%d)\n",
589 (void *)mem_op.segment, (void*)mem_op.base, (void *)mem_op.index,
590 (void *)mem_op.scale, (void *)(addr_t)mem_op.displacement, mem_op.displacement_size);
593 PrintDebug("operand size: %d\n", operand->size);
595 seg = MASK(mem_op.segment, mem_op.segment_size);
596 base = MASK(mem_op.base, mem_op.base_size);
597 index = MASK(mem_op.index, mem_op.index_size);
598 scale = mem_op.scale;
599 displacement = MASK(mem_op.displacement, mem_op.displacement_size);
601 PrintDebug("Seg=%p, base=%p, index=%p, scale=%p, displacement=%p\n",
602 (void *)seg, (void *)base, (void *)index, (void *)scale, (void *)(addr_t)displacement);
604 operand->operand = seg + base + (scale * index) + displacement;
609 static int xed_reg_to_v3_reg(struct guest_info * info, xed_reg_enum_t xed_reg, addr_t * v3_reg, uint_t * reg_len) {
612 case XED_REG_INVALID:
621 *v3_reg = (addr_t)&(info->vm_regs.rax);
625 *v3_reg = (addr_t)&(info->vm_regs.rax);
629 *v3_reg = (addr_t)&(info->vm_regs.rax);
633 *v3_reg = (addr_t)(&(info->vm_regs.rax)) + 1;
637 *v3_reg = (addr_t)&(info->vm_regs.rax);
642 *v3_reg = (addr_t)&(info->vm_regs.rcx);
646 *v3_reg = (addr_t)&(info->vm_regs.rcx);
650 *v3_reg = (addr_t)&(info->vm_regs.rcx);
654 *v3_reg = (addr_t)(&(info->vm_regs.rcx)) + 1;
658 *v3_reg = (addr_t)&(info->vm_regs.rcx);
663 *v3_reg = (addr_t)&(info->vm_regs.rdx);
667 *v3_reg = (addr_t)&(info->vm_regs.rdx);
671 *v3_reg = (addr_t)&(info->vm_regs.rdx);
675 *v3_reg = (addr_t)(&(info->vm_regs.rdx)) + 1;
679 *v3_reg = (addr_t)&(info->vm_regs.rdx);
684 *v3_reg = (addr_t)&(info->vm_regs.rbx);
688 *v3_reg = (addr_t)&(info->vm_regs.rbx);
692 *v3_reg = (addr_t)&(info->vm_regs.rbx);
696 *v3_reg = (addr_t)(&(info->vm_regs.rbx)) + 1;
700 *v3_reg = (addr_t)&(info->vm_regs.rbx);
706 *v3_reg = (addr_t)&(info->vm_regs.rsp);
710 *v3_reg = (addr_t)&(info->vm_regs.rsp);
714 *v3_reg = (addr_t)&(info->vm_regs.rsp);
718 *v3_reg = (addr_t)&(info->vm_regs.rsp);
723 *v3_reg = (addr_t)&(info->vm_regs.rbp);
727 *v3_reg = (addr_t)&(info->vm_regs.rbp);
731 *v3_reg = (addr_t)&(info->vm_regs.rbp);
735 *v3_reg = (addr_t)&(info->vm_regs.rbp);
742 *v3_reg = (addr_t)&(info->vm_regs.rsi);
746 *v3_reg = (addr_t)&(info->vm_regs.rsi);
750 *v3_reg = (addr_t)&(info->vm_regs.rsi);
754 *v3_reg = (addr_t)&(info->vm_regs.rsi);
760 *v3_reg = (addr_t)&(info->vm_regs.rdi);
764 *v3_reg = (addr_t)&(info->vm_regs.rdi);
768 *v3_reg = (addr_t)&(info->vm_regs.rdi);
772 *v3_reg = (addr_t)&(info->vm_regs.rdi);
781 *v3_reg = (addr_t)&(info->rip);
783 return CTRL_REGISTER;
785 *v3_reg = (addr_t)&(info->rip);
787 return CTRL_REGISTER;
789 *v3_reg = (addr_t)&(info->rip);
791 return CTRL_REGISTER;
794 *v3_reg = (addr_t)&(info->ctrl_regs.rflags);
796 return CTRL_REGISTER;
798 *v3_reg = (addr_t)&(info->ctrl_regs.rflags);
800 return CTRL_REGISTER;
802 *v3_reg = (addr_t)&(info->ctrl_regs.rflags);
804 return CTRL_REGISTER;
807 *v3_reg = (addr_t)&(info->ctrl_regs.cr0);
809 return CTRL_REGISTER;
811 *v3_reg = (addr_t)&(info->ctrl_regs.cr2);
813 return CTRL_REGISTER;
815 *v3_reg = (addr_t)&(info->ctrl_regs.cr3);
817 return CTRL_REGISTER;
819 *v3_reg = (addr_t)&(info->ctrl_regs.cr4);
821 return CTRL_REGISTER;
823 *v3_reg = (addr_t)&(info->ctrl_regs.cr8);
825 return CTRL_REGISTER;
847 *v3_reg = (addr_t)&(info->segments.cs);
848 return SEGMENT_REGISTER;
850 *v3_reg = (addr_t)&(info->segments.ds);
851 return SEGMENT_REGISTER;
853 *v3_reg = (addr_t)&(info->segments.es);
854 return SEGMENT_REGISTER;
856 *v3_reg = (addr_t)&(info->segments.ss);
857 return SEGMENT_REGISTER;
859 *v3_reg = (addr_t)&(info->segments.fs);
860 return SEGMENT_REGISTER;
862 *v3_reg = (addr_t)&(info->segments.gs);
863 return SEGMENT_REGISTER;
870 PrintError("Segment selector operand... Don't know how to handle this...\n");
973 case XED_REG_STACKPUSH:
974 case XED_REG_STACKPOP:
980 case XED_REG_X87CONTROL:
981 case XED_REG_X87STATUS:
984 case XED_REG_X87PUSH:
986 case XED_REG_X87POP2:
1021 static v3_op_type_t get_opcode(xed_iform_enum_t iform) {
1024 case XED_IFORM_MOV_CR_GPR64_CR:
1025 case XED_IFORM_MOV_CR_GPR32_CR:
1026 return V3_OP_MOVCR2;
1028 case XED_IFORM_MOV_CR_CR_GPR64:
1029 case XED_IFORM_MOV_CR_CR_GPR32:
1030 return V3_OP_MOV2CR;
1032 case XED_IFORM_SMSW_GPRv:
1035 case XED_IFORM_LMSW_GPR16:
1038 case XED_IFORM_CLTS:
1041 case XED_IFORM_ADC_MEMv_GPRv:
1042 case XED_IFORM_ADC_MEMv_IMM:
1043 case XED_IFORM_ADC_MEMb_GPR8:
1044 case XED_IFORM_ADC_MEMb_IMM:
1047 case XED_IFORM_ADD_MEMv_GPRv:
1048 case XED_IFORM_ADD_MEMb_IMM:
1049 case XED_IFORM_ADD_MEMb_GPR8:
1050 case XED_IFORM_ADD_MEMv_IMM:
1053 case XED_IFORM_AND_MEMv_IMM:
1054 case XED_IFORM_AND_MEMb_GPR8:
1055 case XED_IFORM_AND_MEMv_GPRv:
1056 case XED_IFORM_AND_MEMb_IMM:
1059 case XED_IFORM_SUB_MEMv_IMM:
1060 case XED_IFORM_SUB_MEMb_GPR8:
1061 case XED_IFORM_SUB_MEMb_IMM:
1062 case XED_IFORM_SUB_MEMv_GPRv:
1065 case XED_IFORM_MOV_MEMv_GPRv:
1066 case XED_IFORM_MOV_MEMb_GPR8:
1067 case XED_IFORM_MOV_MEMb_AL:
1068 case XED_IFORM_MOV_MEMv_IMM:
1069 case XED_IFORM_MOV_MEMb_IMM:
1072 case XED_IFORM_DEC_MEMv:
1073 case XED_IFORM_DEC_MEMb:
1076 case XED_IFORM_INC_MEMb:
1077 case XED_IFORM_INC_MEMv:
1080 case XED_IFORM_OR_MEMv_IMM:
1081 case XED_IFORM_OR_MEMb_IMM:
1082 case XED_IFORM_OR_MEMv_GPRv:
1083 case XED_IFORM_OR_MEMb_GPR8:
1086 case XED_IFORM_XOR_MEMv_GPRv:
1087 case XED_IFORM_XOR_MEMb_IMM:
1088 case XED_IFORM_XOR_MEMb_GPR8:
1089 case XED_IFORM_XOR_MEMv_IMM:
1092 case XED_IFORM_NEG_MEMb:
1093 case XED_IFORM_NEG_MEMv:
1096 case XED_IFORM_NOT_MEMv:
1097 case XED_IFORM_NOT_MEMb:
1100 case XED_IFORM_XCHG_MEMv_GPRv:
1101 case XED_IFORM_XCHG_MEMb_GPR8:
1104 case XED_IFORM_SETB_MEMb:
1107 case XED_IFORM_SETBE_MEMb:
1110 case XED_IFORM_SETL_MEMb:
1113 case XED_IFORM_SETLE_MEMb:
1116 case XED_IFORM_SETNB_MEMb:
1119 case XED_IFORM_SETNBE_MEMb:
1120 return V3_OP_SETNBE;
1122 case XED_IFORM_SETNL_MEMb:
1125 case XED_IFORM_SETNLE_MEMb:
1126 return V3_OP_SETNLE;
1128 case XED_IFORM_SETNO_MEMb:
1131 case XED_IFORM_SETNP_MEMb:
1134 case XED_IFORM_SETNS_MEMb:
1137 case XED_IFORM_SETNZ_MEMb:
1140 case XED_IFORM_SETO_MEMb:
1143 case XED_IFORM_SETP_MEMb:
1146 case XED_IFORM_SETS_MEMb:
1149 case XED_IFORM_SETZ_MEMb:
1152 case XED_IFORM_MOVSB:
1153 case XED_IFORM_MOVSW:
1154 case XED_IFORM_MOVSD:
1155 case XED_IFORM_MOVSQ:
1159 return V3_INVALID_OP;