1 //===- X86ModRMFilters.h - Disassembler ModR/M filterss ---------*- 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 Emitter.
11 // It contains ModR/M filters that determine which values of the ModR/M byte
12 // are valid for a partiuclar instruction.
13 // Documentation for the disassembler emitter in general can be found in
14 // X86DisasemblerEmitter.h.
16 //===----------------------------------------------------------------------===//
18 #ifndef X86MODRMFILTERS_H
19 #define X86MODRMFILTERS_H
21 #include "llvm/Support/DataTypes.h"
25 namespace X86Disassembler {
27 /// ModRMFilter - Abstract base class for clases that recognize patterns in
30 virtual void anchor();
32 /// Destructor - Override as necessary.
33 virtual ~ModRMFilter() { }
35 /// isDumb - Indicates whether this filter returns the same value for
36 /// any value of the ModR/M byte.
38 /// @result - True if the filter returns the same value for any ModR/M
39 /// byte; false if not.
40 virtual bool isDumb() const { return false; }
42 /// accepts - Indicates whether the filter accepts a particular ModR/M
45 /// @result - True if the filter accepts the ModR/M byte; false if not.
46 virtual bool accepts(uint8_t modRM) const = 0;
49 /// DumbFilter - Accepts any ModR/M byte. Used for instructions that do not
50 /// require a ModR/M byte or instructions where the entire ModR/M byte is used
52 class DumbFilter : public ModRMFilter {
53 virtual void anchor();
59 bool accepts(uint8_t modRM) const {
64 /// ModFilter - Filters based on the mod bits [bits 7-6] of the ModR/M byte.
65 /// Some instructions are classified based on whether they are 11 or anything
66 /// else. This filter performs that classification.
67 class ModFilter : public ModRMFilter {
68 virtual void anchor();
73 /// @r - True if the mod bits of the ModR/M byte must be 11; false
74 /// otherwise. The name r derives from the fact that the mod
75 /// bits indicate whether the R/M bits [bits 2-0] signify a
76 /// register or a memory operand.
82 bool accepts(uint8_t modRM) const {
83 if (R == ((modRM & 0xc0) == 0xc0))
90 /// EscapeFilter - Filters escape opcodes, which are classified in two ways. If
91 /// the ModR/M byte is between 0xc0 and 0xff, then there is one slot for each
92 /// possible value. Otherwise, there is one instruction for each value of the
93 /// nnn field [bits 5-3], known elsewhere as the reg field.
94 class EscapeFilter : public ModRMFilter {
95 virtual void anchor();
101 /// @c0_ff - True if the ModR/M byte must fall between 0xc0 and 0xff;
103 /// @nnn_or_modRM - If c0_ff is true, the required value of the entire ModR/M
104 /// byte. If c0_ff is false, the required value of the nnn
106 EscapeFilter(bool c0_ff, uint8_t nnn_or_modRM) :
109 NNN_or_ModRM(nnn_or_modRM) {
112 bool accepts(uint8_t modRM) const {
113 if ((C0_FF && modRM >= 0xc0 && (modRM == NNN_or_ModRM)) ||
114 (!C0_FF && modRM < 0xc0 && ((modRM & 0x38) >> 3) == NNN_or_ModRM))
121 /// AddRegEscapeFilter - Some escape opcodes have one of the register operands
122 /// added to the ModR/M byte, meaning that a range of eight ModR/M values
123 /// maps to a single instruction. Such instructions require the ModR/M byte
124 /// to fall between 0xc0 and 0xff.
125 class AddRegEscapeFilter : public ModRMFilter {
126 virtual void anchor();
131 /// @modRM - The value of the ModR/M byte when the register operand
132 /// refers to the first register in the register set.
133 AddRegEscapeFilter(uint8_t modRM) : ModRM(modRM) {
136 bool accepts(uint8_t modRM) const {
137 if (modRM >= ModRM && modRM < ModRM + 8)
144 /// ExtendedFilter - Extended opcodes are classified based on the value of the
145 /// mod field [bits 7-6] and the value of the nnn field [bits 5-3].
146 class ExtendedFilter : public ModRMFilter {
147 virtual void anchor();
153 /// @r - True if the mod field must be set to 11; false otherwise.
154 /// The name is explained at ModFilter.
155 /// @nnn - The required value of the nnn field.
156 ExtendedFilter(bool r, uint8_t nnn) :
162 bool accepts(uint8_t modRM) const {
163 if (((R && ((modRM & 0xc0) == 0xc0)) ||
164 (!R && ((modRM & 0xc0) != 0xc0))) &&
165 (((modRM & 0x38) >> 3) == NNN))
172 /// ExactFilter - The occasional extended opcode (such as VMCALL or MONITOR)
173 /// requires the ModR/M byte to have a specific value.
174 class ExactFilter : public ModRMFilter {
175 virtual void anchor();
180 /// @modRM - The required value of the full ModR/M byte.
181 ExactFilter(uint8_t modRM) :
186 bool accepts(uint8_t modRM) const {
194 } // namespace X86Disassembler