FormatterATT.c (16831B)
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/FormatterATT.h> 28 29 /* ============================================================================================== */ 30 /* Constants */ 31 /* ============================================================================================== */ 32 33 #include <Generated/FormatterStrings.inc> 34 35 /* ============================================================================================== */ 36 /* Formatter functions */ 37 /* ============================================================================================== */ 38 39 /* ---------------------------------------------------------------------------------------------- */ 40 /* Instruction */ 41 /* ---------------------------------------------------------------------------------------------- */ 42 43 ZyanStatus ZydisFormatterATTFormatInstruction(const ZydisFormatter* formatter, 44 ZydisFormatterBuffer* buffer, ZydisFormatterContext* context) 45 { 46 ZYAN_ASSERT(formatter); 47 ZYAN_ASSERT(buffer); 48 ZYAN_ASSERT(context); 49 ZYAN_ASSERT(context->instruction); 50 ZYAN_ASSERT(context->operands); 51 52 ZYAN_CHECK(formatter->func_print_prefixes(formatter, buffer, context)); 53 ZYAN_CHECK(formatter->func_print_mnemonic(formatter, buffer, context)); 54 55 ZyanUPointer state_mnemonic; 56 ZYDIS_BUFFER_REMEMBER(buffer, state_mnemonic); 57 58 const ZyanI8 c = (ZyanI8)context->instruction->operand_count_visible - 1; 59 for (ZyanI8 i = c; i >= 0; --i) 60 { 61 const ZydisDecodedOperand* const operand = &context->operands[i]; 62 63 // Print embedded-mask registers as decorator instead of a regular operand 64 if ((i == 1) && (operand->type == ZYDIS_OPERAND_TYPE_REGISTER) && 65 (operand->encoding == ZYDIS_OPERAND_ENCODING_MASK)) 66 { 67 continue; 68 } 69 70 ZyanUPointer buffer_state; 71 ZYDIS_BUFFER_REMEMBER(buffer, buffer_state); 72 73 if (buffer_state != state_mnemonic) 74 { 75 ZYDIS_BUFFER_APPEND(buffer, DELIM_OPERAND); 76 } else 77 { 78 ZYDIS_BUFFER_APPEND(buffer, DELIM_MNEMONIC); 79 } 80 81 // Set current operand 82 context->operand = operand; 83 84 ZyanStatus status; 85 if (formatter->func_pre_operand) 86 { 87 status = formatter->func_pre_operand(formatter, buffer, context); 88 if (status == ZYDIS_STATUS_SKIP_TOKEN) 89 { 90 ZYAN_CHECK(ZydisFormatterBufferRestore(buffer, buffer_state)); 91 continue; 92 } 93 if (!ZYAN_SUCCESS(status)) 94 { 95 return status; 96 } 97 } 98 99 switch (operand->type) 100 { 101 case ZYDIS_OPERAND_TYPE_REGISTER: 102 status = formatter->func_format_operand_reg(formatter, buffer, context); 103 break; 104 case ZYDIS_OPERAND_TYPE_MEMORY: 105 status = formatter->func_format_operand_mem(formatter, buffer, context); 106 break; 107 case ZYDIS_OPERAND_TYPE_POINTER: 108 status = formatter->func_format_operand_ptr(formatter, buffer, context); 109 break; 110 case ZYDIS_OPERAND_TYPE_IMMEDIATE: 111 status = formatter->func_format_operand_imm(formatter, buffer, context); 112 break; 113 default: 114 return ZYAN_STATUS_INVALID_ARGUMENT; 115 } 116 if (status == ZYDIS_STATUS_SKIP_TOKEN) 117 { 118 ZYAN_CHECK(ZydisFormatterBufferRestore(buffer, buffer_state)); 119 continue; 120 } 121 if (!ZYAN_SUCCESS(status)) 122 { 123 return status; 124 } 125 126 if (formatter->func_post_operand) 127 { 128 status = formatter->func_post_operand(formatter, buffer, context); 129 if (status == ZYDIS_STATUS_SKIP_TOKEN) 130 { 131 ZYAN_CHECK(ZydisFormatterBufferRestore(buffer, buffer_state)); 132 continue; 133 } 134 if (ZYAN_SUCCESS(status)) 135 { 136 return status; 137 } 138 } 139 140 #if !defined(ZYDIS_DISABLE_AVX512) || !defined(ZYDIS_DISABLE_KNC) 141 if ((context->instruction->encoding == ZYDIS_INSTRUCTION_ENCODING_EVEX) || 142 (context->instruction->encoding == ZYDIS_INSTRUCTION_ENCODING_MVEX)) 143 { 144 if ((i == 0) && 145 (context->instruction->operand_count_visible > 1) && 146 (context->operands[1].encoding == ZYDIS_OPERAND_ENCODING_MASK)) 147 { 148 ZYAN_CHECK(formatter->func_print_decorator(formatter, buffer, context, 149 ZYDIS_DECORATOR_MASK)); 150 } 151 if (operand->type == ZYDIS_OPERAND_TYPE_MEMORY) 152 { 153 ZYAN_CHECK(formatter->func_print_decorator(formatter, buffer, context, 154 ZYDIS_DECORATOR_BC)); 155 if (context->instruction->encoding == ZYDIS_INSTRUCTION_ENCODING_MVEX) 156 { 157 ZYAN_CHECK(formatter->func_print_decorator(formatter, buffer, context, 158 ZYDIS_DECORATOR_CONVERSION)); 159 ZYAN_CHECK(formatter->func_print_decorator(formatter, buffer, context, 160 ZYDIS_DECORATOR_EH)); 161 } 162 } else 163 { 164 ZyanBool decorate_operand; 165 if (i == (context->instruction->operand_count_visible - 1)) 166 { 167 decorate_operand = operand->type != ZYDIS_OPERAND_TYPE_IMMEDIATE; 168 } 169 else 170 { 171 decorate_operand = 172 (context->instruction->operand_count_visible > (i + 1)) && 173 ((context->operands[i + 1].type == ZYDIS_OPERAND_TYPE_IMMEDIATE) || 174 (context->operands[i + 1].visibility == ZYDIS_OPERAND_VISIBILITY_HIDDEN)); 175 } 176 if (decorate_operand) 177 { 178 if (context->instruction->encoding == ZYDIS_INSTRUCTION_ENCODING_MVEX) 179 { 180 ZYAN_CHECK(formatter->func_print_decorator(formatter, buffer, context, 181 ZYDIS_DECORATOR_SWIZZLE)); 182 } 183 ZYAN_CHECK(formatter->func_print_decorator(formatter, buffer, context, 184 ZYDIS_DECORATOR_RC)); 185 ZYAN_CHECK(formatter->func_print_decorator(formatter, buffer, context, 186 ZYDIS_DECORATOR_SAE)); 187 } 188 } 189 } 190 #endif 191 } 192 193 return ZYAN_STATUS_SUCCESS; 194 } 195 196 /* ---------------------------------------------------------------------------------------------- */ 197 /* Operands */ 198 /* ---------------------------------------------------------------------------------------------- */ 199 200 ZyanStatus ZydisFormatterATTFormatOperandMEM(const ZydisFormatter* formatter, 201 ZydisFormatterBuffer* buffer, ZydisFormatterContext* context) 202 { 203 ZYAN_ASSERT(formatter); 204 ZYAN_ASSERT(buffer); 205 ZYAN_ASSERT(context); 206 207 ZYAN_CHECK(formatter->func_print_segment(formatter, buffer, context)); 208 209 const ZyanBool absolute = !formatter->force_relative_riprel && 210 (context->runtime_address != ZYDIS_RUNTIME_ADDRESS_NONE); 211 if (absolute && context->operand->mem.disp.has_displacement && 212 (context->operand->mem.index == ZYDIS_REGISTER_NONE) && 213 ((context->operand->mem.base == ZYDIS_REGISTER_NONE) || 214 (context->operand->mem.base == ZYDIS_REGISTER_EIP ) || 215 (context->operand->mem.base == ZYDIS_REGISTER_RIP ))) 216 { 217 // EIP/RIP-relative or absolute-displacement address operand 218 ZYAN_CHECK(formatter->func_print_address_abs(formatter, buffer, context)); 219 } else 220 { 221 const ZyanBool should_print_reg = context->operand->mem.base != ZYDIS_REGISTER_NONE; 222 const ZyanBool should_print_idx = context->operand->mem.index != ZYDIS_REGISTER_NONE; 223 const ZyanBool neither_reg_nor_idx = !should_print_reg && !should_print_idx; 224 225 // Regular memory operand 226 if (neither_reg_nor_idx) 227 { 228 ZYAN_CHECK(formatter->func_print_address_abs(formatter, buffer, context)); 229 } else if (context->operand->mem.disp.has_displacement && context->operand->mem.disp.value) 230 { 231 ZYAN_CHECK(formatter->func_print_disp(formatter, buffer, context)); 232 } 233 234 if (neither_reg_nor_idx) 235 { 236 return ZYAN_STATUS_SUCCESS; 237 } 238 239 ZYDIS_BUFFER_APPEND(buffer, MEMORY_BEGIN_ATT); 240 241 if (should_print_reg) 242 { 243 ZYAN_CHECK(formatter->func_print_register(formatter, buffer, context, 244 context->operand->mem.base)); 245 } 246 if (should_print_idx) 247 { 248 ZYDIS_BUFFER_APPEND(buffer, DELIM_MEMORY); 249 ZYAN_CHECK(formatter->func_print_register(formatter, buffer, context, 250 context->operand->mem.index)); 251 if (context->operand->mem.scale && 252 (context->operand->mem.type != ZYDIS_MEMOP_TYPE_MIB) && 253 ((context->operand->mem.scale > 1) || formatter->force_memory_scale)) 254 { 255 ZYDIS_BUFFER_APPEND_TOKEN(buffer, ZYDIS_TOKEN_DELIMITER); 256 ZYDIS_BUFFER_APPEND(buffer, DELIM_MEMORY); 257 ZYDIS_BUFFER_APPEND_TOKEN(buffer, ZYDIS_TOKEN_IMMEDIATE); 258 ZYAN_CHECK(ZydisStringAppendDecU(&buffer->string, context->operand->mem.scale, 0, 259 ZYAN_NULL, ZYAN_NULL)); 260 } 261 } 262 263 ZYDIS_BUFFER_APPEND(buffer, MEMORY_END_ATT); 264 return ZYAN_STATUS_SUCCESS; 265 } 266 267 return ZYAN_STATUS_SUCCESS; 268 } 269 270 /* ---------------------------------------------------------------------------------------------- */ 271 /* Elemental tokens */ 272 /* ---------------------------------------------------------------------------------------------- */ 273 274 ZyanStatus ZydisFormatterATTPrintMnemonic(const ZydisFormatter* formatter, 275 ZydisFormatterBuffer* buffer, ZydisFormatterContext* context) 276 { 277 ZYAN_ASSERT(formatter); 278 ZYAN_ASSERT(buffer); 279 ZYAN_ASSERT(context); 280 ZYAN_ASSERT(context->instruction); 281 ZYAN_ASSERT(context->operands); 282 283 const ZydisShortString* mnemonic = ZydisMnemonicGetStringWrapped( 284 context->instruction->mnemonic); 285 if (!mnemonic) 286 { 287 ZYDIS_BUFFER_APPEND_CASE(buffer, INVALID_MNEMONIC, formatter->case_mnemonic); 288 return ZYAN_STATUS_SUCCESS; 289 } 290 291 ZYDIS_BUFFER_APPEND_TOKEN(buffer, ZYDIS_TOKEN_MNEMONIC); 292 if (context->instruction->meta.branch_type == ZYDIS_BRANCH_TYPE_FAR) 293 { 294 ZYAN_CHECK(ZydisStringAppendShortCase(&buffer->string, &STR_FAR_ATT, 295 formatter->case_mnemonic)); 296 } 297 ZYAN_CHECK(ZydisStringAppendShortCase(&buffer->string, mnemonic, formatter->case_mnemonic)); 298 299 // Append operand-size suffix 300 ZyanU32 size = 0; 301 for (ZyanU8 i = 0; i < context->instruction->operand_count_visible; ++i) 302 { 303 const ZydisDecodedOperand* const operand = &context->operands[i]; 304 if ((operand->type == ZYDIS_OPERAND_TYPE_MEMORY) && 305 ((operand->mem.type == ZYDIS_MEMOP_TYPE_MEM) || 306 (operand->mem.type == ZYDIS_MEMOP_TYPE_VSIB))) 307 { 308 size = ZydisFormatterHelperGetExplicitSize(formatter, context, operand); 309 break; 310 } 311 } 312 313 switch (size) 314 { 315 case 8: ZydisStringAppendShort(&buffer->string, &STR_SIZE_8_ATT ); break; 316 case 16: ZydisStringAppendShort(&buffer->string, &STR_SIZE_16_ATT ); break; 317 case 32: ZydisStringAppendShort(&buffer->string, &STR_SIZE_32_ATT ); break; 318 case 64: ZydisStringAppendShort(&buffer->string, &STR_SIZE_64_ATT ); break; 319 case 128: ZydisStringAppendShort(&buffer->string, &STR_SIZE_128_ATT); break; 320 case 256: ZydisStringAppendShort(&buffer->string, &STR_SIZE_256_ATT); break; 321 case 512: ZydisStringAppendShort(&buffer->string, &STR_SIZE_512_ATT); break; 322 default: 323 break; 324 } 325 326 if (formatter->print_branch_size) 327 { 328 switch (context->instruction->meta.branch_type) 329 { 330 case ZYDIS_BRANCH_TYPE_NONE: 331 break; 332 case ZYDIS_BRANCH_TYPE_SHORT: 333 return ZydisStringAppendShortCase(&buffer->string, &STR_SHORT, 334 formatter->case_mnemonic); 335 case ZYDIS_BRANCH_TYPE_NEAR: 336 return ZydisStringAppendShortCase(&buffer->string, &STR_NEAR, 337 formatter->case_mnemonic); 338 default: 339 return ZYAN_STATUS_INVALID_ARGUMENT; 340 } 341 } 342 343 return ZYAN_STATUS_SUCCESS; 344 } 345 346 ZyanStatus ZydisFormatterATTPrintRegister(const ZydisFormatter* formatter, 347 ZydisFormatterBuffer* buffer, ZydisFormatterContext* context, ZydisRegister reg) 348 { 349 ZYAN_UNUSED(context); 350 351 ZYAN_ASSERT(formatter); 352 ZYAN_ASSERT(buffer); 353 ZYAN_ASSERT(context); 354 355 ZYDIS_BUFFER_APPEND(buffer, REGISTER); 356 const ZydisShortString* str = ZydisRegisterGetStringWrapped(reg); 357 if (!str) 358 { 359 return ZydisStringAppendShortCase(&buffer->string, &STR_INVALID_REG, 360 formatter->case_registers); 361 } 362 return ZydisStringAppendShortCase(&buffer->string, str, formatter->case_registers); 363 } 364 365 ZyanStatus ZydisFormatterATTPrintAddressABS(const ZydisFormatter* formatter, 366 ZydisFormatterBuffer* buffer, ZydisFormatterContext* context) 367 { 368 ZYAN_ASSERT(formatter); 369 ZYAN_ASSERT(buffer); 370 ZYAN_ASSERT(context); 371 372 if ((context->instruction->meta.branch_type != ZYDIS_BRANCH_TYPE_NONE) && 373 (context->operand->type == ZYDIS_OPERAND_TYPE_MEMORY)) 374 { 375 ZYDIS_BUFFER_APPEND(buffer, MUL); 376 } 377 378 return ZydisFormatterBasePrintAddressABS(formatter, buffer, context); 379 } 380 381 ZyanStatus ZydisFormatterATTPrintDISP(const ZydisFormatter* formatter, 382 ZydisFormatterBuffer* buffer, ZydisFormatterContext* context) 383 { 384 ZYAN_ASSERT(formatter); 385 ZYAN_ASSERT(buffer); 386 ZYAN_ASSERT(context); 387 388 ZYDIS_BUFFER_APPEND_TOKEN(buffer, ZYDIS_TOKEN_DISPLACEMENT); 389 switch (formatter->disp_signedness) 390 { 391 case ZYDIS_SIGNEDNESS_AUTO: 392 case ZYDIS_SIGNEDNESS_SIGNED: 393 ZYDIS_STRING_APPEND_NUM_S(formatter, formatter->disp_base, &buffer->string, 394 context->operand->mem.disp.value, formatter->disp_padding, 395 formatter->hex_force_leading_number, ZYAN_FALSE); 396 break; 397 case ZYDIS_SIGNEDNESS_UNSIGNED: 398 ZYDIS_STRING_APPEND_NUM_U(formatter, formatter->disp_base, &buffer->string, 399 context->operand->mem.disp.value, formatter->disp_padding, 400 formatter->hex_force_leading_number); 401 break; 402 default: 403 return ZYAN_STATUS_INVALID_ARGUMENT; 404 } 405 406 return ZYAN_STATUS_SUCCESS; 407 } 408 409 ZyanStatus ZydisFormatterATTPrintIMM(const ZydisFormatter* formatter, 410 ZydisFormatterBuffer* buffer, ZydisFormatterContext* context) 411 { 412 ZYAN_ASSERT(formatter); 413 ZYAN_ASSERT(buffer); 414 ZYAN_ASSERT(context); 415 416 ZYDIS_BUFFER_APPEND(buffer, IMMEDIATE); 417 return ZydisFormatterBasePrintIMM(formatter, buffer, context); 418 } 419 420 /* ---------------------------------------------------------------------------------------------- */ 421 422 /* ============================================================================================== */