contrib/llvm/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   virtual void anchor();
  31 public:
  32   /// Destructor    - Override as necessary.
  33   virtual ~ModRMFilter() { }
  34
  35   /// isDumb        - Indicates whether this filter returns the same value for
  36   ///                 any value of the ModR/M byte.
  37   ///
  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; }
  41
  42   /// accepts       - Indicates whether the filter accepts a particular ModR/M
  43   ///                 byte value.
  44   ///
  45   /// @result       - True if the filter accepts the ModR/M byte; false if not.
  46   virtual bool accepts(uint8_t modRM) const = 0;
  47 };
  48
  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
  51 ///   for operands.
  52 class DumbFilter : public ModRMFilter {
  53   virtual void anchor();
  54 public:
  55   bool isDumb() const {
  56     return true;
  57   }
  58
  59   bool accepts(uint8_t modRM) const {
  60     return true;
  61   }
  62 };
  63
  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();
  69   bool R;
  70 public:
  71   /// Constructor
  72   ///
  73   /// \param 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.
  77   ModFilter(bool r) :
  78     ModRMFilter(),
  79     R(r) {
  80   }
  81
  82   bool accepts(uint8_t modRM) const {
  83     if (R == ((modRM & 0xc0) == 0xc0))
  84       return true;
  85     else
  86       return false;
  87   }
  88 };
  89
  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();
  96   bool C0_FF;
  97   uint8_t NNN_or_ModRM;
  98 public:
  99   /// Constructor
 100   ///
 101   /// \param c0_ff True if the ModR/M byte must fall between 0xc0 and 0xff;
 102   ///              false otherwise.
 103   ///
 104   /// \param nnn_or_modRM If c0_ff is true, the required value of the entire
 105   ///                     ModR/M byte.  If c0_ff is false, the required value
 106   ///                     of the nnn field.
 107   EscapeFilter(bool c0_ff, uint8_t nnn_or_modRM) :
 108     ModRMFilter(),
 109     C0_FF(c0_ff),
 110     NNN_or_ModRM(nnn_or_modRM) {
 111   }
 112
 113   bool accepts(uint8_t modRM) const {
 114     if ((C0_FF && modRM >= 0xc0 && (modRM == NNN_or_ModRM)) ||
 115         (!C0_FF && modRM < 0xc0  && ((modRM & 0x38) >> 3) == NNN_or_ModRM))
 116       return true;
 117     else
 118       return false;
 119   }
 120 };
 121
 122 /// AddRegEscapeFilter - Some escape opcodes have one of the register operands
 123 ///   added to the ModR/M byte, meaning that a range of eight ModR/M values
 124 ///   maps to a single instruction.  Such instructions require the ModR/M byte
 125 ///   to fall between 0xc0 and 0xff.
 126 class AddRegEscapeFilter : public ModRMFilter {
 127   virtual void anchor();
 128   uint8_t ModRM;
 129 public:
 130   /// Constructor
 131   ///
 132   /// \param modRM The value of the ModR/M byte when the register operand
 133   ///              refers to the first register in the register set.
 134   AddRegEscapeFilter(uint8_t modRM) : ModRM(modRM) {
 135   }
 136
 137   bool accepts(uint8_t modRM) const {
 138     if (modRM >= ModRM && modRM < ModRM + 8)
 139       return true;
 140     else
 141       return false;
 142   }
 143 };
 144
 145 /// ExtendedFilter - Extended opcodes are classified based on the value of the
 146 ///   mod field [bits 7-6] and the value of the nnn field [bits 5-3].
 147 class ExtendedFilter : public ModRMFilter {
 148   virtual void anchor();
 149   bool R;
 150   uint8_t NNN;
 151 public:
 152   /// Constructor
 153   ///
 154   /// \param r   True if the mod field must be set to 11; false otherwise.
 155   ///            The name is explained at ModFilter.
 156   /// \param nnn The required value of the nnn field.
 157   ExtendedFilter(bool r, uint8_t nnn) :
 158     ModRMFilter(),
 159     R(r),
 160     NNN(nnn) {
 161   }
 162
 163   bool accepts(uint8_t modRM) const {
 164     if (((R  && ((modRM & 0xc0) == 0xc0)) ||
 165         (!R && ((modRM & 0xc0) != 0xc0))) &&
 166         (((modRM & 0x38) >> 3) == NNN))
 167       return true;
 168     else
 169       return false;
 170   }
 171 };
 172
 173 /// ExactFilter - The occasional extended opcode (such as VMCALL or MONITOR)
 174 ///   requires the ModR/M byte to have a specific value.
 175 class ExactFilter : public ModRMFilter {
 176   virtual void anchor();
 177   uint8_t ModRM;
 178 public:
 179   /// Constructor
 180   ///
 181   /// \param modRM The required value of the full ModR/M byte.
 182   ExactFilter(uint8_t modRM) :
 183     ModRMFilter(),
 184     ModRM(modRM) {
 185   }
 186
 187   bool accepts(uint8_t modRM) const {
 188     if (ModRM == modRM)
 189       return true;
 190     else
 191       return false;
 192   }
 193 };
 194
 195 } // namespace X86Disassembler
 196
 197 } // namespace llvm
 198
 199 #endif