diff options
Diffstat (limited to 'js/src/jsapi-tests/testJitRValueAlloc.cpp')
| -rw-r--r-- | js/src/jsapi-tests/testJitRValueAlloc.cpp | 256 |
1 files changed, 256 insertions, 0 deletions
diff --git a/js/src/jsapi-tests/testJitRValueAlloc.cpp b/js/src/jsapi-tests/testJitRValueAlloc.cpp new file mode 100644 index 0000000000..27242b7652 --- /dev/null +++ b/js/src/jsapi-tests/testJitRValueAlloc.cpp @@ -0,0 +1,256 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- + * vim: set ts=8 sts=2 et sw=2 tw=80: + */ +/* 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); +} + +class Fibonacci { + class Iterator { + public: + // std::iterator traits. + using iterator_category = std::input_iterator_tag; + using value_type = int32_t; + using difference_type = int32_t; + using pointer = value_type*; + using reference = value_type&; + + private: + uint32_t value_{}; + uint32_t last_{}; + + Iterator() = default; + Iterator(value_type value, value_type last) : value_(value), last_(last) {} + + friend class Fibonacci; + + public: + Iterator& operator++() { + auto next = value_ + last_; + if (next <= static_cast<uint32_t>(INT32_MAX)) { + last_ = value_; + value_ = next; + } else { + *this = Iterator{}; + } + return *this; + } + + bool operator==(const Iterator& other) const { + return value_ == other.value_ && last_ == other.last_; + } + + bool operator!=(const Iterator& other) const { return !(*this == other); } + + auto operator*() const { return static_cast<int32_t>(value_); } + }; + + public: + auto begin() { return Iterator{0, 1}; } + + auto end() { return Iterator{}; } +}; + +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; + for (auto i : Fibonacci{}) { + 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_BIGINT) \ + /* _(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; + for (auto i : Fibonacci{}) { +#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_BIGINT) \ + /* _(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++) { + for (auto j : Fibonacci{}) { + s = RValueAllocation::Untyped(Register::FromCode(i), j); + CHECK(s == Read(s)); + } + } + return true; +} +END_TEST(testJitRValueAlloc_UntypedRegStack) + +BEGIN_TEST(testJitRValueAlloc_UntypedStackReg) { + RValueAllocation s; + for (auto i : Fibonacci{}) { + 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; + for (auto i : Fibonacci{}) { + for (auto j : Fibonacci{}) { + 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; + for (auto i : Fibonacci{}) { + 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; + for (auto i : Fibonacci{}) { + s = RValueAllocation::ConstantPool(i); + CHECK(s == Read(s)); + } + return true; +} +END_TEST(testJitRValueAlloc_ConstantPool) |