summaryrefslogtreecommitdiff
path: root/js/src/jit/none/MacroAssembler-none.h
blob: 599fe75bfb51633c36f4ad92b008b2c5c4a306c0 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#ifndef jit_none_MacroAssembler_none_h
#define jit_none_MacroAssembler_none_h

#include "jit/JitCompartment.h"
#include "jit/MoveResolver.h"
#include "jit/shared/Assembler-shared.h"

namespace js {
namespace jit {

static constexpr Register StackPointer = { Registers::invalid_reg };
static constexpr Register FramePointer = { Registers::invalid_reg };
static constexpr Register ReturnReg = { Registers::invalid_reg };
static constexpr FloatRegister ReturnFloat32Reg = { FloatRegisters::invalid_reg };
static constexpr FloatRegister ReturnDoubleReg = { FloatRegisters::invalid_reg };
static constexpr FloatRegister ReturnSimd128Reg = { FloatRegisters::invalid_reg };
static constexpr FloatRegister ScratchFloat32Reg = { FloatRegisters::invalid_reg };
static constexpr FloatRegister ScratchDoubleReg = { FloatRegisters::invalid_reg };
static constexpr FloatRegister ScratchSimd128Reg = { FloatRegisters::invalid_reg };
static constexpr FloatRegister InvalidFloatReg = { FloatRegisters::invalid_reg };

static constexpr Register OsrFrameReg = { Registers::invalid_reg };
static constexpr Register ArgumentsRectifierReg = { Registers::invalid_reg };
static constexpr Register PreBarrierReg = { Registers::invalid_reg };
static constexpr Register CallTempReg0 = { Registers::invalid_reg };
static constexpr Register CallTempReg1 = { Registers::invalid_reg };
static constexpr Register CallTempReg2 = { Registers::invalid_reg };
static constexpr Register CallTempReg3 = { Registers::invalid_reg };
static constexpr Register CallTempReg4 = { Registers::invalid_reg };
static constexpr Register CallTempReg5 = { Registers::invalid_reg };
static constexpr Register InvalidReg = { Registers::invalid_reg };

static constexpr Register IntArgReg0 = { Registers::invalid_reg };
static constexpr Register IntArgReg1 = { Registers::invalid_reg };
static constexpr Register IntArgReg2 = { Registers::invalid_reg };
static constexpr Register IntArgReg3 = { Registers::invalid_reg };
static constexpr Register GlobalReg = { Registers::invalid_reg };
static constexpr Register HeapReg = { Registers::invalid_reg };

static constexpr Register WasmIonExitRegCallee = { Registers::invalid_reg };
static constexpr Register WasmIonExitRegE0 = { Registers::invalid_reg };
static constexpr Register WasmIonExitRegE1 = { Registers::invalid_reg };

static constexpr Register WasmIonExitRegReturnData = { Registers::invalid_reg };
static constexpr Register WasmIonExitRegReturnType = { Registers::invalid_reg };
static constexpr Register WasmIonExitRegD0 = { Registers::invalid_reg };
static constexpr Register WasmIonExitRegD1 = { Registers::invalid_reg };
static constexpr Register WasmIonExitRegD2 = { Registers::invalid_reg };

static constexpr Register RegExpTesterRegExpReg = { Registers::invalid_reg };
static constexpr Register RegExpTesterStringReg = { Registers::invalid_reg };
static constexpr Register RegExpTesterLastIndexReg = { Registers::invalid_reg };
static constexpr Register RegExpTesterStickyReg = { Registers::invalid_reg };

static constexpr Register RegExpMatcherRegExpReg = { Registers::invalid_reg };
static constexpr Register RegExpMatcherStringReg = { Registers::invalid_reg };
static constexpr Register RegExpMatcherLastIndexReg = { Registers::invalid_reg };
static constexpr Register RegExpMatcherStickyReg = { Registers::invalid_reg };

static constexpr Register JSReturnReg_Type = { Registers::invalid_reg };
static constexpr Register JSReturnReg_Data = { Registers::invalid_reg };
static constexpr Register JSReturnReg = { Registers::invalid_reg };

#if defined(JS_NUNBOX32)
static constexpr ValueOperand JSReturnOperand(InvalidReg, InvalidReg);
static constexpr Register64 ReturnReg64(InvalidReg, InvalidReg);
#elif defined(JS_PUNBOX64)
static constexpr ValueOperand JSReturnOperand(InvalidReg);
static constexpr Register64 ReturnReg64(InvalidReg);
#else
#error "Bad architecture"
#endif

static constexpr Register ABINonArgReg0 = { Registers::invalid_reg };
static constexpr Register ABINonArgReg1 = { Registers::invalid_reg };
static constexpr Register ABINonArgReturnReg0 = { Registers::invalid_reg };
static constexpr Register ABINonArgReturnReg1 = { Registers::invalid_reg };

static constexpr Register WasmTableCallScratchReg = { Registers::invalid_reg };
static constexpr Register WasmTableCallSigReg = { Registers::invalid_reg };
static constexpr Register WasmTableCallIndexReg = { Registers::invalid_reg };
static constexpr Register WasmTlsReg = { Registers::invalid_reg };

static constexpr uint32_t ABIStackAlignment = 4;
static constexpr uint32_t CodeAlignment = 4;
static constexpr uint32_t JitStackAlignment = 8;
static constexpr uint32_t JitStackValueAlignment = JitStackAlignment / sizeof(Value);

static const Scale ScalePointer = TimesOne;

class Assembler : public AssemblerShared
{
  public:
    enum Condition {
        Equal,
        NotEqual,
        Above,
        AboveOrEqual,
        Below,
        BelowOrEqual,
        GreaterThan,
        GreaterThanOrEqual,
        LessThan,
        LessThanOrEqual,
        Overflow,
        CarrySet,
        CarryClear,
        Signed,
        NotSigned,
        Zero,
        NonZero,
        Always,
    };

