HartConfig.cpp

// Copyright 2020 Western Digital Corporation or its affiliates.
// 
// 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 <nlohmann/json.hpp>
#include <charconv>
#include <fstream>
#include <iostream>
#include <unordered_map>
#include <unordered_set>
#include <bit>
#include "HartConfig.hpp"
#include "System.hpp"
#include "Core.hpp"
#include "Hart.hpp"
#include "Mcm.hpp"
#include "aplic/Aplic.hpp"
#include "Aclic.hpp"
#include "iommu/Iommu.hpp"


using namespace WdRiscv;


class HartConfig::Json : public nlohmann::json
{
public:

  HartConfig::Json& operator=(const nlohmann::json& other)
  { nlohmann::json::operator=(other); return *this; }
};


constexpr bool
isPowerOf2(uint64_t x)
{
  return x != 0 and (x & (x-1)) == 0;
}


HartConfig::HartConfig()
  : config_(std::make_unique<Json>())
{
}


HartConfig::~HartConfig() = default;


bool
HartConfig::loadConfigFile(const std::string& filePath)
{
  std::ifstream ifs(filePath);
  if (not ifs.good())
    {
      std::cerr << "Error: Failed to open config file '" << filePath
		<< "' for input.\n";
      return false;
    }

  try
    {
      // Use json::parse rather than operator>> to allow comments to be ignored.
      // Use merge_patch so that multiple config files specified on the command
      // line are merged left to right, allowing later files to override
      // individual key/value pairs in earlier ones.
      auto newConfig = nlohmann::json::parse(ifs, nullptr /* callback */, true /* allow_exceptions */, true /* ignore_comments */);
      config_->merge_patch(newConfig);
    }
  catch (std::exception& e)
    {
      std::cerr << e.what() << "\n";
      return false;
    }
  catch (...)
    {
      std::cerr << "Error: Caught unknown exception while parsing "
		<< " config file '" << filePath << "'\n";
      return false;
    }

  return true;
}


namespace WdRiscv
{
  
  /// Convert given json entry to an unsigned integer value honoring
  /// hexadecimal prefix (0x) if any. Return true on succes and false
  /// if given entry does not represent an integer.
  template <typename URV>
  bool
  getJsonUnsigned(std::string_view tag, const nlohmann::json& js, URV& value)
  {
    value = 0;

    if (js.is_number())
      {
        value = js.get<URV>();
        return true;
      }

    if (js.is_string())
      {
        char*            end = nullptr;
        std::string_view str = js.get<std::string_view>();
        uint64_t         u64 = strtoull(str.data(), &end, 0);
        if (end and *end)
          {
            std::cerr << "Error: Invalid config file unsigned value for '" << tag << "': "
                      << str << '\n';
            return false;
          }
        value = static_cast<URV>(u64);
        if (value != u64)
          {
            std::cerr << "Error: Overflow in config file value for '" << tag << "': "
                      << str << '\n';
            return false;
          }

        return true;
      }

    std::cerr << "Error: Config file entry '" << tag << "' must contain a number\n";
    return false;
  }


  /// Convert given json array value to a vector of unsigned integers
  /// honoring any hexadecimal prefix (0x) if any. Return true on
  /// sucess an false on failure.
  template <typename URV>
  bool
  getJsonUnsignedVec(std::string_view tag, const nlohmann::json& js,
                     std::vector<URV>& vec)
  {
    vec.clear();

    if (not js.is_array())
      {
	std::cerr << "Error: Invalid config file value for '" << tag << "'"
		  << " -- expecting array of numbers\n";
	return false;
      }

    unsigned errors = 0;

    for (const auto& item :js)
      {
	if (item.is_number())
	  vec.push_back(item.get<unsigned>());
	else if (item.is_string())
	  {
            char*            end = nullptr;
            std::string_view str = item.get<std::string_view>();
            uint64_t         u64 = strtoull(str.data(), &end, 0);
	    if (end and *end)
	      {
		std::cerr << "Error: Invalid config file value for '" << tag << "': "
			  << str << '\n';
                errors++;
		continue;
	      }

            URV val = static_cast<URV>(u64);
            if (val != u64)
              {
                std::cerr << "Error: Overflow in config file value for '" << tag << "': "
                          << str << '\n';
                errors++;
                continue;
              }

	    vec.push_back(val);
	  }
	else
          {
            std::cerr << "Error: Invalid config file value for '" << tag << "'"
                      << " -- expecting array of number\n";
            errors++;
          }
      }

    return errors == 0;
  }


  /// Convert given json entry to a boolean value. Return ture on
  /// success and false on failure.
  bool
  getJsonBoolean(std::string_view tag, const nlohmann::json& js, bool& value)
  {
    value = false;

    if (js.is_boolean())
      {
        value = js.get<bool>();
        return true;
      }

    if (js.is_number())
      {
        value = js.get<unsigned>() != 0;
        return true;
      }

    if (js.is_string())
      {
        std::string_view str = js.get<std::string_view>();
        if (str == "0" or str == "false" or str == "False")
          value = false;
        else if (str == "1" or str == "true" or str == "True")
          value = true;
        else
          {
            std::cerr << "Error: Invalid config file boolean value for '" << tag << "': "
                      << str << '\n';
            return false;
          }
        return true;
      }

    std::cerr << "Error: Config file entry '" << tag << "' must contain a bool\n";
    return false;
  }

}


template <typename URV>
static
bool
applyCsrConfig(Hart<URV>& hart, std::string_view nm, const nlohmann::json& conf, bool verbose)
{
  using std::cerr;

  unsigned errors = 0;
  URV reset = 0, mask = 0, pokeMask = 0;
  bool exists = true, shared = false, isDebug = false, isHExt = false;

  std::string name(nm);
  if (name == "dscratch")
    name +=  "0";

  Csr<URV>* csr = hart.findCsr(name);
  if (not csr)
    {
      // For backward compatibility with config files where pmamask0..16 used to be
      // pmacfg16..31
      if (name.starts_with("pmacfg"))
        {
          auto suffix = name.substr(6);
          if (std::find_if_not(suffix.begin(), suffix.end(), ::isdigit) == suffix.end())
            {
              int n = std::stoi(suffix);
              if (n >= 16)
                {
                  auto altName = "pmamask" + std::to_string(n - 16);
                  csr = hart.findCsr(altName);
                }
            }
        }
    }

  if (csr)
    {
      reset = csr->getResetValue();
      mask = csr->getWriteMask();
      pokeMask = csr->getPokeMask();
    }

  if (conf.contains("reset"))
    getJsonUnsigned(name + ".reset", conf.at("reset"), reset) or errors++;

  if (conf.contains("mask"))
    {
      if (not getJsonUnsigned(name + ".mask", conf.at("mask"), mask))
	errors++;

      // If defining a non-standard CSR (as popposed to configuring an
      // existing CSR) then default the poke-mask to the write-mask.
      if (not csr)
	pokeMask = mask;
    }

  if (conf.contains("poke_mask"))
    getJsonUnsigned(name + ".poke_mask", conf.at("poke_mask"), pokeMask) or errors++;

  if (conf.contains("exists"))
    getJsonBoolean(name + ".exists", conf.at("exists"), exists) or errors++;

  if (conf.contains("shared"))
    getJsonBoolean(name + ".shared", conf.at("shared"), shared) or errors++;

  if (conf.contains("is_debug"))
    getJsonBoolean(name + ".is_debug", conf.at("is_debug"), isDebug) or errors++;

  if (conf.contains("is_h_extension"))
    getJsonBoolean(name + ".is_h_extension", conf.at("is_h_extension"), isHExt) or errors++;

  // If number present and csr is not defined, then define a new
  // CSR; otherwise, configure.
  if (conf.contains("number"))
    {
      unsigned number = 0;
      if (not getJsonUnsigned<unsigned>(name + ".number", conf.at("number"), number))
	errors++;
      else
	{
	  if (csr)
	    {
	      if (csr->getNumber() != CsrNumber(number))
		{
		  cerr << "Error: Invalid config file entry for CSR "
                       << name << ": Number (0x" << std::hex << number
                       << ") does not match that of previous definition ("
                       << "0x" << unsigned(csr->getNumber())
                       << ")\n" << std::dec;
		  return false;
		}
	      // If number matches we configure below
	    }
	  else if (hart.defineCsr(name, CsrNumber(number), exists, reset, mask, pokeMask))
	    {
	      csr = hart.findCsr(name);
	      assert(csr);
	    }
	  else
	    {
	      cerr << "Error: Invalid config file CSR definition with name "
                   << name << " and number 0x" << std::hex << number
                   << ": Number already in use\n" << std::dec;
	      return false;
	    }
	}
    }

  if (not csr)
    {
      cerr << "Error: A CSR number must be provided in configuration of non-standard CSR "
           << name << '\n';
      return false;
    }
  bool exists0 = csr->isImplemented();
  URV reset0 = csr->getResetValue(), mask0 = csr->getWriteMask();
  URV pokeMask0 = csr->getPokeMask();
  bool debug0 = csr->isDebug();

  if (name == "mhartid" or name == "vlenb")
    {
      cerr << "Warning: CSR " << name << " cannot be configured.\n";
      return true;
    }

  if (name == "sstatus")
    {
      cerr << "Warning: CSR sstatus is a shadow of mstatus and cannot be configured.\n";
      return true;
    }

  if (name == "mscontext")
    {
      cerr << "Warning: CSR mscontext is an alias of scontext. Use the "
           << "enable_mscontext tag instead of configuring it directly.\n";
      return true;
    }

  if (debug0 and not isDebug)
    {
      if (verbose)
        cerr << "Warning: CSR " << name << " cannot be marked as not debug-mode.\n";
      isDebug = true;
    }

  if (errors)
    return false;

  if (not hart.configCsrByUser(csr->getName(), exists, reset, mask, pokeMask, isDebug, isHExt))
    {
      cerr << "Error: Invalid CSR (" << name << ") in config file.\n";
      return false;
    }

  // Remember an explicit "exists": true: it keeps an optional CSR (e.g. mcounteren
  // without U-mode) that would otherwise not be implemented.
  if (conf.contains("exists") and exists)
    csr->setUserEnabled(true);

  if (conf.contains("privilege_mode"))
    {
      std::string val = conf.at("privilege_mode").get<std::string>();
      PrivilegeMode pm = PrivilegeMode::Machine;
      if (val == "m" or val == "machine")
        pm = PrivilegeMode::Machine;
      else if (val == "s" or val == "supervisor")
        pm = PrivilegeMode::Supervisor;
      else if (val == "u" or val == "user")
        pm = PrivilegeMode::User;
      else
        {
          cerr << "Error: Invalid privilege mode (" << val << ") in config fo CSR "
               << name << '\n';
          return false;
        }
      if (not hart.csRegs().isCustomCsr(csr->getNumber()))
        cerr << "Warning: Config file changes the privilege mode of non-stadard CSR "
             << name << '\n';
      csr->definePrivilegeMode(pm);
    }

  if ((mask & pokeMask) != mask and hart.sysHartIndex() == 0)
    {
      cerr << "Warning: For CSR " << name << " poke mask (0x" << std::hex << pokeMask
           << ") is not a superset of write\n  mask (0x" << mask << std::dec << ")."
           << " Only bits set in both masks will be writable by CSR instructions.\n";
    }

  if (name == "misa")
    {
      // If an extension bit is writable, it should reset to 1.
      URV extBits = (URV(1) << 26) - 1;
      URV writeable = extBits & mask, writeableReset = extBits & mask & reset;
      if (writeable != writeableReset and hart.sysHartIndex() == 0)
	cerr << "Warning: Reset value of MISA should be 0x"
             << std::hex << (reset | writeable) << std::dec
             << " to be compatible with write mask.\n";
      if ((writeable & (URV(1) << ('E' - 'A'))) and hart.sysHartIndex() == 0)
	cerr << "Warning: Bit E of MISA cannot be writebale.\n";
      if ((reset & (1 << ('S' - 'A'))) and not (reset & (1 << ('U' - 'A'))))
        {
          cerr << "Error: Invalid MISA in config file: cannot have S=1 and U=0.\n";
          return false;
        }
    }

  if (verbose)
    {
      if (exists0 != exists or reset0 != reset or mask0 != mask or pokeMask0 != pokeMask)
	{
	  cerr << "Warning: Configuration of CSR (" << name << ") changed in config file:\n";

	  if (exists0 and exists0 != exists)
	    cerr << "  implemented: " << exists0 << " to " << exists << '\n';

	  if (reset0 != reset)
	    cerr << "  reset: 0x" << std::hex << reset0 << " to 0x" << reset << '\n' << std::dec;

	  if (mask0 != mask)
	    cerr << "  mask: 0x" << std::hex << mask0 << " to 0x" << mask << '\n' << std::dec;

	  if (pokeMask0 != pokeMask)
	    cerr << "  poke_mask: " << std::hex << pokeMask0 << " to 0x" << pokeMask << '\n' << std::dec;
	}
    }

  return true;
}


template <typename URV>
static
bool
applyCsrConfig(Hart<URV>& hart, const nlohmann::json& config, bool verbose)
{
  if (not config.contains("csr"))
    return true;  // Nothing to apply

  const auto& csrs = config.at("csr");
  if (not csrs.is_object())
    {
      std::cerr << "Error: Invalid csr entry in config file (expecting an object)\n";
      return false;
    }

  unsigned errors = 0;
  for (auto it = csrs.begin(); it != csrs.end(); ++it)
    {
      std::string_view csrName = it.key();
      const auto& conf = it.value();

      std::string_view tag = "range";
      if (not conf.contains(tag))
	{
	  applyCsrConfig(hart, csrName, conf, verbose) or errors++;
	  continue;
	}

      std::vector<unsigned> range;
      if (not getJsonUnsignedVec(util::join("", "csr.", tag, ".range"), conf.at(tag), range)
	  or range.size() != 2 or range.at(0) > range.at(1))
	{
	  std::cerr << "Error: Invalid range in CSR '" << csrName << "': " << conf.at(tag) << '\n';
	  errors++;
	  continue;
	}

      if (range.at(1) - range.at(0) > 256)
	{
	  std::cerr << "Error: Invalid range in CSR '" << csrName << "': " << conf.at(tag)
		    << ": Range size greater than 256\n";
	  errors++;
	  continue;
	}

      for (unsigned n = range.at(0); n <= range.at(1); ++n)
	{
	  std::string strand = util::join("", csrName, std::to_string(n));
	  if (not applyCsrConfig(hart, strand, conf, verbose))
	    {
	      errors++;
	      break;
	    }
	}
    }

  return errors == 0;
}


/// Parse an entry of the form: [ [ int, bool ], [ int, bool ] ]
/// The integer represents a trigger match type, the bool indicates whether or not
/// matching should be applied to all the addresses of an instruction.
static bool
parseTriggerAllAddr(const nlohmann::json& arr, const std::string_view tag, 
                    std::vector<std::pair<unsigned, bool>>& vec)
{
  if (not arr.is_array())
    {
      std::cerr << "Error: Invalid " << tag << " entry in config file (expecting array)\n";
      return false;
    }

  unsigned errors = 0;
  for (const auto& item : arr)
    {
      if (not item.is_array())
        {
          std::cerr << "Error: Invalid item in " << tag << " entry in config file (expecting array)\n";
          errors++;
          continue;
        }
      if (item.size() != 2)
        {
          std::cerr << "Error: Invalid item in " << tag << " entry in config file (expecting array of 2 elements)\n";
          errors++;
          continue;
        }

      const auto& elem0 = item.at(0);
      std::string elemTag = std::string(tag) + ".match_type";
      unsigned matchType = 0;
      if (not getJsonUnsigned(elemTag, elem0, matchType))
        {
          errors++;
          continue;
        }

      const auto& elem1 = item.at(1);
      elemTag = std::string(tag) + ".flag";
      bool flag = false;
      if (not getJsonBoolean(elemTag, elem1, flag))
        {
          errors++;
          continue;
        }

      std::pair<unsigned, bool> elem{matchType, flag};
      vec.emplace_back(elem);
    }

  return errors == 0;
}


