MacroAssembler-wasm32-inl.h (40607B)
1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- 2 * vim: set ts=8 sts=2 et sw=2 tw=80: 3 * This Source Code Form is subject to the terms of the Mozilla Public 4 * License, v. 2.0. If a copy of the MPL was not distributed with this 5 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ 6 7 #ifndef jit_wasm32_MacroAssembler_wasm32_inl_h 8 #define jit_wasm32_MacroAssembler_wasm32_inl_h 9 10 #include "jit/wasm32/MacroAssembler-wasm32.h" 11 12 namespace js::jit { 13 14 //{{{ check_macroassembler_style 15 16 void MacroAssembler::move64(Imm64 imm, Register64 dest) { MOZ_CRASH(); } 17 18 void MacroAssembler::move64(Register64 src, Register64 dest) { MOZ_CRASH(); } 19 20 void MacroAssembler::moveDoubleToGPR64(FloatRegister src, Register64 dest) { 21 MOZ_CRASH(); 22 } 23 24 void MacroAssembler::moveGPR64ToDouble(Register64 src, FloatRegister dest) { 25 MOZ_CRASH(); 26 } 27 28 void MacroAssembler::moveLowDoubleToGPR(FloatRegister src, Register dest) { 29 MOZ_CRASH(); 30 } 31 32 void MacroAssembler::move64To32(Register64 src, Register dest) { MOZ_CRASH(); } 33 34 void MacroAssembler::move32To64ZeroExtend(Register src, Register64 dest) { 35 MOZ_CRASH(); 36 } 37 38 void MacroAssembler::move8To64SignExtend(Register src, Register64 dest) { 39 MOZ_CRASH(); 40 } 41 42 void MacroAssembler::move16To64SignExtend(Register src, Register64 dest) { 43 MOZ_CRASH(); 44 } 45 46 void MacroAssembler::move32To64SignExtend(Register src, Register64 dest) { 47 MOZ_CRASH(); 48 } 49 50 void MacroAssembler::move8SignExtendToPtr(Register src, Register dest) { 51 MOZ_CRASH(); 52 } 53 54 void MacroAssembler::move16SignExtendToPtr(Register src, Register dest) { 55 MOZ_CRASH(); 56 } 57 58 void MacroAssembler::move32SignExtendToPtr(Register src, Register dest) { 59 MOZ_CRASH(); 60 } 61 62 void MacroAssembler::move32ZeroExtendToPtr(Register src, Register dest) { 63 MOZ_CRASH(); 64 } 65 66 void MacroAssembler::load32SignExtendToPtr(const Address& src, Register dest) { 67 MOZ_CRASH(); 68 } 69 70 void MacroAssembler::notPtr(Register reg) { MOZ_CRASH(); } 71 72 void MacroAssembler::andPtr(Register src, Register dest) { MOZ_CRASH(); } 73 74 void MacroAssembler::andPtr(Imm32 imm, Register dest) { MOZ_CRASH(); } 75 76 void MacroAssembler::andPtr(Imm32 imm, Register src, Register dest) { 77 MOZ_CRASH(); 78 } 79 80 void MacroAssembler::and64(Imm64 imm, Register64 dest) { MOZ_CRASH(); } 81 82 void MacroAssembler::or64(Imm64 imm, Register64 dest) { MOZ_CRASH(); } 83 84 void MacroAssembler::xor64(Imm64 imm, Register64 dest) { MOZ_CRASH(); } 85 86 void MacroAssembler::orPtr(Register src, Register dest) { MOZ_CRASH(); } 87 88 void MacroAssembler::orPtr(Imm32 imm, Register dest) { MOZ_CRASH(); } 89 90 void MacroAssembler::orPtr(Imm32 imm, Register src, Register dest) { 91 MOZ_CRASH(); 92 } 93 94 void MacroAssembler::and64(Register64 src, Register64 dest) { MOZ_CRASH(); } 95 96 void MacroAssembler::or64(Register64 src, Register64 dest) { MOZ_CRASH(); } 97 98 void MacroAssembler::xor64(Register64 src, Register64 dest) { MOZ_CRASH(); } 99 100 void MacroAssembler::xorPtr(Register src, Register dest) { MOZ_CRASH(); } 101 102 void MacroAssembler::xorPtr(Imm32 imm, Register dest) { MOZ_CRASH(); } 103 104 void MacroAssembler::xorPtr(Imm32 imm, Register src, Register dest) { 105 MOZ_CRASH(); 106 } 107 108 void MacroAssembler::byteSwap64(Register64 reg) { MOZ_CRASH(); } 109 110 void MacroAssembler::addPtr(Register src, Register dest) { MOZ_CRASH(); } 111 112 void MacroAssembler::addPtr(Imm32 imm, Register dest) { MOZ_CRASH(); } 113 114 void MacroAssembler::addPtr(ImmWord imm, Register dest) { MOZ_CRASH(); } 115 116 void MacroAssembler::add64(Register64 src, Register64 dest) { MOZ_CRASH(); } 117 118 void MacroAssembler::add64(Imm32 imm, Register64 dest) { MOZ_CRASH(); } 119 120 void MacroAssembler::add64(Imm64 imm, Register64 dest) { MOZ_CRASH(); } 121 122 CodeOffset MacroAssembler::sub32FromStackPtrWithPatch(Register dest) { 123 MOZ_CRASH(); 124 } 125 126 void MacroAssembler::patchSub32FromStackPtr(CodeOffset offset, Imm32 imm) { 127 MOZ_CRASH(); 128 } 129 130 void MacroAssembler::subPtr(Register src, Register dest) { MOZ_CRASH(); } 131 132 void MacroAssembler::subPtr(Imm32 imm, Register dest) { MOZ_CRASH(); } 133 134 void MacroAssembler::sub64(Register64 src, Register64 dest) { MOZ_CRASH(); } 135 136 void MacroAssembler::sub64(Imm64 imm, Register64 dest) { MOZ_CRASH(); } 137 138 void MacroAssembler::mulPtr(Register rhs, Register srcDest) { MOZ_CRASH(); } 139 void MacroAssembler::mulPtr(ImmWord rhs, Register srcDest) { MOZ_CRASH(); } 140 141 void MacroAssembler::mul64(Imm64 imm, const Register64& dest) { MOZ_CRASH(); } 142 143 void MacroAssembler::mul64(const Register64& src, const Register64& dest, 144 const Register temp) { 145 MOZ_CRASH(); 146 } 147 148 void MacroAssembler::mulBy3(Register src, Register dest) { MOZ_CRASH(); } 149 150 void MacroAssembler::inc64(AbsoluteAddress dest) { MOZ_CRASH(); } 151 152 void MacroAssembler::neg64(Register64 reg) { MOZ_CRASH(); } 153 154 void MacroAssembler::negPtr(Register reg) { MOZ_CRASH(); } 155 156 void MacroAssembler::lshiftPtr(Imm32 imm, Register dest) { MOZ_CRASH(); } 157 158 void MacroAssembler::lshiftPtr(Imm32 imm, Register src, Register dest) { 159 MOZ_CRASH(); 160 } 161 162 void MacroAssembler::rshiftPtr(Imm32 imm, Register dest) { MOZ_CRASH(); } 163 164 void MacroAssembler::rshiftPtr(Imm32 imm, Register src, Register dest) { 165 MOZ_CRASH(); 166 } 167 168 void MacroAssembler::rshiftPtrArithmetic(Imm32 imm, Register dest) { 169 MOZ_CRASH(); 170 } 171 172 void MacroAssembler::rshiftPtrArithmetic(Imm32 imm, Register src, 173 Register dest) { 174 MOZ_CRASH(); 175 } 176 177 void MacroAssembler::rshiftPtrArithmetic(Register shift, Register srcDest) { 178 MOZ_CRASH(); 179 } 180 181 void MacroAssembler::lshift64(Imm32 imm, Register64 dest) { MOZ_CRASH(); } 182 183 void MacroAssembler::rshift64(Imm32 imm, Register64 dest) { MOZ_CRASH(); } 184 185 void MacroAssembler::rshift64Arithmetic(Imm32 imm, Register64 dest) { 186 MOZ_CRASH(); 187 } 188 189 void MacroAssembler::lshiftPtr(Register shift, Register srcDest) { 190 MOZ_CRASH(); 191 } 192 193 void MacroAssembler::rshiftPtr(Register shift, Register srcDest) { 194 MOZ_CRASH(); 195 } 196 197 void MacroAssembler::lshift64(Register shift, Register64 srcDest) { 198 MOZ_CRASH(); 199 } 200 201 void MacroAssembler::rshift64(Register shift, Register64 srcDest) { 202 MOZ_CRASH(); 203 } 204 205 void MacroAssembler::rshift64Arithmetic(Register shift, Register64 srcDest) { 206 MOZ_CRASH(); 207 } 208 209 void MacroAssembler::clz64(Register64 src, Register64 dest) { MOZ_CRASH(); } 210 211 void MacroAssembler::ctz64(Register64 src, Register64 dest) { MOZ_CRASH(); } 212 213 void MacroAssembler::popcnt64(Register64 src, Register64 dest, Register temp) { 214 MOZ_CRASH(); 215 } 216 217 template <typename T1, typename T2> 218 void MacroAssembler::cmpPtrSet(Condition cond, T1 lhs, T2 rhs, Register dest) { 219 MOZ_CRASH(); 220 } 221 222 void MacroAssembler::branchToComputedAddress(const BaseIndex& address) { 223 MOZ_CRASH(); 224 } 225 226 void MacroAssembler::move8ZeroExtend(Register src, Register dest) { 227 MOZ_CRASH(); 228 } 229 230 void MacroAssembler::move8SignExtend(Register src, Register dest) { 231 MOZ_CRASH(); 232 } 233 234 void MacroAssembler::move16SignExtend(Register src, Register dest) { 235 MOZ_CRASH(); 236 } 237 238 void MacroAssembler::loadAbiReturnAddress(Register dest) { MOZ_CRASH(); } 239 240 void MacroAssembler::not32(Register reg) { MOZ_CRASH(); } 241 242 void MacroAssembler::and32(Register src, Register dest) { MOZ_CRASH(); } 243 244 void MacroAssembler::and32(Imm32 imm, Register dest) { MOZ_CRASH(); } 245 246 void MacroAssembler::and32(Imm32 imm, Register src, Register dest) { 247 MOZ_CRASH(); 248 } 249 250 void MacroAssembler::and32(Imm32 imm, const Address& dest) { MOZ_CRASH(); } 251 252 void MacroAssembler::and32(const Address& src, Register dest) { MOZ_CRASH(); } 253 254 void MacroAssembler::or32(Register src, Register dest) { MOZ_CRASH(); } 255 256 void MacroAssembler::or32(Imm32 imm, Register dest) { MOZ_CRASH(); } 257 258 void MacroAssembler::or32(Imm32 imm, Register src, Register dest) { 259 MOZ_CRASH(); 260 } 261 262 void MacroAssembler::or32(Imm32 imm, const Address& dest) { MOZ_CRASH(); } 263 264 void MacroAssembler::xor32(Register src, Register dest) { MOZ_CRASH(); } 265 266 void MacroAssembler::xor32(Imm32 imm, Register dest) { MOZ_CRASH(); } 267 268 void MacroAssembler::xor32(Imm32 imm, Register src, Register dest) { 269 MOZ_CRASH(); 270 } 271 272 void MacroAssembler::xor32(Imm32 imm, const Address& dest) { MOZ_CRASH(); } 273 274 void MacroAssembler::xor32(const Address& src, Register dest) { MOZ_CRASH(); } 275 276 void MacroAssembler::byteSwap16SignExtend(Register reg) { MOZ_CRASH(); } 277 278 void MacroAssembler::byteSwap16ZeroExtend(Register reg) { MOZ_CRASH(); } 279 280 void MacroAssembler::byteSwap32(Register reg) { MOZ_CRASH(); } 281 282 void MacroAssembler::add32(Register src, Register dest) { MOZ_CRASH(); } 283 284 void MacroAssembler::add32(Imm32 imm, Register dest) { MOZ_CRASH(); } 285 286 void MacroAssembler::add32(Imm32 imm, Register src, Register dest) { 287 MOZ_CRASH(); 288 } 289 290 void MacroAssembler::add32(Imm32 imm, const Address& dest) { MOZ_CRASH(); } 291 292 void MacroAssembler::add32(const Address& src, Register dest) { MOZ_CRASH(); } 293 294 void MacroAssembler::addFloat32(FloatRegister src, FloatRegister dest) { 295 MOZ_CRASH(); 296 } 297 298 void MacroAssembler::addDouble(FloatRegister src, FloatRegister dest) { 299 MOZ_CRASH(); 300 } 301 302 void MacroAssembler::sub32(const Address& src, Register dest) { MOZ_CRASH(); } 303 304 void MacroAssembler::sub32(Register src, Register dest) { MOZ_CRASH(); } 305 306 void MacroAssembler::sub32(Imm32 imm, Register dest) { MOZ_CRASH(); } 307 308 void MacroAssembler::subFloat32(FloatRegister src, FloatRegister dest) { 309 MOZ_CRASH(); 310 } 311 312 void MacroAssembler::subDouble(FloatRegister src, FloatRegister dest) { 313 MOZ_CRASH(); 314 } 315 316 void MacroAssembler::mul32(Register rhs, Register srcDest) { MOZ_CRASH(); } 317 318 void MacroAssembler::mul32(Imm32 imm, Register srcDest) { MOZ_CRASH(); } 319 320 void MacroAssembler::mulHighUnsigned32(Imm32 imm, Register src, Register dest) { 321 MOZ_CRASH(); 322 } 323 324 void MacroAssembler::mulFloat32(FloatRegister src, FloatRegister dest) { 325 MOZ_CRASH(); 326 } 327 328 void MacroAssembler::mulDouble(FloatRegister src, FloatRegister dest) { 329 MOZ_CRASH(); 330 } 331 332 void MacroAssembler::divFloat32(FloatRegister src, FloatRegister dest) { 333 MOZ_CRASH(); 334 } 335 336 void MacroAssembler::divDouble(FloatRegister src, FloatRegister dest) { 337 MOZ_CRASH(); 338 } 339 340 void MacroAssembler::neg32(Register reg) { MOZ_CRASH(); } 341 342 void MacroAssembler::negateFloat(FloatRegister reg) { MOZ_CRASH(); } 343 344 void MacroAssembler::negateDouble(FloatRegister reg) { MOZ_CRASH(); } 345 346 void MacroAssembler::abs32(Register src, Register dest) { MOZ_CRASH(); } 347 348 void MacroAssembler::absFloat32(FloatRegister src, FloatRegister dest) { 349 MOZ_CRASH(); 350 } 351 352 void MacroAssembler::absDouble(FloatRegister src, FloatRegister dest) { 353 MOZ_CRASH(); 354 } 355 356 void MacroAssembler::sqrtDouble(FloatRegister src, FloatRegister dest) { 357 MOZ_CRASH(); 358 } 359 360 void MacroAssembler::lshift32(Imm32 shift, Register srcDest) { MOZ_CRASH(); } 361 362 void MacroAssembler::lshift32(Imm32 shift, Register src, Register dest) { 363 MOZ_CRASH(); 364 } 365 366 void MacroAssembler::rshift32(Imm32 shift, Register srcDest) { MOZ_CRASH(); } 367 368 void MacroAssembler::rshift32(Imm32 shift, Register src, Register dest) { 369 MOZ_CRASH(); 370 } 371 372 void MacroAssembler::rshift32Arithmetic(Imm32 shift, Register srcDest) { 373 MOZ_CRASH(); 374 } 375 376 void MacroAssembler::rshift32Arithmetic(Imm32 shift, Register src, 377 Register dest) { 378 MOZ_CRASH(); 379 } 380 381 void MacroAssembler::rshift32Arithmetic(Register shift, Register srcDest) { 382 MOZ_CRASH(); 383 } 384 385 void MacroAssembler::lshift32(Register shift, Register srcDest) { MOZ_CRASH(); } 386 387 void MacroAssembler::rshift32(Register shift, Register srcDest) { MOZ_CRASH(); } 388 389 void MacroAssembler::memoryBarrier(MemoryBarrier barrier) { MOZ_CRASH(); } 390 391 void MacroAssembler::clampIntToUint8(Register reg) { MOZ_CRASH(); } 392 393 void MacroAssembler::branchTest32(Condition cond, Register lhs, Register rhs, 394 Label* label) { 395 MOZ_CRASH(); 396 } 397 398 void MacroAssembler::branchTest32(Condition cond, Register lhs, Imm32 rhs, 399 Label* label) { 400 MOZ_CRASH(); 401 } 402 403 void MacroAssembler::branchTest32(Condition cond, const Address& lhs, Imm32 rhh, 404 Label* label) { 405 MOZ_CRASH(); 406 } 407 408 void MacroAssembler::branchTest32(Condition cond, const AbsoluteAddress& lhs, 409 Imm32 rhs, Label* label) { 410 MOZ_CRASH(); 411 } 412 413 void MacroAssembler::branchTestPtr(Condition cond, Register lhs, Register rhs, 414 Label* label) { 415 MOZ_CRASH(); 416 } 417 void MacroAssembler::branchTestPtr(Condition cond, Register lhs, Imm32 rhs, 418 Label* label) { 419 MOZ_CRASH(); 420 } 421 422 void MacroAssembler::branchTestPtr(Condition cond, Register lhs, ImmWord rhs, 423 Label* label) { 424 MOZ_CRASH(); 425 } 426 427 void MacroAssembler::branchTestPtr(Condition cond, const Address& lhs, 428 Imm32 rhs, Label* label) { 429 MOZ_CRASH(); 430 } 431 432 void MacroAssembler::branchTest64(Condition cond, Register64 lhs, 433 Register64 rhs, Register temp, Label* success, 434 Label* fail) { 435 MOZ_CRASH(); 436 } 437 438 void MacroAssembler::branchTest64(Condition cond, Register64 lhs, Imm64 rhs, 439 Label* success, Label* fail) { 440 MOZ_CRASH(); 441 } 442 443 void MacroAssembler::branchTestUndefined(Condition cond, Register tag, 444 Label* label) { 445 MOZ_CRASH(); 446 } 447 448 void MacroAssembler::branchTestInt32(Condition cond, Register tag, 449 Label* label) { 450 MOZ_CRASH(); 451 } 452 453 void MacroAssembler::branchTestDouble(Condition cond, Register tag, 454 Label* label) { 455 MOZ_CRASH(); 456 } 457 458 void MacroAssembler::branchTestNumber(Condition cond, Register tag, 459 Label* label) { 460 MOZ_CRASH(); 461 } 462 463 void MacroAssembler::branchTestBoolean(Condition cond, Register tag, 464 Label* label) { 465 MOZ_CRASH(); 466 } 467 468 void MacroAssembler::branchTestString(Condition cond, Register tag, 469 Label* label) { 470 MOZ_CRASH(); 471 } 472 473 void MacroAssembler::branchTestSymbol(Condition cond, Register tag, 474 Label* label) { 475 MOZ_CRASH(); 476 } 477 478 void MacroAssembler::branchTestBigInt(Condition cond, Register tag, 479 Label* label) { 480 MOZ_CRASH(); 481 } 482 483 void MacroAssembler::branchTestNull(Condition cond, Register tag, 484 Label* label) { 485 MOZ_CRASH(); 486 } 487 488 void MacroAssembler::branchTestObject(Condition cond, Register tag, 489 Label* label) { 490 MOZ_CRASH(); 491 } 492 493 void MacroAssembler::branchTestPrimitive(Condition cond, Register tag, 494 Label* label) { 495 MOZ_CRASH(); 496 } 497 498 void MacroAssembler::branchTestMagic(Condition cond, Register tag, 499 Label* label) { 500 MOZ_CRASH(); 501 } 502 503 void MacroAssembler::branchTestUndefined(Condition cond, const Address& address, 504 Label* label) { 505 MOZ_CRASH(); 506 } 507 508 void MacroAssembler::branchTestUndefined(Condition cond, 509 const BaseIndex& address, 510 Label* label) { 511 MOZ_CRASH(); 512 } 513 514 void MacroAssembler::branchTestInt32(Condition cond, const Address& address, 515 Label* label) { 516 MOZ_CRASH(); 517 } 518 519 void MacroAssembler::branchTestInt32(Condition cond, const BaseIndex& address, 520 Label* label) { 521 MOZ_CRASH(); 522 } 523 524 void MacroAssembler::branchTestInt32(Condition cond, const ValueOperand& value, 525 Label* label) { 526 MOZ_CRASH(); 527 } 528 529 void MacroAssembler::branchTestDouble(Condition cond, const Address& address, 530 Label* label) { 531 MOZ_CRASH(); 532 } 533 534 void MacroAssembler::branchTestDouble(Condition cond, const BaseIndex& address, 535 Label* label) { 536 MOZ_CRASH(); 537 } 538 539 void MacroAssembler::branchTestBoolean(Condition cond, const Address& address, 540 Label* label) { 541 MOZ_CRASH(); 542 } 543 544 void MacroAssembler::branchTestBoolean(Condition cond, const BaseIndex& address, 545 Label* label) { 546 MOZ_CRASH(); 547 } 548 549 void MacroAssembler::branchTestString(Condition cond, const Address& address, 550 Label* label) { 551 MOZ_CRASH(); 552 } 553 554 void MacroAssembler::branchTestString(Condition cond, const BaseIndex& address, 555 Label* label) { 556 MOZ_CRASH(); 557 } 558 559 void MacroAssembler::branchTestSymbol(Condition cond, const Address& address, 560 Label* label) { 561 MOZ_CRASH(); 562 } 563 564 void MacroAssembler::branchTestSymbol(Condition cond, const BaseIndex& address, 565 Label* label) { 566 MOZ_CRASH(); 567 } 568 569 void MacroAssembler::branchTestBigInt(Condition cond, const Address& address, 570 Label* label) { 571 MOZ_CRASH(); 572 } 573 574 void MacroAssembler::branchTestBigInt(Condition cond, const BaseIndex& address, 575 Label* label) { 576 MOZ_CRASH(); 577 } 578 579 void MacroAssembler::branchTestNull(Condition cond, const Address& address, 580 Label* label) { 581 MOZ_CRASH(); 582 } 583 584 void MacroAssembler::branchTestNull(Condition cond, const BaseIndex& address, 585 Label* label) { 586 MOZ_CRASH(); 587 } 588 589 void MacroAssembler::branchTestNull(Condition cond, const ValueOperand& value, 590 Label* label) { 591 MOZ_CRASH(); 592 } 593 594 void MacroAssembler::branchTestObject(Condition cond, const Address& address, 595 Label* label) { 596 MOZ_CRASH(); 597 } 598 599 void MacroAssembler::branchTestObject(Condition cond, const BaseIndex& address, 600 Label* label) { 601 MOZ_CRASH(); 602 } 603 604 void MacroAssembler::branchTestObject(Condition cond, const ValueOperand& value, 605 Label* label) { 606 MOZ_CRASH(); 607 } 608 609 void MacroAssembler::branchTestGCThing(Condition cond, const Address& address, 610 Label* label) { 611 MOZ_CRASH(); 612 } 613 614 void MacroAssembler::branchTestGCThing(Condition cond, const BaseIndex& address, 615 Label* label) { 616 MOZ_CRASH(); 617 } 618 619 void MacroAssembler::branchTestGCThing(Condition cond, 620 const ValueOperand& value, 621 Label* label) { 622 MOZ_CRASH(); 623 } 624 625 void MacroAssembler::branchTestMagic(Condition cond, const Address& address, 626 Label* label) { 627 MOZ_CRASH(); 628 } 629 630 void MacroAssembler::branchTestMagic(Condition cond, const BaseIndex& address, 631 Label* label) { 632 MOZ_CRASH(); 633 } 634 635 void MacroAssembler::branchTestMagic(Condition cond, const Address& valaddr, 636 JSWhyMagic why, Label* label) { 637 MOZ_CRASH(); 638 } 639 640 template <typename T> 641 void MacroAssembler::branchTestValue(Condition cond, const T& lhs, 642 const ValueOperand& rhs, Label* label) { 643 MOZ_CRASH(); 644 } 645 646 void MacroAssembler::branchTestDoubleTruthy(bool truthy, FloatRegister reg, 647 Label* label) { 648 MOZ_CRASH(); 649 } 650 651 void MacroAssembler::branchTestBooleanTruthy(bool truthy, 652 const ValueOperand& value, 653 Label* label) { 654 MOZ_CRASH(); 655 } 656 657 void MacroAssembler::branchTestStringTruthy(bool truthy, 658 const ValueOperand& value, 659 Label* label) { 660 MOZ_CRASH(); 661 } 662 663 void MacroAssembler::branchTestBigIntTruthy(bool truthy, 664 const ValueOperand& value, 665 Label* label) { 666 MOZ_CRASH(); 667 } 668 669 void MacroAssembler::fallibleUnboxPtr(const ValueOperand& src, Register dest, 670 JSValueType type, Label* fail) { 671 MOZ_CRASH(); 672 } 673 674 void MacroAssembler::fallibleUnboxPtr(const Address& src, Register dest, 675 JSValueType type, Label* fail) { 676 MOZ_CRASH(); 677 } 678 679 void MacroAssembler::fallibleUnboxPtr(const BaseIndex& src, Register dest, 680 JSValueType type, Label* fail) { 681 MOZ_CRASH(); 682 } 683 684 void MacroAssembler::cmpPtrMovePtr(Condition cond, Register lhs, Imm32 rhs, 685 Register src, Register dest) { 686 MOZ_CRASH(); 687 } 688 689 void MacroAssembler::cmpPtrMovePtr(Condition cond, Register lhs, Register rhs, 690 Register src, Register dest) { 691 MOZ_CRASH(); 692 } 693 694 void MacroAssembler::cmpPtrMovePtr(Condition cond, Register lhs, 695 const Address& rhs, Register src, 696 Register dest) { 697 MOZ_CRASH(); 698 } 699 700 void MacroAssembler::branch32(Condition cond, const BaseIndex& lhs, Imm32 rhs, 701 Label* label) { 702 MOZ_CRASH(); 703 } 704 705 void MacroAssembler::branch32(Condition cond, const AbsoluteAddress& lhs, 706 Imm32 rhs, Label* label) { 707 MOZ_CRASH(); 708 } 709 710 void MacroAssembler::branch32(Condition cond, const Address& lhs, Register rhs, 711 Label* label) { 712 MOZ_CRASH(); 713 } 714 715 void MacroAssembler::branch32(Condition cond, const Address& lhs, Imm32 rhs, 716 Label* label) { 717 MOZ_CRASH(); 718 } 719 720 void MacroAssembler::branch32(Condition cond, const AbsoluteAddress& lhs, 721 Register rhs, Label* label) { 722 MOZ_CRASH(); 723 } 724 725 void MacroAssembler::branch8(Condition cond, const Address& lhs, Imm32 rhs, 726 Label* label) { 727 MOZ_CRASH(); 728 } 729 730 void MacroAssembler::branch8(Condition cond, const BaseIndex& lhs, Register rhs, 731 Label* label) { 732 MOZ_CRASH(); 733 } 734 735 void MacroAssembler::branch16(Condition cond, const Address& lhs, Imm32 rhs, 736 Label* label) { 737 MOZ_CRASH(); 738 } 739 740 void MacroAssembler::branch32(Condition cond, Register lhs, Register rhs, 741 Label* label) { 742 MOZ_CRASH(); 743 } 744 745 void MacroAssembler::branch32(Condition cond, Register lhs, Imm32 rhs, 746 Label* label) { 747 MOZ_CRASH(); 748 } 749 750 void MacroAssembler::branch32(Condition cond, wasm::SymbolicAddress lhs, 751 Imm32 rhs, Label* label) { 752 MOZ_CRASH(); 753 } 754 755 void MacroAssembler::branchPtr(Condition cond, Register lhs, Register rhs, 756 Label* label) { 757 MOZ_CRASH(); 758 } 759 760 void MacroAssembler::branchPtr(Condition cond, Register lhs, Imm32 rhs, 761 Label* label) { 762 MOZ_CRASH(); 763 } 764 765 void MacroAssembler::branchPtr(Condition cond, Register lhs, ImmPtr rhs, 766 Label* label) { 767 MOZ_CRASH(); 768 } 769 770 void MacroAssembler::branchPtr(Condition cond, Register lhs, ImmGCPtr rhs, 771 Label* label) { 772 MOZ_CRASH(); 773 } 774 775 void MacroAssembler::branchPtr(Condition cond, Register lhs, ImmWord rhs, 776 Label* label) { 777 MOZ_CRASH(); 778 } 779 780 void MacroAssembler::branchPtr(Condition cond, const Address& lhs, Register rhs, 781 Label* label) { 782 MOZ_CRASH(); 783 } 784 785 void MacroAssembler::branchPtr(Condition cond, const Address& lhs, ImmPtr rhs, 786 Label* label) { 787 MOZ_CRASH(); 788 } 789 790 void MacroAssembler::branchPtr(Condition cond, const Address& lhs, ImmGCPtr rhs, 791 Label* label) { 792 MOZ_CRASH(); 793 } 794 795 void MacroAssembler::branchPtr(Condition cond, const Address& lhs, ImmWord rhs, 796 Label* label) { 797 MOZ_CRASH(); 798 } 799 800 void MacroAssembler::branchPtr(Condition cond, const BaseIndex& lhs, 801 ImmWord rhs, Label* label) { 802 MOZ_CRASH(); 803 } 804 805 void MacroAssembler::branchPtr(Condition cond, const BaseIndex& lhs, 806 Register rhs, Label* label) { 807 MOZ_CRASH(); 808 } 809 810 void MacroAssembler::branchPtr(Condition cond, const AbsoluteAddress& lhs, 811 Register rhs, Label* label) { 812 MOZ_CRASH(); 813 } 814 815 void MacroAssembler::branchPtr(Condition cond, const AbsoluteAddress& lhs, 816 ImmWord rhs, Label* label) { 817 MOZ_CRASH(); 818 } 819 820 void MacroAssembler::branchPtr(Condition cond, wasm::SymbolicAddress lhs, 821 Register rhs, Label* label) { 822 MOZ_CRASH(); 823 } 824 825 void MacroAssembler::branchFloat(DoubleCondition cond, FloatRegister lhs, 826 FloatRegister rhs, Label* label) { 827 MOZ_CRASH(); 828 } 829 830 void MacroAssembler::branchDouble(DoubleCondition cond, FloatRegister lhs, 831 FloatRegister rhs, Label* label) { 832 MOZ_CRASH(); 833 } 834 835 template <typename T> 836 void MacroAssembler::branchAdd32(Condition cond, T src, Register dest, 837 Label* label) { 838 MOZ_CRASH(); 839 } 840 841 template <typename T> 842 void MacroAssembler::branchSub32(Condition cond, T src, Register dest, 843 Label* label) { 844 MOZ_CRASH(); 845 } 846 847 template <typename T> 848 void MacroAssembler::branchMul32(Condition cond, T src, Register dest, 849 Label* label) { 850 MOZ_CRASH(); 851 } 852 853 template <typename T> 854 void MacroAssembler::branchRshift32(Condition cond, T src, Register dest, 855 Label* label) { 856 MOZ_CRASH(); 857 } 858 859 void MacroAssembler::branchNeg32(Condition cond, Register reg, Label* label) { 860 MOZ_CRASH(); 861 } 862 863 template <typename T> 864 void MacroAssembler::branchAddPtr(Condition cond, T src, Register dest, 865 Label* label) { 866 MOZ_CRASH(); 867 } 868 869 template <typename T> 870 void MacroAssembler::branchSubPtr(Condition cond, T src, Register dest, 871 Label* label) { 872 MOZ_CRASH(); 873 } 874 875 void MacroAssembler::branchMulPtr(Condition cond, Register src, Register dest, 876 Label* label) { 877 MOZ_CRASH(); 878 } 879 880 void MacroAssembler::branchNegPtr(Condition cond, Register reg, Label* label) { 881 MOZ_CRASH(); 882 } 883 884 void MacroAssembler::decBranchPtr(Condition cond, Register lhs, Imm32 rhs, 885 Label* label) { 886 MOZ_CRASH(); 887 } 888 889 void MacroAssembler::spectreZeroRegister(Condition cond, Register scratch, 890 Register dest) { 891 MOZ_CRASH(); 892 } 893 894 void MacroAssembler::spectreMovePtr(Condition cond, Register src, 895 Register dest) { 896 MOZ_CRASH(); 897 } 898 899 FaultingCodeOffset MacroAssembler::storeDouble(FloatRegister src, 900 const Address& dest) { 901 MOZ_CRASH(); 902 } 903 904 FaultingCodeOffset MacroAssembler::storeDouble(FloatRegister src, 905 const BaseIndex& dest) { 906 MOZ_CRASH(); 907 } 908 909 FaultingCodeOffset MacroAssembler::storeFloat32(FloatRegister src, 910 const Address& dest) { 911 MOZ_CRASH(); 912 } 913 914 FaultingCodeOffset MacroAssembler::storeFloat32(FloatRegister src, 915 const BaseIndex& dest) { 916 MOZ_CRASH(); 917 } 918 919 FaultingCodeOffset MacroAssembler::storeFloat16(FloatRegister src, 920 const Address& dest, Register) { 921 MOZ_CRASH(); 922 } 923 FaultingCodeOffset MacroAssembler::storeFloat16(FloatRegister src, 924 const BaseIndex& dest, 925 Register) { 926 MOZ_CRASH(); 927 } 928 929 void MacroAssembler::addPtr(Imm32 imm, const Address& dest) { MOZ_CRASH(); } 930 931 void MacroAssembler::addPtr(const Address& src, Register dest) { MOZ_CRASH(); } 932 933 void MacroAssembler::subPtr(Register src, const Address& dest) { MOZ_CRASH(); } 934 935 void MacroAssembler::subPtr(const Address& addr, Register dest) { MOZ_CRASH(); } 936 937 void MacroAssembler::branchTruncateFloat32MaybeModUint32(FloatRegister src, 938 Register dest, 939 Label* fail) { 940 MOZ_CRASH(); 941 } 942 943 void MacroAssembler::branchTruncateDoubleMaybeModUint32(FloatRegister src, 944 Register dest, 945 Label* fail) { 946 MOZ_CRASH(); 947 } 948 949 void MacroAssembler::test32MovePtr(Condition cond, Register operand, Imm32 mask, 950 Register src, Register dest) { 951 MOZ_CRASH(); 952 } 953 954 void MacroAssembler::test32MovePtr(Condition cond, const Address& addr, 955 Imm32 mask, Register src, Register dest) { 956 MOZ_CRASH(); 957 } 958 959 void MacroAssembler::cmp32MovePtr(Condition cond, Register lhs, Imm32 rhs, 960 Register src, Register dest) { 961 MOZ_CRASH(); 962 } 963 964 void MacroAssembler::test32LoadPtr(Condition cond, const Address& addr, 965 Imm32 mask, const Address& src, 966 Register dest) { 967 MOZ_CRASH(); 968 } 969 970 void MacroAssembler::spectreBoundsCheck32(Register index, Register length, 971 Register maybeScratch, 972 Label* failure) { 973 MOZ_CRASH(); 974 } 975 976 void MacroAssembler::spectreBoundsCheck32(Register index, const Address& length, 977 Register maybeScratch, 978 Label* failure) { 979 MOZ_CRASH(); 980 } 981 982 void MacroAssembler::spectreBoundsCheckPtr(Register index, Register length, 983 Register maybeScratch, 984 Label* failure) { 985 MOZ_CRASH(); 986 } 987 988 void MacroAssembler::spectreBoundsCheckPtr(Register index, 989 const Address& length, 990 Register maybeScratch, 991 Label* failure) { 992 MOZ_CRASH(); 993 } 994 995 void MacroAssembler::cmp32Load32(Condition cond, Register lhs, Imm32 rhs, 996 const Address& src, Register dest) { 997 MOZ_CRASH(); 998 } 999 1000 void MacroAssembler::cmp32LoadPtr(Condition cond, const Address& lhs, Imm32 rhs, 1001 const Address& src, Register dest) { 1002 MOZ_CRASH(); 1003 } 1004 1005 void MacroAssembler::branchTruncateFloat32ToInt32(FloatRegister src, 1006 Register dest, Label* fail) { 1007 MOZ_CRASH(); 1008 } 1009 1010 void MacroAssembler::branchTruncateDoubleToInt32(FloatRegister src, 1011 Register dest, Label* fail) { 1012 MOZ_CRASH(); 1013 } 1014 1015 void MacroAssembler::branchInt64NotInPtrRange(Register64 src, Label* label) { 1016 MOZ_CRASH(); 1017 } 1018 1019 void MacroAssembler::branchUInt64NotInPtrRange(Register64 src, Label* label) { 1020 MOZ_CRASH(); 1021 } 1022 1023 void MacroAssembler::mulDoublePtr(ImmPtr imm, Register temp, 1024 FloatRegister dest) { 1025 MOZ_CRASH(); 1026 } 1027 1028 template <typename T1, typename T2> 1029 void MacroAssembler::cmp32Set(Condition cond, T1 lhs, T2 rhs, Register dest) { 1030 MOZ_CRASH(); 1031 } 1032 1033 void MacroAssembler::cmp64Set(Condition cond, Register64 lhs, Register64 rhs, 1034 Register dest) { 1035 MOZ_CRASH(); 1036 } 1037 1038 void MacroAssembler::cmp64Set(Condition cond, Register64 lhs, Imm64 rhs, 1039 Register dest) { 1040 MOZ_CRASH(); 1041 } 1042 1043 void MacroAssembler::cmp64Set(Condition cond, Address lhs, Register64 rhs, 1044 Register dest) { 1045 MOZ_CRASH(); 1046 } 1047 1048 void MacroAssembler::cmp64Set(Condition cond, Address lhs, Imm64 rhs, 1049 Register dest) { 1050 MOZ_CRASH(); 1051 } 1052 1053 void MacroAssembler::branchTestDouble(Condition cond, const ValueOperand& value, 1054 Label* label) { 1055 MOZ_CRASH(); 1056 } 1057 1058 void MacroAssembler::branchTestInt32Truthy(bool truthy, 1059 const ValueOperand& value, 1060 Label* label) { 1061 MOZ_CRASH(); 1062 } 1063 1064 void MacroAssembler::branchTestNumber(Condition cond, const ValueOperand& value, 1065 Label* label) { 1066 MOZ_CRASH(); 1067 } 1068 1069 void MacroAssembler::branchTestSymbol(Condition cond, const ValueOperand& value, 1070 Label* label) { 1071 MOZ_CRASH(); 1072 } 1073 1074 void MacroAssembler::branchTestBigInt(Condition cond, const ValueOperand& value, 1075 Label* label) { 1076 MOZ_CRASH(); 1077 } 1078 1079 void MacroAssembler::branchTestBoolean(Condition cond, 1080 const ValueOperand& value, 1081 Label* label) { 1082 MOZ_CRASH(); 1083 } 1084 1085 void MacroAssembler::branchTestMagic(Condition cond, const ValueOperand& value, 1086 Label* label) { 1087 MOZ_CRASH(); 1088 } 1089 1090 void MacroAssembler::branchTestString(Condition cond, const ValueOperand& value, 1091 Label* label) { 1092 MOZ_CRASH(); 1093 } 1094 1095 void MacroAssembler::cmp32Move32(Condition cond, Register lhs, Imm32 rhs, 1096 Register src, Register dest) { 1097 MOZ_CRASH(); 1098 } 1099 1100 void MacroAssembler::cmp32Move32(Condition cond, Register lhs, Register rhs, 1101 Register src, Register dest) { 1102 MOZ_CRASH(); 1103 } 1104 1105 void MacroAssembler::cmp32Move32(Condition cond, Register lhs, 1106 const Address& rhs, Register src, 1107 Register dest) { 1108 MOZ_CRASH(); 1109 } 1110 1111 void MacroAssembler::cmp32Load32(Condition cond, Register lhs, Register rhs, 1112 const Address& src, Register dest) { 1113 MOZ_CRASH(); 1114 } 1115 1116 void MacroAssembler::cmp32Load32(Condition cond, Register lhs, 1117 const Address& rhs, const Address& src, 1118 Register dest) { 1119 MOZ_CRASH(); 1120 } 1121 1122 void MacroAssembler::branchTestUndefined(Condition cond, 1123 const ValueOperand& value, 1124 Label* label) { 1125 MOZ_CRASH(); 1126 } 1127 1128 void MacroAssembler::branchAdd64(Condition cond, Imm64 imm, Register64 dest, 1129 Label* label) { 1130 MOZ_CRASH(); 1131 } 1132 1133 void MacroAssembler::quotient32(Register lhs, Register rhs, Register dest, 1134 bool isUnsigned) { 1135 MOZ_CRASH(); 1136 } 1137 1138 void MacroAssembler::remainder32(Register lhs, Register rhs, Register dest, 1139 bool isUnsigned) { 1140 MOZ_CRASH(); 1141 } 1142 1143 void MacroAssembler::branch64(Condition cond, Register64 lhs, Imm64 val, 1144 Label* success, Label* fail) { 1145 MOZ_CRASH(); 1146 } 1147 1148 void MacroAssembler::branch64(Condition cond, Register64 lhs, Register64 rhs, 1149 Label* success, Label* fail) { 1150 MOZ_CRASH(); 1151 } 1152 1153 void MacroAssembler::branch64(Condition cond, const Address& lhs, Imm64 val, 1154 Label* success, Label* fail) { 1155 MOZ_CRASH(); 1156 } 1157 1158 void MacroAssembler::branch64(Condition cond, const Address& lhs, 1159 Register64 rhs, Label* success, Label* fail) { 1160 MOZ_CRASH(); 1161 } 1162 1163 void MacroAssembler::branch64(Condition cond, const Address& lhs, 1164 const Address& rhs, Register scratch, 1165 Label* label) { 1166 MOZ_CRASH(); 1167 } 1168 1169 void MacroAssembler::min32(Register lhs, Register rhs, Register dest) { 1170 MOZ_CRASH(); 1171 } 1172 1173 void MacroAssembler::min32(Register lhs, Imm32 rhs, Register dest) { 1174 MOZ_CRASH(); 1175 } 1176 1177 void MacroAssembler::max32(Register lhs, Register rhs, Register dest) { 1178 MOZ_CRASH(); 1179 } 1180 1181 void MacroAssembler::max32(Register lhs, Imm32 rhs, Register dest) { 1182 MOZ_CRASH(); 1183 } 1184 1185 void MacroAssembler::minPtr(Register lhs, Register rhs, Register dest) { 1186 MOZ_CRASH(); 1187 } 1188 1189 void MacroAssembler::minPtr(Register lhs, ImmWord rhs, Register dest) { 1190 MOZ_CRASH(); 1191 } 1192 1193 void MacroAssembler::maxPtr(Register lhs, Register rhs, Register dest) { 1194 MOZ_CRASH(); 1195 } 1196 1197 void MacroAssembler::maxPtr(Register lhs, ImmWord rhs, Register dest) { 1198 MOZ_CRASH(); 1199 } 1200 1201 void MacroAssembler::minFloat32(FloatRegister other, FloatRegister srcDest, 1202 bool handleNaN) { 1203 MOZ_CRASH(); 1204 } 1205 1206 void MacroAssembler::minDouble(FloatRegister other, FloatRegister srcDest, 1207 bool handleNaN) { 1208 MOZ_CRASH(); 1209 } 1210 1211 void MacroAssembler::maxFloat32(FloatRegister other, FloatRegister srcDest, 1212 bool handleNaN) { 1213 MOZ_CRASH(); 1214 } 1215 1216 void MacroAssembler::maxDouble(FloatRegister other, FloatRegister srcDest, 1217 bool handleNaN) { 1218 MOZ_CRASH(); 1219 } 1220 1221 void MacroAssembler::rotateLeft(Imm32 count, Register input, Register dest) { 1222 MOZ_CRASH(); 1223 } 1224 1225 void MacroAssembler::rotateLeft(Register count, Register input, Register dest) { 1226 MOZ_CRASH(); 1227 } 1228 1229 void MacroAssembler::rotateLeft64(Imm32 count, Register64 input, 1230 Register64 dest, Register temp) { 1231 MOZ_CRASH(); 1232 } 1233 1234 void MacroAssembler::rotateLeft64(Register count, Register64 input, 1235 Register64 dest, Register temp) { 1236 MOZ_CRASH(); 1237 } 1238 1239 void MacroAssembler::rotateRight(Imm32 count, Register input, Register dest) { 1240 MOZ_CRASH(); 1241 } 1242 1243 void MacroAssembler::rotateRight(Register count, Register input, 1244 Register dest) { 1245 MOZ_CRASH(); 1246 } 1247 1248 void MacroAssembler::rotateRight64(Imm32 count, Register64 input, 1249 Register64 dest, Register temp) { 1250 MOZ_CRASH(); 1251 } 1252 1253 void MacroAssembler::rotateRight64(Register count, Register64 input, 1254 Register64 dest, Register temp) { 1255 MOZ_CRASH(); 1256 } 1257 1258 void MacroAssembler::flexibleLshift32(Register shift, Register srcDest) { 1259 MOZ_CRASH(); 1260 } 1261 1262 void MacroAssembler::flexibleRshift32(Register shift, Register srcDest) { 1263 MOZ_CRASH(); 1264 } 1265 1266 void MacroAssembler::flexibleRshift32Arithmetic(Register shift, 1267 Register srcDest) { 1268 MOZ_CRASH(); 1269 } 1270 1271 void MacroAssembler::flexibleLshiftPtr(Register shift, Register srcDest) { 1272 MOZ_CRASH(); 1273 } 1274 1275 void MacroAssembler::flexibleRshiftPtr(Register shift, Register srcDest) { 1276 MOZ_CRASH(); 1277 } 1278 1279 void MacroAssembler::flexibleRshiftPtrArithmetic(Register shift, 1280 Register srcDest) { 1281 MOZ_CRASH(); 1282 } 1283 1284 void MacroAssembler::branchPrivatePtr(Condition cond, const Address& lhs, 1285 Register rhs, Label* label) { 1286 MOZ_CRASH(); 1287 } 1288 1289 void MacroAssembler::clz32(Register src, Register dest, bool knownNotZero) { 1290 MOZ_CRASH(); 1291 } 1292 1293 void MacroAssembler::ctz32(Register src, Register dest, bool knownNotZero) { 1294 MOZ_CRASH(); 1295 } 1296 1297 void MacroAssembler::popcnt32(Register src, Register dest, Register temp) { 1298 MOZ_CRASH(); 1299 } 1300 1301 void MacroAssembler::moveFloat32ToGPR(FloatRegister src, Register dest) { 1302 MOZ_CRASH(); 1303 } 1304 1305 void MacroAssembler::moveGPRToFloat32(Register src, FloatRegister dest) { 1306 MOZ_CRASH(); 1307 } 1308 1309 void MacroAssembler::moveFloat16ToGPR(FloatRegister src, Register dest) { 1310 MOZ_CRASH(); 1311 } 1312 1313 void MacroAssembler::moveGPRToFloat16(Register src, FloatRegister dest) { 1314 MOZ_CRASH(); 1315 } 1316 1317 void MacroAssembler::branchTestPrimitive(Condition cond, 1318 const ValueOperand& value, 1319 Label* label) { 1320 MOZ_CRASH(); 1321 } 1322 1323 void MacroAssembler::sqrtFloat32(FloatRegister src, FloatRegister dest) { 1324 MOZ_CRASH(); 1325 } 1326 1327 void MacroAssembler::cmp16Set(Condition cond, Address lhs, Imm32 rhs, 1328 Register dest) { 1329 MOZ_CRASH(); 1330 } 1331 1332 void MacroAssembler::cmp8Set(Condition cond, Address lhs, Imm32 rhs, 1333 Register dest) { 1334 MOZ_CRASH(); 1335 } 1336 1337 template <typename T> 1338 void MacroAssembler::testNumberSet(Condition cond, const T& src, 1339 Register dest) { 1340 MOZ_CRASH(); 1341 } 1342 1343 template <typename T> 1344 void MacroAssembler::testBooleanSet(Condition cond, const T& src, 1345 Register dest) { 1346 MOZ_CRASH(); 1347 } 1348 1349 template <typename T> 1350 void MacroAssembler::testStringSet(Condition cond, const T& src, 1351 Register dest) { 1352 MOZ_CRASH(); 1353 } 1354 1355 template <typename T> 1356 void MacroAssembler::testSymbolSet(Condition cond, const T& src, 1357 Register dest) { 1358 MOZ_CRASH(); 1359 } 1360 1361 template <typename T> 1362 void MacroAssembler::testBigIntSet(Condition cond, const T& src, 1363 Register dest) { 1364 MOZ_CRASH(); 1365 } 1366 1367 template <typename T> 1368 void MacroAssembler::branchTestGCThingImpl(Condition cond, const T& t, 1369 Label* label) { 1370 MOZ_CRASH(); 1371 } 1372 1373 //}}} check_macroassembler_style 1374 1375 } // namespace js::jit 1376 1377 #endif /* jit_wasm32_MacroAssembler_wasm32_inl_h */