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