    enum DoubleCondition {
        DoubleOrdered,
        DoubleEqual,
        DoubleNotEqual,
        DoubleGreaterThan,
        DoubleGreaterThanOrEqual,
        DoubleLessThan,
        DoubleLessThanOrEqual,
        DoubleUnordered,
        DoubleEqualOrUnordered,
        DoubleNotEqualOrUnordered,
        DoubleGreaterThanOrUnordered,
        DoubleGreaterThanOrEqualOrUnordered,
        DoubleLessThanOrUnordered,
        DoubleLessThanOrEqualOrUnordered
    };

    static Condition InvertCondition(Condition) { MOZ_CRASH(); }

    template <typename T, typename S>
    static void PatchDataWithValueCheck(CodeLocationLabel, T, S) { MOZ_CRASH(); }
    static void PatchWrite_Imm32(CodeLocationLabel, Imm32) { MOZ_CRASH(); }

    static void PatchWrite_NearCall(CodeLocationLabel, CodeLocationLabel) { MOZ_CRASH(); }
    static uint32_t PatchWrite_NearCallSize() { MOZ_CRASH(); }
    static void PatchInstructionImmediate(uint8_t*, PatchedImmPtr) { MOZ_CRASH(); }

    static void ToggleToJmp(CodeLocationLabel) { MOZ_CRASH(); }
    static void ToggleToCmp(CodeLocationLabel) { MOZ_CRASH(); }
    static void ToggleCall(CodeLocationLabel, bool) { MOZ_CRASH(); }

    static uintptr_t GetPointer(uint8_t*) { MOZ_CRASH(); }

    void verifyHeapAccessDisassembly(uint32_t begin, uint32_t end,
                                     const Disassembler::HeapAccess& heapAccess)
    {
        MOZ_CRASH();
    }
};

class Operand
{
  public:
    Operand (const Address&) { MOZ_CRASH();}
    Operand (const Register) { MOZ_CRASH();}
    Operand (const FloatRegister) { MOZ_CRASH();}
    Operand (Register, Imm32 ) { MOZ_CRASH(); }
    Operand (Register, int32_t ) { MOZ_CRASH(); }
};

class MacroAssemblerNone : public Assembler
{
  public:
    MacroAssemblerNone() { MOZ_CRASH(); }

    MoveResolver moveResolver_;

    size_t size() const { MOZ_CRASH(); }
    size_t bytesNeeded() const { MOZ_CRASH(); }
    size_t jumpRelocationTableBytes() const { MOZ_CRASH(); }
    size_t dataRelocationTableBytes() const { MOZ_CRASH(); }
    size_t preBarrierTableBytes() const { MOZ_CRASH(); }

    size_t numCodeLabels() const { MOZ_CRASH(); }
    CodeLabel codeLabel(size_t) { MOZ_CRASH(); }

    bool asmMergeWith(const MacroAssemblerNone&) { MOZ_CRASH(); }

    void trace(JSTracer*) { MOZ_CRASH(); }
    static void TraceJumpRelocations(JSTracer*, JitCode*, CompactBufferReader&) { MOZ_CRASH(); }
    static void TraceDataRelocations(JSTracer*, JitCode*, CompactBufferReader&) { MOZ_CRASH(); }

    static bool SupportsFloatingPoint() { return false; }
    static bool SupportsSimd() { return false; }
    static bool SupportsUnalignedAccesses() { return false; }

    void executableCopy(void*) { MOZ_CRASH(); }
    void copyJumpRelocationTable(uint8_t*) { MOZ_CRASH(); }
    void copyDataRelocationTable(uint8_t*) { MOZ_CRASH(); }
    void copyPreBarrierTable(uint8_t*) { MOZ_CRASH(); }
    void processCodeLabels(uint8_t*) { MOZ_CRASH(); }

    void flushBuffer() { MOZ_CRASH(); }

    template <typename T> void bind(T) { MOZ_CRASH(); }
    void bindLater(Label*, wasm::TrapDesc) { MOZ_CRASH(); }
    template <typename T> void j(Condition, T) { MOZ_CRASH(); }
    template <typename T> void jump(T) { MOZ_CRASH(); }
    void haltingAlign(size_t) { MOZ_CRASH(); }
    void nopAlign(size_t) { MOZ_CRASH(); }
    void checkStackAlignment() { MOZ_CRASH(); }
    uint32_t currentOffset() { MOZ_CRASH(); }
    uint32_t labelToPatchOffset(CodeOffset) { MOZ_CRASH(); }
    CodeOffset labelForPatch() { MOZ_CRASH(); }

    void nop() { MOZ_CRASH(); }
    void breakpoint() { MOZ_CRASH(); }
    void abiret() { MOZ_CRASH(); }
    void ret() { MOZ_CRASH(); }

    CodeOffset toggledJump(Label*) { MOZ_CRASH(); }
    CodeOffset toggledCall(JitCode*, bool) { MOZ_CRASH(); }
    static size_t ToggledCallSize(uint8_t*) { MOZ_CRASH(); }

    void writePrebarrierOffset(CodeOffset) { MOZ_CRASH(); }

    void finish() { MOZ_CRASH(); }

    template <typename T, typename S> void moveValue(T, S) { MOZ_CRASH(); }
    template <typename T, typename S, typename U> void moveValue(T, S, U) { MOZ_CRASH(); }
    template <typename T, typename S> void storeValue(T, S) { MOZ_CRASH(); }
    template <typename T, typename S, typename U> void storeValue(T, S, U) { MOZ_CRASH(); }
    template <typename T, typename S> void loadValue(T, S) { MOZ_CRASH(); }
    template <typename T> void pushValue(T) { MOZ_CRASH(); }
    template <typename T, typename S> void pushValue(T, S) { MOZ_CRASH(); }
    void popValue(ValueOperand) { MOZ_CRASH(); }
    void tagValue(JSValueType, Register, ValueOperand) { MOZ_CRASH(); }
    void retn(Imm32 n) { MOZ_CRASH(); }
    template <typename T> void push(T) { MOZ_CRASH(); }
    template <typename T> void Push(T) { MOZ_CRASH(); }
    template <typename T> void pop(T) { MOZ_CRASH(); }
    template <typename T> void Pop(T) { MOZ_CRASH(); }
    template <typename T> CodeOffset pushWithPatch(T) { MOZ_CRASH(); }

    CodeOffsetJump jumpWithPatch(RepatchLabel*, Label* doc = nullptr) { MOZ_CRASH(); }
    CodeOffsetJump jumpWithPatch(RepatchLabel*, Condition, Label* doc = nullptr) { MOZ_CRASH(); }
    CodeOffsetJump backedgeJump(RepatchLabel* label, Label* doc = nullptr) { MOZ_CRASH(); }

    void testNullSet(Condition, ValueOperand, Register) { MOZ_CRASH(); }
    void testObjectSet(Condition, ValueOperand, Register) { MOZ_CRASH(); }
    void testUndefinedSet(Condition, ValueOperand, Register) { MOZ_CRASH(); }

