From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mail-pf1-x430.google.com (mail-pf1-x430.google.com [IPv6:2607:f8b0:4864:20::430]) by sourceware.org (Postfix) with ESMTPS id A58DF3858D28 for ; Fri, 29 Apr 2022 18:58:20 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.1 sourceware.org A58DF3858D28 Received: by mail-pf1-x430.google.com with SMTP id a11so7671973pff.1 for ; Fri, 29 Apr 2022 11:58:20 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:mime-version:references:in-reply-to:from:date :message-id:subject:to:cc; bh=muSf0PZsP5m7Oqf6FEorSJ0FXrwp5an6EKuVZCh4dRk=; b=Jk0GGHOKUFe3XYQcdRSwI/JJoU2FCpP0GTz95vWd1NeQ1dIbo01ggu6IjEQfvhabUD o5D6o+ipbTGpBtv2ingcIsZ/SYWx3+1ydRL0tZhIshROr9Do8hbRcqEfJStn96olcsWU brqf1uAaUdQ0ajbMByHvUxHdZMGm2nDsSU/PjOuJSzsUI2FC2atgU2piO60V6fY5zbL6 vgPaqmSgWRPDekUP6DOjmjV7wmv4WNwkPc43pTHqmx9IekAv3bCcO5SCSLPeCsvAkEFD xrJOmV2DYEj5wf1AinctS5BKXcdNUF61V7MKLEz3DQulOO0Axg5bFJc/4mi5gnG/jXk+ 9psA== X-Gm-Message-State: AOAM532T0DRW0pwy2PtoNZn4gASH5XNu7P/ri3bdF+u8q0AfcogkLqVI o+tgRO/1kffmnodVmioLxxBsI/TyQuUSatF7P5g= X-Google-Smtp-Source: ABdhPJyt4waVivTB9sROoIw4V62nYwYCggnACZfmk1d8T6KF5dYmsuD7Y11wNp5ywL0LuxnNT1AsQjr9QYEfgIC6kTo= X-Received: by 2002:a63:af06:0:b0:378:3582:a49f with SMTP id w6-20020a63af06000000b003783582a49fmr587568pge.125.1651258695638; Fri, 29 Apr 2022 11:58:15 -0700 (PDT) MIME-Version: 1.0 References: <388c1dd1235a3c95aefc7caee5726b869b6894e0.1651239378.git.aburgess@redhat.com> In-Reply-To: <388c1dd1235a3c95aefc7caee5726b869b6894e0.1651239378.git.aburgess@redhat.com> From: "H.J. Lu" Date: Fri, 29 Apr 2022 11:57:39 -0700 Message-ID: Subject: Re: [PATCH 2/2] libopcodes: extend the styling within the i386 disassembler To: Andrew Burgess Cc: Binutils Content-Type: text/plain; charset="UTF-8" X-Spam-Status: No, score=-3025.6 required=5.0 tests=BAYES_00, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, FREEMAIL_FROM, GIT_PATCH_0, RCVD_IN_DNSWL_NONE, SPF_HELO_NONE, SPF_PASS, TXREP autolearn=ham autolearn_force=no version=3.4.4 X-Spam-Checker-Version: SpamAssassin 3.4.4 (2020-01-24) on server2.sourceware.org X-BeenThere: binutils@sourceware.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Binutils mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Fri, 29 Apr 2022 18:58:25 -0000 . w On Fri, Apr 29, 2022 at 6:48 AM Andrew Burgess via Binutils wrote: > > The i386 disassembler is pretty complex. Most disassembly is done > indirectly; operands are built into buffers within a struct instr_info > instance, before finally being printed later in the disassembly > process. > > Sometimes the operand buffers are built in a different order to the > order in which they will eventually be printed. > > Each operand can contain multiple components, e.g. multiple registers, > immediates, other textual elements (commas, brackets, etc). > > When looking for how to apply styling I guess the ideal solution would > be to move away from the operands being a single string that is built > up, and instead have each operand be a list of "parts", where each > part is some text and a style. Then, when we eventually print the > operand we would loop over the parts and print each part with the > correct style. > > But it feels like a huge amount of work to move from where we are > now to that potentially ideal solution. Plus, the above solution > would be pretty complex. > > So, instead I propose a .... different solution here, one that works > with the existing infrastructure. > > As each operand is built up, piece be piece, we pass through style > information. This style information is then encoded into the operand > buffer (see below for details). After this the code can continue to > operate as it does right now in order to manage the set of operand > buffers. > > Then, as each operand is printed we can split the operand buffer into > chunks at the style marker boundaries, with each chunk being printed > in the correct style. > > For encoding the style information I use the format "~%x~". As far as > I can tell the '~' is not otherwise used in the i386 disassembler, so Can you use a non-ascii character instead of ~? > this should serve as a unique marker. To speed up writing and then > reading the style markers, I take advantage of the fact that there are > less than 16 styles so I know the '%x' will only ever be a single hex > character. > > In some (not very scientific) benchmarking on my machine, > disassembling a reasonably large (142M) shared library, I'm not seeing > any significant slow down in disassembler speed with this change. > > Most instructions are now being fully syntax highlighted when I > disassemble using the --disassembler-color=extended-color option. I'm > sure that there are probably still a few corner cases that need fixing > up, but we can come back to them later I think. > > When disassembler syntax highlighting is not being used, then there > should be no user visible changes after this commit. > --- > opcodes/i386-dis.c | 571 ++++++++++++++++++++++++++------------------- > 1 file changed, 332 insertions(+), 239 deletions(-) > > diff --git a/opcodes/i386-dis.c b/opcodes/i386-dis.c > index 1e3266329c1..c94d316a03f 100644 > --- a/opcodes/i386-dis.c > +++ b/opcodes/i386-dis.c > @@ -42,12 +42,14 @@ > #include > typedef struct instr_info instr_info; > > +#define STYLE_BUFFER_SIZE 10 > + > static int print_insn (bfd_vma, instr_info *); > static void dofloat (instr_info *, int); > static void OP_ST (instr_info *, int, int); > static void OP_STi (instr_info *, int, int); > static int putop (instr_info *, const char *, int); > -static void oappend (instr_info *, const char *); > +static void oappend (instr_info *, const char *, enum disassembler_style); Please add a new function, oappend_with_style, to take a new argument and change oappend to call oappend_with_style with dis_style_text. > static void append_seg (instr_info *); > static void OP_indirE (instr_info *, int, int); > static void print_operand_value (instr_info *, char *, int, bfd_vma); > @@ -166,6 +168,8 @@ struct instr_info > char *obufp; > char *mnemonicendp; > char scratchbuf[100]; > + char style_buffer[STYLE_BUFFER_SIZE]; > + char staging_area[100]; > unsigned char *start_codep; > unsigned char *insn_codep; > unsigned char *codep; > @@ -248,6 +252,8 @@ struct instr_info > > enum x86_64_isa isa64; > > + int (*printf) (instr_info *ins, enum disassembler_style style, > + const char *fmt, ...) ATTRIBUTE_FPTR_PRINTF_3; > }; > > /* Mark parts used in the REX prefix. When we are testing for > @@ -9300,9 +9306,73 @@ get_sib (instr_info *ins, int sizeflag) > /* Like oappend (below), but S is a string starting with '%'. > In Intel syntax, the '%' is elided. */ > static void > -oappend_maybe_intel (instr_info *ins, const char *s) > +oappend_maybe_intel (instr_info *ins, const char *s, > + enum disassembler_style style) oappend_maybe_intel_wityh_style > { > - oappend (ins, s + ins->intel_syntax); > + oappend (ins, s + ins->intel_syntax, style); > +} > + > +/* Wrap around a call to INS->info->fprintf_styled_func, printing FMT. > + STYLE is the default style to use in the fprintf_styled_func calls, > + however, FMT might include embedded style markers (see oappend_style), > + these embedded markers are not printed, but instead change the style > + used in the next fprintf_styled_func call. > + > + Return non-zero to indicate the print call was a success. */ > + > +static int ATTRIBUTE_PRINTF_3 > +i386_dis_printf (instr_info *ins, enum disassembler_style style, > + const char *fmt, ...) > +{ > + va_list ap; > + enum disassembler_style curr_style = style; > + char *start, *curr; > + > + va_start (ap, fmt); > + vsnprintf (ins->staging_area, 100, fmt, ap); > + va_end (ap); > + > + start = curr = ins->staging_area; > + > + do > + { > + if (*curr == '\0' || *curr == '~') > + { > + /* Output content between our START position and CURR. */ > + int len = curr - start; > + (*ins->info->fprintf_styled_func) (ins->info->stream, curr_style, > + "%.*s", len, start); > + if (*curr == '\0') > + break; > + > + /* Update the CURR_STYLE, it is possible here that if the input > + is corrupted in some way, then we may set CURR_STYLE to an > + invalid value. Don't worry though, we check for that in a > + subsequent if block. */ > + ++curr; > + if (*curr >= '0' && *curr <= '9') > + curr_style = (enum disassembler_style) (*curr - '0'); > + else if (*curr >= 'a' && *curr <= 'f') > + curr_style = (enum disassembler_style) (*curr - 'a' + 10); > + else > + curr_style = dis_style_text; > + > + /* Skip over the hex character, and the closing '~'. Also > + validate that CURR_STYLE is set to a valid value. */ > + ++curr; > + if (*curr != '~' || curr_style > dis_style_comment_start) > + curr_style = dis_style_text; > + ++curr; > + > + /* Reset the START and CURR pointers to after the style marker. */ > + start = curr; > + } > + else > + ++curr; > + } > + while (true); > + > + return 1; > } > > static int > @@ -9317,6 +9387,7 @@ print_insn (bfd_vma pc, instr_info *ins) > struct dis_private priv; > int prefix_length; > > + ins->printf = i386_dis_printf; > ins->isa64 = 0; > ins->intel_mnemonic = !SYSV386_COMPAT; > ins->op_is_jump = false; > @@ -9401,8 +9472,7 @@ print_insn (bfd_vma pc, instr_info *ins) > > if (ins->address_mode == mode_64bit && sizeof (bfd_vma) < 8) > { > - (*ins->info->fprintf_styled_func) (ins->info->stream, dis_style_text, > - _("64-bit address is disabled")); > + ins->printf (ins, dis_style_text, _("64-bit address is disabled")); > return -1; > } > > @@ -9451,16 +9521,14 @@ print_insn (bfd_vma pc, instr_info *ins) > { > name = prefix_name (ins, priv.the_buffer[0], priv.orig_sizeflag); > if (name != NULL) > - (*ins->info->fprintf_styled_func) > - (ins->info->stream, dis_style_mnemonic, "%s", name); > + ins->printf (ins, dis_style_mnemonic, "%s", name); > else > { > /* Just print the first byte as a .byte instruction. */ > - (*ins->info->fprintf_styled_func) > - (ins->info->stream, dis_style_assembler_directive, ".byte "); > - (*ins->info->fprintf_styled_func) > - (ins->info->stream, dis_style_immediate, "0x%x", > - (unsigned int) priv.the_buffer[0]); > + ins->printf (ins, dis_style_assembler_directive, > + ".byte "); > + ins->printf (ins, dis_style_immediate, "0x%x", > + (unsigned int) priv.the_buffer[0]); > } > > return 1; > @@ -9478,10 +9546,9 @@ print_insn (bfd_vma pc, instr_info *ins) > for (i = 0; > i < (int) ARRAY_SIZE (ins->all_prefixes) && ins->all_prefixes[i]; > i++) > - (*ins->info->fprintf_styled_func) > - (ins->info->stream, dis_style_mnemonic, "%s%s", > - (i == 0 ? "" : " "), prefix_name (ins, ins->all_prefixes[i], > - sizeflag)); > + ins->printf (ins, dis_style_mnemonic, "%s%s", > + (i == 0 ? "" : " "), > + prefix_name (ins, ins->all_prefixes[i], sizeflag)); > return i; > } > > @@ -9496,11 +9563,9 @@ print_insn (bfd_vma pc, instr_info *ins) > /* Handle ins->prefixes before fwait. */ > for (i = 0; i < ins->fwait_prefix && ins->all_prefixes[i]; > i++) > - (*ins->info->fprintf_styled_func) > - (ins->info->stream, dis_style_mnemonic, "%s ", > - prefix_name (ins, ins->all_prefixes[i], sizeflag)); > - (*ins->info->fprintf_styled_func) > - (ins->info->stream, dis_style_mnemonic, "fwait"); > + ins->printf (ins, dis_style_mnemonic, "%s ", > + prefix_name (ins, ins->all_prefixes[i], sizeflag)); > + ins->printf (ins, dis_style_mnemonic, "fwait"); > return i + 1; > } > > @@ -9569,14 +9634,15 @@ print_insn (bfd_vma pc, instr_info *ins) > /* Don't print {%k0}. */ > if (ins->vex.mask_register_specifier) > { > - oappend (ins, "{"); > + oappend (ins, "{", dis_style_text); > oappend_maybe_intel (ins, > att_names_mask > - [ins->vex.mask_register_specifier]); > - oappend (ins, "}"); > + [ins->vex.mask_register_specifier], > + dis_style_text); > + oappend (ins, "}", dis_style_text); > } > if (ins->vex.zeroing) > - oappend (ins, "{z}"); > + oappend (ins, "{z}", dis_style_text); > > /* S/G insns require a mask and don't allow > zeroing-masking. */ > @@ -9584,7 +9650,7 @@ print_insn (bfd_vma pc, instr_info *ins) > || dp->op[0].bytemode == vex_vsib_q_w_dq_mode) > && (ins->vex.mask_register_specifier == 0 > || ins->vex.zeroing)) > - oappend (ins, "/(bad)"); > + oappend (ins, "/(bad)", dis_style_text); > } > } > > @@ -9598,8 +9664,8 @@ print_insn (bfd_vma pc, instr_info *ins) > ins->obufp = ins->op_out[i]; > if (*ins->obufp) > continue; > - oappend (ins, names_rounding[ins->vex.ll]); > - oappend (ins, "bad}"); > + oappend (ins, names_rounding[ins->vex.ll], dis_style_text); > + oappend (ins, "bad}", dis_style_text); > break; > } > } > @@ -9649,16 +9715,14 @@ print_insn (bfd_vma pc, instr_info *ins) > are all 0s in inverted form. */ > if (ins->need_vex && ins->vex.register_specifier != 0) > { > - (*ins->info->fprintf_styled_func) (ins->info->stream, dis_style_text, > - "(bad)"); > + ins->printf (ins, dis_style_text, "(bad)"); > return ins->end_codep - priv.the_buffer; > } > > /* If EVEX.z is set, there must be an actual mask register in use. */ > if (ins->vex.zeroing && ins->vex.mask_register_specifier == 0) > { > - (*ins->info->fprintf_styled_func) (ins->info->stream, dis_style_text, > - "(bad)"); > + ins->printf (ins, dis_style_text, "(bad)"); > return ins->end_codep - priv.the_buffer; > } > > @@ -9669,8 +9733,7 @@ print_insn (bfd_vma pc, instr_info *ins) > the encoding invalid. Most other PREFIX_OPCODE rules still apply. */ > if (ins->need_vex ? !ins->vex.prefix : !(ins->prefixes & PREFIX_DATA)) > { > - (*ins->info->fprintf_styled_func) (ins->info->stream, > - dis_style_text, "(bad)"); > + ins->printf (ins, dis_style_text, "(bad)"); > return ins->end_codep - priv.the_buffer; > } > ins->used_prefixes |= PREFIX_DATA; > @@ -9697,8 +9760,7 @@ print_insn (bfd_vma pc, instr_info *ins) > || (ins->vex.evex && dp->prefix_requirement != PREFIX_DATA > && !ins->vex.w != !(ins->used_prefixes & PREFIX_DATA))) > { > - (*ins->info->fprintf_styled_func) (ins->info->stream, > - dis_style_text, "(bad)"); > + ins->printf (ins, dis_style_text, "(bad)"); > return ins->end_codep - priv.the_buffer; > } > break; > @@ -9748,24 +9810,28 @@ print_insn (bfd_vma pc, instr_info *ins) > if (name == NULL) > abort (); > prefix_length += strlen (name) + 1; > - (*ins->info->fprintf_styled_func) > - (ins->info->stream, dis_style_mnemonic, "%s ", name); > + ins->printf (ins, dis_style_mnemonic, "%s ", name); > } > > /* Check maximum code length. */ > if ((ins->codep - ins->start_codep) > MAX_CODE_LENGTH) > { > - (*ins->info->fprintf_styled_func) > - (ins->info->stream, dis_style_text, "(bad)"); > + ins->printf (ins, dis_style_text, "(bad)"); > return MAX_CODE_LENGTH; > } > > - ins->obufp = ins->mnemonicendp; > - for (i = strlen (ins->obuf) + prefix_length; i < 6; i++) > - oappend (ins, " "); > - oappend (ins, " "); > - (*ins->info->fprintf_styled_func) > - (ins->info->stream, dis_style_mnemonic, "%s", ins->obuf); > + i = strlen (ins->obuf); > + if (ins->mnemonicendp == ins->obuf + i) > + { > + i += prefix_length; > + if (i < 6) > + i = 6 - i + 1; > + else > + i = 1; > + } > + else > + i = 0; > + ins->printf (ins, dis_style_mnemonic, "%s%*s", ins->obuf, i, ""); > > /* The enter and bound instructions are printed with operands in the same > order as the intel book; everything else is printed in reverse order. */ > @@ -9804,8 +9870,7 @@ print_insn (bfd_vma pc, instr_info *ins) > if (*op_txt[i]) > { > if (needcomma) > - (*ins->info->fprintf_styled_func) (ins->info->stream, > - dis_style_text, ","); > + ins->printf (ins, dis_style_text, ","); > if (ins->op_index[i] != -1 && !ins->op_riprel[i]) > { > bfd_vma target = (bfd_vma) ins->op_address[ins->op_index[i]]; > @@ -9821,18 +9886,14 @@ print_insn (bfd_vma pc, instr_info *ins) > (*ins->info->print_address_func) (target, ins->info); > } > else > - (*ins->info->fprintf_styled_func) (ins->info->stream, > - dis_style_text, "%s", > - op_txt[i]); > + ins->printf (ins, dis_style_text, "%s", op_txt[i]); > needcomma = 1; > } > > for (i = 0; i < MAX_OPERANDS; i++) > if (ins->op_index[i] != -1 && ins->op_riprel[i]) > { > - (*ins->info->fprintf_styled_func) (ins->info->stream, > - dis_style_comment_start, > - " # "); > + ins->printf (ins, dis_style_comment_start, " # "); > (*ins->info->print_address_func) ((bfd_vma) > (ins->start_pc + (ins->codep - ins->start_codep) > + ins->op_address[ins->op_index[i]]), ins->info); > @@ -10217,15 +10278,18 @@ static void > OP_ST (instr_info *ins, int bytemode ATTRIBUTE_UNUSED, > int sizeflag ATTRIBUTE_UNUSED) > { > - oappend_maybe_intel (ins, "%st"); > + oappend_maybe_intel (ins, "%st", dis_style_text); > } > > static void > OP_STi (instr_info *ins, int bytemode ATTRIBUTE_UNUSED, > int sizeflag ATTRIBUTE_UNUSED) > { > - sprintf (ins->scratchbuf, "%%st(%d)", ins->modrm.rm); > - oappend_maybe_intel (ins, ins->scratchbuf); > + oappend_maybe_intel (ins, "%st", dis_style_text); > + oappend (ins, "(", dis_style_text); > + sprintf (ins->scratchbuf, "%d", ins->modrm.rm); > + oappend (ins, ins->scratchbuf, dis_style_immediate); > + oappend (ins, ")", dis_style_text); > } > > /* Capital letters in template are macros. */ > @@ -10329,7 +10393,7 @@ putop (instr_info *ins, const char *in_template, int sizeflag) > if (!ins->vex.evex || ins->vex.w) > *ins->obufp++ = 'd'; > else > - oappend (ins, "{bad}"); > + oappend (ins, "{bad}", dis_style_text); > break; > default: > abort (); > @@ -10424,7 +10488,7 @@ putop (instr_info *ins, const char *in_template, int sizeflag) > if (!ins->vex.w) > *ins->obufp++ = 'h'; > else > - oappend (ins, "{bad}"); > + oappend (ins, "{bad}", dis_style_text); > } > else > abort (); > @@ -10608,7 +10672,7 @@ putop (instr_info *ins, const char *in_template, int sizeflag) > if (!ins->vex.evex || !ins->vex.w) > *ins->obufp++ = 's'; > else > - oappend (ins, "{bad}"); > + oappend (ins, "{bad}", dis_style_text); > break; > default: > abort (); > @@ -10772,12 +10836,47 @@ putop (instr_info *ins, const char *in_template, int sizeflag) > return 0; > } > > +/* Add a style marker "~X~" to *INS->obufp that encodes STYLE. This > + assumes that the buffer pointed to by INS->obufp has space. In the > + style marker 'X' is replaced with a single hex character that represents > + STYLE. */ > + > +static void > +oappend_style (instr_info *ins, enum disassembler_style style) > +{ > + int num = (int) style; > + > + /* We currently assume that STYLE can be encoded as a single hex > + character. If more styles are added then this might start to fail, > + and we'll need to expand this code. */ > + if (num > 0xf) > + abort (); > + > + *ins->obufp++ = '~'; > + *ins->obufp++ = (num < 10 ? ('0' + num) > + : ((num < 16) ? ('a' + (num - 10)) : '0')); > + *ins->obufp++ = '~'; > + *ins->obufp = '\0'; Do you need '\0'? > +} > + > static void > -oappend (instr_info *ins, const char *s) > +oappend (instr_info *ins, const char *s, enum disassembler_style style) > { > + oappend_style (ins, style); > ins->obufp = stpcpy (ins->obufp, s); > } > > +/* Add a single character C to the buffer pointer to by INS->obufp, marking > + the style for the character as STYLE. */ > + > +static void > +oappend_char (instr_info *ins, const char c, enum disassembler_style style) > +{ > + oappend_style (ins, style); > + *ins->obufp++ = c; > + *ins->obufp = '\0'; > +} > + > static void > append_seg (instr_info *ins) > { > @@ -10789,33 +10888,34 @@ append_seg (instr_info *ins) > switch (ins->active_seg_prefix) > { > case PREFIX_CS: > - oappend_maybe_intel (ins, "%cs:"); > + oappend_maybe_intel (ins, "%cs", dis_style_register); > break; > case PREFIX_DS: > - oappend_maybe_intel (ins, "%ds:"); > + oappend_maybe_intel (ins, "%ds", dis_style_register); > break; > case PREFIX_SS: > - oappend_maybe_intel (ins, "%ss:"); > + oappend_maybe_intel (ins, "%ss", dis_style_register); > break; > case PREFIX_ES: > - oappend_maybe_intel (ins, "%es:"); > + oappend_maybe_intel (ins, "%es", dis_style_register); > break; > case PREFIX_FS: > - oappend_maybe_intel (ins, "%fs:"); > + oappend_maybe_intel (ins, "%fs", dis_style_register); > break; > case PREFIX_GS: > - oappend_maybe_intel (ins, "%gs:"); > + oappend_maybe_intel (ins, "%gs", dis_style_register); > break; > default: > break; > } > + oappend_char (ins, ':', dis_style_text); > } > > static void > OP_indirE (instr_info *ins, int bytemode, int sizeflag) > { > if (!ins->intel_syntax) > - oappend (ins, "*"); > + oappend (ins, "*", dis_style_text); > OP_E (ins, bytemode, sizeflag); > } > > @@ -10931,14 +11031,14 @@ intel_operand_size (instr_info *ins, int bytemode, int sizeflag) > case x_mode: > case evex_half_bcst_xmmq_mode: > if (ins->vex.w) > - oappend (ins, "QWORD PTR "); > + oappend (ins, "QWORD PTR ", dis_style_text); > else > - oappend (ins, "DWORD PTR "); > + oappend (ins, "DWORD PTR ", dis_style_text); > break; > case xh_mode: > case evex_half_bcst_xmmqh_mode: > case evex_half_bcst_xmmqdh_mode: > - oappend (ins, "WORD PTR "); > + oappend (ins, "WORD PTR ", dis_style_text); > break; > default: > ins->vex.no_broadcast = true; > @@ -10951,17 +11051,17 @@ intel_operand_size (instr_info *ins, int bytemode, int sizeflag) > case b_mode: > case b_swap_mode: > case db_mode: > - oappend (ins, "BYTE PTR "); > + oappend (ins, "BYTE PTR ", dis_style_text); > break; > case w_mode: > case w_swap_mode: > case dw_mode: > - oappend (ins, "WORD PTR "); > + oappend (ins, "WORD PTR ", dis_style_text); > break; > case indir_v_mode: > if (ins->address_mode == mode_64bit && ins->isa64 == intel64) > { > - oappend (ins, "QWORD PTR "); > + oappend (ins, "QWORD PTR ", dis_style_text); > break; > } > /* Fall through. */ > @@ -10969,7 +11069,7 @@ intel_operand_size (instr_info *ins, int bytemode, int sizeflag) > if (ins->address_mode == mode_64bit && ((sizeflag & DFLAG) > || (ins->rex & REX_W))) > { > - oappend (ins, "QWORD PTR "); > + oappend (ins, "QWORD PTR ", dis_style_text); > break; > } > /* Fall through. */ > @@ -10978,62 +11078,62 @@ intel_operand_size (instr_info *ins, int bytemode, int sizeflag) > case dq_mode: > USED_REX (REX_W); > if (ins->rex & REX_W) > - oappend (ins, "QWORD PTR "); > + oappend (ins, "QWORD PTR ", dis_style_text); > else if (bytemode == dq_mode) > - oappend (ins, "DWORD PTR "); > + oappend (ins, "DWORD PTR ", dis_style_text); > else > { > if (sizeflag & DFLAG) > - oappend (ins, "DWORD PTR "); > + oappend (ins, "DWORD PTR ", dis_style_text); > else > - oappend (ins, "WORD PTR "); > + oappend (ins, "WORD PTR ", dis_style_text); > ins->used_prefixes |= (ins->prefixes & PREFIX_DATA); > } > break; > case z_mode: > if ((ins->rex & REX_W) || (sizeflag & DFLAG)) > *ins->obufp++ = 'D'; > - oappend (ins, "WORD PTR "); > + oappend (ins, "WORD PTR ", dis_style_text); > if (!(ins->rex & REX_W)) > ins->used_prefixes |= (ins->prefixes & PREFIX_DATA); > break; > case a_mode: > if (sizeflag & DFLAG) > - oappend (ins, "QWORD PTR "); > + oappend (ins, "QWORD PTR ", dis_style_text); > else > - oappend (ins, "DWORD PTR "); > + oappend (ins, "DWORD PTR ", dis_style_text); > ins->used_prefixes |= (ins->prefixes & PREFIX_DATA); > break; > case movsxd_mode: > if (!(sizeflag & DFLAG) && ins->isa64 == intel64) > - oappend (ins, "WORD PTR "); > + oappend (ins, "WORD PTR ", dis_style_text); > else > - oappend (ins, "DWORD PTR "); > + oappend (ins, "DWORD PTR ", dis_style_text); > ins->used_prefixes |= (ins->prefixes & PREFIX_DATA); > break; > case d_mode: > case d_swap_mode: > - oappend (ins, "DWORD PTR "); > + oappend (ins, "DWORD PTR ", dis_style_text); > break; > case q_mode: > case q_swap_mode: > - oappend (ins, "QWORD PTR "); > + oappend (ins, "QWORD PTR ", dis_style_text); > break; > case m_mode: > if (ins->address_mode == mode_64bit) > - oappend (ins, "QWORD PTR "); > + oappend (ins, "QWORD PTR ", dis_style_text); > else > - oappend (ins, "DWORD PTR "); > + oappend (ins, "DWORD PTR ", dis_style_text); > break; > case f_mode: > if (sizeflag & DFLAG) > - oappend (ins, "FWORD PTR "); > + oappend (ins, "FWORD PTR ", dis_style_text); > else > - oappend (ins, "DWORD PTR "); > + oappend (ins, "DWORD PTR ", dis_style_text); > ins->used_prefixes |= (ins->prefixes & PREFIX_DATA); > break; > case t_mode: > - oappend (ins, "TBYTE PTR "); > + oappend (ins, "TBYTE PTR ", dis_style_text); > break; > case x_mode: > case xh_mode: > @@ -11046,26 +11146,26 @@ intel_operand_size (instr_info *ins, int bytemode, int sizeflag) > switch (ins->vex.length) > { > case 128: > - oappend (ins, "XMMWORD PTR "); > + oappend (ins, "XMMWORD PTR ", dis_style_text); > break; > case 256: > - oappend (ins, "YMMWORD PTR "); > + oappend (ins, "YMMWORD PTR ", dis_style_text); > break; > case 512: > - oappend (ins, "ZMMWORD PTR "); > + oappend (ins, "ZMMWORD PTR ", dis_style_text); > break; > default: > abort (); > } > } > else > - oappend (ins, "XMMWORD PTR "); > + oappend (ins, "XMMWORD PTR ", dis_style_text); > break; > case xmm_mode: > - oappend (ins, "XMMWORD PTR "); > + oappend (ins, "XMMWORD PTR ", dis_style_text); > break; > case ymm_mode: > - oappend (ins, "YMMWORD PTR "); > + oappend (ins, "YMMWORD PTR ", dis_style_text); > break; > case xmmq_mode: > case evex_half_bcst_xmmqh_mode: > @@ -11076,13 +11176,13 @@ intel_operand_size (instr_info *ins, int bytemode, int sizeflag) > switch (ins->vex.length) > { > case 128: > - oappend (ins, "QWORD PTR "); > + oappend (ins, "QWORD PTR ", dis_style_text); > break; > case 256: > - oappend (ins, "XMMWORD PTR "); > + oappend (ins, "XMMWORD PTR ", dis_style_text); > break; > case 512: > - oappend (ins, "YMMWORD PTR "); > + oappend (ins, "YMMWORD PTR ", dis_style_text); > break; > default: > abort (); > @@ -11095,13 +11195,13 @@ intel_operand_size (instr_info *ins, int bytemode, int sizeflag) > switch (ins->vex.length) > { > case 128: > - oappend (ins, "WORD PTR "); > + oappend (ins, "WORD PTR ", dis_style_text); > break; > case 256: > - oappend (ins, "DWORD PTR "); > + oappend (ins, "DWORD PTR ", dis_style_text); > break; > case 512: > - oappend (ins, "QWORD PTR "); > + oappend (ins, "QWORD PTR ", dis_style_text); > break; > default: > abort (); > @@ -11115,13 +11215,13 @@ intel_operand_size (instr_info *ins, int bytemode, int sizeflag) > switch (ins->vex.length) > { > case 128: > - oappend (ins, "DWORD PTR "); > + oappend (ins, "DWORD PTR ", dis_style_text); > break; > case 256: > - oappend (ins, "QWORD PTR "); > + oappend (ins, "QWORD PTR ", dis_style_text); > break; > case 512: > - oappend (ins, "XMMWORD PTR "); > + oappend (ins, "XMMWORD PTR ", dis_style_text); > break; > default: > abort (); > @@ -11134,45 +11234,45 @@ intel_operand_size (instr_info *ins, int bytemode, int sizeflag) > switch (ins->vex.length) > { > case 128: > - oappend (ins, "QWORD PTR "); > + oappend (ins, "QWORD PTR ", dis_style_text); > break; > case 256: > - oappend (ins, "YMMWORD PTR "); > + oappend (ins, "YMMWORD PTR ", dis_style_text); > break; > case 512: > - oappend (ins, "ZMMWORD PTR "); > + oappend (ins, "ZMMWORD PTR ", dis_style_text); > break; > default: > abort (); > } > break; > case o_mode: > - oappend (ins, "OWORD PTR "); > + oappend (ins, "OWORD PTR ", dis_style_text); > break; > case vex_vsib_d_w_dq_mode: > case vex_vsib_q_w_dq_mode: > if (!ins->need_vex) > abort (); > if (ins->vex.w) > - oappend (ins, "QWORD PTR "); > + oappend (ins, "QWORD PTR ", dis_style_text); > else > - oappend (ins, "DWORD PTR "); > + oappend (ins, "DWORD PTR ", dis_style_text); > break; > case mask_bd_mode: > if (!ins->need_vex || ins->vex.length != 128) > abort (); > if (ins->vex.w) > - oappend (ins, "DWORD PTR "); > + oappend (ins, "DWORD PTR ", dis_style_text); > else > - oappend (ins, "BYTE PTR "); > + oappend (ins, "BYTE PTR ", dis_style_text); > break; > case mask_mode: > if (!ins->need_vex) > abort (); > if (ins->vex.w) > - oappend (ins, "QWORD PTR "); > + oappend (ins, "QWORD PTR ", dis_style_text); > else > - oappend (ins, "WORD PTR "); > + oappend (ins, "WORD PTR ", dis_style_text); > break; > case v_bnd_mode: > case v_bndmk_mode: > @@ -11221,7 +11321,7 @@ print_register (instr_info *ins, unsigned int reg, unsigned int rexmask, > case bnd_swap_mode: > if (reg > 0x3) > { > - oappend (ins, "(bad)"); > + oappend (ins, "(bad)", dis_style_text); > return; > } > names = att_names_bnd; > @@ -11285,7 +11385,7 @@ print_register (instr_info *ins, unsigned int reg, unsigned int rexmask, > case mask_mode: > if (reg > 0x7) > { > - oappend (ins, "(bad)"); > + oappend (ins, "(bad)", dis_style_text); > return; > } > names = att_names_mask; > @@ -11293,10 +11393,10 @@ print_register (instr_info *ins, unsigned int reg, unsigned int rexmask, > case 0: > return; > default: > - oappend (ins, INTERNAL_DISASSEMBLER_ERROR); > + oappend (ins, INTERNAL_DISASSEMBLER_ERROR, dis_style_text); > return; > } > - oappend_maybe_intel (ins, names[reg]); > + oappend_maybe_intel (ins, names[reg], dis_style_register); > } > > static void > @@ -11488,7 +11588,7 @@ OP_E_memory (instr_info *ins, int bytemode, int sizeflag) > || bytemode == vex_vsib_q_w_dq_mode > || bytemode == vex_sibmem_mode) > { > - oappend (ins, "(bad)"); > + oappend (ins, "(bad)", dis_style_text); > return; > } > } > @@ -11505,7 +11605,7 @@ OP_E_memory (instr_info *ins, int bytemode, int sizeflag) > disp = get32s (ins); > if (riprel && bytemode == v_bndmk_mode) > { > - oappend (ins, "(bad)"); > + oappend (ins, "(bad)", dis_style_text); > return; > } > } > @@ -11560,11 +11660,14 @@ OP_E_memory (instr_info *ins, int bytemode, int sizeflag) > print_displacement (ins, ins->scratchbuf, disp); > else > print_operand_value (ins, ins->scratchbuf, 1, disp); > - oappend (ins, ins->scratchbuf); > + oappend (ins, ins->scratchbuf, dis_style_address_offset); > if (riprel) > { > set_op (ins, disp, 1); > - oappend (ins, !addr32flag ? "(%rip)" : "(%eip)"); > + oappend_char (ins, '(', dis_style_text); > + oappend (ins, !addr32flag ? "%rip" : "%eip", > + dis_style_register); > + oappend_char (ins, ')', dis_style_text); > } > } > > @@ -11578,17 +11681,17 @@ OP_E_memory (instr_info *ins, int bytemode, int sizeflag) > > if (havedisp || (ins->intel_syntax && riprel)) > { > - *ins->obufp++ = ins->open_char; > + oappend_char (ins, ins->open_char, dis_style_text); > if (ins->intel_syntax && riprel) > { > set_op (ins, disp, 1); > - oappend (ins, !addr32flag ? "rip" : "eip"); > + oappend (ins, !addr32flag ? "rip" : "eip", dis_style_register); > } > - *ins->obufp = '\0'; > if (havebase) > oappend_maybe_intel (ins, > (ins->address_mode == mode_64bit && !addr32flag > - ? att_names64 : att_names32)[rbase]); > + ? att_names64 : att_names32)[rbase], > + dis_style_register); > if (ins->has_sib) > { > /* ESP/RSP won't allow index. If base isn't ESP/RSP, > @@ -11599,41 +11702,34 @@ OP_E_memory (instr_info *ins, int bytemode, int sizeflag) > || (havebase && base != ESP_REG_NUM)) > { > if (!ins->intel_syntax || havebase) > - { > - *ins->obufp++ = ins->separator_char; > - *ins->obufp = '\0'; > - } > + oappend_char (ins, ins->separator_char, dis_style_text); > if (indexes) > { > if (ins->address_mode == mode_64bit || vindex < 16) > - oappend_maybe_intel (ins, indexes[vindex]); > + oappend_maybe_intel (ins, indexes[vindex], > + dis_style_register); > else > - oappend (ins, "(bad)"); > + oappend (ins, "(bad)", dis_style_text); > } > else > oappend_maybe_intel (ins, > ins->address_mode == mode_64bit > && !addr32flag ? att_index64 > - : att_index32); > + : att_index32, dis_style_text); > > - *ins->obufp++ = ins->scale_char; > - *ins->obufp = '\0'; > + oappend_char (ins, ins->scale_char, dis_style_text); > sprintf (ins->scratchbuf, "%d", 1 << scale); > - oappend (ins, ins->scratchbuf); > + oappend (ins, ins->scratchbuf, dis_style_immediate); > } > } > if (ins->intel_syntax > && (disp || ins->modrm.mod != 0 || base == 5)) > { > if (!havedisp || (bfd_signed_vma) disp >= 0) > - { > - *ins->obufp++ = '+'; > - *ins->obufp = '\0'; > - } > + oappend_char (ins, '+', dis_style_text); > else if (ins->modrm.mod != 1 && disp != -disp) > { > - *ins->obufp++ = '-'; > - *ins->obufp = '\0'; > + oappend_char (ins, '-', dis_style_text); > disp = - (bfd_signed_vma) disp; > } > > @@ -11641,11 +11737,10 @@ OP_E_memory (instr_info *ins, int bytemode, int sizeflag) > print_displacement (ins, ins->scratchbuf, disp); > else > print_operand_value (ins, ins->scratchbuf, 1, disp); > - oappend (ins, ins->scratchbuf); > + oappend (ins, ins->scratchbuf, dis_style_text); > } > > - *ins->obufp++ = ins->close_char; > - *ins->obufp = '\0'; > + oappend_char (ins, ins->close_char, dis_style_text); > > if (check_gather) > { > @@ -11657,7 +11752,7 @@ OP_E_memory (instr_info *ins, int bytemode, int sizeflag) > if (!ins->vex.r) > modrm_reg += 16; > if (vindex == modrm_reg) > - oappend (ins, "/(bad)"); > + oappend (ins, "/(bad)", dis_style_text); > } > } > else if (ins->intel_syntax) > @@ -11666,11 +11761,12 @@ OP_E_memory (instr_info *ins, int bytemode, int sizeflag) > { > if (!ins->active_seg_prefix) > { > - oappend_maybe_intel (ins, att_names_seg[ds_reg - es_reg]); > - oappend (ins, ":"); > + oappend_maybe_intel (ins, att_names_seg[ds_reg - es_reg], > + dis_style_text); > + oappend (ins, ":", dis_style_text); > } > print_operand_value (ins, ins->scratchbuf, 1, disp); > - oappend (ins, ins->scratchbuf); > + oappend (ins, ins->scratchbuf, dis_style_text); > } > } > } > @@ -11681,7 +11777,7 @@ OP_E_memory (instr_info *ins, int bytemode, int sizeflag) > || bytemode == vex_vsib_d_w_dq_mode > || bytemode == vex_vsib_q_w_dq_mode) > { > - oappend (ins, "(bad)"); > + oappend (ins, "(bad)", dis_style_text); > return; > } > else > @@ -11717,47 +11813,42 @@ OP_E_memory (instr_info *ins, int bytemode, int sizeflag) > if (ins->modrm.mod != 0 || ins->modrm.rm == 6) > { > print_displacement (ins, ins->scratchbuf, disp); > - oappend (ins, ins->scratchbuf); > + oappend (ins, ins->scratchbuf, dis_style_text); > } > > if (ins->modrm.mod != 0 || ins->modrm.rm != 6) > { > - *ins->obufp++ = ins->open_char; > - *ins->obufp = '\0'; > + oappend_char (ins, ins->open_char, dis_style_text); > oappend (ins, > (ins->intel_syntax ? intel_index16 > - : att_index16)[ins->modrm.rm]); > + : att_index16)[ins->modrm.rm], dis_style_text); > if (ins->intel_syntax > && (disp || ins->modrm.mod != 0 || ins->modrm.rm == 6)) > { > if ((bfd_signed_vma) disp >= 0) > - { > - *ins->obufp++ = '+'; > - *ins->obufp = '\0'; > - } > + oappend_char (ins, '+', dis_style_text); > else if (ins->modrm.mod != 1) > { > - *ins->obufp++ = '-'; > - *ins->obufp = '\0'; > + oappend_char (ins, '-', dis_style_text); > disp = - (bfd_signed_vma) disp; > } > > print_displacement (ins, ins->scratchbuf, disp); > - oappend (ins, ins->scratchbuf); > + oappend (ins, ins->scratchbuf, dis_style_text); > } > > - *ins->obufp++ = ins->close_char; > - *ins->obufp = '\0'; > + oappend_char (ins, ins->close_char, dis_style_text); > } > else if (ins->intel_syntax) > { > if (!ins->active_seg_prefix) > { > - oappend_maybe_intel (ins, att_names_seg[ds_reg - es_reg]); > - oappend (ins, ":"); > + oappend_maybe_intel (ins, att_names_seg[ds_reg - es_reg], > + dis_style_text); > + oappend (ins, ":", dis_style_text); > } > print_operand_value (ins, ins->scratchbuf, 1, disp & 0xffff); > - oappend (ins, ins->scratchbuf); > + oappend (ins, ins->scratchbuf, dis_style_text); > } > } > if (ins->vex.b) > @@ -11773,19 +11864,19 @@ OP_E_memory (instr_info *ins, int bytemode, int sizeflag) > if (bytemode == xh_mode) > { > if (ins->vex.w) > - oappend (ins, "{bad}"); > + oappend (ins, "{bad}", dis_style_text); > else > { > switch (ins->vex.length) > { > case 128: > - oappend (ins, "{1to8}"); > + oappend (ins, "{1to8}", dis_style_text); > break; > case 256: > - oappend (ins, "{1to16}"); > + oappend (ins, "{1to16}", dis_style_text); > break; > case 512: > - oappend (ins, "{1to32}"); > + oappend (ins, "{1to32}", dis_style_text); > break; > default: > abort (); > @@ -11802,13 +11893,13 @@ OP_E_memory (instr_info *ins, int bytemode, int sizeflag) > switch (ins->vex.length) > { > case 128: > - oappend (ins, "{1to2}"); > + oappend (ins, "{1to2}", dis_style_text); > break; > case 256: > - oappend (ins, "{1to4}"); > + oappend (ins, "{1to4}", dis_style_text); > break; > case 512: > - oappend (ins, "{1to8}"); > + oappend (ins, "{1to8}", dis_style_text); > break; > default: > abort (); > @@ -11820,13 +11911,13 @@ OP_E_memory (instr_info *ins, int bytemode, int sizeflag) > switch (ins->vex.length) > { > case 128: > - oappend (ins, "{1to4}"); > + oappend (ins, "{1to4}", dis_style_text); > break; > case 256: > - oappend (ins, "{1to8}"); > + oappend (ins, "{1to8}", dis_style_text); > break; > case 512: > - oappend (ins, "{1to16}"); > + oappend (ins, "{1to16}", dis_style_text); > break; > default: > abort (); > @@ -11836,7 +11927,7 @@ OP_E_memory (instr_info *ins, int bytemode, int sizeflag) > ins->vex.no_broadcast = true; > } > if (ins->vex.no_broadcast) > - oappend (ins, "{bad}"); > + oappend (ins, "{bad}", dis_style_text); > } > } > > @@ -11866,7 +11957,7 @@ OP_G (instr_info *ins, int bytemode, int sizeflag) > { > if (ins->vex.evex && !ins->vex.r && ins->address_mode == mode_64bit) > { > - oappend (ins, "(bad)"); > + oappend (ins, "(bad)", dis_style_text); > return; > } > > @@ -11969,7 +12060,7 @@ OP_REG (instr_info *ins, int code, int sizeflag) > { > case es_reg: case ss_reg: case cs_reg: > case ds_reg: case fs_reg: case gs_reg: > - oappend_maybe_intel (ins, att_names_seg[code - es_reg]); > + oappend_maybe_intel (ins, att_names_seg[code - es_reg], dis_style_text); > return; > } > > @@ -12019,10 +12110,10 @@ OP_REG (instr_info *ins, int code, int sizeflag) > } > break; > default: > - oappend (ins, INTERNAL_DISASSEMBLER_ERROR); > + oappend (ins, INTERNAL_DISASSEMBLER_ERROR, dis_style_text); > return; > } > - oappend_maybe_intel (ins, s); > + oappend_maybe_intel (ins, s, dis_style_register); > } > > static void > @@ -12035,7 +12126,7 @@ OP_IMREG (instr_info *ins, int code, int sizeflag) > case indir_dx_reg: > if (!ins->intel_syntax) > { > - oappend (ins, "(%dx)"); > + oappend (ins, "(%dx)", dis_style_text); > return; > } > s = att_names16[dx_reg - ax_reg]; > @@ -12060,10 +12151,10 @@ OP_IMREG (instr_info *ins, int code, int sizeflag) > ins->used_prefixes |= (ins->prefixes & PREFIX_DATA); > break; > default: > - oappend (ins, INTERNAL_DISASSEMBLER_ERROR); > + oappend (ins, INTERNAL_DISASSEMBLER_ERROR, dis_style_text); > return; > } > - oappend_maybe_intel (ins, s); > + oappend_maybe_intel (ins, s, dis_style_register); > } > > static void > @@ -12108,17 +12199,17 @@ OP_I (instr_info *ins, int bytemode, int sizeflag) > break; > case const_1_mode: > if (ins->intel_syntax) > - oappend (ins, "1"); > + oappend (ins, "1", dis_style_text); > return; > default: > - oappend (ins, INTERNAL_DISASSEMBLER_ERROR); > + oappend (ins, INTERNAL_DISASSEMBLER_ERROR, dis_style_text); > return; > } > > op &= mask; > ins->scratchbuf[0] = '$'; > print_operand_value (ins, ins->scratchbuf + 1, 1, op); > - oappend_maybe_intel (ins, ins->scratchbuf); > + oappend_maybe_intel (ins, ins->scratchbuf, dis_style_immediate); > ins->scratchbuf[0] = '\0'; > } > > @@ -12136,7 +12227,7 @@ OP_I64 (instr_info *ins, int bytemode, int sizeflag) > > ins->scratchbuf[0] = '$'; > print_operand_value (ins, ins->scratchbuf + 1, 1, get64 (ins)); > - oappend_maybe_intel (ins, ins->scratchbuf); > + oappend_maybe_intel (ins, ins->scratchbuf, dis_style_immediate); > ins->scratchbuf[0] = '\0'; > } > > @@ -12184,13 +12275,13 @@ OP_sI (instr_info *ins, int bytemode, int sizeflag) > op = get16 (ins); > break; > default: > - oappend (ins, INTERNAL_DISASSEMBLER_ERROR); > + oappend (ins, INTERNAL_DISASSEMBLER_ERROR, dis_style_text); > return; > } > > ins->scratchbuf[0] = '$'; > print_operand_value (ins, ins->scratchbuf + 1, 1, op); > - oappend_maybe_intel (ins, ins->scratchbuf); > + oappend_maybe_intel (ins, ins->scratchbuf, dis_style_immediate); > } > > static void > @@ -12234,21 +12325,21 @@ OP_J (instr_info *ins, int bytemode, int sizeflag) > ins->used_prefixes |= (ins->prefixes & PREFIX_DATA); > break; > default: > - oappend (ins, INTERNAL_DISASSEMBLER_ERROR); > + oappend (ins, INTERNAL_DISASSEMBLER_ERROR, dis_style_text); > return; > } > disp = ((ins->start_pc + (ins->codep - ins->start_codep) + disp) & mask) > | segment; > set_op (ins, disp, 0); > print_operand_value (ins, ins->scratchbuf, 1, disp); > - oappend (ins, ins->scratchbuf); > + oappend (ins, ins->scratchbuf, dis_style_text); > } > > static void > OP_SEG (instr_info *ins, int bytemode, int sizeflag) > { > if (bytemode == w_mode) > - oappend_maybe_intel (ins, att_names_seg[ins->modrm.reg]); > + oappend_maybe_intel (ins, att_names_seg[ins->modrm.reg], dis_style_text); > else > OP_E (ins, ins->modrm.mod == 3 ? bytemode : w_mode, sizeflag); > } > @@ -12273,7 +12364,7 @@ OP_DIR (instr_info *ins, int dummy ATTRIBUTE_UNUSED, int sizeflag) > sprintf (ins->scratchbuf, "0x%x:0x%x", seg, offset); > else > sprintf (ins->scratchbuf, "$0x%x,$0x%x", seg, offset); > - oappend (ins, ins->scratchbuf); > + oappend (ins, ins->scratchbuf, dis_style_text); > } > > static void > @@ -12294,12 +12385,13 @@ OP_OFF (instr_info *ins, int bytemode, int sizeflag) > { > if (!ins->active_seg_prefix) > { > - oappend_maybe_intel (ins, att_names_seg[ds_reg - es_reg]); > - oappend (ins, ":"); > + oappend_maybe_intel (ins, att_names_seg[ds_reg - es_reg], > + dis_style_register); > + oappend (ins, ":", dis_style_text); > } > } > print_operand_value (ins, ins->scratchbuf, 1, off); > - oappend (ins, ins->scratchbuf); > + oappend (ins, ins->scratchbuf, dis_style_address_offset); > } > > static void > @@ -12324,12 +12416,13 @@ OP_OFF64 (instr_info *ins, int bytemode, int sizeflag) > { > if (!ins->active_seg_prefix) > { > - oappend_maybe_intel (ins, att_names_seg[ds_reg - es_reg]); > - oappend (ins, ":"); > + oappend_maybe_intel (ins, att_names_seg[ds_reg - es_reg], > + dis_style_text); > + oappend (ins, ":", dis_style_text); > } > } > print_operand_value (ins, ins->scratchbuf, 1, off); > - oappend (ins, ins->scratchbuf); > + oappend (ins, ins->scratchbuf, dis_style_address_offset); > } > > static void > @@ -12350,9 +12443,8 @@ ptr_reg (instr_info *ins, int code, int sizeflag) > s = att_names32[code - eAX_reg]; > else > s = att_names16[code - eAX_reg]; > - oappend_maybe_intel (ins, s); > - *ins->obufp++ = ins->close_char; > - *ins->obufp = 0; > + oappend_maybe_intel (ins, s, dis_style_register); > + oappend_char (ins, ins->close_char, dis_style_text); > } > > static void > @@ -12375,7 +12467,8 @@ OP_ESreg (instr_info *ins, int code, int sizeflag) > intel_operand_size (ins, b_mode, sizeflag); > } > } > - oappend_maybe_intel (ins, "%es:"); > + oappend_maybe_intel (ins, "%es", dis_style_register); > + oappend_char (ins, ':', dis_style_text); > ptr_reg (ins, code, sizeflag); > } > > @@ -12425,7 +12518,7 @@ OP_C (instr_info *ins, int dummy ATTRIBUTE_UNUSED, > else > add = 0; > sprintf (ins->scratchbuf, "%%cr%d", ins->modrm.reg + add); > - oappend_maybe_intel (ins, ins->scratchbuf); > + oappend_maybe_intel (ins, ins->scratchbuf, dis_style_text); > } > > static void > @@ -12442,7 +12535,7 @@ OP_D (instr_info *ins, int dummy ATTRIBUTE_UNUSED, > sprintf (ins->scratchbuf, "dr%d", ins->modrm.reg + add); > else > sprintf (ins->scratchbuf, "%%db%d", ins->modrm.reg + add); > - oappend (ins, ins->scratchbuf); > + oappend (ins, ins->scratchbuf, dis_style_text); > } > > static void > @@ -12450,7 +12543,7 @@ OP_T (instr_info *ins, int dummy ATTRIBUTE_UNUSED, > int sizeflag ATTRIBUTE_UNUSED) > { > sprintf (ins->scratchbuf, "%%tr%d", ins->modrm.reg); > - oappend_maybe_intel (ins, ins->scratchbuf); > + oappend_maybe_intel (ins, ins->scratchbuf, dis_style_text); > } > > static void > @@ -12470,7 +12563,7 @@ OP_MMX (instr_info *ins, int bytemode ATTRIBUTE_UNUSED, > } > else > names = att_names_mm; > - oappend_maybe_intel (ins, names[reg]); > + oappend_maybe_intel (ins, names[reg], dis_style_register); > } > > static void > @@ -12501,7 +12594,7 @@ print_vector_reg (instr_info *ins, unsigned int reg, int bytemode) > { > if (reg >= 8) > { > - oappend (ins, "(bad)"); > + oappend (ins, "(bad)", dis_style_text); > return; > } > names = att_names_tmm; > @@ -12543,7 +12636,7 @@ print_vector_reg (instr_info *ins, unsigned int reg, int bytemode) > } > else > names = att_names_xmm; > - oappend_maybe_intel (ins, names[reg]); > + oappend_maybe_intel (ins, names[reg], dis_style_register); > } > > static void > @@ -12603,7 +12696,7 @@ OP_EM (instr_info *ins, int bytemode, int sizeflag) > } > else > names = att_names_mm; > - oappend_maybe_intel (ins, names[reg]); > + oappend_maybe_intel (ins, names[reg], dis_style_register); > } > > /* cvt* are the only instructions in sse2 which have > @@ -12629,7 +12722,7 @@ OP_EMC (instr_info *ins, int bytemode, int sizeflag) > MODRM_CHECK; > ins->codep++; > ins->used_prefixes |= (ins->prefixes & PREFIX_DATA); > - oappend_maybe_intel (ins, att_names_mm[ins->modrm.rm]); > + oappend_maybe_intel (ins, att_names_mm[ins->modrm.rm], dis_style_register); > } > > static void > @@ -12637,7 +12730,7 @@ OP_MXC (instr_info *ins, int bytemode ATTRIBUTE_UNUSED, > int sizeflag ATTRIBUTE_UNUSED) > { > ins->used_prefixes |= (ins->prefixes & PREFIX_DATA); > - oappend_maybe_intel (ins, att_names_mm[ins->modrm.reg]); > + oappend_maybe_intel (ins, att_names_mm[ins->modrm.reg], dis_style_text); > } > > static void > @@ -12813,7 +12906,7 @@ OP_3DNowSuffix (instr_info *ins, int bytemode ATTRIBUTE_UNUSED, > ins->obufp = ins->mnemonicendp; > mnemonic = Suffix3DNow[*ins->codep++ & 0xff]; > if (mnemonic) > - oappend (ins, mnemonic); > + ins->obufp = stpcpy (ins->obufp, mnemonic); > else > { > /* Since a variable sized ins->modrm/ins->sib chunk is between the start > @@ -12902,7 +12995,7 @@ CMP_Fixup (instr_info *ins, int bytemode ATTRIBUTE_UNUSED, > /* We have a reserved extension byte. Output it directly. */ > ins->scratchbuf[0] = '$'; > print_operand_value (ins, ins->scratchbuf + 1, 1, cmp_type); > - oappend_maybe_intel (ins, ins->scratchbuf); > + oappend_maybe_intel (ins, ins->scratchbuf, dis_style_text); > ins->scratchbuf[0] = '\0'; > } > } > @@ -12959,7 +13052,7 @@ BadOp (instr_info *ins) > { > /* Throw away prefixes and 1st. opcode byte. */ > ins->codep = ins->insn_codep + 1; > - oappend (ins, "(bad)"); > + ins->obufp = stpcpy (ins->obufp, "(bad)"); > } > > static void > @@ -13123,7 +13216,7 @@ XMM_Fixup (instr_info *ins, int reg, int sizeflag ATTRIBUTE_UNUSED) > abort (); > } > } > - oappend_maybe_intel (ins, names[reg]); > + oappend_maybe_intel (ins, names[reg], dis_style_text); > } > > static void > @@ -13160,7 +13253,7 @@ OP_VEX (instr_info *ins, int bytemode, int sizeflag ATTRIBUTE_UNUSED) > { > if (ins->vex.evex && !ins->vex.v) > { > - oappend (ins, "(bad)"); > + oappend (ins, "(bad)", dis_style_text); > return; > } > > @@ -13172,7 +13265,7 @@ OP_VEX (instr_info *ins, int bytemode, int sizeflag ATTRIBUTE_UNUSED) > switch (bytemode) > { > case scalar_mode: > - oappend_maybe_intel (ins, att_names_xmm[reg]); > + oappend_maybe_intel (ins, att_names_xmm[reg], dis_style_text); > return; > > case vex_vsib_d_w_dq_mode: > @@ -13183,9 +13276,9 @@ OP_VEX (instr_info *ins, int bytemode, int sizeflag ATTRIBUTE_UNUSED) > if (ins->vex.length == 128 > || (bytemode != vex_vsib_d_w_dq_mode > && !ins->vex.w)) > - oappend_maybe_intel (ins, att_names_xmm[reg]); > + oappend_maybe_intel (ins, att_names_xmm[reg], dis_style_text); > else > - oappend_maybe_intel (ins, att_names_ymm[reg]); > + oappend_maybe_intel (ins, att_names_ymm[reg], dis_style_text); > > /* All 3 XMM/YMM registers must be distinct. */ > modrm_reg = ins->modrm.reg; > @@ -13211,13 +13304,13 @@ OP_VEX (instr_info *ins, int bytemode, int sizeflag ATTRIBUTE_UNUSED) > case tmm_mode: > /* All 3 TMM registers must be distinct. */ > if (reg >= 8) > - oappend (ins, "(bad)"); > + oappend (ins, "(bad)", dis_style_text); > else > { > /* This must be the 3rd operand. */ > if (ins->obufp != ins->op_out[2]) > abort (); > - oappend_maybe_intel (ins, att_names_tmm[reg]); > + oappend_maybe_intel (ins, att_names_tmm[reg], dis_style_text); > if (reg == ins->modrm.reg || reg == ins->modrm.rm) > strcpy (ins->obufp, "/(bad)"); > } > @@ -13254,7 +13347,7 @@ OP_VEX (instr_info *ins, int bytemode, int sizeflag ATTRIBUTE_UNUSED) > case mask_mode: > if (reg > 0x7) > { > - oappend (ins, "(bad)"); > + oappend (ins, "(bad)", dis_style_text); > return; > } > names = att_names_mask; > @@ -13274,14 +13367,14 @@ OP_VEX (instr_info *ins, int bytemode, int sizeflag ATTRIBUTE_UNUSED) > case mask_mode: > if (reg > 0x7) > { > - oappend (ins, "(bad)"); > + oappend (ins, "(bad)", dis_style_text); > return; > } > names = att_names_mask; > break; > default: > /* See PR binutils/20893 for a reproducer. */ > - oappend (ins, "(bad)"); > + oappend (ins, "(bad)", dis_style_text); > return; > } > break; > @@ -13292,7 +13385,7 @@ OP_VEX (instr_info *ins, int bytemode, int sizeflag ATTRIBUTE_UNUSED) > abort (); > break; > } > - oappend_maybe_intel (ins, names[reg]); > + oappend_maybe_intel (ins, names[reg], dis_style_register); > } > > static void > @@ -13335,7 +13428,7 @@ OP_REG_VexI4 (instr_info *ins, int bytemode, int sizeflag ATTRIBUTE_UNUSED) > if (bytemode == x_mode && ins->vex.length == 256) > names = att_names_ymm; > > - oappend_maybe_intel (ins, names[reg]); > + oappend_maybe_intel (ins, names[reg], dis_style_text); > > if (ins->vex.w) > { > @@ -13352,7 +13445,7 @@ OP_VexI4 (instr_info *ins, int bytemode ATTRIBUTE_UNUSED, > { > ins->scratchbuf[0] = '$'; > print_operand_value (ins, ins->scratchbuf + 1, 1, ins->codep[-1] & 0xf); > - oappend_maybe_intel (ins, ins->scratchbuf); > + oappend_maybe_intel (ins, ins->scratchbuf, dis_style_text); > } > > static void > @@ -13397,7 +13490,7 @@ VPCMP_Fixup (instr_info *ins, int bytemode ATTRIBUTE_UNUSED, > /* We have a reserved extension byte. Output it directly. */ > ins->scratchbuf[0] = '$'; > print_operand_value (ins, ins->scratchbuf + 1, 1, cmp_type); > - oappend_maybe_intel (ins, ins->scratchbuf); > + oappend_maybe_intel (ins, ins->scratchbuf, dis_style_text); > ins->scratchbuf[0] = '\0'; > } > } > @@ -13449,7 +13542,7 @@ VPCOM_Fixup (instr_info *ins, int bytemode ATTRIBUTE_UNUSED, > /* We have a reserved extension byte. Output it directly. */ > ins->scratchbuf[0] = '$'; > print_operand_value (ins, ins->scratchbuf + 1, 1, cmp_type); > - oappend_maybe_intel (ins, ins->scratchbuf); > + oappend_maybe_intel (ins, ins->scratchbuf, dis_style_text); > ins->scratchbuf[0] = '\0'; > } > } > @@ -13497,7 +13590,7 @@ PCLMUL_Fixup (instr_info *ins, int bytemode ATTRIBUTE_UNUSED, > /* We have a reserved extension byte. Output it directly. */ > ins->scratchbuf[0] = '$'; > print_operand_value (ins, ins->scratchbuf + 1, 1, pclmul_type); > - oappend_maybe_intel (ins, ins->scratchbuf); > + oappend_maybe_intel (ins, ins->scratchbuf, dis_style_immediate); > ins->scratchbuf[0] = '\0'; > } > } > @@ -13526,7 +13619,7 @@ MOVSXD_Fixup (instr_info *ins, int bytemode, int sizeflag) > *p++ = 'd'; > break; > default: > - oappend (ins, INTERNAL_DISASSEMBLER_ERROR); > + oappend (ins, INTERNAL_DISASSEMBLER_ERROR, dis_style_text); > break; > } > > @@ -13569,7 +13662,7 @@ DistinctDest_Fixup (instr_info *ins, int bytemode, int sizeflag) > || (ins->modrm.mod == 3 > && modrm_reg == modrm_rm)) > { > - oappend (ins, "(bad)"); > + oappend (ins, "(bad)", dis_style_text); > } > else > OP_XMM (ins, bytemode, sizeflag); > @@ -13589,14 +13682,14 @@ OP_Rounding (instr_info *ins, int bytemode, int sizeflag ATTRIBUTE_UNUSED) > /* Fall through. */ > case evex_rounding_mode: > ins->evex_used |= EVEX_b_used; > - oappend (ins, names_rounding[ins->vex.ll]); > + oappend (ins, names_rounding[ins->vex.ll], dis_style_text); > break; > case evex_sae_mode: > ins->evex_used |= EVEX_b_used; > - oappend (ins, "{"); > + oappend (ins, "{", dis_style_text); > break; > default: > abort (); > } > - oappend (ins, "sae}"); > + oappend (ins, "sae}", dis_style_text); > } > -- > 2.25.4 > -- H.J.