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
260 * (see topic "Redundant ins->prefixes" in the "Differences from 8086"
293 if (ins->rex & value) \
294 ins->rex_used |= (value) | REX_OPCODE; \
295 if (ins->rex2 & value) \
297 ins->rex2_used |= (value); \
298 ins->rex_used |= REX_OPCODE; \
302 ins->rex_used |= REX_OPCODE; \
363 fetch_modrm (instr_info *ins)
365 if (!fetch_code (ins->info, ins->codep + 1))
368 ins->modrm.mod = (*ins->codep >> 6) & 3;
369 ins->modrm.reg = (*ins->codep >> 3) & 7;
370 ins->modrm.rm = *ins->codep & 7;
376 fetch_error (const instr_info *ins)
381 const struct dis_private *priv = ins->info->private_data;
384 if (ins->codep <= priv->the_buffer)
387 if (ins->prefixes || ins->fwait_prefix >= 0 || (ins->rex & REX_OPCODE))
388 name = prefix_name (ins->address_mode, priv->the_buffer[0],
391 i386_dis_printf (ins->info, dis_style_mnemonic, "%s", name);
395 i386_dis_printf (ins->info, dis_style_assembler_directive, ".byte ");
396 i386_dis_printf (ins->info, dis_style_immediate, "%#x",
1860 typedef bool (*op_rtn) (instr_info *ins, int bytemode, int sizeflag);
2079 { "ins{b|}", { Ybr, indirDX }, 0 },
2594 #define MODRM_CHECK if (!ins->need_modrm) abort ()
4455 { "ins{R|}", { Yzr, indirDX }, 0 },
4456 { "ins{G|}", { Yzr, indirDX }, 0 },
8760 ckprefix (instr_info *ins)
8770 if (!fetch_code (ins->info, ins->codep + 1))
8773 switch (*ins->codep)
8792 if (ins->address_mode == mode_64bit)
8793 newrex = *ins->codep;
8796 ins->last_rex_prefix = i;
8800 if (ins->address_mode == mode_64bit)
8802 if (ins->last_rex_prefix >= 0)
8805 ins->codep++;
8806 if (!fetch_code (ins->info, ins->codep + 1))
8808 ins->rex2_payload = *ins->codep;
8809 ins->rex2 = ins->rex2_payload >> 4;
8810 ins->rex = (ins->rex2_payload & 0xf) | REX_OPCODE;
8811 ins->codep++;
8812 ins->last_rex2_prefix = i;
8813 ins->all_prefixes[i] = REX2_OPCODE;
8817 ins->prefixes |= PREFIX_REPZ;
8818 ins->last_repz_prefix = i;
8821 ins->prefixes |= PREFIX_REPNZ;
8822 ins->last_repnz_prefix = i;
8825 ins->prefixes |= PREFIX_LOCK;
8826 ins->last_lock_prefix = i;
8829 ins->prefixes |= PREFIX_CS;
8830 ins->last_seg_prefix = i;
8831 if (ins->address_mode != mode_64bit)
8832 ins->active_seg_prefix = PREFIX_CS;
8835 ins->prefixes |= PREFIX_SS;
8836 ins->last_seg_prefix = i;
8837 if (ins->address_mode != mode_64bit)
8838 ins->active_seg_prefix = PREFIX_SS;
8841 ins->prefixes |= PREFIX_DS;
8842 ins->last_seg_prefix = i;
8843 if (ins->address_mode != mode_64bit)
8844 ins->active_seg_prefix = PREFIX_DS;
8847 ins->prefixes |= PREFIX_ES;
8848 ins->last_seg_prefix = i;
8849 if (ins->address_mode != mode_64bit)
8850 ins->active_seg_prefix = PREFIX_ES;
8853 ins->prefixes |= PREFIX_FS;
8854 ins->last_seg_prefix = i;
8855 ins->active_seg_prefix = PREFIX_FS;
8858 ins->prefixes |= PREFIX_GS;
8859 ins->last_seg_prefix = i;
8860 ins->active_seg_prefix = PREFIX_GS;
8863 ins->prefixes |= PREFIX_DATA;
8864 ins->last_data_prefix = i;
8867 ins->prefixes |= PREFIX_ADDR;
8868 ins->last_addr_prefix = i;
8874 ins->fwait_prefix = i;
8875 if (ins->prefixes || ins->rex)
8877 ins->prefixes |= PREFIX_FWAIT;
8878 ins->codep++;
8881 return ins->rex ? ckp_bogus : ckp_okay;
8883 ins->prefixes = PREFIX_FWAIT;
8889 if (ins->rex)
8891 if (*ins->codep != FWAIT_OPCODE)
8892 ins->all_prefixes[i++] = *ins->codep;
8893 ins->rex = newrex;
8894 ins->codep++;
9031 get_valid_dis386 (const struct dis386 *dp, instr_info *ins)
9041 dp = ®_table[dp->op[1].bytemode][ins->modrm.reg];
9045 vindex = ins->modrm.mod == 0x3 ? 1 : 0;
9050 dp = &rm_table[dp->op[1].bytemode][ins->modrm.rm];
9055 if (ins->need_vex)
9058 switch (ins->vex.prefix)
9085 if ((ins->prefixes & (PREFIX_REPZ | PREFIX_REPNZ)) != 0)
9087 if (ins->last_repz_prefix > ins->last_repnz_prefix)
9091 last_prefix = ins->last_repz_prefix;
9097 last_prefix = ins->last_repnz_prefix;
9108 if (vindex == 0 && (ins->prefixes & PREFIX_DATA) != 0)
9112 last_prefix = ins->last_data_prefix;
9117 ins->used_prefixes |= prefix;
9118 ins->all_prefixes[last_prefix] = 0;
9128 ins->evex_type = evex_from_vex;
9131 if (ins->address_mode != mode_64bit
9132 || (ins->vex.mask_register_specifier & 0x3) != 0
9133 || ins->vex.ll != 0
9134 || ins->vex.zeroing != 0
9135 || ins->vex.b)
9144 if (ins->modrm.mod == 3)
9151 vindex = ins->address_mode == mode_64bit ? 1 : 0;
9156 if (ins->last_rex2_prefix >= 0)
9158 if (!fetch_code (ins->info, ins->codep + 2))
9160 vindex = *ins->codep++;
9162 ins->end_codep = ins->codep;
9163 if (!fetch_modrm (ins))
9168 if (!ins->need_vex)
9171 switch (ins->vex.length)
9179 if (ins->vex.evex)
9195 if (!ins->vex.evex)
9198 switch (ins->vex.length)
9218 if (!fetch_code (ins->info, ins->codep + 3))
9220 ins->rex = ~(*ins->codep >> 5) & 0x7;
9223 switch ((*ins->codep & 0x1f))
9238 ins->codep++;
9239 ins->vex.w = *ins->codep & 0x80;
9240 if (ins->vex.w && ins->address_mode == mode_64bit)
9241 ins->rex |= REX_W;
9243 ins->vex.register_specifier = (~(*ins->codep >> 3)) & 0xf;
9244 if (ins->address_mode != mode_64bit)
9247 ins->rex &= ~REX_B;
9250 ins->vex.length = (*ins->codep & 0x4) ? 256 : 128;
9251 switch ((*ins->codep & 0x3))
9256 ins->vex.prefix = DATA_PREFIX_OPCODE;
9259 ins->vex.prefix = REPE_PREFIX_OPCODE;
9262 ins->vex.prefix = REPNE_PREFIX_OPCODE;
9265 ins->need_vex = 3;
9266 ins->codep++;
9267 vindex = *ins->codep++;
9270 ins->end_codep = ins->codep;
9271 if (!fetch_modrm (ins))
9276 if (ins->vex.prefix)
9282 if (!fetch_code (ins->info, ins->codep + 3))
9284 ins->rex = ~(*ins->codep >> 5) & 0x7;
9285 switch ((*ins->codep & 0x1f))
9306 ins->codep++;
9307 ins->vex.w = *ins->codep & 0x80;
9308 if (ins->address_mode == mode_64bit)
9310 if (ins->vex.w)
9311 ins->rex |= REX_W;
9318 ins->rex = 0;
9320 ins->vex.register_specifier = (~(*ins->codep >> 3)) & 0xf;
9321 ins->vex.length = (*ins->codep & 0x4) ? 256 : 128;
9322 switch ((*ins->codep & 0x3))
9327 ins->vex.prefix = DATA_PREFIX_OPCODE;
9330 ins->vex.prefix = REPE_PREFIX_OPCODE;
9333 ins->vex.prefix = REPNE_PREFIX_OPCODE;
9336 ins->need_vex = 3;
9337 ins->codep++;
9338 vindex = *ins->codep++;
9339 ins->condition_code = vindex & 0xf;
9357 ins->end_codep = ins->codep;
9360 && !fetch_modrm (ins))
9366 if (!fetch_code (ins->info, ins->codep + 2))
9368 ins->rex = (*ins->codep & 0x80) ? 0 : REX_R;
9372 ins->vex.register_specifier = (~(*ins->codep >> 3)) & 0xf;
9373 ins->vex.length = (*ins->codep & 0x4) ? 256 : 128;
9374 switch ((*ins->codep & 0x3))
9379 ins->vex.prefix = DATA_PREFIX_OPCODE;
9382 ins->vex.prefix = REPE_PREFIX_OPCODE;
9385 ins->vex.prefix = REPNE_PREFIX_OPCODE;
9388 ins->need_vex = 2;
9389 ins->codep++;
9390 vindex = *ins->codep++;
9392 ins->end_codep = ins->codep;
9394 if (vindex != 0x77 && !fetch_modrm (ins))
9400 if (!ins->need_vex)
9403 dp = &vex_w_table[dp->op[1].bytemode][ins->vex.w];
9407 ins->two_source_ops = false;
9409 ins->vex.evex = true;
9410 if (!fetch_code (ins->info, ins->codep + 4))
9413 if (*ins->codep & 0x8)
9414 ins->rex2 |= REX_B;
9415 if (!(*ins->codep & 0x10))
9416 ins->rex2 |= REX_R;
9418 ins->rex = ~(*ins->codep >> 5) & 0x7;
9419 switch (*ins->codep & 0x7)
9434 ins->evex_type = evex_from_legacy;
9435 if (ins->address_mode != mode_64bit)
9437 ins->rex |= REX_OPCODE;
9451 ins->codep++;
9452 ins->vex.w = *ins->codep & 0x80;
9453 if (ins->vex.w && ins->address_mode == mode_64bit)
9454 ins->rex |= REX_W;
9456 ins->vex.register_specifier = (~(*ins->codep >> 3)) & 0xf;
9458 if (!(*ins->codep & 0x4))
9459 ins->rex2 |= REX_X;
9461 switch ((*ins->codep & 0x3))
9466 ins->vex.prefix = DATA_PREFIX_OPCODE;
9469 ins->vex.prefix = REPE_PREFIX_OPCODE;
9472 ins->vex.prefix = REPNE_PREFIX_OPCODE;
9477 ins->codep++;
9480 ins->vex.ll = (*ins->codep >> 5) & 3;
9481 ins->vex.b = *ins->codep & 0x10;
9483 ins->vex.v = *ins->codep & 0x8;
9484 ins->vex.mask_register_specifier = *ins->codep & 0x7;
9485 ins->vex.scc = *ins->codep & 0xf;
9486 ins->vex.zeroing = *ins->codep & 0x80;
9489 ins->vex.nf = *ins->codep & 0x4;
9491 if (ins->address_mode != mode_64bit)
9495 if (ins->evex_type != evex_default
9496 || (ins->rex2 & (REX_B | REX_X)))
9499 ins->rex &= ~REX_B;
9500 ins->rex2 &= ~REX_R;
9503 ins->need_vex = 4;
9505 ins->codep++;
9506 vindex = *ins->codep++;
9507 ins->condition_code = vindex & 0xf;
9516 ins->end_codep = ins->codep;
9517 if (!fetch_modrm (ins))
9520 if (ins->modrm.mod == 3 && (ins->rex2 & REX_X))
9526 if (ins->modrm.mod == 3 && ins->vex.b && ins->evex_type != evex_from_legacy)
9527 ins->vex.length = 512;
9530 switch (ins->vex.ll)
9533 ins->vex.length = 128;
9536 ins->vex.length = 256;
9539 ins->vex.length = 512;
9558 return get_valid_dis386 (dp, ins);
9562 get_sib (instr_info *ins, int sizeflag)
9565 if (ins->need_modrm
9566 && ((sizeflag & AFLAG) || ins->address_mode == mode_64bit)
9567 && ins->modrm.mod != 3
9568 && ins->modrm.rm == 4)
9570 if (!fetch_code (ins->info, ins->codep + 2))
9572 ins->sib.index = (ins->codep[1] >> 3) & 7;
9573 ins->sib.scale = (ins->codep[1] >> 6) & 3;
9574 ins->sib.base = ins->codep[1] & 7;
9575 ins->has_sib = true;
9578 ins->has_sib = false;
9586 oappend (instr_info *ins, const char *s)
9588 oappend_with_style (ins, s, dis_style_text);
9595 oappend_register (instr_info *ins, const char *s)
9597 oappend_with_style (ins, s + ins->intel_syntax, dis_style_register);
9600 /* Wrap around a call to INS->info->fprintf_styled_func, printing FMT.
9701 instr_info ins = {
9711 .obufp = ins.obuf,
9726 ins.address_mode = mode_32bit;
9729 ins.address_mode = mode_16bit;
9733 ins.address_mode = mode_64bit;
9738 ins.isa64 = amd64;
9740 ins.isa64 = intel64;
9743 ins.address_mode = mode_64bit;
9748 ins.address_mode = mode_32bit;
9753 ins.address_mode = mode_16bit;
9759 ins.intel_mnemonic = true;
9761 ins.intel_syntax = 1;
9765 ins.intel_syntax = 0;
9767 ins.intel_mnemonic = false;
9771 if (ins.address_mode == mode_64bit)
9801 if (ins.address_mode == mode_64bit && sizeof (bfd_vma) < 8)
9807 if (ins.intel_syntax)
9809 ins.open_char = '[';
9810 ins.close_char = ']';
9811 ins.separator_char = '+';
9812 ins.scale_char = '*';
9816 ins.open_char = '(';
9817 ins.close_char = ')';
9818 ins.separator_char = ',';
9819 ins.scale_char = ',';
9833 ins.op_out[i] = op_out[i];
9838 switch (ckprefix (&ins))
9846 i < (int) ARRAY_SIZE (ins.all_prefixes) && ins.all_prefixes[i];
9850 prefix_name (ins.address_mode, ins.all_prefixes[i],
9859 ins.nr_prefixes = ins.codep - ins.start_codep;
9861 if (!fetch_code (info, ins.codep + 1))
9864 ret = fetch_error (&ins);
9868 ins.two_source_ops = (*ins.codep == 0x62 || *ins.codep == 0xc8);
9870 if ((ins.prefixes & PREFIX_FWAIT)
9871 && (*ins.codep < 0xd8 || *ins.codep > 0xdf))
9873 /* Handle ins.prefixes before fwait. */
9874 for (i = 0; i < ins.fwait_prefix && ins.all_prefixes[i];
9877 prefix_name (ins.address_mode, ins.all_prefixes[i],
9885 if (ins.last_rex2_prefix < 0 ? *ins.codep == 0x0f : (ins.rex2 & REX2_M))
9887 if (!ins.rex2)
9889 ins.codep++;
9890 if (!fetch_code (info, ins.codep + 1))
9894 dp = &dis386_twobyte[*ins.codep];
9895 ins.need_modrm = twobyte_has_modrm[*ins.codep];
9899 dp = &dis386[*ins.codep];
9900 ins.need_modrm = onebyte_has_modrm[*ins.codep];
9902 ins.condition_code = *ins.codep & 0xf;
9903 ins.codep++;
9905 /* Save sizeflag for printing the extra ins.prefixes later before updating
9909 if (ins.prefixes & PREFIX_ADDR)
9911 if ((ins.prefixes & PREFIX_DATA))
9914 ins.end_codep = ins.codep;
9915 if (ins.need_modrm && !fetch_modrm (&ins))
9920 if (!get_sib (&ins, sizeflag)
9921 || !dofloat (&ins, sizeflag))
9926 dp = get_valid_dis386 (dp, &ins);
9932 if (ins.evex_type == evex_from_legacy
9933 && ins.vex.prefix == DATA_PREFIX_OPCODE)
9936 if(ins.evex_type == evex_default)
9937 ins.vex.nf = false;
9943 ins.vex.mask_register_specifier &= 0x3;
9945 if (dp != NULL && putop (&ins, dp->name, sizeflag) == 0)
9947 if (!get_sib (&ins, sizeflag))
9951 ins.obufp = ins.op_out[i];
9952 ins.op_ad = MAX_OPERANDS - 1 - i;
9954 && !dp->op[i].rtn (&ins, dp->op[i].bytemode, sizeflag))
9958 if (i == 0 && ins.vex.evex)
9961 if (ins.vex.mask_register_specifier)
9964 = att_names_mask[ins.vex.mask_register_specifier];
9966 oappend (&ins, "{");
9967 oappend_register (&ins, reg_name);
9968 oappend (&ins, "}");
9970 if (ins.vex.zeroing)
9971 oappend (&ins, "{z}");
9973 else if (ins.vex.zeroing)
9975 oappend (&ins, "{bad}");
9982 if (ins.vex.zeroing && dp->op[0].bytemode == mask_mode)
9983 ins.illegal_masking = true;
9989 && (ins.vex.mask_register_specifier == 0
9990 || ins.vex.zeroing))
9991 ins.illegal_masking = true;
9993 if (ins.illegal_masking)
9994 oappend (&ins, "/(bad)");
9998 if (ins.vex.nf)
9999 oappend (&ins, "{bad-nf}");
10003 if (ins.modrm.mod == 3 && ins.vex.b && ins.evex_type == evex_default
10004 && !(ins.evex_used & EVEX_b_used))
10008 ins.obufp = ins.op_out[i];
10009 if (*ins.obufp)
10011 oappend (&ins, names_rounding[ins.vex.ll]);
10012 oappend (&ins, "bad}");
10028 ins.op_is_jump = false;
10049 ins.op_is_jump = true;
10062 if (ins.evex_type == evex_from_legacy)
10066 if (!ins.vex.nd && (ins.vex.register_specifier || !ins.vex.v))
10069 ret = ins.end_codep - priv.the_buffer;
10075 if ((ins.vex.mask_register_specifier & 0x3) != 0
10076 || ins.vex.ll != 0 || ins.vex.zeroing != 0)
10079 ret = ins.end_codep - priv.the_buffer;
10085 if (ins.need_vex && ins.vex.register_specifier != 0)
10088 ret = ins.end_codep - priv.the_buffer;
10093 && ins.last_rex2_prefix >= 0 && (ins.rex2 & REX2_SPECIAL) == 0)
10096 ret = ins.end_codep - priv.the_buffer;
10105 if (ins.need_vex ? !ins.vex.prefix : !(ins.prefixes & PREFIX_DATA))
10108 ret = ins.end_codep - priv.the_buffer;
10111 ins.used_prefixes |= PREFIX_DATA;
10119 if (((ins.need_vex
10120 ? ins.vex.prefix == REPE_PREFIX_OPCODE
10121 || ins.vex.prefix == REPNE_PREFIX_OPCODE
10122 : (ins.prefixes
10124 && (ins.used_prefixes
10126 || (((ins.need_vex
10127 ? ins.vex.prefix == DATA_PREFIX_OPCODE
10128 : ((ins.prefixes
10131 && (ins.used_prefixes & PREFIX_DATA) == 0))
10132 || (ins.vex.evex && dp->prefix_requirement != PREFIX_DATA
10133 && !ins.vex.w != !(ins.used_prefixes & PREFIX_DATA)))
10136 ret = ins.end_codep - priv.the_buffer;
10144 ins.used_prefixes &= ~PREFIX_OPCODE;
10145 if (ins.last_data_prefix >= 0)
10146 ins.all_prefixes[ins.last_data_prefix] = 0x66;
10147 if (ins.last_repz_prefix >= 0)
10148 ins.all_prefixes[ins.last_repz_prefix] = 0xf3;
10149 if (ins.last_repnz_prefix >= 0)
10150 ins.all_prefixes[ins.last_repnz_prefix] = 0xf2;
10154 if (ins.vex.prefix == REPE_PREFIX_OPCODE
10155 || ins.vex.prefix == REPNE_PREFIX_OPCODE)
10158 ret = ins.end_codep - priv.the_buffer;
10164 if (ins.vex.prefix)
10167 ret = ins.end_codep - priv.the_buffer;
10174 if ((ins.rex ^ ins.rex_used) == 0
10175 && !ins.need_vex && ins.last_rex_prefix >= 0)
10176 ins.all_prefixes[ins.last_rex_prefix] = 0;
10179 if (ins.last_rex2_prefix >= 0
10180 && ((ins.rex2 & REX2_SPECIAL)
10181 || (((ins.rex2 & 7) ^ (ins.rex2_used & 7)) == 0
10182 && (ins.rex ^ ins.rex_used) == 0
10183 && (ins.rex2 & 7))))
10184 ins.all_prefixes[ins.last_rex2_prefix] = 0;
10187 if ((ins.prefixes & (PREFIX_CS | PREFIX_SS | PREFIX_DS | PREFIX_ES
10189 && (ins.used_prefixes & ins.active_seg_prefix) != 0)
10190 ins.all_prefixes[ins.last_seg_prefix] = 0;
10193 if ((ins.prefixes & PREFIX_ADDR) != 0
10194 && (ins.used_prefixes & PREFIX_ADDR) != 0)
10195 ins.all_prefixes[ins.last_addr_prefix] = 0;
10198 if ((ins.prefixes & PREFIX_DATA) != 0
10199 && (ins.used_prefixes & PREFIX_DATA) != 0
10200 && !ins.need_vex)
10201 ins.all_prefixes[ins.last_data_prefix] = 0;
10203 /* Print the extra ins.prefixes. */
10205 for (i = 0; i < (int) ARRAY_SIZE (ins.all_prefixes); i++)
10206 if (ins.all_prefixes[i])
10208 const char *name = prefix_name (ins.address_mode, ins.all_prefixes[i],
10214 if (ins.all_prefixes[i] == REX2_OPCODE)
10216 (unsigned int) ins.rex2_payload);
10222 if ((ins.codep - ins.start_codep) > MAX_CODE_LENGTH)
10232 if (*ins.op_out[i] != '\0')
10236 ins.obufp = ins.mnemonicendp;
10239 i = strlen (ins.obuf) + prefix_length;
10249 i386_dis_printf (info, dis_style_mnemonic, "%s%*s", ins.obuf, i, "");
10254 if (ins.intel_syntax || ins.two_source_ops)
10257 op_txt[i] = ins.op_out[i];
10259 if (ins.intel_syntax && dp && dp->op[2].rtn == OP_Rounding
10262 op_txt[2] = ins.op_out[3];
10263 op_txt[3] = ins.op_out[2];
10271 ins.op_ad = ins.op_index[i];
10272 ins.op_index[i] = ins.op_index[MAX_OPERANDS - 1 - i];
10273 ins.op_index[MAX_OPERANDS - 1 - i] = ins.op_ad;
10274 riprel = ins.op_riprel[i];
10275 ins.op_riprel[i] = ins.op_riprel[MAX_OPERANDS - 1 - i];
10276 ins.op_riprel[MAX_OPERANDS - 1 - i] = riprel;
10282 op_txt[MAX_OPERANDS - 1 - i] = ins.op_out[i];
10292 switch (i & -(ins.intel_syntax && dp))
10305 if (ins.op_index[i] != -1 && !ins.op_riprel[i])
10307 bfd_vma target = (bfd_vma) ins.op_address[ins.op_index[i]];
10309 if (ins.op_is_jump)
10325 if (ins.op_index[i] != -1 && ins.op_riprel[i])
10329 ((bfd_vma)(ins.start_pc + (ins.codep - ins.start_codep)
10330 + ins.op_address[ins.op_index[i]]),
10334 ret = ins.codep - priv.the_buffer;
10681 swap_operand (instr_info *ins)
10683 char *p = ins->mnemonicendp;
10689 if (p <= ins->obuf + 2)
10695 memmove (p + 2, p, ins->mnemonicendp - p + 1);
10698 ins->mnemonicendp += 2;
10702 dofloat (instr_info *ins, int sizeflag)
10705 unsigned char floatop = ins->codep[-1];
10707 if (ins->modrm.mod != 3)
10709 int fp_indx = (floatop - 0xd8) * 8 + ins->modrm.reg;
10711 putop (ins, float_mem[fp_indx], sizeflag);
10712 ins->obufp = ins->op_out[0];
10713 ins->op_ad = 2;
10714 return OP_E (ins, float_mem_mode[fp_indx], sizeflag);
10718 ins->codep++;
10720 dp = &float_reg[floatop - 0xd8][ins->modrm.reg];
10723 putop (ins, fgrps[dp->op[0].bytemode][ins->modrm.rm], sizeflag);
10726 if (floatop == 0xdf && ins->codep[-1] == 0xe0)
10727 strcpy (ins->op_out[0], att_names16[0] + ins->intel_syntax);
10731 putop (ins, dp->name, sizeflag);
10733 ins->obufp = ins->op_out[0];
10734 ins->op_ad = 2;
10736 && !dp->op[0].rtn (ins, dp->op[0].bytemode, sizeflag))
10739 ins->obufp = ins->op_out[1];
10740 ins->op_ad = 1;
10742 && !dp->op[1].rtn (ins, dp->op[1].bytemode, sizeflag))
10749 ins, int bytemode ATTRIBUTE_UNUSED,
10752 oappend_register (ins, "%st");
10757 OP_STi (instr_info *ins, int bytemode ATTRIBUTE_UNUSED,
10761 int res = snprintf (scratch, ARRAY_SIZE (scratch), "%%st(%d)", ins->modrm.rm);
10765 oappend_register (ins, scratch);
10771 putop (instr_info *ins, const char *in_template, int sizeflag)
10783 oappend (ins, "(bad)");
10784 *ins->obufp = 0;
10785 ins->mnemonicendp = ins->obufp;
10801 if (ins->evex_type == evex_from_legacy && !ins->vex.nd
10802 && !(ins->rex2 & 7) && !evex_printed)
10804 oappend (ins, "{evex} ");
10807 *ins->obufp++ = *p;
10816 if (ins->intel_syntax)
10835 if (ins->intel_syntax)
10837 if ((ins->need_modrm && ins->modrm.mod != 3 && !ins->vex.nd)
10839 *ins->obufp++ = 'b';
10845 if (ins->intel_syntax)
10848 *ins->obufp++ = 'b';
10852 if (ins->address_mode == mode_64bit
10853 && !(ins->prefixes & PREFIX_ADDR))
10855 *ins->obufp++ = 'a';
10856 *ins->obufp++ = 'b';
10857 *ins->obufp++ = 's';
10864 if (!ins->vex.w)
10865 oappend (ins, "bf16");
10867 oappend (ins, "{bad}");
10876 for (const char *q = dis386[0x70 | ins->condition_code].name + 1;
10878 *ins->obufp++ = *q;
10884 oappend (ins, scc_suffix[ins->vex.scc]);
10887 if (ins->vex.nd)
10888 oappend (ins, "(bad)");
10892 ins->vex.v = 1;
10893 ins->vex.nf = false;
10894 ins->vex.mask_register_specifier = 0;
10900 if (ins->intel_syntax && !alt)
10902 if ((ins->prefixes & PREFIX_DATA) || (sizeflag & SUFFIX_ALWAYS))
10905 *ins->obufp++ = ins->intel_syntax ? 'd' : 'l';
10907 *ins->obufp++ = ins->intel_syntax ? 'w' : 's';
10908 ins->used_prefixes |= (ins->prefixes & PREFIX_DATA);
10917 if (!ins->vex.evex || ins->vex.w)
10918 *ins->obufp++ = 'd';
10920 oappend (ins, "{bad}");
10929 if (ins->intel_syntax || !(sizeflag & SUFFIX_ALWAYS))
10932 if (ins->modrm.mod == 3)
10934 if (ins->rex & REX_W)
10935 *ins->obufp++ = 'q';
10939 *ins->obufp++ = ins->intel_syntax ? 'd' : 'l';
10941 *ins->obufp++ = 'w';
10942 ins->used_prefixes |= (ins->prefixes & PREFIX_DATA);
10946 *ins->obufp++ = 'w';
10954 if (ins->modrm.mod != 3)
10958 if (!ins->vex.evex || ins->vex.b || ins->vex.ll >= 2
10959 || (ins->rex2 & 7)
10960 || (ins->modrm.mod == 3 && (ins->rex & REX_X))
10961 || !ins->vex.v || ins->vex.mask_register_specifier)
10966 if (ins->vex.w)
10973 *ins->obufp++ = '{';
10974 *ins->obufp++ = 'e';
10975 *ins->obufp++ = 'v';
10976 *ins->obufp++ = 'e';
10977 *ins->obufp++ = 'x';
10978 *ins->obufp++ = '}';
10979 *ins->obufp++ = ' ';
10991 if (ins->address_mode == mode_64bit)
10994 *ins->obufp++ = 'r';
10996 *ins->obufp++ = 'e';
11000 *ins->obufp++ = 'e';
11001 ins->used_prefixes |= (ins->prefixes & PREFIX_ADDR);
11006 if (ins->intel_syntax)
11008 if ((ins->prefixes & PREFIX_ADDR) || (sizeflag & SUFFIX_ALWAYS))
11011 *ins->obufp++ = ins->address_mode == mode_64bit ? 'q' : 'l';
11013 *ins->obufp++ = ins->address_mode == mode_64bit ? 'l' : 'w';
11014 ins->used_prefixes |= (ins->prefixes & PREFIX_ADDR);
11019 if (ins->vex.nd && !ins->vex.nf)
11021 *ins->obufp++ = 'c';
11022 *ins->obufp++ = 'f';
11028 if (ins->vex.nf)
11030 oappend (ins, "{nf} ");
11032 ins->vex.nf = false;
11035 else if (ins->evex_type == evex_from_vex && !(ins->rex2 & 7)
11036 && ins->vex.v)
11038 oappend (ins, "{evex} ");
11045 int oszc_value = ~ins->vex.register_specifier & 0xf;
11048 oappend (ins, oszc_flags[oszc_value]);
11051 ins->vex.register_specifier = 0;
11057 if (ins->intel_syntax || (ins->obufp[-1] != 's'
11060 if ((ins->rex & REX_W) || (sizeflag & DFLAG))
11061 *ins->obufp++ = 'l';
11063 *ins->obufp++ = 'w';
11064 if (!(ins->rex & REX_W))
11065 ins->used_prefixes |= (ins->prefixes & PREFIX_DATA);
11070 if (ins->intel_syntax)
11072 if ((ins->prefixes & (PREFIX_CS | PREFIX_DS)) == PREFIX_CS
11073 || (ins->prefixes & (PREFIX_CS | PREFIX_DS)) == PREFIX_DS)
11075 ins->used_prefixes |= ins->prefixes & (PREFIX_CS | PREFIX_DS);
11076 *ins->obufp++ = ',';
11077 *ins->obufp++ = 'p';
11081 if (ins->prefixes & PREFIX_DS)
11083 ins->active_seg_prefix = PREFIX_DS;
11084 *ins->obufp++ = 't';
11088 ins->active_seg_prefix = PREFIX_CS;
11089 *ins->obufp++ = 'n';
11095 if (!ins->vex.w)
11096 *ins->obufp++ = 'h';
11098 oappend (ins, "{bad}");
11105 if (ins->rex & REX_W)
11106 *ins->obufp++ = 'q';
11108 *ins->obufp++ = 'd';
11111 if (ins->intel_syntax)
11115 if (ins->rex & REX_W)
11116 *ins->obufp++ = 'q';
11118 *ins->obufp++ = 'l';
11122 if (ins->intel_mnemonic != cond)
11123 *ins->obufp++ = 'r';
11126 if ((ins->prefixes & PREFIX_FWAIT) == 0)
11127 *ins->obufp++ = 'n';
11129 ins->used_prefixes |= PREFIX_FWAIT;
11133 if (ins->rex & REX_W)
11134 *ins->obufp++ = 'o';
11135 else if (ins->intel_syntax && (sizeflag & DFLAG))
11136 *ins->obufp++ = 'q';
11138 *ins->obufp++ = 'd';
11139 if (!(ins->rex & REX_W))
11140 ins->used_prefixes |= (ins->prefixes & PREFIX_DATA);
11143 if (ins->address_mode == mode_64bit
11144 && (ins->isa64 == intel64 || (ins->rex & REX_W)
11145 || !(ins->prefixes & PREFIX_DATA)))
11148 *ins->obufp++ = 'q';
11155 if (!cond && ins->last_rex2_prefix >= 0 && (ins->rex & REX_W))
11159 *ins->obufp++ = 'p';
11160 ins->rex2 |= REX2_SPECIAL;
11165 if (!cond && ins->intel_syntax)
11168 if ((ins->modrm.mod == 3 || !cond)
11173 if ((!(ins->rex & REX_W) && (ins->prefixes & PREFIX_DATA))
11175 && ins->address_mode != mode_64bit))
11177 *ins->obufp++ = (sizeflag & DFLAG)
11178 ? ins->intel_syntax ? 'd' : 'l' : 'w';
11179 ins->used_prefixes |= (ins->prefixes & PREFIX_DATA);
11182 *ins->obufp++ = 'q';
11186 if ((ins->prefixes & PREFIX_DATA)
11187 || (ins->rex & REX_W)
11191 if (ins->rex & REX_W)
11192 *ins->obufp++ = 'q';
11196 *ins->obufp++ = ins->intel_syntax ? 'd' : 'l';
11198 *ins->obufp++ = 'w';
11199 ins->used_prefixes |= (ins->prefixes & PREFIX_DATA);
11209 if (ins->intel_syntax && !alt)
11212 if ((ins->need_modrm && ins->modrm.mod != 3 && !ins->vex.nd)
11215 if (ins->rex & REX_W)
11216 *ins->obufp++ = 'q';
11220 *ins->obufp++ = ins->intel_syntax ? 'd' : 'l';
11222 *ins->obufp++ = 'w';
11223 ins->used_prefixes |= (ins->prefixes & PREFIX_DATA);
11228 *ins->obufp++ = ins->vex.w ? 'q' : 'd';
11231 if (cond ? ins->modrm.mod == 3 && !(sizeflag & SUFFIX_ALWAYS)
11232 : ins->address_mode != mode_64bit)
11234 if ((ins->rex & REX_W))
11237 *ins->obufp++ = 'q';
11239 else if ((ins->address_mode == mode_64bit && cond)
11241 *ins->obufp++ = ins->intel_syntax? 'd' : 'l';
11248 if (ins->rex & REX_W)
11249 *ins->obufp++ = 'q';
11252 if (ins->intel_syntax)
11253 *ins->obufp++ = 'd';
11255 *ins->obufp++ = 'l';
11258 *ins->obufp++ = 'w';
11259 if (ins->intel_syntax && !p[1]
11260 && ((ins->rex & REX_W) || (sizeflag & DFLAG)))
11261 *ins->obufp++ = 'e';
11262 if (!(ins->rex & REX_W))
11263 ins->used_prefixes |= (ins->prefixes & PREFIX_DATA);
11269 if (ins->intel_syntax)
11273 if (ins->rex & REX_W)
11274 *ins->obufp++ = 'q';
11278 *ins->obufp++ = 'l';
11280 *ins->obufp++ = 'w';
11281 ins->used_prefixes |= (ins->prefixes & PREFIX_DATA);
11291 if (ins->address_mode == mode_64bit
11292 && !(ins->prefixes & PREFIX_ADDR))
11294 *ins->obufp++ = 'a';
11295 *ins->obufp++ = 'b';
11296 *ins->obufp++ = 's';
11301 if (!ins->vex.evex || !ins->vex.w)
11302 *ins->obufp++ = 's';
11304 oappend (ins, "{bad}");
11316 if (ins->vex.nd)
11317 oappend (ins, "zu");
11325 if (ins->need_vex)
11326 *ins->obufp++ = 'v';
11333 if (ins->vex.evex)
11335 *ins->obufp++ = '{';
11336 *ins->obufp++ = 'v';
11337 *ins->obufp++ = 'e';
11338 *ins->obufp++ = 'x';
11339 *ins->obufp++ = '}';
11340 *ins->obufp++ = ' ';
11343 if (ins->rex & REX_W)
11345 *ins->obufp++ = 'a';
11346 *ins->obufp++ = 'b';
11347 *ins->obufp++ = 's';
11362 if (ins->rex & REX_W)
11364 if (ins->intel_syntax)
11365 *ins->obufp++ = 'd';
11367 *ins->obufp++ = 'l';
11370 *ins->obufp++ = 'w';
11372 *ins->obufp++ = 'b';
11373 if (!(ins->rex & REX_W))
11374 ins->used_prefixes |= (ins->prefixes & PREFIX_DATA);
11378 if (!ins->need_vex)
11381 *ins->obufp++ = ins->vex.w ? 'd': 's';
11383 *ins->obufp++ = ins->vex.w ? 'w': 'b';
11393 if (ins->need_vex
11394 ? ins->vex.prefix == DATA_PREFIX_OPCODE
11395 : ins->prefixes & PREFIX_DATA)
11397 *ins->obufp++ = 'd';
11398 ins->used_prefixes |= PREFIX_DATA;
11401 *ins->obufp++ = 's';
11406 if (ins->vex.mask_register_specifier)
11407 ins->illegal_masking = true;
11411 if (!ins->need_vex)
11413 if (ins->intel_syntax
11414 || ((ins->modrm.mod == 3 || ins->vex.b)
11417 switch (ins->vex.length)
11420 *ins->obufp++ = 'x';
11423 *ins->obufp++ = 'y';
11426 if (!ins->vex.evex)
11438 ins->modrm.mod = 3;
11439 if (!ins->intel_syntax && (sizeflag & SUFFIX_ALWAYS))
11440 *ins->obufp++ = ins->address_mode == mode_64bit ? 'q' : 'l';
11444 if (!ins->vex.evex)
11446 if (ins->intel_syntax
11447 || ((ins->modrm.mod == 3 || ins->vex.b)
11450 switch (ins->vex.length)
11453 *ins->obufp++ = 'x';
11456 *ins->obufp++ = 'y';
11459 *ins->obufp++ = 'z';
11469 if (ins->intel_syntax)
11471 if (ins->isa64 == intel64 && (ins->rex & REX_W))
11474 *ins->obufp++ = 'q';
11477 if ((ins->prefixes & PREFIX_DATA) || (sizeflag & SUFFIX_ALWAYS))
11480 *ins->obufp++ = 'l';
11482 *ins->obufp++ = 'w';
11483 ins->used_prefixes |= (ins->prefixes & PREFIX_DATA);
11491 *ins
11492 ins->mnemonicendp = ins->obufp;
11496 /* Add a style marker to *INS->obufp that encodes STYLE. This assumes that
11497 the buffer pointed to by INS->obufp has space. A style marker is made
11503 oappend_insert_style (instr_info *ins, enum disassembler_style style)
11513 *ins->obufp++ = STYLE_MARKER_CHAR;
11514 *ins->obufp++ = (num < 10 ? ('0' + num)
11516 *ins->obufp++ = STYLE_MARKER_CHAR;
11524 *ins->obufp = '\0';
11528 oappend_with_style (instr_info *ins, const char *s,
11531 oappend_insert_style (ins, style);
11532 ins->obufp = stpcpy (ins->obufp, s);
11535 /* Add a single character C to the buffer pointer to by INS->obufp, marking
11539 oappend_char_with_style (instr_info *ins, const char c,
11542 oappend_insert_style (ins, style);
11543 *ins->obufp++ = c;
11544 *ins->obufp = '\0';
11550 oappend_char (instr_info *ins, const char c)
11552 oappend_char_with_style (ins, c, dis_style_text);
11556 append_seg (instr_info *ins)
11559 if (!ins->active_seg_prefix)
11562 ins->used_prefixes |= ins->active_seg_prefix;
11563 switch (ins->active_seg_prefix)
11566 oappend_register (ins, att_names_seg[1]);
11569 oappend_register (ins, att_names_seg[3]);
11572 oappend_register (ins, att_names_seg[2]);
11575 oappend_register (ins, att_names_seg[0]);
11578 oappend_register (ins, att_names_seg[4]);
11581 oappend_register (ins, att_names_seg[5]);
11586 oappend_char (ins, ':');
11590 print_operand_value (instr_info *ins, bfd_vma disp,
11595 if (ins->address_mode != mode_64bit)
11598 oappend_with_style (ins, tmp, style);
11604 oappend_immediate (instr_info *ins, bfd_vma imm)
11606 if (!ins->intel_syntax)
11607 oappend_char_with_style (ins, '$', dis_style_immediate);
11608 print_operand_value (ins, imm, dis_style_immediate);
11614 print_displacement (instr_info *ins, bfd_signed_vma val)
11620 oappend_char_with_style (ins, '-', dis_style_address_offset);
11626 switch (ins->address_mode)
11629 oappend_with_style (ins, "0x8000000000000000",
11633 oappend_with_style (ins, "0x80000000",
11637 oappend_with_style (ins, "0x8000",
11646 oappend_with_style (ins, tmp, dis_style_address_offset);
11650 intel_operand_size (instr_info *ins, int bytemode, int sizeflag)
11653 if (ins->vex.b && ins->evex_type == evex_default)
11655 if (!ins->vex.no_broadcast)
11660 if (ins->vex.w)
11661 oappend (ins, "QWORD BCST ");
11663 oappend (ins, "DWORD BCST ");
11668 oappend (ins, "WORD BCST ");
11671 ins->vex.no_broadcast = true;
11681 oappend (ins, "BYTE PTR ");
11686 oappend (ins, "WORD PTR ");
11689 if (ins->address_mode == mode_64bit && ins->isa64 == intel64)
11691 oappend (ins, "QWORD PTR ");
11696 if (ins->address_mode == mode_64bit && ((sizeflag & DFLAG)
11697 || (ins->rex & REX_W)))
11699 oappend (ins, "QWORD PTR ");
11707 if (ins->rex & REX_W)
11708 oappend (ins, "QWORD PTR ");
11710 oappend (ins, "DWORD PTR ");
11714 oappend (ins, "DWORD PTR ");
11716 oappend (ins, "WORD PTR ");
11717 ins->used_prefixes |= (ins->prefixes & PREFIX_DATA);
11721 if ((ins->rex & REX_W) || (sizeflag & DFLAG))
11722 *ins->obufp++ = 'D';
11723 oappend (ins, "WORD PTR ");
11724 if (!(ins->rex & REX_W))
11725 ins->used_prefixes |= (ins->prefixes & PREFIX_DATA);
11729 oappend (ins, "QWORD PTR ");
11731 oappend (ins, "DWORD PTR ");
11732 ins->used_prefixes |= (ins->prefixes & PREFIX_DATA);
11735 if (!(sizeflag & DFLAG) && ins->isa64 == intel64)
11736 oappend (ins, "WORD PTR ");
11738 oappend (ins, "DWORD PTR ");
11739 ins->used_prefixes |= (ins->prefixes & PREFIX_DATA);
11743 oappend (ins, "DWORD PTR ");
11747 oappend (ins, "QWORD PTR ");
11750 if (ins->address_mode == mode_64bit)
11751 oappend (ins, "QWORD PTR ");
11753 oappend (ins, "DWORD PTR ");
11757 oappend (ins, "FWORD PTR ");
11759 oappend (ins, "DWORD PTR ");
11760 ins->used_prefixes |= (ins->prefixes & PREFIX_DATA);
11763 oappend (ins, "TBYTE PTR ");
11771 if (ins->need_vex)
11773 switch (ins->vex.length)
11776 oappend (ins, "XMMWORD PTR ");
11779 oappend (ins, "YMMWORD PTR ");
11782 oappend (ins, "ZMMWORD PTR ");
11789 oappend (ins, "XMMWORD PTR ");
11792 oappend (ins, "XMMWORD PTR ");
11795 oappend (ins, "YMMWORD PTR ");
11800 switch (ins->vex.length)
11804 oappend (ins, "QWORD PTR ");
11807 oappend (ins, "XMMWORD PTR ");
11810 oappend (ins, "YMMWORD PTR ");
11817 if (!ins->need_vex)
11820 switch (ins->vex.length)
11823 oappend (ins, "WORD PTR ");
11826 oappend (ins, "DWORD PTR ");
11829 oappend (ins, "QWORD PTR ");
11837 if (!ins->need_vex)
11840 switch (ins->vex.length)
11843 oappend (ins, "DWORD PTR ");
11846 oappend (ins, "QWORD PTR ");
11849 oappend (ins, "XMMWORD PTR ");
11856 if (!ins->need_vex)
11859 switch (ins->vex.length)
11862 oappend (ins, "QWORD PTR ");
11865 oappend (ins, "YMMWORD PTR ");
11868 oappend (ins, "ZMMWORD PTR ");
11875 oappend (ins, "OWORD PTR ");
11879 if (!ins->need_vex)
11881 if (ins->vex.w)
11882 oappend (ins, "QWORD PTR ");
11884 oappend (ins, "DWORD PTR ");
11887 if (!ins->need_vex || ins->vex.length != 128)
11889 if (ins->vex.w)
11890 oappend (ins, "DWORD PTR ");
11892 oappend (ins, "BYTE PTR ");
11895 if (!ins->need_vex)
11897 if (ins->vex.w)
11898 oappend (ins, "QWORD PTR ");
11900 oappend (ins, "WORD PTR ");
11910 print_register (instr_info *ins, unsigned int reg, unsigned int rexmask,
11917 if (bytemode != mask_mode && ins->vex.mask_register_specifier)
11918 ins->illegal_masking = true;
11921 if (ins->rex & rexmask)
11923 if (ins->rex2 & rexmask)
11932 if (ins->rex || ins->rex2)
11950 names = ins->address_mode == mode_64bit ? att_names64 : att_names32;
11956 oappend (ins, "(bad)");
11962 if (ins->address_mode == mode_64bit && ins->isa64 == intel64)
11969 if (ins->address_mode == mode_64bit && ((sizeflag & DFLAG)
11970 || (ins->rex & REX_W)))
11981 if (ins->rex & REX_W)
11991 ins->used_prefixes |= (ins->prefixes & PREFIX_DATA);
11995 if (!(sizeflag & DFLAG) && ins->isa64 == intel64)
11999 ins->used_prefixes |= (ins->prefixes & PREFIX_DATA);
12002 names = (ins->address_mode == mode_64bit
12004 if (!(ins->prefixes & PREFIX_ADDR))
12005 names = (ins->address_mode == mode_16bit
12010 ins->all_prefixes[ins->last_addr_prefix] = 0;
12011 names = (ins->address_mode != mode_32bit
12013 ins->used_prefixes |= PREFIX_ADDR;
12020 oappend (ins, "(bad)");
12028 oappend (ins, INTERNAL_DISASSEMBLER_ERROR);
12031 oappend_register (ins, names[reg]);
12035 get8s (instr_info *ins, bfd_vma *res)
12037 if (!fetch_code (ins->info, ins->codep + 1))
12039 *res = ((bfd_vma) *ins->codep++ ^ 0x80) - 0x80;
12044 get16 (instr_info *ins, bfd_vma *res)
12046 if (!fetch_code (ins->info, ins->codep + 2))
12048 *res = *ins->codep++;
12049 *res |= (bfd_vma) *ins->codep++ << 8;
12054 get16s (instr_info *ins, bfd_vma *res)
12056 if (!get16 (ins, res))
12063 get32 (instr_info *ins, bfd_vma *res)
12065 if (!fetch_code (ins->info, ins->codep + 4))
12067 *res = *ins->codep++;
12068 *res |= (bfd_vma) *ins->codep++ << 8;
12069 *res |= (bfd_vma) *ins->codep++ << 16;
12070 *res |= (bfd_vma) *ins->codep++ << 24;
12075 get32s (instr_info *ins, bfd_vma *res)
12077 if (!get32 (ins, res))
12086 get64 (instr_info *ins, uint64_t *res)
12091 if (!fetch_code (ins->info, ins->codep + 8))
12093 a = *ins->codep++;
12094 a |= (unsigned int) *ins->codep++ << 8;
12095 a |= (unsigned int) *ins->codep++ << 16;
12096 a |= (unsigned int) *ins->codep++ << 24;
12097 b = *ins->codep++;
12098 b |= (unsigned int) *ins->codep++ << 8;
12099 b |= (unsigned int) *ins->codep++ << 16;
12100 b |= (unsigned int) *ins->codep++ << 24;
12106 set_op (instr_info *ins, bfd_vma op, bool riprel)
12108 ins->op_index[ins->op_ad] = ins->op_ad;
12109 if (ins->address_mode == mode_64bit)
12110 ins->op_address[ins->op_ad] = op;
12112 ins->op_address[ins->op_ad] = op & 0xffffffff;
12113 ins->op_riprel[ins->op_ad] = riprel;
12117 BadOp (instr_info *ins)
12120 struct dis_private *priv = ins->info->private_data;
12122 ins->codep = priv->the_buffer + ins->nr_prefixes + ins->need_vex + 1;
12123 ins->obufp = stpcpy (ins->obufp, "(bad)");
12128 OP_Skip_MODRM (instr_info *ins, int bytemode ATTRIBUTE_UNUSED,
12131 if (ins->modrm.mod != 3)
12132 return BadOp (ins);
12136 ins->codep++;
12137 ins->has_skipped_modrm = true;
12142 OP_E_memory (instr_info *ins, int bytemode, int sizeflag)
12144 int add = (ins->rex & REX_B) ? 8 : 0;
12148 add += (ins->rex2 & REX_B) ? 16 : 0;
12151 if (ins->vex.evex && ins->evex_type == evex_default)
12157 if (ins->vex.zeroing)
12158 ins->illegal_masking = true;
12172 if (ins->address_mode != mode_64bit)
12183 shift = ins->vex.w ? 3 : 2;
12188 if (ins->vex.b)
12190 shift = ins->vex.w ? 2 : 1;
12196 if (ins->vex.b)
12198 shift = ins->vex.w ? 3 : 2;
12208 switch (ins->vex.length)
12226 || (bytemode == ymmq_mode && ins->vex.length == 128))
12245 shift = ins->vex.w ? 1 : 0;
12255 if (ins->intel_syntax)
12256 intel_operand_size (ins, bytemode, sizeflag);
12257 append_seg (ins);
12259 if ((sizeflag & AFLAG) || ins->address_mode == mode_64bit)
12279 base = ins->modrm.rm;
12283 vindex = ins->sib.index;
12285 if (ins->rex & REX_X)
12291 if (!ins->need_vex)
12293 if (ins->vex.evex)
12296 if (ins->rex2 & REX_X)
12298 oappend (ins, "(bad)");
12302 if (!ins->vex.v)
12304 check_gather = ins->obufp == ins->op_out[1];
12307 switch (ins->vex.length)
12313 if (!ins->vex.w
12320 if (!ins->vex.w
12331 if (ins->rex2 & REX_X)
12335 indexes = ins->address_mode == mode_64bit && !addr32flag
12339 scale = ins->sib.scale;
12340 base = ins->sib.base;
12341 ins->codep++;
12350 oappend (ins, "(bad)");
12356 switch (ins->modrm.mod)
12362 if (ins->address_mode == mode_64bit && !ins->has_sib)
12364 if (!get32s (ins, &disp))
12368 oappend (ins, "(bad)");
12374 if (!get8s (ins, &disp))
12376 if (ins->vex.evex && shift > 0)
12380 if (!get32s (ins, &disp))
12387 if (ins->has_sib
12390 && ins->address_mode != mode_16bit)
12392 if (ins->address_mode == mode_64bit)
12413 || (ins->has_sib && (indexes || scale != 0)));
12415 if (!ins->intel_syntax)
12416 if (ins->modrm.mod != 0 || base == 5)
12419 print_displacement (ins, disp);
12421 print_operand_value (ins, disp, dis_style_address_offset);
12424 set_op (ins, disp, true);
12425 oappend_char (ins, '(');
12426 oappend_with_style (ins, !addr32flag ? "%rip" : "%eip",
12428 oappend_char (ins, ')');
12433 && (ins->address_mode != mode_64bit
12438 ins->used_prefixes |= PREFIX_ADDR;
12440 if (havedisp || (ins->intel_syntax && riprel))
12442 oappend_char (ins, ins->open_char);
12443 if (ins->intel_syntax && riprel)
12445 set_op (ins, disp, true);
12446 oappend_with_style (ins, !addr32flag ? "rip" : "eip",
12451 (ins,
12452 (ins->address_mode == mode_64bit && !addr32flag
12454 if (ins->has_sib)
12463 if (!ins->intel_syntax || havebase)
12464 oappend_char (ins, ins->separator_char);
12467 if (ins->address_mode == mode_64bit || vindex < 16)
12468 oappend_register (ins, indexes[vindex]);
12470 oappend (ins, "(bad)");
12473 oappend_register (ins,
12474 ins->address_mode == mode_64bit
12479 oappend_char (ins, ins->scale_char);
12480 oappend_char_with_style (ins, '0' + (1 << scale),
12484 if (ins->intel_syntax
12485 && (disp || ins->modrm.mod != 0 || base == 5))
12488 oappend_char (ins, '+');
12490 print_displacement (ins, disp);
12492 print_operand_value (ins, disp, dis_style_address_offset);
12495 oappend_char (ins, ins->close_char);
12500 int modrm_reg = ins->modrm.reg;
12502 if (ins->rex & REX_R)
12504 if (ins->rex2 & REX_R)
12507 oappend (ins, "/(bad)");
12510 else if (ins->intel_syntax)
12512 if (ins->modrm.mod != 0 || base == 5)
12514 if (!ins->active_seg_prefix)
12516 oappend_register (ins, att_names_seg[ds_reg - es_reg]);
12517 oappend (ins, ":");
12519 print_operand_value (ins, disp, dis_style_text);
12530 oappend (ins, "(bad)");
12538 ins->used_prefixes |= ins->prefixes & PREFIX_ADDR;
12539 switch (ins->modrm.mod)
12542 if (ins->modrm.rm == 6)
12545 if (!get16s (ins, &disp))
12550 if (!get8s (ins, &disp))
12552 if (ins->vex.evex && shift > 0)
12557 if (!ins->intel_syntax)
12558 if (ins->modrm.mod != 0 || ins->modrm.rm == 6)
12559 print_displacement (ins, disp);
12561 if (ins->modrm.mod != 0 || ins->modrm.rm != 6)
12563 oappend_char (ins, ins->open_char);
12564 oappend (ins, ins->intel_syntax ? intel_index16[ins->modrm.rm]
12565 : att_index16[ins->modrm.rm]);
12566 if (ins->intel_syntax
12567 && (disp || ins->modrm.mod != 0 || ins->modrm.rm == 6))
12570 oappend_char (ins, '+');
12571 print_displacement (ins, disp);
12574 oappend_char (ins, ins->close_char);
12576 else if (ins->intel_syntax)
12578 if (!ins->active_seg_prefix)
12580 oappend_register (ins, att_names_seg[ds_reg - es_reg]);
12581 oappend (ins, ":");
12583 print_operand_value (ins, disp & 0xffff, dis_style_text);
12586 if (ins->vex.b && ins->evex_type == evex_default)
12588 ins->evex_used |= EVEX_b_used;
12591 if (ins->obufp == ins->op_out[0])
12592 ins->vex.no_broadcast = true;
12594 if (!ins->vex.no_broadcast
12595 && (!ins->intel_syntax || !(ins->evex_used & EVEX_len_used)))
12599 switch (ins->vex.length)
12602 oappend (ins, "{1to8}");
12605 oappend (ins, "{1to16}");
12608 oappend (ins, "{1to32}");
12616 ins->vex.no_broadcast = true;
12617 else if (ins->vex.w
12621 switch (ins->vex.length)
12624 oappend (ins, "{1to2}");
12627 oappend (ins, "{1to4}");
12630 oappend (ins, "{1to8}");
12639 switch (ins->vex.length)
12642 oappend (ins, "{1to4}");
12645 oappend (ins, "{1to8}");
12648 oappend (ins, "{1to16}");
12655 ins->vex.no_broadcast = true;
12657 if (ins->vex.no_broadcast)
12658 oappend (ins, "{bad}");
12665 OP_E (instr_info *ins, int bytemode, int sizeflag)
12669 if (!ins->has_skipped_modrm)
12671 ins->codep++;
12672 ins->has_skipped_modrm = true;
12675 if (ins->modrm.mod == 3)
12681 swap_operand (ins);
12683 print_register (ins, ins->modrm.rm, REX_B, bytemode, sizeflag);
12690 if (ins->vex.mask_register_specifier)
12691 ins->illegal_masking = true;
12693 return OP_E_memory (ins, bytemode, sizeflag);
12697 OP_indirE (instr_info *ins, int bytemode, int sizeflag)
12699 if (ins->modrm.mod == 3 && bytemode == f_mode)
12701 return BadOp (ins);
12702 if (!ins->intel_syntax)
12703 oappend (ins, "*");
12704 return OP_E (ins, bytemode, sizeflag);
12708 OP_G (instr_info *ins, int bytemode, int sizeflag)
12710 print_register (ins, ins->modrm.reg, REX_R, bytemode, sizeflag);
12715 OP_REG (instr_info *ins, int code, int sizeflag)
12724 oappend_register (ins, att_names_seg[code - es_reg]);
12729 if (ins->rex & REX_B)
12731 if (ins->rex2 & REX_B)
12744 if (ins->rex)
12751 if (ins->address_mode == mode_64bit
12752 && ((sizeflag & DFLAG) || (ins->rex & REX_W)))
12762 if (ins->rex & REX_W)
12770 ins->used_prefixes |= (ins->prefixes & PREFIX_DATA);
12774 oappend (ins, INTERNAL_DISASSEMBLER_ERROR);
12777 oappend_register (ins, s);
12782 OP_IMREG (instr_info *ins, int code, int sizeflag)
12789 if (!ins->intel_syntax)
12791 oappend (ins, "(%dx)");
12801 if (ins->rex & REX_W)
12808 if ((ins->rex & REX_W) || (sizeflag & DFLAG))
12812 if (!(ins->rex & REX_W))
12813 ins->used_prefixes |= (ins->prefixes & PREFIX_DATA);
12816 oappend (ins, INTERNAL_DISASSEMBLER_ERROR);
12819 oappend_register (ins, s);
12824 OP_I (instr_info *ins, int bytemode, int sizeflag)
12831 if (!fetch_code (ins->info, ins->codep + 1))
12833 op = *ins->codep++;
12837 if (ins->rex & REX_W)
12839 if (!get32s (ins, &op))
12844 ins->used_prefixes |= (ins->prefixes & PREFIX_DATA);
12848 if (!get32 (ins, &op))
12855 if (!get16 (ins, &op))
12861 if (ins->intel_syntax)
12862 oappend_with_style (ins, "1", dis_style_immediate);
12864 oappend_with_style (ins, "$1", dis_style_immediate);
12867 oappend (ins, INTERNAL_DISASSEMBLER_ERROR);
12871 oappend_immediate (ins, op);
12876 OP_I64 (instr_info *ins, int bytemode, int sizeflag)
12880 if (bytemode != v_mode || ins->address_mode != mode_64bit
12881 || !(ins->rex & REX_W))
12882 return OP_I (ins, bytemode, sizeflag);
12886 if (!get64 (ins, &op))
12889 oappend_immediate (ins, op);
12894 OP_sI (instr_info *ins, int bytemode, int sizeflag)
12902 if (!get8s (ins, &op))
12906 if (ins->address_mode != mode_64bit
12907 || !((sizeflag & DFLAG) || (ins->rex & REX_W)))
12910 if ((sizeflag & DFLAG) || (ins->rex & REX_W))
12918 if (!(ins->rex & REX_W))
12929 if (!(sizeflag & DFLAG) && !(ins->rex & REX_W))
12931 if (!get16 (ins, &op))
12934 else if (!get32s (ins, &op))
12938 oappend (ins, INTERNAL_DISASSEMBLER_ERROR);
12942 oappend_immediate (ins, op);
12947 OP_J (instr_info *ins, int bytemode, int sizeflag)
12956 if (!get8s (ins, &disp))
12962 || (ins->address_mode == mode_64bit
12963 && ((ins->isa64 == intel64 && bytemode != dqw_mode)
12964 || (ins->rex & REX_W))))
12966 if (!get32s (ins, &disp))
12971 if (!get16s (ins, &disp))
12978 if ((ins->prefixes & PREFIX_DATA) == 0)
12979 segment = ((ins->start_pc + (ins->codep - ins->start_codep))
12982 if (ins->address_mode != mode_64bit
12983 || (ins->isa64 != intel64 && !(ins->rex & REX_W)))
12984 ins->used_prefixes |= (ins->prefixes & PREFIX_DATA);
12987 oappend (ins, INTERNAL_DISASSEMBLER_ERROR);
12990 disp = ((ins->start_pc + (ins->codep - ins->start_codep) + disp) & mask)
12992 set_op (ins, disp, false);
12993 print_operand_value (ins, disp, dis_style_text);
12998 OP_SEG (instr_info *ins, int bytemode, int sizeflag)
13002 oappend_register (ins, att_names_seg[ins->modrm.reg]);
13005 return OP_E (ins, ins->modrm.mod == 3 ? bytemode : w_mode, sizeflag);
13009 OP_DIR (instr_info *ins, int dummy ATTRIBUTE_UNUSED, int sizeflag)
13017 if (!get32 (ins, &offset))
13020 else if (!get16 (ins, &offset))
13022 if (!get16 (ins, &seg))
13024 ins->used_prefixes |= (ins->prefixes & PREFIX_DATA);
13027 ins->intel_syntax ? "0x%x:0x%x" : "$0x%x,$0x%x",
13031 oappend (ins, scratch);
13036 OP_OFF (instr_info *ins, int bytemode, int sizeflag)
13040 if (ins->intel_syntax && (sizeflag & SUFFIX_ALWAYS))
13041 intel_operand_size (ins, bytemode, sizeflag);
13042 append_seg (ins);
13044 if ((sizeflag & AFLAG) || ins->address_mode == mode_64bit)
13046 if (!get32 (ins, &off))
13051 if (!get16 (ins, &off))
13055 if (ins->intel_syntax)
13057 if (!ins->active_seg_prefix)
13059 oappend_register (ins, att_names_seg[ds_reg - es_reg]);
13060 oappend (ins, ":");
13063 print_operand_value (ins, off, dis_style_address_offset);
13068 OP_OFF64 (instr_info *ins, int bytemode, int sizeflag)
13072 if (ins->address_mode != mode_64bit
13073 || (ins->prefixes & PREFIX_ADDR))
13074 return OP_OFF (ins, bytemode, sizeflag);
13076 if (ins->intel_syntax && (sizeflag & SUFFIX_ALWAYS))
13077 intel_operand_size (ins, bytemode, sizeflag);
13078 append_seg (ins);
13080 if (!get64 (ins, &off))
13083 if (ins->intel_syntax)
13085 if (!ins->active_seg_prefix)
13087 oappend_register (ins, att_names_seg[ds_reg - es_reg]);
13088 oappend (ins, ":");
13091 print_operand_value (ins, off, dis_style_address_offset);
13096 ptr_reg (instr_info *ins, int code, int sizeflag)
13100 *ins->obufp++ = ins->open_char;
13101 ins->used_prefixes |= (ins->prefixes & PREFIX_ADDR);
13102 if (ins->address_mode == mode_64bit)
13113 oappend_register (ins, s);
13114 oappend_char (ins, ins->close_char);
13118 OP_ESreg (instr_info *ins, int code, int sizeflag)
13120 if (ins->intel_syntax)
13122 switch (ins->codep[-1])
13125 intel_operand_size (ins, z_mode, sizeflag);
13131 intel_operand_size (ins, v_mode, sizeflag);
13134 intel_operand_size (ins, b_mode, sizeflag);
13137 if (ins->address_mode != mode_64bit)
13139 oappend_register (ins, att_names_seg[0]);
13140 oappend_char (ins, ':');
13142 ptr_reg (ins, code, sizeflag);
13147 OP_DSreg (instr_info *ins, int code, int sizeflag)
13149 if (ins->intel_syntax)
13151 switch (ins->codep[-1])
13156 intel_operand_size (ins, z_mode, sizeflag);
13161 intel_operand_size (ins, v_mode, sizeflag);
13164 intel_operand_size (ins, b_mode, sizeflag);
13167 /* Outside of 64-bit mode set ins->active_seg_prefix to PREFIX_DS if it
13169 if (ins->address_mode != mode_64bit && !ins->active_seg_prefix)
13170 ins->active_seg_prefix = PREFIX_DS;
13171 append_seg (ins);
13172 ptr_reg (ins, code, sizeflag);
13177 OP_C (instr_info *ins, int dummy ATTRIBUTE_UNUSED,
13183 if (ins->rex & REX_R)
13188 else if (ins->address_mode != mode_64bit && (ins->prefixes & PREFIX_LOCK))
13190 ins->all_prefixes[ins->last_lock_prefix] = 0;
13191 ins->used_prefixes |= PREFIX_LOCK;
13197 ins->modrm.reg + add);
13200 oappend_register (ins, scratch);
13205 OP_D (instr_info *ins, int dummy ATTRIBUTE_UNUSED,
13212 if (ins->rex & REX_R)
13217 ins->intel_syntax ? "dr%d" : "%%db%d",
13218 ins->modrm.reg + add);
13221 oappend (ins, scratch);
13226 OP_T (instr_info *ins, int dummy ATTRIBUTE_UNUSED,
13232 res = snprintf (scratch, ARRAY_SIZE (scratch), "%%tr%d", ins->modrm.reg);
13235 oappend_register (ins, scratch);
13240 OP_MMX (instr_info *ins, int bytemode ATTRIBUTE_UNUSED,
13243 int reg = ins->modrm.reg;
13246 ins->used_prefixes |= (ins->prefixes & PREFIX_DATA);
13247 if (ins->prefixes & PREFIX_DATA)
13251 if (ins->rex & REX_R)
13256 oappend_register (ins, names[reg]);
13261 print_vector_reg (instr_info *ins, unsigned int reg, int bytemode)
13269 switch (ins->vex.length)
13278 ins->evex_used |= EVEX_len_used;
13290 oappend (ins, "(bad)");
13295 else if (ins->need_vex
13307 ins->evex_used |= EVEX_len_used;
13308 switch (ins->vex.length)
13314 if (ins->vex.w
13321 if (ins->vex.w
13333 oappend_register (ins, names[reg]);
13337 OP_XMM (instr_info *ins, int bytemode, int sizeflag ATTRIBUTE_UNUSED)
13339 unsigned int reg = ins->modrm.reg;
13342 if (ins->rex & REX_R)
13344 if (ins->vex.evex)
13346 if (ins->rex2 & REX_R)
13351 ins->modrm.reg = reg;
13353 ins->vex.no_broadcast = true;
13355 print_vector_reg (ins, reg, bytemode);
13360 OP_EM (instr_info *ins, int bytemode, int sizeflag)
13365 if (ins->modrm.mod != 3)
13367 if (ins->intel_syntax
13370 bytemode = (ins->prefixes & PREFIX_DATA) ? x_mode : q_mode;
13371 ins->used_prefixes |= (ins->prefixes & PREFIX_DATA);
13373 return OP_E (ins, bytemode, sizeflag);
13377 swap_operand (ins);
13381 ins->codep++;
13382 ins->used_prefixes |= (ins->prefixes & PREFIX_DATA);
13383 reg = ins->modrm.rm;
13384 if (ins->prefixes & PREFIX_DATA)
13388 if (ins->rex & REX_B)
13393 oappend_register (ins, names[reg]);
13403 OP_EMC (instr_info *ins, int bytemode, int sizeflag)
13405 if (ins->modrm.mod != 3)
13407 if (ins->intel_syntax && bytemode == v_mode)
13409 bytemode = (ins->prefixes & PREFIX_DATA) ? x_mode : q_mode;
13410 ins->used_prefixes |= (ins->prefixes & PREFIX_DATA);
13412 return OP_E (ins, bytemode, sizeflag);
13417 ins->codep++;
13418 ins->used_prefixes |= (ins->prefixes & PREFIX_DATA);
13419 oappend_register (ins, att_names_mm[ins->modrm.rm]);
13424 OP_MXC (instr_info *ins, int bytemode ATTRIBUTE_UNUSED,
13427 ins->used_prefixes |= (ins->prefixes & PREFIX_DATA);
13428 oappend_register (ins, att_names_mm[ins->modrm.reg]);
13433 OP_EX (instr_info *ins, int bytemode, int sizeflag)
13439 ins->codep++;
13442 bytemode = ins->vex.w ? q_mode : d_mode;
13444 if (ins->modrm.mod != 3)
13445 return OP_E_memory (ins, bytemode, sizeflag);
13447 reg = ins->modrm.rm;
13449 if (ins->rex & REX_B)
13451 if (ins->vex.evex)
13454 if ((ins->rex & REX_X))
13456 ins->rex2_used &= ~REX_B;
13458 else if (ins->rex2 & REX_B)
13466 swap_operand (ins);
13469 ins->modrm.rm = reg;
13471 print_vector_reg (ins, reg, bytemode);
13476 OP_R (instr_info *ins, int bytemode, int sizeflag)
13478 if (ins->modrm.mod != 3)
13479 return BadOp (ins);
13487 return OP_E (ins, bytemode, sizeflag);
13489 return OP_EM (ins, x_mode, sizeflag);
13491 if (ins->vex.length <= 128)
13493 return BadOp (ins);
13496 return OP_EX (ins, bytemode, sizeflag);
13500 OP_M (instr_info *ins, int bytemode, int sizeflag)
13504 ins->codep++;
13506 if (ins->modrm.mod == 3)
13508 return BadOp (ins);
13511 ins->vex.no_broadcast = true;
13513 return OP_E_memory (ins, bytemode, sizeflag);
13517 OP_0f07 (instr_info *ins, int bytemode, int sizeflag)
13519 if (ins->modrm.mod != 3 || ins->modrm.rm != 0)
13520 return BadOp (ins);
13521 return OP_E (ins, bytemode, sizeflag);
13527 MONTMUL_Fixup (instr_info *ins, int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
13529 if (ins->modrm.mod != 3 || ins->modrm.rm != 0)
13530 return BadOp (ins);
13533 if (ins->prefixes & PREFIX_REPZ)
13534 ins->all_prefixes[ins->last_repz_prefix] = 0xf3;
13538 ins->codep++;
13546 NOP_Fixup (instr_info *ins, int opnd, int sizeflag)
13548 if ((ins->prefixes & PREFIX_DATA) == 0 && (ins->rex & REX_B) == 0)
13550 ins->mnemonicendp = stpcpy (ins->obuf, "nop");
13554 return OP_REG (ins, eAX_reg, sizeflag);
13555 return OP_IMREG (ins, eAX_reg, sizeflag);
13626 OP_3DNowSuffix (instr_info *ins, int bytemode ATTRIBUTE_UNUSED,
13631 if (!fetch_code (ins->info, ins->codep + 1))
13636 ins->obufp = ins->mnemonicendp;
13637 mnemonic = Suffix3DNow[*ins->codep++];
13639 ins->obufp = stpcpy (ins->obufp, mnemonic);
13642 /* Since a variable sized ins->modrm/ins->sib chunk is between the start
13644 all the ins->modrm processing first, and don't know until now that
13646 ins->op_out[0][0] = '\0';
13647 ins->op_out[1][0] = '\0';
13648 BadOp (ins);
13650 ins->mnemonicendp = ins->obufp;
13695 CMP_Fixup (instr_info *ins, int bytemode ATTRIBUTE_UNUSED,
13700 if (!fetch_code (ins->info, ins->codep + 1))
13702 cmp_type = *ins->codep++;
13706 char *p = ins->mnemonicendp - 2;
13711 ins->mnemonicendp += simd_cmp_op[cmp_type].len;
13713 else if (ins->need_vex
13717 char *p = ins->mnemonicendp - 2;
13723 ins->mnemonicendp += vex_cmp_op[cmp_type].len;
13728 oappend_immediate (ins, cmp_type);
13734 OP_Mwait (instr_info *ins, int bytemode, int sizeflag ATTRIBUTE_UNUSED)
13737 if (!ins->intel_syntax)
13739 strcpy (ins->op_out[0], att_names32[0] + ins->intel_syntax);
13740 strcpy (ins->op_out[1], att_names32[1] + ins->intel_syntax);
13742 strcpy (ins->op_out[2], att_names32[3] + ins->intel_syntax);
13743 ins->two_source_ops = true;
13747 ins->codep++;
13752 OP_Monitor (instr_info *ins, int bytemode ATTRIBUTE_UNUSED,
13756 if (!ins->intel_syntax)
13758 const char (*names)[8] = (ins->address_mode == mode_64bit
13761 if (ins->prefixes & PREFIX_ADDR)
13764 ins->all_prefixes[ins->last_addr_prefix] = 0;
13765 names = (ins->address_mode != mode_32bit
13767 ins->used_prefixes |= PREFIX_ADDR;
13769 else if (ins->address_mode == mode_16bit)
13771 strcpy (ins->op_out[0], names[0] + ins->intel_syntax);
13772 strcpy (ins->op_out[1], att_names32[1] + ins->intel_syntax);
13773 strcpy (ins->op_out[2], att_names32[2] + ins->intel_syntax);
13774 ins->two_source_ops = true;
13778 ins->codep++;
13783 REP_Fixup (instr_info *ins, int bytemode, int sizeflag)
13785 /* The 0xf3 prefix should be displayed as "rep" for ins, outs, movs,
13787 if (ins->prefixes & PREFIX_REPZ)
13788 ins->all_prefixes[ins->last_repz_prefix] = REP_PREFIX;
13795 return OP_IMREG (ins, bytemode, sizeflag);
13797 return OP_ESreg (ins, bytemode, sizeflag);
13799 return OP_DSreg (ins, bytemode, sizeflag);
13808 SEP_Fixup (instr_info *ins, int bytemode ATTRIBUTE_UNUSED,
13811 if (ins->isa64 != amd64)
13814 ins->obufp = ins->obuf;
13815 BadOp (ins);
13816 ins->mnemonicendp = ins->obufp;
13817 ++ins->codep;
13825 BND_Fixup (instr_info *ins, int bytemode ATTRIBUTE_UNUSED,
13828 if (ins->prefixes & PREFIX_REPNZ)
13829 ins->all_prefixes[ins->last_repnz_prefix] = BND_PREFIX;
13837 NOTRACK_Fixup (instr_info *ins, int bytemode ATTRIBUTE_UNUSED,
13842 if ((ins->prefixes & PREFIX_DS) != 0
13843 && (ins->address_mode != mode_64bit || ins->last_data_prefix < 0))
13847 ins->active_seg_prefix = 0;
13848 ins->all_prefixes[ins->last_seg_prefix] = NOTRACK_PREFIX;
13853 /* Similar to OP_E. But the 0xf2/0xf3 ins->prefixes should be displayed as
13858 HLE_Fixup1 (instr_info *ins, int bytemode, int sizeflag)
13860 if (ins->modrm.mod != 3
13861 && (ins->prefixes & PREFIX_LOCK) != 0)
13863 if (ins->prefixes & PREFIX_REPZ)
13864 ins->all_prefixes[ins->last_repz_prefix] = XRELEASE_PREFIX;
13865 if (ins->prefixes & PREFIX_REPNZ)
13866 ins->all_prefixes[ins->last_repnz_prefix] = XACQUIRE_PREFIX;
13869 return OP_E (ins, bytemode, sizeflag);
13872 /* Similar to OP_E. But the 0xf2/0xf3 ins->prefixes should be displayed as
13877 HLE_Fixup2 (instr_info *ins, int bytemode, int sizeflag)
13879 if (ins->modrm.mod != 3)
13881 if (ins->prefixes & PREFIX_REPZ)
13882 ins->all_prefixes[ins->last_repz_prefix] = XRELEASE_PREFIX;
13883 if (ins->prefixes & PREFIX_REPNZ)
13884 ins->all_prefixes[ins->last_repnz_prefix] = XACQUIRE_PREFIX;
13887 return OP_E (ins, bytemode, sizeflag);
13894 HLE_Fixup3 (instr_info *ins, int bytemode, int sizeflag)
13896 if (ins->modrm.mod != 3
13897 && ins->last_repz_prefix > ins->last_repnz_prefix
13898 && (ins->prefixes & PREFIX_REPZ) != 0)
13899 ins->all_prefixes[ins->last_repz_prefix] = XRELEASE_PREFIX;
13901 return OP_E (ins, bytemode, sizeflag);
13905 CMPXCHG8B_Fixup (instr_info *ins, int bytemode, int sizeflag)
13908 if (ins->rex & REX_W)
13911 char *p = ins->mnemonicendp - 2;
13912 ins->mnemonicendp = stpcpy (p, "16b");
13915 else if ((ins->prefixes & PREFIX_LOCK) != 0)
13917 if (ins->prefixes & PREFIX_REPZ)
13918 ins->all_prefixes[ins->last_repz_prefix] = XRELEASE_PREFIX;
13919 if (ins->prefixes & PREFIX_REPNZ)
13920 ins->all_prefixes[ins->last_repnz_prefix] = XACQUIRE_PREFIX;
13923 return OP_M (ins, bytemode, sizeflag);
13927 XMM_Fixup (instr_info *ins, int reg, int sizeflag ATTRIBUTE_UNUSED)
13931 if (ins->need_vex)
13933 switch (ins->vex.length)
13944 oappend_register (ins, names[reg]);
13949 FXSAVE_Fixup (instr_info *ins, int bytemode, int sizeflag)
13953 if (ins->rex & REX_W)
13955 char *p = ins->mnemonicendp;
13959 ins->mnemonicendp = p;
13961 return OP_M (ins, bytemode, sizeflag);
13968 OP_VEX (instr_info *ins, int bytemode, int sizeflag ATTRIBUTE_UNUSED)
13973 if (!ins->need_vex)
13976 if (ins->evex_type == evex_from_legacy)
13978 ins->evex_used |= EVEX_b_used;
13979 if (!ins->vex.nd)
13983 reg = ins->vex.register_specifier;
13984 ins->vex.register_specifier = 0;
13985 if (ins->address_mode != mode_64bit)
13987 if (ins->vex.evex && !ins->vex.v)
13989 oappend (ins, "(bad)");
13995 else if (ins->vex.evex && !ins->vex.v)
14001 oappend_register (ins, att_names_xmm[reg]);
14007 if (ins->obufp != ins->op_out[2])
14009 if (ins->vex.length == 128
14011 && !ins->vex.w))
14012 oappend_register (ins, att_names_xmm[reg]);
14014 oappend_register (ins, att_names_ymm[reg]);
14017 modrm_reg = ins->modrm.reg;
14018 if (ins->rex & REX_R)
14021 if (ins->has_sib && ins->modrm.rm == 4)
14023 sib_index = ins->sib.index;
14024 if (ins->rex & REX_X)
14029 strcpy (ins->obufp, "/(bad)");
14031 strcat (ins->op_out[0], "/(bad)");
14033 strcat (ins->op_out[1], "/(bad)");
14040 oappend (ins, "(bad)");
14044 if (ins->obufp != ins->op_out[2])
14046 oappend_register (ins, att_names_tmm[reg]);
14047 if (reg == ins->modrm.reg || reg == ins->modrm.rm)
14048 strcpy (ins->obufp, "/(bad)");
14051 if (ins->modrm.reg == ins->modrm.rm || ins->modrm.reg == reg
14052 || ins->modrm.rm == reg)
14054 if (ins->modrm.reg <= 8
14055 && (ins->modrm.reg == ins->modrm.rm || ins->modrm.reg == reg))
14056 strcat (ins->op_out[0], "/(bad)");
14057 if (ins->modrm.rm <= 8
14058 && (ins->modrm.rm == ins->modrm.reg || ins->modrm.rm == reg))
14059 strcat (ins->op_out[1], "/(bad)");
14066 if (ins->rex & REX_W)
14067 oappend_register (ins, att_names64[reg]);
14070 oappend_register (ins, att_names16[reg]);
14072 oappend_register (ins, att_names32[reg]);
14076 oappend_register (ins, att_names8rex[reg]);
14080 oappend_register (ins, att_names64[reg]);
14084 switch (ins->vex.length)
14091 ins->evex_used |= EVEX_len_used;
14097 oappend (ins, "(bad)");
14112 ins->evex_used |= EVEX_len_used;
14124 oappend (ins, "(bad)");
14130 ins->evex_used |= EVEX_len_used;
14136 oappend_register (ins, names[reg]);
14141 OP_VexR (instr_info *ins, int bytemode, int sizeflag)
14143 if (ins->modrm.mod == 3)
14144 return OP_VEX (ins, bytemode, sizeflag);
14149 OP_VexW (instr_info *ins, int bytemode, int sizeflag)
14151 OP_VEX (ins, bytemode, sizeflag);
14153 if (ins->vex.w)
14156 char *tmp = ins->op_out[2];
14158 ins->op_out[2] = ins->op_out[1];
14159 ins->op_out[1] = tmp;
14165 OP_REG_VexI4 (instr_info *ins, int bytemode, int sizeflag ATTRIBUTE_UNUSED)
14170 if (!fetch_code (ins->info, ins->codep + 1))
14172 reg = *ins->codep++;
14178 if (ins->address_mode != mode_64bit)
14181 if (bytemode == x_mode && ins->vex.length == 256)
14184 oappend_register (ins, names[reg]);
14186 if (ins->vex.w)
14189 char *tmp = ins->op_out[3];
14191 ins->op_out[3] = ins->op_out[2];
14192 ins->op_out[2] = tmp;
14198 OP_VexI4 (instr_info *ins, int bytemode ATTRIBUTE_UNUSED,
14201 oappend_immediate (ins, ins->codep[-1] & 0xf);
14206 VPCMP_Fixup (instr_info *ins, int bytemode ATTRIBUTE_UNUSED,
14211 if (!ins->vex.evex)
14214 if (!fetch_code (ins->info, ins->codep + 1))
14216 cmp_type = *ins->codep++;
14224 char *p = ins->mnemonicendp - 2;
14241 ins->mnemonicendp += simd_cmp_op[cmp_type].len;
14246 oappend_immediate (ins, cmp_type);
14264 VPCOM_Fixup (instr_info *ins, int bytemode ATTRIBUTE_UNUSED,
14269 if (!fetch_code (ins->info, ins->codep + 1))
14271 cmp_type = *ins->codep++;
14275 char *p = ins->mnemonicendp - 2;
14292 ins->mnemonicendp += xop_cmp_op[cmp_type].len;
14297 oappend_immediate (ins, cmp_type);
14311 PCLMUL_Fixup (instr_info *ins, int bytemode ATTRIBUTE_UNUSED,
14316 if (!fetch_code (ins->info, ins->codep + 1))
14318 pclmul_type = *ins->codep++;
14333 char *p = ins->mnemonicendp - 3;
14339 ins->mnemonicendp += pclmul_op[pclmul_type].len;
14344 oappend_immediate (ins, pclmul_type);
14350 MOVSXD_Fixup (instr_info *ins, int bytemode, int sizeflag)
14353 char *p = ins->mnemonicendp;
14358 if (!ins->intel_syntax)
14361 if (ins->rex & REX_W)
14373 oappend (ins, INTERNAL_DISASSEMBLER_ERROR);
14377 ins->mnemonicendp = p;
14379 return OP_E (ins, bytemode, sizeflag);
14383 DistinctDest_Fixup (instr_info *ins, int bytemode, int sizeflag)
14385 unsigned int reg = ins->vex.register_specifier;
14386 unsigned int modrm_reg = ins->modrm.reg;
14387 unsigned int modrm_rm = ins->modrm.rm;
14390 if (ins->rex & REX_R)
14392 if (ins->rex2 & REX_R)
14396 if (ins->address_mode != mode_64bit)
14398 else if (ins->vex.evex && !ins->vex.v)
14402 if (ins->modrm.mod == 3)
14404 if (ins->rex & REX_B)
14406 if (ins->rex & REX_X)
14413 || (ins->modrm.mod == 3
14416 oappend (ins, "(bad)");
14419 return OP_XMM (ins, bytemode, sizeflag);
14423 OP_Rounding (instr_info *ins, int bytemode, int sizeflag ATTRIBUTE_UNUSED)
14425 if (ins->modrm.mod != 3 || !ins->vex.b)
14428 ins->evex_used |= EVEX_b_used;
14432 if (ins->address_mode != mode_64bit || !ins->vex.w)
14436 oappend (ins, names_rounding[ins->vex.ll]);
14439 oappend (ins, "{");
14444 oappend (ins, "sae}");
14449 PREFETCHI_Fixup (instr_info *ins, int bytemode, int sizeflag)
14451 if (ins->modrm.mod != 0 || ins->modrm.rm != 5)
14453 if (ins->intel_syntax)
14455 ins->mnemonicendp = stpcpy (ins->obuf, "nop ");
14460 if (ins->rex & REX_W)
14461 ins->mnemonicendp = stpcpy (ins->obuf, "nopq ");
14465 ins->mnemonicendp = stpcpy (ins->obuf, "nopl ");
14467 ins->mnemonicendp = stpcpy (ins->obuf, "nopw ");
14468 ins->used_prefixes |= (ins->prefixes & PREFIX_DATA);
14474 return OP_M (ins, bytemode, sizeflag);
14478 PUSH2_POP2_Fixup (instr_info *ins, int bytemode, int sizeflag)
14480 if (ins->modrm.mod != 3)
14483 unsigned int vvvv_reg = ins->vex.register_specifier
14484 | (!ins->vex.v << 4);
14485 unsigned int rm_reg = ins->modrm.rm + (ins->rex & REX_B ? 8 : 0)
14486 + (ins->rex2 & REX_B ? 16 : 0);
14489 if (!ins->vex.nd || vvvv_reg == 0x4 || rm_reg == 0x4
14490 || (!ins->modrm.reg
14493 oappend (ins, "(bad)");
14497 return OP_VEX (ins, bytemode, sizeflag);
14501 JMPABS_Fixup (instr_info *ins, int bytemode, int sizeflag)
14503 if (ins->last_rex2_prefix >= 0)
14507 if ((ins->prefixes & (PREFIX_OPCODE | PREFIX_ADDR | PREFIX_LOCK)) != 0x0
14508 || (ins->rex & REX_W) != 0x0)
14510 oappend (ins, "(bad)");
14517 if (!get64 (ins, &op))
14520 ins->mnemonicendp = stpcpy (ins->obuf, "jmpabs");
14521 ins->rex2 |= REX2_SPECIAL;
14522 oappend_immediate (ins, op);
14528 return OP_IMREG (ins, bytemode, sizeflag);
14529 return OP_OFF64 (ins, bytemode, sizeflag);
14533 CFCMOV_Fixup (instr_info *ins, int opnd, int sizeflag)
14537 bool dstmem = !ins->vex.nd && ins->vex.nf;
14542 return OP_E (ins, v_swap_mode, sizeflag);
14543 return OP_G (ins, v_mode, sizeflag);
14547 ins->vex.nf = false;
14548 ins->vex.mask_register_specifier = 0;
14551 return OP_G (ins, v_mode, sizeflag);
14552 return OP_E (ins, v_mode, sizeflag);
Indexes created Sat Apr 04 00:22:49 UTC 2026