    template <typename T, typename S> void cmpPtrSet(Condition, T, S, Register) { MOZ_CRASH(); }
    template <typename T, typename S> void cmp32Set(Condition, T, S, Register) { MOZ_CRASH(); }

    template <typename T, typename S> void mov(T, S) { MOZ_CRASH(); }
    template <typename T, typename S> void movq(T, S) { MOZ_CRASH(); }
    template <typename T, typename S> void movePtr(T, S) { MOZ_CRASH(); }
    template <typename T, typename S> void move32(T, S) { MOZ_CRASH(); }
    template <typename T, typename S> void moveFloat32(T, S) { MOZ_CRASH(); }
    template <typename T, typename S> void moveDouble(T, S) { MOZ_CRASH(); }
    template <typename T, typename S> void move64(T, S) { MOZ_CRASH(); }
    template <typename T> CodeOffset movWithPatch(T, Register) { MOZ_CRASH(); }

    template <typename T> void loadInt32x1(T, FloatRegister dest) { MOZ_CRASH(); }
    template <typename T> void loadInt32x2(T, FloatRegister dest) { MOZ_CRASH(); }
    template <typename T> void loadInt32x3(T, FloatRegister dest) { MOZ_CRASH(); }
    template <typename T> void loadFloat32x3(T, FloatRegister dest) { MOZ_CRASH(); }

    template <typename T> void loadPtr(T, Register) { MOZ_CRASH(); }
    template <typename T> void load32(T, Register) { MOZ_CRASH(); }
    template <typename T> void loadFloat32(T, FloatRegister) { MOZ_CRASH(); }
    template <typename T> void loadDouble(T, FloatRegister) { MOZ_CRASH(); }
    template <typename T> void loadAlignedSimd128Int(T, FloatRegister) { MOZ_CRASH(); }
    template <typename T> void loadUnalignedSimd128Int(T, FloatRegister) { MOZ_CRASH(); }
    template <typename T> void loadAlignedSimd128Float(T, FloatRegister) { MOZ_CRASH(); }
    template <typename T> void loadUnalignedSimd128Float(T, FloatRegister) { MOZ_CRASH(); }
    template <typename T> void loadPrivate(T, Register) { MOZ_CRASH(); }
    template <typename T> void load8SignExtend(T, Register) { MOZ_CRASH(); }
    template <typename T> void load8ZeroExtend(T, Register) { MOZ_CRASH(); }
    template <typename T> void load16SignExtend(T, Register) { MOZ_CRASH(); }
    template <typename T> void load16ZeroExtend(T, Register) { MOZ_CRASH(); }
    template <typename T> void load64(T, Register64 ) { MOZ_CRASH(); }

    template <typename T, typename S> void storePtr(T, S) { MOZ_CRASH(); }
    template <typename T, typename S> void store32(T, S) { MOZ_CRASH(); }
    template <typename T, typename S> void store32_NoSecondScratch(T, S) { MOZ_CRASH(); }
    template <typename T, typename S> void storeFloat32(T, S) { MOZ_CRASH(); }
    template <typename T, typename S> void storeDouble(T, S) { MOZ_CRASH(); }
    template <typename T, typename S> void storeAlignedSimd128Int(T, S) { MOZ_CRASH(); }
    template <typename T, typename S> void storeUnalignedSimd128Int(T, S) { MOZ_CRASH(); }
    template <typename T, typename S> void storeAlignedSimd128Float(T, S) { MOZ_CRASH(); }
    template <typename T, typename S> void storeUnalignedSimd128Float(T, S) { MOZ_CRASH(); }
    template <typename T, typename S> void store8(T, S) { MOZ_CRASH(); }
    template <typename T, typename S> void store16(T, S) { MOZ_CRASH(); }
    template <typename T, typename S> void storeInt32x1(T, S) { MOZ_CRASH(); }
    template <typename T, typename S> void storeInt32x2(T, S) { MOZ_CRASH(); }
    template <typename T, typename S> void storeInt32x3(T, S) { MOZ_CRASH(); }
    template <typename T, typename S> void storeFloat32x3(T, S) { MOZ_CRASH(); }
    template <typename T, typename S> void store64(T, S) { MOZ_CRASH(); }

    template <typename T> void computeEffectiveAddress(T, Register) { MOZ_CRASH(); }

