| // 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 |
| // |
| // 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 "cheriot/riscv_cheriot_encoding.h" |
| |
| #include <cstdint> |
| #include <string> |
| |
| #include "absl/log/log.h" |
| #include "absl/strings/str_cat.h" |
| #include "cheriot/cheriot_register.h" |
| #include "cheriot/cheriot_state.h" |
| #include "cheriot/riscv_cheriot_bin_decoder.h" |
| #include "cheriot/riscv_cheriot_decoder.h" |
| #include "cheriot/riscv_cheriot_enums.h" |
| #include "cheriot/riscv_cheriot_register_aliases.h" |
| #include "mpact/sim/generic/immediate_operand.h" |
| #include "mpact/sim/generic/literal_operand.h" |
| #include "mpact/sim/generic/type_helpers.h" |
| #include "riscv//riscv_register.h" |
| |
| namespace mpact { |
| namespace sim { |
| namespace cheriot { |
| namespace isa32 { |
| |
| using ::mpact::sim::generic::operator*; // NOLINT: is used below (clang error). |
| using ::mpact::sim::riscv::RVFpRegister; |
| |
| // Generic helper functions to create register operands. |
| template <typename RegType> |
| inline DestinationOperandInterface *GetRegisterDestinationOp( |
| CheriotState *state, std::string name, int latency) { |
| auto *reg = state->GetRegister<RegType>(name).first; |
| return reg->CreateDestinationOperand(latency); |
| } |
| |
| template <typename RegType> |
| inline DestinationOperandInterface *GetRegisterDestinationOp( |
| CheriotState *state, std::string name, int latency, std::string op_name) { |
| auto *reg = state->GetRegister<RegType>(name).first; |
| return reg->CreateDestinationOperand(latency, op_name); |
| } |
| |
| template <typename T> |
| inline DestinationOperandInterface *GetCSRSetBitsDestinationOp( |
| CheriotState *state, std::string name, int latency, std::string op_name) { |
| auto result = state->csr_set()->GetCsr(name); |
| if (!result.ok()) { |
| LOG(ERROR) << "No such CSR '" << name << "'"; |
| return nullptr; |
| } |
| auto *csr = result.value(); |
| auto *op = csr->CreateSetDestinationOperand(latency, op_name); |
| return op; |
| } |
| |
| template <typename RegType> |
| inline SourceOperandInterface *GetRegisterSourceOp(CheriotState *state, |
| std::string name) { |
| auto *reg = state->GetRegister<RegType>(name).first; |
| auto *op = reg->CreateSourceOperand(); |
| return op; |
| } |
| |
| template <typename RegType> |
| inline SourceOperandInterface *GetRegisterSourceOp(CheriotState *state, |
| std::string name, |
| std::string op_name) { |
| auto *reg = state->GetRegister<RegType>(name).first; |
| auto *op = reg->CreateSourceOperand(op_name); |
| return op; |
| } |
| |
| RiscVCheriotEncoding::RiscVCheriotEncoding(CheriotState *state) |
| : state_(state) { |
| InitializeSourceOperandGetters(); |
| InitializeDestinationOperandGetters(); |
| } |
| |
| void RiscVCheriotEncoding::InitializeSourceOperandGetters() { |
| // Source operand getters. |
| source_op_getters_.emplace( |
| *SourceOpEnum::kAAq, [this]() -> SourceOperandInterface * { |
| if (encoding::inst32_format::ExtractAq(inst_word_)) { |
| return new generic::IntLiteralOperand<1>(); |
| } |
| return new generic::IntLiteralOperand<0>(); |
| }); |
| source_op_getters_.emplace( |
| *SourceOpEnum::kARl, [this]() -> SourceOperandInterface * { |
| if (encoding::inst32_format::ExtractRl(inst_word_)) { |
| return new generic::IntLiteralOperand<1>(); |
| } |
| return new generic::IntLiteralOperand<0>(); |
| }); |
| source_op_getters_.emplace(*SourceOpEnum::kBImm12, [this]() { |
| return new generic::ImmediateOperand<int32_t>( |
| encoding::inst32_format::ExtractBImm(inst_word_)); |
| }); |
| source_op_getters_.emplace(*SourceOpEnum::kC2, [this]() { |
| return GetRegisterSourceOp<CheriotRegister>(state_, "c2", "csp"); |
| }); |
| source_op_getters_.emplace(*SourceOpEnum::kC3cs1, [this]() { |
| auto num = encoding::c_s::ExtractRs1(inst_word_); |
| return GetRegisterSourceOp<CheriotRegister>( |
| state_, absl::StrCat(CheriotState::kCregPrefix, num), |
| kCRegisterAliases[num]); |
| }); |
| source_op_getters_.emplace(*SourceOpEnum::kC3cs2, [this]() { |
| auto num = encoding::c_s::ExtractRs2(inst_word_); |
| return GetRegisterSourceOp<CheriotRegister>( |
| state_, absl::StrCat(CheriotState::kCregPrefix, num), |
| kCRegisterAliases[num]); |
| }); |
| source_op_getters_.emplace(*SourceOpEnum::kC3rs1, [this]() { |
| auto num = encoding::c_s::ExtractRs1(inst_word_); |
| return GetRegisterSourceOp<CheriotRegister>( |
| state_, absl::StrCat(CheriotState::kXregPrefix, num), |
| kXRegisterAliases[num]); |
| }); |
| source_op_getters_.emplace(*SourceOpEnum::kC3rs2, [this]() { |
| auto num = encoding::c_s::ExtractRs2(inst_word_); |
| return GetRegisterSourceOp<CheriotRegister>( |
| state_, absl::StrCat(CheriotState::kXregPrefix, num), |
| kXRegisterAliases[num]); |
| }); |
| source_op_getters_.emplace(*SourceOpEnum::kCcs2, [this]() { |
| auto num = encoding::c_s_s::ExtractRs2(inst_word_); |
| return GetRegisterSourceOp<CheriotRegister>( |
| state_, absl::StrCat(CheriotState::kCregPrefix, num), |
| kCRegisterAliases[num]); |
| }); |
| source_op_getters_.emplace(*SourceOpEnum::kCgp, [this]() { |
| return GetRegisterSourceOp<CheriotRegister>(state_, "c3", "c3"); |
| }); |
| source_op_getters_.emplace(*SourceOpEnum::kCSRUimm5, [this]() { |
| return new generic::ImmediateOperand<uint32_t>( |
| encoding::inst32_format::ExtractIUimm5(inst_word_)); |
| }); |
| source_op_getters_.emplace(*SourceOpEnum::kCfrs2, [this]() { |
| auto num = encoding::c_r::ExtractRs2(inst_word_); |
| return GetRegisterSourceOp<RVFpRegister>( |
| state_, absl::StrCat(CheriotState::kFregPrefix, num), |
| kFRegisterAliases[num]); |
| }); |
| source_op_getters_.emplace(*SourceOpEnum::kCrs1, [this]() { |
| auto num = encoding::c_r::ExtractRs1(inst_word_); |
| return GetRegisterSourceOp<CheriotRegister>( |
| state_, absl::StrCat(CheriotState::kXregPrefix, num), |
| kXRegisterAliases[num]); |
| }); |
| source_op_getters_.emplace(*SourceOpEnum::kCrs2, [this]() { |
| auto num = encoding::c_r::ExtractRs2(inst_word_); |
| return GetRegisterSourceOp<CheriotRegister>( |
| state_, absl::StrCat(CheriotState::kXregPrefix, num), |
| kXRegisterAliases[num]); |
| }); |
| source_op_getters_.emplace(*SourceOpEnum::kCs1, [this]() { |
| auto num = encoding::r_type::ExtractRs1(inst_word_); |
| return GetRegisterSourceOp<CheriotRegister>( |
| state_, absl::StrCat(CheriotState::kCregPrefix, num), |
| kCRegisterAliases[num]); |
| }); |
| source_op_getters_.emplace(*SourceOpEnum::kCs2, [this]() { |
| auto num = encoding::r_type::ExtractRs2(inst_word_); |
| return GetRegisterSourceOp<CheriotRegister>( |
| state_, absl::StrCat(CheriotState::kCregPrefix, num), |
| kCRegisterAliases[num]); |
| }); |
| source_op_getters_.emplace(*SourceOpEnum::kCsr, [this]() { |
| auto csr_indx = encoding::i_type::ExtractUImm12(inst_word_); |
| auto res = state_->csr_set()->GetCsr(csr_indx); |
| if (!res.ok()) { |
| return new generic::ImmediateOperand<uint32_t>(csr_indx); |
| } |
| auto *csr = res.value(); |
| return new generic::ImmediateOperand<uint32_t>(csr_indx, csr->name()); |
| }); |
| /* |
| source_op_getters_.emplace(*SourceOpEnum::kFrs1, [this]() { |
| int num = encoding::r_type::ExtractRs1(inst_word_); |
| return GetRegisterSourceOp<RVFpRegister>( |
| state_, absl::StrCat(CheriotState::kFregPrefix, num), |
| kFRegisterAliases[num]); |
| }); |
| source_op_getters_.emplace(*SourceOpEnum::kFrs2, [this]() { |
| int num = encoding::r_type::ExtractRs2(inst_word_); |
| return GetRegisterSourceOp<RVFpRegister>( |
| state_, absl::StrCat(CheriotState::kFregPrefix, num), |
| kFRegisterAliases[num]); |
| }); |
| source_op_getters_.emplace(*SourceOpEnum::kFrs3, [this]() { |
| int num = encoding::r4_type::ExtractRs3(inst_word_); |
| return GetRegisterSourceOp<RVFpRegister>( |
| state_, absl::StrCat(CheriotState::kFregPrefix, num), |
| kFRegisterAliases[num]); |
| }); |
| */ |
| source_op_getters_.emplace(*SourceOpEnum::kICbImm8, [this]() { |
| return new generic::ImmediateOperand<int32_t>( |
| encoding::inst16_format::ExtractBimm(inst_word_)); |
| }); |
| source_op_getters_.emplace(*SourceOpEnum::kICiImm6, [this]() { |
| return new generic::ImmediateOperand<int32_t>( |
| encoding::c_i::ExtractImm6(inst_word_)); |
| }); |
| source_op_getters_.emplace(*SourceOpEnum::kICiImm612, [this]() { |
| return new generic::ImmediateOperand<int32_t>( |
| encoding::inst16_format::ExtractImm18(inst_word_)); |
| }); |
| source_op_getters_.emplace(*SourceOpEnum::kICiUimm6, [this]() { |
| return new generic::ImmediateOperand<uint32_t>( |
| encoding::inst16_format::ExtractUimm6(inst_word_)); |
| }); |
| source_op_getters_.emplace(*SourceOpEnum::kICiUimm6x4, [this]() { |
| return new generic::ImmediateOperand<uint32_t>( |
| encoding::inst16_format::ExtractCiImmW(inst_word_)); |
| }); |
| source_op_getters_.emplace(*SourceOpEnum::kICiImm6x16, [this]() { |
| return new generic::ImmediateOperand<int32_t>( |
| encoding::inst16_format::ExtractCiImm10(inst_word_)); |
| }); |
| source_op_getters_.emplace(*SourceOpEnum::kICiUimm6x8, [this]() { |
| return new generic::ImmediateOperand<uint32_t>( |
| encoding::inst16_format::ExtractCiImmD(inst_word_)); |
| }); |
| source_op_getters_.emplace(*SourceOpEnum::kICiwUimm8x4, [this]() { |
| return new generic::ImmediateOperand<uint32_t>( |
| encoding::inst16_format::ExtractCiwImm10(inst_word_)); |
| }); |
| source_op_getters_.emplace(*SourceOpEnum::kICjImm11, [this]() { |
| return new generic::ImmediateOperand<int32_t>( |
| encoding::inst16_format::ExtractJimm(inst_word_)); |
| }); |
| source_op_getters_.emplace(*SourceOpEnum::kIClUimm5x4, [this]() { |
| return new generic::ImmediateOperand<uint32_t>( |
| encoding::inst16_format::ExtractClImmW(inst_word_)); |
| }); |
| source_op_getters_.emplace(*SourceOpEnum::kIClUimm5x8, [this]() { |
| return new generic::ImmediateOperand<uint32_t>( |
| encoding::inst16_format::ExtractClImmD(inst_word_)); |
| }); |
| source_op_getters_.emplace(*SourceOpEnum::kICshUimm6, [this]() { |
| return new generic::ImmediateOperand<uint32_t>( |
| encoding::c_s_h::ExtractUimm6(inst_word_)); |
| }); |
| source_op_getters_.emplace(*SourceOpEnum::kICshImm6, [this]() { |
| return new generic::ImmediateOperand<uint32_t>( |
| encoding::c_s_h::ExtractImm6(inst_word_)); |
| }); |
| source_op_getters_.emplace(*SourceOpEnum::kICssUimm6x4, [this]() { |
| return new generic::ImmediateOperand<uint32_t>( |
| encoding::inst16_format::ExtractCssImmW(inst_word_)); |
| }); |
| source_op_getters_.emplace(*SourceOpEnum::kICssUimm6x8, [this]() { |
| return new generic::ImmediateOperand<uint32_t>( |
| encoding::inst16_format::ExtractCssImmD(inst_word_)); |
| }); |
| source_op_getters_.emplace(*SourceOpEnum::kIImm12, [this]() { |
| return new generic::ImmediateOperand<int32_t>( |
| encoding::inst32_format::ExtractImm12(inst_word_)); |
| }); |
| source_op_getters_.emplace(*SourceOpEnum::kIUimm5, [this]() { |
| return new generic::ImmediateOperand<uint32_t>( |
| encoding::i5_type::ExtractRUimm5(inst_word_)); |
| }); |
| source_op_getters_.emplace(*SourceOpEnum::kIUimm12, [this]() { |
| return new generic::ImmediateOperand<uint32_t>( |
| encoding::inst32_format::ExtractUImm12(inst_word_)); |
| }); |
| source_op_getters_.emplace(*SourceOpEnum::kJImm12, [this]() { |
| return new generic::ImmediateOperand<int32_t>( |
| encoding::inst32_format::ExtractImm12(inst_word_)); |
| }); |
| source_op_getters_.emplace(*SourceOpEnum::kJImm20, [this]() { |
| return new generic::ImmediateOperand<int32_t>( |
| encoding::inst32_format::ExtractJImm(inst_word_)); |
| }); |
| source_op_getters_.emplace(*SourceOpEnum::kPcc, [this]() { |
| return GetRegisterSourceOp<CheriotRegister>(state_, "pcc", "pcc"); |
| }); |
| /* |
| source_op_getters_.emplace(*SourceOpEnum::kRm, |
| [this]() -> SourceOperandInterface * { |
| uint32_t rm = (inst_word_ >> 12) & 0x7; |
| switch (rm) { |
| case 0: |
| return new generic::IntLiteralOperand<0>(); |
| case 1: |
| return new generic::IntLiteralOperand<1>(); |
| case 2: |
| return new generic::IntLiteralOperand<2>(); |
| case 3: |
| return new generic::IntLiteralOperand<3>(); |
| case 4: |
| return new generic::IntLiteralOperand<4>(); |
| case 5: |
| return new generic::IntLiteralOperand<5>(); |
| case 6: |
| return new generic::IntLiteralOperand<6>(); |
| case 7: |
| return new generic::IntLiteralOperand<7>(); |
| default: |
| return nullptr; |
| } |
| }); |
| */ |
| source_op_getters_.emplace( |
| *SourceOpEnum::kRd, [this]() -> SourceOperandInterface * { |
| int num = encoding::r_type::ExtractRd(inst_word_); |
| if (num == 0) return new generic::IntLiteralOperand<0>({1}); |
| return GetRegisterSourceOp<CheriotRegister>( |
| state_, absl::StrCat(CheriotState::kXregPrefix, num), |
| kXRegisterAliases[num]); |
| }); |
| source_op_getters_.emplace( |
| *SourceOpEnum::kRs1, [this]() -> SourceOperandInterface * { |
| int num = encoding::r_type::ExtractRs1(inst_word_); |
| if (num == 0) return new generic::IntLiteralOperand<0>({1}); |
| return GetRegisterSourceOp<CheriotRegister>( |
| state_, absl::StrCat(CheriotState::kXregPrefix, num), |
| kXRegisterAliases[num]); |
| }); |
| source_op_getters_.emplace( |
| *SourceOpEnum::kRs2, [this]() -> SourceOperandInterface * { |
| int num = encoding::r_type::ExtractRs2(inst_word_); |
| if (num == 0) return new generic::IntLiteralOperand<0>({1}); |
| return GetRegisterSourceOp<CheriotRegister>( |
| state_, absl::StrCat(CheriotState::kXregPrefix, num), |
| kXRegisterAliases[num]); |
| }); |
| source_op_getters_.emplace(*SourceOpEnum::kSImm12, [this]() { |
| return new generic::ImmediateOperand<int32_t>( |
| encoding::s_type::ExtractSImm(inst_word_)); |
| }); |
| source_op_getters_.emplace( |
| *SourceOpEnum::kScr, [this]() -> SourceOperandInterface * { |
| int csr_indx = encoding::r_type::ExtractRs2(inst_word_); |
| std::string csr_name; |
| switch (csr_indx) { |
| case 28: |
| csr_name = "mtcc"; |
| break; |
| case 29: |
| csr_name = "mtdc"; |
| break; |
| case 30: |
| csr_name = "mscratchc"; |
| break; |
| case 31: |
| csr_name = "mepcc"; |
| break; |
| default: |
| return nullptr; |
| } |
| auto res = state_->csr_set()->GetCsr(csr_name); |
| if (!res.ok()) { |
| return GetRegisterSourceOp<CheriotRegister>(state_, csr_name, |
| csr_name); |
| } |
| auto *csr = res.value(); |
| auto *op = csr->CreateSourceOperand(); |
| return op; |
| }); |
| source_op_getters_.emplace(*SourceOpEnum::kSImm20, [this]() { |
| return new generic::ImmediateOperand<int32_t>( |
| encoding::u_type::ExtractSImm(inst_word_)); |
| }); |
| source_op_getters_.emplace(*SourceOpEnum::kUImm20, [this]() { |
| return new generic::ImmediateOperand<int32_t>( |
| encoding::inst32_format::ExtractUImm(inst_word_)); |
| }); |
| source_op_getters_.emplace(*SourceOpEnum::kX0, []() { |
| return new generic::IntLiteralOperand<0>({1}); |
| }); |
| source_op_getters_.emplace(*SourceOpEnum::kX2, [this]() { |
| return GetRegisterSourceOp<CheriotRegister>( |
| state_, absl::StrCat(CheriotState::kXregPrefix, 2), |
| kXRegisterAliases[2]); |
| }); |
| source_op_getters_.emplace(*SourceOpEnum::kNone, []() { return nullptr; }); |
| } |
| |
| void RiscVCheriotEncoding::InitializeDestinationOperandGetters() { |
| // Destination operand getters. |
| dest_op_getters_.emplace(*DestOpEnum::kC2, [this](int latency) { |
| return GetRegisterDestinationOp<CheriotRegister>(state_, "c2", latency, |
| "csp"); |
| }); |
| dest_op_getters_.emplace(*DestOpEnum::kC3cd, [this](int latency) { |
| int num = encoding::c_l::ExtractRd(inst_word_); |
| return GetRegisterDestinationOp<CheriotRegister>( |
| state_, absl::StrCat(CheriotState::kCregPrefix, num), latency, |
| kCRegisterAliases[num]); |
| }); |
| dest_op_getters_.emplace(*DestOpEnum::kC3rd, [this](int latency) { |
| int num = encoding::c_l::ExtractRd(inst_word_); |
| if (num == 0) { |
| return GetRegisterDestinationOp<CheriotRegister>(state_, "X0Dest", |
| latency); |
| } |
| return GetRegisterDestinationOp<CheriotRegister>( |
| state_, absl::StrCat(CheriotState::kXregPrefix, num), latency, |
| kXRegisterAliases[num]); |
| }); |
| dest_op_getters_.emplace(*DestOpEnum::kC3rs1, [this](int latency) { |
| int num = encoding::c_l::ExtractRs1(inst_word_); |
| return GetRegisterDestinationOp<CheriotRegister>( |
| state_, absl::StrCat(CheriotState::kXregPrefix, num), latency, |
| kXRegisterAliases[num]); |
| }); |
| dest_op_getters_.emplace(*DestOpEnum::kCd, [this](int latency) { |
| int num = encoding::r_type::ExtractRd(inst_word_); |
| if (num == 0) { |
| return GetRegisterDestinationOp<CheriotRegister>(state_, "X0Dest", |
| latency); |
| } |
| return GetRegisterDestinationOp<CheriotRegister>( |
| state_, absl::StrCat(CheriotState::kCregPrefix, num), latency, |
| kCRegisterAliases[num]); |
| }); |
| dest_op_getters_.emplace(*DestOpEnum::kCsr, [this](int latency) { |
| return GetRegisterDestinationOp<CheriotRegister>( |
| state_, CheriotState::kCsrName, latency); |
| }); |
| dest_op_getters_.emplace(*DestOpEnum::kFrd, [this](int latency) { |
| int num = encoding::r_type::ExtractRd(inst_word_); |
| return GetRegisterDestinationOp<RVFpRegister>( |
| state_, absl::StrCat(CheriotState::kFregPrefix, num), latency, |
| kFRegisterAliases[num]); |
| }); |
| dest_op_getters_.emplace( |
| *DestOpEnum::kScr, [this](int latency) -> DestinationOperandInterface * { |
| int csr_indx = encoding::r_type::ExtractRs2(inst_word_); |
| std::string csr_name; |
| switch (csr_indx) { |
| case 28: |
| csr_name = "mtcc"; |
| break; |
| case 29: |
| csr_name = "mtdc"; |
| break; |
| case 30: |
| csr_name = "mscratchc"; |
| break; |
| case 31: |
| csr_name = "mepcc"; |
| break; |
| default: |
| return nullptr; |
| } |
| auto res = state_->csr_set()->GetCsr(csr_name); |
| if (!res.ok()) { |
| return GetRegisterDestinationOp<CheriotRegister>(state_, csr_name, |
| latency); |
| } |
| auto *csr = res.value(); |
| auto *op = csr->CreateWriteDestinationOperand(latency, csr_name); |
| return op; |
| }); |
| dest_op_getters_.emplace( |
| *DestOpEnum::kRd, [this](int latency) -> DestinationOperandInterface * { |
| int num = encoding::r_type::ExtractRd(inst_word_); |
| if (num == 0) { |
| return GetRegisterDestinationOp<CheriotRegister>(state_, "X0Dest", 0); |
| } else { |
| return GetRegisterDestinationOp<RVFpRegister>( |
| state_, absl::StrCat(CheriotState::kXregPrefix, num), latency, |
| kXRegisterAliases[num]); |
| } |
| }); |
| dest_op_getters_.emplace(*DestOpEnum::kX1, [this](int latency) { |
| return GetRegisterDestinationOp<CheriotRegister>( |
| state_, absl::StrCat(CheriotState::kXregPrefix, 1), latency, |
| kXRegisterAliases[1]); |
| }); |
| /* |
| dest_op_getters_.emplace(*DestOpEnum::kFflags, [this](int latency) { |
| return GetCSRSetBitsDestinationOp<uint32_t>(state_, "fflags", latency, ""); |
| }); |
| */ |
| dest_op_getters_.emplace(*DestOpEnum::kNone, |
| [](int latency) { return nullptr; }); |
| } |
| |
| // Parse the instruction word to determine the opcode. |
| void RiscVCheriotEncoding::ParseInstruction(uint32_t inst_word) { |
| inst_word_ = inst_word; |
| if ((inst_word_ & 0x3) == 3) { |
| auto [opcode, format] = |
| mpact::sim::cheriot::encoding::DecodeRiscVCheriotInst32WithFormat( |
| inst_word_); |
| opcode_ = opcode; |
| format_ = format; |
| return; |
| } |
| |
| auto [opcode, format] = |
| mpact::sim::cheriot::encoding::DecodeRiscVCheriotInst16WithFormat( |
| static_cast<uint16_t>(inst_word_ & 0xffff)); |
| opcode_ = opcode; |
| format_ = format; |
| } |
| |
| DestinationOperandInterface *RiscVCheriotEncoding::GetDestination( |
| SlotEnum, int, OpcodeEnum opcode, DestOpEnum dest_op, int dest_no, |
| int latency) { |
| int index = static_cast<int>(dest_op); |
| auto iter = dest_op_getters_.find(index); |
| if (iter == dest_op_getters_.end()) { |
| LOG(ERROR) << absl::StrCat("No getter for destination op enum value ", |
| index, " for instruction ", |
| kOpcodeNames[static_cast<int>(opcode)]); |
| return nullptr; |
| } |
| return (iter->second)(latency); |
| } |
| |
| SourceOperandInterface *RiscVCheriotEncoding::GetSource(SlotEnum, int, |
| OpcodeEnum opcode, |
| SourceOpEnum source_op, |
| int source_no) { |
| int index = static_cast<int>(source_op); |
| auto iter = source_op_getters_.find(index); |
| if (iter == source_op_getters_.end()) { |
| LOG(ERROR) << absl::StrCat("No getter for source op enum value ", index, |
| " for instruction ", |
| kOpcodeNames[static_cast<int>(opcode)]); |
| return nullptr; |
| } |
| return (iter->second)(); |
| } |
| |
| } // namespace isa32 |
| } // namespace cheriot |
| } // namespace sim |
| } // namespace mpact |
