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
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
|
from rpython.jit.metainterp.history import INT, FLOAT
from rpython.jit.backend.zarch.arch import WORD, DOUBLE_WORD
FWORD = 8
class AssemblerLocation(object):
_immutable_ = True
type = INT
def is_imm(self):
return False
def is_stack(self):
return False
def is_raw_sp(self):
return False
def is_reg(self):
return self.is_core_reg()
def is_core_reg(self):
return False
def is_fp_reg(self):
return False
def is_vector_reg(self):
return False
def is_imm_float(self):
return False
def is_float(self):
return False
def is_in_pool(self):
return False
def as_key(self):
raise NotImplementedError
def get_position(self):
raise NotImplementedError # only for stack
class RegisterLocation(AssemblerLocation):
_immutable_ = True
width = WORD
def __init__(self, value):
self.value = value
def __repr__(self):
return 'r%d' % self.value
def is_core_reg(self):
return True
def is_even(self):
return self.value % 2 == 0
def is_odd(self):
return self.value % 2 == 1
def as_key(self): # 0 <= as_key <= 15
return self.value
class ConstFloatLoc(AssemblerLocation):
"""This class represents an imm float value which is stored in memory at
the address stored in the field value"""
_immutable_ = True
width = FWORD
type = FLOAT
def __init__(self, value):
self.value = value
def getint(self):
return self.value
def __repr__(self):
return "imm_float(stored at %d)" % (self.value)
def is_imm_float(self):
return True
def is_float(self):
return True
def as_key(self):
return self.value
class FloatRegisterLocation(RegisterLocation):
_immutable_ = True
type = FLOAT
width = DOUBLE_WORD
def __repr__(self):
return 'f%d' % self.value
def is_core_reg(self):
return False
def is_fp_reg(self):
return True
def as_key(self): # 16 <= as_key <= 32
return self.value + 16
def is_float(self):
return True
class VectorRegisterLocation(RegisterLocation):
_immutable_ = True
type = FLOAT
width = DOUBLE_WORD*2
def __repr__(self):
return 'v%d' % self.value
def is_core_reg(self):
return False
def as_key(self): # 16 <= as_key <= 32
return self.value + 32
def is_vector_reg(self):
return True
class ImmLocation(AssemblerLocation):
_immutable_ = True
width = WORD
def __init__(self, value):
self.value = value
def getint(self):
return self.value
def __repr__(self):
return "imm(%d)" % (self.value)
def is_imm(self):
return True
class StackLocation(AssemblerLocation):
_immutable_ = True
def __init__(self, position, fp_offset, type=INT):
if type == FLOAT:
self.width = DOUBLE_WORD
else:
self.width = WORD
self.position = position
self.value = fp_offset
self.type = type
def __repr__(self):
return 'FP(%s)+%d' % (self.type, self.position,)
def location_code(self):
return 'b'
def get_position(self):
return self.position
def assembler(self):
return repr(self)
def is_stack(self):
return True
def as_key(self): # an aligned word + 10000
return -self.position + 10000
def is_float(self):
return self.type == FLOAT
class AddressLocation(AssemblerLocation):
_immutable_ = True
def __init__(self, basereg, indexreg, displace, length):
self.displace = displace
# designates the absense of an index/base register!
self.base = 0
self.index = 0
self.length = 0
from rpython.jit.backend.zarch import registers as r
# using this register would be pretty wrong!
assert basereg is not r.r0
assert indexreg is not r.r0
if basereg:
self.base = basereg.value
if indexreg:
self.index = indexreg.value
if length:
self.length = length.value
def __repr__(self):
return 'addr(base=r%d,idx=r%d,len=%d)' % (self.base, self.index, self.length)
class PoolLoc(AddressLocation):
_immutable_ = True
width = WORD
def __init__(self, offset, isfloat=False):
AddressLocation.__init__(self, None, None, offset, None)
assert offset >= 0
self.base = 13
self.isfloat = isfloat
if self.isfloat:
self.type = FLOAT
else:
self.type = INT
def is_in_pool(self):
return True
def is_imm(self):
return False
def is_imm_float(self):
return False
def is_float(self):
return self.isfloat
def __repr__(self):
return "pool(i,%d)" % self.displace
def as_key(self):
return -self.displace // 8 + 20000
def addr(displace, basereg=None, indexreg=None, length=None):
return AddressLocation(basereg, indexreg, displace, length)
def imm(i):
return ImmLocation(i)
def pool(off, float=False):
return PoolLoc(off, float)
def halfword(value):
return ImmLocation(value//2)
def get_fp_offset(base_ofs, position):
from rpython.jit.backend.zarch.registers import JITFRAME_FIXED_SIZE
return base_ofs + WORD * (position + JITFRAME_FIXED_SIZE)
imm3 = imm(3)
imm1 = imm(1)
imm0 = imm(0)
MASK_VEC_BYTE = 0
MASK_VEC_HWORD = 1
MASK_VEC_WORD = 2
MASK_VEC_DWORD = 3
MASK_VEC_QWORD = 4
def itemsize_to_mask(v):
if v == 16:
return imm(MASK_VEC_QWORD)
elif v == 8:
return imm(MASK_VEC_DWORD)
elif v == 4:
return imm(MASK_VEC_WORD)
elif v == 2:
return imm(MASK_VEC_HWORD)
elif v == 1:
return imm(MASK_VEC_BYTE)
assert 0, "not supported itemsize to mask!"
|
