ras/defs.h

   1 /*
   2  * DEFS.H
   3  *
   4  * (c)Copyright 2015-2016, Matthew Dillon, All Rights Reserved.  See the
   5  *    COPYRIGHT file at the base of the distribution.
   6  */
   7
   8 #include <sys/types.h>
   9 #include <sys/file.h>
  10 #include <sys/errno.h>
  11 #include <sys/endian.h>
  12 #include <stdio.h>
  13 #include <stdlib.h>
  14 #include <stdarg.h>
  15 #include <unistd.h>
  16 #include <string.h>
  17 #include <assert.h>
  18 #include <limits.h>
  19 #include <libruntime/export.h>
  20 #include <librune/type.h>
  21 #include <librune/insn.h>
  22
  23 struct RASParser;
  24 struct RASSym;
  25 struct RASBlock;
  26 struct RASInsn;
  27 struct RASSpan;
  28 struct RASCycle;
  29 struct MatchDefer;
  30
  31 typedef uint32_t rastoken_t;
  32
  33 #define TOK_DOT         '.'
  34 #define TOK_COLON       ':'
  35 #define TOK_COMMA       ','
  36 #define TOK_PL          '+'
  37 #define TOK_MI          '-'
  38 #define TOK_OPAREN      '('
  39 #define TOK_CPAREN      ')'
  40 #define TOK_OBRACE      '{'
  41 #define TOK_CBRACE      '}'
  42 #define TOK_DOLLAR      '$'
  43 #define TOK_DQUOTE      '\"'
  44 #define TOK_SQUOTE      '\''
  45
  46 #define TOK_ID          0x0100          /* identifier or label */
  47 #define TOK_SYMBOL      0x0101          /* symbol e.g. @id */
  48 #define TOK_VALUE       0x0102          /* numerical value [$ optional] */
  49 #define TOK_STRING      0x0103          /* quoted string */
  50 #define TOK_REG         0x0104          /* register/pseudo-register %id */
  51
  52 /*
  53  * NOTE: If TOKF_INSN is set the remaining 31 bits represents the instruction
  54  *       code and the other TOKF_* flags are invalid.
  55  */
  56 #define TOKF_PSOP       0x1000
  57 #define TOKF_CONST      0x2000
  58 #define TOKF_SPECIAL    0x4000
  59 #define TOKF_INSN       INSNF_INSN      /* 0x80000000 */
  60
  61 /*
  62  * Pseudoops
  63  */
  64 #define TOK_SECTION     (0x001 | TOKF_PSOP)
  65 #define TOK_ENDSECTION  (0x002 | TOKF_PSOP)
  66 #define TOK_EXTERN      (0x003 | TOKF_PSOP)
  67 #define TOK_BSS         (0x004 | TOKF_PSOP)
  68 #define TOK_DATA        (0x005 | TOKF_PSOP)
  69 #define TOK_RODATA      (0x006 | TOKF_PSOP)
  70 #define TOK_TEXT        (0x007 | TOKF_PSOP)
  71 #define TOK_PROC        (0x008 | TOKF_PSOP)
  72 #define TOK_VARPROC     (0x009 | TOKF_PSOP)
  73 #define TOK_ENDPROC     (0x00A | TOKF_PSOP)
  74 #define TOK_ALIGN       (0x00B | TOKF_PSOP)
  75 #define TOK_WEAK        (0x00C | TOKF_PSOP)
  76 #define TOK_GLOBL       (0x00D | TOKF_PSOP)
  77 #define TOK_CTORS       (0x00E | TOKF_PSOP)
  78
  79 #define TOK_INT8        (0x010 | TOKF_PSOP)     /* 1 << low_nibble bytes */
  80 #define TOK_INT16       (0x011 | TOKF_PSOP)
  81 #define TOK_INT32       (0x012 | TOKF_PSOP)
  82 #define TOK_INT64       (0x013 | TOKF_PSOP)
  83 #define TOK_INT128      (0x014 | TOKF_PSOP)
  84 #define TOK_RES256      (0x015 | TOKF_PSOP)
  85 #define TOK_RES512      (0x016 | TOKF_PSOP)
  86 #define TOK_RES1024     (0x017 | TOKF_PSOP)
  87
  88 #define TOK_UINT8       (0x018 | TOKF_PSOP)     /* 1 << low_nibble bytes */
  89 #define TOK_UINT16      (0x019 | TOKF_PSOP)
  90 #define TOK_UINT32      (0x01A | TOKF_PSOP)
  91 #define TOK_UINT64      (0x01B | TOKF_PSOP)
  92 #define TOK_UINT128     (0x01C | TOKF_PSOP)
  93 #define TOK_URES256     (0x01D | TOKF_PSOP)
  94 #define TOK_URES512     (0x01E | TOKF_PSOP)
  95 #define TOK_URES1024    (0x01F | TOKF_PSOP)
  96
  97 #define TOK_FLOAT       (0x022 | TOKF_PSOP)     /* 1 << low_nibble bytes */
  98 #define TOK_DOUBLE      (0x023 | TOKF_PSOP)
  99 #define TOK_LDOUBLE     (0x024 | TOKF_PSOP)
 100
 101 #define TOK_ZERO        (0x030 | TOKF_PSOP)
 102
 103 #define TOK_LOC         (0x040 | TOKF_PSOP)
 104 #define TOK_FILE        (0x041 | TOKF_PSOP)
 105
 106 /*
 107  * Constants and special identifiers
 108  */
 109 #define TOK_NULL        (0x001 | TOKF_CONST)
 110 #define TOK_CACHE       (0x002 | TOKF_SPECIAL)
 111
 112 /*
 113  * RAS has minimal operators, relegated to relocation or offset management
 114  */
 115 #define TOK_ADD         '+'
 116 #define TOK_SUB         '-'
 117
 118 /*
 119  * RAS has minimal operators, relegated to relocation or offset management
 120  */
 121 #define TOK_ADD         '+'
 122 #define TOK_SUB         '-'
 123
 124 /*
 125  *
 126  */
 127 #define REGF_ADHOC      (REGF_USRBASE)
 128
 129 /*
 130  * Basic block
 131  */
 132 typedef RUNE_HEAD(rinsn_list, RASInsn) rinsn_list_t;
 133 typedef RUNE_HEAD(matchdef_list, MatchDefer) matchdef_list_t;
 134
 135 struct RASBlock {
 136         RUNE_ENTRY(RASBlock) node;
 137         RUNE_ENTRY(RASBlock) defnode;
 138         uint32_t        flags;
 139         int             count;
 140         int             seq;            /* differentiate block passes */
 141         int             defseq;
 142         int             reachcount;
 143         int             incount;        /* blocks that enter ours */
 144         rinsn_list_t    rinsn_list;
 145         matchdef_list_t matchdef_list;
 146         struct RASBlock *bentry;        /* non-null if a super-block */
 147         struct RASBlock *btrue;
 148         struct RASBlock *bfalse;
 149         struct RASBlock *super;
 150 };
 151
 152 typedef struct RASBlock         rblock_t;
 153
 154 #define RBLKF_REACHABLE1        0x00000001
 155 #define RBLKF_REACHABLE2        0x00000002
 156 #define RBLKF_UNUSED0004        0x00000004
 157 #define RBLKF_COLLAPSED         0x00000008
 158 #define RBLKF_REGALLOCATOR      0x00000010
 159
 160 /*
 161  * RAS Symbol (Label, symbol, register)
 162  *
 163  * Symbols are also overloaded to index pseudo-ops and instructions.  There
 164  * is no conflict if a pseudo-op or instruction identifier matches some other
 165  * sort of identifier.
 166  */
 167 struct RASSym {
 168         struct RASSym   *next;
 169         int32_t         flags;
 170         int32_t         hv;
 171         uint32_t        characterize;   /* (instructions only) */
 172         size_t          bytes;          /* string length of identifier */
 173         rastoken_t      tok;            /* keyword token if applicable */
 174         char            *id;
 175         void            (*func)(struct RASParser *p, struct RASInsn *rin);
 176         rblock_t        *label_block;   /* if label */
 177 };
 178
 179 typedef struct RASSym           rsym_t;
 180
 181 #define RSYMF_REF       0x00000001
 182 #define RSYMF_DEF       0x00000002
 183
 184 typedef RUNE_HEAD(rblock_list, RASBlock) rblock_list_t;
 185 typedef RUNE_HEAD(blockdef_list, RASBlock) blockdef_list_t;
 186
 187 /*
 188  * Parser elements
 189  */
 190 struct RASParser {
 191         const uint8_t *line;    /* current line */
 192         const uint8_t *lptr;
 193         const uint8_t *lend;
 194
 195         const uint8_t *tbase;   /* current token buffer ref */
 196         const uint8_t *tend;
 197         rsym_t     *sym;        /* if a label, symbol, or register */
 198
 199         char    *ipath;         /* file path or NULL */
 200         char    *opath;         /* file path or NULL */
 201         FILE    *fi;            /* input file */
 202         FILE    *fo;            /* output file */
 203         int     lineno;
 204         int     error;
 205         int     flags;
 206         int     insn_counter;
 207         uint32_t opt_flags;
 208         uint32_t opt_last;
 209         int64_t valuelo;        /* 8, 16, 32, or 64-bit immediates */
 210         int64_t valuehi;        /* (128-bit immediates) */
 211         rastoken_t tok;         /* current token */
 212         rsym_t     *psym;               /* procedure */
 213         rblock_list_t rblock_list;      /* procedure */
 214         blockdef_list_t blockdef_list;
 215         int     pcomplexity;
 216 };
 217
 218 typedef struct RASParser        RASParser;
 219
 220 #define RASPF_DIDPLMI   0x00000001
 221 #define RASPF_NEGATIVE  0x00000002      /* TOK_VALUE is negative */
 222
 223 #define RASOPT_XMM0_ZERO        0x00000001
 224 #define RASOPT_RAX_ZERO         0x00000002
 225
 226 struct RASSection {
 227 };
 228
 229 typedef struct RASSection       RASSection;
 230
 231 typedef struct RASSpan {
 232         struct RASSpan  *hnext;
 233         struct RASSpan  *root;
 234         struct RASInsn  *rin;
 235         struct RASBlock *block;
 236         struct RASEA    *rea;
 237         struct RASSpan  *link;          /* intra-block links */
 238         struct RASSpan  *lend;
 239         struct RASSpan  *strue;         /* inter-block links */
 240         struct RASSpan  *sfalse;
 241         uint32_t        flags;
 242 } rspan_t;
 243
 244 /*
 245  * argflags
 246  *
 247  * These generally tell the block optimizer whether an EA is being read,
 248  * written, or both.  LEA indicates that the address of the EA is being
 249  * taken (generally disables caching), and NODROP indicates that the
 250  * instruction cannot be discarded if it terminates the life of the
 251  * output variable.
 252  */
 253 #define RAF_READ        CHF_READ        /* inherited from characterization */
 254 #define RAF_WRITE       CHF_WRITE
 255 #define RAF_LEA         CHF_LEA
 256 #define RAF_NODROP      CHF_NODROP      /* cannot discard insn on write term */
 257 #define RAF_FLOAT       CHF_FLOAT       /* direct register is floating */
 258 #define RAF_LIFE_BEG    0x00000020      /* cacheable object life begin */
 259 #define RAF_LIFE_END    0x00000040      /* cacheable object life end */
 260 #define RAF_UNUSED80    0x00000080
 261 #define RAF_TIE1        0x08000000
 262 #define RAF_TIE2        0x10000000
 263 #define RAF_TIE3        0x20000000
 264 #define RAF_SKELETON    0x40000000
 265 #define RAF_SPAN        0x80000000U
 266
 267 typedef struct RASCycle {
 268         struct RASCycle *parent;
 269         rblock_t        *block;
 270         int             complexity;
 271         int             seq;
 272         int             depth;
 273         int             flags;
 274 } rcycle_t;
 275
 276 /*
 277  * NOTE: Uses the same EA_* and REG* defines from librune/type.h
 278  *
 279  * All instruction EAs represent the same object will share their rea_t
 280  * pointer.  Sharing is calculated in the resolve pass.
 281  *
 282  * The optimizer will translate leave the original Rune EA intact and hang
 283  * a translated EA off of it for code generation.  This allows us to take
 284  * as many passes on the basic blocks as we want.
 285  *
 286  * If EA_MEMORY uses a non-trivial register, rea->direct will be non-NULL
 287  * and be rea with an eamode of EA_DIRECT representing the indirect register.
 288  * This allows the register to be tracked for caching purposes.
 289  */
 290 struct RASEA {
 291         struct RASEA    *direct;
 292         uint32_t        regno;
 293         uint32_t        orig_regno;
 294         rsym_t          *sym;
 295         uint8_t         eamode;
 296         uint8_t         orig_eamode;    /* reset for reallocation */
 297         uint16_t        target_reg;
 298         runesize_t      orig_offset;    /* reset for reallocation */
 299         runesize_t      offset;
 300         int64_t         immlo;          /* 8, 16, 32, or 64-bit immediates */
 301         int64_t         immhi;          /* (128-bit immediates) */
 302         int             refs;           /* share count (cacheability) */
 303         uint32_t        flags;
 304         int             regweight;
 305         int             scount;         /* insn count from last span */
 306         uintptr_t       cache_id;       /* additional differentiation */
 307 };
 308
 309 typedef struct RASEA            rea_t;
 310
 311 #define REAF_CACHEABLE  0x00000001      /* cacheable object */
 312 #define REAF_BOOLD      0x00000002      /* got .B ext */
 313 #define REAF_ADDRUSED   0x00000004      /* combined RAF_LEA */
 314 #define REAF_TRANSLATED 0x00000008      /* already translated */
 315 #define REAF_REGALLOCD  0x00000010      /* dynamic alloc/dealloc */
 316 #define REAF_DIRECT     0x00000020      /* used in rea->direct sequence */
 317 #define REAF_DROPOK     0x00000040      /* does not prevent insn drop */
 318
 319 /*
 320  * A RUNE Instruction is specified here.  EAs representing the same object
 321  * will be shared(!).  The primary resolve pass calculates shareable
 322  * EAs and their lifetimes and will set RARGF_* flags.  Later passes
 323  * use these flags to track all active cacheable objects.
 324  *
 325  * The RUNE language allows multiple overlapping or overloaded cacheable
 326  * objects which are distinct from each other as long as the resolver can
 327  * determine that their active lives don't overlap.  The resolver will
 328  * use the READ and WRITE flags to calculate the separation independent
 329  * of semantic layering which allows for maximal register reuse.
 330  *
 331  *
 332  */
 333 struct RASInsn {
 334         RUNE_ENTRY(RASInsn) node;
 335         void            (*func)(struct RASParser *p, struct RASInsn *rin);
 336         rblock_t        *block;         /* block insn belongs in */
 337         const char      *opname;
 338         int32_t         op;
 339         uint8_t         ext1;
 340         uint8_t         ext2;
 341         uint8_t         flags;
 342         uint8_t         operands;       /* usually 0-3. CALL may have 4 */
 343         rspan_t         arg1;
 344         rspan_t         arg2;
 345         rspan_t         arg3;
 346         rspan_t         arg4;
 347         rspan_t         arg1d;
 348         rspan_t         arg2d;
 349         rspan_t         arg3d;
 350         rspan_t         arg4d;
 351         rsym_t          *brtrue;
 352         rsym_t          *brfalse;
 353         rsym_t          *label;         /* (XXX ok to overload on brfalse) */
 354         uint64_t        regused_agg;
 355         uint64_t        regused_init;
 356         uint64_t        special_save;
 357         int             rindex;         /* index of insn in block */
 358         int             loc_file;       /* debug info */
 359         int             loc_line;
 360 };
 361
 362 typedef struct RASInsn          rinsn_t;
 363
 364 /*
 365  * flags
 366  */
 367 #define RINSF_BRANCH    0x01            /* conditional insn w/branch */
 368 #define RINSF_DROPME    0x02            /* flag insn is to be dropped */
 369
 370 #define CHF_READ        0x00000001      /* see REAF above, must match */
 371 #define CHF_WRITE       0x00000002      /* see REAF above, must match */
 372 #define CHF_LEA         0x00000004      /* see REAF above, must match */
 373 #define CHF_NODROP      0x00000008      /* see REAF above, must match */
 374 #define CHF_FLOAT       0x00000010      /* see REAF above, must match */
 375
 376 #define CHF_READ1       (CHF_READ)
 377 #define CHF_READ2       (CHF_READ << CHF_ARG2SHIFT)
 378 #define CHF_READ3       (CHF_READ << CHF_ARG3SHIFT)
 379 #define CHF_READ4       (CHF_READ << CHF_ARG4SHIFT)
 380 #define CHF_WRITE1      (CHF_WRITE)
 381 #define CHF_WRITE2      (CHF_WRITE << CHF_ARG2SHIFT)
 382 #define CHF_WRITE3      (CHF_WRITE << CHF_ARG3SHIFT)
 383 #define CHF_WRITE4      (CHF_WRITE << CHF_ARG4SHIFT)
 384 #define CHF_LEA1        (CHF_LEA)
 385 #define CHF_LEA2        (CHF_LEA << CHF_ARG2SHIFT)
 386 #define CHF_LEA3        (CHF_LEA << CHF_ARG3SHIFT)
 387 #define CHF_LEA4        (CHF_LEA << CHF_ARG4SHIFT)
 388 #define CHF_NODROP1     (CHF_NODROP)
 389 #define CHF_NODROP2     (CHF_NODROP << CHF_ARG2SHIFT)
 390 #define CHF_NODROP3     (CHF_NODROP << CHF_ARG3SHIFT)
 391 #define CHF_NODROP4     (CHF_NODROP << CHF_ARG4SHIFT)
 392 #define CHF_FLOAT1      (CHF_FLOAT)
 393 #define CHF_FLOAT2      (CHF_FLOAT << CHF_ARG2SHIFT)
 394 #define CHF_FLOAT3      (CHF_FLOAT << CHF_ARG3SHIFT)
 395 #define CHF_FLOAT4      (CHF_FLOAT << CHF_ARG4SHIFT)
 396
 397 #define CHF_ARG1MASK    0x0000001F
 398 #define CHF_ARG2MASK    0x000003E0
 399 #define CHF_ARG3MASK    0x00007C00
 400 #define CHF_ARG4MASK    0x000F8000
 401
 402 #define CHF_READLST     0x10000000
 403 #define CHF_WRITELST    0x20000000
 404 #define CHF_FLOATLST    0x40000000
 405 #define CHF_UNUSED8     0x80000000U
 406
 407 #define CHF_ARG1SHIFT   0               /* ease processing for each arg */
 408 #define CHF_ARG2SHIFT   5
 409 #define CHF_ARG3SHIFT   10
 410 #define CHF_ARG4SHIFT   15
 411
 412 #define REXT_I8         0x01
 413 #define REXT_I16        0x02
 414 #define REXT_I32        0x03
 415 #define REXT_I64        0x04
 416 #define REXT_I128       0x05
 417 #define REXT_F32        (0x03 | REXTF_FLOAT)
 418 #define REXT_F64        (0x04 | REXTF_FLOAT)
 419 #define REXT_F128       (0x05 | REXTF_FLOAT)
 420
 421 #define REXTF_FLOAT     0x10
 422 #define REXTF_SEA1      0x20            /* override use ext1 for first arg */
 423 #define REXTF_EA2       0x40            /* use ext2 for both */
 424 #define REXTF_IMASK     (0x0F)
 425 #define REXTF_MASK      (0x0F | REXTF_FLOAT)
 426
 427 extern int ProcNo;
 428 extern int OptComplexity;
 429 extern runesize_t ProcStackSize;
 430 extern runesize_t ProcStackPad;
 431 extern void (*RegAllocator)(RASParser *p, rblock_t *rblock, runesize_t bytes);
 432 extern void (*ProbeFunc)(RASParser *p, rinsn_t *rin);
 433
 434 /*
 435  * Drop the span's EA.  Note that rea->direct is handled independently.
 436  *
 437  */
 438 static __inline
 439 void
 440 droprea(rspan_t *span)
 441 {
 442         rea_t *rea;
 443
 444         rea = span->rea;
 445         if (rea) {
 446                 dassert(rea->refs > 0);
 447                 if (--rea->refs == 0) {
 448                         rea->direct = NULL;             /* ref held by spand */
 449                         zfree(rea, sizeof(*rea));
 450                 }
 451                 span->rea = NULL;
 452         }
 453 }
 454
 455 void RasSymInit(void);
 456 void RasSymReinit(void);
 457
 458 RASParser *RasOpen(const char *path);
 459 void RasClose(RASParser *p);
 460 int RasLine(RASParser *p, rsym_t **symp);
 461 rastoken_t RasToken(RASParser *p);
 462 void RasGetValue(RASParser *p, uint8_t opsize, int64_t *lowp, int64_t *highp);
 463
 464 void RasError(RASParser *p, const char *ctl, ...);
 465 void RasFatal(RASParser *p, const char *ctl, ...);
 466
 467 rsym_t *RasGetSymbol(const uint8_t *ptr, size_t bytes);
 468
 469 void RasParseTopLine(RASParser *p, rsym_t *sym);
 470
 471 void RasEmitLabel(RASParser *p, rsym_t *sym);
 472
 473 void PsopSECTION(RASParser *p, rinsn_t *rin);
 474 void PsopENDSECTION(RASParser *p, rinsn_t *rin);
 475 void PsopEXTERN(RASParser *p, rinsn_t *rin);
 476 void PsopRODATA(RASParser *p, rinsn_t *rin);
 477 void PsopBSS(RASParser *p, rinsn_t *rin);
 478 void PsopDATA(RASParser *p, rinsn_t *rin);
 479 void PsopTEXT(RASParser *p, rinsn_t *rin);
 480 void PsopPROC(RASParser *p, rinsn_t *rin);
 481 void PsopALIGN(RASParser *p, rinsn_t *rin);
 482 void PsopWEAK(RASParser *p, rinsn_t *rin);
 483 void PsopGLOBL(RASParser *p, rinsn_t *rin);
 484 void PsopCTORS(RASParser *p, rinsn_t *rin);
 485 void PsopLOC(RASParser *p, rinsn_t *rin);
 486 void PsopFILE(RASParser *p, rinsn_t *rin);
 487
 488 void PsopZERO(RASParser *p, rinsn_t *rin);
 489 void PsopLAYOUT(RASParser *p, rinsn_t *rin);
 490
 491 void InsnTargetInit(void);
 492 void InsnTargetAdjust(RASParser *p, rinsn_t *rin);
 493 void InsnProcedureBasicBlock(RASParser *p, rblock_t *rblock,
 494                         runesize_t bytes, runesize_t align);
 495 void InsnProcedureStart(RASParser *p, runesize_t bytes, runesize_t align);
 496 void InsnProcedureEnd(RASParser *p, runesize_t bytes, runesize_t align);
 497 void InsnDebugREG(uint16_t target_reg, uint8_t ext);
 498
 499 void InsnLABEL(RASParser *p, rinsn_t *rin);
 500 void InsnMOVE(RASParser *p, rinsn_t *rin);
 501 void InsnADD(RASParser *p, rinsn_t *rin);
 502 void InsnSUB(RASParser *p, rinsn_t *rin);
 503 void InsnAND(RASParser *p, rinsn_t *rin);
 504 void InsnOR(RASParser *p, rinsn_t *rin);
 505 void InsnXOR(RASParser *p, rinsn_t *rin);
 506 void InsnNOT(RASParser *p, rinsn_t *rin);
 507 void InsnCOM(RASParser *p, rinsn_t *rin);
 508 void InsnNEG(RASParser *p, rinsn_t *rin);
 509 void InsnPOS(RASParser *p, rinsn_t *rin);
 510 void InsnASL(RASParser *p, rinsn_t *rin);
 511 void InsnASR(RASParser *p, rinsn_t *rin);
 512 void InsnLSR(RASParser *p, rinsn_t *rin);
 513 void InsnADDC(RASParser *p, rinsn_t *rin);
 514 void InsnSUBC(RASParser *p, rinsn_t *rin);
 515
 516 void InsnMULU(RASParser *p, rinsn_t *rin);
 517 void InsnMULS(RASParser *p, rinsn_t *rin);
 518 void InsnDIVU(RASParser *p, rinsn_t *rin);
 519 void InsnDIVS(RASParser *p, rinsn_t *rin);
 520 void InsnMODU(RASParser *p, rinsn_t *rin);
 521 void InsnMODS(RASParser *p, rinsn_t *rin);
 522
 523 void InsnINC(RASParser *p, rinsn_t *rin);
 524 void InsnDEC(RASParser *p, rinsn_t *rin);
 525
 526 void InsnCMP(RASParser *p, rinsn_t *rin);
 527
 528 void InsnMOVEA(RASParser *p, rinsn_t *rin);
 529 void InsnADDA(RASParser *p, rinsn_t *rin);
 530 void InsnSUBA(RASParser *p, rinsn_t *rin);
 531 void InsnADDAU(RASParser *p, rinsn_t *rin);
 532 void InsnSUBAU(RASParser *p, rinsn_t *rin);
 533 void InsnSUBAA(RASParser *p, rinsn_t *rin);
 534 void InsnLEA(RASParser *p, rinsn_t *rin);
 535
 536 void InsnBCOPY(RASParser *p, rinsn_t *rin);
 537 void InsnBZERO(RASParser *p, rinsn_t *rin);
 538
 539 void InsnCMPTYPE(RASParser *p, rinsn_t *rin);
 540
 541 void InsnCMPA(RASParser *p, rinsn_t *rin);
 542
 543 void InsnCASTU(RASParser *p, rinsn_t *rin);
 544 void InsnCASTS(RASParser *p, rinsn_t *rin);
 545 void InsnCASTP(RASParser *p, rinsn_t *rin);
 546
 547 void InsnPCOPY(RASParser *p, rinsn_t *rin);
 548 void InsnPCHECK(RASParser *p, rinsn_t *rin);
 549
 550 void InsnPGET(RASParser *p, rinsn_t *rin);
 551 void InsnPGETH(RASParser *p, rinsn_t *rin);
 552 void InsnPPUT(RASParser *p, rinsn_t *rin);
 553 void InsnPPUTH(RASParser *p, rinsn_t *rin);
 554 void InsnPREF(RASParser *p, rinsn_t *rin);
 555 void InsnPREL(RASParser *p, rinsn_t *rin);
 556 void InsnPLOCK(RASParser *p, rinsn_t *rin);
 557 void InsnPLOCKH(RASParser *p, rinsn_t *rin);
 558 void InsnPUNLOCK(RASParser *p, rinsn_t *rin);
 559 void InsnPUNLOCKH(RASParser *p, rinsn_t *rin);
 560 void InsnPATOM(RASParser *p, rinsn_t *rin);
 561
 562 void InsnPIGET(RASParser *p, rinsn_t *rin);
 563 void InsnPIGETH(RASParser *p, rinsn_t *rin);
 564
 565 void InsnSTKIGET(RASParser *p, rinsn_t *rin);
 566 void InsnSTKIGETH(RASParser *p, rinsn_t *rin);
 567 void InsnSTKIREF(RASParser *p, rinsn_t *rin);
 568
 569 void InsnSRSGET(RASParser *p, rinsn_t *rin);
 570 void InsnSRSGETH(RASParser *p, rinsn_t *rin);
 571 void InsnSRSPUT(RASParser *p, rinsn_t *rin);
 572 void InsnSRSPUTH(RASParser *p, rinsn_t *rin);
 573
 574 void InsnIGET(RASParser *p, rinsn_t *rin);
 575 void InsnIGETH(RASParser *p, rinsn_t *rin);
 576 void InsnIPUT(RASParser *p, rinsn_t *rin);
 577 void InsnIPUTH(RASParser *p, rinsn_t *rin);
 578 void InsnIREF(RASParser *p, rinsn_t *rin);
 579 void InsnIREL(RASParser *p, rinsn_t *rin);
 580 void InsnILOCK(RASParser *p, rinsn_t *rin);
 581 void InsnILOCKH(RASParser *p, rinsn_t *rin);
 582 void InsnIUNLOCK(RASParser *p, rinsn_t *rin);
 583 void InsnIUNLOCKH(RASParser *p, rinsn_t *rin);
 584 void InsnINEW(RASParser *p, rinsn_t *rin);
 585 void InsnIATOM(RASParser *p, rinsn_t *rin);
 586
 587 void InsnLVALLOC(RASParser *p, rinsn_t *rin);
 588
 589 void InsnBNDTRAP(RASParser *p, rinsn_t *rin);
 590 void InsnCALL(RASParser *p, rinsn_t *rin);
 591 void InsnTCALL(RASParser *p, rinsn_t *rin);
 592 void InsnLCALL(RASParser *p, rinsn_t *rin);
 593 void InsnQCALL(RASParser *p, rinsn_t *rin);
 594 void InsnRCALL(RASParser *p, rinsn_t *rin);
 595
 596 void InsnRET(RASParser *p, rinsn_t *rin);
 597 void InsnDET(RASParser *p, rinsn_t *rin);
 598 void InsnLINK(RASParser *p, rinsn_t *rin);
 599 void InsnTSCHED(RASParser *p, rinsn_t *rin);
 600
 601 void InsnJMP(RASParser *p, rinsn_t *rin);
 602 void InsnTEST(RASParser *p, rinsn_t *rin);
 603
 604 void InsnFMOVE(RASParser *p, rinsn_t *rin);
 605 void InsnFADD(RASParser *p, rinsn_t *rin);
 606 void InsnFSUB(RASParser *p, rinsn_t *rin);
 607 void InsnFMUL(RASParser *p, rinsn_t *rin);
 608 void InsnFDIV(RASParser *p, rinsn_t *rin);
 609
 610 void InsnFINC(RASParser *p, rinsn_t *rin);
 611 void InsnFDEC(RASParser *p, rinsn_t *rin);
 612 void InsnFNEG(RASParser *p, rinsn_t *rin);
 613 void InsnFPOS(RASParser *p, rinsn_t *rin);
 614 void InsnFNOT(RASParser *p, rinsn_t *rin);
 615
 616 void InsnUITOF(RASParser *p, rinsn_t *rin);
 617 void InsnSITOF(RASParser *p, rinsn_t *rin);
 618 void InsnFTOUI(RASParser *p, rinsn_t *rin);
 619 void InsnFTOSI(RASParser *p, rinsn_t *rin);
 620 void InsnCASTF(RASParser *p, rinsn_t *rin);
 621
 622 void InsnFCMP(RASParser *p, rinsn_t *rin);
 623
 624 rblock_t *RasBlockAlloc(rblock_list_t *list);
 625 void RasBlockAdd(rblock_t *rblock, rinsn_t *rin);
 626 void BlockCharacterize(RASParser *p, rblock_t *rblock);
 627 void BlockCollapse(RASParser *p, rblock_t *rblock);
 628 void SpanClear(rspan_t *root);
 629
 630 rastoken_t RasParseInsnEXT(RASParser *p, rastoken_t r, rinsn_t *rin);
 631 rastoken_t RasParseEA(RASParser *p, rastoken_t t, rinsn_t *rin,
 632                         rspan_t *arg, rspan_t *argd);
 633 rastoken_t RasParseSymbol(RASParser *p, rastoken_t t, rsym_t **symp);
 634 rastoken_t RasParseLabel(RASParser *p, rastoken_t t, rsym_t **symp);
 635 rastoken_t RasParseSizeValue(RASParser *p, rastoken_t t, runesize_t *valuep);
 636 void CreateGlobalImmediate(rea_t *sea, rea_t *dea, uint8_t ext);
 637 void DumpGlobalImmediates(void);
 638
 639 void RasInvalidateRegNumbering(void);
 640 void RasResetRegNumbering(void);
 641 uint32_t RasAllocReg(void);
 642