/// Configure the SDTRIG module.
template <typename URV>
static
bool
applySdtrigConfig(Hart<URV>& hart, const nlohmann::json& config)
{
  using std::cerr;

  unsigned errors = 0;

  // We avoid repeating some config errors by printing them only for hart0.
  bool hart0 = hart.sysHartIndex() == 0;

  // Enable debug triggers.
  std::string_view tag = "enable_triggers";
  bool flag = false;
  if (config.contains(tag))
    {
      getJsonBoolean(tag, config.at(tag), flag) or errors++;
      hart.enableSdtrig(flag);
      if (hart0)
	cerr << "Warning: Config file tag \"" << tag << "\" deprecated: "
	     << "Add extension string \"sdtrig\" to \"isa\" tag instead.\n";
    }

  tag = "all_ld_st_addr_trigger";
  if (config.contains(tag))
    {
      getJsonBoolean(tag, config.at(tag), flag) or errors++;
      hart.configAllDataAddrTrigger(flag);
    }

  tag = "all_inst_addr_trigger";
  if (config.contains(tag))
    {
      getJsonBoolean(tag, config.at(tag), flag) or errors++;
      hart.configAllInstrAddrTrigger(flag);
    }

  tag = "trigger_on_all_data_addr";
  if (config.contains(tag))
    {
      std::vector<std::pair<unsigned, bool>> vec;
      parseTriggerAllAddr(config.at(tag), tag, vec) or errors++;
      for (auto typeVal : vec)
        hart.configAllDataAddrTrigger(typeVal.first, typeVal.second);
    }

  tag = "trigger_on_all_instr_addr";
  if (config.contains(tag))
    {
      std::vector<std::pair<unsigned, bool>> vec;
      parseTriggerAllAddr(config.at(tag), tag, vec) or errors++;
      for (auto typeVal : vec)
        hart.configAllInstrAddrTrigger(typeVal.first, typeVal.second);
    }

    // Enable use of TCONTROL CSR to control triggers in Machine mode.
  tag = "trigger_use_tcontrol";
  if (config.contains(tag))
    {
      getJsonBoolean(tag, config.at(tag), flag) or errors++;
      hart.configTriggerUseTcontrol(flag);
    }

  tag = "disabled_trigger_read_mask";
  if (config.contains(tag))
    {
      URV mask = 0;
      getJsonUnsigned(tag, config.at(tag), mask) or errors++;
      hart.configDisabledTriggerReadMask(mask);
    }

  tag = "clear_tdata1_when_disabled";
  if (config.contains(tag))
    {
      getJsonBoolean(tag, config.at(tag), flag) or errors++;
      hart.configClearTdata1OnDisabled(flag);
    }

  tag = "address_triggers_report_ea";
  if (config.contains(tag))
    {
      getJsonBoolean(tag, config.at(tag), flag) or errors++;
      hart.configAddrTrigsReportEa(flag);
    }

  tag = "trigger_types";
  if (config.contains(tag))
    {
      std::vector<std::string> types;
      const auto& items = config.at(tag);
      for (const auto& item : items)
	{
	  if (not item.is_string())
	    {
              if (hart0)
                cerr << "Error: Invalid value in config file item " << tag << " -- expecting string\n";
	      ++errors;
	    }
	  else
	    types.push_back(item.get<std::string>());
	}
      hart.setSupportedTriggerTypes(types) or ++errors;
    }

  tag = "trigger_actions";
  if (config.contains(tag))
    {
      const auto& items = config.at(tag);
      if (items.is_array())
        {
          std::vector<std::string> actions;
          for (const auto& item : items)
            {
              if (not item.is_string())
                {
                  if (hart0)
                    cerr << "Error: Invalid value in config file item " << tag
                         << " -- expecting string\n";
                  ++errors;
                }
              else
                actions.push_back(item.get<std::string>());
            }
          hart.setSupportedTriggerActions(actions) or ++errors;
        }
      else
        {
          if (hart0)
            cerr << "Error: Invalid config file value for '" << tag << "': expecting "
                 << " an array of actions or a map from a trigger type to an array of "
                 << " actions\n";
          ++errors;
        }
    }

  tag = "trigger_actions_per_type";
  if (config.contains(tag))
    {
      const auto& items = config.at(tag);
      if (items.is_object())
        {
          for (auto it = items.begin(); it != items.end(); ++it)
            {
              const std::string& trigType = it.key();
              const auto& trigActions = it.value();
              if (not trigActions.is_array())
                {
                  cerr << "Error: Invalid value for trigger_actions entry '"
                       << trigType << "' -- expecting an array\n";
                  errors++;
                  continue;
                }
              std::vector<std::string> actions;
              for (const auto& actString : trigActions)
                {
                  if (not actString.is_string())
                    {
                      if (hart0)
                        cerr << "Error: Invalid value in config file item " << tag
                             << " for type " << trigType << " -- expecting string\n";
                      ++errors;
                    }
                  actions.push_back(actString.get<std::string>());
                }
              if (not hart.setSupportedTriggerActions(trigType, actions))
                ++errors;
            }
        }
      else
        {
          if (hart0)
            cerr << "Error: Invalid config file value for '" << tag << "': expecting "
                 << " a map from a trigger type to an array of actions\n";
          ++errors;
        }
    }

  tag = "trigger_napot_maskmax";
  if (config.contains(tag))
    {
      unsigned maskMax = 0;
      if (not getJsonUnsigned(tag, config.at(tag), maskMax))
        errors++;
      else if (not hart.configTriggerNapotMaskMax(maskMax))
        {
          if (hart0)
            cerr << "Error: Invalid config file value for '" << tag << "': " << maskMax
                 << " -- expecting 1 to " << (8*sizeof(URV) - 1) << '\n';
          errors++;
        }
    }

  tag = "trigger_clear_unsupported_action";
  if (config.contains(tag))
    {
      getJsonBoolean(tag, config.at(tag), flag) or errors++;
      hart.configTriggerClearUnsupportedAction(flag);
    }

  return errors == 0;
}


/// Configure the TRIGGER CSR maksks.
template <typename URV>
static
bool
applyTriggerConfig(Hart<URV>& hart, const nlohmann::json& config)
{
  if (not config.contains("triggers"))
    return true;  // Nothing to apply

  const auto& triggers = config.at("triggers");
  if (not triggers.is_array())
    {
      std::cerr << "Error: Invalid triggers entry in config file (expecting an array)\n";
      return false;
    }

  unsigned errors = 0;
  unsigned ix = 0;
  for (auto it = triggers.begin(); it != triggers.end(); ++it, ++ix)
    {
      const auto& trig = *it;
      std::string name = std::string("trigger") + std::to_string(ix);
      if (not trig.is_object())
	{
	  std::cerr << "Error: Invalid trigger in config file triggers array "
		    << "(expecting an object at index " << ix << ")\n";
	  ++errors;
	  break;
	}
      bool ok = true;
      for (const auto& tag : {"reset", "mask", "poke_mask"})
        if (not trig.contains(tag))
          {
            std::cerr << "Error: Trigger " << name << " has no '" << tag
                      << "' entry in config file\n";
            ok = false;
          }
      if (not ok)
        {
          errors++;
          continue;
        }

      std::vector<uint64_t> resets, masks, pokeMasks;
      ok = (getJsonUnsignedVec(name + ".reset", trig.at("reset"), resets) and
            getJsonUnsignedVec(name + ".mask", trig.at("mask"), masks) and
            getJsonUnsignedVec(name + ".poke_mask", trig.at("poke_mask"), pokeMasks));
      if (not ok)
        {
          errors++;
          continue;
        }

      // Each trigger has up to 5 components: tdata1, tdata2, tdata3, tinfo, tcontrol
      size_t maxSize = std::max(resets.size(), std::max(masks.size(), pokeMasks.size()));
      if (maxSize > 5)
	std::cerr << "Warning: Trigger " << name << ": Unreasonable item count (" << maxSize
		  << ") for 'reset/mask/poke_mask' field in config file. "
		  << " Expecting no more than to 5. Extra fields ignored.\n";

      if (resets.size() != maxSize or masks.size() != maxSize or pokeMasks.size() != maxSize)
	{
	  std::cerr << "Trigger " << name << ": Error: reset/mask/poke_mask fields must have "
		    << " same number of entries.\n";
	  errors++;
	  continue;
	}

      if (not hart.configTrigger(ix, resets, masks, pokeMasks))
	{
	  std::cerr << "Error: Failed to configure trigger " << std::dec << ix << '\n';
	  ++errors;
	}
    }

  return errors == 0;
}


template <typename URV>
static
bool
applyPerfEventMap(Hart<URV>& hart, const nlohmann::json& config)
{
  constexpr std::string_view tag = "mmode_perf_event_map";
  if (not config.contains(tag))
    return true;

  const auto& perfMap = config.at(tag);
  if (not perfMap.is_object())
    {
      std::cerr << "Error: Invalid " << tag << " entry in config file (expecting an object)\n";
      return false;
    }

  std::unordered_set<URV> eventNumbers;

  unsigned errors = 0;
  for (auto it = perfMap.begin(); it != perfMap.end(); ++it)
    {
      std::string_view eventName = it.key();
      const auto& valObj = it.value();
      std::string path = util::join(".", tag, eventName);
      uint64_t value = 0;
      if (not getJsonUnsigned(path, valObj,  value))
	{
	  errors++;
	  continue;
	}

      EventNumber eventId = EventNumber::None;
      if (not PerfRegs::findEvent(eventName, eventId))
	{
	  std::cerr << "Warning: No such performance event: " << eventName << '\n';
	  continue;
	}

      if (value == 0 and eventId != EventNumber::None)
	{
	  std::cerr << "Error: Event number 0 (no event) cannot be associated with event "
		    << eventName << " in mmode_perf_event_map in config file.\n";
	  errors++;
	  continue;
	}

      if (eventNumbers.contains(value))
	{
	  std::cerr << "Error: Event number " << value << " associaged with more than one event in mmode_perf_event_map in config file.\n";
	  errors++;
	}
      hart.configEventNumber(value, eventId);
      eventNumbers.insert(value);
    }

  return errors == 0;
}


template <typename URV>
static
bool
applyPerfEvents(Hart<URV>& hart, const nlohmann::json& config,
                bool userMode, bool cof, bool /*verbose*/)
{
  unsigned errors = 0;

  std::string_view tag = "num_mmode_perf_regs";
  if (config.contains(tag))
    {
      unsigned count = 0;
      if (not getJsonUnsigned<unsigned>(tag, config.at(tag), count))
        errors++;
      else
        {
          if (not hart.configMachineModePerfCounters(count, cof))
            errors++;
          if (userMode)
            if (not hart.configUserModePerfCounters(count))
              errors++;
        }
    }

  uint64_t maxPerfId = 0;
  tag = "max_mmode_perf_event";
  if (config.contains(tag))
    {
      if (not getJsonUnsigned<uint64_t>(tag, config.at(tag), maxPerfId))
        errors++;
      else
        hart.configMachineModeMaxPerfEvent(maxPerfId);
    }

  tag = "mmode_perf_events";
  if (config.contains(tag))
    {
      std::vector<unsigned> eventsVec;

      const auto& events = config.at(tag);
      if (not events.is_array())
        {
          std::cerr << "Error: Invalid mmode_perf_events entry in config file (expecting an array)\n";
          errors++;
        }
      else
        {
          unsigned ix = 0;
          for (auto it = events.begin(); it != events.end(); ++it, ++ix)
            {
              const auto& event = *it;
              std::string elemTag = util::join("", tag, "element ", std::to_string(ix));
              unsigned eventId = 0;
              if (not getJsonUnsigned<unsigned>(elemTag, event, eventId))
                errors++;
              else
                eventsVec.push_back(eventId);
            }
        }
      hart.configPerfEvents(eventsVec);
    }

  if (not applyPerfEventMap(hart, config))
    errors++;

  return errors == 0;
}


// Min SEW per LMUL is allowed by the spec for m1, m2, m4, and m8.
bool
processMinBytesPerLmul(const nlohmann::json& jsonMap, unsigned minBytes, unsigned maxBytes,
		       std::unordered_map<GroupMultiplier, unsigned>& bytesPerLmul)
{
  if (not jsonMap.is_object())
    {
      std::cerr << "Error: Invalid min_bytes_per_lmul entry in config file (expecting an object)\n";
      return false;
    }

  for (auto it = jsonMap.begin(); it != jsonMap.end(); it++)
    {
      GroupMultiplier group = GroupMultiplier::One;
      std::string_view lmul = it.key();
      const unsigned mewb = it.value();  // min element width in bytes
      if (not VecRegs::to_lmul(lmul, group))
	{
	  std::cerr << "Error: Invalid lmul setting in min_bytes_per_lmul: " << lmul << '\n';
	  return false;
	}
      if (group > GroupMultiplier::Eight)
	{
	  std::cerr << "Error: Invalid lmul setting in min_bytes_per_lmul: " << lmul
		    << " (expecting non-fractional group)\n";
	  return false;
	}

      if (mewb < minBytes or mewb > maxBytes)
	{
	  std::cerr << "Error: Config file min_bytes_per_lmul ("
		    << mewb << ") must be in the range [" << minBytes
		    << "," << maxBytes << "]\n";
	  return false;
	}

      if (not isPowerOf2(mewb))
	{
	  std::cerr << "Error: config file min_bytes_per_lmul ("
		    << mewb << ") is not a power of 2\n";
	  return false;
	}

      bytesPerLmul[group] = mewb;
    }

  return true;
}

// Maximum SEW per LMUL is allowed by the spec for mf8, mf4, and mf2.
bool
processMaxBytesPerLmul(const nlohmann::json& jsonMap, unsigned minBytes, unsigned maxBytes,
		       std::unordered_map<GroupMultiplier, unsigned>& bytesPerLmul)
{
  if (not jsonMap.is_object())
    {
      std::cerr << "Error: Invalid max_bytes_per_lmul tag in config file (expecting an object)\n";
      return false;
    }

  for (auto it = jsonMap.begin(); it != jsonMap.end(); it++)
    {
      GroupMultiplier group = GroupMultiplier::One;
      std::string_view lmul = it.key();
      const unsigned mewb = it.value();  // max element width in bytes
      if (not VecRegs::to_lmul(lmul, group))
	{
	  std::cerr << "Error: Invalid lmul setting in max_bytes_per_lmul: " << lmul << '\n';
	  return false;
	}
      if (group < GroupMultiplier::Eighth)
	{
	  std::cerr << "Error: Invalid lmul setting in max_bytes_per_lmul: " << lmul
		    << " (expecting fractional group)\n";
	  return false;
	}

      if (mewb < minBytes or mewb > maxBytes)
	{
	  std::cerr << "Error: Config file max_bytes_per_lmul ("
		    << mewb << ") must be in the range [" << minBytes
		    << "," << maxBytes << "]\n";
	  return false;
	}

      if (not isPowerOf2(mewb))
	{
	  std::cerr << "Error: config file max_bytes_per_lmul  ("
		    << mewb << ") is not a power of 2\n";
	  return false;
	}

      bytesPerLmul[group] = mewb;
    }
  return true;
}


