tor-browser

The Tor Browser
git clone https://git.dasho.dev/tor-browser.git
Log | Files | Refs | README | LICENSE

MacroAssembler-none.h (13181B)

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