    template <typename T> void compareExchange8SignExtend(const T& mem, Register oldval, Register newval, Register output) { MOZ_CRASH(); }
    template <typename T> void compareExchange8ZeroExtend(const T& mem, Register oldval, Register newval, Register output) { MOZ_CRASH(); }
    template <typename T> void compareExchange16SignExtend(const T& mem, Register oldval, Register newval, Register output) { MOZ_CRASH(); }
    template <typename T> void compareExchange16ZeroExtend(const T& mem, Register oldval, Register newval, Register output) { MOZ_CRASH(); }
    template <typename T> void compareExchange32(const T& mem, Register oldval, Register newval, Register output) { MOZ_CRASH(); }
    template<typename T> void atomicExchange8SignExtend(const T& mem, Register value, Register output) { MOZ_CRASH(); }
    template<typename T> void atomicExchange8ZeroExtend(const T& mem, Register value, Register output) { MOZ_CRASH(); }
    template<typename T> void atomicExchange16SignExtend(const T& mem, Register value, Register output) { MOZ_CRASH(); }
    template<typename T> void atomicExchange16ZeroExtend(const T& mem, Register value, Register output) { MOZ_CRASH(); }
    template<typename T> void atomicExchange32(const T& mem, Register value, Register output) { MOZ_CRASH(); }
    template <typename T, typename S> void atomicFetchAdd8SignExtend(const T& value, const S& mem, Register temp, Register output) { MOZ_CRASH(); }
    template <typename T, typename S> void atomicFetchAdd8ZeroExtend(const T& value, const S& mem, Register temp, Register output) { MOZ_CRASH(); }
    template <typename T, typename S> void atomicFetchAdd16SignExtend(const T& value, const S& mem, Register temp, Register output) { MOZ_CRASH(); }
    template <typename T, typename S> void atomicFetchAdd16ZeroExtend(const T& value, const S& mem, Register temp, Register output) { MOZ_CRASH(); }
    template <typename T, typename S> void atomicFetchAdd32(const T& value, const S& mem, Register temp, Register output) { MOZ_CRASH(); }
    template <typename T, typename S> void atomicAdd8(const T& value, const S& mem) { MOZ_CRASH(); }
    template <typename T, typename S> void atomicAdd16(const T& value, const S& mem) { MOZ_CRASH(); }
    template <typename T, typename S> void atomicAdd32(const T& value, const S& mem) { MOZ_CRASH(); }
    template <typename T, typename S> void atomicFetchSub8SignExtend(const T& value, const S& mem, Register temp, Register output) { MOZ_CRASH(); }
    template <typename T, typename S> void atomicFetchSub8ZeroExtend(const T& value, const S& mem, Register temp, Register output) { MOZ_CRASH(); }
    template <typename T, typename S> void atomicFetchSub16SignExtend(const T& value, const S& mem, Register temp, Register output) { MOZ_CRASH(); }
    template <typename T, typename S> void atomicFetchSub16ZeroExtend(const T& value, const S& mem, Register temp, Register output) { MOZ_CRASH(); }
    template <typename T, typename S> void atomicFetchSub32(const T& value, const S& mem, Register temp, Register output) { MOZ_CRASH(); }
    template <typename T, typename S> void atomicSub8(const T& value, const S& mem) { MOZ_CRASH(); }
    template <typename T, typename S> void atomicSub16(const T& value, const S& mem) { MOZ_CRASH(); }
    template <typename T, typename S> void atomicSub32(const T& value, const S& mem) { MOZ_CRASH(); }
    template <typename T, typename S> void atomicFetchAnd8SignExtend(const T& value, const S& mem, Register temp, Register output) { MOZ_CRASH(); }
    template <typename T, typename S> void atomicFetchAnd8ZeroExtend(const T& value, const S& mem, Register temp, Register output) { MOZ_CRASH(); }
    template <typename T, typename S> void atomicFetchAnd16SignExtend(const T& value, const S& mem, Register temp, Register output) { MOZ_CRASH(); }
    template <typename T, typename S> void atomicFetchAnd16ZeroExtend(const T& value, const S& mem, Register temp, Register output) { MOZ_CRASH(); }
    template <typename T, typename S> void atomicFetchAnd32(const T& value, const S& mem, Register temp, Register output) { MOZ_CRASH(); }
    template <typename T, typename S> void atomicAnd8(const T& value, const S& mem) { MOZ_CRASH(); }
    template <typename T, typename S> void atomicAnd16(const T& value, const S& mem) { MOZ_CRASH(); }
    template <typename T, typename S> void atomicAnd32(const T& value, const S& mem) { MOZ_CRASH(); }
    template <typename T, typename S> void atomicFetchOr8SignExtend(const T& value, const S& mem, Register temp, Register output) { MOZ_CRASH(); }
    template <typename T, typename S> void atomicFetchOr8ZeroExtend(const T& value, const S& mem, Register temp, Register output) { MOZ_CRASH(); }
    template <typename T, typename S> void atomicFetchOr16SignExtend(const T& value, const S& mem, Register temp, Register output) { MOZ_CRASH(); }
    template <typename T, typename S> void atomicFetchOr16ZeroExtend(const T& value, const S& mem, Register temp, Register output) { MOZ_CRASH(); }
    template <typename T, typename S> void atomicFetchOr32(const T& value, const S& mem, Register temp, Register output) { MOZ_CRASH(); }
    template <typename T, typename S> void atomicOr8(const T& value, const S& mem) { MOZ_CRASH(); }
    template <typename T, typename S> void atomicOr16(const T& value, const S& mem) { MOZ_CRASH(); }
    template <typename T, typename S> void atomicOr32(const T& value, const S& mem) { MOZ_CRASH(); }
    template <typename T, typename S> void atomicFetchXor8SignExtend(const T& value, const S& mem, Register temp, Register output) { MOZ_CRASH(); }
    template <typename T, typename S> void atomicFetchXor8ZeroExtend(const T& value, const S& mem, Register temp, Register output) { MOZ_CRASH(); }
    template <typename T, typename S> void atomicFetchXor16SignExtend(const T& value, const S& mem, Register temp, Register output) { MOZ_CRASH(); }
    template <typename T, typename S> void atomicFetchXor16ZeroExtend(const T& value, const S& mem, Register temp, Register output) { MOZ_CRASH(); }
    template <typename T, typename S> void atomicFetchXor32(const T& value, const S& mem, Register temp, Register output) { MOZ_CRASH(); }
    template <typename T, typename S> void atomicXor8(const T& value, const S& mem) { MOZ_CRASH(); }
    template <typename T, typename S> void atomicXor16(const T& value, const S& mem) { MOZ_CRASH(); }
    template <typename T, typename S> void atomicXor32(const T& value, const S& mem) { MOZ_CRASH(); }

