| /* |
| * Copyright (C) 2014 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| #include "gtest/gtest.h" |
| |
| #include <sys/mman.h> |
| |
| #include <cstring> |
| #include <iterator> |
| #include <string> |
| |
| #include "berberis/assembler/machine_code.h" |
| #include "berberis/assembler/rv32e.h" |
| #include "berberis/assembler/rv32i.h" |
| #include "berberis/assembler/rv64i.h" |
| #include "berberis/assembler/x86_32.h" |
| #include "berberis/assembler/x86_64.h" |
| #include "berberis/base/bit_util.h" |
| #include "berberis/base/logging.h" |
| #include "berberis/test_utils/scoped_exec_region.h" |
| |
| #if defined(__i386__) |
| using CodeEmitter = berberis::x86_32::Assembler; |
| #elif defined(__amd64__) |
| using CodeEmitter = berberis::x86_64::Assembler; |
| #elif defined(__riscv) |
| using CodeEmitter = berberis::rv64::Assembler; |
| #else |
| #error "Unsupported platform" |
| #endif |
| |
| namespace berberis { |
| |
| enum class CPUArch { |
| kX86_64, |
| kRiscv64, |
| }; |
| |
| int Callee() { |
| return 239; |
| } |
| |
| float FloatFunc(float f1, float f2) { |
| return f1 - f2; |
| } |
| |
| inline bool IsInstructionEqual(std::string code_str1, |
| std::string code_str2, |
| uint32_t insn, |
| uint32_t insn_size) { |
| return code_str1.compare( |
| insn * (insn_size + 1), insn_size, code_str2, insn * (insn_size + 1), insn_size) == 0; |
| } |
| |
| template <typename ParcelInt> |
| inline bool CompareCode(const ParcelInt* code_template_begin, |
| const ParcelInt* code_template_end, |
| const MachineCode& code, |
| CPUArch arch) { |
| if ((code_template_end - code_template_begin) * sizeof(ParcelInt) != code.install_size()) { |
| ALOGE("Code size mismatch: %zd != %u", |
| (code_template_end - code_template_begin) * static_cast<unsigned>(sizeof(ParcelInt)), |
| code.install_size()); |
| return false; |
| } |
| |
| if (memcmp(code_template_begin, code.AddrAs<uint8_t>(0), code.install_size()) != 0) { |
| ALOGE("Code mismatch"); |
| MachineCode code2; |
| code2.AddSequence(code_template_begin, code_template_end - code_template_begin); |
| std::string code_str1, code_str2; |
| uint32_t insn_size = 0; |
| switch (arch) { |
| case CPUArch::kRiscv64: |
| insn_size = 8; |
| code.AsString(&code_str1, InstructionSize::FourBytes); |
| code2.AsString(&code_str2, InstructionSize::FourBytes); |
| break; |
| case CPUArch::kX86_64: |
| insn_size = 2; |
| code.AsString(&code_str1, InstructionSize::OneByte); |
| code2.AsString(&code_str2, InstructionSize::OneByte); |
| break; |
| } |
| CHECK_EQ(code_str1.size() % (insn_size + 1), 0); |
| CHECK_EQ(code_str2.size() % (insn_size + 1), 0); |
| uint32_t number_of_instructions = code_str1.size() / (insn_size + 1); |
| // Skip identical part. |
| uint32_t insn = 0; |
| while (insn < number_of_instructions && |
| IsInstructionEqual(code_str1, code_str2, insn, insn_size)) { |
| insn++; |
| } |
| for (uint32_t i = insn; i < insn + 20 && i < number_of_instructions; i++) { |
| ALOGE("Assembler generated: %s, should be %s\n", |
| code_str1.substr(i * (insn_size + 1), insn_size).c_str(), |
| code_str2.substr(i * (insn_size + 1), insn_size).c_str()); |
| } |
| |
| return false; |
| } |
| return true; |
| } |
| |
| namespace rv32 { |
| |
| bool AssemblerTest() { |
| MachineCode code; |
| Assembler assembler(&code); |
| Assembler::Label data_begin, data_end, label; |
| assembler.Bind(&data_begin); |
| // We test loads and stores twice to ensure that both positive and negative immediates are |
| // present both in auipc and in the follow-up load/store instructions. |
| assembler.Fld(Assembler::f1, data_end, Assembler::x2); |
| assembler.Flw(Assembler::f3, data_end, Assembler::x4); |
| assembler.Fsd(Assembler::f5, data_end, Assembler::x6); |
| assembler.Fsw(Assembler::f7, data_end, Assembler::x8); |
| assembler.Lb(Assembler::x9, data_end); |
| assembler.Lbu(Assembler::x10, data_end); |
| assembler.Lh(Assembler::x11, data_end); |
| assembler.Lhu(Assembler::x12, data_end); |
| assembler.Lw(Assembler::x13, data_end); |
| assembler.Sb(Assembler::x14, data_end, Assembler::x15); |
| assembler.Sh(Assembler::x16, data_end, Assembler::x17); |
| assembler.Sw(Assembler::x18, data_end, Assembler::x19); |
| assembler.La(Assembler::x20, data_end); |
| assembler.Bcc(Assembler::Condition::kEqual, Assembler::x1, Assembler::x2, label); |
| assembler.Bcc(Assembler::Condition::kNotEqual, Assembler::x3, Assembler::x4, label); |
| assembler.Bcc(Assembler::Condition::kLess, Assembler::x5, Assembler::x6, label); |
| assembler.Bcc(Assembler::Condition::kGreaterEqual, Assembler::x7, Assembler::x8, label); |
| assembler.Bcc(Assembler::Condition::kBelow, Assembler::x9, Assembler::x10, label); |
| assembler.Bcc(Assembler::Condition::kAboveEqual, Assembler::x11, Assembler::x12, label); |
| assembler.Jal(Assembler::x1, label); |
| assembler.Add(Assembler::x1, Assembler::x2, Assembler::x3); |
| assembler.Addi(Assembler::x1, Assembler::x2, 42); |
| assembler.Bind(&label); |
| // Jalr have two alternate forms. |
| assembler.Jalr(Assembler::x1, Assembler::x2, 42); |
| assembler.Jalr(Assembler::x3, {.base = Assembler::x4, .disp = 42}); |
| assembler.Sw(Assembler::x1, {.base = Assembler::x2, .disp = 42}); |
| assembler.Jal(Assembler::x2, label); |
| assembler.Beq(Assembler::x1, Assembler::x2, label); |
| assembler.Bne(Assembler::x3, Assembler::x4, label); |
| assembler.Blt(Assembler::x5, Assembler::x6, label); |
| assembler.Bge(Assembler::x7, Assembler::x8, label); |
| assembler.Bltu(Assembler::x9, Assembler::x10, label); |
| assembler.Bgeu(Assembler::x11, Assembler::x12, label); |
| assembler.Csrrc(Assembler::x1, Assembler::Csr::kVl, Assembler::x2); |
| assembler.Csrrs(Assembler::x3, Assembler::Csr::kVtype, Assembler::x4); |
| assembler.Csrrw(Assembler::x5, Assembler::Csr::kVlenb, Assembler::x6); |
| assembler.Slli(Assembler::x1, Assembler::x2, 3); |
| assembler.Srai(Assembler::x4, Assembler::x5, 6); |
| assembler.Srli(Assembler::x7, Assembler::x8, 9); |
| assembler.FcvtSW(Assembler::f1, Assembler::x2, Assembler::Rounding::kRmm); |
| assembler.FcvtSWu(Assembler::f3, Assembler::x4); |
| assembler.FcvtWS(Assembler::x1, Assembler::f2, Assembler::Rounding::kRmm); |
| assembler.FcvtWuS(Assembler::x3, Assembler::f4); |
| assembler.FsqrtS(Assembler::f1, Assembler::f2, Assembler::Rounding::kRmm); |
| assembler.FsqrtD(Assembler::f3, Assembler::f4); |
| assembler.PrefetchI({.base = Assembler::x1, .disp = 32}); |
| assembler.PrefetchR({.base = Assembler::x2, .disp = 64}); |
| assembler.PrefetchW({.base = Assembler::x3, .disp = 96}); |
| assembler.Li(Assembler::x15, static_cast<int32_t>(0xaf)); |
| assembler.Seqz(Assembler::x20, Assembler::x10); |
| assembler.Snez(Assembler::x2, Assembler::x9); |
| assembler.Sltz(Assembler::x30, Assembler::x1); |
| assembler.Sgtz(Assembler::x25, Assembler::x16); |
| assembler.J(0x42); |
| assembler.Jal(-0x26); |
| assembler.Jr(Assembler::x19); |
| assembler.Jalr(Assembler::x7); |
| // Move target position for more than 2048 bytes down to ensure auipc would use non-zero |
| // immediate. |
| for (size_t index = 138; index < 1200; ++index) { |
| assembler.TwoByte(uint16_t{0}); |
| } |
| assembler.Fld(Assembler::f1, data_begin, Assembler::x2); |
| assembler.Flw(Assembler::f3, data_begin, Assembler::x4); |
| assembler.Fsd(Assembler::f5, data_begin, Assembler::x6); |
| assembler.Fsw(Assembler::f7, data_begin, Assembler::x8); |
| assembler.Lb(Assembler::x9, data_begin); |
| assembler.Lbu(Assembler::x10, data_begin); |
| assembler.Lh(Assembler::x11, data_begin); |
| assembler.Lhu(Assembler::x12, data_begin); |
| assembler.Lw(Assembler::x13, data_begin); |
| assembler.Sb(Assembler::x14, data_begin, Assembler::x15); |
| assembler.Sh(Assembler::x16, data_begin, Assembler::x17); |
| assembler.Sw(Assembler::x18, data_begin, Assembler::x19); |
| assembler.La(Assembler::x20, data_begin); |
| assembler.Bind(&data_end); |
| assembler.Bexti(Assembler::x16, Assembler::x1, 20); |
| assembler.Rori(Assembler::x5, Assembler::x3, 5); |
| assembler.Finalize(); |
| |
| // clang-format off |
| static const uint16_t kCodeTemplate[] = { |
| 0x1117, 0x0000, // begin: auipc x2, 4096 |
| 0x3087, 0x9c81, // fld f1, -1592(x2) |
| 0x1217, 0x0000, // auipc x4, 4096 |
| 0x2187, 0x9c02, // flw f3, -1600(x4) |
| 0x1317, 0x0000, // auipc x6, 4096 |
| 0x3c27, 0x9a53, // fsd f5, -1608(x6) |
| 0x1417, 0x0000, // auipc x8, 4096 |
| 0x2827, 0x9a74, // fsw f7, -1616(x8) |
| 0x1497, 0x0000, // auipc x9, 4096 |
| 0x8483, 0x9a84, // lb x9, -1624(x9) |
| 0x1517, 0x0000, // auipc x10, 4096 |
| 0x4503, 0x9a05, // lbu x10, -1632(x10) |
| 0x1597, 0x0000, // auipc x11, 4096 |
| 0x9583, 0x9985, // lh x11, -1640(x11) |
| 0x1617, 0x0000, // auipc x12, 4096 |
| 0x5603, 0x9906, // lhu x12, -1648(x12) |
| 0x1697, 0x0000, // auipc x13, 4096 |
| 0xa683, 0x9886, // lw x13, -1656(x13) |
| 0x1797, 0x0000, // auipc x15, 4096 |
| 0x8023, 0x98e7, // sb x14, -1664(x15) |
| 0x1897, 0x0000, // auipc x17, 4096 |
| 0x9c23, 0x9708, // sh x16, -1672(x17) |
| 0x1997, 0x0000, // auipc x19, 4096 |
| 0xa823, 0x9729, // sw x18, -1680(x19) |
| 0x1a17, 0x0000, // auipc x20, 4096 |
| 0x0a13, 0x968a, // addi x20, x20, -1688 |
| 0x8263, 0x0220, // beq x1, x2, label |
| 0x9063, 0x0241, // bne x3, x4, label |
| 0xce63, 0x0062, // blt x5, x6, label |
| 0xdc63, 0x0083, // bge x7, x8, label |
| 0xea63, 0x00a4, // bltu x9, x10, label |
| 0xf863, 0x00c5, // bgeu x11, x12, label |
| 0x00ef, 0x00c0, // jal x1, label |
| 0x00b3, 0x0031, // add x1, x2, x3 |
| 0x0093, 0x02a1, // addi x1, x2, 42 |
| 0x00e7, 0x02a1, // label: jalr x1, x2, 42 |
| 0x01e7, 0x02a2, // jalr x3, 42(x4) |
| 0x2523, 0x0211, // sw x1, 42(x2) |
| 0xf16f, 0xff5f, // jal x2, label |
| 0x88e3, 0xfe20, // beq x1, x2, label |
| 0x96e3, 0xfe41, // bne x3, x4, label |
| 0xc4e3, 0xfe62, // blt x5, x6, label |
| 0xd2e3, 0xfe83, // bge x7, x8, label |
| 0xe0e3, 0xfea4, // bltu x9, x10, label |
| 0xfee3, 0xfcc5, // bgeu x11, x12, label |
| 0x30f3, 0xc201, // csrrc x1, vl, x2 |
| 0x21f3, 0xc212, // csrrs x3, vtype, x4 |
| 0x12f3, 0xc223, // csrrw x5, vlenb, x6 |
| 0x1093, 0x0031, // slli x1, x2, 3 |
| 0xd213, 0x4062, // srai x4, x5, 6 |
| 0x5393, 0x0094, // srli x7, x8, 9 |
| 0x40d3, 0xd001, // fcvt.s.w f1, x2, rmm |
| 0x71d3, 0xd012, // fcvt.s.wu f3, x4 |
| 0x40d3, 0xc001, // fcvt.w.s x1, f2, rmm |
| 0x71d3, 0xc012, // fcvt.wu.s x3, f4 |
| 0x40d3, 0x5801, // fsqrt.s f1, f2, rmm |
| 0x71d3, 0x5a02, // fsqrt.d f3, f4 |
| 0xe013, 0x0200, // prefetch.i 32(x1) |
| 0x6013, 0x0411, // prefetch.r 64(x2) |
| 0xe013, 0x0631, // prefetch.w 96(x3) |
| 0x0793, 0x0af0, // addi x15, x15, 0xaf |
| 0x3a13, 0x0015, // sltiu x20, x10, 1 |
| 0x3133, 0x0090, // sltu x2, x0, x9 |
| 0xaf33, 0x0000, // slt x30, x1, x0 |
| 0x2cb3, 0x0100, // slt x25, x0, x16 |
| 0x006f, 0x0420, // jal zero, 0x42 |
| 0xf0ef, 0xfdbf, // jal x1, -0x26 |
| 0x8067, 0x0009, // jalr zero, x19, 0 |
| 0x80e7, 0x0003, // jalr x1, x7, 0 |
| [ 138 ... 1199 ] = 0,// padding |
| 0xf117, 0xffff, // auipc x2, -4096 |
| 0x3087, 0x6a01, // fld f1,1696(x2) |
| 0xf217, 0xffff, // auipc x4, -4096 |
| 0x2187, 0x6982, // flw f3,1688(x4) |
| 0xf317, 0xffff, // auipc x6, -4096 |
| 0x3827, 0x6853, // fsd f5,1680(x6) |
| 0xf417, 0xffff, // auipc x8, -4096 |
| 0x2427, 0x6874, // fsw f7,1672(x8) |
| 0xf497, 0xffff, // auipc x9, -4096 |
| 0x8483, 0x6804, // lb x9,1664(x9) |
| 0xf517, 0xffff, // auipc x10, -4096 |
| 0x4503, 0x6785, // lbu x10,1656(x10) |
| 0xf597, 0xffff, // auipc x11, -4096 |
| 0x9583, 0x6705, // lh x11,1648(x11) |
| 0xf617, 0xffff, // auipc x12, -4096 |
| 0x5603, 0x6686, // lhu x12,1640(x12) |
| 0xf697, 0xffff, // auipc x13, -4096 |
| 0xa683, 0x6606, // lw x13,1632(x13) |
| 0xf797, 0xffff, // auipc x15, -4096 |
| 0x8c23, 0x64e7, // sb x14,1624(x15) |
| 0xf897, 0xffff, // auipc x17, -4096 |
| 0x9823, 0x6508, // sh x16,1616(x17) |
| 0xf997, 0xffff, // auipc x19, -4096 |
| 0xa423, 0x6529, // sw x18,1608(x19) |
| 0xfa17, 0xffff, // auipc x20, -4096 |
| 0x0a13, 0x640a, // addi x20,x20,1600 |
| 0xd813, 0x4940, // bexti x16,x1,20 |
| 0xd293, 0x6051, // rori x5, x3, 5 |
| }; // end: |
| // clang-format on |
| |
| return CompareCode(std::begin(kCodeTemplate), std::end(kCodeTemplate), code, CPUArch::kRiscv64); |
| } |
| |
| } // namespace rv32 |
| |
| namespace rv64 { |
| |
| bool AssemblerTest() { |
| MachineCode code; |
| Assembler assembler(&code); |
| Assembler::Label data_begin, data_end; |
| assembler.Bind(&data_begin); |
| // We test loads and stores twice to ensure that both positive and negative immediates are |
| // present both in auipc and in the follow-up load/store instructions. |
| assembler.Ld(Assembler::x1, data_end); |
| assembler.Lwu(Assembler::x2, data_end); |
| assembler.Sd(Assembler::x3, data_end, Assembler::x4); |
| assembler.Bcc(Assembler::Condition::kAlways, Assembler::x1, Assembler::x2, 48); |
| assembler.Bcc(Assembler::Condition::kEqual, Assembler::x3, Assembler::x4, 44); |
| assembler.Bcc(Assembler::Condition::kNotEqual, Assembler::x5, Assembler::x6, 40); |
| assembler.Bcc(Assembler::Condition::kLess, Assembler::x7, Assembler::x8, 36); |
| assembler.Bcc(Assembler::Condition::kGreaterEqual, Assembler::x9, Assembler::x10, 32); |
| assembler.Bcc(Assembler::Condition::kBelow, Assembler::x11, Assembler::x12, 28); |
| assembler.Bcc(Assembler::Condition::kAboveEqual, Assembler::x13, Assembler::x14, 24); |
| assembler.Jal(Assembler::x1, 20); |
| assembler.Add(Assembler::x1, Assembler::x2, Assembler::x3); |
| assembler.Addw(Assembler::x1, Assembler::x2, Assembler::x3); |
| assembler.Addi(Assembler::x1, Assembler::x2, 42); |
| assembler.Addiw(Assembler::x1, Assembler::x2, 42); |
| // Jalr have two alternate forms. |
| assembler.Jalr(Assembler::x1, Assembler::x2, 42); |
| assembler.Jalr(Assembler::x3, {.base = Assembler::x4, .disp = 42}); |
| assembler.Sw(Assembler::x1, {.base = Assembler::x2, .disp = 42}); |
| assembler.Sd(Assembler::x3, {.base = Assembler::x4, .disp = 42}); |
| assembler.Jal(Assembler::x2, -16); |
| assembler.Beq(Assembler::x1, Assembler::x2, -20); |
| assembler.Bne(Assembler::x3, Assembler::x4, -24); |
| assembler.Blt(Assembler::x5, Assembler::x6, -28); |
| assembler.Bge(Assembler::x7, Assembler::x8, -32); |
| assembler.Bltu(Assembler::x9, Assembler::x10, -36); |
| assembler.Bgeu(Assembler::x11, Assembler::x12, -40); |
| assembler.Bcc(Assembler::Condition::kAlways, Assembler::x13, Assembler::x14, -44); |
| assembler.Csrrc(Assembler::x1, Assembler::Csr::kVl, 2); |
| assembler.Csrrs(Assembler::x3, Assembler::Csr::kVtype, 4); |
| assembler.Csrrw(Assembler::x5, Assembler::Csr::kVlenb, 6); |
| assembler.Csrrci(Assembler::x7, Assembler::Csr::kVl, 8); |
| assembler.Csrrsi(Assembler::x9, Assembler::Csr::kVtype, 10); |
| assembler.Csrrwi(Assembler::x11, Assembler::Csr::kVlenb, 12); |
| assembler.Slliw(Assembler::x1, Assembler::x2, 3); |
| assembler.Sraiw(Assembler::x4, Assembler::x5, 6); |
| assembler.Srliw(Assembler::x7, Assembler::x8, 9); |
| assembler.FcvtDL(Assembler::f1, Assembler::x2, Assembler::Rounding::kRmm); |
| assembler.FcvtDLu(Assembler::f3, Assembler::x4); |
| assembler.FcvtLD(Assembler::x1, Assembler::f2, Assembler::Rounding::kRmm); |
| assembler.FcvtLuD(Assembler::x3, Assembler::f4); |
| assembler.FsqrtS(Assembler::f1, Assembler::f2, Assembler::Rounding::kRmm); |
| assembler.FsqrtD(Assembler::f3, Assembler::f4); |
| assembler.PrefetchI({.base = Assembler::x1, .disp = 32}); |
| assembler.PrefetchR({.base = Assembler::x2, .disp = 64}); |
| assembler.PrefetchW({.base = Assembler::x3, .disp = 96}); |
| assembler.Li(Assembler::x10, static_cast<int64_t>(0xaaaa'0aa0'aaa0'0aaa)); |
| assembler.Ret(); |
| assembler.Call(data_end); |
| assembler.Tail(data_end); |
| assembler.Bgt(Assembler::x4, Assembler::x0, data_end); |
| assembler.Bgtu(Assembler::x2, Assembler::x20, data_end); |
| assembler.Ble(Assembler::x1, Assembler::x30, data_end); |
| assembler.Bleu(Assembler::x8, Assembler::x16, data_end); |
| assembler.Beqz(Assembler::x5, data_end); |
| assembler.Bnez(Assembler::x4, data_end); |
| assembler.Blez(Assembler::x2, data_end); |
| assembler.Bgez(Assembler::x3, data_end); |
| assembler.Bltz(Assembler::x9, data_end); |
| assembler.Bgtz(Assembler::x12, data_end); |
| // Move target position for more than 2048 bytes down to ensure auipc would use non-zero |
| // immediate. |
| for (size_t index = 142; index < 1200; ++index) { |
| assembler.TwoByte(uint16_t{0}); |
| } |
| assembler.Ld(Assembler::x1, data_begin); |
| assembler.Lwu(Assembler::x2, data_begin); |
| assembler.Sd(Assembler::x3, data_begin, Assembler::x4); |
| assembler.Bind(&data_end); |
| assembler.SextW(Assembler::x15, Assembler::x12); |
| assembler.AddUW(Assembler::x14, Assembler::x22, Assembler::x29); |
| assembler.ZextW(Assembler::x13, Assembler::x21); |
| assembler.Sh3add(Assembler::x13, Assembler::x9, Assembler::x10); |
| assembler.Bexti(Assembler::x16, Assembler::x1, 53); |
| assembler.Rori(Assembler::x22, Assembler::x30, 43); |
| assembler.Roriw(Assembler::x29, Assembler::x2, 30); |
| assembler.Ror(Assembler::x14, Assembler::x1, Assembler::x10); |
| assembler.Rorw(Assembler::x25, Assembler::x5, Assembler::x4); |
| assembler.Not(Assembler::x10, Assembler::x4); |
| assembler.Neg(Assembler::x11, Assembler::x3); |
| assembler.Negw(Assembler::x12, Assembler::x2); |
| assembler.SextB(Assembler::x22, Assembler::x7); |
| assembler.SextH(Assembler::x23, Assembler::x8); |
| assembler.Finalize(); |
| |
| // clang-format off |
| static const uint16_t kCodeTemplate[] = { |
| 0x1097, 0x0000, // begin: auipc x1, 4096 |
| 0xb083, 0x9780, // ld, x1, -1672(x1) |
| 0x1117, 0x0000, // auipc x2, 4096 |
| 0x6103, 0x9701, // lwu x2,-1680(x2) |
| 0x1217, 0x0000, // auipc x4, 4096 |
| 0x3423, 0x9632, // sd x3,-1688(x4) |
| 0x006f, 0x0300, // jal x0, label |
| 0x8663, 0x0241, // beq x1, x2, label |
| 0x9463, 0x0262, // bne x3, x4, label |
| 0xc263, 0x0283, // blt x5, x6, label |
| 0xd063, 0x02a4, // bge x7, x8, label |
| 0xee63, 0x00c5, // bltu x9, x10, label |
| 0xfc63, 0x00e6, // bgeu x11, x12, label |
| 0x00ef, 0x0140, // jal x1, label |
| 0x00b3, 0x0031, // add x1, x2, x3 |
| 0x00bb, 0x0031, // addw x1, x2, x3 |
| 0x0093, 0x02a1, // addi x1, x2, 42 |
| 0x009b, 0x02a1, // addiw x1, x2, 42 |
| 0x00e7, 0x02a1, // label: jalr x1, x2, 42 |
| 0x01e7, 0x02a2, // jalr x3, 42(x4) |
| 0x2523, 0x0211, // sw x1, 42(x2) |
| 0x3523, 0x0232, // sd x3, 42(x4) |
| 0xf16f, 0xff1f, // jal x2, label |
| 0x86e3, 0xfe20, // beq x1, x2, label |
| 0x94e3, 0xfe41, // bne x3, x4, label |
| 0xc2e3, 0xfe62, // blt x5, x6, label |
| 0xd0e3, 0xfe83, // bge x7, x8, label |
| 0xeee3, 0xfca4, // bltu x9, x10, label |
| 0xfce3, 0xfcc5, // bgeu x11, x12, label |
| 0xf06f, 0xfd5f, // jal x0, label |
| 0x70f3, 0xc201, // csrrc x1, vl, 2 |
| 0x61f3, 0xc212, // csrrs x3, vtype, 4 |
| 0x52f3, 0xc223, // csrrw x5, vlenb, 6 |
| 0x73f3, 0xc204, // csrrci x7, vl, 8 |
| 0x64f3, 0xc215, // csrrsi x9, vtype, 10 |
| 0x55f3, 0xc226, // csrrwi x11, vlenb, 12 |
| 0x109b, 0x0031, // slliw x1, x2, 3 |
| 0xd21b, 0x4062, // sraiw x4, x5, 6 |
| 0x539b, 0x0094, // srliw x7, x8, 9 |
| 0x40d3, 0xd221, // fcvt.d.l f1, x2, rmm |
| 0x71d3, 0xd232, // fcvt.d.lu f3, x4 |
| 0x40d3, 0xc221, // fcvt.l.d x1, f2, rmm |
| 0x71d3, 0xc232, // fcvt.lu.d x3, f4 |
| 0x40d3, 0x5801, // fsqrt.s f1, f2, rmm |
| 0x71d3, 0x5a02, // fsqrt.d f3, f4 |
| 0xe013, 0x0200, // prefetch.i 32(x1) |
| 0x6013, 0x0411, // prefetch.r 64(x2) |
| 0xe013, 0x0631, // prefetch.w 96(x3) |
| 0x5537,0xfd55, // lui a0, 0xfd555 |
| 0x0513, 0x0555, // addi a0, a0, 85 |
| 0x1513, 0x00d5, // slli a0, a0, 0xd |
| 0x0513, 0x0ab5, // addi a0, a0, 171 |
| 0x1513, 0x00c5, // slli a0, a0, 0xc |
| 0x0513, 0xa015, // addi a0, a0, -1535 |
| 0x1513, 0x00c5, // slli a0, a0, 0xc |
| 0x0513, 0xaaa5, // addi a0,a0,-1366 |
| 0x8067, 0x0000, // ret |
| 0x1317, 0x0000, // auipc x6, 0x1 |
| 0x00e7, 0x8943, // jalr x1, x6, -1900 |
| 0x1317, 0x0000, // auipc x6, 0x1 |
| 0x0067, 0x88c3, // jalr x0, x6, -1908 |
| 0x42e3, 0x0840, // blt x0, x4, 0x884 |
| 0x60e3, 0x082a, // bltu x20, x2, 0x880 |
| 0x5ee3, 0x061f, // bge x30, x1, 0x87c |
| 0x7ce3, 0x0688, // bgeu x16, x8, 0x878 |
| 0x8ae3, 0x0602, // beq x5, 0x874 |
| 0x18e3, 0x0602, // bne x4, 0x870 |
| 0x56e3, 0x0620, // ble x2, 0x86c |
| 0xd4e3, 0x0601, // bge x3, 0x868 |
| 0xc2e3, 0x0604, // blt x9, 0x864 |
| 0x40e3, 0x06c0, // bgt x12, 0x860 |
| [ 142 ... 1199 ] = 0,// padding |
| 0xf097, 0xffff, // auipc x1, -4096 |
| 0xb083, 0x6a00, // ld x1, 1696(x1) |
| 0xf117, 0xffff, // auipc x2, -4096 |
| 0x6103, 0x6981, // lwu x2, 1688(x2) |
| 0xf217, 0xffff, // auipc x4, -4096 |
| 0x3823, 0x6832, // sd x3, 1680(x4) |
| 0x079b, 0x0006, // addi.w x15, x12, 0 |
| 0x073b, 0x09db, // add.uw x14, x22, x29 |
| 0x86bb, 0x080a, // add.uw x13, x21, zero |
| 0xe6b3, 0x20a4, // sh3add x13, x9, x10 |
| 0xd813, 0x4b50, // bexti x16, x1, 53 |
| 0x5b13, 0x62bf, // rori x22, x30, 43 |
| 0x5e9b, 0x61e1, // roriw x29, x2, 30 |
| 0xd733, 0x60a0, // ror x14, x1, x10 |
| 0xdcbb, 0x6042, // rorw x25, x5, x4 |
| 0x4513, 0xfff2, // xori x10, x4, -1 |
| 0x05b3, 0x4030, // sub x11, zero, x3 |
| 0x063b, 0x4020, // subw x12, zero, x2 |
| 0x9b13, 0x6043, // sext.b x22, x7 |
| 0x1b93, 0x6054, // sext.h x23, x8 |
| }; // end: |
| // clang-format on |
| |
| return CompareCode(std::begin(kCodeTemplate), std::end(kCodeTemplate), code, CPUArch::kRiscv64); |
| } |
| |
| } // namespace rv64 |
| |
| namespace x86_32 { |
| |
| bool AssemblerTest() { |
| MachineCode code; |
| Assembler assembler(&code); |
| assembler.Movl(Assembler::eax, {.base = Assembler::esp, .disp = 4}); |
| assembler.CmpXchgl({.base = Assembler::esp, .disp = 4}, Assembler::eax); |
| assembler.Subl(Assembler::esp, 16); |
| assembler.Movl({.base = Assembler::esp}, Assembler::eax); |
| assembler.Push(Assembler::esp); |
| assembler.Push(0xcccccccc); |
| assembler.Pushl({.base = Assembler::esp, .disp = 0x428}); |
| assembler.Popl({.base = Assembler::esp, .disp = 0x428}); |
| assembler.Movl(Assembler::ecx, 0xcccccccc); |
| assembler.Call(Assembler::ecx); |
| assembler.Movl(Assembler::eax, {.base = Assembler::esp, .disp = 8}); |
| assembler.Addl(Assembler::esp, 24); |
| assembler.Ret(); |
| assembler.Finalize(); |
| |
| // clang-format off |
| static const uint8_t kCodeTemplate[] = { |
| 0x8b, 0x44, 0x24, 0x04, // mov 0x4(%esp),%eax |
| 0x0f, 0xb1, 0x44, 0x24, 0x04, // cmpxchg 0x4(%esp),%eax |
| 0x83, 0xec, 0x10, // sub $16, %esp |
| 0x89, 0x04, 0x24, // mov %eax,(%esp) |
| 0x54, // push %esp |
| 0x68, 0xcc, 0xcc, 0xcc, 0xcc, // push $cccccccc |
| 0xff, 0xb4, 0x24, 0x28, 0x04, 0x00, 0x00, // pushl 0x428(%esp) |
| 0x8f, 0x84, 0x24, 0x28, 0x04, 0x00, 0x00, // popl 0x428(%esp) |
| 0xb9, 0xcc, 0xcc, 0xcc, 0xcc, // mov $cccccccc, %ecx |
| 0xff, 0xd1, // call *%ecx |
| 0x8b, 0x44, 0x24, 0x08, // mov 0x8(%esp),%eax |
| 0x83, 0xc4, 0x18, // add $24, %esp |
| 0xc3 // ret |
| }; |
| // clang-format on |
| |
| return CompareCode(std::begin(kCodeTemplate), std::end(kCodeTemplate), code, CPUArch::kX86_64); |
| } |
| |
| } // namespace x86_32 |
| |
| namespace x86_64 { |
| |
| bool AssemblerTest() { |
| MachineCode code; |
| Assembler assembler(&code); |
| assembler.Movq(Assembler::rax, Assembler::rdi); |
| assembler.Subq(Assembler::rsp, 16); |
| assembler.Movq({.base = Assembler::rsp}, Assembler::rax); |
| assembler.Movq({.base = Assembler::rsp, .disp = 8}, Assembler::rax); |
| assembler.Movl({.base = Assembler::rax, .disp = 16}, 239); |
| assembler.Movq(Assembler::r11, {.base = Assembler::rsp}); |
| assembler.Addq(Assembler::rsp, 16); |
| assembler.Ret(); |
| assembler.Finalize(); |
| |
| // clang-format off |
| static const uint8_t kCodeTemplate[] = { |
| 0x48, 0x89, 0xf8, // mov %rdi, %rax |
| 0x48, 0x83, 0xec, 0x10, // sub $0x10, %rsp |
| 0x48, 0x89, 0x04, 0x24, // mov rax, (%rsp) |
| 0x48, 0x89, 0x44, 0x24, 0x08, // mov rax, 8(%rsp) |
| 0xc7, 0x40, 0x10, 0xef, 0x00, // movl $239, 0x10(%rax) |
| 0x00, 0x00, |
| 0x4c, 0x8b, 0x1c, 0x24, // mov (%rsp), r11 |
| 0x48, 0x83, 0xc4, 0x10, // add $0x10, %rsp |
| 0xc3 // ret |
| }; |
| // clang-format on |
| |
| return CompareCode(std::begin(kCodeTemplate), std::end(kCodeTemplate), code, CPUArch::kX86_64); |
| } |
| |
| } // namespace x86_64 |
| |
| #if defined(__i386__) |
| |
| namespace x86_32 { |
| |
| bool LabelTest() { |
| MachineCode code; |
| CodeEmitter as(&code); |
| Assembler::Label skip, skip2, back, end; |
| as.Call(bit_cast<const void*>(&Callee)); |
| as.Jmp(skip); |
| as.Movl(Assembler::eax, 2); |
| as.Bind(&skip); |
| as.Addl(Assembler::eax, 8); |
| as.Jmp(skip2); |
| as.Bind(&back); |
| as.Addl(Assembler::eax, 12); |
| as.Jmp(end); |
| as.Bind(&skip2); |
| as.Jmp(back); |
| as.Bind(&end); |
| as.Ret(); |
| as.Finalize(); |
| |
| ScopedExecRegion exec(&code); |
| |
| int result = exec.get<int()>()(); |
| return result == 239 + 8 + 12; |
| } |
| |
| bool CondTest1() { |
| MachineCode code; |
| CodeEmitter as(&code); |
| as.Movl(Assembler::eax, 0xcccccccc); |
| as.Movl(Assembler::edx, {.base = Assembler::esp, .disp = 4}); // arg1. |
| as.Movl(Assembler::ecx, {.base = Assembler::esp, .disp = 8}); // arg2. |
| as.Cmpl(Assembler::edx, Assembler::ecx); |
| as.Setcc(Assembler::Condition::kEqual, Assembler::eax); |
| as.Ret(); |
| as.Finalize(); |
| |
| ScopedExecRegion exec(&code); |
| |
| using TestFunc = uint32_t(int, int); |
| auto target_func = exec.get<TestFunc>(); |
| uint32_t result = target_func(1, 2); |
| if (result != 0xcccccc00) { |
| ALOGE("Bug in seteq(not equal): %x", result); |
| return false; |
| } |
| result = target_func(-1, -1); |
| if (result != 0xcccccc01) { |
| ALOGE("Bug in seteq(equal): %x", result); |
| return false; |
| } |
| return true; |
| } |
| |
| bool CondTest2() { |
| MachineCode code; |
| CodeEmitter as(&code); |
| as.Movl(Assembler::edx, {.base = Assembler::esp, .disp = 4}); // arg1. |
| as.Movl(Assembler::ecx, {.base = Assembler::esp, .disp = 8}); // arg2. |
| as.Xorl(Assembler::eax, Assembler::eax); |
| as.Testb(Assembler::edx, Assembler::ecx); |
| as.Setcc(Assembler::Condition::kNotZero, Assembler::eax); |
| as.Xchgl(Assembler::eax, Assembler::ecx); |
| as.Xchgl(Assembler::ecx, Assembler::eax); |
| as.Ret(); |
| as.Finalize(); |
| |
| ScopedExecRegion exec(&code); |
| |
| using TestFunc = uint32_t(int, int); |
| auto target_func = exec.get<TestFunc>(); |
| uint32_t result = target_func(0x11, 1); |
| if (result != 0x1) { |
| ALOGE("Bug in testb(not zero): %x", result); |
| return false; |
| } |
| result = target_func(0x11, 0x8); |
| if (result != 0x0) { |
| ALOGE("Bug in testb(zero): %x", result); |
| return false; |
| } |
| return true; |
| } |
| |
| bool JccTest() { |
| MachineCode code; |
| CodeEmitter as(&code); |
| Assembler::Label equal, above, below, done; |
| as.Movl(Assembler::edx, {.base = Assembler::esp, .disp = 4}); // arg1. |
| as.Movl(Assembler::ecx, {.base = Assembler::esp, .disp = 8}); // arg2. |
| as.Cmpl(Assembler::edx, Assembler::ecx); |
| as.Jcc(Assembler::Condition::kEqual, equal); |
| as.Jcc(Assembler::Condition::kBelow, below); |
| as.Jcc(Assembler::Condition::kAbove, above); |
| |
| as.Movl(Assembler::eax, 13); |
| as.Jmp(done); |
| |
| as.Bind(&equal); |
| as.Movl(Assembler::eax, 0u); |
| as.Jmp(done); |
| |
| as.Bind(&below); |
| as.Movl(Assembler::eax, -1); |
| as.Jmp(done); |
| |
| as.Bind(&above); |
| as.Movl(Assembler::eax, 1); |
| as.Jmp(done); |
| |
| as.Bind(&done); |
| as.Ret(); |
| as.Finalize(); |
| |
| ScopedExecRegion exec(&code); |
| |
| using TestFunc = int(int, int); |
| auto target_func = exec.get<TestFunc>(); |
| int result = target_func(1, 1); |
| if (result != 0) { |
| ALOGE("Bug in jcc(equal): %x", result); |
| return false; |
| } |
| result = target_func(1, 0); |
| if (result != 1) { |
| ALOGE("Bug in jcc(above): %x", result); |
| return false; |
| } |
| result = target_func(0, 1); |
| if (result != -1) { |
| ALOGE("Bug in jcc(below): %x", result); |
| return false; |
| } |
| return true; |
| } |
| |
| bool ShiftTest() { |
| MachineCode code; |
| CodeEmitter as(&code); |
| as.Movl(Assembler::eax, {.base = Assembler::esp, .disp = 4}); |
| as.Shll(Assembler::eax, int8_t{2}); |
| as.Shrl(Assembler::eax, int8_t{1}); |
| as.Movl(Assembler::ecx, 3); |
| as.ShllByCl(Assembler::eax); |
| as.Ret(); |
| as.Finalize(); |
| |
| ScopedExecRegion exec(&code); |
| |
| using TestFunc = uint32_t(uint32_t); |
| uint32_t result = exec.get<TestFunc>()(22); |
| return result == (22 << 4); |
| } |
| |
| bool LogicTest() { |
| MachineCode code; |
| CodeEmitter as(&code); |
| as.Movl(Assembler::eax, {.base = Assembler::esp, .disp = 4}); |
| as.Movl(Assembler::ecx, 0x1); |
| as.Xorl(Assembler::eax, Assembler::ecx); |
| as.Movl(Assembler::ecx, 0xf); |
| as.Andl(Assembler::eax, Assembler::ecx); |
| as.Ret(); |
| as.Finalize(); |
| |
| ScopedExecRegion exec(&code); |
| |
| using TestFunc = uint32_t(uint32_t); |
| uint32_t result = exec.get<TestFunc>()(239); |
| return result == ((239 ^ 1) & 0xf); |
| } |
| |
| bool BsrTest() { |
| MachineCode code; |
| CodeEmitter as(&code); |
| |
| as.Movl(Assembler::ecx, {.base = Assembler::esp, .disp = 4}); |
| as.Movl(Assembler::edx, 239); |
| as.Bsrl(Assembler::eax, Assembler::ecx); |
| as.Cmovl(Assembler::Condition::kZero, Assembler::eax, Assembler::edx); |
| as.Ret(); |
| as.Finalize(); |
| |
| ScopedExecRegion exec(&code); |
| |
| using TestFunc = uint32_t(uint32_t arg); |
| auto func = exec.get<TestFunc>(); |
| return func(0) == 239 && func(1 << 15) == 15; |
| } |
| |
| bool CallFPTest() { |
| MachineCode code; |
| CodeEmitter as(&code); |
| as.Push(0x3f800000); |
| as.Push(0x40000000); |
| as.Call(bit_cast<const void*>(&FloatFunc)); |
| as.Fstps({.base = Assembler::esp}); |
| as.Pop(Assembler::eax); |
| as.Addl(Assembler::esp, 4); |
| as.Ret(); |
| as.Finalize(); |
| |
| ScopedExecRegion exec(&code); |
| |
| using TestFunc = uint32_t(); |
| uint32_t result = exec.get<TestFunc>()(); |
| return result == 0x3f800000; |
| } |
| |
| bool XmmTest() { |
| MachineCode code; |
| CodeEmitter as(&code); |
| as.Movl(Assembler::eax, 0x3f800000); |
| as.Movd(Assembler::xmm0, Assembler::eax); |
| as.Movl(Assembler::eax, 0x40000000); |
| as.Movd(Assembler::xmm5, Assembler::eax); |
| as.Addss(Assembler::xmm0, Assembler::xmm5); |
| as.Movd(Assembler::eax, Assembler::xmm0); |
| as.Ret(); |
| as.Finalize(); |
| |
| ScopedExecRegion exec(&code); |
| |
| using TestFunc = uint32_t(); |
| uint32_t result = exec.get<TestFunc>()(); |
| return result == 0x40400000; |
| } |
| |
| bool ReadGlobalTest() { |
| MachineCode code; |
| CodeEmitter as(&code); |
| static const uint32_t kData[] __attribute__((aligned(16))) = // NOLINT |
| {0x00112233, 0x44556677, 0x8899aabb, 0xccddeeff}; |
| as.Movsd(Assembler::xmm0, {.disp = bit_cast<int32_t>(&kData)}); |
| as.Movdqa(Assembler::xmm1, {.disp = bit_cast<int32_t>(&kData)}); |
| as.Movl(Assembler::eax, {.base = Assembler::esp, .disp = 4}); |
| as.Movl(Assembler::ecx, {.base = Assembler::esp, .disp = 8}); |
| as.Movsd({.base = Assembler::eax}, Assembler::xmm0); |
| as.Movdqu({.base = Assembler::ecx}, Assembler::xmm1); |
| |
| as.Ret(); |
| as.Finalize(); |
| |
| ScopedExecRegion exec(&code); |
| |
| using TestFunc = void(void*, void*); |
| uint8_t res1[8]; |
| uint8_t res2[16]; |
| exec.get<TestFunc>()(res1, res2); |
| |
| return (memcmp(res1, kData, 8) == 0) && (memcmp(res2, kData, 16) == 0); |
| } |
| |
| } // namespace x86_32 |
| |
| #elif defined(__amd64__) |
| |
| namespace x86_64 { |
| |
| bool LabelTest() { |
| MachineCode code; |
| CodeEmitter as(&code); |
| Assembler::Label skip, skip2, back, end; |
| as.Call(bit_cast<const void*>(&Callee)); |
| as.Jmp(skip); |
| as.Movl(Assembler::rax, 2); |
| as.Bind(&skip); |
| as.Addb(Assembler::rax, {end}); |
| as.Jmp(skip2); |
| as.Bind(&back); |
| as.Addl(Assembler::rax, 12); |
| as.Jmp(end); |
| as.Bind(&skip2); |
| as.Jmp(back); |
| as.Bind(&end); |
| as.Ret(); |
| as.Finalize(); |
| |
| ScopedExecRegion exec(&code); |
| |
| using TestFunc = int(); |
| int result = exec.get<TestFunc>()(); |
| return result == uint8_t(239 + 0xc3) + 12; |
| } |
| |
| bool CondTest1() { |
| MachineCode code; |
| CodeEmitter as(&code); |
| as.Movl(Assembler::rax, 0xcccccccc); |
| as.Cmpl(Assembler::rdi, Assembler::rsi); |
| as.Setcc(Assembler::Condition::kEqual, Assembler::rax); |
| as.Ret(); |
| as.Finalize(); |
| |
| ScopedExecRegion exec(&code); |
| |
| std::string code_str; |
| code.AsString(&code_str, InstructionSize::OneByte); |
| using TestFunc = uint32_t(int, int); |
| auto target_func = exec.get<TestFunc>(); |
| uint32_t result; |
| result = target_func(1, 2); |
| if (result != 0xcccccc00) { |
| ALOGE("Bug in seteq(not equal): %x", result); |
| return false; |
| } |
| result = target_func(-1, -1); |
| if (result != 0xcccccc01) { |
| ALOGE("Bug in seteq(equal): %x", result); |
| return false; |
| } |
| return true; |
| } |
| |
| bool CondTest2() { |
| MachineCode code; |
| CodeEmitter as(&code); |
| as.Movl(Assembler::rdx, Assembler::rdi); // arg1. |
| as.Movl(Assembler::rcx, Assembler::rsi); // arg2. |
| as.Xorl(Assembler::rax, Assembler::rax); |
| as.Testb(Assembler::rdx, Assembler::rcx); |
| as.Setcc(Assembler::Condition::kNotZero, Assembler::rax); |
| as.Xchgq(Assembler::rax, Assembler::rcx); |
| as.Xchgq(Assembler::rcx, Assembler::rax); |
| as.Xchgq(Assembler::rcx, Assembler::r11); |
| as.Xchgq(Assembler::r11, Assembler::rcx); |
| as.Ret(); |
| as.Finalize(); |
| |
| ScopedExecRegion exec(&code); |
| |
| using TestFunc = uint32_t(int, int); |
| auto target_func = exec.get<TestFunc>(); |
| uint32_t result = target_func(0x11, 1); |
| if (result != 0x1) { |
| printf("Bug in testb(not zero): %x", result); |
| return false; |
| } |
| result = target_func(0x11, 0x8); |
| if (result != 0x0) { |
| printf("Bug in testb(zero): %x", result); |
| return false; |
| } |
| return true; |
| } |
| |
| bool JccTest() { |
| MachineCode code; |
| CodeEmitter as(&code); |
| Assembler::Label equal, above, below, done; |
| as.Cmpl(Assembler::rdi, Assembler::rsi); |
| as.Jcc(Assembler::Condition::kEqual, equal); |
| as.Jcc(Assembler::Condition::kBelow, below); |
| as.Jcc(Assembler::Condition::kAbove, above); |
| |
| as.Movl(Assembler::rax, 13); |
| as.Jmp(done); |
| |
| as.Bind(&equal); |
| as.Movq(Assembler::rax, 0); |
| as.Jmp(done); |
| |
| as.Bind(&below); |
| as.Movl(Assembler::rax, -1); |
| as.Jmp(done); |
| |
| as.Bind(&above); |
| as.Movl(Assembler::rax, 1); |
| as.Jmp(done); |
| |
| as.Bind(&done); |
| as.Ret(); |
| as.Finalize(); |
| |
| ScopedExecRegion exec(&code); |
| |
| using TestFunc = int(int, int); |
| auto target_func = exec.get<TestFunc>(); |
| int result; |
| result = target_func(1, 1); |
| if (result != 0) { |
| ALOGE("Bug in jcc(equal): %x", result); |
| return false; |
| } |
| result = target_func(1, 0); |
| if (result != 1) { |
| ALOGE("Bug in jcc(above): %x", result); |
| return false; |
| } |
| result = target_func(0, 1); |
| if (result != -1) { |
| ALOGE("Bug in jcc(below): %x", result); |
| return false; |
| } |
| return true; |
| } |
| |
| bool ReadWriteTest() { |
| MachineCode code; |
| CodeEmitter as(&code); |
| |
| as.Movq(Assembler::rax, 0); |
| as.Movb(Assembler::rax, {.base = Assembler::rdi}); |
| as.Movl(Assembler::rcx, {.base = Assembler::rsi}); |
| as.Addl(Assembler::rax, Assembler::rcx); |
| as.Movl({.base = Assembler::rsi}, Assembler::rax); |
| as.Ret(); |
| as.Finalize(); |
| |
| ScopedExecRegion exec(&code); |
| |
| using TestFunc = uint32_t(uint8_t*, uint32_t*); |
| uint8_t p1[4] = {0x12, 0x34, 0x56, 0x78}; |
| uint32_t p2 = 0x239; |
| uint32_t result = exec.get<TestFunc>()(p1, &p2); |
| return (result == 0x239 + 0x12) && (p2 == result); |
| } |
| |
| bool CallFPTest() { |
| MachineCode code; |
| CodeEmitter as(&code); |
| as.Movl(Assembler::rax, 0x40000000); |
| as.Movd(Assembler::xmm0, Assembler::rax); |
| as.Movl(Assembler::rax, 0x3f800000); |
| as.Movd(Assembler::xmm1, Assembler::rax); |
| as.Call(bit_cast<const void*>(&FloatFunc)); |
| as.Movd(Assembler::rax, Assembler::xmm0); |
| as.Ret(); |
| as.Finalize(); |
| |
| ScopedExecRegion exec(&code); |
| |
| using TestFunc = uint32_t(); |
| uint32_t result = exec.get<TestFunc>()(); |
| return result == 0x3f800000; |
| } |
| |
| bool XmmTest() { |
| MachineCode code; |
| CodeEmitter as(&code); |
| as.Movl(Assembler::rax, 0x40000000); |
| as.Movd(Assembler::xmm0, Assembler::rax); |
| as.Movl(Assembler::rax, 0x3f800000); |
| as.Movd(Assembler::xmm11, Assembler::rax); |
| as.Addss(Assembler::xmm0, Assembler::xmm11); |
| as.Movaps(Assembler::xmm12, Assembler::xmm0); |
| as.Addss(Assembler::xmm0, Assembler::xmm12); |
| as.Movapd(Assembler::xmm14, Assembler::xmm1); |
| as.Movd(Assembler::rax, Assembler::xmm0); |
| as.Ret(); |
| as.Finalize(); |
| |
| ScopedExecRegion exec(&code); |
| |
| using TestFunc = uint32_t(); |
| uint32_t result = exec.get<TestFunc>()(); |
| return result == 0x40c00000; |
| } |
| |
| bool XmmMemTest() { |
| MachineCode code; |
| CodeEmitter as(&code); |
| |
| as.Movsd(Assembler::xmm0, {.base = Assembler::rdi}); |
| as.Movaps(Assembler::xmm12, Assembler::xmm0); |
| as.Addsd(Assembler::xmm12, Assembler::xmm12); |
| as.Movsd({.base = Assembler::rdi}, Assembler::xmm12); |
| as.Movq(Assembler::rax, Assembler::xmm0); |
| as.Ret(); |
| as.Finalize(); |
| |
| ScopedExecRegion exec(&code); |
| |
| double d = 239.0; |
| char bits[16], *p = bits + 5; |
| memcpy(p, &d, sizeof(d)); |
| |
| using TestFunc = uint64_t(char* p); |
| uint64_t result = exec.get<TestFunc>()(p); |
| uint64_t doubled = *reinterpret_cast<uint64_t*>(p); |
| return result == 0x406de00000000000ULL && doubled == 0x407de00000000000ULL; |
| } |
| |
| bool MovsxblRexTest() { |
| MachineCode code; |
| CodeEmitter as(&code); |
| |
| as.Xorl(Assembler::rdx, Assembler::rdx); |
| as.Movl(Assembler::rsi, 0xdeadff); |
| // CodeEmitter should use REX prefix to encode SIL. |
| // Without REX DH is used. |
| as.Movsxbl(Assembler::rax, Assembler::rsi); |
| as.Ret(); |
| as.Finalize(); |
| |
| ScopedExecRegion exec(&code); |
| |
| using TestFunc = uint32_t(); |
| uint32_t result = exec.get<TestFunc>()(); |
| |
| return result == 0xffffffff; |
| } |
| |
| bool MovzxblRexTest() { |
| MachineCode code; |
| CodeEmitter as(&code); |
| |
| as.Xorl(Assembler::rdx, Assembler::rdx); |
| as.Movl(Assembler::rsi, 0xdeadff); |
| // CodeEmitter should use REX prefix to encode SIL. |
| // Without REX DH is used. |
| as.Movzxbl(Assembler::rax, Assembler::rsi); |
| as.Ret(); |
| as.Finalize(); |
| |
| ScopedExecRegion exec(&code); |
| |
| using TestFunc = uint32_t(); |
| uint32_t result = exec.get<TestFunc>()(); |
| |
| return result == 0x000000ff; |
| } |
| |
| bool ShldlRexTest() { |
| MachineCode code; |
| CodeEmitter as(&code); |
| |
| as.Movl(Assembler::rdx, 0x12345678); |
| // If most-significant bit is not encoded correctly with REX |
| // RAX can be used instead R8 and R10 can be used instead RDX. |
| // Init them all: |
| as.Xorl(Assembler::r8, Assembler::r8); |
| as.Movl(Assembler::rax, 0xdeadbeef); |
| as.Movl(Assembler::r10, 0xdeadbeef); |
| |
| as.Shldl(Assembler::r8, Assembler::rdx, int8_t{8}); |
| as.Movl(Assembler::rcx, 8); |
| as.ShldlByCl(Assembler::r8, Assembler::rdx); |
| |
| as.Movl(Assembler::rax, Assembler::r8); |
| |
| as.Ret(); |
| as.Finalize(); |
| |
| ScopedExecRegion exec(&code); |
| |
| using TestFunc = uint32_t(); |
| uint32_t result = exec.get<TestFunc>()(); |
| |
| return result == 0x1212; |
| } |
| |
| bool ShrdlRexTest() { |
| MachineCode code; |
| CodeEmitter as(&code); |
| |
| as.Movl(Assembler::rdx, 0x12345678); |
| // If most-significant bit is not encoded correctly with REX |
| // RAX can be used instead R8 and R10 can be used instead RDX. |
| // Init them all: |
| as.Xorl(Assembler::r8, Assembler::r8); |
| as.Movl(Assembler::rax, 0xdeadbeef); |
| as.Movl(Assembler::r10, 0xdeadbeef); |
| |
| as.Shrdl(Assembler::r8, Assembler::rdx, int8_t{8}); |
| as.Movl(Assembler::rcx, 8); |
| as.ShrdlByCl(Assembler::r8, Assembler::rdx); |
| |
| as.Movl(Assembler::rax, Assembler::r8); |
| |
| as.Ret(); |
| as.Finalize(); |
| |
| ScopedExecRegion exec(&code); |
| |
| using TestFunc = uint32_t(); |
| uint32_t result = exec.get<TestFunc>()(); |
| |
| return result == 0x78780000; |
| } |
| |
| bool ReadGlobalTest() { |
| MachineCode code; |
| CodeEmitter as(&code); |
| static const uint32_t kData[] __attribute__((aligned(16))) = // NOLINT |
| {0x00112233, 0x44556677, 0x8899aabb, 0xccddeeff}; |
| // We couldn't read data from arbitrary address on x86_64, need address in first 2GiB. |
| void* data = |
| mmap(nullptr, 4096, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS | MAP_32BIT, -1, 0); |
| // Copy our global there. |
| memcpy(data, kData, 16); |
| int32_t data_offset = static_cast<int32_t>(bit_cast<intptr_t>(data)); |
| as.Movsd(Assembler::xmm0, {.disp = data_offset}); |
| as.Movdqa(Assembler::xmm1, {.disp = data_offset}); |
| as.Movsd({.base = Assembler::rdi}, Assembler::xmm0); |
| as.Movdqu({.base = Assembler::rsi}, Assembler::xmm1); |
| |
| as.Ret(); |
| as.Finalize(); |
| |
| ScopedExecRegion exec(&code); |
| |
| using TestFunc = void(void*, void*); |
| uint8_t res1[8]; |
| uint8_t res2[16]; |
| exec.get<TestFunc>()(res1, res2); |
| |
| munmap(data, 4096); |
| |
| return (memcmp(res1, kData, 8) == 0) && (memcmp(res2, kData, 16) == 0); |
| } |
| |
| bool MemShiftTest() { |
| MachineCode code; |
| CodeEmitter as(&code); |
| |
| as.Push(Assembler::rdi); |
| as.Movl(Assembler::rcx, 1); |
| as.ShrlByCl({.base = Assembler::rsp}); |
| as.Addl(Assembler::rcx, 1); |
| as.Movq(Assembler::rdi, Assembler::rsp); |
| as.ShllByCl({.base = Assembler::rdi}); |
| as.Pop(Assembler::rax); |
| |
| as.Ret(); |
| as.Finalize(); |
| |
| ScopedExecRegion exec(&code); |
| |
| using TestFunc = int(int x); |
| int result = exec.get<TestFunc>()(0x10); |
| |
| return result == 0x20; |
| } |
| |
| } // namespace x86_64 |
| |
| #endif |
| |
| #if defined(__i386__) || defined(__amd64__) |
| |
| #if defined(__i386__) |
| |
| extern "C" const uint8_t berberis_gnu_as_output_start[] asm( |
| "berberis_gnu_as_output_start_x86_32"); |
| extern "C" const uint8_t berberis_gnu_as_output_end[] asm( |
| "berberis_gnu_as_output_end_x86_32"); |
| |
| namespace x86_32 { |
| void GenInsnsCommon(CodeEmitter* as); |
| void GenInsnsArch(CodeEmitter* as); |
| } // namespace x86_32 |
| |
| #else |
| |
| extern "C" const uint8_t berberis_gnu_as_output_start[] asm( |
| "berberis_gnu_as_output_start_x86_64"); |
| extern "C" const uint8_t berberis_gnu_as_output_end[] asm( |
| "berberis_gnu_as_output_end_x86_64"); |
| |
| namespace x86_64 { |
| void GenInsnsCommon(CodeEmitter* as); |
| void GenInsnsArch(CodeEmitter* as); |
| } // namespace x86_64 |
| |
| #endif |
| |
| bool ExhaustiveTest() { |
| MachineCode code; |
| CodeEmitter as(&code); |
| |
| #if defined(__i386__) |
| berberis::x86_32::GenInsnsCommon(&as); |
| berberis::x86_32::GenInsnsArch(&as); |
| #else |
| berberis::x86_64::GenInsnsCommon(&as); |
| berberis::x86_64::GenInsnsArch(&as); |
| #endif |
| as.Finalize(); |
| |
| return CompareCode( |
| berberis_gnu_as_output_start, berberis_gnu_as_output_end, code, CPUArch::kX86_64); |
| } |
| |
| bool MixedAssembler() { |
| MachineCode code; |
| x86_32::Assembler as32(&code); |
| x86_64::Assembler as64(&code); |
| x86_32::Assembler::Label lbl32; |
| x86_64::Assembler::Label lbl64; |
| |
| as32.Jmp(lbl32); |
| as32.Xchgl(x86_32::Assembler::eax, x86_32::Assembler::eax); |
| as64.Jmp(lbl64); |
| as64.Xchgl(x86_64::Assembler::rax, x86_64::Assembler::rax); |
| as32.Bind(&lbl32); |
| as32.Movl(x86_32::Assembler::eax, {.disp = 0}); |
| as64.Bind(&lbl64); |
| as32.Finalize(); |
| as64.Finalize(); |
| |
| // clang-format off |
| static const uint8_t kCodeTemplate[] = { |
| 0xe9, 0x08, 0x00, 0x00, 0x00, // jmp lbl32 |
| 0x90, // xchg %eax, %eax == nop |
| 0xe9, 0x07, 0x00, 0x00, 0x00, // jmp lbl64 |
| 0x87, 0xc0, // xchg %eax, %eax != nop |
| // lbl32: |
| 0xa1, 0x00, 0x00, 0x00, 0x00 // movabs %eax, 0x0 |
| // lbl64: |
| }; |
| // clang-format on |
| |
| return CompareCode(std::begin(kCodeTemplate), std::end(kCodeTemplate), code, CPUArch::kX86_64); |
| } |
| #endif |
| |
| } // namespace berberis |
| |
| TEST(Assembler, AssemblerTest) { |
| EXPECT_TRUE(berberis::rv32::AssemblerTest()); |
| EXPECT_TRUE(berberis::rv64::AssemblerTest()); |
| EXPECT_TRUE(berberis::x86_32::AssemblerTest()); |
| EXPECT_TRUE(berberis::x86_64::AssemblerTest()); |
| #if defined(__i386__) |
| EXPECT_TRUE(berberis::x86_32::LabelTest()); |
| EXPECT_TRUE(berberis::x86_32::CondTest1()); |
| EXPECT_TRUE(berberis::x86_32::CondTest2()); |
| EXPECT_TRUE(berberis::x86_32::JccTest()); |
| EXPECT_TRUE(berberis::x86_32::ShiftTest()); |
| EXPECT_TRUE(berberis::x86_32::LogicTest()); |
| EXPECT_TRUE(berberis::x86_32::CallFPTest()); |
| EXPECT_TRUE(berberis::x86_32::XmmTest()); |
| EXPECT_TRUE(berberis::x86_32::BsrTest()); |
| EXPECT_TRUE(berberis::x86_32::ReadGlobalTest()); |
| #elif defined(__amd64__) |
| EXPECT_TRUE(berberis::x86_64::LabelTest()); |
| EXPECT_TRUE(berberis::x86_64::CondTest1()); |
| EXPECT_TRUE(berberis::x86_64::CondTest2()); |
| EXPECT_TRUE(berberis::x86_64::JccTest()); |
| EXPECT_TRUE(berberis::x86_64::ReadWriteTest()); |
| EXPECT_TRUE(berberis::x86_64::CallFPTest()); |
| EXPECT_TRUE(berberis::x86_64::XmmTest()); |
| EXPECT_TRUE(berberis::x86_64::XmmMemTest()); |
| EXPECT_TRUE(berberis::x86_64::MovsxblRexTest()); |
| EXPECT_TRUE(berberis::x86_64::MovzxblRexTest()); |
| EXPECT_TRUE(berberis::x86_64::ShldlRexTest()); |
| EXPECT_TRUE(berberis::x86_64::ShrdlRexTest()); |
| EXPECT_TRUE(berberis::x86_64::ReadGlobalTest()); |
| EXPECT_TRUE(berberis::x86_64::MemShiftTest()); |
| #endif |
| // Currently we don't support these tests for riscv. |
| // TODO(b/352784623): Implement for riscv. |
| #if defined(__i386__) || defined(__x86_64__) |
| EXPECT_TRUE(berberis::ExhaustiveTest()); |
| EXPECT_TRUE(berberis::MixedAssembler()); |
| #endif |
| } |
