1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
|
from __future__ import print_function
#
# Expression regression tests #
#
from pdb import pm
from miasm.expression.expression import *
from miasm.expression.expression_helper import *
# Expression comparison
assert(ExprInt(-1, 64) != ExprInt(-2, 64))
assert(ExprInt(1, 64) != ExprInt(1, 32))
# Expression size
big_cst = ExprInt(1, size=0x1000)
assert big_cst.size == 0x1000
# Possible values
#- Common constants
A = ExprId("A", 32)
B = ExprId("B", 32)
cond1 = ExprId("cond1", 1)
cond2 = ExprId("cond2", 16)
cst1 = ExprInt(1, 32)
cst2 = ExprInt(2, 32)
cst3 = ExprInt(3, 32)
cst4 = ExprInt(4, 32)
#- Launch tests
for expr in [
cst1,
A,
ExprMem(cst1, 32),
ExprCond(cond1, cst1, cst2),
ExprMem(ExprCond(cond1, cst1, cst2), 16),
ExprCond(cond1,
ExprCond(cond2, cst3, cst4),
cst2),
A + cst1,
A + ExprCond(cond1, cst1, cst2),
ExprCond(cond1, cst1, cst2) + ExprCond(cond2, cst3, cst4),
ExprCompose(A, cst1),
ExprCompose(ExprCond(cond1, cst1, cst2), A),
ExprCompose(ExprCond(cond1, cst1, cst2),
ExprCond(cond2, cst3, cst4)),
ExprCond(ExprCond(cond1, cst1, cst2), cst3, cst4),
]:
print("*" * 80)
print(expr)
sol = possible_values(expr)
print(sol)
print("Resulting constraints:")
for consval in sol:
print("For value %s" % consval.value)
for constraint in consval.constraints:
print("\t%s" % constraint.to_constraint())
# Repr
for expr in [
cst1,
A,
ExprMem(cst1, 32),
ExprCond(cond1, cst1, cst2),
A + cst1,
ExprCompose(A, cst1),
A.msb(),
ExprAssign(A, cst1),
]:
print(repr(expr))
assert expr == eval(repr(expr))
aff = ExprAssign(A[0:32], cst1)
assert aff.dst == A and aff.src == cst1
mem = ExprMem(A, 32)
assert mem.get_r() == set([mem])
assert mem.get_r(mem_read=True) == set([mem, A])
C = A+B
D = C + A
E = A / B
F = A // B
assert E is F
assert A in A
assert A in C
assert B in C
assert C in C
assert E in E
assert A in D
assert B in D
assert C in D
assert D in D
assert A in E
assert B in E
assert C not in A
assert C not in B
assert D not in A
assert D not in B
assert D not in C
assert cst1.get_r(cst_read=True) == set([cst1])
mem1 = ExprMem(A, 32)
mem2 = ExprMem(mem1 + B, 32)
assert mem2.get_r() == set([mem2])
assign1 = ExprAssign(A, cst1)
assert assign1.get_r() == set([])
assign2 = ExprAssign(mem1, D)
assert assign2.get_r() == set([A, B])
assert assign2.get_r(mem_read=True) == set([A, B])
assert assign2.get_w() == set([mem1])
assign3 = ExprAssign(mem1, mem2)
assert assign3.get_r() == set([mem2])
assert assign3.get_r(mem_read=True) == set([mem1, mem2, A, B])
assert assign3.get_w() == set([mem1])
|