Added strings to access enum names of generated Op and Resource enums. Added tests to verify that each encoding class covers all the enums. PiperOrigin-RevId: 694634449 Change-Id: I7a3b93a65677c45825788f8d2e870b6cd5a49768
diff --git a/riscv/BUILD b/riscv/BUILD index d2b0aa6..09b022a 100644 --- a/riscv/BUILD +++ b/riscv/BUILD
@@ -773,6 +773,7 @@ ":riscv64g_isa", ":riscv_state", "@com_google_absl//absl/container:flat_hash_map", + "@com_google_absl//absl/functional:any_invocable", "@com_google_absl//absl/log", "@com_google_absl//absl/strings", "@com_google_mpact-sim//mpact/sim/generic:core",
diff --git a/riscv/riscv32g_encoding.h b/riscv/riscv32g_encoding.h index bcf7f2d..7965d40 100644 --- a/riscv/riscv32g_encoding.h +++ b/riscv/riscv32g_encoding.h
@@ -41,6 +41,15 @@ static constexpr int kParseGroup32Size = 32; static constexpr int kParseGroup16Size = 32; + using SourceOpGetterMap = + absl::flat_hash_map<int, absl::AnyInvocable<SourceOperandInterface *()>>; + using DestOpGetterMap = absl::flat_hash_map< + int, absl::AnyInvocable<DestinationOperandInterface *(int)>>; + using SimpleResourceGetterMap = + absl::flat_hash_map<int, absl::AnyInvocable<generic::SimpleResource *()>>; + using ComplexResourceGetterMap = absl::flat_hash_map< + int, absl::AnyInvocable<ResourceOperandInterface *(int, int)>>; + explicit RiscV32GEncoding(RiscVState *state); ~RiscV32GEncoding() override; @@ -94,16 +103,16 @@ // Getter. generic::SimpleResourcePool *resource_pool() const { return resource_pool_; } - private: - using SourceOpGetterMap = - absl::flat_hash_map<int, absl::AnyInvocable<SourceOperandInterface *()>>; - using DestOpGetterMap = absl::flat_hash_map< - int, absl::AnyInvocable<DestinationOperandInterface *(int)>>; - using SimpleResourceGetterMap = - absl::flat_hash_map<int, absl::AnyInvocable<generic::SimpleResource *()>>; - using ComplexResourceGetterMap = absl::flat_hash_map< - int, absl::AnyInvocable<ResourceOperandInterface *(int, int)>>; + const SourceOpGetterMap &source_op_getters() { return source_op_getters_; } + const DestOpGetterMap &dest_op_getters() { return dest_op_getters_; } + const SimpleResourceGetterMap &simple_resource_getters() { + return simple_resource_getters_; + } + const ComplexResourceGetterMap &complex_resource_getters() { + return complex_resource_getters_; + } + private: const std::string xreg_alias_[32] = { "zero", "ra", "sp", "gp", "tp", "t0", "t1", "t2", "s0", "s1", "a0", "a1", "a2", "a3", "a4", "a5", "a6", "a7", "s2", "s3", "s4", "s5",
diff --git a/riscv/riscv32g_vec_encoding.cc b/riscv/riscv32g_vec_encoding.cc index ce5dd31..88ba701 100644 --- a/riscv/riscv32g_vec_encoding.cc +++ b/riscv/riscv32g_vec_encoding.cc
@@ -393,6 +393,12 @@ state_, absl::StrCat(RiscVState::kFregPrefix, num)); })); source_op_getters_.insert( + std::make_pair(static_cast<int>(SourceOpEnum::kFs1), [this]() { + const int num = encoding::v_arith::ExtractRs1(inst_word_); + return GetRegisterSourceOp<RVFpRegister>( + state_, absl::StrCat(RiscVState::kFregPrefix, num)); + })); + source_op_getters_.insert( std::make_pair(static_cast<int>(SourceOpEnum::kICbImm8), [this]() { return new generic::ImmediateOperand<int32_t>( encoding::inst16_format::ExtractBimm(inst_word_)); @@ -478,6 +484,11 @@ encoding::inst32_format::ExtractJImm(inst_word_)); })); source_op_getters_.insert( + std::make_pair(static_cast<int>(SourceOpEnum::kPred), [this]() { + return new generic::ImmediateOperand<uint32_t>( + encoding::fence::ExtractPred(inst_word_)); + })); + source_op_getters_.insert( std::make_pair(static_cast<int>(SourceOpEnum::kRm), [this]() -> SourceOperandInterface * { uint32_t rm = (inst_word_ >> 12) & 0x7; @@ -538,10 +549,21 @@ encoding::inst32_format::ExtractSImm(inst_word_)); })); source_op_getters_.insert( + std::make_pair(static_cast<int>(SourceOpEnum::kSucc), [this]() { + return new generic::ImmediateOperand<uint32_t>( + encoding::fence::ExtractSucc(inst_word_)); + })); + source_op_getters_.insert( std::make_pair(static_cast<int>(SourceOpEnum::kUImm20), [this]() { return new generic::ImmediateOperand<int32_t>( encoding::inst32_format::ExtractUImm(inst_word_)); })); + Insert(source_op_getters_, SourceOpEnum::kVm, + [this]() -> SourceOperandInterface * { + auto vm = encoding::v_arith::ExtractVm(inst_word_); + return new generic::ImmediateOperand<bool>( + vm, absl::StrCat("vm.", vm ? "t" : "f")); + }); source_op_getters_.insert( std::make_pair(static_cast<int>(SourceOpEnum::kX0), [this]() { return new generic::IntLiteralOperand<0>({1}, xreg_alias_[0]);
diff --git a/riscv/riscv32g_vec_encoding.h b/riscv/riscv32g_vec_encoding.h index 4669cdd..196e8a1 100644 --- a/riscv/riscv32g_vec_encoding.h +++ b/riscv/riscv32g_vec_encoding.h
@@ -34,6 +34,15 @@ // This class extends the RiscV scalar encoding class with vector instructions. class RiscV32GVecEncoding : public RiscV32GVEncodingBase { public: + using SourceOpGetterMap = + absl::flat_hash_map<int, absl::AnyInvocable<SourceOperandInterface *()>>; + using DestOpGetterMap = absl::flat_hash_map< + int, absl::AnyInvocable<DestinationOperandInterface *(int)>>; + using SimpleResourceGetterMap = + absl::flat_hash_map<int, absl::AnyInvocable<generic::SimpleResource *()>>; + using ComplexResourceGetterMap = absl::flat_hash_map< + int, absl::AnyInvocable<ResourceOperandInterface *(int, int)>>; + static constexpr int kParseGroup32Size = 32; static constexpr int kParseGroup16Size = 32; @@ -88,16 +97,17 @@ return 0; } - private: - using SourceOpGetterMap = - absl::flat_hash_map<int, absl::AnyInvocable<SourceOperandInterface *()>>; - using DestOpGetterMap = absl::flat_hash_map< - int, absl::AnyInvocable<DestinationOperandInterface *(int)>>; - using SimpleResourceGetterMap = - absl::flat_hash_map<int, absl::AnyInvocable<generic::SimpleResource *()>>; - using ComplexResourceGetterMap = absl::flat_hash_map< - int, absl::AnyInvocable<ResourceOperandInterface *(int, int)>>; + // Getter. + const SourceOpGetterMap &source_op_getters() { return source_op_getters_; } + const DestOpGetterMap &dest_op_getters() { return dest_op_getters_; } + const SimpleResourceGetterMap &simple_resource_getters() { + return simple_resource_getters_; + } + const ComplexResourceGetterMap &complex_resource_getters() { + return complex_resource_getters_; + } + private: const std::string xreg_alias_[32] = { "zero", "ra", "sp", "gp", "tp", "t0", "t1", "t2", "s0", "s1", "a0", "a1", "a2", "a3", "a4", "a5", "a6", "a7", "s2", "s3", "s4", "s5",
diff --git a/riscv/riscv32gzb_encoding.h b/riscv/riscv32gzb_encoding.h index 96e1640..96a1104 100644 --- a/riscv/riscv32gzb_encoding.h +++ b/riscv/riscv32gzb_encoding.h
@@ -76,6 +76,15 @@ } uint32_t inst_word() const override { return inst_word_; } + const SourceOpGetterMap &source_op_getters() { return source_op_getters_; } + const DestOpGetterMap &dest_op_getters() { return dest_op_getters_; } + const SimpleResourceGetterMap &simple_resource_getters() { + return simple_resource_getters_; + } + const ComplexResourceGetterMap &complex_resource_getters() { + return complex_resource_getters_; + } + private: std::string GetSimpleResourceName(SimpleResourceEnum resource_enum);
diff --git a/riscv/riscv32gzb_vec_encoding.h b/riscv/riscv32gzb_vec_encoding.h index 7b2448d..c166534 100644 --- a/riscv/riscv32gzb_vec_encoding.h +++ b/riscv/riscv32gzb_vec_encoding.h
@@ -75,6 +75,15 @@ } uint32_t inst_word() const override { return inst_word_; } + const SourceOpGetterMap &source_op_getters() { return source_op_getters_; } + const DestOpGetterMap &dest_op_getters() { return dest_op_getters_; } + const SimpleResourceGetterMap &simple_resource_getters() { + return simple_resource_getters_; + } + const ComplexResourceGetterMap &complex_resource_getters() { + return complex_resource_getters_; + } + private: std::string GetSimpleResourceName(SimpleResourceEnum resource_enum);
diff --git a/riscv/riscv64g_encoding.h b/riscv/riscv64g_encoding.h index da9a3ed..92a96f9 100644 --- a/riscv/riscv64g_encoding.h +++ b/riscv/riscv64g_encoding.h
@@ -19,6 +19,7 @@ #include <string> #include "absl/container/flat_hash_map.h" +#include "absl/functional/any_invocable.h" #include "mpact/sim/generic/simple_resource.h" #include "mpact/sim/generic/simple_resource_operand.h" #include "riscv/riscv64g_decoder.h" @@ -37,9 +38,30 @@ // instructions according to the operand fields in the encoding. class RiscV64GEncoding : public RiscV64GEncodingBase { public: + using SourceOpGetterMap = + absl::flat_hash_map<int, absl::AnyInvocable<SourceOperandInterface *()>>; + using DestOpGetterMap = absl::flat_hash_map< + int, absl::AnyInvocable<DestinationOperandInterface *(int)>>; + using SimpleResourceGetterMap = + absl::flat_hash_map<int, absl::AnyInvocable<generic::SimpleResource *()>>; + using ComplexResourceGetterMap = absl::flat_hash_map< + int, absl::AnyInvocable<ResourceOperandInterface *(int, int)>>; + static constexpr int kParseGroup32Size = 32; static constexpr int kParseGroup16Size = 32; + // Architectural names for the integer registers. + const std::string xreg_names_[32] = { + "x0", "x1", "x2", "x3", "x4", "x5", "x6", "x7", + "x8", "x9", "x10", "x11", "x12", "x13", "x14", "x15", + "x16", "x17", "x18", "x19", "x20", "x21", "x22", "x23", + "x24", "x25", "x26", "x27", "x28", "x29", "x30", "x31"}; + // ABI names for the integer registers. + const std::string xreg_abi_names_[32] = { + "zero", "ra", "sp", "gp", "tp", "t0", "t1", "t2", "s0", "s1", "a0", + "a1", "a2", "a3", "a4", "a5", "a6", "a7", "s2", "s3", "s4", "s5", + "s6", "s7", "s8", "s9", "s10", "s11", "t3", "t4", "t5", "t6"}; + explicit RiscV64GEncoding(RiscVState *state); RiscV64GEncoding(RiscVState *state, bool use_abi_names); ~RiscV64GEncoding() override; @@ -94,34 +116,12 @@ // Getter. generic::SimpleResourcePool *resource_pool() const { return resource_pool_; } - protected: - using SourceOpGetterMap = - absl::flat_hash_map<int, absl::AnyInvocable<SourceOperandInterface *()>>; - using DestOpGetterMap = absl::flat_hash_map< - int, absl::AnyInvocable<DestinationOperandInterface *(int)>>; - using SimpleResourceGetterMap = - absl::flat_hash_map<int, absl::AnyInvocable<generic::SimpleResource *()>>; - using ComplexResourceGetterMap = absl::flat_hash_map< - int, absl::AnyInvocable<ResourceOperandInterface *(int, int)>>; - - // Architectural names for the integer registers. - const std::string xreg_names_[32] = { - "x0", "x1", "x2", "x3", "x4", "x5", "x6", "x7", - "x8", "x9", "x10", "x11", "x12", "x13", "x14", "x15", - "x16", "x17", "x18", "x19", "x20", "x21", "x22", "x23", - "x24", "x25", "x26", "x27", "x28", "x29", "x30", "x31"}; - // ABI names for the integer registers. - const std::string xreg_abi_names_[32] = { - "zero", "ra", "sp", "gp", "tp", "t0", "t1", "t2", "s0", "s1", "a0", - "a1", "a2", "a3", "a4", "a5", "a6", "a7", "s2", "s3", "s4", "s5", - "s6", "s7", "s8", "s9", "s10", "s11", "t3", "t4", "t5", "t6"}; - - SourceOpGetterMap &source_op_getters() { return source_op_getters_; } - DestOpGetterMap &dest_op_getters() { return dest_op_getters_; } - SimpleResourceGetterMap &simple_resource_getters() { + const SourceOpGetterMap &source_op_getters() { return source_op_getters_; } + const DestOpGetterMap &dest_op_getters() { return dest_op_getters_; } + const SimpleResourceGetterMap &simple_resource_getters() { return simple_resource_getters_; } - ComplexResourceGetterMap &complex_resource_getters() { + const ComplexResourceGetterMap &complex_resource_getters() { return complex_resource_getters_; }
diff --git a/riscv/riscv64g_vec_encoding.h b/riscv/riscv64g_vec_encoding.h index c5dc026..4cec413 100644 --- a/riscv/riscv64g_vec_encoding.h +++ b/riscv/riscv64g_vec_encoding.h
@@ -37,6 +37,15 @@ // instructions according to the operand fields in the encoding. class RiscV64GVecEncoding : public RiscV64GVEncodingBase { public: + using SourceOpGetterMap = + absl::flat_hash_map<int, absl::AnyInvocable<SourceOperandInterface *()>>; + using DestOpGetterMap = absl::flat_hash_map< + int, absl::AnyInvocable<DestinationOperandInterface *(int)>>; + using SimpleResourceGetterMap = + absl::flat_hash_map<int, absl::AnyInvocable<generic::SimpleResource *()>>; + using ComplexResourceGetterMap = absl::flat_hash_map< + int, absl::AnyInvocable<ResourceOperandInterface *(int, int)>>; + static constexpr int kParseGroup32Size = 32; static constexpr int kParseGroup16Size = 32; @@ -92,18 +101,17 @@ } // Getter. - generic::SimpleResourcePool *resource_pool() const { return resource_pool_; } + + const SourceOpGetterMap &source_op_getters() { return source_op_getters_; } + const DestOpGetterMap &dest_op_getters() { return dest_op_getters_; } + const SimpleResourceGetterMap &simple_resource_getters() { + return simple_resource_getters_; + } + const ComplexResourceGetterMap &complex_resource_getters() { + return complex_resource_getters_; + } protected: - using SourceOpGetterMap = - absl::flat_hash_map<int, absl::AnyInvocable<SourceOperandInterface *()>>; - using DestOpGetterMap = absl::flat_hash_map< - int, absl::AnyInvocable<DestinationOperandInterface *(int)>>; - using SimpleResourceGetterMap = - absl::flat_hash_map<int, absl::AnyInvocable<generic::SimpleResource *()>>; - using ComplexResourceGetterMap = absl::flat_hash_map< - int, absl::AnyInvocable<ResourceOperandInterface *(int, int)>>; - // Architectural names for the integer registers. const std::string xreg_names_[32] = { "x0", "x1", "x2", "x3", "x4", "x5", "x6", "x7", @@ -128,18 +136,10 @@ "fa6", "fa7", "fs2", "fs3", "fs4", "fs5", "fs6", "fs7", "fs8", "fs9", "fs10", "fs11", "ft8", "ft9", "ft10", "ft11"}; - SourceOpGetterMap &source_op_getters() { return source_op_getters_; } - DestOpGetterMap &dest_op_getters() { return dest_op_getters_; } - SimpleResourceGetterMap &simple_resource_getters() { - return simple_resource_getters_; - } - ComplexResourceGetterMap &complex_resource_getters() { - return complex_resource_getters_; - } - RiscVState *state() const { return state_; } OpcodeEnum opcode() const { return opcode_; } uint32_t inst_word() const { return inst_word_; } + generic::SimpleResourcePool *resource_pool() const { return resource_pool_; } private: std::string GetSimpleResourceName(SimpleResourceEnum resource_enum);
diff --git a/riscv/riscv64gzb_encoding.cc b/riscv/riscv64gzb_encoding.cc index 631b4fd..9c9d608 100644 --- a/riscv/riscv64gzb_encoding.cc +++ b/riscv/riscv64gzb_encoding.cc
@@ -15,7 +15,6 @@ #include "riscv/riscv64gzb_encoding.h" #include <cstdint> -#include <new> #include "absl/log/log.h" #include "absl/strings/str_cat.h" @@ -27,7 +26,9 @@ #include "riscv/riscv64gzb_enums.h" #include "riscv/riscv_encoding_common.h" #include "riscv/riscv_getters.h" +#include "riscv/riscv_getters_rv64.h" #include "riscv/riscv_getters_zba.h" +#include "riscv/riscv_getters_zbb64.h" #include "riscv/riscv_register.h" #include "riscv/riscv_state.h" @@ -54,8 +55,12 @@ [](int latency, int end) { return nullptr; }); AddRiscVSourceGetters<SourceOpEnum, Extractors, RV64Register, RVFpRegister>( source_op_getters_, this); + AddRiscV64SourceGetters<SourceOpEnum, Extractors, RV64Register, RVFpRegister>( + source_op_getters_, this); AddRiscVZbaSourceGetters<SourceOpEnum, Extractors, RV64Register, RVFpRegister>(source_op_getters_, this); + AddRiscVZbb64SourceGetters<SourceOpEnum, Extractors, RV64Register, + RVFpRegister>(source_op_getters_, this); AddRiscVDestGetters<DestOpEnum, Extractors, RV64Register, RVFpRegister>( dest_op_getters_, this); AddRiscVZbaDestGetters<DestOpEnum, Extractors, RV64Register, RVFpRegister>(
diff --git a/riscv/riscv64gzb_encoding.h b/riscv/riscv64gzb_encoding.h index 007e7bc..8fc2b3b 100644 --- a/riscv/riscv64gzb_encoding.h +++ b/riscv/riscv64gzb_encoding.h
@@ -75,6 +75,15 @@ } uint32_t inst_word() const override { return inst_word_; } + const SourceOpGetterMap &source_op_getters() { return source_op_getters_; } + const DestOpGetterMap &dest_op_getters() { return dest_op_getters_; } + const SimpleResourceGetterMap &simple_resource_getters() { + return simple_resource_getters_; + } + const ComplexResourceGetterMap &complex_resource_getters() { + return complex_resource_getters_; + } + private: std::string GetSimpleResourceName(SimpleResourceEnum resource_enum);
diff --git a/riscv/riscv64gzb_vec_encoding.h b/riscv/riscv64gzb_vec_encoding.h index 3a2e219..8966e99 100644 --- a/riscv/riscv64gzb_vec_encoding.h +++ b/riscv/riscv64gzb_vec_encoding.h
@@ -75,6 +75,15 @@ } uint32_t inst_word() const override { return inst_word_; } + const SourceOpGetterMap &source_op_getters() { return source_op_getters_; } + const DestOpGetterMap &dest_op_getters() { return dest_op_getters_; } + const SimpleResourceGetterMap &simple_resource_getters() { + return simple_resource_getters_; + } + const ComplexResourceGetterMap &complex_resource_getters() { + return complex_resource_getters_; + } + private: std::string GetSimpleResourceName(SimpleResourceEnum resource_enum);
diff --git a/riscv/riscv_getters_rv64.h b/riscv/riscv_getters_rv64.h index 7d399d5..15583c8 100644 --- a/riscv/riscv_getters_rv64.h +++ b/riscv/riscv_getters_rv64.h
@@ -16,7 +16,6 @@ #define THIRD_PARTY_MPACT_RISCV_RISCV_GETTERS_RV64_H_ #include <cstdint> -#include <new> #include "mpact/sim/generic/immediate_operand.h" #include "mpact/sim/generic/literal_operand.h"
diff --git a/riscv/riscv_getters_zbb64.h b/riscv/riscv_getters_zbb64.h index 5e4317a..a824055 100644 --- a/riscv/riscv_getters_zbb64.h +++ b/riscv/riscv_getters_zbb64.h
@@ -16,7 +16,6 @@ #define THIRD_PARTY_MPACT_RISCV_RISCV_GETTERS_ZBB64_H_ #include <cstdint> -#include <new> #include "mpact/sim/generic/immediate_operand.h" #include "mpact/sim/generic/type_helpers.h"
diff --git a/riscv/test/BUILD b/riscv/test/BUILD index 16e6c12..19ca1cc 100644 --- a/riscv/test/BUILD +++ b/riscv/test/BUILD
@@ -219,6 +219,23 @@ "//riscv:riscv32g_isa", "//riscv:riscv_state", "@com_google_googletest//:gtest_main", + "@com_google_mpact-sim//mpact/sim/generic:type_helpers", + "@com_google_mpact-sim//mpact/sim/util/memory", + ], +) + +cc_test( + name = "riscv32g_vec_encoding_test", + size = "small", + srcs = [ + "riscv32g_vec_encoding_test.cc", + ], + deps = [ + "//riscv:riscv32g_vec_decoder", + "//riscv:riscv32gv_isa", + "//riscv:riscv_state", + "@com_google_googletest//:gtest_main", + "@com_google_mpact-sim//mpact/sim/generic:type_helpers", "@com_google_mpact-sim//mpact/sim/util/memory", ], ) @@ -234,6 +251,23 @@ "//riscv:riscv32gzb_isa", "//riscv:riscv_state", "@com_google_googletest//:gtest_main", + "@com_google_mpact-sim//mpact/sim/generic:type_helpers", + "@com_google_mpact-sim//mpact/sim/util/memory", + ], +) + +cc_test( + name = "riscv32gzb_vec_encoding_test", + size = "small", + srcs = [ + "riscv32gzb_vec_encoding_test.cc", + ], + deps = [ + "//riscv:riscv32gvzb_isa", + "//riscv:riscv32gzb_vec_decoder", + "//riscv:riscv_state", + "@com_google_googletest//:gtest_main", + "@com_google_mpact-sim//mpact/sim/generic:type_helpers", "@com_google_mpact-sim//mpact/sim/util/memory", ], ) @@ -249,6 +283,55 @@ "//riscv:riscv64g_isa", "//riscv:riscv_state", "@com_google_googletest//:gtest_main", + "@com_google_mpact-sim//mpact/sim/generic:type_helpers", + "@com_google_mpact-sim//mpact/sim/util/memory", + ], +) + +cc_test( + name = "riscv64g_vec_encoding_test", + size = "small", + srcs = [ + "riscv64g_vec_encoding_test.cc", + ], + deps = [ + "//riscv:riscv64g_vec_decoder", + "//riscv:riscv64gv_isa", + "//riscv:riscv_state", + "@com_google_googletest//:gtest_main", + "@com_google_mpact-sim//mpact/sim/generic:type_helpers", + "@com_google_mpact-sim//mpact/sim/util/memory", + ], +) + +cc_test( + name = "riscv64gzb_encoding_test", + size = "small", + srcs = [ + "riscv64gzb_encoding_test.cc", + ], + deps = [ + "//riscv:riscv64g_bitmanip_decoder", + "//riscv:riscv64gzb_isa", + "//riscv:riscv_state", + "@com_google_googletest//:gtest_main", + "@com_google_mpact-sim//mpact/sim/generic:type_helpers", + "@com_google_mpact-sim//mpact/sim/util/memory", + ], +) + +cc_test( + name = "riscv64gzb_vec_encoding_test", + size = "small", + srcs = [ + "riscv64gzb_vec_encoding_test.cc", + ], + deps = [ + "//riscv:riscv64gvzb_isa", + "//riscv:riscv64gzb_vec_decoder", + "//riscv:riscv_state", + "@com_google_googletest//:gtest_main", + "@com_google_mpact-sim//mpact/sim/generic:type_helpers", "@com_google_mpact-sim//mpact/sim/util/memory", ], )
diff --git a/riscv/test/riscv32g_encoding_test.cc b/riscv/test/riscv32g_encoding_test.cc index 82a9f68..3f2cfe2 100644 --- a/riscv/test/riscv32g_encoding_test.cc +++ b/riscv/test/riscv32g_encoding_test.cc
@@ -17,15 +17,26 @@ #include <cstdint> #include "googlemock/include/gmock/gmock.h" +#include "mpact/sim/generic/type_helpers.h" #include "mpact/sim/util/memory/flat_demand_memory.h" #include "riscv/riscv32g_enums.h" #include "riscv/riscv_state.h" namespace { +using ::mpact::sim::generic::operator*; // NOLINT: clang-tidy false positive. + using mpact::sim::riscv::RiscVState; using mpact::sim::riscv::RiscVXlen; +using mpact::sim::riscv::isa32::ComplexResourceEnum; +using mpact::sim::riscv::isa32::DestOpEnum; +using mpact::sim::riscv::isa32::kComplexResourceNames; +using mpact::sim::riscv::isa32::kDestOpNames; +using mpact::sim::riscv::isa32::kSimpleResourceNames; +using mpact::sim::riscv::isa32::kSourceOpNames; using mpact::sim::riscv::isa32::RiscV32GEncoding; +using mpact::sim::riscv::isa32::SimpleResourceEnum; +using mpact::sim::riscv::isa32::SourceOpEnum; using mpact::sim::util::FlatDemandMemory; using SlotEnum = mpact::sim::riscv::isa32::SlotEnum; using OpcodeEnum = mpact::sim::riscv::isa32::OpcodeEnum; @@ -246,6 +257,40 @@ return (iword | ((val & 0x1f) << 2)); } +TEST_F(RiscV32GEncodingTest, SourceOperands) { + auto &getters = enc_->source_op_getters(); + for (int i = *SourceOpEnum::kNone; i < *SourceOpEnum::kPastMaxValue; ++i) { + EXPECT_TRUE(getters.contains(i)) << "No source operand for enum value " << i + << " (" << kSourceOpNames[i] << ")"; + } +} + +TEST_F(RiscV32GEncodingTest, DestOperands) { + auto &getters = enc_->dest_op_getters(); + for (int i = *DestOpEnum::kNone; i < *DestOpEnum::kPastMaxValue; ++i) { + EXPECT_TRUE(getters.contains(i)) << "No dest operand for enum value " << i + << " (" << kDestOpNames[i] << ")"; + } +} + +TEST_F(RiscV32GEncodingTest, SimpleResources) { + auto &getters = enc_->simple_resource_getters(); + for (int i = *SimpleResourceEnum::kNone; + i < *SimpleResourceEnum::kPastMaxValue; ++i) { + EXPECT_TRUE(getters.contains(i)) << "No source operand for enum value " << i + << " (" << kSimpleResourceNames[i] << ")"; + } +} + +TEST_F(RiscV32GEncodingTest, ComplexResources) { + auto &getters = enc_->source_op_getters(); + for (int i = *ComplexResourceEnum::kNone; + i < *ComplexResourceEnum::kPastMaxValue; ++i) { + EXPECT_TRUE(getters.contains(i)) << "No source operand for enum value " << i + << " (" << kComplexResourceNames[i] << ")"; + } +} + TEST_F(RiscV32GEncodingTest, RV32IOpcodes) { enc_->ParseInstruction(SetRd(kLui, kRdValue)); EXPECT_EQ(enc_->GetOpcode(SlotEnum::kRiscv32g, 0), OpcodeEnum::kLui);
diff --git a/riscv/test/riscv32g_vec_encoding_test.cc b/riscv/test/riscv32g_vec_encoding_test.cc new file mode 100644 index 0000000..f3af998 --- /dev/null +++ b/riscv/test/riscv32g_vec_encoding_test.cc
@@ -0,0 +1,95 @@ +// Copyright 2024 Google LLC +// +// 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 +// +// https://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 "riscv/riscv32g_vec_encoding.h" + +#include "googlemock/include/gmock/gmock.h" +#include "mpact/sim/generic/type_helpers.h" +#include "mpact/sim/util/memory/flat_demand_memory.h" +#include "riscv/riscv32gv_enums.h" +#include "riscv/riscv_state.h" + +// This file contains tests for the RiscV32GZBEncoding class to ensure that +// the instruction decoding is correct. + +namespace { + +using ::mpact::sim::generic::operator*; // NOLINT: clang-tidy false positive. + +using mpact::sim::riscv::RiscVState; +using mpact::sim::riscv::RiscVXlen; +using mpact::sim::riscv::isa32v::ComplexResourceEnum; +using mpact::sim::riscv::isa32v::DestOpEnum; +using mpact::sim::riscv::isa32v::kComplexResourceNames; +using mpact::sim::riscv::isa32v::kDestOpNames; +using mpact::sim::riscv::isa32v::kSimpleResourceNames; +using mpact::sim::riscv::isa32v::kSourceOpNames; +using mpact::sim::riscv::isa32v::RiscV32GVecEncoding; +using mpact::sim::riscv::isa32v::SimpleResourceEnum; +using mpact::sim::riscv::isa32v::SourceOpEnum; +using mpact::sim::util::FlatDemandMemory; +using SlotEnum = mpact::sim::riscv::isa32v::SlotEnum; +using OpcodeEnum = mpact::sim::riscv::isa32v::OpcodeEnum; + +class RiscV32GVecEncodingTest : public testing::Test { + protected: + RiscV32GVecEncodingTest() { + state_ = new RiscVState("test", RiscVXlen::RV32, &memory_); + enc_ = new RiscV32GVecEncoding(state_); + } + ~RiscV32GVecEncodingTest() override { + delete enc_; + delete state_; + } + + FlatDemandMemory memory_; + RiscVState *state_; + RiscV32GVecEncoding *enc_; +}; + +TEST_F(RiscV32GVecEncodingTest, SourceOperands) { + auto &getters = enc_->source_op_getters(); + for (int i = *SourceOpEnum::kNone; i < *SourceOpEnum::kPastMaxValue; ++i) { + EXPECT_TRUE(getters.contains(i)) << "No source operand for enum value " << i + << " (" << kSourceOpNames[i] << ")"; + } +} + +TEST_F(RiscV32GVecEncodingTest, DestOperands) { + auto &getters = enc_->dest_op_getters(); + for (int i = *DestOpEnum::kNone; i < *DestOpEnum::kPastMaxValue; ++i) { + EXPECT_TRUE(getters.contains(i)) << "No dest operand for enum value " << i + << " (" << kDestOpNames[i] << ")"; + } +} + +TEST_F(RiscV32GVecEncodingTest, SimpleResources) { + auto &getters = enc_->simple_resource_getters(); + for (int i = *SimpleResourceEnum::kNone; + i < *SimpleResourceEnum::kPastMaxValue; ++i) { + EXPECT_TRUE(getters.contains(i)) << "No source operand for enum value " << i + << " (" << kSimpleResourceNames[i] << ")"; + } +} + +TEST_F(RiscV32GVecEncodingTest, ComplexResources) { + auto &getters = enc_->source_op_getters(); + for (int i = *ComplexResourceEnum::kNone; + i < *ComplexResourceEnum::kPastMaxValue; ++i) { + EXPECT_TRUE(getters.contains(i)) << "No source operand for enum value " << i + << " (" << kComplexResourceNames[i] << ")"; + } +} + +} // namespace
diff --git a/riscv/test/riscv32gzb_encoding_test.cc b/riscv/test/riscv32gzb_encoding_test.cc index e393e8c..8131160 100644 --- a/riscv/test/riscv32gzb_encoding_test.cc +++ b/riscv/test/riscv32gzb_encoding_test.cc
@@ -15,9 +15,9 @@ #include "riscv/riscv32gzb_encoding.h" #include <cstdint> -#include <new> #include "googlemock/include/gmock/gmock.h" +#include "mpact/sim/generic/type_helpers.h" #include "mpact/sim/util/memory/flat_demand_memory.h" #include "riscv/riscv32gzb_enums.h" #include "riscv/riscv_state.h" @@ -27,9 +27,19 @@ namespace { +using ::mpact::sim::generic::operator*; // NOLINT: clang-tidy false positive. + using mpact::sim::riscv::RiscVState; using mpact::sim::riscv::RiscVXlen; +using mpact::sim::riscv::isa32gzb::ComplexResourceEnum; +using mpact::sim::riscv::isa32gzb::DestOpEnum; +using mpact::sim::riscv::isa32gzb::kComplexResourceNames; +using mpact::sim::riscv::isa32gzb::kDestOpNames; +using mpact::sim::riscv::isa32gzb::kSimpleResourceNames; +using mpact::sim::riscv::isa32gzb::kSourceOpNames; using mpact::sim::riscv::isa32gzb::RiscV32GZBEncoding; +using mpact::sim::riscv::isa32gzb::SimpleResourceEnum; +using mpact::sim::riscv::isa32gzb::SourceOpEnum; using mpact::sim::util::FlatDemandMemory; using SlotEnum = mpact::sim::riscv::isa32gzb::SlotEnum; using OpcodeEnum = mpact::sim::riscv::isa32gzb::OpcodeEnum; @@ -92,6 +102,40 @@ RiscV32GZBEncoding *enc_; }; +TEST_F(RiscV32GZBEncodingTest, SourceOperands) { + auto &getters = enc_->source_op_getters(); + for (int i = *SourceOpEnum::kNone; i < *SourceOpEnum::kPastMaxValue; ++i) { + EXPECT_TRUE(getters.contains(i)) << "No source operand for enum value " << i + << " (" << kSourceOpNames[i] << ")"; + } +} + +TEST_F(RiscV32GZBEncodingTest, DestOperands) { + auto &getters = enc_->dest_op_getters(); + for (int i = *DestOpEnum::kNone; i < *DestOpEnum::kPastMaxValue; ++i) { + EXPECT_TRUE(getters.contains(i)) << "No dest operand for enum value " << i + << " (" << kDestOpNames[i] << ")"; + } +} + +TEST_F(RiscV32GZBEncodingTest, SimpleResources) { + auto &getters = enc_->simple_resource_getters(); + for (int i = *SimpleResourceEnum::kNone; + i < *SimpleResourceEnum::kPastMaxValue; ++i) { + EXPECT_TRUE(getters.contains(i)) << "No source operand for enum value " << i + << " (" << kSimpleResourceNames[i] << ")"; + } +} + +TEST_F(RiscV32GZBEncodingTest, ComplexResources) { + auto &getters = enc_->source_op_getters(); + for (int i = *ComplexResourceEnum::kNone; + i < *ComplexResourceEnum::kPastMaxValue; ++i) { + EXPECT_TRUE(getters.contains(i)) << "No source operand for enum value " << i + << " (" << kComplexResourceNames[i] << ")"; + } +} + TEST_F(RiscV32GZBEncodingTest, Zba) { enc_->ParseInstruction(kSh1Add); EXPECT_EQ(enc_->GetOpcode(SlotEnum::kRiscv32gzb, 0), OpcodeEnum::kSh1add);
diff --git a/riscv/test/riscv32gzb_vec_encoding_test.cc b/riscv/test/riscv32gzb_vec_encoding_test.cc new file mode 100644 index 0000000..f14f8df --- /dev/null +++ b/riscv/test/riscv32gzb_vec_encoding_test.cc
@@ -0,0 +1,95 @@ +// Copyright 2024 Google LLC +// +// 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 +// +// https://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 "riscv/riscv32gzb_vec_encoding.h" + +#include "googlemock/include/gmock/gmock.h" +#include "mpact/sim/generic/type_helpers.h" +#include "mpact/sim/util/memory/flat_demand_memory.h" +#include "riscv/riscv32gvzb_enums.h" +#include "riscv/riscv_state.h" + +// This file contains tests for the RiscV32GZBVecEncoding class to ensure that +// the instruction decoding is correct. + +namespace { + +using ::mpact::sim::generic::operator*; // NOLINT: clang-tidy false positive. + +using mpact::sim::riscv::RiscVState; +using mpact::sim::riscv::RiscVXlen; +using mpact::sim::riscv::isa32gvzb::ComplexResourceEnum; +using mpact::sim::riscv::isa32gvzb::DestOpEnum; +using mpact::sim::riscv::isa32gvzb::kComplexResourceNames; +using mpact::sim::riscv::isa32gvzb::kDestOpNames; +using mpact::sim::riscv::isa32gvzb::kSimpleResourceNames; +using mpact::sim::riscv::isa32gvzb::kSourceOpNames; +using mpact::sim::riscv::isa32gvzb::RiscV32GZBVecEncoding; +using mpact::sim::riscv::isa32gvzb::SimpleResourceEnum; +using mpact::sim::riscv::isa32gvzb::SourceOpEnum; +using mpact::sim::util::FlatDemandMemory; +using SlotEnum = mpact::sim::riscv::isa32gvzb::SlotEnum; +using OpcodeEnum = mpact::sim::riscv::isa32gvzb::OpcodeEnum; + +class RiscV32GZBVecEncodingTest : public testing::Test { + protected: + RiscV32GZBVecEncodingTest() { + state_ = new RiscVState("test", RiscVXlen::RV32, &memory_); + enc_ = new RiscV32GZBVecEncoding(state_); + } + ~RiscV32GZBVecEncodingTest() override { + delete enc_; + delete state_; + } + + FlatDemandMemory memory_; + RiscVState *state_; + RiscV32GZBVecEncoding *enc_; +}; + +TEST_F(RiscV32GZBVecEncodingTest, SourceOperands) { + auto &getters = enc_->source_op_getters(); + for (int i = *SourceOpEnum::kNone; i < *SourceOpEnum::kPastMaxValue; ++i) { + EXPECT_TRUE(getters.contains(i)) << "No source operand for enum value " << i + << " (" << kSourceOpNames[i] << ")"; + } +} + +TEST_F(RiscV32GZBVecEncodingTest, DestOperands) { + auto &getters = enc_->dest_op_getters(); + for (int i = *DestOpEnum::kNone; i < *DestOpEnum::kPastMaxValue; ++i) { + EXPECT_TRUE(getters.contains(i)) << "No dest operand for enum value " << i + << " (" << kDestOpNames[i] << ")"; + } +} + +TEST_F(RiscV32GZBVecEncodingTest, SimpleResources) { + auto &getters = enc_->simple_resource_getters(); + for (int i = *SimpleResourceEnum::kNone; + i < *SimpleResourceEnum::kPastMaxValue; ++i) { + EXPECT_TRUE(getters.contains(i)) << "No source operand for enum value " << i + << " (" << kSimpleResourceNames[i] << ")"; + } +} + +TEST_F(RiscV32GZBVecEncodingTest, ComplexResources) { + auto &getters = enc_->source_op_getters(); + for (int i = *ComplexResourceEnum::kNone; + i < *ComplexResourceEnum::kPastMaxValue; ++i) { + EXPECT_TRUE(getters.contains(i)) << "No source operand for enum value " << i + << " (" << kComplexResourceNames[i] << ")"; + } +} + +} // namespace
diff --git a/riscv/test/riscv64g_encoding_test.cc b/riscv/test/riscv64g_encoding_test.cc index dff3792..eedefa7 100644 --- a/riscv/test/riscv64g_encoding_test.cc +++ b/riscv/test/riscv64g_encoding_test.cc
@@ -17,15 +17,26 @@ #include <cstdint> #include "googlemock/include/gmock/gmock.h" +#include "mpact/sim/generic/type_helpers.h" #include "mpact/sim/util/memory/flat_demand_memory.h" #include "riscv/riscv64g_enums.h" #include "riscv/riscv_state.h" namespace { +using ::mpact::sim::generic::operator*; // NOLINT: clang-tidy false positive. + using mpact::sim::riscv::RiscVState; using mpact::sim::riscv::RiscVXlen; +using mpact::sim::riscv::isa64::ComplexResourceEnum; +using mpact::sim::riscv::isa64::DestOpEnum; +using mpact::sim::riscv::isa64::kComplexResourceNames; +using mpact::sim::riscv::isa64::kDestOpNames; +using mpact::sim::riscv::isa64::kSimpleResourceNames; +using mpact::sim::riscv::isa64::kSourceOpNames; using mpact::sim::riscv::isa64::RiscV64GEncoding; +using mpact::sim::riscv::isa64::SimpleResourceEnum; +using mpact::sim::riscv::isa64::SourceOpEnum; using mpact::sim::util::FlatDemandMemory; using SlotEnum = mpact::sim::riscv::isa64::SlotEnum; using OpcodeEnum = mpact::sim::riscv::isa64::OpcodeEnum; @@ -260,6 +271,40 @@ return (iword | ((val & 0x1f) << 2)); } +TEST_F(RiscV64GEncodingTest, SourceOperands) { + auto &getters = enc_->source_op_getters(); + for (int i = *SourceOpEnum::kNone; i < *SourceOpEnum::kPastMaxValue; ++i) { + EXPECT_TRUE(getters.contains(i)) << "No source operand for enum value " << i + << " (" << kSourceOpNames[i] << ")"; + } +} + +TEST_F(RiscV64GEncodingTest, DestOperands) { + auto &getters = enc_->dest_op_getters(); + for (int i = *DestOpEnum::kNone; i < *DestOpEnum::kPastMaxValue; ++i) { + EXPECT_TRUE(getters.contains(i)) << "No dest operand for enum value " << i + << " (" << kDestOpNames[i] << ")"; + } +} + +TEST_F(RiscV64GEncodingTest, SimpleResources) { + auto &getters = enc_->simple_resource_getters(); + for (int i = *SimpleResourceEnum::kNone; + i < *SimpleResourceEnum::kPastMaxValue; ++i) { + EXPECT_TRUE(getters.contains(i)) << "No source operand for enum value " << i + << " (" << kSimpleResourceNames[i] << ")"; + } +} + +TEST_F(RiscV64GEncodingTest, ComplexResources) { + auto &getters = enc_->source_op_getters(); + for (int i = *ComplexResourceEnum::kNone; + i < *ComplexResourceEnum::kPastMaxValue; ++i) { + EXPECT_TRUE(getters.contains(i)) << "No source operand for enum value " << i + << " (" << kComplexResourceNames[i] << ")"; + } +} + TEST_F(RiscV64GEncodingTest, RV64IOpcodes) { enc_->ParseInstruction(SetRd(kLui, kRdValue)); EXPECT_EQ(enc_->GetOpcode(SlotEnum::kRiscv64g, 0), OpcodeEnum::kLui);
diff --git a/riscv/test/riscv64g_vec_encoding_test.cc b/riscv/test/riscv64g_vec_encoding_test.cc new file mode 100644 index 0000000..1af43a0 --- /dev/null +++ b/riscv/test/riscv64g_vec_encoding_test.cc
@@ -0,0 +1,95 @@ +// Copyright 2024 Google LLC +// +// 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 +// +// https://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 "riscv/riscv64g_vec_encoding.h" + +#include "googlemock/include/gmock/gmock.h" +#include "mpact/sim/generic/type_helpers.h" +#include "mpact/sim/util/memory/flat_demand_memory.h" +#include "riscv/riscv64gv_enums.h" +#include "riscv/riscv_state.h" + +// This file contains tests for the RiscV64GZBEncoding class to ensure that +// the instruction decoding is correct. + +namespace { + +using ::mpact::sim::generic::operator*; // NOLINT: clang-tidy false positive. + +using mpact::sim::riscv::RiscVState; +using mpact::sim::riscv::RiscVXlen; +using mpact::sim::riscv::isa64v::ComplexResourceEnum; +using mpact::sim::riscv::isa64v::DestOpEnum; +using mpact::sim::riscv::isa64v::kComplexResourceNames; +using mpact::sim::riscv::isa64v::kDestOpNames; +using mpact::sim::riscv::isa64v::kSimpleResourceNames; +using mpact::sim::riscv::isa64v::kSourceOpNames; +using mpact::sim::riscv::isa64v::RiscV64GVecEncoding; +using mpact::sim::riscv::isa64v::SimpleResourceEnum; +using mpact::sim::riscv::isa64v::SourceOpEnum; +using mpact::sim::util::FlatDemandMemory; +using SlotEnum = mpact::sim::riscv::isa64v::SlotEnum; +using OpcodeEnum = mpact::sim::riscv::isa64v::OpcodeEnum; + +class RiscV64GVecEncodingTest : public testing::Test { + protected: + RiscV64GVecEncodingTest() { + state_ = new RiscVState("test", RiscVXlen::RV64, &memory_); + enc_ = new RiscV64GVecEncoding(state_); + } + ~RiscV64GVecEncodingTest() override { + delete enc_; + delete state_; + } + + FlatDemandMemory memory_; + RiscVState *state_; + RiscV64GVecEncoding *enc_; +}; + +TEST_F(RiscV64GVecEncodingTest, SourceOperands) { + auto &getters = enc_->source_op_getters(); + for (int i = *SourceOpEnum::kNone; i < *SourceOpEnum::kPastMaxValue; ++i) { + EXPECT_TRUE(getters.contains(i)) << "No source operand for enum value " << i + << " (" << kSourceOpNames[i] << ")"; + } +} + +TEST_F(RiscV64GVecEncodingTest, DestOperands) { + auto &getters = enc_->dest_op_getters(); + for (int i = *DestOpEnum::kNone; i < *DestOpEnum::kPastMaxValue; ++i) { + EXPECT_TRUE(getters.contains(i)) << "No dest operand for enum value " << i + << " (" << kDestOpNames[i] << ")"; + } +} + +TEST_F(RiscV64GVecEncodingTest, SimpleResources) { + auto &getters = enc_->simple_resource_getters(); + for (int i = *SimpleResourceEnum::kNone; + i < *SimpleResourceEnum::kPastMaxValue; ++i) { + EXPECT_TRUE(getters.contains(i)) << "No source operand for enum value " << i + << " (" << kSimpleResourceNames[i] << ")"; + } +} + +TEST_F(RiscV64GVecEncodingTest, ComplexResources) { + auto &getters = enc_->source_op_getters(); + for (int i = *ComplexResourceEnum::kNone; + i < *ComplexResourceEnum::kPastMaxValue; ++i) { + EXPECT_TRUE(getters.contains(i)) << "No source operand for enum value " << i + << " (" << kComplexResourceNames[i] << ")"; + } +} + +} // namespace
diff --git a/riscv/test/riscv64gzb_encoding_test.cc b/riscv/test/riscv64gzb_encoding_test.cc new file mode 100644 index 0000000..fd29d6e --- /dev/null +++ b/riscv/test/riscv64gzb_encoding_test.cc
@@ -0,0 +1,95 @@ +// Copyright 2024 Google LLC +// +// 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 +// +// https://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 "riscv/riscv64gzb_encoding.h" + +#include "googlemock/include/gmock/gmock.h" +#include "mpact/sim/generic/type_helpers.h" +#include "mpact/sim/util/memory/flat_demand_memory.h" +#include "riscv/riscv64gzb_enums.h" +#include "riscv/riscv_state.h" + +// This file contains tests for the RiscV64GZBEncoding class to ensure that +// the instruction decoding is correct. + +namespace { + +using ::mpact::sim::generic::operator*; // NOLINT: clang-tidy false positive. + +using mpact::sim::riscv::RiscVState; +using mpact::sim::riscv::RiscVXlen; +using mpact::sim::riscv::isa64gzb::ComplexResourceEnum; +using mpact::sim::riscv::isa64gzb::DestOpEnum; +using mpact::sim::riscv::isa64gzb::kComplexResourceNames; +using mpact::sim::riscv::isa64gzb::kDestOpNames; +using mpact::sim::riscv::isa64gzb::kSimpleResourceNames; +using mpact::sim::riscv::isa64gzb::kSourceOpNames; +using mpact::sim::riscv::isa64gzb::RiscV64GZBEncoding; +using mpact::sim::riscv::isa64gzb::SimpleResourceEnum; +using mpact::sim::riscv::isa64gzb::SourceOpEnum; +using mpact::sim::util::FlatDemandMemory; +using SlotEnum = mpact::sim::riscv::isa64gzb::SlotEnum; +using OpcodeEnum = mpact::sim::riscv::isa64gzb::OpcodeEnum; + +class RiscV64GZBEncodingTest : public testing::Test { + protected: + RiscV64GZBEncodingTest() { + state_ = new RiscVState("test", RiscVXlen::RV32, &memory_); + enc_ = new RiscV64GZBEncoding(state_); + } + ~RiscV64GZBEncodingTest() override { + delete enc_; + delete state_; + } + + FlatDemandMemory memory_; + RiscVState *state_; + RiscV64GZBEncoding *enc_; +}; + +TEST_F(RiscV64GZBEncodingTest, SourceOperands) { + auto &getters = enc_->source_op_getters(); + for (int i = *SourceOpEnum::kNone; i < *SourceOpEnum::kPastMaxValue; ++i) { + EXPECT_TRUE(getters.contains(i)) << "No source operand for enum value " << i + << " (" << kSourceOpNames[i] << ")"; + } +} + +TEST_F(RiscV64GZBEncodingTest, DestOperands) { + auto &getters = enc_->dest_op_getters(); + for (int i = *DestOpEnum::kNone; i < *DestOpEnum::kPastMaxValue; ++i) { + EXPECT_TRUE(getters.contains(i)) << "No dest operand for enum value " << i + << " (" << kDestOpNames[i] << ")"; + } +} + +TEST_F(RiscV64GZBEncodingTest, SimpleResources) { + auto &getters = enc_->simple_resource_getters(); + for (int i = *SimpleResourceEnum::kNone; + i < *SimpleResourceEnum::kPastMaxValue; ++i) { + EXPECT_TRUE(getters.contains(i)) << "No source operand for enum value " << i + << " (" << kSimpleResourceNames[i] << ")"; + } +} + +TEST_F(RiscV64GZBEncodingTest, ComplexResources) { + auto &getters = enc_->source_op_getters(); + for (int i = *ComplexResourceEnum::kNone; + i < *ComplexResourceEnum::kPastMaxValue; ++i) { + EXPECT_TRUE(getters.contains(i)) << "No source operand for enum value " << i + << " (" << kComplexResourceNames[i] << ")"; + } +} + +} // namespace
diff --git a/riscv/test/riscv64gzb_vec_encoding_test.cc b/riscv/test/riscv64gzb_vec_encoding_test.cc new file mode 100644 index 0000000..fa801c1 --- /dev/null +++ b/riscv/test/riscv64gzb_vec_encoding_test.cc
@@ -0,0 +1,95 @@ +// Copyright 2024 Google LLC +// +// 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 +// +// https://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 "riscv/riscv64gzb_vec_encoding.h" + +#include "googlemock/include/gmock/gmock.h" +#include "mpact/sim/generic/type_helpers.h" +#include "mpact/sim/util/memory/flat_demand_memory.h" +#include "riscv/riscv64gvzb_enums.h" +#include "riscv/riscv_state.h" + +// This file contains tests for the RiscV64GZBVecEncoding class to ensure that +// the instruction decoding is correct. + +namespace { + +using ::mpact::sim::generic::operator*; // NOLINT: clang-tidy false positive. + +using mpact::sim::riscv::RiscVState; +using mpact::sim::riscv::RiscVXlen; +using mpact::sim::riscv::isa64gvzb::ComplexResourceEnum; +using mpact::sim::riscv::isa64gvzb::DestOpEnum; +using mpact::sim::riscv::isa64gvzb::kComplexResourceNames; +using mpact::sim::riscv::isa64gvzb::kDestOpNames; +using mpact::sim::riscv::isa64gvzb::kSimpleResourceNames; +using mpact::sim::riscv::isa64gvzb::kSourceOpNames; +using mpact::sim::riscv::isa64gvzb::RiscV64GZBVecEncoding; +using mpact::sim::riscv::isa64gvzb::SimpleResourceEnum; +using mpact::sim::riscv::isa64gvzb::SourceOpEnum; +using mpact::sim::util::FlatDemandMemory; +using SlotEnum = mpact::sim::riscv::isa64gvzb::SlotEnum; +using OpcodeEnum = mpact::sim::riscv::isa64gvzb::OpcodeEnum; + +class RiscV64GZBVecEncodingTest : public testing::Test { + protected: + RiscV64GZBVecEncodingTest() { + state_ = new RiscVState("test", RiscVXlen::RV64, &memory_); + enc_ = new RiscV64GZBVecEncoding(state_); + } + ~RiscV64GZBVecEncodingTest() override { + delete enc_; + delete state_; + } + + FlatDemandMemory memory_; + RiscVState *state_; + RiscV64GZBVecEncoding *enc_; +}; + +TEST_F(RiscV64GZBVecEncodingTest, SourceOperands) { + auto &getters = enc_->source_op_getters(); + for (int i = *SourceOpEnum::kNone; i < *SourceOpEnum::kPastMaxValue; ++i) { + EXPECT_TRUE(getters.contains(i)) << "No source operand for enum value " << i + << " (" << kSourceOpNames[i] << ")"; + } +} + +TEST_F(RiscV64GZBVecEncodingTest, DestOperands) { + auto &getters = enc_->dest_op_getters(); + for (int i = *DestOpEnum::kNone; i < *DestOpEnum::kPastMaxValue; ++i) { + EXPECT_TRUE(getters.contains(i)) << "No dest operand for enum value " << i + << " (" << kDestOpNames[i] << ")"; + } +} + +TEST_F(RiscV64GZBVecEncodingTest, SimpleResources) { + auto &getters = enc_->simple_resource_getters(); + for (int i = *SimpleResourceEnum::kNone; + i < *SimpleResourceEnum::kPastMaxValue; ++i) { + EXPECT_TRUE(getters.contains(i)) << "No source operand for enum value " << i + << " (" << kSimpleResourceNames[i] << ")"; + } +} + +TEST_F(RiscV64GZBVecEncodingTest, ComplexResources) { + auto &getters = enc_->source_op_getters(); + for (int i = *ComplexResourceEnum::kNone; + i < *ComplexResourceEnum::kPastMaxValue; ++i) { + EXPECT_TRUE(getters.contains(i)) << "No source operand for enum value " << i + << " (" << kComplexResourceNames[i] << ")"; + } +} + +} // namespace
diff --git a/riscv/test/riscv_fp_test_base.h b/riscv/test/riscv_fp_test_base.h index caec811..fc653da 100644 --- a/riscv/test/riscv_fp_test_base.h +++ b/riscv/test/riscv_fp_test_base.h
@@ -372,8 +372,6 @@ for (auto &[reg_name, value] : values) { typename RegisterType::ValueType reg_value = NaNBox<T, typename RegisterType::ValueType>(value); - LOG(INFO) << "Setting " << reg_name << " to " << std::hex << reg_value - << " from: " << value; auto *reg = state_->GetRegister<RegisterType>(reg_name).first; auto *db = state_->db_factory()->Allocate<typename RegisterType::ValueType>(1); @@ -651,16 +649,6 @@ ScopedFPStatus set_fpstatus(rv_fp_->host_fp_interface()); std::tie(op_val, flag) = operation(lhs_span[i], rhs_span[i]); } - if (name == "fmin") { - LOG(INFO) << "L: " << lhs_span[i] << " R: " << rhs_span[i]; - LHS lhs_val = state_->GetRegister<LhsRegisterType>(kR1Name) - .first->data_buffer() - ->template Get<LHS>(0); - RHS rhs_val = state_->GetRegister<RhsRegisterType>(kR2Name) - .first->data_buffer() - ->template Get<RHS>(0); - LOG(INFO) << "Lreg: " << lhs_val << " Rreg: " << rhs_val; - } auto reg_val = state_->GetRegister<DestRegisterType>(kRdName) .first->data_buffer() ->template Get<R>(0);