1 // Copyright 2014, VIXL authors 2 // All rights reserved. 3 // 4 // Redistribution and use in source and binary forms, with or without 5 // modification, are permitted provided that the following conditions are met: 6 // 7 // * Redistributions of source code must retain the above copyright notice, 8 // this list of conditions and the following disclaimer. 9 // * Redistributions in binary form must reproduce the above copyright notice, 10 // this list of conditions and the following disclaimer in the documentation 11 // and/or other materials provided with the distribution. 12 // * Neither the name of ARM Limited nor the names of its contributors may be 13 // used to endorse or promote products derived from this software without 14 // specific prior written permission. 15 // 16 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS CONTRIBUTORS "AS IS" AND 17 // ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 18 // WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 19 // DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE 20 // FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 21 // DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR 22 // SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 23 // CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 24 // OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 25 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 26 27 #include "../globals-vixl.h" 28 #include "../utils-vixl.h" 29 30 #include "decoder-aarch64.h" 31 32 namespace vixl { 33 namespace aarch64 { 34 35 void Decoder::DecodeInstruction(const Instruction* instr) { 36 if (instr->ExtractBits(28, 27) == 0) { 37 VisitUnallocated(instr); 38 } else { 39 switch (instr->ExtractBits(27, 24)) { 40 // 0: PC relative addressing. 41 case 0x0: 42 DecodePCRelAddressing(instr); 43 break; 44 45 // 1: Add/sub immediate. 46 case 0x1: 47 DecodeAddSubImmediate(instr); 48 break; 49 50 // A: Logical shifted register. 51 // Add/sub with carry. 52 // Conditional compare register. 53 // Conditional compare immediate. 54 // Conditional select. 55 // Data processing 1 source. 56 // Data processing 2 source. 57 // B: Add/sub shifted register. 58 // Add/sub extended register. 59 // Data processing 3 source. 60 case 0xA: 61 case 0xB: 62 DecodeDataProcessing(instr); 63 break; 64 65 // 2: Logical immediate. 66 // Move wide immediate. 67 case 0x2: 68 DecodeLogical(instr); 69 break; 70 71 // 3: Bitfield. 72 // Extract. 73 case 0x3: 74 DecodeBitfieldExtract(instr); 75 break; 76 77 // 4: Unconditional branch immediate. 78 // Exception generation. 79 // Compare and branch immediate. 80 // 5: Compare and branch immediate. 81 // Conditional branch. 82 // System. 83 // 6,7: Unconditional branch. 84 // Test and branch immediate. 85 case 0x4: 86 case 0x5: 87 case 0x6: 88 case 0x7: 89 DecodeBranchSystemException(instr); 90 break; 91 92 // 8,9: Load/store register pair post-index. 93 // Load register literal. 94 // Load/store register unscaled immediate. 95 // Load/store register immediate post-index. 96 // Load/store register immediate pre-index. 97 // Load/store register offset. 98 // Load/store exclusive. 99 // C,D: Load/store register pair offset. 100 // Load/store register pair pre-index. 101 // Load/store register unsigned immediate. 102 // Advanced SIMD. 103 case 0x8: 104 case 0x9: 105 case 0xC: 106 case 0xD: 107 DecodeLoadStore(instr); 108 break; 109 110 // E: FP fixed point conversion. 111 // FP integer conversion. 112 // FP data processing 1 source. 113 // FP compare. 114 // FP immediate. 115 // FP data processing 2 source. 116 // FP conditional compare. 117 // FP conditional select. 118 // Advanced SIMD. 119 // F: FP data processing 3 source. 120 // Advanced SIMD. 121 case 0xE: 122 case 0xF: 123 DecodeFP(instr); 124 break; 125 } 126 } 127 } 128 129 void Decoder::AppendVisitor(DecoderVisitor* new_visitor) { 130 visitors_.push_back(new_visitor); 131 } 132 133 134 void Decoder::PrependVisitor(DecoderVisitor* new_visitor) { 135 visitors_.push_front(new_visitor); 136 } 137 138 139 void Decoder::InsertVisitorBefore(DecoderVisitor* new_visitor, 140 DecoderVisitor* registered_visitor) { 141 std::list<DecoderVisitor*>::iterator it; 142 for (it = visitors_.begin(); it != visitors_.end(); it++) { 143 if (*it == registered_visitor) { 144 visitors_.insert(it, new_visitor); 145 return; 146 } 147 } 148 // We reached the end of the list. The last element must be 149 // registered_visitor. 150 VIXL_ASSERT(*it == registered_visitor); 151 visitors_.insert(it, new_visitor); 152 } 153 154 155 void Decoder::InsertVisitorAfter(DecoderVisitor* new_visitor, 156 DecoderVisitor* registered_visitor) { 157 std::list<DecoderVisitor*>::iterator it; 158 for (it = visitors_.begin(); it != visitors_.end(); it++) { 159 if (*it == registered_visitor) { 160 it++; 161 visitors_.insert(it, new_visitor); 162 return; 163 } 164 } 165 // We reached the end of the list. The last element must be 166 // registered_visitor. 167 VIXL_ASSERT(*it == registered_visitor); 168 visitors_.push_back(new_visitor); 169 } 170 171 172 void Decoder::RemoveVisitor(DecoderVisitor* visitor) { 173 visitors_.remove(visitor); 174 } 175 176 177 void Decoder::DecodePCRelAddressing(const Instruction* instr) { 178 VIXL_ASSERT(instr->ExtractBits(27, 24) == 0x0); 179 // We know bit 28 is set, as <b28:b27> = 0 is filtered out at the top level 180 // decode. 181 VIXL_ASSERT(instr->ExtractBit(28) == 0x1); 182 VisitPCRelAddressing(instr); 183 } 184 185 186 void Decoder::DecodeBranchSystemException(const Instruction* instr) { 187 VIXL_ASSERT((instr->ExtractBits(27, 24) == 0x4) || 188 (instr->ExtractBits(27, 24) == 0x5) || 189 (instr->ExtractBits(27, 24) == 0x6) || 190 (instr->ExtractBits(27, 24) == 0x7)); 191 192 switch (instr->ExtractBits(31, 29)) { 193 case 0: 194 case 4: { 195 VisitUnconditionalBranch(instr); 196 break; 197 } 198 case 1: 199 case 5: { 200 if (instr->ExtractBit(25) == 0) { 201 VisitCompareBranch(instr); 202 } else { 203 VisitTestBranch(instr); 204 } 205 break; 206 } 207 case 2: { 208 if (instr->ExtractBit(25) == 0) { 209 if ((instr->ExtractBit(24) == 0x1) || 210 (instr->Mask(0x01000010) == 0x00000010)) { 211 VisitUnallocated(instr); 212 } else { 213 VisitConditionalBranch(instr); 214 } 215 } else { 216 VisitUnallocated(instr); 217 } 218 break; 219 } 220 case 6: { 221 if (instr->ExtractBit(25) == 0) { 222 if (instr->ExtractBit(24) == 0) { 223 if ((instr->ExtractBits(4, 2) != 0) || 224 (instr->Mask(0x00E0001D) == 0x00200001) || 225 (instr->Mask(0x00E0001D) == 0x00400001) || 226 (instr->Mask(0x00E0001E) == 0x00200002) || 227 (instr->Mask(0x00E0001E) == 0x00400002) || 228 (instr->Mask(0x00E0001C) == 0x00600000) || 229 (instr->Mask(0x00E0001C) == 0x00800000) || 230 (instr->Mask(0x00E0001F) == 0x00A00000) || 231 (instr->Mask(0x00C0001C) == 0x00C00000)) { 232 VisitUnallocated(instr); 233 } else { 234 VisitException(instr); 235 } 236 } else { 237 if (instr->ExtractBits(23, 22) == 0) { 238 const Instr masked_003FF0E0 = instr->Mask(0x003FF0E0); 239 if ((instr->ExtractBits(21, 19) == 0x4) || 240 (masked_003FF0E0 == 0x00033000) || 241 (masked_003FF0E0 == 0x003FF020) || 242 (masked_003FF0E0 == 0x003FF060) || 243 (masked_003FF0E0 == 0x003FF0E0) || 244 (instr->Mask(0x00388000) == 0x00008000) || 245 (instr->Mask(0x0038E000) == 0x00000000) || 246 (instr->Mask(0x0039E000) == 0x00002000) || 247 (instr->Mask(0x003AE000) == 0x00002000) || 248 (instr->Mask(0x003CE000) == 0x00042000) || 249 (instr->Mask(0x003FFFC0) == 0x000320C0) || 250 (instr->Mask(0x003FF100) == 0x00032100) || 251 (instr->Mask(0x003FF200) == 0x00032200) || 252 (instr->Mask(0x003FF400) == 0x00032400) || 253 (instr->Mask(0x003FF800) == 0x00032800) || 254 (instr->Mask(0x0038F000) == 0x00005000) || 255 (instr->Mask(0x0038E000) == 0x00006000)) { 256 VisitUnallocated(instr); 257 } else { 258 VisitSystem(instr); 259 } 260 } else { 261 VisitUnallocated(instr); 262 } 263 } 264 } else { 265 if ((instr->ExtractBit(24) == 0x1) || 266 (instr->ExtractBits(20, 16) != 0x1F) || 267 (instr->ExtractBits(15, 10) != 0) || 268 (instr->ExtractBits(4, 0) != 0) || 269 (instr->ExtractBits(24, 21) == 0x3) || 270 (instr->ExtractBits(24, 22) == 0x3)) { 271 VisitUnallocated(instr); 272 } else { 273 VisitUnconditionalBranchToRegister(instr); 274 } 275 } 276 break; 277 } 278 case 3: 279 case 7: { 280 VisitUnallocated(instr); 281 break; 282 } 283 } 284 } 285 286 287 void Decoder::DecodeLoadStore(const Instruction* instr) { 288 VIXL_ASSERT((instr->ExtractBits(27, 24) == 0x8) || 289 (instr->ExtractBits(27, 24) == 0x9) || 290 (instr->ExtractBits(27, 24) == 0xC) || 291 (instr->ExtractBits(27, 24) == 0xD)); 292 // TODO(all): rearrange the tree to integrate this branch. 293 if ((instr->ExtractBit(28) == 0) && (instr->ExtractBit(29) == 0) && 294 (instr->ExtractBit(26) == 1)) { 295 DecodeNEONLoadStore(instr); 296 return; 297 } 298 299 if (instr->ExtractBit(24) == 0) { 300 if (instr->ExtractBit(28) == 0) { 301 if (instr->ExtractBit(29) == 0) { 302 if (instr->ExtractBit(26) == 0) { 303 VisitLoadStoreExclusive(instr); 304 } else { 305 VIXL_UNREACHABLE(); 306 } 307 } else { 308 if ((instr->ExtractBits(31, 30) == 0x3) || 309 (instr->Mask(0xC4400000) == 0x40000000)) { 310 VisitUnallocated(instr); 311 } else { 312 if (instr->ExtractBit(23) == 0) { 313 if (instr->Mask(0xC4400000) == 0xC0400000) { 314 VisitUnallocated(instr); 315 } else { 316 VisitLoadStorePairNonTemporal(instr); 317 } 318 } else { 319 VisitLoadStorePairPostIndex(instr); 320 } 321 } 322 } 323 } else { 324 if (instr->ExtractBit(29) == 0) { 325 if (instr->Mask(0xC4000000) == 0xC4000000) { 326 VisitUnallocated(instr); 327 } else { 328 VisitLoadLiteral(instr); 329 } 330 } else { 331 if ((instr->Mask(0x84C00000) == 0x80C00000) || 332 (instr->Mask(0x44800000) == 0x44800000) || 333 (instr->Mask(0x84800000) == 0x84800000)) { 334 VisitUnallocated(instr); 335 } else { 336 if (instr->ExtractBit(21) == 0) { 337 switch (instr->ExtractBits(11, 10)) { 338 case 0: { 339 VisitLoadStoreUnscaledOffset(instr); 340 break; 341 } 342 case 1: { 343 if (instr->Mask(0xC4C00000) == 0xC0800000) { 344 VisitUnallocated(instr); 345 } else { 346 VisitLoadStorePostIndex(instr); 347 } 348 break; 349 } 350 case 2: { 351 // TODO: VisitLoadStoreRegisterOffsetUnpriv. 352 VisitUnimplemented(instr); 353 break; 354 } 355 case 3: { 356 if (instr->Mask(0xC4C00000) == 0xC0800000) { 357 VisitUnallocated(instr); 358 } else { 359 VisitLoadStorePreIndex(instr); 360 } 361 break; 362 } 363 } 364 } else { 365 if (instr->ExtractBits(11, 10) == 0x2) { 366 if (instr->ExtractBit(14) == 0) { 367 VisitUnallocated(instr); 368 } else { 369 VisitLoadStoreRegisterOffset(instr); 370 } 371 } else { 372 VisitUnallocated(instr); 373 } 374 } 375 } 376 } 377 } 378 } else { 379 if (instr->ExtractBit(28) == 0) { 380 if (instr->ExtractBit(29) == 0) { 381 VisitUnallocated(instr); 382 } else { 383 if ((instr->ExtractBits(31, 30) == 0x3) || 384 (instr->Mask(0xC4400000) == 0x40000000)) { 385 VisitUnallocated(instr); 386 } else { 387 if (instr->ExtractBit(23) == 0) { 388 VisitLoadStorePairOffset(instr); 389 } else { 390 VisitLoadStorePairPreIndex(instr); 391 } 392 } 393 } 394 } else { 395 if (instr->ExtractBit(29) == 0) { 396 VisitUnallocated(instr); 397 } else { 398 if ((instr->Mask(0x84C00000) == 0x80C00000) || 399 (instr->Mask(0x44800000) == 0x44800000) || 400 (instr->Mask(0x84800000) == 0x84800000)) { 401 VisitUnallocated(instr); 402 } else { 403 VisitLoadStoreUnsignedOffset(instr); 404 } 405 } 406 } 407 } 408 } 409 410 411 void Decoder::DecodeLogical(const Instruction* instr) { 412 VIXL_ASSERT(instr->ExtractBits(27, 24) == 0x2); 413 414 if (instr->Mask(0x80400000) == 0x00400000) { 415 VisitUnallocated(instr); 416 } else { 417 if (instr->ExtractBit(23) == 0) { 418 VisitLogicalImmediate(instr); 419 } else { 420 if (instr->ExtractBits(30, 29) == 0x1) { 421 VisitUnallocated(instr); 422 } else { 423 VisitMoveWideImmediate(instr); 424 } 425 } 426 } 427 } 428 429 430 void Decoder::DecodeBitfieldExtract(const Instruction* instr) { 431 VIXL_ASSERT(instr->ExtractBits(27, 24) == 0x3); 432 433 if ((instr->Mask(0x80400000) == 0x80000000) || 434 (instr->Mask(0x80400000) == 0x00400000) || 435 (instr->Mask(0x80008000) == 0x00008000)) { 436 VisitUnallocated(instr); 437 } else if (instr->ExtractBit(23) == 0) { 438 if ((instr->Mask(0x80200000) == 0x00200000) || 439 (instr->Mask(0x60000000) == 0x60000000)) { 440 VisitUnallocated(instr); 441 } else { 442 VisitBitfield(instr); 443 } 444 } else { 445 if ((instr->Mask(0x60200000) == 0x00200000) || 446 (instr->Mask(0x60000000) != 0x00000000)) { 447 VisitUnallocated(instr); 448 } else { 449 VisitExtract(instr); 450 } 451 } 452 } 453 454 455 void Decoder::DecodeAddSubImmediate(const Instruction* instr) { 456 VIXL_ASSERT(instr->ExtractBits(27, 24) == 0x1); 457 if (instr->ExtractBit(23) == 1) { 458 VisitUnallocated(instr); 459 } else { 460 VisitAddSubImmediate(instr); 461 } 462 } 463 464 465 void Decoder::DecodeDataProcessing(const Instruction* instr) { 466 VIXL_ASSERT((instr->ExtractBits(27, 24) == 0xA) || 467 (instr->ExtractBits(27, 24) == 0xB)); 468 469 if (instr->ExtractBit(24) == 0) { 470 if (instr->ExtractBit(28) == 0) { 471 if (instr->Mask(0x80008000) == 0x00008000) { 472 VisitUnallocated(instr); 473 } else { 474 VisitLogicalShifted(instr); 475 } 476 } else { 477 switch (instr->ExtractBits(23, 21)) { 478 case 0: { 479 if (instr->Mask(0x0000FC00) != 0) { 480 VisitUnallocated(instr); 481 } else { 482 VisitAddSubWithCarry(instr); 483 } 484 break; 485 } 486 case 2: { 487 if ((instr->ExtractBit(29) == 0) || (instr->Mask(0x00000410) != 0)) { 488 VisitUnallocated(instr); 489 } else { 490 if (instr->ExtractBit(11) == 0) { 491 VisitConditionalCompareRegister(instr); 492 } else { 493 VisitConditionalCompareImmediate(instr); 494 } 495 } 496 break; 497 } 498 case 4: { 499 if (instr->Mask(0x20000800) != 0x00000000) { 500 VisitUnallocated(instr); 501 } else { 502 VisitConditionalSelect(instr); 503 } 504 break; 505 } 506 case 6: { 507 if (instr->ExtractBit(29) == 0x1) { 508 VisitUnallocated(instr); 509 VIXL_FALLTHROUGH(); 510 } else { 511 if (instr->ExtractBit(30) == 0) { 512 if ((instr->ExtractBit(15) == 0x1) || 513 (instr->ExtractBits(15, 11) == 0) || 514 (instr->ExtractBits(15, 12) == 0x1) || 515 (instr->ExtractBits(15, 12) == 0x3) || 516 (instr->ExtractBits(15, 13) == 0x3) || 517 (instr->Mask(0x8000EC00) == 0x00004C00) || 518 (instr->Mask(0x8000E800) == 0x80004000) || 519 (instr->Mask(0x8000E400) == 0x80004000)) { 520 VisitUnallocated(instr); 521 } else { 522 VisitDataProcessing2Source(instr); 523 } 524 } else { 525 if ((instr->ExtractBit(13) == 1) || 526 (instr->ExtractBits(20, 16) != 0) || 527 (instr->ExtractBits(15, 14) != 0) || 528 (instr->Mask(0xA01FFC00) == 0x00000C00) || 529 (instr->Mask(0x201FF800) == 0x00001800)) { 530 VisitUnallocated(instr); 531 } else { 532 VisitDataProcessing1Source(instr); 533 } 534 } 535 break; 536 } 537 } 538 case 1: 539 case 3: 540 case 5: 541 case 7: 542 VisitUnallocated(instr); 543 break; 544 } 545 } 546 } else { 547 if (instr->ExtractBit(28) == 0) { 548 if (instr->ExtractBit(21) == 0) { 549 if ((instr->ExtractBits(23, 22) == 0x3) || 550 (instr->Mask(0x80008000) == 0x00008000)) { 551 VisitUnallocated(instr); 552 } else { 553 VisitAddSubShifted(instr); 554 } 555 } else { 556 if ((instr->Mask(0x00C00000) != 0x00000000) || 557 (instr->Mask(0x00001400) == 0x00001400) || 558 (instr->Mask(0x00001800) == 0x00001800)) { 559 VisitUnallocated(instr); 560 } else { 561 VisitAddSubExtended(instr); 562 } 563 } 564 } else { 565 if ((instr->ExtractBit(30) == 0x1) || 566 (instr->ExtractBits(30, 29) == 0x1) || 567 (instr->Mask(0xE0600000) == 0x00200000) || 568 (instr->Mask(0xE0608000) == 0x00400000) || 569 (instr->Mask(0x60608000) == 0x00408000) || 570 (instr->Mask(0x60E00000) == 0x00E00000) || 571 (instr->Mask(0x60E00000) == 0x00800000) || 572 (instr->Mask(0x60E00000) == 0x00600000)) { 573 VisitUnallocated(instr); 574 } else { 575 VisitDataProcessing3Source(instr); 576 } 577 } 578 } 579 } 580 581 582 void Decoder::DecodeFP(const Instruction* instr) { 583 VIXL_ASSERT((instr->ExtractBits(27, 24) == 0xE) || 584 (instr->ExtractBits(27, 24) == 0xF)); 585 if (instr->ExtractBit(28) == 0) { 586 DecodeNEONVectorDataProcessing(instr); 587 } else { 588 if (instr->ExtractBits(31, 30) == 0x3) { 589 VisitUnallocated(instr); 590 } else if (instr->ExtractBits(31, 30) == 0x1) { 591 DecodeNEONScalarDataProcessing(instr); 592 } else { 593 if (instr->ExtractBit(29) == 0) { 594 if (instr->ExtractBit(24) == 0) { 595 if (instr->ExtractBit(21) == 0) { 596 if ((instr->ExtractBit(23) == 1) || (instr->ExtractBit(18) == 1) || 597 (instr->Mask(0x80008000) == 0x00000000) || 598 (instr->Mask(0x000E0000) == 0x00000000) || 599 (instr->Mask(0x000E0000) == 0x000A0000) || 600 (instr->Mask(0x00160000) == 0x00000000) || 601 (instr->Mask(0x00160000) == 0x00120000)) { 602 VisitUnallocated(instr); 603 } else { 604 VisitFPFixedPointConvert(instr); 605 } 606 } else { 607 if (instr->ExtractBits(15, 10) == 32) { 608 VisitUnallocated(instr); 609 } else if (instr->ExtractBits(15, 10) == 0) { 610 if ((instr->ExtractBits(23, 22) == 0x3) || 611 (instr->Mask(0x000E0000) == 0x000A0000) || 612 (instr->Mask(0x000E0000) == 0x000C0000) || 613 (instr->Mask(0x00160000) == 0x00120000) || 614 (instr->Mask(0x00160000) == 0x00140000) || 615 (instr->Mask(0x20C40000) == 0x00800000) || 616 (instr->Mask(0x20C60000) == 0x00840000) || 617 (instr->Mask(0xA0C60000) == 0x80060000) || 618 (instr->Mask(0xA0C60000) == 0x00860000) || 619 (instr->Mask(0xA0C60000) == 0x00460000) || 620 (instr->Mask(0xA0CE0000) == 0x80860000) || 621 (instr->Mask(0xA0CE0000) == 0x804E0000) || 622 (instr->Mask(0xA0CE0000) == 0x000E0000) || 623 (instr->Mask(0xA0D60000) == 0x00160000) || 624 (instr->Mask(0xA0D60000) == 0x80560000) || 625 (instr->Mask(0xA0D60000) == 0x80960000)) { 626 VisitUnallocated(instr); 627 } else { 628 VisitFPIntegerConvert(instr); 629 } 630 } else if (instr->ExtractBits(14, 10) == 16) { 631 const Instr masked_A0DF8000 = instr->Mask(0xA0DF8000); 632 if ((instr->Mask(0x80180000) != 0) || 633 (masked_A0DF8000 == 0x00020000) || 634 (masked_A0DF8000 == 0x00030000) || 635 (masked_A0DF8000 == 0x00068000) || 636 (masked_A0DF8000 == 0x00428000) || 637 (masked_A0DF8000 == 0x00430000) || 638 (masked_A0DF8000 == 0x00468000) || 639 (instr->Mask(0xA0D80000) == 0x00800000) || 640 (instr->Mask(0xA0DE0000) == 0x00C00000) || 641 (instr->Mask(0xA0DF0000) == 0x00C30000) || 642 (instr->Mask(0xA0DC0000) == 0x00C40000)) { 643 VisitUnallocated(instr); 644 } else { 645 VisitFPDataProcessing1Source(instr); 646 } 647 } else if (instr->ExtractBits(13, 10) == 8) { 648 if ((instr->ExtractBits(15, 14) != 0) || 649 (instr->ExtractBits(2, 0) != 0) || 650 (instr->Mask(0x80800000) != 0x00000000)) { 651 VisitUnallocated(instr); 652 } else { 653 VisitFPCompare(instr); 654 } 655 } else if (instr->ExtractBits(12, 10) == 4) { 656 if ((instr->ExtractBits(9, 5) != 0) || 657 (instr->Mask(0x80800000) != 0x00000000)) { 658 VisitUnallocated(instr); 659 } else { 660 VisitFPImmediate(instr); 661 } 662 } else { 663 if (instr->Mask(0x80800000) != 0x00000000) { 664 VisitUnallocated(instr); 665 } else { 666 switch (instr->ExtractBits(11, 10)) { 667 case 1: { 668 VisitFPConditionalCompare(instr); 669 break; 670 } 671 case 2: { 672 if ((instr->ExtractBits(15, 14) == 0x3) || 673 (instr->Mask(0x00009000) == 0x00009000) || 674 (instr->Mask(0x0000A000) == 0x0000A000)) { 675 VisitUnallocated(instr); 676 } else { 677 VisitFPDataProcessing2Source(instr); 678 } 679 break; 680 } 681 case 3: { 682 VisitFPConditionalSelect(instr); 683 break; 684 } 685 default: 686 VIXL_UNREACHABLE(); 687 } 688 } 689 } 690 } 691 } else { 692 // Bit 30 == 1 has been handled earlier. 693 VIXL_ASSERT(instr->ExtractBit(30) == 0); 694 if (instr->Mask(0xA0800000) != 0) { 695 VisitUnallocated(instr); 696 } else { 697 VisitFPDataProcessing3Source(instr); 698 } 699 } 700 } else { 701 VisitUnallocated(instr); 702 } 703 } 704 } 705 } 706 707 708 void Decoder::DecodeNEONLoadStore(const Instruction* instr) { 709 VIXL_ASSERT(instr->ExtractBits(29, 25) == 0x6); 710 if (instr->ExtractBit(31) == 0) { 711 if ((instr->ExtractBit(24) == 0) && (instr->ExtractBit(21) == 1)) { 712 VisitUnallocated(instr); 713 return; 714 } 715 716 if (instr->ExtractBit(23) == 0) { 717 if (instr->ExtractBits(20, 16) == 0) { 718 if (instr->ExtractBit(24) == 0) { 719 VisitNEONLoadStoreMultiStruct(instr); 720 } else { 721 VisitNEONLoadStoreSingleStruct(instr); 722 } 723 } else { 724 VisitUnallocated(instr); 725 } 726 } else { 727 if (instr->ExtractBit(24) == 0) { 728 VisitNEONLoadStoreMultiStructPostIndex(instr); 729 } else { 730 VisitNEONLoadStoreSingleStructPostIndex(instr); 731 } 732 } 733 } else { 734 VisitUnallocated(instr); 735 } 736 } 737 738 739 void Decoder::DecodeNEONVectorDataProcessing(const Instruction* instr) { 740 VIXL_ASSERT(instr->ExtractBits(28, 25) == 0x7); 741 if (instr->ExtractBit(31) == 0) { 742 if (instr->ExtractBit(24) == 0) { 743 if (instr->ExtractBit(21) == 0) { 744 if (instr->ExtractBit(15) == 0) { 745 if (instr->ExtractBit(10) == 0) { 746 if (instr->ExtractBit(29) == 0) { 747 if (instr->ExtractBit(11) == 0) { 748 VisitNEONTable(instr); 749 } else { 750 VisitNEONPerm(instr); 751 } 752 } else { 753 VisitNEONExtract(instr); 754 } 755 } else { 756 if (instr->ExtractBits(23, 22) == 0) { 757 VisitNEONCopy(instr); 758 } else { 759 VisitUnallocated(instr); 760 } 761 } 762 } else { 763 VisitUnallocated(instr); 764 } 765 } else { 766 if (instr->ExtractBit(10) == 0) { 767 if (instr->ExtractBit(11) == 0) { 768 VisitNEON3Different(instr); 769 } else { 770 if (instr->ExtractBits(18, 17) == 0) { 771 if (instr->ExtractBit(20) == 0) { 772 if (instr->ExtractBit(19) == 0) { 773 VisitNEON2RegMisc(instr); 774 } else { 775 if (instr->ExtractBits(30, 29) == 0x2) { 776 VisitCryptoAES(instr); 777 } else { 778 VisitUnallocated(instr); 779 } 780 } 781 } else { 782 if (instr->ExtractBit(19) == 0) { 783 VisitNEONAcrossLanes(instr); 784 } else { 785 VisitUnallocated(instr); 786 } 787 } 788 } else { 789 VisitUnallocated(instr); 790 } 791 } 792 } else { 793 VisitNEON3Same(instr); 794 } 795 } 796 } else { 797 if (instr->ExtractBit(10) == 0) { 798 VisitNEONByIndexedElement(instr); 799 } else { 800 if (instr->ExtractBit(23) == 0) { 801 if (instr->ExtractBits(22, 19) == 0) { 802 VisitNEONModifiedImmediate(instr); 803 } else { 804 VisitNEONShiftImmediate(instr); 805 } 806 } else { 807 VisitUnallocated(instr); 808 } 809 } 810 } 811 } else { 812 VisitUnallocated(instr); 813 } 814 } 815 816 817 void Decoder::DecodeNEONScalarDataProcessing(const Instruction* instr) { 818 VIXL_ASSERT(instr->ExtractBits(28, 25) == 0xF); 819 if (instr->ExtractBit(24) == 0) { 820 if (instr->ExtractBit(21) == 0) { 821 if (instr->ExtractBit(15) == 0) { 822 if (instr->ExtractBit(10) == 0) { 823 if (instr->ExtractBit(29) == 0) { 824 if (instr->ExtractBit(11) == 0) { 825 VisitCrypto3RegSHA(instr); 826 } else { 827 VisitUnallocated(instr); 828 } 829 } else { 830 VisitUnallocated(instr); 831 } 832 } else { 833 if (instr->ExtractBits(23, 22) == 0) { 834 VisitNEONScalarCopy(instr); 835 } else { 836 VisitUnallocated(instr); 837 } 838 } 839 } else { 840 VisitUnallocated(instr); 841 } 842 } else { 843 if (instr->ExtractBit(10) == 0) { 844 if (instr->ExtractBit(11) == 0) { 845 VisitNEONScalar3Diff(instr); 846 } else { 847 if (instr->ExtractBits(18, 17) == 0) { 848 if (instr->ExtractBit(20) == 0) { 849 if (instr->ExtractBit(19) == 0) { 850 VisitNEONScalar2RegMisc(instr); 851 } else { 852 if (instr->ExtractBit(29) == 0) { 853 VisitCrypto2RegSHA(instr); 854 } else { 855 VisitUnallocated(instr); 856 } 857 } 858 } else { 859 if (instr->ExtractBit(19) == 0) { 860 VisitNEONScalarPairwise(instr); 861 } else { 862 VisitUnallocated(instr); 863 } 864 } 865 } else { 866 VisitUnallocated(instr); 867 } 868 } 869 } else { 870 VisitNEONScalar3Same(instr); 871 } 872 } 873 } else { 874 if (instr->ExtractBit(10) == 0) { 875 VisitNEONScalarByIndexedElement(instr); 876 } else { 877 if (instr->ExtractBit(23) == 0) { 878 VisitNEONScalarShiftImmediate(instr); 879 } else { 880 VisitUnallocated(instr); 881 } 882 } 883 } 884 } 885 886 887 #define DEFINE_VISITOR_CALLERS(A) \ 888 void Decoder::Visit##A(const Instruction* instr) { \ 889 VIXL_ASSERT(instr->Mask(A##FMask) == A##Fixed); \ 890 std::list<DecoderVisitor*>::iterator it; \ 891 for (it = visitors_.begin(); it != visitors_.end(); it++) { \ 892 (*it)->Visit##A(instr); \ 893 } \ 894 } 895 VISITOR_LIST(DEFINE_VISITOR_CALLERS) 896 #undef DEFINE_VISITOR_CALLERS 897 } // namespace aarch64 898 } // namespace vixl 899