template <typename URV>
static
bool
applyVectorConfig(Hart<URV>& hart, const nlohmann::json& config)
{
  using namespace std::string_view_literals;
  using std::cerr;

  if (not config.contains("vector"))
    return true;  // Nothing to apply

  unsigned errors = 0;
  const auto& vconf = config.at("vector");

  unsigned bytesPerVec = 0;
  std::string_view tag = "bytes_per_vec";
  if (not vconf.contains(tag))
    {
      cerr << "Error: Missing " << tag << " tag in vector section of config file\n";
      errors++;
    }
  else
    {
      if (not getJsonUnsigned(tag, vconf.at(tag), bytesPerVec))
        errors++;
      else if (bytesPerVec == 0 or bytesPerVec > 4096)
        {
          cerr << "Error: Invalid config file bytes_per_vec number: "
               << bytesPerVec << '\n';
          errors++;
        }
      else if (not isPowerOf2(bytesPerVec))
	{
	  cerr << "Error: Config file bytes_per_vec ("
               << bytesPerVec << ") is not a power of 2\n";
	  errors++;
	}
      else if (bytesPerVec < hart.isaVecBytesPerReg())
        {
          cerr << "Error: Config file bytes_per_vec (" << bytesPerVec << ") is less"
               << " that that required by the isa string ("
               << hart.isaVecBytesPerReg() << ")\n";
          errors++;
        }
    }

  std::vector<unsigned> bytesPerElem = { 1, 1 };
  static constexpr auto tags = std::array{ "min_bytes_per_elem"sv, "max_bytes_per_elem"sv };
  for (size_t ix = 0; ix < tags.size(); ++ix)
    {
      unsigned bytes = 0;
      tag = tags.at(ix);
      if (not vconf.contains(tag))
	{
	  if (ix > 0)
	    {
	      std::cerr << "Error: Missing " << tag
			<< " tag in vector section of config file\n";
	      errors++;
	    }
	  continue;
	}

      if (not getJsonUnsigned(tag, vconf.at(tag), bytes))
        errors++;
      else if (bytes == 0 or bytes > bytesPerVec)
        {
          std::cerr << "Error: Invalid config file " << tag << "  number: "
                    << bytes << '\n';
          errors++;
        }
      else
        {
          if (not isPowerOf2(bytes))
            {
              std::cerr << "Error: Config file " << tag << " ("
                        << bytes << ") is not a power of 2\n";
              errors++;
            }
          else
	    bytesPerElem.at(ix) = bytes;
        }
    }

  // SEW=8 is always supported and SEW above 64 is reserved.
  if (bytesPerElem.at(0) != 1)
    {
      std::cerr << "Error: Config file min_bytes_per_elem (" << bytesPerElem.at(0)
                << ") must be 1\n";
      errors++;
    }
  if (bytesPerElem.at(1) > 8)
    {
      std::cerr << "Error: Config file max_bytes_per_elem (" << bytesPerElem.at(1)
                << ") must not be larger than 8\n";
      errors++;
    }

  std::unordered_map<GroupMultiplier, unsigned> minBytesPerLmul;
  tag = "min_sew_per_lmul";
  if (vconf.contains(tag))
    {
      std::cerr << "Error: Tag min_sew_per_lmul is deprecated: Use min_bytes_per_lmul\n";
      if (not processMinBytesPerLmul(vconf.at(tag), bytesPerElem.at(0), bytesPerElem.at(1),
				     minBytesPerLmul))
	errors++;
    }

  tag = "min_bytes_per_lmul";
  if (vconf.contains(tag))
    {
      if (not processMinBytesPerLmul(vconf.at(tag), bytesPerElem.at(0), bytesPerElem.at(1),
				     minBytesPerLmul))
	errors++;
    }

  std::unordered_map<GroupMultiplier, unsigned> maxBytesPerLmul;
  tag = "max_sew_per_lmul";
  if (vconf.contains(tag))
    {
      std::cerr << "Error: Tag max_sew_per_lmul is deprecated: Use max_bytes_per_lmul\n";
      if (not processMaxBytesPerLmul(vconf.at(tag), bytesPerElem.at(0), bytesPerElem.at(1),
				     maxBytesPerLmul))
	errors++;
    }

  tag = "max_bytes_per_lmul";
  if (vconf.contains(tag))
    {
      if (not processMaxBytesPerLmul(vconf.at(tag), bytesPerElem.at(0), bytesPerElem.at(1),
				     maxBytesPerLmul))
	errors++;
    }

  if (errors == 0)
    hart.configVector(bytesPerVec, bytesPerElem.at(0), bytesPerElem.at(1), &minBytesPerLmul,
		      &maxBytesPerLmul);

  tag = "mask_agnostic_policy";
  if (vconf.contains(tag))
    {
      const auto& item = vconf.at(tag);
      if (not item.is_string())
	{
	  std::cerr << "Error: Configuration file tag vector.mask_agnostic_policy must have a string value\n";
	errors++;
	}
      else
	{
	  std::string val = item.get<std::string>();
	  if (val == "ones")
	    hart.configMaskAgnosticAllOnes(true);
	  else if (val == "undisturb")
	    hart.configMaskAgnosticAllOnes(false);
	  else
	    {
	      std::cerr << "Error: Configuration file tag vector.mask_agnostic_policy must be 'ones' or 'undisturb'\n";
	      errors++;
	    }
	}
    }

  tag = "tail_agnostic_policy";
  if (vconf.contains(tag))
    {
      const auto& item = vconf.at(tag);
      if (not item.is_string())
	{
	  std::cerr << "Error: Configuration file tag vector.tail_agnostic_policy must have a string value\n";
	errors++;
	}
      else
	{
	  std::string val = item.get<std::string>();
	  if (val == "ones")
	    hart.configTailAgnosticAllOnes(true);
	  else if (val == "undisturb")
	    hart.configTailAgnosticAllOnes(false);
	  else
	    {
	      std::cerr << "Error: Configuration file tag vector.tail_agnostic_policy must be 'ones' or 'undisturb'\n";
	      errors++;
	    }
	}
    }

  tag = "agnostic_override_for_overlap";
  if (vconf.contains(tag))
    {
      bool flag = false;
      if (getJsonBoolean(tag, vconf.at(tag), flag))
        hart.configAgnosticOverrideForOverlap(flag);
      else
        errors++;
    }

  tag = "trap_non_zero_vstart";
  if (vconf.contains(tag))
    {
      bool flag = false;
      if (not getJsonBoolean(tag, vconf.at(tag), flag))
        errors++;
      else
        hart.enableTrapNonZeroVstart(flag);
    }

  tag = "trap_out_of_bounds_vstart";
  if (vconf.contains(tag))
    {
      bool flag = false;
      if (not getJsonBoolean(tag, vconf.at(tag), flag))
        errors++;
      else
        hart.enableTrapOobVstart(flag);
    }

  tag = "log_masked_load";
  if (vconf.contains(tag))
    {
      bool flag = false;
      if (not getJsonBoolean(tag, vconf.at(tag), flag))
        errors++;
      else
        hart.logMaskedVecLoad(flag);
    }

  tag = "log_masked_store";
  if (vconf.contains(tag))
    {
      bool flag = false;
      if (not getJsonBoolean(tag, vconf.at(tag), flag))
        errors++;
      else
        hart.logMaskedVecStore(flag);
    }

  if (errors == 0)
    hart.configVector(bytesPerVec, bytesPerElem.at(0), bytesPerElem.at(1), &minBytesPerLmul,
		      &maxBytesPerLmul);

  tag = "update_whole_mask";
  if (vconf.contains(tag))
    {
      bool flag = false;
      if (not getJsonBoolean(tag, vconf.at(tag), flag))
        errors++;
      else
        hart.configVectorUpdateWholeMask(flag);
    }

  tag = "trap_invalid_vtype";
  if (vconf.contains(tag))
    {
      bool flag = false;
      if (not getJsonBoolean(tag, vconf.at(tag), flag))
        errors++;
      else
        hart.configVectorTrapVtype(flag);
    }

  tag = "tt_fp_usum_tree_reduction";
  if (vconf.contains(tag))
    {
      const auto& items = vconf.at(tag);
      for (const auto& item : items)
	{
          if (not item.is_string())
            {
              std::cerr << "Error: Invalid value in config file item " << tag
		   << " -- expecting string\n";
              errors++;
	      continue;
            }

          std::string_view sew = item.get<std::string_view>();
          ElementWidth ew = ElementWidth::Byte;
          if (not VecRegs::to_sew(sew, ew))
            {
              std::cerr << "Error: can't convert to valid SEW: " << tag << '\n';
              errors++;
              continue;
            }
          hart.configVectorFpUnorderedSumRed(ew, true);
        }
    }

  tag = "legalize_vsetvl_avl";
  if (vconf.contains(tag))
    {
      bool flag = false;
      if (not getJsonBoolean(tag, vconf.at(tag), flag))
        errors++;
      else
        hart.configVectorLegalizeVsetvlAvl(flag);
    }

  tag = "legalize_vsetvli_avl";
  if (vconf.contains(tag))
    {
      bool flag = false;
      if (not getJsonBoolean(tag, vconf.at(tag), flag))
        errors++;
      else
        hart.configVectorLegalizeVsetvliAvl(flag);
    }

  tag = "legalize_for_egs";
  if (vconf.contains(tag))
    {
      bool flag = false;
      if (not getJsonBoolean(tag, vconf.at(tag), flag))
        errors++;
      else
        hart.configVectorLegalizeForEgs(flag);
    }

  // For backward compatibility. Use partial_segment_load and partial_segment_store
  // instead.
  tag = "partial_segment_update";
  if (vconf.contains(tag))
    {
      bool flag = false;
      if (not getJsonBoolean(tag, vconf.at(tag), flag))
        errors++;
      else
        {
          hart.configVecPartialSegLoad(flag);
          hart.configVecPartialSegStore(flag);
        }
    }

  tag = "partial_segment_load";
  if (vconf.contains(tag))
    {
      bool flag = false;
      if (not getJsonBoolean(tag, vconf.at(tag), flag))
        errors++;
      else
        hart.configVecPartialSegLoad(flag);
    }

  tag = "partial_segment_store";
  if (vconf.contains(tag))
    {
      bool flag = false;
      if (not getJsonBoolean(tag, vconf.at(tag), flag))
        errors++;
      else
        hart.configVecPartialSegStore(flag);
    }

  tag = "fp_usum_nan_canonicalize";
  if (vconf.contains(tag))
    {
      const auto& items = vconf.at(tag);
      for (const auto& item : items)
	{
          if (not item.is_string())
            {
              std::cerr << "Error: Invalid value in config file item " << tag
		   << " -- expecting string\n";
              errors++;
	      continue;
            }

          std::string_view sew = item.get<std::string_view>();
          ElementWidth ew = ElementWidth::Byte;
          if (not VecRegs::to_sew(sew, ew))
            {
              std::cerr << "Error: can't convert to valid SEW: " << tag << '\n';
              errors++;
              continue;
            }
          hart.configVectorFpUnorderedSumCanonical(ew, true);
        }
    }

  tag = "dot_product_partition";
  if (vconf.contains(tag))
    {
      const auto& dpp = vconf.at(tag);
      if (not dpp.is_object())
        {
          std::cerr << "Error: Invalid " << tag << " entry in config file (expecting an object)\n";
          errors++;
        }
      else
        for (auto it = dpp.begin(); it != dpp.end(); ++it)
          {
            std::string sewKey = it.key();
            std::string prefix = util::join("", tag, ".", sewKey);
            ElementWidth ew = ElementWidth::Byte;
            if (not VecRegs::to_sew(sewKey, ew))
              {
                std::cerr << "Error: can't convert to valid SEW: " << prefix << '\n';
                errors++;
                continue;
              }

            const auto& item = it.value();
            if (not item.is_object() or not item.contains("n"))
              {
                std::cerr << "Error: Config file " << prefix << " must be an object with an 'n' field\n";
                errors++;
                continue;
              }

            unsigned n = 0;
            if (not getJsonUnsigned<unsigned>(prefix + ".n", item.at("n"), n))
              {
                errors++;
                continue;
              }
            if (n == 0 or not isPowerOf2(n))
              {
                std::cerr << "Error: Config file " << prefix << ".n (" << n
                          << ") must be a positive power of 2\n";
                errors++;
                continue;
              }
            hart.configVectorDotProdPartitionSize(ew, n);

            if (item.contains("scheme"))
              {
                const auto& schemeItem = item.at("scheme");
                if (not schemeItem.is_string())
                  {
                    std::cerr << "Error: Config file " << prefix << ".scheme must be a string\n";
                    errors++;
                    continue;
                  }
                std::string scheme = schemeItem.get<std::string>();
                if (scheme == "linear")
                  hart.configVectorDotProdPartitionScheme(ew, DotProdPartitionScheme::Linear);
                else
                  {
                    std::cerr << "Error: Config file " << prefix << ".scheme (" << scheme
                              << ") is not a recognized partition scheme\n";
                    errors++;
                  }
              }
          }
    }

  tag = "always_mark_dirty";
  if (vconf.contains(tag))
    {
      bool flag = false;
      if (not getJsonBoolean(tag, vconf.at(tag), flag))
        errors++;
      else
        hart.configVectorAlwaysMarkDirty(flag);
    }

  tag = "always_mark_dirty_covers_load";
  if (vconf.contains(tag))
    {
      bool flag = false;
      if (not getJsonBoolean(tag, vconf.at(tag), flag))
        errors++;
      else
        hart.configVectorAlwaysMarkDirtyCoversLoad(flag);
    }

  tag = "vmvr_ignore_vill";
  if (vconf.contains(tag))
    {
      bool flag = false;
      if (not getJsonBoolean(tag, vconf.at(tag), flag))
        errors++;
      else
        hart.configVmvrIgnoreVill(flag);
    }

  tag = "tt_clear_tval_vl_egs";
  if (vconf.contains(tag))
    {
      bool flag = false;
      if (not getJsonBoolean(tag, vconf.at(tag), flag))
        errors++;
      else
        hart.enableClearMtvalOnEgs(flag);
    }

  return errors == 0;
}


template <typename URV>
static
bool
applySteeConfig(Hart<URV>& hart, const nlohmann::json& config)
{
  using std::cerr;

  if (not config.contains("stee"))
    return true;  // Nothing to apply

  unsigned errors = 0;
  const auto& sconf = config.at("stee");
  
  std::string tag = "zero_mask";
  if (sconf.contains(tag))
    {
      uint64_t mask = 0;
      if (not getJsonUnsigned(tag, sconf.at(tag), mask))
	errors++;
      else
	hart.configSteeZeroMask(mask);
    }

  tag = "secure_mask";
  uint64_t secMask = 0;
  if (sconf.contains(tag))
    {
      if (not getJsonUnsigned(tag, sconf.at(tag), secMask))
	errors++;
      else
	hart.configSteeSecureMask(secMask);
    }

  tag = "trap_insecure_read";
  if (sconf.contains(tag))
    {
      bool flag = false;
      if (not getJsonBoolean(tag, sconf.at(tag), flag))
        errors++;
      else
        hart.configSteeTrapRead(flag);
    }

  tag = "secure_region";
  if (sconf.contains(tag))
    {
      std::vector<uint64_t> vec;
      if (not getJsonUnsignedVec(tag, sconf.at(tag), vec))
	errors++;
      else
	{
	  bool complain = hart.sysHartIndex() == 0;
	  if (vec.size() != 2)
	    {
	      if (complain)
		cerr << "Error: Invalid config stee.secure_region: Expecting array of 2 integers\n";
	      errors++;
	    }
	  else
	    {
	      uint64_t low = vec.at(0), high = vec.at(1);
	      if ((low % hart.pageSize()) != 0 or (high % hart.pageSize()) != 0)
		{
		  low -= low % hart.pageSize();	  
		  high -= high % hart.pageSize();
		  if (complain)
		    {
		      cerr << "Warning: STEE secure region bounds are not page aligned\n";
		      cerr << "Warning: STEE secure region bounds changed to: [0x"
			   << std::hex << low << ", " << high << "]\n" << std::dec;
		    }
		}
	      if (((low & secMask) or (high & secMask)) and complain)
		cerr << "Warning: STEE secure region bounds have secure bit(s) set.\n";

	      if (not errors)
		hart.configSteeSecureRegion(low, high);
	    }
	}
    }

  if (not errors)
    hart.enableStee(true);

  return errors == 0;
}


/// Collect the physical memory attributes from the given json object
/// (tagged "attribs") and add them to the given Pma object.  Return
/// true on success and false on failure. Path is the hierarchical
/// name of the condig object in the JSON configuration file.
/// Sample JSON input parse in this functions:
///     "attribs" : [ "read", "write", "exec", "amo", "rsrv" ]
static
bool
getConfigPma(std::string_view path, const nlohmann::json& attribs, Pma& pma)
{
  using std::cerr;

  if (not attribs.is_array())
    {
      cerr << "Error: Invalid \"attribs\" entry in configuraion item " << path
	   << " -- expecting an array\n";
      return false;
    }

  unsigned errors = 0;

  for (const auto& attrib : attribs)
    {
      if (not attrib.is_string())
	{
	  cerr << "Error: Invalid item value in config item " << path << ".attribs"
	       << " -- expecting a string\n";
	  errors++;
	  continue;
	}

      Pma::Attrib attr = Pma::Attrib::None;
      std::string_view valueStr = attrib.get<std::string_view>();

      if (valueStr == "mag16")
        pma.setMisalAtomicGranule(16);
      else if (not Pma::stringToAttrib(valueStr, attr))
	{
	  cerr << "Error: Invalid value in config item (" << valueStr << ") "
               << path << ".attribs" << '\n';
	  errors++;
	}
      else
	pma.enable(attr);
    }

  return errors == 0;
}


template <typename URV>
static
bool
processMemMappedMasks(Hart<URV>& hart, std::string_view path, const nlohmann::json& masks,
		      uint64_t low, uint64_t high, unsigned size, Pma pma)
{
  // Parse an array of entries, each entry is an array containing low
  // address, high address, and mask.
  unsigned ix = 0;
  unsigned errors = 0;
  for (auto maskIter = masks.begin(); maskIter != masks.end(); ++maskIter, ++ix)
    {
      const auto& entry = *maskIter;
      std::string entryPath = util::join("", path, ".masks[", std::to_string(ix), "]");
      std::vector<uint64_t> vec;
      if (not getJsonUnsignedVec(entryPath, entry, vec))
	{
	  errors++;
	  continue;
	}

      if (vec.size() != 3)
	{
	  std::cerr << "Error: Expecting 3 values for config item "
		    << entryPath << '\n';
	  errors++;
	  continue;
	}

      bool ok = vec.at(0) >= low and vec.at(0) <= high;
      ok = ok and vec.at(1) >= low and vec.at(1) <= high;
      if (not ok)
	{
	  std::cerr << "Error: Mask address out of PMA region bounds for config item "
		    << entryPath << '\n';
	  errors++;
	  continue;
	}

      uint64_t mask = vec.at(2);
      for (uint64_t addr = vec.at(0); addr <= vec.at(1); addr += size)
	if (not hart.defineMemMappedRegister(addr, mask, size, pma))
	  {
	    std::cerr << "Error: Failed to configure mask for config item "
		      << entryPath << " at address 0x" << std::hex << addr
		      << std::dec << '\n';
	    errors++;
	  }
    }

  return errors == 0;
}


/// Return true if config has a defined pmacfg CSR. This is either a
/// pmacfg with no "exists" attribute or with "exists" attribute set
/// to true.
static bool
hasDefinedPmacfgCsr(const nlohmann::json& config)
{
  if (not config.contains("csr"))
    return false;  // No csr section

  const auto& csrs = config.at("csr");
  if (not csrs.is_object())
    return false;  // No csr section in this config.

  // We could have a pmacfg entry with a range of indices.
  if (csrs.contains("pmacfg"))
    {
      const auto& entry = csrs.at("pmacfg");
      if (entry.is_object())
	{
	  if (not entry.contains("exists"))
	    return true;
	  bool exists = false;
	  if (getJsonBoolean("csr.pmacfg", entry.at("exists"), exists) and exists)
	    return true;
	}
    }

  // We could have a specific pmacfg csr (example pmacfg0).
  for (unsigned i = 0; i < 16; ++i)
    {
      std::string name = "pmacfg";
      name += std::to_string(i);
      if (csrs.contains(name))
	{
	  const auto& entry = csrs.at(name);
	  if (not entry.contains("exists"))
	    return true;
	  bool exists = false;
	  if (getJsonBoolean(name + ".exists", entry.at("exists"), exists) and exists)
	    return true;
	}
    }

  return false;
}


template <typename URV>
static
bool
applyPmaConfig(Hart<URV>& hart, const nlohmann::json& config, bool hasPmacfgCsr)
{
  using std::cerr;

  if (not config.is_array())
    {
      cerr << "Error: Invalid memmap.pma entry in config file memmap (execpting an array)\n";
      return false;
    }

  unsigned memMappedCount = 0;  // Count of memory mapped entries.

  unsigned errors = 0;
  unsigned ix = 0;
  for (auto it = config.begin(); it != config.end(); ++it, ++ix)
    {
      std::string path = std::string("memmap.pma[") + std::to_string(ix) + "]";

      const auto& item = *it;
      if (not item.is_object())
	{
	  cerr << "Error: Configuration item at" << path << " is not an object\n";
	  errors++;
	  continue;
	}

      unsigned itemErrors = 0;

      std::string_view tag = "low";
      uint64_t low = 0;
      if (not item.contains(tag))
	{
	  cerr << "Error: Missing entry \"low\" in configuration item " << path << "\n";
	  errors++;
	}
      else if (not getJsonUnsigned(util::join(".", path, tag), item.at(tag), low))
	errors++;

      tag = "high";
      uint64_t high = 0;
      if (not item.contains(tag))
	{
	  cerr << "Error: Missing entry \"high\" in configuration item " << path << "\n";
	  errors++;
	}
      else if (not getJsonUnsigned(util::join(".", path, tag), item.at(tag), high))
	errors++;

      tag = "attribs";
      if (not item.contains(tag))
	{
	  cerr << "Error: Missing entry \"attribs\" in configuration item " << path << "\n";
	  errors++;
	  continue;
	}

      Pma pma;
      if (not getConfigPma(path, item.at(tag), pma))
	{
	  errors++;
	  continue;
	}

      if (not hart.definePmaRegion(ix, low, high, pma))
	{
	  errors++;
	  continue;
	}

      // The MmRegs object is shared between all harts. We process the
      // memory mapped registers in hart 0.
      if (hart.sysHartIndex() != 0)
        continue;

      if (pma.hasMemMappedReg())
	{
	  memMappedCount++;

	  unsigned size = 4;
	  tag = "register_size";
	  if (item.contains(tag))
	    {
	      auto path2 = util::join(".", path, tag);
	      if (not getJsonUnsigned(path2, item.at(tag), size))
		{
		  errors++;
		  continue;
		}
	      if (size != 4 and size != 8)
		{
		  cerr << "Error: Invalid size in config item " << path2 << '\n';
		  errors++;
		  continue;
		}
	    }  

	  if ((low & (size - 1)) != 0)
	    {
	      cerr << "Error: Memory mapped region address (0x" << std::hex
		   << low << std::dec << ") must be aligned to its size ("
		   << size << '\n';
	      errors++;
	    }

	  tag = "masks";
	  if (item.contains(tag) and not itemErrors)
	    {
	      // We associate a PMA with the memeory mapped registers. At this point the
	      // memory mapped PMA is the same as that of the enclosing region. However,
	      // the region PMA may change later as PMA-related custom CSRs get modified
	      // by CSR instructions. The memory mapped PMA has higher priority.
	      if (not processMemMappedMasks(hart, path, item.at(tag), low, high, size, pma))
		errors++;
	    }
	}
    }

  if (memMappedCount != config.size() and hasPmacfgCsr)
    if (hart.sysHartIndex() == 0)
      cerr << "Warning: Configuration file has both memmap pma "
	   << "and a pmacfg CSR. CSRs will override memmap.\n";

  return errors == 0;
}


template<typename URV>
bool
HartConfig::applyMemoryConfig(System<URV>& system, Hart<URV>& hart) const
{
  unsigned errors = 0;
  using std::cerr;

  if (config_ -> contains("memmap"))
    {
      // Apply PMA.
      const auto& memMap = config_ -> at("memmap");
      std::string_view tag = "pma";
      if (memMap.contains(tag))
	if (not applyPmaConfig(hart, memMap.at(tag), hasDefinedPmacfgCsr(*config_)))
	  errors++;

      tag = "allow_amo_in_non_cacheable_regions";
      if (memMap.contains(tag))
        {
          bool flag = false;
          if (getJsonBoolean(tag, memMap.at(tag), flag))
            hart.allowAmoInNonCachable(flag);
          else
            errors++;
        }

      tag = "allow_amo_in_io_regions";
      if (memMap.contains(tag))
        {
          bool flag = false;
          if (getJsonBoolean(tag, memMap.at(tag), flag))
            hart.allowAmoInIo(flag);
          else
            errors++;
        }

      tag = "allow_rsrv_in_non_cacheable_regions";
      if (memMap.contains(tag))
        {
          bool flag = false;
          if (getJsonBoolean(tag, memMap.at(tag), flag))
            hart.allowRsrvInNonCacheable(flag);
          else
            errors++;
        }

      tag = "allow_rsrv_in_io_regions";
      if (memMap.contains(tag))
        {
          bool flag = false;
          if (getJsonBoolean(tag, memMap.at(tag), flag))
            hart.allowRsrvInIo(flag);
          else
            errors++;
        }

      tag = "default_pma";
      if (memMap.contains(tag))
        {
          Pma pma;
          if (not getConfigPma("memmap.default_pma", memMap.at(tag), pma))
            errors++;
          else
            {
              if (pma.hasMemMappedReg())
                {
                  cerr << "Warning: Configuration file default_pma has mem_mapped"
                       << " -- mem_mapped ignored\n";
                  pma.disable(Pma::MemMapped);
                }
              hart.setDefaultPma(pma);
            }
        }
    }

  if (config_ -> contains("cache"))
    cerr << "Warning: Configuration entry 'cache' no longer supported -- ignored\n";

  std::string tag = "memory_initialization_mode";
  if (config_ -> contains(tag))
    {
      using MIM = SparseMem::InitMode;

      std::string val = config_ -> at(tag).get<std::string>();
      if (val == "zero")
        system.setSparseMemInitMode(MIM::Zero);
      else if (val == "address")
        system.setSparseMemInitMode(MIM::Addr);
      else if (val == "salt")
        {
          system.setSparseMemInitMode(MIM::Salt);
          system.setSparseMemInitSalt(0);
        }
      else if (val.starts_with("salt:"))
        {
          auto saltStr = val.substr(sizeof("salt:") - 1);
          char* end = nullptr;
          uint64_t salt = strtoull(saltStr.data(), &end, 0);
          if (end and *end)
            cerr << "Warning: Invalid memory_initialization_mode salt value '"
                 << saltStr << "' -- ignored\n";
          else
            {
              system.setSparseMemInitMode(MIM::Salt);
              system.setSparseMemInitSalt(salt);
            }
        }
      else
        cerr << "Warning: Unknown memory_initialization_mode '" << val << "' -- ignored\n";
    }

  // Temporary.
  tag = "babylon_pma";
  if (config_ -> contains(tag))
    {
      if (bool flag = false; getJsonBoolean(tag, config_ -> at(tag), flag))
        hart.enableBabylonPma(flag);
      else
        errors++;
    }

  return errors == 0;
}


template<typename URV>
bool
HartConfig::configAclint(System<URV>& system, Hart<URV>& hart, uint64_t clintStart,
                         uint64_t clintSize, uint64_t mswiOffset, bool hasMswi,
                         uint64_t mtimeCmpOffset, uint64_t mtimeOffset, bool hasMtimer,
		         bool siOnReset, bool deliverInterrupts) const
{
  // Define callback to recover a hart from a hart index. We do
  // this to avoid having the Hart class depend on the System class.
  auto indexToHart = [&system](unsigned ix) -> Hart<URV>* {
    return system.ithHart(ix).get();
  };

  hart.configAclint(clintStart, clintSize, clintStart + mswiOffset, hasMswi,
		    clintStart + mtimeCmpOffset, clintStart + mtimeOffset, hasMtimer,
		    siOnReset, deliverInterrupts, indexToHart);
  return true;
}


template <typename URV>
bool
HartConfig::applyAplicConfig(System<URV>& system) const
{
  std::string_view tag = "aplic";
  if (not config_ -> contains(tag))
    return true;  // Nothing to apply

  const auto& aplic_cfg = config_ -> at(tag);

  URV num_sources;

  for (std::string_view tag : { "num_sources", "domains" } )
    {
      if (not aplic_cfg.contains(tag))
        {
          std::cerr << "Error: Missing " << tag << " field in aplic section of configuration file.\n";
          return false;
        }
    }

  tag = "num_sources";
  if (not getJsonUnsigned("aplic.num_sources", aplic_cfg.at(tag), num_sources))
    return false;

  tag = "domains";
  const auto& domains = aplic_cfg.at(tag);
  std::vector<TT_APLIC::DomainParams> domain_params_list;

  // used for error checking:
  std::unordered_map<std::string, std::vector<int>> child_indices;
  std::unordered_set<std::string> domain_names;
  int num_roots = 0;

  for (const auto& el : domains.items())
    {
      TT_APLIC::DomainParams domain_params;
      domain_params.name = el.key();
      const auto& domain = el.value();

      if (domain_params.name.empty())
        {
          std::cerr << "Error: the empty string is not a valid domain name.\n";
          return false;
        }
      if (domain_names.find(domain_params.name) != domain_names.end())
        {
          std::cerr << "Error: domain names must be unique.\n";
          return false;
        }
      domain_names.insert(domain_params.name);

      for (std::string_view tag : { "base", "size", "is_machine" } )
        {
          if (not domain.contains(tag))
            {
              std::cerr << "Error: Missing " << tag << " field for domain '" << domain_params.name << "' in configuration file.\n";
              return false;
            }
        }

      if (not getJsonUnsigned("base", domain.at("base"), domain_params.base))
        return false;

      if (not getJsonUnsigned("size", domain.at("size"), domain_params.size))
        return false;

      // The 'parent' field is optional: omitting it (or setting it to null)
      // makes this the root domain. This is required so that merge_patch of
      // multiple config files works, since a null value deletes a key/value
      // pair when merging.
      tag = "parent";
      if (domain.contains(tag))
        {
          const auto& parent = domain.at(tag);
          if (parent.is_string())
            {
              domain_params.parent = parent.get<std::string>();
              if (domain_params.parent == "")
                {
                  std::cerr << "Error: domain '" << domain_params.name << "' uses the empty string for parent domain name; omit the 'parent' field (or set it to null) to make this the root domain.\n";
                  return false;
                }
            }
          else if (not parent.is_null())
            {
              std::cerr << "Error: domain '" << domain_params.name << "' has a 'parent' field that is neither a string nor null.\n";
              return false;
            }
        }

      tag = "child_index";
      URV child_index = 0; // default
      if (domain.contains(tag) and not getJsonUnsigned(tag, domain.at(tag), child_index))
        return false;
      domain_params.child_index = child_index;
      if (domain_params.parent.has_value())
        {
          auto& indices = child_indices[domain_params.parent.value()];
          indices.push_back(child_index);
          std::sort(indices.begin(), indices.end());
        }
      else
        num_roots++;

      tag = "is_machine";
      bool is_machine = false;
      if (not getJsonBoolean(tag, domain.at(tag), is_machine))
        return false;
      domain_params.privilege = is_machine ? TT_APLIC::Machine : TT_APLIC::Supervisor;

      domain_params.hart_indices = {};
      tag = "hart_indices";
      if (domain.contains(tag))
        {
          for (const auto& index : domain.at(tag))
            domain_params.hart_indices.push_back(index.get<unsigned>());
        }

      domain_params_list.push_back(domain_params);
    }

  // error-checking on child indices
  for (const auto& ci : child_indices)
    {
      bool valid = true;
      const auto& indices = ci.second;
      if (indices[0] != 0)
        valid = false;
      for (size_t i = 1; i < indices.size(); i++)
        {
          if (indices[i] != indices[i-1]+1)
            valid = false;
        }
      if (not valid)
        {
          std::cerr << "Error: domain '" << ci.first << "' has invalid child indices: ";
          for (auto i : indices)
            std::cerr << i << " ";
          std::cerr << "Error: \n";
          return false;
        }
    }

  for (const auto& dp : domain_params_list)
    {
      if (dp.parent.has_value() and not domain_names.contains(dp.parent.value()))
        {
          std::cerr << "Error: domain '" << dp.name << "' refers to a non-existent parent, '" << dp.parent.value() << "'.\n";
          return false;
        }
    }

  if (num_roots != 1)
    {
      std::cerr << "Error: expected exactly 1 root domain; found " << num_roots << ".\n";
      return false;
    }

  return system.configAplic(num_sources, domain_params_list);
}


