Miasm2
 All Classes Namespaces Files Functions Variables Typedefs Properties Macros
Public Member Functions | Public Attributes | List of all members
miasm2.ir.translators.z3_ir.Z3Mem Class Reference
+ Inheritance diagram for miasm2.ir.translators.z3_ir.Z3Mem:
+ Collaboration diagram for miasm2.ir.translators.z3_ir.Z3Mem:

Public Member Functions

def __init__
 
def get_mem_array
 
def __getitem__
 
def get
 
def is_little_endian
 
def is_big_endian
 

Public Attributes

 endianness
 
 mems
 
 name
 

Detailed Description

Memory abstration for TranslatorZ3. Memory elements are only accessed,
never written. To give a concrete value for a given memory cell in a solver,
add "mem32.get(address, size) == <value>" constraints to your equation.
The endianness of memory accesses is handled accordingly to the "endianness"
attribute.

Note: Will have one memory space for each addressing size used.
For example, if memory is accessed via 32 bits values and 16 bits values,
these access will not occur in the same address space.

Definition at line 15 of file z3_ir.py.

Constructor & Destructor Documentation

def miasm2.ir.translators.z3_ir.Z3Mem.__init__ (   self,
  endianness = "<",
  name = "mem" 
)
Initializes a Z3Mem object with a given @name and @endianness.
@endianness: Endianness of memory representation. '<' for little endian,
    '>' for big endian.
@name: name of memory Arrays generated. They will be named
    name+str(address size) (for example mem32, mem16...).

Definition at line 27 of file z3_ir.py.

27 
28  def __init__(self, endianness="<", name="mem"):
29  """Initializes a Z3Mem object with a given @name and @endianness.
30  @endianness: Endianness of memory representation. '<' for little endian,
31  '>' for big endian.
32  @name: name of memory Arrays generated. They will be named
33  name+str(address size) (for example mem32, mem16...).
34  """
35  if endianness not in ['<', '>']:
36  raise ValueError("Endianness should be '>' (big) or '<' (little)")
37  self.endianness = endianness
38  self.mems = {} # Address size -> memory z3.Array
39  self.name = name

Member Function Documentation

def miasm2.ir.translators.z3_ir.Z3Mem.__getitem__ (   self,
  addr 
)
One byte memory access. Different address sizes with the same value
will result in different memory accesses.
@addr: a z3 BitVec, the address to read.
Return a z3 BitVec of size 8 bits representing a memory access.

Definition at line 56 of file z3_ir.py.

56 
57  def __getitem__(self, addr):
58  """One byte memory access. Different address sizes with the same value
59  will result in different memory accesses.
60  @addr: a z3 BitVec, the address to read.
61  Return a z3 BitVec of size 8 bits representing a memory access.
62  """
63  size = addr.size()
64  mem = self.get_mem_array(size)
65  return mem[addr]

+ Here is the call graph for this function:

def miasm2.ir.translators.z3_ir.Z3Mem.get (   self,
  addr,
  size 
)
Memory access at address @addr of size @size.
@addr: a z3 BitVec, the address to read.
@size: int, size of the read in bits.
Return a z3 BitVec of size @size representing a memory access.

Definition at line 66 of file z3_ir.py.

66 
67  def get(self, addr, size):
68  """ Memory access at address @addr of size @size.
69  @addr: a z3 BitVec, the address to read.
70  @size: int, size of the read in bits.
71  Return a z3 BitVec of size @size representing a memory access.
72  """
73  original_size = size
74  if original_size % 8 != 0:
75  # Size not aligned on 8bits -> read more than size and extract after
76  size = ((original_size / 8) + 1) * 8
77  res = self[addr]
78  if self.is_little_endian():
79  for i in xrange(1, size/8):
80  res = z3.Concat(self[addr+i], res)
81  else:
82  for i in xrange(1, size/8):
83  res = z3.Concat(res, self[addr+i])
84  if size == original_size:
85  return res
86  else:
87  # Size not aligned, extract right sized result
88  return z3.Extract(original_size-1, 0, res)

+ Here is the call graph for this function:

def miasm2.ir.translators.z3_ir.Z3Mem.get_mem_array (   self,
  size 
)
Returns a z3 Array used internally to represent memory for addresses
of size @size.
@size: integer, size in bit of addresses in the memory to get.
Return a z3 Array: BitVecSort(size) -> BitVecSort(8).

Definition at line 40 of file z3_ir.py.

40 
41  def get_mem_array(self, size):
42  """Returns a z3 Array used internally to represent memory for addresses
43  of size @size.
44  @size: integer, size in bit of addresses in the memory to get.
45  Return a z3 Array: BitVecSort(size) -> BitVecSort(8).
46  """
47  try:
48  mem = self.mems[size]
49  except KeyError:
50  # Lazy instanciation
51  self.mems[size] = z3.Array(self.name + str(size),
52  z3.BitVecSort(size),
53  z3.BitVecSort(8))
54  mem = self.mems[size]
55  return mem

+ Here is the caller graph for this function:

def miasm2.ir.translators.z3_ir.Z3Mem.is_big_endian (   self)
True if this memory is big endian.

Definition at line 93 of file z3_ir.py.

93 
94  def is_big_endian(self):
95  """True if this memory is big endian."""
96  return not self.is_little_endian()
97 

+ Here is the call graph for this function:

def miasm2.ir.translators.z3_ir.Z3Mem.is_little_endian (   self)
True if this memory is little endian.

Definition at line 89 of file z3_ir.py.

89 
90  def is_little_endian(self):
91  """True if this memory is little endian."""
92  return self.endianness == "<"

+ Here is the caller graph for this function:

Member Data Documentation

miasm2.ir.translators.z3_ir.Z3Mem.endianness

Definition at line 36 of file z3_ir.py.

miasm2.ir.translators.z3_ir.Z3Mem.mems

Definition at line 37 of file z3_ir.py.

miasm2.ir.translators.z3_ir.Z3Mem.name

Definition at line 38 of file z3_ir.py.


The documentation for this class was generated from the following file: