ROSE 0.11.145.229
Public Types | Public Member Functions | Static Public Member Functions | Protected Member Functions | List of all members
Rose::BinaryAnalysis::InstructionSemantics::ConcreteSemantics::MemoryState Class Reference

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>

Inheritance diagram for Rose::BinaryAnalysis::InstructionSemantics::ConcreteSemantics::MemoryState:
Inheritance graph
[legend]
Collaboration diagram for Rose::BinaryAnalysis::InstructionSemantics::ConcreteSemantics::MemoryState:
Collaboration graph
[legend]

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 Types inherited from Rose::BinaryAnalysis::InstructionSemantics::BaseSemantics::AddressSpace
using Ptr = AddressSpacePtr
 Shared-ownership pointer.
 
using Purpose = AddressSpacePurpose
 Purpose for the address space.
 

Public Member Functions

virtual BaseSemantics::MemoryStatePtr create (const BaseSemantics::SValuePtr &addrProtoval, const BaseSemantics::SValuePtr &valProtoval) const override
 Virtual constructor.
 
virtual BaseSemantics::AddressSpacePtr 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
 Hash this address space.
 
virtual void print (std::ostream &, Formatter &) const override
 Print an address space.
 
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::AddressSpacePtr &other, BaseSemantics::RiscOperators *addrOps, BaseSemantics::RiscOperators *valOps) override
 Merge address spaces 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.
 
- Public Member Functions inherited from Rose::BinaryAnalysis::InstructionSemantics::BaseSemantics::AddressSpace
virtual SValuePtr read (const AddressSpaceAddress &, const SValuePtr &dflt, RiscOperators &addrOps, RiscOperators &valOps)
 Read a value from the address space.
 
virtual SValuePtr peek (const AddressSpaceAddress &, const SValuePtr &dflt, RiscOperators &addrOps, RiscOperators &valOps)
 Read without causing side effects.
 
virtual void write (const AddressSpaceAddress &, const SValuePtr &value, RiscOperators &addrOps, RiscOperators &valOps)
 Write a value to an address space.
 
std::string printableName () const
 Printable name for this address space.
 
Purpose purpose () const
 Property: Purpose of this address space.
 
void purpose (Purpose)
 Property: Purpose of this address space.
 
const std::string & name () const
 Property: Name for this address space.
 
void name (const std::string &)
 Property: Name for this address space.
 
void print (std::ostream &, const std::string &prefix="") const
 Print an address space.
 
WithFormatter with_format (Formatter &)
 Used for printing address spaces with formatting.
 
WithFormatter operator+ (Formatter &)
 Used for printing address spaces with formatting.
 
WithFormatter operator+ (const std::string &linePrefix)
 Used for printing address spaces 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::AddressSpacePtr &)
 Recasts a base pointer to a concrete memory state.
 
- Static Public Member Functions inherited from Rose::BinaryAnalysis::InstructionSemantics::BaseSemantics::MemoryState
static MemoryStatePtr promote (const AddressSpacePtr &)
 

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)
 
- Protected Member Functions inherited from Rose::BinaryAnalysis::InstructionSemantics::BaseSemantics::AddressSpace
 AddressSpace (Purpose, const std::string &name)
 
 AddressSpace (const AddressSpace &)
 
AddressSpaceoperator= (const AddressSpace &)=delete
 

Member Typedef Documentation

◆ Super

Base type.

Definition at line 155 of file ConcreteSemantics.h.

◆ Ptr

Shared-ownership pointer.

Definition at line 158 of file ConcreteSemantics.h.

Member Function Documentation

◆ instance() [1/2]

static MemoryStatePtr Rose::BinaryAnalysis::InstructionSemantics::ConcreteSemantics::MemoryState::instance ( const BaseSemantics::SValuePtr addrProtoval,
const BaseSemantics::SValuePtr valProtoval 
)
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 MemoryStatePtr Rose::BinaryAnalysis::InstructionSemantics::ConcreteSemantics::MemoryState::instance ( const MemoryStatePtr other)
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()

