| // 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. |
| |
| // This file adds operand getters for the Zc* extensions. |
| |
| #ifndef THIRD_PARTY_MPACT_RISCV_RISCV_ZC_GETTERS_H_ |
| #define THIRD_PARTY_MPACT_RISCV_RISCV_ZC_GETTERS_H_ |
| |
| #include <cstdint> |
| #include <vector> |
| |
| #include "absl/strings/str_cat.h" |
| #include "mpact/sim/generic/immediate_operand.h" |
| #include "mpact/sim/generic/literal_operand.h" |
| #include "mpact/sim/generic/operand_interface.h" |
| #include "mpact/sim/generic/resource_operand_interface.h" |
| #include "riscv/riscv_encoding_common.h" |
| #include "riscv/riscv_getter_helpers.h" |
| #include "riscv/riscv_register_aliases.h" |
| #include "riscv/riscv_state.h" |
| |
| namespace mpact::sim::riscv { |
| using ::mpact::sim::generic::DestinationOperandInterface; |
| using ::mpact::sim::generic::ImmediateOperand; |
| using ::mpact::sim::generic::IntLiteralOperand; |
| using ::mpact::sim::generic::ResourceOperandInterface; |
| using ::mpact::sim::generic::SourceOperandInterface; |
| |
| using SourceOpIf = SourceOperandInterface; |
| |
| // The following function adds source operand getters to the given getter map. |
| // The function uses the template parameters to get the correct enum type |
| // for the instruction set being decoded. The Extractors parameter is used to |
| // get the correct instruction format extractor for the instruction set. The |
| // IntRegister and FpRegister parameters are used to get the correct register |
| // types for the instruction set. |
| |
| // Getters for Zca source operands. |
| |
| template <typename Enum, typename Extractors, typename IntRegister, |
| typename FpRegister> |
| void AddRiscVZcaSourceGetters(SourceOpGetterMap &getter_map, |
| RiscVEncodingCommon *common) { |
| Insert(getter_map, *Enum::kC3rs1, [common]() { |
| auto num = Extractors::CS::ExtractCsRs1(common->inst_word()); |
| return GetRegisterSourceOp<IntRegister>( |
| common->state(), absl::StrCat(RiscVState::kXregPrefix, num), |
| kXRegisterAliases[num]); |
| }); |
| Insert(getter_map, *Enum::kC3rs2, [common]() { |
| auto num = Extractors::CS::ExtractCsRs2(common->inst_word()); |
| return GetRegisterSourceOp<IntRegister>( |
| common->state(), absl::StrCat(RiscVState::kXregPrefix, num), |
| kXRegisterAliases[num]); |
| }); |
| Insert(getter_map, *Enum::kCrd, [common]() { |
| auto num = Extractors::CR::ExtractRd(common->inst_word()); |
| return GetRegisterSourceOp<IntRegister>( |
| common->state(), absl::StrCat(RiscVState::kXregPrefix, num), |
| kXRegisterAliases[num]); |
| }); |
| Insert(getter_map, *Enum::kCrs1, [common]() { |
| auto num = Extractors::CR::ExtractRs1(common->inst_word()); |
| return GetRegisterSourceOp<IntRegister>( |
| common->state(), absl::StrCat(RiscVState::kXregPrefix, num), |
| kXRegisterAliases[num]); |
| }); |
| Insert(getter_map, *Enum::kCrs2, [common]() { |
| auto num = Extractors::CR::ExtractRs2(common->inst_word()); |
| return GetRegisterSourceOp<IntRegister>( |
| common->state(), absl::StrCat(RiscVState::kXregPrefix, num), |
| kXRegisterAliases[num]); |
| }); |
| Insert(getter_map, *Enum::kICbImm8, [common]() { |
| return new ImmediateOperand<int32_t>( |
| Extractors::Inst16Format::ExtractBimm(common->inst_word())); |
| }); |
| Insert(getter_map, *Enum::kICiImm6, [common]() { |
| return new ImmediateOperand<int32_t>( |
| Extractors::CI::ExtractImm6(common->inst_word())); |
| }); |
| Insert(getter_map, *Enum::kICiImm6x16, [common]() { |
| return new generic::ImmediateOperand<int32_t>( |
| Extractors::Inst16Format::ExtractCiImm10(common->inst_word())); |
| }); |
| Insert(getter_map, *Enum::kICiUimm6, [common]() { |
| return new ImmediateOperand<uint32_t>( |
| Extractors::Inst16Format::ExtractUimm6(common->inst_word())); |
| }); |
| Insert(getter_map, *Enum::kICiUimm6x4, |
| [common]() -> SourceOperandInterface * { |
| return new ImmediateOperand<uint32_t>( |
| Extractors::Inst16Format::ExtractCiImmW(common->inst_word())); |
| }); |
| Insert(getter_map, *Enum::kICiwUimm8x4, [common]() { |
| return new ImmediateOperand<uint32_t>( |
| Extractors::Inst16Format::ExtractCiwImm10(common->inst_word())); |
| }); |
| Insert(getter_map, *Enum::kICjImm11, [common]() { |
| return new ImmediateOperand<int32_t>( |
| Extractors::Inst16Format::ExtractJimm(common->inst_word())); |
| }); |
| Insert(getter_map, *Enum::kIClUimm5x4, [common]() { |
| return new ImmediateOperand<uint32_t>( |
| Extractors::Inst16Format::ExtractClImmW(common->inst_word())); |
| }); |
| Insert(getter_map, *Enum::kICssUimm6x4, |
| [common]() -> SourceOperandInterface * { |
| return new ImmediateOperand<uint32_t>( |
| Extractors::Inst16Format::ExtractCssImmW(common->inst_word())); |
| }); |
| Insert(getter_map, *Enum::kX0, |
| []() { return new generic::IntLiteralOperand<0>({1}); }); |
| Insert(getter_map, *Enum::kX2, [common]() { |
| return GetRegisterSourceOp<IntRegister>( |
| common->state(), absl::StrCat(RiscVState::kXregPrefix, 2), |
| kXRegisterAliases[2]); |
| }); |
| } |
| |
| // Getters for Zca destination operands. |
| |
| template <typename Enum, typename Extractors, typename IntRegister, |
| typename FpRegister> |
| void AddRiscVZcaDestGetters(SourceOpGetterMap &getter_map, |
| RiscVEncodingCommon *common) { |
| Insert(getter_map, *Enum::kC3rd, [common](int latency) { |
| int num = Extractors::CL::ExtractClRd(common->inst_word()); |
| return GetRegisterDestinationOp<IntRegister>( |
| common->state(), absl::StrCat(RiscVState::kXregPrefix, num), latency); |
| }); |
| } |
| |
| // Getters for Zcb source operands (not covered in Zca). |
| |
| template <typename Enum, typename Extractors, typename IntRegister, |
| typename FpRegister> |
| void AddRiscVZcbSourceGetters(SourceOpGetterMap &getter_map, |
| RiscVEncodingCommon *common) { |
| Insert(getter_map, *Enum::kUimm2b, [common]() { |
| auto num = Extractors::CLB::ExtractUimm2(common->inst_word()); |
| return new ImmediateOperand<uint32_t>(num); |
| }); |
| Insert(getter_map, *Enum::kUimm2h, [common](int latency) { |
| auto num = Extractors::CLH::ExtractUimm2(common->inst_word()); |
| return new ImmediateOperand<uint32_t>(num); |
| }); |
| } |
| |
| // Getters for Zcb destination operands (not covered in Zca). |
| |
| template <typename Enum, typename Extractors, typename IntRegister, |
| typename FpRegister> |
| void AddRiscVZcbDestGetters(DestOpGetterMap &getter_map, |
| RiscVEncodingCommon *common) { |
| Insert(getter_map, *Enum::kC3rs2, [common](int latency) { |
| int num = Extractors::CLB::ExtractClRd(common->inst_word()); |
| return GetRegisterDestinationOp<IntRegister>( |
| common->state(), absl::StrCat(RiscVState::kXregPrefix, num), latency); |
| }); |
| } |
| |
| // Getters for Zcf source operands. |
| |
| template <typename Enum, typename Extractors, typename IntRegister, |
| typename FpRegister> |
| void AddRiscVZcfSourceGetters(SourceOpGetterMap &getter_map, |
| RiscVEncodingCommon *common) { |
| Insert(getter_map, *Enum::kC3frs2, [common]() { |
| auto num = Extractors::CS::ExtractCsRs2(common->inst_word()); |
| return GetRegisterSourceOp<FpRegister>( |
| common->state(), absl::StrCat(RiscVState::kFregPrefix, num), |
| kFRegisterAliases[num]); |
| }); |
| Insert(getter_map, *Enum::kC3rs1, [common]() { |
| auto num = Extractors::CS::ExtractCsRs1(common->inst_word()); |
| return GetRegisterSourceOp<IntRegister>( |
| common->state(), absl::StrCat(RiscVState::kXregPrefix, num), |
| kXRegisterAliases[num]); |
| }); |
| Insert(getter_map, *Enum::kCfrs2, [common]() { |
| auto num = Extractors::CR::ExtractRs2(common->inst_word()); |
| return GetRegisterSourceOp<FpRegister>( |
| common->state(), absl::StrCat(RiscVState::kFregPrefix, num), |
| kFRegisterAliases[num]); |
| }); |
| Insert(getter_map, *Enum::kICiUimm6x4, |
| [common]() -> SourceOperandInterface * { |
| return new ImmediateOperand<uint32_t>( |
| Extractors::Inst16Format::ExtractCiImmW(common->inst_word())); |
| }); |
| Insert(getter_map, *Enum::kIClUimm5x4, [common]() { |
| return new ImmediateOperand<uint32_t>( |
| Extractors::Inst16Format::ExtractClImmW(common->inst_word())); |
| }); |
| Insert(getter_map, *Enum::kICssUimm6x4, [common]() { |
| return new ImmediateOperand<uint32_t>( |
| Extractors::Inst16Format::ExtractCssImmW(common->inst_word())); |
| }); |
| Insert(getter_map, *Enum::kX2, [common]() { |
| return GetRegisterSourceOp<IntRegister>( |
| common->state(), absl::StrCat(RiscVState::kXregPrefix, 2), |
| kXRegisterAliases[2]); |
| }); |
| } |
| |
| // Getters for Zcf destination operands. |
| |
| template <typename Enum, typename Extractors, typename IntRegister, |
| typename FpRegister> |
| void AddRiscVZcfDestGetters(DestOpGetterMap &getter_map, |
| RiscVEncodingCommon *common) { |
| Insert(getter_map, *Enum::kC3frd, [common](int latency) { |
| int num = Extractors::CL::ExtractClRd(common->inst_word()); |
| return GetRegisterDestinationOp<FpRegister>( |
| common->state(), absl::StrCat(RiscVState::kFregPrefix, num), latency); |
| }); |
| } |
| |
| // Getters for Zcd source operands. |
| |
| template <typename Enum, typename Extractors, typename IntRegister, |
| typename FpRegister> |
| void AddRiscVZcdSourceGetters(SourceOpGetterMap &getter_map, |
| RiscVEncodingCommon *common) { |
| Insert(getter_map, *Enum::kC3drs2, [common]() { |
| auto num = Extractors::CS::ExtractCsRs2(common->inst_word()); |
| return GetRegisterSourceOp<FpRegister>( |
| common->state(), absl::StrCat(RiscVState::kFregPrefix, num), |
| kFRegisterAliases[num]); |
| }); |
| Insert(getter_map, *Enum::kC3rs1, [common]() { |
| auto num = Extractors::CS::ExtractCsRs1(common->inst_word()); |
| return GetRegisterSourceOp<IntRegister>( |
| common->state(), absl::StrCat(RiscVState::kXregPrefix, num), |
| kXRegisterAliases[num]); |
| }); |
| Insert(getter_map, *Enum::kCdrs2, [common]() { |
| auto num = Extractors::CR::ExtractRs2(common->inst_word()); |
| return GetRegisterSourceOp<FpRegister>( |
| common->state(), absl::StrCat(RiscVState::kFregPrefix, num), |
| kFRegisterAliases[num]); |
| }); |
| Insert(getter_map, *Enum::kICiUimm6x8, |
| [common]() -> SourceOperandInterface * { |
| return new ImmediateOperand<uint32_t>( |
| Extractors::Inst16Format::ExtractCiImmW(common->inst_word())); |
| }); |
| Insert(getter_map, *Enum::kIClUimm5x8, [common]() { |
| return new ImmediateOperand<uint32_t>( |
| Extractors::Inst16Format::ExtractClImmW(common->inst_word())); |
| }); |
| Insert(getter_map, *Enum::kICssUimm6x8, [common]() { |
| return new ImmediateOperand<uint32_t>( |
| Extractors::Inst16Format::ExtractCssImmW(common->inst_word())); |
| }); |
| Insert(getter_map, *Enum::kX2, [common]() { |
| return GetRegisterSourceOp<IntRegister>( |
| common->state(), absl::StrCat(RiscVState::kXregPrefix, 2), |
| kXRegisterAliases[2]); |
| }); |
| } |
| |
| // Getters for Zcd destination operands. |
| |
| template <typename Enum, typename Extractors, typename IntRegister, |
| typename FpRegister> |
| void AddRiscVZcdDestGetters(DestOpGetterMap &getter_map, |
| RiscVEncodingCommon *common) { |
| Insert(getter_map, *Enum::kC3drd, [common](int latency) { |
| int num = Extractors::CL::ExtractClRd(common->inst_word()); |
| return GetRegisterDestinationOp<IntRegister>( |
| common->state(), absl::StrCat(RiscVState::kFregPrefix, num), latency); |
| }); |
| } |
| |
| // The following table maps Zcmp Sreg alias register numbers to Xreg numbers. |
| constexpr int kSRegToXRegMap[8] = {8, 9, 18, 19, 20, 21, 22, 23}; |
| |
| // Getters for Zcmp source operands. |
| |
| template <typename Enum, typename Extractors, typename IntRegister, |
| typename FpRegister> |
| void AddRiscVZcmpSourceGetters(SourceOpGetterMap &getter_map, |
| RiscVEncodingCommon *common) { |
| Insert(getter_map, *Enum::kRlist, [common]() { |
| return new ImmediateOperand<uint32_t>( |
| Extractors::CMMP::ExtractRlist(common->inst_word())); |
| }); |
| Insert(getter_map, *Enum::kSpimm, [common]() { |
| return new ImmediateOperand<uint32_t>( |
| Extractors::CMMP::ExtractSpimm(common->inst_word())); |
| }); |
| Insert(getter_map, *Enum::kSreg1, [common]() { |
| int num = |
| kSRegToXRegMap[Extractors::CMMV::ExtractRs1p(common->inst_word())]; |
| return GetRegisterSourceOp<IntRegister>( |
| common->state(), absl::StrCat(RiscVState::kXregPrefix, num), |
| kXRegisterAliases[num]); |
| }); |
| Insert(getter_map, *Enum::kSreg2, [common]() { |
| int num = |
| kSRegToXRegMap[Extractors::CMMV::ExtractRs2p(common->inst_word())]; |
| return GetRegisterSourceOp<IntRegister>( |
| common->state(), absl::StrCat(RiscVState::kXregPrefix, num), |
| kXRegisterAliases[num]); |
| }); |
| Insert(getter_map, *Enum::kX2, [common]() { |
| return GetRegisterSourceOp<IntRegister>( |
| common->state(), absl::StrCat(RiscVState::kXregPrefix, 2), |
| kXRegisterAliases[2]); |
| }); |
| Insert(getter_map, *Enum::kX10, [common]() { |
| return GetRegisterSourceOp<IntRegister>( |
| common->state(), absl::StrCat(RiscVState::kXregPrefix, 10), |
| kXRegisterAliases[10]); |
| }); |
| Insert(getter_map, *Enum::kX11, [common]() { |
| return GetRegisterSourceOp<IntRegister>( |
| common->state(), absl::StrCat(RiscVState::kXregPrefix, 11), |
| kXRegisterAliases[11]); |
| }); |
| } |
| |
| // Getters for Zcmp destination operands. |
| |
| template <typename Enum, typename Extractors, typename IntRegister, |
| typename FpRegister> |
| void AddRiscVZcmpDestGetters(DestOpGetterMap &getter_map, |
| RiscVEncodingCommon *common) { |
| Insert(getter_map, *Enum::kSreg1, [common](int latency) { |
| int num = |
| kSRegToXRegMap[Extractors::CMMV::ExtractRs1p(common->inst_word())]; |
| return GetRegisterDestinationOp<IntRegister>( |
| common->state(), absl::StrCat(RiscVState::kXregPrefix, num), latency); |
| }); |
| Insert(getter_map, *Enum::kSreg2, [common](int latency) { |
| int num = |
| kSRegToXRegMap[Extractors::CMMV::ExtractRs2p(common->inst_word())]; |
| return GetRegisterDestinationOp<IntRegister>( |
| common->state(), absl::StrCat(RiscVState::kXregPrefix, num), latency); |
| }); |
| Insert(getter_map, *Enum::kX2, [common](int latency) { |
| return GetRegisterDestinationOp<IntRegister>( |
| common->state(), absl::StrCat(RiscVState::kXregPrefix, 2), latency); |
| }); |
| Insert(getter_map, *Enum::kX10, [common](int latency) { |
| return GetRegisterDestinationOp<IntRegister>( |
| common->state(), absl::StrCat(RiscVState::kXregPrefix, 10), latency); |
| }); |
| Insert(getter_map, *Enum::kX11, [common](int latency) { |
| return GetRegisterDestinationOp<IntRegister>( |
| common->state(), absl::StrCat(RiscVState::kXregPrefix, 11), latency); |
| }); |
| } |
| |
| // Getters for Zcmp list source operands. |
| |
| template <typename Enum, typename Extractors, typename IntRegister, |
| typename FpRegister> |
| void AddRiscVZcmpListSourceGetters(ListSourceOpGetterMap &getter_map, |
| RiscVEncodingCommon *common) { |
| Insert(getter_map, *Enum::kRlist, [common]() { |
| std::vector<SourceOperandInterface *> result; |
| int rlist = Extractors::CMMP::ExtractRlist(common->inst_word()); |
| // Get the value of 'rlist', and add source operands accordingly. |
| if (rlist < 4) return result; |
| result.push_back(GetRegisterSourceOp<IntRegister>(common->state(), "x1")); |
| if (rlist == 4) return result; |
| result.push_back(GetRegisterSourceOp<IntRegister>(common->state(), "x8")); |
| if (rlist == 5) return result; |
| result.push_back(GetRegisterSourceOp<IntRegister>(common->state(), "x9")); |
| if (rlist == 6) return result; |
| result.push_back(GetRegisterSourceOp<IntRegister>(common->state(), "x18")); |
| if (rlist == 7) return result; |
| result.push_back(GetRegisterSourceOp<IntRegister>(common->state(), "x19")); |
| if (rlist == 8) return result; |
| result.push_back(GetRegisterSourceOp<IntRegister>(common->state(), "x20")); |
| if (rlist == 9) return result; |
| result.push_back(GetRegisterSourceOp<IntRegister>(common->state(), "x21")); |
| if (rlist == 10) return result; |
| result.push_back(GetRegisterSourceOp<IntRegister>(common->state(), "x22")); |
| if (rlist == 11) return result; |
| result.push_back(GetRegisterSourceOp<IntRegister>(common->state(), "x23")); |
| if (rlist == 12) return result; |
| result.push_back(GetRegisterSourceOp<IntRegister>(common->state(), "x24")); |
| if (rlist == 13) return result; |
| result.push_back(GetRegisterSourceOp<IntRegister>(common->state(), "x25")); |
| if (rlist == 14) return result; |
| result.push_back(GetRegisterSourceOp<IntRegister>(common->state(), "x26")); |
| result.push_back(GetRegisterSourceOp<IntRegister>(common->state(), "x27")); |
| return result; |
| }); |
| } |
| |
| // Getters for Zcmp list destination operands. |
| |
| template <typename Enum, typename Extractors, typename IntRegister, |
| typename FpRegister> |
| void AddRiscVZcmpListDestGetters(ListDestOpGetterMap &getter_map, |
| RiscVEncodingCommon *common) { |
| Insert(getter_map, *Enum::kRlist, [common](std::vector<int> latency) { |
| std::vector<DestinationOperandInterface *> result; |
| int rlist = Extractors::CMMP::ExtractRlist(common->inst_word()); |
| // Get the value of 'rlist', and add destination operands accordingly. |
| int size = latency.size(); |
| if (rlist < 4) return result; |
| result.push_back(GetRegisterDestinationOp<IntRegister>( |
| common->state(), "x1", latency[result.size() % size])); |
| if (rlist == 4) return result; |
| result.push_back(GetRegisterDestinationOp<IntRegister>( |
| common->state(), "x8", latency[result.size() % size])); |
| if (rlist == 5) return result; |
| result.push_back(GetRegisterDestinationOp<IntRegister>( |
| common->state(), "x9", latency[result.size() % size])); |
| if (rlist == 6) return result; |
| result.push_back(GetRegisterDestinationOp<IntRegister>( |
| common->state(), "x18", latency[result.size() % size])); |
| if (rlist == 7) return result; |
| result.push_back(GetRegisterDestinationOp<IntRegister>( |
| common->state(), "x19", latency[result.size() % size])); |
| if (rlist == 8) return result; |
| result.push_back(GetRegisterDestinationOp<IntRegister>( |
| common->state(), "x20", latency[result.size() % size])); |
| if (rlist == 9) return result; |
| result.push_back(GetRegisterDestinationOp<IntRegister>( |
| common->state(), "x21", latency[result.size() % size])); |
| if (rlist == 10) return result; |
| result.push_back(GetRegisterDestinationOp<IntRegister>( |
| common->state(), "x22", latency[result.size() % size])); |
| if (rlist == 11) return result; |
| result.push_back(GetRegisterDestinationOp<IntRegister>( |
| common->state(), "x23", latency[result.size() % size])); |
| if (rlist == 12) return result; |
| result.push_back(GetRegisterDestinationOp<IntRegister>( |
| common->state(), "x24", latency[result.size() % size])); |
| if (rlist == 13) return result; |
| result.push_back(GetRegisterDestinationOp<IntRegister>( |
| common->state(), "x25", latency[result.size() % size])); |
| if (rlist == 14) return result; |
| result.push_back(GetRegisterDestinationOp<IntRegister>( |
| common->state(), "x26", latency[result.size() % size])); |
| result.push_back(GetRegisterDestinationOp<IntRegister>( |
| common->state(), "x27", latency[result.size() % size])); |
| return result; |
| }); |
| } |
| |
| template <typename Enum, typename Extractors, typename IntRegister, |
| typename FpRegister> |
| void AddRiscVZcmtSourceGetters(SourceOpGetterMap &getter_map, |
| RiscVEncodingCommon *common) { |
| Insert(getter_map, *Enum::kJtIndex, [common](int latency) { |
| int num = Extractors::CMJT::ExtractIndex(common->inst_word()); |
| return new ImmediateOperand<uint32_t>(num); |
| }); |
| } |
| |
| } // namespace mpact::sim::riscv |
| |
| #endif // THIRD_PARTY_MPACT_RISCV_RISCV_ZC_GETTERS_H_ |
