1 /*===-- X86DisassemblerDecoderInternal.h - Disassembler decoder ---*- C -*-===*
3 * The LLVM Compiler Infrastructure
5 * This file is distributed under the University of Illinois Open Source
6 * License. See LICENSE.TXT for details.
8 *===----------------------------------------------------------------------===*
10 * This file is part of the X86 Disassembler.
11 * It contains the public interface of the instruction decoder.
12 * Documentation for the disassembler can be found in X86Disassembler.h.
14 *===----------------------------------------------------------------------===*/
16 #ifndef X86DISASSEMBLERDECODER_H
17 #define X86DISASSEMBLERDECODER_H
23 #define INSTRUCTION_SPECIFIER_FIELDS \
26 #define INSTRUCTION_IDS \
27 uint16_t instructionIDs;
29 #include "X86DisassemblerDecoderCommon.h"
31 #undef INSTRUCTION_SPECIFIER_FIELDS
32 #undef INSTRUCTION_IDS
35 * Accessor functions for various fields of an Intel instruction
37 #define modFromModRM(modRM) (((modRM) & 0xc0) >> 6)
38 #define regFromModRM(modRM) (((modRM) & 0x38) >> 3)
39 #define rmFromModRM(modRM) ((modRM) & 0x7)
40 #define scaleFromSIB(sib) (((sib) & 0xc0) >> 6)
41 #define indexFromSIB(sib) (((sib) & 0x38) >> 3)
42 #define baseFromSIB(sib) ((sib) & 0x7)
43 #define wFromREX(rex) (((rex) & 0x8) >> 3)
44 #define rFromREX(rex) (((rex) & 0x4) >> 2)
45 #define xFromREX(rex) (((rex) & 0x2) >> 1)
46 #define bFromREX(rex) ((rex) & 0x1)
48 #define rFromVEX2of3(vex) (((~(vex)) & 0x80) >> 7)
49 #define xFromVEX2of3(vex) (((~(vex)) & 0x40) >> 6)
50 #define bFromVEX2of3(vex) (((~(vex)) & 0x20) >> 5)
51 #define mmmmmFromVEX2of3(vex) ((vex) & 0x1f)
52 #define wFromVEX3of3(vex) (((vex) & 0x80) >> 7)
53 #define vvvvFromVEX3of3(vex) (((~(vex)) & 0x78) >> 3)
54 #define lFromVEX3of3(vex) (((vex) & 0x4) >> 2)
55 #define ppFromVEX3of3(vex) ((vex) & 0x3)
57 #define rFromVEX2of2(vex) (((~(vex)) & 0x80) >> 7)
58 #define vvvvFromVEX2of2(vex) (((~(vex)) & 0x78) >> 3)
59 #define lFromVEX2of2(vex) (((vex) & 0x4) >> 2)
60 #define ppFromVEX2of2(vex) ((vex) & 0x3)
63 * These enums represent Intel registers for use by the decoder.
88 #define EA_BASES_16BIT \
124 #define EA_BASES_32BIT \
160 #define EA_BASES_64BIT \
308 #define REGS_SEGMENT \
326 #define REGS_CONTROL \
337 #define ALL_EA_BASES \
342 #define ALL_SIB_BASES \
361 * EABase - All possible values of the base field for effective-address
362 * computations, a.k.a. the Mod and R/M fields of the ModR/M byte. We
363 * distinguish between bases (EA_BASE_*) and registers that just happen to be
364 * referred to when Mod == 0b11 (EA_REG_*).
368 #define ENTRY(x) EA_BASE_##x,
371 #define ENTRY(x) EA_REG_##x,
378 * SIBIndex - All possible values of the SIB index field.
379 * Borrows entries from ALL_EA_BASES with the special case that
380 * sib is synonymous with NONE.
381 * Vector SIB: index can be XMM or YMM.
385 #define ENTRY(x) SIB_INDEX_##x,
395 * SIBBase - All possible values of the SIB base field.
399 #define ENTRY(x) SIB_BASE_##x,
406 * EADisplacement - Possible displacement types for effective-address
417 * Reg - All possible values of the reg field in the ModR/M byte.
420 #define ENTRY(x) MODRM_REG_##x,
427 * SegmentOverride - All possible segment overrides.
441 * VEXLeadingOpcodeByte - Possible values for the VEX.m-mmmm field
448 } VEXLeadingOpcodeByte;
451 * VEXPrefixCode - Possible values for the VEX.pp field
455 VEX_PREFIX_NONE = 0x0,
461 typedef uint8_t BOOL;
464 * byteReader_t - Type for the byte reader that the consumer must provide to
465 * the decoder. Reads a single byte from the instruction's address space.
466 * @param arg - A baton that the consumer can associate with any internal
467 * state that it needs.
468 * @param byte - A pointer to a single byte in memory that should be set to
469 * contain the value at address.
470 * @param address - The address in the instruction's address space that should
472 * @return - -1 if the byte cannot be read for any reason; 0 otherwise.
474 typedef int (*byteReader_t)(const void* arg, uint8_t* byte, uint64_t address);
477 * dlog_t - Type for the logging function that the consumer can provide to
478 * get debugging output from the decoder.
479 * @param arg - A baton that the consumer can associate with any internal
480 * state that it needs.
481 * @param log - A string that contains the message. Will be reused after
482 * the logger returns.
484 typedef void (*dlog_t)(void* arg, const char *log);
487 * The x86 internal instruction, which is produced by the decoder.
489 struct InternalInstruction {
490 /* Reader interface (C) */
492 /* Opaque value passed to the reader */
493 const void* readerArg;
494 /* The address of the next byte to read via the reader */
495 uint64_t readerCursor;
497 /* Logger interface (C) */
499 /* Opaque value passed to the logger */
502 /* General instruction information */
504 /* The mode to disassemble for (64-bit, protected, real) */
505 DisassemblerMode mode;
506 /* The start of the instruction, usable with the reader */
507 uint64_t startLocation;
508 /* The length of the instruction, in bytes */
513 /* 1 if the prefix byte corresponding to the entry is present; 0 if not */
514 uint8_t prefixPresent[0x100];
515 /* contains the location (for use with the reader) of the prefix byte */
516 uint64_t prefixLocations[0x100];
517 /* The value of the VEX prefix, if present */
518 uint8_t vexPrefix[3];
519 /* The length of the VEX prefix (0 if not present) */
521 /* The value of the REX prefix, if present */
523 /* The location where a mandatory prefix would have to be (i.e., right before
524 the opcode, or right before the REX prefix if one is present) */
525 uint64_t necessaryPrefixLocation;
526 /* The segment override type */
527 SegmentOverride segmentOverride;
528 /* 1 if the prefix byte, 0xf2 or 0xf3 is xacquire or xrelease */
529 BOOL xAcquireRelease;
531 /* Sizes of various critical pieces of data, in bytes */
532 uint8_t registerSize;
534 uint8_t displacementSize;
535 uint8_t immediateSize;
537 /* Offsets from the start of the instruction to the pieces of data, which is
538 needed to find relocation entries for adding symbolic operands */
539 uint8_t displacementOffset;
540 uint8_t immediateOffset;
544 /* The value of the two-byte escape prefix (usually 0x0f) */
545 uint8_t twoByteEscape;
546 /* The value of the three-byte escape prefix (usually 0x38 or 0x3a) */
547 uint8_t threeByteEscape;
548 /* The last byte of the opcode, not counting any ModR/M extension */
550 /* The ModR/M byte of the instruction, if it is an opcode extension */
551 uint8_t modRMExtension;
555 /* The type of opcode, used for indexing into the array of decode tables */
556 OpcodeType opcodeType;
557 /* The instruction ID, extracted from the decode table */
558 uint16_t instructionID;
559 /* The specifier for the instruction, from the instruction info table */
560 const struct InstructionSpecifier *spec;
562 /* state for additional bytes, consumed during operand decode. Pattern:
563 consumed___ indicates that the byte was already consumed and does not
564 need to be consumed again */
566 /* The VEX.vvvv field, which contains a third register operand for some AVX
570 /* The ModR/M byte, which contains most register operands and some portion of
571 all memory operands */
575 /* The SIB byte, used for more complex 32- or 64-bit memory operands */
579 /* The displacement, used for memory operands */
580 BOOL consumedDisplacement;
581 int32_t displacement;
583 /* Immediates. There can be two in some cases */
584 uint8_t numImmediatesConsumed;
585 uint8_t numImmediatesTranslated;
586 uint64_t immediates[2];
588 /* A register or immediate operand encoded into the opcode */
589 BOOL consumedOpcodeModifier;
590 uint8_t opcodeModifier;
593 /* Portions of the ModR/M byte */
595 /* These fields determine the allowable values for the ModR/M fields, which
596 depend on operand and address widths */
601 /* The Mod and R/M fields can encode a base for an effective address, or a
602 register. These are separated into two fields here */
604 EADisplacement eaDisplacement;
605 /* The reg field always encodes a register */
613 const struct OperandSpecifier *operands;
616 /* decodeInstruction - Decode one instruction and store the decoding results in
617 * a buffer provided by the consumer.
618 * @param insn - The buffer to store the instruction in. Allocated by the
620 * @param reader - The byteReader_t for the bytes to be read.
621 * @param readerArg - An argument to pass to the reader for storing context
622 * specific to the consumer. May be NULL.
623 * @param logger - The dlog_t to be used in printing status messages from the
624 * disassembler. May be NULL.
625 * @param loggerArg - An argument to pass to the logger for storing context
626 * specific to the logger. May be NULL.
627 * @param startLoc - The address (in the reader's address space) of the first
628 * byte in the instruction.
629 * @param mode - The mode (16-bit, 32-bit, 64-bit) to decode in.
630 * @return - Nonzero if there was an error during decode, 0 otherwise.
632 int decodeInstruction(struct InternalInstruction* insn,
634 const void* readerArg,
639 DisassemblerMode mode);
641 /* x86DisassemblerDebug - C-accessible function for printing a message to
643 * @param file - The name of the file printing the debug message.
644 * @param line - The line number that printed the debug message.
645 * @param s - The message to print.
648 void x86DisassemblerDebug(const char *file,
652 const char *x86DisassemblerGetInstrName(unsigned Opcode, const void *mii);