MacroAssembler-wasm32.h (12569B)
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_h 8 #define jit_wasm32_MacroAssembler_wasm32_h 9 10 #include "jit/wasm32/Assembler-wasm32.h" 11 12 namespace js::jit { 13 14 class CompactBufferReader; 15 16 class ScratchTagScope { 17 public: 18 ScratchTagScope(MacroAssembler&, const ValueOperand) {} 19 operator Register() { MOZ_CRASH(); } 20 void release() { MOZ_CRASH(); } 21 void reacquire() { MOZ_CRASH(); } 22 }; 23 24 class ScratchTagScopeRelease { 25 public: 26 explicit ScratchTagScopeRelease(ScratchTagScope*) {} 27 }; 28 29 class MacroAssemblerWasm32 : public Assembler { 30 public: 31 size_t size() const { return bytesNeeded(); } 32 33 size_t bytesNeeded() const { MOZ_CRASH(); } 34 35 size_t jumpRelocationTableBytes() const { MOZ_CRASH(); } 36 37 size_t dataRelocationTableBytes() const { MOZ_CRASH(); } 38 39 size_t preBarrierTableBytes() const { MOZ_CRASH(); } 40 41 size_t numCodeLabels() const { MOZ_CRASH(); } 42 CodeLabel codeLabel(size_t) { MOZ_CRASH(); } 43 44 bool reserve(size_t size) { MOZ_CRASH(); } 45 bool appendRawCode(const uint8_t* code, size_t numBytes) { MOZ_CRASH(); } 46 bool swapBuffer(wasm::Bytes& bytes) { MOZ_CRASH(); } 47 48 void assertNoGCThings() const { MOZ_CRASH(); } 49 50 static void TraceJumpRelocations(JSTracer*, JitCode*, CompactBufferReader&) { 51 MOZ_CRASH(); 52 } 53 static void TraceDataRelocations(JSTracer*, JitCode*, CompactBufferReader&) { 54 MOZ_CRASH(); 55 } 56 57 static bool SupportsFloatingPoint() { return true; } 58 static bool SupportsUnalignedAccesses() { return false; } 59 static bool SupportsFastUnalignedFPAccesses() { return false; } 60 static bool SupportsFloat64To16() { return false; } 61 static bool SupportsFloat32To16() { return false; } 62 63 void executableCopy(void* buffer); 64 65 void copyJumpRelocationTable(uint8_t*) { MOZ_CRASH(); } 66 67 void copyDataRelocationTable(uint8_t*) { MOZ_CRASH(); } 68 69 void copyPreBarrierTable(uint8_t*) { MOZ_CRASH(); } 70 71 void processCodeLabels(uint8_t*) { MOZ_CRASH(); } 72 73 void flushBuffer() { MOZ_CRASH(); } 74 75 void bind(Label* label) { MOZ_CRASH(); } 76 77 void bind(CodeLabel* label) { MOZ_CRASH(); } 78 79 template <typename T> 80 void j(Condition, T) { 81 MOZ_CRASH(); 82 } 83 84 void jump(Label* label); 85 86 void jump(JitCode* code) { MOZ_CRASH(); } 87 88 void jump(Register reg) { MOZ_CRASH(); } 89 90 void jump(const Address& address) { MOZ_CRASH(); } 91 92 void jump(ImmPtr ptr) { MOZ_CRASH(); } 93 94 void jump(TrampolinePtr code) { MOZ_CRASH(); } 95 96 void writeCodePointer(CodeLabel* label); 97 98 void haltingAlign(size_t); 99 100 void nopAlign(size_t); 101 void checkStackAlignment(); 102 103 uint32_t currentOffset(); 104 105 void nop(); 106 107 void breakpoint(); 108 109 void abiret(); 110 void ret(); 111 112 CodeOffset toggledJump(Label*); 113 CodeOffset toggledCall(JitCode*, bool); 114 static size_t ToggledCallSize(uint8_t*); 115 116 void finish(); 117 118 template <typename T, typename S> 119 void moveValue(T, S) { 120 MOZ_CRASH(); 121 } 122 123 template <typename T, typename S, typename U> 124 void moveValue(T, S, U) { 125 MOZ_CRASH(); 126 } 127 128 template <typename T, typename S> 129 void storeValue(const T&, const S&) { 130 MOZ_CRASH(); 131 } 132 133 template <typename T, typename S, typename U> 134 void storeValue(T, S, U) { 135 MOZ_CRASH(); 136 } 137 138 template <typename T, typename S> 139 void storePrivateValue(const T&, const S&) { 140 MOZ_CRASH(); 141 } 142 143 template <typename T, typename S> 144 void loadValue(T, S) { 145 MOZ_CRASH(); 146 } 147 148 template <typename T, typename S> 149 void loadUnalignedValue(T, S) { 150 MOZ_CRASH(); 151 } 152 153 template <typename T> 154 void pushValue(const T&) { 155 MOZ_CRASH(); 156 } 157 158 void pushValue(ValueOperand val); 159 160 template <typename T, typename S> 161 void pushValue(T, S) { 162 MOZ_CRASH(); 163 } 164 165 void popValue(ValueOperand); 166 void tagValue(JSValueType, Register, ValueOperand); 167 void retn(Imm32 n); 168 169 template <typename T> 170 void push(const T&) { 171 MOZ_CRASH(); 172 } 173 174 void push(Register reg); 175 176 template <typename T> 177 void Push(T) { 178 MOZ_CRASH(); 179 } 180 181 template <typename T> 182 void pop(T) { 183 MOZ_CRASH(); 184 } 185 186 template <typename T> 187 CodeOffset pushWithPatch(T) { 188 MOZ_CRASH(); 189 } 190 191 void testNullSet(Condition, ValueOperand, Register) { MOZ_CRASH(); } 192 void testObjectSet(Condition, ValueOperand, Register) { MOZ_CRASH(); } 193 void testUndefinedSet(Condition, ValueOperand, Register) { MOZ_CRASH(); } 194 195 template <typename T, typename S> 196 void cmpPtrSet(Condition, T, S, Register) { 197 MOZ_CRASH(); 198 } 199 200 template <typename T> 201 void mov(T, Register) { 202 MOZ_CRASH(); 203 } 204 205 template <typename T> 206 void movePtr(T, Register) { 207 MOZ_CRASH(); 208 } 209 210 void movePtr(Register src, Register dst) { MOZ_CRASH(); } 211 212 template <typename T> 213 void move32(const T&, Register) { 214 MOZ_CRASH(); 215 } 216 217 template <typename T, typename S> 218 void movq(T, S) { 219 MOZ_CRASH(); 220 } 221 222 template <typename T, typename S> 223 void moveFloat32(T, S) { 224 MOZ_CRASH(); 225 } 226 227 template <typename T, typename S> 228 void moveDouble(T, S) { 229 MOZ_CRASH(); 230 } 231 232 template <typename T, typename S> 233 void move64(T, S) { 234 MOZ_CRASH(); 235 } 236 237 template <typename T> 238 CodeOffset movWithPatch(T, Register) { 239 MOZ_CRASH(); 240 } 241 242 template <typename T> 243 void loadPtr(T, Register) { 244 MOZ_CRASH(); 245 } 246 247 void loadPtr(const Address& address, Register dest) { MOZ_CRASH(); } 248 249 template <typename T> 250 void load32(T, Register) { 251 MOZ_CRASH(); 252 } 253 254 template <typename T> 255 void load32Unaligned(T, Register) { 256 MOZ_CRASH(); 257 } 258 259 template <typename T> 260 void loadFloat16(T, FloatRegister, Register) { 261 MOZ_CRASH(); 262 } 263 264 template <typename T> 265 void loadFloat32(T, FloatRegister) { 266 MOZ_CRASH(); 267 } 268 269 template <typename T> 270 void loadDouble(T, FloatRegister) { 271 MOZ_CRASH(); 272 } 273 274 template <typename T> 275 void loadPrivate(T, Register) { 276 MOZ_CRASH(); 277 } 278 279 template <typename T> 280 void load8SignExtend(T, Register) { 281 MOZ_CRASH(); 282 } 283 284 template <typename T> 285 void load8ZeroExtend(T, Register) { 286 MOZ_CRASH(); 287 } 288 289 template <typename T> 290 void load16SignExtend(T, Register) { 291 MOZ_CRASH(); 292 } 293 294 template <typename T> 295 void load16UnalignedSignExtend(T, Register) { 296 MOZ_CRASH(); 297 } 298 299 template <typename T> 300 void load16ZeroExtend(T, Register) { 301 MOZ_CRASH(); 302 } 303 304 template <typename T> 305 void load16UnalignedZeroExtend(T, Register) { 306 MOZ_CRASH(); 307 } 308 309 template <typename T> 310 void load64(T, Register64) { 311 MOZ_CRASH(); 312 } 313 314 template <typename T> 315 void load64Unaligned(T, Register64) { 316 MOZ_CRASH(); 317 } 318 319 template <typename T, typename S> 320 void storePtr(const T&, S) { 321 MOZ_CRASH(); 322 } 323 324 void storePtr(Register src, const Address& address) { MOZ_CRASH(); } 325 void storePtr(ImmPtr src, const Address& address) { MOZ_CRASH(); } 326 327 template <typename T, typename S> 328 void store32(T, S) { 329 MOZ_CRASH(); 330 } 331 332 void store32(Imm32 src, const Address& address) { MOZ_CRASH(); } 333 334 template <typename T, typename S> 335 void store32Unaligned(T, S) { 336 MOZ_CRASH(); 337 } 338 339 template <typename T, typename S> 340 void storeFloat32(T, S) { 341 MOZ_CRASH(); 342 } 343 344 template <typename T, typename S> 345 void storeDouble(T, S) { 346 MOZ_CRASH(); 347 } 348 349 template <typename T, typename S> 350 void store8(T, S) { 351 MOZ_CRASH(); 352 } 353 354 template <typename T, typename S> 355 void store16(T, S) { 356 MOZ_CRASH(); 357 } 358 359 template <typename T, typename S> 360 void store16Unaligned(T, S) { 361 MOZ_CRASH(); 362 } 363 364 template <typename T, typename S> 365 void store64(T, S) { 366 MOZ_CRASH(); 367 } 368 369 template <typename T, typename S> 370 void store64Unaligned(T, S) { 371 MOZ_CRASH(); 372 } 373 374 template <typename T> 375 void computeEffectiveAddress(T, Register) { 376 MOZ_CRASH(); 377 } 378 379 void splitTagForTest(ValueOperand, ScratchTagScope&) { MOZ_CRASH(); } 380 381 void boxDouble(FloatRegister, ValueOperand, FloatRegister) { MOZ_CRASH(); } 382 void boxNonDouble(JSValueType, Register, ValueOperand) { MOZ_CRASH(); } 383 void boxNonDouble(Register, Register, ValueOperand) { MOZ_CRASH(); } 384 385 template <typename T> 386 void boxDouble(FloatRegister src, const T& dest) { 387 MOZ_CRASH(); 388 } 389 390 template <typename T> 391 void unboxInt32(T, Register) { 392 MOZ_CRASH(); 393 } 394 395 template <typename T> 396 void unboxBoolean(T, Register) { 397 MOZ_CRASH(); 398 } 399 400 template <typename T> 401 void unboxString(T, Register) { 402 MOZ_CRASH(); 403 } 404 405 template <typename T> 406 void unboxSymbol(T, Register) { 407 MOZ_CRASH(); 408 } 409 410 template <typename T> 411 void unboxBigInt(T, Register) { 412 MOZ_CRASH(); 413 } 414 415 template <typename T> 416 void unboxObject(T, Register) { 417 MOZ_CRASH(); 418 } 419 420 void unboxObject(const Address& src, Register dest) { 421 unboxNonDouble(src, dest, JSVAL_TYPE_OBJECT); 422 } 423 424 template <typename T> 425 void unboxDouble(T, FloatRegister) { 426 MOZ_CRASH(); 427 } 428 429 void unboxValue(const ValueOperand&, AnyRegister, JSValueType) { 430 MOZ_CRASH(); 431 } 432 433 void unboxNonDouble(const ValueOperand&, Register, JSValueType) { 434 MOZ_CRASH(); 435 } 436 437 void unboxNonDouble(const Address& address, Register dest, JSValueType type) { 438 MOZ_CRASH(); 439 } 440 441 template <typename T> 442 void unboxGCThingForGCBarrier(const T&, Register) { 443 MOZ_CRASH(); 444 } 445 446 template <typename T> 447 void unboxWasmAnyRefGCThingForGCBarrier(const T&, Register) { 448 MOZ_CRASH(); 449 } 450 451 void getWasmAnyRefGCThingChunk(Register, Register) { MOZ_CRASH(); } 452 453 void notBoolean(ValueOperand) { MOZ_CRASH(); } 454 [[nodiscard]] Register extractObject(Address, Register) { MOZ_CRASH(); } 455 [[nodiscard]] Register extractObject(ValueOperand, Register) { MOZ_CRASH(); } 456 [[nodiscard]] Register extractSymbol(ValueOperand, Register) { MOZ_CRASH(); } 457 [[nodiscard]] Register extractInt32(ValueOperand, Register) { MOZ_CRASH(); } 458 [[nodiscard]] Register extractBoolean(ValueOperand, Register) { MOZ_CRASH(); } 459 460 template <typename T> 461 [[nodiscard]] Register extractTag(T, Register) { 462 MOZ_CRASH(); 463 } 464 465 void convertFloat32ToInt32(FloatRegister, Register, Label*, bool v = true) { 466 MOZ_CRASH(); 467 } 468 void convertDoubleToInt32(FloatRegister, Register, Label*, bool v = true) { 469 MOZ_CRASH(); 470 } 471 void convertDoubleToPtr(FloatRegister, Register, Label*, bool v = true) { 472 MOZ_CRASH(); 473 } 474 void convertBoolToInt32(Register, Register) { MOZ_CRASH(); } 475 void convertDoubleToFloat32(FloatRegister, FloatRegister) { MOZ_CRASH(); } 476 void convertInt32ToFloat32(Register, FloatRegister) { MOZ_CRASH(); } 477 478 template <typename T> 479 void convertInt32ToDouble(T, FloatRegister) { 480 MOZ_CRASH(); 481 } 482 483 void convertFloat32ToDouble(FloatRegister, FloatRegister) { MOZ_CRASH(); } 484 485 void convertDoubleToFloat16(FloatRegister, FloatRegister) { MOZ_CRASH(); } 486 void convertFloat16ToDouble(FloatRegister, FloatRegister) { MOZ_CRASH(); } 487 void convertFloat32ToFloat16(FloatRegister, FloatRegister) { MOZ_CRASH(); } 488 void convertFloat16ToFloat32(FloatRegister, FloatRegister) { MOZ_CRASH(); } 489 void convertInt32ToFloat16(Register, FloatRegister) { MOZ_CRASH(); } 490 491 void loadConstantDouble(double, FloatRegister) { MOZ_CRASH(); } 492 void loadConstantFloat32(float, FloatRegister) { MOZ_CRASH(); } 493 Condition testInt32Truthy(bool, ValueOperand) { MOZ_CRASH(); } 494 Condition testStringTruthy(bool, ValueOperand) { MOZ_CRASH(); } 495 Condition testBigIntTruthy(bool, ValueOperand) { MOZ_CRASH(); } 496 497 template <typename T> 498 void loadUnboxedValue(T, MIRType, AnyRegister) { 499 MOZ_CRASH(); 500 } 501 502 void convertUInt32ToDouble(Register, FloatRegister) { MOZ_CRASH(); } 503 void convertUInt32ToFloat32(Register, FloatRegister) { MOZ_CRASH(); } 504 void incrementInt32Value(Address) { MOZ_CRASH(); } 505 void handleFailureWithHandlerTail(Label*, Label*, uint32_t*) { MOZ_CRASH(); } 506 507 void buildFakeExitFrame(Register, uint32_t*) { MOZ_CRASH(); } 508 bool buildOOLFakeExitFrame(void*) { MOZ_CRASH(); } 509 510 void setPrinter(Sprinter*) { MOZ_CRASH(); } 511 Operand ToPayload(Operand base) { MOZ_CRASH(); } 512 Address ToPayload(const Address& base) const { return base; } 513 514 Register getStackPointer() const { return StackPointer; } 515 516 // Instrumentation for entering and leaving the profiler. 517 void profilerEnterFrame(Register, Register) { MOZ_CRASH(); } 518 void profilerExitFrame() { MOZ_CRASH(); } 519 520 #ifdef JS_NUNBOX32 521 Address ToType(const Address& address); 522 #endif 523 }; 524 525 using MacroAssemblerSpecific = MacroAssemblerWasm32; 526 527 static inline bool GetTempRegForIntArg(uint32_t, uint32_t, Register*) { 528 MOZ_CRASH(); 529 } 530 531 } // namespace js::jit 532 533 #endif /* jit_wasm32_MacroAssembler_wasm32_h */