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",
1859 typedef bool (*op_rtn) (instr_info *ins, int bytemode, int sizeflag);
2078 { "ins{b|}", { Ybr, indirDX }, 0 },
2593 #define MODRM_CHECK if (!ins->need_modrm) abort ()
4454 { "ins{R|}", { Yzr, indirDX }, 0 },
4455 { "ins{G|}", { Yzr, indirDX }, 0 },
8753 ckprefix (instr_info *ins)
8763 if (!fetch_code (ins->info, ins->codep + 1))
8766 switch (*ins->codep)
8785 if (ins->address_mode == mode_64bit)
8786 newrex = *ins->codep;
8789 ins->last_rex_prefix = i;
8793 if (ins->address_mode == mode_64bit)
8795 if (ins->last_rex_prefix >= 0)
8798 ins->codep++;
8799 if (!fetch_code (ins->info, ins->codep + 1))
8801 ins->rex2_payload = *ins->codep;
8802 ins->rex2 = ins->rex2_payload >> 4;
8803 ins->rex = (ins->rex2_payload & 0xf) | REX_OPCODE;
8804 ins->codep++;
8805 ins->last_rex2_prefix = i;
8806 ins->all_prefixes[i] = REX2_OPCODE;
8810 ins->prefixes |= PREFIX_REPZ;
8811 ins->last_repz_prefix = i;
8814 ins->prefixes |= PREFIX_REPNZ;
8815 ins->last_repnz_prefix = i;
8818 ins->prefixes |= PREFIX_LOCK;
8819 ins->last_lock_prefix = i;
8822 ins->prefixes |= PREFIX_CS;
8823 ins->last_seg_prefix = i;
8824 if (ins->address_mode != mode_64bit)
8825 ins->active_seg_prefix = PREFIX_CS;
8828 ins->prefixes |= PREFIX_SS;
8829 ins->last_seg_prefix = i;
8830 if (ins->address_mode != mode_64bit)
8831 ins->active_seg_prefix = PREFIX_SS;
8834 ins->prefixes |= PREFIX_DS;
8835 ins->last_seg_prefix = i;
8836 if (ins->address_mode != mode_64bit)
8837 ins->active_seg_prefix = PREFIX_DS;
8840 ins->prefixes |= PREFIX_ES;
8841 ins->last_seg_prefix = i;
8842 if (ins->address_mode != mode_64bit)
8843 ins->active_seg_prefix = PREFIX_ES;
8846 ins->prefixes |= PREFIX_FS;
8847 ins->last_seg_prefix = i;
8848 ins->active_seg_prefix = PREFIX_FS;
8851 ins->prefixes |= PREFIX_GS;
8852 ins->last_seg_prefix = i;
8853 ins->active_seg_prefix = PREFIX_GS;
8856 ins->prefixes |= PREFIX_DATA;
8857 ins->last_data_prefix = i;
8860 ins->prefixes |= PREFIX_ADDR;
8861 ins->last_addr_prefix = i;
8867 ins->fwait_prefix = i;
8868 if (ins->prefixes || ins->rex)
8870 ins->prefixes |= PREFIX_FWAIT;
8871 ins->codep++;
8874 return ins->rex ? ckp_bogus : ckp_okay;
8876 ins->prefixes = PREFIX_FWAIT;
8882 if (ins->rex)
8884 if (*ins->codep != FWAIT_OPCODE)
8885 ins->all_prefixes[i++] = *ins->codep;
8886 ins->rex = newrex;
8887 ins->codep++;
9024 get_valid_dis386 (const struct dis386 *dp, instr_info *ins)
9034 dp = ®_table[dp->op[1].bytemode][ins->modrm.reg];
9038 vindex = ins->modrm.mod == 0x3 ? 1 : 0;
9043 dp = &rm_table[dp->op[1].bytemode][ins->modrm.rm];
9048 if (ins->need_vex)
9051 switch (ins->vex.prefix)
9078 if ((ins->prefixes & (PREFIX_REPZ | PREFIX_REPNZ)) != 0)
9080 if (ins->last_repz_prefix > ins->last_repnz_prefix)
9084 last_prefix = ins->last_repz_prefix;
9090 last_prefix = ins->last_repnz_prefix;
9101 if (vindex == 0 && (ins->prefixes & PREFIX_DATA) != 0)
9105 last_prefix = ins->last_data_prefix;
9110 ins->used_prefixes |= prefix;
9111 ins->all_prefixes[last_prefix] = 0;
9121 ins->evex_type = evex_from_vex;
9124 if (ins->address_mode != mode_64bit
9125 || (ins->vex.mask_register_specifier & 0x3) != 0
9126 || ins->vex.ll != 0
9127 || ins->vex.zeroing != 0
9128 || ins->vex.b)
9137 if (ins->modrm.mod == 3)
9144 vindex = ins->address_mode == mode_64bit ? 1 : 0;
9149 if (ins->last_rex2_prefix >= 0)
9151 if (!fetch_code (ins->info, ins->codep + 2))
9153 vindex = *ins->codep++;
9155 ins->end_codep = ins->codep;
9156 if (!fetch_modrm (ins))
9161 if (!ins->need_vex)
9164 switch (ins->vex.length)
9172 if (ins->vex.evex)
9188 if (!ins->vex.evex)
9191 switch (ins->vex.length)
9211 if (!fetch_code (ins->info, ins->codep + 3))
9213 ins->rex = ~(*ins->codep >> 5) & 0x7;
9216 switch ((*ins->codep & 0x1f))
9231 ins->codep++;
9232 ins->vex.w = *ins->codep & 0x80;
9233 if (ins->vex.w && ins->address_mode == mode_64bit)
9234 ins->rex |= REX_W;
9236 ins->vex.register_specifier = (~(*ins->codep >> 3)) & 0xf;
9237 if (ins->address_mode != mode_64bit)
9240 ins->rex &= ~REX_B;
9243 ins->vex.length = (*ins->codep & 0x4) ? 256 : 128;
9244 switch ((*ins->codep & 0x3))
9249 ins->vex.prefix = DATA_PREFIX_OPCODE;
9252 ins->vex.prefix = REPE_PREFIX_OPCODE;
9255 ins->vex.prefix = REPNE_PREFIX_OPCODE;
9258 ins->need_vex = 3;
9259 ins->codep++;
9260 vindex = *ins->codep++;
9263 ins->end_codep = ins->codep;
9264 if (!fetch_modrm (ins))
9269 if (ins->vex.prefix)
9275 if (!fetch_code (ins->info, ins->codep + 3))
9277 ins->rex = ~(*ins->codep >> 5) & 0x7;
9278 switch ((*ins->codep & 0x1f))
9299 ins->codep++;
9300 ins->vex.w = *ins->codep & 0x80;
9301 if (ins->address_mode == mode_64bit)
9303 if (ins->vex.w)
9304 ins->rex |= REX_W;
9311 ins->rex = 0;
9313 ins->vex.register_specifier = (~(*ins->codep >> 3)) & 0xf;
9314 ins->vex.length = (*ins->codep & 0x4) ? 256 : 128;
9315 switch ((*ins->codep & 0x3))
9320 ins->vex.prefix = DATA_PREFIX_OPCODE;
9323 ins->vex.prefix = REPE_PREFIX_OPCODE;
9326 ins->vex.prefix = REPNE_PREFIX_OPCODE;
9329 ins->need_vex = 3;
9330 ins->codep++;
9331 vindex = *ins->codep++;
9332 ins->condition_code = vindex & 0xf;
9350 ins->end_codep = ins->codep;
9353 && !fetch_modrm (ins))
9359 if (!fetch_code (ins->info, ins->codep + 2))
9361 ins->rex = (*ins->codep & 0x80) ? 0 : REX_R;
9365 ins->vex.register_specifier = (~(*ins->codep >> 3)) & 0xf;
9366 ins->vex.length = (*ins->codep & 0x4) ? 256 : 128;
9367 switch ((*ins->codep & 0x3))
9372 ins->vex.prefix = DATA_PREFIX_OPCODE;
9375 ins->vex.prefix = REPE_PREFIX_OPCODE;
9378 ins->vex.prefix = REPNE_PREFIX_OPCODE;
9381 ins->need_vex = 2;
9382 ins->codep++;
9383 vindex = *ins->codep++;
9385 ins->end_codep = ins->codep;
9387 if (vindex != 0x77 && !fetch_modrm (ins))
9393 if (!ins->need_vex)
9396 dp = &vex_w_table[dp->op[1].bytemode][ins->vex.w];
9400 ins->two_source_ops = false;
9402 ins->vex.evex = true;
9403 if (!fetch_code (ins->info, ins->codep + 4))
9406 if (*ins->codep & 0x8)
9407 ins->rex2 |= REX_B;
9408 if (!(*ins->codep & 0x10))
9409 ins->rex2 |= REX_R;
9411 ins->rex = ~(*ins->codep >> 5) & 0x7;
9412 switch (*ins->codep & 0x7)
9427 ins->evex_type = evex_from_legacy;
9428 if (ins
9430 ins->rex |= REX_OPCODE;
9444 ins->codep++;
9445 ins->vex.w = *ins->codep & 0x80;
9446 if (ins->vex.w && ins->address_mode == mode_64bit)
9447 ins->rex |= REX_W;
9449 ins->vex.register_specifier = (~(*ins->codep >> 3)) & 0xf;
9451 if (!(*ins->codep & 0x4))
9452 ins->rex2 |= REX_X;
9454 switch ((*ins->codep & 0x3))
9459 ins->vex.prefix = DATA_PREFIX_OPCODE;
9462 ins->vex.prefix = REPE_PREFIX_OPCODE;
9465 ins->vex.prefix = REPNE_PREFIX_OPCODE;
9470 ins->codep++;
9473 ins->vex.ll = (*ins->codep >> 5) & 3;
9474 ins->vex.b = *ins->codep & 0x10;
9476 ins->vex.v = *ins->codep & 0x8;
9477 ins->vex.mask_register_specifier = *ins->codep & 0x7;
9478 ins->vex.scc = *ins->codep & 0xf;
9479 ins->vex.zeroing = *ins->codep & 0x80;
9482 ins->vex.nf = *ins->codep & 0x4;
9484 if (ins->address_mode != mode_64bit)
9488 if (ins->evex_type != evex_default
9489 || (ins->rex2 & (REX_B | REX_X)))
9492 ins->rex &= ~REX_B;
9493 ins->rex2 &= ~REX_R;
9496 ins->need_vex = 4;
9498 ins->codep++;
9499 vindex = *ins->codep++;
9500 ins->condition_code = vindex & 0xf;
9509 ins->end_codep = ins->codep;
9510 if (!fetch_modrm (ins))
9513 if (ins->modrm.mod == 3 && (ins->rex2 & REX_X))
9519 if (ins->modrm.mod == 3 && ins->vex.b && ins->evex_type != evex_from_legacy)
9520 ins->vex.length = 512;
9523 switch (ins->vex.ll)
9526 ins->vex.length = 128;
9529 ins->vex.length = 256;
9532 ins->vex.length = 512;
9551 return get_valid_dis386 (dp, ins);
9555 get_sib (instr_info *ins, int sizeflag)
9558 if (ins->need_modrm
9559 && ((sizeflag & AFLAG) || ins->address_mode == mode_64bit)
9560 && ins->modrm.mod != 3
9561 && ins->modrm.rm == 4)
9563 if (!fetch_code (ins->info, ins->codep + 2))
9565 ins->sib.index = (ins->codep[1] >> 3) & 7;
9566 ins->sib.scale = (ins->codep[1] >> 6) & 3;
9567 ins->sib.base = ins->codep[1] & 7;
9568 ins->has_sib = true;
9571 ins->has_sib = false;
9579 oappend (instr_info *ins, const char *s)
9581 oappend_with_style (ins, s, dis_style_text);
9588 oappend_register (instr_info *ins, const char *s)
9590 oappend_with_style (ins, s + ins->intel_syntax, dis_style_register);
9593 /* Wrap around a call to INS->info->fprintf_styled_func, printing FMT.
9694 instr_info ins = {
9704 .obufp = ins.obuf,
9719 ins.address_mode = mode_32bit;
9722 ins.address_mode = mode_16bit;
9726 ins.address_mode = mode_64bit;
9731 ins.isa64 = amd64;
9733 ins.isa64 = intel64;
9736 ins.address_mode = mode_64bit;
9741 ins.address_mode = mode_32bit;
9746 ins.address_mode = mode_16bit;
9752 ins.intel_mnemonic = true;
9754 ins.intel_syntax = 1;
9758 ins.intel_syntax = 0;
9760 ins.intel_mnemonic = false;
9764 if (ins.address_mode == mode_64bit)
9794 if (ins.address_mode == mode_64bit && sizeof (bfd_vma) < 8)
9800 if (ins.intel_syntax)
9802 ins.open_char = '[';
9803 ins.close_char = ']';
9804 ins.separator_char = '+';
9805 ins.scale_char = '*';
9809 ins.open_char = '(';
9810 ins.close_char = ')';
9811 ins.separator_char = ',';
9812 ins.scale_char = ',';
9826 ins.op_out[i] = op_out[i];
9831 switch (ckprefix (&ins))
9839 i < (int) ARRAY_SIZE (ins.all_prefixes) && ins.all_prefixes[i];
9843 prefix_name (ins.address_mode, ins.all_prefixes[i],
9852 ins.nr_prefixes = ins.codep - ins.start_codep;
9854 if (!fetch_code (info, ins.codep + 1))
9857 ret = fetch_error (&ins);
9861 ins.two_source_ops = (*ins.codep == 0x62 || *ins.codep == 0xc8);
9863 if ((ins.prefixes & PREFIX_FWAIT)
9864 && (*ins.codep < 0xd8 || *ins.codep > 0xdf))
9866 /* Handle ins.prefixes before fwait. */
9867 for (i = 0; i < ins.fwait_prefix && ins.all_prefixes[i];
9870 prefix_name (ins.address_mode, ins.all_prefixes[i],
9878 if (ins.last_rex2_prefix < 0 ? *ins.codep == 0x0f : (ins.rex2 & REX2_M))
9880 if (!ins.rex2)
9882 ins.codep++;
9883 if (!fetch_code (info, ins.codep + 1))
9887 dp = &dis386_twobyte[*ins.codep];
9888 ins.need_modrm = twobyte_has_modrm[*ins.codep];
9892 dp = &dis386[*ins.codep];
9893 ins.need_modrm = onebyte_has_modrm[*ins.codep];
9895 ins.condition_code = *ins.codep & 0xf;
9896 ins.codep++;
9898 /* Save sizeflag for printing the extra ins.prefixes later before updating
9902 if (ins.prefixes & PREFIX_ADDR)
9904 if ((ins.prefixes & PREFIX_DATA))
9907 ins.end_codep = ins.codep;
9908 if (ins.need_modrm && !fetch_modrm (&ins))
9913 if (!get_sib (&ins, sizeflag)
9914 || !dofloat (&ins, sizeflag))
9919 dp = get_valid_dis386 (dp, &ins);
9925 if (ins.evex_type == evex_from_legacy
9926 && ins.vex.prefix == DATA_PREFIX_OPCODE)
9929 if(ins.evex_type == evex_default)
9930 ins.vex.nf = false;
9936 ins.vex.mask_register_specifier &= 0x3;
9938 if (dp != NULL && putop (&ins, dp->name, sizeflag) == 0)
9940 if (!get_sib (&ins, sizeflag))
9944 ins.obufp = ins.op_out[i];
9945 ins.op_ad = MAX_OPERANDS - 1 - i;
9947 && !dp->op[i].rtn (&ins, dp->op[i].bytemode, sizeflag))
9951 if (i == 0 && ins.vex.evex)
9954 if (ins.vex.mask_register_specifier)
9957 = att_names_mask[ins.vex.mask_register_specifier];
9959 oappend (&ins, "{");
9960 oappend_register (&ins, reg_name);
9961 oappend (&ins, "}");
9963 if (ins.vex.zeroing)
9964 oappend (&ins, "{z}");
9966 else if (ins.vex.zeroing)
9968 oappend (&ins, "{bad}");
9975 if (ins.vex.zeroing && dp->op[0].bytemode == mask_mode)
9976 ins.illegal_masking = true;
9982 && (ins.vex.mask_register_specifier == 0
9983 || ins.vex.zeroing))
9984 ins.illegal_masking = true;
9986 if (ins.illegal_masking)
9987 oappend (&ins, "/(bad)");
9991 if (ins.vex.nf)
9992 oappend (&ins, "{bad-nf}");
9996 if (ins.modrm.mod == 3 && ins.vex.b && ins.evex_type == evex_default
9997 && !(ins.evex_used & EVEX_b_used))
10001 ins.obufp = ins.op_out[i];
10002 if (*ins.obufp)
10004 oappend (&ins, names_rounding[ins.vex.ll]);
10005 oappend (&ins, "bad}");
10021 ins.op_is_jump = false;
10042 ins.op_is_jump = true;
10055 if (ins.evex_type == evex_from_legacy)
10059 if (!ins.vex.nd && (ins.vex.register_specifier || !ins.vex.v))
10062 ret = ins.end_codep - priv.the_buffer;
10068 if ((ins.vex.mask_register_specifier & 0x3) != 0
10069 || ins.vex.ll != 0 || ins.vex.zeroing != 0)
10072 ret = ins.end_codep - priv.the_buffer;
10078 if (ins.need_vex && ins.vex.register_specifier != 0)
10081 ret = ins.end_codep - priv.the_buffer;
10086 && ins.last_rex2_prefix >= 0 && (ins.rex2 & REX2_SPECIAL) == 0)
10089 ret = ins.end_codep - priv.the_buffer;
10098 if (ins.need_vex ? !ins.vex.prefix : !(ins.prefixes & PREFIX_DATA))
10101 ret = ins.end_codep - priv.the_buffer;
10104 ins.used_prefixes |= PREFIX_DATA;
10112 if (((ins.need_vex
10113 ? ins.vex.prefix == REPE_PREFIX_OPCODE
10114 || ins.vex.prefix == REPNE_PREFIX_OPCODE
10115 : (ins.prefixes
10117 && (ins.used_prefixes
10119 || (((ins.need_vex
10120 ? ins.vex.prefix == DATA_PREFIX_OPCODE
10121 : ((ins.prefixes
10124 && (ins.used_prefixes & PREFIX_DATA) == 0))
10125 || (ins.vex.evex && dp->prefix_requirement != PREFIX_DATA
10126 && !ins.vex.w != !(ins.used_prefixes & PREFIX_DATA)))
10129 ret = ins.end_codep - priv.the_buffer;
10137 ins.used_prefixes &= ~PREFIX_OPCODE;
10138 if (ins.last_data_prefix >= 0)
10139 ins.all_prefixes[ins.last_data_prefix] = 0x66;
10140 if (ins.last_repz_prefix >= 0)
10141 ins.all_prefixes[ins.last_repz_prefix] = 0xf3;
10142 if (ins.last_repnz_prefix >= 0)
10143 ins.all_prefixes[ins.last_repnz_prefix] = 0xf2;
10147 if (ins.vex.prefix == REPE_PREFIX_OPCODE
10148 || ins.vex.prefix == REPNE_PREFIX_OPCODE)
10151 ret = ins.end_codep - priv.the_buffer;
10157 if (ins.vex.prefix)
10160 ret = ins.end_codep - priv.the_buffer;
10167 if ((ins.rex ^ ins.rex_used) == 0
10168 && !ins.need_vex && ins.last_rex_prefix >= 0)
10169 ins.all_prefixes[ins.last_rex_prefix] = 0;
10172 if (ins.last_rex2_prefix >= 0
10173 && ((ins.rex2 & REX2_SPECIAL)
10174 || (((ins.rex2 & 7) ^ (ins.rex2_used & 7)) == 0
10175 && (ins.rex ^ ins.rex_used) == 0
10176 && (ins.rex2 & 7))))
10177 ins.all_prefixes[ins.last_rex2_prefix] = 0;
10180 if ((ins.prefixes & (PREFIX_CS | PREFIX_SS | PREFIX_DS | PREFIX_ES
10182 && (ins.used_prefixes & ins.active_seg_prefix) != 0)
10183 ins.all_prefixes[ins.last_seg_prefix] = 0;
10186 if ((ins.prefixes & PREFIX_ADDR) != 0
10187 && (ins.used_prefixes & PREFIX_ADDR) != 0)
10188 ins.all_prefixes[ins.last_addr_prefix] = 0;
10191 if ((ins.prefixes & PREFIX_DATA) != 0
10192 && (ins.used_prefixes & PREFIX_DATA) != 0
10193 && !ins.need_vex)
10194 ins.all_prefixes[ins.last_data_prefix] = 0;
10196 /* Print the extra ins.prefixes. */
10198 for (i = 0; i < (int) ARRAY_SIZE (ins.all_prefixes); i++)
10199 if (ins.all_prefixes[i])
10201 const char *name = prefix_name (ins.address_mode, ins.all_prefixes[i],
10207 if (ins.all_prefixes[i] == REX2_OPCODE)
10209 (unsigned int) ins.rex2_payload);
10215 if ((ins.codep - ins.start_codep) > MAX_CODE_LENGTH)
10225 if (*ins.op_out[i] != '\0')
10229 ins.obufp = ins.mnemonicendp;
10232 i = strlen (ins.obuf) + prefix_length;
10242 i386_dis_printf (info, dis_style_mnemonic, "%s%*s", ins.obuf, i, "");
10247 if (ins.intel_syntax || ins.two_source_ops)
10250 op_txt[i] = ins.op_out[i];
10252 if (ins.intel_syntax && dp && dp->op[2].rtn == OP_Rounding
10255 op_txt[2] = ins.op_out[3];
10256 op_txt[3] = ins.op_out[2];
10264 ins.op_ad = ins.op_index[i];
10265 ins.op_index[i] = ins.op_index[MAX_OPERANDS - 1 - i];
10266 ins.op_index[MAX_OPERANDS - 1 - i] = ins.op_ad;
10267 riprel = ins.op_riprel[i];
10268 ins.op_riprel[i] = ins.op_riprel[MAX_OPERANDS - 1 - i];
10269 ins.op_riprel[MAX_OPERANDS - 1 - i] = riprel;
10275 op_txt[MAX_OPERANDS - 1 - i] = ins.op_out[i];
10285 switch (i & -(ins.intel_syntax && dp))
10298 if (ins.op_index[i] != -1 && !ins.op_riprel[i])
10300 bfd_vma target = (bfd_vma) ins.op_address[ins.op_index[i]];
10302 if (ins.op_is_jump)
10318 if (ins.op_index[i] != -1 && ins.op_riprel[i])
10322 ((bfd_vma)(ins.start_pc + (ins.codep - ins.start_codep)
10323 + ins.op_address[ins.op_index[i]]),
10327 ret = ins.codep - priv.the_buffer;
10674 swap_operand (instr_info *ins)
10676 char *p = ins->mnemonicendp;
10682 if (p <= ins->obuf + 2)
10688 memmove (p + 2, p, ins->mnemonicendp - p + 1);
10691 ins->mnemonicendp += 2;
10695 dofloat (instr_info *ins, int sizeflag)
10698 unsigned char floatop = ins->codep[-1];
10700 if (ins->modrm.mod != 3)
10702 int fp_indx = (floatop - 0xd8) * 8 + ins->modrm.reg;
10704 putop (ins, float_mem[fp_indx], sizeflag);
10705 ins->obufp = ins->op_out[0];
10706 ins->op_ad = 2;
10707 return OP_E (ins, float_mem_mode[fp_indx], sizeflag);
10711 ins->codep++;
10713 dp = &float_reg[floatop - 0xd8][ins->modrm.reg];
10716 putop (ins, fgrps[dp->op[0].bytemode][ins->modrm.rm], sizeflag);
10719 if (floatop == 0xdf && ins->codep[-1] == 0xe0)
10720 strcpy (ins->op_out[0], att_names16[0] + ins->intel_syntax);
10724 putop (ins, dp->name, sizeflag);
10726 ins->obufp = ins->op_out[0];
10727 ins->op_ad = 2;
10729 && !dp->op[0].rtn (ins, dp->op[0].bytemode, sizeflag))
10732 ins->obufp = ins->op_out[1];
10733 ins->op_ad = 1;
10735 && !dp->op[1].rtn (ins, dp->op[1].bytemode, sizeflag))
10742 OP_ST (instr_info *ins, int bytemode ATTRIBUTE_UNUSED,
10745 oappend_register (ins, "%st");
10750 OP_STi (instr_info *ins, int bytemode ATTRIBUTE_UNUSED,
10754 int res = snprintf (scratch, ARRAY_SIZE (scratch), "%%st(%d)", ins->modrm.rm);
10758 oappend_register (ins, scratch);
10764 putop (instr_info *ins, const char *in_template, int sizeflag)
10776 oappend (ins, "(bad)");
10777 *ins->obufp = 0;
10778 ins->mnemonicendp = ins->obufp;
10794 if (ins->evex_type == evex_from_legacy && !ins->vex.nd
10795 && !(ins->rex2 & 7) && !evex_printed)
10797 oappend (ins, "{evex} ");
10800 *ins->obufp++ = *p;
10809 if (ins->intel_syntax)
10828 if (ins->intel_syntax)
10830 if ((ins->need_modrm && ins->modrm.mod != 3 && !ins->vex.nd)
10832 *ins->obufp++ = 'b';
10838 if (ins->intel_syntax)
10841 *ins->obufp++ = 'b';
10845 if (ins->address_mode == mode_64bit
10846 && !(ins->prefixes & PREFIX_ADDR))
10848 *ins->obufp++ = 'a';
10849 *ins->obufp++ = 'b';
10850 *ins->obufp++ = 's';
10857 if (!ins->vex.w)
10858 oappend (ins, "bf16");
10860 oappend (ins, "{bad}");
10869 for (const char *q = dis386[0x70 | ins->condition_code].name + 1;
10871 *ins->obufp++ = *q;
10877 oappend (ins, scc_suffix[ins->vex.scc]);
10880 if (ins->vex.nd)
10881 oappend (ins, "(bad)");
10885 ins->vex.v = 1;
10886 ins->vex.nf = false;
10887 ins->vex.mask_register_specifier = 0;
10893 if (ins->intel_syntax && !alt)
10895 if ((ins->prefixes & PREFIX_DATA) || (sizeflag & SUFFIX_ALWAYS))
10898 *ins->obufp++ = ins->intel_syntax ? 'd' : 'l';
10900 *ins->obufp++ = ins->intel_syntax ? 'w' : 's';
10901 ins->used_prefixes |= (ins->prefixes & PREFIX_DATA);
10910 if (!ins->vex.evex || ins->vex.w)
10911 *ins->obufp++ = 'd';
10913 oappend (ins, "{bad}");
10922 if (ins->intel_syntax || !(sizeflag & SUFFIX_ALWAYS))
10925 if (ins->modrm.mod == 3)
10927 if (ins->rex & REX_W)
10928 *ins->obufp++ = 'q';
10932 *ins->obufp++ = ins->intel_syntax ? 'd' : 'l';
10934 *ins->obufp++ = 'w';
10935 ins->used_prefixes |= (ins->prefixes & PREFIX_DATA);
10939 *ins->obufp++ = 'w';
10947 if (ins->modrm.mod != 3)
10951 if (!ins->vex.evex || ins->vex.b || ins->vex.ll >= 2
10952 || (ins->rex2 & 7)
10953 || (ins->modrm.mod == 3 && (ins->rex & REX_X))
10954 || !ins->vex.v || ins->vex.mask_register_specifier)
10959 if (ins->vex.w)
10966 *ins->obufp++ = '{';
10967 *ins->obufp++ = 'e';
10968 *ins->obufp++ = 'v';
10969 *ins->obufp++ = 'e';
10970 *ins->obufp++ = 'x';
10971 *ins->obufp++ = '}';
10972 *ins->obufp++ = ' ';
10984 if (ins->address_mode == mode_64bit)
10987 *ins->obufp++ = 'r';
10989 *ins->obufp++ = 'e';
10993 *ins->obufp++ = 'e';
10994 ins->used_prefixes |= (ins->prefixes & PREFIX_ADDR);
10999 if (ins->intel_syntax)
11001 if ((ins->prefixes & PREFIX_ADDR) || (sizeflag & SUFFIX_ALWAYS))
11004 *ins->obufp++ = ins->address_mode == mode_64bit ? 'q' : 'l';
11006 *ins->obufp++ = ins->address_mode == mode_64bit ? 'l' : 'w';
11007 ins->used_prefixes |= (ins->prefixes & PREFIX_ADDR);
11012 if (ins->vex.nd && !ins->vex.nf)
11014 *ins->obufp++ = 'c';
11015 *ins->obufp++ = 'f';
11021 if (ins->vex.nf)
11023 oappend (ins, "{nf} ");
11025 ins->vex.nf = false;
11028 else if (ins->evex_type == evex_from_vex && !(ins->rex2 & 7)
11029 && ins->vex.v)
11031 oappend (ins, "{evex} ");
11038 int oszc_value = ~ins->vex.register_specifier & 0xf;
11041 oappend (ins, oszc_flags[oszc_value]);
11044 ins->vex.register_specifier = 0;
11050 if (ins->intel_syntax || (ins->obufp[-1] != 's'
11053 if ((ins->rex & REX_W) || (sizeflag & DFLAG))
11054 *ins->obufp++ = 'l';
11056 *ins->obufp++ = 'w';
11057 if (!(ins->rex & REX_W))
11058 ins->used_prefixes |= (ins->prefixes & PREFIX_DATA);
11063 if (ins->intel_syntax)
11065 if ((ins->prefixes & (PREFIX_CS | PREFIX_DS)) == PREFIX_CS
11066 || (ins->prefixes & (PREFIX_CS | PREFIX_DS)) == PREFIX_DS)
11068 ins->used_prefixes |= ins->prefixes & (PREFIX_CS | PREFIX_DS);
11069 *ins->obufp++ = ',';
11070 *ins->obufp++ = 'p';
11074 if (ins->prefixes & PREFIX_DS)
11076 ins->active_seg_prefix = PREFIX_DS;
11077 *ins->obufp++ = 't';
11081 ins->active_seg_prefix = PREFIX_CS;
11082 *ins->obufp++ = 'n';
11088 if (!ins->vex.w)
11089 *ins->obufp++ = 'h';
11091 oappend (ins, "{bad}");
11098 if (ins->rex & REX_W)
11099 *ins->obufp++ = 'q';
11101 *ins->obufp++ = 'd';
11104 if (ins->intel_syntax)
11108 if (ins->rex & REX_W)
11109 *ins->obufp++ = 'q';
11111 *ins->obufp++ = 'l';
11115 if (ins->intel_mnemonic != cond)
11116 *ins->obufp++ = 'r';
11119 if ((ins->prefixes & PREFIX_FWAIT) == 0)
11120 *ins->obufp++ = 'n';
11122 ins->used_prefixes |= PREFIX_FWAIT;
11126 if (ins->rex & REX_W)
11127 *ins->obufp++ = 'o';
11128 else if (ins->intel_syntax && (sizeflag & DFLAG))
11129 *ins->obufp++ = 'q';
11131 *ins->obufp++ = 'd';
11132 if (!(ins->rex & REX_W))
11133 ins->used_prefixes |= (ins->prefixes & PREFIX_DATA);
11136 if (ins->address_mode == mode_64bit
11137 && (ins->isa64 == intel64 || (ins->rex & REX_W)
11138 || !(ins->prefixes & PREFIX_DATA)))
11141 *ins->obufp++ = 'q';
11148 if (!cond && ins->last_rex2_prefix >= 0 && (ins->rex & REX_W))
11152 *ins->obufp++ = 'p';
11153 ins->rex2 |= REX2_SPECIAL;
11158 if (!cond && ins->intel_syntax)
11161 if ((ins->modrm.mod == 3 || !cond)
11166 if ((!(ins->rex & REX_W) && (ins->prefixes & PREFIX_DATA))
11168 && ins->address_mode != mode_64bit))
11170 *ins->obufp++ = (sizeflag & DFLAG)
11171 ? ins->intel_syntax ? 'd' : 'l' : 'w';
11172 ins->used_prefixes |= (ins->prefixes & PREFIX_DATA);
11175 *ins->obufp++ = 'q';
11179 if ((ins->prefixes & PREFIX_DATA)
11180 || (ins->rex & REX_W)
11184 if (ins->rex & REX_W)
11185 *ins->obufp++ = 'q';
11189 *ins->obufp++ = ins->intel_syntax ? 'd' : 'l';
11191 *ins->obufp++ = 'w';
11192 ins->used_prefixes |= (ins->prefixes & PREFIX_DATA);
11202 if (ins->intel_syntax && !alt)
11205 if ((ins->need_modrm && ins->modrm.mod != 3 && !ins->vex.nd)
11208 if (ins->rex & REX_W)
11209 *ins->obufp++ = 'q';
11213 *ins->obufp++ = ins->intel_syntax ? 'd' : 'l';
11215 *ins->obufp++ = 'w';
11216 ins->used_prefixes |= (ins->prefixes & PREFIX_DATA);
11221 *ins->obufp++ = ins->vex.w ? 'q' : 'd';
11224 if (cond ? ins->modrm.mod == 3 && !(sizeflag & SUFFIX_ALWAYS)
11225 : ins->address_mode != mode_64bit)
11227 if ((ins->rex & REX_W))
11230 *ins->obufp++ = 'q';
11232 else if ((ins->address_mode == mode_64bit && cond)
11234 *ins->obufp++ = ins->intel_syntax? 'd' : 'l';
11241 if (ins->rex & REX_W)
11242 *ins->obufp++ = 'q';
11245 if (ins->intel_syntax)
11246 *ins->obufp++ = 'd';
11248 *ins->obufp++ = 'l';
11251 *ins->obufp++ = 'w';
11252 if (ins->intel_syntax && !p[1]
11253 && ((ins->rex & REX_W) || (sizeflag & DFLAG)))
11254 *ins->obufp++ = 'e';
11255 if (!(ins->rex & REX_W))
11256 ins->used_prefixes |= (ins->prefixes & PREFIX_DATA);
11262 if (ins->intel_syntax)
11266 if (ins->rex & REX_W)
11267 *ins->obufp++ = 'q';
11271 *ins->obufp++ = 'l';
11273 *ins->obufp++ = 'w';
11274 ins->used_prefixes |= (ins->prefixes & PREFIX_DATA);
11284 if (ins->address_mode == mode_64bit
11285 && !(ins->prefixes & PREFIX_ADDR))
11287 *ins->obufp++ = 'a';
11288 *ins->obufp++ = 'b';
11289 *ins->obufp++ = 's';
11294 if (!ins->vex.evex || !ins->vex.w)
11295 *ins->obufp++ = 's';
11297 oappend (ins, "{bad}");
11309 if (ins->vex.nd)
11310 oappend (ins, "zu");
11318 if (ins->need_vex)
11319 *ins->obufp++ = 'v';
11326 if (ins->vex.evex)
11328 *ins->obufp++ = '{';
11329 *ins->obufp++ = 'v';
11330 *ins->obufp++ = 'e';
11331 *ins->obufp++ = 'x';
11332 *ins->obufp++ = '}';
11333 *ins->obufp++ = ' ';
11336 if (ins->rex & REX_W)
11338 *ins->obufp++ = 'a';
11339 *ins->obufp++ = 'b';
11340 *ins->obufp++ = 's';
11355 if (ins->rex & REX_W)
11357 if (ins->intel_syntax)
11358 *ins->obufp++ = 'd';
11360 *ins->obufp++ = 'l';
11363 *ins->obufp++ = 'w';
11365 *ins->obufp++ = 'b';
11366 if (!(ins->rex & REX_W))
11367 ins->used_prefixes |= (ins->prefixes & PREFIX_DATA);
11371 if (!ins->need_vex)
11374 *ins->obufp++ = ins->vex.w ? 'd': 's';
11376 *ins->obufp++ = ins->vex.w ? 'w': 'b';
11386 if (ins->need_vex
11387 ? ins->vex.prefix == DATA_PREFIX_OPCODE
11388 : ins->prefixes & PREFIX_DATA)
11390 *ins->obufp++ = 'd';
11391 ins->used_prefixes |= PREFIX_DATA;
11394 *ins->obufp++ = 's';
11399 if (ins->vex.mask_register_specifier)
11400 ins->illegal_masking = true;
11404 if (!ins->need_vex)
11406 if (ins->intel_syntax
11407 || ((ins->modrm.mod == 3 || ins->vex.b)
11410 switch (ins->vex.length)
11413 *ins->obufp++ = 'x';
11416 *ins->obufp++ = 'y';
11419 if (!ins->vex.evex)
11431 ins->modrm.mod = 3;
11432 if (!ins->intel_syntax && (sizeflag & SUFFIX_ALWAYS))
11433 *ins->obufp++ = ins->address_mode == mode_64bit ? 'q' : 'l';
11437 if (!ins->vex.evex)
11439 if (ins->intel_syntax
11440 || ((ins->modrm.mod == 3 || ins->vex.b)
11443 switch (ins->vex.length)
11446 *ins->obufp++ = 'x';
11449 *ins->obufp++ = 'y';
11452 *ins->obufp++ = 'z';
11462 if (ins->intel_syntax)
11464 if (ins->isa64 == intel64 && (ins->rex & REX_W))
11467 *ins->obufp++ = 'q';
11470 if ((ins->prefixes & PREFIX_DATA) || (sizeflag & SUFFIX_ALWAYS))
11473 *ins->obufp++ = 'l';
11475 *ins->obufp++ = 'w';
11476 ins->used_prefixes |= (ins->prefixes & PREFIX_DATA);
11484 *ins->obufp = 0;
11485 ins->mnemonicendp = ins->obufp;
11489 /* Add a style marker to *INS
11490 the buffer pointed to by INS->obufp has space. A style marker is made
11496 oappend_insert_style (instr_info *ins, enum disassembler_style style)
11506 *ins->obufp++ = STYLE_MARKER_CHAR;
11507 *ins->obufp++ = (num < 10 ? ('0' + num)
11509 *ins->obufp++ = STYLE_MARKER_CHAR;
11517 *ins->obufp = '\0';
11521 oappend_with_style (instr_info *ins, const char *s,
11524 oappend_insert_style (ins, style);
11525 ins->obufp = stpcpy (ins->obufp, s);
11528 /* Add a single character C to the buffer pointer to by INS->obufp, marking
11532 oappend_char_with_style (instr_info *ins, const char c,
11535 oappend_insert_style (ins, style);
11536 *ins->obufp++ = c;
11537 *ins->obufp = '\0';
11543 oappend_char (instr_info *ins, const char c)
11545 oappend_char_with_style (ins, c, dis_style_text);
11549 append_seg (instr_info *ins)
11552 if (!ins->active_seg_prefix)
11555 ins->used_prefixes |= ins->active_seg_prefix;
11556 switch (ins->active_seg_prefix)
11559 oappend_register (ins, att_names_seg[1]);
11562 oappend_register (ins, att_names_seg[3]);
11565 oappend_register (ins, att_names_seg[2]);
11568 oappend_register (ins, att_names_seg[0]);
11571 oappend_register (ins, att_names_seg[4]);
11574 oappend_register (ins, att_names_seg[5]);
11579 oappend_char (ins, ':');
11583 print_operand_value (instr_info *ins, bfd_vma disp,
11588 if (ins->address_mode != mode_64bit)
11591 oappend_with_style (ins, tmp, style);
11597 oappend_immediate (instr_info *ins, bfd_vma imm)
11599 if (!ins->intel_syntax)
11600 oappend_char_with_style (ins, '$', dis_style_immediate);
11601 print_operand_value (ins, imm, dis_style_immediate);
11607 print_displacement (instr_info *ins, bfd_signed_vma val)
11613 oappend_char_with_style (ins, '-', dis_style_address_offset);
11619 switch (ins->address_mode)
11622 oappend_with_style (ins, "0x8000000000000000",
11626 oappend_with_style (ins, "0x80000000",
11630 oappend_with_style (ins, "0x8000",
11639 oappend_with_style (ins, tmp, dis_style_address_offset);
11643 intel_operand_size (instr_info *ins, int bytemode, int sizeflag)
11646 if (ins->vex.b && ins->evex_type == evex_default)
11648 if (!ins->vex.no_broadcast)
11653 if (ins->vex.w)
11654 oappend (ins, "QWORD BCST ");
11656 oappend (ins, "DWORD BCST ");
11661 oappend (ins, "WORD BCST ");
11664 ins->vex.no_broadcast = true;
11674 oappend (ins, "BYTE PTR ");
11679 oappend (ins, "WORD PTR ");
11682 if (ins->address_mode == mode_64bit && ins->isa64 == intel64)
11684 oappend (ins, "QWORD PTR ");
11689 if (ins->address_mode == mode_64bit && ((sizeflag & DFLAG)
11690 || (ins->rex & REX_W)))
11692 oappend (ins, "QWORD PTR ");
11700 if (ins->rex & REX_W)
11701 oappend (ins, "QWORD PTR ");
11703 oappend (ins, "DWORD PTR ");
11707 oappend (ins, "DWORD PTR ");
11709 oappend (ins, "WORD PTR ");
11710 ins->used_prefixes |= (ins->prefixes & PREFIX_DATA);
11714 if ((ins->rex & REX_W) || (sizeflag & DFLAG))
11715 *ins->obufp++ = 'D';
11716 oappend (ins, "WORD PTR ");
11717 if (!(ins->rex & REX_W))
11718 ins->used_prefixes |= (ins->prefixes & PREFIX_DATA);
11722 oappend (ins, "QWORD PTR ");
11724 oappend (ins, "DWORD PTR ");
11725 ins->used_prefixes |= (ins->prefixes & PREFIX_DATA);
11728 if (!(sizeflag & DFLAG) && ins->isa64 == intel64)
11729 oappend (ins, "WORD PTR ");
11731 oappend (ins, "DWORD PTR ");
11732 ins->used_prefixes |= (ins->prefixes & PREFIX_DATA);
11736 oappend (ins, "DWORD PTR ");
11740 oappend (ins, "QWORD PTR ");
11743 if (ins->address_mode == mode_64bit)
11744 oappend (ins, "QWORD PTR ");
11746 oappend (ins, "DWORD PTR ");
11750 oappend (ins, "FWORD PTR ");
11752 oappend (ins, "DWORD PTR ");
11753 ins->used_prefixes |= (ins->prefixes & PREFIX_DATA);
11756 oappend (ins, "TBYTE PTR ");
11764 if (ins->need_vex)
11766 switch (ins->vex.length)
11769 oappend (ins, "XMMWORD PTR ");
11772 oappend (ins, "YMMWORD PTR ");
11775 oappend (ins, "ZMMWORD PTR ");
11782 oappend (ins, "XMMWORD PTR ");
11785 oappend (ins, "XMMWORD PTR ");
11788 oappend (ins, "YMMWORD PTR ");
11793 switch (ins->vex.length)
11797 oappend (ins, "QWORD PTR ");
11800 oappend (ins, "XMMWORD PTR ");
11803 oappend (ins, "YMMWORD PTR ");
11810 if (!ins->need_vex)
11813 switch (ins->vex.length)
11816 oappend (ins, "WORD PTR ");
11819 oappend (ins, "DWORD PTR ");
11822 oappend (ins, "QWORD PTR ");
11830 if (!ins->need_vex)
11833 switch (ins->vex.length)
11836 oappend (ins, "DWORD PTR ");
11839 oappend (ins, "QWORD PTR ");
11842 oappend (ins, "XMMWORD PTR ");
11849 if (!ins->need_vex)
11852 switch (ins->vex.length)
11855 oappend (ins, "QWORD PTR ");
11858 oappend (ins, "YMMWORD PTR ");
11861 oappend (ins, "ZMMWORD PTR ");
11868 oappend (ins, "OWORD PTR ");
11872 if (!ins->need_vex)
11874 if (ins->vex.w)
11875 oappend (ins, "QWORD PTR ");
11877 oappend (ins, "DWORD PTR ");
11880 if (!ins->need_vex || ins->vex.length != 128)
11882 if (ins->vex.w)
11883 oappend (ins, "DWORD PTR ");
11885 oappend (ins, "BYTE PTR ");
11888 if (!ins->need_vex)
11890 if (ins->vex.w)
11891 oappend (ins, "QWORD PTR ");
11893 oappend (ins, "WORD PTR ");
11903 print_register (instr_info *ins, unsigned int reg, unsigned int rexmask,
11910 if (bytemode != mask_mode && ins->vex.mask_register_specifier)
11911 ins->illegal_masking = true;
11914 if (ins->rex & rexmask)
11916 if (ins->rex2 & rexmask)
11925 if (ins->rex || ins->rex2)
11943 names = ins->address_mode == mode_64bit ? att_names64 : att_names32;
11949 oappend (ins, "(bad)");
11955 if (ins->address_mode == mode_64bit && ins->isa64 == intel64)
11962 if (ins->address_mode == mode_64bit && ((sizeflag & DFLAG)
11963 || (ins->rex & REX_W)))
11974 if (ins->rex & REX_W)
11984 ins->used_prefixes |= (ins->prefixes & PREFIX_DATA);
11988 if (!(sizeflag & DFLAG) && ins->isa64 == intel64)
11992 ins->used_prefixes |= (ins->prefixes & PREFIX_DATA);
11995 names = (ins->address_mode == mode_64bit
11997 if (!(ins->prefixes & PREFIX_ADDR))
11998 names = (ins->address_mode == mode_16bit
12003 ins->all_prefixes[ins->last_addr_prefix] = 0;
12004 names = (ins->address_mode != mode_32bit
12006 ins->used_prefixes |= PREFIX_ADDR;
12013 oappend (ins, "(bad)");
12021 oappend (ins, INTERNAL_DISASSEMBLER_ERROR);
12024 oappend_register (ins, names[reg]);
12028 get8s (instr_info *ins, bfd_vma *res)
12030 if (!fetch_code (ins->info, ins->codep + 1))
12032 *res = ((bfd_vma) *ins->codep++ ^ 0x80) - 0x80;
12037 get16 (instr_info *ins, bfd_vma *res)
12039 if (!fetch_code (ins->info, ins->codep + 2))
12041 *res = *ins->codep++;
12042 *res |= (bfd_vma) *ins->codep++ << 8;
12047 get16s (instr_info *ins, bfd_vma *res)
12049 if (!get16 (ins, res))
12056 get32 (instr_info *ins, bfd_vma *res)
12058 if (!fetch_code (ins->info, ins->codep + 4))
12060 *res = *ins->codep++;
12061 *res |= (bfd_vma) *ins->codep++ << 8;
12062 *res |= (bfd_vma) *ins->codep++ << 16;
12063 *res |= (bfd_vma) *ins->codep++ << 24;
12068 get32s (instr_info *ins, bfd_vma *res)
12070 if (!get32 (ins, res))
12079 get64 (instr_info *ins, uint64_t *res)
12084 if (!fetch_code (ins->info, ins->codep + 8))
12086 a = *ins->codep++;
12087 a |= (unsigned int) *ins->codep++ << 8;
12088 a |= (unsigned int) *ins->codep++ << 16;
12089 a |= (unsigned int) *ins->codep++ << 24;
12090 b = *ins->codep++;
12091 b |= (unsigned int) *ins->codep++ << 8;
12092 b |= (unsigned int) *ins->codep++ << 16;
12093 b |= (unsigned int) *ins->codep++ << 24;
12099 set_op (instr_info *ins, bfd_vma op, bool riprel)
12101 ins->op_index[ins->op_ad] = ins->op_ad;
12102 if (ins->address_mode == mode_64bit)
12103 ins->op_address[ins->op_ad] = op;
12105 ins->op_address[ins->op_ad] = op & 0xffffffff;
12106 ins->op_riprel[ins->op_ad] = riprel;
12110 BadOp (instr_info *ins)
12113 struct dis_private *priv = ins->info->private_data;
12115 ins->codep = priv->the_buffer + ins->nr_prefixes + ins->need_vex + 1;
12116 ins->obufp = stpcpy (ins->obufp, "(bad)");
12121 OP_Skip_MODRM (instr_info *ins, int bytemode ATTRIBUTE_UNUSED,
12124 if (ins->modrm.mod != 3)
12125 return BadOp (ins);
12129 ins->codep++;
12130 ins->has_skipped_modrm = true;
12135 OP_E_memory (instr_info *ins, int bytemode, int sizeflag)
12137 int add = (ins->rex & REX_B) ? 8 : 0;
12141 add += (ins->rex2 & REX_B) ? 16 : 0;
12144 if (ins->vex.evex && ins->evex_type == evex_default)
12150 if (ins->vex.zeroing)
12151 ins->illegal_masking = true;
12165 if (ins->address_mode != mode_64bit)
12176 shift = ins->vex.w ? 3 : 2;
12181 if (ins->vex.b)
12183 shift = ins->vex.w ? 2 : 1;
12189 if (ins->vex.b)
12191 shift = ins->vex.w ? 3 : 2;
12201 switch (ins->vex.length)
12219 || (bytemode == ymmq_mode && ins->vex.length == 128))
12238 shift = ins->vex.w ? 1 : 0;
12248 if (ins->intel_syntax)
12249 intel_operand_size (ins, bytemode, sizeflag);
12250 append_seg (ins);
12252 if ((sizeflag & AFLAG) || ins->address_mode == mode_64bit)
12272 base = ins->modrm.rm;
12276 vindex = ins->sib.index;
12278 if (ins->rex & REX_X)
12284 if (!ins->need_vex)
12286 if (ins->vex.evex)
12289 if (ins->rex2 & REX_X)
12291 oappend (ins, "(bad)");
12295 if (!ins->vex.v)
12297 check_gather = ins->obufp == ins->op_out[1];
12300 switch (ins->vex.length)
12306 if (!ins->vex.w
12313 if (!ins->vex.w
12324 if (ins->rex2 & REX_X)
12328 indexes = ins->address_mode == mode_64bit && !addr32flag
12332 scale = ins->sib.scale;
12333 base = ins->sib.base;
12334 ins->codep++;
12343 oappend (ins, "(bad)");
12349 switch (ins->modrm.mod)
12355 if (ins->address_mode == mode_64bit && !ins->has_sib)
12357 if (!get32s (ins, &disp))
12361 oappend (ins, "(bad)");
12367 if (!get8s (ins, &disp))
12369 if (ins->vex.evex && shift > 0)
12373 if (!get32s (ins, &disp))
12380 if (ins->has_sib
12383 && ins->address_mode != mode_16bit)
12385 if (ins->address_mode == mode_64bit)
12406 || (ins->has_sib && (indexes || scale != 0)));
12408 if (!ins->intel_syntax)
12409 if (ins->modrm.mod != 0 || base == 5)
12412 print_displacement (ins, disp);
12414 print_operand_value (ins, disp, dis_style_address_offset);
12417 set_op (ins, disp, true);
12418 oappend_char (ins, '(');
12419 oappend_with_style (ins, !addr32flag ? "%rip" : "%eip",
12421 oappend_char (ins, ')');
12426 && (ins->address_mode != mode_64bit
12431 ins->used_prefixes |= PREFIX_ADDR;
12433 if (havedisp || (ins->intel_syntax && riprel))
12435 oappend_char (ins, ins->open_char);
12436 if (ins->intel_syntax && riprel)
12438 set_op (ins, disp, true);
12439 oappend_with_style (ins, !addr32flag ? "rip" : "eip",
12444 (ins,
12445 (ins->address_mode == mode_64bit && !addr32flag
12447 if (ins->has_sib)
12456 if (!ins->intel_syntax || havebase)
12457 oappend_char (ins, ins->separator_char);
12460 if (ins->address_mode == mode_64bit || vindex < 16)
12461 oappend_register (ins, indexes[vindex]);
12463 oappend (ins, "(bad)");
12466 oappend_register (ins,
12467 ins->address_mode == mode_64bit
12472 oappend_char (ins, ins->scale_char);
12473 oappend_char_with_style (ins, '0' + (1 << scale),
12477 if (ins->intel_syntax
12478 && (disp || ins->modrm.mod != 0 || base == 5))
12481 oappend_char (ins, '+');
12483 print_displacement (ins, disp);
12485 print_operand_value (ins, disp, dis_style_address_offset);
12488 oappend_char (ins, ins->close_char);
12493 int modrm_reg = ins->modrm.reg;
12495 if (ins->rex & REX_R)
12497 if (ins->rex2 & REX_R)
12500 oappend (ins, "/(bad)");
12503 else if (ins->intel_syntax)
12505 if (ins->modrm.mod != 0 || base == 5)
12507 if (!ins->active_seg_prefix)
12509 oappend_register (ins, att_names_seg[ds_reg - es_reg]);
12510 oappend (ins, ":");
12512 print_operand_value (ins, disp, dis_style_text);
12523 oappend (ins, "(bad)");
12531 ins->used_prefixes |= ins->prefixes & PREFIX_ADDR;
12532 switch (ins->modrm.mod)
12535 if (ins->modrm.rm == 6)
12538 if (!get16s (ins, &disp))
12543 if (!get8s (ins, &disp))
12545 if (ins->vex.evex && shift > 0)
12550 if (!ins->intel_syntax)
12551 if (ins->modrm.mod != 0 || ins->modrm.rm == 6)
12552 print_displacement (ins, disp);
12554 if (ins->modrm.mod != 0 || ins->modrm.rm != 6)
12556 oappend_char (ins, ins->open_char);
12557 oappend (ins, ins->intel_syntax ? intel_index16[ins->modrm.rm]
12558 : att_index16[ins->modrm.rm]);
12559 if (ins->intel_syntax
12560 && (disp || ins->modrm.mod != 0 || ins->modrm.rm == 6))
12563 oappend_char (ins, '+');
12564 print_displacement (ins, disp);
12567 oappend_char (ins, ins->close_char);
12569 else if (ins->intel_syntax)
12571 if (!ins->active_seg_prefix)
12573 oappend_register (ins, att_names_seg[ds_reg - es_reg]);
12574 oappend (ins, ":");
12576 print_operand_value (ins, disp & 0xffff, dis_style_text);
12579 if (ins->vex.b && ins->evex_type == evex_default)
12581 ins->evex_used |= EVEX_b_used;
12584 if (ins->obufp == ins->op_out[0])
12585 ins->vex.no_broadcast = true;
12587 if (!ins->vex.no_broadcast
12588 && (!ins->intel_syntax || !(ins->evex_used & EVEX_len_used)))
12592 switch (ins->vex.length)
12595 oappend (ins, "{1to8}");
12598 oappend (ins, "{1to16}");
12601 oappend (ins, "{1to32}");
12609 ins->vex.no_broadcast = true;
12610 else if (ins->vex.w
12614 switch (ins->vex.length)
12617 oappend (ins, "{1to2}");
12620 oappend (ins, "{1to4}");
12623 oappend (ins, "{1to8}");
12632 switch (ins->vex.length)
12635 oappend (ins, "{1to4}");
12638 oappend (ins, "{1to8}");
12641 oappend (ins, "{1to16}");
12648 ins->vex.no_broadcast = true;
12650 if (ins->vex.no_broadcast)
12651 oappend (ins, "{bad}");
12658 OP_E (instr_info *ins, int bytemode, int sizeflag)
12662 if (!ins->has_skipped_modrm)
12664 ins->codep++;
12665 ins->has_skipped_modrm = true;
12668 if (ins->modrm.mod == 3)
12674 swap_operand (ins);
12676 print_register (ins, ins->modrm.rm, REX_B, bytemode, sizeflag);
12683 if (ins->vex.mask_register_specifier)
12684 ins->illegal_masking = true;
12686 return OP_E_memory (ins, bytemode, sizeflag);
12690 OP_indirE (instr_info *ins, int bytemode, int sizeflag)
12692 if (ins->modrm.mod == 3 && bytemode == f_mode)
12694 return BadOp (ins);
12695 if (!ins->intel_syntax)
12696 oappend (ins, "*");
12697 return OP_E (ins, bytemode, sizeflag);
12701 OP_G (instr_info *ins, int bytemode, int sizeflag)
12703 print_register (ins, ins->modrm.reg, REX_R, bytemode, sizeflag);
12708 OP_REG (instr_info *ins, int code, int sizeflag)
12717 oappend_register (ins, att_names_seg[code - es_reg]);
12722 if (ins->rex & REX_B)
12724 if (ins->rex2 & REX_B)
12737 if (ins->rex)
12744 if (ins->address_mode == mode_64bit
12745 && ((sizeflag & DFLAG) || (ins->rex & REX_W)))
12755 if (ins->rex & REX_W)
12763 ins->used_prefixes |= (ins->prefixes & PREFIX_DATA);
12767 oappend (ins, INTERNAL_DISASSEMBLER_ERROR);
12770 oappend_register (ins, s);
12775 OP_IMREG (instr_info *ins, int code, int sizeflag)
12782 if (!ins->intel_syntax)
12784 oappend (ins, "(%dx)");
12794 if (ins->rex & REX_W)
12801 if ((ins->rex & REX_W) || (sizeflag & DFLAG))
12805 if (!(ins->rex & REX_W))
12806 ins->used_prefixes |= (ins->prefixes & PREFIX_DATA);
12809 oappend (ins, INTERNAL_DISASSEMBLER_ERROR);
12812 oappend_register (ins, s);
12817 OP_I (instr_info *ins, int bytemode, int sizeflag)
12824 if (!fetch_code (ins->info, ins->codep + 1))
12826 op = *ins->codep++;
12830 if (ins->rex & REX_W)
12832 if (!get32s (ins, &op))
12837 ins->used_prefixes |= (ins->prefixes & PREFIX_DATA);
12841 if (!get32 (ins, &op))
12848 if (!get16 (ins, &op))
12854 if (ins->intel_syntax)
12855 oappend_with_style (ins, "1", dis_style_immediate);
12857 oappend_with_style (ins, "$1", dis_style_immediate);
12860 oappend (ins, INTERNAL_DISASSEMBLER_ERROR);
12864 oappend_immediate (ins, op);
12869 OP_I64 (instr_info *ins, int bytemode, int sizeflag)
12873 if (bytemode != v_mode || ins->address_mode != mode_64bit
12874 || !(ins->rex & REX_W))
12875 return OP_I (ins, bytemode, sizeflag);
12879 if (!get64 (ins, &op))
12882 oappend_immediate (ins, op);
12887 OP_sI (instr_info *ins, int bytemode, int sizeflag)
12895 if (!get8s (ins, &op))
12899 if (ins->address_mode != mode_64bit
12900 || !((sizeflag & DFLAG) || (ins->rex & REX_W)))
12903 if ((sizeflag & DFLAG) || (ins->rex & REX_W))
12911 if (!(ins->rex & REX_W))
12922 if (!(sizeflag & DFLAG) && !(ins->rex & REX_W))
12924 if (!get16 (ins, &op))
12927 else if (!get32s (ins, &op))
12931 oappend (ins, INTERNAL_DISASSEMBLER_ERROR);
12935 oappend_immediate (ins, op);
12940 OP_J (instr_info *ins, int bytemode, int sizeflag)
12949 if (!get8s (ins, &disp))
12955 || (ins->address_mode == mode_64bit
12956 ins->isa64 == intel64 && bytemode != dqw_mode)
12957 || (ins->rex & REX_W))))
12959 if (!get32s (ins, &disp))
12964 if (!get16s (ins, &disp))
12971 if ((ins->prefixes & PREFIX_DATA) == 0)
12972 segment = ((ins->start_pc + (ins->codep - ins->start_codep))
12975 if (ins->address_mode != mode_64bit
12976 || (ins->isa64 != intel64 && !(ins->rex & REX_W)))
12977 ins->used_prefixes |= (ins->prefixes & PREFIX_DATA);
12980 oappend (ins, INTERNAL_DISASSEMBLER_ERROR);
12983 disp = ((ins->start_pc + (ins->codep - ins->start_codep) + disp) & mask)
12985 set_op (ins, disp, false);
12986 print_operand_value (ins, disp, dis_style_text);
12991 OP_SEG (instr_info *ins, int bytemode, int sizeflag)
12995 oappend_register (ins, att_names_seg[ins->modrm.reg]);
12998 return OP_E (ins, ins->modrm.mod == 3 ? bytemode : w_mode, sizeflag);
13002 OP_DIR (instr_info *ins, int dummy ATTRIBUTE_UNUSED, int sizeflag)
13010 if (!get32 (ins, &offset))
13013 else if (!get16 (ins, &offset))
13015 if (!get16 (ins, &seg))
13017 ins->used_prefixes |= (ins->prefixes & PREFIX_DATA);
13020 ins->intel_syntax ? "0x%x:0x%x" : "$0x%x,$0x%x",
13024 oappend (ins, scratch);
13029 OP_OFF (instr_info *ins, int bytemode, int sizeflag)
13033 if (ins->intel_syntax && (sizeflag & SUFFIX_ALWAYS))
13034 intel_operand_size (ins, bytemode, sizeflag);
13035 append_seg (ins);
13037 if ((sizeflag & AFLAG) || ins->address_mode == mode_64bit)
13039 if (!get32 (ins, &off))
13044 if (!get16 (ins, &off))
13048 if (ins->intel_syntax)
13050 if (!ins->active_seg_prefix)
13052 oappend_register (ins, att_names_seg[ds_reg - es_reg]);
13053 oappend (ins, ":");
13056 print_operand_value (ins, off, dis_style_address_offset);
13061 OP_OFF64 (instr_info *ins, int bytemode, int sizeflag)
13065 if (ins->address_mode != mode_64bit
13066 || (ins->prefixes & PREFIX_ADDR))
13067 return OP_OFF (ins, bytemode, sizeflag);
13069 if (ins->intel_syntax && (sizeflag & SUFFIX_ALWAYS))
13070 intel_operand_size (ins, bytemode, sizeflag);
13071 append_seg (ins);
13073 if (!get64 (ins, &off))
13076 if (ins->intel_syntax)
13078 if (!ins->active_seg_prefix)
13080 oappend_register (ins, att_names_seg[ds_reg - es_reg]);
13081 oappend (ins, ":");
13084 print_operand_value (ins, off, dis_style_address_offset);
13089 ptr_reg (instr_info *ins, int code, int sizeflag)
13093 *ins->obufp++ = ins->open_char;
13094 ins->used_prefixes |= (ins->prefixes & PREFIX_ADDR);
13095 if (ins->address_mode == mode_64bit)
13106 oappend_register (ins, s);
13107 oappend_char (ins, ins->close_char);
13111 OP_ESreg (instr_info *ins, int code, int sizeflag)
13113 if (ins->intel_syntax)
13115 switch (ins->codep[-1])
13118 intel_operand_size (ins, z_mode, sizeflag);
13124 intel_operand_size (ins, v_mode, sizeflag);
13127 intel_operand_size (ins, b_mode, sizeflag);
13130 if (ins->address_mode != mode_64bit)
13132 oappend_register (ins, att_names_seg[0]);
13133 oappend_char (ins, ':');
13135 ptr_reg (ins, code, sizeflag);
13140 OP_DSreg (instr_info *ins, int code, int sizeflag)
13142 if (ins->intel_syntax)
13144 switch (ins->codep[-1])
13149 intel_operand_size (ins, z_mode, sizeflag);
13154 intel_operand_size (ins, v_mode, sizeflag);
13157 intel_operand_size (ins, b_mode, sizeflag);
13160 /* Outside of 64-bit mode set ins->active_seg_prefix to PREFIX_DS if it
13162 if (ins->address_mode != mode_64bit && !ins->active_seg_prefix)
13163 ins->active_seg_prefix = PREFIX_DS;
13164 append_seg (ins);
13165 ptr_reg (ins, code, sizeflag);
13170 OP_C (instr_info *ins, int dummy ATTRIBUTE_UNUSED,
13176 if (ins->rex & REX_R)
13181 else if (ins->address_mode != mode_64bit && (ins->prefixes & PREFIX_LOCK))
13183 ins->all_prefixes[ins->last_lock_prefix] = 0;
13184 ins->used_prefixes |= PREFIX_LOCK;
13190 ins->modrm.reg + add);
13193 oappend_register (ins, scratch);
13198 OP_D (instr_info *ins, int dummy ATTRIBUTE_UNUSED,
13205 if (ins->rex & REX_R)
13210 ins->intel_syntax ? "dr%d" : "%%db%d",
13211 ins->modrm.reg + add);
13214 oappend (ins, scratch);
13219 OP_T (instr_info *ins, int dummy ATTRIBUTE_UNUSED,
13225 res = snprintf (scratch, ARRAY_SIZE (scratch), "%%tr%d", ins->modrm.reg);
13228 oappend_register (ins, scratch);
13233 OP_MMX (instr_info *ins, int bytemode ATTRIBUTE_UNUSED,
13236 int reg = ins->modrm.reg;
13239 ins->used_prefixes |= (ins->prefixes & PREFIX_DATA);
13240 if (ins->prefixes & PREFIX_DATA)
13244 if (ins->rex & REX_R)
13249 oappend_register (ins, names[reg]);
13254 print_vector_reg (instr_info *ins, unsigned int reg, int bytemode)
13262 switch (ins->vex.length)
13271 ins->evex_used |= EVEX_len_used;
13283 oappend (ins, "(bad)");
13288 else if (ins->need_vex
13300 ins->evex_used |= EVEX_len_used;
13301 switch (ins->vex.length)
13307 if (ins->vex.w
13314 if (ins->vex.w
13326 oappend_register (ins, names[reg]);
13330 OP_XMM (instr_info *ins, int bytemode, int sizeflag ATTRIBUTE_UNUSED)
13332 unsigned int reg = ins->modrm.reg;
13335 if (ins->rex & REX_R)
13337 if (ins->vex.evex)
13339 if (ins->rex2 & REX_R)
13344 ins->modrm.reg = reg;
13346 ins->vex.no_broadcast = true;
13348 print_vector_reg (ins, reg, bytemode);
13353 OP_EM (instr_info *ins, int bytemode, int sizeflag)
13358 if (ins->modrm.mod != 3)
13360 if (ins->intel_syntax
13363 bytemode = (ins->prefixes & PREFIX_DATA) ? x_mode : q_mode;
13364 ins->used_prefixes |= (ins->prefixes & PREFIX_DATA);
13366 return OP_E (ins, bytemode, sizeflag);
13370 swap_operand (ins);
13374 ins->codep++;
13375 ins->used_prefixes |= (ins->prefixes & PREFIX_DATA);
13376 reg = ins->modrm.rm;
13377 if (ins->prefixes & PREFIX_DATA)
13381 if (ins->rex & REX_B)
13386 oappend_register (ins, names[reg]);
13396 OP_EMC (instr_info *ins, int bytemode, int sizeflag)
13398 if (ins->modrm.mod != 3)
13400 if (ins->intel_syntax && bytemode == v_mode)
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);
13410 ins->codep++;
13411 ins->used_prefixes |= (ins->prefixes & PREFIX_DATA);
13412 oappend_register (ins, att_names_mm[ins->modrm.rm]);
13417 OP_MXC (instr_info *ins, int bytemode ATTRIBUTE_UNUSED,
13420 ins->used_prefixes |= (ins->prefixes & PREFIX_DATA);
13421 oappend_register (ins, att_names_mm[ins->modrm.reg]);
13426 OP_EX (instr_info *ins, int bytemode, int sizeflag)
13432 ins->codep++;
13435 bytemode = ins->vex.w ? q_mode : d_mode;
13437 if (ins->modrm.mod != 3)
13438 return OP_E_memory (ins, bytemode, sizeflag);
13440 reg = ins->modrm.rm;
13442 if (ins->rex & REX_B)
13444 if (ins->vex.evex)
13447 if ((ins->rex & REX_X))
13449 ins->rex2_used &= ~REX_B;
13451 else if (ins->rex2 & REX_B)
13459 swap_operand (ins);
13462 ins->modrm.rm = reg;
13464 print_vector_reg (ins, reg, bytemode);
13469 OP_R (instr_info *ins, int bytemode, int sizeflag)
13471 if (ins->modrm.mod != 3)
13472 return BadOp (ins);
13480 return OP_E (ins, bytemode, sizeflag);
13482 return OP_EM (ins, x_mode, sizeflag);
13484 if (ins->vex.length <= 128)
13486 return BadOp (ins);
13489 return OP_EX (ins, bytemode, sizeflag);
13493 OP_M (instr_info *ins, int bytemode, int sizeflag)
13497 ins->codep++;
13499 if (ins->modrm.mod == 3)
13501 return BadOp (ins);
13504 ins->vex.no_broadcast = true;
13506 return OP_E_memory (ins, bytemode, sizeflag);
13510 OP_0f07 (instr_info *ins, int bytemode, int sizeflag)
13512 if (ins->modrm.mod != 3 || ins->modrm.rm != 0)
13513 return BadOp (ins);
13514 return OP_E (ins, bytemode, sizeflag);
13520 MONTMUL_Fixup (instr_info *ins, int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
13522 if (ins->modrm.mod != 3 || ins->modrm.rm != 0)
13523 return BadOp (ins);
13526 if (ins->prefixes & PREFIX_REPZ)
13527 ins->all_prefixes[ins->last_repz_prefix] = 0xf3;
13531 ins->codep++;
13539 NOP_Fixup (instr_info *ins, int opnd, int sizeflag)
13541 if ((ins->prefixes & PREFIX_DATA) == 0 && (ins->rex & REX_B) == 0)
13543 ins->mnemonicendp = stpcpy (ins->obuf, "nop");
13547 return OP_REG (ins, eAX_reg, sizeflag);
13548 return OP_IMREG (ins, eAX_reg, sizeflag);
13619 OP_3DNowSuffix (instr_info *ins, int bytemode ATTRIBUTE_UNUSED,
13624 if (!fetch_code (ins->info, ins->codep + 1))
13629 ins->obufp = ins->mnemonicendp;
13630 mnemonic = Suffix3DNow[*ins->codep++];
13632 ins->obufp = stpcpy (ins->obufp, mnemonic);
13635 /* Since a variable sized ins->modrm/ins->sib chunk is between the start
13637 all the ins->modrm processing first, and don't know until now that
13639 ins->op_out[0][0] = '\0';
13640 ins->op_out[1][0] = '\0';
13641 BadOp (ins);
13643 ins->mnemonicendp = ins->obufp;
13688 CMP_Fixup (instr_info *ins, int bytemode ATTRIBUTE_UNUSED,
13693 if (!fetch_code (ins->info, ins->codep + 1))
13695 cmp_type = *ins->codep++;
13699 char *p = ins->mnemonicendp - 2;
13704 ins->mnemonicendp += simd_cmp_op[cmp_type].len;
13706 else if (ins->need_vex
13710 char *p = ins->mnemonicendp - 2;
13716 ins->mnemonicendp += vex_cmp_op[cmp_type].len;
13721 oappend_immediate (ins, cmp_type);
13727 OP_Mwait (instr_info *ins, int bytemode, int sizeflag ATTRIBUTE_UNUSED)
13730 if (!ins->intel_syntax)
13732 strcpy (ins->op_out[0], att_names32[0] + ins->intel_syntax);
13733 strcpy (ins->op_out[1], att_names32[1] + ins->intel_syntax);
13735 strcpy (ins->op_out[2], att_names32[3] + ins->intel_syntax);
13736 ins->two_source_ops = true;
13740 ins->codep++;
13745 OP_Monitor (instr_info *ins, int bytemode ATTRIBUTE_UNUSED,
13749 if (!ins->intel_syntax)
13751 const char (*names)[8] = (ins->address_mode == mode_64bit
13754 if (ins->prefixes & PREFIX_ADDR)
13757 ins->all_prefixes[ins->last_addr_prefix] = 0;
13758 names = (ins->address_mode != mode_32bit
13760 ins->used_prefixes |= PREFIX_ADDR;
13762 else if (ins->address_mode == mode_16bit)
13764 strcpy (ins->op_out[0], names[0] + ins->intel_syntax);
13765 strcpy (ins->op_out[1], att_names32[1] + ins->intel_syntax);
13766 strcpy (ins->op_out[2], att_names32[2] + ins->intel_syntax);
13767 ins->two_source_ops = true;
13771 ins->codep++;
13776 REP_Fixup (instr_info *ins, int bytemode, int sizeflag)
13778 /* The 0xf3 prefix should be displayed as "rep" for ins, outs, movs,
13780 if (ins->prefixes & PREFIX_REPZ)
13781 ins->all_prefixes[ins->last_repz_prefix] = REP_PREFIX;
13788 return OP_IMREG (ins, bytemode, sizeflag);
13790 return OP_ESreg (ins, bytemode, sizeflag);
13792 return OP_DSreg (ins, bytemode, sizeflag);
13801 SEP_Fixup (instr_info *ins, int bytemode ATTRIBUTE_UNUSED,
13804 if (ins->isa64 != amd64)
13807 ins->obufp = ins->obuf;
13808 BadOp (ins);
13809 ins->mnemonicendp = ins->obufp;
13810 ++ins->codep;
13818 BND_Fixup (instr_info *ins, int bytemode ATTRIBUTE_UNUSED,
13821 if (ins->prefixes & PREFIX_REPNZ)
13822 ins->all_prefixes[ins->last_repnz_prefix] = BND_PREFIX;
13830 NOTRACK_Fixup (instr_info *ins, int bytemode ATTRIBUTE_UNUSED,
13835 if ((ins->prefixes & PREFIX_DS) != 0
13836 && (ins->address_mode != mode_64bit || ins->last_data_prefix < 0))
13840 ins->active_seg_prefix = 0;
13841 ins->all_prefixes[ins->last_seg_prefix] = NOTRACK_PREFIX;
13846 /* Similar to OP_E. But the 0xf2/0xf3 ins->prefixes should be displayed as
13851 HLE_Fixup1 (instr_info *ins, int bytemode, int sizeflag)
13853 if (ins->modrm.mod != 3
13854 && (ins->prefixes & PREFIX_LOCK) != 0)
13856 if (ins->prefixes & PREFIX_REPZ)
13857 ins->all_prefixes[ins->last_repz_prefix] = XRELEASE_PREFIX;
13858 if (ins->prefixes & PREFIX_REPNZ)
13859 ins->all_prefixes[ins->last_repnz_prefix] = XACQUIRE_PREFIX;
13862 return OP_E (ins, bytemode, sizeflag);
13865 /* Similar to OP_E. But the 0xf2/0xf3 ins->prefixes should be displayed as
13870 HLE_Fixup2 (instr_info *ins, int bytemode, int sizeflag)
13872 if (ins->modrm.mod != 3)
13874 if (ins->prefixes & PREFIX_REPZ)
13875 ins->all_prefixes[ins->last_repz_prefix] = XRELEASE_PREFIX;
13876 if (ins->prefixes & PREFIX_REPNZ)
13877 ins->all_prefixes[ins->last_repnz_prefix] = XACQUIRE_PREFIX;
13880 return OP_E (ins, bytemode, sizeflag);
13887 HLE_Fixup3 (instr_info *ins, int bytemode, int sizeflag)
13889 if (ins->modrm.mod != 3
13890 && ins->last_repz_prefix > ins->last_repnz_prefix
13891 && (ins->prefixes & PREFIX_REPZ) != 0)
13892 ins->all_prefixes[ins->last_repz_prefix] = XRELEASE_PREFIX;
13894 return OP_E (ins, bytemode, sizeflag);
13898 CMPXCHG8B_Fixup (instr_info *ins, int bytemode, int sizeflag)
13901 if (ins->rex & REX_W)
13904 char *p = ins->mnemonicendp - 2;
13905 ins->mnemonicendp = stpcpy (p, "16b");
13908 else if ((ins->prefixes & PREFIX_LOCK) != 0)
13910 if (ins->prefixes & PREFIX_REPZ)
13911 ins->all_prefixes[ins->last_repz_prefix] = XRELEASE_PREFIX;
13912 if (ins->prefixes & PREFIX_REPNZ)
13913 ins->all_prefixes[ins->last_repnz_prefix] = XACQUIRE_PREFIX;
13916 return OP_M (ins, bytemode, sizeflag);
13920 XMM_Fixup (instr_info *ins, int reg, int sizeflag ATTRIBUTE_UNUSED)
13924 if (ins->need_vex)
13926 switch (ins->vex.length)
13937 oappend_register (ins, names[reg]);
13942 FXSAVE_Fixup (instr_info *ins, int bytemode, int sizeflag)
13946 if (ins->rex & REX_W)
13948 char *p = ins->mnemonicendp;
13952 ins->mnemonicendp = p;
13954 return OP_M (ins, bytemode, sizeflag);
13961 OP_VEX (instr_info *ins, int bytemode, int sizeflag ATTRIBUTE_UNUSED)
13966 if (!ins->need_vex)
13969 if (ins->evex_type == evex_from_legacy)
13971 ins->evex_used |= EVEX_b_used;
13972 if (!ins->vex.nd)
13976 reg = ins->vex.register_specifier;
13977 ins->vex.register_specifier = 0;
13978 if (ins->address_mode != mode_64bit)
13980 if (ins->vex.evex && !ins->vex.v)
13982 oappend (ins, "(bad)");
13988 else if (ins->vex.evex && !ins->vex.v)
13994 oappend_register (ins, att_names_xmm[reg]);
14000 if (ins->obufp != ins->op_out[2])
14002 if (ins->vex.length == 128
14004 && !ins->vex.w))
14005 oappend_register (ins, att_names_xmm[reg]);
14007 oappend_register (ins, att_names_ymm[reg]);
14010 modrm_reg = ins->modrm.reg;
14011 if (ins->rex & REX_R)
14014 if (ins->has_sib && ins->modrm.rm == 4)
14016 sib_index = ins->sib.index;
14017 if (ins->rex & REX_X)
14022 strcpy (ins->obufp, "/(bad)");
14024 strcat (ins->op_out[0], "/(bad)");
14026 strcat (ins->op_out[1], "/(bad)");
14033 oappend (ins, "(bad)");
14037 if (ins->obufp != ins->op_out[2])
14039 oappend_register (ins, att_names_tmm[reg]);
14040 if (reg == ins->modrm.reg || reg == ins->modrm.rm)
14041 strcpy (ins->obufp, "/(bad)");
14044 if (ins->modrm.reg == ins->modrm.rm || ins->modrm.reg == reg
14045 || ins->modrm.rm == reg)
14047 if (ins->modrm.reg <= 8
14048 && (ins->modrm.reg == ins->modrm.rm || ins->modrm.reg == reg))
14049 strcat (ins->op_out[0], "/(bad)");
14050 if (ins->modrm.rm <= 8
14051 && (ins->modrm.rm == ins->modrm.reg || ins->modrm.rm == reg))
14052 strcat (ins->op_out[1], "/(bad)");
14059 if (ins->rex & REX_W)
14060 oappend_register (ins, att_names64[reg]);
14063 oappend_register (ins, att_names16[reg]);
14065 oappend_register (ins, att_names32[reg]);
14069 oappend_register (ins, att_names8rex[reg]);
14073 oappend_register (ins, att_names64[reg]);
14077 switch (ins->vex.length)
14084 ins->evex_used |= EVEX_len_used;
14090 oappend (ins, "(bad)");
14105 ins->evex_used |= EVEX_len_used;
14117 oappend (ins, "(bad)");
14123 ins->evex_used |= EVEX_len_used;
14129 oappend_register (ins, names[reg]);
14134 OP_VexR (instr_info *ins, int bytemode, int sizeflag)
14136 if (ins->modrm.mod == 3)
14137 return OP_VEX (ins, bytemode, sizeflag);
14142 OP_VexW (instr_info *ins, int bytemode, int sizeflag)
14144 OP_VEX (ins, bytemode, sizeflag);
14146 if (ins->vex.w)
14149 char *tmp = ins->op_out[2];
14151 ins->op_out[2] = ins->op_out[1];
14152 ins->op_out[1] = tmp;
14158 OP_REG_VexI4 (instr_info *ins, int bytemode, int sizeflag ATTRIBUTE_UNUSED)
14163 if (!fetch_code (ins->info, ins->codep + 1))
14165 reg = *ins->codep++;
14171 if (ins->address_mode != mode_64bit)
14174 if (bytemode == x_mode && ins->vex.length == 256)
14177 oappend_register (ins, names[reg]);
14179 if (ins->vex.w)
14182 char *tmp = ins->op_out[3];
14184 ins->op_out[3] = ins->op_out[2];
14185 ins->op_out[2] = tmp;
14191 OP_VexI4 (instr_info *ins, int bytemode ATTRIBUTE_UNUSED,
14194 oappend_immediate (ins, ins->codep[-1] & 0xf);
14199 VPCMP_Fixup (instr_info *ins, int bytemode ATTRIBUTE_UNUSED,
14204 if (!ins->vex.evex)
14207 if (!fetch_code (ins->info, ins->codep + 1))
14209 cmp_type = *ins->codep++;
14217 char *p = ins->mnemonicendp - 2;
14234 ins->mnemonicendp += simd_cmp_op[cmp_type].len;
14239 oappend_immediate (ins, cmp_type);
14257 VPCOM_Fixup (instr_info *ins, int bytemode ATTRIBUTE_UNUSED,
14262 if (!fetch_code (ins->info, ins->codep + 1))
14264 cmp_type = *ins->codep++;
14268 char *p = ins->mnemonicendp - 2;
14285 ins->mnemonicendp += xop_cmp_op[cmp_type].len;
14290 oappend_immediate (ins, cmp_type);
14304 PCLMUL_Fixup (instr_info *ins, int bytemode ATTRIBUTE_UNUSED,
14309 if (!fetch_code (ins->info, ins->codep + 1))
14311 pclmul_type = *ins->codep++;
14326 char *p = ins->mnemonicendp - 3;
14332 ins->mnemonicendp += pclmul_op[pclmul_type].len;
14337 oappend_immediate (ins, pclmul_type);
14343 MOVSXD_Fixup (instr_info *ins, int bytemode, int sizeflag)
14346 char *p = ins->mnemonicendp;
14351 if (!ins->intel_syntax)
14354 if (ins->rex & REX_W)
14366 oappend (ins, INTERNAL_DISASSEMBLER_ERROR);
14370 ins->mnemonicendp = p;
14372 return OP_E (ins, bytemode, sizeflag);
14376 DistinctDest_Fixup (instr_info *ins, int bytemode, int sizeflag)
14378 unsigned int reg = ins->vex.register_specifier;
14379 unsigned int modrm_reg = ins->modrm.reg;
14380 unsigned int modrm_rm = ins->modrm.rm;
14383 if (ins->rex & REX_R)
14385 if (ins->rex2 & REX_R)
14389 if (ins->address_mode != mode_64bit)
14391 else if (ins->vex.evex && !ins->vex.v)
14395 if (ins->modrm.mod == 3)
14397 if (ins->rex & REX_B)
14399 if (ins->rex & REX_X)
14406 || (ins->modrm.mod == 3
14409 oappend (ins, "(bad)");
14412 return OP_XMM (ins, bytemode, sizeflag);
14416 OP_Rounding (instr_info *ins, int bytemode, int sizeflag ATTRIBUTE_UNUSED)
14418 if (ins->modrm.mod != 3 || !ins->vex.b)
14421 ins->evex_used |= EVEX_b_used;
14425 if (ins->address_mode != mode_64bit || !ins->vex.w)
14429 oappend (ins, names_rounding[ins->vex.ll]);
14432 oappend (ins, "{");
14437 oappend (ins, "sae}");
14442 PREFETCHI_Fixup (instr_info *ins, int bytemode, int sizeflag)
14444 if (ins->modrm.mod != 0 || ins->modrm.rm != 5)
14446 if (ins->intel_syntax)
14448 ins->mnemonicendp = stpcpy (ins->obuf, "nop ");
14453 if (ins->rex & REX_W)
14454 ins->mnemonicendp = stpcpy (ins->obuf, "nopq ");
14458 ins->mnemonicendp = stpcpy (ins->obuf, "nopl ");
14460 ins->mnemonicendp = stpcpy (ins->obuf, "nopw ");
14461 ins->used_prefixes |= (ins->prefixes & PREFIX_DATA);
14467 return OP_M (ins, bytemode, sizeflag);
14471 PUSH2_POP2_Fixup (instr_info *ins, int bytemode, int sizeflag)
14473 if (ins->modrm.mod != 3)
14476 unsigned int vvvv_reg = ins->vex.register_specifier
14477 | (!ins->vex.v << 4);
14478 unsigned int rm_reg = ins->modrm.rm + (ins->rex & REX_B ? 8 : 0)
14479 + (ins->rex2 & REX_B ? 16 : 0);
14482 if (!ins->vex.nd || vvvv_reg == 0x4 || rm_reg == 0x4
14483 || (!ins->modrm.reg
14486 oappend (ins, "(bad)");
14490 return OP_VEX (ins, bytemode, sizeflag);
14494 JMPABS_Fixup (instr_info *ins, int bytemode, int sizeflag)
14496 if (ins->last_rex2_prefix >= 0)
14500 if ((ins->prefixes & (PREFIX_OPCODE | PREFIX_ADDR | PREFIX_LOCK)) != 0x0
14501 || (ins->rex & REX_W) != 0x0)
14503 oappend (ins, "(bad)");
14510 if (!get64 (ins, &op))
14513 ins->mnemonicendp = stpcpy (ins->obuf, "jmpabs");
14514 ins->rex2 |= REX2_SPECIAL;
14515 oappend_immediate (ins, op);
14521 return OP_IMREG (ins, bytemode, sizeflag);
14522 return OP_OFF64 (ins, bytemode, sizeflag);
14526 CFCMOV_Fixup (instr_info *ins, int opnd, int sizeflag)
14530 bool dstmem = !ins->vex.nd && ins->vex.nf;
14535 return OP_E (ins, v_swap_mode, sizeflag);
14536 return OP_G (ins, v_mode, sizeflag);
14540 ins->vex.nf = false;
14541 ins->vex.mask_register_specifier = 0;
14544 return OP_G (ins, v_mode, sizeflag);
14545 return OP_E (ins, v_mode, sizeflag);
Indexes created Sat Apr 04 00:22:49 UTC 2026