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
125
126
127
128
|
from rpython.translator.interactive import Translation
from rpython.translator.c.test.test_genc import compile
from rpython.conftest import option
from rpython.rtyper.lltypesystem import llmemory, lltype
from rpython.rlib.objectmodel import ComputedIntSymbolic
def test_offsetof():
STRUCT = lltype.GcStruct("s", ("x", lltype.Signed), ("y", lltype.Signed))
offsetx = llmemory.offsetof(STRUCT, 'x')
offsety = llmemory.offsetof(STRUCT, 'y')
def f():
s = lltype.malloc(STRUCT)
s.x = 1
adr = llmemory.cast_ptr_to_adr(s)
result = (adr + offsetx).signed[0]
(adr + offsety).signed[0] = 2
return result * 10 + s.y
fn = compile(f, [])
res = fn()
assert res == 12
def test_offsetof_nogc():
ARR = lltype.Array(lltype.Signed)
offsetx = llmemory.arraylengthoffset(ARR)
offsety = llmemory.itemoffsetof(ARR, 0)
ARR2 = lltype.GcArray(lltype.Signed)
offsetx2 = llmemory.arraylengthoffset(ARR2)
offsety2 = llmemory.itemoffsetof(ARR2, 0)
def f():
a = lltype.malloc(ARR, 5, flavor='raw')
a2 = lltype.malloc(ARR2, 6, flavor='raw')
a2[0] = 1
a[0] = 3
adr = llmemory.cast_ptr_to_adr(a)
adr2 = llmemory.cast_ptr_to_adr(a2)
return ((adr + offsetx).signed[0] * 1000 +
(adr + offsety).signed[0] * 100 +
(adr2 + offsetx2).signed[0] * 10 + (adr2 + offsety2).signed[0])
fn = compile(f, [])
res = fn()
assert res == 5361
def test_sizeof_array_with_no_length():
A = lltype.Array(lltype.Signed, hints={'nolength': True})
arraysize = llmemory.sizeof(A, 10)
signedsize = llmemory.sizeof(lltype.Signed)
def f():
return arraysize-signedsize*10
fn = compile(f, [])
res = fn()
assert res == 0
def test_itemoffsetof():
ARRAY = lltype.GcArray(lltype.Signed)
itemoffsets = [llmemory.itemoffsetof(ARRAY, i) for i in range(5)]
def f():
a = lltype.malloc(ARRAY, 5)
adr = llmemory.cast_ptr_to_adr(a)
result = 0
for i in range(5):
a[i] = i + 1
for i in range(5):
result = result * 10 + (adr + itemoffsets[i]).signed[0]
for i in range(5):
(adr + itemoffsets[i]).signed[0] = i
for i in range(5):
result = 10 * result + a[i]
return result
fn = compile(f, [])
res = fn()
assert res == 1234501234
def test_itemoffsetof_fixedsizearray():
ARRAY = lltype.FixedSizeArray(lltype.Signed, 5)
itemoffsets = [llmemory.itemoffsetof(ARRAY, i) for i in range(5)]
a = lltype.malloc(ARRAY, immortal=True)
def f():
adr = llmemory.cast_ptr_to_adr(a)
result = 0
for i in range(5):
a[i] = i + 1
for i in range(5):
result = result * 10 + (adr + itemoffsets[i]).signed[0]
for i in range(5):
(adr + itemoffsets[i]).signed[0] = i
for i in range(5):
result = 10 * result + a[i]
return result
fn = compile(f, [])
res = fn()
assert res == 1234501234
def test_sizeof_constsize_struct():
# _not_ a GcStruct, since we want to raw_malloc it
STRUCT = lltype.Struct("s", ("x", lltype.Signed), ("y", lltype.Signed))
STRUCTPTR = lltype.Ptr(STRUCT)
sizeofs = llmemory.sizeof(STRUCT)
offsety = llmemory.offsetof(STRUCT, 'y')
def f():
adr = llmemory.raw_malloc(sizeofs)
s = llmemory.cast_adr_to_ptr(adr, STRUCTPTR)
s.y = 5 # does not crash
result = (adr + offsety).signed[0] * 10 + int(offsety < sizeofs)
llmemory.raw_free(adr)
return result
fn = compile(f, [])
res = fn()
assert res == 51
def test_computed_int_symbolic():
too_early = True
def compute_fn():
assert not too_early
return 7
k = ComputedIntSymbolic(compute_fn)
def f(ignored):
return k*6
t = Translation(f)
t.rtype()
if option.view:
t.view()
too_early = False
fn = compile(f, [int])
res = fn(0)
assert res == 42
|
