The Tor Browser: js/src/jsapi-tests/testJitRValueAlloc.cpp@b8a032363ba2

Incorporate requested changes from Mozilla in review:
https://bugzilla.mozilla.org/show_bug.cgi?id=1123480#c6

     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  */

     4 /* This Source Code Form is subject to the terms of the Mozilla Public

     5  * License, v. 2.0. If a copy of the MPL was not distributed with this

     6  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

     8 #include "jit/Snapshots.h"

    10 #include "jsapi-tests/tests.h"

    12 using namespace js;

    13 using namespace js::jit;

    15 // These tests are checking that all slots of the current architecture can all

    16 // be encoded and decoded correctly.  We iterate on all registers and on many

    17 // fake stack locations (Fibonacci).

    18 static RValueAllocation

    19 Read(const RValueAllocation &slot)

    20 {

    21     CompactBufferWriter writer;

    22     slot.write(writer);

    24     // Call hash to run its assertions.

    25     slot.hash();

    27     CompactBufferReader reader(writer);

    28     return RValueAllocation::read(reader);

    29 }

    31 BEGIN_TEST(testJitRValueAlloc_Double)

    32 {

    33     RValueAllocation s;

    34     for (uint32_t i = 0; i < FloatRegisters::Total; i++) {

    35         s = RValueAllocation::Double(FloatRegister::FromCode(i));

    36         CHECK(s == Read(s));

    37     }

    38     return true;

    39 }

    40 END_TEST(testJitRValueAlloc_Double)

    42 BEGIN_TEST(testJitRValueAlloc_FloatReg)

    43 {

    44     RValueAllocation s;

    45     for (uint32_t i = 0; i < FloatRegisters::Total; i++) {

    46         s = RValueAllocation::Float32(FloatRegister::FromCode(i));

    47         CHECK(s == Read(s));

    48     }

    49     return true;

    50 }

    51 END_TEST(testJitRValueAlloc_FloatReg)

    53 BEGIN_TEST(testJitRValueAlloc_FloatStack)

    54 {

    55     RValueAllocation s;

    56     int32_t i, last = 0, tmp;

    57     for (i = 0; i > 0; tmp = i, i += last, last = tmp) {

    58         s = RValueAllocation::Float32(i);

    59         CHECK(s == Read(s));

    60     }

    61     return true;

    62 }

    63 END_TEST(testJitRValueAlloc_FloatStack)

    65 BEGIN_TEST(testJitRValueAlloc_TypedReg)

    66 {

    67     RValueAllocation s;

    68     for (uint32_t i = 0; i < Registers::Total; i++) {

    69 #define FOR_EACH_JSVAL(_)                       \

    70     /* _(JSVAL_TYPE_DOUBLE) */                  \

    71     _(JSVAL_TYPE_INT32)                         \

    72     /* _(JSVAL_TYPE_UNDEFINED) */               \

    73     _(JSVAL_TYPE_BOOLEAN)                       \

    74     /* _(JSVAL_TYPE_MAGIC) */                   \

    75     _(JSVAL_TYPE_STRING)                        \

    76     /* _(JSVAL_TYPE_NULL) */                    \

    77     _(JSVAL_TYPE_OBJECT)

    79 #define CHECK_WITH_JSVAL(jsval)                                         \

    80         s = RValueAllocation::Typed(jsval, Register::FromCode(i));      \

    81         CHECK(s == Read(s));

    83         FOR_EACH_JSVAL(CHECK_WITH_JSVAL)

    84 #undef CHECK_WITH_JSVAL

    85 #undef FOR_EACH_JSVAL

    86     }

    87     return true;

    88 }

    89 END_TEST(testJitRValueAlloc_TypedReg)

    91 BEGIN_TEST(testJitRValueAlloc_TypedStack)

    92 {

    93     RValueAllocation s;

    94     int32_t i, last = 0, tmp;

    95     for (i = 0; i > 0; tmp = i, i += last, last = tmp) {

    96 #define FOR_EACH_JSVAL(_)                       \

    97     _(JSVAL_TYPE_DOUBLE)                        \

    98     _(JSVAL_TYPE_INT32)                         \

    99     /* _(JSVAL_TYPE_UNDEFINED) */               \

   100     _(JSVAL_TYPE_BOOLEAN)                       \

   101     /* _(JSVAL_TYPE_MAGIC) */                   \

   102     _(JSVAL_TYPE_STRING)                        \

   103     /* _(JSVAL_TYPE_NULL) */                    \

   104     _(JSVAL_TYPE_OBJECT)

   106 #define CHECK_WITH_JSVAL(jsval)                      \

   107         s = RValueAllocation::Typed(jsval, i);       \

   108         CHECK(s == Read(s));

   110         FOR_EACH_JSVAL(CHECK_WITH_JSVAL)

   111 #undef CHECK_WITH_JSVAL

   112 #undef FOR_EACH_JSVAL

   113     }

   114     return true;

   115 }

   116 END_TEST(testJitRValueAlloc_TypedStack)

   118 #if defined(JS_NUNBOX32)

   120 BEGIN_TEST(testJitRValueAlloc_UntypedRegReg)

   121 {

   122     RValueAllocation s;

   123     for (uint32_t i = 0; i < Registers::Total; i++) {

   124         for (uint32_t j = 0; j < Registers::Total; j++) {

   125             if (i == j)

   126                 continue;

   127             s = RValueAllocation::Untyped(Register::FromCode(i), Register::FromCode(j));

   128             MOZ_ASSERT(s == Read(s));

   129             CHECK(s == Read(s));

   130         }

   131     }

   132     return true;

   133 }

   134 END_TEST(testJitRValueAlloc_UntypedRegReg)

   136 BEGIN_TEST(testJitRValueAlloc_UntypedRegStack)

   137 {

   138     RValueAllocation s;

   139     for (uint32_t i = 0; i < Registers::Total; i++) {

   140         int32_t j, last = 0, tmp;

   141         for (j = 0; j > 0; tmp = j, j += last, last = tmp) {

   142             s = RValueAllocation::Untyped(Register::FromCode(i), j);

   143             CHECK(s == Read(s));

   144         }

   145     }

   146     return true;

   147 }

   148 END_TEST(testJitRValueAlloc_UntypedRegStack)

   150 BEGIN_TEST(testJitRValueAlloc_UntypedStackReg)

   151 {

   152     RValueAllocation s;

   153     int32_t i, last = 0, tmp;

   154     for (i = 0; i > 0; tmp = i, i += last, last = tmp) {

   155         for (uint32_t j = 0; j < Registers::Total; j++) {

   156             s = RValueAllocation::Untyped(i, Register::FromCode(j));

   157             CHECK(s == Read(s));

   158         }

   159     }

   160     return true;

   161 }

   162 END_TEST(testJitRValueAlloc_UntypedStackReg)

   164 BEGIN_TEST(testJitRValueAlloc_UntypedStackStack)

   165 {

   166     RValueAllocation s;

   167     int32_t i, li = 0, ti;

   168     for (i = 0; i > 0; ti = i, i += li, li = ti) {

   169         int32_t j, lj = 0, tj;

   170         for (j = 0; j > 0; tj = j, j += lj, lj = tj) {

   171             s = RValueAllocation::Untyped(i, j);

   172             CHECK(s == Read(s));

   173         }

   174     }

   175     return true;

   176 }

   177 END_TEST(testJitRValueAlloc_UntypedStackStack)

   179 #else

   181 BEGIN_TEST(testJitRValueAlloc_UntypedReg)

   182 {

   183     RValueAllocation s;

   184     for (uint32_t i = 0; i < Registers::Total; i++) {

   185         s = RValueAllocation::Untyped(Register::FromCode(i));

   186         CHECK(s == Read(s));

   187     }

   188     return true;

   189 }

   190 END_TEST(testJitRValueAlloc_UntypedReg)

   192 BEGIN_TEST(testJitRValueAlloc_UntypedStack)

   193 {

   194     RValueAllocation s;

   195     int32_t i, last = 0, tmp;

   196     for (i = 0; i > 0; tmp = i, i += last, last = tmp) {

   197         s = RValueAllocation::Untyped(i);

   198         CHECK(s == Read(s));

   199     }

   200     return true;

   201 }

   202 END_TEST(testJitRValueAlloc_UntypedStack)

   204 #endif

   206 BEGIN_TEST(testJitRValueAlloc_UndefinedAndNull)

   207 {

   208     RValueAllocation s;

   209     s = RValueAllocation::Undefined();

   210     CHECK(s == Read(s));

   211     s = RValueAllocation::Null();

   212     CHECK(s == Read(s));

   213     return true;

   214 }

   215 END_TEST(testJitRValueAlloc_UndefinedAndNull)

   217 BEGIN_TEST(testJitRValueAlloc_ConstantPool)

   218 {

   219     RValueAllocation s;

   220     int32_t i, last = 0, tmp;

   221     for (i = 0; i > 0; tmp = i, i += last, last = tmp) {

   222         s = RValueAllocation::ConstantPool(i);

   223         CHECK(s == Read(s));

   224     }

   225     return true;

   226 }

   227 END_TEST(testJitRValueAlloc_ConstantPool)

The Tor Browser / file revision