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_none_MacroAssembler_none_h
8 #define jit_none_MacroAssembler_none_h
9
10 #include "jit/JitRealm.h"
11 #include "jit/MoveResolver.h"
12 #include "jit/shared/Assembler-shared.h"
13
14 namespace js {
15 namespace jit {
16
17 static constexpr Register StackPointer{Registers::invalid_reg};
18 static constexpr Register FramePointer{Registers::invalid_reg};
19 static constexpr Register ReturnReg{Registers::invalid_reg2};
20 static constexpr FloatRegister ReturnFloat32Reg = {FloatRegisters::invalid_reg};
21 static constexpr FloatRegister ReturnDoubleReg = {FloatRegisters::invalid_reg};
22 static constexpr FloatRegister ReturnSimd128Reg = {FloatRegisters::invalid_reg};
23 static constexpr FloatRegister ScratchFloat32Reg = {
24 FloatRegisters::invalid_reg};
25 static constexpr FloatRegister ScratchDoubleReg = {FloatRegisters::invalid_reg};
26 static constexpr FloatRegister ScratchSimd128Reg = {
27 FloatRegisters::invalid_reg};
28 static constexpr FloatRegister InvalidFloatReg = {FloatRegisters::invalid_reg};
29
30 struct ScratchFloat32Scope : FloatRegister {
ScratchFloat32ScopeScratchFloat32Scope31 explicit ScratchFloat32Scope(MacroAssembler& masm) {}
32 };
33
34 struct ScratchDoubleScope : FloatRegister {
ScratchDoubleScopeScratchDoubleScope35 explicit ScratchDoubleScope(MacroAssembler& masm) {}
36 };
37
38 static constexpr Register OsrFrameReg{Registers::invalid_reg};
39 static constexpr Register PreBarrierReg{Registers::invalid_reg};
40 static constexpr Register InterpreterPCReg{Registers::invalid_reg};
41 static constexpr Register CallTempReg0{Registers::invalid_reg};
42 static constexpr Register CallTempReg1{Registers::invalid_reg};
43 static constexpr Register CallTempReg2{Registers::invalid_reg};
44 static constexpr Register CallTempReg3{Registers::invalid_reg};
45 static constexpr Register CallTempReg4{Registers::invalid_reg};
46 static constexpr Register CallTempReg5{Registers::invalid_reg};
47 static constexpr Register InvalidReg{Registers::invalid_reg};
48 static constexpr Register CallTempNonArgRegs[] = {InvalidReg, InvalidReg};
49 static const uint32_t NumCallTempNonArgRegs =
50 mozilla::ArrayLength(CallTempNonArgRegs);
51
52 static constexpr Register IntArgReg0{Registers::invalid_reg};
53 static constexpr Register IntArgReg1{Registers::invalid_reg};
54 static constexpr Register IntArgReg2{Registers::invalid_reg};
55 static constexpr Register IntArgReg3{Registers::invalid_reg};
56 static constexpr Register HeapReg{Registers::invalid_reg};
57
58 static constexpr Register RegExpTesterRegExpReg{Registers::invalid_reg};
59 static constexpr Register RegExpTesterStringReg{Registers::invalid_reg};
60 static constexpr Register RegExpTesterLastIndexReg{Registers::invalid_reg};
61 static constexpr Register RegExpTesterStickyReg{Registers::invalid_reg};
62
63 static constexpr Register RegExpMatcherRegExpReg{Registers::invalid_reg};
64 static constexpr Register RegExpMatcherStringReg{Registers::invalid_reg};
65 static constexpr Register RegExpMatcherLastIndexReg{Registers::invalid_reg};
66 static constexpr Register RegExpMatcherStickyReg{Registers::invalid_reg};
67
68 // Uses |invalid_reg2| to avoid static_assert failures.
69 static constexpr Register JSReturnReg_Type{Registers::invalid_reg2};
70 static constexpr Register JSReturnReg_Data{Registers::invalid_reg2};
71 static constexpr Register JSReturnReg{Registers::invalid_reg2};
72
73 #if defined(JS_NUNBOX32)
74 static constexpr ValueOperand JSReturnOperand(InvalidReg, InvalidReg);
75 static constexpr Register64 ReturnReg64(InvalidReg, InvalidReg);
76 #elif defined(JS_PUNBOX64)
77 static constexpr ValueOperand JSReturnOperand(InvalidReg);
78 static constexpr Register64 ReturnReg64(InvalidReg);
79 #else
80 # error "Bad architecture"
81 #endif
82
83 static constexpr Register ABINonArgReg0{Registers::invalid_reg};
84 static constexpr Register ABINonArgReg1{Registers::invalid_reg};
85 static constexpr Register ABINonArgReg2{Registers::invalid_reg};
86 static constexpr Register ABINonArgReg3{Registers::invalid_reg};
87 static constexpr Register ABINonArgReturnReg0{Registers::invalid_reg};
88 static constexpr Register ABINonArgReturnReg1{Registers::invalid_reg};
89 static constexpr Register ABINonVolatileReg{Registers::invalid_reg};
90 static constexpr Register ABINonArgReturnVolatileReg{Registers::invalid_reg};
91
92 static constexpr FloatRegister ABINonArgDoubleReg = {
93 FloatRegisters::invalid_reg};
94
95 static constexpr Register WasmTableCallScratchReg0{Registers::invalid_reg};
96 static constexpr Register WasmTableCallScratchReg1{Registers::invalid_reg};
97 static constexpr Register WasmTableCallSigReg{Registers::invalid_reg};
98 static constexpr Register WasmTableCallIndexReg{Registers::invalid_reg};
99 static constexpr Register WasmTlsReg{Registers::invalid_reg};
100 static constexpr Register WasmJitEntryReturnScratch{Registers::invalid_reg};
101
102 static constexpr uint32_t ABIStackAlignment = 4;
103 static constexpr uint32_t CodeAlignment = 16;
104 static constexpr uint32_t JitStackAlignment = 8;
105 static constexpr uint32_t JitStackValueAlignment =
106 JitStackAlignment / sizeof(Value);
107
108 static const Scale ScalePointer = TimesOne;
109
110 class Assembler : public AssemblerShared {
111 public:
112 enum Condition {
113 Equal,
114 NotEqual,
115 Above,
116 AboveOrEqual,
117 Below,
118 BelowOrEqual,
119 GreaterThan,
120 GreaterThanOrEqual,
121 LessThan,
122 LessThanOrEqual,
123 Overflow,
124 CarrySet,
125 CarryClear,
126 Signed,
127 NotSigned,
128 Zero,
129 NonZero,
130 Always,
131 };
132
133 enum DoubleCondition {
134 DoubleOrdered,
135 DoubleEqual,
136 DoubleNotEqual,
137 DoubleGreaterThan,
138 DoubleGreaterThanOrEqual,
139 DoubleLessThan,
140 DoubleLessThanOrEqual,
141 DoubleUnordered,
142 DoubleEqualOrUnordered,
143 DoubleNotEqualOrUnordered,
144 DoubleGreaterThanOrUnordered,
145 DoubleGreaterThanOrEqualOrUnordered,
146 DoubleLessThanOrUnordered,
147 DoubleLessThanOrEqualOrUnordered
148 };
149
InvertCondition(Condition)150 static Condition InvertCondition(Condition) { MOZ_CRASH(); }
151
InvertCondition(DoubleCondition)152 static DoubleCondition InvertCondition(DoubleCondition) { MOZ_CRASH(); }
153
154 template <typename T, typename S>
PatchDataWithValueCheck(CodeLocationLabel,T,S)155 static void PatchDataWithValueCheck(CodeLocationLabel, T, S) {
156 MOZ_CRASH();
157 }
PatchWrite_Imm32(CodeLocationLabel,Imm32)158 static void PatchWrite_Imm32(CodeLocationLabel, Imm32) { MOZ_CRASH(); }
159
PatchWrite_NearCall(CodeLocationLabel,CodeLocationLabel)160 static void PatchWrite_NearCall(CodeLocationLabel, CodeLocationLabel) {
161 MOZ_CRASH();
162 }
PatchWrite_NearCallSize()163 static uint32_t PatchWrite_NearCallSize() { MOZ_CRASH(); }
164
ToggleToJmp(CodeLocationLabel)165 static void ToggleToJmp(CodeLocationLabel) { MOZ_CRASH(); }
ToggleToCmp(CodeLocationLabel)166 static void ToggleToCmp(CodeLocationLabel) { MOZ_CRASH(); }
ToggleCall(CodeLocationLabel,bool)167 static void ToggleCall(CodeLocationLabel, bool) { MOZ_CRASH(); }
168
Bind(uint8_t *,const CodeLabel &)169 static void Bind(uint8_t*, const CodeLabel&) { MOZ_CRASH(); }
170
GetPointer(uint8_t *)171 static uintptr_t GetPointer(uint8_t*) { MOZ_CRASH(); }
172
HasRoundInstruction(RoundingMode)173 static bool HasRoundInstruction(RoundingMode) { return false; }
174
verifyHeapAccessDisassembly(uint32_t begin,uint32_t end,const Disassembler::HeapAccess & heapAccess)175 void verifyHeapAccessDisassembly(uint32_t begin, uint32_t end,
176 const Disassembler::HeapAccess& heapAccess) {
177 MOZ_CRASH();
178 }
179
setUnlimitedBuffer()180 void setUnlimitedBuffer() { MOZ_CRASH(); }
181 };
182
183 class Operand {
184 public:
Operand(const Address &)185 explicit Operand(const Address&) { MOZ_CRASH(); }
Operand(const Register)186 explicit Operand(const Register) { MOZ_CRASH(); }
Operand(const FloatRegister)187 explicit Operand(const FloatRegister) { MOZ_CRASH(); }
Operand(Register,Imm32)188 explicit Operand(Register, Imm32) { MOZ_CRASH(); }
Operand(Register,int32_t)189 explicit Operand(Register, int32_t) { MOZ_CRASH(); }
190 };
191
192 class ScratchTagScope {
193 public:
ScratchTagScope(MacroAssembler &,const ValueOperand)194 ScratchTagScope(MacroAssembler&, const ValueOperand) {}
Register()195 operator Register() { MOZ_CRASH(); }
release()196 void release() { MOZ_CRASH(); }
reacquire()197 void reacquire() { MOZ_CRASH(); }
198 };
199
200 class ScratchTagScopeRelease {
201 public:
ScratchTagScopeRelease(ScratchTagScope *)202 explicit ScratchTagScopeRelease(ScratchTagScope*) {}
203 };
204
205 class MacroAssemblerNone : public Assembler {
206 public:
MacroAssemblerNone()207 MacroAssemblerNone() { MOZ_CRASH(); }
208
209 MoveResolver moveResolver_;
210
size()211 size_t size() const { MOZ_CRASH(); }
bytesNeeded()212 size_t bytesNeeded() const { MOZ_CRASH(); }
jumpRelocationTableBytes()213 size_t jumpRelocationTableBytes() const { MOZ_CRASH(); }
dataRelocationTableBytes()214 size_t dataRelocationTableBytes() const { MOZ_CRASH(); }
preBarrierTableBytes()215 size_t preBarrierTableBytes() const { MOZ_CRASH(); }
216
numCodeLabels()217 size_t numCodeLabels() const { MOZ_CRASH(); }
codeLabel(size_t)218 CodeLabel codeLabel(size_t) { MOZ_CRASH(); }
219
reserve(size_t size)220 bool reserve(size_t size) { MOZ_CRASH(); }
appendRawCode(const uint8_t * code,size_t numBytes)221 bool appendRawCode(const uint8_t* code, size_t numBytes) { MOZ_CRASH(); }
swapBuffer(wasm::Bytes & bytes)222 bool swapBuffer(wasm::Bytes& bytes) { MOZ_CRASH(); }
223
assertNoGCThings()224 void assertNoGCThings() const { MOZ_CRASH(); }
225
TraceJumpRelocations(JSTracer *,JitCode *,CompactBufferReader &)226 static void TraceJumpRelocations(JSTracer*, JitCode*, CompactBufferReader&) {
227 MOZ_CRASH();
228 }
TraceDataRelocations(JSTracer *,JitCode *,CompactBufferReader &)229 static void TraceDataRelocations(JSTracer*, JitCode*, CompactBufferReader&) {
230 MOZ_CRASH();
231 }
232
SupportsFloatingPoint()233 static bool SupportsFloatingPoint() { return false; }
SupportsUnalignedAccesses()234 static bool SupportsUnalignedAccesses() { return false; }
SupportsFastUnalignedAccesses()235 static bool SupportsFastUnalignedAccesses() { return false; }
236
237 void executableCopy(void*, bool = true) { MOZ_CRASH(); }
copyJumpRelocationTable(uint8_t *)238 void copyJumpRelocationTable(uint8_t*) { MOZ_CRASH(); }
copyDataRelocationTable(uint8_t *)239 void copyDataRelocationTable(uint8_t*) { MOZ_CRASH(); }
copyPreBarrierTable(uint8_t *)240 void copyPreBarrierTable(uint8_t*) { MOZ_CRASH(); }
processCodeLabels(uint8_t *)241 void processCodeLabels(uint8_t*) { MOZ_CRASH(); }
242
flushBuffer()243 void flushBuffer() { MOZ_CRASH(); }
244
245 template <typename T>
bind(T)246 void bind(T) {
247 MOZ_CRASH();
248 }
249 template <typename T>
j(Condition,T)250 void j(Condition, T) {
251 MOZ_CRASH();
252 }
253 template <typename T>
jump(T)254 void jump(T) {
255 MOZ_CRASH();
256 }
writeCodePointer(CodeLabel * label)257 void writeCodePointer(CodeLabel* label) { MOZ_CRASH(); }
haltingAlign(size_t)258 void haltingAlign(size_t) { MOZ_CRASH(); }
nopAlign(size_t)259 void nopAlign(size_t) { MOZ_CRASH(); }
checkStackAlignment()260 void checkStackAlignment() { MOZ_CRASH(); }
currentOffset()261 uint32_t currentOffset() { MOZ_CRASH(); }
262
nop()263 void nop() { MOZ_CRASH(); }
breakpoint()264 void breakpoint() { MOZ_CRASH(); }
abiret()265 void abiret() { MOZ_CRASH(); }
ret()266 void ret() { MOZ_CRASH(); }
267
toggledJump(Label *)268 CodeOffset toggledJump(Label*) { MOZ_CRASH(); }
toggledCall(JitCode *,bool)269 CodeOffset toggledCall(JitCode*, bool) { MOZ_CRASH(); }
ToggledCallSize(uint8_t *)270 static size_t ToggledCallSize(uint8_t*) { MOZ_CRASH(); }
271
finish()272 void finish() { MOZ_CRASH(); }
273
274 template <typename T, typename S>
moveValue(T,S)275 void moveValue(T, S) {
276 MOZ_CRASH();
277 }
278 template <typename T, typename S, typename U>
moveValue(T,S,U)279 void moveValue(T, S, U) {
280 MOZ_CRASH();
281 }
282 template <typename T, typename S>
storeValue(const T &,const S &)283 void storeValue(const T&, const S&) {
284 MOZ_CRASH();
285 }
286 template <typename T, typename S, typename U>
storeValue(T,S,U)287 void storeValue(T, S, U) {
288 MOZ_CRASH();
289 }
290 template <typename T, typename S>
loadValue(T,S)291 void loadValue(T, S) {
292 MOZ_CRASH();
293 }
294 template <typename T, typename S>
loadUnalignedValue(T,S)295 void loadUnalignedValue(T, S) {
296 MOZ_CRASH();
297 }
298 template <typename T>
pushValue(const T &)299 void pushValue(const T&) {
300 MOZ_CRASH();
301 }
302 template <typename T, typename S>
pushValue(T,S)303 void pushValue(T, S) {
304 MOZ_CRASH();
305 }
popValue(ValueOperand)306 void popValue(ValueOperand) { MOZ_CRASH(); }
tagValue(JSValueType,Register,ValueOperand)307 void tagValue(JSValueType, Register, ValueOperand) { MOZ_CRASH(); }
retn(Imm32 n)308 void retn(Imm32 n) { MOZ_CRASH(); }
309 template <typename T>
push(const T &)310 void push(const T&) {
311 MOZ_CRASH();
312 }
313 template <typename T>
Push(T)314 void Push(T) {
315 MOZ_CRASH();
316 }
317 template <typename T>
pop(T)318 void pop(T) {
319 MOZ_CRASH();
320 }
321 template <typename T>
Pop(T)322 void Pop(T) {
323 MOZ_CRASH();
324 }
325 template <typename T>
pushWithPatch(T)326 CodeOffset pushWithPatch(T) {
327 MOZ_CRASH();
328 }
329
testNullSet(Condition,ValueOperand,Register)330 void testNullSet(Condition, ValueOperand, Register) { MOZ_CRASH(); }
testObjectSet(Condition,ValueOperand,Register)331 void testObjectSet(Condition, ValueOperand, Register) { MOZ_CRASH(); }
testUndefinedSet(Condition,ValueOperand,Register)332 void testUndefinedSet(Condition, ValueOperand, Register) { MOZ_CRASH(); }
333
334 template <typename T, typename S>
cmpPtrSet(Condition,T,S,Register)335 void cmpPtrSet(Condition, T, S, Register) {
336 MOZ_CRASH();
337 }
338 template <typename T, typename S>
cmp32Set(Condition,T,S,Register)339 void cmp32Set(Condition, T, S, Register) {
340 MOZ_CRASH();
341 }
342
343 template <typename T>
mov(T,Register)344 void mov(T, Register) {
345 MOZ_CRASH();
346 }
347 template <typename T>
movePtr(T,Register)348 void movePtr(T, Register) {
349 MOZ_CRASH();
350 }
351 template <typename T>
move32(const T &,Register)352 void move32(const T&, Register) {
353 MOZ_CRASH();
354 }
355 template <typename T, typename S>
movq(T,S)356 void movq(T, S) {
357 MOZ_CRASH();
358 }
359 template <typename T, typename S>
moveFloat32(T,S)360 void moveFloat32(T, S) {
361 MOZ_CRASH();
362 }
363 template <typename T, typename S>
moveDouble(T,S)364 void moveDouble(T, S) {
365 MOZ_CRASH();
366 }
367 template <typename T, typename S>
move64(T,S)368 void move64(T, S) {
369 MOZ_CRASH();
370 }
371 template <typename T>
movWithPatch(T,Register)372 CodeOffset movWithPatch(T, Register) {
373 MOZ_CRASH();
374 }
375
376 template <typename T>
loadPtr(T,Register)377 void loadPtr(T, Register) {
378 MOZ_CRASH();
379 }
380 template <typename T>
load32(T,Register)381 void load32(T, Register) {
382 MOZ_CRASH();
383 }
384 template <typename T>
load32Unaligned(T,Register)385 void load32Unaligned(T, Register) {
386 MOZ_CRASH();
387 }
388 template <typename T>
loadFloat32(T,FloatRegister)389 void loadFloat32(T, FloatRegister) {
390 MOZ_CRASH();
391 }
392 template <typename T>
loadDouble(T,FloatRegister)393 void loadDouble(T, FloatRegister) {
394 MOZ_CRASH();
395 }
396 template <typename T>
loadPrivate(T,Register)397 void loadPrivate(T, Register) {
398 MOZ_CRASH();
399 }
400 template <typename T>
load8SignExtend(T,Register)401 void load8SignExtend(T, Register) {
402 MOZ_CRASH();
403 }
404 template <typename T>
load8ZeroExtend(T,Register)405 void load8ZeroExtend(T, Register) {
406 MOZ_CRASH();
407 }
408 template <typename T>
load16SignExtend(T,Register)409 void load16SignExtend(T, Register) {
410 MOZ_CRASH();
411 }
412 template <typename T>
load16UnalignedSignExtend(T,Register)413 void load16UnalignedSignExtend(T, Register) {
414 MOZ_CRASH();
415 }
416 template <typename T>
load16ZeroExtend(T,Register)417 void load16ZeroExtend(T, Register) {
418 MOZ_CRASH();
419 }
420 template <typename T>
load16UnalignedZeroExtend(T,Register)421 void load16UnalignedZeroExtend(T, Register) {
422 MOZ_CRASH();
423 }
424 template <typename T>
load64(T,Register64)425 void load64(T, Register64) {
426 MOZ_CRASH();
427 }
428 template <typename T>
load64Unaligned(T,Register64)429 void load64Unaligned(T, Register64) {
430 MOZ_CRASH();
431 }
432
433 template <typename T, typename S>
storePtr(const T &,S)434 void storePtr(const T&, S) {
435 MOZ_CRASH();
436 }
437 template <typename T, typename S>
store32(T,S)438 void store32(T, S) {
439 MOZ_CRASH();
440 }
441 template <typename T, typename S>
store32_NoSecondScratch(T,S)442 void store32_NoSecondScratch(T, S) {
443 MOZ_CRASH();
444 }
445 template <typename T, typename S>
store32Unaligned(T,S)446 void store32Unaligned(T, S) {
447 MOZ_CRASH();
448 }
449 template <typename T, typename S>
storeFloat32(T,S)450 void storeFloat32(T, S) {
451 MOZ_CRASH();
452 }
453 template <typename T, typename S>
storeDouble(T,S)454 void storeDouble(T, S) {
455 MOZ_CRASH();
456 }
457 template <typename T, typename S>
store8(T,S)458 void store8(T, S) {
459 MOZ_CRASH();
460 }
461 template <typename T, typename S>
store16(T,S)462 void store16(T, S) {
463 MOZ_CRASH();
464 }
465 template <typename T, typename S>
store16Unaligned(T,S)466 void store16Unaligned(T, S) {
467 MOZ_CRASH();
468 }
469 template <typename T, typename S>
store64(T,S)470 void store64(T, S) {
471 MOZ_CRASH();
472 }
473 template <typename T, typename S>
store64Unaligned(T,S)474 void store64Unaligned(T, S) {
475 MOZ_CRASH();
476 }
477
478 template <typename T>
computeEffectiveAddress(T,Register)479 void computeEffectiveAddress(T, Register) {
480 MOZ_CRASH();
481 }
482
splitTagForTest(ValueOperand,ScratchTagScope &)483 void splitTagForTest(ValueOperand, ScratchTagScope&) { MOZ_CRASH(); }
484
boxDouble(FloatRegister,ValueOperand,FloatRegister)485 void boxDouble(FloatRegister, ValueOperand, FloatRegister) { MOZ_CRASH(); }
boxNonDouble(JSValueType,Register,ValueOperand)486 void boxNonDouble(JSValueType, Register, ValueOperand) { MOZ_CRASH(); }
487 template <typename T>
boxDouble(FloatRegister src,const T & dest)488 void boxDouble(FloatRegister src, const T& dest) {
489 MOZ_CRASH();
490 }
491 template <typename T>
unboxInt32(T,Register)492 void unboxInt32(T, Register) {
493 MOZ_CRASH();
494 }
495 template <typename T>
unboxBoolean(T,Register)496 void unboxBoolean(T, Register) {
497 MOZ_CRASH();
498 }
499 template <typename T>
unboxString(T,Register)500 void unboxString(T, Register) {
501 MOZ_CRASH();
502 }
503 template <typename T>
unboxSymbol(T,Register)504 void unboxSymbol(T, Register) {
505 MOZ_CRASH();
506 }
507 template <typename T>
unboxBigInt(T,Register)508 void unboxBigInt(T, Register) {
509 MOZ_CRASH();
510 }
511 template <typename T>
unboxObject(T,Register)512 void unboxObject(T, Register) {
513 MOZ_CRASH();
514 }
515 template <typename T>
unboxDouble(T,FloatRegister)516 void unboxDouble(T, FloatRegister) {
517 MOZ_CRASH();
518 }
unboxValue(const ValueOperand &,AnyRegister,JSValueType)519 void unboxValue(const ValueOperand&, AnyRegister, JSValueType) {
520 MOZ_CRASH();
521 }
unboxNonDouble(const ValueOperand &,Register,JSValueType)522 void unboxNonDouble(const ValueOperand&, Register, JSValueType) {
523 MOZ_CRASH();
524 }
unboxNonDouble(const Address &,Register,JSValueType)525 void unboxNonDouble(const Address&, Register, JSValueType) { MOZ_CRASH(); }
526 template <typename T>
unboxGCThingForGCBarrier(const T &,Register)527 void unboxGCThingForGCBarrier(const T&, Register) {
528 MOZ_CRASH();
529 }
530 template <typename T>
unboxObjectOrNull(const T & src,Register dest)531 void unboxObjectOrNull(const T& src, Register dest) {
532 MOZ_CRASH();
533 }
notBoolean(ValueOperand)534 void notBoolean(ValueOperand) { MOZ_CRASH(); }
extractObject(Address,Register)535 MOZ_MUST_USE Register extractObject(Address, Register) { MOZ_CRASH(); }
extractObject(ValueOperand,Register)536 MOZ_MUST_USE Register extractObject(ValueOperand, Register) { MOZ_CRASH(); }
extractSymbol(ValueOperand,Register)537 MOZ_MUST_USE Register extractSymbol(ValueOperand, Register) { MOZ_CRASH(); }
extractInt32(ValueOperand,Register)538 MOZ_MUST_USE Register extractInt32(ValueOperand, Register) { MOZ_CRASH(); }
extractBoolean(ValueOperand,Register)539 MOZ_MUST_USE Register extractBoolean(ValueOperand, Register) { MOZ_CRASH(); }
540 template <typename T>
extractTag(T,Register)541 MOZ_MUST_USE Register extractTag(T, Register) {
542 MOZ_CRASH();
543 }
544
545 void convertFloat32ToInt32(FloatRegister, Register, Label*, bool v = true) {
546 MOZ_CRASH();
547 }
548 void convertDoubleToInt32(FloatRegister, Register, Label*, bool v = true) {
549 MOZ_CRASH();
550 }
convertBoolToInt32(Register,Register)551 void convertBoolToInt32(Register, Register) { MOZ_CRASH(); }
552
convertDoubleToFloat32(FloatRegister,FloatRegister)553 void convertDoubleToFloat32(FloatRegister, FloatRegister) { MOZ_CRASH(); }
convertInt32ToFloat32(Register,FloatRegister)554 void convertInt32ToFloat32(Register, FloatRegister) { MOZ_CRASH(); }
555
556 template <typename T>
convertInt32ToDouble(T,FloatRegister)557 void convertInt32ToDouble(T, FloatRegister) {
558 MOZ_CRASH();
559 }
convertFloat32ToDouble(FloatRegister,FloatRegister)560 void convertFloat32ToDouble(FloatRegister, FloatRegister) { MOZ_CRASH(); }
561
boolValueToDouble(ValueOperand,FloatRegister)562 void boolValueToDouble(ValueOperand, FloatRegister) { MOZ_CRASH(); }
boolValueToFloat32(ValueOperand,FloatRegister)563 void boolValueToFloat32(ValueOperand, FloatRegister) { MOZ_CRASH(); }
int32ValueToDouble(ValueOperand,FloatRegister)564 void int32ValueToDouble(ValueOperand, FloatRegister) { MOZ_CRASH(); }
int32ValueToFloat32(ValueOperand,FloatRegister)565 void int32ValueToFloat32(ValueOperand, FloatRegister) { MOZ_CRASH(); }
566
loadConstantDouble(double,FloatRegister)567 void loadConstantDouble(double, FloatRegister) { MOZ_CRASH(); }
loadConstantFloat32(float,FloatRegister)568 void loadConstantFloat32(float, FloatRegister) { MOZ_CRASH(); }
testInt32Truthy(bool,ValueOperand)569 Condition testInt32Truthy(bool, ValueOperand) { MOZ_CRASH(); }
testStringTruthy(bool,ValueOperand)570 Condition testStringTruthy(bool, ValueOperand) { MOZ_CRASH(); }
testBigIntTruthy(bool,ValueOperand)571 Condition testBigIntTruthy(bool, ValueOperand) { MOZ_CRASH(); }
572
573 template <typename T>
loadUnboxedValue(T,MIRType,AnyRegister)574 void loadUnboxedValue(T, MIRType, AnyRegister) {
575 MOZ_CRASH();
576 }
577 template <typename T>
storeUnboxedValue(const ConstantOrRegister &,MIRType,T,MIRType)578 void storeUnboxedValue(const ConstantOrRegister&, MIRType, T, MIRType) {
579 MOZ_CRASH();
580 }
581 template <typename T>
storeUnboxedPayload(ValueOperand value,T,size_t,JSValueType)582 void storeUnboxedPayload(ValueOperand value, T, size_t, JSValueType) {
583 MOZ_CRASH();
584 }
585
convertUInt32ToDouble(Register,FloatRegister)586 void convertUInt32ToDouble(Register, FloatRegister) { MOZ_CRASH(); }
convertUInt32ToFloat32(Register,FloatRegister)587 void convertUInt32ToFloat32(Register, FloatRegister) { MOZ_CRASH(); }
incrementInt32Value(Address)588 void incrementInt32Value(Address) { MOZ_CRASH(); }
ensureDouble(ValueOperand,FloatRegister,Label *)589 void ensureDouble(ValueOperand, FloatRegister, Label*) { MOZ_CRASH(); }
handleFailureWithHandlerTail(void *)590 void handleFailureWithHandlerTail(void*) { MOZ_CRASH(); }
591
buildFakeExitFrame(Register,uint32_t *)592 void buildFakeExitFrame(Register, uint32_t*) { MOZ_CRASH(); }
buildOOLFakeExitFrame(void *)593 bool buildOOLFakeExitFrame(void*) { MOZ_CRASH(); }
loadWasmGlobalPtr(uint32_t,Register)594 void loadWasmGlobalPtr(uint32_t, Register) { MOZ_CRASH(); }
loadWasmPinnedRegsFromTls()595 void loadWasmPinnedRegsFromTls() { MOZ_CRASH(); }
596
setPrinter(Sprinter *)597 void setPrinter(Sprinter*) { MOZ_CRASH(); }
ToPayload(Operand base)598 Operand ToPayload(Operand base) { MOZ_CRASH(); }
ToPayload(Address)599 Address ToPayload(Address) { MOZ_CRASH(); }
600
getStackPointer()601 Register getStackPointer() const { MOZ_CRASH(); }
602
603 // Instrumentation for entering and leaving the profiler.
profilerEnterFrame(Register,Register)604 void profilerEnterFrame(Register, Register) { MOZ_CRASH(); }
profilerExitFrame()605 void profilerExitFrame() { MOZ_CRASH(); }
606
607 #ifdef JS_NUNBOX32
ToType(Address)608 Address ToType(Address) { MOZ_CRASH(); }
609 #endif
610 };
611
612 typedef MacroAssemblerNone MacroAssemblerSpecific;
613
614 class ABIArgGenerator {
615 public:
ABIArgGenerator()616 ABIArgGenerator() { MOZ_CRASH(); }
next(MIRType)617 ABIArg next(MIRType) { MOZ_CRASH(); }
current()618 ABIArg& current() { MOZ_CRASH(); }
stackBytesConsumedSoFar()619 uint32_t stackBytesConsumedSoFar() const { MOZ_CRASH(); }
620 };
621
GetTempRegForIntArg(uint32_t,uint32_t,Register *)622 static inline bool GetTempRegForIntArg(uint32_t, uint32_t, Register*) {
623 MOZ_CRASH();
624 }
625
626 } // namespace jit
627 } // namespace js
628
629 #endif /* jit_none_MacroAssembler_none_h */
630