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