1 //===- X86DisassemblerTables.cpp - Disassembler tables ----------*- 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 the implementation of the disassembler tables. 11 // Documentation for the disassembler emitter in general can be found in 12 // X86DisassemblerEmitter.h. 13 // 14 //===----------------------------------------------------------------------===// 15 16 #include "X86DisassemblerTables.h" 17 #include "X86DisassemblerShared.h" 18 #include "X86ModRMFilters.h" 19 #include "llvm/ADT/SmallVector.h" 20 #include "llvm/Support/ErrorHandling.h" 21 #include "llvm/Support/Format.h" 22 #include "llvm/Support/raw_ostream.h" 23 #include <map> 24 25 using namespace llvm; 26 using namespace X86Disassembler; 27 28 /// stringForContext - Returns a string containing the name of a particular 29 /// InstructionContext, usually for diagnostic purposes. 30 /// 31 /// @param insnContext - The instruction class to transform to a string. 32 /// @return - A statically-allocated string constant that contains the 33 /// name of the instruction class. 34 static inline const char *stringForContext(InstructionContext insnContext) { 35 switch (insnContext) { 36 default: 37 llvm_unreachable("Unhandled instruction class"); 38 #define ENUM_ENTRY(n, r, d) \ 39 case n: \ 40 return #n; \ 41 break; 42 #define ENUM_ENTRY_K_B(n, r, d) \ 43 ENUM_ENTRY(n, r, d) \ 44 ENUM_ENTRY(n##_K_B, r, d) ENUM_ENTRY(n##_KZ, r, d) ENUM_ENTRY(n##_K, r, d) \ 45 ENUM_ENTRY(n##_B, r, d) ENUM_ENTRY(n##_KZ_B, r, d) 46 INSTRUCTION_CONTEXTS 47 #undef ENUM_ENTRY 48 #undef ENUM_ENTRY_K_B 49 } 50 } 51 52 /// stringForOperandType - Like stringForContext, but for OperandTypes. 53 static inline const char *stringForOperandType(OperandType type) { 54 switch (type) { 55 default: 56 llvm_unreachable("Unhandled type"); 57 #define ENUM_ENTRY(i, d) \ 58 case i: \ 59 return #i; 60 TYPES 61 #undef ENUM_ENTRY 62 } 63 } 64 65 /// stringForOperandEncoding - like stringForContext, but for 66 /// OperandEncodings. 67 static inline const char *stringForOperandEncoding(OperandEncoding encoding) { 68 switch (encoding) { 69 default: 70 llvm_unreachable("Unhandled encoding"); 71 #define ENUM_ENTRY(i, d) \ 72 case i: \ 73 return #i; 74 ENCODINGS 75 #undef ENUM_ENTRY 76 } 77 } 78 79 /// inheritsFrom - Indicates whether all instructions in one class also belong 80 /// to another class. 81 /// 82 /// @param child - The class that may be the subset 83 /// @param parent - The class that may be the superset 84 /// @return - True if child is a subset of parent, false otherwise. 85 static inline bool inheritsFrom(InstructionContext child, 86 InstructionContext parent, bool noPrefix = true, 87 bool VEX_LIG = false, bool WIG = false, 88 bool AdSize64 = false) { 89 if (child == parent) 90 return true; 91 92 switch (parent) { 93 case IC: 94 return (inheritsFrom(child, IC_64BIT, AdSize64) || 95 (noPrefix && inheritsFrom(child, IC_OPSIZE, noPrefix)) || 96 inheritsFrom(child, IC_ADSIZE) || 97 (noPrefix && inheritsFrom(child, IC_XD, noPrefix)) || 98 (noPrefix && inheritsFrom(child, IC_XS, noPrefix))); 99 case IC_64BIT: 100 return (inheritsFrom(child, IC_64BIT_REXW) || 101 (noPrefix && inheritsFrom(child, IC_64BIT_OPSIZE, noPrefix)) || 102 (!AdSize64 && inheritsFrom(child, IC_64BIT_ADSIZE)) || 103 (noPrefix && inheritsFrom(child, IC_64BIT_XD, noPrefix)) || 104 (noPrefix && inheritsFrom(child, IC_64BIT_XS, noPrefix))); 105 case IC_OPSIZE: 106 return inheritsFrom(child, IC_64BIT_OPSIZE) || 107 inheritsFrom(child, IC_OPSIZE_ADSIZE); 108 case IC_ADSIZE: 109 return (noPrefix && inheritsFrom(child, IC_OPSIZE_ADSIZE, noPrefix)); 110 case IC_OPSIZE_ADSIZE: 111 return false; 112 case IC_64BIT_ADSIZE: 113 return (noPrefix && inheritsFrom(child, IC_64BIT_OPSIZE_ADSIZE, noPrefix)); 114 case IC_64BIT_OPSIZE_ADSIZE: 115 return false; 116 case IC_XD: 117 return inheritsFrom(child, IC_64BIT_XD); 118 case IC_XS: 119 return inheritsFrom(child, IC_64BIT_XS); 120 case IC_XD_OPSIZE: 121 return inheritsFrom(child, IC_64BIT_XD_OPSIZE); 122 case IC_XS_OPSIZE: 123 return inheritsFrom(child, IC_64BIT_XS_OPSIZE); 124 case IC_XD_ADSIZE: 125 return inheritsFrom(child, IC_64BIT_XD_ADSIZE); 126 case IC_XS_ADSIZE: 127 return inheritsFrom(child, IC_64BIT_XS_ADSIZE); 128 case IC_64BIT_REXW: 129 return ((noPrefix && inheritsFrom(child, IC_64BIT_REXW_XS, noPrefix)) || 130 (noPrefix && inheritsFrom(child, IC_64BIT_REXW_XD, noPrefix)) || 131 (noPrefix && inheritsFrom(child, IC_64BIT_REXW_OPSIZE, noPrefix)) || 132 (!AdSize64 && inheritsFrom(child, IC_64BIT_REXW_ADSIZE))); 133 case IC_64BIT_OPSIZE: 134 return inheritsFrom(child, IC_64BIT_REXW_OPSIZE) || 135 (!AdSize64 && inheritsFrom(child, IC_64BIT_OPSIZE_ADSIZE)) || 136 (!AdSize64 && inheritsFrom(child, IC_64BIT_REXW_ADSIZE)); 137 case IC_64BIT_XD: 138 return (inheritsFrom(child, IC_64BIT_REXW_XD) || 139 (!AdSize64 && inheritsFrom(child, IC_64BIT_XD_ADSIZE))); 140 case IC_64BIT_XS: 141 return (inheritsFrom(child, IC_64BIT_REXW_XS) || 142 (!AdSize64 && inheritsFrom(child, IC_64BIT_XS_ADSIZE))); 143 case IC_64BIT_XD_OPSIZE: 144 case IC_64BIT_XS_OPSIZE: 145 return false; 146 case IC_64BIT_XD_ADSIZE: 147 case IC_64BIT_XS_ADSIZE: 148 return false; 149 case IC_64BIT_REXW_XD: 150 case IC_64BIT_REXW_XS: 151 case IC_64BIT_REXW_OPSIZE: 152 case IC_64BIT_REXW_ADSIZE: 153 case IC_64BIT_REX2: 154 return false; 155 case IC_VEX: 156 return (VEX_LIG && WIG && inheritsFrom(child, IC_VEX_L_W)) || 157 (WIG && inheritsFrom(child, IC_VEX_W)) || 158 (VEX_LIG && inheritsFrom(child, IC_VEX_L)); 159 case IC_VEX_XS: 160 return (VEX_LIG && WIG && inheritsFrom(child, IC_VEX_L_W_XS)) || 161 (WIG && inheritsFrom(child, IC_VEX_W_XS)) || 162 (VEX_LIG && inheritsFrom(child, IC_VEX_L_XS)); 163 case IC_VEX_XD: 164 return (VEX_LIG && WIG && inheritsFrom(child, IC_VEX_L_W_XD)) || 165 (WIG && inheritsFrom(child, IC_VEX_W_XD)) || 166 (VEX_LIG && inheritsFrom(child, IC_VEX_L_XD)); 167 case IC_VEX_OPSIZE: 168 return (VEX_LIG && WIG && inheritsFrom(child, IC_VEX_L_W_OPSIZE)) || 169 (WIG && inheritsFrom(child, IC_VEX_W_OPSIZE)) || 170 (VEX_LIG && inheritsFrom(child, IC_VEX_L_OPSIZE)); 171 case IC_VEX_W: 172 return VEX_LIG && inheritsFrom(child, IC_VEX_L_W); 173 case IC_VEX_W_XS: 174 return VEX_LIG && inheritsFrom(child, IC_VEX_L_W_XS); 175 case IC_VEX_W_XD: 176 return VEX_LIG && inheritsFrom(child, IC_VEX_L_W_XD); 177 case IC_VEX_W_OPSIZE: 178 return VEX_LIG && inheritsFrom(child, IC_VEX_L_W_OPSIZE); 179 case IC_VEX_L: 180 return WIG && inheritsFrom(child, IC_VEX_L_W); 181 case IC_VEX_L_XS: 182 return WIG && inheritsFrom(child, IC_VEX_L_W_XS); 183 case IC_VEX_L_XD: 184 return WIG && inheritsFrom(child, IC_VEX_L_W_XD); 185 case IC_VEX_L_OPSIZE: 186 return WIG && inheritsFrom(child, IC_VEX_L_W_OPSIZE); 187 case IC_VEX_L_W: 188 case IC_VEX_L_W_XS: 189 case IC_VEX_L_W_XD: 190 case IC_VEX_L_W_OPSIZE: 191 return false; 192 case IC_EVEX: 193 return (VEX_LIG && WIG && inheritsFrom(child, IC_EVEX_L_W)) || 194 (VEX_LIG && WIG && inheritsFrom(child, IC_EVEX_L2_W)) || 195 (WIG && inheritsFrom(child, IC_EVEX_W)) || 196 (VEX_LIG && inheritsFrom(child, IC_EVEX_L)) || 197 (VEX_LIG && inheritsFrom(child, IC_EVEX_L2)); 198 case IC_EVEX_XS: 199 return (VEX_LIG && WIG && inheritsFrom(child, IC_EVEX_L_W_XS)) || 200 (VEX_LIG && WIG && inheritsFrom(child, IC_EVEX_L2_W_XS)) || 201 (WIG && inheritsFrom(child, IC_EVEX_W_XS)) || 202 (VEX_LIG && inheritsFrom(child, IC_EVEX_L_XS)) || 203 (VEX_LIG && inheritsFrom(child, IC_EVEX_L2_XS)); 204 case IC_EVEX_XD: 205 return (VEX_LIG && WIG && inheritsFrom(child, IC_EVEX_L_W_XD)) || 206 (VEX_LIG && WIG && inheritsFrom(child, IC_EVEX_L2_W_XD)) || 207 (WIG && inheritsFrom(child, IC_EVEX_W_XD)) || 208 (VEX_LIG && inheritsFrom(child, IC_EVEX_L_XD)) || 209 (VEX_LIG && inheritsFrom(child, IC_EVEX_L2_XD)); 210 case IC_EVEX_OPSIZE: 211 return (VEX_LIG && WIG && inheritsFrom(child, IC_EVEX_L_W_OPSIZE)) || 212 (VEX_LIG && WIG && inheritsFrom(child, IC_EVEX_L2_W_OPSIZE)) || 213 (WIG && inheritsFrom(child, IC_EVEX_W_OPSIZE)) || 214 (VEX_LIG && inheritsFrom(child, IC_EVEX_L_OPSIZE)) || 215 (VEX_LIG && inheritsFrom(child, IC_EVEX_L2_OPSIZE)); 216 case IC_EVEX_OPSIZE_ADSIZE: 217 return false; 218 case IC_EVEX_K: 219 return (VEX_LIG && WIG && inheritsFrom(child, IC_EVEX_L_W_K)) || 220 (VEX_LIG && WIG && inheritsFrom(child, IC_EVEX_L2_W_K)) || 221 (WIG && inheritsFrom(child, IC_EVEX_W_K)) || 222 (VEX_LIG && inheritsFrom(child, IC_EVEX_L_K)) || 223 (VEX_LIG && inheritsFrom(child, IC_EVEX_L2_K)); 224 case IC_EVEX_XS_K: 225 return (VEX_LIG && WIG && inheritsFrom(child, IC_EVEX_L_W_XS_K)) || 226 (VEX_LIG && WIG && inheritsFrom(child, IC_EVEX_L2_W_XS_K)) || 227 (WIG && inheritsFrom(child, IC_EVEX_W_XS_K)) || 228 (VEX_LIG && inheritsFrom(child, IC_EVEX_L_XS_K)) || 229 (VEX_LIG && inheritsFrom(child, IC_EVEX_L2_XS_K)); 230 case IC_EVEX_XD_K: 231 return (VEX_LIG && WIG && inheritsFrom(child, IC_EVEX_L_W_XD_K)) || 232 (VEX_LIG && WIG && inheritsFrom(child, IC_EVEX_L2_W_XD_K)) || 233 (WIG && inheritsFrom(child, IC_EVEX_W_XD_K)) || 234 (VEX_LIG && inheritsFrom(child, IC_EVEX_L_XD_K)) || 235 (VEX_LIG && inheritsFrom(child, IC_EVEX_L2_XD_K)); 236 case IC_EVEX_OPSIZE_K: 237 return (VEX_LIG && WIG && inheritsFrom(child, IC_EVEX_L_W_OPSIZE_K)) || 238 (VEX_LIG && WIG && inheritsFrom(child, IC_EVEX_L2_W_OPSIZE_K)) || 239 (WIG && inheritsFrom(child, IC_EVEX_W_OPSIZE_K)) || 240 (VEX_LIG && inheritsFrom(child, IC_EVEX_L_OPSIZE_K)) || 241 (VEX_LIG && inheritsFrom(child, IC_EVEX_L2_OPSIZE_K)); 242 case IC_EVEX_KZ: 243 return (VEX_LIG && WIG && inheritsFrom(child, IC_EVEX_L_W_KZ)) || 244 (VEX_LIG && WIG && inheritsFrom(child, IC_EVEX_L2_W_KZ)) || 245 (WIG && inheritsFrom(child, IC_EVEX_W_KZ)) || 246 (VEX_LIG && inheritsFrom(child, IC_EVEX_L_KZ)) || 247 (VEX_LIG && inheritsFrom(child, IC_EVEX_L2_KZ)); 248 case IC_EVEX_XS_KZ: 249 return (VEX_LIG && WIG && inheritsFrom(child, IC_EVEX_L_W_XS_KZ)) || 250 (VEX_LIG && WIG && inheritsFrom(child, IC_EVEX_L2_W_XS_KZ)) || 251 (WIG && inheritsFrom(child, IC_EVEX_W_XS_KZ)) || 252 (VEX_LIG && inheritsFrom(child, IC_EVEX_L_XS_KZ)) || 253 (VEX_LIG && inheritsFrom(child, IC_EVEX_L2_XS_KZ)); 254 case IC_EVEX_XD_KZ: 255 return (VEX_LIG && WIG && inheritsFrom(child, IC_EVEX_L_W_XD_KZ)) || 256 (VEX_LIG && WIG && inheritsFrom(child, IC_EVEX_L2_W_XD_KZ)) || 257 (WIG && inheritsFrom(child, IC_EVEX_W_XD_KZ)) || 258 (VEX_LIG && inheritsFrom(child, IC_EVEX_L_XD_KZ)) || 259 (VEX_LIG && inheritsFrom(child, IC_EVEX_L2_XD_KZ)); 260 case IC_EVEX_OPSIZE_KZ: 261 return (VEX_LIG && WIG && inheritsFrom(child, IC_EVEX_L_W_OPSIZE_KZ)) || 262 (VEX_LIG && WIG && inheritsFrom(child, IC_EVEX_L2_W_OPSIZE_KZ)) || 263 (WIG && inheritsFrom(child, IC_EVEX_W_OPSIZE_KZ)) || 264 (VEX_LIG && inheritsFrom(child, IC_EVEX_L_OPSIZE_KZ)) || 265 (VEX_LIG && inheritsFrom(child, IC_EVEX_L2_OPSIZE_KZ)); 266 case IC_EVEX_W: 267 return (VEX_LIG && inheritsFrom(child, IC_EVEX_L_W)) || 268 (VEX_LIG && inheritsFrom(child, IC_EVEX_L2_W)); 269 case IC_EVEX_W_XS: 270 return (VEX_LIG && inheritsFrom(child, IC_EVEX_L_W_XS)) || 271 (VEX_LIG && inheritsFrom(child, IC_EVEX_L2_W_XS)); 272 case IC_EVEX_W_XD: 273 return (VEX_LIG && inheritsFrom(child, IC_EVEX_L_W_XD)) || 274 (VEX_LIG && inheritsFrom(child, IC_EVEX_L2_W_XD)); 275 case IC_EVEX_W_OPSIZE: 276 return (VEX_LIG && inheritsFrom(child, IC_EVEX_L_W_OPSIZE)) || 277 (VEX_LIG && inheritsFrom(child, IC_EVEX_L2_W_OPSIZE)); 278 case IC_EVEX_W_K: 279 return (VEX_LIG && inheritsFrom(child, IC_EVEX_L_W_K)) || 280 (VEX_LIG && inheritsFrom(child, IC_EVEX_L2_W_K)); 281 case IC_EVEX_W_XS_K: 282 return (VEX_LIG && inheritsFrom(child, IC_EVEX_L_W_XS_K)) || 283 (VEX_LIG && inheritsFrom(child, IC_EVEX_L2_W_XS_K)); 284 case IC_EVEX_W_XD_K: 285 return (VEX_LIG && inheritsFrom(child, IC_EVEX_L_W_XD_K)) || 286 (VEX_LIG && inheritsFrom(child, IC_EVEX_L2_W_XD_K)); 287 case IC_EVEX_W_OPSIZE_K: 288 return (VEX_LIG && inheritsFrom(child, IC_EVEX_L_W_OPSIZE_K)) || 289 (VEX_LIG && inheritsFrom(child, IC_EVEX_L2_W_OPSIZE_K)); 290 case IC_EVEX_W_KZ: 291 return (VEX_LIG && inheritsFrom(child, IC_EVEX_L_W_KZ)) || 292 (VEX_LIG && inheritsFrom(child, IC_EVEX_L2_W_KZ)); 293 case IC_EVEX_W_XS_KZ: 294 return (VEX_LIG && inheritsFrom(child, IC_EVEX_L_W_XS_KZ)) || 295 (VEX_LIG && inheritsFrom(child, IC_EVEX_L2_W_XS_KZ)); 296 case IC_EVEX_W_XD_KZ: 297 return (VEX_LIG && inheritsFrom(child, IC_EVEX_L_W_XD_KZ)) || 298 (VEX_LIG && inheritsFrom(child, IC_EVEX_L2_W_XD_KZ)); 299 case IC_EVEX_W_OPSIZE_KZ: 300 return (VEX_LIG && inheritsFrom(child, IC_EVEX_L_W_OPSIZE_KZ)) || 301 (VEX_LIG && inheritsFrom(child, IC_EVEX_L2_W_OPSIZE_KZ)); 302 case IC_EVEX_L: 303 return WIG && inheritsFrom(child, IC_EVEX_L_W); 304 case IC_EVEX_L_XS: 305 return WIG && inheritsFrom(child, IC_EVEX_L_W_XS); 306 case IC_EVEX_L_XD: 307 return WIG && inheritsFrom(child, IC_EVEX_L_W_XD); 308 case IC_EVEX_L_OPSIZE: 309 return WIG && inheritsFrom(child, IC_EVEX_L_W_OPSIZE); 310 case IC_EVEX_L_K: 311 return WIG && inheritsFrom(child, IC_EVEX_L_W_K); 312 case IC_EVEX_L_XS_K: 313 return WIG && inheritsFrom(child, IC_EVEX_L_W_XS_K); 314 case IC_EVEX_L_XD_K: 315 return WIG && inheritsFrom(child, IC_EVEX_L_W_XD_K); 316 case IC_EVEX_L_OPSIZE_K: 317 return WIG && inheritsFrom(child, IC_EVEX_L_W_OPSIZE_K); 318 case IC_EVEX_L_KZ: 319 return WIG && inheritsFrom(child, IC_EVEX_L_W_KZ); 320 case IC_EVEX_L_XS_KZ: 321 return WIG && inheritsFrom(child, IC_EVEX_L_W_XS_KZ); 322 case IC_EVEX_L_XD_KZ: 323 return WIG && inheritsFrom(child, IC_EVEX_L_W_XD_KZ); 324 case IC_EVEX_L_OPSIZE_KZ: 325 return WIG && inheritsFrom(child, IC_EVEX_L_W_OPSIZE_KZ); 326 case IC_EVEX_L_W: 327 case IC_EVEX_L_W_XS: 328 case IC_EVEX_L_W_XD: 329 case IC_EVEX_L_W_OPSIZE: 330 return false; 331 case IC_EVEX_L_W_K: 332 case IC_EVEX_L_W_XS_K: 333 case IC_EVEX_L_W_XD_K: 334 case IC_EVEX_L_W_OPSIZE_K: 335 return false; 336 case IC_EVEX_L_W_KZ: 337 case IC_EVEX_L_W_XS_KZ: 338 case IC_EVEX_L_W_XD_KZ: 339 case IC_EVEX_L_W_OPSIZE_KZ: 340 return false; 341 case IC_EVEX_L2: 342 return WIG && inheritsFrom(child, IC_EVEX_L2_W); 343 case IC_EVEX_L2_XS: 344 return WIG && inheritsFrom(child, IC_EVEX_L2_W_XS); 345 case IC_EVEX_L2_XD: 346 return WIG && inheritsFrom(child, IC_EVEX_L2_W_XD); 347 case IC_EVEX_L2_OPSIZE: 348 return WIG && inheritsFrom(child, IC_EVEX_L2_W_OPSIZE); 349 case IC_EVEX_L2_K: 350 return WIG && inheritsFrom(child, IC_EVEX_L2_W_K); 351 case IC_EVEX_L2_XS_K: 352 return WIG && inheritsFrom(child, IC_EVEX_L2_W_XS_K); 353 case IC_EVEX_L2_XD_K: 354 return WIG && inheritsFrom(child, IC_EVEX_L2_W_XD_K); 355 case IC_EVEX_L2_OPSIZE_K: 356 return WIG && inheritsFrom(child, IC_EVEX_L2_W_OPSIZE_K); 357 case IC_EVEX_L2_KZ: 358 return WIG && inheritsFrom(child, IC_EVEX_L2_W_KZ); 359 case IC_EVEX_L2_XS_KZ: 360 return WIG && inheritsFrom(child, IC_EVEX_L2_W_XS_KZ); 361 case IC_EVEX_L2_XD_KZ: 362 return WIG && inheritsFrom(child, IC_EVEX_L2_W_XD_KZ); 363 case IC_EVEX_L2_OPSIZE_KZ: 364 return WIG && inheritsFrom(child, IC_EVEX_L2_W_OPSIZE_KZ); 365 case IC_EVEX_L2_W: 366 case IC_EVEX_L2_W_XS: 367 case IC_EVEX_L2_W_XD: 368 case IC_EVEX_L2_W_OPSIZE: 369 return false; 370 case IC_EVEX_L2_W_K: 371 case IC_EVEX_L2_W_XS_K: 372 case IC_EVEX_L2_W_XD_K: 373 case IC_EVEX_L2_W_OPSIZE_K: 374 return false; 375 case IC_EVEX_L2_W_KZ: 376 case IC_EVEX_L2_W_XS_KZ: 377 case IC_EVEX_L2_W_XD_KZ: 378 case IC_EVEX_L2_W_OPSIZE_KZ: 379 return false; 380 case IC_EVEX_B: 381 return (VEX_LIG && WIG && inheritsFrom(child, IC_EVEX_L_W_B)) || 382 (VEX_LIG && WIG && inheritsFrom(child, IC_EVEX_L2_W_B)) || 383 (WIG && inheritsFrom(child, IC_EVEX_W_B)) || 384 (VEX_LIG && inheritsFrom(child, IC_EVEX_L_B)) || 385 (VEX_LIG && inheritsFrom(child, IC_EVEX_L2_B)); 386 case IC_EVEX_XS_B: 387 return (VEX_LIG && WIG && inheritsFrom(child, IC_EVEX_L_W_XS_B)) || 388 (VEX_LIG && WIG && inheritsFrom(child, IC_EVEX_L2_W_XS_B)) || 389 (WIG && inheritsFrom(child, IC_EVEX_W_XS_B)) || 390 (VEX_LIG && inheritsFrom(child, IC_EVEX_L_XS_B)) || 391 (VEX_LIG && inheritsFrom(child, IC_EVEX_L2_XS_B)); 392 case IC_EVEX_XD_B: 393 return (VEX_LIG && WIG && inheritsFrom(child, IC_EVEX_L_W_XD_B)) || 394 (VEX_LIG && WIG && inheritsFrom(child, IC_EVEX_L2_W_XD_B)) || 395 (WIG && inheritsFrom(child, IC_EVEX_W_XD_B)) || 396 (VEX_LIG && inheritsFrom(child, IC_EVEX_L_XD_B)) || 397 (VEX_LIG && inheritsFrom(child, IC_EVEX_L2_XD_B)); 398 case IC_EVEX_OPSIZE_B: 399 return (VEX_LIG && WIG && inheritsFrom(child, IC_EVEX_L_W_OPSIZE_B)) || 400 (VEX_LIG && WIG && inheritsFrom(child, IC_EVEX_L2_W_OPSIZE_B)) || 401 (WIG && inheritsFrom(child, IC_EVEX_W_OPSIZE_B)) || 402 (VEX_LIG && inheritsFrom(child, IC_EVEX_L_OPSIZE_B)) || 403 (VEX_LIG && inheritsFrom(child, IC_EVEX_L2_OPSIZE_B)); 404 case IC_EVEX_K_B: 405 return (VEX_LIG && WIG && inheritsFrom(child, IC_EVEX_L_W_K_B)) || 406 (VEX_LIG && WIG && inheritsFrom(child, IC_EVEX_L2_W_K_B)) || 407 (WIG && inheritsFrom(child, IC_EVEX_W_K_B)) || 408 (VEX_LIG && inheritsFrom(child, IC_EVEX_L_K_B)) || 409 (VEX_LIG && inheritsFrom(child, IC_EVEX_L2_K_B)); 410 case IC_EVEX_XS_K_B: 411 return (VEX_LIG && WIG && inheritsFrom(child, IC_EVEX_L_W_XS_K_B)) || 412 (VEX_LIG && WIG && inheritsFrom(child, IC_EVEX_L2_W_XS_K_B)) || 413 (WIG && inheritsFrom(child, IC_EVEX_W_XS_K_B)) || 414 (VEX_LIG && inheritsFrom(child, IC_EVEX_L_XS_K_B)) || 415 (VEX_LIG && inheritsFrom(child, IC_EVEX_L2_XS_K_B)); 416 case IC_EVEX_XD_K_B: 417 return (VEX_LIG && WIG && inheritsFrom(child, IC_EVEX_L_W_XD_K_B)) || 418 (VEX_LIG && WIG && inheritsFrom(child, IC_EVEX_L2_W_XD_K_B)) || 419 (WIG && inheritsFrom(child, IC_EVEX_W_XD_K_B)) || 420 (VEX_LIG && inheritsFrom(child, IC_EVEX_L_XD_K_B)) || 421 (VEX_LIG && inheritsFrom(child, IC_EVEX_L2_XD_K_B)); 422 case IC_EVEX_OPSIZE_K_B: 423 return (VEX_LIG && WIG && inheritsFrom(child, IC_EVEX_L_W_OPSIZE_K_B)) || 424 (VEX_LIG && WIG && inheritsFrom(child, IC_EVEX_L2_W_OPSIZE_K_B)) || 425 (WIG && inheritsFrom(child, IC_EVEX_W_OPSIZE_K_B)) || 426 (VEX_LIG && inheritsFrom(child, IC_EVEX_L_OPSIZE_K_B)) || 427 (VEX_LIG && inheritsFrom(child, IC_EVEX_L2_OPSIZE_K_B)); 428 case IC_EVEX_KZ_B: 429 return (VEX_LIG && WIG && inheritsFrom(child, IC_EVEX_L_W_KZ_B)) || 430 (VEX_LIG && WIG && inheritsFrom(child, IC_EVEX_L2_W_KZ_B)) || 431 (WIG && inheritsFrom(child, IC_EVEX_W_KZ_B)) || 432 (VEX_LIG && inheritsFrom(child, IC_EVEX_L_KZ_B)) || 433 (VEX_LIG && inheritsFrom(child, IC_EVEX_L2_KZ_B)); 434 case IC_EVEX_XS_KZ_B: 435 return (VEX_LIG && WIG && inheritsFrom(child, IC_EVEX_L_W_XS_KZ_B)) || 436 (VEX_LIG && WIG && inheritsFrom(child, IC_EVEX_L2_W_XS_KZ_B)) || 437 (WIG && inheritsFrom(child, IC_EVEX_W_XS_KZ_B)) || 438 (VEX_LIG && inheritsFrom(child, IC_EVEX_L_XS_KZ_B)) || 439 (VEX_LIG && inheritsFrom(child, IC_EVEX_L2_XS_KZ_B)); 440 case IC_EVEX_XD_KZ_B: 441 return (VEX_LIG && WIG && inheritsFrom(child, IC_EVEX_L_W_XD_KZ_B)) || 442 (VEX_LIG && WIG && inheritsFrom(child, IC_EVEX_L2_W_XD_KZ_B)) || 443 (WIG && inheritsFrom(child, IC_EVEX_W_XD_KZ_B)) || 444 (VEX_LIG && inheritsFrom(child, IC_EVEX_L_XD_KZ_B)) || 445 (VEX_LIG && inheritsFrom(child, IC_EVEX_L2_XD_KZ_B)); 446 case IC_EVEX_OPSIZE_KZ_B: 447 return (VEX_LIG && WIG && inheritsFrom(child, IC_EVEX_L_W_OPSIZE_KZ_B)) || 448 (VEX_LIG && WIG && inheritsFrom(child, IC_EVEX_L2_W_OPSIZE_KZ_B)) || 449 (WIG && inheritsFrom(child, IC_EVEX_W_OPSIZE_KZ_B)) || 450 (VEX_LIG && inheritsFrom(child, IC_EVEX_L_OPSIZE_KZ_B)) || 451 (VEX_LIG && inheritsFrom(child, IC_EVEX_L2_OPSIZE_KZ_B)); 452 case IC_EVEX_W_B: 453 return (VEX_LIG && inheritsFrom(child, IC_EVEX_L_W_B)) || 454 (VEX_LIG && inheritsFrom(child, IC_EVEX_L2_W_B)); 455 case IC_EVEX_W_XS_B: 456 return (VEX_LIG && inheritsFrom(child, IC_EVEX_L_W_XS_B)) || 457 (VEX_LIG && inheritsFrom(child, IC_EVEX_L2_W_XS_B)); 458 case IC_EVEX_W_XD_B: 459 return (VEX_LIG && inheritsFrom(child, IC_EVEX_L_W_XD_B)) || 460 (VEX_LIG && inheritsFrom(child, IC_EVEX_L2_W_XD_B)); 461 case IC_EVEX_W_OPSIZE_B: 462 return (VEX_LIG && inheritsFrom(child, IC_EVEX_L_W_OPSIZE_B)) || 463 (VEX_LIG && inheritsFrom(child, IC_EVEX_L2_W_OPSIZE_B)); 464 case IC_EVEX_W_K_B: 465 return (VEX_LIG && inheritsFrom(child, IC_EVEX_L_W_K_B)) || 466 (VEX_LIG && inheritsFrom(child, IC_EVEX_L2_W_K_B)); 467 case IC_EVEX_W_XS_K_B: 468 return (VEX_LIG && inheritsFrom(child, IC_EVEX_L_W_XS_K_B)) || 469 (VEX_LIG && inheritsFrom(child, IC_EVEX_L2_W_XS_K_B)); 470 case IC_EVEX_W_XD_K_B: 471 return (VEX_LIG && inheritsFrom(child, IC_EVEX_L_W_XD_K_B)) || 472 (VEX_LIG && inheritsFrom(child, IC_EVEX_L2_W_XD_K_B)); 473 case IC_EVEX_W_OPSIZE_K_B: 474 return (VEX_LIG && inheritsFrom(child, IC_EVEX_L_W_OPSIZE_K_B)) || 475 (VEX_LIG && inheritsFrom(child, IC_EVEX_L2_W_OPSIZE_K_B)); 476 case IC_EVEX_W_KZ_B: 477 return (VEX_LIG && inheritsFrom(child, IC_EVEX_L_W_KZ_B)) || 478 (VEX_LIG && inheritsFrom(child, IC_EVEX_L2_W_KZ_B)); 479 case IC_EVEX_W_XS_KZ_B: 480 return (VEX_LIG && inheritsFrom(child, IC_EVEX_L_W_XS_KZ_B)) || 481 (VEX_LIG && inheritsFrom(child, IC_EVEX_L2_W_XS_KZ_B)); 482 case IC_EVEX_W_XD_KZ_B: 483 return (VEX_LIG && inheritsFrom(child, IC_EVEX_L_W_XD_KZ_B)) || 484 (VEX_LIG && inheritsFrom(child, IC_EVEX_L2_W_XD_KZ_B)); 485 case IC_EVEX_W_OPSIZE_KZ_B: 486 return (VEX_LIG && inheritsFrom(child, IC_EVEX_L_W_OPSIZE_KZ_B)) || 487 (VEX_LIG && inheritsFrom(child, IC_EVEX_L2_W_OPSIZE_KZ_B)); 488 case IC_EVEX_L_B: 489 return WIG && inheritsFrom(child, IC_EVEX_L_W_B); 490 case IC_EVEX_L_XS_B: 491 return WIG && inheritsFrom(child, IC_EVEX_L_W_XS_B); 492 case IC_EVEX_L_XD_B: 493 return WIG && inheritsFrom(child, IC_EVEX_L_W_XD_B); 494 case IC_EVEX_L_OPSIZE_B: 495 return WIG && inheritsFrom(child, IC_EVEX_L_W_OPSIZE_B); 496 case IC_EVEX_L_K_B: 497 return WIG && inheritsFrom(child, IC_EVEX_L_W_K_B); 498 case IC_EVEX_L_XS_K_B: 499 return WIG && inheritsFrom(child, IC_EVEX_L_W_XS_K_B); 500 case IC_EVEX_L_XD_K_B: 501 return WIG && inheritsFrom(child, IC_EVEX_L_W_XD_K_B); 502 case IC_EVEX_L_OPSIZE_K_B: 503 return WIG && inheritsFrom(child, IC_EVEX_L_W_OPSIZE_K_B); 504 case IC_EVEX_L_KZ_B: 505 return WIG && inheritsFrom(child, IC_EVEX_L_W_KZ_B); 506 case IC_EVEX_L_XS_KZ_B: 507 return WIG && inheritsFrom(child, IC_EVEX_L_W_XS_KZ_B); 508 case IC_EVEX_L_XD_KZ_B: 509 return WIG && inheritsFrom(child, IC_EVEX_L_W_XD_KZ_B); 510 case IC_EVEX_L_OPSIZE_KZ_B: 511 return WIG && inheritsFrom(child, IC_EVEX_L_W_OPSIZE_KZ_B); 512 case IC_EVEX_L_W_B: 513 case IC_EVEX_L_W_XS_B: 514 case IC_EVEX_L_W_XD_B: 515 case IC_EVEX_L_W_OPSIZE_B: 516 return false; 517 case IC_EVEX_L_W_K_B: 518 case IC_EVEX_L_W_XS_K_B: 519 case IC_EVEX_L_W_XD_K_B: 520 case IC_EVEX_L_W_OPSIZE_K_B: 521 return false; 522 case IC_EVEX_L_W_KZ_B: 523 case IC_EVEX_L_W_XS_KZ_B: 524 case IC_EVEX_L_W_XD_KZ_B: 525 case IC_EVEX_L_W_OPSIZE_KZ_B: 526 return false; 527 case IC_EVEX_L2_B: 528 return WIG && inheritsFrom(child, IC_EVEX_L2_W_B); 529 case IC_EVEX_L2_XS_B: 530 return WIG && inheritsFrom(child, IC_EVEX_L2_W_XS_B); 531 case IC_EVEX_L2_XD_B: 532 return WIG && inheritsFrom(child, IC_EVEX_L2_W_XD_B); 533 case IC_EVEX_L2_OPSIZE_B: 534 return WIG && inheritsFrom(child, IC_EVEX_L2_W_OPSIZE_B); 535 case IC_EVEX_L2_K_B: 536 return WIG && inheritsFrom(child, IC_EVEX_L2_W_K_B); 537 case IC_EVEX_L2_XS_K_B: 538 return WIG && inheritsFrom(child, IC_EVEX_L2_W_XS_K_B); 539 case IC_EVEX_L2_XD_K_B: 540 return WIG && inheritsFrom(child, IC_EVEX_L2_W_XD_K_B); 541 case IC_EVEX_L2_OPSIZE_K_B: 542 return WIG && inheritsFrom(child, IC_EVEX_L2_W_OPSIZE_K_B); 543 case IC_EVEX_L2_KZ_B: 544 return WIG && inheritsFrom(child, IC_EVEX_L2_W_KZ_B); 545 case IC_EVEX_L2_XS_KZ_B: 546 return WIG && inheritsFrom(child, IC_EVEX_L2_W_XS_KZ_B); 547 case IC_EVEX_L2_XD_KZ_B: 548 return WIG && inheritsFrom(child, IC_EVEX_L2_W_XD_KZ_B); 549 case IC_EVEX_L2_OPSIZE_KZ_B: 550 return WIG && inheritsFrom(child, IC_EVEX_L2_W_OPSIZE_KZ_B); 551 case IC_EVEX_L2_W_B: 552 case IC_EVEX_L2_W_XS_B: 553 case IC_EVEX_L2_W_XD_B: 554 case IC_EVEX_L2_W_OPSIZE_B: 555 return false; 556 case IC_EVEX_L2_W_K_B: 557 case IC_EVEX_L2_W_XS_K_B: 558 case IC_EVEX_L2_W_XD_K_B: 559 case IC_EVEX_L2_W_OPSIZE_K_B: 560 return false; 561 case IC_EVEX_L2_W_KZ_B: 562 case IC_EVEX_L2_W_XS_KZ_B: 563 case IC_EVEX_L2_W_XD_KZ_B: 564 case IC_EVEX_L2_W_OPSIZE_KZ_B: 565 return false; 566 default: 567 errs() << "Unknown instruction class: " 568 << stringForContext((InstructionContext)parent) << "\n"; 569 llvm_unreachable("Unknown instruction class"); 570 } 571 } 572 573 /// outranks - Indicates whether, if an instruction has two different applicable 574 /// classes, which class should be preferred when performing decode. This 575 /// imposes a total ordering (ties are resolved toward "lower") 576 /// 577 /// @param upper - The class that may be preferable 578 /// @param lower - The class that may be less preferable 579 /// @return - True if upper is to be preferred, false otherwise. 580 static inline bool outranks(InstructionContext upper, 581 InstructionContext lower) { 582 assert(upper < IC_max); 583 assert(lower < IC_max); 584 585 #define ENUM_ENTRY(n, r, d) r, 586 #define ENUM_ENTRY_K_B(n, r, d) \ 587 ENUM_ENTRY(n, r, d) \ 588 ENUM_ENTRY(n##_K_B, r, d) \ 589 ENUM_ENTRY(n##_KZ_B, r, d) ENUM_ENTRY(n##_KZ, r, d) ENUM_ENTRY(n##_K, r, d) \ 590 ENUM_ENTRY(n##_B, r, d) 591 static int ranks[IC_max] = {INSTRUCTION_CONTEXTS}; 592 #undef ENUM_ENTRY 593 #undef ENUM_ENTRY_K_B 594 595 return (ranks[upper] > ranks[lower]); 596 } 597 598 /// getDecisionType - Determines whether a ModRM decision with 255 entries can 599 /// be compacted by eliminating redundant information. 600 /// 601 /// @param decision - The decision to be compacted. 602 /// @return - The compactest available representation for the decision. 603 static ModRMDecisionType getDecisionType(ModRMDecision &decision) { 604 bool satisfiesOneEntry = true; 605 bool satisfiesSplitRM = true; 606 bool satisfiesSplitReg = true; 607 bool satisfiesSplitMisc = true; 608 609 for (unsigned index = 0; index < 256; ++index) { 610 if (decision.instructionIDs[index] != decision.instructionIDs[0]) 611 satisfiesOneEntry = false; 612 613 if (((index & 0xc0) == 0xc0) && 614 (decision.instructionIDs[index] != decision.instructionIDs[0xc0])) 615 satisfiesSplitRM = false; 616 617 if (((index & 0xc0) != 0xc0) && 618 (decision.instructionIDs[index] != decision.instructionIDs[0x00])) 619 satisfiesSplitRM = false; 620 621 if (((index & 0xc0) == 0xc0) && (decision.instructionIDs[index] != 622 decision.instructionIDs[index & 0xf8])) 623 satisfiesSplitReg = false; 624 625 if (((index & 0xc0) != 0xc0) && (decision.instructionIDs[index] != 626 decision.instructionIDs[index & 0x38])) 627 satisfiesSplitMisc = false; 628 } 629 630 if (satisfiesOneEntry) 631 return MODRM_ONEENTRY; 632 633 if (satisfiesSplitRM) 634 return MODRM_SPLITRM; 635 636 if (satisfiesSplitReg && satisfiesSplitMisc) 637 return MODRM_SPLITREG; 638 639 if (satisfiesSplitMisc) 640 return MODRM_SPLITMISC; 641 642 return MODRM_FULL; 643 } 644 645 /// stringForDecisionType - Returns a statically-allocated string corresponding 646 /// to a particular decision type. 647 /// 648 /// @param dt - The decision type. 649 /// @return - A pointer to the statically-allocated string (e.g., 650 /// "MODRM_ONEENTRY" for MODRM_ONEENTRY). 651 static const char *stringForDecisionType(ModRMDecisionType dt) { 652 #define ENUM_ENTRY(n) \ 653 case n: \ 654 return #n; 655 switch (dt) { 656 default: 657 llvm_unreachable("Unknown decision type"); 658 MODRMTYPES 659 }; 660 #undef ENUM_ENTRY 661 } 662 663 DisassemblerTables::DisassemblerTables() { 664 for (unsigned i = 0; i < std::size(Tables); i++) 665 Tables[i] = std::make_unique<ContextDecision>(); 666 667 HasConflicts = false; 668 } 669 670 DisassemblerTables::~DisassemblerTables() {} 671 672 void DisassemblerTables::emitModRMDecision(raw_ostream &o1, raw_ostream &o2, 673 unsigned &i1, unsigned &i2, 674 unsigned &ModRMTableNum, 675 ModRMDecision &decision) const { 676 static uint32_t sEntryNumber = 1; 677 ModRMDecisionType dt = getDecisionType(decision); 678 679 if (dt == MODRM_ONEENTRY && decision.instructionIDs[0] == 0) { 680 // Empty table. 681 o2 << "{" << stringForDecisionType(dt) << ", 0}"; 682 return; 683 } 684 685 std::vector<unsigned> ModRMDecision; 686 687 switch (dt) { 688 default: 689 llvm_unreachable("Unknown decision type"); 690 case MODRM_ONEENTRY: 691 ModRMDecision.push_back(decision.instructionIDs[0]); 692 break; 693 case MODRM_SPLITRM: 694 ModRMDecision.push_back(decision.instructionIDs[0x00]); 695 ModRMDecision.push_back(decision.instructionIDs[0xc0]); 696 break; 697 case MODRM_SPLITREG: 698 for (unsigned index = 0; index < 64; index += 8) 699 ModRMDecision.push_back(decision.instructionIDs[index]); 700 for (unsigned index = 0xc0; index < 256; index += 8) 701 ModRMDecision.push_back(decision.instructionIDs[index]); 702 break; 703 case MODRM_SPLITMISC: 704 for (unsigned index = 0; index < 64; index += 8) 705 ModRMDecision.push_back(decision.instructionIDs[index]); 706 for (unsigned index = 0xc0; index < 256; ++index) 707 ModRMDecision.push_back(decision.instructionIDs[index]); 708 break; 709 case MODRM_FULL: 710 for (unsigned short InstructionID : decision.instructionIDs) 711 ModRMDecision.push_back(InstructionID); 712 break; 713 } 714 715 unsigned &EntryNumber = ModRMTable[ModRMDecision]; 716 if (EntryNumber == 0) { 717 EntryNumber = ModRMTableNum; 718 719 ModRMTableNum += ModRMDecision.size(); 720 o1 << "/*Table" << EntryNumber << "*/\n"; 721 i1++; 722 for (unsigned I : ModRMDecision) { 723 o1.indent(i1 * 2) << format("0x%hx", I) << ", /*" 724 << InstructionSpecifiers[I].name << "*/\n"; 725 } 726 i1--; 727 } 728 729 o2 << "{" << stringForDecisionType(dt) << ", " << EntryNumber << "}"; 730 731 switch (dt) { 732 default: 733 llvm_unreachable("Unknown decision type"); 734 case MODRM_ONEENTRY: 735 sEntryNumber += 1; 736 break; 737 case MODRM_SPLITRM: 738 sEntryNumber += 2; 739 break; 740 case MODRM_SPLITREG: 741 sEntryNumber += 16; 742 break; 743 case MODRM_SPLITMISC: 744 sEntryNumber += 8 + 64; 745 break; 746 case MODRM_FULL: 747 sEntryNumber += 256; 748 break; 749 } 750 751 // We assume that the index can fit into uint16_t. 752 assert(sEntryNumber < 65536U && 753 "Index into ModRMDecision is too large for uint16_t!"); 754 (void)sEntryNumber; 755 } 756 757 void DisassemblerTables::emitOpcodeDecision(raw_ostream &o1, raw_ostream &o2, 758 unsigned &i1, unsigned &i2, 759 unsigned &ModRMTableNum, 760 OpcodeDecision &opDecision) const { 761 o2 << "{"; 762 ++i2; 763 764 unsigned index; 765 for (index = 0; index < 256; ++index) { 766 auto &decision = opDecision.modRMDecisions[index]; 767 ModRMDecisionType dt = getDecisionType(decision); 768 if (!(dt == MODRM_ONEENTRY && decision.instructionIDs[0] == 0)) 769 break; 770 } 771 if (index == 256) { 772 // If all 256 entries are MODRM_ONEENTRY, omit output. 773 static_assert(MODRM_ONEENTRY == 0); 774 --i2; 775 o2 << "},\n"; 776 } else { 777 o2 << " /* struct OpcodeDecision */ {\n"; 778 for (index = 0; index < 256; ++index) { 779 o2.indent(i2); 780 781 o2 << "/*0x" << format("%02hhx", index) << "*/"; 782 783 emitModRMDecision(o1, o2, i1, i2, ModRMTableNum, 784 opDecision.modRMDecisions[index]); 785 786 if (index < 255) 787 o2 << ","; 788 789 o2 << "\n"; 790 } 791 o2.indent(i2) << "}\n"; 792 --i2; 793 o2.indent(i2) << "},\n"; 794 } 795 } 796 797 void DisassemblerTables::emitContextDecision(raw_ostream &o1, raw_ostream &o2, 798 unsigned &i1, unsigned &i2, 799 unsigned &ModRMTableNum, 800 ContextDecision &decision, 801 const char *name) const { 802 o2.indent(i2) << "static const struct ContextDecision " << name 803 << " = {{/* opcodeDecisions */\n"; 804 i2++; 805 806 for (unsigned index = 0; index < IC_max; ++index) { 807 o2.indent(i2) << "/*"; 808 o2 << stringForContext((InstructionContext)index); 809 o2 << "*/ "; 810 811 emitOpcodeDecision(o1, o2, i1, i2, ModRMTableNum, 812 decision.opcodeDecisions[index]); 813 } 814 815 i2--; 816 o2.indent(i2) << "}};" << "\n"; 817 } 818 819 void DisassemblerTables::emitInstructionInfo(raw_ostream &o, 820 unsigned &i) const { 821 unsigned NumInstructions = InstructionSpecifiers.size(); 822 823 o << "static const struct OperandSpecifier x86OperandSets[][" 824 << X86_MAX_OPERANDS << "] = {\n"; 825 826 typedef SmallVector<std::pair<OperandEncoding, OperandType>, X86_MAX_OPERANDS> 827 OperandListTy; 828 std::map<OperandListTy, unsigned> OperandSets; 829 830 unsigned OperandSetNum = 0; 831 for (unsigned Index = 0; Index < NumInstructions; ++Index) { 832 OperandListTy OperandList; 833 834 for (auto Operand : InstructionSpecifiers[Index].operands) { 835 OperandEncoding Encoding = (OperandEncoding)Operand.encoding; 836 OperandType Type = (OperandType)Operand.type; 837 OperandList.push_back(std::make_pair(Encoding, Type)); 838 } 839 unsigned &N = OperandSets[OperandList]; 840 if (N != 0) 841 continue; 842 843 N = ++OperandSetNum; 844 845 o << " { /* " << (OperandSetNum - 1) << " */\n"; 846 for (unsigned i = 0, e = OperandList.size(); i != e; ++i) { 847 const char *Encoding = stringForOperandEncoding(OperandList[i].first); 848 const char *Type = stringForOperandType(OperandList[i].second); 849 o << " { " << Encoding << ", " << Type << " },\n"; 850 } 851 o << " },\n"; 852 } 853 o << "};" << "\n\n"; 854 855 o.indent(i * 2) << "static const struct InstructionSpecifier "; 856 o << INSTRUCTIONS_STR "[" << InstructionSpecifiers.size() << "] = {\n"; 857 858 i++; 859 860 for (unsigned index = 0; index < NumInstructions; ++index) { 861 o.indent(i * 2) << "{ /* " << index << " */\n"; 862 i++; 863 864 OperandListTy OperandList; 865 for (auto Operand : InstructionSpecifiers[index].operands) { 866 OperandEncoding Encoding = (OperandEncoding)Operand.encoding; 867 OperandType Type = (OperandType)Operand.type; 868 OperandList.push_back(std::make_pair(Encoding, Type)); 869 } 870 o.indent(i * 2) << (OperandSets[OperandList] - 1) << ",\n"; 871 872 o.indent(i * 2) << "/* " << InstructionSpecifiers[index].name << " */\n"; 873 874 i--; 875 o.indent(i * 2) << "},\n"; 876 } 877 878 i--; 879 o.indent(i * 2) << "};" << "\n"; 880 } 881 882 void DisassemblerTables::emitContextTable(raw_ostream &o, unsigned &i) const { 883 o.indent(i * 2) << "static const uint8_t " CONTEXTS_STR "[" << ATTR_max 884 << "] = {\n"; 885 i++; 886 887 for (unsigned index = 0; index < ATTR_max; ++index) { 888 o.indent(i * 2); 889 890 if ((index & ATTR_EVEX) && (index & ATTR_OPSIZE) && (index & ATTR_ADSIZE)) 891 o << "IC_EVEX_OPSIZE_ADSIZE"; 892 else if ((index & ATTR_EVEX) || (index & ATTR_VEX) || (index & ATTR_VEXL)) { 893 if (index & ATTR_EVEX) 894 o << "IC_EVEX"; 895 else 896 o << "IC_VEX"; 897 898 if ((index & ATTR_EVEX) && (index & ATTR_EVEXL2)) 899 o << "_L2"; 900 else if (index & ATTR_VEXL) 901 o << "_L"; 902 903 if (index & ATTR_REXW) 904 o << "_W"; 905 906 if (index & ATTR_OPSIZE) 907 o << "_OPSIZE"; 908 else if (index & ATTR_XD) 909 o << "_XD"; 910 else if (index & ATTR_XS) 911 o << "_XS"; 912 913 if (index & ATTR_EVEX) { 914 if (index & ATTR_EVEXKZ) 915 o << "_KZ"; 916 else if (index & ATTR_EVEXK) 917 o << "_K"; 918 919 if (index & ATTR_EVEXB) 920 o << "_B"; 921 } 922 } else if ((index & ATTR_64BIT) && (index & ATTR_REX2)) 923 o << "IC_64BIT_REX2"; 924 else if ((index & ATTR_64BIT) && (index & ATTR_REXW) && (index & ATTR_XS)) 925 o << "IC_64BIT_REXW_XS"; 926 else if ((index & ATTR_64BIT) && (index & ATTR_REXW) && (index & ATTR_XD)) 927 o << "IC_64BIT_REXW_XD"; 928 else if ((index & ATTR_64BIT) && (index & ATTR_REXW) && 929 (index & ATTR_OPSIZE)) 930 o << "IC_64BIT_REXW_OPSIZE"; 931 else if ((index & ATTR_64BIT) && (index & ATTR_REXW) && 932 (index & ATTR_ADSIZE)) 933 o << "IC_64BIT_REXW_ADSIZE"; 934 else if ((index & ATTR_64BIT) && (index & ATTR_XD) && (index & ATTR_OPSIZE)) 935 o << "IC_64BIT_XD_OPSIZE"; 936 else if ((index & ATTR_64BIT) && (index & ATTR_XD) && (index & ATTR_ADSIZE)) 937 o << "IC_64BIT_XD_ADSIZE"; 938 else if ((index & ATTR_64BIT) && (index & ATTR_XS) && (index & ATTR_OPSIZE)) 939 o << "IC_64BIT_XS_OPSIZE"; 940 else if ((index & ATTR_64BIT) && (index & ATTR_XS) && (index & ATTR_ADSIZE)) 941 o << "IC_64BIT_XS_ADSIZE"; 942 else if ((index & ATTR_64BIT) && (index & ATTR_XS)) 943 o << "IC_64BIT_XS"; 944 else if ((index & ATTR_64BIT) && (index & ATTR_XD)) 945 o << "IC_64BIT_XD"; 946 else if ((index & ATTR_64BIT) && (index & ATTR_OPSIZE) && 947 (index & ATTR_ADSIZE)) 948 o << "IC_64BIT_OPSIZE_ADSIZE"; 949 else if ((index & ATTR_64BIT) && (index & ATTR_OPSIZE)) 950 o << "IC_64BIT_OPSIZE"; 951 else if ((index & ATTR_64BIT) && (index & ATTR_ADSIZE)) 952 o << "IC_64BIT_ADSIZE"; 953 else if ((index & ATTR_64BIT) && (index & ATTR_REXW)) 954 o << "IC_64BIT_REXW"; 955 else if ((index & ATTR_64BIT)) 956 o << "IC_64BIT"; 957 else if ((index & ATTR_XS) && (index & ATTR_OPSIZE)) 958 o << "IC_XS_OPSIZE"; 959 else if ((index & ATTR_XD) && (index & ATTR_OPSIZE)) 960 o << "IC_XD_OPSIZE"; 961 else if ((index & ATTR_XS) && (index & ATTR_ADSIZE)) 962 o << "IC_XS_ADSIZE"; 963 else if ((index & ATTR_XD) && (index & ATTR_ADSIZE)) 964 o << "IC_XD_ADSIZE"; 965 else if (index & ATTR_XS) 966 o << "IC_XS"; 967 else if (index & ATTR_XD) 968 o << "IC_XD"; 969 else if ((index & ATTR_OPSIZE) && (index & ATTR_ADSIZE)) 970 o << "IC_OPSIZE_ADSIZE"; 971 else if (index & ATTR_OPSIZE) 972 o << "IC_OPSIZE"; 973 else if (index & ATTR_ADSIZE) 974 o << "IC_ADSIZE"; 975 else 976 o << "IC"; 977 978 o << ", // " << index << "\n"; 979 } 980 981 i--; 982 o.indent(i * 2) << "};" << "\n"; 983 } 984 985 void DisassemblerTables::emitContextDecisions(raw_ostream &o1, raw_ostream &o2, 986 unsigned &i1, unsigned &i2, 987 unsigned &ModRMTableNum) const { 988 emitContextDecision(o1, o2, i1, i2, ModRMTableNum, *Tables[0], ONEBYTE_STR); 989 emitContextDecision(o1, o2, i1, i2, ModRMTableNum, *Tables[1], TWOBYTE_STR); 990 emitContextDecision(o1, o2, i1, i2, ModRMTableNum, *Tables[2], 991 THREEBYTE38_STR); 992 emitContextDecision(o1, o2, i1, i2, ModRMTableNum, *Tables[3], 993 THREEBYTE3A_STR); 994 emitContextDecision(o1, o2, i1, i2, ModRMTableNum, *Tables[4], XOP8_MAP_STR); 995 emitContextDecision(o1, o2, i1, i2, ModRMTableNum, *Tables[5], XOP9_MAP_STR); 996 emitContextDecision(o1, o2, i1, i2, ModRMTableNum, *Tables[6], XOPA_MAP_STR); 997 emitContextDecision(o1, o2, i1, i2, ModRMTableNum, *Tables[7], 998 THREEDNOW_MAP_STR); 999 emitContextDecision(o1, o2, i1, i2, ModRMTableNum, *Tables[8], MAP4_STR); 1000 emitContextDecision(o1, o2, i1, i2, ModRMTableNum, *Tables[9], MAP5_STR); 1001 emitContextDecision(o1, o2, i1, i2, ModRMTableNum, *Tables[10], MAP6_STR); 1002 emitContextDecision(o1, o2, i1, i2, ModRMTableNum, *Tables[11], MAP7_STR); 1003 } 1004 1005 void DisassemblerTables::emit(raw_ostream &o) const { 1006 unsigned i1 = 0; 1007 unsigned i2 = 0; 1008 1009 std::string s1; 1010 std::string s2; 1011 1012 raw_string_ostream o1(s1); 1013 raw_string_ostream o2(s2); 1014 1015 emitInstructionInfo(o, i2); 1016 o << "\n"; 1017 1018 emitContextTable(o, i2); 1019 o << "\n"; 1020 1021 unsigned ModRMTableNum = 0; 1022 1023 o << "static const InstrUID modRMTable[] = {\n"; 1024 i1++; 1025 std::vector<unsigned> EmptyTable(1, 0); 1026 ModRMTable[EmptyTable] = ModRMTableNum; 1027 ModRMTableNum += EmptyTable.size(); 1028 o1 << "/*EmptyTable*/\n"; 1029 o1.indent(i1 * 2) << "0x0,\n"; 1030 i1--; 1031 emitContextDecisions(o1, o2, i1, i2, ModRMTableNum); 1032 1033 o << o1.str(); 1034 o << " 0x0\n"; 1035 o << "};\n"; 1036 o << "\n"; 1037 o << o2.str(); 1038 o << "\n"; 1039 o << "\n"; 1040 } 1041 1042 void DisassemblerTables::setTableFields(ModRMDecision &decision, 1043 const ModRMFilter &filter, InstrUID uid, 1044 uint8_t opcode) { 1045 for (unsigned index = 0; index < 256; ++index) { 1046 if (filter.accepts(index)) { 1047 if (decision.instructionIDs[index] == uid) 1048 continue; 1049 1050 if (decision.instructionIDs[index] != 0) { 1051 InstructionSpecifier &newInfo = InstructionSpecifiers[uid]; 1052 InstructionSpecifier &previousInfo = 1053 InstructionSpecifiers[decision.instructionIDs[index]]; 1054 1055 if (previousInfo.name == "NOOP" && 1056 (newInfo.name == "XCHG16ar" || newInfo.name == "XCHG32ar" || 1057 newInfo.name == "XCHG64ar")) 1058 continue; // special case for XCHG*ar and NOOP 1059 1060 if (outranks(previousInfo.insnContext, newInfo.insnContext)) 1061 continue; 1062 1063 if (previousInfo.insnContext == newInfo.insnContext) { 1064 errs() << "Error: Primary decode conflict: "; 1065 errs() << newInfo.name << " would overwrite " << previousInfo.name; 1066 errs() << "\n"; 1067 errs() << "ModRM " << index << "\n"; 1068 errs() << "Opcode " << (uint16_t)opcode << "\n"; 1069 errs() << "Context " << stringForContext(newInfo.insnContext) << "\n"; 1070 HasConflicts = true; 1071 } 1072 } 1073 1074 decision.instructionIDs[index] = uid; 1075 } 1076 } 1077 } 1078 1079 void DisassemblerTables::setTableFields( 1080 OpcodeType type, InstructionContext insnContext, uint8_t opcode, 1081 const ModRMFilter &filter, InstrUID uid, bool is32bit, bool noPrefix, 1082 bool ignoresVEX_L, bool ignoresW, unsigned addressSize) { 1083 ContextDecision &decision = *Tables[type]; 1084 1085 for (unsigned index = 0; index < IC_max; ++index) { 1086 if ((is32bit || addressSize == 16) && 1087 inheritsFrom((InstructionContext)index, IC_64BIT)) 1088 continue; 1089 1090 bool adSize64 = addressSize == 64; 1091 if (inheritsFrom((InstructionContext)index, 1092 InstructionSpecifiers[uid].insnContext, noPrefix, 1093 ignoresVEX_L, ignoresW, adSize64)) 1094 setTableFields(decision.opcodeDecisions[index].modRMDecisions[opcode], 1095 filter, uid, opcode); 1096 } 1097 } 1098