angr.storage.memory_mixins¶

class angr.storage.memory_mixins.AbstractMemory¶: Bases: UnwrapperMixin, NameResolutionMixin, DataNormalizationMixin, SimplificationMixin, InspectMixin, ActionsMixinHigh, UnderconstrainedMixin, SizeConcretizationMixin, SizeNormalizationMixin, ActionsMixinLow, ConditionalMixin, RegionedAddressConcretizationMixin, RegionedMemoryMixin

class angr.storage.memory_mixins.AbstractMergerMixin

Bases: MemoryMixin

AbstractMergerMixin handles merging initialized values.

class angr.storage.memory_mixins.ActionsMixinHigh

Bases: MemoryMixin

load(addr, size=None, *, condition=None, fallback=None, disable_actions=False, action=None, **kwargs)

store(addr, data, size=None, *, disable_actions=False, action=None, condition=None, **kwargs)

class angr.storage.memory_mixins.ActionsMixinLow

Bases: MemoryMixin

load(addr, size=None, *, action=None, **kwargs)

store(addr, data, size=None, *, action=None, **kwargs)

Parameters:: action (SimActionData | None)

class angr.storage.memory_mixins.AddressConcretizationMixin

Bases: MemoryMixin

The address concretization mixin allows symbolic reads and writes to be handled sanely by dispatching them as a number of conditional concrete reads/writes. It provides a “concretization strategies” interface allowing the process of serializing symbolic addresses into concrete ones to be specified.

__init__(read_strategies=None, write_strategies=None, **kwargs)

concretize_write_addr(addr, strategies=None, condition=None)

Concretizes an address meant for writing.

Parameters:

addr – An expression for the address.
strategies – A list of concretization strategies (to override the default).
condition – Any extra constraints that should be observed when determining address satisfiability

Returns:

A list of concrete addresses.

concretize_read_addr(addr, strategies=None, condition=None)

Concretizes an address meant for reading.

Parameters:

addr – An expression for the address.
strategies – A list of concretization strategies (to override the default).

Returns:

A list of concrete addresses.

load(addr, size=None, *, condition=None, **kwargs)

store(addr, data, size=None, *, condition=None, **kwargs)

permissions(addr, permissions=None, **kwargs)

map_region(addr, length, permissions, **kwargs)

unmap_region(addr, length, **kwargs)

class angr.storage.memory_mixins.ClemoryBackerMixin

Bases: PagedMemoryMixin

__init__(cle_memory_backer=None, **kwargs)

Parameters:: cle_memory_backer (None | Loader | Clemory)

class angr.storage.memory_mixins.ConcreteBackerMixin: Bases: ClemoryBackerMixin

class angr.storage.memory_mixins.ConditionalMixin

Bases: MemoryMixin

load(addr, size=None, *, condition=None, fallback=None, **kwargs)

store(addr, data, size=None, *, condition=None, **kwargs)

class angr.storage.memory_mixins.ConvenientMappingsMixin

Bases: MemoryMixin

Implements mappings between names and hashes of symbolic variables and these variables themselves.

__init__(**kwargs)

store(addr, data, size=None, **kwargs)

get_symbolic_addrs()

addrs_for_name(n): Returns addresses that contain expressions that contain a variable named n.

addrs_for_hash(h): Returns addresses that contain expressions that contain a variable with the hash of h.

replace_all(old, new)

Replaces all instances of expression old with expression new.

Parameters:

old (BV) – A claripy expression. Must contain at least one named variable (to make it possible to use the name index for speedup).
new (BV) – The new variable to replace it with.

class angr.storage.memory_mixins.CooperationBase

Bases: Generic

Any given subclass of this class which is not a subclass of MemoryMixin should have the property that any subclass it which is a subclass of MemoryMixin should all work with the same datatypes

class angr.storage.memory_mixins.DataNormalizationMixin

Bases: MemoryMixin

Normalizes the data field for a store and the fallback field for a load to be BVs.

store(addr, data, size=None, **kwargs)

load(addr, size=None, *, fallback=None, **kwargs)

class angr.storage.memory_mixins.DefaultFillerMixin: Bases: MemoryMixin

class angr.storage.memory_mixins.DictBackerMixin

Bases: PagedMemoryMixin

__init__(dict_memory_backer=None, **kwargs)

class angr.storage.memory_mixins.DirtyAddrsMixin

Bases: MemoryMixin

store(addr, data, size=None, **kwargs)

class angr.storage.memory_mixins.ExplicitFillerMixin

