Lines Matching refs:ins
169 /* Flags for ins->prefixes which we somehow handled when printing the
197 /* We can up to 14 ins->prefixes since the maximum instruction length is
261 * (see topic "Redundant ins->prefixes" in the "Differences from 8086"
294 if (ins->rex & value) \
295 ins->rex_used |= (value) | REX_OPCODE; \
296 if (ins->rex2 & value) \
298 ins->rex2_used |= (value); \
299 ins->rex_used |= REX_OPCODE; \
303 ins->rex_used |= REX_OPCODE; \
364 fetch_modrm (instr_info *ins)
366 if (!fetch_code (ins->info, ins->codep + 1))
369 ins->modrm.mod = (*ins->codep >> 6) & 3;
370 ins->modrm.reg = (*ins->codep >> 3) & 7;
371 ins->modrm.rm = *ins->codep & 7;
377 fetch_error (const instr_info *ins)
382 const struct dis_private *priv = ins->info->private_data;
385 if (ins->codep <= priv->the_buffer)
388 if (ins->prefixes || ins->fwait_prefix >= 0 || (ins->rex & REX_OPCODE))
389 name = prefix_name (ins->address_mode, priv->the_buffer[0],
392 i386_dis_printf (ins->info, dis_style_mnemonic, "%s", name);
396 i386_dis_printf (ins->info, dis_style_assembler_directive, ".byte ");
397 i386_dis_printf (ins->info, dis_style_immediate, "%#x",
1798 typedef bool (*op_rtn) (instr_info *ins, int bytemode, int sizeflag);
2017 { "ins{b|}", { Ybr, indirDX }, 0 },
2532 #define MODRM_CHECK if (!ins->need_modrm) abort ()
4322 { "ins{R|}", { Yzr, indirDX }, 0 },
4323 { "ins{G|}", { Yzr, indirDX }, 0 },
8461 ckprefix (instr_info *ins)
8471 if (!fetch_code (ins->info, ins->codep + 1))
8474 switch (*ins->codep)
8493 if (ins->address_mode == mode_64bit)
8494 newrex = *ins->codep;
8497 ins->last_rex_prefix = i;
8501 if (ins->address_mode == mode_64bit)
8503 if (ins->last_rex_prefix >= 0)
8506 ins->codep++;
8507 if (!fetch_code (ins->info, ins->codep + 1))
8509 ins->rex2_payload = *ins->codep;
8510 ins->rex2 = ins->rex2_payload >> 4;
8511 ins->rex = (ins->rex2_payload & 0xf) | REX_OPCODE;
8512 ins->codep++;
8513 ins->last_rex2_prefix = i;
8514 ins->all_prefixes[i] = REX2_OPCODE;
8518 ins->prefixes |= PREFIX_REPZ;
8519 ins->last_repz_prefix = i;
8522 ins->prefixes |= PREFIX_REPNZ;
8523 ins->last_repnz_prefix = i;
8526 ins->prefixes |= PREFIX_LOCK;
8527 ins->last_lock_prefix = i;
8530 ins->prefixes |= PREFIX_CS;
8531 ins->last_seg_prefix = i;
8532 if (ins->address_mode != mode_64bit)
8533 ins->active_seg_prefix = PREFIX_CS;
8536 ins->prefixes |= PREFIX_SS;
8537 ins->last_seg_prefix = i;
8538 if (ins->address_mode != mode_64bit)
8539 ins->active_seg_prefix = PREFIX_SS;
8542 ins->prefixes |= PREFIX_DS;
8543 ins->last_seg_prefix = i;
8544 if (ins->address_mode != mode_64bit)
8545 ins->active_seg_prefix = PREFIX_DS;
8548 ins->prefixes |= PREFIX_ES;
8549 ins->last_seg_prefix = i;
8550 if (ins->address_mode != mode_64bit)
8551 ins->active_seg_prefix = PREFIX_ES;
8554 ins->prefixes |= PREFIX_FS;
8555 ins->last_seg_prefix = i;
8556 ins->active_seg_prefix = PREFIX_FS;
8559 ins->prefixes |= PREFIX_GS;
8560 ins->last_seg_prefix = i;
8561 ins->active_seg_prefix = PREFIX_GS;
8564 ins->prefixes |= PREFIX_DATA;
8565 ins->last_data_prefix = i;
8568 ins->prefixes |= PREFIX_ADDR;
8569 ins->last_addr_prefix = i;
8575 ins->fwait_prefix = i;
8576 if (ins->prefixes || ins->rex)
8578 ins->prefixes |= PREFIX_FWAIT;
8579 ins->codep++;
8582 return ins->rex ? ckp_bogus : ckp_okay;
8584 ins->prefixes = PREFIX_FWAIT;
8590 if (ins->rex)
8592 if (*ins->codep != FWAIT_OPCODE)
8593 ins->all_prefixes[i++] = *ins->codep;
8594 ins->rex = newrex;
8595 ins->codep++;
8729 get_valid_dis386 (const struct dis386 *dp, instr_info *ins)
8739 dp = ®_table[dp->op[1].bytemode][ins->modrm.reg];
8743 vindex = ins->modrm.mod == 0x3 ? 1 : 0;
8748 dp = &rm_table[dp->op[1].bytemode][ins->modrm.rm];
8753 if (ins->need_vex)
8756 switch (ins->vex.prefix)
8783 if ((ins->prefixes & (PREFIX_REPZ | PREFIX_REPNZ)) != 0)
8785 if (ins->last_repz_prefix > ins->last_repnz_prefix)
8789 last_prefix = ins->last_repz_prefix;
8795 last_prefix = ins->last_repnz_prefix;
8806 if (vindex == 0 && (ins->prefixes & PREFIX_DATA) != 0)
8810 last_prefix = ins->last_data_prefix;
8815 ins->used_prefixes |= prefix;
8816 ins->all_prefixes[last_prefix] = 0;
8826 ins->evex_type = evex_from_vex;
8829 if (ins->address_mode != mode_64bit
8830 || (ins->vex.mask_register_specifier & 0x3) != 0
8831 || ins->vex.ll != 0
8832 || ins->vex.zeroing != 0
8833 || ins->vex.b)
8842 if (ins->modrm.mod == 3)
8849 vindex = ins->address_mode == mode_64bit ? 1 : 0;
8854 if (ins->last_rex2_prefix >= 0)
8856 if (!fetch_code (ins->info, ins->codep + 2))
8858 vindex = *ins->codep++;
8860 ins->end_codep = ins->codep;
8861 if (!fetch_modrm (ins))
8866 if (!ins->need_vex)
8869 switch (ins->vex.length)
8877 if (ins->vex.evex)
8893 if (!ins->vex.evex)
8896 switch (ins->vex.length)
8916 if (!fetch_code (ins->info, ins->codep + 3))
8918 ins->rex = ~(*ins->codep >> 5) & 0x7;
8921 switch ((*ins->codep & 0x1f))
8936 ins->codep++;
8937 ins->vex.w = *ins->codep & 0x80;
8938 if (ins->vex.w && ins->address_mode == mode_64bit)
8939 ins->rex |= REX_W;
8941 ins->vex.register_specifier = (~(*ins->codep >> 3)) & 0xf;
8942 if (ins->address_mode != mode_64bit)
8945 ins->rex &= ~REX_B;
8948 ins->vex.length = (*ins->codep & 0x4) ? 256 : 128;
8949 switch ((*ins->codep & 0x3))
8954 ins->vex.prefix = DATA_PREFIX_OPCODE;
8957 ins->vex.prefix = REPE_PREFIX_OPCODE;
8960 ins->vex.prefix = REPNE_PREFIX_OPCODE;
8963 ins->need_vex = 3;
8964 ins->codep++;
8965 vindex = *ins->codep++;
8968 ins->end_codep = ins->codep;
8969 if (!fetch_modrm (ins))
8974 if (ins->vex.prefix)
8980 if (!fetch_code (ins->info, ins->codep + 3))
8982 ins->rex = ~(*ins->codep >> 5) & 0x7;
8983 switch ((*ins->codep & 0x1f))
9001 ins->codep++;
9002 ins->vex.w = *ins->codep & 0x80;
9003 if (ins->address_mode == mode_64bit)
9005 if (ins->vex.w)
9006 ins->rex |= REX_W;
9013 ins->rex = 0;
9015 ins->vex.register_specifier = (~(*ins->codep >> 3)) & 0xf;
9016 ins->vex.length = (*ins->codep & 0x4) ? 256 : 128;
9017 switch ((*ins->codep & 0x3))
9022 ins->vex.prefix = DATA_PREFIX_OPCODE;
9025 ins->vex.prefix = REPE_PREFIX_OPCODE;
9028 ins->vex.prefix = REPNE_PREFIX_OPCODE;
9031 ins->need_vex = 3;
9032 ins->codep++;
9033 vindex = *ins->codep++;
9034 ins->condition_code = vindex & 0xf;
9043 ins->end_codep = ins->codep;
9046 && !fetch_modrm (ins))
9052 if (!fetch_code (ins->info, ins->codep + 2))
9054 ins->rex = (*ins->codep & 0x80) ? 0 : REX_R;
9058 ins->vex.register_specifier = (~(*ins->codep >> 3)) & 0xf;
9059 ins->vex.length = (*ins->codep & 0x4) ? 256 : 128;
9060 switch ((*ins->codep & 0x3))
9065 ins->vex.prefix = DATA_PREFIX_OPCODE;
9068 ins->vex.prefix = REPE_PREFIX_OPCODE;
9071 ins->vex.prefix = REPNE_PREFIX_OPCODE;
9074 ins->need_vex = 2;
9075 ins->codep++;
9076 vindex = *ins->codep++;
9078 ins->end_codep = ins->codep;
9080 if (vindex != 0x77 && !fetch_modrm (ins))
9086 if (!ins->need_vex)
9089 dp = &vex_w_table[dp->op[1].bytemode][ins->vex.w];
9093 ins->two_source_ops = false;
9095 ins->vex.evex = true;
9096 if (!fetch_code (ins->info, ins->codep + 4))
9099 if (*ins->codep & 0x8)
9100 ins->rex2 |= REX_B;
9101 if (!(*ins->codep & 0x10))
9102 ins->rex2 |= REX_R;
9104 ins->rex = ~(*ins->codep >> 5) & 0x7;
9105 switch (*ins->codep & 0x7)
9120 ins->evex_type = evex_from_legacy;
9121 if (ins->address_mode != mode_64bit)
9123 ins->rex |= REX_OPCODE;
9137 ins->codep++;
9138 ins->vex.w = *ins->codep & 0x80;
9139 if (ins->vex.w && ins->address_mode == mode_64bit)
9140 ins->rex |= REX_W;
9142 ins->vex.register_specifier = (~(*ins->codep >> 3)) & 0xf;
9144 if (!(*ins->codep & 0x4))
9145 ins->rex2 |= REX_X;
9147 ins->vex.u = *ins->codep & 0x4;
9149 switch ((*ins->codep & 0x3))
9154 ins->vex.prefix = DATA_PREFIX_OPCODE;
9157 ins->vex.prefix = REPE_PREFIX_OPCODE;
9160 ins->vex.prefix = REPNE_PREFIX_OPCODE;
9165 ins->codep++;
9168 ins->vex.ll = (*ins->codep >> 5) & 3;
9169 ins->vex.b = *ins->codep & 0x10;
9171 ins->vex.v = *ins->codep & 0x8;
9172 ins->vex.mask_register_specifier = *ins->codep & 0x7;
9173 ins->vex.scc = *ins->codep & 0xf;
9174 ins->vex.zeroing = *ins->codep & 0x80;
9177 ins->vex.nf = *ins->codep & 0x4;
9179 if (ins->address_mode != mode_64bit)
9183 if (ins->evex_type != evex_default || (ins->rex2 & REX_B)
9184 || ((ins->rex2 & REX_X) && (ins->modrm.mod != 3)))
9187 ins->rex &= ~REX_B;
9188 ins->rex2 &= ~REX_R;
9191 ins->need_vex = 4;
9193 ins->codep++;
9194 vindex = *ins->codep++;
9195 ins->condition_code = vindex & 0xf;
9204 ins->end_codep = ins->codep;
9205 if (!fetch_modrm (ins))
9211 if (ins->modrm.mod == 3 && !ins->vex.u && !ins->vex.b)
9217 if (ins->modrm.mod == 3 && ins->vex.b && ins->evex_type != evex_from_legacy)
9219 if (ins->vex.u)
9220 ins->vex.length = 512;
9222 ins->vex.length = 256;
9226 switch (ins->vex.ll)
9229 ins->vex.length = 128;
9232 ins->vex.length = 256;
9235 ins->vex.length = 512;
9254 return get_valid_dis386 (dp, ins);
9258 get_sib (instr_info *ins, int sizeflag)
9261 if (ins->need_modrm
9262 && ((sizeflag & AFLAG) || ins->address_mode == mode_64bit)
9263 && ins->modrm.mod != 3
9264 && ins->modrm.rm == 4)
9266 if (!fetch_code (ins->info, ins->codep + 2))
9268 ins->sib.index = (ins->codep[1] >> 3) & 7;
9269 ins->sib.scale = (ins->codep[1] >> 6) & 3;
9270 ins->sib.base = ins->codep[1] & 7;
9271 ins->has_sib = true;
9274 ins->has_sib = false;
9282 oappend (instr_info *ins, const char *s)
9284 oappend_with_style (ins, s, dis_style_text);
9291 oappend_register (instr_info *ins, const char *s)
9293 oappend_with_style (ins, s + ins->intel_syntax, dis_style_register);
9296 /* Wrap around a call to INS->info->fprintf_styled_func, printing FMT.
9397 instr_info ins = {
9407 .obufp = ins.obuf,
9422 ins.address_mode = mode_32bit;
9425 ins.address_mode = mode_16bit;
9429 ins.address_mode = mode_64bit;
9434 ins.isa64 = amd64;
9436 ins.isa64 = intel64;
9439 ins.address_mode = mode_64bit;
9444 ins.address_mode = mode_32bit;
9449 ins.address_mode = mode_16bit;
9455 ins.intel_mnemonic = true;
9457 ins.intel_syntax = 1;
9461 ins.intel_syntax = 0;
9463 ins.intel_mnemonic = false;
9467 if (ins.address_mode == mode_64bit)
9497 if (ins.address_mode == mode_64bit && sizeof (bfd_vma) < 8)
9503 if (ins.intel_syntax)
9505 ins.open_char = '[';
9506 ins.close_char = ']';
9507 ins.separator_char = '+';
9508 ins.scale_char = '*';
9512 ins.open_char = '(';
9513 ins.close_char = ')';
9514 ins.separator_char = ',';
9515 ins.scale_char = ',';
9529 ins.op_out[i] = op_out[i];
9534 switch (ckprefix (&ins))
9542 i < (int) ARRAY_SIZE (ins.all_prefixes) && ins.all_prefixes[i];
9546 prefix_name (ins.address_mode, ins.all_prefixes[i],
9555 ins.nr_prefixes = ins.codep - ins.start_codep;
9557 if (!fetch_code (info, ins.codep + 1))
9560 ret = fetch_error (&ins);
9564 ins.two_source_ops = (*ins.codep == 0x62 || *ins.codep == 0xc8);
9566 if ((ins.prefixes & PREFIX_FWAIT)
9567 && (*ins.codep < 0xd8 || *ins.codep > 0xdf))
9569 /* Handle ins.prefixes before fwait. */
9570 for (i = 0; i < ins.fwait_prefix && ins.all_prefixes[i];
9573 prefix_name (ins.address_mode, ins.all_prefixes[i],
9581 if (ins.last_rex2_prefix < 0 ? *ins.codep == 0x0f : (ins.rex2 & REX2_M))
9583 if (!ins.rex2)
9585 ins.codep++;
9586 if (!fetch_code (info, ins.codep + 1))
9590 dp = &dis386_twobyte[*ins.codep];
9591 ins.need_modrm = twobyte_has_modrm[*ins.codep];
9595 dp = &dis386[*ins.codep];
9596 ins.need_modrm = onebyte_has_modrm[*ins.codep];
9598 ins.condition_code = *ins.codep & 0xf;
9599 ins.codep++;
9601 /* Save sizeflag for printing the extra ins.prefixes later before updating
9605 if (ins.prefixes & PREFIX_ADDR)
9607 if ((ins.prefixes & PREFIX_DATA))
9610 ins.end_codep = ins.codep;
9611 if (ins.need_modrm && !fetch_modrm (&ins))
9616 if (!get_sib (&ins, sizeflag)
9617 || !dofloat (&ins, sizeflag))
9622 dp = get_valid_dis386 (dp, &ins);
9628 if (ins.evex_type == evex_from_legacy
9629 && ins.vex.prefix == DATA_PREFIX_OPCODE)
9632 if(ins.evex_type == evex_default)
9633 ins.vex.nf = false;
9639 ins.vex.mask_register_specifier &= 0x3;
9641 if (dp != NULL && putop (&ins, dp->name, sizeflag) == 0)
9643 if (!get_sib (&ins, sizeflag))
9647 ins.obufp = ins.op_out[i];
9648 ins.op_ad = MAX_OPERANDS - 1 - i;
9650 && !dp->op[i].rtn (&ins, dp->op[i].bytemode, sizeflag))
9654 if (i == 0 && ins.vex.evex)
9657 if (ins.vex.mask_register_specifier)
9660 = att_names_mask[ins.vex.mask_register_specifier];
9662 oappend (&ins, "{");
9663 oappend_register (&ins, reg_name);
9664 oappend (&ins, "}");
9666 if (ins.vex.zeroing)
9667 oappend (&ins, "{z}");
9669 else if (ins.vex.zeroing)
9671 oappend (&ins, "{bad}");
9678 if (ins.vex.zeroing && dp->op[0].bytemode == mask_mode)
9679 ins.illegal_masking = true;
9685 && (ins.vex.mask_register_specifier == 0
9686 || ins.vex.zeroing))
9687 ins.illegal_masking = true;
9689 if (ins.illegal_masking)
9690 oappend (&ins, "/(bad)");
9694 if (ins.vex.nf)
9695 oappend (&ins, "{bad-nf}");
9699 if (ins.modrm.mod == 3 && ins.vex.b && ins.evex_type == evex_default
9700 && !(ins.evex_used & EVEX_b_used))
9704 ins.obufp = ins.op_out[i];
9705 if (*ins.obufp)
9707 oappend (&ins, names_rounding[ins.vex.ll]);
9708 oappend (&ins, "bad}");
9724 ins.op_is_jump = false;
9745 ins.op_is_jump = true;
9758 if (ins.evex_type == evex_from_legacy)
9762 if (!ins.vex.nd && (ins.vex.register_specifier || !ins.vex.v))
9765 ret = ins.end_codep - priv.the_buffer;
9771 if ((ins.vex.mask_register_specifier & 0x3) != 0
9772 || ins.vex.ll != 0 || ins.vex.zeroing != 0)
9775 ret = ins.end_codep - priv.the_buffer;
9781 if (ins.need_vex && ins.vex.register_specifier != 0)
9784 ret = ins.end_codep - priv.the_buffer;
9789 && ins.last_rex2_prefix >= 0 && (ins.rex2 & REX2_SPECIAL) == 0)
9792 ret = ins.end_codep - priv.the_buffer;
9801 if (ins.need_vex ? !ins.vex.prefix : !(ins.prefixes & PREFIX_DATA))
9804 ret = ins.end_codep - priv.the_buffer;
9807 ins.used_prefixes |= PREFIX_DATA;
9815 if (((ins.need_vex
9816 ? ins.vex.prefix == REPE_PREFIX_OPCODE
9817 || ins.vex.prefix == REPNE_PREFIX_OPCODE
9818 : (ins.prefixes
9820 && (ins.used_prefixes
9822 || (((ins.need_vex
9823 ? ins.vex.prefix == DATA_PREFIX_OPCODE
9824 : ((ins.prefixes
9827 && (ins.used_prefixes & PREFIX_DATA) == 0))
9828 || (ins.vex.evex && dp->prefix_requirement != PREFIX_DATA
9829 && !ins.vex.w != !(ins.used_prefixes & PREFIX_DATA)))
9832 ret = ins.end_codep - priv.the_buffer;
9840 ins.used_prefixes &= ~PREFIX_OPCODE;
9841 if (ins.last_data_prefix >= 0)
9842 ins.all_prefixes[ins.last_data_prefix] = 0x66;
9843 if (ins.last_repz_prefix >= 0)
9844 ins.all_prefixes[ins.last_repz_prefix] = 0xf3;
9845 if (ins.last_repnz_prefix >= 0)
9846 ins.all_prefixes[ins.last_repnz_prefix] = 0xf2;
9850 if (ins.vex.prefix == REPE_PREFIX_OPCODE
9851 || ins.vex.prefix == REPNE_PREFIX_OPCODE)
9854 ret = ins.end_codep - priv.the_buffer;
9860 if (ins.vex.prefix)
9863 ret = ins.end_codep - priv.the_buffer;
9870 if ((ins.rex ^ ins.rex_used) == 0
9871 && !ins.need_vex && ins.last_rex_prefix >= 0)
9872 ins.all_prefixes[ins.last_rex_prefix] = 0;
9875 if (ins.last_rex2_prefix >= 0
9876 && ((ins.rex2 & REX2_SPECIAL)
9877 || (((ins.rex2 & 7) ^ (ins.rex2_used & 7)) == 0
9878 && (ins.rex ^ ins.rex_used) == 0
9879 && (ins.rex2 & 7))))
9880 ins.all_prefixes[ins.last_rex2_prefix] = 0;
9883 if ((ins.prefixes & (PREFIX_CS | PREFIX_SS | PREFIX_DS | PREFIX_ES
9885 && (ins.used_prefixes & ins.active_seg_prefix) != 0)
9886 ins.all_prefixes[ins.last_seg_prefix] = 0;
9889 if ((ins.prefixes & PREFIX_ADDR) != 0
9890 && (ins.used_prefixes & PREFIX_ADDR) != 0)
9891 ins.all_prefixes[ins.last_addr_prefix] = 0;
9894 if ((ins.prefixes & PREFIX_DATA) != 0
9895 && (ins.used_prefixes & PREFIX_DATA) != 0
9896 && !ins.need_vex)
9897 ins.all_prefixes[ins.last_data_prefix] = 0;
9899 /* Print the extra ins.prefixes. */
9901 for (i = 0; i < (int) ARRAY_SIZE (ins.all_prefixes); i++)
9902 if (ins.all_prefixes[i])
9904 const char *name = prefix_name (ins.address_mode, ins.all_prefixes[i],
9910 if (ins.all_prefixes[i] == REX2_OPCODE)
9912 (unsigned int) ins.rex2_payload);
9918 if ((ins.codep - ins.start_codep) > MAX_CODE_LENGTH)
9928 if (*ins.op_out[i] != '\0')
9932 ins.obufp = ins.mnemonicendp;
9935 i = strlen (ins.obuf) + prefix_length;
9945 i386_dis_printf (info, dis_style_mnemonic, "%s%*s", ins.obuf, i, "");
9950 if (ins.intel_syntax || ins.two_source_ops)
9953 op_txt[i] = ins.op_out[i];
9955 if (ins.intel_syntax && dp && dp->op[2].rtn == OP_Rounding
9958 op_txt[2] = ins.op_out[3];
9959 op_txt[3] = ins.op_out[2];
9967 ins.op_ad = ins.op_index[i];
9968 ins.op_index[i] = ins.op_index[MAX_OPERANDS - 1 - i];
9969 ins.op_index[MAX_OPERANDS - 1 - i] = ins.op_ad;
9970 riprel = ins.op_riprel[i];
9971 ins.op_riprel[i] = ins.op_riprel[MAX_OPERANDS - 1 - i];
9972 ins.op_riprel[MAX_OPERANDS - 1 - i] = riprel;
9978 op_txt[MAX_OPERANDS - 1 - i] = ins.op_out[i];
9988 switch (i & -(ins.intel_syntax && dp))
10001 if (ins.op_index[i] != -1 && !ins.op_riprel[i])
10003 bfd_vma target = (bfd_vma) ins.op_address[ins.op_index[i]];
10005 if (ins.op_is_jump)
10021 if (ins.op_index[i] != -1 && ins.op_riprel[i])
10025 ((bfd_vma)(ins.start_pc + (ins.codep - ins.start_codep)
10026 + ins.op_address[ins.op_index[i]]),
10030 ret = ins.codep - priv.the_buffer;
10377 swap_operand (instr_info *ins)
10379 char *p = ins->mnemonicendp;
10385 if (p <= ins->obuf + 2)
10391 memmove (p + 2, p, ins->mnemonicendp - p + 1);
10394 ins->mnemonicendp += 2;
10398 dofloat (instr_info *ins, int sizeflag)
10401 unsigned char floatop = ins->codep[-1];
10403 if (ins->modrm.mod != 3)
10405 int fp_indx = (floatop - 0xd8) * 8 + ins->modrm.reg;
10407 putop (ins, float_mem[fp_indx], sizeflag);
10408 ins->obufp = ins->op_out[0];
10409 ins->op_ad = 2;
10410 return OP_E (ins, float_mem_mode[fp_indx], sizeflag);
10414 ins->codep++;
10416 dp = &float_reg[floatop - 0xd8][ins->modrm.reg];
10419 putop (ins, fgrps[dp->op[0].bytemode][ins->modrm.rm], sizeflag);
10422 if (floatop == 0xdf && ins->codep[-1] == 0xe0)
10423 strcpy (ins->op_out[0], att_names16[0] + ins->intel_syntax);
10427 putop (ins, dp->name, sizeflag);
10429 ins->obufp = ins->op_out[0];
10430 ins->op_ad = 2;
10432 && !dp->op[0].rtn (ins, dp->op[0].bytemode, sizeflag))
10435 ins->obufp = ins->op_out[1];
10436 ins->op_ad = 1;
10438 && !dp->op[1].rtn (ins, dp->op[1].bytemode, sizeflag))
10445 OP_ST (instr_info *ins, int bytemode ATTRIBUTE_UNUSED,
10448 oappend_register (ins, "%st");
10453 OP_STi (instr_info *ins, int bytemode ATTRIBUTE_UNUSED,
10457 int res = snprintf (scratch, ARRAY_SIZE (scratch), "%%st(%d)", ins->modrm.rm);
10461 oappend_register (ins, scratch);
10467 putop (instr_info *ins, const char *in_template, int sizeflag)
10479 oappend (ins, "(bad)");
10480 *ins->obufp = 0;
10481 ins->mnemonicendp = ins->obufp;
10497 if (ins->evex_type == evex_from_legacy && !ins->vex.nd
10498 && !(ins->rex2 & 7) && !evex_printed)
10500 oappend (ins, "{evex} ");
10503 *ins->obufp++ = *p;
10512 if (ins->intel_syntax)
10531 if (ins->intel_syntax)
10533 if ((ins->need_modrm && ins->modrm.mod != 3 && !ins->vex.nd)
10535 *ins->obufp++ = 'b';
10541 if (ins->intel_syntax)
10544 *ins->obufp++ = 'b';
10548 if (ins->address_mode == mode_64bit
10549 && !(ins->prefixes & PREFIX_ADDR))
10551 *ins->obufp++ = 'a';
10552 *ins->obufp++ = 'b';
10553 *ins->obufp++ = 's';
10560 if (!ins->vex.w)
10561 oappend (ins, "bf16");
10563 oappend (ins, "{bad}");
10572 for (const char *q = dis386[0x70 | ins->condition_code].name + 1;
10574 *ins->obufp++ = *q;
10580 oappend (ins, scc_suffix[ins->vex.scc]);
10583 if (ins->vex.nd)
10584 oappend (ins, "(bad)");
10588 ins->vex.v = 1;
10589 ins->vex.nf = false;
10590 ins->vex.mask_register_specifier = 0;
10596 if (ins->intel_syntax && !alt)
10598 if ((ins->prefixes & PREFIX_DATA) || (sizeflag & SUFFIX_ALWAYS))
10601 *ins->obufp++ = ins->intel_syntax ? 'd' : 'l';
10603 *ins->obufp++ = ins->intel_syntax ? 'w' : 's';
10604 ins->used_prefixes |= (ins->prefixes & PREFIX_DATA);
10613 if (!ins->vex.evex || ins->vex.w)
10614 *ins->obufp++ = 'd';
10616 oappend (ins, "{bad}");
10625 if (ins->intel_syntax || !(sizeflag & SUFFIX_ALWAYS))
10628 if (ins->modrm.mod == 3)
10630 if (ins->rex & REX_W)
10631 *ins->obufp++ = 'q';
10635 *ins->obufp++ = ins->intel_syntax ? 'd' : 'l';
10637 *ins->obufp++ = 'w';
10638 ins->used_prefixes |= (ins->prefixes & PREFIX_DATA);
10642 *ins->obufp++ = 'w';
10650 if (ins->modrm.mod != 3)
10654 if (!ins->vex.evex || ins->vex.b || ins->vex.ll >= 2
10655 || (ins->rex2 & 7)
10656 || (ins->modrm.mod == 3 && (ins->rex & REX_X))
10657 || !ins->vex.v || ins->vex.mask_register_specifier)
10662 if (ins->vex.w)
10669 *ins->obufp++ = '{';
10670 *ins->obufp++ = 'e';
10671 *ins->obufp++ = 'v';
10672 *ins->obufp++ = 'e';
10673 *ins->obufp++ = 'x';
10674 *ins->obufp++ = '}';
10675 *ins->obufp++ = ' ';
10687 if (ins->address_mode == mode_64bit)
10690 *ins->obufp++ = 'r';
10692 *ins->obufp++ = 'e';
10696 *ins->obufp++ = 'e';
10697 ins->used_prefixes |= (ins->prefixes & PREFIX_ADDR);
10702 if (ins->intel_syntax)
10704 if ((ins->prefixes & PREFIX_ADDR) || (sizeflag & SUFFIX_ALWAYS))
10707 *ins->obufp++ = ins->address_mode == mode_64bit ? 'q' : 'l';
10709 *ins->obufp++ = ins->address_mode == mode_64bit ? 'l' : 'w';
10710 ins->used_prefixes |= (ins->prefixes & PREFIX_ADDR);
10715 if (ins->vex.nd && !ins->vex.nf)
10717 *ins->obufp++ = 'c';
10718 *ins->obufp++ = 'f';
10724 if (ins->vex.nf)
10726 oappend (ins, "{nf} ");
10728 ins->vex.nf = false;
10731 else if (ins->evex_type == evex_from_vex && !(ins->rex2 & 7)
10732 && ins->vex.v)
10734 oappend (ins, "{evex} ");
10741 int oszc_value = ~ins->vex.register_specifier & 0xf;
10744 oappend (ins, oszc_flags[oszc_value]);
10747 ins->vex.register_specifier = 0;
10753 if (ins->intel_syntax || (ins->obufp[-1] != 's'
10756 if ((ins->rex & REX_W) || (sizeflag & DFLAG))
10757 *ins->obufp++ = 'l';
10759 *ins
10760 if (!(ins->rex & REX_W))
10761 ins->used_prefixes |= (ins->prefixes & PREFIX_DATA);
10766 if (ins->intel_syntax)
10768 if ((ins->prefixes & (PREFIX_CS | PREFIX_DS)) == PREFIX_CS
10769 || (ins->prefixes & (PREFIX_CS | PREFIX_DS)) == PREFIX_DS)
10771 ins->used_prefixes |= ins->prefixes & (PREFIX_CS | PREFIX_DS);
10772 *ins->obufp++ = ',';
10773 *ins->obufp++ = 'p';
10777 if (ins->prefixes & PREFIX_DS)
10779 ins->active_seg_prefix = PREFIX_DS;
10780 *ins->obufp++ = 't';
10784 ins->active_seg_prefix = PREFIX_CS;
10785 *ins->obufp++ = 'n';
10791 if (!ins->vex.w)
10792 *ins->obufp++ = 'h';
10794 oappend (ins, "{bad}");
10801 if (ins->rex & REX_W)
10802 *ins->obufp++ = 'q';
10804 *ins->obufp++ = 'd';
10807 if (ins->intel_syntax)
10811 if (ins->rex & REX_W)
10812 *ins->obufp++ = 'q';
10814 *ins->obufp++ = 'l';
10818 if (ins->intel_mnemonic != cond)
10819 *ins->obufp++ = 'r';
10822 if ((ins->prefixes & PREFIX_FWAIT) == 0)
10823 *ins->obufp++ = 'n';
10825 ins->used_prefixes |= PREFIX_FWAIT;
10829 if (ins->rex & REX_W)
10830 *ins->obufp++ = 'o';
10831 else if (ins->intel_syntax && (sizeflag & DFLAG))
10832 *ins->obufp++ = 'q';
10834 *ins->obufp++ = 'd';
10835 if (!(ins->rex & REX_W))
10836 ins->used_prefixes |= (ins->prefixes & PREFIX_DATA);
10839 if (ins->address_mode == mode_64bit
10840 && (ins->isa64 == intel64 || (ins->rex & REX_W)
10841 || !(ins->prefixes & PREFIX_DATA)))
10844 *ins->obufp++ = 'q';
10851 if (!cond && ins->last_rex2_prefix >= 0 && (ins->rex & REX_W))
10855 *ins->obufp++ = 'p';
10856 ins->rex2 |= REX2_SPECIAL;
10861 if (!cond && ins->intel_syntax)
10864 if ((ins->modrm.mod == 3 || !cond)
10869 if ((!(ins->rex & REX_W) && (ins->prefixes & PREFIX_DATA))
10871 && ins->address_mode != mode_64bit))
10873 *ins->obufp++ = (sizeflag & DFLAG)
10874 ? ins->intel_syntax ? 'd' : 'l' : 'w';
10875 ins->used_prefixes |= (ins->prefixes & PREFIX_DATA);
10878 *ins->obufp++ = 'q';
10882 if ((ins->prefixes & PREFIX_DATA)
10883 || (ins->rex & REX_W)
10887 if (ins->rex & REX_W)
10888 *ins->obufp++ = 'q';
10892 *ins->obufp++ = ins->intel_syntax ? 'd' : 'l';
10894 *ins->obufp++ = 'w';
10895 ins->used_prefixes |= (ins->prefixes & PREFIX_DATA);
10905 if (ins->intel_syntax && !alt)
10908 if ((ins->need_modrm && ins->modrm.mod != 3 && !ins->vex.nd)
10911 if (ins->rex & REX_W)
10912 *ins->obufp++ = 'q';
10916 *ins->obufp++ = ins->intel_syntax ? 'd' : 'l';
10918 *ins->obufp++ = 'w';
10919 ins->used_prefixes |= (ins->prefixes & PREFIX_DATA);
10924 *ins->obufp++ = ins->vex.w ? 'q' : 'd';
10927 if (cond ? ins->modrm.mod == 3 && !(sizeflag & SUFFIX_ALWAYS)
10928 : ins->address_mode != mode_64bit)
10930 if ((ins->rex & REX_W))
10933 *ins->obufp++ = 'q';
10935 else if ((ins->address_mode == mode_64bit && cond)
10937 *ins->obufp++ = ins->intel_syntax? 'd' : 'l';
10944 if (ins->rex & REX_W)
10945 *ins->obufp++ = 'q';
10948 if (ins->intel_syntax)
10949 *ins->obufp++ = 'd';
10951 *ins->obufp++ = 'l';
10954 *ins->obufp++ = 'w';
10955 if (ins->intel_syntax && !p[1]
10956 && ((ins->rex & REX_W) || (sizeflag & DFLAG)))
10957 *ins->obufp++ = 'e';
10958 if (!(ins->rex & REX_W))
10959 ins->used_prefixes |= (ins->prefixes & PREFIX_DATA);
10965 if (ins->intel_syntax)
10969 if (ins->rex & REX_W)
10970 *ins->obufp++ = 'q';
10974 *ins->obufp++ = 'l';
10976 *ins->obufp++ = 'w';
10977 ins->used_prefixes |= (ins->prefixes & PREFIX_DATA);
10987 if (ins->address_mode == mode_64bit
10988 && !(ins->prefixes & PREFIX_ADDR))
10990 *ins->obufp++ = 'a';
10991 *ins->obufp++ = 'b';
10992 *ins->obufp++ = 's';
10997 if (!ins->vex.evex || !ins->vex.w)
10998 *ins->obufp++ = 's';
11000 oappend (ins, "{bad}");
11012 if (ins->vex.nd)
11013 oappend (ins, "zu");
11021 if (ins->need_vex)
11022 *ins->obufp++ = 'v';
11029 if (ins->vex.evex)
11031 *ins->obufp++ = '{';
11032 *ins->obufp++ = 'v';
11033 *ins->obufp++ = 'e';
11034 *ins->obufp++ = 'x';
11035 *ins->obufp++ = '}';
11036 *ins->obufp++ = ' ';
11039 if (ins->rex & REX_W)
11041 *ins->obufp++ = 'a';
11042 *ins->obufp++ = 'b';
11043 *ins->obufp++ = 's';
11058 if (ins->rex & REX_W)
11060 if (ins->intel_syntax)
11061 *ins->obufp++ = 'd';
11063 *ins->obufp++ = 'l';
11066 *ins->obufp++ = 'w';
11068 *ins->obufp++ = 'b';
11069 if (!(ins->rex & REX_W))
11070 ins->used_prefixes |= (ins->prefixes & PREFIX_DATA);
11074 if (!ins->need_vex)
11077 *ins->obufp++ = ins->vex.w ? 'd': 's';
11079 *ins->obufp++ = ins->vex.w ? 'w': 'b';
11089 if (ins->need_vex
11090 ? ins->vex.prefix == DATA_PREFIX_OPCODE
11091 : ins->prefixes & PREFIX_DATA)
11093 *ins->obufp++ = 'd';
11094 ins->used_prefixes |= PREFIX_DATA;
11097 *ins->obufp++ = 's';
11102 if (ins->vex.mask_register_specifier)
11103 ins->illegal_masking = true;
11107 if (!ins->need_vex)
11109 if (ins->intel_syntax
11110 || ((ins->modrm.mod == 3 || ins->vex.b)
11113 switch (ins->vex.length)
11116 *ins->obufp++ = 'x';
11119 *ins->obufp++ = 'y';
11122 if (!ins->vex.evex)
11134 ins->modrm.mod = 3;
11135 if (!ins->intel_syntax && (sizeflag & SUFFIX_ALWAYS))
11136 *ins->obufp++ = ins->address_mode == mode_64bit ? 'q' : 'l';
11140 if (!ins->vex.evex)
11142 if (ins->intel_syntax
11143 || ((ins->modrm.mod == 3 || ins->vex.b)
11146 switch (ins->vex.length)
11149 *ins->obufp++ = 'x';
11152 *ins->obufp++ = 'y';
11155 *ins->obufp++ = 'z';
11165 if (ins->intel_syntax)
11167 if (ins->isa64 == intel64 && (ins->rex & REX_W))
11170 *ins->obufp++ = 'q';
11173 if ((ins->prefixes & PREFIX_DATA) || (sizeflag & SUFFIX_ALWAYS))
11176 *ins->obufp++ = 'l';
11178 *ins->obufp++ = 'w';
11179 ins->used_prefixes |= (ins->prefixes & PREFIX_DATA);
11187 *ins->obufp = 0;
11188 ins->mnemonicendp = ins->obufp;
11192 /* Add a style marker to *INS->obufp that encodes STYLE. This assumes that
11193 the buffer pointed to by INS->obufp has space. A style marker is made
11199 oappend_insert_style (instr_info *ins, enum disassembler_style style)
11209 *ins->obufp++ = STYLE_MARKER_CHAR;
11210 *ins->obufp++ = (num < 10 ? ('0' + num)
11212 *ins->obufp++ = STYLE_MARKER_CHAR;
11220 *ins->obufp = '\0';
11224 oappend_with_style (instr_info *ins, const char *s,
11227 oappend_insert_style (ins, style);
11228 ins->obufp = stpcpy (ins->obufp, s);
11231 /* Add a single character C to the buffer pointer to by INS->obufp, marking
11235 oappend_char_with_style (instr_info *ins, const char c,
11238 oappend_insert_style (ins, style);
11239 *ins->obufp++ = c;
11240 *ins->obufp = '\0';
11246 oappend_char (instr_info *ins, const char c)
11248 oappend_char_with_style (ins, c, dis_style_text);
11252 append_seg (instr_info *ins)
11255 if (!ins->active_seg_prefix)
11258 ins->used_prefixes |= ins->active_seg_prefix;
11259 switch (ins->active_seg_prefix)
11262 oappend_register (ins, att_names_seg[1]);
11265 oappend_register (ins, att_names_seg[3]);
11268 oappend_register (ins, att_names_seg[2]);
11271 oappend_register (ins, att_names_seg[0]);
11274 oappend_register (ins, att_names_seg[4]);
11277 oappend_register (ins, att_names_seg[5]);
11282 oappend_char (ins, ':');
11286 print_operand_value (instr_info *ins, bfd_vma disp,
11291 if (ins->address_mode != mode_64bit)
11294 oappend_with_style (ins, tmp, style);
11300 oappend_immediate (instr_info *ins, bfd_vma imm)
11302 if (!ins->intel_syntax)
11303 oappend_char_with_style (ins, '$', dis_style_immediate);
11304 print_operand_value (ins, imm, dis_style_immediate);
11310 print_displacement (instr_info *ins, bfd_signed_vma val)
11316 oappend_char_with_style (ins, '-', dis_style_address_offset);
11322 switch (ins->address_mode)
11325 oappend_with_style (ins, "0x8000000000000000",
11329 oappend_with_style (ins, "0x80000000",
11333 oappend_with_style (ins, "0x8000",
11342 oappend_with_style (ins, tmp, dis_style_address_offset);
11346 intel_operand_size (instr_info *ins, int bytemode, int sizeflag)
11349 if (ins->vex.b && ins->evex_type == evex_default)
11351 if (!ins->vex.no_broadcast)
11356 if (ins->vex.w)
11357 oappend (ins, "QWORD BCST ");
11359 oappend (ins, "DWORD BCST ");
11364 oappend (ins, "WORD BCST ");
11367 ins->vex.no_broadcast = true;
11377 oappend (ins, "BYTE PTR ");
11382 oappend (ins, "WORD PTR ");
11385 if (ins->address_mode == mode_64bit && ins->isa64 == intel64)
11387 oappend (ins, "QWORD PTR ");
11392 if (ins->address_mode == mode_64bit && ((sizeflag & DFLAG)
11393 || (ins->rex & REX_W)))
11395 oappend (ins, "QWORD PTR ");
11403 if (ins->rex & REX_W)
11404 oappend (ins, "QWORD PTR ");
11406 oappend (ins, "DWORD PTR ");
11410 oappend (ins, "DWORD PTR ");
11412 oappend (ins, "WORD PTR ");
11413 ins->used_prefixes |= (ins->prefixes & PREFIX_DATA);
11417 if ((ins->rex & REX_W) || (sizeflag & DFLAG))
11418 *ins->obufp++ = 'D';
11419 oappend (ins, "WORD PTR ");
11420 if (!(ins->rex & REX_W))
11421 ins->used_prefixes |= (ins->prefixes & PREFIX_DATA);
11425 oappend (ins, "QWORD PTR ");
11427 oappend (ins, "DWORD PTR ");
11428 ins->used_prefixes |= (ins->prefixes & PREFIX_DATA);
11431 if (!(sizeflag & DFLAG) && ins->isa64 == intel64)
11432 oappend (ins, "WORD PTR ");
11434 oappend (ins, "DWORD PTR ");
11435 ins->used_prefixes |= (ins->prefixes & PREFIX_DATA);
11439 oappend (ins, "DWORD PTR ");
11443 oappend (ins, "QWORD PTR ");
11446 if (ins->address_mode == mode_64bit)
11447 oappend (ins, "QWORD PTR ");
11449 oappend (ins, "DWORD PTR ");
11453 oappend (ins, "FWORD PTR ");
11455 oappend (ins, "DWORD PTR ");
11456 ins->used_prefixes |= (ins->prefixes & PREFIX_DATA);
11459 oappend (ins, "TBYTE PTR ");
11467 if (ins->need_vex)
11469 switch (ins->vex.length)
11472 oappend (ins, "XMMWORD PTR ");
11475 oappend (ins, "YMMWORD PTR ");
11478 oappend (ins, "ZMMWORD PTR ");
11485 oappend (ins, "XMMWORD PTR ");
11488 oappend (ins, "XMMWORD PTR ");
11491 oappend (ins, "YMMWORD PTR ");
11496 switch (ins->vex.length)
11500 oappend (ins, "QWORD PTR ");
11503 oappend (ins, "XMMWORD PTR ");
11506 oappend (ins, "YMMWORD PTR ");
11513 if (!ins->need_vex)
11516 switch (ins->vex.length)
11519 oappend (ins, "WORD PTR ");
11522 oappend (ins, "DWORD PTR ");
11525 oappend (ins, "QWORD PTR ");
11533 if (!ins->need_vex)
11536 switch (ins->vex.length)
11539 oappend (ins, "DWORD PTR ");
11542 oappend (ins, "QWORD PTR ");
11545 oappend (ins, "XMMWORD PTR ");
11552 if (!ins->need_vex)
11555 switch (ins->vex.length)
11558 oappend (ins, "QWORD PTR ");
11561 oappend (ins, "YMMWORD PTR ");
11564 oappend (ins, "ZMMWORD PTR ");
11571 oappend (ins, "OWORD PTR ");
11575 if (!ins->need_vex)
11577 if (ins->vex.w)
11578 oappend (ins, "QWORD PTR ");
11580 oappend (ins, "DWORD PTR ");
11583 if (!ins->need_vex || ins->vex.length != 128)
11585 if (ins->vex.w)
11586 oappend (ins, "DWORD PTR ");
11588 oappend (ins, "BYTE PTR ");
11591 if (!ins->need_vex)
11593 if (ins->vex.w)
11594 oappend (ins, "QWORD PTR ");
11596 oappend (ins, "WORD PTR ");
11606 print_register (instr_info *ins, unsigned int reg, unsigned int rexmask,
11613 if (bytemode != mask_mode && ins->vex.mask_register_specifier)
11614 ins->illegal_masking = true;
11617 if (ins->rex & rexmask)
11619 if (ins->rex2 & rexmask)
11628 if (ins->rex || ins->rex2)
11646 names = ins->address_mode == mode_64bit ? att_names64 : att_names32;
11652 oappend (ins, "(bad)");
11658 if (ins->address_mode == mode_64bit && ins->isa64 == intel64)
11665 if (ins->address_mode == mode_64bit && ((sizeflag & DFLAG)
11666 || (ins->rex & REX_W)))
11677 if (ins->rex & REX_W)
11687 ins->used_prefixes |= (ins->prefixes & PREFIX_DATA);
11691 if (!(sizeflag & DFLAG) && ins->isa64 == intel64)
11695 ins->used_prefixes |= (ins->prefixes & PREFIX_DATA);
11698 names = (ins->address_mode == mode_64bit
11700 if (!(ins->prefixes & PREFIX_ADDR))
11701 names = (ins->address_mode == mode_16bit
11706 ins->all_prefixes[ins->last_addr_prefix] = 0;
11707 names = (ins->address_mode != mode_32bit
11709 ins->used_prefixes |= PREFIX_ADDR;
11716 oappend (ins, "(bad)");
11724 oappend (ins, INTERNAL_DISASSEMBLER_ERROR);
11727 oappend_register (ins, names[reg]);
11731 get8s (instr_info *ins, bfd_vma *res)
11733 if (!fetch_code (ins->info, ins->codep + 1))
11735 *res = ((bfd_vma) *ins->codep++ ^ 0x80) - 0x80;
11740 get16 (instr_info *ins, bfd_vma *res)
11742 if (!fetch_code (ins->info, ins->codep + 2))
11744 *res = *ins->codep++;
11745 *res |= (bfd_vma) *ins->codep++ << 8;
11750 get16s (instr_info *ins, bfd_vma *res)
11752 if (!get16 (ins, res))
11759 get32 (instr_info *ins, bfd_vma *res)
11761 if (!fetch_code (ins->info, ins->codep + 4))
11763 *res = *ins->codep++;
11764 *res |= (bfd_vma) *ins->codep++ << 8;
11765 *res |= (bfd_vma) *ins->codep++ << 16;
11766 *res |= (bfd_vma) *ins->codep++ << 24;
11771 get32s (instr_info *ins, bfd_vma *res)
11773 if (!get32 (ins, res))
11782 get64 (instr_info *ins, uint64_t *res)
11787 if (!fetch_code (ins->info, ins->codep + 8))
11789 a = *ins->codep++;
11790 a |= (unsigned int) *ins->codep++ << 8;
11791 a |= (unsigned int) *ins->codep++ << 16;
11792 a |= (unsigned int) *ins->codep++ << 24;
11793 b = *ins->codep++;
11794 b |= (unsigned int) *ins->codep++ << 8;
11795 b |= (unsigned int) *ins->codep++ << 16;
11796 b |= (unsigned int) *ins->codep++ << 24;
11802 set_op (instr_info *ins, bfd_vma op, bool riprel)
11804 ins->op_index[ins->op_ad] = ins->op_ad;
11805 if (ins->address_mode == mode_64bit)
11806 ins->op_address[ins->op_ad] = op;
11808 ins->op_address[ins->op_ad] = op & 0xffffffff;
11809 ins->op_riprel[ins->op_ad] = riprel;
11813 BadOp (instr_info *ins)
11816 struct dis_private *priv = ins->info->private_data;
11818 ins->codep = priv->the_buffer + ins->nr_prefixes + ins->need_vex + 1;
11819 ins->obufp = stpcpy (ins->obufp, "(bad)");
11824 OP_Skip_MODRM (instr_info *ins, int bytemode ATTRIBUTE_UNUSED,
11827 if (ins->modrm.mod != 3)
11828 return BadOp (ins);
11832 ins->codep++;
11833 ins->has_skipped_modrm = true;
11838 OP_E_memory (instr_info *ins, int bytemode, int sizeflag)
11840 int add = (ins->rex & REX_B) ? 8 : 0;
11844 add += (ins->rex2 & REX_B) ? 16 : 0;
11847 if (ins->vex.evex && ins->evex_type == evex_default)
11853 if (ins->vex.zeroing)
11854 ins->illegal_masking = true;
11868 if (ins->address_mode != mode_64bit)
11879 shift = ins->vex.w ? 3 : 2;
11884 if (ins->vex.b)
11886 shift = ins->vex.w ? 2 : 1;
11892 if (ins->vex.b)
11894 shift = ins->vex.w ? 3 : 2;
11904 switch (ins->vex.length)
11922 || (bytemode == ymmq_mode && ins->vex.length == 128))
11941 shift = ins->vex.w ? 1 : 0;
11951 if (ins->intel_syntax)
11952 intel_operand_size (ins, bytemode, sizeflag);
11953 append_seg (ins);
11955 if ((sizeflag & AFLAG) || ins->address_mode == mode_64bit)
11975 base = ins->modrm.rm;
11979 vindex = ins->sib.index;
11981 if (ins->rex & REX_X)
11987 if (!ins->need_vex)
11989 if (ins->vex.evex)
11992 if (ins->rex2 & REX_X)
11994 oappend (ins, "(bad)");
11998 if (!ins->vex.v)
12000 check_gather = ins->obufp == ins->op_out[1];
12003 switch (ins->vex.length)
12009 if (!ins->vex.w
12016 if (!ins->vex.w
12027 if (ins->rex2 & REX_X)
12031 indexes = ins->address_mode == mode_64bit && !addr32flag
12035 scale = ins->sib.scale;
12036 base = ins->sib.base;
12037 ins->codep++;
12046 oappend (ins, "(bad)");
12052 switch (ins->modrm.mod)
12058 if (ins->address_mode == mode_64bit && !ins->has_sib)
12060 if (!get32s (ins, &disp))
12064 oappend (ins, "(bad)");
12070 if (!get8s (ins, &disp))
12072 if (ins->vex.evex && shift > 0)
12076 if (!get32s (ins, &disp))
12083 if (ins->has_sib
12086 && ins->address_mode != mode_16bit)
12088 if (ins->address_mode == mode_64bit)
12109 || (ins->has_sib && (indexes || scale != 0)));
12111 if (!ins->intel_syntax)
12112 if (ins->modrm.mod != 0 || base == 5)
12115 print_displacement (ins, disp);
12117 print_operand_value (ins, disp, dis_style_address_offset);
12120 set_op (ins, disp, true);
12121 oappend_char (ins, '(');
12122 oappend_with_style (ins, !addr32flag ? "%rip" : "%eip",
12124 oappend_char (ins, ')');
12129 && (ins->address_mode != mode_64bit
12134 ins->used_prefixes |= PREFIX_ADDR;
12136 if (havedisp || (ins->intel_syntax && riprel))
12138 oappend_char (ins, ins->open_char);
12139 if (ins->intel_syntax && riprel)
12141 set_op (ins, disp, true);
12142 oappend_with_style (ins, !addr32flag ? "rip" : "eip",
12147 (ins,
12148 (ins->address_mode == mode_64bit && !addr32flag
12150 if (ins->has_sib)
12159 if (!ins->intel_syntax || havebase)
12160 oappend_char (ins, ins->separator_char);
12163 if (ins->address_mode == mode_64bit || vindex < 16)
12164 oappend_register (ins, indexes[vindex]);
12166 oappend (ins, "(bad)");
12169 oappend_register (ins,
12170 ins->address_mode == mode_64bit
12175 oappend_char (ins, ins->scale_char);
12176 oappend_char_with_style (ins, '0' + (1 << scale),
12180 if (ins->intel_syntax
12181 && (disp || ins->modrm.mod != 0 || base == 5))
12184 oappend_char (ins, '+');
12186 print_displacement (ins, disp);
12188 print_operand_value (ins, disp, dis_style_address_offset);
12191 oappend_char (ins, ins->close_char);
12196 int modrm_reg = ins->modrm.reg;
12198 if (ins->rex & REX_R)
12200 if (ins->rex2 & REX_R)
12203 oappend (ins, "/(bad)");
12206 else if (ins->intel_syntax)
12208 if (ins->modrm.mod != 0 || base == 5)
12210 if (!ins->active_seg_prefix)
12212 oappend_register (ins, att_names_seg[ds_reg - es_reg]);
12213 oappend (ins, ":");
12215 print_operand_value (ins, disp, dis_style_text);
12226 oappend (ins, "(bad)");
12234 ins->used_prefixes |= ins->prefixes & PREFIX_ADDR;
12235 switch (ins->modrm.mod)
12238 if (ins->modrm.rm == 6)
12241 if (!get16s (ins, &disp))
12246 if (!get8s (ins, &disp))
12248 if (ins->vex.evex && shift > 0)
12253 if (!ins->intel_syntax)
12254 if (ins->modrm.mod != 0 || ins->modrm.rm == 6)
12255 print_displacement (ins, disp);
12257 if (ins->modrm.mod != 0 || ins->modrm.rm != 6)
12259 oappend_char (ins, ins->open_char);
12260 oappend (ins, ins->intel_syntax ? intel_index16[ins->modrm.rm]
12261 : att_index16[ins->modrm.rm]);
12262 if (ins->intel_syntax
12263 && (disp || ins->modrm.mod != 0 || ins->modrm.rm == 6))
12266 oappend_char (ins, '+');
12267 print_displacement (ins, disp);
12270 oappend_char (ins, ins->close_char);
12272 else if (ins->intel_syntax)
12274 if (!ins->active_seg_prefix)
12276 oappend_register (ins, att_names_seg[ds_reg - es_reg]);
12277 oappend (ins, ":");
12279 print_operand_value (ins, disp & 0xffff, dis_style_text);
12282 if (ins->vex.b && ins->evex_type == evex_default)
12284 ins->evex_used |= EVEX_b_used;
12287 if (ins->obufp == ins->op_out[0])
12288 ins->vex.no_broadcast = true;
12290 if (!ins->vex.no_broadcast
12291 && (!ins->intel_syntax || !(ins->evex_used & EVEX_len_used)))
12295 switch (ins->vex.length)
12298 oappend (ins, "{1to8}");
12301 oappend (ins, "{1to16}");
12304 oappend (ins, "{1to32}");
12312 ins->vex.no_broadcast = true;
12313 else if (ins->vex.w
12317 switch (ins->vex.length)
12320 oappend (ins, "{1to2}");
12323 oappend (ins, "{1to4}");
12326 oappend (ins, "{1to8}");
12335 switch (ins->vex.length)
12338 oappend (ins, "{1to4}");
12341 oappend (ins, "{1to8}");
12344 oappend (ins, "{1to16}");
12351 ins->vex.no_broadcast = true;
12353 if (ins->vex.no_broadcast)
12354 oappend (ins, "{bad}");
12361 OP_E (instr_info *ins, int bytemode, int sizeflag)
12365 if (!ins->has_skipped_modrm)
12367 ins->codep++;
12368 ins->has_skipped_modrm = true;
12371 if (ins->modrm.mod == 3)
12377 swap_operand (ins);
12379 print_register (ins, ins->modrm.rm, REX_B, bytemode, sizeflag);
12386 if (ins->vex.mask_register_specifier)
12387 ins->illegal_masking = true;
12389 return OP_E_memory (ins, bytemode, sizeflag);
12393 OP_indirE (instr_info *ins, int bytemode, int sizeflag)
12395 if (ins->modrm.mod == 3 && bytemode == f_mode)
12397 return BadOp (ins);
12398 if (!ins->intel_syntax)
12399 oappend (ins, "*");
12400 return OP_E (ins, bytemode, sizeflag);
12404 OP_G (instr_info *ins, int bytemode, int sizeflag)
12406 print_register (ins, ins->modrm.reg, REX_R, bytemode, sizeflag);
12411 OP_REG (instr_info *ins, int code, int sizeflag)
12420 oappend_register (ins, att_names_seg[code - es_reg]);
12425 if (ins->rex & REX_B)
12427 if (ins->rex2 & REX_B)
12440 if (ins->rex)
12447 if (ins->address_mode == mode_64bit
12448 && ((sizeflag & DFLAG) || (ins->rex & REX_W)))
12458 if (ins->rex & REX_W)
12466 ins->used_prefixes |= (ins->prefixes & PREFIX_DATA);
12470 oappend (ins, INTERNAL_DISASSEMBLER_ERROR);
12473 oappend_register (ins, s);
12478 OP_IMREG (instr_info *ins, int code, int sizeflag)
12485 if (!ins->intel_syntax)
12487 oappend (ins, "(%dx)");
12497 if (ins->rex & REX_W)
12504 if ((ins->rex & REX_W) || (sizeflag & DFLAG))
12508 if (!(ins->rex & REX_W))
12509 ins->used_prefixes |= (ins->prefixes & PREFIX_DATA);
12512 oappend (ins, INTERNAL_DISASSEMBLER_ERROR);
12515 oappend_register (ins, s);
12520 OP_I (instr_info *ins, int bytemode, int sizeflag)
12527 if (!fetch_code (ins->info, ins->codep + 1))
12529 op = *ins->codep++;
12533 if (ins->rex & REX_W)
12535 if (!get32s (ins, &op))
12540 ins->used_prefixes |= (ins->prefixes & PREFIX_DATA);
12544 if (!get32 (ins, &op))
12551 if (!get16 (ins, &op))
12557 if (ins->intel_syntax)
12558 oappend_with_style (ins, "1", dis_style_immediate);
12560 oappend_with_style (ins, "$1", dis_style_immediate);
12563 oappend (ins, INTERNAL_DISASSEMBLER_ERROR);
12567 oappend_immediate (ins, op);
12572 OP_I64 (instr_info *ins, int bytemode, int sizeflag)
12576 if (bytemode != v_mode || ins->address_mode != mode_64bit
12577 || !(ins->rex & REX_W))
12578 return OP_I (ins, bytemode, sizeflag);
12582 if (!get64 (ins, &op))
12585 oappend_immediate (ins, op);
12590 OP_sI (instr_info *ins, int bytemode, int sizeflag)
12598 if (!get8s (ins, &op))
12602 if (ins->address_mode != mode_64bit
12603 || !((sizeflag & DFLAG) || (ins->rex & REX_W)))
12606 if ((sizeflag & DFLAG) || (ins->rex & REX_W))
12614 if (!(ins->rex & REX_W))
12625 if (!(sizeflag & DFLAG) && !(ins->rex & REX_W))
12627 if (!get16 (ins, &op))
12630 else if (!get32s (ins, &op))
12634 oappend (ins, INTERNAL_DISASSEMBLER_ERROR);
12638 oappend_immediate (ins, op);
12643 OP_J (instr_info *ins, int bytemode, int sizeflag)
12652 if (!get8s (ins, &disp))
12658 || (ins->address_mode == mode_64bit
12659 && ((ins->isa64 == intel64 && bytemode != dqw_mode)
12660 || (ins->rex & REX_W))))
12662 if (!get32s (ins, &disp))
12667 if (!get16s (ins, &disp))
12674 if ((ins->prefixes & PREFIX_DATA) == 0)
12675 segment = ((ins->start_pc + (ins->codep - ins->start_codep))
12678 if (ins->address_mode != mode_64bit
12679 || (ins->isa64 != intel64 && !(ins->rex & REX_W)))
12680 ins->used_prefixes |= (ins->prefixes & PREFIX_DATA);
12683 oappend (ins, INTERNAL_DISASSEMBLER_ERROR);
12686 disp = ((ins->start_pc + (ins->codep - ins->start_codep) + disp) & mask)
12688 set_op (ins, disp, false);
12689 print_operand_value (ins, disp, dis_style_text);
12694 OP_SEG (instr_info *ins, int bytemode, int sizeflag)
12698 oappend_register (ins, att_names_seg[ins->modrm.reg]);
12701 return OP_E (ins, ins->modrm.mod == 3 ? bytemode : w_mode, sizeflag);
12705 OP_DIR (instr_info *ins, int dummy ATTRIBUTE_UNUSED, int sizeflag)
12713 if (!get32 (ins, &offset))
12716 else if (!get16 (ins, &offset))
12718 if (!get16 (ins, &seg))
12720 ins->used_prefixes |= (ins->prefixes & PREFIX_DATA);
12723 ins->intel_syntax ? "0x%x:0x%x" : "$0x%x,$0x%x",
12727 oappend (ins, scratch);
12732 OP_OFF (instr_info *ins, int bytemode, int sizeflag)
12736 if (ins->intel_syntax && (sizeflag & SUFFIX_ALWAYS))
12737 intel_operand_size (ins, bytemode, sizeflag);
12738 append_seg (ins);
12740 if ((sizeflag & AFLAG) || ins->address_mode == mode_64bit)
12742 if (!get32 (ins, &off))
12747 if (!get16 (ins, &off))
12751 if (ins->intel_syntax)
12753 if (!ins->active_seg_prefix)
12755 oappend_register (ins, att_names_seg[ds_reg - es_reg]);
12756 oappend (ins, ":");
12759 print_operand_value (ins, off, dis_style_address_offset);
12764 OP_OFF64 (instr_info *ins, int bytemode, int sizeflag)
12768 if (ins->address_mode != mode_64bit
12769 || (ins->prefixes & PREFIX_ADDR))
12770 return OP_OFF (ins, bytemode, sizeflag);
12772 if (ins->intel_syntax && (sizeflag & SUFFIX_ALWAYS))
12773 intel_operand_size (ins, bytemode, sizeflag);
12774 append_seg (ins);
12776 if (!get64 (ins, &off))
12779 if (ins->intel_syntax)
12781 if (!ins->active_seg_prefix)
12783 oappend_register (ins, att_names_seg[ds_reg - es_reg]);
12784 oappend (ins, ":");
12787 print_operand_value (ins, off, dis_style_address_offset);
12792 ptr_reg (instr_info *ins, int code, int sizeflag)
12796 *ins->obufp++ = ins->open_char;
12797 ins->used_prefixes |= (ins->prefixes & PREFIX_ADDR);
12798 if (ins->address_mode == mode_64bit)
12809 oappend_register (ins, s);
12810 oappend_char (ins, ins->close_char);
12814 OP_ESreg (instr_info *ins, int code, int sizeflag)
12816 if (ins->intel_syntax)
12818 switch (ins->codep[-1])
12821 intel_operand_size (ins, z_mode, sizeflag);
12827 intel_operand_size (ins, v_mode, sizeflag);
12830 intel_operand_size (ins, b_mode, sizeflag);
12833 oappend_register (ins, att_names_seg[0]);
12834 oappend_char (ins, ':');
12835 ptr_reg (ins, code, sizeflag);
12840 OP_DSreg (instr_info *ins, int code, int sizeflag)
12842 if (ins->intel_syntax)
12844 switch (ins->codep[-1])
12847 intel_operand_size (ins, z_mode, sizeflag);
12852 intel_operand_size (ins, v_mode, sizeflag);
12855 intel_operand_size (ins, b_mode, sizeflag);
12858 /* Set ins->active_seg_prefix to PREFIX_DS if it is unset so that the
12860 if (!ins->active_seg_prefix)
12861 ins->active_seg_prefix = PREFIX_DS;
12862 append_seg (ins);
12863 ptr_reg (ins, code, sizeflag);
12868 OP_C (instr_info *ins, int dummy ATTRIBUTE_UNUSED,
12874 if (ins->rex & REX_R)
12879 else if (ins->address_mode != mode_64bit && (ins->prefixes & PREFIX_LOCK))
12881 ins->all_prefixes[ins->last_lock_prefix] = 0;
12882 ins->used_prefixes |= PREFIX_LOCK;
12888 ins->modrm.reg + add);
12891 oappend_register (ins, scratch);
12896 OP_D (instr_info *ins, int dummy ATTRIBUTE_UNUSED,
12903 if (ins->rex & REX_R)
12908 ins->intel_syntax ? "dr%d" : "%%db%d",
12909 ins->modrm.reg + add);
12912 oappend (ins, scratch);
12917 OP_T (instr_info *ins, int dummy ATTRIBUTE_UNUSED,
12923 res = snprintf (scratch, ARRAY_SIZE (scratch), "%%tr%d", ins->modrm.reg);
12926 oappend_register (ins, scratch);
12931 OP_MMX (instr_info *ins, int bytemode ATTRIBUTE_UNUSED,
12934 int reg = ins->modrm.reg;
12937 ins->used_prefixes |= (ins->prefixes & PREFIX_DATA);
12938 if (ins->prefixes & PREFIX_DATA)
12942 if (ins->rex & REX_R)
12947 oappend_register (ins, names[reg]);
12952 print_vector_reg (instr_info *ins, unsigned int reg, int bytemode)
12960 switch (ins->vex.length)
12969 ins->evex_used |= EVEX_len_used;
12981 oappend (ins, "(bad)");
12986 else if (ins->need_vex
12998 ins->evex_used |= EVEX_len_used;
12999 switch (ins->vex.length)
13005 if (ins->vex.w
13012 if (ins->vex.w
13024 oappend_register (ins, names[reg]);
13028 OP_XMM (instr_info *ins, int bytemode, int sizeflag ATTRIBUTE_UNUSED)
13030 unsigned int reg = ins->modrm.reg;
13033 if (ins->rex & REX_R)
13035 if (ins->vex.evex)
13037 if (ins->rex2 & REX_R)
13042 ins->modrm.reg = reg;
13044 ins->vex.no_broadcast = true;
13046 print_vector_reg (ins, reg, bytemode);
13051 OP_EM (instr_info *ins, int bytemode, int sizeflag)
13056 if (ins->modrm.mod != 3)
13058 if (ins->intel_syntax
13061 bytemode = (ins->prefixes & PREFIX_DATA) ? x_mode : q_mode;
13062 ins->used_prefixes |= (ins->prefixes & PREFIX_DATA);
13064 return OP_E (ins, bytemode, sizeflag);
13068 swap_operand (ins);
13072 ins->codep++;
13073 ins->used_prefixes |= (ins->prefixes & PREFIX_DATA);
13074 reg = ins->modrm.rm;
13075 if (ins->prefixes & PREFIX_DATA)
13079 if (ins->rex & REX_B)
13084 oappend_register (ins, names[reg]);
13094 OP_EMC (instr_info *ins, int bytemode, int sizeflag)
13096 if (ins->modrm.mod != 3)
13098 if (ins->intel_syntax && bytemode == v_mode)
13100 bytemode = (ins->prefixes & PREFIX_DATA) ? x_mode : q_mode;
13101 ins->used_prefixes |= (ins->prefixes & PREFIX_DATA);
13103 return OP_E (ins, bytemode, sizeflag);
13108 ins->codep++;
13109 ins->used_prefixes |= (ins->prefixes & PREFIX_DATA);
13110 oappend_register (ins, att_names_mm[ins->modrm.rm]);
13115 OP_MXC (instr_info *ins, int bytemode ATTRIBUTE_UNUSED,
13118 ins->used_prefixes |= (ins->prefixes & PREFIX_DATA);
13119 oappend_register (ins, att_names_mm[ins->modrm.reg]);
13124 OP_EX (instr_info *ins, int bytemode, int sizeflag)
13130 ins->codep++;
13133 bytemode = ins->vex.w ? q_mode : d_mode;
13135 if (ins->modrm.mod != 3)
13136 return OP_E_memory (ins, bytemode, sizeflag);
13138 reg = ins->modrm.rm;
13140 if (ins->rex & REX_B)
13142 if (ins->vex.evex)
13145 if ((ins->rex & REX_X))
13147 ins->rex2_used &= ~REX_B;
13149 else if (ins->rex2 & REX_B)
13157 swap_operand (ins);
13160 ins->modrm.rm = reg;
13162 print_vector_reg (ins, reg, bytemode);
13167 OP_R (instr_info *ins, int bytemode, int sizeflag)
13169 if (ins->modrm.mod != 3)
13170 return BadOp (ins);
13178 return OP_E (ins, bytemode, sizeflag);
13180 return OP_EM (ins, x_mode, sizeflag);
13182 if (ins->vex.length <= 128)
13184 return BadOp (ins);
13187 return OP_EX (ins, bytemode, sizeflag);
13191 OP_M (instr_info *ins, int bytemode, int sizeflag)
13195 ins->codep++;
13197 if (ins->modrm.mod == 3)
13199 return BadOp (ins);
13202 ins->vex.no_broadcast = true;
13204 return OP_E_memory (ins, bytemode, sizeflag);
13208 OP_0f07 (instr_info *ins, int bytemode, int sizeflag)
13210 if (ins->modrm.mod != 3 || ins->modrm.rm != 0)
13211 return BadOp (ins);
13212 return OP_E (ins, bytemode, sizeflag);
13218 MONTMUL_Fixup (instr_info *ins, int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
13220 if (ins->modrm.mod != 3 || ins->modrm.rm != 0)
13221 return BadOp (ins);
13224 if (ins->prefixes & PREFIX_REPZ)
13225 ins->all_prefixes[ins->last_repz_prefix] = 0xf3;
13229 ins->codep++;
13237 NOP_Fixup (instr_info *ins, int opnd, int sizeflag)
13239 if ((ins->prefixes & PREFIX_DATA) == 0 && (ins->rex & REX_B) == 0)
13241 ins->mnemonicendp = stpcpy (ins->obuf, "nop");
13245 return OP_REG (ins, eAX_reg, sizeflag);
13246 return OP_IMREG (ins, eAX_reg, sizeflag);
13317 OP_3DNowSuffix (instr_info *ins, int bytemode ATTRIBUTE_UNUSED,
13322 if (!fetch_code (ins->info, ins->codep + 1))
13327 ins->obufp = ins->mnemonicendp;
13328 mnemonic = Suffix3DNow[*ins->codep++];
13330 ins->obufp = stpcpy (ins->obufp, mnemonic);
13333 /* Since a variable sized ins->modrm/ins->sib chunk is between the start
13335 all the ins->modrm processing first, and don't know until now that
13337 ins->op_out[0][0] = '\0';
13338 ins->op_out[1][0] = '\0';
13339 BadOp (ins);
13341 ins->mnemonicendp = ins->obufp;
13386 CMP_Fixup (instr_info *ins, int bytemode ATTRIBUTE_UNUSED,
13391 if (!fetch_code (ins->info, ins->codep + 1))
13393 cmp_type = *ins->codep++;
13397 char *p = ins->mnemonicendp - 2;
13402 ins->mnemonicendp += simd_cmp_op[cmp_type].len;
13404 else if (ins->need_vex
13408 char *p = ins->mnemonicendp - 2;
13414 ins->mnemonicendp += vex_cmp_op[cmp_type].len;
13419 oappend_immediate (ins, cmp_type);
13425 OP_Mwait (instr_info *ins, int bytemode, int sizeflag ATTRIBUTE_UNUSED)
13428 if (!ins->intel_syntax)
13430 strcpy (ins->op_out[0], att_names32[0] + ins->intel_syntax);
13431 strcpy (ins->op_out[1], att_names32[1] + ins->intel_syntax);
13433 strcpy (ins->op_out[2], att_names32[3] + ins->intel_syntax);
13434 ins->two_source_ops = true;
13438 ins->codep++;
13443 OP_Monitor (instr_info *ins, int bytemode ATTRIBUTE_UNUSED,
13447 if (!ins->intel_syntax)
13449 const char (*names)[8] = (ins->address_mode == mode_64bit
13452 if (ins->prefixes & PREFIX_ADDR)
13455 ins->all_prefixes[ins->last_addr_prefix] = 0;
13456 names = (ins->address_mode != mode_32bit
13458 ins->used_prefixes |= PREFIX_ADDR;
13460 else if (ins->address_mode == mode_16bit)
13462 strcpy (ins->op_out[0], names[0] + ins->intel_syntax);
13463 strcpy (ins->op_out[1], att_names32[1] + ins->intel_syntax);
13464 strcpy (ins->op_out[2], att_names32[2] + ins->intel_syntax);
13465 ins->two_source_ops = true;
13469 ins->codep++;
13474 REP_Fixup (instr_info *ins, int bytemode, int sizeflag)
13476 /* The 0xf3 prefix should be displayed as "rep" for ins, outs, movs,
13478 if (ins->prefixes & PREFIX_REPZ)
13479 ins->all_prefixes[ins->last_repz_prefix] = REP_PREFIX;
13486 return OP_IMREG (ins, bytemode, sizeflag);
13488 return OP_ESreg (ins, bytemode, sizeflag);
13490 return OP_DSreg (ins, bytemode, sizeflag);
13499 SEP_Fixup (instr_info *ins, int bytemode ATTRIBUTE_UNUSED,
13502 if (ins->isa64 != amd64)
13505 ins->obufp = ins->obuf;
13506 BadOp (ins);
13507 ins->mnemonicendp = ins->obufp;
13508 ++ins->codep;
13516 BND_Fixup (instr_info *ins, int bytemode ATTRIBUTE_UNUSED,
13519 if (ins->prefixes & PREFIX_REPNZ)
13520 ins->all_prefixes[ins->last_repnz_prefix] = BND_PREFIX;
13528 NOTRACK_Fixup (instr_info *ins, int bytemode ATTRIBUTE_UNUSED,
13533 if ((ins->prefixes & PREFIX_DS) != 0
13534 && (ins->address_mode != mode_64bit || ins->last_data_prefix < 0))
13538 ins->active_seg_prefix = 0;
13539 ins->all_prefixes[ins->last_seg_prefix] = NOTRACK_PREFIX;
13544 /* Similar to OP_E. But the 0xf2/0xf3 ins->prefixes should be displayed as
13549 HLE_Fixup1 (instr_info *ins, int bytemode, int sizeflag)
13551 if (ins->modrm.mod != 3
13552 && (ins->prefixes & PREFIX_LOCK) != 0)
13554 if (ins->prefixes & PREFIX_REPZ)
13555 ins->all_prefixes[ins->last_repz_prefix] = XRELEASE_PREFIX;
13556 if (ins->prefixes & PREFIX_REPNZ)
13557 ins->all_prefixes[ins->last_repnz_prefix] = XACQUIRE_PREFIX;
13560 return OP_E (ins, bytemode, sizeflag);
13563 /* Similar to OP_E. But the 0xf2/0xf3 ins->prefixes should be displayed as
13568 HLE_Fixup2 (instr_info *ins, int bytemode, int sizeflag)
13570 if (ins->modrm.mod != 3)
13572 if (ins->prefixes & PREFIX_REPZ)
13573 ins->all_prefixes[ins->last_repz_prefix] = XRELEASE_PREFIX;
13574 if (ins->prefixes & PREFIX_REPNZ)
13575 ins->all_prefixes[ins->last_repnz_prefix] = XACQUIRE_PREFIX;
13578 return OP_E (ins, bytemode, sizeflag);
13585 HLE_Fixup3 (instr_info *ins, int bytemode, int sizeflag)
13587 if (ins->modrm.mod != 3
13588 && ins->last_repz_prefix > ins->last_repnz_prefix
13589 && (ins->prefixes & PREFIX_REPZ) != 0)
13590 ins->all_prefixes[ins->last_repz_prefix] = XRELEASE_PREFIX;
13592 return OP_E (ins, bytemode, sizeflag);
13596 CMPXCHG8B_Fixup (instr_info *ins, int bytemode, int sizeflag)
13599 if (ins->rex & REX_W)
13602 char *p = ins->mnemonicendp - 2;
13603 ins->mnemonicendp = stpcpy (p, "16b");
13606 else if ((ins->prefixes & PREFIX_LOCK) != 0)
13608 if (ins->prefixes & PREFIX_REPZ)
13609 ins->all_prefixes[ins->last_repz_prefix] = XRELEASE_PREFIX;
13610 if (ins->prefixes & PREFIX_REPNZ)
13611 ins->all_prefixes[ins->last_repnz_prefix] = XACQUIRE_PREFIX;
13614 return OP_M (ins, bytemode, sizeflag);
13618 XMM_Fixup (instr_info *ins, int reg, int sizeflag ATTRIBUTE_UNUSED)
13622 if (ins->need_vex)
13624 switch (ins->vex.length)
13635 oappend_register (ins, names[reg]);
13640 FXSAVE_Fixup (instr_info *ins, int bytemode, int sizeflag)
13644 if (ins->rex & REX_W)
13646 char *p = ins->mnemonicendp;
13650 ins->mnemonicendp = p;
13652 return OP_M (ins, bytemode, sizeflag);
13659 OP_VEX (instr_info *ins, int bytemode, int sizeflag ATTRIBUTE_UNUSED)
13664 if (!ins->need_vex)
13667 if (ins->evex_type == evex_from_legacy)
13669 ins->evex_used |= EVEX_b_used;
13670 if (!ins->vex.nd)
13674 reg = ins->vex.register_specifier;
13675 ins->vex.register_specifier = 0;
13676 if (ins->address_mode != mode_64bit)
13678 if (ins->vex.evex && !ins->vex.v)
13680 oappend (ins, "(bad)");
13686 else if (ins->vex.evex && !ins->vex.v)
13692 oappend_register (ins, att_names_xmm[reg]);
13698 if (ins->obufp != ins->op_out[2])
13700 if (ins->vex.length == 128
13702 && !ins->vex.w))
13703 oappend_register (ins, att_names_xmm[reg]);
13705 oappend_register (ins, att_names_ymm[reg]);
13708 modrm_reg = ins->modrm.reg;
13709 if (ins->rex & REX_R)
13712 if (ins->has_sib && ins->modrm.rm == 4)
13714 sib_index = ins->sib.index;
13715 if (ins->rex & REX_X)
13720 strcpy (ins->obufp, "/(bad)");
13722 strcat (ins->op_out[0], "/(bad)");
13724 strcat (ins->op_out[1], "/(bad)");
13731 oappend (ins, "(bad)");
13735 if (ins->obufp != ins->op_out[2])
13737 oappend_register (ins, att_names_tmm[reg]);
13738 if (reg == ins->modrm.reg || reg == ins->modrm.rm)
13739 strcpy (ins->obufp, "/(bad)");
13742 if (ins->modrm.reg == ins->modrm.rm || ins->modrm.reg == reg
13743 || ins->modrm.rm == reg)
13745 if (ins->modrm.reg <= 8
13746 && (ins->modrm.reg == ins->modrm.rm || ins->modrm.reg == reg))
13747 strcat (ins->op_out[0], "/(bad)");
13748 if (ins->modrm.rm <= 8
13749 && (ins->modrm.rm == ins->modrm.reg || ins->modrm.rm == reg))
13750 strcat (ins->op_out[1], "/(bad)");
13756 switch (ins->vex.length)
13763 ins->evex_used |= EVEX_len_used;
13767 if (ins->rex & REX_W)
13785 oappend (ins, "(bad)");
13800 ins->evex_used |= EVEX_len_used;
13812 oappend (ins, "(bad)");
13818 ins->evex_used |= EVEX_len_used;
13824 oappend_register (ins, names[reg]);
13829 OP_VexR (instr_info *ins, int bytemode, int sizeflag)
13831 if (ins->modrm.mod == 3)
13832 return OP_VEX (ins, bytemode, sizeflag);
13837 OP_VexW (instr_info *ins, int bytemode, int sizeflag)
13839 OP_VEX (ins, bytemode, sizeflag);
13841 if (ins->vex.w)
13844 char *tmp = ins->op_out[2];
13846 ins->op_out[2] = ins->op_out[1];
13847 ins->op_out[1] = tmp;
13853 OP_REG_VexI4 (instr_info *ins, int bytemode, int sizeflag ATTRIBUTE_UNUSED)
13858 if (!fetch_code (ins->info, ins->codep + 1))
13860 reg = *ins->codep++;
13866 if (ins->address_mode != mode_64bit)
13869 if (bytemode == x_mode && ins->vex.length == 256)
13872 oappend_register (ins, names[reg]);
13874 if (ins->vex.w)
13877 char *tmp = ins->op_out[3];
13879 ins->op_out[3] = ins->op_out[2];
13880 ins->op_out[2] = tmp;
13886 OP_VexI4 (instr_info *ins, int bytemode ATTRIBUTE_UNUSED,
13889 oappend_immediate (ins, ins->codep[-1] & 0xf);
13894 VPCMP_Fixup (instr_info *ins, int bytemode ATTRIBUTE_UNUSED,
13899 if (!ins->vex.evex)
13902 if (!fetch_code (ins->info, ins->codep + 1))
13904 cmp_type = *ins->codep++;
13912 char *p = ins->mnemonicendp - 2;
13929 ins->mnemonicendp += simd_cmp_op[cmp_type].len;
13934 oappend_immediate (ins, cmp_type);
13952 VPCOM_Fixup (instr_info *ins, int bytemode ATTRIBUTE_UNUSED,
13957 if (!fetch_code (ins->info, ins->codep + 1))
13959 cmp_type = *ins->codep++;
13963 char *p = ins->mnemonicendp - 2;
13980 ins->mnemonicendp += xop_cmp_op[cmp_type].len;
13985 oappend_immediate (ins, cmp_type);
13999 PCLMUL_Fixup (instr_info *ins, int bytemode ATTRIBUTE_UNUSED,
14004 if (!fetch_code (ins->info, ins->codep + 1))
14006 pclmul_type = *ins->codep++;
14021 char *p = ins->mnemonicendp - 3;
14027 ins->mnemonicendp += pclmul_op[pclmul_type].len;
14032 oappend_immediate (ins, pclmul_type);
14038 MOVSXD_Fixup (instr_info *ins, int bytemode, int sizeflag)
14041 char *p = ins->mnemonicendp;
14046 if (!ins->intel_syntax)
14049 if (ins->rex & REX_W)
14061 oappend (ins, INTERNAL_DISASSEMBLER_ERROR);
14065 ins->mnemonicendp = p;
14067 return OP_E (ins, bytemode, sizeflag);
14071 DistinctDest_Fixup (instr_info *ins, int bytemode, int sizeflag)
14073 unsigned int reg = ins->vex.register_specifier;
14074 unsigned int modrm_reg = ins->modrm.reg;
14075 unsigned int modrm_rm = ins->modrm.rm;
14078 if (ins->rex & REX_R)
14080 if (ins->rex2 & REX_R)
14084 if (ins->address_mode != mode_64bit)
14086 else if (ins->vex.evex && !ins->vex.v)
14090 if (ins->modrm.mod == 3)
14092 if (ins->rex & REX_B)
14094 if (ins->rex & REX_X)
14101 || (ins->modrm.mod == 3
14104 oappend (ins, "(bad)");
14107 return OP_XMM (ins, bytemode, sizeflag);
14111 OP_Rounding (instr_info *ins, int bytemode, int sizeflag ATTRIBUTE_UNUSED)
14113 if (ins->modrm.mod != 3 || !ins->vex.b)
14119 if (ins->address_mode != mode_64bit || !ins->vex.w)
14123 ins->evex_used |= EVEX_b_used;
14124 oappend (ins, names_rounding[ins->vex.ll]);
14127 ins->evex_used |= EVEX_b_used;
14128 oappend (ins, "{");
14133 oappend (ins, "sae}");
14138 PREFETCHI_Fixup (instr_info *ins, int bytemode, int sizeflag)
14140 if (ins->modrm.mod != 0 || ins->modrm.rm != 5)
14142 if (ins->intel_syntax)
14144 ins->mnemonicendp = stpcpy (ins->obuf, "nop ");
14149 if (ins->rex & REX_W)
14150 ins->mnemonicendp = stpcpy (ins->obuf, "nopq ");
14154 ins->mnemonicendp = stpcpy (ins->obuf, "nopl ");
14156 ins->mnemonicendp = stpcpy (ins->obuf, "nopw ");
14157 ins->used_prefixes |= (ins->prefixes & PREFIX_DATA);
14163 return OP_M (ins, bytemode, sizeflag);
14167 PUSH2_POP2_Fixup (instr_info *ins, int bytemode, int sizeflag)
14169 if (ins->modrm.mod != 3)
14172 unsigned int vvvv_reg = ins->vex.register_specifier
14173 | (!ins->vex.v << 4);
14174 unsigned int rm_reg = ins->modrm.rm + (ins->rex & REX_B ? 8 : 0)
14175 + (ins->rex2 & REX_B ? 16 : 0);
14178 if (!ins->vex.nd || vvvv_reg == 0x4 || rm_reg == 0x4
14179 || (!ins->modrm.reg
14182 oappend (ins, "(bad)");
14186 return OP_VEX (ins, bytemode, sizeflag);
14190 JMPABS_Fixup (instr_info *ins, int bytemode, int sizeflag)
14192 if (ins->last_rex2_prefix >= 0)
14196 if ((ins->prefixes & (PREFIX_OPCODE | PREFIX_ADDR | PREFIX_LOCK)) != 0x0
14197 || (ins->rex & REX_W) != 0x0)
14199 oappend (ins, "(bad)");
14206 if (!get64 (ins, &op))
14209 ins->mnemonicendp = stpcpy (ins->obuf, "jmpabs");
14210 ins->rex2 |= REX2_SPECIAL;
14211 oappend_immediate (ins, op);
14217 return OP_IMREG (ins, bytemode, sizeflag);
14218 return OP_OFF64 (ins, bytemode, sizeflag);
14222 CFCMOV_Fixup (instr_info *ins, int opnd, int sizeflag)
14226 bool dstmem = !ins->vex.nd && ins->vex.nf;
14231 return OP_E (ins, v_swap_mode, sizeflag);
14232 return OP_G (ins, v_mode, sizeflag);
14236 ins->vex.nf = false;
14237 ins->vex.mask_register_specifier = 0;
14240 return OP_G (ins, v_mode, sizeflag);
14241 return OP_E (ins, v_mode, sizeflag);
Indexes created Sat Apr 04 00:22:49 UTC 2026