    Register splitTagForTest(ValueOperand) { MOZ_CRASH(); }

    void boxDouble(FloatRegister, ValueOperand) { MOZ_CRASH(); }
    void boxNonDouble(JSValueType, Register, ValueOperand) { MOZ_CRASH(); }
    template <typename T> void unboxInt32(T, Register) { MOZ_CRASH(); }
    template <typename T> void unboxBoolean(T, Register) { MOZ_CRASH(); }
    template <typename T> void unboxString(T, Register) { MOZ_CRASH(); }
    template <typename T> void unboxSymbol(T, Register) { MOZ_CRASH(); }
    template <typename T> void unboxObject(T, Register) { MOZ_CRASH(); }
    template <typename T> void unboxDouble(T, FloatRegister) { MOZ_CRASH(); }
    void unboxValue(const ValueOperand&, AnyRegister) { MOZ_CRASH(); }
    void unboxNonDouble(const ValueOperand&, Register ) { MOZ_CRASH();}
    void notBoolean(ValueOperand) { MOZ_CRASH(); }
    Register extractObject(Address, Register) { MOZ_CRASH(); }
    Register extractObject(ValueOperand, Register) { MOZ_CRASH(); }
    Register extractInt32(ValueOperand, Register) { MOZ_CRASH(); }
    Register extractBoolean(ValueOperand, Register) { MOZ_CRASH(); }
    template <typename T> Register extractTag(T, Register) { MOZ_CRASH(); }

    void convertFloat32ToInt32(FloatRegister, Register, Label*, bool v = true) { MOZ_CRASH(); }
    void convertDoubleToInt32(FloatRegister, Register, Label*, bool v = true) { MOZ_CRASH(); }
    void convertBoolToInt32(Register, Register) { MOZ_CRASH(); }

    void convertDoubleToFloat32(FloatRegister, FloatRegister) { MOZ_CRASH(); }
    void convertInt32ToFloat32(Register, FloatRegister) { MOZ_CRASH(); }

