1//===- X86DisassemblerTables.h - Disassembler tables ------------*- 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 the interface of the disassembler tables.
12// Documentation for the disassembler emitter in general can be found in
13//  X86DisasemblerEmitter.h.
14//
15//===----------------------------------------------------------------------===//
16
17#ifndef X86DISASSEMBLERTABLES_H
18#define X86DISASSEMBLERTABLES_H
19
20#include "X86DisassemblerShared.h"
21#include "X86ModRMFilters.h"
22#include "llvm/Support/raw_ostream.h"
23#include <map>
24#include <vector>
25
26namespace llvm {
27
28namespace X86Disassembler {
29
30/// DisassemblerTables - Encapsulates all the decode tables being generated by
31///   the table emitter.  Contains functions to populate the tables as well as
32///   to emit them as hierarchical C structures suitable for consumption by the
33///   runtime.
34class DisassemblerTables {
35private:
36  /// The decoder tables.  There is one for each opcode type:
37  /// [0] one-byte opcodes
38  /// [1] two-byte opcodes of the form 0f __
39  /// [2] three-byte opcodes of the form 0f 38 __
40  /// [3] three-byte opcodes of the form 0f 3a __
41  /// [4] three-byte opcodes of the form 0f a6 __
42  /// [5] three-byte opcodes of the form 0f a7 __
43  /// [6] XOP8 map opcode
44  /// [7] XOP9 map opcode
45  /// [8] XOPA map opcode
46  ContextDecision* Tables[9];
47
48  // Table of ModRM encodings.
49  typedef std::map<std::vector<unsigned>, unsigned> ModRMMapTy;
50  mutable ModRMMapTy ModRMTable;
51
52  /// The instruction information table
53  std::vector<InstructionSpecifier> InstructionSpecifiers;
54
55  /// True if there are primary decode conflicts in the instruction set
56  bool HasConflicts;
57
58  /// emitModRMDecision - Emits a table of entries corresponding to a single
59  ///   ModR/M decision.  Compacts the ModR/M decision if possible.  ModR/M
60  ///   decisions are printed as:
61  ///
62  ///   { /* struct ModRMDecision */
63  ///     TYPE,
64  ///     modRMTablennnn
65  ///   }
66  ///
67  ///   where nnnn is a unique ID for the corresponding table of IDs.
68  ///   TYPE indicates whether the table has one entry that is the same
69  ///   regardless of ModR/M byte, two entries - one for bytes 0x00-0xbf and one
70  ///   for bytes 0xc0-0xff -, or 256 entries, one for each possible byte.
71  ///   nnnn is the number of a table for looking up these values.  The tables
72  ///   are written separately so that tables consisting entirely of zeros will
73  ///   not be duplicated.  (These all have the name modRMEmptyTable.)  A table
74  ///   is printed as:
75  ///
76  ///   InstrUID modRMTablennnn[k] = {
77  ///     nnnn, /* MNEMONIC */
78  ///     ...
79  ///     nnnn /* MNEMONIC */
80  ///   };
81  ///
82  /// @param o1       - The output stream to print the ID table to.
83  /// @param o2       - The output stream to print the decision structure to.
84  /// @param i1       - The indentation level to use with stream o1.
85  /// @param i2       - The indentation level to use with stream o2.
86  /// @param ModRMTableNum - next table number for adding to ModRMTable.
87  /// @param decision - The ModR/M decision to emit.  This decision has 256
88  ///                   entries - emitModRMDecision decides how to compact it.
89  void emitModRMDecision(raw_ostream &o1, raw_ostream &o2,
90                         unsigned &i1, unsigned &i2, unsigned &ModRMTableNum,
91                         ModRMDecision &decision) const;
92
93  /// emitOpcodeDecision - Emits an OpcodeDecision and all its subsidiary ModR/M
94  ///   decisions.  An OpcodeDecision is printed as:
95  ///
96  ///   { /* struct OpcodeDecision */
97  ///     /* 0x00 */
98  ///     { /* struct ModRMDecision */
99  ///       ...
100  ///     }
101  ///     ...
102  ///   }
103  ///
104  ///   where the ModRMDecision structure is printed as described in the
105  ///   documentation for emitModRMDecision().  emitOpcodeDecision() passes on a
106  ///   stream and indent level for the UID tables generated by
107  ///   emitModRMDecision(), but does not use them itself.
108  ///
109  /// @param o1       - The output stream to print the ID tables generated by
110  ///                   emitModRMDecision() to.
111  /// @param o2       - The output stream for the decision structure itself.
112  /// @param i1       - The indent level to use with stream o1.
113  /// @param i2       - The indent level to use with stream o2.
114  /// @param ModRMTableNum - next table number for adding to ModRMTable.
115  /// @param decision - The OpcodeDecision to emit along with its subsidiary
116  ///                    structures.
117  void emitOpcodeDecision(raw_ostream &o1, raw_ostream &o2,
118                          unsigned &i1, unsigned &i2, unsigned &ModRMTableNum,
119                          OpcodeDecision &decision) const;
120
121  /// emitContextDecision - Emits a ContextDecision and all its subsidiary
122  ///   Opcode and ModRMDecisions.  A ContextDecision is printed as:
123  ///
124  ///   struct ContextDecision NAME = {
125  ///     { /* OpcodeDecisions */
126  ///       /* IC */
127  ///       { /* struct OpcodeDecision */
128  ///         ...
129  ///       },
130  ///       ...
131  ///     }
132  ///   }
133  ///
134  ///   NAME is the name of the ContextDecision (typically one of the four names
135  ///   ONEBYTE_SYM, TWOBYTE_SYM, THREEBYTE38_SYM, THREEBYTE3A_SYM,
136  ///   THREEBYTEA6_SYM, and THREEBYTEA7_SYM from
137  ///   X86DisassemblerDecoderCommon.h).
138  ///   IC is one of the contexts in InstructionContext.  There is an opcode
139  ///   decision for each possible context.
140  ///   The OpcodeDecision structures are printed as described in the
141  ///   documentation for emitOpcodeDecision.
142  ///
143  /// @param o1       - The output stream to print the ID tables generated by
144  ///                   emitModRMDecision() to.
145  /// @param o2       - The output stream to print the decision structure to.
146  /// @param i1       - The indent level to use with stream o1.
147  /// @param i2       - The indent level to use with stream o2.
148  /// @param ModRMTableNum - next table number for adding to ModRMTable.
149  /// @param decision - The ContextDecision to emit along with its subsidiary
150  ///                   structures.
151  /// @param name     - The name for the ContextDecision.
152  void emitContextDecision(raw_ostream &o1, raw_ostream &o2,
153                           unsigned &i1, unsigned &i2, unsigned &ModRMTableNum,
154                           ContextDecision &decision, const char* name) const;
155
156  /// emitInstructionInfo - Prints the instruction specifier table, which has
157  ///   one entry for each instruction, and contains name and operand
158  ///   information.  This table is printed as:
159  ///
160  ///   struct InstructionSpecifier CONTEXTS_SYM[k] = {
161  ///     {
162  ///       /* nnnn */
163  ///       "MNEMONIC",
164  ///       0xnn,
165  ///       {
166  ///         {
167  ///           ENCODING,
168  ///           TYPE
169  ///         },
170  ///         ...
171  ///       }
172  ///     },
173  ///   };
174  ///
175  ///   k is the total number of instructions.
176  ///   nnnn is the ID of the current instruction (0-based).  This table
177  ///   includes entries for non-instructions like PHINODE.
178  ///   0xnn is the lowest possible opcode for the current instruction, used for
179  ///   AddRegFrm instructions to compute the operand's value.
180  ///   ENCODING and TYPE describe the encoding and type for a single operand.
181  ///
182  /// @param o  - The output stream to which the instruction table should be
183  ///             written.
184  /// @param i  - The indent level for use with the stream.
185  void emitInstructionInfo(raw_ostream &o, unsigned &i) const;
186
187  /// emitContextTable - Prints the table that is used to translate from an
188  ///   instruction attribute mask to an instruction context.  This table is
189  ///   printed as:
190  ///
191  ///   InstructionContext CONTEXTS_STR[256] = {
192  ///     IC, /* 0x00 */
193  ///     ...
194  ///   };
195  ///
196  ///   IC is the context corresponding to the mask 0x00, and there are 256
197  ///   possible masks.
198  ///
199  /// @param o  - The output stream to which the context table should be written.
200  /// @param i  - The indent level for use with the stream.
201  void emitContextTable(raw_ostream &o, uint32_t &i) const;
202
203  /// emitContextDecisions - Prints all four ContextDecision structures using
204  ///   emitContextDecision().
205  ///
206  /// @param o1 - The output stream to print the ID tables generated by
207  ///             emitModRMDecision() to.
208  /// @param o2 - The output stream to print the decision structures to.
209  /// @param i1 - The indent level to use with stream o1.
210  /// @param i2 - The indent level to use with stream o2.
211  /// @param ModRMTableNum - next table number for adding to ModRMTable.
212  void emitContextDecisions(raw_ostream &o1, raw_ostream &o2,
213                            unsigned &i1, unsigned &i2,
214                            unsigned &ModRMTableNum) const;
215
216  /// setTableFields - Uses a ModRMFilter to set the appropriate entries in a
217  ///   ModRMDecision to refer to a particular instruction ID.
218  ///
219  /// @param decision - The ModRMDecision to populate.
220  /// @param filter   - The filter to use in deciding which entries to populate.
221  /// @param uid      - The unique ID to set matching entries to.
222  /// @param opcode   - The opcode of the instruction, for error reporting.
223  void setTableFields(ModRMDecision &decision,
224                      const ModRMFilter &filter,
225                      InstrUID uid,
226                      uint8_t opcode);
227public:
228  /// Constructor - Allocates space for the class decisions and clears them.
229  DisassemblerTables();
230
231  ~DisassemblerTables();
232
233  /// emit - Emits the instruction table, context table, and class decisions.
234  ///
235  /// @param o  - The output stream to print the tables to.
236  void emit(raw_ostream &o) const;
237
238  /// setTableFields - Uses the opcode type, instruction context, opcode, and a
239  ///   ModRMFilter as criteria to set a particular set of entries in the
240  ///   decode tables to point to a specific uid.
241  ///
242  /// @param type         - The opcode type (ONEBYTE, TWOBYTE, etc.)
243  /// @param insnContext  - The context to use (IC, IC_64BIT, etc.)
244  /// @param opcode       - The last byte of the opcode (not counting any escape
245  ///                       or extended opcodes).
246  /// @param filter       - The ModRMFilter that decides which ModR/M byte values
247  ///                       correspond to the desired instruction.
248  /// @param uid          - The unique ID of the instruction.
249  /// @param is32bit      - Instructon is only 32-bit
250  /// @param ignoresVEX_L - Instruction ignores VEX.L
251  void setTableFields(OpcodeType type,
252                      InstructionContext insnContext,
253                      uint8_t opcode,
254                      const ModRMFilter &filter,
255                      InstrUID uid,
256                      bool is32bit,
257                      bool ignoresVEX_L);
258
259  /// specForUID - Returns the instruction specifier for a given unique
260  ///   instruction ID.  Used when resolving collisions.
261  ///
262  /// @param uid  - The unique ID of the instruction.
263  /// @return     - A reference to the instruction specifier.
264  InstructionSpecifier& specForUID(InstrUID uid) {
265    if (uid >= InstructionSpecifiers.size())
266      InstructionSpecifiers.resize(uid + 1);
267
268    return InstructionSpecifiers[uid];
269  }
270
271  // hasConflicts - Reports whether there were primary decode conflicts
272  //   from any instructions added to the tables.
273  // @return  - true if there were; false otherwise.
274
275  bool hasConflicts() {
276    return HasConflicts;
277  }
278};
279
280} // namespace X86Disassembler
281
282} // namespace llvm
283
284#endif
285