diff --git a/mpact/sim/decoder/BinFormat.g4 b/mpact/sim/decoder/BinFormat.g4
index 912fe0a..c09440f 100644
--- a/mpact/sim/decoder/BinFormat.g4
+++ b/mpact/sim/decoder/BinFormat.g4
@@ -130,6 +130,7 @@
   : name=IDENT ':' format_name=IDENT ':' field_constraint_list ';'
   | generate=GENERATE '(' range_assignment (',' range_assignment)* ')'
     '{' generator_instruction_def_list '}' ';'
+  | name=IDENT ':' SPECIALIZES parent=IDENT ':' field_constraint_list ';'
   ;
 
 
@@ -257,6 +258,7 @@
 INSTRUCTION : 'instruction';
 GROUP : 'group';
 DECODER : 'decoder';
+SPECIALIZES : 'specializes';
 
 // Other tokens.
 STRING_LITERAL : UNTERMINATED_STRING_LITERAL '"';
diff --git a/mpact/sim/decoder/bin_format_visitor.cc b/mpact/sim/decoder/bin_format_visitor.cc
index d278ca2..ccd01d6 100644
--- a/mpact/sim/decoder/bin_format_visitor.cc
+++ b/mpact/sim/decoder/bin_format_visitor.cc
@@ -171,6 +171,8 @@
   if (error_listener_->HasError() > 0) {
     return absl::InternalError("Errors encountered - terminating.");
   }
+  // Process specializations.
+  ProcessSpecializations(encoding_info.get());
 
   // Create output streams for .h and .cc files.
   std::string dot_h_name = absl::StrCat(prefix, "_bin_decoder.h");
@@ -779,11 +781,19 @@
 void BinFormatVisitor::VisitInstructionDef(InstructionDefCtx *ctx,
                                            InstructionGroup *inst_group) {
   if (ctx == nullptr) return;
-
+  // If it is a generator, process it.
   if (ctx->generate != nullptr) {
     ProcessInstructionDefGenerator(ctx, inst_group);
     return;
   }
+  // Check to see if it is a specialization. If it is a specialization, save it
+  // for later processing when all the instructions have been processed.
+  int file_index = context_file_map_.at(ctx);
+  if (ctx->parent != nullptr) {
+    specializations_.push_back(ctx);
+    context_file_map_.insert({ctx, file_index});
+    return;
+  }
   // Get the instruction name and the format it refers to.
   std::string name = ctx->name->getText();
   std::string format_name = ctx->format_name->getText();
@@ -813,7 +823,6 @@
       inst_group->AddInstructionEncoding(ctx->format_name, name, format);
   if (format == nullptr) return;
   // Add constraints to the instruction encoding.
-  int file_index = context_file_map_.at(ctx);
   for (auto *constraint : ctx->field_constraint_list()->field_constraint()) {
     context_file_map_.insert({constraint, file_index});
     VisitConstraint(format, constraint, inst_encoding);
@@ -1223,6 +1232,33 @@
   return parent_group;
 }
 
+void BinFormatVisitor::ProcessSpecializations(BinEncodingInfo *encoding_info) {
+  for (auto *ctx : specializations_) {
+    auto file_index = context_file_map_.at(ctx);
+    std::string name = ctx->name->getText();
+    std::string parent_name = ctx->parent->getText();
+    for (auto &[unused, grp_ptr] : encoding_info->instruction_group_map()) {
+      auto iter = grp_ptr->encoding_name_map().find(parent_name);
+      if (iter != grp_ptr->encoding_name_map().end()) {
+        auto *parent_encoding = iter->second;
+        auto *format = parent_encoding->format();
+        auto *inst_encoding = new InstructionEncoding(name, format);
+        for (auto *constraint :
+             ctx->field_constraint_list()->field_constraint()) {
+          context_file_map_.insert({constraint, file_index});
+          VisitConstraint(format, constraint, inst_encoding);
+        }
+        if (!grp_ptr->AddSpecialization(name, parent_name, inst_encoding)
+                 .ok()) {
+          delete inst_encoding;
+          continue;
+        }
+        break;
+      }
+    }
+  }
+}
+
 }  // namespace bin_format
 }  // namespace decoder
 }  // namespace sim