    template <typename T> void convertInt32ToDouble(T, FloatRegister) { MOZ_CRASH(); }
    void convertFloat32ToDouble(FloatRegister, FloatRegister) { MOZ_CRASH(); }
    static bool convertUInt64ToDoubleNeedsTemp() { MOZ_CRASH(); }
    void convertUInt64ToDouble(Register64, FloatRegister, Register) { MOZ_CRASH(); }

    void boolValueToDouble(ValueOperand, FloatRegister) { MOZ_CRASH(); }
    void boolValueToFloat32(ValueOperand, FloatRegister) { MOZ_CRASH(); }
    void int32ValueToDouble(ValueOperand, FloatRegister) { MOZ_CRASH(); }
    void int32ValueToFloat32(ValueOperand, FloatRegister) { MOZ_CRASH(); }

    void loadConstantDouble(double, FloatRegister) { MOZ_CRASH(); }
    void loadConstantFloat32(float, FloatRegister) { MOZ_CRASH(); }
    void loadConstantDouble(wasm::RawF64, FloatRegister) { MOZ_CRASH(); }
    void loadConstantFloat32(wasm::RawF32, FloatRegister) { MOZ_CRASH(); }
    Condition testInt32Truthy(bool, ValueOperand) { MOZ_CRASH(); }
    Condition testStringTruthy(bool, ValueOperand) { MOZ_CRASH(); }

    template <typename T> void loadUnboxedValue(T, MIRType, AnyRegister) { MOZ_CRASH(); }
    template <typename T> void storeUnboxedValue(const ConstantOrRegister&, MIRType, T, MIRType) { MOZ_CRASH(); }
    template <typename T> void storeUnboxedPayload(ValueOperand value, T, size_t) { MOZ_CRASH(); }

    void convertUInt32ToDouble(Register, FloatRegister) { MOZ_CRASH(); }
    void convertUInt32ToFloat32(Register, FloatRegister) { MOZ_CRASH(); }
    void incrementInt32Value(Address) { MOZ_CRASH(); }
    void ensureDouble(ValueOperand, FloatRegister, Label*) { MOZ_CRASH(); }
    void handleFailureWithHandlerTail(void*) { MOZ_CRASH(); }

    void buildFakeExitFrame(Register, uint32_t*) { MOZ_CRASH(); }
    bool buildOOLFakeExitFrame(void*) { MOZ_CRASH(); }
    void loadWasmGlobalPtr(uint32_t, Register) { MOZ_CRASH(); }
    void loadWasmActivationFromTls(Register) { MOZ_CRASH(); }
    void loadWasmActivationFromSymbolicAddress(Register) { MOZ_CRASH(); }
    void loadWasmPinnedRegsFromTls() { MOZ_CRASH(); }

    void setPrinter(Sprinter*) { MOZ_CRASH(); }
    Operand ToPayload(Operand base) { MOZ_CRASH(); }

    static const Register getStackPointer() { MOZ_CRASH(); }

    // Instrumentation for entering and leaving the profiler.
    void profilerEnterFrame(Register , Register ) { MOZ_CRASH(); }
    void profilerExitFrame() { MOZ_CRASH(); }

#ifdef JS_NUNBOX32
    Address ToPayload(Address) { MOZ_CRASH(); }
    Address ToType(Address) { MOZ_CRASH(); }
#endif

    struct AutoPrepareForPatching {
        explicit AutoPrepareForPatching(MacroAssemblerNone&) {
            MOZ_CRASH();
        }
    };
};

typedef MacroAssemblerNone MacroAssemblerSpecific;

class ABIArgGenerator
{
  public:
    ABIArgGenerator() { MOZ_CRASH(); }
    ABIArg next(MIRType) { MOZ_CRASH(); }
    ABIArg& current() { MOZ_CRASH(); }
    uint32_t stackBytesConsumedSoFar() const { MOZ_CRASH(); }
};

static inline void
PatchJump(CodeLocationJump&, CodeLocationLabel, ReprotectCode reprotect = DontReprotect)
{
    MOZ_CRASH();
}

static inline bool GetTempRegForIntArg(uint32_t, uint32_t, Register*) { MOZ_CRASH(); }

static inline
void PatchBackedge(CodeLocationJump& jump_, CodeLocationLabel label, JitRuntime::BackedgeTarget target)
{
    MOZ_CRASH();
}

} // namespace jit
} // namespace js

#endif /* jit_none_MacroAssembler_none_h */