template <typename URV>
bool
HartConfig::applyAclicConfig(System<URV>& system) const
{
  auto& hart0 = *system.ithHart(0);

  bool hasSmidctrl = hart0.extensionIsEnabled(RvExtension::Smidctrl);
  bool hasSsidctrl = hart0.extensionIsEnabled(RvExtension::Ssidctrl);

  std::string_view tag = "aclic";
  if (not config_ -> contains(tag))
    return true;  // Nothing to apply

  if (not hasSmidctrl)
    {
      std::cerr << "Error: Cannot configure ACLIC without enabling Smidctrl\n";
      return false;
    }

  const auto& aclic_cfg = config_ -> at(tag);

  if (not aclic_cfg.contains("num_sources"))
    {
      std::cerr << "Error: Missing num_sources field in aclic section of configuration file.\n";
      return false;
    }

  TT_ACLIC::AclicParams params;

  URV num_sources = 0;
  if (not getJsonUnsigned("aclic.num_sources", aclic_cfg.at("num_sources"), num_sources))
    return false;
  params.numSources = static_cast<unsigned>(num_sources);

  // has_supervisor_domain is inferred from Ssidctrl being in the ISA.
  params.hasSupervisorDomain = hasSsidctrl;
  if (aclic_cfg.contains("has_supervisor_domain"))
    {
      bool flag = false;
      if (not getJsonBoolean("has_supervisor_domain", aclic_cfg.at("has_supervisor_domain"), flag))
        return false;
      if (flag != hasSsidctrl)
        std::cerr << "Warning: aclic.has_supervisor_domain=" << (flag ? "true" : "false")
                  << " conflicts with ISA (Ssidctrl "
                  << (hasSsidctrl ? "present" : "absent")
                  << "); using ISA value\n";
    }

  if (aclic_cfg.contains("ipriolen"))
    {
      URV ipriolen = 0;
      if (not getJsonUnsigned("aclic.ipriolen", aclic_cfg.at("ipriolen"), ipriolen))
        return false;
      params.ipriolen = static_cast<unsigned>(ipriolen);
    }

  return system.configAclic(params);
}