diff --git a/mpact/sim/decoder/bin_format_visitor.h b/mpact/sim/decoder/bin_format_visitor.h
index f6e9e63..f10455a 100644
--- a/mpact/sim/decoder/bin_format_visitor.h
+++ b/mpact/sim/decoder/bin_format_visitor.h
@@ -133,6 +133,7 @@
       const std::string &group_name, GroupNameListCtx *ctx,
       absl::flat_hash_set<std::string> &group_name_set,
       BinEncodingInfo *encoding_info);
+  void ProcessSpecializations(BinEncodingInfo *encoding_info);
 
   // Accessors.
   decoder::DecoderErrorListener *error_listener() const {
@@ -163,6 +164,8 @@
   std::vector<BinFmtAntlrParserWrapper *> antlr_parser_wrappers_;
   // Map from comparator string to constraint type.
   absl::flat_hash_map<std::string, ConstraintType> constraint_string_to_type_;
+  // Specializations to process after all instructions have been processed.
+  std::vector<InstructionDefCtx *> specializations_;
 };
 
 }  // namespace bin_format
diff --git a/mpact/sim/decoder/encoding_group.cc b/mpact/sim/decoder/encoding_group.cc
index 9238df1..30d203f 100644
--- a/mpact/sim/decoder/encoding_group.cc
+++ b/mpact/sim/decoder/encoding_group.cc
@@ -118,6 +118,7 @@
   for (auto *enc : encoding_vec_) {
     if (!enc->other_constraints().empty()) return false;
     if (!enc->equal_extracted_constraints().empty()) return false;
+    if (!enc->HasSpecialization()) return false;
   }
   return discriminator_ == varying_;
 }
@@ -504,6 +505,16 @@
                   definitions_ptr);
   EmitExtractions(indent, encoding->other_constraints(), extracted,
                   definitions_ptr);
+  // Write any field/overlay extractions needed for the specializations (that
+  // haven't already been extracted).
+  for (auto const &[unused, encoding] : encoding->specializations()) {
+    EmitExtractions(indent, encoding->equal_constraints(), extracted,
+                    definitions_ptr);
+    EmitExtractions(indent, encoding->equal_extracted_constraints(), extracted,
+                    definitions_ptr);
+    EmitExtractions(indent, encoding->other_constraints(), extracted,
+                    definitions_ptr);
+  }
   // Construct the if statement.
   std::string condition;
   std::string connector;
@@ -516,19 +527,62 @@
   count += EmitOtherConstraintConditions(encoding->other_constraints(),
                                          connector, &condition);
 
+  bool specialization = encoding->HasSpecialization();
   // Ensure the number of parentheses are appropriate to the number of
   // conjunctions in the if statement.
   if (count > 1) {
-    absl::StrAppend(definitions_ptr, indent_str, "if (", condition, ")\n");
+    absl::StrAppend(definitions_ptr, indent_str, "if (", condition,
+                    specialization ? ") {\n" : ")\n");
     indent_str.append("  ");
   } else if (count == 1) {
-    absl::StrAppend(definitions_ptr, indent_str, "if ", condition, "\n");
+    absl::StrAppend(definitions_ptr, indent_str, "if ", condition,
+                    specialization ? " {\n" : "\n");
+    indent_str.append("  ");
+  }
+  // If the instruction has specializations, emit the if statement for each
+  // specialization.
+  std::string if_str = "if ";
+  if (specialization) {
+    for (auto const &[name, encoding] : encoding->specializations()) {
+      int spec_count = 0;
+      std::string spec_condition;
+      std::string spec_connector;
+      // Construct the condition for the specialization instruction.
+      spec_count += EmitConstraintConditions(
+          encoding->equal_constraints(), "==", spec_connector, &spec_condition);
+      spec_count +=
+          EmitConstraintConditions(encoding->equal_extracted_constraints(),
+                                   "==", spec_connector, &spec_condition);
+      spec_count += EmitOtherConstraintConditions(
+          encoding->other_constraints(), spec_connector, &spec_condition);
+      if (spec_count > 1) {
+        absl::StrAppend(definitions_ptr, indent_str, if_str, "(",
+                        spec_condition, ") {\n");
+        indent_str.append("  ");
+      } else if (spec_count == 1) {
+        absl::StrAppend(definitions_ptr, indent_str, if_str, spec_condition,
+                        " {\n");
+      }
+      absl::StrAppend(definitions_ptr, indent_str, "  return std::make_pair(",
+                      opcode_enum, "::k", ToPascalCase(encoding->name()),
+                      ", FormatEnum::k", ToPascalCase(encoding->format_name()),
+                      ");\n");
+      if_str = "} else if ";
+    }
+    absl::StrAppend(definitions_ptr, indent_str, "} else {\n");
     indent_str.append("  ");
   }
   absl::StrAppend(definitions_ptr, indent_str, "return std::make_pair(",
                   opcode_enum, "::k", ToPascalCase(encoding->name()),
                   ", FormatEnum::k", ToPascalCase(encoding->format_name()),
                   ");\n");
