src/openpower/decoder/power_insn.py

   1 import collections as _collections
   2 import csv as _csv
   3 import dataclasses as _dataclasses
   4 import enum as _enum
   5 import functools as _functools
   6 import itertools as _itertools
   7 import os as _os
   8 import operator as _operator
   9 import pathlib as _pathlib
  10 import re as _re
  11
  12 try:
  13     from functools import cached_property
  14 except ImportError:
  15     from cached_property import cached_property
  16
  17 from openpower.decoder.power_enums import (
  18     Function as _Function,
  19     MicrOp as _MicrOp,
  20     In1Sel as _In1Sel,
  21     In2Sel as _In2Sel,
  22     In3Sel as _In3Sel,
  23     OutSel as _OutSel,
  24     CRInSel as _CRInSel,
  25     CRIn2Sel as _CRIn2Sel,
  26     CROutSel as _CROutSel,
  27     LDSTLen as _LDSTLen,
  28     LDSTMode as _LDSTMode,
  29     RCOE as _RCOE,
  30     CryIn as _CryIn,
  31     Form as _Form,
  32     SVEtype as _SVEtype,
  33     SVMode as _SVMode,
  34     SVPtype as _SVPtype,
  35     SVExtra as _SVExtra,
  36     RegType as _RegType,
  37     SVExtraRegType as _SVExtraRegType,
  38     SVExtraReg as _SVExtraReg,
  39 )
  40 from openpower.decoder.selectable_int import (
  41     SelectableInt as _SelectableInt,
  42     selectconcat as _selectconcat,
  43 )
  44 from openpower.decoder.power_fields import (
  45     Field as _Field,
  46     Mapping as _Mapping,
  47     DecodeFields as _DecodeFields,
  48 )
  49 from openpower.decoder.pseudo.pagereader import ISA as _ISA
  50
  51
  52 @_functools.total_ordering
  53 class Verbosity(_enum.Enum):
  54     SHORT = _enum.auto()
  55     NORMAL = _enum.auto()
  56     VERBOSE = _enum.auto()
  57
  58     def __lt__(self, other):
  59         if not isinstance(other, self.__class__):
  60             return NotImplemented
  61         return (self.value < other.value)
  62
  63
  64 def dataclass(cls, record, keymap=None, typemap=None):
  65     if keymap is None:
  66         keymap = {}
  67     if typemap is None:
  68         typemap = {field.name:field.type for field in _dataclasses.fields(cls)}
  69
  70     def transform(key_value):
  71         (key, value) = key_value
  72         key = keymap.get(key, key)
  73         hook = typemap.get(key, lambda value: value)
  74         if hook is bool and value in ("", "0"):
  75             value = False
  76         else:
  77             value = hook(value)
  78         return (key, value)
  79
  80     record = dict(map(transform, record.items()))
  81     for key in frozenset(record.keys()):
  82         if record[key] == "":
  83             record.pop(key)
  84
  85     return cls(**record)
  86
  87
  88 @_functools.total_ordering
  89 @_dataclasses.dataclass(eq=True, frozen=True)
  90 class Opcode:
  91     class Integer(int):
  92         def __new__(cls, value):
  93             if isinstance(value, str):
  94                 value = int(value, 0)
  95             if not isinstance(value, int):
  96                 raise ValueError(value)
  97
  98             if value.bit_length() > 64:
  99                 raise ValueError(value)
 100
 101             return super().__new__(cls, value)
 102
 103         def __str__(self):
 104             return super().__repr__()
 105
 106         def __repr__(self):
 107             return f"{self:0{self.bit_length()}b}"
 108
 109         def bit_length(self):
 110             if super().bit_length() > 32:
 111                 return 64
 112             return 32
 113
 114     class Value(Integer):
 115         pass
 116
 117     class Mask(Integer):
 118         pass
 119
 120     value: Value
 121     mask: Mask
 122
 123     def __lt__(self, other):
 124         if not isinstance(other, Opcode):
 125             return NotImplemented
 126         return ((self.value, self.mask) < (other.value, other.mask))
 127
 128     def __post_init__(self):
 129         if self.value.bit_length() != self.mask.bit_length():
 130             raise ValueError("bit length mismatch")
 131
 132     def __repr__(self):
 133         def pattern(value, mask, bit_length):
 134             for bit in range(bit_length):
 135                 if ((mask & (1 << (bit_length - bit - 1))) == 0):
 136                     yield "-"
 137                 elif (value & (1 << (bit_length - bit - 1))):
 138                     yield "1"
 139                 else:
 140                     yield "0"
 141
 142         return "".join(pattern(self.value, self.mask, self.value.bit_length()))
 143
 144
 145 class IntegerOpcode(Opcode):
 146     def __init__(self, value):
 147         if value.startswith("0b"):
 148            mask = int(("1" * len(value[2:])), 2)
 149         else:
 150             mask = 0b111111
 151
 152         value = Opcode.Value(value)
 153         mask = Opcode.Mask(mask)
 154
 155         return super().__init__(value=value, mask=mask)
 156
 157
 158 class PatternOpcode(Opcode):
 159     def __init__(self, pattern):
 160         if not isinstance(pattern, str):
 161             raise ValueError(pattern)
 162
 163         (value, mask) = (0, 0)
 164         for symbol in pattern:
 165             if symbol not in {"0", "1", "-"}:
 166                 raise ValueError(pattern)
 167             value |= (symbol == "1")
 168             mask |= (symbol != "-")
 169             value <<= 1
 170             mask <<= 1
 171         value >>= 1
 172         mask >>= 1
 173
 174         value = Opcode.Value(value)
 175         mask = Opcode.Mask(mask)
 176
 177         return super().__init__(value=value, mask=mask)
 178
 179
 180 @_dataclasses.dataclass(eq=True, frozen=True)
 181 class PPCRecord:
 182     class FlagsMeta(type):
 183         def __iter__(cls):
 184             yield from (
 185                 "inv A",
 186                 "inv out",
 187                 "cry out",
 188                 "BR",
 189                 "sgn ext",
 190                 "rsrv",
 191                 "32b",
 192                 "sgn",
 193                 "lk",
 194                 "sgl pipe",
 195             )
 196
 197     class Flags(frozenset, metaclass=FlagsMeta):
 198         def __new__(cls, flags=frozenset()):
 199             flags = frozenset(flags)
 200             diff = (flags - frozenset(cls))
 201             if diff:
 202                 raise ValueError(flags)
 203             return super().__new__(cls, flags)
 204
 205     opcode: Opcode
 206     comment: str
 207     flags: Flags = Flags()
 208     comment2: str = ""
 209     function: _Function = _Function.NONE
 210     intop: _MicrOp = _MicrOp.OP_ILLEGAL
 211     in1: _In1Sel = _In1Sel.RA
 212     in2: _In2Sel = _In2Sel.NONE
 213     in3: _In3Sel = _In3Sel.NONE
 214     out: _OutSel = _OutSel.NONE
 215     cr_in: _CRInSel = _CRInSel.NONE
 216     cr_in2: _CRIn2Sel = _CRIn2Sel.NONE
 217     cr_out: _CROutSel = _CROutSel.NONE
 218     cry_in: _CryIn = _CryIn.ZERO
 219     ldst_len: _LDSTLen = _LDSTLen.NONE
 220     upd: _LDSTMode = _LDSTMode.NONE
 221     Rc: _RCOE = _RCOE.NONE
 222     form: _Form = _Form.NONE
 223     conditions: str = ""
 224     unofficial: bool = False
 225
 226     __KEYMAP = {
 227         "unit": "function",
 228         "internal op": "intop",
 229         "CR in": "cr_in",
 230         "CR out": "cr_out",
 231         "cry in": "cry_in",
 232         "ldst len": "ldst_len",
 233         "rc": "Rc",
 234         "CONDITIONS": "conditions",
 235     }
 236
 237     @classmethod
 238     def CSV(cls, record, opcode_cls):
 239         typemap = {field.name:field.type for field in _dataclasses.fields(cls)}
 240         typemap["opcode"] = opcode_cls
 241
 242         if record["CR in"] == "BA_BB":
 243             record["cr_in"] = "BA"
 244             record["cr_in2"] = "BB"
 245             del record["CR in"]
 246
 247         flags = set()
 248         for flag in frozenset(PPCRecord.Flags):
 249             if bool(record.pop(flag, "")):
 250                 flags.add(flag)
 251         record["flags"] = PPCRecord.Flags(flags)
 252
 253         return dataclass(cls, record,
 254             keymap=PPCRecord.__KEYMAP,
 255             typemap=typemap)
 256
 257     @cached_property
 258     def names(self):
 259         return frozenset(self.comment.split("=")[-1].split("/"))
 260
 261
 262 class PPCMultiRecord(tuple):
 263     def __getattr__(self, attr):
 264         if attr == "opcode":
 265             raise AttributeError(attr)
 266         return getattr(self[0], attr)
 267
 268
 269 @_dataclasses.dataclass(eq=True, frozen=True)
 270 class SVP64Record:
 271     class ExtraMap(tuple):
 272         class Extra(tuple):
 273             @_dataclasses.dataclass(eq=True, frozen=True)
 274             class Entry:
 275                 regtype: _SVExtraRegType = _SVExtraRegType.NONE
 276                 reg: _SVExtraReg = _SVExtraReg.NONE
 277
 278                 def __repr__(self):
 279                     return f"{self.regtype.value}:{self.reg.name}"
 280
 281             def __new__(cls, value="0"):
 282                 if isinstance(value, str):
 283                     def transform(value):
 284                         (regtype, reg) = value.split(":")
 285                         regtype = _SVExtraRegType(regtype)
 286                         reg = _SVExtraReg(reg)
 287                         return cls.Entry(regtype=regtype, reg=reg)
 288
 289                     if value == "0":
 290                         value = tuple()
 291                     else:
 292                         value = map(transform, value.split(";"))
 293
 294                 return super().__new__(cls, value)
 295
 296             def __repr__(self):
 297                 return repr(list(self))
 298
 299         def __new__(cls, value=tuple()):
 300             value = tuple(value)
 301             if len(value) == 0:
 302                 value = (("0",) * 4)
 303             return super().__new__(cls, map(cls.Extra, value))
 304
 305         def __repr__(self):
 306             return repr({index:self[index] for index in range(0, 4)})
 307
 308     name: str
 309     ptype: _SVPtype = _SVPtype.NONE
 310     etype: _SVEtype = _SVEtype.NONE
 311     in1: _In1Sel = _In1Sel.NONE
 312     in2: _In2Sel = _In2Sel.NONE
 313     in3: _In3Sel = _In3Sel.NONE
 314     out: _OutSel = _OutSel.NONE
 315     out2: _OutSel = _OutSel.NONE
 316     cr_in: _CRInSel = _CRInSel.NONE
 317     cr_in2: _CRIn2Sel = _CRIn2Sel.NONE
 318     cr_out: _CROutSel = _CROutSel.NONE
 319     extra: ExtraMap = ExtraMap()
 320     conditions: str = ""
 321     mode: _SVMode = _SVMode.NORMAL
 322
 323     __KEYMAP = {
 324         "insn": "name",
 325         "CONDITIONS": "conditions",
 326         "Ptype": "ptype",
 327         "Etype": "etype",
 328         "CR in": "cr_in",
 329         "CR out": "cr_out",
 330     }
 331
 332     @classmethod
 333     def CSV(cls, record):
 334         for key in frozenset({
 335                     "in1", "in2", "in3", "CR in",
 336                     "out", "out2", "CR out",
 337                 }):
 338             value = record[key]
 339             if value == "0":
 340                 record[key] = "NONE"
 341
 342         if record["CR in"] == "BA_BB":
 343             record["cr_in"] = "BA"
 344             record["cr_in2"] = "BB"
 345             del record["CR in"]
 346
 347         extra = []
 348         for idx in range(0, 4):
 349             extra.append(record.pop(f"{idx}"))
 350
 351         record["extra"] = cls.ExtraMap(extra)
 352
 353         return dataclass(cls, record, keymap=cls.__KEYMAP)
 354
 355     @_functools.lru_cache(maxsize=None)
 356     def extra_idx(self, key):
 357         extra_idx = (
 358             _SVExtra.Idx0,
 359             _SVExtra.Idx1,
 360             _SVExtra.Idx2,
 361             _SVExtra.Idx3,
 362         )
 363
 364         if key not in frozenset({
 365                     "in1", "in2", "in3", "cr_in", "cr_in2",
 366                     "out", "out2", "cr_out",
 367                 }):
 368             raise KeyError(key)
 369
 370         sel = getattr(self, key)
 371         if sel is _CRInSel.BA_BB:
 372             return _SVExtra.Idx_1_2
 373         reg = _SVExtraReg(sel)
 374         if reg is _SVExtraReg.NONE:
 375             return _SVExtra.NONE
 376
 377         extra_map = {
 378             _SVExtraRegType.SRC: {},
 379             _SVExtraRegType.DST: {},
 380         }
 381         for index in range(0, 4):
 382             for entry in self.extra[index]:
 383                 extra_map[entry.regtype][entry.reg] = extra_idx[index]
 384
 385         for regtype in (_SVExtraRegType.SRC, _SVExtraRegType.DST):
 386             extra = extra_map[regtype].get(reg, _SVExtra.NONE)
 387             if extra is not _SVExtra.NONE:
 388                 return extra
 389
 390         return _SVExtra.NONE
 391
 392     extra_idx_in1 = property(_functools.partial(extra_idx, key="in1"))
 393     extra_idx_in2 = property(_functools.partial(extra_idx, key="in2"))
 394     extra_idx_in3 = property(_functools.partial(extra_idx, key="in3"))
 395     extra_idx_out = property(_functools.partial(extra_idx, key="out"))
 396     extra_idx_out2 = property(_functools.partial(extra_idx, key="out2"))
 397     extra_idx_cr_in = property(_functools.partial(extra_idx, key="cr_in"))
 398     extra_idx_cr_out = property(_functools.partial(extra_idx, key="cr_out"))
 399
 400     @_functools.lru_cache(maxsize=None)
 401     def extra_reg(self, key):
 402         return _SVExtraReg(getattr(self, key))
 403
 404     extra_reg_in1 = property(_functools.partial(extra_reg, key="in1"))
 405     extra_reg_in2 = property(_functools.partial(extra_reg, key="in2"))
 406     extra_reg_in3 = property(_functools.partial(extra_reg, key="in3"))
 407     extra_reg_out = property(_functools.partial(extra_reg, key="out"))
 408     extra_reg_out2 = property(_functools.partial(extra_reg, key="out2"))
 409     extra_reg_cr_in = property(_functools.partial(extra_reg, key="cr_in"))
 410     extra_reg_cr_out = property(_functools.partial(extra_reg, key="cr_out"))
 411
 412
 413 class BitSel:
 414     def __init__(self, value=(0, 32)):
 415         if isinstance(value, str):
 416             (start, end) = map(int, value.split(":"))
 417         else:
 418             (start, end) = value
 419         if start < 0 or end < 0 or start >= end:
 420             raise ValueError(value)
 421
 422         self.__start = start
 423         self.__end = end
 424
 425         return super().__init__()
 426
 427     def __repr__(self):
 428         return f"[{self.__start}:{self.__end}]"
 429
 430     def __iter__(self):
 431         yield from range(self.start, (self.end + 1))
 432
 433     def __reversed__(self):
 434         return tuple(reversed(tuple(self)))
 435
 436     @property
 437     def start(self):
 438         return self.__start
 439
 440     @property
 441     def end(self):
 442         return self.__end
 443
 444
 445 @_dataclasses.dataclass(eq=True, frozen=True)
 446 class Section:
 447     class Mode(_enum.Enum):
 448         INTEGER = _enum.auto()
 449         PATTERN = _enum.auto()
 450
 451         @classmethod
 452         def _missing_(cls, value):
 453             if isinstance(value, str):
 454                 return cls[value.upper()]
 455             return super()._missing_(value)
 456
 457     class Suffix(int):
 458         def __new__(cls, value=None):
 459             if isinstance(value, str):
 460                 if value.upper() == "NONE":
 461                     value = None
 462                 else:
 463                     value = int(value, 0)
 464             if value is None:
 465                 value = 0
 466
 467             return super().__new__(cls, value)
 468
 469         def __str__(self):
 470             return repr(self)
 471
 472         def __repr__(self):
 473             return (bin(self) if self else "None")
 474
 475     path: _pathlib.Path
 476     bitsel: BitSel
 477     suffix: Suffix
 478     mode: Mode
 479     opcode: IntegerOpcode = None
 480
 481     @classmethod
 482     def CSV(cls, record):
 483         typemap = {field.name:field.type for field in _dataclasses.fields(cls)}
 484         if record["opcode"] == "NONE":
 485             typemap["opcode"] = lambda _: None
 486
 487         return dataclass(cls, record, typemap=typemap)
 488
 489
 490 class Fields:
 491     def __init__(self, items):
 492         if isinstance(items, dict):
 493             items = items.items()
 494
 495         def transform(item):
 496             (name, bitrange) = item
 497             return (name, tuple(bitrange.values()))
 498
 499         self.__mapping = dict(map(transform, items))
 500
 501         return super().__init__()
 502
 503     def __repr__(self):
 504         return repr(self.__mapping)
 505
 506     def __iter__(self):
 507         yield from self.__mapping.items()
 508
 509     def __contains__(self, key):
 510         return self.__mapping.__contains__(key)
 511
 512     def __getitem__(self, key):
 513         return self.__mapping.get(key, None)
 514
 515
 516 @_dataclasses.dataclass(eq=True, frozen=True)
 517 class Operand:
 518     name: str
 519
 520     def span(self, record):
 521         return record.fields[self.name]
 522
 523     def disassemble(self, insn, record,
 524             verbosity=Verbosity.NORMAL, indent=""):
 525         raise NotImplementedError
 526
 527
 528 class DynamicOperand(Operand):
 529     def disassemble(self, insn, record,
 530             verbosity=Verbosity.NORMAL, indent=""):
 531         span = self.span(record=record)
 532         if isinstance(insn, SVP64Instruction):
 533             span = tuple(map(lambda bit: (bit + 32), span))
 534         value = insn[span]
 535
 536         if verbosity >= Verbosity.VERBOSE:
 537             span = map(str, span)
 538             yield f"{indent}{self.name}"
 539             yield f"{indent}{indent}{int(value):0{value.bits}b}"
 540             yield f"{indent}{indent}{', '.join(span)}"
 541         else:
 542             yield str(int(value))
 543
 544
 545 class SignedOperand(DynamicOperand):
 546     def disassemble(self, insn, record,
 547             verbosity=Verbosity.NORMAL, indent=""):
 548         span = self.span(record=record)
 549         if isinstance(insn, SVP64Instruction):
 550             span = tuple(map(lambda bit: (bit + 32), span))
 551         value = insn[span]
 552
 553         if verbosity >= Verbosity.VERBOSE:
 554             span = map(str, span)
 555             yield f"{indent}{self.name}"
 556             yield f"{indent}{indent}{int(value):0{value.bits}b}"
 557             yield f"{indent}{indent}{', '.join(span)}"
 558         else:
 559             yield str(value.to_signed_int())
 560
 561
 562 @_dataclasses.dataclass(eq=True, frozen=True)
 563 class StaticOperand(Operand):
 564     value: int
 565
 566     def disassemble(self, insn, record,
 567             verbosity=Verbosity.NORMAL, indent=""):
 568         span = self.span(record=record)
 569         if isinstance(insn, SVP64Instruction):
 570             span = tuple(map(lambda bit: (bit + 32), span))
 571         value = insn[span]
 572
 573         if verbosity >= Verbosity.VERBOSE:
 574             span = map(str, span)
 575             yield f"{indent}{self.name}"
 576             yield f"{indent}{indent}{int(value):0{value.bits}b}"
 577             yield f"{indent}{indent}{', '.join(span)}"
 578         else:
 579             yield str(int(value))
 580
 581
 582 class ImmediateOperand(DynamicOperand):
 583     pass
 584
 585
 586 class NonZeroOperand(DynamicOperand):
 587     def disassemble(self, insn, record,
 588             verbosity=Verbosity.NORMAL, indent=""):
 589         span = self.span(record=record)
 590         if isinstance(insn, SVP64Instruction):
 591             span = tuple(map(lambda bit: (bit + 32), span))
 592         value = insn[span]
 593
 594         if verbosity >= Verbosity.VERBOSE:
 595             span = map(str, span)
 596             yield f"{indent}{self.name}"
 597             yield f"{indent}{indent}{int(value):0{value.bits}b}"
 598             yield f"{indent}{indent}{', '.join(span)}"
 599         else:
 600             yield str(int(value) + 1)
 601
 602
 603 class RegisterOperand(DynamicOperand):
 604     def sv_spec_enter(self, value, span):
 605         return (value, span)
 606
 607     def sv_spec_leave(self, value, span, origin_value, origin_span):
 608         return (value, span)
 609
 610     def spec(self, insn, record):
 611         vector = False
 612         span = self.span(record=record)
 613         if isinstance(insn, SVP64Instruction):
 614             span = tuple(map(lambda bit: (bit + 32), span))
 615         value = insn[span]
 616         span = tuple(map(str, span))
 617
 618         if isinstance(insn, SVP64Instruction):
 619             (origin_value, origin_span) = (value, span)
 620             (value, span) = self.sv_spec_enter(value=value, span=span)
 621
 622             extra_idx = self.extra_idx(record=record)
 623             if extra_idx is _SVExtra.NONE:
 624                 return (vector, value, span)
 625
 626             if record.etype is _SVEtype.EXTRA3:
 627                 spec = insn.prefix.rm.extra3[extra_idx]
 628             elif record.etype is _SVEtype.EXTRA2:
 629                 spec = insn.prefix.rm.extra2[extra_idx]
 630             else:
 631                 raise ValueError(record.etype)
 632
 633             if spec != 0:
 634                 vector = bool(spec[0])
 635                 spec_span = spec.__class__
 636                 if record.etype is _SVEtype.EXTRA3:
 637                     spec_span = tuple(map(str, spec_span[1, 2]))
 638                     spec = spec[1, 2]
 639                 elif record.etype is _SVEtype.EXTRA2:
 640                     spec_span = tuple(map(str, spec_span[1,]))
 641                     spec = _SelectableInt(value=spec[1].value, bits=2)
 642                     if vector:
 643                         spec <<= 1
 644                         spec_span = (spec_span + ("{0}",))
 645                     else:
 646                         spec_span = (("{0}",) + spec_span)
 647                 else:
 648                     raise ValueError(record.etype)
 649
 650                 vector_shift = (2 + (5 - value.bits))
 651                 scalar_shift = value.bits
 652                 spec_shift = (5 - value.bits)
 653
 654                 bits = (len(span) + len(spec_span))
 655                 value = _SelectableInt(value=value.value, bits=bits)
 656                 spec = _SelectableInt(value=spec.value, bits=bits)
 657                 if vector:
 658                     value = ((value << vector_shift) | (spec << spec_shift))
 659                     span = (span + spec_span + ((spec_shift * ('{0}',))))
 660                 else:
 661                     value = ((spec << scalar_shift) | value)
 662                     span = ((spec_shift * ('{0}',)) + spec_span + span)
 663
 664             (value, span) = self.sv_spec_leave(value=value, span=span,
 665                 origin_value=origin_value, origin_span=origin_span)
 666
 667         return (vector, value, span)
 668
 669     @property
 670     def extra_reg(self):
 671         return _SVExtraReg(self.name)
 672
 673     def extra_idx(self, record):
 674         for key in frozenset({
 675                     "in1", "in2", "in3", "cr_in", "cr_in2",
 676                     "out", "out2", "cr_out",
 677                 }):
 678             extra_reg = record.svp64.extra_reg(key=key)
 679             if extra_reg is self.extra_reg:
 680                 return record.extra_idx(key=key)
 681
 682         return _SVExtra.NONE
 683
 684     def disassemble(self, insn, record,
 685             verbosity=Verbosity.NORMAL, prefix="", indent=""):
 686         (vector, value, span) = self.spec(insn=insn, record=record)
 687
 688         if verbosity >= Verbosity.VERBOSE:
 689             mode = "vector" if vector else "scalar"
 690             yield f"{indent}{self.name} ({mode})"
 691             yield f"{indent}{indent}{int(value):0{value.bits}b}"
 692             yield f"{indent}{indent}{', '.join(span)}"
 693             if isinstance(insn, SVP64Instruction):
 694                 extra_idx = self.extra_idx(record)
 695                 if record.etype is _SVEtype.NONE:
 696                     yield f"{indent}{indent}extra[none]"
 697                 else:
 698                     etype = repr(record.etype).lower()
 699                     yield f"{indent}{indent}{etype}{extra_idx!r}"
 700         else:
 701             vector = "*" if vector else ""
 702             yield f"{vector}{prefix}{int(value)}"
 703
 704
 705 class GPROperand(RegisterOperand):
 706     def disassemble(self, insn, record,
 707             verbosity=Verbosity.NORMAL, indent=""):
 708         prefix = "" if (verbosity <= Verbosity.SHORT) else "r"
 709         yield from super().disassemble(prefix=prefix,
 710             insn=insn, record=record,
 711             verbosity=verbosity, indent=indent)
 712
 713
 714 class FPROperand(RegisterOperand):
 715     def disassemble(self, insn, record,
 716             verbosity=Verbosity.NORMAL, indent=""):
 717         prefix = "" if (verbosity <= Verbosity.SHORT) else "f"
 718         yield from super().disassemble(prefix=prefix,
 719             insn=insn, record=record,
 720             verbosity=verbosity, indent=indent)
 721
 722
 723 class CR3Operand(RegisterOperand):
 724     pass
 725
 726
 727 class CR5Operand(RegisterOperand):
 728     def sv_spec_enter(self, value, span):
 729         value = _SelectableInt(value=(value.value >> 2), bits=3)
 730         return (value, span)
 731
 732     def sv_spec_leave(self, value, span, origin_value, origin_span):
 733         value = _selectconcat(value, origin_value[3:5])
 734         span += origin_span
 735         return (value, span)
 736
 737
 738 class TargetAddrOperand(RegisterOperand):
 739     def disassemble(self, insn, record, field,
 740             verbosity=Verbosity.NORMAL, indent=""):
 741         span = self.span(record=record)
 742         if isinstance(insn, SVP64Instruction):
 743             span = tuple(map(lambda bit: (bit + 32), span))
 744         value = insn[span]
 745
 746         if verbosity >= Verbosity.VERBOSE:
 747             span = tuple(map(str, span))
 748             yield f"{indent}{self.name} = EXTS({field} || 0b00))"
 749             yield f"{indent}{indent}{field}"
 750             yield f"{indent}{indent}{indent}{int(value):0{value.bits}b}00"
 751             yield f"{indent}{indent}{indent}{', '.join(span + ('{0}', '{0}'))}"
 752         else:
 753             yield hex(_selectconcat(value,
 754                 _SelectableInt(value=0b00, bits=2)).to_signed_int())
 755
 756
 757 class TargetAddrOperandLI(TargetAddrOperand):
 758     def span(self, record):
 759         return record.fields["LI"]
 760
 761     def disassemble(self, insn, record,
 762             verbosity=Verbosity.NORMAL, indent=""):
 763         return super().disassemble(field="LI",
 764             insn=insn, record=record,
 765             verbosity=verbosity, indent=indent)
 766
 767
 768 class TargetAddrOperandBD(TargetAddrOperand):
 769     def span(self, record):
 770         return record.fields["BD"]
 771
 772     def disassemble(self, insn, record,
 773             verbosity=Verbosity.NORMAL, indent=""):
 774         return super().disassemble(field="BD",
 775             insn=insn, record=record,
 776             verbosity=verbosity, indent=indent)
 777
 778
 779 class DOperandDX(DynamicOperand):
 780     def span(self, record):
 781         operands = map(DynamicOperand, ("d0", "d1", "d2"))
 782         spans = map(lambda operand: operand.span(record=record), operands)
 783         return sum(spans, tuple())
 784
 785     def disassemble(self, insn, record,
 786             verbosity=Verbosity.NORMAL, indent=""):
 787         span = self.span(record=record)
 788         if isinstance(insn, SVP64Instruction):
 789             span = tuple(map(lambda bit: (bit + 32), span))
 790         value = insn[span]
 791
 792         if verbosity >= Verbosity.VERBOSE:
 793             yield f"{indent}D"
 794             mapping = {
 795                 "d0": "[0:9]",
 796                 "d1": "[10:15]",
 797                 "d2": "[16]",
 798             }
 799             for (subname, subspan) in mapping.items():
 800                 operand = DynamicOperand(name=subname)
 801                 span = operand.span(record=record)
 802                 if isinstance(insn, SVP64Instruction):
 803                     span = tuple(map(lambda bit: (bit + 32), span))
 804                 value = insn[span]
 805                 span = map(str, span)
 806                 yield f"{indent}{indent}{operand.name} = D{subspan}"
 807                 yield f"{indent}{indent}{indent}{int(value):0{value.bits}b}"
 808                 yield f"{indent}{indent}{indent}{', '.join(span)}"
 809         else:
 810             yield str(value.to_signed_int())
 811
 812
 813 class Operands(tuple):
 814     def __new__(cls, insn, iterable):
 815         custom_insns = {
 816             "b": {"target_addr": TargetAddrOperandLI},
 817             "ba": {"target_addr": TargetAddrOperandLI},
 818             "bl": {"target_addr": TargetAddrOperandLI},
 819             "bla": {"target_addr": TargetAddrOperandLI},
 820             "bc": {"target_addr": TargetAddrOperandBD},
 821             "bca": {"target_addr": TargetAddrOperandBD},
 822             "bcl": {"target_addr": TargetAddrOperandBD},
 823             "bcla": {"target_addr": TargetAddrOperandBD},
 824             "addpcis": {"D": DOperandDX},
 825             "fishmv": {"D": DOperandDX},
 826             "fmvis": {"D": DOperandDX},
 827         }
 828         custom_fields = {
 829             "SVi": NonZeroOperand,
 830             "SVd": NonZeroOperand,
 831             "SVxd": NonZeroOperand,
 832             "SVyd": NonZeroOperand,
 833             "SVzd": NonZeroOperand,
 834             "BD": SignedOperand,
 835             "D": SignedOperand,
 836             "DQ": SignedOperand,
 837             "DS": SignedOperand,
 838             "SI": SignedOperand,
 839             "IB": SignedOperand,
 840             "LI": SignedOperand,
 841             "SIM": SignedOperand,
 842             "SVD": SignedOperand,
 843             "SVDS": SignedOperand,
 844         }
 845
 846         operands = []
 847         for operand in iterable:
 848             dynamic_cls = DynamicOperand
 849             static_cls = StaticOperand
 850
 851             if "=" in operand:
 852                 (name, value) = operand.split("=")
 853                 operand = static_cls(name=name, value=int(value))
 854                 operands.append(operand)
 855             else:
 856                 if operand.endswith(")"):
 857                     operand = operand.replace("(", " ").replace(")", "")
 858                     (immediate, _, operand) = operand.partition(" ")
 859                 else:
 860                     immediate = None
 861
 862                 if immediate is not None:
 863                     operands.append(ImmediateOperand(name=immediate))
 864
 865                 if insn in custom_insns and operand in custom_insns[insn]:
 866                     dynamic_cls = custom_insns[insn][operand]
 867                 if operand in custom_fields:
 868                     dynamic_cls = custom_fields[operand]
 869
 870                 if operand in _RegType.__members__:
 871                     regtype = _RegType[operand]
 872                     if regtype is _RegType.GPR:
 873                         dynamic_cls = GPROperand
 874                     elif regtype is _RegType.FPR:
 875                         dynamic_cls = FPROperand
 876                     if regtype is _RegType.CR_BIT: # 5-bit
 877                         dynamic_cls = CR5Operand
 878                     if regtype is _RegType.CR_REG: # actually CR Field, 3-bit
 879                         dynamic_cls = CR3Operand
 880
 881                 operand = dynamic_cls(name=operand)
 882                 operands.append(operand)
 883
 884         return super().__new__(cls, operands)
 885
 886     def __contains__(self, key):
 887         return self.__getitem__(key) is not None
 888
 889     def __getitem__(self, key):
 890         for operand in self:
 891             if operand.name == key:
 892                 return operand
 893
 894         return None
 895
 896     @property
 897     def dynamic(self):
 898         for operand in self:
 899             if isinstance(operand, DynamicOperand):
 900                 yield operand
 901
 902     @property
 903     def static(self):
 904         for operand in self:
 905             if isinstance(operand, StaticOperand):
 906                 yield operand
 907
 908
 909 class PCode:
 910     def __init__(self, iterable):
 911         self.__pcode = tuple(iterable)
 912         return super().__init__()
 913
 914     def __iter__(self):
 915         yield from self.__pcode
 916
 917     def __repr__(self):
 918         return self.__pcode.__repr__()
 919
 920
 921 @_dataclasses.dataclass(eq=True, frozen=True)
 922 class MarkdownRecord:
 923     pcode: PCode
 924     operands: Operands
 925
 926
 927 @_functools.total_ordering
 928 @_dataclasses.dataclass(eq=True, frozen=True)
 929 class Record:
 930     name: str
 931     section: Section
 932     ppc: PPCRecord
 933     fields: Fields
 934     mdwn: MarkdownRecord
 935     svp64: SVP64Record = None
 936
 937     def __lt__(self, other):
 938         if not isinstance(other, Record):
 939             return NotImplemented
 940         return (min(self.opcodes) < min(other.opcodes))
 941
 942     @property
 943     def opcodes(self):
 944         def opcode(ppc):
 945             value = ([0] * 32)
 946             mask = ([0] * 32)
 947
 948             PO = self.section.opcode
 949             if PO is not None:
 950                 for (src, dst) in enumerate(reversed(BitSel((0, 5)))):
 951                     value[dst] = int((PO.value & (1 << src)) != 0)
 952                     mask[dst] = int((PO.mask & (1 << src)) != 0)
 953
 954             XO = ppc.opcode
 955             for (src, dst) in enumerate(reversed(self.section.bitsel)):
 956                 value[dst] = int((XO.value & (1 << src)) != 0)
 957                 mask[dst] = int((XO.mask & (1 << src)) != 0)
 958
 959             for operand in self.mdwn.operands.static:
 960                 for (src, dst) in enumerate(reversed(operand.span(record=self))):
 961                     value[dst] = int((operand.value & (1 << src)) != 0)
 962                     mask[dst] = 1
 963
 964             value = Opcode.Value(int(("".join(map(str, value))), 2))
 965             mask = Opcode.Mask(int(("".join(map(str, mask))), 2))
 966
 967             return Opcode(value=value, mask=mask)
 968
 969         return tuple(sorted(map(opcode, self.ppc)))
 970
 971     def match(self, key):
 972         for opcode in self.opcodes:
 973             if ((opcode.value & opcode.mask) ==
 974                     (key & opcode.mask)):
 975                 return True
 976         return False
 977
 978     @property
 979     def function(self):
 980         return self.ppc.function
 981
 982     @property
 983     def in1(self):
 984         return self.ppc.in1
 985
 986     @property
 987     def in2(self):
 988         return self.ppc.in2
 989
 990     @property
 991     def in3(self):
 992         return self.ppc.in3
 993
 994     @property
 995     def out(self):
 996         return self.ppc.out
 997
 998     @property
 999     def out2(self):