Bases: MemoryMixin

__init__(uninitialized_read_handler=None, **kwargs)

class angr.storage.memory_mixins.FastMemory¶: Bases: NameResolutionMixin, SimpleInterfaceMixin, SimplificationMixin, InspectMixin, ConditionalMixin, ExplicitFillerMixin, DefaultFillerMixin, SlottedMemoryMixin

class angr.storage.memory_mixins.HexDumperMixin

Bases: MemoryMixin

hex_dump(start, size, word_size=4, words_per_row=4, endianness='Iend_BE', symbolic_char='?', unprintable_char='.', solve=False, extra_constraints=None, inspect=False, disable_actions=True)

Returns a hex dump as a string. The solver, if enabled, is called once for every byte potentially making this function very slow. It is meant to be used mainly as a “visualization” for debugging.

Warning: May read and display more bytes than size due to rounding. Particularly, if size is less than, or not a multiple of word_size*words_per_line.

Parameters:

start – starting address from which to print
size – number of bytes to display
word_size – number of bytes to group together as one space-delimited unit
words_per_row – number of words to display per row of output
endianness – endianness to use when displaying each word (ASCII representation is unchanged)
symbolic_char – the character to display when a byte is symbolic and has multiple solutions
unprintable_char – the character to display when a byte is not printable
solve – whether or not to attempt to solve (warning: can be very slow)
extra_constraints – extra constraints to pass to the solver is solve is True
inspect – whether or not to trigger SimInspect breakpoints for the memory load
disable_actions – whether or not to disable SimActions for the memory load

Returns:

hex dump as a string

class angr.storage.memory_mixins.HistoryTrackingMixin

Bases: RefcountMixin, MemoryMixin

Tracks the history of memory writes.

__init__(*args, **kwargs)

store(addr, data, size=None, **kwargs)

parents()

changed_bytes(other, **kwargs)

Return type:: set[int] | None

all_bytes_changed_in_history()

Return type:: SegmentList

class angr.storage.memory_mixins.ISPOMixin

Bases: MemoryMixin

An implementation of the International Stateless Persons Organisation, a mixin which should be applied as a bottom layer for memories which have no state and must redirect certain operations to a parent memory. Main usecase is for memory region classes which are stored within other memories, such as pages.

class angr.storage.memory_mixins.InspectMixin

Bases: MemoryMixin

This mixin adds support for the inspect plugin to the memory model.

Inspect breakpoints are called for the following events:

mem_read (before and after)

mem_write (before and after)

reg_read (before and after)

reg_write (before and after)

address_concretization_add_constraints (before)

store(addr, data, size=None, *, condition=None, endness=None, inspect=True, **kwargs)

load(addr, size=None, *, condition=None, endness=None, inspect=True, **kwargs)

class angr.storage.memory_mixins.JavaVmMemory¶: Bases: JavaVmMemoryMixin

class angr.storage.memory_mixins.JavaVmMemoryMixin

Bases: MemoryMixin

A memory mixin for JavaVM memory.

__init__(memory_id='mem', stack=None, heap=None, vm_static_table=None, load_strategies=None, store_strategies=None, max_array_size=1000, **kwargs)

static get_new_uuid(): Generate a unique id within the scope of the JavaVM memory. This, for example, is used for distinguishing memory objects of the same type (e.g. multiple instances of the same class).

store(addr, data, frame=0)

load(addr, frame=0, none_if_missing=False)

push_stack_frame()

pop_stack_frame()

property stack

store_array_element(array, idx, value)

store_array_elements(array, start_idx, data)

Stores either a single element or a range of elements in the array.

Parameters:

array – Reference to the array.
start_idx – Starting index for the store.
data – Either a single value or a list of values.

load_array_element(array, idx)

load_array_elements(array, start_idx, no_of_elements)

Loads either a single element or a range of elements from the array.

Parameters:

array – Reference to the array.
start_idx – Starting index for the load.
no_of_elements – Number of elements to load.

concretize_store_idx(idx, strategies=None)

Concretizes a store index.

Parameters:

idx – An expression for the index.
strategies – A list of concretization strategies (to override the default).
min_idx – Minimum value for a concretized index (inclusive).
max_idx – Maximum value for a concretized index (exclusive).

Returns:

A list of concrete indexes.

concretize_load_idx(idx, strategies=None)

Concretizes a load index.

Parameters:

idx – An expression for the index.
strategies – A list of concretization strategies (to override the default).
min_idx – Minimum value for a concretized index (inclusive).
max_idx – Maximum value for a concretized index (exclusive).