+  if (specialization) {
+    // Close the if statements.
+    indent_str = indent_str.substr(2);
+    absl::StrAppend(definitions_ptr, indent_str, "}\n");
+    indent_str = indent_str.substr(2);
+    absl::StrAppend(definitions_ptr, indent_str, "}\n");
+  }
   return count != 0 ? 1 : 0;
 }
 
@@ -599,8 +653,8 @@
   std::string indent_str(indent + 2, ' ');
   // Write any field/overlay extractions needed for the constraints.
   // Note, the extractions may be wider than the instruction word width, due
-  // to constant bits being added, so make sure to use appropriate type for each
-  // extraction.
+  // to constant bits being added, so make sure to use appropriate type for
+  // each extraction.
   for (auto const *constraint : constraints) {
     if (constraint->can_ignore) continue;
     if (constraint->field != nullptr) {
diff --git a/mpact/sim/decoder/instruction_encoding.cc b/mpact/sim/decoder/instruction_encoding.cc
index 9b91ff2..3fd17b7 100644
--- a/mpact/sim/decoder/instruction_encoding.cc
+++ b/mpact/sim/decoder/instruction_encoding.cc
@@ -16,6 +16,7 @@
 
 #include <cstdint>
 #include <string>
+#include <utility>
 
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
@@ -55,6 +56,25 @@
   }
 }
 
+InstructionEncoding::~InstructionEncoding() {
+  for (auto *constraint : equal_constraints_) {
+    delete constraint;
+  }
+  equal_constraints_.clear();
+  for (auto *constraint : equal_extracted_constraints_) {
+    delete constraint;
+  }
+  equal_extracted_constraints_.clear();
+  for (auto *constraint : other_constraints_) {
+    delete constraint;
+  }
+  other_constraints_.clear();
+  for (auto &[name, enc_ptr] : specializations_) {
+    delete enc_ptr;
+  }
+  specializations_.clear();
+}
+
 absl::StatusOr<Constraint *> InstructionEncoding::CreateConstraint(
     ConstraintType type, std::string lhs_name, std::string rhs_name) {
   Constraint constraint;
@@ -196,21 +216,6 @@
   return constraint;
 }
 
-InstructionEncoding::~InstructionEncoding() {
-  for (auto *constraint : equal_constraints_) {
-    delete constraint;
-  }
-  equal_constraints_.clear();
-  for (auto *constraint : equal_extracted_constraints_) {
-    delete constraint;
-  }
-  equal_extracted_constraints_.clear();
-  for (auto *constraint : other_constraints_) {
-    delete constraint;
-  }
-  other_constraints_.clear();
-}
-
 absl::Status InstructionEncoding::AddEqualConstraint(std::string field_name,
                                                      int64_t value) {
   // Invalidate the computed masks and values when a new constraint is added.
@@ -337,6 +342,20 @@
   return mask_ | extracted_mask_ | other_mask_;
 }
 
