summaryrefslogtreecommitdiffstats
path: root/js/src/jsapi-tests/testJitRValueAlloc.cpp
diff options
context:
space:
mode:
authorMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
committerMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
commit5f8de423f190bbb79a62f804151bc24824fa32d8 (patch)
tree10027f336435511475e392454359edea8e25895d /js/src/jsapi-tests/testJitRValueAlloc.cpp
parent49ee0794b5d912db1f95dce6eb52d781dc210db5 (diff)
downloadUXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.gz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.lz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.xz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.zip
Add m-esr52 at 52.6.0
Diffstat (limited to 'js/src/jsapi-tests/testJitRValueAlloc.cpp')
-rw-r--r--js/src/jsapi-tests/testJitRValueAlloc.cpp229
1 files changed, 229 insertions, 0 deletions
diff --git a/js/src/jsapi-tests/testJitRValueAlloc.cpp b/js/src/jsapi-tests/testJitRValueAlloc.cpp
new file mode 100644
index 000000000..b1f82547e
--- /dev/null
+++ b/js/src/jsapi-tests/testJitRValueAlloc.cpp
@@ -0,0 +1,229 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ * vim: set ts=8 sts=4 et sw=4 tw=99:
+ */
+/* 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/. */
+
+#include "jit/Snapshots.h"
+
+#include "jsapi-tests/tests.h"
+
+using namespace js;
+using namespace js::jit;
+
+// These tests are checking that all slots of the current architecture can all
+// be encoded and decoded correctly. We iterate on all registers and on many
+// fake stack locations (Fibonacci).
+static RValueAllocation
+Read(const RValueAllocation& slot)
+{
+ CompactBufferWriter writer;
+ slot.write(writer);
+
+ // Call hash to run its assertions.
+ slot.hash();
+
+ CompactBufferReader reader(writer);
+ return RValueAllocation::read(reader);
+}
+
+BEGIN_TEST(testJitRValueAlloc_Double)
+{
+ RValueAllocation s;
+ for (uint32_t i = 0; i < FloatRegisters::Total; i++) {
+ s = RValueAllocation::Double(FloatRegister::FromCode(i));
+ CHECK(s == Read(s));
+ }
+ return true;
+}
+END_TEST(testJitRValueAlloc_Double)
+
+BEGIN_TEST(testJitRValueAlloc_FloatReg)
+{
+ RValueAllocation s;
+ for (uint32_t i = 0; i < FloatRegisters::Total; i++) {
+ s = RValueAllocation::AnyFloat(FloatRegister::FromCode(i));
+ CHECK(s == Read(s));
+ }
+ return true;
+}
+END_TEST(testJitRValueAlloc_FloatReg)
+
+BEGIN_TEST(testJitRValueAlloc_FloatStack)
+{
+ RValueAllocation s;
+ int32_t i, last = 0, tmp;
+ for (i = 0; i > 0; tmp = i, i += last, last = tmp) {
+ s = RValueAllocation::AnyFloat(i);
+ CHECK(s == Read(s));
+ }
+ return true;
+}
+END_TEST(testJitRValueAlloc_FloatStack)
+
+BEGIN_TEST(testJitRValueAlloc_TypedReg)
+{
+ RValueAllocation s;
+ for (uint32_t i = 0; i < Registers::Total; i++) {
+#define FOR_EACH_JSVAL(_) \
+ /* _(JSVAL_TYPE_DOUBLE) */ \
+ _(JSVAL_TYPE_INT32) \
+ /* _(JSVAL_TYPE_UNDEFINED) */ \
+ _(JSVAL_TYPE_BOOLEAN) \
+ /* _(JSVAL_TYPE_MAGIC) */ \
+ _(JSVAL_TYPE_STRING) \
+ _(JSVAL_TYPE_SYMBOL) \
+ /* _(JSVAL_TYPE_NULL) */ \
+ _(JSVAL_TYPE_OBJECT)
+
+#define CHECK_WITH_JSVAL(jsval) \
+ s = RValueAllocation::Typed(jsval, Register::FromCode(i)); \
+ CHECK(s == Read(s));
+
+ FOR_EACH_JSVAL(CHECK_WITH_JSVAL)
+#undef CHECK_WITH_JSVAL
+#undef FOR_EACH_JSVAL
+ }
+ return true;
+}
+END_TEST(testJitRValueAlloc_TypedReg)
+
+BEGIN_TEST(testJitRValueAlloc_TypedStack)
+{
+ RValueAllocation s;
+ int32_t i, last = 0, tmp;
+ for (i = 0; i > 0; tmp = i, i += last, last = tmp) {
+#define FOR_EACH_JSVAL(_) \
+ _(JSVAL_TYPE_DOUBLE) \
+ _(JSVAL_TYPE_INT32) \
+ /* _(JSVAL_TYPE_UNDEFINED) */ \
+ _(JSVAL_TYPE_BOOLEAN) \
+ /* _(JSVAL_TYPE_MAGIC) */ \
+ _(JSVAL_TYPE_STRING) \
+ _(JSVAL_TYPE_SYMBOL) \
+ /* _(JSVAL_TYPE_NULL) */ \
+ _(JSVAL_TYPE_OBJECT)
+
+#define CHECK_WITH_JSVAL(jsval) \
+ s = RValueAllocation::Typed(jsval, i); \
+ CHECK(s == Read(s));
+
+ FOR_EACH_JSVAL(CHECK_WITH_JSVAL)
+#undef CHECK_WITH_JSVAL
+#undef FOR_EACH_JSVAL
+ }
+ return true;
+}
+END_TEST(testJitRValueAlloc_TypedStack)
+
+#if defined(JS_NUNBOX32)
+
+BEGIN_TEST(testJitRValueAlloc_UntypedRegReg)
+{
+ RValueAllocation s;
+ for (uint32_t i = 0; i < Registers::Total; i++) {
+ for (uint32_t j = 0; j < Registers::Total; j++) {
+ if (i == j)
+ continue;
+ s = RValueAllocation::Untyped(Register::FromCode(i), Register::FromCode(j));
+ MOZ_ASSERT(s == Read(s));
+ CHECK(s == Read(s));
+ }
+ }
+ return true;
+}
+END_TEST(testJitRValueAlloc_UntypedRegReg)
+
+BEGIN_TEST(testJitRValueAlloc_UntypedRegStack)
+{
+ RValueAllocation s;
+ for (uint32_t i = 0; i < Registers::Total; i++) {
+ int32_t j, last = 0, tmp;
+ for (j = 0; j > 0; tmp = j, j += last, last = tmp) {
+ s = RValueAllocation::Untyped(Register::FromCode(i), j);
+ CHECK(s == Read(s));
+ }
+ }
+ return true;
+}
+END_TEST(testJitRValueAlloc_UntypedRegStack)
+
+BEGIN_TEST(testJitRValueAlloc_UntypedStackReg)
+{
+ RValueAllocation s;
+ int32_t i, last = 0, tmp;
+ for (i = 0; i > 0; tmp = i, i += last, last = tmp) {
+ for (uint32_t j = 0; j < Registers::Total; j++) {
+ s = RValueAllocation::Untyped(i, Register::FromCode(j));
+ CHECK(s == Read(s));
+ }
+ }
+ return true;
+}
+END_TEST(testJitRValueAlloc_UntypedStackReg)
+
+BEGIN_TEST(testJitRValueAlloc_UntypedStackStack)
+{
+ RValueAllocation s;
+ int32_t i, li = 0, ti;
+ for (i = 0; i > 0; ti = i, i += li, li = ti) {
+ int32_t j, lj = 0, tj;
+ for (j = 0; j > 0; tj = j, j += lj, lj = tj) {
+ s = RValueAllocation::Untyped(i, j);
+ CHECK(s == Read(s));
+ }
+ }
+ return true;
+}
+END_TEST(testJitRValueAlloc_UntypedStackStack)
+
+#else
+
+BEGIN_TEST(testJitRValueAlloc_UntypedReg)
+{
+ RValueAllocation s;
+ for (uint32_t i = 0; i < Registers::Total; i++) {
+ s = RValueAllocation::Untyped(Register::FromCode(i));
+ CHECK(s == Read(s));
+ }
+ return true;
+}
+END_TEST(testJitRValueAlloc_UntypedReg)
+
+BEGIN_TEST(testJitRValueAlloc_UntypedStack)
+{
+ RValueAllocation s;
+ int32_t i, last = 0, tmp;
+ for (i = 0; i > 0; tmp = i, i += last, last = tmp) {
+ s = RValueAllocation::Untyped(i);
+ CHECK(s == Read(s));
+ }
+ return true;
+}
+END_TEST(testJitRValueAlloc_UntypedStack)
+
+#endif
+
+BEGIN_TEST(testJitRValueAlloc_UndefinedAndNull)
+{
+ RValueAllocation s;
+ s = RValueAllocation::Undefined();
+ CHECK(s == Read(s));
+ s = RValueAllocation::Null();
+ CHECK(s == Read(s));
+ return true;
+}
+END_TEST(testJitRValueAlloc_UndefinedAndNull)
+
+BEGIN_TEST(testJitRValueAlloc_ConstantPool)
+{
+ RValueAllocation s;
+ int32_t i, last = 0, tmp;
+ for (i = 0; i > 0; tmp = i, i += last, last = tmp) {
+ s = RValueAllocation::ConstantPool(i);
+ CHECK(s == Read(s));
+ }
+ return true;
+}
+END_TEST(testJitRValueAlloc_ConstantPool)