Returns:

A list of concrete indexes.

class angr.storage.memory_mixins.KeyValueMemory¶: Bases: KeyValueMemoryMixin

class angr.storage.memory_mixins.KeyValueMemoryMixin

Bases: MemoryMixin

KeyValueMemoryMixin is a mixin that provides a simple key-value store for memory.

__init__(*args, **kwargs)

load(addr, size=None, none_if_missing=False, **kwargs)

store(addr, data, type_=None, **kwargs)

class angr.storage.memory_mixins.LabelMergerMixin

Bases: MemoryMixin

A memory mixin for merging labels. Labels come from SimLabeledMemoryObject.

__init__(*args, **kwargs)

class angr.storage.memory_mixins.LabeledMemory¶

Bases: SizeNormalizationMixin, ListPagesWithLabelsMixin, DefaultFillerMixin, TopMergerMixin, LabelMergerMixin, PagedMemoryMixin

LabeledMemory is used in static analysis. It allows storing values with labels, such as Definition.

class angr.storage.memory_mixins.ListPage

Bases: MemoryObjectMixin, PageBase

This class implements a page memory mixin with lists as the main content store.

__init__(memory=None, content=None, sinkhole=None, mo_cmp=None, **kwargs)

load(addr, size=None, endness=None, page_addr=None, memory=None, cooperate=False, **kwargs)

store(addr, data, size=None, endness=None, memory=None, cooperate=False, **kwargs)

changed_bytes(other, page_addr=None)

Parameters:

other (ListPage)
page_addr (int | None)

class angr.storage.memory_mixins.ListPagesMixin

Bases: PagedMemoryMixin

PAGE_TYPE: alias of ListPage

class angr.storage.memory_mixins.ListPagesWithLabelsMixin: Bases: LabeledPagesMixin, ListPagesMixin

class angr.storage.memory_mixins.MVListPage

Bases: MemoryObjectSetMixin, PageBase

MVListPage allows storing multiple values at the same location.

Each store() may take a value or multiple values. Each load() returns an iterator of all values stored at that location.

__init__(memory=None, content=None, sinkhole=None, mo_cmp=None, **kwargs)

load(addr, size=None, endness=None, page_addr=None, memory=None, cooperate=False, **kwargs)

Return type:: list[tuple[int, SimMemoryObject | SimLabeledMemoryObject]]

store(addr, data, size=None, endness=None, memory=None, cooperate=False, **kwargs)

compare(other, page_addr=None, memory=None, changed_offsets=None)

Return type:

bool

Parameters:

other (MVListPage)
page_addr (int | None)

changed_bytes(other, page_addr=None)

Parameters:

other (MVListPage)
page_addr (int | None)

content_gen(index)

class angr.storage.memory_mixins.MVListPagesMixin

Bases: PagedMemoryMixin

PAGE_TYPE: alias of MVListPage

__init__(*args, skip_missing_values_during_merging=False, **kwargs)

class angr.storage.memory_mixins.MVListPagesWithLabelsMixin: Bases: LabeledPagesMixin, MVListPagesMixin

class angr.storage.memory_mixins.MemoryObjectMixin

Bases: CooperationBase[SimMemoryObject]

Uses SimMemoryObjects in region storage. With this, load will return a list of tuple (address, MO) and store will take a MO.

class angr.storage.memory_mixins.MemoryRegionMetaMixin

Bases: MemoryMixin

__init__(related_function_addr=None, **kwargs)

property is_stack

property related_function_addr

get_abstract_locations(addr, size)

Get a list of abstract locations that is within the range of [addr, addr + size]

This implementation is pretty slow. But since this method won’t be called frequently, we can live with the bad implementation for now.

Parameters:

addr – Starting address of the memory region.
size – Size of the memory region, in bytes.

Returns:

A list of covered AbstractLocation objects, or an empty list if there is none.

store(addr, data, size=None, *, bbl_addr=None, stmt_id=None, ins_addr=None, endness=None, **kwargs)

load(addr, size=None, *, bbl_addr=None, stmt_idx=None, ins_addr=None, **kwargs)

dbg_print(indent=0): Print out debugging information

class angr.storage.memory_mixins.MultiValueMergerMixin

Bases: MemoryMixin

__init__(*args, element_limit=5, annotation_limit=256, top_func=None, is_top_func=None, phi_maker=None, merge_into_top=True, **kwargs)

class angr.storage.memory_mixins.MultiValuedMemory¶: Bases: SizeNormalizationMixin, MVListPagesMixin, DefaultFillerMixin, MultiValueMergerMixin, PagedMemoryMixin, PagedMemoryMultiValueMixin

class angr.storage.memory_mixins.NameResolutionMixin

Bases: MemoryMixin

This mixin allows you to provide register names as load addresses, and will automatically translate this to an offset and size.

store(addr, data, size=None, **kwargs)

load(addr, size=None, **kwargs)

class angr.storage.memory_mixins.PageBase

Bases: HistoryTrackingMixin, RefcountMixin, CooperationBase, ISPOMixin, PermissionsMixin, MemoryMixin

This is a fairly succinct definition of the contract between PagedMemoryMixin and its constituent pages:

Pages must implement the MemoryMixin model for loads, stores, copying, merging, etc
However, loading/storing may not necessarily use the same data domain as PagedMemoryMixin. In order to do more efficient loads/stores across pages, we use the CooperationBase interface which allows the page class to determine how to generate and unwrap the objects which are actually stored.
To support COW, we use the RefcountMixin and the ISPOMixin (which adds the contract element that memory=self be passed to every method call)
Pages have permissions associated with them, stored in the PermissionsMixin.

Read the docstrings for each of the constituent classes to understand the nuances of their functionalities

class angr.storage.memory_mixins.PagedMemoryMixin

Bases: MemoryMixin[int | BV | SimActionObject, BV, int | BV | SimActionObject], Generic

A bottom-level storage mechanism. Dispatches reads to individual pages, the type of which is the PAGE_TYPE class variable.

SUPPORTS_CONCRETE_LOAD: bool = True¶

PAGE_TYPE: type[PageType]

__init__(page_size=4096, default_permissions=3, permissions_map=None, page_kwargs=None, **kwargs)

load(addr, size=None, *, endness=None, **kwargs)

Parameters:

addr (int)
size (int | None)

store(addr, data, size=None, *, endness=None, **kwargs)

Parameters:

addr (int)
size (int | None)

compare(other)

Return type:: bool
Parameters:: other (PagedMemoryMixin)

permissions(addr, permissions=None, **kwargs)

map_region(addr, length, permissions, *, init_zero=False, **kwargs)

unmap_region(addr, length, **kwargs)

changed_bytes(other)

Return type:: set[int]

changed_pages(other)

Return type:: dict[int, set[int] | None]

flush_pages(white_list): Flush all pages not included in the white_list by removing their pages. Note, this will not wipe them from memory if they were backed by a memory_backer, it will simply reset them to their initial state. Returns the list of pages that were cleared consisting of (addr, length) tuples. :type white_list: :param white_list: white list of regions in the form of (start, end) to exclude from the flush :return: a list of memory page ranges that were flushed :rtype: list

class angr.storage.memory_mixins.PagedMemoryMultiValueMixin

Bases: MemoryMixin

Implement optimizations and fast accessors for the MultiValues-variant of Paged Memory.

load_annotations(addr, size, **kwargs)

Parameters:

addr (int)
size (int)

class angr.storage.memory_mixins.PermissionsMixin

Bases: MemoryMixin

This mixin adds a permissions_bits field and properties for extracting the read/write/exec permissions. It does NOT add permissions checking.

__init__(permissions=None, **kwargs)

Parameters:: permissions (int | BV | None)

property perm_read

property perm_write

property perm_exec

class angr.storage.memory_mixins.PrivilegedPagingMixin

Bases: PagedMemoryMixin

A mixin for paged memory models which will raise SimSegfaultExceptions if STRICT_PAGE_ACCESS is enabled and a segfault condition is detected.

Segfault conditions include: - getting a page for reading which is non-readable - getting a page for writing which is non-writable - creating a page

The latter condition means that this should be inserted under any mixins which provide other implementations of _initialize_page.

class angr.storage.memory_mixins.RefcountMixin

Bases: MemoryMixin

This mixin adds a locked reference counter and methods to manipulate it, to facilitate copy-on-write optimizations.

__init__(**kwargs)

acquire_unique(): Call this function to return a version of this page which can be used for writing, which may or may not be the same object as before. If you use this you must immediately replace the shared reference you previously had with the new unique copy.

acquire_shared()

Call this function to indicate that this page has had a reference added to it and must be copied before it can be acquired uniquely again. Creating the object implicitly starts it with one shared reference.

Return type:: None

release_shared()

