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