856182f36de8e918c92418196d5a129a2869d5ef
1 from collections
import namedtuple
3 import operator
as _operator
4 import functools
as _functools
6 from openpower
.decoder
.power_enums
import find_wiki_file
as _find_wiki_file
7 from openpower
.decoder
.selectable_int
import (
8 SelectableInt
as _SelectableInt
,
10 selectconcat
as _selectconcat
,
11 selectltu
as _selectltu
,
15 class RemapError(ValueError):
20 def __init__(self
, cls
):
22 return super().__init
__()
24 def __get__(self
, instance
, owner
):
27 return self
.__cls
(storage
=instance
.storage
)
29 def __set__(self
, instance
, value
):
31 raise AttributeError("read-only attribute")
32 self
.__cls
(storage
=instance
.storage
).assign(value
)
35 @_functools.total_ordering
37 def __init__(self
, storage
, *args
, **kwargs
):
38 if not isinstance(storage
, _SelectableInt
):
39 raise ValueError(storage
)
41 self
.storage
= storage
46 def __post_init__(self
, *args
, **kwargs
):
49 def __binary_operator(self
, op
, other
):
50 span
= dict.fromkeys(self
.__class
__.span
).keys()
51 lhs
= _selectconcat(*(self
.storage
[bit
] for bit
in span
))
53 if isinstance(other
, Reference
):
54 span
= dict.fromkeys(other
.__class
__.span
).keys()
55 rhs
= _selectconcat(*(other
.storage
[bit
] for bit
in span
))
56 elif isinstance(other
, int):
57 bits
= len(self
.__class
__)
58 if other
.bit_length() > bits
:
59 raise OverflowError(other
)
60 rhs
= _SelectableInt(value
=other
, bits
=bits
)
61 elif isinstance(other
, _SelectableInt
):
64 raise ValueError(other
)
68 def __lt__(self
, other
):
69 return self
.__binary
_operator
(_selectltu
, other
)
71 def __eq__(self
, other
):
72 return self
.__binary
_operator
(_operator
.eq
, other
)
75 return bool(int(self
))
78 span
= dict.fromkeys(self
.__class
__.span
).keys()
79 return int(_selectconcat(*(self
.storage
[bit
] for bit
in span
)))
82 return int(self
).__index
__()
89 def storage(self
, storage
):
90 if not isinstance(storage
, _SelectableInt
):
91 raise ValueError(storage
)
93 self
.__storage
= storage
95 def assign(self
, value
, bits
=None):
97 bits
= range(len(self
.__class
__))
98 elif isinstance(bits
, int):
100 elif isinstance(bits
, slice):
101 assert bits
.step
is None or bits
.step
== 1
102 bits
= range(bits
.start
, bits
.stop
)
105 if isinstance(value
, int):
106 if value
.bit_length() > len(bits
):
107 raise OverflowError(value
)
108 value
= _SelectableInt(value
=value
, bits
=len(bits
))
109 if not isinstance(value
, _SelectableInt
):
110 raise ValueError(value
)
111 if value
.bits
!= len(bits
):
112 raise OverflowError(value
)
114 span
= tuple(self
.__class
__.span
)
115 mapping
= dict(enumerate(span
))
116 for (src
, bit
) in enumerate(bits
):
117 if src
>= value
.bits
:
118 raise OverflowError(src
)
119 dst
= mapping
.get(bit
)
121 raise OverflowError(bit
)
122 self
.storage
[dst
] = value
[src
]
125 class FieldMeta(type):
126 def __new__(metacls
, clsname
, bases
, ns
, items
=()):
127 assert "__members__" not in ns
131 if not isinstance(item
, int):
132 raise ValueError(item
)
134 raise ValueError(item
)
137 ns
["__members__"] = tuple(members
)
139 return super().__new
__(metacls
, clsname
, bases
, ns
)
142 if not cls
.__members
__:
144 return f
"{cls.__name__}{cls.__members__!r}"
147 yield from cls
.__members
__
150 return len(cls
.__members
__)
152 def __getitem__(cls
, selector
):
153 if isinstance(selector
, int):
154 selector
= (selector
,)
158 if not isinstance(idx
, int):
159 raise ValueError(selector
)
160 item
= cls
.__members
__[idx
]
163 return cls
.__class
__(cls
.__name
__, (Field
,), {}, items
=items
)
165 def remap(cls
, scheme
):
166 if isinstance(scheme
, type) and issubclass(scheme
, Mapping
):
167 scheme
= range(len(scheme
))
168 scheme
= cls
.__class
__(cls
.__name
__, (cls
,), {}, items
=scheme
)
172 elif len(cls
) > len(scheme
):
173 llen
= f
"len(scheme)"
174 rlen
= f
"len({cls.__name__})"
175 raise RemapError(f
"{llen} != {rlen}")
178 ns
["__doc__"] = cls
.__doc
__
179 items
= map(lambda item
: scheme
.__members
__[item
], cls
)
181 return cls
.__class
__(cls
.__name
__, (cls
,), ns
, items
=items
)
185 return cls
.__members
__
188 class Field(Reference
, metaclass
=FieldMeta
):
190 return f
"[{len(self.__class__)}]0x{int(self):x}"
193 for bit
in self
.__class
__:
194 yield self
.storage
[bit
]
196 def __getitem__(self
, key
):
197 if isinstance(key
, int):
198 bit
= self
.storage
[self
.__class
__.__members
__[key
]]
199 return _SelectableInt(value
=bit
, bits
=1)
200 if isinstance(key
, slice):
201 assert key
.step
is None or key
.step
== 1
202 key
= range(key
.start
, key
.stop
)
204 return _selectconcat(*(self
[bit
] for bit
in key
))
206 def __setitem__(self
, key
, value
):
207 return self
.assign(value
=value
, bits
=key
)
210 def traverse(cls
, path
):
211 yield (path
, cls
.__members
__)
214 class MappingMeta(type):
215 def __new__(metacls
, clsname
, bases
, ns
):
219 if isinstance(cls
, metacls
):
220 members
.update(cls
.__members
__)
222 for (name
, cls
) in ns
.get("__annotations__", {}).items():
223 if not (isinstance(cls
, type) and
224 issubclass(cls
, (Mapping
, Field
))):
225 raise ValueError(f
"{clsname}.{name}: {cls!r}")
229 members
[name
] = cls
.remap(ns
[name
])
230 except RemapError
as error
:
231 raise RemapError(f
"{name}: {error}")
234 raise ValueError(f
"{clsname}.{name}: missing initializer")
237 ns
["__members__"] = members
238 for (name
, cls
) in members
.items():
239 ns
[name
] = Descriptor(cls
)
241 return super().__new
__(metacls
, clsname
, bases
, ns
)
244 return f
"{cls.__name__}({cls.__members__!r})"
247 yield from cls
.__members
__.items()
251 for field
in cls
.__members
__.values():
252 length
= max(length
, len(field
))
255 def __getitem__(cls
, selector
):
256 return cls
.__members
__["_"][selector
]
258 def remap(cls
, scheme
):
262 for (name
, field
) in cls
:
263 annotations
[name
] = field
.remap(scheme
)
264 ns
["__annotations__"] = annotations
265 ns
["__doc__"] = cls
.__doc
__
267 return cls
.__class
__(cls
.__name
__, (cls
,), ns
)
271 for field
in cls
.__members
__.values():
272 yield from field
.span
275 class Mapping(Reference
, metaclass
=MappingMeta
):
276 def __init__(self
, storage
, **kwargs
):
278 for (name
, cls
) in self
.__class
__:
279 members
[name
] = cls(storage
)
281 self
.__members
= members
283 return super().__init
__(storage
, **kwargs
)
286 items
= tuple(f
"{name}={field!r}" for (name
, field
) in self
)
287 return f
"{{{', '.join(items)}}}"
290 yield from self
.__members
.items()
292 def __getitem__(self
, key
):
293 if isinstance(key
, (int, slice, list, tuple, range)):
294 return self
["_"].__getitem
__(key
)
296 return self
.__members
.__getitem
__(key
)
298 def __setitem__(self
, key
, value
):
299 if isinstance(key
, (int, slice, list, tuple, range)):
300 return self
["_"].assign(value
=value
, bits
=key
)
302 return self
.assign(value
=value
, bits
=key
)
304 def __getattr__(self
, key
):
305 raise AttributeError(key
)
308 def traverse(cls
, path
):
309 for (name
, member
) in cls
.__members
__.items():
311 yield from member
.traverse(path
=path
)
313 yield from member
.traverse(path
=name
)
315 yield from member
.traverse(path
=f
"{path}.{name}")
318 def decode_instructions(form
):
322 if l
.strip().startswith("Formats"):
323 l
= l
.strip().split(":")[-1]
324 l
= l
.replace(" ", "")
328 res
[fmt
] = [accum
[0]]
330 res
[fmt
].append(accum
[0])
333 accum
.append(l
.strip())
337 def decode_form_header(hdr
):
341 for f
in hdr
.split("|"):
345 idx
= int(f
.strip().split(' ')[0])
351 def find_unique(d
, key
):
355 while "%s_%d" % (key
, idx
) in d
:
357 return "%s_%d" % (key
, idx
)
360 def decode_line(header
, line
):
364 prev_fieldname
= None
365 for f
in line
.split("|"):
368 end
= count
+ len(f
) + 1
369 fieldname
= f
.strip()
370 if not fieldname
or fieldname
.startswith('/'):
371 if prev_fieldname
is not None:
372 res
[prev_fieldname
] = (res
[prev_fieldname
], header
[count
])
373 prev_fieldname
= None
376 bitstart
= header
[count
]
377 if prev_fieldname
is not None:
378 res
[prev_fieldname
] = (res
[prev_fieldname
], bitstart
)
379 res
[fieldname
] = bitstart
381 prev_fieldname
= fieldname
382 res
[prev_fieldname
] = (bitstart
, 32)
386 def decode_form(form
):
387 header
= decode_form_header(form
[0])
389 for line
in form
[1:]:
390 dec
= decode_line(header
, line
)
396 for k
, (start
, end
) in l
.items():
398 if (start
, end
) == fields
[k
]:
399 continue # already in and matching for this Form
401 alternate
= "%s_%d" % (k
, falternate
[k
])
402 if (start
, end
) == fields
[alternate
]:
404 falternate
[k
] = fidx
= falternate
.get(k
, 0) + 1
405 fields
["%s_%d" % (k
, fidx
)] = (start
, end
)
407 fields
[k
] = (start
, end
)
413 def __init__(self
, bitkls
=_BitRange
, bitargs
=(), fname
=None,
416 self
.bitargs
= bitargs
418 assert name_on_wiki
is None
420 name_on_wiki
= "fields.text"
421 self
.fname
= _find_wiki_file(name_on_wiki
)
424 def form_names(self
):
425 return self
.instrs
.keys()
427 def create_specs(self
):
428 self
.forms
, self
.instrs
= self
.decode_fields()
429 forms
= self
.form_names
430 #print ("specs", self.forms, forms)
432 fields
= self
.instrs
[form
]
434 Fields
= namedtuple("Fields", fk
)
435 instr
= Fields(**fields
)
436 setattr(self
, "Form%s" % form
, instr
)
437 # now add in some commonly-used fields (should be done automatically)
438 # note that these should only be ones which are the same on all Forms
439 # note: these are from microwatt insn_helpers.vhdl
440 self
.common_fields
= {
441 "PO": self
.Formall
.PO
,
442 "FRS": self
.FormX
.FRS
,
443 "FRT": self
.FormX
.FRT
,
444 "FRA": self
.FormX
.FRA
,
445 "FRB": self
.FormX
.FRB
,
446 "FRC": self
.FormA
.FRC
,
451 "RC": self
.FormVA
.RC
,
455 "SH32": self
.FormM
.SH
,
456 "sh": self
.FormMD
.sh
,
457 "MB32": self
.FormM
.MB
,
458 "ME32": self
.FormM
.ME
,
463 "OE": self
.FormXO
.OE
,
466 "CR": self
.FormXL
.XO
,
467 "BB": self
.FormXL
.BB
,
468 "BA": self
.FormXL
.BA
,
469 "BT": self
.FormXL
.BT
,
470 "FXM": self
.FormXFX
.FXM
,
471 "BO": self
.FormXL
.BO
,
472 "BI": self
.FormXL
.BI
,
473 "BH": self
.FormXL
.BH
,
475 "DS": self
.FormDS
.DS
,
481 "SPR": self
.FormXFX
.SPR
}
482 for k
, v
in self
.common_fields
.items():
485 def decode_fields(self
):
486 with
open(self
.fname
) as f
:
488 #print ("decode", txt)
499 forms
[heading
].append(l
)
502 heading
= l
[1:].strip()
503 # if heading.startswith('1.6.28'): # skip instr fields for now
505 heading
= heading
.split(' ')[-1]
512 for hdr
, form
in forms
.items():
513 if heading
== 'Fields':
514 i
= decode_instructions(form
)
515 for form
, field
in i
.items():
516 inst
[form
] = self
.decode_instruction_fields(field
)
518 # res[hdr] = decode_form(form)
521 def decode_instruction_fields(self
, fields
):
524 f
, spec
= field
.strip().split(" ")
525 ss
= spec
[1:-1].split(",")
528 individualfields
= []
529 for f0
, s0
in zip(fs
, ss
):
530 txt
= "%s (%s)" % (f0
, s0
)
531 individualfields
.append(txt
)
533 res
.update(self
.decode_instruction_fields(
535 d
= self
.bitkls(*self
.bitargs
)
549 f
= f
.replace(",", "_")
550 unique
= find_unique(res
, f
)
556 if __name__
== '__main__':
559 forms
, instrs
= dec
.forms
, dec
.instrs
560 for form
, fields
in instrs
.items():
562 for field
, bits
in fields
.items():
563 print("\tfield", field
, bits
)