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(SignedOperand):
 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 operand in custom_fields:
 866                     dynamic_cls = custom_fields[operand]
 867                 if insn in custom_insns and operand in custom_insns[insn]:
 868                     dynamic_cls = custom_insns[insn][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 bytes(self, byteorder="little"):
1068         nr_bytes = (self.storage.bits // 8)
1069         return int(self).to_bytes(nr_bytes, byteorder=byteorder)
1070
1071     def record(self, db):
1072         record = db[self]
1073         if record is None:
1074             raise KeyError(self)
1075         return record
1076
1077     def spec(self, db, prefix):
1078         record = self.record(db=db)
1079
1080         dynamic_operands = tuple(map(_operator.itemgetter(0),
1081             self.dynamic_operands(db=db)))
1082
1083         static_operands = []
1084         for (name, value) in self.static_operands(db=db):
1085             static_operands.append(f"{name}={value}")
1086
1087         operands = ""
1088         if dynamic_operands:
1089             operands += f" {','.join(dynamic_operands)}"
1090         if static_operands:
1091             operands += f" ({' '.join(static_operands)})"
1092
1093         return f"{prefix}{record.name}{operands}"
1094
1095     def dynamic_operands(self, db, verbosity=Verbosity.NORMAL):
1096         record = self.record(db=db)
1097
1098         imm = False
1099         imm_name = ""
1100         imm_value = ""
1101         for operand in record.mdwn.operands.dynamic:
1102             name = operand.name
1103             dis = operand.disassemble(insn=self, record=record,
1104                 verbosity=min(verbosity, Verbosity.NORMAL))
1105             value = " ".join(dis)
1106             if imm:
1107                 name = f"{imm_name}({name})"
1108                 value = f"{imm_value}({value})"
1109                 imm = False
1110             if isinstance(operand, ImmediateOperand):
1111                 imm_name = name
1112                 imm_value = value
1113                 imm = True
1114             if not imm:
1115                 yield (name, value)
1116
1117     def static_operands(self, db):
1118         record = self.record(db=db)
1119         for operand in record.mdwn.operands.static:
1120             yield (operand.name, operand.value)
1121
1122     def disassemble(self, db,
1123             byteorder="little",
1124             verbosity=Verbosity.NORMAL):
1125         raise NotImplementedError
1126
1127
1128 class WordInstruction(Instruction):
1129     _: _Field = range(0, 32)
1130     po: _Field = range(0, 6)
1131
1132     @classmethod
1133     def integer(cls, value, byteorder="little"):
1134         return super().integer(bits=32, value=value, byteorder=byteorder)
1135
1136     @property
1137     def binary(self):
1138         bits = []
1139         for idx in range(32):
1140             bit = int(self[idx])
1141             bits.append(bit)
1142         return "".join(map(str, bits))
1143
1144     def disassemble(self, db,
1145             byteorder="little",
1146             verbosity=Verbosity.NORMAL):
1147         integer = int(self)
1148         if verbosity <= Verbosity.SHORT:
1149             blob = ""
1150         else:
1151             blob = integer.to_bytes(length=4, byteorder=byteorder)
1152             blob = " ".join(map(lambda byte: f"{byte:02x}", blob))
1153             blob += "    "
1154
1155         record = db[self]
1156         if record is None:
1157             yield f"{blob}.long 0x{integer:08x}"
1158             return
1159
1160         operands = tuple(map(_operator.itemgetter(1),
1161             self.dynamic_operands(db=db, verbosity=verbosity)))
1162         if operands:
1163             yield f"{blob}{record.name} {','.join(operands)}"
1164         else:
1165             yield f"{blob}{record.name}"
1166
1167         if verbosity >= Verbosity.VERBOSE:
1168             indent = (" " * 4)
1169             binary = self.binary
1170             spec = self.spec(db=db, prefix="")
1171             yield f"{indent}spec"
1172             yield f"{indent}{indent}{spec}"
1173             yield f"{indent}pcode"
1174             for stmt in record.mdwn.pcode:
1175                 yield f"{indent}{indent}{stmt}"
1176             yield f"{indent}binary"
1177             yield f"{indent}{indent}[0:8]   {binary[0:8]}"
1178             yield f"{indent}{indent}[8:16]  {binary[8:16]}"
1179             yield f"{indent}{indent}[16:24] {binary[16:24]}"
1180             yield f"{indent}{indent}[24:32] {binary[24:32]}"
1181             yield f"{indent}opcodes"
1182             for opcode in record.opcodes:
1183                 yield f"{indent}{indent}{opcode!r}"
1184             for operand in record.mdwn.operands:
1185                 yield from operand.disassemble(insn=self, record=record,
1186                     verbosity=verbosity, indent=indent)
1187             yield ""
1188
1189
1190 class PrefixedInstruction(Instruction):
1191     class Prefix(WordInstruction.remap(range(0, 32))):
1192         pass
1193
1194     class Suffix(WordInstruction.remap(range(32, 64))):
1195         pass
1196
1197     _: _Field = range(64)
1198     prefix: Prefix
1199     suffix: Suffix
1200     po: Suffix.po
1201
1202     @classmethod
1203     def integer(cls, value, byteorder="little"):
1204         return super().integer(bits=64, value=value, byteorder=byteorder)
1205
1206     @classmethod
1207     def pair(cls, prefix=0, suffix=0, byteorder="little"):
1208         def transform(value):
1209             return WordInstruction.integer(value=value,
1210                 byteorder=byteorder)[0:32]
1211
1212         (prefix, suffix) = map(transform, (prefix, suffix))
1213         value = _selectconcat(prefix, suffix)
1214
1215         return super().integer(bits=64, value=value)
1216
1217
1218 class Mode(_Mapping):
1219     _: _Field = range(0, 5)
1220
1221
1222 class Extra(_Mapping):
1223     _: _Field = range(0, 9)
1224
1225
1226 class Extra2(Extra):
1227     idx0: _Field = range(0, 2)
1228     idx1: _Field = range(2, 4)
1229     idx2: _Field = range(4, 6)
1230     idx3: _Field = range(6, 8)
1231
1232     def __getitem__(self, key):
1233         return {
1234             0: self.idx0,
1235             1: self.idx1,
1236             2: self.idx2,
1237             3: self.idx3,
1238             _SVExtra.Idx0: self.idx0,
1239             _SVExtra.Idx1: self.idx1,
1240             _SVExtra.Idx2: self.idx2,
1241             _SVExtra.Idx3: self.idx3,
1242         }[key]
1243
1244     def __setitem__(self, key, value):
1245         self[key].assign(value)
1246
1247
1248 class Extra3(Extra):
1249     idx0: _Field = range(0, 3)
1250     idx1: _Field = range(3, 6)
1251     idx2: _Field = range(6, 9)
1252
1253     def __getitem__(self, key):
1254         return {
1255             0: self.idx0,
1256             1: self.idx1,
1257             2: self.idx2,
1258             _SVExtra.Idx0: self.idx0,
1259             _SVExtra.Idx1: self.idx1,
1260             _SVExtra.Idx2: self.idx2,
1261         }[key]
1262
1263     def __setitem__(self, key, value):
1264         self[key].assign(value)
1265
1266
1267 class BaseRM(_Mapping):
1268     _: _Field = range(24)
1269     mmode: _Field = (0,)
1270     mask: _Field = range(1, 4)
1271     elwidth: _Field = range(4, 6)
1272     ewsrc: _Field = range(6, 8)
1273     subvl: _Field = range(8, 10)
1274     mode: Mode.remap(range(19, 24))
1275     smask: _Field = range(16, 19)
1276
1277     extra: Extra.remap(range(10, 19))
1278     extra2: Extra2.remap(range(10, 19))
1279     extra3: Extra3.remap(range(10, 19))
1280
1281     def disassemble(self, verbosity=Verbosity.NORMAL):
1282         if verbosity >= Verbosity.VERBOSE:
1283             indent = (" " * 4)
1284             for (name, value, members) in self.traverse(path="RM"):
1285                 yield f"{name}"
1286                 yield f"{indent}{int(value):0{value.bits}b}"
1287                 yield f"{indent}{', '.join(map(str, members))}"
1288
1289
1290 class NormalRM(BaseRM):
1291     class simple(BaseRM):
1292         """normal: simple mode"""
1293         dz: BaseRM.mode[3]
1294         sz: BaseRM.mode[4]
1295
1296     class smr(BaseRM):
1297         """normal: scalar reduce mode (mapreduce), SUBVL=1"""
1298         RG: BaseRM.mode[4]
1299
1300     class pmr(BaseRM):
1301         """normal: parallel reduce mode (mapreduce), SUBVL=1"""
1302         pass
1303
1304     class svmr(BaseRM):
1305         """normal: subvector reduce mode, SUBVL>1"""
1306         SVM: BaseRM.mode[3]
1307
1308     class pu(BaseRM):
1309         """normal: Pack/Unpack mode, SUBVL>1"""
1310         SVM: BaseRM.mode[3]
1311
1312     class ffrc1(BaseRM):
1313         """normal: Rc=1: ffirst CR sel"""
1314         inv: BaseRM.mode[2]
1315         CR: BaseRM.mode[3, 4]
1316
1317     class ffrc0(BaseRM):
1318         """normal: Rc=0: ffirst z/nonz"""
1319         inv: BaseRM.mode[2]
1320         VLi: BaseRM.mode[3]
1321         RC1: BaseRM.mode[4]
1322
1323     class sat(BaseRM):
1324         """normal: sat mode: N=0/1 u/s, SUBVL=1"""
1325         N: BaseRM.mode[2]
1326         dz: BaseRM.mode[3]
1327         sz: BaseRM.mode[4]
1328
1329     class satx(BaseRM):
1330         """normal: sat mode: N=0/1 u/s, SUBVL>1"""
1331         N: BaseRM.mode[2]
1332         zz: BaseRM.mode[3]
1333         dz: BaseRM.mode[3]
1334         sz: BaseRM.mode[3]
1335
1336     class satpu(BaseRM):
1337         """normal: Pack/Unpack sat mode: N=0/1 u/s, SUBVL>1"""
1338         N: BaseRM.mode[2]
1339         zz: BaseRM.mode[3]
1340         dz: BaseRM.mode[3]
1341         sz: BaseRM.mode[3]
1342
1343     class prrc1(BaseRM):
1344         """normal: Rc=1: pred-result CR sel"""
1345         inv: BaseRM.mode[2]
1346         CR: BaseRM.mode[3, 4]
1347
1348     class prrc0(BaseRM):
1349         """normal: Rc=0: pred-result z/nonz"""
1350         inv: BaseRM.mode[2]
1351         zz: BaseRM.mode[3]
1352         RC1: BaseRM.mode[4]
1353         dz: BaseRM.mode[3]
1354         sz: BaseRM.mode[3]
1355
1356     simple: simple
1357     smr: smr
1358     pmr: pmr
1359     svmr: svmr
1360     pu: pu
1361     ffrc1: ffrc1
1362     ffrc0: ffrc0
1363     sat: sat
1364     satx: satx
1365     satpu: satpu
1366     prrc1: prrc1
1367     prrc0: prrc0
1368
1369
1370 class LDSTImmRM(BaseRM):
1371     class simple(BaseRM):
1372         """ld/st immediate: simple mode"""
1373         zz: BaseRM.mode[3]
1374         els: BaseRM.mode[4]
1375         dz: BaseRM.mode[3]
1376         sz: BaseRM.mode[3]
1377
1378     class spu(BaseRM):
1379         """ld/st immediate: Structured Pack/Unpack"""
1380         zz: BaseRM.mode[3]
1381         els: BaseRM.mode[4]
1382         dz: BaseRM.mode[3]
1383         sz: BaseRM.mode[3]
1384
1385     class ffrc1(BaseRM):
1386         """ld/st immediate: Rc=1: ffirst CR sel"""
1387         inv: BaseRM.mode[2]
1388         CR: BaseRM.mode[3, 4]
1389
1390     class ffrc0(BaseRM):
1391         """ld/st immediate: Rc=0: ffirst z/nonz"""
1392         inv: BaseRM.mode[2]
1393         els: BaseRM.mode[3]
1394         RC1: BaseRM.mode[4]
1395
1396     class sat(BaseRM):
1397         """ld/st immediate: sat mode: N=0/1 u/s"""
1398         N: BaseRM.mode[2]
1399         zz: BaseRM.mode[3]
1400         els: BaseRM.mode[4]
1401         dz: BaseRM.mode[3]
1402         sz: BaseRM.mode[3]
1403
1404     class prrc1(BaseRM):
1405         """ld/st immediate: Rc=1: pred-result CR sel"""
1406         inv: BaseRM.mode[2]
1407         CR: BaseRM.mode[3, 4]
1408
1409     class prrc0(BaseRM):
1410         """ld/st immediate: Rc=0: pred-result z/nonz"""
1411         inv: BaseRM.mode[2]
1412         els: BaseRM.mode[3]
1413         RC1: BaseRM.mode[4]
1414
1415     simple: simple
1416     spu: spu
1417     ffrc1: ffrc1
1418     ffrc0: ffrc0
1419     sat: sat
1420     prrc1: prrc1
1421     prrc0: prrc0
1422
1423
1424 class LDSTIdxRM(BaseRM):
1425     class simple(BaseRM):
1426         """ld/st index: simple mode"""
1427         SEA: BaseRM.mode[2]
1428         sz: BaseRM.mode[3]
1429         dz: BaseRM.mode[3]
1430
1431     class stride(BaseRM):
1432         """ld/st index: strided (scalar only source)"""
1433         SEA: BaseRM.mode[2]
1434         dz: BaseRM.mode[3]
1435         sz: BaseRM.mode[4]
1436
1437     class sat(BaseRM):
1438         """ld/st index: sat mode: N=0/1 u/s"""
1439         N: BaseRM.mode[2]
1440         dz: BaseRM.mode[3]
1441         sz: BaseRM.mode[4]
1442
1443     class prrc1(BaseRM):
1444         """ld/st index: Rc=1: pred-result CR sel"""
1445         inv: BaseRM.mode[2]
1446         CR: BaseRM.mode[3, 4]
1447
1448     class prrc0(BaseRM):
1449         """ld/st index: Rc=0: pred-result z/nonz"""
1450         inv: BaseRM.mode[2]
1451         zz: BaseRM.mode[3]
1452         RC1: BaseRM.mode[4]
1453         dz: BaseRM.mode[3]
1454         sz: BaseRM.mode[3]
1455
1456     simple: simple
1457     stride: stride
1458     sat: sat
1459     prrc1: prrc1
1460     prrc0: prrc0
1461
1462
1463 class CROpRM(BaseRM):
1464     class simple(BaseRM):
1465         """cr_op: simple mode"""
1466         sz: BaseRM[6]
1467         SNZ: BaseRM[7]
1468         RG: BaseRM[20]
1469         dz: BaseRM[22]
1470
1471     class smr(BaseRM):
1472         """cr_op: scalar reduce mode (mapreduce), SUBVL=1"""
1473         sz: BaseRM[6]
1474         SNZ: BaseRM[7]
1475         RG: BaseRM[20]
1476
1477     class svmr(BaseRM):
1478         """cr_op: subvector reduce mode, SUBVL>1"""
1479         zz: BaseRM[6]
1480         SNZ: BaseRM[7]
1481         RG: BaseRM[20]
1482         SVM: BaseRM[22]
1483         dz: BaseRM[6]
1484         sz: BaseRM[6]
1485
1486     class reserved(BaseRM):
1487         """cr_op: reserved"""
1488         zz: BaseRM[6]
1489         SNZ: BaseRM[7]
1490         RG: BaseRM[20]
1491         dz: BaseRM[6]
1492         sz: BaseRM[6]
1493
1494     class ff3(BaseRM):
1495         """cr_op: ffirst 3-bit mode"""
1496         zz: BaseRM[6]
1497         SNZ: BaseRM[7]
1498         VLI: BaseRM[20]
1499         inv: BaseRM[21]
1500         CR: BaseRM[22, 23]
1501         dz: BaseRM[6]
1502         sz: BaseRM[6]
1503
1504     class ff5(BaseRM):
1505         """cr_op: ffirst 5-bit mode"""
1506         zz: BaseRM[6]
1507         SNZ: BaseRM[7]
1508         VLI: BaseRM[20]
1509         inv: BaseRM[21]
1510         dz: BaseRM[22]
1511         dz: BaseRM[6]
1512         sz: BaseRM[6]
1513
1514     simple: simple
1515     smr: smr
1516     svmr: svmr
1517     reserved: reserved
1518     ff3: ff3
1519     ff5: ff5
1520
1521
1522 class BranchBaseRM(BaseRM):
1523     ALL: BaseRM[4]
1524     SNZ: BaseRM[5]
1525     SL: BaseRM[17]
1526     SLu: BaseRM[18]
1527     LRu: BaseRM[22]
1528     sz: BaseRM[23]
1529
1530
1531 class BranchRM(BranchBaseRM):
1532     class simple(BranchBaseRM):
1533         """branch: simple mode"""
1534         pass
1535
1536     class vls(BranchBaseRM):
1537         """branch: VLSET mode"""
1538         VSb: BaseRM[7]
1539         VLI: BaseRM[21]
1540
1541     class ctr(BranchBaseRM):
1542         """branch: CTR-test mode"""
1543         CTi: BaseRM[6]
1544
1545     class ctrvls(vls, ctr):
1546         """branch: CTR-test+VLSET mode"""
1547         pass
1548
1549
1550 class RM(BaseRM):
1551     normal: NormalRM
1552     ldst_imm: LDSTImmRM
1553     ldst_idx: LDSTIdxRM
1554     cr_op: CROpRM
1555
1556     def select(self, record, Rc):
1557         rm = self
1558
1559         if record.svp64.mode is _SVMode.NORMAL:
1560             rm = rm.normal
1561             if rm.mode[0:2] == 0b00:
1562                 if rm.mode[2] == 0b0:
1563                     rm = rm.simple
1564                 else:
1565                     if self.subvl == 0b00:
1566                         if rm.mode[3] == 0b0:
1567                             rm = rm.smr
1568                         else:
1569                             rm = rm.pmr
1570                     else:
1571                         if rm.mode[4] == 0b0:
1572                             rm = rm.svmr
1573                         else:
1574                             rm = rm.pu
1575             elif rm.mode[0:2] == 0b01:
1576                 if Rc:
1577                     rm = rm.ffrc1
1578                 else:
1579                     rm = rm.ffrc0
1580             elif rm.mode[0:2] == 0b10:
1581                 if self.subvl == 0b00:
1582                     rm = rm.sat
1583                 else:
1584                     if rm.mode[4]:
1585                         rm = rm.satx
1586                     else:
1587                         rm = rm.satpu
1588             elif rm.mode[0:2] == 0b11:
1589                 if Rc:
1590                     rm = rm.prrc1
1591                 else:
1592                     rm = rm.prrc0
1593
1594         elif record.svp64.mode is _SVMode.LDST_IMM:
1595             rm = rm.ldst_imm
1596             if rm.mode[0:2] == 0b00:
1597                 if rm.mode[2] == 0b0:
1598                     rm = rm.simple
1599                 else:
1600                     rm = rm.spu
1601             elif rm.mode[0:2] == 0b01:
1602                 if Rc:
1603                     rm = rm.ffrc1
1604                 else:
1605                     rm = rm.ffrc0
1606             elif rm.mode[0:2] == 0b10:
1607                 rm = rm.sat
1608             elif rm.mode[0:2] == 0b11:
1609                 if Rc:
1610                     rm = rm.prrc1
1611                 else:
1612                     rm = rm.prrc0
1613
1614         elif record.svp64.mode is _SVMode.LDST_IMM:
1615             rm = rm.ldst_idx
1616             if rm.mode[0:2] == 0b00:
1617                 rm = rm.simple
1618             elif rm.mode[0:2] == 0b01:
1619                 rm = rm.stride
1620             elif rm.mode[0:2] == 0b10:
1621                 rm = rm.sat
1622             elif rm.mode[0:2] == 0b11:
1623                 if Rc:
1624                     rm = rm.prrc1
1625                 else:
1626                     rm = rm.prrc0
1627
1628         elif record.svp64.mode is _SVMode.CROP:
1629             rm = rm.cr_op
1630             if rm[19] == 0b0:
1631                 if rm[21] == 0b0:
1632                     rm = rm.simple
1633                 else:
1634                     if self.subvl == 0:
1635                         rm = rm.smr
1636                     else:
1637                         if rm[23] == 0b0:
1638                             rm = rm.svmr
1639                         else:
1640                             rm = rm.reserved
1641             else:
1642                 regtype = None
1643                 for idx in range(0, 4):
1644                     for entry in record.svp64.extra[idx]:
1645                         if entry.regtype is _SVExtraRegType.DST:
1646                             if regtype is not None:
1647                                 raise ValueError(record.svp64)
1648                             regtype = _RegType(entry.reg)
1649                 if regtype is _RegType.CR_REG:
1650                     rm = rm.ff5
1651                 elif regtype is _RegType.CR_BIT:
1652                     rm = rm.ff3
1653                 else:
1654                     raise ValueError(record.svp64)
1655
1656         elif record.svp64.mode is _SVMode.BRANCH:
1657             if rm[19] == 0b0:
1658                 if rm[20] == 0b0:
1659                     rm = rm.simple
1660                 else:
1661                     rm = rm.vls
1662             else:
1663                 if rm[20] == 0b0:
1664                     rm = rm.ctr
1665                 else:
1666                     rm = rm.ctrvls
1667
1668         if rm.__class__ is self.__class__:
1669             raise ValueError(self)
1670
1671         return rm
1672
1673
1674 class SVP64Instruction(PrefixedInstruction):
1675     """SVP64 instruction: https://libre-soc.org/openpower/sv/svp64/"""
1676     class Prefix(PrefixedInstruction.Prefix):
1677         id: _Field = (7, 9)
1678         rm: RM.remap((6, 8) + tuple(range(10, 32)))
1679
1680     prefix: Prefix
1681
1682     def record(self, db):
1683         record = db[self.suffix]
1684         if record is None:
1685             raise KeyError(self)
1686         return record
1687
1688     @property
1689     def binary(self):
1690         bits = []
1691         for idx in range(64):
1692             bit = int(self[idx])
1693             bits.append(bit)
1694         return "".join(map(str, bits))
1695
1696     def disassemble(self, db,
1697             byteorder="little",
1698             verbosity=Verbosity.NORMAL):
1699         def blob(integer):
1700             if verbosity <= Verbosity.SHORT:
1701                 return ""
1702             else:
1703                 blob = integer.to_bytes(length=4, byteorder=byteorder)
1704                 blob = " ".join(map(lambda byte: f"{byte:02x}", blob))
1705                 return f"{blob}    "
1706
1707         record = self.record(db=db)
1708         blob_prefix = blob(int(self.prefix))
1709         blob_suffix = blob(int(self.suffix))
1710         if record is None or record.svp64 is None:
1711             yield f"{blob_prefix}.long 0x{int(self.prefix):08x}"
1712             yield f"{blob_suffix}.long 0x{int(self.suffix):08x}"
1713             return
1714
1715         operands = tuple(map(_operator.itemgetter(1),
1716             self.dynamic_operands(db=db, verbosity=verbosity)))
1717         if operands:
1718             yield f"{blob_prefix}sv.{record.name} {','.join(operands)}"
1719         else:
1720             yield f"{blob_prefix}{record.name}"
1721         if blob_suffix:
1722             yield f"{blob_suffix}"
1723
1724         Rc = False
1725         if record.mdwn.operands["Rc"] is not None:
1726             Rc = bool(self.suffix[record.fields["Rc"]])
1727
1728         rm = self.prefix.rm.select(record=record, Rc=Rc)
1729         if verbosity >= Verbosity.VERBOSE:
1730             indent = (" " * 4)
1731             binary = self.binary
1732             spec = self.spec(db=db, prefix="sv.")
1733
1734             yield f"{indent}spec"
1735             yield f"{indent}{indent}{spec}"
1736             yield f"{indent}pcode"
1737             for stmt in record.mdwn.pcode:
1738                 yield f"{indent}{indent}{stmt}"
1739             yield f"{indent}binary"
1740             yield f"{indent}{indent}[0:8]   {binary[0:8]}"
1741             yield f"{indent}{indent}[8:16]  {binary[8:16]}"
1742             yield f"{indent}{indent}[16:24] {binary[16:24]}"
1743             yield f"{indent}{indent}[24:32] {binary[24:32]}"
1744             yield f"{indent}{indent}[32:40] {binary[32:40]}"
1745             yield f"{indent}{indent}[40:48] {binary[40:48]}"
1746             yield f"{indent}{indent}[48:56] {binary[48:56]}"
1747             yield f"{indent}{indent}[56:64] {binary[56:64]}"
1748             yield f"{indent}opcodes"
1749             for opcode in record.opcodes:
1750                 yield f"{indent}{indent}{opcode!r}"
1751             for operand in record.mdwn.operands:
1752                 yield from operand.disassemble(insn=self, record=record,
1753                     verbosity=verbosity, indent=indent)
1754             yield f"{indent}RM"
1755             yield f"{indent}{indent}{rm.__doc__}"
1756             for line in rm.disassemble(verbosity=verbosity):
1757                 yield f"{indent}{indent}{line}"
1758             yield ""
1759
1760
1761 def parse(stream, factory):
1762     def match(entry):
1763         return ("TODO" not in frozenset(entry.values()))
1764
1765     lines = filter(lambda line: not line.strip().startswith("#"), stream)
1766     entries = _csv.DictReader(lines)
1767     entries = filter(match, entries)
1768     return tuple(map(factory, entries))
1769
1770
1771 class MarkdownDatabase:
1772     def __init__(self):
1773         db = {}
1774         for (name, desc) in _ISA():
1775             operands = []
1776             if desc.regs:
1777                 (dynamic, *static) = desc.regs
1778                 operands.extend(dynamic)
1779                 operands.extend(static)
1780             pcode = PCode(iterable=desc.pcode)
1781             operands = Operands(insn=name, iterable=operands)
1782             db[name] = MarkdownRecord(pcode=pcode, operands=operands)
1783
1784         self.__db = db
1785
1786         return super().__init__()
1787
1788     def __iter__(self):
1789         yield from self.__db.items()
1790
1791     def __contains__(self, key):
1792         return self.__db.__contains__(key)
1793
1794     def __getitem__(self, key):
1795         return self.__db.__getitem__(key)
1796
1797
1798 class FieldsDatabase:
1799     def __init__(self):
1800         db = {}
1801         df = _DecodeFields()
1802         df.create_specs()
1803         for (form, fields) in df.instrs.items():
1804             if form in {"DQE", "TX"}:
1805                 continue
1806             if form == "all":
1807                 form = "NONE"
1808             db[_Form[form]] = Fields(fields)
1809
1810         self.__db = db
1811
1812         return super().__init__()
1813
1814     def __getitem__(self, key):
1815         return self.__db.__getitem__(key)
1816
1817
1818 class PPCDatabase:
1819     def __init__(self, root, mdwndb):
1820         # The code below groups the instructions by section:identifier.
1821         # We use the comment as an identifier, there's nothing better.
1822         # The point is to capture different opcodes for the same instruction.
1823         dd = _collections.defaultdict
1824         records = dd(lambda: dd(set))
1825         path = (root / "insndb.csv")
1826         with open(path, "r", encoding="UTF-8") as stream:
1827             for section in parse(stream, Section.CSV):
1828                 path = (root / section.path)
1829                 opcode_cls = {
1830                     section.Mode.INTEGER: IntegerOpcode,
1831                     section.Mode.PATTERN: PatternOpcode,
1832                 }[section.mode]
1833                 factory = _functools.partial(
1834                     PPCRecord.CSV, opcode_cls=opcode_cls)
1835                 with open(path, "r", encoding="UTF-8") as stream:
1836                     for insn in parse(stream, factory):
1837                         records[section][insn.comment].add(insn)
1838
1839         sections = dd(set)
1840         for (section, group) in records.items():
1841             for records in group.values():
1842                 sections[section].add(PPCMultiRecord(records))
1843
1844         db = {}
1845         for (section, records) in sections.items():
1846             for record in records:
1847                 def exact_match(names):
1848                     for name in names:
1849                         if name in mdwndb:
1850                             yield name
1851
1852                 def Rc_match(names):
1853                     for name in names:
1854                         if f"{name}." in mdwndb:
1855                             yield f"{name}."
1856                         yield name
1857
1858                 def LK_match(names):
1859                     if "lk" not in record.flags:
1860                         yield from names
1861                         return
1862
1863                     for name in names:
1864                         if f"{name}l" in mdwndb:
1865                             yield f"{name}l"
1866                         yield name
1867
1868                 def AA_match(names):
1869                     if record.intop not in {_MicrOp.OP_B, _MicrOp.OP_BC}:
1870                         yield from names
1871                         return
1872
1873                     for name in names:
1874                         operands = mdwndb[name].operands["AA"]
1875                         if ((operands is not None) and
1876                                 (f"{name}a" in mdwndb)):
1877                             yield f"{name}a"
1878                         yield name
1879
1880                 def reductor(names, match):
1881                     return match(names)
1882
1883                 matches = (exact_match, Rc_match, LK_match, AA_match)
1884
1885                 names = _functools.reduce(reductor, matches, record.names)
1886                 for name in names:
1887                     db[name] = (section, record)
1888
1889         self.__db = db
1890         self.__mdwndb = mdwndb
1891
1892         return super().__init__()
1893
1894     @_functools.lru_cache(maxsize=512, typed=False)
1895     def __getitem__(self, key):
1896         return self.__db.get(key, (None, None))
1897
1898
1899 class SVP64Database:
1900     def __init__(self, root, ppcdb):
1901         db = set()
1902         pattern = _re.compile(r"^(?:LDST)?RM-(1P|2P)-.*?\.csv$")
1903         for (prefix, _, names) in _os.walk(root):
1904             prefix = _pathlib.Path(prefix)
1905             for name in filter(lambda name: pattern.match(name), names):
1906                 path = (prefix / _pathlib.Path(name))
1907                 with open(path, "r", encoding="UTF-8") as stream:
1908                     db.update(parse(stream, SVP64Record.CSV))
1909
1910         self.__db = {record.name:record for record in db}
1911         self.__ppcdb = ppcdb
1912
1913         return super().__init__()
1914
1915     def __getitem__(self, key):
1916         (_, record) = self.__ppcdb[key]
1917         if record is None:
1918             return None
1919
1920         for name in record.names:
1921             record = self.__db.get(name, None)
1922             if record is not None:
1923                 return record
1924
1925         return None
1926
1927
1928 class Database:
1929     def __init__(self, root):
1930         root = _pathlib.Path(root)
1931         mdwndb = MarkdownDatabase()
1932         fieldsdb = FieldsDatabase()
1933         ppcdb = PPCDatabase(root=root, mdwndb=mdwndb)
1934         svp64db = SVP64Database(root=root, ppcdb=ppcdb)
1935
1936         db = set()
1937         names = {}
1938         opcodes = _collections.defaultdict(set)
1939
1940         for (name, mdwn) in mdwndb:
1941             (section, ppc) = ppcdb[name]
1942             if ppc is None:
1943                 continue
1944             svp64 = svp64db[name]
1945             fields = fieldsdb[ppc.form]
1946             record = Record(name=name,
1947                 section=section, ppc=ppc, svp64=svp64,
1948                 mdwn=mdwn, fields=fields)
1949             db.add(record)
1950             names[record.name] = record
1951             PO = section.opcode
1952             if PO is None:
1953                 PO = ppc[0].opcode
1954             opcodes[PO.value].add(record)
1955
1956         self.__db = db
1957         self.__names = names
1958         self.__opcodes = opcodes
1959
1960         return super().__init__()
1961
1962     def __repr__(self):
1963         return repr(self.__db)
1964
1965     def __iter__(self):
1966         yield from self.__db
1967
1968     @_functools.lru_cache(maxsize=None)
1969     def __contains__(self, key):
1970         return self.__getitem__(key) is not None
1971
1972     @_functools.lru_cache(maxsize=None)
1973     def __getitem__(self, key):
1974         if isinstance(key, (int, Instruction)):
1975             key = int(key)
1976             XO = int(_SelectableInt(value=int(key), bits=32)[0:6])
1977             for record in self.__opcodes[XO]:
1978                 if record.match(key=key):
1979                    return record
1980
1981         elif isinstance(key, str):
1982             return self.__names[key]
1983
1984         return None