Source code

Revision control

Other Tools

/* -*- 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/RegisterSets.h"
#include "jsapi-tests/tests.h"
using namespace js;
using namespace js::jit;
static bool CoPrime(size_t a, size_t b) {
if (b <= 1) {
return a == 1 || b == 1;
}
return CoPrime(b, a % b);
}
// This macros are use to iterave over all registers in a large number of
// non-looping sequences, which does not rely on the getFirst / getLast
// functions.
#define BEGIN_INDEX_WALK(RegTotal) \
static const size_t Total = RegTotal; \
for (size_t walk = 1; walk < RegTotal; walk += 2) { \
if (!CoPrime(RegTotal, walk)) continue; \
for (size_t start = 0; start < RegTotal; start++) { \
size_t index = start;
#define END_INDEX_WALK \
} \
}
#define BEGIN_All_WALK(RegTotal) \
static const size_t Total = RegTotal; \
size_t walk = 1; \
size_t start = 0; \
size_t index = start;
#define FOR_ALL_REGISTERS(Register, reg) \
do { \
Register reg = Register::FromCode(index);
#define END_FOR_ALL_REGISTERS \
index = (index + walk) % Total; \
} \
while (index != start)
BEGIN_TEST(testJitRegisterSet_GPR) {
BEGIN_INDEX_WALK(Registers::Total)
LiveGeneralRegisterSet liveRegs;
AllocatableGeneralRegisterSet pool(GeneralRegisterSet::All());
CHECK(liveRegs.empty());
CHECK(pool.set() == GeneralRegisterSet::All());
FOR_ALL_REGISTERS(Register, reg) {
CHECK(!pool.has(reg) || !liveRegs.has(reg));
if (pool.has(reg)) {
CHECK(!liveRegs.has(reg));
pool.take(reg);
liveRegs.add(reg);
CHECK(liveRegs.has(reg));
CHECK(!pool.has(reg));
}
CHECK(!pool.has(reg) || !liveRegs.has(reg));
}
END_FOR_ALL_REGISTERS;
CHECK(pool.empty());
FOR_ALL_REGISTERS(Register, reg) {
CHECK(!pool.has(reg) || !liveRegs.has(reg));
if (liveRegs.has(reg)) {
CHECK(!pool.has(reg));
liveRegs.take(reg);
pool.add(reg);
CHECK(pool.has(reg));
CHECK(!liveRegs.has(reg));
}
CHECK(!pool.has(reg) || !liveRegs.has(reg));
}
END_FOR_ALL_REGISTERS;
CHECK(liveRegs.empty());
CHECK(pool.set() == GeneralRegisterSet::All());
END_INDEX_WALK
return true;
}
END_TEST(testJitRegisterSet_GPR)
BEGIN_TEST(testJitRegisterSet_FPU) {
BEGIN_INDEX_WALK(FloatRegisters::Total)
LiveFloatRegisterSet liveRegs;
AllocatableFloatRegisterSet pool(FloatRegisterSet::All());
CHECK(liveRegs.empty());
CHECK(pool.set() == FloatRegisterSet::All());
FOR_ALL_REGISTERS(FloatRegister, reg) {
CHECK(!pool.has(reg) || !liveRegs.has(reg));
if (pool.has(reg)) {
CHECK(!liveRegs.has(reg));
pool.take(reg);
liveRegs.add(reg);
CHECK(liveRegs.has(reg));
CHECK(!pool.has(reg));
}
CHECK(!pool.has(reg) || !liveRegs.has(reg));
}
END_FOR_ALL_REGISTERS;
CHECK(pool.empty());
FOR_ALL_REGISTERS(FloatRegister, reg) {
CHECK(!pool.has(reg) || !liveRegs.has(reg));
if (liveRegs.has(reg)) {
CHECK(!pool.has(reg));
liveRegs.take(reg);
pool.add(reg);
CHECK(pool.has(reg));
CHECK(!liveRegs.has(reg));
}
CHECK(!pool.has(reg) || !liveRegs.has(reg));
}
END_FOR_ALL_REGISTERS;
CHECK(liveRegs.empty());
CHECK(pool.set() == FloatRegisterSet::All());
END_INDEX_WALK
return true;
}
END_TEST(testJitRegisterSet_FPU)
void pullAllFpus(AllocatableFloatRegisterSet& set, uint32_t& max_bits,
uint32_t bits) {
FloatRegisterSet allocSet(set.bits());
FloatRegisterSet available_f32(
allocSet.allAllocatable<RegTypeName::Float32>());
FloatRegisterSet available_f64(
allocSet.allAllocatable<RegTypeName::Float64>());
FloatRegisterSet available_v128(
allocSet.allAllocatable<RegTypeName::Vector128>());
for (FloatRegisterIterator it(available_f32); it.more(); ++it) {
FloatRegister tmp = *it;
set.take(tmp);
pullAllFpus(set, max_bits, bits + 32);
set.add(tmp);
}
for (FloatRegisterIterator it(available_f64); it.more(); ++it) {
FloatRegister tmp = *it;
set.take(tmp);
pullAllFpus(set, max_bits, bits + 64);
set.add(tmp);
}
for (FloatRegisterIterator it(available_v128); it.more(); ++it) {
FloatRegister tmp = *it;
set.take(tmp);
pullAllFpus(set, max_bits, bits + 128);
set.add(tmp);
}
if (bits >= max_bits) {
max_bits = bits;
}
}
BEGIN_TEST(testJitRegisterSet_FPU_Aliases) {
BEGIN_All_WALK(FloatRegisters::Total);
FOR_ALL_REGISTERS(FloatRegister, reg) {
AllocatableFloatRegisterSet pool;
pool.add(reg);
uint32_t alias_bits = 0;
for (uint32_t i = 0; i < reg.numAlignedAliased(); i++) {
FloatRegister alias = reg.alignedAliased(i);
if (alias.isSingle()) {
if (alias_bits <= 32) {
alias_bits = 32;
}
} else if (alias.isDouble()) {
if (alias_bits <= 64) {
alias_bits = 64;
}
} else if (alias.isSimd128()) {
if (alias_bits <= 128) {
alias_bits = 128;
}
}
}
uint32_t max_bits = 0;
pullAllFpus(pool, max_bits, 0);
// By adding one register, we expect that we should not be able to pull
// more than any of its aligned aliases. This rule should hold for both
// x64 and ARM.
CHECK(max_bits <= alias_bits);
// We added one register, we expect to be able to pull it back.
CHECK(max_bits > 0);
}
END_FOR_ALL_REGISTERS;
return true;
}
END_TEST(testJitRegisterSet_FPU_Aliases)