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 LLVM_LIB_TARGET_X86_DISASSEMBLER_X86DISASSEMBLERDECODER_H
17 #define LLVM_LIB_TARGET_X86_DISASSEMBLER_X86DISASSEMBLERDECODER_H
19 #include "X86DisassemblerDecoderCommon.h"
20 #include "llvm/ADT/ArrayRef.h"
23 namespace X86Disassembler
{
25 // Accessor functions for various fields of an Intel instruction
26 #define modFromModRM(modRM) (((modRM) & 0xc0) >> 6)
27 #define regFromModRM(modRM) (((modRM) & 0x38) >> 3)
28 #define rmFromModRM(modRM) ((modRM) & 0x7)
29 #define scaleFromSIB(sib) (((sib) & 0xc0) >> 6)
30 #define indexFromSIB(sib) (((sib) & 0x38) >> 3)
31 #define baseFromSIB(sib) ((sib) & 0x7)
32 #define wFromREX(rex) (((rex) & 0x8) >> 3)
33 #define rFromREX(rex) (((rex) & 0x4) >> 2)
34 #define xFromREX(rex) (((rex) & 0x2) >> 1)
35 #define bFromREX(rex) ((rex) & 0x1)
37 #define rFromEVEX2of4(evex) (((~(evex)) & 0x80) >> 7)
38 #define xFromEVEX2of4(evex) (((~(evex)) & 0x40) >> 6)
39 #define bFromEVEX2of4(evex) (((~(evex)) & 0x20) >> 5)
40 #define r2FromEVEX2of4(evex) (((~(evex)) & 0x10) >> 4)
41 #define mmFromEVEX2of4(evex) ((evex) & 0x3)
42 #define wFromEVEX3of4(evex) (((evex) & 0x80) >> 7)
43 #define vvvvFromEVEX3of4(evex) (((~(evex)) & 0x78) >> 3)
44 #define ppFromEVEX3of4(evex) ((evex) & 0x3)
45 #define zFromEVEX4of4(evex) (((evex) & 0x80) >> 7)
46 #define l2FromEVEX4of4(evex) (((evex) & 0x40) >> 6)
47 #define lFromEVEX4of4(evex) (((evex) & 0x20) >> 5)
48 #define bFromEVEX4of4(evex) (((evex) & 0x10) >> 4)
49 #define v2FromEVEX4of4(evex) (((~evex) & 0x8) >> 3)
50 #define aaaFromEVEX4of4(evex) ((evex) & 0x7)
52 #define rFromVEX2of3(vex) (((~(vex)) & 0x80) >> 7)
53 #define xFromVEX2of3(vex) (((~(vex)) & 0x40) >> 6)
54 #define bFromVEX2of3(vex) (((~(vex)) & 0x20) >> 5)
55 #define mmmmmFromVEX2of3(vex) ((vex) & 0x1f)
56 #define wFromVEX3of3(vex) (((vex) & 0x80) >> 7)
57 #define vvvvFromVEX3of3(vex) (((~(vex)) & 0x78) >> 3)
58 #define lFromVEX3of3(vex) (((vex) & 0x4) >> 2)
59 #define ppFromVEX3of3(vex) ((vex) & 0x3)
61 #define rFromVEX2of2(vex) (((~(vex)) & 0x80) >> 7)
62 #define vvvvFromVEX2of2(vex) (((~(vex)) & 0x78) >> 3)
63 #define lFromVEX2of2(vex) (((vex) & 0x4) >> 2)
64 #define ppFromVEX2of2(vex) ((vex) & 0x3)
66 #define rFromXOP2of3(xop) (((~(xop)) & 0x80) >> 7)
67 #define xFromXOP2of3(xop) (((~(xop)) & 0x40) >> 6)
68 #define bFromXOP2of3(xop) (((~(xop)) & 0x20) >> 5)
69 #define mmmmmFromXOP2of3(xop) ((xop) & 0x1f)
70 #define wFromXOP3of3(xop) (((xop) & 0x80) >> 7)
71 #define vvvvFromXOP3of3(vex) (((~(vex)) & 0x78) >> 3)
72 #define lFromXOP3of3(xop) (((xop) & 0x4) >> 2)
73 #define ppFromXOP3of3(xop) ((xop) & 0x3)
75 // These enums represent Intel registers for use by the decoder.
98 #define EA_BASES_16BIT \
134 #define EA_BASES_32BIT \
170 #define EA_BASES_64BIT \
328 #define REGS_SEGMENT \
354 #define REGS_CONTROL \
372 #define ALL_EA_BASES \
377 #define ALL_SIB_BASES \
396 /// \brief All possible values of the base field for effective-address
397 /// computations, a.k.a. the Mod and R/M fields of the ModR/M byte.
398 /// We distinguish between bases (EA_BASE_*) and registers that just happen
399 /// to be referred to when Mod == 0b11 (EA_REG_*).
402 #define ENTRY(x) EA_BASE_##x,
405 #define ENTRY(x) EA_REG_##x,
411 /// \brief All possible values of the SIB index field.
412 /// borrows entries from ALL_EA_BASES with the special case that
413 /// sib is synonymous with NONE.
414 /// Vector SIB: index can be XMM or YMM.
417 #define ENTRY(x) SIB_INDEX_##x,
426 /// \brief All possible values of the SIB base field.
429 #define ENTRY(x) SIB_BASE_##x,
435 /// \brief Possible displacement types for effective-address computations.
443 /// \brief All possible values of the reg field in the ModR/M byte.
445 #define ENTRY(x) MODRM_REG_##x,
451 /// \brief All possible segment overrides.
452 enum SegmentOverride
{
463 /// \brief Possible values for the VEX.m-mmmm field
464 enum VEXLeadingOpcodeByte
{
471 XOP_MAP_SELECT_8
= 0x8,
472 XOP_MAP_SELECT_9
= 0x9,
473 XOP_MAP_SELECT_A
= 0xA
476 /// \brief Possible values for the VEX.pp/EVEX.pp field
478 VEX_PREFIX_NONE
= 0x0,
484 enum VectorExtensionType
{
485 TYPE_NO_VEX_XOP
= 0x0,
492 /// \brief Type for the byte reader that the consumer must provide to
493 /// the decoder. Reads a single byte from the instruction's address space.
494 /// \param arg A baton that the consumer can associate with any internal
495 /// state that it needs.
496 /// \param byte A pointer to a single byte in memory that should be set to
497 /// contain the value at address.
498 /// \param address The address in the instruction's address space that should
500 /// \return -1 if the byte cannot be read for any reason; 0 otherwise.
501 typedef int (*byteReader_t
)(const void *arg
, uint8_t *byte
, uint64_t address
);
503 /// \brief Type for the logging function that the consumer can provide to
504 /// get debugging output from the decoder.
505 /// \param arg A baton that the consumer can associate with any internal
506 /// state that it needs.
507 /// \param log A string that contains the message. Will be reused after
508 /// the logger returns.
509 typedef void (*dlog_t
)(void *arg
, const char *log
);
511 /// The specification for how to extract and interpret a full instruction and
513 struct InstructionSpecifier
{
517 /// The x86 internal instruction, which is produced by the decoder.
518 struct InternalInstruction
{
519 // Reader interface (C)
521 // Opaque value passed to the reader
522 const void* readerArg
;
523 // The address of the next byte to read via the reader
524 uint64_t readerCursor
;
526 // Logger interface (C)
528 // Opaque value passed to the logger
531 // General instruction information
533 // The mode to disassemble for (64-bit, protected, real)
534 DisassemblerMode mode
;
535 // The start of the instruction, usable with the reader
536 uint64_t startLocation
;
537 // The length of the instruction, in bytes
542 // 1 if the prefix byte corresponding to the entry is present; 0 if not
543 uint8_t prefixPresent
[0x100];
544 // contains the location (for use with the reader) of the prefix byte
545 uint64_t prefixLocations
[0x100];
546 // The value of the vector extension prefix(EVEX/VEX/XOP), if present
547 uint8_t vectorExtensionPrefix
[4];
548 // The type of the vector extension prefix
549 VectorExtensionType vectorExtensionType
;
550 // The value of the REX prefix, if present
552 // The location where a mandatory prefix would have to be (i.e., right before
553 // the opcode, or right before the REX prefix if one is present).
554 uint64_t necessaryPrefixLocation
;
555 // The segment override type
556 SegmentOverride segmentOverride
;
557 // 1 if the prefix byte, 0xf2 or 0xf3 is xacquire or xrelease
558 bool xAcquireRelease
;
560 // Sizes of various critical pieces of data, in bytes
561 uint8_t registerSize
;
563 uint8_t displacementSize
;
564 uint8_t immediateSize
;
566 // Offsets from the start of the instruction to the pieces of data, which is
567 // needed to find relocation entries for adding symbolic operands.
568 uint8_t displacementOffset
;
569 uint8_t immediateOffset
;
573 // The last byte of the opcode, not counting any ModR/M extension
575 // The ModR/M byte of the instruction, if it is an opcode extension
576 uint8_t modRMExtension
;
580 // The type of opcode, used for indexing into the array of decode tables
581 OpcodeType opcodeType
;
582 // The instruction ID, extracted from the decode table
583 uint16_t instructionID
;
584 // The specifier for the instruction, from the instruction info table
585 const InstructionSpecifier
*spec
;
587 // state for additional bytes, consumed during operand decode. Pattern:
588 // consumed___ indicates that the byte was already consumed and does not
589 // need to be consumed again.
591 // The VEX.vvvv field, which contains a third register operand for some AVX
595 // The writemask for AVX-512 instructions which is contained in EVEX.aaa
598 // The ModR/M byte, which contains most register operands and some portion of
599 // all memory operands.
603 // The SIB byte, used for more complex 32- or 64-bit memory operands
607 // The displacement, used for memory operands
608 bool consumedDisplacement
;
609 int32_t displacement
;
611 // Immediates. There can be two in some cases
612 uint8_t numImmediatesConsumed
;
613 uint8_t numImmediatesTranslated
;
614 uint64_t immediates
[2];
616 // A register or immediate operand encoded into the opcode
619 // Portions of the ModR/M byte
621 // These fields determine the allowable values for the ModR/M fields, which
622 // depend on operand and address widths.
627 // The Mod and R/M fields can encode a base for an effective address, or a
628 // register. These are separated into two fields here.
630 EADisplacement eaDisplacement
;
631 // The reg field always encodes a register
639 ArrayRef
<OperandSpecifier
> operands
;
642 /// \brief Decode one instruction and store the decoding results in
643 /// a buffer provided by the consumer.
644 /// \param insn The buffer to store the instruction in. Allocated by the
646 /// \param reader The byteReader_t for the bytes to be read.
647 /// \param readerArg An argument to pass to the reader for storing context
648 /// specific to the consumer. May be NULL.
649 /// \param logger The dlog_t to be used in printing status messages from the
650 /// disassembler. May be NULL.
651 /// \param loggerArg An argument to pass to the logger for storing context
652 /// specific to the logger. May be NULL.
653 /// \param startLoc The address (in the reader's address space) of the first
654 /// byte in the instruction.
655 /// \param mode The mode (16-bit, 32-bit, 64-bit) to decode in.
656 /// \return Nonzero if there was an error during decode, 0 otherwise.
657 int decodeInstruction(InternalInstruction
*insn
,
659 const void *readerArg
,
664 DisassemblerMode mode
);
666 /// \brief Print a message to debugs()
667 /// \param file The name of the file printing the debug message.
668 /// \param line The line number that printed the debug message.
669 /// \param s The message to print.
670 void Debug(const char *file
, unsigned line
, const char *s
);
672 const char *GetInstrName(unsigned Opcode
, const void *mii
);
674 } // namespace X86Disassembler
projects / rustc.git / blob