1  /***************************************************************************************************
  2  
  3    Zyan Disassembler Library (Zydis)
  4  
  5    Original Author : Florian Bernd, Joel Hoener
  6  
  7   * Permission is hereby granted, free of charge, to any person obtaining a copy
  8   * of this software and associated documentation files (the "Software"), to deal
  9   * in the Software without restriction, including without limitation the rights
 10   * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 11   * copies of the Software, and to permit persons to whom the Software is
 12   * furnished to do so, subject to the following conditions:
 13   *
 14   * The above copyright notice and this permission notice shall be included in all
 15   * copies or substantial portions of the Software.
 16   *
 17   * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 18   * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 19   * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 20   * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 21   * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 22   * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 23   * SOFTWARE.
 24  
 25  ***************************************************************************************************/
 26  
 27  #include <Zydis/Internal/FormatterBase.h>
 28  #include <Zydis/Utils.h>
 29  
 30  /* ============================================================================================== */
 31  /* Constants                                                                                      */
 32  /* ============================================================================================== */
 33  
 34  #include <Generated/FormatterStrings.inc>
 35  
 36  static const ZydisShortString* const STR_PREF_REX[16] =
 37  {
 38      &STR_PREF_REX_40,
 39      &STR_PREF_REX_41,
 40      &STR_PREF_REX_42,
 41      &STR_PREF_REX_43,
 42      &STR_PREF_REX_44,
 43      &STR_PREF_REX_45,
 44      &STR_PREF_REX_46,
 45      &STR_PREF_REX_47,
 46      &STR_PREF_REX_48,
 47      &STR_PREF_REX_49,
 48      &STR_PREF_REX_4A,
 49      &STR_PREF_REX_4B,
 50      &STR_PREF_REX_4C,
 51      &STR_PREF_REX_4D,
 52      &STR_PREF_REX_4E,
 53      &STR_PREF_REX_4F
 54  };
 55  
 56  static const ZydisPredefinedToken* const TOK_PREF_REX[16] =
 57  {
 58      (const ZydisPredefinedToken* const)&TOK_DATA_PREF_REX_40,
 59      (const ZydisPredefinedToken* const)&TOK_DATA_PREF_REX_41,
 60      (const ZydisPredefinedToken* const)&TOK_DATA_PREF_REX_42,
 61      (const ZydisPredefinedToken* const)&TOK_DATA_PREF_REX_43,
 62      (const ZydisPredefinedToken* const)&TOK_DATA_PREF_REX_44,
 63      (const ZydisPredefinedToken* const)&TOK_DATA_PREF_REX_45,
 64      (const ZydisPredefinedToken* const)&TOK_DATA_PREF_REX_46,
 65      (const ZydisPredefinedToken* const)&TOK_DATA_PREF_REX_47,
 66      (const ZydisPredefinedToken* const)&TOK_DATA_PREF_REX_48,
 67      (const ZydisPredefinedToken* const)&TOK_DATA_PREF_REX_49,
 68      (const ZydisPredefinedToken* const)&TOK_DATA_PREF_REX_4A,
 69      (const ZydisPredefinedToken* const)&TOK_DATA_PREF_REX_4B,
 70      (const ZydisPredefinedToken* const)&TOK_DATA_PREF_REX_4C,
 71      (const ZydisPredefinedToken* const)&TOK_DATA_PREF_REX_4D,
 72      (const ZydisPredefinedToken* const)&TOK_DATA_PREF_REX_4E,
 73      (const ZydisPredefinedToken* const)&TOK_DATA_PREF_REX_4F
 74  };
 75  
 76  /* ============================================================================================== */
 77  /* Helper functions                                                                               */
 78  /* ============================================================================================== */
 79  
 80  ZyanU32 ZydisFormatterHelperGetExplicitSize(const ZydisFormatter* formatter,
 81      ZydisFormatterContext* context, const ZydisDecodedOperand* operand)
 82  {
 83      ZYAN_ASSERT(formatter);
 84      ZYAN_ASSERT(context);
 85      ZYAN_ASSERT(operand);
 86  
 87      ZYAN_ASSERT(operand->type == ZYDIS_OPERAND_TYPE_MEMORY);
 88      ZYAN_ASSERT((operand->mem.type == ZYDIS_MEMOP_TYPE_MEM) ||
 89                  (operand->mem.type == ZYDIS_MEMOP_TYPE_VSIB));
 90  
 91      if (formatter->force_memory_size)
 92      {
 93          return operand->size;
 94      }
 95  
 96      if (!context->operands)
 97      {
 98          // Single operand formatting. We can not derive the explicit size by using the other
 99          // operands.
100          return 0;
101      }
102  
103      switch (operand->id)
104      {
105      case 0:
106          if (context->instruction->operand_count_visible < 2)
107          {
108              return 0;
109          }
110          if ((context->operands[1].type == ZYDIS_OPERAND_TYPE_UNUSED) ||
111              (context->operands[1].type == ZYDIS_OPERAND_TYPE_IMMEDIATE))
112          {
113              return context->operands[0].size;
114          }
115          if (context->operands[0].size != context->operands[1].size)
116          {
117              return context->operands[0].size;
118          }
119          if ((context->operands[1].type == ZYDIS_OPERAND_TYPE_REGISTER) &&
120              (context->operands[1].visibility == ZYDIS_OPERAND_VISIBILITY_IMPLICIT) &&
121              (context->operands[1].reg.value == ZYDIS_REGISTER_CL))
122          {
123              return context->operands[0].size;
124          }
125          break;
126      case 1:
127      case 2:
128          if (context->operands[operand->id - 1].size !=
129              context->operands[operand->id].size)
130          {
131              return context->operands[operand->id].size;
132          }
133          break;
134      default:
135          break;
136      }
137  
138      return 0;
139  }
140  
141  /* ============================================================================================== */
142  /* Formatter functions                                                                            */
143  /* ============================================================================================== */
144  
145  /* ---------------------------------------------------------------------------------------------- */
146  /* Operands                                                                                       */
147  /* ---------------------------------------------------------------------------------------------- */
148  
149  ZyanStatus ZydisFormatterBaseFormatOperandREG(const ZydisFormatter* formatter,
150      ZydisFormatterBuffer* buffer, ZydisFormatterContext* context)
151  {
152      ZYAN_ASSERT(formatter);
153      ZYAN_ASSERT(buffer);
154      ZYAN_ASSERT(context);
155  
156      return formatter->func_print_register(formatter, buffer, context, context->operand->reg.value);
157  }
158  
159  ZyanStatus ZydisFormatterBaseFormatOperandPTR(const ZydisFormatter* formatter,
160      ZydisFormatterBuffer* buffer, ZydisFormatterContext* context)
161  {
162      ZYAN_ASSERT(formatter);
163      ZYAN_ASSERT(buffer);
164      ZYAN_ASSERT(context);
165  
166      ZYDIS_BUFFER_APPEND_TOKEN(buffer, ZYDIS_TOKEN_IMMEDIATE);
167      ZYDIS_STRING_APPEND_NUM_U(formatter, formatter->addr_base, &buffer->string,
168          context->operand->ptr.segment, 4, formatter->hex_force_leading_number);
169      ZYDIS_BUFFER_APPEND(buffer, DELIM_SEGMENT);
170  
171      ZyanU8 padding;
172      switch (context->instruction->operand_width)
173      {
174      case 16:
175          padding = 4;
176          break;
177      case 32:
178          padding = 8;
179          break;
180      default:
181          return ZYAN_STATUS_INVALID_ARGUMENT;
182      }
183  
184      ZYDIS_BUFFER_APPEND_TOKEN(buffer, ZYDIS_TOKEN_IMMEDIATE);
185      ZYDIS_STRING_APPEND_NUM_U(formatter, formatter->addr_base, &buffer->string,
186          context->operand->ptr.offset , padding, formatter->hex_force_leading_number);
187  
188      return ZYAN_STATUS_SUCCESS;
189  }
190  
191  ZyanStatus ZydisFormatterBaseFormatOperandIMM(const ZydisFormatter* formatter,
192      ZydisFormatterBuffer* buffer, ZydisFormatterContext* context)
193  {
194      ZYAN_ASSERT(formatter);
195      ZYAN_ASSERT(buffer);
196      ZYAN_ASSERT(context);
197  
198      // The immediate operand contains an address
199      if (context->operand->imm.is_relative)
200      {
201          const ZyanBool absolute = !formatter->force_relative_branches &&
202              (context->runtime_address != ZYDIS_RUNTIME_ADDRESS_NONE);
203          if (absolute)
204          {
205              return formatter->func_print_address_abs(formatter, buffer, context);
206          }
207          return formatter->func_print_address_rel(formatter, buffer, context);
208      }
209  
210      // The immediate operand contains an actual ordinal value
211      return formatter->func_print_imm(formatter, buffer, context);
212  }
213  
214  /* ---------------------------------------------------------------------------------------------- */
215  /* Elemental tokens                                                                               */
216  /* ---------------------------------------------------------------------------------------------- */
217  
218  ZyanStatus ZydisFormatterBasePrintAddressABS(const ZydisFormatter* formatter,
219      ZydisFormatterBuffer* buffer, ZydisFormatterContext* context)
220  {
221      ZYAN_ASSERT(formatter);
222      ZYAN_ASSERT(buffer);
223      ZYAN_ASSERT(context);
224  
225      ZyanU64 address;
226      ZYAN_CHECK(ZydisCalcAbsoluteAddress(context->instruction, context->operand,
227          context->runtime_address, &address));
228      ZyanU8 padding = (formatter->addr_padding_absolute ==
229          ZYDIS_PADDING_AUTO) ? 0 : (ZyanU8)formatter->addr_padding_absolute;
230      if ((formatter->addr_padding_absolute == ZYDIS_PADDING_AUTO) &&
231          (formatter->addr_base == ZYDIS_NUMERIC_BASE_HEX))
232      {
233          switch (context->instruction->stack_width)
234          {
235          case 16:
236              padding =  4;
237              address = (ZyanU16)address;
238              break;
239          case 32:
240              padding =  8;
241              address = (ZyanU32)address;
242              break;
243          case 64:
244              padding = 16;
245              break;
246          default:
247              return ZYAN_STATUS_INVALID_ARGUMENT;
248          }
249      }
250  
251      ZYDIS_BUFFER_APPEND_TOKEN(buffer, ZYDIS_TOKEN_ADDRESS_ABS);
252      ZYDIS_STRING_APPEND_NUM_U(formatter, formatter->addr_base, &buffer->string, address, padding,
253          formatter->hex_force_leading_number);
254  
255      return ZYAN_STATUS_SUCCESS;
256  }
257  
258  ZyanStatus ZydisFormatterBasePrintAddressREL(const ZydisFormatter* formatter,
259      ZydisFormatterBuffer* buffer, ZydisFormatterContext* context)
260  {
261      ZYAN_ASSERT(formatter);
262      ZYAN_ASSERT(buffer);
263      ZYAN_ASSERT(context);
264  
265      ZyanU64 address;
266      ZYAN_CHECK(ZydisCalcAbsoluteAddress(context->instruction, context->operand, 0, &address));
267  
268      ZyanU8 padding = (formatter->addr_padding_relative ==
269          ZYDIS_PADDING_AUTO) ? 0 : (ZyanU8)formatter->addr_padding_relative;
270      if ((formatter->addr_padding_relative == ZYDIS_PADDING_AUTO) &&
271          (formatter->addr_base == ZYDIS_NUMERIC_BASE_HEX))
272      {
273          switch (context->instruction->stack_width)
274          {
275          case 16:
276              padding =  4;
277              address = (ZyanU16)address;
278              break;
279          case 32:
280              padding =  8;
281              address = (ZyanU32)address;
282              break;
283          case 64:
284              padding = 16;
285              break;
286          default:
287              return ZYAN_STATUS_INVALID_ARGUMENT;
288          }
289      }
290  
291      ZYDIS_BUFFER_APPEND_TOKEN(buffer, ZYDIS_TOKEN_ADDRESS_REL);
292      switch (formatter->addr_signedness)
293      {
294      case ZYDIS_SIGNEDNESS_AUTO:
295      case ZYDIS_SIGNEDNESS_SIGNED:
296          ZYDIS_STRING_APPEND_NUM_S(formatter, formatter->addr_base, &buffer->string, address,
297              padding, formatter->hex_force_leading_number, ZYAN_TRUE);
298          break;
299      case ZYDIS_SIGNEDNESS_UNSIGNED:
300          ZYAN_CHECK(ZydisStringAppendShort(&buffer->string, &STR_ADD));
301          ZYDIS_STRING_APPEND_NUM_U(formatter, formatter->addr_base, &buffer->string, address,
302              padding, formatter->hex_force_leading_number);
303          break;
304      default:
305          return ZYAN_STATUS_INVALID_ARGUMENT;
306      }
307  
308      return ZYAN_STATUS_SUCCESS;
309  }
310  
311  ZyanStatus ZydisFormatterBasePrintIMM(const ZydisFormatter* formatter,
312      ZydisFormatterBuffer* buffer, ZydisFormatterContext* context)
313  {
314      ZYAN_ASSERT(formatter);
315      ZYAN_ASSERT(buffer);
316      ZYAN_ASSERT(context);
317  
318      ZYDIS_BUFFER_APPEND_TOKEN(buffer, ZYDIS_TOKEN_IMMEDIATE);
319  
320      const ZyanBool is_signed =
321          (formatter->imm_signedness == ZYDIS_SIGNEDNESS_SIGNED) ||
322          (formatter->imm_signedness == ZYDIS_SIGNEDNESS_AUTO && (context->operand->imm.is_signed));
323      if (is_signed && (context->operand->imm.value.s < 0))
324      {
325          ZYDIS_STRING_APPEND_NUM_S(formatter, formatter->imm_base, &buffer->string,
326              context->operand->imm.value.s, formatter->imm_padding,
327              formatter->hex_force_leading_number, ZYAN_FALSE);
328          return ZYAN_STATUS_SUCCESS;
329      }
330      ZyanU64 value;
331      ZyanU8 padding = (formatter->imm_padding ==
332          ZYDIS_PADDING_AUTO) ? 0 : (ZyanU8)formatter->imm_padding;
333      switch (context->instruction->operand_width)
334      {
335      case 8:
336          if (formatter->imm_padding == ZYDIS_PADDING_AUTO)
337          {
338              padding =  2;
339          }
340          value = (ZyanU8 )context->operand->imm.value.u;
341          break;
342      case 16:
343          if (formatter->imm_padding == ZYDIS_PADDING_AUTO)
344          {
345              padding =  4;
346          }
347          value = (ZyanU16)context->operand->imm.value.u;
348          break;
349      case 32:
350          if (formatter->imm_padding == ZYDIS_PADDING_AUTO)
351          {
352              padding =  8;
353          }
354          value = (ZyanU32)context->operand->imm.value.u;
355          break;
356      case 64:
357          if (formatter->imm_padding == ZYDIS_PADDING_AUTO)
358          {
359              padding = 16;
360          }
361          value = (ZyanU64)context->operand->imm.value.u;
362          break;
363      default:
364          return ZYAN_STATUS_INVALID_ARGUMENT;
365      }
366      ZYDIS_STRING_APPEND_NUM_U(formatter, formatter->imm_base, &buffer->string, value, padding,
367          formatter->hex_force_leading_number);
368  
369      return ZYAN_STATUS_SUCCESS;
370  }
371  
372  /* ---------------------------------------------------------------------------------------------- */
373  /* Optional tokens                                                                                */
374  /* ---------------------------------------------------------------------------------------------- */
375  
376  ZyanStatus ZydisFormatterBasePrintSegment(const ZydisFormatter* formatter,
377      ZydisFormatterBuffer* buffer, ZydisFormatterContext* context)
378  {
379      ZYAN_ASSERT(formatter);
380      ZYAN_ASSERT(buffer);
381      ZYAN_ASSERT(context);
382  
383      ZyanBool printed_segment = ZYAN_FALSE;
384      switch (context->operand->mem.segment)
385      {
386      case ZYDIS_REGISTER_ES:
387      case ZYDIS_REGISTER_CS:
388      case ZYDIS_REGISTER_FS:
389      case ZYDIS_REGISTER_GS:
390          ZYAN_CHECK(formatter->func_print_register(formatter, buffer, context,
391              context->operand->mem.segment));
392          printed_segment = ZYAN_TRUE;
393          break;
394      case ZYDIS_REGISTER_SS:
395          if ((formatter->force_memory_segment) ||
396              (context->instruction->attributes & ZYDIS_ATTRIB_HAS_SEGMENT_SS))
397          {
398              ZYAN_CHECK(formatter->func_print_register(formatter, buffer, context,
399                  context->operand->mem.segment));
400              printed_segment = ZYAN_TRUE;
401          }
402          break;
403      case ZYDIS_REGISTER_DS:
404          if ((formatter->force_memory_segment) ||
405              (context->instruction->attributes & ZYDIS_ATTRIB_HAS_SEGMENT_DS))
406          {
407              ZYAN_CHECK(formatter->func_print_register(formatter, buffer, context,
408                  context->operand->mem.segment));
409              printed_segment = ZYAN_TRUE;
410          }
411          break;
412      default:
413          break;
414      }
415      if (printed_segment)
416      {
417          ZYDIS_BUFFER_APPEND(buffer, DELIM_SEGMENT);
418      }
419  
420      return ZYAN_STATUS_SUCCESS;
421  }
422  
423  ZyanStatus ZydisFormatterBasePrintPrefixes(const ZydisFormatter* formatter,
424      ZydisFormatterBuffer* buffer, ZydisFormatterContext* context)
425  {
426      ZYAN_ASSERT(formatter);
427      ZYAN_ASSERT(buffer);
428      ZYAN_ASSERT(context);
429  
430      if (formatter->detailed_prefixes)
431      {
432          for (ZyanU8 i = 0; i < context->instruction->raw.prefix_count; ++i)
433          {
434              const ZyanU8 value = context->instruction->raw.prefixes[i].value;
435              switch (context->instruction->raw.prefixes[i].type)
436              {
437              case ZYDIS_PREFIX_TYPE_IGNORED:
438              case ZYDIS_PREFIX_TYPE_MANDATORY:
439              {
440                  if ((value & 0xF0) == 0x40)
441                  {
442                      if (buffer->is_token_list)
443                      {
444                          // TODO: Case
445                          ZYAN_CHECK(ZydisFormatterBufferAppendPredefined(buffer,
446                              TOK_PREF_REX[value & 0x0F]));
447                      } else
448                      {
449                          ZYAN_CHECK(ZydisStringAppendShortCase(&buffer->string,
450                              STR_PREF_REX[value & 0x0F], formatter->case_prefixes));
451                      }
452                  } else
453                  {
454                      switch (value)
455                      {
456                      case 0xF0:
457                          ZYDIS_BUFFER_APPEND_CASE(buffer, PREF_LOCK, formatter->case_prefixes);
458                          break;
459                      case 0x2E:
460                          ZYDIS_BUFFER_APPEND_CASE(buffer, PREF_SEG_CS, formatter->case_prefixes);
461                          break;
462                      case 0x36:
463                          ZYDIS_BUFFER_APPEND_CASE(buffer, PREF_SEG_SS, formatter->case_prefixes);
464                          break;
465                      case 0x3E:
466                          ZYDIS_BUFFER_APPEND_CASE(buffer, PREF_SEG_DS, formatter->case_prefixes);
467                          break;
468                      case 0x26:
469                          ZYDIS_BUFFER_APPEND_CASE(buffer, PREF_SEG_ES, formatter->case_prefixes);
470                          break;
471                      case 0x64:
472                          ZYDIS_BUFFER_APPEND_CASE(buffer, PREF_SEG_FS, formatter->case_prefixes);
473                          break;
474                      case 0x65:
475                          ZYDIS_BUFFER_APPEND_CASE(buffer, PREF_SEG_GS, formatter->case_prefixes);
476                          break;
477                      default:
478                          ZYDIS_BUFFER_APPEND_TOKEN(buffer, ZYDIS_TOKEN_PREFIX);
479                          ZYAN_CHECK(ZydisStringAppendHexU(&buffer->string, value, 0,
480                              formatter->hex_force_leading_number, formatter->hex_uppercase,
481                              ZYAN_NULL, ZYAN_NULL));
482                          ZYDIS_BUFFER_APPEND_TOKEN(buffer, ZYDIS_TOKEN_WHITESPACE);
483                          ZYAN_CHECK(ZydisStringAppendShort(&buffer->string, &STR_WHITESPACE));
484                          break;
485                      }
486                  }
487                  break;
488              }
489              case ZYDIS_PREFIX_TYPE_EFFECTIVE:
490                  switch (value)
491                  {
492                  case 0xF0:
493                      ZYDIS_BUFFER_APPEND_CASE(buffer, PREF_LOCK, formatter->case_prefixes);
494                      break;
495                  case 0xF2:
496                      if (context->instruction->attributes & ZYDIS_ATTRIB_HAS_XACQUIRE)
497                      {
498                          ZYDIS_BUFFER_APPEND_CASE(buffer, PREF_XACQUIRE, formatter->case_prefixes);
499                      }
500                      if (context->instruction->attributes & ZYDIS_ATTRIB_HAS_REPNE)
501                      {
502                          ZYDIS_BUFFER_APPEND_CASE(buffer, PREF_REPNE, formatter->case_prefixes);
503                      }
504  
505                      if (context->instruction->attributes & ZYDIS_ATTRIB_HAS_BND)
506                      {
507                          ZYDIS_BUFFER_APPEND_CASE(buffer, PREF_BND, formatter->case_prefixes);
508                      }
509                      break;
510                  case 0xF3:
511                      if (context->instruction->attributes & ZYDIS_ATTRIB_HAS_XRELEASE)
512                      {
513                          ZYDIS_BUFFER_APPEND_CASE(buffer, PREF_XRELEASE, formatter->case_prefixes);
514                      }
515                      if (context->instruction->attributes & ZYDIS_ATTRIB_HAS_REP)
516                      {
517                          ZYDIS_BUFFER_APPEND_CASE(buffer, PREF_REP, formatter->case_prefixes);
518                      }
519                      if (context->instruction->attributes & ZYDIS_ATTRIB_HAS_REPE)
520                      {
521                          ZYDIS_BUFFER_APPEND_CASE(buffer, PREF_REPE, formatter->case_prefixes);
522                      }
523                      break;
524                  default:
525                      break;
526                  }
527                  break;
528              default:
529                  return ZYAN_STATUS_INVALID_ARGUMENT;
530              }
531          }
532          return ZYAN_STATUS_SUCCESS;
533      }
534  
535      if (context->instruction->attributes & ZYDIS_ATTRIB_HAS_XACQUIRE)
536      {
537          ZYDIS_BUFFER_APPEND_CASE(buffer, PREF_XACQUIRE, formatter->case_prefixes);
538      }
539      if (context->instruction->attributes & ZYDIS_ATTRIB_HAS_XRELEASE)
540      {
541          ZYDIS_BUFFER_APPEND_CASE(buffer, PREF_XRELEASE, formatter->case_prefixes);
542      }
543  
544      if (context->instruction->attributes & ZYDIS_ATTRIB_HAS_LOCK)
545      {
546          ZYDIS_BUFFER_APPEND_CASE(buffer, PREF_LOCK, formatter->case_prefixes);
547      }
548  
549      if (context->instruction->attributes & ZYDIS_ATTRIB_HAS_BND)
550      {
551          ZYDIS_BUFFER_APPEND_CASE(buffer, PREF_BND, formatter->case_prefixes);
552      }
553  
554      if (context->instruction->attributes & ZYDIS_ATTRIB_HAS_NOTRACK)
555      {
556          ZYDIS_BUFFER_APPEND_CASE(buffer, PREF_NOTRACK, formatter->case_prefixes);
557      }
558  
559      if (context->instruction->attributes & ZYDIS_ATTRIB_HAS_REP)
560      {
561          ZYDIS_BUFFER_APPEND_CASE(buffer, PREF_REP, formatter->case_prefixes);
562          return ZYAN_STATUS_SUCCESS;
563      }
564      if (context->instruction->attributes & ZYDIS_ATTRIB_HAS_REPE)
565      {
566          ZYDIS_BUFFER_APPEND_CASE(buffer, PREF_REPE, formatter->case_prefixes);
567          return ZYAN_STATUS_SUCCESS;
568      }
569      if (context->instruction->attributes & ZYDIS_ATTRIB_HAS_REPNE)
570      {
571          ZYDIS_BUFFER_APPEND_CASE(buffer, PREF_REPNE, formatter->case_prefixes);
572          return ZYAN_STATUS_SUCCESS;
573      }
574  
575      return ZYAN_STATUS_SUCCESS;
576  }
577  
578  ZyanStatus ZydisFormatterBasePrintDecorator(const ZydisFormatter* formatter,
579      ZydisFormatterBuffer* buffer, ZydisFormatterContext* context, ZydisDecorator decorator)
580  {
581      ZYAN_ASSERT(formatter);
582      ZYAN_ASSERT(buffer);
583      ZYAN_ASSERT(context);
584  
585  #if defined(ZYDIS_DISABLE_AVX512) && defined(ZYDIS_DISABLE_KNC)
586      ZYAN_UNUSED(formatter);
587      ZYAN_UNUSED(buffer);
588      ZYAN_UNUSED(context);
589  #endif
590  
591      switch (decorator)
592      {
593      case ZYDIS_DECORATOR_MASK:
594      {
595  #if !defined(ZYDIS_DISABLE_AVX512) || !defined(ZYDIS_DISABLE_KNC)
596          if (context->instruction->avx.mask.reg != ZYDIS_REGISTER_K0)
597          {
598              if (buffer->is_token_list)
599              {
600                  ZYDIS_BUFFER_APPEND(buffer, DECO_BEGIN);
601                  ZYAN_CHECK(formatter->func_print_register(formatter, buffer, context,
602                      context->instruction->avx.mask.reg));
603                  ZYDIS_BUFFER_APPEND(buffer, DECO_END);
604              } else
605              {
606                  ZYAN_CHECK(ZydisStringAppendShort(&buffer->string, &STR_DECO_BEGIN));
607                  ZYAN_CHECK(formatter->func_print_register(formatter, buffer, context,
608                      context->instruction->avx.mask.reg));
609                  ZYAN_CHECK(ZydisStringAppendShort(&buffer->string, &STR_DECO_END));
610              }
611  
612              // Only print the zeroing decorator, if the instruction is not a "zeroing masking only"
613              // instruction (e.g. `vcmpsd`)
614              if ((context->instruction->avx.mask.mode == ZYDIS_MASK_MODE_ZEROING ||
615                   context->instruction->avx.mask.mode == ZYDIS_MASK_MODE_CONTROL_ZEROING) &&
616                  (context->instruction->raw.evex.z))
617              {
618                  ZYDIS_BUFFER_APPEND_CASE(buffer, DECO_ZERO, formatter->case_decorators);
619              }
620          }
621  #endif
622          break;
623      }
624      case ZYDIS_DECORATOR_BC:
625  #if !defined(ZYDIS_DISABLE_AVX512)
626          if (!context->instruction->avx.broadcast.is_static)
627          {
628              switch (context->instruction->avx.broadcast.mode)
629              {
630              case ZYDIS_BROADCAST_MODE_INVALID:
631                  break;
632              case ZYDIS_BROADCAST_MODE_1_TO_2:
633                  ZYDIS_BUFFER_APPEND_CASE(buffer, DECO_1TO2, formatter->case_decorators);
634                  break;
635              case ZYDIS_BROADCAST_MODE_1_TO_4:
636                  ZYDIS_BUFFER_APPEND_CASE(buffer, DECO_1TO4, formatter->case_decorators);
637                  break;
638              case ZYDIS_BROADCAST_MODE_1_TO_8:
639                  ZYDIS_BUFFER_APPEND_CASE(buffer, DECO_1TO8, formatter->case_decorators);
640                  break;
641              case ZYDIS_BROADCAST_MODE_1_TO_16:
642                  ZYDIS_BUFFER_APPEND_CASE(buffer, DECO_1TO16, formatter->case_decorators);
643                  break;
644              case ZYDIS_BROADCAST_MODE_1_TO_32:
645                  ZYDIS_BUFFER_APPEND_CASE(buffer, DECO_1TO32, formatter->case_decorators);
646                  break;
647              case ZYDIS_BROADCAST_MODE_1_TO_64:
648                  ZYDIS_BUFFER_APPEND_CASE(buffer, DECO_1TO64, formatter->case_decorators);
649                  break;
650              case ZYDIS_BROADCAST_MODE_4_TO_8:
651                  ZYDIS_BUFFER_APPEND_CASE(buffer, DECO_4TO8, formatter->case_decorators);
652                  break;
653              case ZYDIS_BROADCAST_MODE_4_TO_16:
654                  ZYDIS_BUFFER_APPEND_CASE(buffer, DECO_4TO16, formatter->case_decorators);
655                  break;
656              case ZYDIS_BROADCAST_MODE_8_TO_16:
657                  ZYDIS_BUFFER_APPEND_CASE(buffer, DECO_8TO16, formatter->case_decorators);
658                  break;
659              default:
660                  return ZYAN_STATUS_INVALID_ARGUMENT;
661              }
662          }
663  #endif
664          break;
665      case ZYDIS_DECORATOR_RC:
666  #if !defined(ZYDIS_DISABLE_AVX512)
667          if (context->instruction->avx.has_sae)
668          {
669              switch (context->instruction->avx.rounding.mode)
670              {
671              case ZYDIS_ROUNDING_MODE_INVALID:
672                  break;
673              case ZYDIS_ROUNDING_MODE_RN:
674                  ZYDIS_BUFFER_APPEND_CASE(buffer, DECO_RN_SAE, formatter->case_decorators);
675                  break;
676              case ZYDIS_ROUNDING_MODE_RD:
677                  ZYDIS_BUFFER_APPEND_CASE(buffer, DECO_RD_SAE, formatter->case_decorators);
678                  break;
679              case ZYDIS_ROUNDING_MODE_RU:
680                  ZYDIS_BUFFER_APPEND_CASE(buffer, DECO_RU_SAE, formatter->case_decorators);
681                  break;
682              case ZYDIS_ROUNDING_MODE_RZ:
683                  ZYDIS_BUFFER_APPEND_CASE(buffer, DECO_RZ_SAE, formatter->case_decorators);
684                  break;
685              default:
686                  return ZYAN_STATUS_INVALID_ARGUMENT;
687              }
688          } else
689          {
690              switch (context->instruction->avx.rounding.mode)
691              {
692              case ZYDIS_ROUNDING_MODE_INVALID:
693                  break;
694              case ZYDIS_ROUNDING_MODE_RN:
695                  ZYDIS_BUFFER_APPEND_CASE(buffer, DECO_RN, formatter->case_decorators);
696                  break;
697              case ZYDIS_ROUNDING_MODE_RD:
698                  ZYDIS_BUFFER_APPEND_CASE(buffer, DECO_RD, formatter->case_decorators);
699                  break;
700              case ZYDIS_ROUNDING_MODE_RU:
701                  ZYDIS_BUFFER_APPEND_CASE(buffer, DECO_RU, formatter->case_decorators);
702                  break;
703              case ZYDIS_ROUNDING_MODE_RZ:
704                  ZYDIS_BUFFER_APPEND_CASE(buffer, DECO_RZ, formatter->case_decorators);
705                  break;
706              default:
707                  return ZYAN_STATUS_INVALID_ARGUMENT;
708              }
709          }
710  #endif
711          break;
712      case ZYDIS_DECORATOR_SAE:
713  #if !defined(ZYDIS_DISABLE_AVX512)
714          if (context->instruction->avx.has_sae && !context->instruction->avx.rounding.mode)
715          {
716              ZYDIS_BUFFER_APPEND_CASE(buffer, DECO_SAE, formatter->case_decorators);
717          }
718  #endif
719          break;
720      case ZYDIS_DECORATOR_SWIZZLE:
721  #if !defined(ZYDIS_DISABLE_KNC)
722          switch (context->instruction->avx.swizzle.mode)
723          {
724          case ZYDIS_SWIZZLE_MODE_INVALID:
725          case ZYDIS_SWIZZLE_MODE_DCBA:
726              // Nothing to do here
727              break;
728          case ZYDIS_SWIZZLE_MODE_CDAB:
729              ZYDIS_BUFFER_APPEND_CASE(buffer, DECO_CDAB, formatter->case_decorators);
730              break;
731          case ZYDIS_SWIZZLE_MODE_BADC:
732              ZYDIS_BUFFER_APPEND_CASE(buffer, DECO_BADC, formatter->case_decorators);
733              break;
734          case ZYDIS_SWIZZLE_MODE_DACB:
735              ZYDIS_BUFFER_APPEND_CASE(buffer, DECO_DACB, formatter->case_decorators);
736              break;
737          case ZYDIS_SWIZZLE_MODE_AAAA:
738              ZYDIS_BUFFER_APPEND_CASE(buffer, DECO_AAAA, formatter->case_decorators);
739              break;
740          case ZYDIS_SWIZZLE_MODE_BBBB:
741              ZYDIS_BUFFER_APPEND_CASE(buffer, DECO_BBBB, formatter->case_decorators);
742              break;
743          case ZYDIS_SWIZZLE_MODE_CCCC:
744              ZYDIS_BUFFER_APPEND_CASE(buffer, DECO_CCCC, formatter->case_decorators);
745              break;
746          case ZYDIS_SWIZZLE_MODE_DDDD:
747              ZYDIS_BUFFER_APPEND_CASE(buffer, DECO_DDDD, formatter->case_decorators);
748              break;
749          default:
750              return ZYAN_STATUS_INVALID_ARGUMENT;
751          }
752  #endif
753          break;
754      case ZYDIS_DECORATOR_CONVERSION:
755  #if !defined(ZYDIS_DISABLE_KNC)
756          switch (context->instruction->avx.conversion.mode)
757          {
758          case ZYDIS_CONVERSION_MODE_INVALID:
759              break;
760          case ZYDIS_CONVERSION_MODE_FLOAT16:
761              ZYDIS_BUFFER_APPEND_CASE(buffer, DECO_FLOAT16, formatter->case_decorators);
762              break;
763          case ZYDIS_CONVERSION_MODE_SINT8:
764              ZYDIS_BUFFER_APPEND_CASE(buffer, DECO_SINT8, formatter->case_decorators);
765              break;
766          case ZYDIS_CONVERSION_MODE_UINT8:
767              ZYDIS_BUFFER_APPEND_CASE(buffer, DECO_UINT8, formatter->case_decorators);
768              break;
769          case ZYDIS_CONVERSION_MODE_SINT16:
770              ZYDIS_BUFFER_APPEND_CASE(buffer, DECO_SINT16, formatter->case_decorators);
771              break;
772          case ZYDIS_CONVERSION_MODE_UINT16:
773              ZYDIS_BUFFER_APPEND_CASE(buffer, DECO_UINT16, formatter->case_decorators);
774              break;
775          default:
776              return ZYAN_STATUS_INVALID_ARGUMENT;
777          }
778  #endif
779          break;
780      case ZYDIS_DECORATOR_EH:
781  #if !defined(ZYDIS_DISABLE_KNC)
782          if (context->instruction->avx.has_eviction_hint)
783          {
784              ZYDIS_BUFFER_APPEND_CASE(buffer, DECO_EH, formatter->case_decorators);
785          }
786  #endif
787          break;
788      default:
789          return ZYAN_STATUS_INVALID_ARGUMENT;
790      }
791  
792      return ZYAN_STATUS_SUCCESS;
793  }
794  
795  /* ---------------------------------------------------------------------------------------------- */
796  
797  /* ============================================================================================== */