virtual BaseSemantics::MemoryStatePtr Rose::BinaryAnalysis::InstructionSemantics::ConcreteSemantics::MemoryState::create ( const BaseSemantics::SValuePtr addrProtoval,
const BaseSemantics::SValuePtr valProtoval 
) const
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()

virtual BaseSemantics::AddressSpacePtr Rose::BinaryAnalysis::InstructionSemantics::ConcreteSemantics::MemoryState::clone ( ) const
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::AddressSpace.

◆ promote()

static MemoryStatePtr Rose::BinaryAnalysis::InstructionSemantics::ConcreteSemantics::MemoryState::promote ( const BaseSemantics::AddressSpacePtr )
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()

virtual void Rose::BinaryAnalysis::InstructionSemantics::ConcreteSemantics::MemoryState::clear ( )
overridevirtual

Clear memory.

Removes all memory cells from this memory state.

Implements Rose::BinaryAnalysis::InstructionSemantics::BaseSemantics::MemoryState.

◆ hash()

virtual void Rose::BinaryAnalysis::InstructionSemantics::ConcreteSemantics::MemoryState::hash ( Combinatorics::Hasher ,
BaseSemantics::RiscOperators addrOps,
BaseSemantics::RiscOperators valOps 
) const
overridevirtual

Hash this address space.

Hashes this address space by appending its data to the specified hasher. The goal is to identify when two address spaces are the "same" and allow certain kinds of analyses to take shortcuts. The address space purpose and name are not included in the hash. Separate RISC operators are passed for the addresses and values of this address space and are used if the hashing requires any operations on the addresses or values.

Implements Rose::BinaryAnalysis::InstructionSemantics::BaseSemantics::AddressSpace.

◆ print()

virtual void Rose::BinaryAnalysis::InstructionSemantics::ConcreteSemantics::MemoryState::print ( std::ostream &  ,
Formatter  
) const
overridevirtual

Print an address space.

The output most likely occupies more than one line and each emitted line will be terminated with a line feed.

Implements Rose::BinaryAnalysis::InstructionSemantics::BaseSemantics::AddressSpace.

◆ readMemory()

virtual BaseSemantics::SValuePtr Rose::BinaryAnalysis::InstructionSemantics::ConcreteSemantics::MemoryState::readMemory ( const BaseSemantics::SValuePtr address,
const BaseSemantics::SValuePtr dflt,
BaseSemantics::RiscOperators addrOps,
BaseSemantics::RiscOperators valOps 
)
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()

virtual BaseSemantics::SValuePtr Rose::BinaryAnalysis::InstructionSemantics::ConcreteSemantics::MemoryState::peekMemory ( const BaseSemantics::SValuePtr address,
const BaseSemantics::SValuePtr dflt,
BaseSemantics::RiscOperators addrOps,
BaseSemantics::RiscOperators valOps 
)
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()

virtual void Rose::BinaryAnalysis::InstructionSemantics::ConcreteSemantics::MemoryState::writeMemory ( const BaseSemantics::SValuePtr addr,
const BaseSemantics::SValuePtr value,
BaseSemantics::RiscOperators addrOps,
BaseSemantics::RiscOperators valOps 
)
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()

virtual bool Rose::BinaryAnalysis::InstructionSemantics::ConcreteSemantics::MemoryState::merge ( const BaseSemantics::AddressSpacePtr other,
BaseSemantics::RiscOperators addrOps,
BaseSemantics::RiscOperators valOps 
)
overridevirtual

Merge address spaces for data flow analysis.

Merges the other address space into this address space, returning true if this space changed.

Implements Rose::BinaryAnalysis::InstructionSemantics::BaseSemantics::AddressSpace.

◆ memoryMap() [1/2]

const MemoryMap::Ptr Rose::BinaryAnalysis::InstructionSemantics::ConcreteSemantics::MemoryState::memoryMap ( ) const
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]

rose_addr_t Rose::BinaryAnalysis::InstructionSemantics::ConcreteSemantics::MemoryState::pageSize ( ) const
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: