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);