mpact/sim/util/renode/renode_mpact.cc - mpact-sim - Git at Google

 // Copyright 2024 Google LLC
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //     https://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.

 #include "mpact/sim/util/renode/renode_mpact.h"

 #include <cstddef>
 #include <cstdint>
 #include <cstring>
 #include <fstream>
 #include <ios>
 #include <limits>
 #include <string>

 #include "absl/log/log.h"
 #include "absl/status/status.h"
 #include "absl/strings/str_cat.h"
 #include "mpact/sim/generic/core_debug_interface.h"
 #include "mpact/sim/generic/type_helpers.h"
 #include "mpact/sim/util/memory/memory_interface.h"
 #include "mpact/sim/util/renode/renode_debug_interface.h"
 #include "mpact/sim/util/renode/renode_memory_access.h"

 using ::mpact::sim::generic::operator*;  // NOLINT: used below (clang error).
 using ::mpact::sim::util::MemoryInterface;

 // This function must be defined in the library.
 extern ::mpact::sim::util::renode::RenodeDebugInterface* CreateMpactSim(
     std::string name, std::string cpu_type, MemoryInterface*);

 using ::mpact::sim::util::renode::RenodeAgent;
 using ::mpact::sim::util::renode::RenodeCpuRegister;

 // Implementation of the C interface functions. They each forward the call to
 // the corresponding method in RenodeAgent.
 int32_t construct(char* cpu_type, int32_t max_name_length) {
   return RenodeAgent::Instance()->Construct(cpu_type, max_name_length, nullptr,
                                             nullptr);
 }

 int32_t construct_with_sysbus(char* cpu_type, int32_t max_name_length,
                               int32_t (*read_callback)(uint64_t, char*,
                                                        int32_t),
                               int32_t (*write_callback)(uint64_t, char*,
                                                         int32_t)) {
   return RenodeAgent::Instance()->Construct(cpu_type, max_name_length,
                                             read_callback, write_callback);
 }

 int32_t connect(char* cpu_type, int32_t id, int32_t max_name_length) {
   return RenodeAgent::Instance()->Connect(cpu_type, id, max_name_length,
                                           nullptr, nullptr);
 }

 int32_t connect_with_sysbus(char* cpu_type, int32_t id, int32_t max_name_length,
                             int32_t (*read_callback)(uint64_t, char*, int32_t),
                             int32_t (*write_callback)(uint64_t, char*,
                                                       int32_t)) {
   return RenodeAgent::Instance()->Connect(cpu_type, id, max_name_length,
                                           read_callback, write_callback);
 }

 void destruct(int32_t id) { RenodeAgent::Instance()->Destroy(id); }

 int32_t reset(int32_t id) { return RenodeAgent::Instance()->Reset(id); }

 int32_t get_reg_info_size(int32_t id) {
   return RenodeAgent::Instance()->GetRegisterInfoSize(id);
 }

 int32_t get_reg_info(int32_t id, int32_t index, char* name, void* info) {
   if (info == nullptr) return -1;
   return RenodeAgent::Instance()->GetRegisterInfo(
       id, index, name, static_cast<RenodeCpuRegister*>(info));
 }

 uint64_t load_elf(int32_t id, const char* elf_file_name, bool for_symbols_only,
                   int32_t* status) {
   return RenodeAgent::Instance()->LoadExecutable(id, elf_file_name,
                                                  for_symbols_only, status);
 }

 int32_t load_image(int32_t id, const char* file_name, uint64_t address) {
   return RenodeAgent::Instance()->LoadImage(id, file_name, address);
 }

 int32_t read_register(int32_t id, uint32_t reg_id, uint64_t* value) {
   return RenodeAgent::Instance()->ReadRegister(id, reg_id, value);
 }

 int32_t write_register(int32_t id, uint32_t reg_id, uint64_t value) {
   return RenodeAgent::Instance()->WriteRegister(id, reg_id, value);
 }

 uint64_t read_memory(int32_t id, uint64_t address, char* buffer,
                      uint64_t length) {
   return RenodeAgent::Instance()->ReadMemory(id, address, buffer, length);
 }

 uint64_t write_memory(int32_t id, uint64_t address, const char* buffer,
                       uint64_t length) {
   return RenodeAgent::Instance()->WriteMemory(id, address, buffer, length);
 }

 uint64_t step(int32_t id, uint64_t num_to_step, int32_t* status) {
   return RenodeAgent::Instance()->Step(id, num_to_step, status);
 }

 int32_t set_config(int32_t id, const char* config_names[],
                    const char* config_values[], int32_t size) {
   return RenodeAgent::Instance()->SetConfig(id, config_names, config_values,
                                             size);
 }

 int32_t set_irq_value(int32_t id, int32_t irq_num, bool irq_value) {
   return RenodeAgent::Instance()->SetIrqValue(id, irq_num, irq_value);
 }

 namespace mpact {
 namespace sim {
 namespace util {
 namespace renode {

 using HaltReason = ::mpact::sim::generic::CoreDebugInterface::HaltReason;

 RenodeAgent* RenodeAgent::instance_ = nullptr;
 int32_t RenodeAgent::count_ = 0;

 // Create the debug instance by calling the factory function.
 int32_t RenodeAgent::Construct(char* cpu_type, int32_t max_name_length,
                                int32_t (*read_callback)(uint64_t, char*,
                                                         int32_t),
                                int32_t (*write_callback)(uint64_t, char*,
                                                          int32_t)) {
   std::string name = absl::StrCat("renode", count_);
   auto* memory_access = new RenodeMemoryAccess(read_callback, write_callback);
   auto* dbg = CreateMpactSim(name, cpu_type, memory_access);
   if (dbg == nullptr) {
     delete memory_access;
     return -1;
   }
   // Make sure that we don't reuse an instance number that may have been created
   // through Connect.
   while (core_dbg_instances_.contains(RenodeAgent::count_)) {
     RenodeAgent::count_++;
   }
   core_dbg_instances_.emplace(RenodeAgent::count_, dbg);
   name_length_map_.emplace(RenodeAgent::count_, max_name_length);
   renode_memory_access_.emplace(RenodeAgent::count_, memory_access);
   return RenodeAgent::count_++;
 }

 int32_t RenodeAgent::Connect(char* cpu_type, int32_t id,
                              int32_t max_name_length,
                              int32_t (*read_callback)(uint64_t, char*, int32_t),
                              int32_t (*write_callback)(uint64_t, char*,
                                                        int32_t)) {
   // First check if the instance already exists.
   auto iter = core_dbg_instances_.find(id);
   if (iter != core_dbg_instances_.end()) {
     // If memory callbacks are provided, don't overwrite any previous non-null
     // callbacks.
     auto* mem_access = renode_memory_access_.at(id);
     // Replace any null callbacks.
     if (!mem_access->has_read_fcn()) {
       mem_access->set_read_fcn(read_callback);
     }
     if (!mem_access->has_write_fcn()) {
       mem_access->set_write_fcn(write_callback);
     }
     return id;
   }

   // The instance does not exist, so create a new debug instance.
   std::string name = absl::StrCat("renode", id);
   auto* memory_access = new RenodeMemoryAccess(read_callback, write_callback);
   auto* dbg = CreateMpactSim(name, cpu_type, memory_access);
   if (dbg == nullptr) {
     delete memory_access;
     return -1;
   }
   core_dbg_instances_.emplace(id, dbg);
   name_length_map_.emplace(id, max_name_length);
   renode_memory_access_.emplace(id, memory_access);
   return id;
 }

 // Destroy the debug instance.
 void RenodeAgent::Destroy(int32_t id) {
   // Check for valid instance.
   auto dbg_iter = core_dbg_instances_.find(id);
   // If it doesn't exist, it may already have been deleted, so just return.
   if (dbg_iter == core_dbg_instances_.end()) return;

   delete dbg_iter->second;
   core_dbg_instances_.erase(dbg_iter);

   // Delete the memory access shim.
   auto mem_iter = renode_memory_access_.find(id);
   if (mem_iter == renode_memory_access_.end()) return;
   delete mem_iter->second;
   renode_memory_access_.erase(mem_iter);
 }

 int32_t RenodeAgent::Reset(int32_t id) {
   // Check for valid instance.
   auto dbg_iter = core_dbg_instances_.find(id);
   if (dbg_iter == core_dbg_instances_.end()) return -1;

   // For now, do nothing.
   return 0;
 }

 int32_t RenodeAgent::GetRegisterInfoSize(int32_t id) const {
   // Check for valid instance.
   auto dbg_iter = core_dbg_instances_.find(id);
   if (dbg_iter == core_dbg_instances_.end()) return -1;
   auto* dbg = dbg_iter->second;
   return dbg->GetRenodeRegisterInfoSize();
 }

 int32_t RenodeAgent::GetRegisterInfo(int32_t id, int32_t index, char* name,
                                      RenodeCpuRegister* info) {
   // Check for valid instance.
   if (info == nullptr) return -1;
   auto dbg_iter = core_dbg_instances_.find(id);
   if (dbg_iter == core_dbg_instances_.end()) return -1;
   auto* dbg = dbg_iter->second;
   int32_t max_len = name_length_map_.at(id);
   auto result = dbg->GetRenodeRegisterInfo(index, max_len, name, *info);
   if (!result.ok()) return -1;
   return 0;
 }

 // Read the register given by the id.
 int32_t RenodeAgent::ReadRegister(int32_t id, uint32_t reg_id,
                                   uint64_t* value) {
   // Check for valid instance.
   if (value == nullptr) return -1;
   auto dbg_iter = core_dbg_instances_.find(id);
   if (dbg_iter == core_dbg_instances_.end()) return -1;
   // Read register.
   auto* dbg = dbg_iter->second;
   auto result = dbg->ReadRegister(reg_id);
   if (!result.ok()) return -1;
   *value = result.value();
   return 0;
 }

 int32_t RenodeAgent::WriteRegister(int32_t id, uint32_t reg_id,
                                    uint64_t value) {
   // Check for valid instance.
   auto dbg_iter = core_dbg_instances_.find(id);
   if (dbg_iter == core_dbg_instances_.end()) return -1;
   // Write register.
   auto* dbg = dbg_iter->second;
   auto result = dbg->WriteRegister(reg_id, value);
   if (!result.ok()) return -1;
   return 0;
 }

 uint64_t RenodeAgent::ReadMemory(int32_t id, uint64_t address, char* buffer,
                                  uint64_t length) {
   // Get the debug interface.
   auto dbg_iter = core_dbg_instances_.find(id);
   if (dbg_iter == core_dbg_instances_.end()) {
     LOG(ERROR) << "No such core dbg instance: " << id;
     return 0;
   }
   auto* dbg = dbg_iter->second;
   auto res = dbg->ReadMemory(address, buffer, length);
   if (!res.ok()) return 0;
   return res.value();
 }

 uint64_t RenodeAgent::WriteMemory(int32_t id, uint64_t address,
                                   const char* buffer, uint64_t length) {
   // Get the debug interface.
   auto dbg_iter = core_dbg_instances_.find(id);
   if (dbg_iter == core_dbg_instances_.end()) {
     LOG(ERROR) << "No such core dbg instance: " << id;
     return 0;
   }
   auto* dbg = dbg_iter->second;
   auto res = dbg->WriteMemory(address, buffer, length);
   if (!res.ok()) return 0;
   return res.value();
 }

 uint64_t RenodeAgent::LoadExecutable(int32_t id, const char* file_name,
                                      bool for_symbols_only, int32_t* status) {
   // Get the debug interface.
   auto dbg_iter = core_dbg_instances_.find(id);
   if (dbg_iter == core_dbg_instances_.end()) {
     LOG(ERROR) << "No such core dbg instance: " << id;
     *status = -1;
     return 0;
   }
   // Instantiate loader.
   auto* dbg = dbg_iter->second;
   auto res = dbg->LoadExecutable(file_name, for_symbols_only);
   if (!res.ok()) {
     LOG(ERROR) << "Failed to load executable: " << res.status().message();
     *status = -1;
     return 0;
   }
   *status = 0;
   uint64_t entry = res.value();
   return entry;
 }

 int32_t RenodeAgent::LoadImage(int32_t id, const char* file_name,
                                uint64_t address) {
   // Get the debug interface.
   auto dbg_iter = core_dbg_instances_.find(id);
   if (dbg_iter == core_dbg_instances_.end()) {
     LOG(ERROR) << "No such core dbg instance: " << id;
     return -1;
   }
   auto* dbg = dbg_iter->second;
   // Open up the image file.
   std::ifstream image_file;
   image_file.open(file_name, std::ios::in | std::ios::binary);
   if (!image_file.good()) {
     LOG(ERROR) << "LoadImage: Input file not in good state";
     return -1;
   }
   char buffer[kBufferSize];
   size_t gcount = 0;
   uint64_t load_address = address;
   do {
     // Fill buffer.
     image_file.read(buffer, kBufferSize);
     // Get the number of bytes that was read.
     gcount = image_file.gcount();
     // Write to the simulator memory.
     auto res = dbg->WriteMemory(load_address, buffer, gcount);
     // Check that the write succeeded, increment address if it did.
     if (!res.ok()) {
       LOG(ERROR) << "LoadImage: Memory write failed";
       return -1;
     }
     if (res.value() != gcount) {
       LOG(ERROR) << "LoadImage: Memory write failed to write all the bytes";
       return -1;
     }
     load_address += gcount;
   } while (image_file.good() && (gcount > 0));
   return 0;
 }

 uint64_t RenodeAgent::Step(int32_t id, uint64_t num_to_step, int32_t* status) {
   // Get the core debug if object.
   auto* dbg = RenodeAgent::Instance()->core_dbg(id);
   // Is the debug interface valid?
   if (dbg == nullptr) {
     if (status != nullptr) {
       *status = static_cast<int32_t>(ExecutionResult::kAborted);
     }
     return 0;
   }

   if (num_to_step == 0) {
     *status = static_cast<int32_t>(ExecutionResult::kOk);
     return 0;
   }

   // Check the previous halt reason.
   auto halt_res = dbg->GetLastHaltReason();
   if (!halt_res.ok()) {
     if (status != nullptr) {
       *status = static_cast<int32_t>(ExecutionResult::kAborted);
     }
     return 0;
   }

   // If the previous halt reason was a semihost halt request, then we
   // shouldn't step any further. Just return with "waiting for interrupt"
   // code.
   if (halt_res.value() ==
       *RenodeDebugInterface::HaltReason::kSemihostHaltRequest) {
     *status = static_cast<int32_t>(ExecutionResult::kAborted);
     return 0;
   }
   // Perform the stepping.
   uint32_t total_executed = 0;
   while (num_to_step > 0) {
     // Check how far to step, and make multiple calls if the number
     // is greater than <int>::max();
     int step_count = (num_to_step > std::numeric_limits<int>::max())
                          ? std::numeric_limits<int>::max()
                          : static_cast<int>(num_to_step);
     auto res = dbg->Step(step_count);
     // An error occurred.
     if (!res.ok()) {
       if (status != nullptr) {
         *status = static_cast<int32_t>(ExecutionResult::kAborted);
       }
       return total_executed;
     }
     int num_executed = res.value();
     total_executed += num_executed;

     // Check if the execution was halted due to a semihosting halt request,
     // i.e., program exit.
     halt_res = dbg->GetLastHaltReason();
     if (!halt_res.ok()) {
       if (status != nullptr) {
         *status = static_cast<int32_t>(ExecutionResult::kAborted);
       }
       return total_executed;
     }
     if (halt_res.value() == *HaltReason::kProgramDone) {
       if (status != nullptr) {
         *status = static_cast<int32_t>(ExecutionResult::kAborted);
       }
       return total_executed;
     }
     if (halt_res.value() ==
         *RenodeDebugInterface::HaltReason::kSemihostHaltRequest) {
       if (status != nullptr) {
         *status = static_cast<uint32_t>(ExecutionResult::kAborted);
       }
       return total_executed;
     }
     // Check if the execution ended at a software breakpoint.
     if (halt_res.value() ==
         *RenodeDebugInterface::HaltReason::kSoftwareBreakpoint) {
       if (status != nullptr) {
         *status = static_cast<int32_t>(ExecutionResult::kStoppedAtBreakpoint);
       }
       return total_executed;
     }
     // If we stepped fewer instructions than anticipated, stop stepping and
     // return with no error.
     if (num_executed < step_count) {
       if (status != nullptr) {
         *status = static_cast<int32_t>(ExecutionResult::kOk);
       }
       return total_executed;
     }
     num_to_step -= num_executed;
   }
   if (status != nullptr) {
     *status = static_cast<int32_t>(ExecutionResult::kOk);
   }
   return total_executed;
 }

 // Set configuration item.
 int32_t RenodeAgent::SetConfig(int32_t id, const char* config_names[],
                                const char* config_values[], int size) {
   // Get the core debug interface object.
   auto* dbg = RenodeAgent::Instance()->core_dbg(id);
   // Is the debug interface valid?
   if (dbg == nullptr) {
     return -1;
   }
   auto status = dbg->SetConfig(config_names, config_values, size);
   if (!status.ok()) {
     LOG(ERROR) << "SetConfig: " << status.message();
     return -1;
   }
   return 0;
 }

 // Set irq value.
 int32_t RenodeAgent::SetIrqValue(int32_t id, int32_t irq_num, bool irq_value) {
   // Get the core debug interface object.
   auto* dbg = RenodeAgent::Instance()->core_dbg(id);
   // Is the debug interface valid?
   if (dbg == nullptr) {
     return -1;
   }
   auto status = dbg->SetIrqValue(irq_num, irq_value);
   if (!status.ok()) {
     LOG(ERROR) << "SetIrqValue: " << status.message();
     return -1;
   }
   return 0;
 }

 }  // namespace renode
 }  // namespace util
 }  // namespace sim
 }  // namespace mpact
	// Copyright 2024 Google LLC
	//
	// Licensed under the Apache License, Version 2.0 (the "License");
	// you may not use this file except in compliance with the License.
	// You may obtain a copy of the License at
	//
	// https://www.apache.org/licenses/LICENSE-2.0
	//
	// Unless required by applicable law or agreed to in writing, software
	// distributed under the License is distributed on an "AS IS" BASIS,
	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	// See the License for the specific language governing permissions and
	// limitations under the License.

	#include "mpact/sim/util/renode/renode_mpact.h"

	#include <cstddef>
	#include <cstdint>
	#include <cstring>
	#include <fstream>
	#include <ios>
	#include <limits>
	#include <string>

	#include "absl/log/log.h"
	#include "absl/status/status.h"
	#include "absl/strings/str_cat.h"
	#include "mpact/sim/generic/core_debug_interface.h"
	#include "mpact/sim/generic/type_helpers.h"
	#include "mpact/sim/util/memory/memory_interface.h"
	#include "mpact/sim/util/renode/renode_debug_interface.h"
	#include "mpact/sim/util/renode/renode_memory_access.h"

	using ::mpact::sim::generic::operator*; // NOLINT: used below (clang error).
	using ::mpact::sim::util::MemoryInterface;

	// This function must be defined in the library.
	extern ::mpact::sim::util::renode::RenodeDebugInterface* CreateMpactSim(
	std::string name, std::string cpu_type, MemoryInterface*);

	using ::mpact::sim::util::renode::RenodeAgent;
	using ::mpact::sim::util::renode::RenodeCpuRegister;

	// Implementation of the C interface functions. They each forward the call to
	// the corresponding method in RenodeAgent.
	int32_t construct(char* cpu_type, int32_t max_name_length) {
	return RenodeAgent::Instance()->Construct(cpu_type, max_name_length, nullptr,
	nullptr);
	}

	int32_t construct_with_sysbus(char* cpu_type, int32_t max_name_length,
	int32_t (read_callback)(uint64_t, char,
	int32_t),
	int32_t (write_callback)(uint64_t, char,
	int32_t)) {
	return RenodeAgent::Instance()->Construct(cpu_type, max_name_length,
	read_callback, write_callback);
	}

	int32_t connect(char* cpu_type, int32_t id, int32_t max_name_length) {
	return RenodeAgent::Instance()->Connect(cpu_type, id, max_name_length,
	nullptr, nullptr);
	}

	int32_t connect_with_sysbus(char* cpu_type, int32_t id, int32_t max_name_length,
	int32_t (read_callback)(uint64_t, char, int32_t),
	int32_t (write_callback)(uint64_t, char,
	int32_t)) {
	return RenodeAgent::Instance()->Connect(cpu_type, id, max_name_length,
	read_callback, write_callback);
	}

	void destruct(int32_t id) { RenodeAgent::Instance()->Destroy(id); }

	int32_t reset(int32_t id) { return RenodeAgent::Instance()->Reset(id); }

	int32_t get_reg_info_size(int32_t id) {
	return RenodeAgent::Instance()->GetRegisterInfoSize(id);
	}

	int32_t get_reg_info(int32_t id, int32_t index, char* name, void* info) {
	if (info == nullptr) return -1;
	return RenodeAgent::Instance()->GetRegisterInfo(
	id, index, name, static_cast<RenodeCpuRegister*>(info));
	}

	uint64_t load_elf(int32_t id, const char* elf_file_name, bool for_symbols_only,
	int32_t* status) {
	return RenodeAgent::Instance()->LoadExecutable(id, elf_file_name,
	for_symbols_only, status);
	}

	int32_t load_image(int32_t id, const char* file_name, uint64_t address) {
	return RenodeAgent::Instance()->LoadImage(id, file_name, address);
	}

	int32_t read_register(int32_t id, uint32_t reg_id, uint64_t* value) {
	return RenodeAgent::Instance()->ReadRegister(id, reg_id, value);
	}

	int32_t write_register(int32_t id, uint32_t reg_id, uint64_t value) {
	return RenodeAgent::Instance()->WriteRegister(id, reg_id, value);
	}

	uint64_t read_memory(int32_t id, uint64_t address, char* buffer,
	uint64_t length) {
	return RenodeAgent::Instance()->ReadMemory(id, address, buffer, length);
	}

	uint64_t write_memory(int32_t id, uint64_t address, const char* buffer,
	uint64_t length) {
	return RenodeAgent::Instance()->WriteMemory(id, address, buffer, length);
	}

	uint64_t step(int32_t id, uint64_t num_to_step, int32_t* status) {
	return RenodeAgent::Instance()->Step(id, num_to_step, status);
	}

	int32_t set_config(int32_t id, const char* config_names[],
	const char* config_values[], int32_t size) {
	return RenodeAgent::Instance()->SetConfig(id, config_names, config_values,
	size);
	}

	int32_t set_irq_value(int32_t id, int32_t irq_num, bool irq_value) {
	return RenodeAgent::Instance()->SetIrqValue(id, irq_num, irq_value);
	}

	namespace mpact {
	namespace sim {
	namespace util {
	namespace renode {

	using HaltReason = ::mpact::sim::generic::CoreDebugInterface::HaltReason;

	RenodeAgent* RenodeAgent::instance_ = nullptr;
	int32_t RenodeAgent::count_ = 0;

	// Create the debug instance by calling the factory function.
	int32_t RenodeAgent::Construct(char* cpu_type, int32_t max_name_length,
	int32_t (read_callback)(uint64_t, char,
	int32_t),
	int32_t (write_callback)(uint64_t, char,
	int32_t)) {
	std::string name = absl::StrCat("renode", count_);
	auto* memory_access = new RenodeMemoryAccess(read_callback, write_callback);
	auto* dbg = CreateMpactSim(name, cpu_type, memory_access);
	if (dbg == nullptr) {
	delete memory_access;
	return -1;
	}
	// Make sure that we don't reuse an instance number that may have been created
	// through Connect.
	while (core_dbg_instances_.contains(RenodeAgent::count_)) {
	RenodeAgent::count_++;
	}
	core_dbg_instances_.emplace(RenodeAgent::count_, dbg);
	name_length_map_.emplace(RenodeAgent::count_, max_name_length);
	renode_memory_access_.emplace(RenodeAgent::count_, memory_access);
	return RenodeAgent::count_++;
	}

	int32_t RenodeAgent::Connect(char* cpu_type, int32_t id,
	int32_t max_name_length,
	int32_t (read_callback)(uint64_t, char, int32_t),
	int32_t (write_callback)(uint64_t, char,
	int32_t)) {
	// First check if the instance already exists.
	auto iter = core_dbg_instances_.find(id);
	if (iter != core_dbg_instances_.end()) {
	// If memory callbacks are provided, don't overwrite any previous non-null
	// callbacks.
	auto* mem_access = renode_memory_access_.at(id);
	// Replace any null callbacks.
	if (!mem_access->has_read_fcn()) {
	mem_access->set_read_fcn(read_callback);
	}
	if (!mem_access->has_write_fcn()) {
	mem_access->set_write_fcn(write_callback);
	}
	return id;
	}

	// The instance does not exist, so create a new debug instance.
	std::string name = absl::StrCat("renode", id);
	auto* memory_access = new RenodeMemoryAccess(read_callback, write_callback);
	auto* dbg = CreateMpactSim(name, cpu_type, memory_access);
	if (dbg == nullptr) {
	delete memory_access;
	return -1;
	}
	core_dbg_instances_.emplace(id, dbg);
	name_length_map_.emplace(id, max_name_length);
	renode_memory_access_.emplace(id, memory_access);
	return id;
	}

	// Destroy the debug instance.
	void RenodeAgent::Destroy(int32_t id) {
	// Check for valid instance.
	auto dbg_iter = core_dbg_instances_.find(id);
	// If it doesn't exist, it may already have been deleted, so just return.
	if (dbg_iter == core_dbg_instances_.end()) return;

	delete dbg_iter->second;
	core_dbg_instances_.erase(dbg_iter);

	// Delete the memory access shim.
	auto mem_iter = renode_memory_access_.find(id);
	if (mem_iter == renode_memory_access_.end()) return;
	delete mem_iter->second;
	renode_memory_access_.erase(mem_iter);
	}

	int32_t RenodeAgent::Reset(int32_t id) {
	// Check for valid instance.
	auto dbg_iter = core_dbg_instances_.find(id);
	if (dbg_iter == core_dbg_instances_.end()) return -1;

	// For now, do nothing.
	return 0;
	}

	int32_t RenodeAgent::GetRegisterInfoSize(int32_t id) const {
	// Check for valid instance.
	auto dbg_iter = core_dbg_instances_.find(id);
	if (dbg_iter == core_dbg_instances_.end()) return -1;
	auto* dbg = dbg_iter->second;
	return dbg->GetRenodeRegisterInfoSize();
	}

	int32_t RenodeAgent::GetRegisterInfo(int32_t id, int32_t index, char* name,
	RenodeCpuRegister* info) {
	// Check for valid instance.
	if (info == nullptr) return -1;
	auto dbg_iter = core_dbg_instances_.find(id);
	if (dbg_iter == core_dbg_instances_.end()) return -1;
	auto* dbg = dbg_iter->second;
	int32_t max_len = name_length_map_.at(id);
	auto result = dbg->GetRenodeRegisterInfo(index, max_len, name, *info);
	if (!result.ok()) return -1;
	return 0;
	}

	// Read the register given by the id.
	int32_t RenodeAgent::ReadRegister(int32_t id, uint32_t reg_id,
	uint64_t* value) {
	// Check for valid instance.
	if (value == nullptr) return -1;
	auto dbg_iter = core_dbg_instances_.find(id);
	if (dbg_iter == core_dbg_instances_.end()) return -1;
	// Read register.
	auto* dbg = dbg_iter->second;
	auto result = dbg->ReadRegister(reg_id);
	if (!result.ok()) return -1;
	*value = result.value();
	return 0;
	}

	int32_t RenodeAgent::WriteRegister(int32_t id, uint32_t reg_id,
	uint64_t value) {
	// Check for valid instance.
	auto dbg_iter = core_dbg_instances_.find(id);
	if (dbg_iter == core_dbg_instances_.end()) return -1;
	// Write register.
	auto* dbg = dbg_iter->second;
	auto result = dbg->WriteRegister(reg_id, value);
	if (!result.ok()) return -1;
	return 0;
	}

	uint64_t RenodeAgent::ReadMemory(int32_t id, uint64_t address, char* buffer,
	uint64_t length) {
	// Get the debug interface.
	auto dbg_iter = core_dbg_instances_.find(id);
	if (dbg_iter == core_dbg_instances_.end()) {
	LOG(ERROR) << "No such core dbg instance: " << id;
	return 0;
	}
	auto* dbg = dbg_iter->second;
	auto res = dbg->ReadMemory(address, buffer, length);
	if (!res.ok()) return 0;
	return res.value();
	}

	uint64_t RenodeAgent::WriteMemory(int32_t id, uint64_t address,
	const char* buffer, uint64_t length) {
	// Get the debug interface.
	auto dbg_iter = core_dbg_instances_.find(id);
	if (dbg_iter == core_dbg_instances_.end()) {
	LOG(ERROR) << "No such core dbg instance: " << id;
	return 0;
	}
	auto* dbg = dbg_iter->second;
	auto res = dbg->WriteMemory(address, buffer, length);
	if (!res.ok()) return 0;
	return res.value();
	}

	uint64_t RenodeAgent::LoadExecutable(int32_t id, const char* file_name,
	bool for_symbols_only, int32_t* status) {
	// Get the debug interface.
	auto dbg_iter = core_dbg_instances_.find(id);
	if (dbg_iter == core_dbg_instances_.end()) {
	LOG(ERROR) << "No such core dbg instance: " << id;
	*status = -1;
	return 0;
	}
	// Instantiate loader.
	auto* dbg = dbg_iter->second;
	auto res = dbg->LoadExecutable(file_name, for_symbols_only);
	if (!res.ok()) {
	LOG(ERROR) << "Failed to load executable: " << res.status().message();
	*status = -1;
	return 0;
	}
	*status = 0;
	uint64_t entry = res.value();
	return entry;
	}

	int32_t RenodeAgent::LoadImage(int32_t id, const char* file_name,
	uint64_t address) {
	// Get the debug interface.
	auto dbg_iter = core_dbg_instances_.find(id);
	if (dbg_iter == core_dbg_instances_.end()) {
	LOG(ERROR) << "No such core dbg instance: " << id;
	return -1;
	}
	auto* dbg = dbg_iter->second;
	// Open up the image file.
	std::ifstream image_file;
	image_file.open(file_name, std::ios::in \| std::ios::binary);
	if (!image_file.good()) {
	LOG(ERROR) << "LoadImage: Input file not in good state";
	return -1;
	}
	char buffer[kBufferSize];
	size_t gcount = 0;
	uint64_t load_address = address;
	do {
	// Fill buffer.
	image_file.read(buffer, kBufferSize);
	// Get the number of bytes that was read.
	gcount = image_file.gcount();
	// Write to the simulator memory.
	auto res = dbg->WriteMemory(load_address, buffer, gcount);
	// Check that the write succeeded, increment address if it did.
	if (!res.ok()) {
	LOG(ERROR) << "LoadImage: Memory write failed";
	return -1;
	}
	if (res.value() != gcount) {
	LOG(ERROR) << "LoadImage: Memory write failed to write all the bytes";
	return -1;
	}
	load_address += gcount;
	} while (image_file.good() && (gcount > 0));
	return 0;
	}

	uint64_t RenodeAgent::Step(int32_t id, uint64_t num_to_step, int32_t* status) {
	// Get the core debug if object.
	auto* dbg = RenodeAgent::Instance()->core_dbg(id);
	// Is the debug interface valid?
	if (dbg == nullptr) {
	if (status != nullptr) {
	*status = static_cast<int32_t>(ExecutionResult::kAborted);
	}
	return 0;
	}

	if (num_to_step == 0) {
	*status = static_cast<int32_t>(ExecutionResult::kOk);
	return 0;
	}

	// Check the previous halt reason.
	auto halt_res = dbg->GetLastHaltReason();
	if (!halt_res.ok()) {
	if (status != nullptr) {
	*status = static_cast<int32_t>(ExecutionResult::kAborted);
	}
	return 0;
	}

	// If the previous halt reason was a semihost halt request, then we
	// shouldn't step any further. Just return with "waiting for interrupt"
	// code.
	if (halt_res.value() ==
	*RenodeDebugInterface::HaltReason::kSemihostHaltRequest) {
	*status = static_cast<int32_t>(ExecutionResult::kAborted);
	return 0;
	}
	// Perform the stepping.
	uint32_t total_executed = 0;
	while (num_to_step > 0) {
	// Check how far to step, and make multiple calls if the number
	// is greater than <int>::max();
	int step_count = (num_to_step > std::numeric_limits<int>::max())
	? std::numeric_limits<int>::max()
	: static_cast<int>(num_to_step);
	auto res = dbg->Step(step_count);
	// An error occurred.
	if (!res.ok()) {
	if (status != nullptr) {
	*status = static_cast<int32_t>(ExecutionResult::kAborted);
	}
	return total_executed;
	}
	int num_executed = res.value();
	total_executed += num_executed;

	// Check if the execution was halted due to a semihosting halt request,
	// i.e., program exit.
	halt_res = dbg->GetLastHaltReason();
	if (!halt_res.ok()) {
	if (status != nullptr) {
	*status = static_cast<int32_t>(ExecutionResult::kAborted);
	}
	return total_executed;
	}
	if (halt_res.value() == *HaltReason::kProgramDone) {
	if (status != nullptr) {
	*status = static_cast<int32_t>(ExecutionResult::kAborted);
	}
	return total_executed;
	}
	if (halt_res.value() ==
	*RenodeDebugInterface::HaltReason::kSemihostHaltRequest) {
	if (status != nullptr) {
	*status = static_cast<uint32_t>(ExecutionResult::kAborted);
	}
	return total_executed;
	}
	// Check if the execution ended at a software breakpoint.
	if (halt_res.value() ==
	*RenodeDebugInterface::HaltReason::kSoftwareBreakpoint) {
	if (status != nullptr) {
	*status = static_cast<int32_t>(ExecutionResult::kStoppedAtBreakpoint);
	}
	return total_executed;
	}
	// If we stepped fewer instructions than anticipated, stop stepping and
	// return with no error.
	if (num_executed < step_count) {
	if (status != nullptr) {
	*status = static_cast<int32_t>(ExecutionResult::kOk);
	}
	return total_executed;
	}
	num_to_step -= num_executed;
	}
	if (status != nullptr) {
	*status = static_cast<int32_t>(ExecutionResult::kOk);
	}
	return total_executed;
	}

	// Set configuration item.
	int32_t RenodeAgent::SetConfig(int32_t id, const char* config_names[],
	const char* config_values[], int size) {
	// Get the core debug interface object.
	auto* dbg = RenodeAgent::Instance()->core_dbg(id);
	// Is the debug interface valid?
	if (dbg == nullptr) {
	return -1;
	}
	auto status = dbg->SetConfig(config_names, config_values, size);
	if (!status.ok()) {
	LOG(ERROR) << "SetConfig: " << status.message();
	return -1;
	}
	return 0;
	}

	// Set irq value.
	int32_t RenodeAgent::SetIrqValue(int32_t id, int32_t irq_num, bool irq_value) {
	// Get the core debug interface object.
	auto* dbg = RenodeAgent::Instance()->core_dbg(id);
	// Is the debug interface valid?
	if (dbg == nullptr) {
	return -1;
	}
	auto status = dbg->SetIrqValue(irq_num, irq_value);
	if (!status.ok()) {
	LOG(ERROR) << "SetIrqValue: " << status.message();
	return -1;
	}
	return 0;
	}

	} // namespace renode
	} // namespace util
	} // namespace sim
	} // namespace mpact