Call this function to indicate that this page has had a shared reference to it released

Return type:: None

class angr.storage.memory_mixins.RegionCategoryMixin

Bases: MemoryMixin

property category

reg, mem, or file.

Type:: Return the category of this SimMemory instance. It can be one of the three following categories

class angr.storage.memory_mixins.RegionedAddressConcretizationMixin

Bases: MemoryMixin

__init__(read_strategies=None, write_strategies=None, **kwargs)

class angr.storage.memory_mixins.RegionedMemory¶: Bases: RegionCategoryMixin, MemoryRegionMetaMixin, StaticFindMixin, UnwrapperMixin, NameResolutionMixin, DataNormalizationMixin, SimplificationMixin, SizeConcretizationMixin, SizeNormalizationMixin, AddressConcretizationMixin, ConvenientMappingsMixin, DirtyAddrsMixin, ClemoryBackerMixin, DictBackerMixin, UltraPagesMixin, DefaultFillerMixin, AbstractMergerMixin, PagedMemoryMixin

class angr.storage.memory_mixins.RegionedMemoryMixin

Bases: MemoryMixin

Regioned memory. This mixin manages multiple memory regions. Each address is represented as a tuple of (region ID, offset into the region), which is called a regioned address.

Converting absolute addresses into regioned addresses: We map an absolute address to a region by looking up which region this address belongs to in the region map. Currently this is only enabled for stack. Heap support has not landed yet.

When start analyzing a function, the user should call set_stack_address_mapping() to create a new region mapping. Likewise, when exiting from a function, the user should cancel the previous mapping by calling unset_stack_address_mapping().

__init__(write_targets_limit=2048, read_targets_limit=4096, stack_region_map=None, generic_region_map=None, stack_size=65536, cle_memory_backer=None, dict_memory_backer=None, regioned_memory_cls=None, **kwargs)

load(addr, size=None, *, endness=None, condition=None, **kwargs)

Parameters:

size (BV | int | None)
condition (Bool | None)

store(addr, data, size=None, *, endness=None, **kwargs)

Parameters:: size (int | None)

find(addr, data, max_search, **kwargs)

Parameters:: addr (int | Bits)

replace_all(old, new)

Parameters:

old (BV)
new (BV)

set_stack_address_mapping(absolute_address, region_id, related_function_address=None)

Create a new mapping between an absolute address (which is the base address of a specific stack frame) and a region ID.

Parameters:

absolute_address (int) – The absolute memory address.
region_id (str) – The region ID.
related_function_address (int | None) – Related function address.

unset_stack_address_mapping(absolute_address)

Remove a stack mapping.

Parameters:: absolute_address (int) – An absolute memory address that is the base address of the stack frame to destroy.

stack_id(function_address)

Return a memory region ID for a function. If the default region ID exists in the region mapping, an integer will appended to the region name. In this way we can handle recursive function calls, or a function that appears more than once in the call frame.

This also means that stack_id() should only be called when creating a new stack frame for a function. You are not supposed to call this function every time you want to map a function address to a stack ID.

Parameters:: function_address (int) – Address of the function.
Return type:: str
Returns:: ID of the new memory region.

set_stack_size(size)

Parameters:: size (int)

class angr.storage.memory_mixins.SimpleInterfaceMixin

Bases: MemoryMixin

load(addr, size=None, *, endness=None, condition=None, fallback=None, **kwargs)

store(addr, data, size=None, *, endness=None, condition=None, **kwargs)

class angr.storage.memory_mixins.SimplificationMixin

Bases: MemoryMixin

store(addr, data, size=None, **kwargs)

class angr.storage.memory_mixins.SizeConcretizationMixin

Bases: MemoryMixin

This mixin allows memory to process symbolic sizes. It will not touch any sizes which are not ASTs with non-BVV ops. Assumes that the data is a BV.

symbolic load sizes will be concretized as their maximum and a warning will be logged
symbolic store sizes will be dispatched as several conditional stores with concrete sizes

__init__(concretize_symbolic_write_size=False, max_concretize_count=256, max_symbolic_size=4194304, raise_memory_limit_error=False, size_limit=257, **kwargs)

Parameters:

concretize_symbolic_write_size (bool)
max_concretize_count (int | None)
max_symbolic_size (int)
raise_memory_limit_error (bool)
size_limit (int)

load(addr, size=None, **kwargs)

store(addr, data, size=None, *, condition=None, **kwargs)

class angr.storage.memory_mixins.SizeNormalizationMixin

