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 "llvm/Support/DataTypes.h" 21 22namespace llvm { 23 24namespace X86Disassembler { 25 26/// ModRMFilter - Abstract base class for clases that recognize patterns in 27/// ModR/M bytes. 28class ModRMFilter { 29 virtual void anchor(); 30public: 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. 51class DumbFilter : public ModRMFilter { 52 void anchor() override; 53public: 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. 66class ModFilter : public ModRMFilter { 67 void anchor() override; 68 bool R; 69public: 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) : 77 ModRMFilter(), 78 R(r) { 79 } 80 81 bool accepts(uint8_t modRM) const override { 82 return (R == ((modRM & 0xc0) == 0xc0)); 83 } 84}; 85 86/// ExtendedFilter - Extended opcodes are classified based on the value of the 87/// mod field [bits 7-6] and the value of the nnn field [bits 5-3]. 88class ExtendedFilter : public ModRMFilter { 89 void anchor() override; 90 bool R; 91 uint8_t NNN; 92public: 93 /// Constructor 94 /// 95 /// \param r True if the mod field must be set to 11; false otherwise. 96 /// The name is explained at ModFilter. 97 /// \param nnn The required value of the nnn field. 98 ExtendedFilter(bool r, uint8_t nnn) : 99 ModRMFilter(), 100 R(r), 101 NNN(nnn) { 102 } 103 104 bool accepts(uint8_t modRM) const override { 105 return (((R && ((modRM & 0xc0) == 0xc0)) || 106 (!R && ((modRM & 0xc0) != 0xc0))) && 107 (((modRM & 0x38) >> 3) == NNN)); 108 } 109}; 110 111/// ExactFilter - The occasional extended opcode (such as VMCALL or MONITOR) 112/// requires the ModR/M byte to have a specific value. 113class ExactFilter : public ModRMFilter { 114 void anchor() override; 115 uint8_t ModRM; 116public: 117 /// Constructor 118 /// 119 /// \param modRM The required value of the full ModR/M byte. 120 ExactFilter(uint8_t modRM) : 121 ModRMFilter(), 122 ModRM(modRM) { 123 } 124 125 bool accepts(uint8_t modRM) const override { 126 return (ModRM == modRM); 127 } 128}; 129 130} // namespace X86Disassembler 131 132} // namespace llvm 133 134#endif 135