MemoryExceptions.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "sparta/utils/SpartaException.hpp"
#include "sparta/memory/AddressTypes.hpp"
 
namespace sparta
{
    namespace memory
    {
        class MemoryTranslationError : public SpartaException
        {
        public:
            MemoryTranslationError(addr_t addr,
                                   const std::string& why) :
                SpartaException(((std::stringstream&)(std::stringstream() << "Invalid translation from " << std::hex
                                                    << addr << " : " << why)).str())
            { }
        };
 
        class MemoryAccessError : public SpartaException
        {
        public:
            MemoryAccessError(addr_t addr,
                              addr_t size,
                              const std::string& access,
                              const std::string& why) :
                SpartaException(((std::stringstream&)(std::stringstream() << "Invalid " << access << " access at 0x" << std::hex
                                                    << addr << " of size: " << std::dec << size << ": " << why)).str())
            { }
        };
 
        class MemoryReadError : public MemoryAccessError
        {
        public:
            MemoryReadError(addr_t addr,
                            addr_t size,
                            const std::string& why) :
                MemoryAccessError(addr, size, "read", why)
            { }
        };
 
        class MemoryWriteError : public MemoryAccessError
        {
        public:
            MemoryWriteError(addr_t addr,
                             addr_t size,
                             const std::string& why) :
                MemoryAccessError(addr, size, "write", why)
            { }
        };
 
        class MemoryPeekError : public MemoryAccessError
        {
        public:
            MemoryPeekError(addr_t addr,
                            addr_t size,
                            const std::string& why) :
                MemoryAccessError(addr, size, "peek", why)
            { }
        };
 
        class MemoryPokeError : public MemoryAccessError
        {
        public:
            MemoryPokeError(addr_t addr,
                            addr_t size,
                            const std::string& why) :
                MemoryAccessError(addr, size, "poke", why)
            { }
        };
 
    } // namespace memory
} // namespace sparta