[loop-buffer]
property key      value
maximum-interval  14

[calling-convention]
property key       value
arguments          A4 B4 A6 B6 A8 B8 A10 B10 A12 B12
data-page          B14
link               B3
preserved          A10 A11 A12 A13 A14 A15 B10 B11 B12 B13 B14 B15
result             A4 A5
stack              B15
stack-alignment    8

[predicates]
creg:int key  z:int key  condition unique
0         0      always
1         0      [B0]
1         1      [!B0]
2         0      [B1]
2         1      [!B1]
3         0      [B2]
3         1      [!B2]
4         0      [A1]
4         1      [!A1]
5         0      [A2]
5         1      [!A2]
6         0      [A0]
6         1      [!A0]

[control-registers]
number:int key  read unique  write unique
0       AMR    AMR
1       CSR    CSR
2       IFR    ISR
3       -      ICR
4       IER    IER
5       ISTP   ISTP
6       IRP    IRP
7       NRP    NRP
9       DETR   DETR
10      TSCL   TSCL
11      TSCH   TSCH
13      ILC    ILC
14      RILC   RILC
15      REP    REP
16      PCE1   PCE1
17      DNUM   DNUM
18      FADCR  FADCR
19      FAUCR  FAUCR
20      FMCR   FMCR
21      SSR    SSR
22      GPLYA  GPLYA
23      GPLYB  GPLYB
24      GFPGFR  GFPGFR
25      DIER   DIER
26      TSR    TSR
27      ITSR   ITSR
28      NTSR   NTSR
29      EFR    ECR
31      IERR   IERR

[addressing-modes]
mode:list unique  form     base
0 4        *-R[offset]    unchanged
1 5        *+R[offset]    unchanged
10 14      *R--[offset]   decremented after
11 15      *R++[offset]   incremented after
2 3 6 7    -              -
8 12       *--R[offset]   decremented first
9 13       *++R[offset]   incremented first

[operand-types]
type key  holds     words:int  pair      constant
bv2      register   1          -         -
bv4      register   1          -         -
cond0    condition  -          -         -
creg     control    -          -         -
cst      constant   -          -         signed
dint     register   2          even      -
dp       register   2          even      -
dpa      register   2          adjacent  -
dpports  ports      2          -         -
dpr      register   2          wrapping  -
ds2      register   2          even      -
duint    register   2          even      -
dws4     register   2          even      -
dwu4     register   2          even      -
i2       register   1          -         -
i4       register   1          -         -
int      register   1          -         -
l3i      constant   -          -         l3i
ptr      pointer    1          -         -
s2       register   1          -         -
s3i      constant   -          -         s3i
s4       register   1          -         -
scst     constant   -          -         signed
sdint    register   2          even      -
sint     register   1          -         -
sllong   register   2          even      -
slong    register   2          even      -
slsb16   register   1          -         -
smsb16   register   1          -         -
sp       register   1          -         -
u2       register   1          -         -
u4       register   1          -         -
ucst     constant   -          -         unsigned
uint     register   1          -         -
ullong   register   2          even      -
ulong    register   2          even      -
ulsb16   register   1          -         -
umsb16   register   1          -         -
uscst    constant   -          -         unsigned

[compact-banks]
bits:int key  bank
1             direct
3             rs
4             direct
5             direct

