AuroraMiddleware/v8
1
0
Fork 0
Code Issues 2 Pull Requests Releases Wiki Activity
d469a70049
v8/test/cctest/test-assembler-loong64.cc
Liu Yu 82cbc72c0e [loong64][mips64] Various post-Code rename cleanups 
Port commit c0367102a3

Bug: v8:13654
Change-Id: I768dc6b569814be93caa10fd91fb453ca2015dc7
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/4196756
Commit-Queue: Zhao Jiazhong <zhaojiazhong-hf@loongson.cn>
Auto-Submit: Liu Yu <liuyu@loongson.cn>
Reviewed-by: Zhao Jiazhong <zhaojiazhong-hf@loongson.cn>
Cr-Commit-Position: refs/heads/main@{#85531}
2023-01-29 07:50:03 +00:00

5181 lines
156 KiB
C++
Raw Blame History

// Copyright 2021 the V8 project authors. All rights reserved.
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following
// disclaimer in the documentation and/or other materials provided
// with the distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived
// from this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include <iostream>
#include "src/base/utils/random-number-generator.h"
#include "src/codegen/assembler-inl.h"
#include "src/codegen/macro-assembler.h"
#include "src/diagnostics/disassembler.h"
#include "src/execution/simulator.h"
#include "src/heap/factory.h"
#include "src/init/v8.h"
#include "test/cctest/cctest.h"
namespace v8 {
namespace internal {
// Define these function prototypes to match JSEntryFunction in execution.cc.
// TODO(LOONG64): Refine these signatures per test case.
using F1 = void*(int x, int p1, int p2, int p3, int p4);
using F2 = void*(int x, int y, int p2, int p3, int p4);
using F3 = void*(void* p, int p1, int p2, int p3, int p4);
using F4 = void*(int64_t x, int64_t y, int64_t p2, int64_t p3, int64_t p4);
using F5 = void*(void* p0, void* p1, int p2, int p3, int p4);
#define __ assm.
// v0->a2, v1->a3
TEST(LA0) {
CcTest::InitializeVM();
Isolate* isolate = CcTest::i_isolate();
HandleScope scope(isolate);
MacroAssembler assm(isolate, v8::internal::CodeObjectRequired::kYes);
// Addition.
__ addi_d(a2, a0, 0xC);
__ or_(a0, a2, zero_reg);
__ jirl(zero_reg, ra, 0);
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::FOR_TESTING).Build();
auto f = GeneratedCode<F2>::FromCode(*code);
int64_t res = reinterpret_cast<int64_t>(f.Call(0xAB0, 0, 0, 0, 0));
CHECK_EQ(0xABCL, res);
}
TEST(LA1) {
CcTest::InitializeVM();
Isolate* isolate = CcTest::i_isolate();
HandleScope scope(isolate);
MacroAssembler assm(isolate, v8::internal::CodeObjectRequired::kYes);
Label L, C;
__ ori(a1, a0, 0);
__ ori(a2, zero_reg, 0);
__ b(&C);
__ bind(&L);
__ add_d(a2, a2, a1);
__ addi_d(a1, a1, -1);
__ bind(&C);
__ ori(a3, a1, 0);
__ Branch(&L, ne, a3, Operand((int64_t)0));
__ or_(a0, a2, zero_reg);
__ or_(a1, a3, zero_reg);
__ jirl(zero_reg, ra, 0);
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::FOR_TESTING).Build();
auto f = GeneratedCode<F1>::FromCode(*code);
int64_t res = reinterpret_cast<int64_t>(f.Call(50, 0, 0, 0, 0));
CHECK_EQ(1275L, res);
}
TEST(LA2) {
CcTest::InitializeVM();
Isolate* isolate = CcTest::i_isolate();
HandleScope scope(isolate);
MacroAssembler assm(isolate, v8::internal::CodeObjectRequired::kYes);
Label exit, error;
__ ori(a4, zero_reg, 0); // 00000000
__ lu12i_w(a4, 0x12345); // 12345000
__ ori(a4, a4, 0); // 12345000
__ ori(a2, a4, 0xF0F); // 12345F0F
__ Branch(&error, ne, a2, Operand(0x12345F0F));
__ ori(a4, zero_reg, 0);
__ lu32i_d(a4, 0x12345); // 1 2345 0000 0000
__ ori(a4, a4, 0xFFF); // 1 2345 0000 0FFF
__ addi_d(a2, a4, 1);
__ Branch(&error, ne, a2, Operand(0x1234500001000));
__ ori(a4, zero_reg, 0);
__ lu52i_d(a4, zero_reg, 0x123); // 1230 0000 0000 0000
__ ori(a4, a4, 0xFFF); // 123F 0000 0000 0FFF
__ addi_d(a2, a4, 1); // 1230 0000 0000 1000
__ Branch(&error, ne, a2, Operand(0x1230000000001000));
__ li(a2, 0x31415926);
__ b(&exit);
__ bind(&error);
__ li(a2, 0x666);
__ bind(&exit);
__ or_(a0, a2, zero_reg);
__ jirl(zero_reg, ra, 0);
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::FOR_TESTING).Build();
auto f = GeneratedCode<F2>::FromCode(*code);
int64_t res = reinterpret_cast<int64_t>(f.Call(0, 0, 0, 0, 0));
CHECK_EQ(0x31415926L, res);
}
TEST(LA3) {
// Test 32bit calculate instructions.
CcTest::InitializeVM();
Isolate* isolate = CcTest::i_isolate();
HandleScope scope(isolate);
MacroAssembler assm(isolate, v8::internal::CodeObjectRequired::kYes);
Label exit, error;
__ li(a4, 0x00000004);
__ li(a5, 0x00001234);
__ li(a6, 0x12345678);
__ li(a7, 0x7FFFFFFF);
__ li(t0, static_cast<int32_t>(0xFFFFFFFC));
__ li(t1, static_cast<int32_t>(0xFFFFEDCC));
__ li(t2, static_cast<int32_t>(0xEDCBA988));
__ li(t3, static_cast<int32_t>(0x80000000));
__ ori(a2, zero_reg, 0); // 0x00000000
__ add_w(a2, a4, a5); // 0x00001238
__ sub_w(a2, a2, a4); // 0x00001234
__ Branch(&error, ne, a2, Operand(0x00001234));
__ ori(a3, zero_reg, 0); // 0x00000000
__ add_w(a3, a7, a4); // 32bit addu result is sign-extended into 64bit reg.
__ Branch(&error, ne, a3, Operand(0xFFFFFFFF80000003));
__ sub_w(a3, t3, a4); // 0x7FFFFFFC
__ Branch(&error, ne, a3, Operand(0x7FFFFFFC));
__ ori(a2, zero_reg, 0); // 0x00000000
__ ori(a3, zero_reg, 0); // 0x00000000
__ addi_w(a2, zero_reg, 0x421); // 0x00007421
__ addi_w(a2, a2, -0x1); // 0x00007420
__ addi_w(a2, a2, -0x20); // 0x00007400
__ Branch(&error, ne, a2, Operand(0x0000400));
__ addi_w(a3, a7, 0x1); // 0x80000000 - result is sign-extended.
__ Branch(&error, ne, a3, Operand(0xFFFFFFFF80000000));
__ ori(a2, zero_reg, 0); // 0x00000000
__ ori(a3, zero_reg, 0); // 0x00000000
__ alsl_w(a2, a6, a4, 3); // 0xFFFFFFFF91A2B3C4
__ alsl_w(a2, a2, a4, 2); // 0x468ACF14
__ Branch(&error, ne, a2, Operand(0x468acf14));
__ ori(a0, zero_reg, 31);
__ alsl_wu(a3, a6, a4, 3); // 0x91A2B3C4
__ alsl_wu(a3, a3, a7, 1); // 0xFFFFFFFFA3456787
__ Branch(&error, ne, a3, Operand(0xA3456787));
__ ori(a2, zero_reg, 0);
__ ori(a3, zero_reg, 0);
__ mul_w(a2, a5, a7);
__ div_w(a2, a2, a4);
__ Branch(&error, ne, a2, Operand(0xFFFFFFFFFFFFFB73));
__ mul_w(a3, a4, t1);
__ Branch(&error, ne, a3, Operand(0xFFFFFFFFFFFFB730));
__ div_w(a3, t3, a4);
__ Branch(&error, ne, a3, Operand(0xFFFFFFFFE0000000));
__ ori(a2, zero_reg, 0);
__ mulh_w(a2, a4, t1);
__ Branch(&error, ne, a2, Operand(0xFFFFFFFFFFFFFFFF));
__ mulh_w(a2, a4, a6);
__ Branch(&error, ne, a2, Operand(static_cast<int64_t>(0)));
__ ori(a2, zero_reg, 0);
__ mulh_wu(a2, a4, t1);
__ Branch(&error, ne, a2, Operand(0x3));
__ mulh_wu(a2, a4, a6);
__ Branch(&error, ne, a2, Operand(static_cast<int64_t>(0)));
__ ori(a2, zero_reg, 0);
__ mulw_d_w(a2, a4, t1);
__ Branch(&error, ne, a2, Operand(0xFFFFFFFFFFFFB730));
__ mulw_d_w(a2, a4, a6);
__ Branch(&error, ne, a2, Operand(0x48D159E0));
__ ori(a2, zero_reg, 0);
__ mulw_d_wu(a2, a4, t1);
__ Branch(&error, ne, a2, Operand(0x3FFFFB730)); //========0xFFFFB730
__ ori(a2, zero_reg, 81);
__ mulw_d_wu(a2, a4, a6);
__ Branch(&error, ne, a2, Operand(0x48D159E0));
__ ori(a2, zero_reg, 0);
__ div_wu(a2, a7, a5);
__ Branch(&error, ne, a2, Operand(0x70821));
__ div_wu(a2, t0, a5);
__ Branch(&error, ne, a2, Operand(0xE1042));
__ div_wu(a2, t0, t1);
__ Branch(&error, ne, a2, Operand(0x1));
__ ori(a2, zero_reg, 0);
__ mod_w(a2, a6, a5);
__ Branch(&error, ne, a2, Operand(0xDA8));
__ ori(a2, zero_reg, 0);
__ mod_w(a2, t2, a5);
__ Branch(&error, ne, a2, Operand(0xFFFFFFFFFFFFF258));
__ ori(a2, zero_reg, 0);
__ mod_w(a2, t2, t1);
__ Branch(&error, ne, a2, Operand(0xFFFFFFFFFFFFF258));
__ ori(a2, zero_reg, 0);
__ mod_wu(a2, a6, a5);
__ Branch(&error, ne, a2, Operand(0xDA8));
__ mod_wu(a2, t2, a5);
__ Branch(&error, ne, a2, Operand(0xF0));
__ mod_wu(a2, t2, t1);
__ Branch(&error, ne, a2, Operand(0xFFFFFFFFEDCBA988));
__ li(a2, 0x31415926);
__ b(&exit);
__ bind(&error);
__ li(a2, 0x666);
__ bind(&exit);
__ or_(a0, a2, zero_reg);
__ jirl(zero_reg, ra, 0);
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::FOR_TESTING).Build();
auto f = GeneratedCode<F2>::FromCode(*code);
int64_t res = reinterpret_cast<int64_t>(f.Call(0, 0, 0, 0, 0));
CHECK_EQ(0x31415926L, res);
}
TEST(LA4) {
// Test 64bit calculate instructions.
CcTest::InitializeVM();
Isolate* isolate = CcTest::i_isolate();
HandleScope scope(isolate);
MacroAssembler assm(isolate, v8::internal::CodeObjectRequired::kYes);
Label exit, error;
__ li(a4, 0x17312);
__ li(a5, 0x1012131415161718);
__ li(a6, 0x51F4B764A26E7412);
__ li(a7, 0x7FFFFFFFFFFFFFFF);
__ li(t0, static_cast<int64_t>(0xFFFFFFFFFFFFF547));
__ li(t1, static_cast<int64_t>(0xDF6B8F35A10E205C));
__ li(t2, static_cast<int64_t>(0x81F25A87C4236841));
__ li(t3, static_cast<int64_t>(0x8000000000000000));
__ ori(a2, zero_reg, 0);
__ add_d(a2, a4, a5);
__ sub_d(a2, a2, a4);
__ Branch(&error, ne, a2, Operand(0x1012131415161718));
__ ori(a3, zero_reg, 0);
__ add_d(a3, a6, a7); //溢出
__ Branch(&error, ne, a3, Operand(0xd1f4b764a26e7411));
__ sub_d(a3, t3, a4); //溢出
__ Branch(&error, ne, a3, Operand(0x7ffffffffffe8cee));
__ ori(a2, zero_reg, 0);
__ addi_d(a2, a5, 0x412); //正值
__ Branch(&error, ne, a2, Operand(0x1012131415161b2a));
__ addi_d(a2, a7, 0x547); //负值
__ Branch(&error, ne, a2, Operand(0x8000000000000546));
__ ori(t4, zero_reg, 0);
__ addu16i_d(a2, t4, 0x1234);
__ Branch(&error, ne, a2, Operand(0x12340000));
__ addu16i_d(a2, a2, 0x9876);
__ Branch(&error, ne, a2, Operand(0xffffffffaaaa0000));
__ ori(a2, zero_reg, 0);
__ alsl_d(a2, t2, t0, 3);
__ Branch(&error, ne, a2, Operand(0xf92d43e211b374f));
__ ori(a2, zero_reg, 0);
__ mul_d(a2, a5, a6);
__ Branch(&error, ne, a2, Operand(0xdbe6a8729a547fb0));
__ mul_d(a2, t0, t1);
__ Branch(&error, ne, a2, Operand(0x57ad69f40f870584));
__ mul_d(a2, a4, t0);
__ Branch(&error, ne, a2, Operand(0xfffffffff07523fe));
__ ori(a2, zero_reg, 0);
__ mulh_d(a2, a5, a6);
__ Branch(&error, ne, a2, Operand(0x52514c6c6b54467));
__ mulh_d(a2, t0, t1);
__ Branch(&error, ne, a2, Operand(0x15d));
__ ori(a2, zero_reg, 0);
__ mulh_du(a2, a5, a6);
__ Branch(&error, ne, a2, Operand(0x52514c6c6b54467));
__ mulh_du(a2, t0, t1);
__ Branch(&error, ne, a2, Operand(0xdf6b8f35a10e1700));
__ mulh_du(a2, a4, t0);
__ Branch(&error, ne, a2, Operand(0x17311));
__ ori(a2, zero_reg, 0);
__ div_d(a2, a5, a6);
__ Branch(&error, ne, a2, Operand(static_cast<int64_t>(0)));
__ div_d(a2, t0, t1);
__ Branch(&error, ne, a2, Operand(static_cast<int64_t>(0)));
__ div_d(a2, t1, a4);
__ Branch(&error, ne, a2, Operand(0xffffe985f631e6d9));
__ ori(a2, zero_reg, 0);
__ div_du(a2, a5, a6);
__ Branch(&error, ne, a2, Operand(static_cast<int64_t>(0)));
__ div_du(a2, t0, t1);
__ Branch(&error, ne, a2, Operand(0x1));
__ div_du(a2, t1, a4);
__ Branch(&error, ne, a2, Operand(0x9a22ffd3973d));
__ ori(a2, zero_reg, 0);
__ mod_d(a2, a6, a4);
__ Branch(&error, ne, a2, Operand(0x13558));
__ mod_d(a2, t2, t0);
__ Branch(&error, ne, a2, Operand(0xfffffffffffffb0a));
__ mod_d(a2, t1, a4);
__ Branch(&error, ne, a2, Operand(0xffffffffffff6a1a));
__ ori(a2, zero_reg, 0);
__ mod_du(a2, a6, a4);
__ Branch(&error, ne, a2, Operand(0x13558));
__ mod_du(a2, t2, t0);
__ Branch(&error, ne, a2, Operand(0x81f25a87c4236841));
__ mod_du(a2, t1, a4);
__ Branch(&error, ne, a2, Operand(0x1712));
// Everything was correctly executed. Load the expected result.
__ li(a2, 0x31415926);
__ b(&exit);
__ bind(&error);
__ li(a2, 0x666);
// Got an error. Return a wrong result.
__ bind(&exit);
__ or_(a0, a2, zero_reg);
__ jirl(zero_reg, ra, 0);
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::FOR_TESTING).Build();
auto f = GeneratedCode<F2>::FromCode(*code);
int64_t res = reinterpret_cast<int64_t>(f.Call(0, 0, 0, 0, 0));
CHECK_EQ(0x31415926L, res);
}
TEST(LA5) {
CcTest::InitializeVM();
Isolate* isolate = CcTest::i_isolate();
HandleScope scope(isolate);
MacroAssembler assm(isolate, v8::internal::CodeObjectRequired::kYes);
Label exit, error;
__ li(a4, 0x17312);
__ li(a5, 0x1012131415161718);
__ li(a6, 0x51F4B764A26E7412);
__ li(a7, 0x7FFFFFFFFFFFFFFF);
__ li(t0, static_cast<int64_t>(0xFFFFFFFFFFFFF547));
__ li(t1, static_cast<int64_t>(0xDF6B8F35A10E205C));
__ li(t2, static_cast<int64_t>(0x81F25A87C4236841));
__ li(t3, static_cast<int64_t>(0x8000000000000000));
__ ori(a2, zero_reg, 0);
__ slt(a2, a5, a6);
__ Branch(&error, ne, a2, Operand(0x1));
__ slt(a2, a7, t0);
__ Branch(&error, ne, a2, Operand(static_cast<int64_t>(0)));
__ slt(a2, t1, t1);
__ Branch(&error, ne, a2, Operand(static_cast<int64_t>(0)));
__ ori(a2, zero_reg, 0);
__ sltu(a2, a5, a6);
__ Branch(&error, ne, a2, Operand(0x1));
__ sltu(a2, a7, t0);
__ Branch(&error, ne, a2, Operand(0x1));
__ sltu(a2, t1, t1);
__ Branch(&error, ne, a2, Operand(static_cast<int64_t>(0)));
__ ori(a2, zero_reg, 0);
__ slti(a2, a5, 0x123);
__ Branch(&error, ne, a2, Operand(static_cast<int64_t>(0)));
__ slti(a2, t0, 0x123);
__ Branch(&error, ne, a2, Operand(0x1));
__ ori(a2, zero_reg, 0);
__ sltui(a2, a5, 0x123);
__ Branch(&error, ne, a2, Operand(static_cast<int64_t>(0)));
__ sltui(a2, t0, 0x123);
__ Branch(&error, ne, a2, Operand(static_cast<int64_t>(0)));
__ ori(a2, zero_reg, 0);
__ and_(a2, a4, a5);
__ Branch(&error, ne, a2, Operand(0x1310));
__ and_(a2, a6, a7);
__ Branch(&error, ne, a2, Operand(0x51F4B764A26E7412));
__ ori(a2, zero_reg, 0);
__ or_(a2, t0, t1);
__ Branch(&error, ne, a2, Operand(0xfffffffffffff55f));
__ or_(a2, t2, t3);
__ Branch(&error, ne, a2, Operand(0x81f25a87c4236841));
__ ori(a2, zero_reg, 0);
__ nor(a2, a4, a5);
__ Branch(&error, ne, a2, Operand(0xefedecebeae888e5));
__ nor(a2, a6, a7);
__ Branch(&error, ne, a2, Operand(0x8000000000000000));
__ ori(a2, zero_reg, 0);
__ xor_(a2, t0, t1);
__ Branch(&error, ne, a2, Operand(0x209470ca5ef1d51b));
__ xor_(a2, t2, t3);
__ Branch(&error, ne, a2, Operand(0x1f25a87c4236841));
__ ori(a2, zero_reg, 0);
__ andn(a2, a4, a5);
__ Branch(&error, ne, a2, Operand(0x16002));
__ andn(a2, a6, a7);
__ Branch(&error, ne, a2, Operand(static_cast<int64_t>(0)));
__ ori(a2, zero_reg, 0);
__ orn(a2, t0, t1);
__ Branch(&error, ne, a2, Operand(0xffffffffffffffe7));
__ orn(a2, t2, t3);
__ Branch(&error, ne, a2, Operand(0xffffffffffffffff));
__ ori(a2, zero_reg, 0);
__ andi(a2, a4, 0x123);
__ Branch(&error, ne, a2, Operand(0x102));
__ andi(a2, a6, 0xDCB);
__ Branch(&error, ne, a2, Operand(0x402));
__ ori(a2, zero_reg, 0);
__ xori(a2, t0, 0x123);
__ Branch(&error, ne, a2, Operand(0xfffffffffffff464));
__ xori(a2, t2, 0xDCB);
__ Branch(&error, ne, a2, Operand(0x81f25a87c423658a));
// Everything was correctly executed. Load the expected result.
__ li(a2, 0x31415926);
__ b(&exit);
__ bind(&error);
// Got an error. Return a wrong result.
__ li(a2, 0x666);
__ bind(&exit);
__ or_(a0, a2, zero_reg);
__ jirl(zero_reg, ra, 0);
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::FOR_TESTING).Build();
auto f = GeneratedCode<F2>::FromCode(*code);
int64_t res = reinterpret_cast<int64_t>(f.Call(0, 0, 0, 0, 0));
CHECK_EQ(0x31415926L, res);
}
TEST(LA6) {
// Test loads and stores instruction.
CcTest::InitializeVM();
Isolate* isolate = CcTest::i_isolate();
HandleScope scope(isolate);
MacroAssembler assm(isolate, v8::internal::CodeObjectRequired::kYes);
struct T {
int64_t si1;
int64_t si2;
int64_t si3;
int64_t result_ld_b_si1;
int64_t result_ld_b_si2;
int64_t result_ld_h_si1;
int64_t result_ld_h_si2;
int64_t result_ld_w_si1;
int64_t result_ld_w_si2;
int64_t result_ld_d_si1;
int64_t result_ld_d_si3;
int64_t result_ld_bu_si2;
int64_t result_ld_hu_si2;
int64_t result_ld_wu_si2;
int64_t result_st_b;
int64_t result_st_h;
int64_t result_st_w;
};
T t;
// Ld_b
__ Ld_b(a4, MemOperand(a0, offsetof(T, si1)));
__ St_d(a4, MemOperand(a0, offsetof(T, result_ld_b_si1)));
__ Ld_b(a4, MemOperand(a0, offsetof(T, si2)));
__ St_d(a4, MemOperand(a0, offsetof(T, result_ld_b_si2)));
// Ld_h
__ Ld_h(a5, MemOperand(a0, offsetof(T, si1)));
__ St_d(a5, MemOperand(a0, offsetof(T, result_ld_h_si1)));
__ Ld_h(a5, MemOperand(a0, offsetof(T, si2)));
__ St_d(a5, MemOperand(a0, offsetof(T, result_ld_h_si2)));
// Ld_w
__ Ld_w(a6, MemOperand(a0, offsetof(T, si1)));
__ St_d(a6, MemOperand(a0, offsetof(T, result_ld_w_si1)));
__ Ld_w(a6, MemOperand(a0, offsetof(T, si2)));
__ St_d(a6, MemOperand(a0, offsetof(T, result_ld_w_si2)));
// Ld_d
__ Ld_d(a7, MemOperand(a0, offsetof(T, si1)));
__ St_d(a7, MemOperand(a0, offsetof(T, result_ld_d_si1)));
__ Ld_d(a7, MemOperand(a0, offsetof(T, si3)));
__ St_d(a7, MemOperand(a0, offsetof(T, result_ld_d_si3)));
// Ld_bu
__ Ld_bu(t0, MemOperand(a0, offsetof(T, si2)));
__ St_d(t0, MemOperand(a0, offsetof(T, result_ld_bu_si2)));
// Ld_hu
__ Ld_hu(t1, MemOperand(a0, offsetof(T, si2)));
__ St_d(t1, MemOperand(a0, offsetof(T, result_ld_hu_si2)));
// Ld_wu
__ Ld_wu(t2, MemOperand(a0, offsetof(T, si2)));
__ St_d(t2, MemOperand(a0, offsetof(T, result_ld_wu_si2)));
// St
__ li(t4, 0x11111111);
// St_b
__ Ld_d(t5, MemOperand(a0, offsetof(T, si3)));
__ St_d(t5, MemOperand(a0, offsetof(T, result_st_b)));
__ St_b(t4, MemOperand(a0, offsetof(T, result_st_b)));
// St_h
__ Ld_d(t6, MemOperand(a0, offsetof(T, si3)));
__ St_d(t6, MemOperand(a0, offsetof(T, result_st_h)));
__ St_h(t4, MemOperand(a0, offsetof(T, result_st_h)));
// St_w
__ Ld_d(t7, MemOperand(a0, offsetof(T, si3)));
__ St_d(t7, MemOperand(a0, offsetof(T, result_st_w)));
__ St_w(t4, MemOperand(a0, offsetof(T, result_st_w)));
__ jirl(zero_reg, ra, 0);
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::FOR_TESTING).Build();
auto f = GeneratedCode<F3>::FromCode(*code);
t.si1 = 0x11223344;
t.si2 = 0x99AABBCC;
t.si3 = 0x1122334455667788;
f.Call(&t, 0, 0, 0, 0);
CHECK_EQ(static_cast<int64_t>(0x44), t.result_ld_b_si1);
CHECK_EQ(static_cast<int64_t>(0xFFFFFFFFFFFFFFCC), t.result_ld_b_si2);
CHECK_EQ(static_cast<int64_t>(0x3344), t.result_ld_h_si1);
CHECK_EQ(static_cast<int64_t>(0xFFFFFFFFFFFFBBCC), t.result_ld_h_si2);
CHECK_EQ(static_cast<int64_t>(0x11223344), t.result_ld_w_si1);
CHECK_EQ(static_cast<int64_t>(0xFFFFFFFF99AABBCC), t.result_ld_w_si2);
CHECK_EQ(static_cast<int64_t>(0x11223344), t.result_ld_d_si1);
CHECK_EQ(static_cast<int64_t>(0x1122334455667788), t.result_ld_d_si3);
CHECK_EQ(static_cast<int64_t>(0xCC), t.result_ld_bu_si2);
CHECK_EQ(static_cast<int64_t>(0xBBCC), t.result_ld_hu_si2);
CHECK_EQ(static_cast<int64_t>(0x99AABBCC), t.result_ld_wu_si2);
CHECK_EQ(static_cast<int64_t>(0x1122334455667711), t.result_st_b);
CHECK_EQ(static_cast<int64_t>(0x1122334455661111), t.result_st_h);
CHECK_EQ(static_cast<int64_t>(0x1122334411111111), t.result_st_w);
}
TEST(LA7) {
CcTest::InitializeVM();
Isolate* isolate = CcTest::i_isolate();
HandleScope scope(isolate);
MacroAssembler assm(isolate, v8::internal::CodeObjectRequired::kYes);
struct T {
int64_t si1;
int64_t si2;
int64_t si3;
int64_t result_ldx_b_si1;
int64_t result_ldx_b_si2;
int64_t result_ldx_h_si1;
int64_t result_ldx_h_si2;
int64_t result_ldx_w_si1;
int64_t result_ldx_w_si2;
int64_t result_ldx_d_si1;
int64_t result_ldx_d_si3;
int64_t result_ldx_bu_si2;
int64_t result_ldx_hu_si2;
int64_t result_ldx_wu_si2;
int64_t result_stx_b;
int64_t result_stx_h;
int64_t result_stx_w;
};
T t;
// ldx_b
__ li(a2, static_cast<int64_t>(offsetof(T, si1)));
__ Ld_b(a4, MemOperand(a0, a2));
__ St_d(a4, MemOperand(a0, offsetof(T, result_ldx_b_si1)));
__ li(a2, static_cast<int64_t>(offsetof(T, si2)));
__ Ld_b(a4, MemOperand(a0, a2));
__ St_d(a4, MemOperand(a0, offsetof(T, result_ldx_b_si2)));
// ldx_h
__ li(a2, static_cast<int64_t>(offsetof(T, si1)));
__ Ld_h(a5, MemOperand(a0, a2));
__ St_d(a5, MemOperand(a0, offsetof(T, result_ldx_h_si1)));
__ li(a2, static_cast<int64_t>(offsetof(T, si2)));
__ Ld_h(a5, MemOperand(a0, a2));
__ St_d(a5, MemOperand(a0, offsetof(T, result_ldx_h_si2)));
// ldx_w
__ li(a2, static_cast<int64_t>(offsetof(T, si1)));
__ Ld_w(a6, MemOperand(a0, a2));
__ St_d(a6, MemOperand(a0, offsetof(T, result_ldx_w_si1)));
__ li(a2, static_cast<int64_t>(offsetof(T, si2)));
__ Ld_w(a6, MemOperand(a0, a2));
__ St_d(a6, MemOperand(a0, offsetof(T, result_ldx_w_si2)));
// Ld_d
__ li(a2, static_cast<int64_t>(offsetof(T, si1)));
__ Ld_d(a7, MemOperand(a0, a2));
__ St_d(a7, MemOperand(a0, offsetof(T, result_ldx_d_si1)));
__ li(a2, static_cast<int64_t>(offsetof(T, si3)));
__ Ld_d(a7, MemOperand(a0, a2));
__ St_d(a7, MemOperand(a0, offsetof(T, result_ldx_d_si3)));
// Ld_bu
__ li(a2, static_cast<int64_t>(offsetof(T, si2)));
__ Ld_bu(t0, MemOperand(a0, a2));
__ St_d(t0, MemOperand(a0, offsetof(T, result_ldx_bu_si2)));
// Ld_hu
__ li(a2, static_cast<int64_t>(offsetof(T, si2)));
__ Ld_hu(t1, MemOperand(a0, a2));
__ St_d(t1, MemOperand(a0, offsetof(T, result_ldx_hu_si2)));
// Ld_wu
__ li(a2, static_cast<int64_t>(offsetof(T, si2)));
__ Ld_wu(t2, MemOperand(a0, a2));
__ St_d(t2, MemOperand(a0, offsetof(T, result_ldx_wu_si2)));
// St
__ li(t4, 0x11111111);
// St_b
__ Ld_d(t5, MemOperand(a0, offsetof(T, si3)));
__ St_d(t5, MemOperand(a0, offsetof(T, result_stx_b)));
__ li(a2, static_cast<int64_t>(offsetof(T, result_stx_b)));
__ St_b(t4, MemOperand(a0, a2));
// St_h
__ Ld_d(t6, MemOperand(a0, offsetof(T, si3)));
__ St_d(t6, MemOperand(a0, offsetof(T, result_stx_h)));
__ li(a2, static_cast<int64_t>(offsetof(T, result_stx_h)));
__ St_h(t4, MemOperand(a0, a2));
// St_w
__ Ld_d(t7, MemOperand(a0, offsetof(T, si3)));
__ li(a2, static_cast<int64_t>(offsetof(T, result_stx_w)));
__ St_d(t7, MemOperand(a0, a2));
__ li(a3, static_cast<int64_t>(offsetof(T, result_stx_w)));
__ St_w(t4, MemOperand(a0, a3));
__ jirl(zero_reg, ra, 0);
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::FOR_TESTING).Build();
auto f = GeneratedCode<F3>::FromCode(*code);
t.si1 = 0x11223344;
t.si2 = 0x99AABBCC;
t.si3 = 0x1122334455667788;
f.Call(&t, 0, 0, 0, 0);
CHECK_EQ(static_cast<int64_t>(0x44), t.result_ldx_b_si1);
CHECK_EQ(static_cast<int64_t>(0xFFFFFFFFFFFFFFCC), t.result_ldx_b_si2);
CHECK_EQ(static_cast<int64_t>(0x3344), t.result_ldx_h_si1);
CHECK_EQ(static_cast<int64_t>(0xFFFFFFFFFFFFBBCC), t.result_ldx_h_si2);
CHECK_EQ(static_cast<int64_t>(0x11223344), t.result_ldx_w_si1);
CHECK_EQ(static_cast<int64_t>(0xFFFFFFFF99AABBCC), t.result_ldx_w_si2);
CHECK_EQ(static_cast<int64_t>(0x11223344), t.result_ldx_d_si1);
CHECK_EQ(static_cast<int64_t>(0x1122334455667788), t.result_ldx_d_si3);
CHECK_EQ(static_cast<int64_t>(0xCC), t.result_ldx_bu_si2);
CHECK_EQ(static_cast<int64_t>(0xBBCC), t.result_ldx_hu_si2);
CHECK_EQ(static_cast<int64_t>(0x99AABBCC), t.result_ldx_wu_si2);
CHECK_EQ(static_cast<int64_t>(0x1122334455667711), t.result_stx_b);
CHECK_EQ(static_cast<int64_t>(0x1122334455661111), t.result_stx_h);
CHECK_EQ(static_cast<int64_t>(0x1122334411111111), t.result_stx_w);
}
TEST(LDPTR_STPTR) {
CcTest::InitializeVM();
Isolate* isolate = CcTest::i_isolate();
HandleScope scope(isolate);
MacroAssembler assm(isolate, v8::internal::CodeObjectRequired::kYes);
int64_t test[10];
__ ldptr_w(a4, a0, 0);
__ stptr_d(a4, a0, 24); // test[3]
__ ldptr_w(a5, a0, 8); // test[1]
__ stptr_d(a5, a0, 32); // test[4]
__ ldptr_d(a6, a0, 16); // test[2]
__ stptr_d(a6, a0, 40); // test[5]
__ li(t0, 0x11111111);
__ stptr_d(a6, a0, 48); // test[6]
__ stptr_w(t0, a0, 48); // test[6]
__ jirl(zero_reg, ra, 0);
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::FOR_TESTING).Build();
auto f = GeneratedCode<F3>::FromCode(*code);
test[0] = 0x11223344;
test[1] = 0x99AABBCC;
test[2] = 0x1122334455667788;
f.Call(&test, 0, 0, 0, 0);
CHECK_EQ(static_cast<int64_t>(0x11223344), test[3]);
CHECK_EQ(static_cast<int64_t>(0xFFFFFFFF99AABBCC), test[4]);
CHECK_EQ(static_cast<int64_t>(0x1122334455667788), test[5]);
CHECK_EQ(static_cast<int64_t>(0x1122334411111111), test[6]);
}
TEST(LA8) {
// Test 32bit shift instructions.
CcTest::InitializeVM();
Isolate* isolate = CcTest::i_isolate();
HandleScope scope(isolate);
struct T {
int32_t input;
int32_t result_sll_w_0;
int32_t result_sll_w_8;
int32_t result_sll_w_10;
int32_t result_sll_w_31;
int32_t result_srl_w_0;
int32_t result_srl_w_8;
int32_t result_srl_w_10;
int32_t result_srl_w_31;
int32_t result_sra_w_0;
int32_t result_sra_w_8;
int32_t result_sra_w_10;
int32_t result_sra_w_31;
int32_t result_rotr_w_0;
int32_t result_rotr_w_8;
int32_t result_slli_w_0;
int32_t result_slli_w_8;
int32_t result_slli_w_10;
int32_t result_slli_w_31;
int32_t result_srli_w_0;
int32_t result_srli_w_8;
int32_t result_srli_w_10;
int32_t result_srli_w_31;
int32_t result_srai_w_0;
int32_t result_srai_w_8;
int32_t result_srai_w_10;
int32_t result_srai_w_31;
int32_t result_rotri_w_0;
int32_t result_rotri_w_8;
int32_t result_rotri_w_10;
int32_t result_rotri_w_31;
};
T t;
MacroAssembler assm(isolate, v8::internal::CodeObjectRequired::kYes);
__ Ld_w(a4, MemOperand(a0, offsetof(T, input)));
// sll_w
__ li(a5, 0);
__ sll_w(t0, a4, a5);
__ li(a5, 0x8);
__ sll_w(t1, a4, a5);
__ li(a5, 0xA);
__ sll_w(t2, a4, a5);
__ li(a5, 0x1F);
__ sll_w(t3, a4, a5);
__ St_w(t0, MemOperand(a0, offsetof(T, result_sll_w_0)));
__ St_w(t1, MemOperand(a0, offsetof(T, result_sll_w_8)));
__ St_w(t2, MemOperand(a0, offsetof(T, result_sll_w_10)));
__ St_w(t3, MemOperand(a0, offsetof(T, result_sll_w_31)));
// srl_w
__ li(a5, 0x0);
__ srl_w(t0, a4, a5);
__ li(a5, 0x8);
__ srl_w(t1, a4, a5);
__ li(a5, 0xA);
__ srl_w(t2, a4, a5);
__ li(a5, 0x1F);
__ srl_w(t3, a4, a5);
__ St_w(t0, MemOperand(a0, offsetof(T, result_srl_w_0)));
__ St_w(t1, MemOperand(a0, offsetof(T, result_srl_w_8)));
__ St_w(t2, MemOperand(a0, offsetof(T, result_srl_w_10)));
__ St_w(t3, MemOperand(a0, offsetof(T, result_srl_w_31)));
// sra_w
__ li(a5, 0x0);
__ sra_w(t0, a4, a5);
__ li(a5, 0x8);
__ sra_w(t1, a4, a5);
__ li(a6, static_cast<int32_t>(0x80000000));
__ add_w(a6, a6, a4);
__ li(a5, 0xA);
__ sra_w(t2, a6, a5);
__ li(a5, 0x1F);
__ sra_w(t3, a6, a5);
__ St_w(t0, MemOperand(a0, offsetof(T, result_sra_w_0)));
__ St_w(t1, MemOperand(a0, offsetof(T, result_sra_w_8)));
__ St_w(t2, MemOperand(a0, offsetof(T, result_sra_w_10)));
__ St_w(t3, MemOperand(a0, offsetof(T, result_sra_w_31)));
// rotr
__ li(a5, 0x0);
__ rotr_w(t0, a4, a5);
__ li(a6, 0x8);
__ rotr_w(t1, a4, a6);
__ St_w(t0, MemOperand(a0, offsetof(T, result_rotr_w_0)));
__ St_w(t1, MemOperand(a0, offsetof(T, result_rotr_w_8)));
// slli_w
__ slli_w(t0, a4, 0);
__ slli_w(t1, a4, 0x8);
__ slli_w(t2, a4, 0xA);
__ slli_w(t3, a4, 0x1F);
__ St_w(t0, MemOperand(a0, offsetof(T, result_slli_w_0)));
__ St_w(t1, MemOperand(a0, offsetof(T, result_slli_w_8)));
__ St_w(t2, MemOperand(a0, offsetof(T, result_slli_w_10)));
__ St_w(t3, MemOperand(a0, offsetof(T, result_slli_w_31)));
// srli_w
__ srli_w(t0, a4, 0);
__ srli_w(t1, a4, 0x8);
__ srli_w(t2, a4, 0xA);
__ srli_w(t3, a4, 0x1F);
__ St_w(t0, MemOperand(a0, offsetof(T, result_srli_w_0)));
__ St_w(t1, MemOperand(a0, offsetof(T, result_srli_w_8)));
__ St_w(t2, MemOperand(a0, offsetof(T, result_srli_w_10)));
__ St_w(t3, MemOperand(a0, offsetof(T, result_srli_w_31)));
// srai_w
__ srai_w(t0, a4, 0);
__ srai_w(t1, a4, 0x8);
__ li(a6, static_cast<int32_t>(0x80000000));
__ add_w(a6, a6, a4);
__ srai_w(t2, a6, 0xA);
__ srai_w(t3, a6, 0x1F);
__ St_w(t0, MemOperand(a0, offsetof(T, result_srai_w_0)));
__ St_w(t1, MemOperand(a0, offsetof(T, result_srai_w_8)));
__ St_w(t2, MemOperand(a0, offsetof(T, result_srai_w_10)));
__ St_w(t3, MemOperand(a0, offsetof(T, result_srai_w_31)));
// rotri_w
__ rotri_w(t0, a4, 0);
__ rotri_w(t1, a4, 0x8);
__ rotri_w(t2, a4, 0xA);
__ rotri_w(t3, a4, 0x1F);
__ St_w(t0, MemOperand(a0, offsetof(T, result_rotri_w_0)));
__ St_w(t1, MemOperand(a0, offsetof(T, result_rotri_w_8)));
__ St_w(t2, MemOperand(a0, offsetof(T, result_rotri_w_10)));
__ St_w(t3, MemOperand(a0, offsetof(T, result_rotri_w_31)));
__ jirl(zero_reg, ra, 0);
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::FOR_TESTING).Build();
auto f = GeneratedCode<F3>::FromCode(*code);
t.input = 0x12345678;
f.Call(&t, 0x0, 0, 0, 0);
CHECK_EQ(static_cast<int32_t>(0x12345678), t.result_sll_w_0);
CHECK_EQ(static_cast<int32_t>(0x34567800), t.result_sll_w_8);
CHECK_EQ(static_cast<int32_t>(0xD159E000), t.result_sll_w_10);
CHECK_EQ(static_cast<int32_t>(0x0), t.result_sll_w_31);
CHECK_EQ(static_cast<int32_t>(0x12345678), t.result_srl_w_0);
CHECK_EQ(static_cast<int32_t>(0x123456), t.result_srl_w_8);
CHECK_EQ(static_cast<int32_t>(0x48D15), t.result_srl_w_10);
CHECK_EQ(static_cast<int32_t>(0x0), t.result_srl_w_31);
CHECK_EQ(static_cast<int32_t>(0x12345678), t.result_sra_w_0);
CHECK_EQ(static_cast<int32_t>(0x123456), t.result_sra_w_8);
CHECK_EQ(static_cast<int32_t>(0xFFE48D15), t.result_sra_w_10);
CHECK_EQ(static_cast<int32_t>(0xFFFFFFFF), t.result_sra_w_31);
CHECK_EQ(static_cast<int32_t>(0x12345678), t.result_rotr_w_0);
CHECK_EQ(static_cast<int32_t>(0x78123456), t.result_rotr_w_8);
CHECK_EQ(static_cast<int32_t>(0x12345678), t.result_slli_w_0);
CHECK_EQ(static_cast<int32_t>(0x34567800), t.result_slli_w_8);
CHECK_EQ(static_cast<int32_t>(0xD159E000), t.result_slli_w_10);
CHECK_EQ(static_cast<int32_t>(0x0), t.result_slli_w_31);
CHECK_EQ(static_cast<int32_t>(0x12345678), t.result_srli_w_0);
CHECK_EQ(static_cast<int32_t>(0x123456), t.result_srli_w_8);
CHECK_EQ(static_cast<int32_t>(0x48D15), t.result_srli_w_10);
CHECK_EQ(static_cast<int32_t>(0x0), t.result_srli_w_31);
CHECK_EQ(static_cast<int32_t>(0x12345678), t.result_srai_w_0);
CHECK_EQ(static_cast<int32_t>(0x123456), t.result_srai_w_8);
CHECK_EQ(static_cast<int32_t>(0xFFE48D15), t.result_srai_w_10);
CHECK_EQ(static_cast<int32_t>(0xFFFFFFFF), t.result_srai_w_31);
CHECK_EQ(static_cast<int32_t>(0x12345678), t.result_rotri_w_0);
CHECK_EQ(static_cast<int32_t>(0x78123456), t.result_rotri_w_8);
CHECK_EQ(static_cast<int32_t>(0x9E048D15), t.result_rotri_w_10);
CHECK_EQ(static_cast<int32_t>(0x2468ACF0), t.result_rotri_w_31);
}
TEST(LA9) {
// Test 64bit shift instructions.
CcTest::InitializeVM();
Isolate* isolate = CcTest::i_isolate();
HandleScope scope(isolate);
struct T {
int64_t input;
int64_t result_sll_d_0;
int64_t result_sll_d_13;
int64_t result_sll_d_30;
int64_t result_sll_d_63;
int64_t result_srl_d_0;
int64_t result_srl_d_13;
int64_t result_srl_d_30;
int64_t result_srl_d_63;
int64_t result_sra_d_0;
int64_t result_sra_d_13;
int64_t result_sra_d_30;
int64_t result_sra_d_63;
int64_t result_rotr_d_0;
int64_t result_rotr_d_13;
int64_t result_slli_d_0;
int64_t result_slli_d_13;
int64_t result_slli_d_30;
int64_t result_slli_d_63;
int64_t result_srli_d_0;
int64_t result_srli_d_13;
int64_t result_srli_d_30;
int64_t result_srli_d_63;
int64_t result_srai_d_0;
int64_t result_srai_d_13;
int64_t result_srai_d_30;
int64_t result_srai_d_63;
int64_t result_rotri_d_0;
int64_t result_rotri_d_13;
int64_t result_rotri_d_30;
int64_t result_rotri_d_63;
};
T t;
MacroAssembler assm(isolate, v8::internal::CodeObjectRequired::kYes);
__ Ld_d(a4, MemOperand(a0, offsetof(T, input)));
// sll_d
__ li(a5, 0);
__ sll_d(t0, a4, a5);
__ li(a5, 0xD);
__ sll_d(t1, a4, a5);
__ li(a5, 0x1E);
__ sll_d(t2, a4, a5);
__ li(a5, 0x3F);
__ sll_d(t3, a4, a5);
__ St_d(t0, MemOperand(a0, offsetof(T, result_sll_d_0)));
__ St_d(t1, MemOperand(a0, offsetof(T, result_sll_d_13)));
__ St_d(t2, MemOperand(a0, offsetof(T, result_sll_d_30)));
__ St_d(t3, MemOperand(a0, offsetof(T, result_sll_d_63)));
// srl_d
__ li(a5, 0x0);
__ srl_d(t0, a4, a5);
__ li(a5, 0xD);
__ srl_d(t1, a4, a5);
__ li(a5, 0x1E);
__ srl_d(t2, a4, a5);
__ li(a5, 0x3F);
__ srl_d(t3, a4, a5);
__ St_d(t0, MemOperand(a0, offsetof(T, result_srl_d_0)));
__ St_d(t1, MemOperand(a0, offsetof(T, result_srl_d_13)));
__ St_d(t2, MemOperand(a0, offsetof(T, result_srl_d_30)));
__ St_d(t3, MemOperand(a0, offsetof(T, result_srl_d_63)));
// sra_d
__ li(a5, 0x0);
__ sra_d(t0, a4, a5);
__ li(a5, 0xD);
__ sra_d(t1, a4, a5);
__ li(a6, static_cast<int64_t>(0x8000000000000000));
__ add_d(a6, a6, a4);
__ li(a5, 0x1E);
__ sra_d(t2, a6, a5);
__ li(a5, 0x3F);
__ sra_d(t3, a6, a5);
__ St_d(t0, MemOperand(a0, offsetof(T, result_sra_d_0)));
__ St_d(t1, MemOperand(a0, offsetof(T, result_sra_d_13)));
__ St_d(t2, MemOperand(a0, offsetof(T, result_sra_d_30)));
__ St_d(t3, MemOperand(a0, offsetof(T, result_sra_d_63)));
// rotr
__ li(a5, 0x0);
__ rotr_d(t0, a4, a5);
__ li(a6, 0xD);
__ rotr_d(t1, a4, a6);
__ St_d(t0, MemOperand(a0, offsetof(T, result_rotr_d_0)));
__ St_d(t1, MemOperand(a0, offsetof(T, result_rotr_d_13)));
// slli_d
__ slli_d(t0, a4, 0);
__ slli_d(t1, a4, 0xD);
__ slli_d(t2, a4, 0x1E);
__ slli_d(t3, a4, 0x3F);
__ St_d(t0, MemOperand(a0, offsetof(T, result_slli_d_0)));
__ St_d(t1, MemOperand(a0, offsetof(T, result_slli_d_13)));
__ St_d(t2, MemOperand(a0, offsetof(T, result_slli_d_30)));
__ St_d(t3, MemOperand(a0, offsetof(T, result_slli_d_63)));
// srli_d
__ srli_d(t0, a4, 0);
__ srli_d(t1, a4, 0xD);
__ srli_d(t2, a4, 0x1E);
__ srli_d(t3, a4, 0x3F);
__ St_d(t0, MemOperand(a0, offsetof(T, result_srli_d_0)));
__ St_d(t1, MemOperand(a0, offsetof(T, result_srli_d_13)));
__ St_d(t2, MemOperand(a0, offsetof(T, result_srli_d_30)));
__ St_d(t3, MemOperand(a0, offsetof(T, result_srli_d_63)));
// srai_d
__ srai_d(t0, a4, 0);
__ srai_d(t1, a4, 0xD);
__ li(a6, static_cast<int64_t>(0x8000000000000000));
__ add_d(a6, a6, a4);
__ srai_d(t2, a6, 0x1E);
__ srai_d(t3, a6, 0x3F);
__ St_d(t0, MemOperand(a0, offsetof(T, result_srai_d_0)));
__ St_d(t1, MemOperand(a0, offsetof(T, result_srai_d_13)));
__ St_d(t2, MemOperand(a0, offsetof(T, result_srai_d_30)));
__ St_d(t3, MemOperand(a0, offsetof(T, result_srai_d_63)));
// rotri_d
__ rotri_d(t0, a4, 0);
__ rotri_d(t1, a4, 0xD);
__ rotri_d(t2, a4, 0x1E);
__ rotri_d(t3, a4, 0x3F);
__ St_d(t0, MemOperand(a0, offsetof(T, result_rotri_d_0)));
__ St_d(t1, MemOperand(a0, offsetof(T, result_rotri_d_13)));
__ St_d(t2, MemOperand(a0, offsetof(T, result_rotri_d_30)));
__ St_d(t3, MemOperand(a0, offsetof(T, result_rotri_d_63)));
__ jirl(zero_reg, ra, 0);
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::FOR_TESTING).Build();
auto f = GeneratedCode<F3>::FromCode(*code);
t.input = 0x51F4B764A26E7412;
f.Call(&t, 0, 0, 0, 0);
CHECK_EQ(static_cast<int64_t>(0x51f4b764a26e7412), t.result_sll_d_0);
CHECK_EQ(static_cast<int64_t>(0x96ec944dce824000), t.result_sll_d_13);
CHECK_EQ(static_cast<int64_t>(0x289b9d0480000000), t.result_sll_d_30);
CHECK_EQ(static_cast<int64_t>(0x0), t.result_sll_d_63);
CHECK_EQ(static_cast<int64_t>(0x51f4b764a26e7412), t.result_srl_d_0);
CHECK_EQ(static_cast<int64_t>(0x28fa5bb251373), t.result_srl_d_13);
CHECK_EQ(static_cast<int64_t>(0x147d2dd92), t.result_srl_d_30);
CHECK_EQ(static_cast<int64_t>(0x0), t.result_srl_d_63);
CHECK_EQ(static_cast<int64_t>(0x51f4b764a26e7412), t.result_sra_d_0);
CHECK_EQ(static_cast<int64_t>(0x28fa5bb251373), t.result_sra_d_13);
CHECK_EQ(static_cast<int64_t>(0xffffffff47d2dd92), t.result_sra_d_30);
CHECK_EQ(static_cast<int64_t>(0xffffffffffffffff), t.result_sra_d_63);
CHECK_EQ(static_cast<int64_t>(0x51f4b764a26e7412), t.result_rotr_d_0);
CHECK_EQ(static_cast<int64_t>(0xa0928fa5bb251373), t.result_rotr_d_13);
CHECK_EQ(static_cast<int64_t>(0x51f4b764a26e7412), t.result_slli_d_0);
CHECK_EQ(static_cast<int64_t>(0x96ec944dce824000), t.result_slli_d_13);
CHECK_EQ(static_cast<int64_t>(0x289b9d0480000000), t.result_slli_d_30);
CHECK_EQ(static_cast<int64_t>(0x0), t.result_slli_d_63);
CHECK_EQ(static_cast<int64_t>(0x51f4b764a26e7412), t.result_srli_d_0);
CHECK_EQ(static_cast<int64_t>(0x28fa5bb251373), t.result_srli_d_13);
CHECK_EQ(static_cast<int64_t>(0x147d2dd92), t.result_srli_d_30);
CHECK_EQ(static_cast<int64_t>(0x0), t.result_srli_d_63);
CHECK_EQ(static_cast<int64_t>(0x51f4b764a26e7412), t.result_srai_d_0);
CHECK_EQ(static_cast<int64_t>(0x28fa5bb251373), t.result_srai_d_13);
CHECK_EQ(static_cast<int64_t>(0xffffffff47d2dd92), t.result_srai_d_30);
CHECK_EQ(static_cast<int64_t>(0xffffffffffffffff), t.result_srai_d_63);
CHECK_EQ(static_cast<int64_t>(0x51f4b764a26e7412), t.result_rotri_d_0);
CHECK_EQ(static_cast<int64_t>(0xa0928fa5bb251373), t.result_rotri_d_13);
CHECK_EQ(static_cast<int64_t>(0x89b9d04947d2dd92), t.result_rotri_d_30);
CHECK_EQ(static_cast<int64_t>(0xa3e96ec944dce824), t.result_rotri_d_63);
}
TEST(LA10) {
// Test 32bit bit operation instructions.
CcTest::InitializeVM();
Isolate* isolate = CcTest::i_isolate();
HandleScope scope(isolate);
MacroAssembler assm(isolate, v8::internal::CodeObjectRequired::kYes);
struct T {
int64_t si1;
int64_t si2;
int32_t result_ext_w_b_si1;
int32_t result_ext_w_b_si2;
int32_t result_ext_w_h_si1;
int32_t result_ext_w_h_si2;
int32_t result_clo_w_si1;
int32_t result_clo_w_si2;
int32_t result_clz_w_si1;
int32_t result_clz_w_si2;
int32_t result_cto_w_si1;
int32_t result_cto_w_si2;
int32_t result_ctz_w_si1;
int32_t result_ctz_w_si2;
int32_t result_bytepick_w_si1;
int32_t result_bytepick_w_si2;
int32_t result_revb_2h_si1;
int32_t result_revb_2h_si2;
int32_t result_bitrev_4b_si1;
int32_t result_bitrev_4b_si2;
int32_t result_bitrev_w_si1;
int32_t result_bitrev_w_si2;
int32_t result_bstrins_w_si1;
int32_t result_bstrins_w_si2;
int32_t result_bstrpick_w_si1;
int32_t result_bstrpick_w_si2;
};
T t;
__ Ld_d(a4, MemOperand(a0, offsetof(T, si1)));
__ Ld_d(a5, MemOperand(a0, offsetof(T, si2)));
// ext_w_b
__ ext_w_b(t0, a4);
__ ext_w_b(t1, a5);
__ St_w(t0, MemOperand(a0, offsetof(T, result_ext_w_b_si1)));
__ St_w(t1, MemOperand(a0, offsetof(T, result_ext_w_b_si2)));
// ext_w_h
__ ext_w_h(t0, a4);
__ ext_w_h(t1, a5);
__ St_w(t0, MemOperand(a0, offsetof(T, result_ext_w_h_si1)));
__ St_w(t1, MemOperand(a0, offsetof(T, result_ext_w_h_si2)));
/* //clo_w
__ clo_w(t0, a4);
__ clo_w(t1, a5);
__ St_w(t0, MemOperand(a0, offsetof(T, result_clo_w_si1)));
__ St_w(t1, MemOperand(a0, offsetof(T, result_clo_w_si2)));*/
// clz_w
__ clz_w(t0, a4);
__ clz_w(t1, a5);
__ St_w(t0, MemOperand(a0, offsetof(T, result_clz_w_si1)));
__ St_w(t1, MemOperand(a0, offsetof(T, result_clz_w_si2)));
/* //cto_w
__ cto_w(t0, a4);
__ cto_w(t1, a5);
__ St_w(t0, MemOperand(a0, offsetof(T, result_cto_w_si1)));
__ St_w(t1, MemOperand(a0, offsetof(T, result_cto_w_si2)));*/
// ctz_w
__ ctz_w(t0, a4);
__ ctz_w(t1, a5);
__ St_w(t0, MemOperand(a0, offsetof(T, result_ctz_w_si1)));
__ St_w(t1, MemOperand(a0, offsetof(T, result_ctz_w_si2)));
// bytepick_w
__ bytepick_w(t0, a4, a5, 0);
__ bytepick_w(t1, a5, a4, 2);
__ St_w(t0, MemOperand(a0, offsetof(T, result_bytepick_w_si1)));
__ St_w(t1, MemOperand(a0, offsetof(T, result_bytepick_w_si2)));
// revb_2h
__ revb_2h(t0, a4);
__ revb_2h(t1, a5);
__ St_w(t0, MemOperand(a0, offsetof(T, result_revb_2h_si1)));
__ St_w(t1, MemOperand(a0, offsetof(T, result_revb_2h_si2)));
// bitrev
__ bitrev_4b(t0, a4);
__ bitrev_4b(t1, a5);
__ St_w(t0, MemOperand(a0, offsetof(T, result_bitrev_4b_si1)));
__ St_w(t1, MemOperand(a0, offsetof(T, result_bitrev_4b_si2)));
// bitrev_w
__ bitrev_w(t0, a4);
__ bitrev_w(t1, a5);
__ St_w(t0, MemOperand(a0, offsetof(T, result_bitrev_w_si1)));
__ St_w(t1, MemOperand(a0, offsetof(T, result_bitrev_w_si2)));
// bstrins
__ or_(t0, zero_reg, zero_reg);
__ or_(t1, zero_reg, zero_reg);
__ bstrins_w(t0, a4, 0xD, 0x4);
__ bstrins_w(t1, a5, 0x16, 0x5);
__ St_w(t0, MemOperand(a0, offsetof(T, result_bstrins_w_si1)));
__ St_w(t1, MemOperand(a0, offsetof(T, result_bstrins_w_si2)));
// bstrpick
__ or_(t0, zero_reg, zero_reg);
__ or_(t1, zero_reg, zero_reg);
__ bstrpick_w(t0, a4, 0xD, 0x4);
__ bstrpick_w(t1, a5, 0x16, 0x5);
__ St_w(t0, MemOperand(a0, offsetof(T, result_bstrpick_w_si1)));
__ St_w(t1, MemOperand(a0, offsetof(T, result_bstrpick_w_si2)));
__ jirl(zero_reg, ra, 0);
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::FOR_TESTING).Build();
auto f = GeneratedCode<F3>::FromCode(*code);
t.si1 = 0x51F4B764A26E7412;
t.si2 = 0x81F25A87C423B891;
f.Call(&t, 0, 0, 0, 0);
CHECK_EQ(static_cast<int32_t>(0x12), t.result_ext_w_b_si1);
CHECK_EQ(static_cast<int32_t>(0xffffff91), t.result_ext_w_b_si2);
CHECK_EQ(static_cast<int32_t>(0x7412), t.result_ext_w_h_si1);
CHECK_EQ(static_cast<int32_t>(0xffffb891), t.result_ext_w_h_si2);
// CHECK_EQ(static_cast<int32_t>(0x1), t.result_clo_w_si1);
// CHECK_EQ(static_cast<int32_t>(0x2), t.result_clo_w_si2);
CHECK_EQ(static_cast<int32_t>(0x0), t.result_clz_w_si1);
CHECK_EQ(static_cast<int32_t>(0x0), t.result_clz_w_si2);
// CHECK_EQ(static_cast<int32_t>(0x0), t.result_cto_w_si1);
// CHECK_EQ(static_cast<int32_t>(0x1), t.result_cto_w_si2);
CHECK_EQ(static_cast<int32_t>(0x1), t.result_ctz_w_si1);
CHECK_EQ(static_cast<int32_t>(0x0), t.result_ctz_w_si2);
CHECK_EQ(static_cast<int32_t>(0xc423b891), t.result_bytepick_w_si1);
CHECK_EQ(static_cast<int32_t>(0x7412c423),
t.result_bytepick_w_si2); // 0xffffc423
CHECK_EQ(static_cast<int32_t>(0x6ea21274), t.result_revb_2h_si1);
CHECK_EQ(static_cast<int32_t>(0x23c491b8), t.result_revb_2h_si2);
CHECK_EQ(static_cast<int32_t>(0x45762e48), t.result_bitrev_4b_si1);
CHECK_EQ(static_cast<int32_t>(0x23c41d89), t.result_bitrev_4b_si2);
CHECK_EQ(static_cast<int32_t>(0x482e7645), t.result_bitrev_w_si1);
CHECK_EQ(static_cast<int32_t>(0x891dc423), t.result_bitrev_w_si2);
CHECK_EQ(static_cast<int32_t>(0x120), t.result_bstrins_w_si1);
CHECK_EQ(static_cast<int32_t>(0x771220), t.result_bstrins_w_si2);
CHECK_EQ(static_cast<int32_t>(0x341), t.result_bstrpick_w_si1);
CHECK_EQ(static_cast<int32_t>(0x11dc4), t.result_bstrpick_w_si2);
}
TEST(LA11) {
// Test 64bit bit operation instructions.
CcTest::InitializeVM();
Isolate* isolate = CcTest::i_isolate();
HandleScope scope(isolate);
MacroAssembler assm(isolate, v8::internal::CodeObjectRequired::kYes);
struct T {
int64_t si1;
int64_t si2;
int64_t result_clo_d_si1;
int64_t result_clo_d_si2;
int64_t result_clz_d_si1;
int64_t result_clz_d_si2;
int64_t result_cto_d_si1;
int64_t result_cto_d_si2;
int64_t result_ctz_d_si1;
int64_t result_ctz_d_si2;
int64_t result_bytepick_d_si1;
int64_t result_bytepick_d_si2;
int64_t result_revb_4h_si1;
int64_t result_revb_4h_si2;
int64_t result_revb_2w_si1;
int64_t result_revb_2w_si2;
int64_t result_revb_d_si1;
int64_t result_revb_d_si2;
int64_t result_revh_2w_si1;
int64_t result_revh_2w_si2;
int64_t result_revh_d_si1;
int64_t result_revh_d_si2;
int64_t result_bitrev_8b_si1;
int64_t result_bitrev_8b_si2;
int64_t result_bitrev_d_si1;
int64_t result_bitrev_d_si2;
int64_t result_bstrins_d_si1;
int64_t result_bstrins_d_si2;
int64_t result_bstrpick_d_si1;
int64_t result_bstrpick_d_si2;
int64_t result_maskeqz_si1;
int64_t result_maskeqz_si2;
int64_t result_masknez_si1;
int64_t result_masknez_si2;
};
T t;
__ Ld_d(a4, MemOperand(a0, offsetof(T, si1)));
__ Ld_d(a5, MemOperand(a0, offsetof(T, si2)));
/* //clo_d
__ clo_d(t0, a4);
__ clo_d(t1, a5);
__ St_w(t0, MemOperand(a0, offsetof(T, result_clo_d_si1)));
__ St_w(t1, MemOperand(a0, offsetof(T, result_clo_d_si2)));*/
// clz_d
__ or_(t0, zero_reg, zero_reg);
__ clz_d(t0, a4);
__ clz_d(t1, a5);
__ St_d(t0, MemOperand(a0, offsetof(T, result_clz_d_si1)));
__ St_d(t1, MemOperand(a0, offsetof(T, result_clz_d_si2)));
/* //cto_d
__ cto_d(t0, a4);
__ cto_d(t1, a5);
__ St_w(t0, MemOperand(a0, offsetof(T, result_cto_d_si1)));
__ St_w(t1, MemOperand(a0, offsetof(T, result_cto_d_si2)));*/
// ctz_d
__ ctz_d(t0, a4);
__ ctz_d(t1, a5);
__ St_d(t0, MemOperand(a0, offsetof(T, result_ctz_d_si1)));
__ St_d(t1, MemOperand(a0, offsetof(T, result_ctz_d_si2)));
// bytepick_d
__ bytepick_d(t0, a4, a5, 0);
__ bytepick_d(t1, a5, a4, 5);
__ St_d(t0, MemOperand(a0, offsetof(T, result_bytepick_d_si1)));
__ St_d(t1, MemOperand(a0, offsetof(T, result_bytepick_d_si2)));
// revb_4h
__ revb_4h(t0, a4);
__ revb_4h(t1, a5);
__ St_d(t0, MemOperand(a0, offsetof(T, result_revb_4h_si1)));
__ St_d(t1, MemOperand(a0, offsetof(T, result_revb_4h_si2)));
// revb_2w
__ revb_2w(t0, a4);
__ revb_2w(t1, a5);
__ St_d(t0, MemOperand(a0, offsetof(T, result_revb_2w_si1)));
__ St_d(t1, MemOperand(a0, offsetof(T, result_revb_2w_si2)));
// revb_d
__ revb_d(t0, a4);
__ revb_d(t1, a5);
__ St_d(t0, MemOperand(a0, offsetof(T, result_revb_d_si1)));
__ St_d(t1, MemOperand(a0, offsetof(T, result_revb_d_si2)));
// revh_2w
__ revh_2w(t0, a4);
__ revh_2w(t1, a5);
__ St_d(t0, MemOperand(a0, offsetof(T, result_revh_2w_si1)));
__ St_d(t1, MemOperand(a0, offsetof(T, result_revh_2w_si2)));
// revh_d
__ revh_d(t0, a4);
__ revh_d(t1, a5);
__ St_d(t0, MemOperand(a0, offsetof(T, result_revh_d_si1)));
__ St_d(t1, MemOperand(a0, offsetof(T, result_revh_d_si2)));
// bitrev_8b
__ bitrev_8b(t0, a4);
__ bitrev_8b(t1, a5);
__ St_d(t0, MemOperand(a0, offsetof(T, result_bitrev_8b_si1)));
__ St_d(t1, MemOperand(a0, offsetof(T, result_bitrev_8b_si2)));
// bitrev_d
__ bitrev_d(t0, a4);
__ bitrev_d(t1, a5);
__ St_d(t0, MemOperand(a0, offsetof(T, result_bitrev_d_si1)));
__ St_d(t1, MemOperand(a0, offsetof(T, result_bitrev_d_si2)));
// bstrins_d
__ or_(t0, zero_reg, zero_reg);
__ or_(t1, zero_reg, zero_reg);
__ bstrins_d(t0, a4, 5, 0);
__ bstrins_d(t1, a5, 39, 12);
__ St_d(t0, MemOperand(a0, offsetof(T, result_bstrins_d_si1)));
__ St_d(t1, MemOperand(a0, offsetof(T, result_bstrins_d_si2)));
// bstrpick_d
__ or_(t0, zero_reg, zero_reg);
__ or_(t1, zero_reg, zero_reg);
__ bstrpick_d(t0, a4, 5, 0);
__ bstrpick_d(t1, a5, 63, 48);
__ St_d(t0, MemOperand(a0, offsetof(T, result_bstrpick_d_si1)));
__ St_d(t1, MemOperand(a0, offsetof(T, result_bstrpick_d_si2)));
// maskeqz
__ maskeqz(t0, a4, a4);
__ maskeqz(t1, a5, zero_reg);
__ St_d(t0, MemOperand(a0, offsetof(T, result_maskeqz_si1)));
__ St_d(t1, MemOperand(a0, offsetof(T, result_maskeqz_si2)));
// masknez
__ masknez(t0, a4, a4);
__ masknez(t1, a5, zero_reg);
__ St_d(t0, MemOperand(a0, offsetof(T, result_masknez_si1)));
__ St_d(t1, MemOperand(a0, offsetof(T, result_masknez_si2)));
__ jirl(zero_reg, ra, 0);
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::FOR_TESTING).Build();
auto f = GeneratedCode<F3>::FromCode(*code);
t.si1 = 0x10C021098B710CDE;
t.si2 = 0xFB8017FF781A15C3;
f.Call(&t, 0, 0, 0, 0);
// CHECK_EQ(static_cast<int64_t>(0x0), t.result_clo_d_si1);
// CHECK_EQ(static_cast<int64_t>(0x5), t.result_clo_d_si2);
CHECK_EQ(static_cast<int64_t>(0x3), t.result_clz_d_si1);
CHECK_EQ(static_cast<int64_t>(0x0), t.result_clz_d_si2);
// CHECK_EQ(static_cast<int64_t>(0x0), t.result_cto_d_si1);
// CHECK_EQ(static_cast<int64_t>(0x2), t.result_cto_d_si2);
CHECK_EQ(static_cast<int64_t>(0x1), t.result_ctz_d_si1);
CHECK_EQ(static_cast<int64_t>(0x0), t.result_ctz_d_si2);
CHECK_EQ(static_cast<int64_t>(0xfb8017ff781a15c3), t.result_bytepick_d_si1);
CHECK_EQ(static_cast<int64_t>(0x710cdefb8017ff78), t.result_bytepick_d_si2);
CHECK_EQ(static_cast<int64_t>(0xc0100921718bde0c), t.result_revb_4h_si1);
CHECK_EQ(static_cast<int64_t>(0x80fbff171a78c315), t.result_revb_4h_si2);
CHECK_EQ(static_cast<int64_t>(0x921c010de0c718b), t.result_revb_2w_si1);
CHECK_EQ(static_cast<int64_t>(0xff1780fbc3151a78), t.result_revb_2w_si2);
CHECK_EQ(static_cast<int64_t>(0xde0c718b0921c010), t.result_revb_d_si1);
CHECK_EQ(static_cast<int64_t>(0xc3151a78ff1780fb), t.result_revb_d_si2);
CHECK_EQ(static_cast<int64_t>(0x210910c00cde8b71), t.result_revh_2w_si1);
CHECK_EQ(static_cast<int64_t>(0x17fffb8015c3781a), t.result_revh_2w_si2);
CHECK_EQ(static_cast<int64_t>(0xcde8b71210910c0), t.result_revh_d_si1);
CHECK_EQ(static_cast<int64_t>(0x15c3781a17fffb80), t.result_revh_d_si2);
CHECK_EQ(static_cast<int64_t>(0x8038490d18e307b), t.result_bitrev_8b_si1);
CHECK_EQ(static_cast<int64_t>(0xdf01e8ff1e58a8c3), t.result_bitrev_8b_si2);
CHECK_EQ(static_cast<int64_t>(0x7b308ed190840308), t.result_bitrev_d_si1);
CHECK_EQ(static_cast<int64_t>(0xc3a8581effe801df), t.result_bitrev_d_si2);
CHECK_EQ(static_cast<int64_t>(0x1e), t.result_bstrins_d_si1);
CHECK_EQ(static_cast<int64_t>(0x81a15c3000), t.result_bstrins_d_si2);
CHECK_EQ(static_cast<int64_t>(0x1e), t.result_bstrpick_d_si1);
CHECK_EQ(static_cast<int64_t>(0xfb80), t.result_bstrpick_d_si2);
CHECK_EQ(static_cast<int64_t>(0x10C021098B710CDE), t.result_maskeqz_si1);
CHECK_EQ(static_cast<int64_t>(0), t.result_maskeqz_si2);
CHECK_EQ(static_cast<int64_t>(0), t.result_masknez_si1);
CHECK_EQ(static_cast<int64_t>(0xFB8017FF781A15C3), t.result_masknez_si2);
}
uint64_t run_beq(int64_t value1, int64_t value2, int16_t offset) {
Isolate* isolate = CcTest::i_isolate();
HandleScope scope(isolate);
MacroAssembler assm(isolate, v8::internal::CodeObjectRequired::kYes);
Label main_block, L;
__ li(a2, 0l);
__ b(&main_block);
// Block 1
__ addi_d(a2, a2, 0x1);
__ addi_d(a2, a2, 0x2);
__ b(&L);
// Block 2
__ addi_d(a2, a2, 0x10);
__ addi_d(a2, a2, 0x20);
__ b(&L);
// Block 3 (Main)
__ bind(&main_block);
__ beq(a0, a1, offset);
__ bind(&L);
__ or_(a0, a2, zero_reg);
__ jirl(zero_reg, ra, 0);
// Block 4
__ addi_d(a2, a2, 0x100);
__ addi_d(a2, a2, 0x200);
__ b(&L);
// Block 5
__ addi_d(a2, a2, 0x300);
__ addi_d(a2, a2, 0x400);
__ b(&L);
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::FOR_TESTING).Build();
auto f = GeneratedCode<F2>::FromCode(*code);
uint64_t res = reinterpret_cast<uint64_t>(f.Call(value1, value2, 0, 0, 0));
return res;
}
TEST(BEQ) {
CcTest::InitializeVM();
struct TestCaseBeq {
int64_t value1;
int64_t value2;
int16_t offset;
uint64_t expected_res;
};
// clang-format off
struct TestCaseBeq tc[] = {
// value1, value2, offset, expected_res
{ 0, 0, -6, 0x3 },
{ 1, 1, -3, 0x30 },
{ -2, -2, 3, 0x300 },
{ 3, -3, 6, 0 },
{ 4, 4, 6, 0x700 },
};
// clang-format on
size_t nr_test_cases = sizeof(tc) / sizeof(TestCaseBeq);
for (size_t i = 0; i < nr_test_cases; ++i) {
uint64_t res = run_beq(tc[i].value1, tc[i].value2, tc[i].offset);
CHECK_EQ(tc[i].expected_res, res);
}
}
uint64_t run_bne(int64_t value1, int64_t value2, int16_t offset) {
Isolate* isolate = CcTest::i_isolate();
HandleScope scope(isolate);
MacroAssembler assm(isolate, v8::internal::CodeObjectRequired::kYes);
Label main_block, L;
__ li(a2, 0l);
__ b(&main_block);
// Block 1
__ addi_d(a2, a2, 0x1);
__ addi_d(a2, a2, 0x2);
__ b(&L);
// Block 2
__ addi_d(a2, a2, 0x10);
__ addi_d(a2, a2, 0x20);
__ b(&L);
// Block 3 (Main)
__ bind(&main_block);
__ bne(a0, a1, offset);
__ bind(&L);
__ or_(a0, a2, zero_reg);
__ jirl(zero_reg, ra, 0);
// Block 4
__ addi_d(a2, a2, 0x100);
__ addi_d(a2, a2, 0x200);
__ b(&L);
// Block 5
__ addi_d(a2, a2, 0x300);
__ addi_d(a2, a2, 0x400);
__ b(&L);
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::FOR_TESTING).Build();
auto f = GeneratedCode<F2>::FromCode(*code);
uint64_t res = reinterpret_cast<uint64_t>(f.Call(value1, value2, 0, 0, 0));
return res;
}
TEST(BNE) {
CcTest::InitializeVM();
struct TestCaseBne {
int64_t value1;
int64_t value2;
int16_t offset;
uint64_t expected_res;
};
// clang-format off
struct TestCaseBne tc[] = {
// value1, value2, offset, expected_res
{ 1, -1, -6, 0x3 },
{ 2, -2, -3, 0x30 },
{ 3, -3, 3, 0x300 },
{ 4, -4, 6, 0x700 },
{ 0, 0, 6, 0 },
};
// clang-format on
size_t nr_test_cases = sizeof(tc) / sizeof(TestCaseBne);
for (size_t i = 0; i < nr_test_cases; ++i) {
uint64_t res = run_bne(tc[i].value1, tc[i].value2, tc[i].offset);
CHECK_EQ(tc[i].expected_res, res);
}
}
uint64_t run_blt(int64_t value1, int64_t value2, int16_t offset) {
Isolate* isolate = CcTest::i_isolate();
HandleScope scope(isolate);
MacroAssembler assm(isolate, v8::internal::CodeObjectRequired::kYes);
Label main_block, L;
__ li(a2, 0l);
__ b(&main_block);
// Block 1
__ addi_d(a2, a2, 0x1);
__ addi_d(a2, a2, 0x2);
__ b(&L);
// Block 2
__ addi_d(a2, a2, 0x10);
__ addi_d(a2, a2, 0x20);
__ b(&L);
// Block 3 (Main)
__ bind(&main_block);
__ blt(a0, a1, offset);
__ bind(&L);
__ or_(a0, a2, zero_reg);
__ jirl(zero_reg, ra, 0);
// Block 4
__ addi_d(a2, a2, 0x100);
__ addi_d(a2, a2, 0x200);
__ b(&L);
// Block 5
__ addi_d(a2, a2, 0x300);
__ addi_d(a2, a2, 0x400);
__ b(&L);
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::FOR_TESTING).Build();
auto f = GeneratedCode<F2>::FromCode(*code);
uint64_t res = reinterpret_cast<uint64_t>(f.Call(value1, value2, 0, 0, 0));
return res;
}
TEST(BLT) {
CcTest::InitializeVM();
struct TestCaseBlt {
int64_t value1;
int64_t value2;
int16_t offset;
uint64_t expected_res;
};
// clang-format off
struct TestCaseBlt tc[] = {
// value1, value2, offset, expected_res
{ -1, 1, -6, 0x3 },
{ -2, 2, -3, 0x30 },
{ -3, 3, 3, 0x300 },
{ -4, 4, 6, 0x700 },
{ 5, -5, 6, 0 },
{ 0, 0, 6, 0 },
};
// clang-format on
size_t nr_test_cases = sizeof(tc) / sizeof(TestCaseBlt);
for (size_t i = 0; i < nr_test_cases; ++i) {
uint64_t res = run_blt(tc[i].value1, tc[i].value2, tc[i].offset);
CHECK_EQ(tc[i].expected_res, res);
}
}
uint64_t run_bge(uint64_t value1, uint64_t value2, int16_t offset) {
Isolate* isolate = CcTest::i_isolate();
HandleScope scope(isolate);
MacroAssembler assm(isolate, v8::internal::CodeObjectRequired::kYes);
Label main_block, L;
__ li(a2, 0l);
__ b(&main_block);
// Block 1
__ addi_d(a2, a2, 0x1);
__ addi_d(a2, a2, 0x2);
__ b(&L);
// Block 2
__ addi_d(a2, a2, 0x10);
__ addi_d(a2, a2, 0x20);
__ b(&L);
// Block 3 (Main)
__ bind(&main_block);
__ bge(a0, a1, offset);
__ bind(&L);
__ or_(a0, a2, zero_reg);
__ jirl(zero_reg, ra, 0);
// Block 4
__ addi_d(a2, a2, 0x100);
__ addi_d(a2, a2, 0x200);
__ b(&L);
// Block 5
__ addi_d(a2, a2, 0x300);
__ addi_d(a2, a2, 0x400);
__ b(&L);
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::FOR_TESTING).Build();
auto f = GeneratedCode<F2>::FromCode(*code);
uint64_t res = reinterpret_cast<uint64_t>(f.Call(value1, value2, 0, 0, 0));
return res;
}
TEST(BGE) {
CcTest::InitializeVM();
struct TestCaseBge {
int64_t value1;
int64_t value2;
int16_t offset;
uint64_t expected_res;
};
// clang-format off
struct TestCaseBge tc[] = {
// value1, value2, offset, expected_res
{ 0, 0, -6, 0x3 },
{ 1, 1, -3, 0x30 },
{ 2, -2, 3, 0x300 },
{ 3, -3, 6, 0x700 },
{ -4, 4, 6, 0 },
};
// clang-format on
size_t nr_test_cases = sizeof(tc) / sizeof(TestCaseBge);
for (size_t i = 0; i < nr_test_cases; ++i) {
uint64_t res = run_bge(tc[i].value1, tc[i].value2, tc[i].offset);
CHECK_EQ(tc[i].expected_res, res);
}
}
uint64_t run_bltu(int64_t value1, int64_t value2, int16_t offset) {
Isolate* isolate = CcTest::i_isolate();
HandleScope scope(isolate);
MacroAssembler assm(isolate, v8::internal::CodeObjectRequired::kYes);
Label main_block, L;
__ li(a2, 0l);
__ b(&main_block);
// Block 1
__ addi_d(a2, a2, 0x1);
__ addi_d(a2, a2, 0x2);
__ b(&L);
// Block 2
__ addi_d(a2, a2, 0x10);
__ addi_d(a2, a2, 0x20);
__ b(&L);
// Block 3 (Main)
__ bind(&main_block);
__ bltu(a0, a1, offset);
__ bind(&L);
__ or_(a0, a2, zero_reg);
__ jirl(zero_reg, ra, 0);
// Block 4
__ addi_d(a2, a2, 0x100);
__ addi_d(a2, a2, 0x200);
__ b(&L);
// Block 5
__ addi_d(a2, a2, 0x300);
__ addi_d(a2, a2, 0x400);
__ b(&L);
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::FOR_TESTING).Build();
auto f = GeneratedCode<F2>::FromCode(*code);
uint64_t res = reinterpret_cast<uint64_t>(f.Call(value1, value2, 0, 0, 0));
return res;
}
TEST(BLTU) {
CcTest::InitializeVM();
struct TestCaseBltu {
int64_t value1;
int64_t value2;
int16_t offset;
uint64_t expected_res;
};
// clang-format off
struct TestCaseBltu tc[] = {
// value1, value2, offset, expected_res
{ 0, 1, -6, 0x3 },
{ 1, -1, -3, 0x30 },
{ 2, -2, 3, 0x300 },
{ 3, -3, 6, 0x700 },
{ 4, 4, 6, 0 },
};
// clang-format on
size_t nr_test_cases = sizeof(tc) / sizeof(TestCaseBltu);
for (size_t i = 0; i < nr_test_cases; ++i) {
uint64_t res = run_bltu(tc[i].value1, tc[i].value2, tc[i].offset);
CHECK_EQ(tc[i].expected_res, res);
}
}
uint64_t run_bgeu(int64_t value1, int64_t value2, int16_t offset) {
Isolate* isolate = CcTest::i_isolate();
HandleScope scope(isolate);
MacroAssembler assm(isolate, v8::internal::CodeObjectRequired::kYes);
Label main_block, L;
__ li(a2, 0l);
__ b(&main_block);
// Block 1
__ addi_d(a2, a2, 0x1);
__ addi_d(a2, a2, 0x2);
__ b(&L);
// Block 2
__ addi_d(a2, a2, 0x10);
__ addi_d(a2, a2, 0x20);
__ b(&L);
// Block 3 (Main)
__ bind(&main_block);
__ bgeu(a0, a1, offset);
__ bind(&L);
__ or_(a0, a2, zero_reg);
__ jirl(zero_reg, ra, 0);
// Block 4
__ addi_d(a2, a2, 0x100);
__ addi_d(a2, a2, 0x200);
__ b(&L);
// Block 5
__ addi_d(a2, a2, 0x300);
__ addi_d(a2, a2, 0x400);
__ b(&L);
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::FOR_TESTING).Build();
auto f = GeneratedCode<F2>::FromCode(*code);
uint64_t res = reinterpret_cast<uint64_t>(f.Call(value1, value2, 0, 0, 0));
return res;
}
TEST(BGEU) {
CcTest::InitializeVM();
struct TestCaseBgeu {
int64_t value1;
int64_t value2;
int16_t offset;
uint64_t expected_res;
};
// clang-format off
struct TestCaseBgeu tc[] = {
// value1, value2, offset, expected_res
{ 0, 0, -6, 0x3 },
{ -1, 1, -3, 0x30 },
{ -2, 2, 3, 0x300 },
{ -3, 3, 6, 0x700 },
{ 4, -4, 6, 0 },
};
// clang-format on
size_t nr_test_cases = sizeof(tc) / sizeof(TestCaseBgeu);
for (size_t i = 0; i < nr_test_cases; ++i) {
uint64_t res = run_bgeu(tc[i].value1, tc[i].value2, tc[i].offset);
CHECK_EQ(tc[i].expected_res, res);
}
}
uint64_t run_beqz(int64_t value, int32_t offset) {
Isolate* isolate = CcTest::i_isolate();
HandleScope scope(isolate);
MacroAssembler assm(isolate, v8::internal::CodeObjectRequired::kYes);
Label main_block, L;
__ li(a2, 0l);
__ b(&main_block);
// Block 1
__ addi_d(a2, a2, 0x1);
__ addi_d(a2, a2, 0x2);
__ b(&L);
// Block 2
__ addi_d(a2, a2, 0x10);
__ addi_d(a2, a2, 0x20);
__ b(&L);
// Block 3 (Main)
__ bind(&main_block);
__ beqz(a0, offset);
__ bind(&L);
__ or_(a0, a2, zero_reg);
__ jirl(zero_reg, ra, 0);
// Block 4
__ addi_d(a2, a2, 0x100);
__ addi_d(a2, a2, 0x200);
__ b(&L);
// Block 5
__ addi_d(a2, a2, 0x300);
__ addi_d(a2, a2, 0x400);
__ b(&L);
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::FOR_TESTING).Build();
auto f = GeneratedCode<F2>::FromCode(*code);
uint64_t res = reinterpret_cast<uint64_t>(f.Call(value, 0, 0, 0, 0));
return res;
}
TEST(BEQZ) {
CcTest::InitializeVM();
struct TestCaseBeqz {
int64_t value;
int32_t offset;
uint64_t expected_res;
};
// clang-format off
struct TestCaseBeqz tc[] = {
// value, offset, expected_res
{ 0, -6, 0x3 },
{ 0, -3, 0x30 },
{ 0, 3, 0x300 },
{ 0, 6, 0x700 },
{ 1, 6, 0 },
};
// clang-format on
size_t nr_test_cases = sizeof(tc) / sizeof(TestCaseBeqz);
for (size_t i = 0; i < nr_test_cases; ++i) {
uint64_t res = run_beqz(tc[i].value, tc[i].offset);
CHECK_EQ(tc[i].expected_res, res);
}
}
uint64_t run_bnez_b(int64_t value, int32_t offset) {
// bnez, b.
Isolate* isolate = CcTest::i_isolate();
HandleScope scope(isolate);
MacroAssembler assm(isolate, v8::internal::CodeObjectRequired::kYes);
Label main_block, L;
__ li(a2, 0l);
__ b(&main_block);
// Block 1
__ addi_d(a2, a2, 0x1);
__ addi_d(a2, a2, 0x2);
__ b(5);
// Block 2
__ addi_d(a2, a2, 0x10);
__ addi_d(a2, a2, 0x20);
__ b(2);
// Block 3 (Main)
__ bind(&main_block);
__ bnez(a0, offset);
__ bind(&L);
__ or_(a0, a2, zero_reg);
__ jirl(zero_reg, ra, 0);
// Block 4
__ addi_d(a2, a2, 0x100);
__ addi_d(a2, a2, 0x200);
__ b(-4);
// Block 5
__ addi_d(a2, a2, 0x300);
__ addi_d(a2, a2, 0x400);
__ b(-7);
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::FOR_TESTING).Build();
auto f = GeneratedCode<F2>::FromCode(*code);
uint64_t res = reinterpret_cast<uint64_t>(f.Call(value, 0, 0, 0, 0));
return res;
}
TEST(BNEZ_B) {
CcTest::InitializeVM();
struct TestCaseBnez {
int64_t value;
int32_t offset;
uint64_t expected_res;
};
// clang-format off
struct TestCaseBnez tc[] = {
// value, offset, expected_res
{ 1, -6, 0x3 },
{ -2, -3, 0x30 },
{ 3, 3, 0x300 },
{ -4, 6, 0x700 },
{ 0, 6, 0 },
};
// clang-format on
size_t nr_test_cases = sizeof(tc) / sizeof(TestCaseBnez);
for (size_t i = 0; i < nr_test_cases; ++i) {
uint64_t res = run_bnez_b(tc[i].value, tc[i].offset);
CHECK_EQ(tc[i].expected_res, res);
}
}
uint64_t run_bl(int32_t offset) {
Isolate* isolate = CcTest::i_isolate();
HandleScope scope(isolate);
MacroAssembler assm(isolate, v8::internal::CodeObjectRequired::kYes);
Label main_block;
__ li(a2, 0l);
__ Push(ra); // Push is implemented by two instructions, addi_d and st_d
__ b(&main_block);
// Block 1
__ addi_d(a2, a2, 0x1);
__ addi_d(a2, a2, 0x2);
__ jirl(zero_reg, ra, 0);
// Block 2
__ addi_d(a2, a2, 0x10);
__ addi_d(a2, a2, 0x20);
__ jirl(zero_reg, ra, 0);
// Block 3 (Main)
__ bind(&main_block);
__ bl(offset);
__ or_(a0, a2, zero_reg);
__ Pop(ra); // Pop is implemented by two instructions, ld_d and addi_d.
__ jirl(zero_reg, ra, 0);
// Block 4
__ addi_d(a2, a2, 0x100);
__ addi_d(a2, a2, 0x200);
__ jirl(zero_reg, ra, 0);
// Block 5
__ addi_d(a2, a2, 0x300);
__ addi_d(a2, a2, 0x400);
__ jirl(zero_reg, ra, 0);
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::FOR_TESTING).Build();
auto f = GeneratedCode<F2>::FromCode(*code);
uint64_t res = reinterpret_cast<uint64_t>(f.Call(0, 0, 0, 0, 0));
return res;
}
TEST(BL) {
CcTest::InitializeVM();
struct TestCaseBl {
int32_t offset;
uint64_t expected_res;
};
// clang-format off
struct TestCaseBl tc[] = {
// offset, expected_res
{ -6, 0x3 },
{ -3, 0x30 },
{ 5, 0x300 },
{ 8, 0x700 },
};
// clang-format on
size_t nr_test_cases = sizeof(tc) / sizeof(TestCaseBl);
for (size_t i = 0; i < nr_test_cases; ++i) {
uint64_t res = run_bl(tc[i].offset);
CHECK_EQ(tc[i].expected_res, res);
}
}
TEST(PCADD) {
CcTest::InitializeVM();
Isolate* isolate = CcTest::i_isolate();
HandleScope scope(isolate);
MacroAssembler assm(isolate, v8::internal::CodeObjectRequired::kYes);
Label exit, error;
__ Push(ra);
// pcaddi
__ li(a4, 0x1FFFFC);
__ li(a5, 0);
__ li(a6, static_cast<int32_t>(0xFFE00000));
__ bl(1);
__ pcaddi(a3, 0x7FFFF);
__ add_d(a2, ra, a4);
__ Branch(&error, ne, a2, Operand(a3));
__ bl(1);
__ pcaddi(a3, 0);
__ add_d(a2, ra, a5);
__ Branch(&error, ne, a2, Operand(a3));
__ bl(1);
__ pcaddi(a3, 0x80000);
__ add_d(a2, ra, a6);
__ Branch(&error, ne, a2, Operand(a3));
// pcaddu12i
__ li(a4, 0x7FFFF000);
__ li(a5, 0);
__ li(a6, static_cast<int32_t>(0x80000000));
__ bl(1);
__ pcaddu12i(a2, 0x7FFFF);
__ add_d(a3, ra, a4);
__ Branch(&error, ne, a2, Operand(a3));
__ bl(1);
__ pcaddu12i(a2, 0);
__ add_d(a3, ra, a5);
__ Branch(&error, ne, a2, Operand(a3));
__ bl(1);
__ pcaddu12i(a2, 0x80000);
__ add_d(a3, ra, a6);
__ Branch(&error, ne, a2, Operand(a3));
// pcaddu18i
__ li(a4, 0x1FFFFC0000);
__ li(a5, 0);
__ li(a6, static_cast<int64_t>(0xFFFFFFE000000000));
__ bl(1);
__ pcaddu18i(a2, 0x7FFFF);
__ add_d(a3, ra, a4);
__ Branch(&error, ne, a2, Operand(a3));
__ bl(1);
__ pcaddu18i(a2, 0);
__ add_d(a3, ra, a5);
__ Branch(&error, ne, a2, Operand(a3));
__ bl(1);
__ pcaddu18i(a2, 0x80000);
__ add_d(a3, ra, a6);
__ Branch(&error, ne, a2, Operand(a3));
// pcalau12i
__ li(a4, 0x7FFFF000);
__ li(a5, 0);
__ li(a6, static_cast<int32_t>(0x80000000));
__ li(a7, static_cast<int64_t>(0xFFFFFFFFFFFFF000));
__ bl(1);
__ pcalau12i(a3, 0x7FFFF);
__ add_d(a2, ra, a4);
__ and_(t0, a2, a7);
__ and_(t1, a3, a7);
__ Branch(&error, ne, t0, Operand(t1));
__ bl(1);
__ pcalau12i(a3, 0);
__ add_d(a2, ra, a5);
__ and_(t0, a2, a7);
__ and_(t1, a3, a7);
__ Branch(&error, ne, t0, Operand(t1));
__ bl(1);
__ pcalau12i(a2, 0x80000);
__ add_d(a3, ra, a6);
__ and_(t0, a2, a7);
__ and_(t1, a3, a7);
__ Branch(&error, ne, t0, Operand(t1));
__ li(a0, 0x31415926);
__ b(&exit);
__ bind(&error);
__ li(a0, 0x666);
__ bind(&exit);
__ Pop(ra);
__ jirl(zero_reg, ra, 0);
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::FOR_TESTING).Build();
auto f = GeneratedCode<F2>::FromCode(*code);
int64_t res = reinterpret_cast<int64_t>(f.Call(0, 0, 0, 0, 0));
CHECK_EQ(0x31415926L, res);
}
uint64_t run_jirl(int16_t offset) {
Isolate* isolate = CcTest::i_isolate();
HandleScope scope(isolate);
MacroAssembler assm(isolate, v8::internal::CodeObjectRequired::kYes);
Label main_block;
__ li(a2, 0l);
__ Push(ra);
__ b(&main_block);
// Block 1
__ addi_d(a2, a2, 0x1);
__ addi_d(a2, a2, 0x2);
__ jirl(zero_reg, ra, 0);
// Block 2
__ addi_d(a2, a2, 0x10);
__ addi_d(a2, a2, 0x20);
__ jirl(zero_reg, ra, 0);
// Block 3 (Main)
__ bind(&main_block);
__ pcaddi(a3, 1);
__ jirl(ra, a3, offset);
__ or_(a0, a2, zero_reg);
__ Pop(ra); // Pop is implemented by two instructions, ld_d and addi_d.
__ jirl(zero_reg, ra, 0);
// Block 4
__ addi_d(a2, a2, 0x100);
__ addi_d(a2, a2, 0x200);
__ jirl(zero_reg, ra, 0);
// Block 5
__ addi_d(a2, a2, 0x300);
__ addi_d(a2, a2, 0x400);
__ jirl(zero_reg, ra, 0);
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::FOR_TESTING).Build();
auto f = GeneratedCode<F2>::FromCode(*code);
uint64_t res = reinterpret_cast<uint64_t>(f.Call(0, 0, 0, 0, 0));
return res;
}
TEST(JIRL) {
CcTest::InitializeVM();
struct TestCaseJirl {
int16_t offset;
uint64_t expected_res;
};
// clang-format off
struct TestCaseJirl tc[] = {
// offset, expected_res
{ -7, 0x3 },
{ -4, 0x30 },
{ 5, 0x300 },
{ 8, 0x700 },
};
// clang-format on
size_t nr_test_cases = sizeof(tc) / sizeof(TestCaseJirl);
for (size_t i = 0; i < nr_test_cases; ++i) {
uint64_t res = run_jirl(tc[i].offset);
CHECK_EQ(tc[i].expected_res, res);
}
}
TEST(LA12) {
// Test floating point calculate instructions.
CcTest::InitializeVM();
Isolate* isolate = CcTest::i_isolate();
HandleScope scope(isolate);
struct T {
double a;
double b;
double c;
double d;
double e;
double f;
double result_fadd_d;
double result_fsub_d;
double result_fmul_d;
double result_fdiv_d;
double result_fmadd_d;
double result_fmsub_d;
double result_fnmadd_d;
double result_fnmsub_d;
double result_fsqrt_d;
double result_frecip_d;
double result_frsqrt_d;
double result_fscaleb_d;
double result_flogb_d;
double result_fcopysign_d;
double result_fclass_d;
};
T t;
MacroAssembler assm(isolate, v8::internal::CodeObjectRequired::kYes);
// Double precision floating point instructions.
__ Fld_d(f8, MemOperand(a0, offsetof(T, a)));
__ Fld_d(f9, MemOperand(a0, offsetof(T, b)));
__ fneg_d(f10, f8);
__ fadd_d(f11, f9, f10);
__ Fst_d(f11, MemOperand(a0, offsetof(T, result_fadd_d)));
__ fabs_d(f11, f11);
__ fsub_d(f12, f11, f9);
__ Fst_d(f12, MemOperand(a0, offsetof(T, result_fsub_d)));
__ Fld_d(f13, MemOperand(a0, offsetof(T, c)));
__ Fld_d(f14, MemOperand(a0, offsetof(T, d)));
__ Fld_d(f15, MemOperand(a0, offsetof(T, e)));
__ fmin_d(f16, f13, f14);
__ fmul_d(f17, f15, f16);
__ Fst_d(f17, MemOperand(a0, offsetof(T, result_fmul_d)));
__ fmax_d(f18, f13, f14);
__ fdiv_d(f19, f15, f18);
__ Fst_d(f19, MemOperand(a0, offsetof(T, result_fdiv_d)));
__ fmina_d(f16, f13, f14);
__ fmadd_d(f18, f17, f15, f16);
__ Fst_d(f18, MemOperand(a0, offsetof(T, result_fmadd_d)));
__ fnmadd_d(f19, f17, f15, f16);
__ Fst_d(f19, MemOperand(a0, offsetof(T, result_fnmadd_d)));
__ fmaxa_d(f16, f13, f14);
__ fmsub_d(f20, f17, f15, f16);
__ Fst_d(f20, MemOperand(a0, offsetof(T, result_fmsub_d)));
__ fnmsub_d(f21, f17, f15, f16);
__ Fst_d(f21, MemOperand(a0, offsetof(T, result_fnmsub_d)));
__ Fld_d(f8, MemOperand(a0, offsetof(T, f)));
__ fsqrt_d(f10, f8);
__ Fst_d(f10, MemOperand(a0, offsetof(T, result_fsqrt_d)));
//__ frecip_d(f11, f10);
//__ frsqrt_d(f12, f8);
//__ Fst_d(f11, MemOperand(a0, offsetof(T, result_frecip_d)));
//__ Fst_d(f12, MemOperand(a0, offsetof(T, result_frsqrt_d)));
/*__ fscaleb_d(f16, f13, f15);
__ flogb_d(f17, f15);
__ fcopysign_d(f18, f8, f9);
__ fclass_d(f19, f9);
__ Fst_d(f16, MemOperand(a0, offsetof(T, result_fscaleb_d)));
__ Fst_d(f17, MemOperand(a0, offsetof(T, result_flogb_d)));
__ Fst_d(f18, MemOperand(a0, offsetof(T, result_fcopysign_d)));
__ Fst_d(f19, MemOperand(a0, offsetof(T, result_fclass_d)));*/
__ jirl(zero_reg, ra, 0);
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::FOR_TESTING).Build();
auto f = GeneratedCode<F3>::FromCode(*code);
// Double test values.
t.a = 1.5e14;
t.b = -2.75e11;
t.c = 1.5;
t.d = -2.75;
t.e = 120.0;
t.f = 120.44;
f.Call(&t, 0, 0, 0, 0);
CHECK_EQ(static_cast<double>(-1.502750e14), t.result_fadd_d);
CHECK_EQ(static_cast<double>(1.505500e14), t.result_fsub_d);
CHECK_EQ(static_cast<double>(-3.300000e02), t.result_fmul_d);
CHECK_EQ(static_cast<double>(8.000000e01), t.result_fdiv_d);
CHECK_EQ(static_cast<double>(-3.959850e04), t.result_fmadd_d);
CHECK_EQ(static_cast<double>(-3.959725e04), t.result_fmsub_d);
CHECK_EQ(static_cast<double>(3.959850e04), t.result_fnmadd_d);
CHECK_EQ(static_cast<double>(3.959725e04), t.result_fnmsub_d);
CHECK_EQ(static_cast<double>(10.97451593465515908537), t.result_fsqrt_d);
// CHECK_EQ(static_cast<double>( 8.164965e-08), t.result_frecip_d);
// CHECK_EQ(static_cast<double>( 8.164966e-08), t.result_frsqrt_d);
// CHECK_EQ(static_cast<double>(), t.result_fscaleb_d);
// CHECK_EQ(static_cast<double>( 6.906891), t.result_flogb_d);
// CHECK_EQ(static_cast<double>( 2.75e11), t.result_fcopysign_d);
// CHECK_EQ(static_cast<double>(), t.result_fclass_d);
}
TEST(LA13) {
CcTest::InitializeVM();
Isolate* isolate = CcTest::i_isolate();
HandleScope scope(isolate);
struct T {
float a;
float b;
float c;
float d;
float e;
float result_fadd_s;
float result_fsub_s;
float result_fmul_s;
float result_fdiv_s;
float result_fmadd_s;
float result_fmsub_s;
float result_fnmadd_s;
float result_fnmsub_s;
float result_fsqrt_s;
float result_frecip_s;
float result_frsqrt_s;
float result_fscaleb_s;
float result_flogb_s;
float result_fcopysign_s;
float result_fclass_s;
};
T t;
MacroAssembler assm(isolate, v8::internal::CodeObjectRequired::kYes);
// Float precision floating point instructions.
__ Fld_s(f8, MemOperand(a0, offsetof(T, a)));
__ Fld_s(f9, MemOperand(a0, offsetof(T, b)));
__ fneg_s(f10, f8);
__ fadd_s(f11, f9, f10);
__ Fst_s(f11, MemOperand(a0, offsetof(T, result_fadd_s)));
__ fabs_s(f11, f11);
__ fsub_s(f12, f11, f9);
__ Fst_s(f12, MemOperand(a0, offsetof(T, result_fsub_s)));
__ Fld_s(f13, MemOperand(a0, offsetof(T, c)));
__ Fld_s(f14, MemOperand(a0, offsetof(T, d)));
__ Fld_s(f15, MemOperand(a0, offsetof(T, e)));
__ fmin_s(f16, f13, f14);
__ fmul_s(f17, f15, f16);
__ Fst_s(f17, MemOperand(a0, offsetof(T, result_fmul_s)));
__ fmax_s(f18, f13, f14);
__ fdiv_s(f19, f15, f18);
__ Fst_s(f19, MemOperand(a0, offsetof(T, result_fdiv_s)));
__ fmina_s(f16, f13, f14);
__ fmadd_s(f18, f17, f15, f16);
__ Fst_s(f18, MemOperand(a0, offsetof(T, result_fmadd_s)));
__ fnmadd_s(f19, f17, f15, f16);
__ Fst_s(f19, MemOperand(a0, offsetof(T, result_fnmadd_s)));
__ fmaxa_s(f16, f13, f14);
__ fmsub_s(f20, f17, f15, f16);
__ Fst_s(f20, MemOperand(a0, offsetof(T, result_fmsub_s)));
__ fnmsub_s(f21, f17, f15, f16);
__ Fst_s(f21, MemOperand(a0, offsetof(T, result_fnmsub_s)));
__ fsqrt_s(f10, f8);
//__ frecip_s(f11, f10);
//__ frsqrt_s(f12, f8);
__ Fst_s(f10, MemOperand(a0, offsetof(T, result_fsqrt_s)));
//__ Fst_s(f11, MemOperand(a0, offsetof(T, result_frecip_s)));
//__ Fst_s(f12, MemOperand(a0, offsetof(T, result_frsqrt_s)));
/*__ fscaleb_s(f16, f13, f15);
__ flogb_s(f17, f15);
__ fcopysign_s(f18, f8, f9);
__ fclass_s(f19, f9);
__ Fst_s(f16, MemOperand(a0, offsetof(T, result_fscaleb_s)));
__ Fst_s(f17, MemOperand(a0, offsetof(T, result_flogb_s)));
__ Fst_s(f18, MemOperand(a0, offsetof(T, result_fcopysign_s)));
__ Fst_s(f19, MemOperand(a0, offsetof(T, result_fclass_s)));*/
__ jirl(zero_reg, ra, 0);
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::FOR_TESTING).Build();
auto f = GeneratedCode<F3>::FromCode(*code);
// Float test values.
t.a = 1.5e6;
t.b = -2.75e4;
t.c = 1.5;
t.d = -2.75;
t.e = 120.0;
f.Call(&t, 0, 0, 0, 0);
CHECK_EQ(static_cast<float>(-1.527500e06), t.result_fadd_s);
CHECK_EQ(static_cast<float>(1.555000e06), t.result_fsub_s);
CHECK_EQ(static_cast<float>(-3.300000e02), t.result_fmul_s);
CHECK_EQ(static_cast<float>(8.000000e01), t.result_fdiv_s);
CHECK_EQ(static_cast<float>(-3.959850e04), t.result_fmadd_s);
CHECK_EQ(static_cast<float>(-3.959725e04), t.result_fmsub_s);
CHECK_EQ(static_cast<float>(3.959850e04), t.result_fnmadd_s);
CHECK_EQ(static_cast<float>(3.959725e04), t.result_fnmsub_s);
CHECK_EQ(static_cast<float>(1224.744873), t.result_fsqrt_s);
// CHECK_EQ(static_cast<float>( 8.164966e-04), t.result_frecip_s);
// CHECK_EQ(static_cast<float>( 8.164966e-04), t.result_frsqrt_s);
// CHECK_EQ(static_cast<float>(), t.result_fscaleb_s);
// CHECK_EQ(static_cast<float>( 6.906890), t.result_flogb_s);
// CHECK_EQ(static_cast<float>( 2.75e4), t.result_fcopysign_s);
// CHECK_EQ(static_cast<float>(), t.result_fclass_s);
}
TEST(FCMP_COND) {
CcTest::InitializeVM();
Isolate* isolate = CcTest::i_isolate();
HandleScope scope(isolate);
MacroAssembler assm(isolate, v8::internal::CodeObjectRequired::kYes);
struct TestFloat {
double dTrue;
double dFalse;
double dOp1;
double dOp2;
double dCaf;
double dCun;
double dCeq;
double dCueq;
double dClt;
double dCult;
double dCle;
double dCule;
double dCne;
double dCor;
double dCune;
double dSaf;
double dSun;
double dSeq;
double dSueq;
double dSlt;
double dSult;
double dSle;
double dSule;
double dSne;
double dSor;
double dSune;
float fTrue;
float fFalse;
float fOp1;
float fOp2;
float fCaf;
float fCun;
float fCeq;
float fCueq;
float fClt;
float fCult;
float fCle;
float fCule;
float fCne;
float fCor;
float fCune;
float fSaf;
float fSun;
float fSeq;
float fSueq;
float fSlt;
float fSult;
float fSle;
float fSule;
float fSne;
float fSor;
float fSune;
};
TestFloat test;
__ Fld_d(f8, MemOperand(a0, offsetof(TestFloat, dOp1)));
__ Fld_d(f9, MemOperand(a0, offsetof(TestFloat, dOp2)));
__ Fld_s(f10, MemOperand(a0, offsetof(TestFloat, fOp1)));
__ Fld_s(f11, MemOperand(a0, offsetof(TestFloat, fOp2)));
__ Fld_d(f12, MemOperand(a0, offsetof(TestFloat, dFalse)));
__ Fld_d(f13, MemOperand(a0, offsetof(TestFloat, dTrue)));
__ Fld_s(f14, MemOperand(a0, offsetof(TestFloat, fFalse)));
__ Fld_s(f15, MemOperand(a0, offsetof(TestFloat, fTrue)));
__ fcmp_cond_d(CAF, f8, f9, FCC0);
__ fcmp_cond_s(CAF, f10, f11, FCC1);
__ fsel(FCC0, f16, f12, f13);
__ fsel(FCC1, f17, f14, f15);
__ Fst_d(f16, MemOperand(a0, offsetof(TestFloat, dCaf)));
__ Fst_s(f17, MemOperand(a0, offsetof(TestFloat, fCaf)));
__ fcmp_cond_d(CUN, f8, f9, FCC0);
__ fcmp_cond_s(CUN, f10, f11, FCC1);
__ fsel(FCC0, f16, f12, f13);
__ fsel(FCC1, f17, f14, f15);
__ Fst_d(f16, MemOperand(a0, offsetof(TestFloat, dCun)));
__ Fst_s(f17, MemOperand(a0, offsetof(TestFloat, fCun)));
__ fcmp_cond_d(CEQ, f8, f9, FCC0);
__ fcmp_cond_s(CEQ, f10, f11, FCC1);
__ fsel(FCC0, f16, f12, f13);
__ fsel(FCC1, f17, f14, f15);
__ Fst_d(f16, MemOperand(a0, offsetof(TestFloat, dCeq)));
__ Fst_s(f17, MemOperand(a0, offsetof(TestFloat, fCeq)));
__ fcmp_cond_d(CUEQ, f8, f9, FCC0);
__ fcmp_cond_s(CUEQ, f10, f11, FCC1);
__ fsel(FCC0, f16, f12, f13);
__ fsel(FCC1, f17, f14, f15);
__ Fst_d(f16, MemOperand(a0, offsetof(TestFloat, dCueq)));
__ Fst_s(f17, MemOperand(a0, offsetof(TestFloat, fCueq)));
__ fcmp_cond_d(CLT, f8, f9, FCC0);
__ fcmp_cond_s(CLT, f10, f11, FCC1);
__ fsel(FCC0, f16, f12, f13);
__ fsel(FCC1, f17, f14, f15);
__ Fst_d(f16, MemOperand(a0, offsetof(TestFloat, dClt)));
__ Fst_s(f17, MemOperand(a0, offsetof(TestFloat, fClt)));
__ fcmp_cond_d(CULT, f8, f9, FCC0);
__ fcmp_cond_s(CULT, f10, f11, FCC1);
__ fsel(FCC0, f16, f12, f13);
__ fsel(FCC1, f17, f14, f15);
__ Fst_d(f16, MemOperand(a0, offsetof(TestFloat, dCult)));
__ Fst_s(f17, MemOperand(a0, offsetof(TestFloat, fCult)));
__ fcmp_cond_d(CLE, f8, f9, FCC0);
__ fcmp_cond_s(CLE, f10, f11, FCC1);
__ fsel(FCC0, f16, f12, f13);
__ fsel(FCC1, f17, f14, f15);
__ Fst_d(f16, MemOperand(a0, offsetof(TestFloat, dCle)));
__ Fst_s(f17, MemOperand(a0, offsetof(TestFloat, fCle)));
__ fcmp_cond_d(CULE, f8, f9, FCC0);
__ fcmp_cond_s(CULE, f10, f11, FCC1);
__ fsel(FCC0, f16, f12, f13);
__ fsel(FCC1, f17, f14, f15);
__ Fst_d(f16, MemOperand(a0, offsetof(TestFloat, dCule)));
__ Fst_s(f17, MemOperand(a0, offsetof(TestFloat, fCule)));
__ fcmp_cond_d(CNE, f8, f9, FCC0);
__ fcmp_cond_s(CNE, f10, f11, FCC1);
__ fsel(FCC0, f16, f12, f13);
__ fsel(FCC1, f17, f14, f15);
__ Fst_d(f16, MemOperand(a0, offsetof(TestFloat, dCne)));
__ Fst_s(f17, MemOperand(a0, offsetof(TestFloat, fCne)));
__ fcmp_cond_d(COR, f8, f9, FCC0);
__ fcmp_cond_s(COR, f10, f11, FCC1);
__ fsel(FCC0, f16, f12, f13);
__ fsel(FCC1, f17, f14, f15);
__ Fst_d(f16, MemOperand(a0, offsetof(TestFloat, dCor)));
__ Fst_s(f17, MemOperand(a0, offsetof(TestFloat, fCor)));
__ fcmp_cond_d(CUNE, f8, f9, FCC0);
__ fcmp_cond_s(CUNE, f10, f11, FCC1);
__ fsel(FCC0, f16, f12, f13);
__ fsel(FCC1, f17, f14, f15);
__ Fst_d(f16, MemOperand(a0, offsetof(TestFloat, dCune)));
__ Fst_s(f17, MemOperand(a0, offsetof(TestFloat, fCune)));
/* __ fcmp_cond_d(SAF, f8, f9, FCC0);
__ fcmp_cond_s(SAF, f10, f11, FCC1);
__ fsel(FCC0, f16, f12, f13);
__ fsel(FCC1, f17, f14, f15);
__ Fst_d(f16, MemOperand(a0, offsetof(TestFloat, dSaf)));
__ Fst_s(f17, MemOperand(a0, offsetof(TestFloat, fSaf)));
__ fcmp_cond_d(SUN, f8, f9, FCC0);
__ fcmp_cond_s(SUN, f10, f11, FCC1);
__ fsel(FCC0, f16, f12, f13);
__ fsel(FCC1, f17, f14, f15);
__ Fst_d(f16, MemOperand(a0, offsetof(TestFloat, dSun)));
__ Fst_s(f17, MemOperand(a0, offsetof(TestFloat, fSun)));
__ fcmp_cond_d(SEQ, f8, f9, FCC0);
__ fcmp_cond_s(SEQ, f10, f11, FCC1);
__ fsel(FCC0, f16, f12, f13);
__ fsel(FCC1, f17, f14, f15);
__ Fst_d(f16, MemOperand(a0, offsetof(TestFloat, dSeq)));
__ Fst_f(f17, MemOperand(a0, offsetof(TestFloat, fSeq)));
__ fcmp_cond_d(SUEQ, f8, f9, FCC0);
__ fcmp_cond_s(SUEQ, f10, f11, FCC1);
__ fsel(FCC0, f16, f12, f13);
__ fsel(FCC1, f17, f14, f15);
__ Fst_d(f16, MemOperand(a0, offsetof(TestFloat, dSueq)));
__ Fst_f(f17, MemOperand(a0, offsetof(TestFloat, fSueq)));
__ fcmp_cond_d(SLT, f8, f9, FCC0);
__ fcmp_cond_s(SLT, f10, f11, FCC1);
__ fsel(f16, f12, f13, FCC0);
__ fsel(f17, f14, f15, FCC1);
__ Fld_d(f16, MemOperand(a0, offsetof(TestFloat, dSlt)));
__ Fst_d(f17, MemOperand(a0, offsetof(TestFloat, fSlt)));
__ fcmp_cond_d(SULT, f8, f9, FCC0);
__ fcmp_cond_s(SULT, f10, f11, FCC1);
__ fsel(FCC0, f16, f12, f13);
__ fsel(FCC1, f17, f14, f15);
__ Fst_d(f16, MemOperand(a0, offsetof(TestFloat, dSult)));
__ Fst_s(f17, MemOperand(a0, offsetof(TestFloat, fSult)));
__ fcmp_cond_d(SLE, f8, f9, FCC0);
__ fcmp_cond_s(SLE, f10, f11, FCC1);
__ fsel(FCC0, f16, f12, f13);
__ fsel(FCC1, f17, f14, f15);
__ Fst_d(f16, MemOperand(a0, offsetof(TestFloat, dSle)));
__ Fst_f(f17, MemOperand(a0, offsetof(TestFloat, fSle)));
__ fcmp_cond_d(SULE, f8, f9, FCC0);
__ fcmp_cond_s(SULE, f10, f11, FCC1);
__ fsel(FCC0, f16, f12, f13);
__ fsel(FCC1, f17, f14, f15);
__ Fst_d(f16, MemOperand(a0, offsetof(TestFloat, dSule)));
__ Fst_f(f17, MemOperand(a0, offsetof(TestFloat, fSule)));
__ fcmp_cond_d(SNE, f8, f9, FCC0);
__ fcmp_cond_s(SNE, f10, f11, FCC1);
__ fsel(FCC0, f16, f12, f13);
__ fsel(FCC1, f17, f14, f15);
__ Fst_d(f16, MemOperand(a0, offsetof(TestFloat, dSne)));
__ Fst_s(f17, MemOperand(a0, offsetof(TestFloat, fSne)));
__ fcmp_cond_d(SOR, f8, f9, FCC0);
__ fcmp_cond_s(SOR, f10, f11, FCC1);
__ fsel(FCC0, f16, f12, f13);
__ fsel(FCC1, f17, f14, f15);
__ Fst_d(f16, MemOperand(a0, offsetof(TestFloat, dSor)));
__ Fst_s(f17, MemOperand(a0, offsetof(TestFloat, fSor)));
__ fcmp_cond_d(SUNE, f8, f9, FCC0);
__ fcmp_cond_s(SUNE, f10, f11, FCC1);
__ fsel(FCC0, f16, f12, f13);
__ fsel(FCC1, f17, f14, f15);
__ Fst_d(f16, MemOperand(a0, offsetof(TestFloat, dSune)));
__ Fst_s(f17, MemOperand(a0, offsetof(TestFloat, fSune)));*/
__ jirl(zero_reg, ra, 0);
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::FOR_TESTING).Build();
auto f = GeneratedCode<F3>::FromCode(*code);
test.dTrue = 1234.0;
test.dFalse = 0.0;
test.fTrue = 12.0;
test.fFalse = 0.0;
test.dOp1 = 2.0;
test.dOp2 = 3.0;
test.fOp1 = 2.0;
test.fOp2 = 3.0;
f.Call(&test, 0, 0, 0, 0);
CHECK_EQ(test.dCaf, test.dFalse);
CHECK_EQ(test.fCaf, test.fFalse);
CHECK_EQ(test.dCun, test.dFalse);
CHECK_EQ(test.fCun, test.fFalse);
CHECK_EQ(test.dCeq, test.dFalse);
CHECK_EQ(test.fCeq, test.fFalse);
CHECK_EQ(test.dCueq, test.dFalse);
CHECK_EQ(test.fCueq, test.fFalse);
CHECK_EQ(test.dClt, test.dTrue);
CHECK_EQ(test.fClt, test.fTrue);
CHECK_EQ(test.dCult, test.dTrue);
CHECK_EQ(test.fCult, test.fTrue);
CHECK_EQ(test.dCle, test.dTrue);
CHECK_EQ(test.fCle, test.fTrue);
CHECK_EQ(test.dCule, test.dTrue);
CHECK_EQ(test.fCule, test.fTrue);
CHECK_EQ(test.dCne, test.dTrue);
CHECK_EQ(test.fCne, test.fTrue);
CHECK_EQ(test.dCor, test.dTrue);
CHECK_EQ(test.fCor, test.fTrue);
CHECK_EQ(test.dCune, test.dTrue);
CHECK_EQ(test.fCune, test.fTrue);
/* CHECK_EQ(test.dSaf, test.dFalse);
CHECK_EQ(test.fSaf, test.fFalse);
CHECK_EQ(test.dSun, test.dFalse);
CHECK_EQ(test.fSun, test.fFalse);
CHECK_EQ(test.dSeq, test.dFalse);
CHECK_EQ(test.fSeq, test.fFalse);
CHECK_EQ(test.dSueq, test.dFalse);
CHECK_EQ(test.fSueq, test.fFalse);
CHECK_EQ(test.dClt, test.dTrue);
CHECK_EQ(test.fClt, test.fTrue);
CHECK_EQ(test.dCult, test.dTrue);
CHECK_EQ(test.fCult, test.fTrue);
CHECK_EQ(test.dSle, test.dTrue);
CHECK_EQ(test.fSle, test.fTrue);
CHECK_EQ(test.dSule, test.dTrue);
CHECK_EQ(test.fSule, test.fTrue);
CHECK_EQ(test.dSne, test.dTrue);
CHECK_EQ(test.fSne, test.fTrue);
CHECK_EQ(test.dSor, test.dTrue);
CHECK_EQ(test.fSor, test.fTrue);
CHECK_EQ(test.dSune, test.dTrue);
CHECK_EQ(test.fSune, test.fTrue);*/
test.dOp1 = std::numeric_limits<double>::max();
test.dOp2 = std::numeric_limits<double>::min();
test.fOp1 = std::numeric_limits<float>::min();
test.fOp2 = -std::numeric_limits<float>::max();
f.Call(&test, 0, 0, 0, 0);
CHECK_EQ(test.dCaf, test.dFalse);
CHECK_EQ(test.fCaf, test.fFalse);
CHECK_EQ(test.dCun, test.dFalse);
CHECK_EQ(test.fCun, test.fFalse);
CHECK_EQ(test.dCeq, test.dFalse);
CHECK_EQ(test.fCeq, test.fFalse);
CHECK_EQ(test.dCueq, test.dFalse);
CHECK_EQ(test.fCueq, test.fFalse);
CHECK_EQ(test.dClt, test.dFalse);
CHECK_EQ(test.fClt, test.fFalse);
CHECK_EQ(test.dCult, test.dFalse);
CHECK_EQ(test.fCult, test.fFalse);
CHECK_EQ(test.dCle, test.dFalse);
CHECK_EQ(test.fCle, test.fFalse);
CHECK_EQ(test.dCule, test.dFalse);
CHECK_EQ(test.fCule, test.fFalse);
CHECK_EQ(test.dCne, test.dTrue);
CHECK_EQ(test.fCne, test.fTrue);
CHECK_EQ(test.dCor, test.dTrue);
CHECK_EQ(test.fCor, test.fTrue);
CHECK_EQ(test.dCune, test.dTrue);
CHECK_EQ(test.fCune, test.fTrue);
/* CHECK_EQ(test.dSaf, test.dFalse);
CHECK_EQ(test.fSaf, test.fFalse);
CHECK_EQ(test.dSun, test.dFalse);
CHECK_EQ(test.fSun, test.fFalse);
CHECK_EQ(test.dSeq, test.dFalse);
CHECK_EQ(test.fSeq, test.fFalse);
CHECK_EQ(test.dSueq, test.dFalse);
CHECK_EQ(test.fSueq, test.fFalse);
CHECK_EQ(test.dSlt, test.dFalse);
CHECK_EQ(test.fSlt, test.fFalse);
CHECK_EQ(test.dSult, test.dFalse);
CHECK_EQ(test.fSult, test.fFalse);
CHECK_EQ(test.dSle, test.dFalse);
CHECK_EQ(test.fSle, test.fFalse);
CHECK_EQ(test.dSule, test.dFalse);
CHECK_EQ(test.fSule, test.fFalse);
CHECK_EQ(test.dSne, test.dTrue);
CHECK_EQ(test.fSne, test.fTrue);
CHECK_EQ(test.dSor, test.dTrue);
CHECK_EQ(test.fSor, test.fTrue);
CHECK_EQ(test.dSune, test.dTrue);
CHECK_EQ(test.fSune, test.fTrue);*/
test.dOp1 = std::numeric_limits<double>::quiet_NaN();
test.dOp2 = 0.0;
test.fOp1 = std::numeric_limits<float>::quiet_NaN();
test.fOp2 = 0.0;
f.Call(&test, 0, 0, 0, 0);
CHECK_EQ(test.dCaf, test.dFalse);
CHECK_EQ(test.fCaf, test.fFalse);
CHECK_EQ(test.dCun, test.dTrue);
CHECK_EQ(test.fCun, test.fTrue);
CHECK_EQ(test.dCeq, test.dFalse);
CHECK_EQ(test.fCeq, test.fFalse);
CHECK_EQ(test.dCueq, test.dTrue);
CHECK_EQ(test.fCueq, test.fTrue);
CHECK_EQ(test.dClt, test.dFalse);
CHECK_EQ(test.fClt, test.fFalse);
CHECK_EQ(test.dCult, test.dTrue);
CHECK_EQ(test.fCult, test.fTrue);
CHECK_EQ(test.dCle, test.dFalse);
CHECK_EQ(test.fCle, test.fFalse);
CHECK_EQ(test.dCule, test.dTrue);
CHECK_EQ(test.fCule, test.fTrue);
CHECK_EQ(test.dCne, test.dFalse);
CHECK_EQ(test.fCne, test.fFalse);
CHECK_EQ(test.dCor, test.dFalse);
CHECK_EQ(test.fCor, test.fFalse);
CHECK_EQ(test.dCune, test.dTrue);
CHECK_EQ(test.fCune, test.fTrue);
/* CHECK_EQ(test.dSaf, test.dTrue);
CHECK_EQ(test.fSaf, test.fTrue);
CHECK_EQ(test.dSun, test.dTrue);
CHECK_EQ(test.fSun, test.fTrue);
CHECK_EQ(test.dSeq, test.dFalse);
CHECK_EQ(test.fSeq, test.fFalse);
CHECK_EQ(test.dSueq, test.dTrue);
CHECK_EQ(test.fSueq, test.fTrue);
CHECK_EQ(test.dSlt, test.dFalse);
CHECK_EQ(test.fSlt, test.fFalse);
CHECK_EQ(test.dSult, test.dTrue);
CHECK_EQ(test.fSult, test.fTrue);
CHECK_EQ(test.dSle, test.dFalse);
CHECK_EQ(test.fSle, test.fFalse);
CHECK_EQ(test.dSule, test.dTrue);
CHECK_EQ(test.fSule, test.fTrue);
CHECK_EQ(test.dSne, test.dFalse);
CHECK_EQ(test.fSne, test.fFalse);
CHECK_EQ(test.dSor, test.dFalse);
CHECK_EQ(test.fSor, test.fFalse);
CHECK_EQ(test.dSune, test.dTrue);
CHECK_EQ(test.fSune, test.fTrue);*/
}
TEST(FCVT) {
CcTest::InitializeVM();
Isolate* isolate = CcTest::i_isolate();
HandleScope scope(isolate);
MacroAssembler assm(isolate, v8::internal::CodeObjectRequired::kYes);
struct TestFloat {
float fcvt_d_s_in;
double fcvt_s_d_in;
double fcvt_d_s_out;
float fcvt_s_d_out;
int fcsr;
};
TestFloat test;
__ xor_(a4, a4, a4);
__ xor_(a5, a5, a5);
__ Ld_w(a4, MemOperand(a0, offsetof(TestFloat, fcsr)));
__ movfcsr2gr(a5);
__ movgr2fcsr(a4);
__ Fld_s(f8, MemOperand(a0, offsetof(TestFloat, fcvt_d_s_in)));
__ Fld_d(f9, MemOperand(a0, offsetof(TestFloat, fcvt_s_d_in)));
__ fcvt_d_s(f10, f8);
__ fcvt_s_d(f11, f9);
__ Fst_d(f10, MemOperand(a0, offsetof(TestFloat, fcvt_d_s_out)));
__ Fst_s(f11, MemOperand(a0, offsetof(TestFloat, fcvt_s_d_out)));
__ movgr2fcsr(a5);
__ jirl(zero_reg, ra, 0);
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::FOR_TESTING).Build();
auto f = GeneratedCode<F3>::FromCode(*code);
test.fcsr = kRoundToNearest;
test.fcvt_d_s_in = -0.51;
test.fcvt_s_d_in = -0.51;
f.Call(&test, 0, 0, 0, 0);
CHECK_EQ(test.fcvt_d_s_out, static_cast<double>(test.fcvt_d_s_in));
CHECK_EQ(test.fcvt_s_d_out, static_cast<float>(test.fcvt_s_d_in));
test.fcvt_d_s_in = 0.49;
test.fcvt_s_d_in = 0.49;
f.Call(&test, 0, 0, 0, 0);
CHECK_EQ(test.fcvt_d_s_out, static_cast<double>(test.fcvt_d_s_in));
CHECK_EQ(test.fcvt_s_d_out, static_cast<float>(test.fcvt_s_d_in));
test.fcvt_d_s_in = std::numeric_limits<float>::max();
test.fcvt_s_d_in = std::numeric_limits<double>::max();
f.Call(&test, 0, 0, 0, 0);
CHECK_EQ(test.fcvt_d_s_out, static_cast<double>(test.fcvt_d_s_in));
CHECK_EQ(test.fcvt_s_d_out, static_cast<float>(test.fcvt_s_d_in));
test.fcvt_d_s_in = -std::numeric_limits<float>::max();
test.fcvt_s_d_in = -std::numeric_limits<double>::max();
f.Call(&test, 0, 0, 0, 0);
CHECK_EQ(test.fcvt_d_s_out, static_cast<double>(test.fcvt_d_s_in));
CHECK_EQ(test.fcvt_s_d_out, static_cast<float>(test.fcvt_s_d_in));
test.fcvt_d_s_in = std::numeric_limits<float>::min();
test.fcvt_s_d_in = std::numeric_limits<double>::min();
f.Call(&test, 0, 0, 0, 0);
CHECK_EQ(test.fcvt_d_s_out, static_cast<double>(test.fcvt_d_s_in));
CHECK_EQ(test.fcvt_s_d_out, static_cast<float>(test.fcvt_s_d_in));
}
TEST(FFINT) {
CcTest::InitializeVM();
Isolate* isolate = CcTest::i_isolate();
HandleScope scope(isolate);
MacroAssembler assm(isolate, v8::internal::CodeObjectRequired::kYes);
struct TestFloat {
int32_t ffint_s_w_in;
int64_t ffint_s_l_in;
int32_t ffint_d_w_in;
int64_t ffint_d_l_in;
float ffint_s_w_out;
float ffint_s_l_out;
double ffint_d_w_out;
double ffint_d_l_out;
int fcsr;
};
TestFloat test;
__ xor_(a4, a4, a4);
__ xor_(a5, a5, a5);
__ Ld_w(a4, MemOperand(a0, offsetof(TestFloat, fcsr)));
__ movfcsr2gr(a5);
__ movgr2fcsr(a4);
__ Fld_s(f8, MemOperand(a0, offsetof(TestFloat, ffint_s_w_in)));
__ Fld_d(f9, MemOperand(a0, offsetof(TestFloat, ffint_s_l_in)));
__ Fld_s(f10, MemOperand(a0, offsetof(TestFloat, ffint_d_w_in)));
__ Fld_d(f11, MemOperand(a0, offsetof(TestFloat, ffint_d_l_in)));
__ ffint_s_w(f12, f8);
__ ffint_s_l(f13, f9);
__ ffint_d_w(f14, f10);
__ ffint_d_l(f15, f11);
__ Fst_s(f12, MemOperand(a0, offsetof(TestFloat, ffint_s_w_out)));
__ Fst_s(f13, MemOperand(a0, offsetof(TestFloat, ffint_s_l_out)));
__ Fst_d(f14, MemOperand(a0, offsetof(TestFloat, ffint_d_w_out)));
__ Fst_d(f15, MemOperand(a0, offsetof(TestFloat, ffint_d_l_out)));
__ movgr2fcsr(a5);
__ jirl(zero_reg, ra, 0);
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::FOR_TESTING).Build();
auto f = GeneratedCode<F3>::FromCode(*code);
test.fcsr = kRoundToNearest;
test.ffint_s_w_in = -1;
test.ffint_s_l_in = -1;
test.ffint_d_w_in = -1;
test.ffint_d_l_in = -1;
f.Call(&test, 0, 0, 0, 0);
CHECK_EQ(test.ffint_s_w_out, static_cast<float>(test.ffint_s_w_in));
CHECK_EQ(test.ffint_s_l_out, static_cast<float>(test.ffint_s_l_in));
CHECK_EQ(test.ffint_d_w_out, static_cast<double>(test.ffint_d_w_in));
CHECK_EQ(test.ffint_d_l_out, static_cast<double>(test.ffint_d_l_in));
test.ffint_s_w_in = 1;
test.ffint_s_l_in = 1;
test.ffint_d_w_in = 1;
test.ffint_d_l_in = 1;
f.Call(&test, 0, 0, 0, 0);
CHECK_EQ(test.ffint_s_w_out, static_cast<float>(test.ffint_s_w_in));
CHECK_EQ(test.ffint_s_l_out, static_cast<float>(test.ffint_s_l_in));
CHECK_EQ(test.ffint_d_w_out, static_cast<double>(test.ffint_d_w_in));
CHECK_EQ(test.ffint_d_l_out, static_cast<double>(test.ffint_d_l_in));
test.ffint_s_w_in = std::numeric_limits<int32_t>::max();
test.ffint_s_l_in = std::numeric_limits<int64_t>::max();
test.ffint_d_w_in = std::numeric_limits<int32_t>::max();
test.ffint_d_l_in = std::numeric_limits<int64_t>::max();
f.Call(&test, 0, 0, 0, 0);
CHECK_EQ(test.ffint_s_w_out, static_cast<float>(test.ffint_s_w_in));
CHECK_EQ(test.ffint_s_l_out, static_cast<float>(test.ffint_s_l_in));
CHECK_EQ(test.ffint_d_w_out, static_cast<double>(test.ffint_d_w_in));
CHECK_EQ(test.ffint_d_l_out, static_cast<double>(test.ffint_d_l_in));
test.ffint_s_w_in = std::numeric_limits<int32_t>::min();
test.ffint_s_l_in = std::numeric_limits<int64_t>::min();
test.ffint_d_w_in = std::numeric_limits<int32_t>::min();
test.ffint_d_l_in = std::numeric_limits<int64_t>::min();
f.Call(&test, 0, 0, 0, 0);
CHECK_EQ(test.ffint_s_w_out, static_cast<float>(test.ffint_s_w_in));
CHECK_EQ(test.ffint_s_l_out, static_cast<float>(test.ffint_s_l_in));
CHECK_EQ(test.ffint_d_w_out, static_cast<double>(test.ffint_d_w_in));
CHECK_EQ(test.ffint_d_l_out, static_cast<double>(test.ffint_d_l_in));
}
TEST(FTINT) {
CcTest::InitializeVM();
Isolate* isolate = CcTest::i_isolate();
HandleScope scope(isolate);
MacroAssembler assm(isolate, v8::internal::CodeObjectRequired::kYes);
struct Test {
double a;
float b;
int32_t c;
int32_t d;
int64_t e;
int64_t f;
int fcsr;
};
Test test;
const int kTableLength = 9;
// clang-format off
double inputs_d[kTableLength] = {
3.1, 3.6, 3.5, -3.1, -3.6, -3.5,
2147483648.0,
std::numeric_limits<double>::quiet_NaN(),
std::numeric_limits<double>::infinity()
};
float inputs_s[kTableLength] = {
3.1, 3.6, 3.5, -3.1, -3.6, -3.5,
2147483648.0,
std::numeric_limits<double>::quiet_NaN(),
std::numeric_limits<double>::infinity()
};
double outputs_RN_W[kTableLength] = {
3.0, 4.0, 4.0, -3.0, -4.0, -4.0,
kFPUInvalidResult, 0,
kFPUInvalidResult};
double outputs_RN_L[kTableLength] = {
3.0, 4.0, 4.0, -3.0, -4.0, -4.0,
2147483648.0, 0,
static_cast<double>(kFPU64InvalidResult)};
double outputs_RZ_W[kTableLength] = {
3.0, 3.0, 3.0, -3.0, -3.0, -3.0,
kFPUInvalidResult, 0,
kFPUInvalidResult};
double outputs_RZ_L[kTableLength] = {
3.0, 3.0, 3.0, -3.0, -3.0, -3.0,
2147483648.0, 0,
static_cast<double>(kFPU64InvalidResult)};
double outputs_RP_W[kTableLength] = {
4.0, 4.0, 4.0, -3.0, -3.0, -3.0,
kFPUInvalidResult, 0,
kFPUInvalidResult};
double outputs_RP_L[kTableLength] = {
4.0, 4.0, 4.0, -3.0, -3.0, -3.0,
2147483648.0, 0,
static_cast<double>(kFPU64InvalidResult)};
double outputs_RM_W[kTableLength] = {
3.0, 3.0, 3.0, -4.0, -4.0, -4.0,
kFPUInvalidResult, 0,
kFPUInvalidResult};
double outputs_RM_L[kTableLength] = {
3.0, 3.0, 3.0, -4.0, -4.0, -4.0,
2147483648.0, 0,
static_cast<double>(kFPU64InvalidResult)};
// clang-format on
int fcsr_inputs[4] = {kRoundToNearest, kRoundToZero, kRoundToPlusInf,
kRoundToMinusInf};
double* outputs[8] = {
outputs_RN_W, outputs_RN_L, outputs_RZ_W, outputs_RZ_L,
outputs_RP_W, outputs_RP_L, outputs_RM_W, outputs_RM_L,
};
__ Fld_d(f8, MemOperand(a0, offsetof(Test, a)));
__ Fld_s(f9, MemOperand(a0, offsetof(Test, b)));
__ xor_(a5, a5, a5);
__ Ld_w(a5, MemOperand(a0, offsetof(Test, fcsr)));
__ movfcsr2gr(a4);
__ movgr2fcsr(a5);
__ ftint_w_d(f10, f8);
__ ftint_w_s(f11, f9);
__ ftint_l_d(f12, f8);
__ ftint_l_s(f13, f9);
__ Fst_s(f10, MemOperand(a0, offsetof(Test, c)));
__ Fst_s(f11, MemOperand(a0, offsetof(Test, d)));
__ Fst_d(f12, MemOperand(a0, offsetof(Test, e)));
__ Fst_d(f13, MemOperand(a0, offsetof(Test, f)));
__ movgr2fcsr(a4);
__ jirl(zero_reg, ra, 0);
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::FOR_TESTING).Build();
auto f = GeneratedCode<F3>::FromCode(*code);
for (int j = 0; j < 4; j++) {
test.fcsr = fcsr_inputs[j];
for (int i = 0; i < kTableLength; i++) {
test.a = inputs_d[i];
test.b = inputs_s[i];
f.Call(&test, 0, 0, 0, 0);
CHECK_EQ(test.c, outputs[2 * j][i]);
CHECK_EQ(test.d, outputs[2 * j][i]);
CHECK_EQ(test.e, outputs[2 * j + 1][i]);
CHECK_EQ(test.f, outputs[2 * j + 1][i]);
}
}
}
TEST(FTINTRM) {
CcTest::InitializeVM();
Isolate* isolate = CcTest::i_isolate();
HandleScope scope(isolate);
MacroAssembler assm(isolate, v8::internal::CodeObjectRequired::kYes);
struct Test {
double a;
float b;
int32_t c;
int32_t d;
int64_t e;
int64_t f;
};
Test test;
const int kTableLength = 9;
// clang-format off
double inputs_d[kTableLength] = {
3.1, 3.6, 3.5, -3.1, -3.6, -3.5,
2147483648.0,
std::numeric_limits<double>::quiet_NaN(),
std::numeric_limits<double>::infinity()
};
float inputs_s[kTableLength] = {
3.1, 3.6, 3.5, -3.1, -3.6, -3.5,
2147483648.0,
std::numeric_limits<double>::quiet_NaN(),
std::numeric_limits<double>::infinity()
};
double outputs_w[kTableLength] = {
3.0, 3.0, 3.0, -4.0, -4.0, -4.0,
kFPUInvalidResult, 0,
kFPUInvalidResult};
double outputs_l[kTableLength] = {
3.0, 3.0, 3.0, -4.0, -4.0, -4.0,
2147483648.0, 0,
static_cast<double>(kFPU64InvalidResult)};
// clang-format on
__ Fld_d(f8, MemOperand(a0, offsetof(Test, a)));
__ Fld_s(f9, MemOperand(a0, offsetof(Test, b)));
__ ftintrm_w_d(f10, f8);
__ ftintrm_w_s(f11, f9);
__ ftintrm_l_d(f12, f8);
__ ftintrm_l_s(f13, f9);
__ Fst_s(f10, MemOperand(a0, offsetof(Test, c)));
__ Fst_s(f11, MemOperand(a0, offsetof(Test, d)));
__ Fst_d(f12, MemOperand(a0, offsetof(Test, e)));
__ Fst_d(f13, MemOperand(a0, offsetof(Test, f)));
__ jirl(zero_reg, ra, 0);
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::FOR_TESTING).Build();
auto f = GeneratedCode<F3>::FromCode(*code);
for (int i = 0; i < kTableLength; i++) {
test.a = inputs_d[i];
test.b = inputs_s[i];
f.Call(&test, 0, 0, 0, 0);
CHECK_EQ(test.c, outputs_w[i]);
CHECK_EQ(test.d, outputs_w[i]);
CHECK_EQ(test.e, outputs_l[i]);
CHECK_EQ(test.f, outputs_l[i]);
}
}
TEST(FTINTRP) {
CcTest::InitializeVM();
Isolate* isolate = CcTest::i_isolate();
HandleScope scope(isolate);
MacroAssembler assm(isolate, v8::internal::CodeObjectRequired::kYes);
struct Test {
double a;
float b;
int32_t c;
int32_t d;
int64_t e;
int64_t f;
};
Test test;
const int kTableLength = 9;
// clang-format off
double inputs_d[kTableLength] = {
3.1, 3.6, 3.5, -3.1, -3.6, -3.5,
2147483648.0,
std::numeric_limits<double>::quiet_NaN(),
std::numeric_limits<double>::infinity()
};
float inputs_s[kTableLength] = {
3.1, 3.6, 3.5, -3.1, -3.6, -3.5,
2147483648.0,
std::numeric_limits<double>::quiet_NaN(),
std::numeric_limits<double>::infinity()
};
double outputs_w[kTableLength] = {
4.0, 4.0, 4.0, -3.0, -3.0, -3.0,
kFPUInvalidResult, 0,
kFPUInvalidResult};
double outputs_l[kTableLength] = {
4.0, 4.0, 4.0, -3.0, -3.0, -3.0,
2147483648.0, 0,
static_cast<double>(kFPU64InvalidResult)};
// clang-format on
__ Fld_d(f8, MemOperand(a0, offsetof(Test, a)));
__ Fld_s(f9, MemOperand(a0, offsetof(Test, b)));
__ ftintrp_w_d(f10, f8);
__ ftintrp_w_s(f11, f9);
__ ftintrp_l_d(f12, f8);
__ ftintrp_l_s(f13, f9);
__ Fst_s(f10, MemOperand(a0, offsetof(Test, c)));
__ Fst_s(f11, MemOperand(a0, offsetof(Test, d)));
__ Fst_d(f12, MemOperand(a0, offsetof(Test, e)));
__ Fst_d(f13, MemOperand(a0, offsetof(Test, f)));
__ jirl(zero_reg, ra, 0);
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::FOR_TESTING).Build();
auto f = GeneratedCode<F3>::FromCode(*code);
for (int i = 0; i < kTableLength; i++) {
test.a = inputs_d[i];
test.b = inputs_s[i];
f.Call(&test, 0, 0, 0, 0);
CHECK_EQ(test.c, outputs_w[i]);
CHECK_EQ(test.d, outputs_w[i]);
CHECK_EQ(test.e, outputs_l[i]);
CHECK_EQ(test.f, outputs_l[i]);
}
}
TEST(FTINTRZ) {
CcTest::InitializeVM();
Isolate* isolate = CcTest::i_isolate();
HandleScope scope(isolate);
MacroAssembler assm(isolate, v8::internal::CodeObjectRequired::kYes);
struct Test {
double a;
float b;
int32_t c;
int32_t d;
int64_t e;
int64_t f;
};
Test test;
const int kTableLength = 9;
// clang-format off
double inputs_d[kTableLength] = {
3.1, 3.6, 3.5, -3.1, -3.6, -3.5,
2147483648.0,
std::numeric_limits<double>::quiet_NaN(),
std::numeric_limits<double>::infinity()
};
float inputs_s[kTableLength] = {
3.1, 3.6, 3.5, -3.1, -3.6, -3.5,
2147483648.0,
std::numeric_limits<double>::quiet_NaN(),
std::numeric_limits<double>::infinity()
};
double outputs_w[kTableLength] = {
3.0, 3.0, 3.0, -3.0, -3.0, -3.0,
kFPUInvalidResult, 0,
kFPUInvalidResult};
double outputs_l[kTableLength] = {
3.0, 3.0, 3.0, -3.0, -3.0, -3.0,
2147483648.0, 0,
static_cast<double>(kFPU64InvalidResult)};
// clang-format on
__ Fld_d(f8, MemOperand(a0, offsetof(Test, a)));
__ Fld_s(f9, MemOperand(a0, offsetof(Test, b)));
__ ftintrz_w_d(f10, f8);
__ ftintrz_w_s(f11, f9);
__ ftintrz_l_d(f12, f8);
__ ftintrz_l_s(f13, f9);
__ Fst_s(f10, MemOperand(a0, offsetof(Test, c)));
__ Fst_s(f11, MemOperand(a0, offsetof(Test, d)));
__ Fst_d(f12, MemOperand(a0, offsetof(Test, e)));
__ Fst_d(f13, MemOperand(a0, offsetof(Test, f)));
__ jirl(zero_reg, ra, 0);
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::FOR_TESTING).Build();
auto f = GeneratedCode<F3>::FromCode(*code);
for (int i = 0; i < kTableLength; i++) {
test.a = inputs_d[i];
test.b = inputs_s[i];
f.Call(&test, 0, 0, 0, 0);
CHECK_EQ(test.c, outputs_w[i]);
CHECK_EQ(test.d, outputs_w[i]);
CHECK_EQ(test.e, outputs_l[i]);
CHECK_EQ(test.f, outputs_l[i]);
}
}
TEST(FTINTRNE) {
CcTest::InitializeVM();
Isolate* isolate = CcTest::i_isolate();
HandleScope scope(isolate);
MacroAssembler assm(isolate, v8::internal::CodeObjectRequired::kYes);
struct Test {
double a;
float b;
int32_t c;
int32_t d;
int64_t e;
int64_t f;
};
Test test;
const int kTableLength = 9;
// clang-format off
double inputs_d[kTableLength] = {
3.1, 3.6, 3.5, -3.1, -3.6, -3.5,
2147483648.0,
std::numeric_limits<double>::quiet_NaN(),
std::numeric_limits<double>::infinity()
};
float inputs_s[kTableLength] = {
3.1, 3.6, 3.5, -3.1, -3.6, -3.5,
2147483648.0,
std::numeric_limits<double>::quiet_NaN(),
std::numeric_limits<double>::infinity()
};
double outputs_w[kTableLength] = {
3.0, 4.0, 4.0, -3.0, -4.0, -4.0,
kFPUInvalidResult, 0,
kFPUInvalidResult};
double outputs_l[kTableLength] = {
3.0, 4.0, 4.0, -3.0, -4.0, -4.0,
2147483648.0, 0,
static_cast<double>(kFPU64InvalidResult)};
// clang-format on
__ Fld_d(f8, MemOperand(a0, offsetof(Test, a)));
__ Fld_s(f9, MemOperand(a0, offsetof(Test, b)));
__ ftintrne_w_d(f10, f8);
__ ftintrne_w_s(f11, f9);
__ ftintrne_l_d(f12, f8);
__ ftintrne_l_s(f13, f9);
__ Fst_s(f10, MemOperand(a0, offsetof(Test, c)));
__ Fst_s(f11, MemOperand(a0, offsetof(Test, d)));
__ Fst_d(f12, MemOperand(a0, offsetof(Test, e)));
__ Fst_d(f13, MemOperand(a0, offsetof(Test, f)));
__ jirl(zero_reg, ra, 0);
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::FOR_TESTING).Build();
auto f = GeneratedCode<F3>::FromCode(*code);
for (int i = 0; i < kTableLength; i++) {
test.a = inputs_d[i];
test.b = inputs_s[i];
f.Call(&test, 0, 0, 0, 0);
CHECK_EQ(test.c, outputs_w[i]);
CHECK_EQ(test.d, outputs_w[i]);
CHECK_EQ(test.e, outputs_l[i]);
CHECK_EQ(test.f, outputs_l[i]);
}
}
TEST(FRINT) {
CcTest::InitializeVM();
Isolate* isolate = CcTest::i_isolate();
HandleScope scope(isolate);
MacroAssembler assm(isolate, v8::internal::CodeObjectRequired::kYes);
struct Test {
double a;
float b;
double c;
float d;
int fcsr;
};
Test test;
const int kTableLength = 32;
// clang-format off
double inputs_d[kTableLength] = {
18446744073709551617.0, 4503599627370496.0, -4503599627370496.0,
1.26782468584154733584017312973E30, 1.44860108245951772690707170478E147,
1.7976931348623157E+308, 6.27463370218383111104242366943E-307,
309485009821345068724781056.89,
2.1, 2.6, 2.5, 3.1, 3.6, 3.5,
-2.1, -2.6, -2.5, -3.1, -3.6, -3.5,
37778931862957161709568.0, 37778931862957161709569.0,
37778931862957161709580.0, 37778931862957161709581.0,
37778931862957161709582.0, 37778931862957161709583.0,
37778931862957161709584.0, 37778931862957161709585.0,
37778931862957161709586.0, 37778931862957161709587.0,
std::numeric_limits<double>::max() - 0.1,
std::numeric_limits<double>::infinity()
};
float inputs_s[kTableLength] = {
18446744073709551617.0, 4503599627370496.0, -4503599627370496.0,
1.26782468584154733584017312973E30, 1.44860108245951772690707170478E37,
1.7976931348623157E+38, 6.27463370218383111104242366943E-37,
309485009821345068724781056.89,
2.1, 2.6, 2.5, 3.1, 3.6, 3.5,
-2.1, -2.6, -2.5, -3.1, -3.6, -3.5,
37778931862957161709568.0, 37778931862957161709569.0,
37778931862957161709580.0, 37778931862957161709581.0,
37778931862957161709582.0, 37778931862957161709583.0,
37778931862957161709584.0, 37778931862957161709585.0,
37778931862957161709586.0, 37778931862957161709587.0,
std::numeric_limits<float>::lowest() + 0.6,
std::numeric_limits<float>::infinity()
};
float outputs_RN_S[kTableLength] = {
18446744073709551617.0, 4503599627370496.0, -4503599627370496.0,
1.26782468584154733584017312973E30, 1.44860108245951772690707170478E37,
1.7976931348623157E38, 0,
309485009821345068724781057.0,
2.0, 3.0, 2.0, 3.0, 4.0, 4.0,
-2.0, -3.0, -2.0, -3.0, -4.0, -4.0,
37778931862957161709568.0, 37778931862957161709569.0,
37778931862957161709580.0, 37778931862957161709581.0,
37778931862957161709582.0, 37778931862957161709583.0,
37778931862957161709584.0, 37778931862957161709585.0,
37778931862957161709586.0, 37778931862957161709587.0,
std::numeric_limits<float>::lowest() + 1,
std::numeric_limits<float>::infinity()
};
double outputs_RN_D[kTableLength] = {
18446744073709551617.0, 4503599627370496.0, -4503599627370496.0,
1.26782468584154733584017312973E30, 1.44860108245951772690707170478E147,
1.7976931348623157E308, 0,
309485009821345068724781057.0,
2.0, 3.0, 2.0, 3.0, 4.0, 4.0,
-2.0, -3.0, -2.0, -3.0, -4.0, -4.0,
37778931862957161709568.0, 37778931862957161709569.0,
37778931862957161709580.0, 37778931862957161709581.0,
37778931862957161709582.0, 37778931862957161709583.0,
37778931862957161709584.0, 37778931862957161709585.0,
37778931862957161709586.0, 37778931862957161709587.0,
std::numeric_limits<double>::max(),
std::numeric_limits<double>::infinity()
};
float outputs_RZ_S[kTableLength] = {
18446744073709551617.0, 4503599627370496.0, -4503599627370496.0,
1.26782468584154733584017312973E30, 1.44860108245951772690707170478E37,
1.7976931348623157E38, 0,
309485009821345068724781057.0,
2.0, 2.0, 2.0, 3.0, 3.0, 3.0,
-2.0, -2.0, -2.0, -3.0, -3.0, -3.0,
37778931862957161709568.0, 37778931862957161709569.0,
37778931862957161709580.0, 37778931862957161709581.0,
37778931862957161709582.0, 37778931862957161709583.0,
37778931862957161709584.0, 37778931862957161709585.0,
37778931862957161709586.0, 37778931862957161709587.0,
std::numeric_limits<float>::lowest() + 1,
std::numeric_limits<float>::infinity()
};
double outputs_RZ_D[kTableLength] = {
18446744073709551617.0, 4503599627370496.0, -4503599627370496.0,
1.26782468584154733584017312973E30, 1.44860108245951772690707170478E147,
1.7976931348623157E308, 0,
309485009821345068724781057.0,
2.0, 2.0, 2.0, 3.0, 3.0, 3.0,
-2.0, -2.0, -2.0, -3.0, -3.0, -3.0,
37778931862957161709568.0, 37778931862957161709569.0,
37778931862957161709580.0, 37778931862957161709581.0,
37778931862957161709582.0, 37778931862957161709583.0,
37778931862957161709584.0, 37778931862957161709585.0,
37778931862957161709586.0, 37778931862957161709587.0,
std::numeric_limits<double>::max() - 1,
std::numeric_limits<double>::infinity()
};
float outputs_RP_S[kTableLength] = {
18446744073709551617.0, 4503599627370496.0, -4503599627370496.0,
1.26782468584154733584017312973E30, 1.44860108245951772690707170478E37,
1.7976931348623157E38, 1,
309485009821345068724781057.0,
3.0, 3.0, 3.0, 4.0, 4.0, 4.0,
-2.0, -2.0, -2.0, -3.0, -3.0, -3.0,
37778931862957161709568.0, 37778931862957161709569.0,
37778931862957161709580.0, 37778931862957161709581.0,
37778931862957161709582.0, 37778931862957161709583.0,
37778931862957161709584.0, 37778931862957161709585.0,
37778931862957161709586.0, 37778931862957161709587.0,
std::numeric_limits<float>::lowest() + 1,
std::numeric_limits<float>::infinity()
};
double outputs_RP_D[kTableLength] = {
18446744073709551617.0, 4503599627370496.0, -4503599627370496.0,
1.26782468584154733584017312973E30, 1.44860108245951772690707170478E147,
1.7976931348623157E308, 1,
309485009821345068724781057.0,
3.0, 3.0, 3.0, 4.0, 4.0, 4.0,
-2.0, -2.0, -2.0, -3.0, -3.0, -3.0,
37778931862957161709568.0, 37778931862957161709569.0,
37778931862957161709580.0, 37778931862957161709581.0,
37778931862957161709582.0, 37778931862957161709583.0,
37778931862957161709584.0, 37778931862957161709585.0,
37778931862957161709586.0, 37778931862957161709587.0,
std::numeric_limits<double>::max(),
std::numeric_limits<double>::infinity()
};
float outputs_RM_S[kTableLength] = {
18446744073709551617.0, 4503599627370496.0, -4503599627370496.0,
1.26782468584154733584017312973E30, 1.44860108245951772690707170478E37,
1.7976931348623157E38, 0,
309485009821345068724781057.0,
2.0, 2.0, 2.0, 3.0, 3.0, 3.0,
-3.0, -3.0, -3.0, -4.0, -4.0, -4.0,
37778931862957161709568.0, 37778931862957161709569.0,
37778931862957161709580.0, 37778931862957161709581.0,
37778931862957161709582.0, 37778931862957161709583.0,
37778931862957161709584.0, 37778931862957161709585.0,
37778931862957161709586.0, 37778931862957161709587.0,
std::numeric_limits<float>::lowest() + 1,
std::numeric_limits<float>::infinity()
};
double outputs_RM_D[kTableLength] = {
18446744073709551617.0, 4503599627370496.0, -4503599627370496.0,
1.26782468584154733584017312973E30, 1.44860108245951772690707170478E147,
1.7976931348623157E308, 0,
309485009821345068724781057.0,
2.0, 2.0, 2.0, 3.0, 3.0, 3.0,
-3.0, -3.0, -3.0, -4.0, -4.0, -4.0,
37778931862957161709568.0, 37778931862957161709569.0,
37778931862957161709580.0, 37778931862957161709581.0,
37778931862957161709582.0, 37778931862957161709583.0,
37778931862957161709584.0, 37778931862957161709585.0,
37778931862957161709586.0, 37778931862957161709587.0,
std::numeric_limits<double>::max(),
std::numeric_limits<double>::infinity()
};
// clang-format on
int fcsr_inputs[4] = {kRoundToNearest, kRoundToZero, kRoundToPlusInf,
kRoundToMinusInf};
double* outputs_d[4] = {outputs_RN_D, outputs_RZ_D, outputs_RP_D,
outputs_RM_D};
float* outputs_s[4] = {outputs_RN_S, outputs_RZ_S, outputs_RP_S,
outputs_RM_S};
__ Fld_d(f8, MemOperand(a0, offsetof(Test, a)));
__ Fld_s(f9, MemOperand(a0, offsetof(Test, b)));
__ xor_(a5, a5, a5);
__ Ld_w(a5, MemOperand(a0, offsetof(Test, fcsr)));
__ movfcsr2gr(a4);
__ movgr2fcsr(a5);
__ frint_d(f10, f8);
__ frint_s(f11, f9);
__ Fst_d(f10, MemOperand(a0, offsetof(Test, c)));
__ Fst_s(f11, MemOperand(a0, offsetof(Test, d)));
__ movgr2fcsr(a4);
__ jirl(zero_reg, ra, 0);
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::FOR_TESTING).Build();
auto f = GeneratedCode<F3>::FromCode(*code);
for (int j = 0; j < 4; j++) {
test.fcsr = fcsr_inputs[j];
for (int i = 0; i < kTableLength; i++) {
test.a = inputs_d[i];
test.b = inputs_s[i];
f.Call(&test, 0, 0, 0, 0);
CHECK_EQ(test.c, outputs_d[j][i]);
CHECK_EQ(test.d, outputs_s[j][i]);
}
}
}
TEST(FMOV) {
const int kTableLength = 7;
CcTest::InitializeVM();
Isolate* isolate = CcTest::i_isolate();
HandleScope scope(isolate);
MacroAssembler assm(isolate, v8::internal::CodeObjectRequired::kYes);
struct TestFloat {
double a;
float b;
double c;
float d;
};
TestFloat test;
// clang-format off
double inputs_D[kTableLength] = {
5.3, -5.3, 0.29, -0.29, 0,
std::numeric_limits<double>::max(),
-std::numeric_limits<double>::max()
};
float inputs_S[kTableLength] = {
4.8, -4.8, 0.29, -0.29, 0,
std::numeric_limits<float>::max(),
-std::numeric_limits<float>::max()
};
double outputs_D[kTableLength] = {
5.3, -5.3, 0.29, -0.29, 0,
std::numeric_limits<double>::max(),
-std::numeric_limits<double>::max()
};
float outputs_S[kTableLength] = {
4.8, -4.8, 0.29, -0.29, 0,
std::numeric_limits<float>::max(),
-std::numeric_limits<float>::max()
};
// clang-format on
__ Fld_d(f8, MemOperand(a0, offsetof(TestFloat, a)));
__ Fld_s(f9, MemOperand(a0, offsetof(TestFloat, b)));
__ fmov_d(f10, f8);
__ fmov_s(f11, f9);
__ Fst_d(f10, MemOperand(a0, offsetof(TestFloat, c)));
__ Fst_s(f11, MemOperand(a0, offsetof(TestFloat, d)));
__ jirl(zero_reg, ra, 0);
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::FOR_TESTING).Build();
auto f = GeneratedCode<F3>::FromCode(*code);
for (int i = 0; i < kTableLength; i++) {
test.a = inputs_D[i];
test.b = inputs_S[i];
f.Call(&test, 0, 0, 0, 0);
CHECK_EQ(test.c, outputs_D[i]);
CHECK_EQ(test.d, outputs_S[i]);
}
}
TEST(LA14) {
CcTest::InitializeVM();
Isolate* isolate = CcTest::i_isolate();
HandleScope scope(isolate);
struct T {
double a;
double b;
double c;
double d;
int64_t high;
int64_t low;
};
T t;
MacroAssembler assm(isolate, v8::internal::CodeObjectRequired::kYes);
__ Fld_d(f8, MemOperand(a0, offsetof(T, a)));
__ Fld_d(f9, MemOperand(a0, offsetof(T, b)));
__ movfr2gr_s(a4, f8);
__ movfrh2gr_s(a5, f8);
__ movfr2gr_d(a6, f9);
__ movgr2fr_w(f9, a4);
__ movgr2frh_w(f9, a5);
__ movgr2fr_d(f8, a6);
__ Fst_d(f8, MemOperand(a0, offsetof(T, a)));
__ Fst_d(f9, MemOperand(a0, offsetof(T, c)));
__ Fld_d(f8, MemOperand(a0, offsetof(T, d)));
__ movfrh2gr_s(a4, f8);
__ movfr2gr_s(a5, f8);
__ St_d(a4, MemOperand(a0, offsetof(T, high)));
__ St_d(a5, MemOperand(a0, offsetof(T, low)));
__ jirl(zero_reg, ra, 0);
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::FOR_TESTING).Build();
auto f = GeneratedCode<F3>::FromCode(*code);
t.a = 1.5e22;
t.b = 2.75e11;
t.c = 17.17;
t.d = -2.75e11;
f.Call(&t, 0, 0, 0, 0);
CHECK_EQ(2.75e11, t.a);
CHECK_EQ(2.75e11, t.b);
CHECK_EQ(1.5e22, t.c);
CHECK_EQ(static_cast<int64_t>(0xFFFFFFFFC25001D1L), t.high);
CHECK_EQ(static_cast<int64_t>(0xFFFFFFFFBF800000L), t.low);
t.a = -1.5e22;
t.b = -2.75e11;
t.c = 17.17;
t.d = 274999868928.0;
f.Call(&t, 0, 0, 0, 0);
CHECK_EQ(-2.75e11, t.a);
CHECK_EQ(-2.75e11, t.b);
CHECK_EQ(-1.5e22, t.c);
CHECK_EQ(static_cast<int64_t>(0x425001D1L), t.high);
CHECK_EQ(static_cast<int64_t>(0x3F800000L), t.low);
}
uint64_t run_bceqz(int fcc_value, int32_t offset) {
Isolate* isolate = CcTest::i_isolate();
HandleScope scope(isolate);
MacroAssembler assm(isolate, v8::internal::CodeObjectRequired::kYes);
Label main_block, L;
__ li(a2, 0);
__ li(t0, fcc_value);
__ b(&main_block);
// Block 1
for (int32_t i = -104; i <= -55; ++i) {
__ addi_d(a2, a2, 0x1);
}
__ b(&L);
// Block 2
for (int32_t i = -53; i <= -4; ++i) {
__ addi_d(a2, a2, 0x10);
}
__ b(&L);
// Block 3 (Main)
__ bind(&main_block);
__ movcf2gr(t1, FCC0);
__ movgr2cf(FCC0, t0);
__ bceqz(FCC0, offset);
__ bind(&L);
__ movgr2cf(FCC0, t1);
__ or_(a0, a2, zero_reg);
__ jirl(zero_reg, ra, 0);
// Block 4
for (int32_t i = 4; i <= 53; ++i) {
__ addi_d(a2, a2, 0x100);
}
__ b(&L);
// Block 5
for (int32_t i = 55; i <= 104; ++i) {
__ addi_d(a2, a2, 0x300);
}
__ b(&L);
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::FOR_TESTING).Build();
auto f = GeneratedCode<F2>::FromCode(*code);
uint64_t res = reinterpret_cast<uint64_t>(f.Call(0, 0, 0, 0, 0));
return res;
}
TEST(BCEQZ) {
CcTest::InitializeVM();
struct TestCaseBceqz {
int fcc;
int32_t offset;
uint64_t expected_res;
};
// clang-format off
struct TestCaseBceqz tc[] = {
// fcc, offset, expected_res
{ 0, -90, 0x24 },
{ 0, -27, 0x180 },
{ 0, 47, 0x700 },
{ 0, 70, 0x6900 },
{ 1, -27, 0 },
{ 1, 47, 0 },
};
// clang-format on
size_t nr_test_cases = sizeof(tc) / sizeof(TestCaseBceqz);
for (size_t i = 0; i < nr_test_cases; ++i) {
uint64_t res = run_bceqz(tc[i].fcc, tc[i].offset);
CHECK_EQ(tc[i].expected_res, res);
}
}
uint64_t run_bcnez(int fcc_value, int32_t offset) {
Isolate* isolate = CcTest::i_isolate();
HandleScope scope(isolate);
MacroAssembler assm(isolate, v8::internal::CodeObjectRequired::kYes);
Label main_block, L;
__ li(a2, 0);
__ li(t0, fcc_value);
__ b(&main_block);
// Block 1
for (int32_t i = -104; i <= -55; ++i) {
__ addi_d(a2, a2, 0x1);
}
__ b(&L);
// Block 2
for (int32_t i = -53; i <= -4; ++i) {
__ addi_d(a2, a2, 0x10);
}
__ b(&L);
// Block 3 (Main)
__ bind(&main_block);
__ movcf2gr(t1, FCC0);
__ movgr2cf(FCC0, t0);
__ bcnez(FCC0, offset);
__ bind(&L);
__ movgr2cf(FCC0, t1);
__ or_(a0, a2, zero_reg);
__ jirl(zero_reg, ra, 0);
// Block 4
for (int32_t i = 4; i <= 53; ++i) {
__ addi_d(a2, a2, 0x100);
}
__ b(&L);
// Block 5
for (int32_t i = 55; i <= 104; ++i) {
__ addi_d(a2, a2, 0x300);
}
__ b(&L);
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::FOR_TESTING).Build();
auto f = GeneratedCode<F2>::FromCode(*code);
uint64_t res = reinterpret_cast<uint64_t>(f.Call(0, 0, 0, 0, 0));
return res;
}
TEST(BCNEZ) {
CcTest::InitializeVM();
struct TestCaseBcnez {
int fcc;
int32_t offset;
uint64_t expected_res;
};
// clang-format off
struct TestCaseBcnez tc[] = {
// fcc, offset, expected_res
{ 1, -90, 0x24 },
{ 1, -27, 0x180 },
{ 1, 47, 0x700 },
{ 1, 70, 0x6900 },
{ 0, -27, 0 },
{ 0, 47, 0 },
};
// clang-format on
size_t nr_test_cases = sizeof(tc) / sizeof(TestCaseBcnez);
for (size_t i = 0; i < nr_test_cases; ++i) {
uint64_t res = run_bcnez(tc[i].fcc, tc[i].offset);
CHECK_EQ(tc[i].expected_res, res);
}
}
TEST(jump_tables1) {
// Test jump tables with forward jumps.
CcTest::InitializeVM();
Isolate* isolate = CcTest::i_isolate();
HandleScope scope(isolate);
MacroAssembler assm(isolate, v8::internal::CodeObjectRequired::kYes);
const int kNumCases = 512;
int values[kNumCases];
isolate->random_number_generator()->NextBytes(values, sizeof(values));
Label labels[kNumCases];
__ addi_d(sp, sp, -8);
__ St_d(ra, MemOperand(sp, 0));
__ Align(8);
Label done;
{
__ BlockTrampolinePoolFor(kNumCases * 2 + 6);
__ pcaddi(ra, 2);
__ slli_d(t7, a0, 3);
__ add_d(t7, t7, ra);
__ Ld_d(t7, MemOperand(t7, 4 * kInstrSize));
__ jirl(zero_reg, t7, 0);
__ nop();
for (int i = 0; i < kNumCases; ++i) {
__ dd(&labels[i]);
}
}
for (int i = 0; i < kNumCases; ++i) {
__ bind(&labels[i]);
__ lu12i_w(a2, (values[i] >> 12) & 0xFFFFF);
__ ori(a2, a2, values[i] & 0xFFF);
__ b(&done);
__ nop();
}
__ bind(&done);
__ Ld_d(ra, MemOperand(sp, 0));
__ addi_d(sp, sp, 8);
__ or_(a0, a2, zero_reg);
__ jirl(zero_reg, ra, 0);
CHECK_EQ(0, assm.UnboundLabelsCount());
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::FOR_TESTING).Build();
#ifdef OBJECT_PRINT
code->Print(std::cout);
#endif
auto f = GeneratedCode<F1>::FromCode(*code);
for (int i = 0; i < kNumCases; ++i) {
int64_t res = reinterpret_cast<int64_t>(f.Call(i, 0, 0, 0, 0));
::printf("f(%d) = %" PRId64 "\n", i, res);
CHECK_EQ((values[i]), static_cast<int>(res));
}
}
TEST(jump_tables2) {
// Test jump tables with backward jumps.
CcTest::InitializeVM();
Isolate* isolate = CcTest::i_isolate();
HandleScope scope(isolate);
MacroAssembler assm(isolate, v8::internal::CodeObjectRequired::kYes);
const int kNumCases = 512;
int values[kNumCases];
isolate->random_number_generator()->NextBytes(values, sizeof(values));
Label labels[kNumCases];
__ addi_d(sp, sp, -8);
__ St_d(ra, MemOperand(sp, 0));
Label done, dispatch;
__ b(&dispatch);
__ nop();
for (int i = 0; i < kNumCases; ++i) {
__ bind(&labels[i]);
__ lu12i_w(a2, (values[i] >> 12) & 0xFFFFF);
__ ori(a2, a2, values[i] & 0xFFF);
__ b(&done);
__ nop();
}
__ Align(8);
__ bind(&dispatch);
{
__ BlockTrampolinePoolFor(kNumCases * 2 + 6);
__ pcaddi(ra, 2);
__ slli_d(t7, a0, 3);
__ add_d(t7, t7, ra);
__ Ld_d(t7, MemOperand(t7, 4 * kInstrSize));
__ jirl(zero_reg, t7, 0);
__ nop();
for (int i = 0; i < kNumCases; ++i) {
__ dd(&labels[i]);
}
}
__ bind(&done);
__ Ld_d(ra, MemOperand(sp, 0));
__ addi_d(sp, sp, 8);
__ or_(a0, a2, zero_reg);
__ jirl(zero_reg, ra, 0);
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::FOR_TESTING).Build();
#ifdef OBJECT_PRINT
code->Print(std::cout);
#endif
auto f = GeneratedCode<F1>::FromCode(*code);
for (int i = 0; i < kNumCases; ++i) {
int64_t res = reinterpret_cast<int64_t>(f.Call(i, 0, 0, 0, 0));
::printf("f(%d) = %" PRId64 "\n", i, res);
CHECK_EQ(values[i], res);
}
}
TEST(jump_tables3) {
// Test jump tables with backward jumps and embedded heap objects.
CcTest::InitializeVM();
Isolate* isolate = CcTest::i_isolate();
HandleScope scope(isolate);
MacroAssembler assm(isolate, v8::internal::CodeObjectRequired::kYes);
const int kNumCases = 512;
Handle<Object> values[kNumCases];
for (int i = 0; i < kNumCases; ++i) {
double value = isolate->random_number_generator()->NextDouble();
values[i] = isolate->factory()->NewHeapNumber<AllocationType::kOld>(value);
}
Label labels[kNumCases];
Object obj;
int64_t imm64;
__ addi_d(sp, sp, -8);
__ St_d(ra, MemOperand(sp, 0));
Label done, dispatch;
__ b(&dispatch);
__ nop();
for (int i = 0; i < kNumCases; ++i) {
__ bind(&labels[i]);
obj = *values[i];
imm64 = obj.ptr();
__ lu12i_w(a2, (imm64 >> 12) & 0xFFFFF);
__ ori(a2, a2, imm64 & 0xFFF);
__ lu32i_d(a2, (imm64 >> 32) & 0xFFFFF);
__ lu52i_d(a2, a2, (imm64 >> 52) & 0xFFF);
__ b(&done);
}
__ Align(8);
__ bind(&dispatch);
{
__ BlockTrampolinePoolFor(kNumCases * 2 + 6);
__ pcaddi(ra, 2);
__ slli_d(t7, a0, 3); // In delay slot.
__ add_d(t7, t7, ra);
__ Ld_d(t7, MemOperand(t7, 4 * kInstrSize));
__ jirl(zero_reg, t7, 0);
__ nop();
for (int i = 0; i < kNumCases; ++i) {
__ dd(&labels[i]);
}
}
__ bind(&done);
__ Ld_d(ra, MemOperand(sp, 0));
__ addi_d(sp, sp, 8);
__ or_(a0, a2, zero_reg);
__ jirl(zero_reg, ra, 0);
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::FOR_TESTING).Build();
#ifdef OBJECT_PRINT
code->Print(std::cout);
#endif
auto f = GeneratedCode<F1>::FromCode(*code);
for (int i = 0; i < kNumCases; ++i) {
Handle<Object> result(
Object(reinterpret_cast<Address>(f.Call(i, 0, 0, 0, 0))), isolate);
#ifdef OBJECT_PRINT
::printf("f(%d) = ", i);
result->Print(std::cout);
::printf("\n");
#endif
CHECK(values[i].is_identical_to(result));
}
}
uint64_t run_li_macro(int64_t imm, LiFlags mode, int32_t num_instr = 0) {
Isolate* isolate = CcTest::i_isolate();
HandleScope scope(isolate);
MacroAssembler assm(isolate, v8::internal::CodeObjectRequired::kYes);
Label code_start;
__ bind(&code_start);
__ li(a2, imm, mode);
if (num_instr > 0) {
CHECK_EQ(assm.InstructionsGeneratedSince(&code_start), num_instr);
CHECK_EQ(__ InstrCountForLi64Bit(imm), num_instr);
}
__ or_(a0, a2, zero_reg);
__ jirl(zero_reg, ra, 0);
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::FOR_TESTING).Build();
#ifdef OBJECT_PRINT
code->Print(std::cout);
#endif
auto f = GeneratedCode<F2>::FromCode(*code);
uint64_t res = reinterpret_cast<uint64_t>(f.Call(0, 0, 0, 0, 0));
return res;
}
TEST(li_macro) {
CcTest::InitializeVM();
// Test li macro-instruction for border cases.
struct TestCase_li {
uint64_t imm;
int32_t num_instr;
};
// clang-format off
struct TestCase_li tc[] = {
// imm, num_instr
{0xFFFFFFFFFFFFF800, 1}, // min_int12
// The test case above generates addi_d instruction.
// This is int12 value and we can load it using just addi_d.
{ 0x800, 1}, // max_int12 + 1
// Generates ori
// max_int12 + 1 is not int12 but is uint12, just use ori.
{0xFFFFFFFFFFFFF7FF, 2}, // min_int12 - 1
// Generates lu12i + ori
// We load int32 value using lu12i_w + ori.
{ 0x801, 1}, // max_int12 + 2
// Generates ori
// Also an uint1 value, use ori.
{ 0x00001000, 1}, // max_uint12 + 1
// Generates lu12i_w
// Low 12 bits are 0, load value using lu12i_w.
{ 0x00001001, 2}, // max_uint12 + 2
// Generates lu12i_w + ori
// We have to generate two instructions in this case.
{0x00000000FFFFFFFF, 2}, // max_uint32
// addi_w + lu32i_d
{0x00000000FFFFFFFE, 2}, // max_uint32 - 1
// addi_w + lu32i_d
{0xFFFFFFFF80000000, 1}, // min_int32
// lu12i_w
{0x0000000080000000, 2}, // max_int32 + 1
// lu12i_w + lu32i_d
{0xFFFF0000FFFF8765, 3},
// lu12i_w + ori + lu32i_d
{0x1234ABCD87654321, 4},
// lu12i_w + ori + lu32i_d + lu52i_d
{0xFFFF789100000000, 2},
// xor + lu32i_d
{0xF12F789100000000, 3},
// xor + lu32i_d + lu52i_d
{0xF120000000000800, 2},
// ori + lu52i_d
{0xFFF0000000000000, 1},
// lu52i_d
{0xF100000000000000, 1},
{0x0122000000000000, 2},
{0x1234FFFF77654321, 4},
{0x1230000077654321, 3},
};
// clang-format on
size_t nr_test_cases = sizeof(tc) / sizeof(TestCase_li);
for (size_t i = 0; i < nr_test_cases; ++i) {
CHECK_EQ(tc[i].imm,
run_li_macro(tc[i].imm, OPTIMIZE_SIZE, tc[i].num_instr));
CHECK_EQ(tc[i].imm, run_li_macro(tc[i].imm, CONSTANT_SIZE));
if (is_int48(tc[i].imm)) {
CHECK_EQ(tc[i].imm, run_li_macro(tc[i].imm, ADDRESS_LOAD));
}
}
}
TEST(FMIN_FMAX) {
CcTest::InitializeVM();
Isolate* isolate = CcTest::i_isolate();
HandleScope scope(isolate);
MacroAssembler assm(isolate, v8::internal::CodeObjectRequired::kYes);
struct TestFloat {
double a;
double b;
float c;
float d;
double e;
double f;
float g;
float h;
};
TestFloat test;
const double dnan = std::numeric_limits<double>::quiet_NaN();
const double dinf = std::numeric_limits<double>::infinity();
const double dminf = -std::numeric_limits<double>::infinity();
const float fnan = std::numeric_limits<float>::quiet_NaN();
const float finf = std::numeric_limits<float>::infinity();
const float fminf = -std::numeric_limits<float>::infinity();
const int kTableLength = 13;
// clang-format off
double inputsa[kTableLength] = {2.0, 3.0, dnan, 3.0, -0.0, 0.0, dinf,
dnan, 42.0, dinf, dminf, dinf, dnan};
double inputsb[kTableLength] = {3.0, 2.0, 3.0, dnan, 0.0, -0.0, dnan,
dinf, dinf, 42.0, dinf, dminf, dnan};
double outputsdmin[kTableLength] = {2.0, 2.0, 3.0, 3.0, -0.0,
-0.0, dinf, dinf, 42.0, 42.0,
dminf, dminf, dnan};
double outputsdmax[kTableLength] = {3.0, 3.0, 3.0, 3.0, 0.0, 0.0, dinf,
dinf, dinf, dinf, dinf, dinf, dnan};
float inputsc[kTableLength] = {2.0, 3.0, fnan, 3.0, -0.0, 0.0, finf,
fnan, 42.0, finf, fminf, finf, fnan};
float inputsd[kTableLength] = {3.0, 2.0, 3.0, fnan, 0.0, -0.0, fnan,
finf, finf, 42.0, finf, fminf, fnan};
float outputsfmin[kTableLength] = {2.0, 2.0, 3.0, 3.0, -0.0,
-0.0, finf, finf, 42.0, 42.0,
fminf, fminf, fnan};
float outputsfmax[kTableLength] = {3.0, 3.0, 3.0, 3.0, 0.0, 0.0, finf,
finf, finf, finf, finf, finf, fnan};
// clang-format on
__ Fld_d(f8, MemOperand(a0, offsetof(TestFloat, a)));
__ Fld_d(f9, MemOperand(a0, offsetof(TestFloat, b)));
__ Fld_s(f10, MemOperand(a0, offsetof(TestFloat, c)));
__ Fld_s(f11, MemOperand(a0, offsetof(TestFloat, d)));
__ fmin_d(f12, f8, f9);
__ fmax_d(f13, f8, f9);
__ fmin_s(f14, f10, f11);
__ fmax_s(f15, f10, f11);
__ Fst_d(f12, MemOperand(a0, offsetof(TestFloat, e)));
__ Fst_d(f13, MemOperand(a0, offsetof(TestFloat, f)));
__ Fst_s(f14, MemOperand(a0, offsetof(TestFloat, g)));
__ Fst_s(f15, MemOperand(a0, offsetof(TestFloat, h)));
__ jirl(zero_reg, ra, 0);
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::FOR_TESTING).Build();
auto f = GeneratedCode<F3>::FromCode(*code);
for (int i = 4; i < kTableLength; i++) {
test.a = inputsa[i];
test.b = inputsb[i];
test.c = inputsc[i];
test.d = inputsd[i];
f.Call(&test, 0, 0, 0, 0);
CHECK_EQ(0, memcmp(&test.e, &outputsdmin[i], sizeof(test.e)));
CHECK_EQ(0, memcmp(&test.f, &outputsdmax[i], sizeof(test.f)));
CHECK_EQ(0, memcmp(&test.g, &outputsfmin[i], sizeof(test.g)));
CHECK_EQ(0, memcmp(&test.h, &outputsfmax[i], sizeof(test.h)));
}
}
TEST(FMINA_FMAXA) {
const int kTableLength = 23;
CcTest::InitializeVM();
Isolate* isolate = CcTest::i_isolate();
HandleScope scope(isolate);
MacroAssembler assm(isolate, v8::internal::CodeObjectRequired::kYes);
const double dnan = std::numeric_limits<double>::quiet_NaN();
const double dinf = std::numeric_limits<double>::infinity();
const double dminf = -std::numeric_limits<double>::infinity();
const float fnan = std::numeric_limits<float>::quiet_NaN();
const float finf = std::numeric_limits<float>::infinity();
const float fminf = std::numeric_limits<float>::infinity();
struct TestFloat {
double a;
double b;
double resd1;
double resd2;
float c;
float d;
float resf1;
float resf2;
};
TestFloat test;
// clang-format off
double inputsa[kTableLength] = {
5.3, 4.8, 6.1, 9.8, 9.8, 9.8, -10.0, -8.9, -9.8, -10.0, -8.9, -9.8,
dnan, 3.0, -0.0, 0.0, dinf, dnan, 42.0, dinf, dminf, dinf, dnan};
double inputsb[kTableLength] = {
4.8, 5.3, 6.1, -10.0, -8.9, -9.8, 9.8, 9.8, 9.8, -9.8, -11.2, -9.8,
3.0, dnan, 0.0, -0.0, dnan, dinf, dinf, 42.0, dinf, dminf, dnan};
double resd1[kTableLength] = {
4.8, 4.8, 6.1, 9.8, -8.9, -9.8, 9.8, -8.9, -9.8, -9.8, -8.9, -9.8,
3.0, 3.0, -0.0, -0.0, dinf, dinf, 42.0, 42.0, dminf, dminf, dnan};
double resd2[kTableLength] = {
5.3, 5.3, 6.1, -10.0, 9.8, 9.8, -10.0, 9.8, 9.8, -10.0, -11.2, -9.8,
3.0, 3.0, 0.0, 0.0, dinf, dinf, dinf, dinf, dinf, dinf, dnan};
float inputsc[kTableLength] = {
5.3, 4.8, 6.1, 9.8, 9.8, 9.8, -10.0, -8.9, -9.8, -10.0, -8.9, -9.8,
fnan, 3.0, -0.0, 0.0, finf, fnan, 42.0, finf, fminf, finf, fnan};
float inputsd[kTableLength] = {
4.8, 5.3, 6.1, -10.0, -8.9, -9.8, 9.8, 9.8, 9.8, -9.8, -11.2, -9.8,
3.0, fnan, -0.0, 0.0, fnan, finf, finf, 42.0, finf, fminf, fnan};
float resf1[kTableLength] = {
4.8, 4.8, 6.1, 9.8, -8.9, -9.8, 9.8, -8.9, -9.8, -9.8, -8.9, -9.8,
3.0, 3.0, -0.0, -0.0, finf, finf, 42.0, 42.0, fminf, fminf, fnan};
float resf2[kTableLength] = {
5.3, 5.3, 6.1, -10.0, 9.8, 9.8, -10.0, 9.8, 9.8, -10.0, -11.2, -9.8,
3.0, 3.0, 0.0, 0.0, finf, finf, finf, finf, finf, finf, fnan};
// clang-format on
__ Fld_d(f8, MemOperand(a0, offsetof(TestFloat, a)));
__ Fld_d(f9, MemOperand(a0, offsetof(TestFloat, b)));
__ Fld_s(f10, MemOperand(a0, offsetof(TestFloat, c)));
__ Fld_s(f11, MemOperand(a0, offsetof(TestFloat, d)));
__ fmina_d(f12, f8, f9);
__ fmaxa_d(f13, f8, f9);
__ fmina_s(f14, f10, f11);
__ fmaxa_s(f15, f10, f11);
__ Fst_d(f12, MemOperand(a0, offsetof(TestFloat, resd1)));
__ Fst_d(f13, MemOperand(a0, offsetof(TestFloat, resd2)));
__ Fst_s(f14, MemOperand(a0, offsetof(TestFloat, resf1)));
__ Fst_s(f15, MemOperand(a0, offsetof(TestFloat, resf2)));
__ jirl(zero_reg, ra, 0);
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::FOR_TESTING).Build();
auto f = GeneratedCode<F3>::FromCode(*code);
for (int i = 0; i < kTableLength; i++) {
test.a = inputsa[i];
test.b = inputsb[i];
test.c = inputsc[i];
test.d = inputsd[i];
f.Call(&test, 0, 0, 0, 0);
if (i < kTableLength - 1) {
CHECK_EQ(test.resd1, resd1[i]);
CHECK_EQ(test.resd2, resd2[i]);
CHECK_EQ(test.resf1, resf1[i]);
CHECK_EQ(test.resf2, resf2[i]);
} else {
CHECK(std::isnan(test.resd1));
CHECK(std::isnan(test.resd2));
CHECK(std::isnan(test.resf1));
CHECK(std::isnan(test.resf2));
}
}
}
TEST(FADD) {
CcTest::InitializeVM();
Isolate* isolate = CcTest::i_isolate();
HandleScope scope(isolate);
MacroAssembler assm(isolate, v8::internal::CodeObjectRequired::kYes);
struct TestFloat {
double a;
double b;
double c;
float d;
float e;
float f;
};
TestFloat test;
__ Fld_d(f8, MemOperand(a0, offsetof(TestFloat, a)));
__ Fld_d(f9, MemOperand(a0, offsetof(TestFloat, b)));
__ fadd_d(f10, f8, f9);
__ Fst_d(f10, MemOperand(a0, offsetof(TestFloat, c)));
__ Fld_s(f11, MemOperand(a0, offsetof(TestFloat, d)));
__ Fld_s(f12, MemOperand(a0, offsetof(TestFloat, e)));
__ fadd_s(f13, f11, f12);
__ Fst_s(f13, MemOperand(a0, offsetof(TestFloat, f)));
__ jirl(zero_reg, ra, 0);
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::FOR_TESTING).Build();
auto f = GeneratedCode<F3>::FromCode(*code);
test.a = 2.0;
test.b = 3.0;
test.d = 2.0;
test.e = 3.0;
f.Call(&test, 0, 0, 0, 0);
CHECK_EQ(test.c, 5.0);
CHECK_EQ(test.f, 5.0);
test.a = std::numeric_limits<double>::max();
test.b = -std::numeric_limits<double>::max(); // lowest()
test.d = std::numeric_limits<float>::max();
test.e = -std::numeric_limits<float>::max(); // lowest()
f.Call(&test, 0, 0, 0, 0);
CHECK_EQ(test.c, 0.0);
CHECK_EQ(test.f, 0.0);
test.a = std::numeric_limits<double>::max();
test.b = std::numeric_limits<double>::max();
test.d = std::numeric_limits<float>::max();
test.e = std::numeric_limits<float>::max();
f.Call(&test, 0, 0, 0, 0);
CHECK(!std::isfinite(test.c));
CHECK(!std::isfinite(test.f));
test.a = 5.0;
test.b = std::numeric_limits<double>::signaling_NaN();
test.d = 5.0;
test.e = std::numeric_limits<float>::signaling_NaN();
f.Call(&test, 0, 0, 0, 0);
CHECK(std::isnan(test.c));
CHECK(std::isnan(test.f));
}
TEST(FSUB) {
const int kTableLength = 12;
CcTest::InitializeVM();
Isolate* isolate = CcTest::i_isolate();
HandleScope scope(isolate);
MacroAssembler assm(isolate, v8::internal::CodeObjectRequired::kYes);
struct TestFloat {
float a;
float b;
float resultS;
double c;
double d;
double resultD;
};
TestFloat test;
// clang-format off
double inputfs_D[kTableLength] = {
5.3, 4.8, 2.9, -5.3, -4.8, -2.9,
5.3, 4.8, 2.9, -5.3, -4.8, -2.9
};
double inputft_D[kTableLength] = {
4.8, 5.3, 2.9, 4.8, 5.3, 2.9,
-4.8, -5.3, -2.9, -4.8, -5.3, -2.9
};
double outputs_D[kTableLength] = {
0.5, -0.5, 0.0, -10.1, -10.1, -5.8,
10.1, 10.1, 5.8, -0.5, 0.5, 0.0
};
float inputfs_S[kTableLength] = {
5.3, 4.8, 2.9, -5.3, -4.8, -2.9,
5.3, 4.8, 2.9, -5.3, -4.8, -2.9
};
float inputft_S[kTableLength] = {
4.8, 5.3, 2.9, 4.8, 5.3, 2.9,
-4.8, -5.3, -2.9, -4.8, -5.3, -2.9
};
float outputs_S[kTableLength] = {
0.5, -0.5, 0.0, -10.1, -10.1, -5.8,
10.1, 10.1, 5.8, -0.5, 0.5, 0.0
};
// clang-format on
__ Fld_s(f8, MemOperand(a0, offsetof(TestFloat, a)));
__ Fld_s(f9, MemOperand(a0, offsetof(TestFloat, b)));
__ Fld_d(f10, MemOperand(a0, offsetof(TestFloat, c)));
__ Fld_d(f11, MemOperand(a0, offsetof(TestFloat, d)));
__ fsub_s(f12, f8, f9);
__ fsub_d(f13, f10, f11);
__ Fst_s(f12, MemOperand(a0, offsetof(TestFloat, resultS)));
__ Fst_d(f13, MemOperand(a0, offsetof(TestFloat, resultD)));
__ jirl(zero_reg, ra, 0);
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::FOR_TESTING).Build();
auto f = GeneratedCode<F3>::FromCode(*code);
for (int i = 0; i < kTableLength; i++) {
test.a = inputfs_S[i];
test.b = inputft_S[i];
test.c = inputfs_D[i];
test.d = inputft_D[i];
f.Call(&test, 0, 0, 0, 0);
CHECK_EQ(test.resultS, outputs_S[i]);
CHECK_EQ(test.resultD, outputs_D[i]);
}
}
TEST(FMUL) {
const int kTableLength = 4;
CcTest::InitializeVM();
Isolate* isolate = CcTest::i_isolate();
HandleScope scope(isolate);
MacroAssembler assm(isolate, v8::internal::CodeObjectRequired::kYes);
struct TestFloat {
float a;
float b;
float resultS;
double c;
double d;
double resultD;
};
TestFloat test;
// clang-format off
double inputfs_D[kTableLength] = {
5.3, -5.3, 5.3, -2.9
};
double inputft_D[kTableLength] = {
4.8, 4.8, -4.8, -0.29
};
float inputfs_S[kTableLength] = {
5.3, -5.3, 5.3, -2.9
};
float inputft_S[kTableLength] = {
4.8, 4.8, -4.8, -0.29
};
// clang-format on
__ Fld_s(f8, MemOperand(a0, offsetof(TestFloat, a)));
__ Fld_s(f9, MemOperand(a0, offsetof(TestFloat, b)));
__ Fld_d(f10, MemOperand(a0, offsetof(TestFloat, c)));
__ Fld_d(f11, MemOperand(a0, offsetof(TestFloat, d)));
__ fmul_s(f12, f8, f9);
__ fmul_d(f13, f10, f11);
__ Fst_s(f12, MemOperand(a0, offsetof(TestFloat, resultS)));
__ Fst_d(f13, MemOperand(a0, offsetof(TestFloat, resultD)));
__ jirl(zero_reg, ra, 0);
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::FOR_TESTING).Build();
auto f = GeneratedCode<F3>::FromCode(*code);
for (int i = 0; i < kTableLength; i++) {
test.a = inputfs_S[i];
test.b = inputft_S[i];
test.c = inputfs_D[i];
test.d = inputft_D[i];
f.Call(&test, 0, 0, 0, 0);
CHECK_EQ(test.resultS, inputfs_S[i] * inputft_S[i]);
CHECK_EQ(test.resultD, inputfs_D[i] * inputft_D[i]);
}
}
TEST(FDIV) {
CcTest::InitializeVM();
Isolate* isolate = CcTest::i_isolate();
HandleScope scope(isolate);
MacroAssembler assm(isolate, v8::internal::CodeObjectRequired::kYes);
struct Test {
double dOp1;
double dOp2;
double dRes;
float fOp1;
float fOp2;
float fRes;
};
Test test;
__ movfcsr2gr(a4);
__ movgr2fcsr(zero_reg);
__ Fld_d(f8, MemOperand(a0, offsetof(Test, dOp1)));
__ Fld_d(f9, MemOperand(a0, offsetof(Test, dOp2)));
__ Fld_s(f10, MemOperand(a0, offsetof(Test, fOp1)));
__ Fld_s(f11, MemOperand(a0, offsetof(Test, fOp2)));
__ fdiv_d(f12, f8, f9);
__ fdiv_s(f13, f10, f11);
__ Fst_d(f12, MemOperand(a0, offsetof(Test, dRes)));
__ Fst_s(f13, MemOperand(a0, offsetof(Test, fRes)));
__ movgr2fcsr(a4);
__ jirl(zero_reg, ra, 0);
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::FOR_TESTING).Build();
auto f = GeneratedCode<F3>::FromCode(*code);
f.Call(&test, 0, 0, 0, 0);
const int test_size = 3;
// clang-format off
double dOp1[test_size] = {
5.0, DBL_MAX, DBL_MAX};
double dOp2[test_size] = {
2.0, 2.0, -DBL_MAX};
double dRes[test_size] = {
2.5, DBL_MAX / 2.0, -1.0};
float fOp1[test_size] = {
5.0, FLT_MAX, FLT_MAX};
float fOp2[test_size] = {
2.0, 2.0, -FLT_MAX};
float fRes[test_size] = {
2.5, FLT_MAX / 2.0, -1.0};
// clang-format on
for (int i = 0; i < test_size; i++) {
test.dOp1 = dOp1[i];
test.dOp2 = dOp2[i];
test.fOp1 = fOp1[i];
test.fOp2 = fOp2[i];
f.Call(&test, 0, 0, 0, 0);
CHECK_EQ(test.dRes, dRes[i]);
CHECK_EQ(test.fRes, fRes[i]);
}
test.dOp1 = DBL_MAX;
test.dOp2 = -0.0;
test.fOp1 = FLT_MAX;
test.fOp2 = -0.0;
f.Call(&test, 0, 0, 0, 0);
CHECK(!std::isfinite(test.dRes));
CHECK(!std::isfinite(test.fRes));
test.dOp1 = 0.0;
test.dOp2 = -0.0;
test.fOp1 = 0.0;
test.fOp2 = -0.0;
f.Call(&test, 0, 0, 0, 0);
CHECK(std::isnan(test.dRes));
CHECK(std::isnan(test.fRes));
test.dOp1 = std::numeric_limits<double>::quiet_NaN();
test.dOp2 = -5.0;
test.fOp1 = std::numeric_limits<float>::quiet_NaN();
test.fOp2 = -5.0;
f.Call(&test, 0, 0, 0, 0);
CHECK(std::isnan(test.dRes));
CHECK(std::isnan(test.fRes));
}
TEST(FABS) {
CcTest::InitializeVM();
Isolate* isolate = CcTest::i_isolate();
HandleScope scope(isolate);
MacroAssembler assm(isolate, v8::internal::CodeObjectRequired::kYes);
struct TestFloat {
double a;
float b;
};
TestFloat test;
__ movfcsr2gr(a4);
__ movgr2fcsr(zero_reg);
__ Fld_d(f8, MemOperand(a0, offsetof(TestFloat, a)));
__ Fld_s(f9, MemOperand(a0, offsetof(TestFloat, b)));
__ fabs_d(f10, f8);
__ fabs_s(f11, f9);
__ Fst_d(f10, MemOperand(a0, offsetof(TestFloat, a)));
__ Fst_s(f11, MemOperand(a0, offsetof(TestFloat, b)));
__ movgr2fcsr(a4);
__ jirl(zero_reg, ra, 0);
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::FOR_TESTING).Build();
auto f = GeneratedCode<F3>::FromCode(*code);
test.a = -2.0;
test.b = -2.0;
f.Call(&test, 0, 0, 0, 0);
CHECK_EQ(test.a, 2.0);
CHECK_EQ(test.b, 2.0);
test.a = 2.0;
test.b = 2.0;
f.Call(&test, 0, 0, 0, 0);
CHECK_EQ(test.a, 2.0);
CHECK_EQ(test.b, 2.0);
// Testing biggest positive number
test.a = std::numeric_limits<double>::max();
test.b = std::numeric_limits<float>::max();
f.Call(&test, 0, 0, 0, 0);
CHECK_EQ(test.a, std::numeric_limits<double>::max());
CHECK_EQ(test.b, std::numeric_limits<float>::max());
// Testing smallest negative number
test.a = -std::numeric_limits<double>::max(); // lowest()
test.b = -std::numeric_limits<float>::max(); // lowest()
f.Call(&test, 0, 0, 0, 0);
CHECK_EQ(test.a, std::numeric_limits<double>::max());
CHECK_EQ(test.b, std::numeric_limits<float>::max());
// Testing smallest positive number
test.a = -std::numeric_limits<double>::min();
test.b = -std::numeric_limits<float>::min();
f.Call(&test, 0, 0, 0, 0);
CHECK_EQ(test.a, std::numeric_limits<double>::min());
CHECK_EQ(test.b, std::numeric_limits<float>::min());
// Testing infinity
test.a =
-std::numeric_limits<double>::max() / std::numeric_limits<double>::min();
test.b =
-std::numeric_limits<float>::max() / std::numeric_limits<float>::min();
f.Call(&test, 0, 0, 0, 0);
CHECK_EQ(test.a, std::numeric_limits<double>::max() /
std::numeric_limits<double>::min());
CHECK_EQ(test.b, std::numeric_limits<float>::max() /
std::numeric_limits<float>::min());
test.a = std::numeric_limits<double>::quiet_NaN();
test.b = std::numeric_limits<float>::quiet_NaN();
f.Call(&test, 0, 0, 0, 0);
CHECK(std::isnan(test.a));
CHECK(std::isnan(test.b));
test.a = std::numeric_limits<double>::signaling_NaN();
test.b = std::numeric_limits<float>::signaling_NaN();
f.Call(&test, 0, 0, 0, 0);
CHECK(std::isnan(test.a));
CHECK(std::isnan(test.b));
}
template <class T>
struct TestCaseMaddMsub {
T fj, fk, fa, fd_fmadd, fd_fmsub, fd_fnmadd, fd_fnmsub;
};
template <typename T, typename F>
void helper_fmadd_fmsub_fnmadd_fnmsub(F func) {
CcTest::InitializeVM();
Isolate* isolate = CcTest::i_isolate();
HandleScope scope(isolate);
MacroAssembler assm(isolate, v8::internal::CodeObjectRequired::kYes);
T x = std::sqrt(static_cast<T>(2.0));
T y = std::sqrt(static_cast<T>(3.0));
T z = std::sqrt(static_cast<T>(5.0));
T x2 = 11.11, y2 = 22.22, z2 = 33.33;
// clang-format off
TestCaseMaddMsub<T> test_cases[] = {
{x, y, z, 0.0, 0.0, 0.0, 0.0},
{x, y, -z, 0.0, 0.0, 0.0, 0.0},
{x, -y, z, 0.0, 0.0, 0.0, 0.0},
{x, -y, -z, 0.0, 0.0, 0.0, 0.0},
{-x, y, z, 0.0, 0.0, 0.0, 0.0},
{-x, y, -z, 0.0, 0.0, 0.0, 0.0},
{-x, -y, z, 0.0, 0.0, 0.0, 0.0},
{-x, -y, -z, 0.0, 0.0, 0.0, 0.0},
{-3.14, 0.2345, -123.000056, 0.0, 0.0, 0.0, 0.0},
{7.3, -23.257, -357.1357, 0.0, 0.0, 0.0, 0.0},
{x2, y2, z2, 0.0, 0.0, 0.0, 0.0},
{x2, y2, -z2, 0.0, 0.0, 0.0, 0.0},
{x2, -y2, z2, 0.0, 0.0, 0.0, 0.0},
{x2, -y2, -z2, 0.0, 0.0, 0.0, 0.0},
{-x2, y2, z2, 0.0, 0.0, 0.0, 0.0},
{-x2, y2, -z2, 0.0, 0.0, 0.0, 0.0},
{-x2, -y2, z2, 0.0, 0.0, 0.0, 0.0},
{-x2, -y2, -z2, 0.0, 0.0, 0.0, 0.0},
};
// clang-format on
if (std::is_same<T, float>::value) {
__ Fld_s(f8, MemOperand(a0, offsetof(TestCaseMaddMsub<T>, fj)));
__ Fld_s(f9, MemOperand(a0, offsetof(TestCaseMaddMsub<T>, fk)));
__ Fld_s(f10, MemOperand(a0, offsetof(TestCaseMaddMsub<T>, fa)));
} else if (std::is_same<T, double>::value) {
__ Fld_d(f8, MemOperand(a0, offsetof(TestCaseMaddMsub<T>, fj)));
__ Fld_d(f9, MemOperand(a0, offsetof(TestCaseMaddMsub<T>, fk)));
__ Fld_d(f10, MemOperand(a0, offsetof(TestCaseMaddMsub<T>, fa)));
} else {
UNREACHABLE();
}
func(assm);
__ jirl(zero_reg, ra, 0);
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::FOR_TESTING).Build();
auto f = GeneratedCode<F3>::FromCode(*code);
const size_t kTableLength = sizeof(test_cases) / sizeof(TestCaseMaddMsub<T>);
TestCaseMaddMsub<T> tc;
for (size_t i = 0; i < kTableLength; i++) {
tc.fj = test_cases[i].fj;
tc.fk = test_cases[i].fk;
tc.fa = test_cases[i].fa;
f.Call(&tc, 0, 0, 0, 0);
T res_fmadd;
T res_fmsub;
T res_fnmadd;
T res_fnmsub;
res_fmadd = std::fma(tc.fj, tc.fk, tc.fa);
res_fmsub = std::fma(tc.fj, tc.fk, -tc.fa);
res_fnmadd = -std::fma(tc.fj, tc.fk, tc.fa);
res_fnmsub = -std::fma(tc.fj, tc.fk, -tc.fa);
CHECK_EQ(tc.fd_fmadd, res_fmadd);
CHECK_EQ(tc.fd_fmsub, res_fmsub);
CHECK_EQ(tc.fd_fnmadd, res_fnmadd);
CHECK_EQ(tc.fd_fnmsub, res_fnmsub);
}
}
TEST(FMADD_FMSUB_FNMADD_FNMSUB_S) {
helper_fmadd_fmsub_fnmadd_fnmsub<float>([](MacroAssembler& assm) {
__ fmadd_s(f11, f8, f9, f10);
__ Fst_s(f11, MemOperand(a0, offsetof(TestCaseMaddMsub<float>, fd_fmadd)));
__ fmsub_s(f12, f8, f9, f10);
__ Fst_s(f12, MemOperand(a0, offsetof(TestCaseMaddMsub<float>, fd_fmsub)));
__ fnmadd_s(f13, f8, f9, f10);
__ Fst_s(f13, MemOperand(a0, offsetof(TestCaseMaddMsub<float>, fd_fnmadd)));
__ fnmsub_s(f14, f8, f9, f10);
__ Fst_s(f14, MemOperand(a0, offsetof(TestCaseMaddMsub<float>, fd_fnmsub)));
});
}
TEST(FMADD_FMSUB_FNMADD_FNMSUB_D) {
helper_fmadd_fmsub_fnmadd_fnmsub<double>([](MacroAssembler& assm) {
__ fmadd_d(f11, f8, f9, f10);
__ Fst_d(f11, MemOperand(a0, offsetof(TestCaseMaddMsub<double>, fd_fmadd)));
__ fmsub_d(f12, f8, f9, f10);
__ Fst_d(f12, MemOperand(a0, offsetof(TestCaseMaddMsub<double>, fd_fmsub)));
__ fnmadd_d(f13, f8, f9, f10);
__ Fst_d(f13,
MemOperand(a0, offsetof(TestCaseMaddMsub<double>, fd_fnmadd)));
__ fnmsub_d(f14, f8, f9, f10);
__ Fst_d(f14,
MemOperand(a0, offsetof(TestCaseMaddMsub<double>, fd_fnmsub)));
});
}
/*
TEST(FSQRT_FRSQRT_FRECIP) {
const int kTableLength = 4;
const double deltaDouble = 2E-15;
const float deltaFloat = 2E-7;
const float sqrt2_s = sqrt(2);
const double sqrt2_d = sqrt(2);
CcTest::InitializeVM();
Isolate* isolate = CcTest::i_isolate();
HandleScope scope(isolate);
MacroAssembler assm(isolate, v8::internal::CodeObjectRequired::kYes);
struct TestFloat {
float a;
float resultS1;
float resultS2;
float resultS3;
double b;
double resultD1;
double resultD2;
double resultD3;
};
TestFloat test;
// clang-format off
double inputs_D[kTableLength] = {
0.0L, 4.0L, 2.0L, 4e-28L
};
double outputs_D[kTableLength] = {
0.0L, 2.0L, sqrt2_d, 2e-14L
};
float inputs_S[kTableLength] = {
0.0, 4.0, 2.0, 4e-28
};
float outputs_S[kTableLength] = {
0.0, 2.0, sqrt2_s, 2e-14
};
// clang-format on
__ Fld_s(f8, MemOperand(a0, offsetof(TestFloat, a)));
__ Fld_d(f9, MemOperand(a0, offsetof(TestFloat, b)));
__ fsqrt_s(f10, f8);
__ fsqrt_d(f11, f9);
__ frsqrt_s(f12, f8);
__ frsqrt_d(f13, f9);
__ frecip_s(f14, f8);
__ frecip_d(f15, f9);
__ Fst_s(f10, MemOperand(a0, offsetof(TestFloat, resultS1)));
__ Fst_d(f11, MemOperand(a0, offsetof(TestFloat, resultD1)));
__ Fst_s(f12, MemOperand(a0, offsetof(TestFloat, resultS2)));
__ Fst_d(f13, MemOperand(a0, offsetof(TestFloat, resultD2)));
__ Fst_s(f14, MemOperand(a0, offsetof(TestFloat, resultS3)));
__ Fst_d(f15, MemOperand(a0, offsetof(TestFloat, resultD3)));
__ jirl(zero_reg, ra, 0);
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code = Factory::CodeBuilder(isolate, desc,
CodeKind::STUB).Build(); auto f = GeneratedCode<F3>::FromCode(*code);
for (int i = 0; i < kTableLength; i++) {
float f1;
double d1;
test.a = inputs_S[i];
test.b = inputs_D[i];
f.Call(&test, 0, 0, 0, 0);
CHECK_EQ(test.resultS1, outputs_S[i]);
CHECK_EQ(test.resultD1, outputs_D[i]);
if (i != 0) {
f1 = test.resultS2 - 1.0F/outputs_S[i];
f1 = (f1 < 0) ? f1 : -f1;
CHECK(f1 <= deltaFloat);
d1 = test.resultD2 - 1.0L/outputs_D[i];
d1 = (d1 < 0) ? d1 : -d1;
CHECK(d1 <= deltaDouble);
f1 = test.resultS3 - 1.0F/inputs_S[i];
f1 = (f1 < 0) ? f1 : -f1;
CHECK(f1 <= deltaFloat);
d1 = test.resultD3 - 1.0L/inputs_D[i];
d1 = (d1 < 0) ? d1 : -d1;
CHECK(d1 <= deltaDouble);
} else {
CHECK_EQ(test.resultS2, 1.0F/outputs_S[i]);
CHECK_EQ(test.resultD2, 1.0L/outputs_D[i]);
CHECK_EQ(test.resultS3, 1.0F/inputs_S[i]);
CHECK_EQ(test.resultD3, 1.0L/inputs_D[i]);
}
}
}*/
TEST(LA15) {
// Test chaining of label usages within instructions (issue 1644).
CcTest::InitializeVM();
Isolate* isolate = CcTest::i_isolate();
HandleScope scope(isolate);
Assembler assm(AssemblerOptions{});
Label target;
__ beq(a0, a1, &target);
__ nop();
__ bne(a0, a1, &target);
__ nop();
__ bind(&target);
__ nop();
__ jirl(zero_reg, ra, 0);
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::FOR_TESTING).Build();
auto f = GeneratedCode<F2>::FromCode(*code);
f.Call(1, 1, 0, 0, 0);
}
TEST(Trampoline) {
static const int kMaxBranchOffset = (1 << (18 - 1)) - 1;
CcTest::InitializeVM();
Isolate* isolate = CcTest::i_isolate();
HandleScope scope(isolate);
MacroAssembler assm(isolate, v8::internal::CodeObjectRequired::kYes);
Label done;
size_t nr_calls = kMaxBranchOffset / kInstrSize + 5;
__ xor_(a2, a2, a2);
__ BranchShort(&done, eq, a0, Operand(a1));
for (size_t i = 0; i < nr_calls; ++i) {
__ addi_d(a2, a2, 1);
}
__ bind(&done);
__ or_(a0, a2, zero_reg);
__ jirl(zero_reg, ra, 0);
CodeDesc desc;
assm.GetCode(isolate, &desc);
Handle<Code> code =
Factory::CodeBuilder(isolate, desc, CodeKind::FOR_TESTING).Build();
auto f = GeneratedCode<F2>::FromCode(*code);
int64_t res = reinterpret_cast<int64_t>(f.Call(42, 42, 0, 0, 0));
CHECK_EQ(0, res);
}
#undef __
} // namespace internal
} // namespace v8
Reference in New Issue View Git Blame Copy Permalink