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