[timing-types]
type key    reads:list  writes:list  busy  branch  base  authority             instructions:list unique
adddp       0.0@0 1.0@0 0.1@1 1.1@1  6 7  2  -  -  SPRUFE8B Table 4-16   ADDDP SUBDP
branch      *@0        1            1     6       -     SPRUFE8B Table 4-11   B BNOP CALLP BDEC BPOS
compare-dp  0.0@0 1.0@0 0.1@1 1.1@1  2    2  -  -  SPRUFE8B Table 4-15   CMPEQDP CMPLTDP CMPGTDP
four-cycle  *@0        4            1     -       -     SPRUFE8B Table 4-13   INTSP SPINT MPYSP ADDSP DOTP2 DOTPN2 DOTPSU4 DOTPRSU2 DOTPU4 DOTPNRSU2 DDOTPH2 DDOTPL2 DDOTPH2R DDOTPL2R DDOTP4 MPY2 CMPY CMPYR1 CMPYR XORMPY SMPY2 MPY2IR MPYU4 MPYSU4 MPYHI MPYLI MPYHIR MPYLIR MPY32 MPY32SU MPY32US MPY32U SMPY32 MVD SUBSP INTSPU SPTRUNC DPSP DPINT DPTRUNC GMPY GMPY4
intdp       *@0        4 5          1     -       -     SPRUFE8B Table 4-14   INTDP INTDPU
load        *@0        5            1     -       1     SPRUFE8B Table 4-10   LDB LDBU LDH LDHU LDW LDNW LDDW LDNDW
mpydp       0.0@0 1.0@0 0.0@1 1.1@1 0.1@2 1.0@2 0.1@3 1.1@3  9 10  4  -  -  SPRUFE8B Table 4-19   MPYDP
mpyi        *@0 *@1 *@2 *@3  9      4     -       -     SPRUFE8B Table 4-17   MPYI
mpyid       *@0 *@1 *@2 *@3  9 10   4     -       -     SPRUFE8B Table 4-18   MPYID
mpysp2dp    0.0@0 1.0@0  4 5        2     -       -     SPRUFE8B Table 4-21   MPYSP2DP
mpyspdp     0.0@0 1.0@0 0.0@1 1.1@1  6 7  3  -  -  SPRUFE8B Table 4-20   MPYSPDP
multiply16  *@0        2            1     -       -     SPRUFE8B Table 4-7    MPY MPYU MPYUS MPYSU SMPY MPYH MPYHU MPYHUS MPYHSU SMPYH MPYHL MPYHLU MPYHULS MPYHSLU SMPYHL MPYLH MPYLHU MPYLUHS MPYLSHU SMPYLH AVG2 AVGU4 XPND2 XPND4 BITC4 SHFL DEAL BITR ROTL SSHVL SSHVR
single      *@0        1            1     -       -     SPRUFE8B Table 4-6    MVK MVKH ADDK ADD ADDKPC NOP ABSSP CMPEQSP CMPGTSP CMPLTSP RCPSP RSQRSP EXT EXTU SET CLR SAT DMV ADDAB ADDAH ADDAW ADDAD SUBAB SUBAH SUBAW MVC ABS ABS2 ADD2 ADD4 ADDSUB ADDSUB2 ADDU AND ANDN CMPEQ CMPEQ2 CMPEQ4 CMPGT CMPGT2 CMPGTU CMPGTU4 CMPLT CMPLTU DPACK2 DPACKX2 LMBD MAX2 MAXU4 MIN2 MINU4 NORM OR PACK2 PACKH2 PACKH4 PACKHL2 PACKL4 PACKLH2 RPACK2 SADD SADD2 SADDSUB SADDSUB2 SADDU4 SADDUS2 SHFL3 SHL SHLMB SHR SHR2 SHRMB SHRU SHRU2 SPACK2 SPACKU4 SSHL SSUB SSUB2 SUB SUB2 SUB4 SUBABS4 SUBC SUBU SWAP4 UNPKHU4 UNPKLU4 XOR DINT RINT SWE SWENR IDLE
store       *@0        -            1     -       1     SPRUFE8B Table 4-8    STB STH STW STNW STDW STNDW
two-cycle-dp  *@0      1 2       1     -       -     SPRUFE8B Table 4-12   ABSDP RCPDP RSQRDP SPDP
untyped     -          -            -     -       -     none in SPRUFE8B      SPLOOP SPLOOPD SPLOOPW SPKERNEL SPKERNELR SPMASK SPMASKR PLD

[listing]
mnemonic key  operands:list
ADDKPC    pce1(0) operand(1) operand(2)
B         target(0)
BDEC      target(0) operand(1)
BNOP      target(0) operand(1)
BPOS      target(0) operand(1)
CALLP     target(0) register(3)
LMBD      lsb(0) operand(1) operand(2)
MVKH      high16(0) operand(1)
SPKERNEL  stage(0) cycle(0)
SPMASK    units(0)
SPMASKR   units(0)

