Description
Byte-addressable memory.
This class represents an entire state of memory via MemoryMap, allocating new memory in units of pages (the size of a page is configurable.
Definition at line 152 of file ConcreteSemantics.h.
#include <Rose/BinaryAnalysis/InstructionSemantics/ConcreteSemantics.h>
Public Types | |
| using | Super = BaseSemantics::MemoryState |
| Base type. | |
| using | Ptr = MemoryStatePtr |
| Shared-ownership pointer. | |
 Public Types inherited from Rose::BinaryAnalysis::InstructionSemantics::BaseSemantics::MemoryState | |
| typedef MemoryStatePtr | Ptr |
| Shared-ownership pointer. | |
Public Member Functions | |
| virtual BaseSemantics::MemoryStatePtr | create (const BaseSemantics::SValuePtr &addrProtoval, const BaseSemantics::SValuePtr &valProtoval) const override |
| Virtual constructor. | |
| virtual BaseSemantics::MemoryStatePtr | clone () const override |
| Virtual copy constructor. | |
| virtual void | clear () override |
| Clear memory. | |
| virtual void | hash (Combinatorics::Hasher &, BaseSemantics::RiscOperators *addrOps, BaseSemantics::RiscOperators *valOps) const override |
| Calculate a hash for this memory state. | |
| virtual void | print (std::ostream &, Formatter &) const override |
| Print a memory state to more than one line of output. | |
| virtual BaseSemantics::SValuePtr | readMemory (const BaseSemantics::SValuePtr &addr, const BaseSemantics::SValuePtr &dflt, BaseSemantics::RiscOperators *addrOps, BaseSemantics::RiscOperators *valOps) override |
| Read a value from memory. | |
| virtual BaseSemantics::SValuePtr | peekMemory (const BaseSemantics::SValuePtr &addr, const BaseSemantics::SValuePtr &dflt, BaseSemantics::RiscOperators *addrOps, BaseSemantics::RiscOperators *valOps) override |
| Read a value from memory without side effects. | |
| virtual void | writeMemory (const BaseSemantics::SValuePtr &addr, const BaseSemantics::SValuePtr &value, BaseSemantics::RiscOperators *addrOps, BaseSemantics::RiscOperators *valOps) override |
| Write a value to memory. | |
| virtual bool | merge (const BaseSemantics::MemoryStatePtr &other, BaseSemantics::RiscOperators *addrOps, BaseSemantics::RiscOperators *valOps) override |
| Merge memory states for data flow analysis. | |
| const MemoryMap::Ptr | memoryMap () const |
| Returns the memory map. | |
| void | memoryMap (const MemoryMap::Ptr &, Sawyer::Optional< unsigned > padAccess=Sawyer::Nothing()) |
| Set memory map. | |
| void | allocatePage (rose_addr_t va) |
| Allocate a page of memory. | |
| rose_addr_t | pageSize () const |
| Size of each page of memory. | |
| void | pageSize (rose_addr_t nBytes) |
| Size of each page of memory. | |
| Public Member Functions inherited from Rose::BinaryAnalysis::InstructionSemantics::BaseSemantics::MemoryState | |
| SValuePtr | get_addr_protoval () const |
| Return the address protoval. | |
| SValuePtr | get_val_protoval () const |
| Return the value protoval. | |
| MergerPtr | merger () const |
| Property: Merger. | |
| void | merger (const MergerPtr &) |
| Property: Merger. | |
| bool | byteRestricted () const |
| Indicates whether memory cell values are required to be eight bits wide. | |
| void | byteRestricted (bool) |
| Indicates whether memory cell values are required to be eight bits wide. | |
| ByteOrder::Endianness | get_byteOrder () const |
| Memory byte order. | |
| void | set_byteOrder (ByteOrder::Endianness) |
| Memory byte order. | |
| void | print (std::ostream &, const std::string prefix="") const |
| Print a memory state to more than one line of output. | |
| WithFormatter | with_format (Formatter &) |
| Used for printing memory states with formatting. | |
| WithFormatter | operator+ (Formatter &) |
| Used for printing memory states with formatting. | |
| WithFormatter | operator+ (const std::string &linePrefix) |
| Used for printing memory states with formatting. | |
Static Public Member Functions | |
| static MemoryStatePtr | instance (const BaseSemantics::SValuePtr &addrProtoval, const BaseSemantics::SValuePtr &valProtoval) |
| Instantiates a new memory state having specified prototypical value. | |
| static MemoryStatePtr | instance (const MemoryStatePtr &other) |
| Instantiates a new deep copy of an existing state. | |
| static MemoryStatePtr | promote (const BaseSemantics::MemoryStatePtr &) |
| Recasts a base pointer to a concrete memory state. | |
| Static Public Member Functions inherited from Rose::BinaryAnalysis::InstructionSemantics::BaseSemantics::MemoryState | |
| static MemoryStatePtr | promote (const MemoryStatePtr &) |
Protected Member Functions | |
| MemoryState (const BaseSemantics::SValuePtr &addrProtoval, const BaseSemantics::SValuePtr &valProtoval) | |
| MemoryState (const MemoryState &other) | |
| BaseSemantics::SValuePtr | readOrPeekMemory (const BaseSemantics::SValuePtr &addr, const BaseSemantics::SValuePtr &dflt, BaseSemantics::RiscOperators *addrOps, BaseSemantics::RiscOperators *valOps, bool allowSideEffects) |
| Protected Member Functions inherited from Rose::BinaryAnalysis::InstructionSemantics::BaseSemantics::MemoryState | |
| MemoryState (const SValuePtr &addrProtoval, const SValuePtr &valProtoval) | |
| MemoryState (const MemoryStatePtr &other) | |
Member Typedef Documentation
◆ Super
| using Rose::BinaryAnalysis::InstructionSemantics::ConcreteSemantics::MemoryState::Super = BaseSemantics::MemoryState |
Base type.
Definition at line 155 of file ConcreteSemantics.h.
◆ Ptr
| using Rose::BinaryAnalysis::InstructionSemantics::ConcreteSemantics::MemoryState::Ptr = MemoryStatePtr |
Shared-ownership pointer.
Definition at line 158 of file ConcreteSemantics.h.
Member Function Documentation
◆ instance() [1/2]
|
static |
Instantiates a new memory state having specified prototypical value.
The addrProtoval and valProtoval must both be of ConcreteSemantics::SValue type or derived classes.
◆ instance() [2/2]
|
static |
Instantiates a new deep copy of an existing state.
For efficiency purposes, the data buffers are not copied immediately but rather marked as copy-on-write. However, the newly constructed memory map will have its own segments, which hold the segment names, access permissions, etc.
◆ create()
|
overridevirtual |
Virtual constructor.
Creates a memory state having specified prototypical value, which should be of type ConcreteSemantics::SValue or subclasses.
Implements Rose::BinaryAnalysis::InstructionSemantics::BaseSemantics::MemoryState.
◆ clone()
|
overridevirtual |
Virtual copy constructor.
Creates a new deep copy of this memory state. For efficiency purposes, the data buffers are not copied immediately but rather marked as copy-on-write. However, the newly constructed memory map will have its own segments, which hold the segment names, access permissions, etc.
Implements Rose::BinaryAnalysis::InstructionSemantics::BaseSemantics::MemoryState.
◆ promote()
|
static |
Recasts a base pointer to a concrete memory state.
This is a checked cast that will fail if the specified pointer does not have a run-time type that is a ConcreteSemantics::MemoryState or subclass thereof.
◆ clear()
|
overridevirtual |
Clear memory.
Removes all memory cells from this memory state.
Implements Rose::BinaryAnalysis::InstructionSemantics::BaseSemantics::MemoryState.
◆ hash()
|
overridevirtual |
Calculate a hash for this memory state.
This hashes the addresses and values stored in memory. The goal is to be able to identify when two memory states are the "same". An analysis might be able to take shortcuts if it encounters a state that it has seen before.
Implements Rose::BinaryAnalysis::InstructionSemantics::BaseSemantics::MemoryState.
◆ print()
|
overridevirtual |
Print a memory state to more than one line of output.
Implements Rose::BinaryAnalysis::InstructionSemantics::BaseSemantics::MemoryState.
◆ readMemory()
|
overridevirtual |
Read a value from memory.
Consults the memory represented by this MemoryState object and returns a semantic value. Depending on the semantic domain, the value can be a value that is already stored in the memory state, a supplied default value, a new value constructed from some combination of existing values and/or the default value, or anything else. For instance, in a symbolic domain the address could alias multiple existing memory locations and the implementation may choose to return a McCarthy expression. Additional data (such as SMT solvers) may be passed via the RiscOperators argument.
The size of the value being read does not necessarily need to be equal to the size of values stored in the memory state, though it typically is(1). For instance, an implementation may allow reading a 32-bit little endian value from a memory state that stores only bytes. A RiscOperators object is provided for use in these situations.
In order to support cases where an address does not match any existing location, the dflt value can be used to initialize a new memory location. The manner in which the default is used depends on the implementation. In any case, the width of the dflt value determines how much to read.
Footnote 1: A MemoryState::readMemory() call is the last in a sequence of delegations starting with RiscOperators::readMemory(). The designers of the MemoryState, State, and RiscOperators subclasses will need to coordinate to decide which layer should handle concatenating values from individual memory locations.
Implements Rose::BinaryAnalysis::InstructionSemantics::BaseSemantics::MemoryState.
◆ peekMemory()
|
overridevirtual |
Read a value from memory without side effects.
This is similar to readMemory except there are no side effects. The memory state is not modified by this function.
Implements Rose::BinaryAnalysis::InstructionSemantics::BaseSemantics::MemoryState.
◆ writeMemory()
|
overridevirtual |
Write a value to memory.
Consults the memory represented by this MemoryState object and possibly inserts the specified value. The details of how a value is inserted into a memory state depends entirely on the implementation in a subclass and will probably be different for each semantic domain.
A MemoryState::writeMemory() call is the last in a sequence of delegations starting with RiscOperators::writeMemory(). The designers of the MemoryState, State, and RiscOperators will need to coordinate to decide which layer (if any) should handle splitting a multi-byte value into multiple memory locations.
Implements Rose::BinaryAnalysis::InstructionSemantics::BaseSemantics::MemoryState.
◆ merge()
|
overridevirtual |
Merge memory states for data flow analysis.
Merges the other state into this state, returning true if this state changed.
Implements Rose::BinaryAnalysis::InstructionSemantics::BaseSemantics::MemoryState.
◆ memoryMap() [1/2]
|
inline |
Returns the memory map.
Definition at line 243 of file ConcreteSemantics.h.
◆ memoryMap() [2/2]
| void Rose::BinaryAnalysis::InstructionSemantics::ConcreteSemantics::MemoryState::memoryMap | ( | const MemoryMap::Ptr & | , |
| Sawyer::Optional< unsigned > | padAccess = Sawyer::Nothing() |
||
| ) |
Set memory map.
If the specified map's areas are not in units of pages then padding segments will be added to this memory state. The padding segments will either have the accessibility specified by padAccess, or will have the same accessibility as the memory region being padded. All padding segments will be named "padding".
◆ pageSize() [1/2]
|
inline |
Size of each page of memory.
Memory is allocated in units of the page size and aligned on page-size boundaries. The page size cannot be changed once the map contains data.
Definition at line 258 of file ConcreteSemantics.h.
◆ pageSize() [2/2]
| void Rose::BinaryAnalysis::InstructionSemantics::ConcreteSemantics::MemoryState::pageSize | ( | rose_addr_t | nBytes | ) |
Size of each page of memory.
Memory is allocated in units of the page size and aligned on page-size boundaries. The page size cannot be changed once the map contains data.
◆ allocatePage()
| void Rose::BinaryAnalysis::InstructionSemantics::ConcreteSemantics::MemoryState::allocatePage | ( | rose_addr_t | va | ) |
Allocate a page of memory.
The specified address will be contained in the page, which is aligned on a page boundary. Do not call this if the page is already allocated unless: it will replace the allocated page with a new one containing all zeros.
The documentation for this class was generated from the following file:
