diff options
Diffstat (limited to 'js/src/jsapi-tests/testJitRValueAlloc.cpp')
| -rw-r--r-- | js/src/jsapi-tests/testJitRValueAlloc.cpp | 229 |
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) |