git.gag.com Git - fw/sdcc/blob - src/pic/pcode.h

   1 /*-------------------------------------------------------------------------
   2
   3    pcode.h - post code generation
   4    Written By -  Scott Dattalo scott@dattalo.com
   5
   6    This program is free software; you can redistribute it and/or modify it
   7    under the terms of the GNU General Public License as published by the
   8    Free Software Foundation; either version 2, or (at your option) any
   9    later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program; if not, write to the Free Software
  18    Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  19
  20 -------------------------------------------------------------------------*/
  21
  22 //#include "ralloc.h"
  23 struct regs;
  24
  25 /*
  26    Post code generation
  27
  28    The post code generation is an assembler optimizer. The assembly code
  29    produced by all of the previous steps is fully functional. This step
  30    will attempt to analyze the flow of the assembly code and agressively
  31    optimize it. The peep hole optimizer attempts to do the same thing.
  32    As you may recall, the peep hole optimizer replaces blocks of assembly
  33    with more optimal blocks (e.g. removing redundant register loads).
  34    However, the peep hole optimizer has to be somewhat conservative since
  35    an assembly program has implicit state information that's unavailable
  36    when only a few instructions are examined.
  37      Consider this example:
  38
  39    example1:
  40      movwf  t1
  41      movf   t1,w
  42
  43    The movf seems redundant since we know that the W register already
  44    contains the same value of t1. So a peep hole optimizer is tempted to
  45    remove the "movf". However, this is dangerous since the movf affects
  46    the flags in the status register (specifically the Z flag) and subsequent
  47    code may depend upon this. Look at these two examples:
  48
  49    example2:
  50      movwf  t1
  51      movf   t1,w     ; Can't remove this movf
  52      skpz
  53       return
  54
  55    example3:
  56      movwf  t1
  57      movf   t1,w     ; This  movf can be removed
  58      xorwf  t2,w     ; since xorwf will over write Z
  59      skpz
  60       return
  61
  62 */
  63
  64
  65 #ifndef __PCODE_H__
  66 #define __PCODE_H__
  67
  68 /***********************************************************************
  69  * debug stuff
  70  *
  71  * The DFPRINTF macro will call fprintf if PCODE_DEBUG is defined.
  72  * The macro is used like:
  73  *
  74  * DPRINTF(("%s #%d\n","test", 1));
  75  *
  76  * The double parenthesis (()) are necessary
  77  *
  78  ***********************************************************************/
  79 //#define PCODE_DEBUG
  80
  81 #ifdef PCODE_DEBUG
  82 #define DFPRINTF(args) (fprintf args)
  83 #else
  84 #define DFPRINTF(args) ;
  85 #endif
  86
  87
  88 /***********************************************************************
  89  *  PIC status bits - this will move into device dependent headers
  90  ***********************************************************************/
  91 #define PIC_C_BIT    0
  92 #define PIC_DC_BIT   1
  93 #define PIC_Z_BIT    2
  94 #define PIC_RP0_BIT  5   /* Register Bank select bits RP1:0 : */
  95 #define PIC_RP1_BIT  6   /* 00 - bank 0, 01 - bank 1, 10 - bank 2, 11 - bank 3 */
  96 #define PIC_IRP_BIT  7   /* Indirect register page select */
  97
  98 /***********************************************************************
  99  *  PIC INTCON bits - this will move into device dependent headers
 100  ***********************************************************************/
 101 #define PIC_RBIF_BIT 0   /* Port B level has changed flag */
 102 #define PIC_INTF_BIT 1   /* Port B bit 0 interrupt on edge flag */
 103 #define PIC_T0IF_BIT 2   /* TMR0 has overflowed flag */
 104 #define PIC_RBIE_BIT 3   /* Port B level has changed - Interrupt Enable */
 105 #define PIC_INTE_BIT 4   /* Port B bit 0 interrupt on edge - Int Enable */
 106 #define PIC_T0IE_BIT 5   /* TMR0 overflow Interrupt Enable */
 107 #define PIC_PIE_BIT  6   /* Peripheral Interrupt Enable */
 108 #define PIC_GIE_BIT  7   /* Global Interrupt Enable */
 109
 110 /***********************************************************************
 111  *  Operand types
 112  ***********************************************************************/
 113 #define POT_RESULT  0
 114 #define POT_LEFT    1
 115 #define POT_RIGHT   2
 116
 117
 118 /***********************************************************************
 119  *
 120  *  PIC_OPTYPE - Operand types that are specific to the PIC architecture
 121  *
 122  *  If a PIC assembly instruction has an operand then here is where we
 123  *  associate a type to it. For example,
 124  *
 125  *     movf    reg,W
 126  *
 127  *  The movf has two operands: 'reg' and the W register. 'reg' is some
 128  *  arbitrary general purpose register, hence it has the type PO_GPR_REGISTER.
 129  *  The W register, which is the PIC's accumulator, has the type PO_W.
 130  *
 131  ***********************************************************************/
 132
 133
 134
 135 typedef enum
 136 {
 137   PO_NONE=0,         // No operand e.g. NOP
 138   PO_W,              // The 'W' register
 139   PO_STATUS,         // The 'STATUS' register
 140   PO_FSR,            // The "file select register" (in 18c it's one of three)
 141   PO_INDF,           // The Indirect register
 142   PO_INTCON,         // Interrupt Control register
 143   PO_GPR_REGISTER,   // A general purpose register
 144   PO_GPR_BIT,        // A bit of a general purpose register
 145   PO_GPR_TEMP,       // A general purpose temporary register
 146   PO_SFR_REGISTER,   // A special function register (e.g. PORTA)
 147   PO_PCL,            // Program counter Low register
 148   PO_PCLATH,         // Program counter Latch high register
 149   PO_LITERAL,        // A constant
 150   PO_IMMEDIATE,      //  (8051 legacy)
 151   PO_DIR,            // Direct memory (8051 legacy)
 152   PO_CRY,            // bit memory (8051 legacy)
 153   PO_BIT,            // bit operand.
 154   PO_STR,            //  (8051 legacy)
 155   PO_LABEL,
 156   PO_WILD            // Wild card operand in peep optimizer
 157 } PIC_OPTYPE;
 158
 159
 160 /***********************************************************************
 161  *
 162  *  PIC_OPCODE
 163  *
 164  *  This is not a list of the PIC's opcodes per se, but instead
 165  *  an enumeration of all of the different types of pic opcodes.
 166  *
 167  ***********************************************************************/
 168
 169 typedef enum
 170 {
 171   POC_WILD=-1,   /* Wild card - used in the pCode peep hole optimizer
 172                   * to represent ANY pic opcode */
 173   POC_ADDLW=0,
 174   POC_ADDWF,
 175   POC_ADDFW,
 176   POC_ANDLW,
 177   POC_ANDWF,
 178   POC_ANDFW,
 179   POC_BCF,
 180   POC_BSF,
 181   POC_BTFSC,
 182   POC_BTFSS,
 183   POC_CALL,
 184   POC_COMF,
 185   POC_COMFW,
 186   POC_CLRF,
 187   POC_CLRW,
 188   POC_CLRWDT,
 189   POC_DECF,
 190   POC_DECFW,
 191   POC_DECFSZ,
 192   POC_DECFSZW,
 193   POC_GOTO,
 194   POC_INCF,
 195   POC_INCFW,
 196   POC_INCFSZ,
 197   POC_INCFSZW,
 198   POC_IORLW,
 199   POC_IORWF,
 200   POC_IORFW,
 201   POC_MOVF,
 202   POC_MOVFW,
 203   POC_MOVLW,
 204   POC_MOVWF,
 205   POC_NOP,
 206   POC_RETLW,
 207   POC_RETURN,
 208   POC_RETFIE,
 209   POC_RLF,
 210   POC_RLFW,
 211   POC_RRF,
 212   POC_RRFW,
 213   POC_SUBLW,
 214   POC_SUBWF,
 215   POC_SUBFW,
 216   POC_SWAPF,
 217   POC_SWAPFW,
 218   POC_TRIS,
 219   POC_XORLW,
 220   POC_XORWF,
 221   POC_XORFW
 222 } PIC_OPCODE;
 223
 224
 225 /***********************************************************************
 226  *  PC_TYPE  - pCode Types
 227  ***********************************************************************/
 228
 229 typedef enum
 230 {
 231   PC_COMMENT=0,   /* pCode is a comment     */
 232   PC_INLINE,      /* user's inline code     */
 233   PC_OPCODE,      /* PORT dependent opcode  */
 234   PC_LABEL,       /* assembly label         */
 235   PC_FLOW,        /* flow analysis          */
 236   PC_FUNCTION,    /* Function start or end  */
 237   PC_WILD,        /* wildcard - an opcode place holder used
 238                    * in the pCode peep hole optimizer */
 239   PC_CSOURCE,     /* C-Source Line  */
 240   PC_BAD          /* Mark the pCode object as being bad */
 241 } PC_TYPE;
 242
 243 /************************************************/
 244 /***************  Structures ********************/
 245 /************************************************/
 246 /* These are here as forward references - the
 247  * full definition of these are below           */
 248 struct pCode;
 249 struct pCodeWildBlock;
 250 struct pCodeRegLives;
 251
 252 /*************************************************
 253   pBranch
 254
 255   The first step in optimizing pCode is determining
 256  the program flow. This information is stored in
 257  single-linked lists in the for of 'from' and 'to'
 258  objects with in a pcode. For example, most instructions
 259  don't involve any branching. So their from branch
 260  points to the pCode immediately preceding them and
 261  their 'to' branch points to the pcode immediately
 262  following them. A skip instruction is an example of
 263  a pcode that has multiple (in this case two) elements
 264  in the 'to' branch. A 'label' pcode is an where there
 265  may be multiple 'from' branches.
 266  *************************************************/
 267
 268 typedef struct pBranch
 269 {
 270   struct pCode   *pc;    // Next pCode in a branch
 271   struct pBranch *next;  /* If more than one branch
 272                           * the next one is here */
 273
 274 } pBranch;
 275
 276 /*************************************************
 277   pCodeOp
 278
 279   pCode Operand structure.
 280   For those assembly instructions that have arguments,
 281   the pCode will have a pCodeOp in which the argument
 282   can be stored. For example
 283
 284     movf   some_register,w
 285
 286   'some_register' will be stored/referenced in a pCodeOp
 287
 288  *************************************************/
 289
 290 typedef struct pCodeOp
 291 {
 292   PIC_OPTYPE type;
 293   char *name;
 294
 295 } pCodeOp;
 296 #if 0
 297 typedef struct pCodeOpBit
 298 {
 299   pCodeOp pcop;
 300   int bit;
 301   unsigned int inBitSpace: 1; /* True if in bit space, else
 302                                  just a bit of a register */
 303 } pCodeOpBit;
 304 #endif
 305 typedef struct pCodeOpLit
 306 {
 307   pCodeOp pcop;
 308   int lit;
 309 } pCodeOpLit;
 310
 311 typedef struct pCodeOpImmd
 312 {
 313   pCodeOp pcop;
 314   int offset;           /* low,med, or high byte of immediat value */
 315   int index;            /* add this to the immediate value */
 316   unsigned _const:1;    /* is in code space    */
 317
 318   int rIdx;             /* If this immd points to a register */
 319   struct regs *r;       /* then this is the reg. */
 320
 321 } pCodeOpImmd;
 322
 323 typedef struct pCodeOpLabel
 324 {
 325   pCodeOp pcop;
 326   int key;
 327 } pCodeOpLabel;
 328
 329 typedef struct pCodeOpReg
 330 {
 331   pCodeOp pcop;    // Can be either GPR or SFR
 332   int rIdx;        // Index into the register table
 333   struct regs *r;
 334   int instance;    // byte # of Multi-byte registers
 335   struct pBlock *pb;
 336 } pCodeOpReg;
 337
 338 typedef struct pCodeOpRegBit
 339 {
 340   pCodeOpReg  pcor;       // The Register containing this bit
 341   int bit;                // 0-7 bit number.
 342   PIC_OPTYPE subtype;     // The type of this register.
 343   unsigned int inBitSpace: 1; /* True if in bit space, else
 344                                  just a bit of a register */
 345 } pCodeOpRegBit;
 346
 347
 348 typedef struct pCodeOpWild
 349 {
 350   pCodeOp pcop;
 351
 352   struct pCodeWildBlock *pcwb;
 353
 354   int id;                 /* index into an array of char *'s that will match
 355                            * the wild card. The array is in *pcp. */
 356   pCodeOp *subtype;       /* Pointer to the Operand type into which this wild
 357                            * card will be expanded */
 358   pCodeOp *matched;       /* When a wild matches, we'll store a pointer to the
 359                            * opcode we matched */
 360
 361 } pCodeOpWild;
 362
 363
 364 /*************************************************
 365     pCode
 366
 367     Here is the basic build block of a PIC instruction.
 368     Each pic instruction will get allocated a pCode.
 369     A linked list of pCodes makes a program.
 370
 371 **************************************************/
 372
 373 typedef struct pCode
 374 {
 375   PC_TYPE    type;
 376
 377   struct pCode *prev;  // The pCode objects are linked together
 378   struct pCode *next;  // in doubly linked lists.
 379
 380   int seq;             // sequence number
 381
 382   struct pBlock *pb;   // The pBlock that contains this pCode.
 383
 384   /* "virtual functions"
 385    *  The pCode structure is like a base class
 386    * in C++. The subsequent structures that "inherit"
 387    * the pCode structure will initialize these function
 388    * pointers to something useful */
 389   //  void (*analyze) (struct pCode *_this);
 390   void (*destruct)(struct pCode *_this);
 391   void (*print)  (FILE *of,struct pCode *_this);
 392
 393 } pCode;
 394
 395
 396 /*************************************************
 397     pCodeComment
 398 **************************************************/
 399
 400 typedef struct pCodeComment
 401 {
 402
 403   pCode  pc;
 404
 405   char *comment;
 406
 407 } pCodeComment;
 408
 409 /*************************************************
 410     pCodeComment
 411 **************************************************/
 412
 413 typedef struct pCodeCSource
 414 {
 415
 416   pCode  pc;
 417
 418   int  line_number;
 419   char *line;
 420   char *file_name;
 421
 422 } pCodeCSource;
 423
 424
 425 /*************************************************
 426     pCodeFlow
 427
 428   The Flow object is used as marker to separate
 429  the assembly code into contiguous chunks. In other
 430  words, everytime an instruction cause or potentially
 431  causes a branch, a Flow object will be inserted into
 432  the pCode chain to mark the beginning of the next
 433  contiguous chunk.
 434
 435 **************************************************/
 436
 437 typedef struct pCodeFlow
 438 {
 439
 440   pCode  pc;
 441
 442   pCode *end;   /* Last pCode in this flow. Note that
 443                    the first pCode is pc.next */
 444
 445   /*  set **uses;   * map the pCode instruction inCond and outCond conditions
 446                  * in this array of set's. The reason we allocate an
 447                  * array of pointers instead of declaring each type of
 448                  * usage is because there are port dependent usage definitions */
 449   //int nuses;    /* number of uses sets */
 450
 451   set *from;    /* flow blocks that can send control to this flow block */
 452   set *to;      /* flow blocks to which this one can send control */
 453   struct pCodeFlow *ancestor; /* The most immediate "single" pCodeFlow object that
 454                                * executes prior to this one. In many cases, this
 455                                * will be just the previous */
 456
 457   int inCond;   /* Input conditions - stuff assumed defined at entry */
 458   int outCond;  /* Output conditions - stuff modified by flow block */
 459
 460   int firstBank; /* The first and last bank flags are the first and last */
 461   int lastBank;  /* register banks used within one flow object */
 462
 463   int FromConflicts;
 464   int ToConflicts;
 465
 466   set *registers;/* Registers used in this flow */
 467
 468 } pCodeFlow;
 469
 470 /*************************************************
 471   pCodeFlowLink
 472
 473   The Flow Link object is used to record information
 474  about how consecutive excutive Flow objects are related.
 475  The pCodeFlow objects demarcate the pCodeInstructions
 476  into contiguous chunks. The FlowLink records conflicts
 477  in the discontinuities. For example, if one Flow object
 478  references a register in bank 0 and the next Flow object
 479  references a register in bank 1, then there is a discontinuity
 480  in the banking registers.
 481
 482 */
 483 typedef struct pCodeFlowLink
 484 {
 485   pCodeFlow  *pcflow;   /* pointer to linked pCodeFlow object */
 486
 487   int bank_conflict;    /* records bank conflicts */
 488
 489 } pCodeFlowLink;
 490
 491 /*************************************************
 492     pCodeInstruction
 493
 494     Here we describe all the facets of a PIC instruction
 495     (expansion for the 18cxxx is also provided).
 496
 497 **************************************************/
 498
 499 typedef struct pCodeInstruction
 500 {
 501
 502   pCode  pc;
 503
 504   PIC_OPCODE op;        // The opcode of the instruction.
 505
 506   char const * const mnemonic;       // Pointer to mnemonic string
 507
 508   pBranch *from;       // pCodes that execute before this one
 509   pBranch *to;         // pCodes that execute after
 510   pBranch *label;      // pCode instructions that have labels
 511
 512   pCodeOp *pcop;               /* Operand, if this instruction has one */
 513   pCodeFlow *pcflow;           /* flow block to which this instruction belongs */
 514   pCodeCSource *cline;         /* C Source from which this instruction was derived */
 515
 516   unsigned int num_ops;        /* Number of operands (0,1,2 for mid range pics) */
 517   unsigned int isModReg:  1;   /* If destination is W or F, then 1==F */
 518   unsigned int isBitInst: 1;   /* e.g. BCF */
 519   unsigned int isBranch:  1;   /* True if this is a branching instruction */
 520   unsigned int isSkip:    1;   /* True if this is a skip instruction */
 521   unsigned int isLit:     1;   /* True if this instruction has an literal operand */
 522
 523   PIC_OPCODE inverted_op;      /* Opcode of instruction that's the opposite of this one */
 524   unsigned int inCond;   // Input conditions for this instruction
 525   unsigned int outCond;  // Output conditions for this instruction
 526
 527 } pCodeInstruction;
 528
 529
 530 /*************************************************
 531     pCodeLabel
 532 **************************************************/
 533
 534 typedef struct pCodeLabel
 535 {
 536
 537   pCode  pc;
 538
 539   char *label;
 540   int key;
 541
 542 } pCodeLabel;
 543
 544 /*************************************************
 545     pCodeFunction
 546 **************************************************/
 547
 548 typedef struct pCodeFunction
 549 {
 550
 551   pCode  pc;
 552
 553   char *modname;
 554   char *fname;     /* If NULL, then this is the end of
 555                       a function. Otherwise, it's the
 556                       start and the name is contained
 557                       here */
 558
 559   pBranch *from;       // pCodes that execute before this one
 560   pBranch *to;         // pCodes that execute after
 561   pBranch *label;      // pCode instructions that have labels
 562
 563   int  ncalled;    /* Number of times function is called */
 564
 565 } pCodeFunction;
 566
 567
 568 /*************************************************
 569     pCodeWild
 570 **************************************************/
 571
 572 typedef struct pCodeWild
 573 {
 574
 575   pCodeInstruction  pci;
 576
 577   int    id;     /* Index into the wild card array of a peepBlock
 578                   * - this wild card will get expanded into that pCode
 579                   *   that is stored at this index */
 580
 581   /* Conditions on wild pcode instruction */
 582   int    mustBeBitSkipInst:1;
 583   int    mustNotBeBitSkipInst:1;
 584   int    invertBitSkipInst:1;
 585
 586   pCodeOp *operand;  // Optional operand
 587   pCodeOp *label;    // Optional label
 588
 589 } pCodeWild;
 590
 591 /*************************************************
 592     pBlock
 593
 594     Here are PIC program snippets. There's a strong
 595     correlation between the eBBlocks and pBlocks.
 596     SDCC subdivides a C program into managable chunks.
 597     Each chunk becomes a eBBlock and ultimately in the
 598     PIC port a pBlock.
 599
 600 **************************************************/
 601
 602 typedef struct pBlock
 603 {
 604   memmap *cmemmap;   /* The snippet is from this memmap */
 605   char   dbName;     /* if cmemmap is NULL, then dbName will identify the block */
 606   pCode *pcHead;     /* A pointer to the first pCode in a link list of pCodes */
 607   pCode *pcTail;     /* A pointer to the last pCode in a link list of pCodes */
 608
 609   struct pBlock *next;      /* The pBlocks will form a doubly linked list */
 610   struct pBlock *prev;
 611
 612   set *function_entries;    /* dll of functions in this pblock */
 613   set *function_exits;
 614   set *function_calls;
 615   set *tregisters;
 616
 617   set *FlowTree;
 618   unsigned visited:1;       /* set true if traversed in call tree */
 619
 620   unsigned seq;             /* sequence number of this pBlock */
 621
 622 } pBlock;
 623
 624 /*************************************************
 625     pFile
 626
 627     The collection of pBlock program snippets are
 628     placed into a linked list that is implemented
 629     in the pFile structure.
 630
 631     The pcode optimizer will parse the pFile.
 632
 633 **************************************************/
 634
 635 typedef struct pFile
 636 {
 637   pBlock *pbHead;     /* A pointer to the first pBlock */
 638   pBlock *pbTail;     /* A pointer to the last pBlock */
 639
 640   pBranch *functions; /* A SLL of functions in this pFile */
 641
 642 } pFile;
 643
 644
 645
 646 /*************************************************
 647   pCodeWildBlock
 648
 649   The pCodeWildBlock object keeps track of the wild
 650   variables, operands, and opcodes that exist in
 651   a pBlock.
 652 **************************************************/
 653 typedef struct pCodeWildBlock {
 654   pBlock    *pb;
 655   struct pCodePeep *pcp;    // pointer back to ... I don't like this...
 656
 657   int       nvars;          // Number of wildcard registers in target.
 658   char    **vars;           // array of pointers to them
 659
 660   int       nops;           // Number of wildcard operands in target.
 661   pCodeOp **wildpCodeOps;   // array of pointers to the pCodeOp's.
 662
 663   int       nwildpCodes;    // Number of wildcard pCodes in target/replace
 664   pCode   **wildpCodes;     // array of pointers to the pCode's.
 665
 666 } pCodeWildBlock;
 667
 668 /*************************************************
 669   pCodePeep
 670
 671   The pCodePeep object mimics the peep hole optimizer
 672   in the main SDCC src (e.g. SDCCpeeph.c). Essentially
 673   there is a target pCode chain and a replacement
 674   pCode chain. The target chain is compared to the
 675   pCode that is generated by gen.c. If a match is
 676   found then the pCode is replaced by the replacement
 677   pCode chain.
 678 **************************************************/
 679 typedef struct pCodePeep {
 680   pCodeWildBlock target;     // code we'd like to optimize
 681   pCodeWildBlock replace;    // and this is what we'll optimize it with.
 682
 683   //pBlock *target;
 684   //pBlock replace;            // and this is what we'll optimize it with.
 685
 686
 687
 688   /* (Note: a wildcard register is a place holder. Any register
 689    * can be replaced by the wildcard when the pcode is being
 690    * compared to the target. */
 691
 692   /* Post Conditions. A post condition is a condition that
 693    * must be either true or false before the peep rule is
 694    * accepted. For example, a certain rule may be accepted
 695    * if and only if the Z-bit is not used as an input to
 696    * the subsequent instructions in a pCode chain.
 697    */
 698   unsigned int postFalseCond;
 699   unsigned int postTrueCond;
 700
 701 } pCodePeep;
 702
 703 /*************************************************
 704
 705   pCode peep command definitions
 706
 707  Here are some special commands that control the
 708 way the peep hole optimizer behaves
 709
 710 **************************************************/
 711
 712 enum peepCommandTypes{
 713   NOTBITSKIP = 0,
 714   BITSKIP,
 715   INVERTBITSKIP,
 716   _LAST_PEEP_COMMAND_
 717 };
 718
 719 /*************************************************
 720     peepCommand structure stores the peep commands.
 721
 722 **************************************************/
 723
 724 typedef struct peepCommand {
 725   int id;
 726   char *cmd;
 727 } peepCommand;
 728
 729 /*************************************************
 730     pCode Macros
 731
 732 **************************************************/
 733 #define PCODE(x)  ((pCode *)(x))
 734 #define PCI(x)    ((pCodeInstruction *)(x))
 735 #define PCL(x)    ((pCodeLabel *)(x))
 736 #define PCF(x)    ((pCodeFunction *)(x))
 737 #define PCFL(x)   ((pCodeFlow *)(x))
 738 #define PCFLINK(x)((pCodeFlowLink *)(x))
 739 #define PCW(x)    ((pCodeWild *)(x))
 740 #define PCCS(x)   ((pCodeCSource *)(x))
 741
 742 #define PCOP(x)   ((pCodeOp *)(x))
 743 //#define PCOB(x)   ((pCodeOpBit *)(x))
 744 #define PCOL(x)   ((pCodeOpLit *)(x))
 745 #define PCOI(x)   ((pCodeOpImmd *)(x))
 746 #define PCOLAB(x) ((pCodeOpLabel *)(x))
 747 #define PCOR(x)   ((pCodeOpReg *)(x))
 748 #define PCORB(x)  ((pCodeOpRegBit *)(x))
 749 #define PCOW(x)   ((pCodeOpWild *)(x))
 750
 751 #define PBR(x)    ((pBranch *)(x))
 752
 753 #define PCWB(x)   ((pCodeWildBlock *)(x))
 754
 755
 756 /*
 757   macros for checking pCode types
 758 */
 759 #define isPCI(x)        ((PCODE(x)->type == PC_OPCODE))
 760 #define isPCI_BRANCH(x) ((PCODE(x)->type == PC_OPCODE) &&  PCI(x)->isBranch)
 761 #define isPCI_SKIP(x)   ((PCODE(x)->type == PC_OPCODE) &&  PCI(x)->isSkip)
 762 #define isPCI_LIT(x)    ((PCODE(x)->type == PC_OPCODE) &&  PCI(x)->isLit)
 763 #define isPCI_BITSKIP(x)((PCODE(x)->type == PC_OPCODE) &&  PCI(x)->isSkip && PCI(x)->isBitInst)
 764 #define isPCFL(x)       ((PCODE(x)->type == PC_FLOW))
 765 #define isPCF(x)        ((PCODE(x)->type == PC_FUNCTION))
 766 #define isPCL(x)        ((PCODE(x)->type == PC_LABEL))
 767 #define isPCW(x)        ((PCODE(x)->type == PC_WILD))
 768 #define isPCCS(x)       ((PCODE(x)->type == PC_CSOURCE))
 769
 770 #define isCALL(x)       ((isPCI(x)) && (PCI(x)->op == POC_CALL))
 771 #define isSTATUS_REG(r) ((r)->pc_type == PO_STATUS)
 772
 773 #define isPCOLAB(x)     ((PCOP(x)->type) == PO_LABEL)
 774
 775 /*-----------------------------------------------------------------*
 776  * pCode functions.
 777  *-----------------------------------------------------------------*/
 778
 779 pCode *newpCode (PIC_OPCODE op, pCodeOp *pcop); // Create a new pCode given an operand
 780 pCode *newpCodeCharP(char *cP);              // Create a new pCode given a char *
 781 pCode *newpCodeInlineP(char *cP);            // Create a new pCode given a char *
 782 pCode *newpCodeFunction(char *g, char *f);   // Create a new function
 783 pCode *newpCodeLabel(char *name,int key);    // Create a new label given a key
 784 pCode *newpCodeCSource(int ln, char *f, char *l); // Create a new symbol line
 785 pBlock *newpCodeChain(memmap *cm,char c, pCode *pc); // Create a new pBlock
 786 void printpBlock(FILE *of, pBlock *pb);      // Write a pBlock to a file
 787 void printpCode(FILE *of, pCode *pc);        // Write a pCode to a file
 788 void addpCode2pBlock(pBlock *pb, pCode *pc); // Add a pCode to a pBlock
 789 void addpBlock(pBlock *pb);                  // Add a pBlock to a pFile
 790 void copypCode(FILE *of, char dbName);       // Write all pBlocks with dbName to *of
 791 void movepBlock2Head(char dbName);           // move pBlocks around
 792 void AnalyzepCode(char dbName);
 793 int OptimizepCode(char dbName);
 794 void printCallTree(FILE *of);
 795 void pCodePeepInit(void);
 796 void pBlockConvert2ISR(pBlock *pb);
 797
 798 pCodeOp *newpCodeOpLabel(char *name, int key);
 799 pCodeOp *newpCodeOpImmd(char *name, int offset, int index, int code_space);
 800 pCodeOp *newpCodeOpLit(int lit);
 801 pCodeOp *newpCodeOpBit(char *name, int bit,int inBitSpace);
 802 pCodeOp *newpCodeOpRegFromStr(char *name);
 803 pCodeOp *newpCodeOp(char *name, PIC_OPTYPE p);
 804 pCodeOp *pCodeOpCopy(pCodeOp *pcop);
 805
 806 pCode * findNextInstruction(pCode *pci);
 807 pCode * findNextpCode(pCode *pc, PC_TYPE pct);
 808 int isPCinFlow(pCode *pc, pCode *pcflow);
 809 struct regs * getRegFromInstruction(pCode *pc);
 810
 811 extern void pcode_test(void);
 812
 813 /*-----------------------------------------------------------------*
 814  * pCode objects.
 815  *-----------------------------------------------------------------*/
 816
 817 extern pCodeOpReg pc_status;
 818 extern pCodeOpReg pc_intcon;
 819 extern pCodeOpReg pc_indf;
 820 extern pCodeOpReg pc_fsr;
 821 extern pCodeOpReg pc_pcl;
 822 extern pCodeOpReg pc_pclath;
 823 extern pCodeOpReg pc_kzero;
 824 extern pCodeOpReg pc_wsave;     /* wsave and ssave are used to save W and the Status */
 825 extern pCodeOpReg pc_ssave;     /* registers during an interrupt */
 826
 827
 828 #endif // __PCODE_H__