+absl::Status InstructionEncoding::AddSpecialization(
+    const std::string &name, InstructionEncoding *encoding) {
+  if (specializations_.contains(name)) {
+    format_->encoding_info()->error_listener()->semanticError(
+        nullptr, absl::StrCat("Duplicate instruction specialization name '",
+                              name, "' in format '", format_name_, "'."));
+    return absl::AlreadyExistsError(
+        absl::StrCat("Duplicate instruction specialization name '", name,
+                     "' in format '", format_name_, "'."));
+  }
+  specializations_.insert(std::make_pair(name, encoding));
+  return absl::OkStatus();
+}
+
 uint64_t InstructionEncoding::GetValue() {
   if (!mask_set_) {
     auto result = ComputeMaskAndValue();
diff --git a/mpact/sim/decoder/instruction_encoding.h b/mpact/sim/decoder/instruction_encoding.h
index 730e68b..6e7a246 100644
--- a/mpact/sim/decoder/instruction_encoding.h
+++ b/mpact/sim/decoder/instruction_encoding.h
@@ -19,6 +19,7 @@
 #include <string>
 #include <vector>
 
+#include "absl/container/btree_map.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "mpact/sim/decoder/bin_format_visitor.h"
@@ -76,6 +77,10 @@
   // Get the mask of the instruction word based on the bits in both equal and
   // not equal constraints.
   uint64_t GetCombinedMask();
+  // Add specialization to this encoding.
+  absl::Status AddSpecialization(const std::string &name,
+                                 InstructionEncoding *encoding);
+  bool HasSpecialization() const { return !specializations_.empty(); }
 
   // Accessors.
   const std::string &name() const { return name_; }
@@ -99,6 +104,13 @@
     return other_constraints_;
   }
 
+  const absl::btree_map<std::string, InstructionEncoding *> &specializations()
+      const {
+    return specializations_;
+  }
+
+  Format *format() const { return format_; }
+
  private:
   // Internal helper to create and check a constraint.
   absl::StatusOr<Constraint *> CreateConstraint(ConstraintType type,
@@ -122,6 +134,7 @@
   uint64_t other_mask_ = 0;
   uint64_t extracted_mask_ = 0;
   uint64_t value_ = 0;
+  absl::btree_map<std::string, InstructionEncoding *> specializations_;
 };
 
 }  // namespace bin_format
diff --git a/mpact/sim/decoder/instruction_group.cc b/mpact/sim/decoder/instruction_group.cc
index ca0018c..4b4e394 100644
--- a/mpact/sim/decoder/instruction_group.cc
+++ b/mpact/sim/decoder/instruction_group.cc
@@ -21,6 +21,7 @@
 #include <tuple>
 #include <utility>
 
+#include "absl/status/status.h"
 #include "absl/strings/str_cat.h"
 #include "antlr4-runtime/Token.h"
 #include "mpact/sim/decoder/bin_encoding_info.h"
@@ -78,24 +79,24 @@
   // Warn if the instruction name has been seen before. It might be fully valid
   // that an instruction name has multiple encodings, but warn about it, in
   // case it is an error.
-  if (encoding_name_set_.contains(name)) {
+  if (encoding_name_map_.contains(name)) {
     encoding_info_->error_listener()->semanticWarning(
         token, absl::StrCat("Duplicate instruction opcode name '", name,
                             "' in group '", this->name(), "'."));
   }
-  encoding_name_set_.insert(name);
   auto *encoding = new InstructionEncoding(name, format);
   encoding_vec_.push_back(encoding);
+  encoding_name_map_.insert(std::make_pair(name, encoding));
   return encoding;
 }
 
 void InstructionGroup::AddInstructionEncoding(InstructionEncoding *encoding) {
-  if (encoding_name_set_.contains(encoding->name())) {
+  if (encoding_name_map_.contains(encoding->name())) {
     encoding_info_->error_listener()->semanticWarning(
         nullptr, absl::StrCat("Duplicate instruction opcode name '",
                               encoding->name(), "' in group '", name(), "'."));
   }
-  encoding_name_set_.insert(encoding->name());
+  encoding_name_map_.insert(std::make_pair(encoding->name(), encoding));
   encoding_vec_.push_back(encoding);
 }
 
@@ -139,6 +140,23 @@
   }
 }
 