[aliases]
instruction key      format:list@bits  listing
ADD -cst,src,dst     -       SUB src,cst,dst
ADD 0,src,dst        -       MV src,dst
ADD cst,r,r          LSDx1   ADD r,cst,r
ADD cst,src,dst      L3i     ADD src,cst,dst
ADD src,0,dst        -       MV src,dst
ADDAB src,0,dst      -       MV src,dst
NOP 1                N-nop   NOP
OR 0,src,dst         -       MV src,dst
PACKLH2 src,src,dst  -       SWAP2 src,dst
SUB 0,src,dst        -       NEG src,dst
SUB a,a,a            Dx2op   SUB a,a,a
SUB a,a,b            S3 L3   SUB a,a,b
SUB src,src,dst      -       ZERO dst
XOR -1,src,dst       -       NOT src,dst
XOR cst,src,dst      LSDx1   XOR src,cst,dst

[spellings]
written key                reading key  builds             authority
ADD any,cst*4,dst          compacts  ADDAW any,cst,dst     cl6x 8.5.0's compressor writes a word multiple added as ADDAW's 16-bit form
ADD cst,r,r                compacts  ADDK cst,r            cl6x 8.5.0's compressor writes a constant added to its own register as ADDK's 16-bit form (ADD .S1 1,A7,A7 is 27ae)
B any                      compacts  BNOP any,0            cl6x 8.5.0's compressor writes a branch as BNOP's 16-bit form with no NOP (B .S2 B3 is 01ef)
CALL any                   is       B any                  cl6x 8.5.0 writes a call through a register as CALL; asm6x builds B
CALLRET any                is       B any                  cl6x 8.5.0 writes a tail call through a register as CALLRET; asm6x builds B
MV src,dst                 compacts  ADD 0,src,dst         cl6x 8.5.0's compressor writes ADD's 16-bit form
MV src,dst                 is       OR 0,src,dst           SPRUFE8B MV allows ADD or OR; asm6x writes OR
RET any                    is       B any                  cl6x 8.5.0 writes a return through a register as RET; asm6x builds B
RETNOP any1,any2           is       BNOP any1,any2         cl6x 8.5.0 writes a return with its delay as RETNOP; asm6x builds BNOP .S2
RETP any1,any2             is       CALLP any1,any2        cl6x 8.5.0 writes a tail call with its return register as RETP; asm6x builds CALLP
SADDSU2 a,b,dst            is       SADDUS2 b,a,dst        SPRUFE8B SADDSU2: SADDUS2 with the sources swapped
SUB any,-cst,dst           or       ADD cst,any,dst        asm6x writes a constant subtracted as it added (spelling sweep)
SUB any,0,dst              or       ADD 0,any,dst          asm6x writes zero subtracted as zero added (spelling sweep)
SUB any,cst*4,dst          compacts  SUBAW any,cst,dst     cl6x 8.5.0's compressor writes a word multiple subtracted as SUBAW's 16-bit form (SUB .D2 B15,16,B15 is 8cf7)
SUB any,cst,dst            compacts  ADD -cst,any,dst      cl6x 8.5.0's compressor writes a constant subtracted as its negative added (SUB .L2 B5,1,B5 is eed1)
ZERO dst                   is       MVK 0,dst              SPRUFE8B ZERO: a register is MVK 0
ZERO h:l                   is       SUB unread,unread,h:l  SPRUFE8B ZERO: a pair is SUB of a value from itself; asm6x 8.3.15 and 8.5.0 take the lowest register its packet does not otherwise read