1000         if self.svp64 is None:
1001             return _OutSel.NONE
1002         return self.ppc.out
1003
1004     @property
1005     def cr_in(self):
1006         return self.ppc.cr_in
1007
1008     @property
1009     def cr_in2(self):
1010         return self.ppc.cr_in2
1011
1012     @property
1013     def cr_out(self):
1014         return self.ppc.cr_out
1015
1016     ptype = property(lambda self: self.svp64.ptype)
1017     etype = property(lambda self: self.svp64.etype)
1018
1019     def extra_idx(self, key):
1020         return self.svp64.extra_idx(key)
1021
1022     extra_idx_in1 = property(lambda self: self.svp64.extra_idx_in1)
1023     extra_idx_in2 = property(lambda self: self.svp64.extra_idx_in2)
1024     extra_idx_in3 = property(lambda self: self.svp64.extra_idx_in3)
1025     extra_idx_out = property(lambda self: self.svp64.extra_idx_out)
1026     extra_idx_out2 = property(lambda self: self.svp64.extra_idx_out2)
1027     extra_idx_cr_in = property(lambda self: self.svp64.extra_idx_cr_in)
1028     extra_idx_cr_out = property(lambda self: self.svp64.extra_idx_cr_out)
1029
1030
1031 class Instruction(_Mapping):
1032     @classmethod
1033     def integer(cls, value=0, bits=None, byteorder="little"):
1034         if isinstance(value, (int, bytes)) and not isinstance(bits, int):
1035             raise ValueError(bits)
1036
1037         if isinstance(value, bytes):
1038             if ((len(value) * 8) != bits):
1039                 raise ValueError(f"bit length mismatch")
1040             value = int.from_bytes(value, byteorder=byteorder)
1041
1042         if isinstance(value, int):
1043             value = _SelectableInt(value=value, bits=bits)
1044         elif isinstance(value, Instruction):
1045             value = value.storage
1046
1047         if not isinstance(value, _SelectableInt):
1048             raise ValueError(value)
1049         if bits is None:
1050             bits = len(cls)
1051         if len(value) != bits:
1052             raise ValueError(value)
1053
1054         value = _SelectableInt(value=value, bits=bits)
1055
1056         return cls(storage=value)
1057
1058     def __hash__(self):
1059         return hash(int(self))
1060
1061     def __getitem__(self, key):
1062         return self.storage.__getitem__(key)
1063
1064     def __setitem__(self, key, value):
1065         return self.storage.__setitem__(key, value)
1066
1067     def record(self, db):
1068         record = db[self]
1069         if record is None:
1070             raise KeyError(self)
1071         return record
1072
1073     def spec(self, db, prefix):
1074         record = self.record(db=db)
1075
1076         dynamic_operands = tuple(map(_operator.itemgetter(0),
1077             self.dynamic_operands(db=db)))
1078
1079         static_operands = []
1080         for (name, value) in self.static_operands(db=db):
1081             static_operands.append(f"{name}={value}")
1082
1083         operands = ""
1084         if dynamic_operands:
1085             operands += f" {','.join(dynamic_operands)}"
1086         if static_operands:
1087             operands += f" ({' '.join(static_operands)})"
1088
1089         return f"{prefix}{record.name}{operands}"
1090
1091     def dynamic_operands(self, db, verbosity=Verbosity.NORMAL):
1092         record = self.record(db=db)
1093
1094         imm = False
1095         imm_name = ""
1096         imm_value = ""
1097         for operand in record.mdwn.operands.dynamic:
1098             name = operand.name
1099             dis = operand.disassemble(insn=self, record=record,
1100                 verbosity=min(verbosity, Verbosity.NORMAL))
1101             value = " ".join(dis)
1102             if imm:
1103                 name = f"{imm_name}({name})"
1104                 value = f"{imm_value}({value})"
1105                 imm = False
1106             if isinstance(operand, ImmediateOperand):
1107                 imm_name = name
1108                 imm_value = value
1109                 imm = True
1110             if not imm:
1111                 yield (name, value)
1112
1113     def static_operands(self, db):
1114         record = self.record(db=db)
1115         for operand in record.mdwn.operands.static:
1116             yield (operand.name, operand.value)
1117
1118     def disassemble(self, db,
1119             byteorder="little",
1120             verbosity=Verbosity.NORMAL):
1121         raise NotImplementedError
1122
1123
1124 class WordInstruction(Instruction):
1125     _: _Field = range(0, 32)
1126     po: _Field = range(0, 6)
1127
1128     @classmethod
1129     def integer(cls, value, byteorder="little"):
1130         return super().integer(bits=32, value=value, byteorder=byteorder)
1131
1132     @property
1133     def binary(self):
1134         bits = []
1135         for idx in range(32):
1136             bit = int(self[idx])
1137             bits.append(bit)
1138         return "".join(map(str, bits))
1139
1140     def disassemble(self, db,
1141             byteorder="little",
1142             verbosity=Verbosity.NORMAL):
1143         integer = int(self)
1144         if verbosity <= Verbosity.SHORT:
1145             blob = ""
1146         else:
1147             blob = integer.to_bytes(length=4, byteorder=byteorder)
1148             blob = " ".join(map(lambda byte: f"{byte:02x}", blob))
1149             blob += "    "
1150
1151         record = db[self]
1152         if record is None:
1153             yield f"{blob}.long 0x{integer:08x}"
1154             return
1155
1156         operands = tuple(map(_operator.itemgetter(1),
1157             self.dynamic_operands(db=db, verbosity=verbosity)))
1158         if operands:
1159             yield f"{blob}{record.name} {','.join(operands)}"
1160         else:
1161             yield f"{blob}{record.name}"
1162
1163         if verbosity >= Verbosity.VERBOSE:
1164             indent = (" " * 4)
1165             binary = self.binary
1166             spec = self.spec(db=db, prefix="")
1167             yield f"{indent}spec"
1168             yield f"{indent}{indent}{spec}"
1169             yield f"{indent}pcode"
1170             for stmt in record.mdwn.pcode:
1171                 yield f"{indent}{indent}{stmt}"
1172             yield f"{indent}binary"
1173             yield f"{indent}{indent}[0:8]   {binary[0:8]}"
1174             yield f"{indent}{indent}[8:16]  {binary[8:16]}"
1175             yield f"{indent}{indent}[16:24] {binary[16:24]}"
1176             yield f"{indent}{indent}[24:32] {binary[24:32]}"
1177             yield f"{indent}opcodes"
1178             for opcode in record.opcodes:
1179                 yield f"{indent}{indent}{opcode!r}"
1180             for operand in record.mdwn.operands:
1181                 yield from operand.disassemble(insn=self, record=record,
1182                     verbosity=verbosity, indent=indent)
1183             yield ""
1184
1185
1186 class PrefixedInstruction(Instruction):
1187     class Prefix(WordInstruction.remap(range(0, 32))):
1188         pass
1189
1190     class Suffix(WordInstruction.remap(range(32, 64))):
1191         pass
1192
1193     _: _Field = range(64)
1194     prefix: Prefix
1195     suffix: Suffix
1196     po: Suffix.po
1197
1198     @classmethod
1199     def integer(cls, value, byteorder="little"):
1200         return super().integer(bits=64, value=value, byteorder=byteorder)
1201
1202     @classmethod
1203     def pair(cls, prefix=0, suffix=0, byteorder="little"):
1204         def transform(value):
1205             return WordInstruction.integer(value=value,
1206                 byteorder=byteorder)[0:32]
1207
1208         (prefix, suffix) = map(transform, (prefix, suffix))
1209         value = _selectconcat(prefix, suffix)
1210
1211         return super().integer(value=value)
1212
1213
1214 class Mode(_Mapping):
1215     _: _Field = range(0, 5)
1216
1217
1218 class Extra(_Mapping):
1219     _: _Field = range(0, 9)
1220
1221
1222 class Extra2(Extra):
1223     idx0: _Field = range(0, 2)
1224     idx1: _Field = range(2, 4)
1225     idx2: _Field = range(4, 6)
1226     idx3: _Field = range(6, 8)
1227
1228     def __getitem__(self, key):
1229         return {
1230             0: self.idx0,
1231             1: self.idx1,
1232             2: self.idx2,
1233             3: self.idx3,
1234             _SVExtra.Idx0: self.idx0,
1235             _SVExtra.Idx1: self.idx1,
1236             _SVExtra.Idx2: self.idx2,
1237             _SVExtra.Idx3: self.idx3,
1238         }[key]
1239
1240     def __setitem__(self, key, value):
1241         self[key].assign(value)
1242
1243
1244 class Extra3(Extra):
1245     idx0: _Field = range(0, 3)
1246     idx1: _Field = range(3, 6)
1247     idx2: _Field = range(6, 9)
1248
1249     def __getitem__(self, key):
1250         return {
1251             0: self.idx0,
1252             1: self.idx1,
1253             2: self.idx2,
1254             _SVExtra.Idx0: self.idx0,
1255             _SVExtra.Idx1: self.idx1,
1256             _SVExtra.Idx2: self.idx2,
1257         }[key]
1258
1259     def __setitem__(self, key, value):
1260         self[key].assign(value)
1261
1262
1263 class BaseRM(_Mapping):
1264     _: _Field = range(24)
1265     mmode: _Field = (0,)
1266     mask: _Field = range(1, 4)
1267     elwidth: _Field = range(4, 6)
1268     ewsrc: _Field = range(6, 8)
1269     subvl: _Field = range(8, 10)
1270     mode: Mode.remap(range(19, 24))
1271     smask: _Field = range(16, 19)
1272
1273     extra: Extra.remap(range(10, 19))
1274     extra2: Extra2.remap(range(10, 19))
1275     extra3: Extra3.remap(range(10, 19))
1276
1277
1278 class NormalRM(BaseRM):
1279     class simple(BaseRM):
1280         """simple mode"""
1281         dz: BaseRM.mode[3]
1282         sz: BaseRM.mode[4]
1283
1284     class smr(Mode):
1285         """scalar reduce mode (mapreduce), SUBVL=1"""
1286         RG: BaseRM.mode[4]
1287
1288     class pmr(Mode):
1289         """parallel reduce mode (mapreduce), SUBVL=1"""
1290         pass
1291
1292     class svmr(Mode):
1293         """subvector reduce mode, SUBVL>1"""
1294         SVM: BaseRM.mode[3]
1295
1296     class pu(Mode):
1297         """Pack/Unpack mode, SUBVL>1"""
1298         SVM: BaseRM.mode[3]
1299
1300     class ffrc1(Mode):
1301         """Rc=1: ffirst CR sel"""
1302         inv: BaseRM.mode[2]
1303         CR: BaseRM.mode[3, 4]
1304
1305     class ffrc0(Mode):
1306         """Rc=0: ffirst z/nonz"""
1307         inv: BaseRM.mode[2]
1308         VLi: BaseRM.mode[3]
1309         RC1: BaseRM.mode[4]
1310
1311     class sat(Mode):
1312         """sat mode: N=0/1 u/s, SUBVL=1"""
1313         N: BaseRM.mode[2]
1314         dz: BaseRM.mode[3]
1315         sz: BaseRM.mode[4]
1316
1317     class satx(Mode):
1318         """sat mode: N=0/1 u/s, SUBVL>1"""
1319         N: BaseRM.mode[2]
1320         zz: BaseRM.mode[3]
1321         dz: BaseRM.mode[3]
1322         sz: BaseRM.mode[3]
1323
1324     class satpu(Mode):
1325         """Pack/Unpack sat mode: N=0/1 u/s, SUBVL>1"""
1326         N: BaseRM.mode[2]
1327         zz: BaseRM.mode[3]
1328         dz: BaseRM.mode[3]
1329         sz: BaseRM.mode[3]
1330
1331     class prrc1(Mode):
1332         """Rc=1: pred-result CR sel"""
1333         inv: BaseRM.mode[2]
1334         CR: BaseRM.mode[3, 4]
1335
1336     class prrc0(Mode):
1337         """Rc=0: pred-result z/nonz"""
1338         inv: BaseRM.mode[2]
1339         zz: BaseRM.mode[3]
1340         RC1: BaseRM.mode[4]
1341         dz: BaseRM.mode[3]
1342         sz: BaseRM.mode[3]
1343
1344     simple: simple
1345     smr: smr
1346     pmr: pmr
1347     svmr: svmr
1348     pu: pu
1349     ffrc1: ffrc1
1350     ffrc0: ffrc0
1351     sat: sat
1352     satx: satx
1353     satpu: satpu
1354     prrc1: prrc1
1355     prrc0: prrc0
1356
1357
1358 class LDSTImmRM(BaseRM):
1359     class simple(Mode):
1360         """simple mode"""
1361         zz: BaseRM.mode[3]
1362         els: BaseRM.mode[4]
1363         dz: BaseRM.mode[3]
1364         sz: BaseRM.mode[3]
1365
1366     class spu(Mode):
1367         """Structured Pack/Unpack"""
1368         zz: BaseRM.mode[3]
1369         els: BaseRM.mode[4]
1370         dz: BaseRM.mode[3]
1371         sz: BaseRM.mode[3]
1372
1373     class ffrc1(Mode):
1374         """Rc=1: ffirst CR sel"""
1375         inv: BaseRM.mode[2]
1376         CR: BaseRM.mode[3, 4]
1377
1378     class ffrc0(Mode):
1379         """Rc=0: ffirst z/nonz"""
1380         inv: BaseRM.mode[2]
1381         els: BaseRM.mode[3]
1382         RC1: BaseRM.mode[4]
1383
1384     class sat(Mode):
1385         """sat mode: N=0/1 u/s"""
1386         N: BaseRM.mode[2]
1387         zz: BaseRM.mode[3]
1388         els: BaseRM.mode[4]
1389         dz: BaseRM.mode[3]
1390         sz: BaseRM.mode[3]
1391
1392     class prrc1(Mode):
1393         """Rc=1: pred-result CR sel"""
1394         inv: BaseRM.mode[2]
1395         CR: BaseRM.mode[3, 4]
1396
1397     class prrc0(Mode):
1398         """Rc=0: pred-result z/nonz"""
1399         inv: BaseRM.mode[2]
1400         els: BaseRM.mode[3]
1401         RC1: BaseRM.mode[4]
1402
1403     simple: simple
1404     spu: spu
1405     ffrc1: ffrc1
1406     ffrc0: ffrc0
1407     sat: sat
1408     prrc1: prrc1
1409     prrc0: prrc0
1410
1411
1412 class LDSTIdxRM(BaseRM):
1413     class simple(Mode):
1414         """simple mode"""
1415         SEA: BaseRM.mode[2]
1416         sz: BaseRM.mode[3]
1417         dz: BaseRM.mode[3]
1418
1419     class stride(Mode):
1420         """strided (scalar only source)"""
1421         SEA: BaseRM.mode[2]
1422         dz: BaseRM.mode[3]
1423         sz: BaseRM.mode[4]
1424
1425     class sat(Mode):
1426         """sat mode: N=0/1 u/s"""
1427         N: BaseRM.mode[2]
1428         dz: BaseRM.mode[3]
1429         sz: BaseRM.mode[4]
1430
1431     class prrc1(Mode):
1432         """Rc=1: pred-result CR sel"""
1433         inv: BaseRM.mode[2]
1434         CR: BaseRM.mode[3, 4]
1435
1436     class prrc0(Mode):
1437         """Rc=0: pred-result z/nonz"""
1438         inv: BaseRM.mode[2]
1439         zz: BaseRM.mode[3]
1440         RC1: BaseRM.mode[4]
1441         dz: BaseRM.mode[3]
1442         sz: BaseRM.mode[3]
1443
1444     simple: simple
1445     stride: stride
1446     sat: sat
1447     prrc1: prrc1
1448     prrc0: prrc0
1449
1450
1451 class CROpRM(BaseRM):
1452     class simple(BaseRM):
1453         """simple mode"""
1454         sz: BaseRM[6]
1455         SNZ: BaseRM[7]
1456         RG: BaseRM[20]
1457         dz: BaseRM[22]
1458
1459     class smr(BaseRM):
1460         """scalar reduce mode (mapreduce), SUBVL=1"""
1461         sz: BaseRM[6]
1462         SNZ: BaseRM[7]
1463         RG: BaseRM[20]
1464
1465     class svmr(BaseRM):
1466         """subvector reduce mode, SUBVL>1"""
1467         zz: BaseRM[6]
1468         SNZ: BaseRM[7]
1469         RG: BaseRM[20]
1470         SVM: BaseRM[22]
1471         dz: BaseRM[6]
1472         sz: BaseRM[6]
1473
1474     class reserved(BaseRM):
1475         """reserved"""
1476         zz: BaseRM[6]
1477         SNZ: BaseRM[7]
1478         RG: BaseRM[20]
1479         dz: BaseRM[6]
1480         sz: BaseRM[6]
1481
1482     class ff3(BaseRM):
1483         """ffirst 3-bit mode"""
1484         zz: BaseRM[6]
1485         SNZ: BaseRM[7]
1486         VLI: BaseRM[20]
1487         inv: BaseRM[21]
1488         CR: BaseRM[22, 23]
1489         dz: BaseRM[6]
1490         sz: BaseRM[6]
1491
1492     class ff5(BaseRM):
1493         """ffirst 5-bit mode"""
1494         zz: BaseRM[6]
1495         SNZ: BaseRM[7]
1496         VLI: BaseRM[20]
1497         inv: BaseRM[21]
1498         dz: BaseRM[22]
1499         dz: BaseRM[6]
1500         sz: BaseRM[6]
1501
1502     simple: simple
1503     smr: smr
1504     svmr: svmr
1505     reserved: reserved
1506     ff3: ff3
1507     ff5: ff5
1508
1509
1510 class BranchBaseRM(BaseRM):
1511     ALL: BaseRM[4]
1512     SNZ: BaseRM[5]
1513     SL: BaseRM[17]
1514     SLu: BaseRM[18]
1515     LRu: BaseRM[22]
1516     sz: BaseRM[23]
1517
1518
1519 class BranchRM(BranchBaseRM):
1520     class simple(BranchBaseRM):
1521         """simple mode"""
1522         pass
1523
1524     class vls(BranchBaseRM):
1525         """VLSET mode"""
1526         VSb: BaseRM[7]
1527         VLI: BaseRM[21]
1528
1529     class ctr(BranchBaseRM):
1530         """CTR-test mode"""
1531         CTi: BaseRM[6]
1532
1533     class ctrvls(vls, ctr):
1534         """CTR-test+VLSET mode"""
1535         pass
1536
1537
1538 class RM(BaseRM):
1539     normal: NormalRM
1540     ldst_imm: LDSTImmRM
1541     ldst_idx: LDSTIdxRM
1542     cr_op: CROpRM
1543
1544
1545 class SVP64Instruction(PrefixedInstruction):
1546     """SVP64 instruction: https://libre-soc.org/openpower/sv/svp64/"""
1547     class Prefix(PrefixedInstruction.Prefix):
1548         id: _Field = (7, 9)
1549         rm: RM.remap((6, 8) + tuple(range(10, 32)))
1550
1551     prefix: Prefix
1552
1553     def record(self, db):
1554         record = db[self.suffix]
1555         if record is None:
1556             raise KeyError(self)
1557         return record
1558
1559     @property
1560     def binary(self):
1561         bits = []
1562         for idx in range(64):
1563             bit = int(self[idx])
1564             bits.append(bit)
1565         return "".join(map(str, bits))
1566
1567     def rm(self, db):
1568         record = self.record(db=db)
1569
1570         Rc = False
1571         if record.mdwn.operands["Rc"] is not None:
1572             Rc = bool(self[record.fields["Rc"]])
1573
1574         record = self.record(db=db)
1575         subvl = self.prefix.rm.subvl
1576         rm = self.prefix.rm
1577
1578         if record.svp64.mode is _SVMode.NORMAL:
1579             rm = rm.normal
1580             if rm.mode[0:2] == 0b00:
1581                 if rm.mode[2] == 0b0:
1582                     rm = rm.simple
1583                 else:
1584                     if subvl == 0b00:
1585                         if rm.mode[3] == 0b0:
1586                             rm = rm.smr
1587                         else:
1588                             rm = rm.pmr
1589                     else:
1590                         if rm.mode[4] == 0b0:
1591                             rm = rm.svmr
1592                         else:
1593                             rm = rm.pu
1594             elif rm.mode[0:2] == 0b01:
1595                 if Rc:
1596                     rm = rm.ffrc1
1597                 else:
1598                     rm = rm.ffrc0
1599             elif rm.mode[0:2] == 0b10:
1600                 if subvl == 0b00:
1601                     rm = rm.sat
1602                 else:
1603                     if rm.mode[4]:
1604                         rm = rm.satx
1605                     else:
1606                         rm = rm.satpu
1607             elif rm.mode[0:2] == 0b11:
1608                 if Rc:
1609                     rm = rm.prrc1
1610                 else:
1611                     rm = rm.prrc0
1612
1613         elif record.svp64.mode is _SVMode.LDST_IMM:
1614             rm = rm.ldst_imm
1615             if rm.mode[0:2] == 0b00:
1616                 if rm.mode[2] == 0b0:
1617                     rm = rm.simple
1618                 else:
1619                     rm = rm.spu
1620             elif rm.mode[0:2] == 0b01:
1621                 if Rc:
1622                     rm = rm.ffrc1
1623                 else:
1624                     rm = rm.ffrc0
1625             elif rm.mode[0:2] == 0b10:
1626                 rm = rm.sat
1627             elif rm.mode[0:2] == 0b11:
1628                 if Rc:
1629                     rm = rm.prrc1
1630                 else:
1631                     rm = rm.prrc0
1632
1633         elif record.svp64.mode is _SVMode.LDST_IMM:
1634             rm = rm.ldst_idx
1635             if rm.mode[0:2] == 0b00:
1636                 rm = rm.simple
1637             elif rm.mode[0:2] == 0b01:
1638                 rm = rm.stride
1639             elif rm.mode[0:2] == 0b10:
1640                 rm = rm.sat
1641             elif rm.mode[0:2] == 0b11:
1642                 if Rc:
1643                     rm = rm.prrc1
1644                 else:
1645                     rm = rm.prrc0
1646
1647         elif record.svp64.mode is _SVMode.CROP:
1648             rm = rm.cr_op
1649             if rm[19] == 0b0:
1650                 if rm[21] == 0b0:
1651                     rm = rm.simple
1652                 else:
1653                     if subvl == 0:
1654                         rm = rm.smr
1655                     else:
1656                         if rm[23] == 0b0:
1657                             rm = rm.svmr
1658                         else:
1659                             rm = rm.reserved
1660             else:
1661                 regtype = None
1662                 for idx in range(0, 4):
1663                     for entry in record.svp64.extra[idx]:
1664                         if entry.regtype is _SVExtraRegType.DST:
1665                             if regtype is not None:
1666                                 raise ValueError(record.svp64)
1667                             regtype = _RegType(entry.reg)
1668                 if regtype is _RegType.CR_REG:
1669                     rm = rm.ff5
1670                 elif regtype is _RegType.CR_BIT:
1671                     rm = rm.ff3
1672                 else:
1673                     raise ValueError(record.svp64)
1674
1675         elif record.svp64.mode is _SVMode.BRANCH:
1676             if rm[19] == 0b0:
1677                 if rm[20] == 0b0:
1678                     rm = rm.simple
1679                 else:
1680                     rm = rm.vls
1681             else:
1682                 if rm[20] == 0b0:
1683                     rm = rm.ctr
1684                 else:
1685                     rm = rm.ctrvls
1686
1687         else:
1688             raise ValueError(self)
1689
1690         table = {
1691             NormalRM.simple: "normal: simple",
1692             NormalRM.smr: "normal: smr",
1693             NormalRM.pmr: "normal: pmr",
1694             NormalRM.svmr: "normal: svmr",
1695             NormalRM.pu: "normal: pu",
1696             NormalRM.ffrc1: "normal: ffrc1",
1697             NormalRM.ffrc0: "normal: ffrc0",
1698             NormalRM.sat: "normal: sat",
1699             NormalRM.satx: "normal: satx",
1700             NormalRM.satpu: "normal: satpu",
1701             NormalRM.prrc1: "normal: prrc1",
1702             NormalRM.prrc0: "normal: prrc0",
1703             LDSTImmRM.simple: "ld/st imm: simple",
1704             LDSTImmRM.spu: "ld/st imm: spu",
1705             LDSTImmRM.ffrc1: "ld/st imm: ffrc1",
1706             LDSTImmRM.ffrc0: "ld/st imm: ffrc0",
1707             LDSTImmRM.sat: "ld/st imm: sat",
1708             LDSTImmRM.prrc1: "ld/st imm: prrc1",
1709             LDSTImmRM.prrc0: "ld/st imm: prrc0",
1710             LDSTIdxRM.simple: "ld/st idx: simple",
1711             LDSTIdxRM.stride: "ld/st idx: stride",
1712             LDSTIdxRM.sat: "ld/st idx: sat",
1713             LDSTIdxRM.prrc1: "ld/st idx: prrc1",
1714             LDSTIdxRM.prrc0: "ld/st idx: prrc0",
1715             CROpRM.simple: "simple mode",
1716             CROpRM.smr: "scalar reduce mode (mapreduce), SUBVL=1",
1717             CROpRM.svmr: "subvector reduce mode, SUBVL>1",
1718             CROpRM.reserved: "reserved",
1719             CROpRM.ff3: "ffirst 3-bit mode",
1720             CROpRM.ff5: "ffirst 5-bit mode",
1721             BranchRM.simple: "simple mode",
1722             BranchRM.vls: "VLSET mode",
1723             BranchRM.ctr: "CTR-test mode",
1724             BranchRM.ctrvls: "CTR-test+VLSET mode",
1725         }
1726         for (cls, desc) in table.items():
1727             if isinstance(rm, cls):
1728                 return (rm, desc)
1729
1730         raise ValueError(self)
1731
1732     def disassemble(self, db,
1733             byteorder="little",
1734             verbosity=Verbosity.NORMAL):
1735         def blob(integer):
1736             if verbosity <= Verbosity.SHORT:
1737                 return ""
1738             else:
1739                 blob = integer.to_bytes(length=4, byteorder=byteorder)
1740                 blob = " ".join(map(lambda byte: f"{byte:02x}", blob))
1741                 return f"{blob}    "
1742
1743         blob_prefix = blob(int(self.prefix))
1744         blob_suffix = blob(int(self.suffix))
1745         record = db[self]
1746         if record is None or record.svp64 is None:
1747             yield f"{blob_prefix}.long 0x{int(self.prefix):08x}"
1748             yield f"{blob_suffix}.long 0x{int(self.suffix):08x}"
1749             return
1750
1751         operands = tuple(map(_operator.itemgetter(1),
1752             self.dynamic_operands(db=db, verbosity=verbosity)))
1753         if operands:
1754             yield f"{blob_prefix}sv.{record.name} {','.join(operands)}"
1755         else:
1756             yield f"{blob_prefix}{record.name}"
1757         if blob_suffix:
1758             yield f"{blob_suffix}"
1759
1760         (rm, rm_desc) = self.rm(db=db)
1761
1762         if verbosity >= Verbosity.VERBOSE:
1763             indent = (" " * 4)
1764             binary = self.binary
1765             spec = self.spec(db=db, prefix="sv.")
1766             yield f"{indent}spec"
1767             yield f"{indent}{indent}{spec}"
1768             yield f"{indent}pcode"
1769             for stmt in record.mdwn.pcode:
1770                 yield f"{indent}{indent}{stmt}"
1771             yield f"{indent}binary"
1772             yield f"{indent}{indent}[0:8]   {binary[0:8]}"
1773             yield f"{indent}{indent}[8:16]  {binary[8:16]}"
1774             yield f"{indent}{indent}[16:24] {binary[16:24]}"
1775             yield f"{indent}{indent}[24:32] {binary[24:32]}"
1776             yield f"{indent}{indent}[32:40] {binary[32:40]}"
1777             yield f"{indent}{indent}[40:48] {binary[40:48]}"
1778             yield f"{indent}{indent}[48:56] {binary[48:56]}"
1779             yield f"{indent}{indent}[56:64] {binary[56:64]}"
1780             yield f"{indent}opcodes"
1781             for opcode in record.opcodes:
1782                 yield f"{indent}{indent}{opcode!r}"
1783             for operand in record.mdwn.operands:
1784                 yield from operand.disassemble(insn=self, record=record,
1785                     verbosity=verbosity, indent=indent)
1786
1787             yield f"{indent}RM"
1788             yield f"{indent}{indent}{rm_desc}"
1789             yield ""
1790
1791
1792 def parse(stream, factory):
1793     def match(entry):
1794         return ("TODO" not in frozenset(entry.values()))
1795
1796     lines = filter(lambda line: not line.strip().startswith("#"), stream)
1797     entries = _csv.DictReader(lines)
1798     entries = filter(match, entries)
1799     return tuple(map(factory, entries))
1800
1801
1802 class MarkdownDatabase:
1803     def __init__(self):
1804         db = {}
1805         for (name, desc) in _ISA():
1806             operands = []
1807             if desc.regs:
1808                 (dynamic, *static) = desc.regs
1809                 operands.extend(dynamic)
1810                 operands.extend(static)
1811             pcode = PCode(iterable=desc.pcode)
1812             operands = Operands(insn=name, iterable=operands)
1813             db[name] = MarkdownRecord(pcode=pcode, operands=operands)
1814
1815         self.__db = db
1816
1817         return super().__init__()
1818
1819     def __iter__(self):
1820         yield from self.__db.items()
1821
1822     def __getitem__(self, key):
1823         return self.__db.__getitem__(key)
1824
1825
1826 class FieldsDatabase:
1827     def __init__(self):
1828         db = {}
1829         df = _DecodeFields()
1830         df.create_specs()
1831         for (form, fields) in df.instrs.items():
1832             if form in {"DQE", "TX"}:
1833                 continue
1834             if form == "all":
1835                 form = "NONE"
1836             db[_Form[form]] = Fields(fields)
1837
1838         self.__db = db
1839
1840         return super().__init__()
1841
1842     def __getitem__(self, key):
1843         return self.__db.__getitem__(key)
1844
1845
1846 class PPCDatabase:
1847     def __init__(self, root, mdwndb):
1848         # The code below groups the instructions by section:identifier.
1849         # We use the comment as an identifier, there's nothing better.
1850         # The point is to capture different opcodes for the same instruction.
1851         dd = _collections.defaultdict
1852         records = dd(lambda: dd(set))
1853         path = (root / "insndb.csv")
1854         with open(path, "r", encoding="UTF-8") as stream:
1855             for section in parse(stream, Section.CSV):
1856                 path = (root / section.path)
1857                 opcode_cls = {
1858                     section.Mode.INTEGER: IntegerOpcode,
1859                     section.Mode.PATTERN: PatternOpcode,
1860                 }[section.mode]
1861                 factory = _functools.partial(
1862                     PPCRecord.CSV, opcode_cls=opcode_cls)
1863                 with open(path, "r", encoding="UTF-8") as stream:
1864                     for insn in parse(stream, factory):
1865                         records[section][insn.comment].add(insn)
1866
1867         db = dd(set)
1868         for (section, group) in records.items():
1869             for records in group.values():
1870                 db[section].add(PPCMultiRecord(records))
1871
1872         self.__db = db
1873         self.__mdwndb = mdwndb
1874
1875         return super().__init__()
1876
1877     def __getitem__(self, key):
1878         def exact_match(key, record):
1879             return (key in record.names)
1880
1881         def Rc_match(key, record):
1882             if not key.endswith("."):
1883                 return False
1884
1885             if record.Rc is _RCOE.NONE:
1886                 return False
1887
1888             return exact_match(key[:-1], record)
1889
1890         def LK_match(key, record):
1891             if not key.endswith("l"):
1892                 return False
1893
1894             if "lk" not in record.flags:
1895                 return False
1896
1897             return exact_match(key[:-1], record)
1898
1899         def AA_match(key, record):
1900             if not key.endswith("a"):
1901                 return False
1902
1903             if record.intop not in {_MicrOp.OP_B, _MicrOp.OP_BC}:
1904                 return False
1905
1906             if self.__mdwndb[key].operands["AA"] is None:
1907                 return False
1908
1909             return (exact_match(key[:-1], record) or
1910                 LK_match(key[:-1], record))
1911
1912         for (section, records) in self.__db.items():
1913             for record in records:
1914                 if exact_match(key, record):
1915                     return (section, record)
1916
1917             for record in records:
1918                 if (Rc_match(key, record) or
1919                         LK_match(key, record) or
1920                         AA_match(key, record)):
1921                     return (section, record)
1922
1923         return (None, None)
1924
1925
1926 class SVP64Database:
1927     def __init__(self, root, ppcdb):
1928         db = set()
1929         pattern = _re.compile(r"^(?:LDST)?RM-(1P|2P)-.*?\.csv$")
1930         for (prefix, _, names) in _os.walk(root):
1931             prefix = _pathlib.Path(prefix)
1932             for name in filter(lambda name: pattern.match(name), names):
1933                 path = (prefix / _pathlib.Path(name))
1934                 with open(path, "r", encoding="UTF-8") as stream:
1935                     db.update(parse(stream, SVP64Record.CSV))
1936
1937         self.__db = {record.name:record for record in db}
1938         self.__ppcdb = ppcdb
1939
1940         return super().__init__()
1941
1942     def __getitem__(self, key):
1943         (_, record) = self.__ppcdb[key]
1944         if record is None:
1945             return None
1946
1947         for name in record.names:
1948             record = self.__db.get(name, None)
1949             if record is not None:
1950                 return record
1951
1952         return None
1953
1954
1955 class Database:
1956     def __init__(self, root):
1957         root = _pathlib.Path(root)
1958         mdwndb = MarkdownDatabase()
1959         fieldsdb = FieldsDatabase()
1960         ppcdb = PPCDatabase(root=root, mdwndb=mdwndb)
1961         svp64db = SVP64Database(root=root, ppcdb=ppcdb)
1962
1963         db = set()
1964         names = {}
1965         opcodes = _collections.defaultdict(set)
1966
1967         for (name, mdwn) in mdwndb:
1968             (section, ppc) = ppcdb[name]
1969             if ppc is None:
1970                 continue
1971             svp64 = svp64db[name]
1972             fields = fieldsdb[ppc.form]
1973             record = Record(name=name,
1974                 section=section, ppc=ppc, svp64=svp64,
1975                 mdwn=mdwn, fields=fields)
1976             db.add(record)
1977             names[record.name] = record
1978             PO = section.opcode
1979             if PO is None:
1980                 PO = ppc[0].opcode
1981             opcodes[PO.value].add(record)
1982
1983         self.__db = db
1984         self.__names = names
1985         self.__opcodes = opcodes
1986
1987         return super().__init__()
1988
1989     def __repr__(self):
1990         return repr(self.__db)
1991
1992     def __iter__(self):
1993         yield from self.__db
1994
1995     @_functools.lru_cache(maxsize=None)
1996     def __contains__(self, key):
1997         return self.__getitem__(key) is not None
1998
1999     @_functools.lru_cache(maxsize=None)
2000     def __getitem__(self, key):
2001         if isinstance(key, (int, Instruction)):
2002             key = int(key)
2003             XO = int(_SelectableInt(value=int(key), bits=32)[0:6])
2004             for record in self.__opcodes[XO]:
2005                 if record.match(key=key):
2006                    return record
2007
2008         elif isinstance(key, str):
2009             return self.__names[key]
2010
2011         return None