The Tor Browser / file comparison
comparison: js/src/jsapi-tests/testJitRValueAlloc.cpp
js/src/jsapi-tests/testJitRValueAlloc.cpp
- branch
- TOR_BUG_3246
- changeset 7
- 129ffea94266
equal
deleted
inserted
replaced
| -1:000000000000 | 0:dc35eda67a0d |
|---|---|
| 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/. */ | |
| 7 | |
| 8 #include "jit/Snapshots.h" | |
| 9 | |
| 10 #include "jsapi-tests/tests.h" | |
| 11 | |
| 12 using namespace js; | |
| 13 using namespace js::jit; | |
| 14 | |
| 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); | |
| 23 | |
| 24 // Call hash to run its assertions. | |
| 25 slot.hash(); | |
| 26 | |
| 27 CompactBufferReader reader(writer); | |
| 28 return RValueAllocation::read(reader); | |
| 29 } | |
| 30 | |
| 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) | |
| 41 | |
| 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) | |
| 52 | |
| 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) | |
| 64 | |
| 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) | |
| 78 | |
| 79 #define CHECK_WITH_JSVAL(jsval) \ | |
| 80 s = RValueAllocation::Typed(jsval, Register::FromCode(i)); \ | |
| 81 CHECK(s == Read(s)); | |
| 82 | |
| 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) | |
| 90 | |
| 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) | |
| 105 | |
| 106 #define CHECK_WITH_JSVAL(jsval) \ | |
| 107 s = RValueAllocation::Typed(jsval, i); \ | |
| 108 CHECK(s == Read(s)); | |
| 109 | |
| 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) | |
| 117 | |
| 118 #if defined(JS_NUNBOX32) | |
| 119 | |
| 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) | |
| 135 | |
| 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) | |
| 149 | |
| 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) | |
| 163 | |
| 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) | |
| 178 | |
| 179 #else | |
| 180 | |
| 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) | |
| 191 | |
| 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) | |
| 203 | |
| 204 #endif | |
| 205 | |
| 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) | |
| 216 | |
| 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) |
