include/library/memoryspace.hpp

   1 #ifndef _library__memoryspace__hpp__included__
   2 #define _library__memoryspace__hpp__included__
   3
   4 #include <string>
   5 #include <list>
   6 #include <vector>
   7 #include <cstdint>
   8 #include <cstring>
   9 #include "threadtypes.hpp"
  10
  11 /**
  12  * Information about region of memory.
  13  */
  14 struct memory_region
  15 {
  16 /**
  17  * Destructor.
  18  */
  19         virtual ~memory_region() throw();
  20 /**
  21  * Name of the region (mainly for debugging and showing to user).
  22  */
  23         std::string name;
  24 /**
  25  * Base address of the region.
  26  */
  27         uint64_t base;
  28 /**
  29  * Size of the region.
  30  */
  31         uint64_t size;
  32 /**
  33  * Last address in region.
  34  */
  35         uint64_t last_address() const throw() { return base + size - 1; }
  36 /**
  37  * Endianess of region (-1 => little, 0 => host, 1 => big).
  38  */
  39         int endian;
  40 /**
  41  * Read-only flag.
  42  */
  43         bool readonly;
  44 /**
  45  * Special flag.
  46  *
  47  * Signals that this region is not RAM/ROM-like, but is special I/O region where reads and writes might not be
  48  * consistent.
  49  */
  50         bool special;
  51 /**
  52  * Direct mapping for the region. If not NULL, read/write will not be used, instead all operations directly
  53  * manipulate this buffer (faster). Must be NULL for special regions.
  54  */
  55         unsigned char* direct_map;
  56 /**
  57  * Read from region.
  58  *
  59  * Parameter offset: Offset to start the read.
  60  * Parameter buffer: Buffer to store the data to.
  61  * Parameter tsize: Amount to read.
  62  *
  63  * Note: The default implementation reads from direct_map.
  64  * Note: Needs to be overridden if direct_map is NULL.
  65  * Note: Must be able to read the whole region at once.
  66  */
  67         virtual void read(uint64_t offset, void* buffer, size_t tsize);
  68 /**
  69  * Write to region (writes to readonly regions are ignored).
  70  *
  71  * Parameter offset: Offset to start the write.
  72  * Parameter buffer: Buffer to read the data from.
  73  * Parameter tsize: Amount to write.
  74  * Returns: True on success, false on failure.
  75  *
  76  * Note: The default implementation writes to direct_map if available and readwrite. Otherwise fails.
  77  * Note: Must be able to write the whole region at once.
  78  */
  79         virtual bool write(uint64_t offset, const void* buffer, size_t tsize);
  80 };
  81
  82 /**
  83  * Direct-mapped region.
  84  */
  85 struct memory_region_direct : public memory_region
  86 {
  87 /**
  88  * Create new direct-mapped region.
  89  *
  90  * Parameter name: Name of the region.
  91  * Parameter base: Base address of the region.
  92  * Parameter endian: Endianess of the region.
  93  * Parameter memory: Memory backing the region.
  94  * Parameter size: Size of the region.
  95  * Parameter _readonly: If true, region is readonly.
  96  */
  97         memory_region_direct(const std::string& name, uint64_t base, int endian, unsigned char* memory,
  98                 size_t size, bool _readonly = false);
  99 /**
 100  * Destructor.
 101  */
 102         ~memory_region_direct() throw();
 103 };
 104
 105 /**
 106  * A whole memory space.
 107  */
 108 class memory_space
 109 {
 110 public:
 111 /**
 112  * Get system endianess.
 113  */
 114 #if (defined(__i386__) || defined(__x86_64__))
 115         static int get_system_endian() throw() { return -1; }
 116 #else
 117         static int get_system_endian() throw() { if(!sysendian) sysendian = _get_system_endian(); return sysendian; }
 118 #endif
 119 /**
 120  * Do native unaligned reads work?
 121  */
 122 #if (defined(__i386__) || defined(__x86_64__))
 123         static int can_read_unaligned() throw() { return true; }
 124 #else
 125         static int can_read_unaligned() throw() { return false; }
 126 #endif
 127 /**
 128  * Lookup region covering address.
 129  *
 130  * Parameter address: The address to look up.
 131  * Returns: The region/offset pair, or NULL/0 if that address is unmapped.
 132  */
 133         std::pair<memory_region*, uint64_t> lookup(uint64_t address);
 134 /**
 135  * Lookup region covering linear address.
 136  *
 137  * Parameter linear: The linear address to look up.
 138  * Returns: The region/offset pair, or NULL/0 if that address is unmapped.
 139  */
 140         std::pair<memory_region*, uint64_t> lookup_linear(uint64_t linear);
 141 /**
 142  * Lookup region with specified index..
 143  *
 144  * Parameter n: The index to look up.
 145  * Returns: The region, or NULL if index is invalid.
 146  */
 147         memory_region* lookup_n(size_t n);
 148 /**
 149  * Get number of regions.
 150  */
 151         size_t get_region_count() { return u_regions.size(); }
 152 /**
 153  * Get linear RAM size.
 154  *
 155  * Returns: The linear RAM size in bytes.
 156  */
 157         uint64_t get_linear_size() { return linear_size; }
 158 /**
 159  * Get list of all regions in memory space.
 160  */
 161         std::list<memory_region*> get_regions();
 162 /**
 163  * Set list of all regions in memory space.
 164  */
 165         void set_regions(const std::list<memory_region*>& regions);
 166 /**
 167  * Read an element (primitive type) from memory.
 168  *
 169  * Parameter address: The address to read.
 170  * Returns: The read value.
 171  */
 172         template<typename T> T read(uint64_t address);
 173 /**
 174  * Write an element (primitive type) to memory.
 175  *
 176  * Parameter address: The address to write.
 177  * Parameter value: The value to write.
 178  * Returns: True on success, false on failure.
 179  */
 180         template<typename T> bool write(uint64_t address, T value);
 181 /**
 182  * Read a byte range (not across regions).
 183  *
 184  * Parameter address: Base address to start the read from.
 185  * Parameter buffer: Buffer to store the data to.
 186  * Parameter bsize: Size of buffer.
 187  */
 188         void read_range(uint64_t address, void* buffer, size_t bsize);
 189 /**
 190  * Write a byte range (not across regions).
 191  *
 192  * Parameter address: Base address to start the write from.
 193  * Parameter buffer: Buffer to read the data from.
 194  * Parameter bsize: Size of buffer.
 195  * Returns: True on success, false on failure.
 196  */
 197         bool write_range(uint64_t address, const void* buffer, size_t bsize);
 198 /**
 199  * Read an element (primitive type) from memory.
 200  *
 201  * Parameter linear: The linear address to read.
 202  * Returns: The read value.
 203  */
 204         template<typename T> T read_linear(uint64_t linear);
 205 /**
 206  * Write an element (primitive type) to memory.
 207  *
 208  * Parameter linear: The linear address to write.
 209  * Parameter value: The value to write.
 210  * Returns: True on success, false on failure.
 211  */
 212         template<typename T> bool write_linear(uint64_t linear, T value);
 213 /**
 214  * Read a byte range (not across regions).
 215  *
 216  * Parameter linear: Base linear address to start the read from.
 217  * Parameter buffer: Buffer to store the data to.
 218  * Parameter bsize: Size of buffer.
 219  */
 220         void read_range_linear(uint64_t linear, void* buffer, size_t bsize);
 221 /**
 222  * Write a byte range (not across regions).
 223  *
 224  * Parameter linear: Base linear address to start the write from.
 225  * Parameter buffer: Buffer to read the data from.
 226  * Parameter bsize: Size of buffer.
 227  * Returns: True on success, false on failure.
 228  */
 229         bool write_range_linear(uint64_t linear, const void* buffer, size_t bsize);
 230 /**
 231  * Read complete linear memory.
 232  *
 233  * Parameter buffer: Buffer to store to (get_linear_size() bytes).
 234  */
 235         void read_all_linear_memory(uint8_t* buffer);
 236 private:
 237         mutex_class mutex;
 238         std::vector<memory_region*> u_regions;
 239         std::vector<memory_region*> u_lregions;
 240         std::vector<uint64_t> linear_bases;
 241         uint64_t linear_size;
 242         static int _get_system_endian();
 243         static int sysendian;
 244 };
 245
 246
 247 #endif