mpact/sim/util/renode/renode_mpact.h - 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.

 #ifndef MPACT_SIM_UTIL_RENODE_RENODE_MPACT_H_
 #define MPACT_SIM_UTIL_RENODE_RENODE_MPACT_H_

 #include <cstddef>
 #include <cstdint>

 #include "absl/container/flat_hash_map.h"
 #include "absl/functional/any_invocable.h"
 #include "mpact/sim/util/renode/renode_debug_interface.h"
 #include "mpact/sim/util/renode/renode_memory_access.h"

 // This file defines the interface that Renode uses to communicate with the
 // simulator as well as support classes to implement the interface.

 // C interface used by Renode.
 extern "C" {
 // There are two ways to create debug instances: create and connect. The main
 // difference between them is that connect specifies the debug instance id to
 // use (and thus must be managed by the caller). This also also allows multiple
 // connections to the debug instance, which is useful if the debug instance
 // is used both as a bus initiator as well as a bus target in a system
 // simulation.

 // Create a debug instance, returning its id. A return value of zero indicates
 // and error. The sysbus variant of the call provides methods to perform loads
 // and stores from a memory space managed by the caller.
 int32_t construct(char* cpu_type, int32_t max_name_length);
 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));
 // Connect with, or construct, a debug instance connected to a simulator with
 // the given id. A return value of zero indicates an error. The sysbus variant
 // of the call provides methods to perform loads and stores from a memory space
 // managed by the caller.
 int32_t connect(char* cpu_type, int32_t id, int32_t max_name_length);
 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));
 // Destruct the given debug instance. A negative return value indicates an
 // error.
 void destruct(int32_t id);
 // Return the number of register entries.
 int32_t get_reg_info_size(int32_t id);
 // Return the register entry with the given index. The info pointer should
 // store an object of type RenodeCpuRegister.
 int32_t get_reg_info(int32_t id, int32_t index, char* name, void* info);
 // Use the loader to read in the given ELF executable. If the for_symbols_only
 // is true, do not write it to memory or set the PC to the entry point. The
 // memory and register initialization will be performed by ReNode. In this case
 // the file is loaded only to provide symbol lookup.
 uint64_t load_elf(int32_t id, const char* elf_file_name, bool for_symbols_only,
                   int32_t* status);
 // Load the content of the given file into memory, starting at the given
 // address.
 int32_t load_image(int32_t id, const char* file_name, uint64_t address);
 // Read register reg_id in the instance id, store the value in the pointer
 // given. A return value < 0 is an error.
 int32_t read_register(int32_t id, uint32_t reg_id, uint64_t* value);
 // Write register reg_id in the instance id. A return value < 0 is an error.
 int32_t write_register(int32_t id, uint32_t reg_id, uint64_t value);
 // Read/Write memory.
 uint64_t read_memory(int32_t id, uint64_t address, char* buffer,
                      uint64_t length);
 uint64_t write_memory(int32_t id, uint64_t address, const char* buffer,
                       uint64_t length);
 // Reset the instance. A return value < 0 is an error.
 int32_t reset(int32_t id);
 // Step the instance id by num_to_step instructions. Return the number of
 // instructions stepped. The status is written to the pointer *status.
 uint64_t step(int32_t id, uint64_t num_to_step, int32_t* status);
 // Set configuration items. This passes in the id, two arrays of strings (names
 // and values), and the size of the two arrays. Depending on the name of the
 // configuration item, the string will be interpreted according to the expected
 // type.
 int32_t set_config(int32_t id, const char* config_name[],
                    const char* config_value[], int32_t size);
 // Set the given irq number (if valid) to the provided value.
 int32_t set_irq_value(int32_t id, int32_t irq_number, bool irq_value);
 }  // extern "C"

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

 // Execution results.
 enum class ExecutionResult : int32_t {
   kOk = 0,
   kInterrupted = 1,
   kWaitingForInterrupt = 2,
   kStoppedAtBreakpoint = 3,
   kStoppedAtWatchpoint = 4,
   kExternalMmuFault = 5,
   kAborted = -1,
 };

 // Intermediary between the C interface above and the actual debug interface
 // of the simulator.
 class RenodeAgent {
  public:
   constexpr static size_t kBufferSize = 64 * 1024;
   // This is a singleton class, so need a static Instance method.
   static RenodeAgent* Instance() {
     if (instance_ != nullptr) return instance_;

     instance_ = new RenodeAgent();
     return instance_;
   }

   // These methods correspond to the C methods defined above.
   int32_t 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));
   int32_t 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));
   void Destroy(int32_t id);
   int32_t Reset(int32_t id);
   int32_t GetRegisterInfoSize(int32_t id) const;
   int32_t GetRegisterInfo(int32_t id, int32_t index, char* name,
                           RenodeCpuRegister* info);
   int32_t ReadRegister(int32_t id, uint32_t reg_id, uint64_t* value);
   int32_t WriteRegister(int32_t id, uint32_t reg_id, uint64_t value);
   uint64_t ReadMemory(int32_t id, uint64_t address, char* buffer,
                       uint64_t length);
   uint64_t WriteMemory(int32_t id, uint64_t address, const char* buffer,
                        uint64_t length);

   uint64_t LoadExecutable(int32_t id, const char* elf_file_name,
                           bool for_symbols_only, int32_t* status);
   int32_t LoadImage(int32_t id, const char* file_name, uint64_t address);
   uint64_t Step(int32_t id, uint64_t num_to_step, int32_t* status);
   int32_t SetConfig(int32_t id, const char* config_names[],
                     const char* config_values[], int32_t size);
   int32_t SetIrqValue(int32_t id, int32_t irq_number, bool irq_value);

   // Accessor.
   RenodeDebugInterface* core_dbg(int32_t id) const {
     auto ptr = core_dbg_instances_.find(id);
     if (ptr != core_dbg_instances_.end()) return ptr->second;
     return nullptr;
   }

  private:
   using RenodeMemoryFcn = absl::AnyInvocable<int32_t(uint64_t, char*, int32_t)>;
   // Private constructor.
   RenodeAgent() = default;
   static RenodeAgent* instance_;
   static int32_t count_;
   // Map of renode memory access interfaces used to access devices and memory
   // off the system bus.
   absl::flat_hash_map<int32_t, RenodeMemoryAccess*> renode_memory_access_;
   // Map of debug instances.
   absl::flat_hash_map<int32_t, RenodeDebugInterface*> core_dbg_instances_;
   absl::flat_hash_map<int32_t, int32_t> name_length_map_;
   absl::flat_hash_map<int32_t, uint64_t> memory_bases_;
   absl::flat_hash_map<int32_t, uint64_t> memory_sizes_;
 };

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

 #endif  // MPACT_SIM_UTIL_RENODE_RENODE_MPACT_H_
	// 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.

	#ifndef MPACT_SIM_UTIL_RENODE_RENODE_MPACT_H_
	#define MPACT_SIM_UTIL_RENODE_RENODE_MPACT_H_

	#include <cstddef>
	#include <cstdint>

	#include "absl/container/flat_hash_map.h"
	#include "absl/functional/any_invocable.h"
	#include "mpact/sim/util/renode/renode_debug_interface.h"
	#include "mpact/sim/util/renode/renode_memory_access.h"

	// This file defines the interface that Renode uses to communicate with the
	// simulator as well as support classes to implement the interface.

	// C interface used by Renode.
	extern "C" {
	// There are two ways to create debug instances: create and connect. The main
	// difference between them is that connect specifies the debug instance id to
	// use (and thus must be managed by the caller). This also also allows multiple
	// connections to the debug instance, which is useful if the debug instance
	// is used both as a bus initiator as well as a bus target in a system
	// simulation.

	// Create a debug instance, returning its id. A return value of zero indicates
	// and error. The sysbus variant of the call provides methods to perform loads
	// and stores from a memory space managed by the caller.
	int32_t construct(char* cpu_type, int32_t max_name_length);
	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));
	// Connect with, or construct, a debug instance connected to a simulator with
	// the given id. A return value of zero indicates an error. The sysbus variant
	// of the call provides methods to perform loads and stores from a memory space
	// managed by the caller.
	int32_t connect(char* cpu_type, int32_t id, int32_t max_name_length);
	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));
	// Destruct the given debug instance. A negative return value indicates an
	// error.
	void destruct(int32_t id);
	// Return the number of register entries.
	int32_t get_reg_info_size(int32_t id);
	// Return the register entry with the given index. The info pointer should
	// store an object of type RenodeCpuRegister.
	int32_t get_reg_info(int32_t id, int32_t index, char* name, void* info);
	// Use the loader to read in the given ELF executable. If the for_symbols_only
	// is true, do not write it to memory or set the PC to the entry point. The
	// memory and register initialization will be performed by ReNode. In this case
	// the file is loaded only to provide symbol lookup.
	uint64_t load_elf(int32_t id, const char* elf_file_name, bool for_symbols_only,
	int32_t* status);
	// Load the content of the given file into memory, starting at the given
	// address.
	int32_t load_image(int32_t id, const char* file_name, uint64_t address);
	// Read register reg_id in the instance id, store the value in the pointer
	// given. A return value < 0 is an error.
	int32_t read_register(int32_t id, uint32_t reg_id, uint64_t* value);
	// Write register reg_id in the instance id. A return value < 0 is an error.
	int32_t write_register(int32_t id, uint32_t reg_id, uint64_t value);
	// Read/Write memory.
	uint64_t read_memory(int32_t id, uint64_t address, char* buffer,
	uint64_t length);
	uint64_t write_memory(int32_t id, uint64_t address, const char* buffer,
	uint64_t length);
	// Reset the instance. A return value < 0 is an error.
	int32_t reset(int32_t id);
	// Step the instance id by num_to_step instructions. Return the number of
	// instructions stepped. The status is written to the pointer *status.
	uint64_t step(int32_t id, uint64_t num_to_step, int32_t* status);
	// Set configuration items. This passes in the id, two arrays of strings (names
	// and values), and the size of the two arrays. Depending on the name of the
	// configuration item, the string will be interpreted according to the expected
	// type.
	int32_t set_config(int32_t id, const char* config_name[],
	const char* config_value[], int32_t size);
	// Set the given irq number (if valid) to the provided value.
	int32_t set_irq_value(int32_t id, int32_t irq_number, bool irq_value);
	} // extern "C"

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

	// Execution results.
	enum class ExecutionResult : int32_t {
	kOk = 0,
	kInterrupted = 1,
	kWaitingForInterrupt = 2,
	kStoppedAtBreakpoint = 3,
	kStoppedAtWatchpoint = 4,
	kExternalMmuFault = 5,
	kAborted = -1,
	};

	// Intermediary between the C interface above and the actual debug interface
	// of the simulator.
	class RenodeAgent {
	public:
	constexpr static size_t kBufferSize = 64 * 1024;
	// This is a singleton class, so need a static Instance method.
	static RenodeAgent* Instance() {
	if (instance_ != nullptr) return instance_;

	instance_ = new RenodeAgent();
	return instance_;
	}

	// These methods correspond to the C methods defined above.
	int32_t 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));
	int32_t 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));
	void Destroy(int32_t id);
	int32_t Reset(int32_t id);
	int32_t GetRegisterInfoSize(int32_t id) const;
	int32_t GetRegisterInfo(int32_t id, int32_t index, char* name,
	RenodeCpuRegister* info);
	int32_t ReadRegister(int32_t id, uint32_t reg_id, uint64_t* value);
	int32_t WriteRegister(int32_t id, uint32_t reg_id, uint64_t value);
	uint64_t ReadMemory(int32_t id, uint64_t address, char* buffer,
	uint64_t length);
	uint64_t WriteMemory(int32_t id, uint64_t address, const char* buffer,
	uint64_t length);

	uint64_t LoadExecutable(int32_t id, const char* elf_file_name,
	bool for_symbols_only, int32_t* status);
	int32_t LoadImage(int32_t id, const char* file_name, uint64_t address);
	uint64_t Step(int32_t id, uint64_t num_to_step, int32_t* status);
	int32_t SetConfig(int32_t id, const char* config_names[],
	const char* config_values[], int32_t size);
	int32_t SetIrqValue(int32_t id, int32_t irq_number, bool irq_value);

	// Accessor.
	RenodeDebugInterface* core_dbg(int32_t id) const {
	auto ptr = core_dbg_instances_.find(id);
	if (ptr != core_dbg_instances_.end()) return ptr->second;
	return nullptr;
	}

	private:
	using RenodeMemoryFcn = absl::AnyInvocable<int32_t(uint64_t, char*, int32_t)>;
	// Private constructor.
	RenodeAgent() = default;
	static RenodeAgent* instance_;
	static int32_t count_;
	// Map of renode memory access interfaces used to access devices and memory
	// off the system bus.
	absl::flat_hash_map<int32_t, RenodeMemoryAccess*> renode_memory_access_;
	// Map of debug instances.
	absl::flat_hash_map<int32_t, RenodeDebugInterface*> core_dbg_instances_;
	absl::flat_hash_map<int32_t, int32_t> name_length_map_;
	absl::flat_hash_map<int32_t, uint64_t> memory_bases_;
	absl::flat_hash_map<int32_t, uint64_t> memory_sizes_;
	};

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

	#endif // MPACT_SIM_UTIL_RENODE_RENODE_MPACT_H_