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