1 //===- X86ModRMFilters.h - Disassembler ModR/M filterss ---------*- C++ -*-===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 // 9 // This file is part of the X86 Disassembler Emitter. 10 // It contains ModR/M filters that determine which values of the ModR/M byte 11 // are valid for a partiuclar instruction. 12 // Documentation for the disassembler emitter in general can be found in 13 // X86DisassemblerEmitter.h. 14 // 15 //===----------------------------------------------------------------------===// 16 17 #ifndef LLVM_UTILS_TABLEGEN_X86MODRMFILTERS_H 18 #define LLVM_UTILS_TABLEGEN_X86MODRMFILTERS_H 19 20 #include <cstdint> 21 22 namespace llvm { 23 24 namespace X86Disassembler { 25 26 /// ModRMFilter - Abstract base class for clases that recognize patterns in 27 /// ModR/M bytes. 28 class ModRMFilter { 29 virtual void anchor(); 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 void anchor() override; 53 public: 54 bool isDumb() const override { 55 return true; 56 } 57 58 bool accepts(uint8_t modRM) const override { 59 return true; 60 } 61 }; 62 63 /// ModFilter - Filters based on the mod bits [bits 7-6] of the ModR/M byte. 64 /// Some instructions are classified based on whether they are 11 or anything 65 /// else. This filter performs that classification. 66 class ModFilter : public ModRMFilter { 67 void anchor() override; 68 bool R; 69 public: 70 /// Constructor 71 /// 72 /// \param r True if the mod bits of the ModR/M byte must be 11; false 73 /// otherwise. The name r derives from the fact that the mod 74 /// bits indicate whether the R/M bits [bits 2-0] signify a 75 /// register or a memory operand. 76 ModFilter(bool r) : R(r) {} 77 78 bool accepts(uint8_t modRM) const override { 79 return (R == ((modRM & 0xc0) == 0xc0)); 80 } 81 }; 82 83 /// ExtendedFilter - Extended opcodes are classified based on the value of the 84 /// mod field [bits 7-6] and the value of the nnn field [bits 5-3]. 85 class ExtendedFilter : public ModRMFilter { 86 void anchor() override; 87 bool R; 88 uint8_t NNN; 89 public: 90 /// Constructor 91 /// 92 /// \param r True if the mod field must be set to 11; false otherwise. 93 /// The name is explained at ModFilter. 94 /// \param nnn The required value of the nnn field. 95 ExtendedFilter(bool r, uint8_t nnn) : R(r), NNN(nnn) {} 96 97 bool accepts(uint8_t modRM) const override { 98 return (((R && ((modRM & 0xc0) == 0xc0)) || 99 (!R && ((modRM & 0xc0) != 0xc0))) && 100 (((modRM & 0x38) >> 3) == NNN)); 101 } 102 }; 103 104 /// ExtendedRMFilter - Extended opcodes are classified based on the value of the 105 /// mod field [bits 7-6] and the value of the nnn field [bits 2-0]. 106 class ExtendedRMFilter : public ModRMFilter { 107 void anchor() override; 108 bool R; 109 uint8_t NNN; 110 public: 111 /// Constructor 112 /// 113 /// \param r True if the mod field must be set to 11; false otherwise. 114 /// The name is explained at ModFilter. 115 /// \param nnn The required value of the nnn field. 116 ExtendedRMFilter(bool r, uint8_t nnn) : R(r), NNN(nnn) {} 117 118 bool accepts(uint8_t modRM) const override { 119 return ((R && ((modRM & 0xc0) == 0xc0)) && 120 ((modRM & 0x7) == NNN)); 121 } 122 }; 123 /// ExactFilter - The occasional extended opcode (such as VMCALL or MONITOR) 124 /// requires the ModR/M byte to have a specific value. 125 class ExactFilter : public ModRMFilter { 126 void anchor() override; 127 uint8_t ModRM; 128 public: 129 /// Constructor 130 /// 131 /// \param modRM The required value of the full ModR/M byte. 132 ExactFilter(uint8_t modRM) : ModRM(modRM) {} 133 134 bool accepts(uint8_t modRM) const override { 135 return (ModRM == modRM); 136 } 137 }; 138 139 } // namespace X86Disassembler 140 141 } // namespace llvm 142 143 #endif 144