Bases: MemoryMixin

Provides basic services related to normalizing sizes. After this mixin, sizes will always be a plain int. Assumes that the data is a BV.

load will throw a TypeError if no size is provided
store will default to len(data)//byte_width if no size is provided

load(addr, size=None, **kwargs)

store(addr, data, size=None, **kwargs)

class angr.storage.memory_mixins.SlottedMemoryMixin

Bases: MemoryMixin

__init__(width=None, **kwargs)

load(addr, size=None, *, endness=None, **kwargs)

store(addr, data, size=None, *, endness=None, **kwargs)

changed_bytes(other)

class angr.storage.memory_mixins.SmartFindMixin

Bases: MemoryMixin

Memory mixin providing basic searching over concrete and symbolic data.

find(addr, data, max_search, *, default=None, endness=None, chunk_size=None, max_symbolic_bytes=None, condition=None, char_size=1, **kwargs)

class angr.storage.memory_mixins.SpecialFillerMixin

Bases: MemoryMixin

__init__(special_memory_filler=None, **kwargs)

class angr.storage.memory_mixins.StackAllocationMixin

Bases: PagedMemoryMixin

This mixin adds automatic allocation for a stack region based on the stack_end and stack_size parameters.

__init__(stack_end=None, stack_size=None, stack_perms=None, **kwargs)

allocate_stack_pages(addr, size, **kwargs)

Pre-allocates pages for the stack without triggering any logic related to reading from them.

Parameters:

addr (int) – The highest address that should be mapped
size (int) – The number of bytes to be allocated. byte 1 is the one at addr, byte 2 is the one before that, and so on.

Returns:

A list of the new page objects

class angr.storage.memory_mixins.StaticFindMixin

Bases: SmartFindMixin

Implements data finding for abstract memory.

find(addr, data, max_search, *, default=None, endness=None, chunk_size=None, max_symbolic_bytes=None, condition=None, char_size=1, **kwargs)

class angr.storage.memory_mixins.SymbolicMergerMixin: Bases: MemoryMixin

class angr.storage.memory_mixins.TopMergerMixin

Bases: MemoryMixin

A memory mixin for merging values in memory to TOP.

__init__(*args, top_func=None, **kwargs)

class angr.storage.memory_mixins.UltraPage

Bases: MemoryObjectMixin, PageBase

Default page implementation

SUPPORTS_CONCRETE_LOAD: bool = True¶

__init__(memory=None, init_zero=False, **kwargs)

classmethod new_from_shared(data, memory=None, **kwargs)

load(addr, size=None, page_addr=None, endness=None, memory=None, cooperate=False, **kwargs)

store(addr, data, size=None, endness=None, memory=None, page_addr=None, cooperate=False, **kwargs)

Parameters:

data (int | SimMemoryObject)
size (int | None)

changed_bytes(other, page_addr=None)

Return type:: set[int]

replace_all_with_offsets(offsets, old, new, memory=None)

Parameters:

offsets (Iterable[int])
old (BV)
new (BV)

class angr.storage.memory_mixins.UltraPagesMixin

Bases: PagedMemoryMixin

PAGE_TYPE: alias of UltraPage

class angr.storage.memory_mixins.UnderconstrainedMixin

Bases: MemoryMixin

__init__(*args, **kwargs)

load(addr, size=None, **kwargs)

store(addr, data, size=None, **kwargs)

class angr.storage.memory_mixins.UnwrapperMixin

Bases: MemoryMixin

This mixin processes SimActionObjects by passing on their .ast field.

store(addr, data, size=None, *, condition=None, **kwargs)

load(addr, size=None, *, condition=None, fallback=None, **kwargs)

find(addr, data, max_search, *, default=None, **kwargs)

Submodules

`actions_mixin`
`address_concretization_mixin`
`bvv_conversion_mixin`
`conditional_store_mixin`
`convenient_mappings_mixin`
`default_filler_mixin`
`dirty_addrs_mixin`
`hex_dumper_mixin`
`inspect_mixin`
`javavm_memory_mixin`
`keyvalue_memory_mixin`
`label_merger_mixin`
`memory_mixin`
`multi_value_merger_mixin`
`name_resolution_mixin`
`paged_memory`
`regioned_memory`
`simple_interface_mixin`
`simplification_mixin`
`size_resolution_mixin`
`slotted_memory`
`smart_find_mixin`
`symbolic_merger_mixin`
`top_merger_mixin`
`underconstrained_mixin`
`unwrapper_mixin`