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",
1868 typedef bool (*op_rtn) (instr_info *ins, int bytemode, int sizeflag);
2087 { "ins{b|}", { Ybr, indirDX }, 0 },
2602 #define MODRM_CHECK if (!ins->need_modrm) abort ()
4463 { "ins{R|}", { Yzr, indirDX }, 0 },
4464 { "ins{G|}", { Yzr, indirDX }, 0 },
8792 ckprefix (instr_info *ins)
8802 if (!fetch_code (ins->info, ins->codep + 1))
8805 switch (*ins->codep)
8824 if (ins->address_mode == mode_64bit)
8825 newrex = *ins->codep;
8828 ins->last_rex_prefix = i;
8832 if (ins->address_mode == mode_64bit)
8834 if (ins->last_rex_prefix >= 0)
8837 ins->codep++;
8838 if (!fetch_code (ins->info, ins->codep + 1))
8840 ins->rex2_payload = *ins->codep;
8841 ins->rex2 = ins->rex2_payload >> 4;
8842 ins->rex = (ins->rex2_payload & 0xf) | REX_OPCODE;
8843 ins->codep++;
8844 ins->last_rex2_prefix = i;
8845 ins->all_prefixes[i] = REX2_OPCODE;
8849 ins->prefixes |= PREFIX_REPZ;
8850 ins->last_repz_prefix = i;
8853 ins->prefixes |= PREFIX_REPNZ;
8854 ins->last_repnz_prefix = i;
8857 ins->prefixes |= PREFIX_LOCK;
8858 ins->last_lock_prefix = i;
8861 ins->prefixes |= PREFIX_CS;
8862 ins->last_seg_prefix = i;
8863 if (ins->address_mode != mode_64bit)
8864 ins->active_seg_prefix = PREFIX_CS;
8867 ins->prefixes |= PREFIX_SS;
8868 ins->last_seg_prefix = i;
8869 if (ins->address_mode != mode_64bit)
8870 ins->active_seg_prefix = PREFIX_SS;
8873 ins->prefixes |= PREFIX_DS;
8874 ins->last_seg_prefix = i;
8875 if (ins->address_mode != mode_64bit)
8876 ins->active_seg_prefix = PREFIX_DS;
8879 ins->prefixes |= PREFIX_ES;
8880 ins->last_seg_prefix = i;
8881 if (ins->address_mode != mode_64bit)
8882 ins->active_seg_prefix = PREFIX_ES;
8885 ins->prefixes |= PREFIX_FS;
8886 ins->last_seg_prefix = i;
8887 ins->active_seg_prefix = PREFIX_FS;
8890 ins->prefixes |= PREFIX_GS;
8891 ins->last_seg_prefix = i;
8892 ins->active_seg_prefix = PREFIX_GS;
8895 ins->prefixes |= PREFIX_DATA;
8896 ins->last_data_prefix = i;
8899 ins->prefixes |= PREFIX_ADDR;
8900 ins->last_addr_prefix = i;
8906 ins->fwait_prefix = i;
8907 if (ins->prefixes || ins->rex)
8909 ins->prefixes |= PREFIX_FWAIT;
8910 ins->codep++;
8913 return ins->rex ? ckp_bogus : ckp_okay;
8915 ins->prefixes = PREFIX_FWAIT;
8921 if (ins->rex)
8923 if (*ins->codep != FWAIT_OPCODE)
8924 ins->all_prefixes[i++] = *ins->codep;
8925 ins->rex = newrex;
8926 ins->codep++;
9063 get_valid_dis386 (const struct dis386 *dp, instr_info *ins)
9073 dp = ®_table[dp->op[1].bytemode][ins->modrm.reg];
9077 vindex = ins->modrm.mod == 0x3 ? 1 : 0;
9082 dp = &rm_table[dp->op[1].bytemode][ins->modrm.rm];
9087 if (ins->need_vex)
9090 switch (ins->vex.prefix)
9117 if ((ins->prefixes & (PREFIX_REPZ | PREFIX_REPNZ)) != 0)
9119 if (ins->last_repz_prefix > ins->last_repnz_prefix)
9123 last_prefix = ins->last_repz_prefix;
9129 last_prefix = ins->last_repnz_prefix;
9140 if (vindex == 0 && (ins->prefixes & PREFIX_DATA) != 0)
9144 last_prefix = ins->last_data_prefix;
9149 ins->used_prefixes |= prefix;
9150 ins->all_prefixes[last_prefix] = 0;
9160 ins->evex_type = evex_from_vex;
9163 if (ins->address_mode != mode_64bit
9164 || (ins->vex.mask_register_specifier & 0x3) != 0
9165 || ins->vex.ll != 0
9166 || ins->vex.zeroing != 0
9167 || ins->vex.b)
9176 if (ins->modrm.mod == 3)
9183 vindex = ins->address_mode == mode_64bit ? 1 : 0;
9188 if (ins->last_rex2_prefix >= 0)
9190 if (!fetch_code (ins->info, ins->codep + 2))
9192 vindex = *ins->codep++;
9194 ins->end_codep = ins->codep;
9195 if (!fetch_modrm (ins))
9200 if (!ins->need_vex)
9203 switch (ins->vex.length)
9211 if (ins->vex.evex)
9227 if (!ins->vex.evex)
9230 switch (ins->vex.length)
9250 if (!fetch_code (ins->info, ins->codep + 3))
9252 ins->rex = ~(*ins->codep >> 5) & 0x7;
9255 switch ((*ins->codep & 0x1f))
9270 ins->codep++;
9271 ins->vex.w = *ins->codep & 0x80;
9272 if (ins->vex.w && ins->address_mode == mode_64bit)
9273 ins->rex |= REX_W;
9275 ins->vex.register_specifier = (~(*ins->codep >> 3)) & 0xf;
9276 if (ins->address_mode != mode_64bit)
9279 ins->rex &= ~REX_B;
9282 ins->vex.length = (*ins->codep & 0x4) ? 256 : 128;
9283 switch ((*ins->codep & 0x3))
9288 ins->vex.prefix = DATA_PREFIX_OPCODE;
9291 ins->vex.prefix = REPE_PREFIX_OPCODE;
9294 ins->vex.prefix = REPNE_PREFIX_OPCODE;
9297 ins->need_vex = 3;
9298 ins->codep++;
9299 vindex = *ins->codep++;
9302 ins->end_codep = ins->codep;
9303 if (!fetch_modrm (ins))
9308 if (ins->vex.prefix)
9314 if (!fetch_code (ins->info, ins->codep + 3))
9316 ins->rex = ~(*ins->codep >> 5) & 0x7;
9317 switch ((*ins->codep & 0x1f))
9338 ins->codep++;
9339 ins->vex.w = *ins->codep & 0x80;
9340 if (ins->address_mode == mode_64bit)
9342 if (ins->vex.w)
9343 ins->rex |= REX_W;
9350 ins->rex = 0;
9352 ins->vex.register_specifier = (~(*ins->codep >> 3)) & 0xf;
9353 ins->vex.length = (*ins->codep & 0x4) ? 256 : 128;
9354 switch ((*ins->codep & 0x3))
9359 ins->vex.prefix = DATA_PREFIX_OPCODE;
9362 ins->vex.prefix = REPE_PREFIX_OPCODE;
9365 ins->vex.prefix = REPNE_PREFIX_OPCODE;
9368 ins->need_vex = 3;
9369 ins->codep++;
9370 vindex = *ins->codep++;
9371 ins->condition_code = vindex & 0xf;
9389 ins->end_codep = ins->codep;
9392 && !fetch_modrm (ins))
9398 if (!fetch_code (ins->info, ins->codep + 2))
9400 ins->rex = (*ins->codep & 0x80) ? 0 : REX_R;
9404 ins->vex.register_specifier = (~(*ins->codep >> 3)) & 0xf;
9405 ins->vex.length = (*ins->codep & 0x4) ? 256 : 128;
9406 switch ((*ins->codep & 0x3))
9411 ins->vex.prefix = DATA_PREFIX_OPCODE;
9414 ins->vex.prefix = REPE_PREFIX_OPCODE;
9417 ins->vex.prefix = REPNE_PREFIX_OPCODE;
9420 ins->need_vex = 2;
9421 ins->codep++;
9422 vindex = *ins->codep++;
9424 ins->end_codep = ins->codep;
9426 if (vindex != 0x77 && !fetch_modrm (ins))
9432 if (!ins->need_vex)
9435 dp = &vex_w_table[dp->op[1].bytemode][ins->vex.w];
9439 ins->two_source_ops = false;
9441 ins->vex.evex = true;
9442 if (!fetch_code (ins->info, ins->codep + 4))
9445 if (*ins->codep & 0x8)
9446 ins->rex2 |= REX_B;
9447 if (!(*ins->codep & 0x10))
9448 ins->rex2 |= REX_R;
9450 ins->rex = ~(*ins->codep >> 5) & 0x7;
9451 switch (*ins->codep & 0x7)
9466 ins->evex_type = evex_from_legacy;
9467 if (ins->address_mode != mode_64bit)
9469 ins->rex |= REX_OPCODE;
9483 ins->codep++;
9484 ins->vex.w = *ins->codep & 0x80;
9485 if (ins->vex.w && ins->address_mode == mode_64bit)
9486 ins->rex |= REX_W;
9488 ins->vex.register_specifier = (~(*ins->codep >> 3)) & 0xf;
9490 if (!(*ins->codep & 0x4))
9491 ins->rex2 |= REX_X;
9493 switch ((*ins->codep & 0x3))
9498 ins->vex.prefix = DATA_PREFIX_OPCODE;
9501 ins->vex.prefix = REPE_PREFIX_OPCODE;
9504 ins->vex.prefix = REPNE_PREFIX_OPCODE;
9509 ins->codep++;
9512 ins->vex.ll = (*ins->codep >> 5) & 3;
9513 ins->vex.b = *ins->codep & 0x10;
9515 ins->vex.v = *ins->codep & 0x8;
9516 ins->vex.mask_register_specifier = *ins->codep & 0x7;
9517 ins->vex.scc = *ins->codep & 0xf;
9518 ins->vex.zeroing = *ins->codep & 0x80;
9521 ins->vex.nf = *ins->codep & 0x4;
9523 if (ins->address_mode != mode_64bit)
9527 if (ins->evex_type != evex_default
9528 || (ins->rex2 & (REX_B | REX_X)))
9531 ins->rex &= ~REX_B;
9532 ins->rex2 &= ~REX_R;
9535 ins->need_vex = 4;
9537 ins->codep++;
9538 vindex = *ins->codep++;
9539 ins->condition_code = vindex & 0xf;
9548 ins->end_codep = ins->codep;
9549 if (!fetch_modrm (ins))
9552 if (ins->modrm.mod == 3 && (ins->rex2 & REX_X))
9558 if (ins->modrm.mod == 3 && ins->vex.b && ins->evex_type != evex_from_legacy)
9559 ins->vex.length = 512;
9562 switch (ins->vex.ll)
9565 ins->vex.length = 128;
9568 ins->vex.length = 256;
9571 ins->vex.length = 512;
9590 return get_valid_dis386 (dp, ins);
9594 get_sib (instr_info *ins, int sizeflag)
9597 if (ins->need_modrm
9598 && ((sizeflag & AFLAG) || ins->address_mode == mode_64bit)
9599 && ins->modrm.mod != 3
9600 && ins->modrm.rm == 4)
9602 if (!fetch_code (ins->info, ins->codep + 2))
9604 ins->sib.index = (ins->codep[1] >> 3) & 7;
9605 ins->sib.scale = (ins->codep[1] >> 6) & 3;
9606 ins->sib.base = ins->codep[1] & 7;
9607 ins->has_sib = true;
9610 ins->has_sib = false;
9618 oappend (instr_info *ins, const char *s)
9620 oappend_with_style (ins, s, dis_style_text);
9627 oappend_register (instr_info *ins, const char *s)
9629 oappend_with_style (ins, s + ins->intel_syntax, dis_style_register);
9632 /* Wrap around a call to INS->info->fprintf_styled_func, printing FMT.
9733 instr_info ins = {
9743 .obufp = ins.obuf,
9758 ins.address_mode = mode_32bit;
9761 ins.address_mode = mode_16bit;
9765 ins.address_mode = mode_64bit;
9770 ins.isa64 = amd64;
9772 ins.isa64 = intel64;
9775 ins.address_mode = mode_64bit;
9780 ins.address_mode = mode_32bit;
9785 ins.address_mode = mode_16bit;
9791 ins.intel_mnemonic = true;
9793 ins.intel_syntax = 1;
9797 ins.intel_syntax = 0;
9799 ins.intel_mnemonic = false;
9803 if (ins.address_mode == mode_64bit)
9833 if (ins.address_mode == mode_64bit && sizeof (bfd_vma) < 8)
9839 if (ins.intel_syntax)
9841 ins.open_char = '[';
9842 ins.close_char = ']';
9843 ins.separator_char = '+';
9844 ins.scale_char = '*';
9848 ins.open_char = '(';
9849 ins.close_char = ')';
9850 ins.separator_char = ',';
9851 ins.scale_char = ',';
9865 ins.op_out[i] = op_out[i];
9870 switch (ckprefix (&ins))
9878 i < (int) ARRAY_SIZE (ins.all_prefixes) && ins.all_prefixes[i];
9882 prefix_name (ins.address_mode, ins.all_prefixes[i],
9891 ins.nr_prefixes = ins.codep - ins.start_codep;
9893 if (!fetch_code (info, ins.codep + 1))
9896 ret = fetch_error (&ins);
9900 ins.two_source_ops = (*ins.codep == 0x62 || *ins.codep == 0xc8);
9902 if ((ins.prefixes & PREFIX_FWAIT)
9903 && (*ins.codep < 0xd8 || *ins.codep > 0xdf))
9905 /* Handle ins.prefixes before fwait. */
9906 for (i = 0; i < ins.fwait_prefix && ins.all_prefixes[i];
9909 prefix_name (ins.address_mode, ins.all_prefixes[i],
9917 if (ins.last_rex2_prefix < 0 ? *ins.codep == 0x0f : (ins.rex2 & REX2_M))
9919 if (!ins.rex2)
9921 ins.codep++;
9922 if (!fetch_code (info, ins.codep + 1))
9926 dp = &dis386_twobyte[*ins.codep];
9927 ins.need_modrm = twobyte_has_modrm[*ins.codep];
9931 dp = &dis386[*ins.codep];
9932 ins.need_modrm = onebyte_has_modrm[*ins.codep];
9934 ins.condition_code = *ins.codep & 0xf;
9935 ins.codep++;
9937 /* Save sizeflag for printing the extra ins.prefixes later before updating
9941 if (ins.prefixes & PREFIX_ADDR)
9943 if ((ins.prefixes & PREFIX_DATA))
9946 ins.end_codep = ins.codep;
9947 if (ins.need_modrm && !fetch_modrm (&ins))
9952 if (!get_sib (&ins, sizeflag)
9953 || !dofloat (&ins, sizeflag))
9958 dp = get_valid_dis386 (dp, &ins);
9964 if (ins.evex_type == evex_from_legacy
9965 && ins.vex.prefix == DATA_PREFIX_OPCODE)
9968 if(ins.evex_type == evex_default)
9969 ins.vex.nf = false;
9975 ins.vex.mask_register_specifier &= 0x3;
9977 if (dp != NULL && putop (&ins, dp->name, sizeflag) == 0)
9979 if (!get_sib (&ins, sizeflag))
9983 ins.obufp = ins.op_out[i];
9984 ins.op_ad = MAX_OPERANDS - 1 - i;
9986 && !dp->op[i].rtn (&ins, dp->op[i].bytemode, sizeflag))
9990 if (i == 0 && ins.vex.evex)
9993 if (ins.vex.mask_register_specifier)
9996 = att_names_mask[ins.vex.mask_register_specifier];
9998 oappend (&ins, "{");
9999 oappend_register (&ins, reg_name);
10000 oappend (&ins, "}");
10002 if (ins.vex.zeroing)
10003 oappend (&ins, "{z}");
10005 else if (ins.vex.zeroing)
10007 oappend (&ins, "{bad}");
10014 if (ins.vex.zeroing && dp->op[0].bytemode == mask_mode)
10015 ins.illegal_masking = true;
10021 && (ins.vex.mask_register_specifier == 0
10022 || ins.vex.zeroing))
10023 ins.illegal_masking = true;
10025 if (ins.illegal_masking)
10026 oappend (&ins, "/(bad)");
10030 if (ins.vex.nf)
10031 oappend (&ins, "{bad-nf}");
10035 if (ins.modrm.mod == 3 && ins.vex.b && ins.evex_type == evex_default
10036 && !(ins.evex_used & EVEX_b_used))
10040 ins.obufp = ins.op_out[i];
10041 if (*ins.obufp)
10043 oappend (&ins, names_rounding[ins.vex.ll]);
10044 oappend (&ins, "bad}");
10060 ins.op_is_jump = false;
10081 ins.op_is_jump = true;
10094 if (ins.evex_type == evex_from_legacy)
10098 if (!ins.vex.nd && (ins.vex.register_specifier || !ins.vex.v))
10101 ret = ins.end_codep - priv.the_buffer;
10107 if ((ins.vex.mask_register_specifier & 0x3) != 0
10108 || ins.vex.ll != 0 || ins.vex.zeroing != 0)
10111 ret = ins.end_codep - priv.the_buffer;
10117 if (ins.need_vex && ins.vex.register_specifier != 0)
10120 ret = ins.end_codep - priv.the_buffer;
10125 && ins.last_rex2_prefix >= 0 && (ins.rex2 & REX2_SPECIAL) == 0)
10128 ret = ins.end_codep - priv.the_buffer;
10137 if (ins.need_vex ? !ins.vex.prefix : !(ins.prefixes & PREFIX_DATA))
10140 ret = ins.end_codep - priv.the_buffer;
10143 ins.used_prefixes |= PREFIX_DATA;
10151 if (((ins.need_vex
10152 ? ins.vex.prefix == REPE_PREFIX_OPCODE
10153 || ins.vex.prefix == REPNE_PREFIX_OPCODE
10154 : (ins.prefixes
10156 && (ins.used_prefixes
10158 || (((ins.need_vex
10159 ? ins.vex.prefix == DATA_PREFIX_OPCODE
10160 : ((ins.prefixes
10163 && (ins.used_prefixes & PREFIX_DATA) == 0))
10164 || (ins.vex.evex && dp->prefix_requirement != PREFIX_DATA
10165 && !ins.vex.w != !(ins.used_prefixes & PREFIX_DATA)))
10168 ret = ins.end_codep - priv.the_buffer;
10176 ins.used_prefixes &= ~PREFIX_OPCODE;
10177 if (ins.last_data_prefix >= 0)
10178 ins.all_prefixes[ins.last_data_prefix] = 0x66;
10179 if (ins.last_repz_prefix >= 0)
10180 ins.all_prefixes[ins.last_repz_prefix] = 0xf3;
10181 if (ins.last_repnz_prefix >= 0)
10182 ins.all_prefixes[ins.last_repnz_prefix] = 0xf2;
10186 if (ins.vex.prefix == REPE_PREFIX_OPCODE
10187 || ins.vex.prefix == REPNE_PREFIX_OPCODE)
10190 ret = ins.end_codep - priv.the_buffer;
10196 if (ins.vex.prefix)
10199 ret = ins.end_codep - priv.the_buffer;
10206 if ((ins.rex ^ ins.rex_used) == 0
10207 && !ins.need_vex && ins.last_rex_prefix >= 0)
10208 ins.all_prefixes[ins.last_rex_prefix] = 0;
10211 if (ins.last_rex2_prefix >= 0
10212 && ((ins.rex2 & REX2_SPECIAL)
10213 || (((ins.rex2 & 7) ^ (ins.rex2_used & 7)) == 0
10214 && (ins.rex ^ ins.rex_used) == 0
10215 && (ins.rex2 & 7))))
10216 ins.all_prefixes[ins.last_rex2_prefix] = 0;
10219 if ((ins.prefixes & (PREFIX_CS | PREFIX_SS | PREFIX_DS | PREFIX_ES
10221 && (ins.used_prefixes & ins.active_seg_prefix) != 0)
10222 ins.all_prefixes[ins.last_seg_prefix] = 0;
10225 if ((ins.prefixes & PREFIX_ADDR) != 0
10226 && (ins.used_prefixes & PREFIX_ADDR) != 0)
10227 ins.all_prefixes[ins.last_addr_prefix] = 0;
10230 if ((ins.prefixes & PREFIX_DATA) != 0
10231 && (ins.used_prefixes & PREFIX_DATA) != 0
10232 && !ins.need_vex)
10233 ins.all_prefixes[ins.last_data_prefix] = 0;
10235 /* Print the extra ins.prefixes. */
10237 for (i = 0; i < (int) ARRAY_SIZE (ins.all_prefixes); i++)
10238 if (ins.all_prefixes[i])
10240 const char *name = prefix_name (ins.address_mode, ins.all_prefixes[i],
10246 if (ins.all_prefixes[i] == REX2_OPCODE)
10248 (unsigned int) ins.rex2_payload);
10254 if ((ins.codep - ins.start_codep) > MAX_CODE_LENGTH)
10264 if (*ins.op_out[i] != '\0')
10268 ins.obufp = ins.mnemonicendp;
10271 i = strlen (ins.obuf) + prefix_length;
10281 i386_dis_printf (info, dis_style_mnemonic, "%s%*s", ins.obuf, i, "");
10286 if (ins.intel_syntax || ins.two_source_ops)
10289 op_txt[i] = ins.op_out[i];
10291 if (ins.intel_syntax && dp && dp->op[2].rtn == OP_Rounding
10294 op_txt[2] = ins.op_out[3];
10295 op_txt[3] = ins.op_out[2];
10303 ins.op_ad = ins.op_index[i];
10304 ins.op_index[i] = ins.op_index[MAX_OPERANDS - 1 - i];
10305 ins.op_index[MAX_OPERANDS - 1 - i] = ins.op_ad;
10306 riprel = ins.op_riprel[i];
10307 ins.op_riprel[i] = ins.op_riprel[MAX_OPERANDS - 1 - i];
10308 ins.op_riprel[MAX_OPERANDS - 1 - i] = riprel;
10314 op_txt[MAX_OPERANDS - 1 - i] = ins.op_out[i];
10324 switch (i & -(ins.intel_syntax && dp))
10337 if (ins.op_index[i] != -1 && !ins.op_riprel[i])
10339 bfd_vma target = (bfd_vma) ins.op_address[ins.op_index[i]];
10341 if (ins.op_is_jump)
10357 if (ins.op_index[i] != -1 && ins.op_riprel[i])
10361 ((bfd_vma)(ins.start_pc + (ins.codep - ins.start_codep)
10362 + ins.op_address[ins.op_index[i]]),
10366 ret = ins.codep - priv.the_buffer;
10713 swap_operand (instr_info *ins)
10715 char *p = ins->mnemonicendp;
10721 if (p <= ins->obuf + 2)
10727 memmove (p + 2, p, ins->mnemonicendp - p + 1);
10730 ins->mnemonicendp += 2;
10734 dofloat (instr_info *ins, int sizeflag)
10737 unsigned char floatop = ins->codep[-1];
10739 if (ins->modrm.mod != 3)
10741 int fp_indx = (floatop - 0xd8) * 8 + ins->modrm.reg;
10743 putop (ins, float_mem[fp_indx], sizeflag);
10744 ins->obufp = ins->op_out[0];
10745 ins->op_ad = 2;
10746 return OP_E (ins, float_mem_mode[fp_indx], sizeflag);
10750 ins->codep++;
10752 dp = &float_reg[floatop - 0xd8][ins->modrm.reg];
10755 putop (ins, fgrps[dp->op[0].bytemode][ins->modrm.rm], sizeflag);
10758 if (floatop == 0xdf && ins->codep[-1] == 0xe0)
10759 strcpy (ins->op_out[0], att_names16[0] + ins->intel_syntax);
10763 putop (ins, dp->name, sizeflag);
10765 ins->obufp = ins->op_out[0];
10766 ins->op_ad = 2;
10768 && !dp->op[0].rtn (ins, dp->op[0].bytemode, sizeflag))
10771 ins->obufp = ins->op_out[1];
10772 ins->op_ad = 1;
10774 && !dp->op[1].rtn (ins, dp->op[1].bytemode, sizeflag))
10781 OP_ST (instr_info *ins, int bytemode ATTRIBUTE_UNUSED,
10784 oappend_register (ins, "%st");
10789 OP_STi (instr_info *ins, int bytemode ATTRIBUTE_UNUSED,
10793 int res = snprintf (scratch, ARRAY_SIZE (scratch), "%%st(%d)", ins->modrm.rm);
10797 oappend_register (ins, scratch);
10803 putop (instr_info *ins, const char *in_template, int sizeflag)
10815 oappend (ins, "(bad)");
10816 *ins->obufp = 0;
10817 ins->mnemonicendp = ins->obufp;
10833 if (ins->evex_type == evex_from_legacy && !ins->vex.nd
10834 && !(ins->rex2 & 7) && !evex_printed)
10836 oappend (ins, "{evex} ");
10839 *ins->obufp++ = *p;
10848 if (ins->intel_syntax)
10867 if (ins->intel_syntax)
10869 if ((ins->need_modrm && ins->modrm.mod != 3 && !ins->vex.nd)
10871 *ins->obufp++ = 'b';
10877 if (ins->intel_syntax)
10880 *ins->obufp++ = 'b';
10884 if (ins->address_mode == mode_64bit
10885 && !(ins->prefixes & PREFIX_ADDR))
10887 *ins->obufp++ = 'a';
10888 *ins->obufp++ = 'b';
10889 *ins->obufp++ = 's';
10896 if (!ins->vex.w)
10897 oappend (ins, "bf16");
10899 oappend (ins, "{bad}");
10908 for (const char *q = dis386[0x70 | ins->condition_code].name + 1;
10910 *ins->obufp++ = *q;
10916 oappend (ins, scc_suffix[ins->vex.scc]);
10919 if (ins->vex.nd)
10920 oappend (ins, "(bad)");
10924 ins->vex.v = 1;
10925 ins->vex.nf = false;
10926 ins->vex.mask_register_specifier = 0;
10932 if (ins->intel_syntax && !alt)
10934 if ((ins->prefixes & PREFIX_DATA) || (sizeflag & SUFFIX_ALWAYS))
10937 *ins->obufp++ = ins->intel_syntax ? 'd' : 'l';
10939 *ins->obufp++ = ins->intel_syntax ? 'w' : 's';
10940 ins->used_prefixes |= (ins->prefixes & PREFIX_DATA);
10949 if (!ins->vex.evex || ins->vex.w)
10950 *ins->obufp++ = 'd';
10952 oappend (ins, "{bad}");
10961 if (ins->intel_syntax || !(sizeflag & SUFFIX_ALWAYS))
10964 if (ins->modrm.mod == 3)
10966 if (ins->rex & REX_W)
10967 *ins->obufp++ = 'q';
10971 *ins->obufp++ = ins->intel_syntax ? 'd' : 'l';
10973 *ins->obufp++ = 'w';
10974 ins->used_prefixes |= (ins->prefixes & PREFIX_DATA);
10978 *ins->obufp++ = 'w';
10986 if (ins->modrm.mod != 3)
10990 if (!ins->vex.evex || ins->vex.b || ins->vex.ll >= 2
10991 || (ins->rex2 & 7)
10992 || (ins->modrm.mod == 3 && (ins->rex & REX_X))
10993 || !ins->vex.v || ins->vex.mask_register_specifier)
10998 if (ins->vex.w)
11005 *ins->obufp++ = '{';
11006 *ins->obufp++ = 'e';
11007 *ins->obufp++ = 'v';
11008 *ins->obufp++ = 'e';
11009 *ins->obufp++ = 'x';
11010 *ins->obufp++ = '}';
11011 *ins->obufp++ = ' ';
11023 if (ins->address_mode == mode_64bit)
11026 *ins->obufp++ = 'r';
11028 *ins->obufp++ = 'e';
11032 *ins->obufp++ = 'e';
11033 ins->used_prefixes |= (ins->prefixes & PREFIX_ADDR);
11038 if (ins->intel_syntax)
11040 if ((ins->prefixes & PREFIX_ADDR) || (sizeflag & SUFFIX_ALWAYS))
11043 *ins->obufp++ = ins->address_mode == mode_64bit ? 'q' : 'l';
11045 *ins->obufp++ = ins->address_mode == mode_64bit ? 'l' : 'w';
11046 ins->used_prefixes |= (ins->prefixes & PREFIX_ADDR);
11051 if (ins->vex.nd && !ins->vex.nf)
11053 *ins->obufp++ = 'c';
11054 *ins->obufp++ = 'f';
11060 if (ins->vex.nf)
11062 oappend (ins, "{nf} ");
11064 ins->vex.nf = false;
11067 else if (ins->evex_type == evex_from_vex && !(ins->rex2 & 7)
11068 && ins->vex.v)
11070 oappend (ins, "{evex} ");
11077 int oszc_value = ~ins->vex.register_specifier & 0xf;
11080 oappend (ins, oszc_flags[oszc_value]);
11083 ins->vex.register_specifier = 0;
11089 if (ins->intel_syntax || (ins->obufp[-1] != 's'
11092 if ((ins->rex & REX_W) || (sizeflag & DFLAG))
11093 *ins->obufp++ = 'l';
11095 *ins->obufp++ = 'w';
11096 if (!(ins->rex & REX_W))
11097 ins->used_prefixes |= (ins->prefixes & PREFIX_DATA);
11102 if (ins->intel_syntax)
11104 if ((ins->prefixes & (PREFIX_CS | PREFIX_DS)) == PREFIX_CS
11105 || (ins->prefixes & (PREFIX_CS | PREFIX_DS)) == PREFIX_DS)
11107 ins->used_prefixes |= ins->prefixes & (PREFIX_CS | PREFIX_DS);
11108 *ins->obufp++ = ',';
11109 *ins->obufp++ = 'p';
11113 if (ins->prefixes & PREFIX_DS)
11115 ins->active_seg_prefix = PREFIX_DS;
11116 *ins->obufp++ = 't';
11120 ins->active_seg_prefix = PREFIX_CS;
11121 *ins->obufp++ = 'n';
11127 if (!ins->vex.w)
11128 *ins->obufp++ = 'h';
11130 oappend (ins, "{bad}");
11137 if (ins->rex & REX_W)
11138 *ins->obufp++ = 'q';
11140 *ins->obufp++ = 'd';
11143 if (ins->intel_syntax)
11147 if (ins->rex & REX_W)
11148 *ins->obufp++ = 'q';
11150 *ins->obufp++ = 'l';
11154 if (ins->intel_mnemonic != cond)
11155 *ins->obufp++ = 'r';
11158 if ((ins->prefixes & PREFIX_FWAIT) == 0)
11159 *ins->obufp++ = 'n';
11161 ins->used_prefixes |= PREFIX_FWAIT;
11165 if (ins->rex & REX_W)
11166 *ins->obufp++ = 'o';
11167 else if (ins->intel_syntax && (sizeflag & DFLAG))
11168 *ins->obufp++ = 'q';
11170 *ins->obufp++ = 'd';
11171 if (!(ins->rex & REX_W))
11172 ins->used_prefixes |= (ins->prefixes & PREFIX_DATA);
11175 if (ins->address_mode == mode_64bit
11176 && (ins->isa64 == intel64 || (ins->rex & REX_W)
11177 || !(ins->prefixes & PREFIX_DATA)))
11180 *ins->obufp++ = 'q';
11187 if (!cond && ins->last_rex2_prefix >= 0 && (ins->rex & REX_W))
11191 *ins->obufp++ = 'p';
11192 ins->rex2 |= REX2_SPECIAL;
11197 if (!cond && ins->intel_syntax)
11200 if ((ins->modrm.mod == 3 || !cond)
11205 if ((!(ins->rex & REX_W) && (ins->prefixes & PREFIX_DATA))
11207 && ins->address_mode != mode_64bit))
11209 *ins->obufp++ = (sizeflag & DFLAG)
11210 ? ins->intel_syntax ? 'd' : 'l' : 'w';
11211 ins->used_prefixes |= (ins->prefixes & PREFIX_DATA);
11214 *ins->obufp++ = 'q';
11218 if ((ins->prefixes & PREFIX_DATA)
11219 || (ins->rex & REX_W)
11223 if (ins->rex & REX_W)
11224 *ins->obufp++ = 'q';
11228 *ins->obufp++ = ins->intel_syntax ? 'd' : 'l';
11230 *ins->obufp++ = 'w';
11231 ins->used_prefixes |= (ins->prefixes & PREFIX_DATA);
11241 if (ins->intel_syntax && !alt)
11244 if ((ins->need_modrm && ins->modrm.mod != 3 && !ins->vex.nd)
11247 if (ins->rex & REX_W)
11248 *ins->obufp++ = 'q';
11252 *ins->obufp++ = ins->intel_syntax ? 'd' : 'l';
11254 *ins->obufp++ = 'w';
11255 ins->used_prefixes |= (ins->prefixes & PREFIX_DATA);
11260 *ins->obufp++ = ins->vex.w ? 'q' : 'd';
11263 if (cond ? ins->modrm.mod == 3 && !(sizeflag & SUFFIX_ALWAYS)
11264 : ins->address_mode != mode_64bit)
11266 if ((ins->rex & REX_W))
11269 *ins->obufp++ = 'q';
11271 else if ((ins->address_mode == mode_64bit && cond)
11273 *ins->obufp++ = ins->intel_syntax? 'd' : 'l';
11280 if (ins->rex & REX_W)
11281 *ins->obufp++ = 'q';
11284 if (ins->intel_syntax)
11285 *ins->obufp++ = 'd';
11287 *ins->obufp++ = 'l';
11290 *ins->obufp++ = 'w';
11291 if (ins->intel_syntax && !p[1]
11292 && ((ins->rex & REX_W) || (sizeflag & DFLAG)))
11293 *ins->obufp++ = 'e';
11294 if (!(ins->rex & REX_W))
11295 ins->used_prefixes |= (ins->prefixes & PREFIX_DATA);
11301 if (ins->intel_syntax)
11305 if (ins->rex & REX_W)
11306 *ins->obufp++ = 'q';
11310 *ins->obufp++ = 'l';
11312 *ins->obufp++ = 'w';
11313 ins->used_prefixes |= (ins->prefixes & PREFIX_DATA);
11323 if (ins->address_mode == mode_64bit
11324 && !(ins->prefixes & PREFIX_ADDR))
11326 *ins->obufp++ = 'a';
11327 *ins->obufp++ = 'b';
11328 *ins->obufp++ = 's';
11333 if (!ins->vex.evex || !ins->vex.w)
11334 *ins->obufp++ = 's';
11336 oappend (ins, "{bad}");
11348 if (ins->vex.nd)
11349 oappend (ins, "zu");
11357 if (ins->need_vex)
11358 *ins->obufp++ = 'v';
11365 if (ins->vex.evex)
11367 *ins->obufp++ = '{';
11368 *ins->obufp++ = 'v';
11369 *ins->obufp++ = 'e';
11370 *ins->obufp++ = 'x';
11371 *ins->obufp++ = '}';
11372 *ins->obufp++ = ' ';
11375 if (ins->rex & REX_W)
11377 *ins->obufp++ = 'a';
11378 *ins->obufp++ = 'b';
11379 *ins->obufp++ = 's';
11394 if (ins->rex & REX_W)
11396 if (ins->intel_syntax)
11397 *ins->obufp++ = 'd';
11399 *ins->obufp++ = 'l';
11402 *ins->obufp++ = 'w';
11404 *ins->obufp++ = 'b';
11405 if (!(ins->rex & REX_W))
11406 ins->used_prefixes |= (ins->prefixes & PREFIX_DATA);
11410 if (!ins->need_vex)
11413 *ins->obufp++ = ins->vex.w ? 'd': 's';
11415 *ins->obufp++ = ins->vex.w ? 'w': 'b';
11425 if (ins->need_vex
11426 ? ins->vex.prefix == DATA_PREFIX_OPCODE
11427 : ins->prefixes & PREFIX_DATA)
11429 *ins->obufp++ = 'd';
11430 ins->used_prefixes |= PREFIX_DATA;
11433 *ins->obufp++ = 's';
11438 if (ins->vex.mask_register_specifier)
11439 ins->illegal_masking = true;
11443 if (!ins->need_vex)
11445 if (ins->intel_syntax
11446 || ((ins->modrm.mod == 3 || ins->vex.b)
11449 switch (ins->vex.length)
11452 *ins->obufp++ = 'x';
11455 *ins->obufp++ = 'y';
11458 if (!ins->vex.evex)
11470 ins->modrm.mod = 3;
11471 if (!ins->intel_syntax && (sizeflag & SUFFIX_ALWAYS))
11472 *ins->obufp++ = ins->address_mode == mode_64bit ? 'q' : 'l';
11476 if (!ins->vex.evex)
11478 if (ins->intel_syntax
11479 || ((ins->modrm.mod == 3 || ins->vex.b)
11482 switch (ins->vex.length)
11485 *ins->obufp++ = 'x';
11488 *ins->obufp++ = 'y';
11491 *ins->obufp++ = 'z';
11501 if (ins->intel_syntax)
11503 if (ins->isa64 == intel64 && (ins->rex & REX_W))
11506 *ins->obufp++ = 'q';
11509 if ((ins->prefixes & PREFIX_DATA) || (sizeflag & SUFFIX_ALWAYS))
11512 *ins->obufp++ = 'l';
11514 *ins->obufp++ = 'w';
11515 ins->used_prefixes |= (ins->prefixes & PREFIX_DATA);
11523 *ins->obufp = 0;
11524 ins->mnemonicendp = ins->obufp;
11528 /* Add a style marker to *INS->obufp that encodes STYLE. This assumes that
11529 the buffer pointed to by INS->obufp has space. A style marker is made
11535 oappend_insert_style (instr_info *ins, enum disassembler_style style)
11545 *ins->obufp++ = STYLE_MARKER_CHAR;
11546 *ins->obufp++ = (num < 10 ? ('0' + num)
11548 *ins->obufp++ = STYLE_MARKER_CHAR;
11556 *ins->obufp = '\0';
11560 oappend_with_style (instr_info *ins, const char *s,
11563 oappend_insert_style (ins, style);
11564 ins->obufp = stpcpy (ins->obufp, s);
11567 /* Add a single character C to the buffer pointer to by INS->obufp, marking
11571 oappend_char_with_style (instr_info *ins, const char c,
11574 oappend_insert_style (ins, style);
11575 *ins->obufp++ = c;
11576 *ins->obufp = '\0';
11582 oappend_char (instr_info *ins, const char c)
11584 oappend_char_with_style (ins, c, dis_style_text);
11588 append_seg (instr_info *ins)
11591 if (!ins->active_seg_prefix)
11594 ins->used_prefixes |= ins->active_seg_prefix;
11595 switch (ins->active_seg_prefix)
11598 oappend_register (ins, att_names_seg[1]);
11601 oappend_register (ins, att_names_seg[3]);
11604 oappend_register (ins, att_names_seg[2]);
11607 oappend_register (ins, att_names_seg[0]);
11610 oappend_register (ins, att_names_seg[4]);
11613 oappend_register (ins, att_names_seg[5]);
11618 oappend_char (ins, ':');
11622 print_operand_value (instr_info *ins, bfd_vma disp,
11627 if (ins->address_mode != mode_64bit)
11630 oappend_with_style (ins, tmp, style);
11636 oappend_immediate (instr_info *ins, bfd_vma imm)
11638 if (!ins->intel_syntax)
11639 oappend_char_with_style (ins, '$', dis_style_immediate);
11640 print_operand_value (ins, imm, dis_style_immediate);
11646 print_displacement (instr_info *ins, bfd_signed_vma val)
11652 oappend_char_with_style (ins, '-', dis_style_address_offset);
11658 switch (ins->address_mode)
11661 oappend_with_style (ins, "0x8000000000000000",
11665 oappend_with_style (ins, "0x80000000",
11669 oappend_with_style (ins, "0x8000",
11678 oappend_with_style (ins, tmp, dis_style_address_offset);
11682 intel_operand_size (instr_info *ins, int bytemode, int sizeflag)
11685 if (ins->vex.b && ins->evex_type == evex_default)
11687 if (!ins->vex.no_broadcast)
11692 if (ins->vex.w)
11693 oappend (ins, "QWORD BCST ");
11695 oappend (ins, "DWORD BCST ");
11700 oappend (ins, "WORD BCST ");
11703 ins->vex.no_broadcast = true;
11713 oappend (ins, "BYTE PTR ");
11718 oappend (ins, "WORD PTR ");
11721 if (ins->address_mode == mode_64bit && ins->isa64 == intel64)
11723 oappend (ins, "QWORD PTR ");
11728 if (ins->address_mode == mode_64bit && ((sizeflag & DFLAG)
11729 || (ins->rex & REX_W)))
11731 oappend (ins, "QWORD PTR ");
11739 if (ins->rex & REX_W)
11740 oappend (ins, "QWORD PTR ");
11742 oappend (ins, "DWORD PTR ");
11746 oappend (ins, "DWORD PTR ");
11748 oappend (ins, "WORD PTR ");
11749 ins->used_prefixes |= (ins->prefixes & PREFIX_DATA);
11753 if ((ins->rex & REX_W) || (sizeflag & DFLAG))
11754 *ins->obufp++ = 'D';
11755 oappend (ins, "WORD PTR ");
11756 if (!(ins->rex & REX_W))
11757 ins->used_prefixes |= (ins->prefixes & PREFIX_DATA);
11761 oappend (ins, "QWORD PTR ");
11763 oappend (ins, "DWORD PTR ");
11764 ins->used_prefixes |= (ins->prefixes & PREFIX_DATA);
11767 if (!(sizeflag & DFLAG) && ins->isa64 == intel64)
11768 oappend (ins, "WORD PTR ");
11770 oappend (ins, "DWORD PTR ");
11771 ins->used_prefixes |= (ins->prefixes & PREFIX_DATA);
11775 oappend (ins, "DWORD PTR ");
11779 oappend (ins, "QWORD PTR ");
11782 if (ins->address_mode == mode_64bit)
11783 oappend (ins, "QWORD PTR ");
11785 oappend (ins, "DWORD PTR ");
11789 oappend (ins, "FWORD PTR ");
11791 oappend (ins, "DWORD PTR ");
11792 ins->used_prefixes |= (ins->prefixes & PREFIX_DATA);
11795 oappend (ins, "TBYTE PTR ");
11803 if (ins->need_vex)
11805 switch (ins->vex.length)
11808 oappend (ins, "XMMWORD PTR ");
11811 oappend (ins, "YMMWORD PTR ");
11814 oappend (ins, "ZMMWORD PTR ");
11821 oappend (ins, "XMMWORD PTR ");
11824 oappend (ins, "XMMWORD PTR ");
11827 oappend (ins, "YMMWORD PTR ");
11832 switch (ins->vex.length)
11836 oappend (ins, "QWORD PTR ");
11839 oappend (ins, "XMMWORD PTR ");
11842 oappend (ins, "YMMWORD PTR ");
11849 if (!ins->need_vex)
11852 switch (ins->vex.length)
11855 oappend (ins, "WORD PTR ");
11858 oappend (ins, "DWORD PTR ");
11861 oappend (ins, "QWORD PTR ");
11869 if (!ins->need_vex)
11872 switch (ins->vex.length)
11875 oappend (ins, "DWORD PTR ");
11878 oappend (ins, "QWORD PTR ");
11881 oappend (ins, "XMMWORD PTR ");
11888 if (!ins->need_vex)
11891 switch (ins->vex.length)
11894 oappend (ins, "QWORD PTR ");
11897 oappend (ins, "YMMWORD PTR ");
11900 oappend (ins, "ZMMWORD PTR ");
11907 oappend (ins, "OWORD PTR ");
11911 if (!ins->need_vex)
11913 if (ins->vex.w)
11914 oappend (ins, "QWORD PTR ");
11916 oappend (ins, "DWORD PTR ");
11919 if (!ins->need_vex || ins->vex.length != 128)
11921 if (ins->vex.w)
11922 oappend (ins, "DWORD PTR ");
11924 oappend (ins, "BYTE PTR ");
11927 if (!ins->need_vex)
11929 if (ins->vex.w)
11930 oappend (ins, "QWORD PTR ");
11932 oappend (ins, "WORD PTR ");
11942 print_register (instr_info *ins, unsigned int reg, unsigned int rexmask,
11949 if (bytemode != mask_mode && ins->vex.mask_register_specifier)
11950 ins->illegal_masking = true;
11953 if (ins->rex & rexmask)
11955 if (ins->rex2 & rexmask)
11964 if (ins->rex || ins->rex2)
11982 names = ins->address_mode == mode_64bit ? att_names64 : att_names32;
11988 oappend (ins, "(bad)");
11994 if (ins->address_mode == mode_64bit && ins->isa64 == intel64)
12001 if (ins->address_mode == mode_64bit && ((sizeflag & DFLAG)
12002 || (ins->rex & REX_W)))
12013 if (ins->rex & REX_W)
12023 ins->used_prefixes |= (ins->prefixes & PREFIX_DATA);
12027 if (!(sizeflag & DFLAG) && ins->isa64 == intel64)
12031 ins->used_prefixes |= (ins->prefixes & PREFIX_DATA);
12034 names = (ins->address_mode == mode_64bit
12036 if (!(ins->prefixes & PREFIX_ADDR))
12037 names = (ins->address_mode == mode_16bit
12042 ins->all_prefixes[ins->last_addr_prefix] = 0;
12043 names = (ins->address_mode != mode_32bit
12045 ins->used_prefixes |= PREFIX_ADDR;
12052 oappend (ins, "(bad)");
12060 oappend (ins, INTERNAL_DISASSEMBLER_ERROR);
12063 oappend_register (ins, names[reg]);
12067 get8s (instr_info *ins, bfd_vma *res)
12069 if (!fetch_code (ins->info, ins->codep + 1))
12071 *res = ((bfd_vma) *ins->codep++ ^ 0x80) - 0x80;
12076 get16 (instr_info *ins, bfd_vma *res)
12078 if (!fetch_code (ins->info, ins->codep + 2))
12080 *res = *ins->codep++;
12081 *res |= (bfd_vma) *ins->codep++ << 8;
12086 get16s (instr_info *ins, bfd_vma *res)
12088 if (!get16 (ins, res))
12095 get32 (instr_info *ins, bfd_vma *res)
12097 if (!fetch_code (ins->info, ins->codep + 4))
12099 *res = *ins->codep++;
12100 *res |= (bfd_vma) *ins->codep++ << 8;
12101 *res |= (bfd_vma) *ins->codep++ << 16;
12102 *res |= (bfd_vma) *ins->codep++ << 24;
12107 get32s (instr_info *ins, bfd_vma *res)
12109 if (!get32 (ins, res))
12118 get64 (instr_info *ins, uint64_t *res)
12123 if (!fetch_code (ins->info, ins->codep + 8))
12125 a = *ins->codep++;
12126 a |= (unsigned int) *ins->codep++ << 8;
12127 a |= (unsigned int) *ins->codep++ << 16;
12128 a |= (unsigned int) *ins->codep++ << 24;
12129 b = *ins->codep++;
12130 b |= (unsigned int) *ins->codep++ << 8;
12131 b |= (unsigned int) *ins->codep++ << 16;
12132 b |= (unsigned int) *ins->codep++ << 24;
12138 set_op (instr_info *ins, bfd_vma op, bool riprel)
12140 ins->op_index[ins->op_ad] = ins->op_ad;
12141 if (ins->address_mode == mode_64bit)
12142 ins->op_address[ins->op_ad] = op;
12144 ins->op_address[ins->op_ad] = op & 0xffffffff;
12145 ins->op_riprel[ins->op_ad] = riprel;
12149 BadOp (instr_info *ins)
12152 struct dis_private *priv = ins->info->private_data;
12154 ins->codep = priv->the_buffer + ins->nr_prefixes + ins->need_vex + 1;
12155 ins->obufp = stpcpy (ins->obufp, "(bad)");
12160 OP_Skip_MODRM (instr_info *ins, int bytemode ATTRIBUTE_UNUSED,
12163 if (ins->modrm.mod != 3)
12164 return BadOp (ins);
12168 ins->codep++;
12169 ins->has_skipped_modrm = true;
12174 OP_E_memory (instr_info *ins, int bytemode, int sizeflag)
12176 int add = (ins->rex & REX_B) ? 8 : 0;
12180 add += (ins->rex2 & REX_B) ? 16 : 0;
12183 if (ins->vex.evex && ins->evex_type == evex_default)
12189 if (ins->vex.zeroing)
12190 ins->illegal_masking = true;
12204 if (ins->address_mode != mode_64bit)
12215 shift = ins->vex.w ? 3 : 2;
12220 if (ins->vex.b)
12222 shift = ins->vex.w ? 2 : 1;
12228 if (ins->vex.b)
12230 shift = ins->vex.w ? 3 : 2;
12240 switch (ins->vex.length)
12258 || (bytemode == ymmq_mode && ins->vex.length == 128))
12277 shift = ins->vex.w ? 1 : 0;
12287 if (ins->intel_syntax)
12288 intel_operand_size (ins, bytemode, sizeflag);
12289 append_seg (ins);
12291 if ((sizeflag & AFLAG) || ins->address_mode == mode_64bit)
12311 base = ins->modrm.rm;
12315 vindex = ins->sib.index;
12317 if (ins->rex & REX_X)
12323 if (!ins->need_vex)
12325 if (ins->vex.evex)
12328 if (ins->rex2 & REX_X)
12330 oappend (ins, "(bad)");
12334 if (!ins->vex.v)
12336 check_gather = ins->obufp == ins->op_out[1];
12339 switch (ins->vex.length)
12345 if (!ins->vex.w
12352 if (!ins->vex.w
12363 if (ins->rex2 & REX_X)
12367 indexes = ins->address_mode == mode_64bit && !addr32flag
12371 scale = ins->sib.scale;
12372 base = ins->sib.base;
12373 ins->codep++;
12382 oappend (ins, "(bad)");
12388 switch (ins->modrm.mod)
12394 if (ins->address_mode == mode_64bit && !ins->has_sib)
12396 if (!get32s (ins, &disp))
12400 oappend (ins, "(bad)");
12406 if (!get8s (ins, &disp))
12408 if (ins->vex.evex && shift > 0)
12412 if (!get32s (ins, &disp))
12419 if (ins->has_sib
12422 && ins->address_mode != mode_16bit)
12424 if (ins->address_mode == mode_64bit)
12445 || (ins->has_sib && (indexes || scale != 0)));
12447 if (!ins->intel_syntax)
12448 if (ins->modrm.mod != 0 || base == 5)
12451 print_displacement (ins, disp);
12453 print_operand_value (ins, disp, dis_style_address_offset);
12456 set_op (ins, disp, true);
12457 oappend_char (ins, '(');
12458 oappend_with_style (ins, !addr32flag ? "%rip" : "%eip",
12460 oappend_char (ins, ')');
12465 && (ins->address_mode != mode_64bit
12470 ins->used_prefixes |= PREFIX_ADDR;
12472 if (havedisp || (ins->intel_syntax && riprel))
12474 oappend_char (ins, ins->open_char);
12475 if (ins->intel_syntax && riprel)
12477 set_op (ins, disp, true);
12478 oappend_with_style (ins, !addr32flag ? "rip" : "eip",
12483 (ins,
12484 (ins->address_mode == mode_64bit && !addr32flag
12486 if (ins->has_sib)
12495 if (!ins->intel_syntax || havebase)
12496 oappend_char (ins, ins->separator_char);
12499 if (ins->address_mode == mode_64bit || vindex < 16)
12500 oappend_register (ins, indexes[vindex]);
12502 oappend (ins, "(bad)");
12505 oappend_register (ins,
12506 ins->address_mode == mode_64bit
12511 oappend_char (ins, ins->scale_char);
12512 oappend_char_with_style (ins, '0' + (1 << scale),
12516 if (ins->intel_syntax
12517 && (disp || ins->modrm.mod != 0 || base == 5))
12520 oappend_char (ins, '+');
12522 print_displacement (ins, disp);
12524 print_operand_value (ins, disp, dis_style_address_offset);
12527 oappend_char (ins, ins->close_char);
12532 int modrm_reg = ins->modrm.reg;
12534 if (ins->rex & REX_R)
12536 if (ins->rex2 & REX_R)
12539 oappend (ins, "/(bad)");
12542 else if (ins->intel_syntax)
12544 if (ins->modrm.mod != 0 || base == 5)
12546 if (!ins->active_seg_prefix)
12548 oappend_register (ins, att_names_seg[ds_reg - es_reg]);
12549 oappend (ins, ":");
12551 print_operand_value (ins, disp, dis_style_text);
12562 oappend (ins, "(bad)");
12570 ins->used_prefixes |= ins->prefixes & PREFIX_ADDR;
12571 switch (ins->modrm.mod)
12574 if (ins->modrm.rm == 6)
12577 if (!get16s (ins, &disp))
12582 if (!get8s (ins, &disp))
12584 if (ins->vex.evex && shift > 0)
12589 if (!ins->intel_syntax)
12590 if (ins->modrm.mod != 0 || ins->modrm.rm == 6)
12591 print_displacement (ins, disp);
12593 if (ins->modrm.mod != 0 || ins->modrm.rm != 6)
12595 oappend_char (ins, ins->open_char);
12596 oappend (ins, ins->intel_syntax ? intel_index16[ins->modrm.rm]
12597 : att_index16[ins->modrm.rm]);
12598 if (ins->intel_syntax
12599 && (disp || ins->modrm.mod != 0 || ins->modrm.rm == 6))
12602 oappend_char (ins, '+');
12603 print_displacement (ins, disp);
12606 oappend_char (ins, ins->close_char);
12608 else if (ins->intel_syntax)
12610 if (!ins->active_seg_prefix)
12612 oappend_register (ins, att_names_seg[ds_reg - es_reg]);
12613 oappend (ins, ":");
12615 print_operand_value (ins, disp & 0xffff, dis_style_text);
12618 if (ins->vex.b && ins->evex_type == evex_default)
12620 ins->evex_used |= EVEX_b_used;
12623 if (ins->obufp == ins->op_out[0])
12624 ins->vex.no_broadcast = true;
12626 if (!ins->vex.no_broadcast
12627 && (!ins->intel_syntax || !(ins->evex_used & EVEX_len_used)))
12631 switch (ins->vex.length)
12634 oappend (ins, "{1to8}");
12637 oappend (ins, "{1to16}");
12640 oappend (ins, "{1to32}");
12648 ins->vex.no_broadcast = true;
12649 else if (ins->vex.w
12653 switch (ins->vex.length)
12656 oappend (ins, "{1to2}");
12659 oappend (ins, "{1to4}");
12662 oappend (ins, "{1to8}");
12671 switch (ins->vex.length)
12674 oappend (ins, "{1to4}");
12677 oappend (ins, "{1to8}");
12680 oappend (ins, "{1to16}");
12687 ins->vex.no_broadcast = true;
12689 if (ins->vex.no_broadcast)
12690 oappend (ins, "{bad}");
12697 OP_E (instr_info *ins, int bytemode, int sizeflag)
12701 if (!ins->has_skipped_modrm)
12703 ins->codep++;
12704 ins->has_skipped_modrm = true;
12707 if (ins->modrm.mod == 3)
12713 swap_operand (ins);
12715 print_register (ins, ins->modrm.rm, REX_B, bytemode, sizeflag);
12722 if (ins->vex.mask_register_specifier)
12723 ins->illegal_masking = true;
12725 return OP_E_memory (ins, bytemode, sizeflag);
12729 OP_indirE (instr_info *ins, int bytemode, int sizeflag)
12731 if (ins->modrm.mod == 3 && bytemode == f_mode)
12733 return BadOp (ins);
12734 if (!ins->intel_syntax)
12735 oappend (ins, "*");
12736 return OP_E (ins, bytemode, sizeflag);
12740 OP_G (instr_info *ins, int bytemode, int sizeflag)
12742 print_register (ins, ins->modrm.reg, REX_R, bytemode, sizeflag);
12747 OP_REG (instr_info *ins, int code, int sizeflag)
12756 oappend_register (ins, att_names_seg[code - es_reg]);
12761 if (ins->rex & REX_B)
12763 if (ins->rex2 & REX_B)
12776 if (ins->rex)
12783 if (ins->address_mode == mode_64bit
12784 && ((sizeflag & DFLAG) || (ins->rex & REX_W)))
12794 if (ins->rex & REX_W)
12802 ins->used_prefixes |= (ins->prefixes & PREFIX_DATA);
12806 oappend (ins, INTERNAL_DISASSEMBLER_ERROR);
12809 oappend_register (ins, s);
12814 OP_IMREG (instr_info *ins, int code, int sizeflag)
12821 if (!ins->intel_syntax)
12823 oappend (ins, "(%dx)");
12833 if (ins->rex & REX_W)
12840 if ((ins->rex & REX_W) || (sizeflag & DFLAG))
12844 if (!(ins->rex & REX_W))
12845 ins->used_prefixes |= (ins->prefixes & PREFIX_DATA);
12848 oappend (ins, INTERNAL_DISASSEMBLER_ERROR);
12851 oappend_register (ins, s);
12856 OP_I (instr_info *ins, int bytemode, int sizeflag)
12863 if (!fetch_code (ins->info, ins->codep + 1))
12865 op = *ins->codep++;
12869 if (ins->rex & REX_W)
12871 if (!get32s (ins, &op))
12876 ins->used_prefixes |= (ins->prefixes & PREFIX_DATA);
12880 if (!get32 (ins, &op))
12887 if (!get16 (ins, &op))
12893 if (ins->intel_syntax)
12894 oappend_with_style (ins, "1", dis_style_immediate);
12896 oappend_with_style (ins, "$1", dis_style_immediate);
12899 oappend (ins, INTERNAL_DISASSEMBLER_ERROR);
12903 oappend_immediate (ins, op);
12908 OP_I64 (instr_info *ins, int bytemode, int sizeflag)
12912 if (bytemode != v_mode || ins->address_mode != mode_64bit
12913 || !(ins->rex & REX_W))
12914 return OP_I (ins, bytemode, sizeflag);
12918 if (!get64 (ins, &op))
12921 oappend_immediate (ins, op);
12926 OP_sI (instr_info *ins, int bytemode, int sizeflag)
12934 if (!get8s (ins, &op))
12938 if (ins->address_mode != mode_64bit
12939 || !((sizeflag & DFLAG) || (ins->rex & REX_W)))
12942 if ((sizeflag & DFLAG) || (ins->rex & REX_W))
12950 if (!(ins
12961 if (!(sizeflag & DFLAG) && !(ins->rex & REX_W))
12963 if (!get16 (ins, &op))
12966 else if (!get32s (ins, &op))
12970 oappend (ins, INTERNAL_DISASSEMBLER_ERROR);
12974 oappend_immediate (ins, op);
12979 OP_J (instr_info *ins, int bytemode, int sizeflag)
12988 if (!get8s (ins, &disp))
12994 || (ins->address_mode == mode_64bit
12995 && ((ins->isa64 == intel64 && bytemode != dqw_mode)
12996 || (ins->rex & REX_W))))
12998 if (!get32s (ins, &disp))
13003 if (!get16s (ins, &disp))
13010 if ((ins->prefixes & PREFIX_DATA) == 0)
13011 segment = ((ins->start_pc + (ins->codep - ins->start_codep))
13014 if (ins->address_mode != mode_64bit
13015 || (ins->isa64 != intel64 && !(ins->rex & REX_W)))
13016 ins->used_prefixes |= (ins->prefixes & PREFIX_DATA);
13019 oappend (ins, INTERNAL_DISASSEMBLER_ERROR);
13022 disp = ((ins->start_pc + (ins->codep - ins->start_codep) + disp) & mask)
13024 set_op (ins, disp, false);
13025 print_operand_value (ins, disp, dis_style_text);
13030 OP_SEG (instr_info *ins, int bytemode, int sizeflag)
13034 oappend_register (ins, att_names_seg[ins->modrm.reg]);
13037 return OP_E (ins, ins->modrm.mod == 3 ? bytemode : w_mode, sizeflag);
13041 OP_DIR (instr_info *ins, int dummy ATTRIBUTE_UNUSED, int sizeflag)
13049 if (!get32 (ins, &offset))
13052 else if (!get16 (ins, &offset))
13054 if (!get16 (ins, &seg))
13056 ins->used_prefixes |= (ins->prefixes & PREFIX_DATA);
13059 ins->intel_syntax ? "0x%x:0x%x" : "$0x%x,$0x%x",
13063 oappend (ins, scratch);
13068 OP_OFF (instr_info *ins, int bytemode, int sizeflag)
13072 if (ins->intel_syntax && (sizeflag & SUFFIX_ALWAYS))
13073 intel_operand_size (ins, bytemode, sizeflag);
13074 append_seg (ins);
13076 if ((sizeflag & AFLAG) || ins->address_mode == mode_64bit)
13078 if (!get32 (ins, &off))
13083 if (!get16 (ins, &off))
13087 if (ins->intel_syntax)
13089 if (!ins->active_seg_prefix)
13091 oappend_register (ins, att_names_seg[ds_reg - es_reg]);
13092 oappend (ins, ":");
13095 print_operand_value (ins, off, dis_style_address_offset);
13100 OP_OFF64 (instr_info *ins, int bytemode, int sizeflag)
13104 if (ins->address_mode != mode_64bit
13105 || (ins->prefixes & PREFIX_ADDR))
13106 return OP_OFF (ins, bytemode, sizeflag);
13108 if (ins->intel_syntax && (sizeflag & SUFFIX_ALWAYS))
13109 intel_operand_size (ins, bytemode, sizeflag);
13110 append_seg (ins);
13112 if (!get64 (ins, &off))
13115 if (ins->intel_syntax)
13117 if (!ins->active_seg_prefix)
13119 oappend_register (ins, att_names_seg[ds_reg - es_reg]);
13120 oappend (ins, ":");
13123 print_operand_value (ins, off, dis_style_address_offset);
13128 ptr_reg (instr_info *ins, int code, int sizeflag)
13132 *ins->obufp++ = ins->open_char;
13133 ins->used_prefixes |= (ins->prefixes & PREFIX_ADDR);
13134 if (ins->address_mode == mode_64bit)
13145 oappend_register (ins, s);
13146 oappend_char (ins, ins->close_char);
13150 OP_ESreg (instr_info *ins, int code, int sizeflag)
13152 if (ins->intel_syntax)
13154 switch (ins->codep[-1])
13157 intel_operand_size (ins, z_mode, sizeflag);
13163 intel_operand_size (ins, v_mode, sizeflag);
13166 intel_operand_size (ins, b_mode, sizeflag);
13169 if (ins->address_mode != mode_64bit)
13171 oappend_register (ins, att_names_seg[0]);
13172 oappend_char (ins, ':');
13174 ptr_reg (ins, code, sizeflag);
13179 OP_DSreg (instr_info *ins, int code, int sizeflag)
13181 if (ins->intel_syntax)
13183 switch (ins->codep[-1])
13188 intel_operand_size (ins, z_mode, sizeflag);
13193 intel_operand_size (ins, v_mode, sizeflag);
13196 intel_operand_size (ins, b_mode, sizeflag);
13199 /* Outside of 64-bit mode set ins->active_seg_prefix to PREFIX_DS if it
13201 if (ins->address_mode != mode_64bit && !ins->active_seg_prefix)
13202 ins->active_seg_prefix = PREFIX_DS;
13203 append_seg (ins);
13204 ptr_reg (ins, code, sizeflag);
13209 OP_C (instr_info *ins, int dummy ATTRIBUTE_UNUSED,
13215 if (ins->rex & REX_R)
13220 else if (ins->address_mode != mode_64bit && (ins->prefixes & PREFIX_LOCK))
13222 ins->all_prefixes[ins->last_lock_prefix] = 0;
13223 ins->used_prefixes |= PREFIX_LOCK;
13229 ins->modrm.reg + add);
13232 oappend_register (ins, scratch);
13237 OP_D (instr_info *ins, int dummy ATTRIBUTE_UNUSED,
13244 if (ins->rex & REX_R)
13249 ins->intel_syntax ? "dr%d" : "%%db%d",
13250 ins->modrm.reg + add);
13253 oappend (ins, scratch);
13258 OP_T (instr_info *ins, int dummy ATTRIBUTE_UNUSED,
13264 res = snprintf (scratch, ARRAY_SIZE (scratch), "%%tr%d", ins->modrm.reg);
13267 oappend_register (ins, scratch);
13272 OP_MMX (instr_info *ins, int bytemode ATTRIBUTE_UNUSED,
13275 int reg = ins->modrm.reg;
13278 ins->used_prefixes |= (ins->prefixes & PREFIX_DATA);
13279 if (ins->prefixes & PREFIX_DATA)
13283 if (ins->rex & REX_R)
13288 oappend_register (ins, names[reg]);
13293 print_vector_reg (instr_info *ins, unsigned int reg, int bytemode)
13301 switch (ins->vex.length)
13310 ins->evex_used |= EVEX_len_used;
13322 oappend (ins, "(bad)");
13327 else if (ins->need_vex
13339 ins->evex_used |= EVEX_len_used;
13340 switch (ins->vex.length)
13346 if (ins->vex.w
13353 if (ins->vex.w
13365 oappend_register (ins, names[reg]);
13369 OP_XMM (instr_info *ins, int bytemode, int sizeflag ATTRIBUTE_UNUSED)
13371 unsigned int reg = ins->modrm.reg;
13374 if (ins->rex & REX_R)
13376 if (ins->vex.evex)
13378 if (ins->rex2 & REX_R)
13383 ins->modrm.reg = reg;
13385 ins->vex.no_broadcast = true;
13387 print_vector_reg (ins, reg, bytemode);
13392 OP_EM (instr_info *ins, int bytemode, int sizeflag)
13397 if (ins->modrm.mod != 3)
13399 if (ins->intel_syntax
13402 bytemode = (ins->prefixes & PREFIX_DATA) ? x_mode : q_mode;
13403 ins->used_prefixes |= (ins->prefixes & PREFIX_DATA);
13405 return OP_E (ins, bytemode, sizeflag);
13409 swap_operand (ins);
13413 ins->codep++;
13414 ins->used_prefixes |= (ins->prefixes & PREFIX_DATA);
13415 reg = ins->modrm.rm;
13416 if (ins->prefixes & PREFIX_DATA)
13420 if (ins->rex & REX_B)
13425 oappend_register (ins, names[reg]);
13435 OP_EMC (instr_info *ins, int bytemode, int sizeflag)
13437 if (ins->modrm.mod != 3)
13439 if (ins->intel_syntax && bytemode == v_mode)
13441 bytemode = (ins->prefixes & PREFIX_DATA) ? x_mode : q_mode;
13442 ins->used_prefixes |= (ins->prefixes & PREFIX_DATA);
13444 return OP_E (ins, bytemode, sizeflag);
13449 ins->codep++;
13450 ins->used_prefixes |= (ins->prefixes & PREFIX_DATA);
13451 oappend_register (ins, att_names_mm[ins->modrm.rm]);
13456 OP_MXC (instr_info *ins, int bytemode ATTRIBUTE_UNUSED,
13459 ins->used_prefixes |= (ins->prefixes & PREFIX_DATA);
13460 oappend_register (ins, att_names_mm[ins->modrm.reg]);
13465 OP_EX (instr_info *ins, int bytemode, int sizeflag)
13471 ins->codep++;
13474 bytemode = ins->vex.w ? q_mode : d_mode;
13476 if (ins->modrm.mod != 3)
13477 return OP_E_memory (ins, bytemode, sizeflag);
13479 reg = ins->modrm.rm;
13481 if (ins->rex & REX_B)
13483 if (ins->vex.evex)
13486 if ((ins->rex & REX_X))
13488 ins->rex2_used &= ~REX_B;
13490 else if (ins->rex2 & REX_B)
13498 swap_operand (ins);
13501 ins->modrm.rm = reg;
13503 print_vector_reg (ins, reg, bytemode);
13508 OP_R (instr_info *ins, int bytemode, int sizeflag)
13510 if (ins->modrm.mod != 3)
13511 return BadOp (ins);
13519 return OP_E (ins, bytemode, sizeflag);
13521 return OP_EM (ins, x_mode, sizeflag);
13523 if (ins->vex.length <= 128)
13525 return BadOp (ins);
13528 return OP_EX (ins, bytemode, sizeflag);
13532 OP_M (instr_info *ins, int bytemode, int sizeflag)
13536 ins->codep++;
13538 if (ins->modrm.mod == 3)
13540 return BadOp (ins);
13543 ins->vex.no_broadcast = true;
13545 return OP_E_memory (ins, bytemode, sizeflag);
13549 OP_0f07 (instr_info *ins, int bytemode, int sizeflag)
13551 if (ins->modrm.mod != 3 || ins->modrm.rm != 0)
13552 return BadOp (ins);
13553 return OP_E (ins, bytemode, sizeflag);
13559 MONTMUL_Fixup (instr_info *ins, int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
13561 if (ins->modrm.mod != 3 || ins->modrm.rm != 0)
13562 return BadOp (ins);
13565 if (ins->prefixes & PREFIX_REPZ)
13566 ins->all_prefixes[ins->last_repz_prefix] = 0xf3;
13570 ins->codep++;
13578 NOP_Fixup (instr_info *ins, int opnd, int sizeflag)
13580 if ((ins->prefixes & PREFIX_DATA) == 0 && (ins->rex & REX_B) == 0)
13582 ins->mnemonicendp = stpcpy (ins->obuf, "nop");
13586 return OP_REG (ins, eAX_reg, sizeflag);
13587 return OP_IMREG (ins, eAX_reg, sizeflag);
13658 OP_3DNowSuffix (instr_info *ins, int bytemode ATTRIBUTE_UNUSED,
13663 if (!fetch_code (ins->info, ins->codep + 1))
13668 ins->obufp = ins->mnemonicendp;
13669 mnemonic = Suffix3DNow[*ins->codep++];
13671 ins->obufp = stpcpy (ins->obufp, mnemonic);
13674 /* Since a variable sized ins->modrm/ins->sib chunk is between the start
13676 all the ins->modrm processing first, and don't know until now that
13678 ins->op_out[0][0] = '\0';
13679 ins->op_out[1][0] = '\0';
13680 BadOp (ins);
13682 ins->mnemonicendp = ins->obufp;
13727 CMP_Fixup (instr_info *ins, int bytemode ATTRIBUTE_UNUSED,
13732 if (!fetch_code (ins->info, ins->codep + 1))
13734 cmp_type = *ins->codep++;
13738 char *p = ins->mnemonicendp - 2;
13743 ins->mnemonicendp += simd_cmp_op[cmp_type].len;
13745 else if (ins->need_vex
13749 char *p = ins->mnemonicendp - 2;
13755 ins->mnemonicendp += vex_cmp_op[cmp_type].len;
13760 oappend_immediate (ins, cmp_type);
13766 OP_Mwait (instr_info *ins, int bytemode, int sizeflag ATTRIBUTE_UNUSED)
13769 if (!ins->intel_syntax)
13771 strcpy (ins->op_out[0], att_names32[0] + ins->intel_syntax);
13772 strcpy (ins->op_out[1], att_names32[1] + ins->intel_syntax);
13774 strcpy (ins->op_out[2], att_names32[3] + ins->intel_syntax);
13775 ins->two_source_ops = true;
13779 ins->codep++;
13784 OP_Monitor (instr_info *ins, int bytemode ATTRIBUTE_UNUSED,
13788 if (!ins->intel_syntax)
13790 const char (*names)[8] = (ins->address_mode == mode_64bit
13793 if (ins->prefixes & PREFIX_ADDR)
13796 ins->all_prefixes[ins->last_addr_prefix] = 0;
13797 names = (ins->address_mode != mode_32bit
13799 ins->used_prefixes |= PREFIX_ADDR;
13801 else if (ins->address_mode == mode_16bit)
13803 strcpy (ins->op_out[0], names[0] + ins->intel_syntax);
13804 strcpy (ins->op_out[1], att_names32[1] + ins->intel_syntax);
13805 strcpy (ins->op_out[2], att_names32[2] + ins->intel_syntax);
13806 ins->two_source_ops = true;
13810 ins->codep++;
13815 REP_Fixup (instr_info *ins, int bytemode, int sizeflag)
13817 /* The 0xf3 prefix should be displayed as "rep" for ins, outs, movs,
13819 if (ins->prefixes & PREFIX_REPZ)
13820 ins->all_prefixes[ins->last_repz_prefix] = REP_PREFIX;
13827 return OP_IMREG (ins, bytemode, sizeflag);
13829 return OP_ESreg (ins, bytemode, sizeflag);
13831 return OP_DSreg (ins, bytemode, sizeflag);
13840 SEP_Fixup (instr_info *ins, int bytemode ATTRIBUTE_UNUSED,
13843 if (ins->isa64 != amd64)
13846 ins->obufp = ins->obuf;
13847 BadOp (ins);
13848 ins->mnemonicendp = ins->obufp;
13849 ++ins->codep;
13857 BND_Fixup (instr_info *ins, int bytemode ATTRIBUTE_UNUSED,
13860 if (ins->prefixes & PREFIX_REPNZ)
13861 ins->all_prefixes[ins->last_repnz_prefix] = BND_PREFIX;
13869 NOTRACK_Fixup (instr_info *ins, int bytemode ATTRIBUTE_UNUSED,
13874 if ((ins->prefixes & PREFIX_DS) != 0
13875 && (ins->address_mode != mode_64bit || ins->last_data_prefix < 0))
13879 ins->active_seg_prefix = 0;
13880 ins->all_prefixes[ins->last_seg_prefix] = NOTRACK_PREFIX;
13885 /* Similar to OP_E. But the 0xf2/0xf3 ins->prefixes should be displayed as
13890 HLE_Fixup1 (instr_info *ins, int bytemode, int sizeflag)
13892 if (ins->modrm.mod != 3
13893 && (ins->prefixes & PREFIX_LOCK) != 0)
13895 if (ins->prefixes & PREFIX_REPZ)
13896 ins->all_prefixes[ins->last_repz_prefix] = XRELEASE_PREFIX;
13897 if (ins->prefixes & PREFIX_REPNZ)
13898 ins->all_prefixes[ins->last_repnz_prefix] = XACQUIRE_PREFIX;
13901 return OP_E (ins, bytemode, sizeflag);
13904 /* Similar to OP_E. But the 0xf2/0xf3 ins->prefixes should be displayed as
13909 HLE_Fixup2 (instr_info *ins, int bytemode, int sizeflag)
13911 if (ins->modrm.mod != 3)
13913 if (ins->prefixes & PREFIX_REPZ)
13914 ins->all_prefixes[ins->last_repz_prefix] = XRELEASE_PREFIX;
13915 if (ins->prefixes & PREFIX_REPNZ)
13916 ins->all_prefixes[ins->last_repnz_prefix] = XACQUIRE_PREFIX;
13919 return OP_E (ins, bytemode, sizeflag);
13926 HLE_Fixup3 (instr_info *ins, int bytemode, int sizeflag)
13928 if (ins->modrm.mod != 3
13929 && ins->last_repz_prefix > ins->last_repnz_prefix
13930 && (ins->prefixes & PREFIX_REPZ) != 0)
13931 ins->all_prefixes[ins->last_repz_prefix] = XRELEASE_PREFIX;
13933 return OP_E (ins, bytemode, sizeflag);
13937 CMPXCHG8B_Fixup (instr_info *ins, int bytemode, int sizeflag)
13940 if (ins->rex & REX_W)
13943 char *p = ins->mnemonicendp - 2;
13944 ins->mnemonicendp = stpcpy (p, "16b");
13947 else if ((ins->prefixes & PREFIX_LOCK) != 0)
13949 if (ins->prefixes & PREFIX_REPZ)
13950 ins->all_prefixes[ins->last_repz_prefix] = XRELEASE_PREFIX;
13951 if (ins->prefixes & PREFIX_REPNZ)
13952 ins->all_prefixes[ins->last_repnz_prefix] = XACQUIRE_PREFIX;
13955 return OP_M (ins, bytemode, sizeflag);
13959 XMM_Fixup (instr_info *ins, int reg, int sizeflag ATTRIBUTE_UNUSED)
13963 if (ins->need_vex)
13965 switch (ins->vex.length)
13976 oappend_register (ins, names[reg]);
13981 FXSAVE_Fixup (instr_info *ins, int bytemode, int sizeflag)
13985 if (ins->rex & REX_W)
13987 char *p = ins->mnemonicendp;
13991 ins->mnemonicendp = p;
13993 return OP_M (ins, bytemode, sizeflag);
14000 OP_VEX (instr_info *ins, int bytemode, int sizeflag ATTRIBUTE_UNUSED)
14005 if (!ins->need_vex)
14008 if (ins->evex_type == evex_from_legacy)
14010 ins->evex_used |= EVEX_b_used;
14011 if (!ins->vex.nd)
14015 reg = ins->vex.register_specifier;
14016 ins->vex.register_specifier = 0;
14017 if (ins->address_mode != mode_64bit)
14019 if (ins->vex.evex && !ins->vex.v)
14021 oappend (ins, "(bad)");
14027 else if (ins->vex.evex && !ins->vex.v)
14033 oappend_register (ins, att_names_xmm[reg]);
14039 if (ins->obufp != ins->op_out[2])
14041 if (ins->vex.length == 128
14043 && !ins->vex.w))
14044 oappend_register (ins, att_names_xmm[reg]);
14046 oappend_register (ins, att_names_ymm[reg]);
14049 modrm_reg = ins->modrm.reg;
14050 if (ins->rex & REX_R)
14053 if (ins->has_sib && ins->modrm.rm == 4)
14055 sib_index = ins->sib.index;
14056 if (ins->rex & REX_X)
14061 strcpy (ins->obufp, "/(bad)");
14063 strcat (ins->op_out[0], "/(bad)");
14065 strcat (ins->op_out[1], "/(bad)");
14072 oappend (ins, "(bad)");
14076 if (ins->obufp != ins->op_out[2])
14078 oappend_register (ins, att_names_tmm[reg]);
14079 if (reg == ins->modrm.reg || reg == ins->modrm.rm)
14080 strcpy (ins->obufp, "/(bad)");
14083 if (ins->modrm.reg == ins->modrm.rm || ins->modrm.reg == reg
14084 || ins->modrm.rm == reg)
14086 if (ins->modrm.reg <= 8
14087 && (ins->modrm.reg == ins->modrm.rm || ins->modrm.reg == reg))
14088 strcat (ins->op_out[0], "/(bad)");
14089 if (ins->modrm.rm <= 8
14090 && (ins->modrm.rm == ins->modrm.reg || ins->modrm.rm == reg))
14091 strcat (ins->op_out[1], "/(bad)");
14098 if (ins->rex & REX_W)
14099 oappend_register (ins, att_names64[reg]);
14102 oappend_register (ins, att_names16[reg]);
14104 oappend_register (ins, att_names32[reg]);
14108 oappend_register (ins, att_names8rex[reg]);
14112 oappend_register (ins, att_names64[reg]);
14116 switch (ins->vex.length)
14123 ins->evex_used |= EVEX_len_used;
14129 oappend (ins, "(bad)");
14144 ins->evex_used |= EVEX_len_used;
14156 oappend (ins, "(bad)");
14162 ins->evex_used |= EVEX_len_used;
14168 oappend_register (ins, names[reg]);
14173 OP_VexR (instr_info *ins, int bytemode, int sizeflag)
14175 if (ins->modrm.mod == 3)
14176 return OP_VEX (ins, bytemode, sizeflag);
14181 OP_VexW (instr_info *ins, int bytemode, int sizeflag)
14183 OP_VEX (ins, bytemode, sizeflag);
14185 if (ins->vex.w)
14188 char *tmp = ins->op_out[2];
14190 ins->op_out[2] = ins->op_out[1];
14191 ins->op_out[1] = tmp;
14197 OP_REG_VexI4 (instr_info *ins, int bytemode, int sizeflag ATTRIBUTE_UNUSED)
14202 if (!fetch_code (ins->info, ins->codep + 1))
14204 reg = *ins->codep++;
14210 if (ins->address_mode != mode_64bit)
14213 if (bytemode == x_mode && ins->vex.length == 256)
14216 oappend_register (ins, names[reg]);
14218 if (ins->vex.w)
14221 char *tmp = ins->op_out[3];
14223 ins->op_out[3] = ins->op_out[2];
14224 ins->op_out[2] = tmp;
14230 OP_VexI4 (instr_info *ins, int bytemode ATTRIBUTE_UNUSED,
14233 oappend_immediate (ins, ins->codep[-1] & 0xf);
14238 VPCMP_Fixup (instr_info *ins, int bytemode ATTRIBUTE_UNUSED,
14243 if (!ins->vex.evex)
14246 if (!fetch_code (ins->info, ins->codep + 1))
14248 cmp_type = *ins->codep++;
14256 char *p = ins->mnemonicendp - 2;
14273 ins->mnemonicendp += simd_cmp_op[cmp_type].len;
14278 oappend_immediate (ins, cmp_type);
14296 VPCOM_Fixup (instr_info *ins, int bytemode ATTRIBUTE_UNUSED,
14301 if (!fetch_code (insins->codep + 1))
14303 cmp_type = *ins->codep++;
14307 char *p = ins->mnemonicendp - 2;
14324 ins->mnemonicendp += xop_cmp_op[cmp_type].len;
14329 oappend_immediate (ins, cmp_type);
14343 PCLMUL_Fixup (instr_info *ins, int bytemode ATTRIBUTE_UNUSED,
14348 if (!fetch_code (ins->info, ins->codep + 1))
14350 pclmul_type = *ins->codep++;
14365 char *p = ins->mnemonicendp - 3;
14371 ins->mnemonicendp += pclmul_op[pclmul_type].len;
14376 oappend_immediate (ins, pclmul_type);
14382 MOVSXD_Fixup (instr_info *ins, int bytemode, int sizeflag)
14385 char *p = ins->mnemonicendp;
14390 if (!ins->intel_syntax)
14393 if (ins->rex & REX_W)
14405 oappend (ins, INTERNAL_DISASSEMBLER_ERROR);
14409 ins->mnemonicendp = p;
14411 return OP_E (ins, bytemode, sizeflag);
14415 DistinctDest_Fixup (instr_info *ins, int bytemode, int sizeflag)
14417 unsigned int reg = ins->vex.register_specifier;
14418 unsigned int modrm_reg = ins->modrm.reg;
14419 unsigned int modrm_rm = ins->modrm.rm;
14422 if (ins->rex & REX_R)
14424 if (ins->rex2 & REX_R)
14428 if (ins->address_mode != mode_64bit)
14430 else if (ins->vex.evex && !ins->vex.v)
14434 if (ins->modrm.mod == 3)
14436 if (ins->rex & REX_B)
14438 if (ins->rex & REX_X)
14445 || (ins->modrm.mod == 3
14448 oappend (ins, "(bad)");
14451 return OP_XMM (ins, bytemode, sizeflag);
14455 OP_Rounding (instr_info *ins, int bytemode, int sizeflag ATTRIBUTE_UNUSED)
14457 if (ins->modrm.mod != 3 || !ins->vex.b)
14460 ins->evex_used |= EVEX_b_used;
14464 if (ins->address_mode != mode_64bit || !ins->vex.w)
14468 oappend (ins, names_rounding[ins->vex.ll]);
14471 oappend (ins, "{");
14476 oappend (ins, "sae}");
14481 PREFETCHI_Fixup (instr_info *ins, int bytemode, int sizeflag)
14483 if (ins->modrm.mod != 0 || ins->modrm.rm != 5)
14485 if (ins->intel_syntax)
14487 ins->mnemonicendp = stpcpy (ins->obuf, "nop ");
14492 if (ins->rex & REX_W)
14493 ins->mnemonicendp = stpcpy (ins->obuf, "nopq ");
14497 ins->mnemonicendp = stpcpy (ins->obuf, "nopl ");
14499 ins->mnemonicendp = stpcpy (ins->obuf, "nopw ");
14500 ins->used_prefixes |= (ins->prefixes & PREFIX_DATA);
14506 return OP_M (ins, bytemode, sizeflag);
14510 PUSH2_POP2_Fixup (instr_info *ins, int bytemode, int sizeflag)
14512 if (ins->modrm.mod != 3)
14515 unsigned int vvvv_reg = ins->vex.register_specifier
14516 | (!ins->vex.v << 4);
14517 unsigned int rm_reg = ins->modrm.rm + (ins->rex & REX_B ? 8 : 0)
14518 + (ins->rex2 & REX_B ? 16 : 0);
14521 if (!ins->vex.nd || vvvv_reg == 0x4 || rm_reg == 0x4
14522 || (!ins->modrm.reg
14525 oappend (ins, "(bad)");
14529 return OP_VEX (ins, bytemode, sizeflag);
14533 JMPABS_Fixup (instr_info *ins, int bytemode, int sizeflag)
14535 if (ins->last_rex2_prefix >= 0)
14539 if ((ins->prefixes & (PREFIX_OPCODE | PREFIX_ADDR | PREFIX_LOCK)) != 0x0
14540 || (ins->rex & REX_W) != 0x0)
14542 oappend (ins, "(bad)");
14549 if (!get64 (ins, &op))
14552 ins->mnemonicendp = stpcpy (ins->obuf, "jmpabs");
14553 ins->rex2 |= REX2_SPECIAL;
14554 oappend_immediate (ins, op);
14560 return OP_IMREG (ins, bytemode, sizeflag);
14561 return OP_OFF64 (ins, bytemode, sizeflag);
14565 CFCMOV_Fixup (instr_info *ins, int opnd, int sizeflag)
14569 bool dstmem = !ins->vex.nd && ins->vex.nf;
14574 return OP_E (ins, v_swap_mode, sizeflag);
14575 return OP_G (ins, v_mode, sizeflag);
14579 ins->vex.nf = false;
14580 ins->vex.mask_register_specifier = 0;
14583 return OP_G (ins, v_mode, sizeflag);
14584 return OP_E (ins, v_mode, sizeflag);
Indexes created Sat Apr 04 00:22:49 UTC 2026