utils/TableGen/X86ModRMFilters.h

   1 //===- X86ModRMFilters.h - Disassembler ModR/M filterss ---------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  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.
  15 //
  16 //===----------------------------------------------------------------------===//
  17
  18 #ifndef X86MODRMFILTERS_H
  19 #define X86MODRMFILTERS_H
  20
  21 #include "llvm/Support/DataTypes.h"
  22
  23 namespace llvm {
  24
  25 namespace X86Disassembler {
  26
  27 /// ModRMFilter - Abstract base class for clases that recognize patterns in
  28 ///   ModR/M bytes.
  29 class ModRMFilter {
  30 public:
  31   /// Destructor    - Override as necessary.
  32   virtual ~ModRMFilter() { }
  33
  34   /// isDumb        - Indicates whether this filter returns the same value for
  35   ///                 any value of the ModR/M byte.
  36   ///
  37   /// @result       - True if the filter returns the same value for any ModR/M
  38   ///                 byte; false if not.
  39   virtual bool isDumb() const { return false; }
  40
  41   /// accepts       - Indicates whether the filter accepts a particular ModR/M
  42   ///                 byte value.
  43   ///
  44   /// @result       - True if the filter accepts the ModR/M byte; false if not.
  45   virtual bool accepts(uint8_t modRM) const = 0;
  46 };
  47
  48 /// DumbFilter - Accepts any ModR/M byte.  Used for instructions that do not
  49 ///   require a ModR/M byte or instructions where the entire ModR/M byte is used
  50 ///   for operands.
  51 class DumbFilter : public ModRMFilter {
  52 public:
  53   bool isDumb() const {
  54     return true;
  55   }
  56
  57   bool accepts(uint8_t modRM) const {
  58     return true;
  59   }
  60 };
  61
  62 /// ModFilter - Filters based on the mod bits [bits 7-6] of the ModR/M byte.
  63 ///   Some instructions are classified based on whether they are 11 or anything
  64 ///   else.  This filter performs that classification.
  65 class ModFilter : public ModRMFilter {
  66 private:
  67   bool R;
  68 public:
  69   /// Constructor
  70   ///
  71   /// @r            - True if the mod bits of the ModR/M byte must be 11; false
  72   ///                 otherwise.  The name r derives from the fact that the mod
  73   ///                 bits indicate whether the R/M bits [bits 2-0] signify a
  74   ///                 register or a memory operand.
  75   ModFilter(bool r) :
  76     ModRMFilter(),
  77     R(r) {
  78   }
  79
  80   bool accepts(uint8_t modRM) const {
  81     if (R == ((modRM & 0xc0) == 0xc0))
  82       return true;
  83     else
  84       return false;
  85   }
  86 };
  87
  88 /// EscapeFilter - Filters escape opcodes, which are classified in two ways.  If
  89 ///   the ModR/M byte is between 0xc0 and 0xff, then there is one slot for each
  90 ///   possible value.  Otherwise, there is one instruction for each value of the
  91 ///   nnn field [bits 5-3], known elsewhere as the reg field.
  92 class EscapeFilter : public ModRMFilter {
  93 private:
  94   bool C0_FF;
  95   uint8_t NNN_or_ModRM;
  96 public:
  97   /// Constructor
  98   ///
  99   /// @c0_ff        - True if the ModR/M byte must fall between 0xc0 and 0xff;
 100   ///                 false otherwise.
 101   /// @nnn_or_modRM - If c0_ff is true, the required value of the entire ModR/M
 102   ///                 byte.  If c0_ff is false, the required value of the nnn
 103   ///                 field.
 104   EscapeFilter(bool c0_ff, uint8_t nnn_or_modRM) :
 105     ModRMFilter(),
 106     C0_FF(c0_ff),
 107     NNN_or_ModRM(nnn_or_modRM) {
 108   }
 109
 110   bool accepts(uint8_t modRM) const {
 111     if ((C0_FF && modRM >= 0xc0 && (modRM == NNN_or_ModRM)) ||
 112         (!C0_FF && modRM < 0xc0  && ((modRM & 0x38) >> 3) == NNN_or_ModRM))
 113       return true;
 114     else
 115       return false;
 116   }
 117 };
 118
 119 /// AddRegEscapeFilter - Some escape opcodes have one of the register operands
 120 ///   added to the ModR/M byte, meaning that a range of eight ModR/M values
 121 ///   maps to a single instruction.  Such instructions require the ModR/M byte
 122 ///   to fall between 0xc0 and 0xff.
 123 class AddRegEscapeFilter : public ModRMFilter {
 124 private:
 125   uint8_t ModRM;
 126 public:
 127   /// Constructor
 128   ///
 129   /// @modRM        - The value of the ModR/M byte when the register operand
 130   ///                 refers to the first register in the register set.
 131   AddRegEscapeFilter(uint8_t modRM) : ModRM(modRM) {
 132   }
 133
 134   bool accepts(uint8_t modRM) const {
 135     if (modRM >= ModRM && modRM < ModRM + 8)
 136       return true;
 137     else
 138       return false;
 139   }
 140 };
 141
 142 /// ExtendedFilter - Extended opcodes are classified based on the value of the
 143 ///   mod field [bits 7-6] and the value of the nnn field [bits 5-3].
 144 class ExtendedFilter : public ModRMFilter {
 145 private:
 146   bool R;
 147   uint8_t NNN;
 148 public:
 149   /// Constructor
 150   ///
 151   /// @r            - True if the mod field must be set to 11; false otherwise.
 152   ///                 The name is explained at ModFilter.
 153   /// @nnn          - The required value of the nnn field.
 154   ExtendedFilter(bool r, uint8_t nnn) :
 155     ModRMFilter(),
 156     R(r),
 157     NNN(nnn) {
 158   }
 159
 160   bool accepts(uint8_t modRM) const {
 161     if (((R  && ((modRM & 0xc0) == 0xc0)) ||
 162         (!R && ((modRM & 0xc0) != 0xc0))) &&
 163         (((modRM & 0x38) >> 3) == NNN))
 164       return true;
 165     else
 166       return false;
 167   }
 168 };
 169
 170 /// ExactFilter - The occasional extended opcode (such as VMCALL or MONITOR)
 171 ///   requires the ModR/M byte to have a specific value.
 172 class ExactFilter : public ModRMFilter
 173 {
 174 private:
 175   uint8_t ModRM;
 176 public:
 177   /// Constructor
 178   ///
 179   /// @modRM        - The required value of the full ModR/M byte.
 180   ExactFilter(uint8_t modRM) :
 181     ModRMFilter(),
 182     ModRM(modRM) {
 183   }
 184
 185   bool accepts(uint8_t modRM) const {
 186     if (ModRM == modRM)
 187       return true;
 188     else
 189       return false;
 190   }
 191 };
 192
 193 } // namespace X86Disassembler
 194
 195 } // namespace llvm
 196
 197 #endif