[commuting]
mnemonic key  partner   authority
ADD           -         asm6x takes either source order
ADD2          -         asm6x takes either source order
ADD4          -         asm6x takes either source order (spelling sweep)
ADDDP         -         asm6x takes either source order (spelling sweep)
ADDSP         -         asm6x takes either source order
ADDU          -         asm6x takes either source order (spelling sweep)
AND           -         asm6x takes either source order
AVG2          -         asm6x takes either source order (spelling sweep)
AVGU4         -         asm6x takes either source order (spelling sweep)
CMPEQ         -         asm6x takes either source order
CMPEQ2        -         asm6x takes either source order (spelling sweep)
CMPEQ4        -         asm6x takes either source order (spelling sweep)
CMPEQDP       -         asm6x takes either source order (spelling sweep)
CMPEQSP       -         asm6x takes either source order (spelling sweep)
CMPGT         CMPLT     asm6x writes the mirrored compare
CMPGTDP       CMPLTDP   asm6x writes the mirrored compare (spelling sweep)
CMPGTSP       CMPLTSP   asm6x writes the mirrored compare (spelling sweep)
CMPGTU        CMPLTU    asm6x writes the mirrored compare
CMPY          -         asm6x takes either source order (spelling sweep)
CMPYR         -         asm6x takes either source order (spelling sweep)
CMPYR1        -         asm6x takes either source order (spelling sweep)
DOTP2         -         asm6x takes either source order (spelling sweep)
DOTPN2        -         asm6x takes either source order (spelling sweep)
DOTPU4        -         asm6x takes either source order (spelling sweep)
GMPY4         -         asm6x takes either source order (spelling sweep)
MAX2          -         asm6x takes either source order
MAXU4         -         asm6x takes either source order (spelling sweep)
MIN2          -         asm6x takes either source order
MINU4         -         asm6x takes either source order (spelling sweep)
MPY           -         asm6x takes either source order
MPY2          -         asm6x takes either source order (spelling sweep)
MPY32         -         asm6x takes either source order
MPY32SU       MPY32US   asm6x writes the mirrored multiply (spelling sweep)
MPY32U        -         asm6x takes either source order (spelling sweep)
MPYDP         -         asm6x takes either source order (spelling sweep)
MPYH          -         asm6x takes either source order
MPYHL         MPYLH     asm6x writes the mirrored multiply (spelling sweep)
MPYHLU        MPYLHU    asm6x writes the mirrored multiply (spelling sweep)
MPYHSLU       MPYLUHS   asm6x writes the mirrored multiply (spelling sweep)
MPYHSU        MPYHUS    asm6x writes the mirrored multiply (spelling sweep)
MPYHU         -         asm6x takes either source order
MPYHULS       MPYLSHU   asm6x writes the mirrored multiply (spelling sweep)
MPYI          -         asm6x takes either source order (spelling sweep)
MPYID         -         asm6x takes either source order (spelling sweep)
MPYSP         -         asm6x takes either source order
MPYSP2DP      -         asm6x takes either source order (spelling sweep)
MPYSU         MPYUS     asm6x writes the mirrored multiply (spelling sweep)
MPYU          -         asm6x takes either source order
MPYU4         -         asm6x takes either source order (spelling sweep)
OR            -         asm6x takes either source order
SADD          -         asm6x takes either source order (spelling sweep)
SADD2         -         asm6x takes either source order (spelling sweep)
SADDU4        -         asm6x takes either source order (spelling sweep)
SMPY          -         asm6x takes either source order
SMPY2         -         asm6x takes either source order (spelling sweep)
SMPY32        -         asm6x takes either source order (spelling sweep)
SMPYH         -         asm6x takes either source order
SMPYHL        SMPYLH    asm6x writes the mirrored multiply (spelling sweep)
XOR           -         asm6x takes either source order

