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_GPR_POINTER,    // A general purpose pointer
 147   PO_SFR_REGISTER,   // A special function register (e.g. PORTA)
 148   PO_PCL,            // Program counter Low register
 149   PO_PCLATH,         // Program counter Latch high register
 150   PO_LITERAL,        // A constant
 151   PO_IMMEDIATE,      //  (8051 legacy)
 152   PO_DIR,            // Direct memory (8051 legacy)
 153   PO_CRY,            // bit memory (8051 legacy)
 154   PO_BIT,            // bit operand.
 155   PO_STR,            //  (8051 legacy)
 156   PO_LABEL,
 157   PO_WILD            // Wild card operand in peep optimizer
 158 } PIC_OPTYPE;
 159
 160
 161 /***********************************************************************
 162  *
 163  *  PIC_OPCODE
 164  *
 165  *  This is not a list of the PIC's opcodes per se, but instead
 166  *  an enumeration of all of the different types of pic opcodes.
 167  *
 168  ***********************************************************************/
 169
 170 typedef enum
 171 {
 172   POC_WILD=-1,   /* Wild card - used in the pCode peep hole optimizer
 173                   * to represent ANY pic opcode */
 174   POC_ADDLW=0,
 175   POC_ADDWF,
 176   POC_ADDFW,
 177   POC_ANDLW,
 178   POC_ANDWF,
 179   POC_ANDFW,
 180   POC_BCF,
 181   POC_BSF,
 182   POC_BTFSC,
 183   POC_BTFSS,
 184   POC_CALL,
 185   POC_COMF,
 186   POC_COMFW,
 187   POC_CLRF,
 188   POC_CLRW,
 189   POC_CLRWDT,
 190   POC_DECF,
 191   POC_DECFW,
 192   POC_DECFSZ,
 193   POC_DECFSZW,
 194   POC_GOTO,
 195   POC_INCF,
 196   POC_INCFW,
 197   POC_INCFSZ,
 198   POC_INCFSZW,
 199   POC_IORLW,
 200   POC_IORWF,
 201   POC_IORFW,
 202   POC_MOVF,
 203   POC_MOVFW,
 204   POC_MOVLW,
 205   POC_MOVWF,
 206   POC_NOP,
 207   POC_RETLW,
 208   POC_RETURN,
 209   POC_RETFIE,
 210   POC_RLF,
 211   POC_RLFW,
 212   POC_RRF,
 213   POC_RRFW,
 214   POC_SUBLW,
 215   POC_SUBWF,
 216   POC_SUBFW,
 217   POC_SWAPF,
 218   POC_SWAPFW,
 219   POC_TRIS,
 220   POC_XORLW,
 221   POC_XORWF,
 222   POC_XORFW
 223 } PIC_OPCODE;
 224
 225
 226 /***********************************************************************
 227  *  PC_TYPE  - pCode Types
 228  ***********************************************************************/
 229
 230 typedef enum
 231 {
 232   PC_COMMENT=0,   /* pCode is a comment     */
 233   PC_INLINE,      /* user's inline code     */
 234   PC_OPCODE,      /* PORT dependent opcode  */
 235   PC_LABEL,       /* assembly label         */
 236   PC_FLOW,        /* flow analysis          */
 237   PC_FUNCTION,    /* Function start or end  */
 238   PC_WILD,        /* wildcard - an opcode place holder used
 239                    * in the pCode peep hole optimizer */
 240   PC_CSOURCE,     /* C-Source Line  */
 241   PC_BAD          /* Mark the pCode object as being bad */
 242 } PC_TYPE;
 243
 244 /************************************************/
 245 /***************  Structures ********************/
 246 /************************************************/
 247 /* These are here as forward references - the
 248  * full definition of these are below           */
 249 struct pCode;
 250 struct pCodeWildBlock;
 251 struct pCodeRegLives;
 252
 253 /*************************************************
 254   pBranch
 255
 256   The first step in optimizing pCode is determining
 257  the program flow. This information is stored in
 258  single-linked lists in the for of 'from' and 'to'
 259  objects with in a pcode. For example, most instructions
 260  don't involve any branching. So their from branch
 261  points to the pCode immediately preceding them and
 262  their 'to' branch points to the pcode immediately
 263  following them. A skip instruction is an example of
 264  a pcode that has multiple (in this case two) elements
 265  in the 'to' branch. A 'label' pcode is an where there
 266  may be multiple 'from' branches.
 267  *************************************************/
 268
 269 typedef struct pBranch
 270 {
 271   struct pCode   *pc;    // Next pCode in a branch
 272   struct pBranch *next;  /* If more than one branch
 273                           * the next one is here */
 274
 275 } pBranch;
 276
 277 /*************************************************
 278   pCodeOp
 279
 280   pCode Operand structure.
 281   For those assembly instructions that have arguments,
 282   the pCode will have a pCodeOp in which the argument
 283   can be stored. For example
 284
 285     movf   some_register,w
 286
 287   'some_register' will be stored/referenced in a pCodeOp
 288
 289  *************************************************/
 290
 291 typedef struct pCodeOp
 292 {
 293   PIC_OPTYPE type;
 294   char *name;
 295
 296 } pCodeOp;
 297 #if 0
 298 typedef struct pCodeOpBit
 299 {
 300   pCodeOp pcop;
 301   int bit;
 302   unsigned int inBitSpace: 1; /* True if in bit space, else
 303                                  just a bit of a register */
 304 } pCodeOpBit;
 305 #endif
 306 typedef struct pCodeOpLit
 307 {
 308   pCodeOp pcop;
 309   int lit;
 310 } pCodeOpLit;
 311
 312 typedef struct pCodeOpImmd
 313 {
 314   pCodeOp pcop;
 315   int offset;           /* low,med, or high byte of immediate value */
 316   int index;            /* add this to the immediate value */
 317   unsigned _const:1;    /* is in code space    */
 318   unsigned _function:1; /* is a (pointer to a) function */
 319
 320   int rIdx;             /* If this immd points to a register */
 321   struct regs *r;       /* then this is the reg. */
 322
 323 } pCodeOpImmd;
 324
 325 typedef struct pCodeOpLabel
 326 {
 327   pCodeOp pcop;
 328   int key;
 329 } pCodeOpLabel;
 330
 331 typedef struct pCodeOpReg
 332 {
 333   pCodeOp pcop;    // Can be either GPR or SFR
 334   int rIdx;        // Index into the register table
 335   struct regs *r;
 336   int instance;    // byte # of Multi-byte registers
 337   struct pBlock *pb;
 338 } pCodeOpReg;
 339
 340 typedef struct pCodeOpRegBit
 341 {
 342   pCodeOpReg  pcor;       // The Register containing this bit
 343   int bit;                // 0-7 bit number.
 344   PIC_OPTYPE subtype;     // The type of this register.
 345   unsigned int inBitSpace: 1; /* True if in bit space, else
 346                                  just a bit of a register */
 347 } pCodeOpRegBit;
 348
 349
 350 typedef struct pCodeOpRegPtr
 351 {
 352   pCodeOpReg  pcor;       // The Register containing this bit
 353
 354   //  PIC_OPTYPE subtype;     // The type of this register.
 355   //  unsigned int inBitSpace: 1; /* True if in bit space, else
 356
 357 } pCodeOpRegPtr;
 358
 359 typedef struct pCodeOpWild
 360 {
 361   pCodeOp pcop;
 362
 363   struct pCodeWildBlock *pcwb;
 364
 365   int id;                 /* index into an array of char *'s that will match
 366                            * the wild card. The array is in *pcp. */
 367   pCodeOp *subtype;       /* Pointer to the Operand type into which this wild
 368                            * card will be expanded */
 369   pCodeOp *matched;       /* When a wild matches, we'll store a pointer to the
 370                            * opcode we matched */
 371
 372 } pCodeOpWild;
 373
 374
 375 /*************************************************
 376     pCode
 377
 378     Here is the basic build block of a PIC instruction.
 379     Each pic instruction will get allocated a pCode.
 380     A linked list of pCodes makes a program.
 381
 382 **************************************************/
 383
 384 typedef struct pCode
 385 {
 386   PC_TYPE    type;
 387
 388   struct pCode *prev;  // The pCode objects are linked together
 389   struct pCode *next;  // in doubly linked lists.
 390
 391   int seq;             // sequence number
 392
 393   struct pBlock *pb;   // The pBlock that contains this pCode.
 394
 395   /* "virtual functions"
 396    *  The pCode structure is like a base class
 397    * in C++. The subsequent structures that "inherit"
 398    * the pCode structure will initialize these function
 399    * pointers to something useful */
 400   //  void (*analyze) (struct pCode *_this);
 401   void (*destruct)(struct pCode *_this);
 402   void (*print)  (FILE *of,struct pCode *_this);
 403
 404 } pCode;
 405
 406
 407 /*************************************************
 408     pCodeComment
 409 **************************************************/
 410
 411 typedef struct pCodeComment
 412 {
 413
 414   pCode  pc;
 415
 416   char *comment;
 417
 418 } pCodeComment;
 419
 420 /*************************************************
 421     pCodeComment
 422 **************************************************/
 423
 424 typedef struct pCodeCSource
 425 {
 426
 427   pCode  pc;
 428
 429   int  line_number;
 430   char *line;
 431   char *file_name;
 432
 433 } pCodeCSource;
 434
 435
 436 /*************************************************
 437     pCodeFlow
 438
 439   The Flow object is used as marker to separate
 440  the assembly code into contiguous chunks. In other
 441  words, everytime an instruction cause or potentially
 442  causes a branch, a Flow object will be inserted into
 443  the pCode chain to mark the beginning of the next
 444  contiguous chunk.
 445
 446 **************************************************/
 447
 448 typedef struct pCodeFlow
 449 {
 450
 451   pCode  pc;
 452
 453   pCode *end;   /* Last pCode in this flow. Note that
 454                    the first pCode is pc.next */
 455
 456   /*  set **uses;   * map the pCode instruction inCond and outCond conditions
 457                  * in this array of set's. The reason we allocate an
 458                  * array of pointers instead of declaring each type of
 459                  * usage is because there are port dependent usage definitions */
 460   //int nuses;    /* number of uses sets */
 461
 462   set *from;    /* flow blocks that can send control to this flow block */
 463   set *to;      /* flow blocks to which this one can send control */
 464   struct pCodeFlow *ancestor; /* The most immediate "single" pCodeFlow object that
 465                                * executes prior to this one. In many cases, this
 466                                * will be just the previous */
 467
 468   int inCond;   /* Input conditions - stuff assumed defined at entry */
 469   int outCond;  /* Output conditions - stuff modified by flow block */
 470
 471   int firstBank; /* The first and last bank flags are the first and last */
 472   int lastBank;  /* register banks used within one flow object */
 473
 474   int FromConflicts;
 475   int ToConflicts;
 476
 477   set *registers;/* Registers used in this flow */
 478
 479 } pCodeFlow;
 480
 481 /*************************************************
 482   pCodeFlowLink
 483
 484   The Flow Link object is used to record information
 485  about how consecutive excutive Flow objects are related.
 486  The pCodeFlow objects demarcate the pCodeInstructions
 487  into contiguous chunks. The FlowLink records conflicts
 488  in the discontinuities. For example, if one Flow object
 489  references a register in bank 0 and the next Flow object
 490  references a register in bank 1, then there is a discontinuity
 491  in the banking registers.
 492
 493 */
 494 typedef struct pCodeFlowLink
 495 {
 496   pCodeFlow  *pcflow;   /* pointer to linked pCodeFlow object */
 497
 498   int bank_conflict;    /* records bank conflicts */
 499
 500 } pCodeFlowLink;
 501
 502 /*************************************************
 503     pCodeInstruction
 504
 505     Here we describe all the facets of a PIC instruction
 506     (expansion for the 18cxxx is also provided).
 507
 508 **************************************************/
 509
 510 typedef struct pCodeInstruction
 511 {
 512
 513   pCode  pc;
 514
 515   PIC_OPCODE op;        // The opcode of the instruction.
 516
 517   char const * const mnemonic;       // Pointer to mnemonic string
 518
 519   pBranch *from;       // pCodes that execute before this one
 520   pBranch *to;         // pCodes that execute after
 521   pBranch *label;      // pCode instructions that have labels
 522
 523   pCodeOp *pcop;               /* Operand, if this instruction has one */
 524   pCodeFlow *pcflow;           /* flow block to which this instruction belongs */
 525   pCodeCSource *cline;         /* C Source from which this instruction was derived */
 526
 527   unsigned int num_ops;        /* Number of operands (0,1,2 for mid range pics) */
 528   unsigned int isModReg:  1;   /* If destination is W or F, then 1==F */
 529   unsigned int isBitInst: 1;   /* e.g. BCF */
 530   unsigned int isBranch:  1;   /* True if this is a branching instruction */
 531   unsigned int isSkip:    1;   /* True if this is a skip instruction */
 532   unsigned int isLit:     1;   /* True if this instruction has an literal operand */
 533
 534   PIC_OPCODE inverted_op;      /* Opcode of instruction that's the opposite of this one */
 535   unsigned int inCond;   // Input conditions for this instruction
 536   unsigned int outCond;  // Output conditions for this instruction
 537
 538 } pCodeInstruction;
 539
 540
 541 /*************************************************
 542     pCodeLabel
 543 **************************************************/
 544
 545 typedef struct pCodeLabel
 546 {
 547
 548   pCode  pc;
 549
 550   char *label;
 551   int key;
 552
 553 } pCodeLabel;
 554
 555 /*************************************************
 556     pCodeFunction
 557 **************************************************/
 558
 559 typedef struct pCodeFunction
 560 {
 561
 562   pCode  pc;
 563
 564   char *modname;
 565   char *fname;     /* If NULL, then this is the end of
 566                       a function. Otherwise, it's the
 567                       start and the name is contained
 568                       here */
 569
 570   pBranch *from;       // pCodes that execute before this one
 571   pBranch *to;         // pCodes that execute after
 572   pBranch *label;      // pCode instructions that have labels
 573
 574   int  ncalled;    /* Number of times function is called */
 575
 576 } pCodeFunction;
 577
 578
 579 /*************************************************
 580     pCodeWild
 581 **************************************************/
 582
 583 typedef struct pCodeWild
 584 {
 585
 586   pCodeInstruction  pci;
 587
 588   int    id;     /* Index into the wild card array of a peepBlock
 589                   * - this wild card will get expanded into that pCode
 590                   *   that is stored at this index */
 591
 592   /* Conditions on wild pcode instruction */
 593   int    mustBeBitSkipInst:1;
 594   int    mustNotBeBitSkipInst:1;
 595   int    invertBitSkipInst:1;
 596
 597   pCodeOp *operand;  // Optional operand
 598   pCodeOp *label;    // Optional label
 599
 600 } pCodeWild;
 601
 602 /*************************************************
 603     pBlock
 604
 605     Here are PIC program snippets. There's a strong
 606     correlation between the eBBlocks and pBlocks.
 607     SDCC subdivides a C program into managable chunks.
 608     Each chunk becomes a eBBlock and ultimately in the
 609     PIC port a pBlock.
 610
 611 **************************************************/
 612
 613 typedef struct pBlock
 614 {
 615   memmap *cmemmap;   /* The snippet is from this memmap */
 616   char   dbName;     /* if cmemmap is NULL, then dbName will identify the block */
 617   pCode *pcHead;     /* A pointer to the first pCode in a link list of pCodes */
 618   pCode *pcTail;     /* A pointer to the last pCode in a link list of pCodes */
 619
 620   struct pBlock *next;      /* The pBlocks will form a doubly linked list */
 621   struct pBlock *prev;
 622
 623   set *function_entries;    /* dll of functions in this pblock */
 624   set *function_exits;
 625   set *function_calls;
 626   set *tregisters;
 627
 628   set *FlowTree;
 629   unsigned visited:1;       /* set true if traversed in call tree */
 630
 631   unsigned seq;             /* sequence number of this pBlock */
 632
 633 } pBlock;
 634
 635 /*************************************************
 636     pFile
 637
 638     The collection of pBlock program snippets are
 639     placed into a linked list that is implemented
 640     in the pFile structure.
 641
 642     The pcode optimizer will parse the pFile.
 643
 644 **************************************************/
 645
 646 typedef struct pFile
 647 {
 648   pBlock *pbHead;     /* A pointer to the first pBlock */
 649   pBlock *pbTail;     /* A pointer to the last pBlock */
 650
 651   pBranch *functions; /* A SLL of functions in this pFile */
 652
 653 } pFile;
 654
 655
 656
 657 /*************************************************
 658   pCodeWildBlock
 659
 660   The pCodeWildBlock object keeps track of the wild
 661   variables, operands, and opcodes that exist in
 662   a pBlock.
 663 **************************************************/
 664 typedef struct pCodeWildBlock {
 665   pBlock    *pb;
 666   struct pCodePeep *pcp;    // pointer back to ... I don't like this...
 667
 668   int       nvars;          // Number of wildcard registers in target.
 669   char    **vars;           // array of pointers to them
 670
 671   int       nops;           // Number of wildcard operands in target.
 672   pCodeOp **wildpCodeOps;   // array of pointers to the pCodeOp's.
 673
 674   int       nwildpCodes;    // Number of wildcard pCodes in target/replace
 675   pCode   **wildpCodes;     // array of pointers to the pCode's.
 676
 677 } pCodeWildBlock;
 678
 679 /*************************************************
 680   pCodePeep
 681
 682   The pCodePeep object mimics the peep hole optimizer
 683   in the main SDCC src (e.g. SDCCpeeph.c). Essentially
 684   there is a target pCode chain and a replacement
 685   pCode chain. The target chain is compared to the
 686   pCode that is generated by gen.c. If a match is
 687   found then the pCode is replaced by the replacement
 688   pCode chain.
 689 **************************************************/
 690 typedef struct pCodePeep {
 691   pCodeWildBlock target;     // code we'd like to optimize
 692   pCodeWildBlock replace;    // and this is what we'll optimize it with.
 693
 694   //pBlock *target;
 695   //pBlock replace;            // and this is what we'll optimize it with.
 696
 697
 698
 699   /* (Note: a wildcard register is a place holder. Any register
 700    * can be replaced by the wildcard when the pcode is being
 701    * compared to the target. */
 702
 703   /* Post Conditions. A post condition is a condition that
 704    * must be either true or false before the peep rule is
 705    * accepted. For example, a certain rule may be accepted
 706    * if and only if the Z-bit is not used as an input to
 707    * the subsequent instructions in a pCode chain.
 708    */
 709   unsigned int postFalseCond;
 710   unsigned int postTrueCond;
 711
 712 } pCodePeep;
 713
 714 /*************************************************
 715
 716   pCode peep command definitions
 717
 718  Here are some special commands that control the
 719 way the peep hole optimizer behaves
 720
 721 **************************************************/
 722
 723 enum peepCommandTypes{
 724   NOTBITSKIP = 0,
 725   BITSKIP,
 726   INVERTBITSKIP,
 727   _LAST_PEEP_COMMAND_
 728 };
 729
 730 /*************************************************
 731     peepCommand structure stores the peep commands.
 732
 733 **************************************************/
 734
 735 typedef struct peepCommand {
 736   int id;
 737   char *cmd;
 738 } peepCommand;
 739
 740 /*************************************************
 741     pCode Macros
 742
 743 **************************************************/
 744 #define PCODE(x)  ((pCode *)(x))
 745 #define PCI(x)    ((pCodeInstruction *)(x))
 746 #define PCL(x)    ((pCodeLabel *)(x))
 747 #define PCF(x)    ((pCodeFunction *)(x))
 748 #define PCFL(x)   ((pCodeFlow *)(x))
 749 #define PCFLINK(x)((pCodeFlowLink *)(x))
 750 #define PCW(x)    ((pCodeWild *)(x))
 751 #define PCCS(x)   ((pCodeCSource *)(x))
 752
 753 #define PCOP(x)   ((pCodeOp *)(x))
 754 //#define PCOB(x)   ((pCodeOpBit *)(x))
 755 #define PCOL(x)   ((pCodeOpLit *)(x))
 756 #define PCOI(x)   ((pCodeOpImmd *)(x))
 757 #define PCOLAB(x) ((pCodeOpLabel *)(x))
 758 #define PCOR(x)   ((pCodeOpReg *)(x))
 759 #define PCORB(x)  ((pCodeOpRegBit *)(x))
 760 #define PCOW(x)   ((pCodeOpWild *)(x))
 761
 762 #define PBR(x)    ((pBranch *)(x))
 763
 764 #define PCWB(x)   ((pCodeWildBlock *)(x))
 765
 766
 767 /*
 768   macros for checking pCode types
 769 */
 770 #define isPCI(x)        ((PCODE(x)->type == PC_OPCODE))
 771 #define isPCI_BRANCH(x) ((PCODE(x)->type == PC_OPCODE) &&  PCI(x)->isBranch)
 772 #define isPCI_SKIP(x)   ((PCODE(x)->type == PC_OPCODE) &&  PCI(x)->isSkip)
 773 #define isPCI_LIT(x)    ((PCODE(x)->type == PC_OPCODE) &&  PCI(x)->isLit)
 774 #define isPCI_BITSKIP(x)((PCODE(x)->type == PC_OPCODE) &&  PCI(x)->isSkip && PCI(x)->isBitInst)
 775 #define isPCFL(x)       ((PCODE(x)->type == PC_FLOW))
 776 #define isPCF(x)        ((PCODE(x)->type == PC_FUNCTION))
 777 #define isPCL(x)        ((PCODE(x)->type == PC_LABEL))
 778 #define isPCW(x)        ((PCODE(x)->type == PC_WILD))
 779 #define isPCCS(x)       ((PCODE(x)->type == PC_CSOURCE))
 780
 781 #define isCALL(x)       ((isPCI(x)) && (PCI(x)->op == POC_CALL))
 782 #define isSTATUS_REG(r) ((r)->pc_type == PO_STATUS)
 783
 784 #define isPCOLAB(x)     ((PCOP(x)->type) == PO_LABEL)
 785
 786 /*-----------------------------------------------------------------*
 787  * pCode functions.
 788  *-----------------------------------------------------------------*/
 789
 790 pCode *newpCode (PIC_OPCODE op, pCodeOp *pcop); // Create a new pCode given an operand
 791 pCode *newpCodeCharP(char *cP);              // Create a new pCode given a char *
 792 pCode *newpCodeInlineP(char *cP);            // Create a new pCode given a char *
 793 pCode *newpCodeFunction(char *g, char *f);   // Create a new function
 794 pCode *newpCodeLabel(char *name,int key);    // Create a new label given a key
 795 pCode *newpCodeCSource(int ln, char *f, char *l); // Create a new symbol line
 796 pBlock *newpCodeChain(memmap *cm,char c, pCode *pc); // Create a new pBlock
 797 void printpBlock(FILE *of, pBlock *pb);      // Write a pBlock to a file
 798 void printpCode(FILE *of, pCode *pc);        // Write a pCode to a file
 799 void addpCode2pBlock(pBlock *pb, pCode *pc); // Add a pCode to a pBlock
 800 void addpBlock(pBlock *pb);                  // Add a pBlock to a pFile
 801 void copypCode(FILE *of, char dbName);       // Write all pBlocks with dbName to *of
 802 void movepBlock2Head(char dbName);           // move pBlocks around
 803 void AnalyzepCode(char dbName);
 804 int OptimizepCode(char dbName);
 805 void printCallTree(FILE *of);
 806 void pCodePeepInit(void);
 807 void pBlockConvert2ISR(pBlock *pb);
 808
 809 pCodeOp *newpCodeOpLabel(char *name, int key);
 810 pCodeOp *newpCodeOpImmd(char *name, int offset, int index, int code_space,int is_func);
 811 pCodeOp *newpCodeOpLit(int lit);
 812 pCodeOp *newpCodeOpBit(char *name, int bit,int inBitSpace);
 813 pCodeOp *newpCodeOpRegFromStr(char *name);
 814 pCodeOp *newpCodeOp(char *name, PIC_OPTYPE p);
 815 pCodeOp *pCodeOpCopy(pCodeOp *pcop);
 816
 817 pCode * findNextInstruction(pCode *pci);
 818 pCode * findNextpCode(pCode *pc, PC_TYPE pct);
 819 int isPCinFlow(pCode *pc, pCode *pcflow);
 820 struct regs * getRegFromInstruction(pCode *pc);
 821
 822 extern void pcode_test(void);
 823
 824 /*-----------------------------------------------------------------*
 825  * pCode objects.
 826  *-----------------------------------------------------------------*/
 827
 828 extern pCodeOpReg pc_status;
 829 extern pCodeOpReg pc_intcon;
 830 extern pCodeOpReg pc_indf;
 831 extern pCodeOpReg pc_fsr;
 832 extern pCodeOpReg pc_pcl;
 833 extern pCodeOpReg pc_pclath;
 834 extern pCodeOpReg pc_kzero;
 835 extern pCodeOpReg pc_wsave;     /* wsave and ssave are used to save W and the Status */
 836 extern pCodeOpReg pc_ssave;     /* registers during an interrupt */
 837
 838
 839 #endif // __PCODE_H__