template <typename URV>
bool
HartConfig::applyIommuConfig(System<URV>& system) const
{
  std::string_view tag = "iommu";
  if (not config_ -> contains(tag))
    return true;  // Nothing to apply

  const auto& iommu_cfg = config_ -> at(tag);

  for (std::string_view tag : { "base", "size", "capabilities" } )
    {
      if (not iommu_cfg.contains(tag))
        {
          std::cerr << "Error: Missing " << tag << " field in iommu section of configuration file.\n";
          return false;
        }
    }

  TT_IOMMU::Iommu::Parameters params;

#define EXTRACT(type, tag, variable) \
  if (iommu_cfg.contains(tag) and not getJson ## type(tag, iommu_cfg.at(tag), variable)) \
    return false;

  EXTRACT(Unsigned, "base",                   params.baseAddress)
  EXTRACT(Unsigned, "size",                   params.size)
  EXTRACT(Unsigned, "capabilities",           params.capabilities)
  EXTRACT(Unsigned, "fctl",                   params.fctl)
  EXTRACT(Boolean,  "auto_process_commands",  params.autoProcessCommands)
  EXTRACT(Boolean,  "ddtp_1lvl_legal",        params.ddtp1LvlLegal)
  EXTRACT(Boolean,  "ddtp_2lvl_legal",        params.ddtp2LvlLegal)
  EXTRACT(Boolean,  "ddtp_3lvl_legal",        params.ddtp3LvlLegal)
  EXTRACT(Unsigned, "ddt_cache_size",         params.ddtCacheSize)
  EXTRACT(Unsigned, "pdt_cache_size",         params.pdtCacheSize)
  EXTRACT(Unsigned, "rcid_width",             params.rcidWidth)
  EXTRACT(Unsigned, "mcid_width",             params.mcidWidth)
  EXTRACT(Unsigned, "num_hpm",                params.numHpm)
  EXTRACT(Unsigned, "hpm_width",              params.hpmWidth)
  EXTRACT(Unsigned, "num_int_vec",            params.numIntVec)

  unsigned tlbSize = 2048;
  EXTRACT(Unsigned, "tlb_size",               tlbSize)

  unsigned aplic_source = 0;
  EXTRACT(Unsigned, "aplic_source",           aplic_source)

#undef EXTRACT

  // Error checking

  TT_IOMMU::Capabilities capabilities { .value = params.capabilities };

  if (capabilities.fields.igs != unsigned(TT_IOMMU::IgsMode::Msi) and not iommu_cfg.contains("aplic_source"))
    {
      std::cerr << "Error: In IOMMU config, capabilities.IGS supports WSI but 'aplic_source' not specified.\n";
      return false;
    }

  params.memorySize = 1ull << capabilities.fields.pas;

  return system.configIommu(params, tlbSize, aplic_source);
}

/// Helper function that converts a JSON array of interrupt identifiers into a vector of
/// InterruptCause values. Return true on success and false on parse errors.
static bool
parseInterruptArray(const nlohmann::json &arr, const std::string &context,
                    bool quiet, std::vector<InterruptCause>& vec)
{
  unsigned errors = 0;
  for (const auto &item : arr)
    {
      auto ic = InterruptCause{};
      if (item.is_number())
        {
          unsigned num = item.get<unsigned>();
          ic = static_cast<InterruptCause>(num);
        }
      else if (item.is_string())
        {
          std::string s = item.get<std::string>();
          std::transform(s.begin(), s.end(), s.begin(), ::tolower);
          if (s == "ssi")              ic = InterruptCause::S_SOFTWARE;
          else if (s == "vssi")        ic = InterruptCause::VS_SOFTWARE;
          else if (s == "msi")         ic = InterruptCause::M_SOFTWARE;
          else if (s == "sti")         ic = InterruptCause::S_TIMER;
          else if (s == "vsti")        ic = InterruptCause::VS_TIMER;
          else if (s == "mti")         ic = InterruptCause::M_TIMER;
          else if (s == "sei")         ic = InterruptCause::S_EXTERNAL;
          else if (s == "vsei")        ic = InterruptCause::VS_EXTERNAL;
          else if (s == "mei")         ic = InterruptCause::M_EXTERNAL;
          else if (s == "sgei")        ic = InterruptCause::G_EXTERNAL;
          else if (s == "lcofi")       ic = InterruptCause::LCOF;
          else
            {
              if (not quiet)
                std::cerr << "Error: Unknown interrupt symbol in " << context << ": " << s << "\n";
              errors++;
              continue;
            }
        }
      else
        {
          if (not quiet)
            std::cerr << "Error: Invalid element in " << context << " (expecting number or string)\n";
          errors++;
          continue;
        }
      if (std::find(vec.begin(), vec.end(), ic) != vec.end())
        {
          if (not quiet)
            std::cerr << "Warning: Duplicate interrupt entry in " << context << ": "
                      << static_cast<unsigned>(ic) << "\n";
          continue;
        }
      vec.push_back(ic);
    }
  return errors == 0;
}


#if REMOTE_FRAME_BUFFER
template<typename URV>
bool
HartConfig::applyFrameBufferConfig(System<URV>& system) const
{
  std::string_view tag = "frame_buffer";
  if (not config_ -> contains(tag)) 
    {
      return true;
    }

  std::cout << "Configuring frame buffer\n";

  const auto& frame_buffer_cfg = config_ -> at(tag);

  std::string type = "";
  uint64_t base, width, height, bytes_per_pixel = 0, port = 5998;

  tag = "type";
  if (frame_buffer_cfg.contains(tag))
    {
      type = frame_buffer_cfg.at(tag).get<std::string>();
    }
  else
    {
      std::cerr << "Error: Missing type field in frame_buffer section of configuration file.\n";
      return false;
    }

  tag = "base";
  if (frame_buffer_cfg.contains(tag))
    {
      if (not getJsonUnsigned("frame_buffer.base", frame_buffer_cfg.at(tag), base))
        return false;
    }
  else
    {
      std::cerr << "Error: Missing base field in frame_buffer section of configuration file.\n";
      return false;
    }

  tag = "width";
  if (frame_buffer_cfg.contains(tag))
    {
      if (not getJsonUnsigned("frame_buffer.width", frame_buffer_cfg.at(tag), width))
        return false;
    }
  else
    {
      std::cerr << "Error: Missing width field in frame_buffer section of configuration file.\n";
      return false;
    }

  tag = "height";
  if (frame_buffer_cfg.contains(tag))
    {
      if (not getJsonUnsigned("frame_buffer.height", frame_buffer_cfg.at(tag), height))
        return false;
    }
  else
    {
      std::cerr << "Error: Missing height field in frame_buffer section of configuration file.\n";
      return false;
    }

  tag = "bytes_per_pixel";
  if (frame_buffer_cfg.contains(tag))
    {
      if (not getJsonUnsigned("frame_buffer.bytes_per_pixel", frame_buffer_cfg.at(tag), bytes_per_pixel))
        return false;
    }
  else
    {
      std::cerr << "Error: Missing bytes_per_pixel field in frame_buffer section of configuration file.\n";
      return false;
    }

  tag = "port";
  if (frame_buffer_cfg.contains(tag))
    {
      if (not getJsonUnsigned("frame_buffer.port", frame_buffer_cfg.at(tag), port))
        return false;
    }

  return system.defineFrameBuffer(type, base, width, height, bytes_per_pixel, port);
}
#endif


template<typename URV>
bool
HartConfig::applyConfig(Hart<URV>& hart, bool userMode, bool verbose,
                        std::string_view effectiveIsa) const
{
  using std::cerr;
  unsigned errors = 0;

  // Define PC value after reset.
  std::string_view tag = "reset_vec";
  if (config_ -> contains(tag))
    {
      URV resetPc = 0;
      if (getJsonUnsigned(tag, config_ -> at(tag), resetPc))
        hart.defineResetPc(resetPc);
      else
        errors++;
    }

  // Define non-maskable-interrupt pc
  tag = "nmi_vec";
  if (config_ -> contains(tag))
    {
      URV nmiPc = 0;
      if (getJsonUnsigned(tag, config_ -> at(tag), nmiPc))
        hart.defineNmiPc(nmiPc);
      else
        errors++;
    }

  // Define exception-pc non-maskable-interrupt
  tag = "nmi_exception_vec";
  if (config_ -> contains(tag))
    {
      URV pc = 0;
      if (getJsonUnsigned(tag, config_ -> at(tag), pc))
        hart.defineNmiExceptionPc(pc);
      else
        errors++;
    }

  // PC after an NMI is nmi_vec when this is false; otherwise, it is
  // nmi_vec + cause*4. Similarly after an exception while in the
  // nmi interrupt handler, the PC is is nmi_excetion_vec when this is
  // false; otherwise, it is nmi_exception_vec + cause*4.
  bool flag = false;
  tag = "indexed_nmi";
  if (config_ -> contains(tag))
    {
      getJsonBoolean(tag, config_->at(tag), flag) or errors++;
      hart.indexedNmi(flag);
    }

  // Use ABI register names (e.g. sp instead of x2).
  tag = "abi_names";
  if (config_ -> contains(tag))
    {
      getJsonBoolean(tag, config_->at(tag), flag) or errors++;
      hart.enableAbiNames(flag);
    }

  // Trace page table walk in log.
  tag = "trace_ptw";
  if (config_ -> contains(tag))
    {
      getJsonBoolean(tag, config_ ->at(tag), flag) or errors++;
      hart.tracePtw(flag);
    }

  // We avoid repeating some config errors by printing them only for hart0.
  bool hart0 = hart.sysHartIndex() == 0;

  // Reservation size in bytes for the load-reserve (LR) instruction.
  // Default is 4 for rv32 and 8 for rv64. A reservation size smaller
  // than default has no effect.
  tag = "reservation_bytes";
  if (config_ -> contains(tag))
    {
      unsigned resBytes = sizeof(URV);
      if (getJsonUnsigned(tag, config_ ->at(tag), resBytes))
	{
	  if (isPowerOf2(resBytes))
	    hart.configReservationSize(resBytes);
	  else
	    {
              if (hart0)
                cerr << "Error: Config file reservation_bytes ("
                     << resBytes << ") is not a power of 2\n";
	      errors++;
	    }
	}
      else
	errors++;
    }

  // Keep reservation on exception in SC.W/D.
  tag = "keep_reservation_on_sc_exception";
  if (config_ -> contains(tag))
    {
      getJsonBoolean(tag, config_ ->at(tag), flag) or errors++;
      hart.keepReservationOnScException(flag);
    }

  // Enable performance counters.
  tag = "enable_performance_counters";
  if (config_ -> contains(tag))
    {
      if (hart0)
        cerr << "Warning: Config file tag \"" << tag << "\" deprecated: "
             << "Add extension string \"zicntr\" to \"isa\" tag instead.\n";
    }

  tag = "perf_count_atomic_load_store";
  if (config_ -> contains(tag))
    {
      getJsonBoolean(tag, config_ ->at(tag), flag) or errors++;
      hart.perfCountAtomicLoadStore(flag);
    }

  tag = "perf_count_fp_load_store";
  if (config_ -> contains(tag))
    {
      getJsonBoolean(tag, config_ ->at(tag), flag) or errors++;
      hart.perfCountFpLoadStore(flag);
    }

  tag = "perf_count_fp_load_store";
  if (config_ -> contains(tag))
    {
      getJsonBoolean(tag, config_ ->at(tag), flag) or errors++;
      hart.perfCountFpLoadStore(flag);
    }

  tag = "perf_count_fp_load_store_as_fp";
  if (config_ -> contains(tag))
    {
      getJsonBoolean(tag, config_ ->at(tag), flag) or errors++;
      hart.perfCountFpLoadStoreAsFp(flag);
    }

  tag = "perf_count_vec_load_store_as_vec";
  if (config_ -> contains(tag))
    {
      getJsonBoolean(tag, config_ ->at(tag), flag) or errors++;
      hart.perfCountVecLoadStoreAsVec(flag);
    }

  for (std::string_view ztag : { "zba", "zbb", "zbc", "zbs", "zfh" , "zfhmin", "zknd",
                                 "zkne", "zknh", "zbkb", "zbkx", "zksed", "zksh"} )
    {
      std::string etag = util::join("", "enable_", ztag);
      if (config_ -> contains(etag) and hart0)
	cerr << "Warning: Config file tag \"" << etag << "\" deprecated: "
	     << "Add extension string \"" << ztag << "\" to \"isa\" tag instead.\n";
    }

  for (std::string_view ztag : { "zbe", "zbf", "zbm", "zbp", "zbr", "zbt" } )
    {
      std::string etag = util::join("", "enable_", ztag);
      if (config_ -> contains(etag) and hart0)
	cerr << "Warning: Config file tag \"" << etag << "\" is no longer supported.\n";
    }

  // Counter overflow: sscofpmf extension. Use the isa in effect if given.
  std::string isa{effectiveIsa};
  if (isa.empty())
    getIsa(isa);
  bool cof = isa.find("sscofpmf") != std::string::npos;

  tag = "enable_counter_overflow";
  if (config_ ->contains(tag))
    {
      if (hart0)
        cerr << "Warning: Config file tag \"enable_counter_overflow\" deprecated: "
             << " Add extension string \"sscofpmf\" to \"isa\" tag instread.\n";
      getJsonBoolean(tag, config_ ->at(tag), cof) or errors++;
    }

  applyPerfEvents(hart, *config_, userMode, cof, verbose) or errors++;
  applyCsrConfig(hart, *config_, verbose) or errors++;

  // After CSR config so the alias picks up scontext's mask and reset value.
  // Implemented state follows scontext, which enableSdtrig sets once the ISA is applied.
  tag = "enable_mscontext";
  if (config_ -> contains(tag))
    {
      bool mscontext = false;
      getJsonBoolean(tag, config_ -> at(tag), mscontext) or errors++;
      hart.enableMscontext(mscontext);
    }

  applyTriggerConfig(hart, *config_) or errors++;
  applySdtrigConfig(hart, *config_) or errors++;

  // No longer needed here. Remove once enable_counter_overflow is removed.
  hart.enableSscofpmf(cof);

  tag = "trap_non_zero_vstart";
  if (config_ ->contains(tag))
    {
      if (hart0)
        cerr << "Warning: Configuration tag trap_non_zero_vstart should be in vector section.\n";
      bool flag = false;
      if (not getJsonBoolean(tag, config_ ->at(tag), flag))
        errors++;
      else
        hart.enableTrapNonZeroVstart(flag);
    }
  applyVectorConfig(hart, *config_) or errors++;

  applySteeConfig(hart, *config_) or errors++;

  tag = "memmap";
  if (config_ -> contains(tag))
    {
      const auto& memmap = config_ -> at(tag);
      tag = "consoleio";
      if (memmap.contains(tag))
	{
          URV io = 0;
          if (getJsonUnsigned("memmap.consoleio", memmap.at(tag), io))
            hart.setConsoleIo(io);
          else
            errors++;
	}
    }

  tag = "physical_memory_protection_grain";
  if (config_ -> contains(tag))
    {
      uint64_t size = 0;
      if (getJsonUnsigned<uint64_t>(tag, config_ -> at(tag), size))
        hart.configMemoryProtectionGrain(size);
      else
        errors++;
    }

  tag = "guest_interrupt_count";
  if (config_ -> contains(tag))
    {
      uint64_t size = 0;
      if (not getJsonUnsigned<uint64_t>(tag, config_ -> at(tag), size))
        errors++;
      else if (size >= sizeof(URV)*8)
        {
          std::cerr << "Error: Config file " << tag << " (" << size << ") must be less than XLEN.\n";
          errors++;
        }
      else
        hart.configGuestInterruptCount(size);
    }
  else if (config_ -> contains("imsic") and config_ -> at("imsic").contains("guests"))
    {
      // Unless guest_interrupt_count sets it, a hart's GEILEN is its number of guest
      // interrupt files. This must be done here (before configIsa/setDefaultMasks) because
      // the HGEIE/HGEIP masks are derived from GEILEN and are not changed afterwards.
      uint64_t guests = 0;
      if (getJsonUnsigned<uint64_t>("imsic.guests", config_ -> at("imsic").at("guests"), guests))
        hart.configGuestInterruptCount(guests);
      else
        errors++;
    }

  tag = "coherent_icache";
  if (config_ -> contains(tag))
    {
      getJsonBoolean(tag, config_ ->at(tag), flag) or errors++;
      hart.setCoherentIcache(flag);
    }

  tag = "enable_misaligned_data";
  if (config_ -> contains(tag))
    {
      getJsonBoolean(tag, config_ ->at(tag), flag) or errors++;
      hart.enableMisalignedData(flag);
    }

  tag = "misaligned_has_priority";
  if (config_ -> contains (tag))
    {
      getJsonBoolean(tag, config_ ->at(tag), flag) or errors++;
      hart.misalignedExceptionHasPriority(flag);
    }

  tag = "in_sequence_misaligned";
  if (config_ -> contains(tag))
    {
      getJsonBoolean(tag, config_ ->at(tag), flag) or errors++;
      hart.enableInSeqnMisaligned(flag);
    }

  tag = "force_rounding_mode";
  if (config_ -> contains(tag))
    {
      std::string_view str = config_->at(tag).get<std::string_view>();
      if (str == "rne")
	hart.forceRoundingMode(RoundingMode::NearestEven);
      else if (str == "rtz")
	hart.forceRoundingMode(RoundingMode::Zero);
      else if (str == "rdn")
	hart.forceRoundingMode(RoundingMode::Down);
      else if (str == "rup")
	hart.forceRoundingMode(RoundingMode::Up);
      else if (str == "rmm")
	hart.forceRoundingMode(RoundingMode::NearestMax);
      else
	{
          if (hart0)
            cerr << "Error: Invalid force_rounding_mode config: " << str << '\n';
	  errors++;
	}
    }

  tag = "enable_csv_log";
  if (config_ -> contains(tag))
    {
      getJsonBoolean(tag, config_ -> at(tag), flag) or errors++;
      hart.enableCsvLog(flag);
    }

  tag = "page_fault_on_first_access";
  if (config_ -> contains(tag))
    {
      if (hart.sysHartIndex() == 0 and hart0)
	cerr << "Warning: Config tag " << tag << " is deprecated -- "
	     << "feature is now controlled by bit 61 of the MENVCFG/HENVCFG CSR.\n";
      getJsonBoolean(tag, config_ -> at(tag), flag) or errors++;
      // hart.setFaultOnFirstAccess(flag);
    }

  tag = "snapshot_periods";
  if (config_ -> contains(tag))
    {
      std::vector<uint64_t> periods;
      if (not getJsonUnsignedVec(tag, config_ -> at(tag), periods))
        errors++;
      else
        {
          std::sort(periods.begin(), periods.end());
          if (std::find(periods.begin(), periods.end(), 0)
                          != periods.end())
            {
              if (hart0)
                cerr << "Warning: Snapshot periods of 0 are ignored\n";
              periods.erase(std::remove(periods.begin(), periods.end(), 0), periods.end());
            }

          auto it = std::unique(periods.begin(), periods.end());
          if (it != periods.end())
            {
              periods.erase(it, periods.end());
              if (hart0)
                cerr << "Warning: Duplicate snapshot periods not supported, removed duplicates\n";
            }
        }
    }

  tag = "tlb_entries";
  if (config_ -> contains(tag))
    {
      unsigned size = 0;
      if (not getJsonUnsigned(tag, config_ -> at(tag), size))
        errors++;
      else
      {
        if ((size & (size - 1)) != 0)
          {
            if (hart0)
              cerr << "Error: TLB size must be a power of 2\n";
            errors++;
          }
        else
          hart.setTlbSize(size);
      }
    }

  tag = "clear_mprv_on_ret";
  if (config_ -> contains(tag) and hart0)
    cerr << "Warning: Config tag \"" << tag << "\" is deprecated and no longer has any effect\n";

  tag = "clear_mtval_on_illegal_instruction";
  if (config_ -> contains(tag))
    {
      if (not getJsonBoolean(tag, config_ -> at(tag), flag))
        errors++;
      else
        hart.enableClearMtvalOnIllInst(flag);
    }

  // Default false: trap on unimplemented *iselect (spec recommended). True: no-op
  // (read-zero / write-ignore) to match implementations that treat the unspecified
  // behavior that way (e.g. current Babylon RTL).
  tag = "nop_ireg_on_oob_iselect";
  if (config_ -> contains(tag))
    {
      if (not getJsonBoolean(tag, config_ -> at(tag), flag))
        errors++;
      else
        hart.enableNopIregOnOobIselect(flag);
    }

  tag = "clear_mtval_on_ebreak";
  if (config_ -> contains(tag))
    {
      if (not getJsonBoolean(tag, config_ -> at(tag), flag))
        errors++;
      else
        hart.enableClearMtvalOnEbreak(flag);
    }

  tag = "clear_tinst_on_cbo_inval";
  if (config_ -> contains(tag))
    {
      if (not getJsonBoolean(tag, config_ -> at(tag), flag))
        errors++;
      else
        hart.enableClearTinstOnCboInval(flag);
    }

  tag = "clear_tinst_on_cbo_flush";
  if (config_ -> contains(tag))
    {
      if (not getJsonBoolean(tag, config_ -> at(tag), flag))
        errors++;
      else
        hart.enableClearTinstOnCboFlush(flag);
    }

  tag = "clear_tinst_on_lrsc";
  if (config_ -> contains(tag))
    {
      if (not getJsonBoolean(tag, config_ -> at(tag), flag))
        errors++;
      else
        hart.enableClearTinstOnLrSc(flag);
    }

  tag = "align_cbo_address";
  if (config_ -> contains(tag))
    {
      if (not getJsonBoolean(tag, config_ -> at(tag), flag))
        errors++;
      else
        hart.enableAlignCboAddress(flag);
    }

  // Same as above, but this is used to apply a scaling factor
  // instead of a simple shift.
  tag = "time_down_sample";
  if (config_ ->contains(tag))
    {
      unsigned n = 0;
      if (not getJsonUnsigned(tag, config_ -> at(tag), n))
	errors++;
      else
	hart.setTimeDownSample(n);
    }

  tag = "cancel_lr_on_ret";
  if (config_ -> contains(tag))
    {
      if (hart0)
        cerr << "Warning: Config tag \"cancel_lr_on_ret\" is deprecated. Use cancel_lr_on_trap.\n";
      if (not getJsonBoolean(tag, config_ -> at(tag), flag))
        errors++;
      else
        hart.enableCancelLrOnTrap(flag);
    }

  tag = "cancel_lr_on_trap";
  if (config_ -> contains(tag))
    {
      if (not getJsonBoolean(tag, config_ -> at(tag), flag))
        errors++;
      else
        hart.enableCancelLrOnTrap(flag);
    }

  tag = "cancel_lr_on_debug";
  if (config_ -> contains(tag))
    {
      if (not getJsonBoolean(tag, config_ -> at(tag), flag))
        errors++;
      else
        hart.enableCancelLrOnDebug(flag);
    }

  tag = "debug_park_loop";
  if (config_ -> contains(tag))
    {
      URV dep = 0;
      if (not getJsonUnsigned(tag, config_ -> at(tag), dep))
        errors++;
      else
        hart.setDebugParkLoop(dep);
    }

  tag = "debug_trap_address";
  if (config_ -> contains(tag))
    {
      URV addr = 0;
      if (not getJsonUnsigned(tag, config_ -> at(tag), addr))
        errors++;
      else
        hart.setDebugTrapAddress(addr);
    }

  tag = "debug_mode_xret_illegal";
  if (config_ -> contains(tag))
    {
      if (not getJsonBoolean(tag, config_ -> at(tag), flag))
        errors++;
      else
        hart.enableDebugModeXretIllegal(flag);
    }

  tag = "fs_dirty_without_flags";
  if (config_ -> contains(tag))
    {
      if (not getJsonBoolean(tag, config_ -> at(tag), flag))
        errors++;
      else
        hart.enableFsDirtyWithoutFlags(flag);
    }

  tag = "trace_pmp";
  if (config_ -> contains(tag))
    {
      getJsonBoolean(tag, config_ ->at(tag), flag) or errors++;
      hart.tracePmp(flag);
    }

  tag = "trace_pma";
  if (config_ -> contains(tag))
    {
      getJsonBoolean(tag, config_ ->at(tag), flag) or errors++;
      hart.tracePma(flag);
    }

  tag = "enable_pmp_tor";
  if (config_ -> contains(tag))
    {
      getJsonBoolean(tag, config_ ->at(tag), flag) or errors++;
      hart.enablePmpTor(flag);
    }

  tag = "enable_pmp_na4";
  if (config_ -> contains(tag))
    {
      getJsonBoolean(tag, config_ ->at(tag), flag) or errors++;
      hart.enablePmpNa4(flag);
    }

  tag = "address_translation_modes";
  if (config_ -> contains(tag))
    {
      unsigned atmErrors = 0;
      std::vector<VirtMem::Mode> modes;
      const auto& atm = config_ -> at(tag);
      for (const auto& item : atm)
	{
	  if (not item.is_string())
	    {
              if (hart0)
                cerr << "Error: Invalid value in config file item " << tag
                     << " -- expecting string\n";
	      atmErrors++;
	      continue;
	    }
	  std::string_view modeStr = item.get<std::string_view>();
	  VirtMem::Mode mode = VirtMem::Mode::Bare;
	  if (not VirtMem::to_mode(modeStr, mode))
	    {
              if (hart0)
                cerr << "Error: Error no such address translation mode: " << tag << '\n';
	      atmErrors++;
	      continue;
	    }
	  using VM = VirtMem::Mode;
	  bool legal = mode == VM::Bare;
	  if constexpr (sizeof(URV) == 4)
	    legal = legal or mode == VM::Sv32;
	  else
	    legal = legal or mode == VM::Sv39 or mode == VM::Sv48 or mode == VM::Sv57;
	  if (not legal)
	    {
              if (hart0)
                cerr << "Error: Address translation mode " << modeStr << " in config file "
                     << tag << " is not supported for XLEN=" << sizeof(URV)*8 << '\n';
	      atmErrors++;
	      continue;
	    }
	  modes.push_back(mode);
	}
      if (std::find(modes.begin(), modes.end(), VirtMem::Mode::Bare) == modes.end())
	{
          if (hart0)
            cerr << "Warning: Bare mode missing in config file address_translation_modes -- adding it\n";
	  modes.push_back(VirtMem::Mode::Bare);
	}
      auto has = [&modes](VirtMem::Mode m) {
        return std::find(modes.begin(), modes.end(), m) != modes.end();
      };
      // Sv48 requires Sv39 and Sv57 requires Sv48.
      if (has(VirtMem::Mode::Sv48) and not has(VirtMem::Mode::Sv39))
	{
          if (hart0)
            cerr << "Error: Address translation mode sv48 in config file " << tag
                 << " requires sv39\n";
	  atmErrors++;
	}
      if (has(VirtMem::Mode::Sv57) and not has(VirtMem::Mode::Sv48))
	{
          if (hart0)
            cerr << "Error: Address translation mode sv57 in config file " << tag
                 << " requires sv48\n";
	  atmErrors++;
	}
      if (not atmErrors)
	hart.configAddressTranslationModes(modes);
      errors += atmErrors;
    }

  tag = "address_translation_pmms";
  if (config_ -> contains(tag))
    {
      unsigned atpErrors = 0;
      std::vector<PmaskManager::Mode> pmms;
      const auto& items = config_ -> at(tag);
      for (const auto& item : items)
	{
	  if (not item.is_string())
	    {
              if (hart0)
                cerr << "Error: Invalid value in config file item " << tag << " -- expecting string\n";
	      atpErrors++;
	      continue;
	    }
	  std::string_view pmmStr = item.get<std::string_view>();
	  PmaskManager::Mode pmm{};
	  if (not PmaskManager::to_pmm(pmmStr, pmm))
	    {
              if (hart0)
                cerr << "Error: Error no such address translation pmm: " << tag << '\n';
	      atpErrors++;
	      continue;
	    }
	  pmms.push_back(pmm);
	}
      if (not atpErrors)
	hart.configAddressTranslationPmms(pmms);
      errors += atpErrors;
    }

  tag = "enable_translation_pbmt";
  if (config_ -> contains(tag))
    {
      getJsonBoolean(tag, config_ ->at(tag), flag) or errors++;
      hart.enableTranslationPbmt(flag);
    }

  tag = "enable_pbmt";
  if (config_ -> contains(tag))
    {
      if (hart0)
        cerr << "Config file tag enable_pbmt has been deprecated. Use enable_translation_pbmt.\n";
      getJsonBoolean(tag, config_ ->at(tag), flag) or errors++;
      hart.enableTranslationPbmt(flag);
      errors++;
    }      

  tag = "enable_translation_napot";
  if (config_ -> contains(tag))
    {
      if (hart0)
	cerr << "Warning: Config tag " << tag << " is deprecated. "
	     << "Use svnapot with --isa instead.\n";
      getJsonBoolean(tag, config_ ->at(tag), flag) or errors++;
      hart.enableTranslationNapot(flag);
    }

  tag = "enable_svinval";
  if (config_ -> contains(tag))
    {
      if (hart0)
	cerr << "Warning: Config tag " << tag << " is deprecated. "
	     << "Use svinval with --isa instead.\n";
      getJsonBoolean(tag, config_ ->at(tag), flag) or errors++;
      hart.enableSvinval(flag);
    }

  tag = "enable_supervisor_time_compare";
  if (config_ -> contains(tag))
    {
      if (hart0)
	cerr << "Warning: Config tag " << tag << " is deprecated. "
	     << "Use sstc with --isa instead.\n";
      getJsonBoolean(tag, config_ ->at(tag), flag) or errors++;
      hart.enableRvsstc(flag);
    }

  tag = "enable_aia";
  if (config_ ->contains(tag))
    {
      if (hart0)
	cerr << "Warning: Config tag " << tag << " is deprecated. "
	     << "Use smaia with --isa instead.\n";
      getJsonBoolean(tag, config_ ->at(tag), flag) or errors++;
      hart.enableAiaExtension(flag);
    }

  tag = "enable_smstateen";
  if (config_ ->contains(tag))
    {
      if (hart0)
	cerr << "Warning: Config tag " << tag << " is deprecated. "
	     << "Use smstateen with --isa instead.\n";
      getJsonBoolean(tag, config_ ->at(tag), flag) or errors++;
      hart.enableSmstateen(flag);
    }

  tag = "wfi_timeout";
  if (config_ ->contains(tag))
    {
      uint64_t timeout = 0;
      getJsonUnsigned(tag, config_ ->at(tag), timeout) or errors++;
      hart.setWfiTimeout(timeout);
    }

  tag = "wfi_stall_exception";
  if (config_ ->contains(tag))
    {
      bool flag = false;
      getJsonBoolean(tag, config_ ->at(tag), flag) or errors++;
      hart.setWfiStallException(flag);
    }

  tag = "hfence_gvma_ignores_gpa";
  if (config_ ->contains(tag))
    {
      bool flag = false;
      getJsonBoolean(tag, config_ ->at(tag), flag) or errors++;
      hart.hfenceGvmaIgnoresGpa(flag);
    }

  tag = "enable_semihosting";
  if (config_ ->contains(tag))
    {
      bool flag = false;
      getJsonBoolean(tag, config_ ->at(tag), flag) or errors++;
      hart.enableSemihosting(flag);
    }

  // This flag exists to model implementations which speculatively
  // set the D bit in G-stage PTEs while performing implicit accesses for
  // VS-stage page table walks.
  // 
  // Implementations are permitted to speculatively set the A bit in VS-stage
  // PTEs. But when two stages of translation are active, doing so would
  // require first setting the D bit in the corresponding G-stage PTE. Thus, in
  // order to permit speculatively setting VS-stage A bits, it must be
  // permissible to speculatively set G-stage D bits.
  // 
  // Given this, Ascalon sets D bits in G-stage PTEs when performing implicit
  // accesses for VG-stage walks, regardless of whether the any PTE update in
  // the VS-stage ends up being necessary.
  //
  // (Note that G-stage D bit updates are still precise for the final G-stage
  // walk which occurs after the VG-stage is complete.)
  //
  // Here is the spec (sec 12.3.1 of privileged sepc version 20251216):
  //   When two-stage address translation is active, updates to the D bit in G-stage PTEs
  //   may be performed by an implicit access to a VS-stage PTE, if the G-stage PTE
  //   provides write permission, before any speculative access to the VS-stage PTE.
  tag = "mark_dirty_gstage_for_vs_nonleaf_pte";
  if (config_->contains(tag))
    {
      bool flag = false;
      getJsonBoolean(tag, config_->at(tag), flag) or errors++;
      hart.enableDirtyGForVsNonleaf(flag);
    }

  tag = "auto_increment_timer";
  if (config_->contains(tag))
    {
      bool flag = false;
      getJsonBoolean(tag, config_->at(tag), flag) or errors++;
      hart.autoIncrementTimer(flag);
    }

  bool quiet = hart.sysHartIndex() != 0;
  tag = "machine_interrupts";
  if (config_->contains(tag))
    {
      const auto &mi = config_->at(tag);
      if (!mi.is_array())
        {
          if (hart0)
            cerr << "Error: Invalid machine_interrupts entry in config file (expecting array)\n";
          ++errors;
        }
      else
        {
          std::vector<InterruptCause> vec;
          if (parseInterruptArray(mi, "machine_interrupts", quiet, vec))
            hart.setMachineInterrupts(vec);
          else
            ++errors;
        }
    }

  tag = "supervisor_interrupts";
  if (config_->contains(tag))
    {
      const auto &si = config_->at(tag);
      if (!si.is_array())
        {
          if (hart0)
            cerr << "Error: Invalid supervisor_interrupts entry in config file (expecting array)\n";
          ++errors;
        }
      else
        {
          std::vector<InterruptCause> vec;
          if (parseInterruptArray(si, "supervisor_interrupts", quiet, vec))
            hart.setSupervisorInterrupts(vec);
          else
            ++errors;
        }
    }

  tag = "non_maskable_interrupts";
  if (config_->contains(tag))
    {
      const auto &si = config_->at(tag);
      if (!si.is_array())
        {
          if (hart0)
            cerr << "Error: Invalid non_maskable_interrutps entry in config file (expecting array)\n";
          ++errors;
        }
      else
        {
          std::vector<uint64_t> vec;
          if (getJsonUnsignedVec(tag, si, vec))
            hart.setNonMaskableInterrupts(vec);
          else
            ++errors;
        }
    }

  tag = "can_receive_interrupts";
  if (config_->contains(tag))
    {
      bool flag = false;
      getJsonBoolean(tag, config_->at(tag), flag) or errors++;
      hart.setCanReceiveInterrupts(flag);
    }

  tag = "enable_mtip";
  if (config_->contains(tag))
    {
      bool flag = false;
      getJsonBoolean(tag, config_->at(tag), flag) or errors++;
      hart.enableMtip(flag);
    }

  tag = "enable_stip";
  if (config_->contains(tag))
    {
      bool flag = false;
      getJsonBoolean(tag, config_->at(tag), flag) or errors++;
      hart.enableStip(flag);
    }

  return errors == 0;
}


template<typename URV>
bool
HartConfig::applyClintConfig(System<URV>& system, Hart<URV>& hart) const
{
  std::string_view tag = "clint";
  if (not config_ -> contains(tag))
    return true;

  uint64_t addr = 0;
  if (not getJsonUnsigned(tag, config_ ->at(tag), addr))
    return false;

  if ((addr & 7) != 0)
    {
      std::cerr << "Error: Config file clint address (0x" << std::hex
		<< addr << std::dec << ") is not a multiple of 8\n";
      return false;
    }

  uint64_t size = 0xc000;
  return configAclint(system, hart, addr, size, 0 /* swOffset */, true /* hasMswi */,
                      0x4000 /* mtimeCmpOffset */, 0xbff8 /* timeOffset */, true /* hasMtimer */,
		      false /*siOnReset*/, true /*deliverInterrupts*/);
}


template<typename URV>
bool
HartConfig::applyAclintConfig(System<URV>& system, Hart<URV>& hart) const
{
  std::string_view tag = "aclint";
  if (not config_ -> contains(tag))
    return true;

  auto& aclint = config_ -> at("aclint");

  uint64_t base = 0, size = 0, swOffset = 0, mtimeCmpOffset = 0, timeOffset = 0;

  tag = "base";
  if (aclint.contains(tag))
    {
      if (not getJsonUnsigned("aclint.base", aclint.at(tag), base))
	return false;
    }
  else
    {
      std::cerr << "Error: Missing base field in aclint section of configuration file.\n";
      return false;
    }

  tag = "size";
  if (aclint.contains(tag))
    {
      if (not getJsonUnsigned("aclint.size", aclint.at(tag), size))
	return false;
    }
  else
    {
      std::cerr << "Error: Missing size field in aclint section of configuration file.\n";
      return false;
    }

  bool hasMswi = false;
  tag = "sw_offset";
  if (aclint.contains(tag))
    {
      if (not getJsonUnsigned("aclint.sw_offset", aclint.at(tag), swOffset))
        return false;
      hasMswi = true;
    }
  uint64_t swEnd = swOffset + 0x4000;

  bool hasMtimer = false;
  tag = "timer_offset";     // Legacy, replaced with timecmp_offset.
  if (aclint.contains(tag))
    {
      if (not getJsonUnsigned("aclint.timer_offset", aclint.at(tag), mtimeCmpOffset))
        return false;
      hasMtimer = true;
    }
  else if (std::string_view tag2 = "timecmp_offset"; aclint.contains(tag2))
    {
      if (not getJsonUnsigned("aclint.timecmp_offset", aclint.at(tag2), mtimeCmpOffset))
        return false;
      hasMtimer = true;
    }

  uint64_t mtimeCmpEnd = mtimeCmpOffset + 0x8000;

  tag = "time_offset";
  if (aclint.contains(tag))
    {
      if (not hasMtimer)
        {
          std::cerr << "Error: aclint specified time_offset, but no timecmp_offset\n";
          return false;
        }
      if (not getJsonUnsigned("aclint.time_offset", aclint.at(tag), timeOffset))
        return false;
    }
  else if (hasMtimer)
    {
      std::cerr << "Error: aclint specified timer_offset, but no time_offset\n";
      return false;
    }

  if ((base & 7) != 0 or (swOffset & 7) != 0 or (mtimeCmpOffset & 7) != 0 or
      (timeOffset & 7) != 0)
    {
      std::cerr << "Error: Config file aclint addresses and offsets\n"
                << "(0x" << std::hex << base << ")\n"
                << "(0x" << swOffset << ")\n"
                << "(0x" << mtimeCmpOffset << ")\n"
                << "(0x" << timeOffset << std::dec << ")\n"
                << "must be a multiple of 8\n";
      return false;
    }

  // Check overlap.
  if (hasMswi and (timeOffset >= swOffset and timeOffset < swEnd))
    {
      std::cerr << "Error: aclint MTIME cannot sit in MSWI region.\n";
      return false;
    }

  if (hasMswi and hasMtimer and
      ((mtimeCmpOffset >= swOffset and mtimeCmpOffset < swEnd) or
       (swOffset >= mtimeCmpOffset and swOffset < mtimeCmpEnd)))
    {
      std::cerr << "Error: aclint MTIMER and MSWI regions cannot overlap.\n";
      return false;
    }

  bool siOnReset = false;
  tag = "software_interrupt_on_reset";
  if (aclint.contains(tag))
    {
      if (not getJsonBoolean("aclint.software_interrupt_on_reset", aclint.at(tag), siOnReset))
        return false;
      if (not hasMswi)
        {
          std::cerr << "Error: aclint software_interrupt_on_reset configured"
                    << " without software device enabled.\n";
          return false;
        }
    }

  bool deliverInterrupts = true;
  tag = "deliver_interrupts";
  if (aclint.contains(tag))
    if (not getJsonBoolean("aclint.deliver_interrupts", aclint.at(tag), deliverInterrupts))
      return false;

  tag = "time_adjust";
  if (aclint.contains(tag))
    {
      uint64_t offset = 0;
      if (not getJsonUnsigned("aclint.time_adjust", aclint.at(tag), offset))
        return false;
      hart.setAclintAdjustTimeCompare(offset);
    }

  tag = "timecmp_reset";
  if (aclint.contains(tag))
    {
      uint64_t reset = 0;
      if (not getJsonUnsigned("aclint.timecmp_reset", aclint.at(tag), reset))
        return false;
      hart.setAclintAlarm(reset);
    }

  return configAclint(system, hart, base, size, swOffset, hasMswi, mtimeCmpOffset,
                      timeOffset, hasMtimer, siOnReset, deliverInterrupts);
}


template<typename URV>
bool
HartConfig::applyImsicConfig(System<URV>& system) const
{
  if (not config_ -> contains("imsic"))
    return true;

  auto& hart0 = *system.ithHart(0);
  if (not hart0.extensionIsEnabled(RvExtension::Smaia))
    {
      std::cerr << "Error: Cannot configure IMSIC without enabling Smaia\n";
      return false;
    }

  auto& imsic = config_ -> at("imsic");

  uint64_t mbase = 0, mstride = 0, sbase = 0, sstride = 0;

  std::string_view tag = "mbase";
  if (imsic.contains(tag))
    if (not getJsonUnsigned("imsic.mbase",  imsic.at(tag), mbase))
      return false;

  tag = "mstride";
  if (imsic.contains(tag))
    if (not getJsonUnsigned("imsic.mstride",  imsic.at(tag), mstride))
      return false;

  tag = "sbase";
  if (imsic.contains(tag))
    if (not getJsonUnsigned("imsic.sbase",  imsic.at(tag), sbase))
      return false;

  tag = "sstride";
  if (imsic.contains(tag))
    if (not getJsonUnsigned("imsic.stride",  imsic.at(tag), sstride))
      return false;

  unsigned guests = 0;
  tag = "guests";
  if (imsic.contains(tag))
    if (not getJsonUnsigned("imsic.guests", imsic.at(tag), guests))
      return false;

  std::vector<unsigned> idVec = { 64, 64, 64}; // For M, S, and VS privs.
  tag = "ids";
  if (imsic.contains(tag))
    {
      if (imsic.at(tag).is_array())
	{
	  if (not getJsonUnsignedVec("imsic.ids", imsic.at(tag), idVec))
	    return false;
	  if (idVec.size() != 3)
	    {
	      std::cerr << "Error: Config file imsic.ids array must have 3 values\n";
	      return false;
	    }
	}
      else
	{
	  unsigned ids = 0;
	  if (not getJsonUnsigned("imsic.ids", imsic.at(tag), ids))
	    return false;
	  std::fill(idVec.begin(), idVec.end(), ids);
	}
    }

  // Threshold mask is the smallest all-ones bit-mask that covers all the bits
  // necessary to represent an id.
  std::vector<unsigned> tmVec(idVec.size());   // Threshold masks.
  for (unsigned i = 0; i < idVec.size(); ++i)
    tmVec.at(i) = std::bit_ceil(idVec.at(i)) - 1;

  tag = "eithreshold_mask";
  if (imsic.contains(tag))
    {
      if (imsic.at(tag).is_array())
	{
	  if (not getJsonUnsignedVec("imsic.threshold_mask", imsic.at(tag), tmVec))
	    return false;
	  if (tmVec.size() != 3)
	    {
	      std::cerr << "Error: Config file imsic.threshold array must have 3 values\n";
	      return false;
	    }
	}
      else
	{
	  unsigned tm = 0;
	  if (not getJsonUnsigned("imsic.eithreshold_mask", imsic.at(tag), tm))
	    return false;
	  std::fill(tmVec.begin(), tmVec.end(), tm);
	}
    }

  bool maplic = false;    // Machine file supports aplic
  tag = "maplic";
  if (imsic.contains(tag))
    if (not getJsonBoolean("imsic.maplic", imsic.at(tag), maplic))
      return false;

  bool saplic = false;   // Supervisor file supports applic
  tag = "saplic";
  if (imsic.contains(tag))
    if (not getJsonBoolean("imsic.saplic", imsic.at(tag), saplic))
      return false;

  bool trace = false;
  tag = "trace";
  if (imsic.contains(tag))
    if (not getJsonBoolean("imsic.trace", imsic.at(tag), trace))
      return false;

  return system.configImsic(mbase, mstride, sbase, sstride, guests, idVec, tmVec, maplic,
                            saplic, trace);
}


template<typename URV>
bool
HartConfig::applyPciConfig(System<URV>& system) const
{
  std::string_view tag = "pci";
  if (not config_ -> contains(tag))
    return true;

  auto& pci = config_ -> at(tag);
  if (not pci.contains("config_base") or not pci.contains("mmio_base") or not pci.contains("mmio_size"))
    {
      std::cerr << "Error: Invalid pci entry in config file\n";
      return false;
    }
  uint64_t configBase = 0, mmioBase = 0, mmioSize = 0;
  if (not getJsonUnsigned(util::join("", tag, ".config_base"), pci.at("config_base"), configBase) or
      not getJsonUnsigned(util::join("", tag, ".mmio_base"), pci.at("mmio_base"), mmioBase) or
      not getJsonUnsigned(util::join("", tag, ".mmio_size"), pci.at("mmio_size"), mmioSize))
    return false;
  unsigned buses = 0, slots = 0;
  if (not getJsonUnsigned(util::join("", tag, ".buses"), pci.at("buses"), buses) or
      not getJsonUnsigned(util::join("", tag, ".slots"), pci.at("slots"), slots))
    return false;

  return system.configPci(configBase, mmioBase, mmioSize, buses, slots);
}


template<typename URV>
bool
HartConfig::configHarts(System<URV>& system, bool userMode, bool verbose,
                        std::string_view isa) const
{
  userMode = userMode or this->userModeEnabled();

#if 0
  // If the MISA CSR is not configured by the user, then auto configure it to match the
  // ISA string.
  bool updateMisa = not hasCsrConfig("misa");
#endif

  // Apply JSON configuration to each hart.
  for (unsigned i = 0; i < system.hartCount(); ++i)
    {
      Hart<URV>& hart = *system.ithHart(i);

#if 0
      if (not isa.empty())
	if (not hart.configIsa(isa, updateMisa))
	  return false;
#endif

      if (not applyConfig(hart, userMode, verbose, isa))
	return false;

      if (not applyClintConfig(system, hart))
        return false;

      if (not applyAclintConfig(system, hart))
	return false;
    }

  unsigned mbLineSize = 64;
  std::string_view tag = "merge_buffer_line_size";
  if (config_ -> contains(tag))
    if (not getJsonUnsigned(tag, config_ -> at(tag), mbLineSize))
      return false;

  tag = "merge_buffer_check_all";
  bool checkAll = false;
  if (config_ -> contains(tag))
    if (not getJsonBoolean(tag, config_ -> at(tag), checkAll))
      return false;

  tag = "enable_memory_consistency";
  bool enableMcm = false;
  if (config_ -> contains(tag))
    if (not getJsonBoolean(tag, config_ -> at(tag), enableMcm))
      return false;

  tag = "enable_mcm_cache";
  bool enableMcmCache = true;
  if (config_ -> contains(tag))
    if (not getJsonBoolean(tag, config_ -> at(tag), enableMcmCache))
      return false;

  // Parse enable_ppo, it it is missing all PPO rules are enabled.
  std::vector<unsigned> enabledPpos;
  if (not getEnabledPpos(enabledPpos))
    return false;

  if (enableMcm and not system.enableMcm(mbLineSize, checkAll, enableMcmCache, enabledPpos))
    return false;

  tag = "enable_tso";
  bool enableTso = false;
  if (config_ -> contains(tag))
    if (not getJsonBoolean(tag, config_ -> at(tag), enableTso))
      return false;
  system.enableTso(enableTso);

  tag = "warn_on_mcm_ppo_fail";
  bool ppoWarn = false;
  if (config_ -> contains(tag))
    if (not getJsonBoolean(tag, config_ -> at(tag), ppoWarn))
      return false;
  system.mcmWarnOnPpoFail(ppoWarn);

  tag = "uart";
  if (config_ -> contains(tag))
    {
      auto& uart = config_ -> at(tag);
      if (not uart.contains("address") or not uart.contains("size"))
	{
	  std::cerr << "Error: Invalid uart entry in config file: missing address/size entry.\n";
	  return false;
	}
      uint64_t addr = 0, size = 0;
      if (not getJsonUnsigned(util::join("", tag, ".address"), uart.at("address"), addr) or
          not getJsonUnsigned(util::join("", tag, ".size"), uart.at("size"), size))
	return false;

      std::string type = "uart8250";
      if (not uart.contains("type"))
	std::cerr << "Error: Missing uart type. Using uart250. Valid types: uart8250, usartsf.\n";
      else
	{
	  type = uart.at("type").get<std::string>();
	  if (type != "uartsf" and type != "uart8250")
	    {
	      std::cerr << "Error: Invalid uart type: " << type << ". Valid types: uartsf, uart8250.\n";
	      return false;
	    }
	}
		
      uint32_t iid = 0;
      std::string channel = "pty";
      unsigned regShift = 2;  // Default to shift 2 (4-byte spacing: 1 << 2 = 4)
      if (type == "uart8250")
        {
          if (uart.contains("iid") &&
              not getJsonUnsigned(util::join("", tag, ".iid"), uart.at("iid"), iid))
            return false;

          if (not uart.contains("channel"))
              std::cerr << "Warning: Missing uart channel. Using " << channel << ". "
                << "Valid channels: stdio, pty, unix:<server socket path>, or a"
                << "semicolon separated list of those.\n";
          else
            channel = uart.at("channel").get<std::string>();

          if (uart.contains("reg_shift"))
            {
              if (not getJsonUnsigned(util::join("", tag, ".reg_shift"), uart.at("reg_shift"), regShift))
                return false;
            }
        }
      else if (type == "uartsf")
        {
          if (uart.contains("reg_shift"))
            {
              std::cerr << "Warning: reg_shift parameter is not supported for uartsf UART type and will be ignored.\n";
            }
        }

      if (not system.defineUart(type, addr, size, iid, channel, regShift))
	return false;
    }

  if (not applyPciConfig(system))
    return false;

#if REMOTE_FRAME_BUFFER
  if (not applyFrameBufferConfig(system))
    return false;
#endif

  return finalizeCsrConfig(system);
}


template<typename URV>
bool
HartConfig::configMemory(System<URV>& system, bool unmappedElfOk) const
{
  system.checkUnmappedElf(not unmappedElfOk);

  bool ok = true;

  for (unsigned i = 0; i < system.hartCount(); ++i)
    {
      auto& hart = *system.ithHart(i);
      ok = applyMemoryConfig(system, hart) and ok;
    }

  return ok;
}


bool
HartConfig::getXlen(unsigned& xlen) const
{
  if (config_ -> contains("xlen"))
    {
      std::cerr << "Config file tag xlen is deprecated: xlen is obtained from the isa tag.\n";
      return getJsonUnsigned("xlen", config_ -> at("xlen"), xlen);
    }
  std::string isa;
  if (not getIsa(isa))
    return false;

  if (isa.empty())
    return false;

  if (isa.starts_with("rv64"))
    {
      xlen = 64;
      return true;
    }

  if (isa.starts_with("rv32"))
    {
      xlen = 32;
      return true;
    }

  std::cerr << "Error: Invalid register width in isa string (" << isa << ") in config file -- ignored\n";
  return false;
}


bool
HartConfig::getCoreCount(unsigned& count) const
{
  if (config_ -> contains("cores"))
    return getJsonUnsigned("cores", config_ -> at("cores"), count);
  return false;
}


bool
HartConfig::getHartsPerCore(unsigned& count) const
{
  if (config_ -> contains("harts"))
    return getJsonUnsigned("harts", config_ -> at("harts"), count);
  return false;
}


bool
HartConfig::getPageSize(size_t& pageSize) const
{
  if (not config_ -> contains("memmap"))
    return false;

  auto& mem = config_ -> at("memmap");
  if (not mem.contains("page_size"))
    return false;

  return getJsonUnsigned("memmap.page_size", mem.at("page_size"), pageSize);
}


bool
HartConfig::getHartIdOffset(unsigned& offset) const
{
  constexpr std::string_view tag = "core_hart_id_offset";
  if (not config_ -> contains(tag))
    return false;

  return getJsonUnsigned(tag, config_->at(tag), offset);
}


bool
HartConfig::getIsa(std::string& isa) const
{
  constexpr std::string_view tag = "isa";
  if (not config_ -> contains(tag))
    return false;

  auto& item = config_ -> at(tag);
  if (item.is_string())
    {
      isa = item.get<std::string>();
      return true;
    }
  return false;
}


bool
HartConfig::getEnabledPpos(std::vector<unsigned>& enabledPpos) const
{
  std::string tag = "enable_ppo";

  if (config_ -> contains(tag))
    {
      auto& ep = config_ -> at(tag);
      if (ep.is_boolean())
	{
	  bool flag = false;
	  if (not getJsonBoolean(tag, config_ -> at(tag), flag))
	    return false;
	  if (flag)
	    for (unsigned i = 0; i < Mcm<uint64_t>::PpoRule::Io; ++i) // Temporary: Skip Io.
	      enabledPpos.push_back(i);
	}
      else if (ep.is_array())
	{
	  std::vector<unsigned> temp;

	  if (not getJsonUnsignedVec(tag, ep, temp))
	    return false;

	  // Keep valid rule numbers
	  for (auto ix : temp)
	    {
	      if (ix < Mcm<uint64_t>::PpoRule::Limit)
		enabledPpos.push_back(ix);
	      else
		std::cerr << "Error: Invalid PPO rule number in config file enable_ppo tag: " << ix << '\n';
	    }
	}
    }
  else
    {
      // Tag is missing: all rules enabled. Temporary: Skip Io.
      for (unsigned i = 0; i < Mcm<uint64_t>::PpoRule::Io; ++i)
	enabledPpos.push_back(i);
    }

  return true;
}


bool
HartConfig::getMemorySize(size_t& memSize) const
{
  if (not config_ -> contains("memmap"))
    return false;

  auto& mem = config_ -> at("memmap");
  if (not mem.contains("size"))
    return false;

  return getJsonUnsigned("memmap.size", mem.at("size"), memSize);
}


bool
HartConfig::getMcmLineSize(unsigned& ls) const
{
  constexpr std::string_view tag = "merge_buffer_line_size";
  if (not config_ -> contains(tag))
    return false;
  return getJsonUnsigned(tag, config_ -> at(tag), ls);
}


bool
HartConfig::getMcmCheckAll(bool& ca) const
{
  constexpr std::string_view tag = "merge_buffer_check_all";
  if (not config_ -> contains(tag))
    return false;
  return getJsonBoolean(tag, config_ -> at(tag), ca);
}


bool
HartConfig::getMcmEnableCache(bool& cache) const
{
  constexpr std::string_view tag = "enable_mcm_cache";
  if (not config_ -> contains(tag))
    return false;
  return getJsonBoolean(tag, config_ -> at(tag), cache);
}


bool
HartConfig::userModeEnabled() const
{
  uint64_t resetVal = 0;
  if (not getMisaReset(resetVal))
    return false;

  // User mode enabled if bit corresponding to U extension is set.
  return ((uint64_t(1) << ('u' - 'a')) & resetVal) != 0;
}


bool
HartConfig::supervisorModeEnabled() const
{
  uint64_t resetVal = 0;
  if (not getMisaReset(resetVal))
    return false;

  // User mode enabled if bit corresponding to S extension is set.
  return ((uint64_t(1) << ('s' - 'a')) & resetVal) != 0;
}


void
HartConfig::clear()
{
  config_ -> clear();
}


/// Associate callback with write/poke of mcounthinibit
template <typename URV>
void
defineMcountinhibitSideEffects(System<URV>& system)
{
  for (unsigned i = 0; i < system.hartCount(); ++i)
    {
      auto hart = system.ithHart(i);
      std::weak_ptr<Hart<URV>> wHart(hart);

      // For poke, the effect takes place immediately (next instruction
      // will see the new control).
      auto postPoke = [wHart] (Csr<URV>&, URV) -> void {
		        auto hart = wHart.lock();
			if (not hart)
			  return;  // Should not happen.
                        URV val = hart->peekCsr(CsrNumber::MCOUNTINHIBIT);
                        hart->setPerformanceCounterControl(~val);
                        hart->setPerformanceCounterControl(~val); // Needed. Do not remove.
                      };

      // For write (invoked from current instruction), the effect
      // takes place on the following instruction.
      auto postWrite = [wHart] (Csr<URV>&, URV) -> void {
	                 auto hart = wHart.lock();
			 if (not hart)
			   return;  // Should not happen.
                         URV val = hart->peekCsr(CsrNumber::MCOUNTINHIBIT);
                         hart->setPerformanceCounterControl(~val);
                       };

      for (const auto* csrName : { "mcountinhibit", "scountinhibit" })
        {
          if (auto csrPtr = hart->findCsr(csrName); csrPtr)
            {
              csrPtr->registerPostPoke(postPoke);
              csrPtr->registerPostWrite(postWrite);
            }
        }
    }
}


template <typename URV>
bool
HartConfig::finalizeCsrConfig(System<URV>& system) const
{
  if (system.hartCount() == 0)
    return false;

  // Define callback to react to write/poke to mcountinhibit CSR.
  defineMcountinhibitSideEffects(system);
  return true;
}


bool
HartConfig::getMisaReset(uint64_t& val) const
{
  val = 0;

  if (not config_ -> contains("csr"))
    return false;  // No csr section

  const auto& csrs = config_ -> at("csr");
  if (not csrs.is_object())
    return false;  // No csr section in this config.

  if (not csrs.contains("misa"))
    return false;  // CSR misa not present in csr section

  const auto& misa = csrs.at("misa");
  if (not misa.is_object())
    return false;

  if (not misa.contains("reset"))
    return false;  // No reset entry under misa

  uint64_t resetVal = 0;
  if (not getJsonUnsigned("csr.misa.reset", misa.at("reset"), resetVal))
    return false;

  val = resetVal;
  return true;
}


bool
HartConfig::hasCsrConfig(std::string_view csrName) const
{
  if (not config_ -> contains("csr"))
    return false;  // No csr section

  const auto& csrs = config_ -> at("csr");
  if (not csrs.is_object())
    return false;  // No csr section in this config.

  if (not csrs.contains(csrName))
    return false;  // Target csr not present in csr section

  return true;
}


// Instantiate tempate member functions

template bool
HartConfig::applyConfig<uint32_t>(Hart<uint32_t>&, bool, bool, std::string_view) const;

template bool
HartConfig::applyConfig<uint64_t>(Hart<uint64_t>&, bool, bool, std::string_view) const;

template bool
HartConfig::configHarts<uint32_t>(System<uint32_t>&, bool, bool, std::string_view) const;

template bool
HartConfig::configHarts<uint64_t>(System<uint64_t>&, bool, bool, std::string_view) const;

template bool
HartConfig::configMemory(System<uint32_t>&, bool) const;

template bool
HartConfig::configMemory(System<uint64_t>&, bool) const;


template bool
HartConfig::applyMemoryConfig<uint32_t>(System<uint32_t>&, Hart<uint32_t>&) const;

template bool
HartConfig::applyMemoryConfig<uint64_t>(System<uint64_t>&, Hart<uint64_t>&) const;

template bool
HartConfig::finalizeCsrConfig<uint32_t>(System<uint32_t>&) const;

template bool
HartConfig::finalizeCsrConfig<uint64_t>(System<uint64_t>&) const;

template bool
HartConfig::configAclint<uint32_t>(System<uint32_t>&, Hart<uint32_t>&, uint64_t clintStart,
                                   uint64_t size, uint64_t mswiOffset, bool hasMswi,
                                   uint64_t mtimeCmpOffset, uint64_t mtimeOffset, bool hasMtimer,
		                   bool siOnReset = false, bool deliverInterrupts = true) const;
template bool
HartConfig::configAclint<uint64_t>(System<uint64_t>&, Hart<uint64_t>&, uint64_t clintStart,
                                   uint64_t size, uint64_t mswiOffset, bool hasMswi,
                                   uint64_t mtimeCmpOffset, uint64_t mtimeOffset, bool hasMtimer,
		                   bool siOnReset = false, bool deliverInterrupts = true) const;

template bool
HartConfig::applyImsicConfig(System<uint32_t>&) const;

template bool
HartConfig::applyImsicConfig(System<uint64_t>&) const;

template bool
HartConfig::applyAplicConfig(System<uint32_t>&) const;

template bool
HartConfig::applyAplicConfig(System<uint64_t>&) const;

template bool
HartConfig::applyAclicConfig(System<uint32_t>&) const;

template bool
HartConfig::applyAclicConfig(System<uint64_t>&) const;

template bool
HartConfig::applyIommuConfig(System<uint32_t>&) const;

template bool
HartConfig::applyIommuConfig(System<uint64_t>&) const;

#if REMOTE_FRAME_BUFFER
template bool
HartConfig::applyFrameBufferConfig(System<uint32_t>&) const;

template bool
HartConfig::applyFrameBufferConfig(System<uint64_t>&) const;
#endif