[directives]
directive key  origin  reads       detail
.align         ti      align       -
.asg           ti      asg         -
.asmfunc       ti      no-bytes    -
.battr         ti      no-bytes    -
.bes           ti      bes         -
.bits          ti      bits        -
.break         ti      break       -
.bss           ti      room-bss    -
.byte          ti      data1       -
.cdecls        ti      cdecls      -
.char          ti      data1       -
.clearmap      ti      refused     it serves linear assembly, which a source is not
.clink         ti      no-bytes    -
.common        ti      common-bss  -
.compiler_opts  ti     no-bytes    -
.copy          ti      include     -
.cstring       ti      cstring     -
.cstruct       ti      refused     structure and union types are not read yet
.cunion        ti      refused     structure and union types are not read yet
.data          ti      section     -
.def           ti      def         -
.define        ti      define      -
.double        ti      refused     floating-point constants are not read yet
.drlist        ti      no-bytes    -
.drnolist      ti      no-bytes    -
.dwattr        ti      no-bytes    -
.dwcfi         ti      no-bytes    -
.dwcie         ti      no-bytes    -
.dwendentry    ti      no-bytes    -
.dwendtag      ti      no-bytes    -
.dwfde         ti      no-bytes    -
.dwpsn         ti      no-bytes    -
.dwtag         ti      no-bytes    -
.elfsym        ti      no-bytes    -
.else          ti      else        -
.elseif        ti      elseif      -
.emember       ti      refused     structure and union types are not read yet
.emsg          ti      emsg        -
.end           ti      end         -
.endasmfunc    ti      no-bytes    -
.endenum       ti      refused     structure and union types are not read yet
.endgroup      ti      refused     section groups are the linker's, which a placed source does not pass through
.endif         ti      endif       -
.endloop       ti      endloop     -
.endm          ti      endm        -
.endstruct     ti      refused     structure and union types are not read yet
.endunion      ti      refused     structure and union types are not read yet
.enum          ti      refused     structure and union types are not read yet
.equ           ti      constant    -
.eval          ti      eval        -
.export        ti      refused     dynamic visibility is the linker's, which a placed source does not pass through
.farcommon     ti      common-far  -
.fclist        ti      no-bytes    -
.fcnolist      ti      no-bytes    -
.field         ti      refused     bit fields are not read yet
.float         ti      refused     floating-point constants are not read yet
.fphead        ziddle  header      -
.global        ti      global      -
.gmember       ti      refused     section groups are the linker's, which a placed source does not pass through
.group         ti      refused     section groups are the linker's, which a placed source does not pass through
.half          ti      data2       -
.hidden        ti      refused     dynamic visibility is the linker's, which a placed source does not pass through
.if            ti      if          -
.import        ti      refused     dynamic visibility is the linker's, which a placed source does not pass through
.include       ti      include     -
.int           ti      data4       -
.label         ti      refused     a load-time label differs from its run address, and a placed source runs where it loads
.length        ti      no-bytes    -
.list          ti      no-bytes    -
.long          ti      data4       -
.loop          ti      loop        -
.macro         ti      macro       -
.map           ti      refused     it serves linear assembly, which a source is not
.mexit         ti      mexit       -
.mlib          ti      refused     a macro library is an archive, which a source is not read from yet; .include the file of macros
.mlist         ti      no-bytes    -
.mmsg          ti      mmsg        -
.mnolist       ti      no-bytes    -
.nearcommon    ti      common-bss  -
.newblock      ti      refused     local labels ($n) are not read yet
.nocmp         ti      nocmp       -
.nolist        ti      no-bytes    -
.noremark      ti      no-bytes    -
.option        ti      no-bytes    -
.page          ti      no-bytes    -
.protected     ti      refused     dynamic visibility is the linker's, which a placed source does not pass through
.ref           ti      ref         -
.remark        ti      no-bytes    -
.retain        ti      no-bytes    -
.retainrefs    ti      no-bytes    -
.sect          ti      sect        -
.set           ti      constant    -
.setsect       ti      refused     the absolute lister writes it, and a source is not its output
.setsym        ti      refused     the absolute lister writes it, and a source is not its output
.short         ti      data2       -
.space         ti      space       -
.sslist        ti      no-bytes    -
.ssnolist      ti      no-bytes    -
.string        ti      string      -
.struct        ti      refused     structure and union types are not read yet
.symdepend     ti      refused     it steers the linker, which a placed source does not pass through
.tab           ti      no-bytes    -
.tag           ti      refused     structure and union types are not read yet
.text          ti      section     -
.title         ti      no-bytes    -
.ubyte         ti      data1       -
.uchar         ti      data1       -
.uhalf         ti      data2       -
.uint          ti      data4       -
.ulong         ti      data4       -
.unasg         ti      unasg       -
.undefine      ti      unasg       -
.union         ti      refused     structure and union types are not read yet
.usect         ti      usect       -
.ushort        ti      data2       -
.uword         ti      data4       -
.var           ti      var         -
.weak          ti      refused     a weak symbol is the linker's to resolve, which a placed source does not pass through
.width         ti      no-bytes    -
.wmsg          ti      wmsg        -
.word          ti      data4       -

[reserved-names]
name key
amr
csr
desr
detr
dier
dnum
ecr
efr
fadcr
faucr
fmcr
gfpgfr
gplya
gplyb
icr
ier
ierr
ifr
ilc
in
irp
isr
istp
itsr
nrp
ntsr
out
pc
pce1
rep
rilc
ssr
tsch
tscl
tsr

[macro-limits]
property key    value
nesting         32
symbols         32
uncounted-loop  1024