+absl::Status InstructionGroup::AddSpecialization(
+    const std::string &name, const std::string &parent_name,
+    InstructionEncoding *encoding) {
+  if (encoding_name_map_.contains(name)) {
+    encoding_info_->error_listener()->semanticError(
+        nullptr,
+        absl::StrCat("Duplicate instruction specialization opcode name '", name,
+                     "' in group '", this->name(), "'."));
+    return absl::AlreadyExistsError(
+        absl::StrCat("Duplicate instruction specialization opcode name '", name,
+                     "' in group '", this->name(), "'."));
+  }
+  encoding_name_map_.insert(std::make_pair(name, encoding));
+  auto *parent_encoding = encoding_name_map_.at(parent_name);
+  return parent_encoding->AddSpecialization(name, encoding);
+}
+
 // Helper function used to sort the instruction group elements in a vector.
 static bool InstructionGroupLess(EncodingGroup *lhs, EncodingGroup *rhs) {
   uint64_t lhs_value = 0;
diff --git a/mpact/sim/decoder/instruction_group.h b/mpact/sim/decoder/instruction_group.h
index 2f7fb77..40459e2 100644
--- a/mpact/sim/decoder/instruction_group.h
+++ b/mpact/sim/decoder/instruction_group.h
@@ -21,7 +21,8 @@
 #include <vector>
 
 #include "absl/container/btree_map.h"
-#include "absl/container/flat_hash_set.h"
+#include "absl/container/flat_hash_map.h"
+#include "absl/status/status.h"
 #include "antlr4-runtime/Token.h"
 #include "mpact/sim/decoder/bin_encoding_info.h"
 #include "mpact/sim/decoder/encoding_group.h"
@@ -59,6 +60,10 @@
   // Return a string containing information about this instruction group and
   // how it has been partitioned across encoding groups.
   std::string WriteGroup();
+  // Add a specialization to this instruction group.
+  absl::Status AddSpecialization(const std::string &name,
+                                 const std::string &parent_name,
+                                 InstructionEncoding *encoding);
 
   // Accessors.
   const std::string &name() const { return name_; }
@@ -69,6 +74,12 @@
   }
   int width() const { return width_; }
   BinEncodingInfo *encoding_info() const { return encoding_info_; }
+  const absl::flat_hash_map<std::string, InstructionEncoding *> &
+  encoding_name_map() const {
+    return encoding_name_map_;
+  }
+
+  Format *format() const { return format_; }
 
  private:
   std::string name_;
@@ -78,7 +89,7 @@
   std::string opcode_enum_;
   BinEncodingInfo *encoding_info_;
   std::vector<InstructionEncoding *> encoding_vec_;
-  absl::flat_hash_set<std::string> encoding_name_set_;
+  absl::flat_hash_map<std::string, InstructionEncoding *> encoding_name_map_;
   absl::btree_multimap<uint64_t, InstructionEncoding *> encoding_map_;
   std::vector<EncodingGroup *> encoding_group_vec_;
 };
diff --git a/mpact/sim/decoder/test/testfiles/instruction_group.bin_fmt b/mpact/sim/decoder/test/testfiles/instruction_group.bin_fmt
index 95eb73d..ff97c54 100644
--- a/mpact/sim/decoder/test/testfiles/instruction_group.bin_fmt
+++ b/mpact/sim/decoder/test/testfiles/instruction_group.bin_fmt
@@ -282,6 +282,12 @@
   csrrwi_nr: IType  : func3 == 0b101, rd == 0,  opcode == 0b111'0011;
   csrrsi_nw: IType  : func3 == 0b110, rs1 == 0, opcode == 0b111'0011;
   csrrci_nw: IType  : func3 == 0b111, rs1 == 0, opcode == 0b111'0011;
+  rdcycle    : specializes csrrs_nw : imm12 == 0xc00;
+  rdtime     : specializes csrrs_nw : imm12 == 0xc01;
+  rdinstret  : specializes csrrs_nw : imm12 == 0xc02;
+  rdcycleh   : specializes csrrs_nw : imm12 == 0xc80;
+  rdtimeh    : specializes csrrs_nw : imm12 == 0xc81;
+  rdinstreth : specializes csrrs_nw : imm12 == 0xc82;
 };
 
 // RiscV32 Privileged instructions.