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

   1 /*-------------------------------------------------------------------------
   2
   3         pcode.c - 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 #include <stdio.h>
  22
  23 #include "common.h"   // Include everything in the SDCC src directory
  24 #include "newalloc.h"
  25
  26
  27 #include "pcode.h"
  28 #include "pcodeflow.h"
  29 #include "ralloc.h"
  30 #include "device.h"
  31
  32 pCode *findFunction(char *fname);
  33
  34 static void FixRegisterBanking(pBlock *pb);
  35
  36 #if defined(__BORLANDC__) || defined(_MSC_VER)
  37 #define STRCASECMP stricmp
  38 #else
  39 #define STRCASECMP strcasecmp
  40 #endif
  41
  42 /****************************************************************/
  43 /****************************************************************/
  44
  45 peepCommand peepCommands[] = {
  46
  47         {NOTBITSKIP, "_NOTBITSKIP_"},
  48         {BITSKIP, "_BITSKIP_"},
  49         {INVERTBITSKIP, "_INVERTBITSKIP_"},
  50
  51         {-1, NULL}
  52 };
  53
  54
  55
  56 // Eventually this will go into device dependent files:
  57 pCodeOpReg pc_status    = {{PO_STATUS,  "STATUS"}, -1, NULL,0,NULL};
  58 pCodeOpReg pc_indf      = {{PO_INDF,    "INDF"}, -1, NULL,0,NULL};
  59 pCodeOpReg pc_fsr       = {{PO_FSR,     "FSR"}, -1, NULL,0,NULL};
  60 pCodeOpReg pc_intcon    = {{PO_INTCON,  "INTCON"}, -1, NULL,0,NULL};
  61 pCodeOpReg pc_pcl       = {{PO_PCL,     "PCL"}, -1, NULL,0,NULL};
  62 pCodeOpReg pc_pclath    = {{PO_PCLATH,  "PCLATH"}, -1, NULL,0,NULL};
  63
  64 pCodeOpReg pc_wsave     = {{PO_GPR_REGISTER,  "WSAVE"}, -1, NULL,0,NULL};
  65 pCodeOpReg pc_ssave     = {{PO_GPR_REGISTER,  "SSAVE"}, -1, NULL,0,NULL};
  66 pCodeOpReg pc_psave     = {{PO_GPR_REGISTER,  "PSAVE"}, -1, NULL,0,NULL};
  67
  68 static int mnemonics_initialized = 0;
  69
  70 static hTab *pic14MnemonicsHash = NULL;
  71 static hTab *pic14pCodePeepCommandsHash = NULL;
  72
  73
  74 pFile *the_pFile = NULL;
  75 static pBlock *pb_dead_pcodes = NULL;
  76
  77 /* Hardcoded flags to change the behavior of the PIC port */
  78 static int functionInlining = 1;      /* inline functions if nonzero */
  79 int debug_verbose = 0;                /* Set true to inundate .asm file */
  80
  81 // static int GpCodeSequenceNumber = 1;
  82 int GpcFlowSeq = 1;
  83
  84 /* statistics (code size estimation) */
  85 static unsigned int pcode_insns = 0;
  86 static unsigned int pcode_doubles = 0;
  87
  88
  89 unsigned maxIdx; /* This keeps track of the maximum register index for call tree register reuse */
  90 unsigned peakIdx; /* This keeps track of the peak register index for call tree register reuse */
  91
  92 extern void RemoveUnusedRegisters(void);
  93 extern void RegsUnMapLiveRanges(void);
  94 extern void BuildFlowTree(pBlock *pb);
  95 extern void pCodeRegOptimizeRegUsage(int level);
  96 extern int picIsInitialized(void);
  97 extern const char *pCodeOpType(pCodeOp *pcop);
  98
  99 /****************************************************************/
 100 /*                      Forward declarations                    */
 101 /****************************************************************/
 102
 103 void unlinkpCode(pCode *pc);
 104 #if 0
 105 static void genericAnalyze(pCode *pc);
 106 static void AnalyzeGOTO(pCode *pc);
 107 static void AnalyzeSKIP(pCode *pc);
 108 static void AnalyzeRETURN(pCode *pc);
 109 #endif
 110
 111 static void genericDestruct(pCode *pc);
 112 static void genericPrint(FILE *of,pCode *pc);
 113
 114 static void pCodePrintLabel(FILE *of, pCode *pc);
 115 static void pCodePrintFunction(FILE *of, pCode *pc);
 116 static void pCodeOpPrint(FILE *of, pCodeOp *pcop);
 117 static char *get_op_from_instruction( pCodeInstruction *pcc);
 118 char *get_op( pCodeOp *pcop,char *buff,size_t buf_size);
 119 int pCodePeepMatchLine(pCodePeep *peepBlock, pCode *pcs, pCode *pcd);
 120 int pCodePeepMatchRule(pCode *pc);
 121 void pBlockStats(FILE *of, pBlock *pb);
 122 pBlock *newpBlock(void);
 123 pCodeOp *popCopyGPR2Bit(pCodeOp *pc, int bitval);
 124 void pCodeRegMapLiveRanges(pBlock *pb);
 125
 126 pBranch * pBranchAppend(pBranch *h, pBranch *n);
 127
 128
 129 /****************************************************************/
 130 /*                    PIC Instructions                          */
 131 /****************************************************************/
 132
 133 pCodeInstruction pciADDWF = {
 134         {PC_OPCODE, NULL, NULL, 0, 0, NULL,
 135                 //   genericAnalyze,
 136                 genericDestruct,
 137                 genericPrint},
 138                 POC_ADDWF,
 139                 "ADDWF",
 140                 NULL, // from branch
 141                 NULL, // to branch
 142                 NULL, // label
 143                 NULL, // operand
 144                 NULL, // flow block
 145                 NULL, // C source
 146                 2,    // num ops
 147                 1,0,  // dest, bit instruction
 148                 0,0,  // branch, skip
 149                 0,    // literal operand
 150                 POC_NOP,
 151                 (PCC_W | PCC_REGISTER),   // inCond
 152                 (PCC_REGISTER | PCC_C | PCC_DC | PCC_Z) // outCond
 153 };
 154
 155 pCodeInstruction pciADDFW = {
 156         {PC_OPCODE, NULL, NULL, 0, 0, NULL,
 157                 //   genericAnalyze,
 158                 genericDestruct,
 159                 genericPrint},
 160                 POC_ADDFW,
 161                 "ADDWF",
 162                 NULL, // from branch
 163                 NULL, // to branch
 164                 NULL, // label
 165                 NULL, // operand
 166                 NULL, // flow block
 167                 NULL, // C source
 168                 2,    // num ops
 169                 0,0,  // dest, bit instruction
 170                 0,0,  // branch, skip
 171                 0,    // literal operand
 172                 POC_NOP,
 173                 (PCC_W | PCC_REGISTER),   // inCond
 174                 (PCC_W | PCC_C | PCC_DC | PCC_Z) // outCond
 175 };
 176
 177 pCodeInstruction pciADDLW = {
 178         {PC_OPCODE, NULL, NULL, 0, 0, NULL,
 179                 //   genericAnalyze,
 180                 genericDestruct,
 181                 genericPrint},
 182                 POC_ADDLW,
 183                 "ADDLW",
 184                 NULL, // from branch
 185                 NULL, // to branch
 186                 NULL, // label
 187                 NULL, // operand
 188                 NULL, // flow block
 189                 NULL, // C source
 190                 1,    // num ops
 191                 0,0,  // dest, bit instruction
 192                 0,0,  // branch, skip
 193                 1,    // literal operand
 194                 POC_NOP,
 195                 (PCC_W | PCC_LITERAL),   // inCond
 196                 (PCC_W | PCC_Z | PCC_C | PCC_DC) // outCond
 197 };
 198
 199 pCodeInstruction pciANDLW = {
 200         {PC_OPCODE, NULL, NULL, 0, 0, NULL,
 201                 //   genericAnalyze,
 202                 genericDestruct,
 203                 genericPrint},
 204                 POC_ANDLW,
 205                 "ANDLW",
 206                 NULL, // from branch
 207                 NULL, // to branch
 208                 NULL, // label
 209                 NULL, // operand
 210                 NULL, // flow block
 211                 NULL, // C source
 212                 1,    // num ops
 213                 0,0,  // dest, bit instruction
 214                 0,0,  // branch, skip
 215                 1,    // literal operand
 216                 POC_NOP,
 217                 (PCC_W | PCC_LITERAL),   // inCond
 218                 (PCC_W | PCC_Z) // outCond
 219 };
 220
 221 pCodeInstruction pciANDWF = {
 222         {PC_OPCODE, NULL, NULL, 0, 0, NULL,
 223                 //   genericAnalyze,
 224                 genericDestruct,
 225                 genericPrint},
 226                 POC_ANDWF,
 227                 "ANDWF",
 228                 NULL, // from branch
 229                 NULL, // to branch
 230                 NULL, // label
 231                 NULL, // operand
 232                 NULL, // flow block
 233                 NULL, // C source
 234                 2,    // num ops
 235                 1,0,  // dest, bit instruction
 236                 0,0,  // branch, skip
 237                 0,    // literal operand
 238                 POC_NOP,
 239                 (PCC_W | PCC_REGISTER),   // inCond
 240                 (PCC_REGISTER | PCC_Z) // outCond
 241 };
 242
 243 pCodeInstruction pciANDFW = {
 244         {PC_OPCODE, NULL, NULL, 0, 0, NULL,
 245                 //   genericAnalyze,
 246                 genericDestruct,
 247                 genericPrint},
 248                 POC_ANDFW,
 249                 "ANDWF",
 250                 NULL, // from branch
 251                 NULL, // to branch
 252                 NULL, // label
 253                 NULL, // operand
 254                 NULL, // flow block
 255                 NULL, // C source
 256                 2,    // num ops
 257                 0,0,  // dest, bit instruction
 258                 0,0,  // branch, skip
 259                 0,    // literal operand
 260                 POC_NOP,
 261                 (PCC_W | PCC_REGISTER),   // inCond
 262                 (PCC_W | PCC_Z) // outCond
 263 };
 264
 265 pCodeInstruction pciBCF = {
 266         {PC_OPCODE, NULL, NULL, 0, 0, NULL,
 267                 //   genericAnalyze,
 268                 genericDestruct,
 269                 genericPrint},
 270                 POC_BCF,
 271                 "BCF",
 272                 NULL, // from branch
 273                 NULL, // to branch
 274                 NULL, // label
 275                 NULL, // operand
 276                 NULL, // flow block
 277                 NULL, // C source
 278                 2,    // num ops
 279                 1,1,  // dest, bit instruction
 280                 0,0,  // branch, skip
 281                 0,    // literal operand
 282                 POC_BSF,
 283                 (PCC_REGISTER | PCC_EXAMINE_PCOP),      // inCond
 284                 (PCC_REGISTER | PCC_EXAMINE_PCOP)       // outCond
 285 };
 286
 287 pCodeInstruction pciBSF = {
 288         {PC_OPCODE, NULL, NULL, 0, 0, NULL,
 289                 //   genericAnalyze,
 290                 genericDestruct,
 291                 genericPrint},
 292                 POC_BSF,
 293                 "BSF",
 294                 NULL, // from branch
 295                 NULL, // to branch
 296                 NULL, // label
 297                 NULL, // operand
 298                 NULL, // flow block
 299                 NULL, // C source
 300                 2,    // num ops
 301                 1,1,  // dest, bit instruction
 302                 0,0,  // branch, skip
 303                 0,    // literal operand
 304                 POC_BCF,
 305                 (PCC_REGISTER | PCC_EXAMINE_PCOP),      // inCond
 306                 (PCC_REGISTER | PCC_EXAMINE_PCOP)       // outCond
 307 };
 308
 309 pCodeInstruction pciBTFSC = {
 310         {PC_OPCODE, NULL, NULL, 0, 0, NULL,
 311                 //   AnalyzeSKIP,
 312                 genericDestruct,
 313                 genericPrint},
 314                 POC_BTFSC,
 315                 "BTFSC",
 316                 NULL, // from branch
 317                 NULL, // to branch
 318                 NULL, // label
 319                 NULL, // operand
 320                 NULL, // flow block
 321                 NULL, // C source
 322                 2,    // num ops
 323                 0,1,  // dest, bit instruction
 324                 1,1,  // branch, skip
 325                 0,    // literal operand
 326                 POC_BTFSS,
 327                 (PCC_REGISTER | PCC_EXAMINE_PCOP),      // inCond
 328                 PCC_NONE // outCond
 329 };
 330
 331 pCodeInstruction pciBTFSS = {
 332         {PC_OPCODE, NULL, NULL, 0, 0, NULL,
 333                 //   AnalyzeSKIP,
 334                 genericDestruct,
 335                 genericPrint},
 336                 POC_BTFSS,
 337                 "BTFSS",
 338                 NULL, // from branch
 339                 NULL, // to branch
 340                 NULL, // label
 341                 NULL, // operand
 342                 NULL, // flow block
 343                 NULL, // C source
 344                 2,    // num ops
 345                 0,1,  // dest, bit instruction
 346                 1,1,  // branch, skip
 347                 0,    // literal operand
 348                 POC_BTFSC,
 349                 (PCC_REGISTER | PCC_EXAMINE_PCOP),   // inCond
 350                 PCC_NONE // outCond
 351 };
 352
 353 pCodeInstruction pciCALL = {
 354         {PC_OPCODE, NULL, NULL, 0, 0, NULL,
 355                 //   genericAnalyze,
 356                 genericDestruct,
 357                 genericPrint},
 358                 POC_CALL,
 359                 "CALL",
 360                 NULL, // from branch
 361                 NULL, // to branch
 362                 NULL, // label
 363                 NULL, // operand
 364                 NULL, // flow block
 365                 NULL, // C source
 366                 1,    // num ops
 367                 0,0,  // dest, bit instruction
 368                 1,0,  // branch, skip
 369                 0,    // literal operand
 370                 POC_NOP,
 371                 (PCC_NONE | PCC_W), // inCond, reads argument from WREG
 372                 (PCC_NONE | PCC_W | PCC_C | PCC_DC | PCC_Z)  // outCond, flags are destroyed by called function
 373 };
 374
 375 pCodeInstruction pciCOMF = {
 376         {PC_OPCODE, NULL, NULL, 0, 0, NULL,
 377                 //   genericAnalyze,
 378                 genericDestruct,
 379                 genericPrint},
 380                 POC_COMF,
 381                 "COMF",
 382                 NULL, // from branch
 383                 NULL, // to branch
 384                 NULL, // label
 385                 NULL, // operand
 386                 NULL, // flow block
 387                 NULL, // C source
 388                 2,    // num ops
 389                 1,0,  // dest, bit instruction
 390                 0,0,  // branch, skip
 391                 0,    // literal operand
 392                 POC_NOP,
 393                 PCC_REGISTER,  // inCond
 394                 PCC_REGISTER | PCC_Z  // outCond
 395 };
 396
 397 pCodeInstruction pciCOMFW = {
 398         {PC_OPCODE, NULL, NULL, 0, 0, NULL,
 399                 //   genericAnalyze,
 400                 genericDestruct,
 401                 genericPrint},
 402                 POC_COMFW,
 403                 "COMF",
 404                 NULL, // from branch
 405                 NULL, // to branch
 406                 NULL, // label
 407                 NULL, // operand
 408                 NULL, // flow block
 409                 NULL, // C source
 410                 2,    // num ops
 411                 0,0,  // dest, bit instruction
 412                 0,0,  // branch, skip
 413                 0,    // literal operand
 414                 POC_NOP,
 415                 PCC_REGISTER,  // inCond
 416                 PCC_W | PCC_Z  // outCond
 417 };
 418
 419 pCodeInstruction pciCLRF = {
 420         {PC_OPCODE, NULL, NULL, 0, 0, NULL,
 421                 //   genericAnalyze,
 422                 genericDestruct,
 423                 genericPrint},
 424                 POC_CLRF,
 425                 "CLRF",
 426                 NULL, // from branch
 427                 NULL, // to branch
 428                 NULL, // label
 429                 NULL, // operand
 430                 NULL, // flow block
 431                 NULL, // C source
 432                 1,    // num ops
 433                 0,0,  // dest, bit instruction
 434                 0,0,  // branch, skip
 435                 0,    // literal operand
 436                 POC_NOP,
 437                 PCC_NONE, // inCond
 438                 PCC_REGISTER | PCC_Z // outCond
 439 };
 440
 441 pCodeInstruction pciCLRW = {
 442         {PC_OPCODE, NULL, NULL, 0, 0, NULL,
 443                 //   genericAnalyze,
 444                 genericDestruct,
 445                 genericPrint},
 446                 POC_CLRW,
 447                 "CLRW",
 448                 NULL, // from branch
 449                 NULL, // to branch
 450                 NULL, // label
 451                 NULL, // operand
 452                 NULL, // flow block
 453                 NULL, // C source
 454                 0,    // num ops
 455                 0,0,  // dest, bit instruction
 456                 0,0,  // branch, skip
 457                 0,    // literal operand
 458                 POC_NOP,
 459                 PCC_NONE, // inCond
 460                 PCC_W | PCC_Z  // outCond
 461 };
 462
 463 pCodeInstruction pciCLRWDT = {
 464         {PC_OPCODE, NULL, NULL, 0, 0, NULL,
 465                 //   genericAnalyze,
 466                 genericDestruct,
 467                 genericPrint},
 468                 POC_CLRWDT,
 469                 "CLRWDT",
 470                 NULL, // from branch
 471                 NULL, // to branch
 472                 NULL, // label
 473                 NULL, // operand
 474                 NULL, // flow block
 475                 NULL, // C source
 476                 0,    // num ops
 477                 0,0,  // dest, bit instruction
 478                 0,0,  // branch, skip
 479                 0,    // literal operand
 480                 POC_NOP,
 481                 PCC_NONE, // inCond
 482                 PCC_NONE  // outCond
 483 };
 484
 485 pCodeInstruction pciDECF = {
 486         {PC_OPCODE, NULL, NULL, 0, 0, NULL,
 487                 //   genericAnalyze,
 488                 genericDestruct,
 489                 genericPrint},
 490                 POC_DECF,
 491                 "DECF",
 492                 NULL, // from branch
 493                 NULL, // to branch
 494                 NULL, // label
 495                 NULL, // operand
 496                 NULL, // flow block
 497                 NULL, // C source
 498                 2,    // num ops
 499                 1,0,  // dest, bit instruction
 500                 0,0,  // branch, skip
 501                 0,    // literal operand
 502                 POC_NOP,
 503                 PCC_REGISTER,   // inCond
 504                 PCC_REGISTER | PCC_Z   // outCond
 505 };
 506
 507 pCodeInstruction pciDECFW = {
 508         {PC_OPCODE, NULL, NULL, 0, 0, NULL,
 509                 //   genericAnalyze,
 510                 genericDestruct,
 511                 genericPrint},
 512                 POC_DECFW,
 513                 "DECF",
 514                 NULL, // from branch
 515                 NULL, // to branch
 516                 NULL, // label
 517                 NULL, // operand
 518                 NULL, // flow block
 519                 NULL, // C source
 520                 2,    // num ops
 521                 0,0,  // dest, bit instruction
 522                 0,0,  // branch, skip
 523                 0,    // literal operand
 524                 POC_NOP,
 525                 PCC_REGISTER,   // inCond
 526                 PCC_W | PCC_Z   // outCond
 527 };
 528
 529 pCodeInstruction pciDECFSZ = {
 530         {PC_OPCODE, NULL, NULL, 0, 0, NULL,
 531                 //   AnalyzeSKIP,
 532                 genericDestruct,
 533                 genericPrint},
 534                 POC_DECFSZ,
 535                 "DECFSZ",
 536                 NULL, // from branch
 537                 NULL, // to branch
 538                 NULL, // label
 539                 NULL, // operand
 540                 NULL, // flow block
 541                 NULL, // C source
 542                 2,    // num ops
 543                 1,0,  // dest, bit instruction
 544                 1,1,  // branch, skip
 545                 0,    // literal operand
 546                 POC_DECF,               // followed by BTFSC STATUS, Z --> also kills STATUS
 547                 PCC_REGISTER,           // inCond
 548                 PCC_REGISTER | PCC_Z    // outCond
 549 };
 550
 551 pCodeInstruction pciDECFSZW = {
 552         {PC_OPCODE, NULL, NULL, 0, 0, NULL,
 553                 //   AnalyzeSKIP,
 554                 genericDestruct,
 555                 genericPrint},
 556                 POC_DECFSZW,
 557                 "DECFSZ",
 558                 NULL, // from branch
 559                 NULL, // to branch
 560                 NULL, // label
 561                 NULL, // operand
 562                 NULL, // flow block
 563                 NULL, // C source
 564                 2,    // num ops
 565                 0,0,  // dest, bit instruction
 566                 1,1,  // branch, skip
 567                 0,    // literal operand
 568                 POC_DECFW,      // followed by BTFSC STATUS, Z --> also kills STATUS
 569                 PCC_REGISTER,   // inCond
 570                 PCC_W | PCC_Z   // outCond
 571 };
 572
 573 pCodeInstruction pciGOTO = {
 574         {PC_OPCODE, NULL, NULL, 0, 0, NULL,
 575                 //   AnalyzeGOTO,
 576                 genericDestruct,
 577                 genericPrint},
 578                 POC_GOTO,
 579                 "GOTO",
 580                 NULL, // from branch
 581                 NULL, // to branch
 582                 NULL, // label
 583                 NULL, // operand
 584                 NULL, // flow block
 585                 NULL, // C source
 586                 1,    // num ops
 587                 0,0,  // dest, bit instruction
 588                 1,0,  // branch, skip
 589                 0,    // literal operand
 590                 POC_NOP,
 591                 PCC_NONE,   // inCond
 592                 PCC_NONE    // outCond
 593 };
 594
 595 pCodeInstruction pciINCF = {
 596         {PC_OPCODE, NULL, NULL, 0, 0, NULL,
 597                 //   genericAnalyze,
 598                 genericDestruct,
 599                 genericPrint},
 600                 POC_INCF,
 601                 "INCF",
 602                 NULL, // from branch
 603                 NULL, // to branch
 604                 NULL, // label
 605                 NULL, // operand
 606                 NULL, // flow block
 607                 NULL, // C source
 608                 2,    // num ops
 609                 1,0,  // dest, bit instruction
 610                 0,0,  // branch, skip
 611                 0,    // literal operand
 612                 POC_NOP,
 613                 PCC_REGISTER,   // inCond
 614                 PCC_REGISTER | PCC_Z   // outCond
 615 };
 616
 617 pCodeInstruction pciINCFW = {
 618         {PC_OPCODE, NULL, NULL, 0, 0, NULL,
 619                 //   genericAnalyze,
 620                 genericDestruct,
 621                 genericPrint},
 622                 POC_INCFW,
 623                 "INCF",
 624                 NULL, // from branch
 625                 NULL, // to branch
 626                 NULL, // label
 627                 NULL, // operand
 628                 NULL, // flow block
 629                 NULL, // C source
 630                 2,    // num ops
 631                 0,0,  // dest, bit instruction
 632                 0,0,  // branch, skip
 633                 0,    // literal operand
 634                 POC_NOP,
 635                 PCC_REGISTER,   // inCond
 636                 PCC_W | PCC_Z   // outCond
 637 };
 638
 639 pCodeInstruction pciINCFSZ = {
 640         {PC_OPCODE, NULL, NULL, 0, 0, NULL,
 641                 //   AnalyzeSKIP,
 642                 genericDestruct,
 643                 genericPrint},
 644                 POC_INCFSZ,
 645                 "INCFSZ",
 646                 NULL, // from branch
 647                 NULL, // to branch
 648                 NULL, // label
 649                 NULL, // operand
 650                 NULL, // flow block
 651                 NULL, // C source
 652                 2,    // num ops
 653                 1,0,  // dest, bit instruction
 654                 1,1,  // branch, skip
 655                 0,    // literal operand
 656                 POC_INCF,               // followed by BTFSC STATUS, Z --> also kills STATUS
 657                 PCC_REGISTER,           // inCond
 658                 PCC_REGISTER | PCC_Z    // outCond
 659 };
 660
 661 pCodeInstruction pciINCFSZW = {
 662         {PC_OPCODE, NULL, NULL, 0, 0, NULL,
 663                 //   AnalyzeSKIP,
 664                 genericDestruct,
 665                 genericPrint},
 666                 POC_INCFSZW,
 667                 "INCFSZ",
 668                 NULL, // from branch
 669                 NULL, // to branch
 670                 NULL, // label
 671                 NULL, // operand
 672                 NULL, // flow block
 673                 NULL, // C source
 674                 2,    // num ops
 675                 0,0,  // dest, bit instruction
 676                 1,1,  // branch, skip
 677                 0,    // literal operand
 678                 POC_INCFW,      // followed by BTFSC STATUS, Z --> also kills STATUS
 679                 PCC_REGISTER,   // inCond
 680                 PCC_W | PCC_Z   // outCond
 681 };
 682
 683 pCodeInstruction pciIORWF = {
 684         {PC_OPCODE, NULL, NULL, 0, 0, NULL,
 685                 //   genericAnalyze,
 686                 genericDestruct,
 687                 genericPrint},
 688                 POC_IORWF,
 689                 "IORWF",
 690                 NULL, // from branch
 691                 NULL, // to branch
 692                 NULL, // label
 693                 NULL, // operand
 694                 NULL, // flow block
 695                 NULL, // C source
 696                 2,    // num ops
 697                 1,0,  // dest, bit instruction
 698                 0,0,  // branch, skip
 699                 0,    // literal operand
 700                 POC_NOP,
 701                 (PCC_W | PCC_REGISTER),   // inCond
 702                 (PCC_REGISTER | PCC_Z) // outCond
 703 };
 704
 705 pCodeInstruction pciIORFW = {
 706         {PC_OPCODE, NULL, NULL, 0, 0, NULL,
 707                 //   genericAnalyze,
 708                 genericDestruct,
 709                 genericPrint},
 710                 POC_IORFW,
 711                 "IORWF",
 712                 NULL, // from branch
 713                 NULL, // to branch
 714                 NULL, // label
 715                 NULL, // operand
 716                 NULL, // flow block
 717                 NULL, // C source
 718                 2,    // num ops
 719                 0,0,  // dest, bit instruction
 720                 0,0,  // branch, skip
 721                 0,    // literal operand
 722                 POC_NOP,
 723                 (PCC_W | PCC_REGISTER),   // inCond
 724                 (PCC_W | PCC_Z) // outCond
 725 };
 726
 727 pCodeInstruction pciIORLW = {
 728         {PC_OPCODE, NULL, NULL, 0, 0, NULL,
 729                 //   genericAnalyze,
 730                 genericDestruct,
 731                 genericPrint},
 732                 POC_IORLW,
 733                 "IORLW",
 734                 NULL, // from branch
 735                 NULL, // to branch
 736                 NULL, // label
 737                 NULL, // operand
 738                 NULL, // flow block
 739                 NULL, // C source
 740                 1,    // num ops
 741                 0,0,  // dest, bit instruction
 742                 0,0,  // branch, skip
 743                 1,    // literal operand
 744                 POC_NOP,
 745                 (PCC_W | PCC_LITERAL),   // inCond
 746                 (PCC_W | PCC_Z) // outCond
 747 };
 748
 749 pCodeInstruction pciMOVF = {
 750         {PC_OPCODE, NULL, NULL, 0, 0, NULL,
 751                 //   genericAnalyze,
 752                 genericDestruct,
 753                 genericPrint},
 754                 POC_MOVF,
 755                 "MOVF",
 756                 NULL, // from branch
 757                 NULL, // to branch
 758                 NULL, // label
 759                 NULL, // operand
 760                 NULL, // flow block
 761                 NULL, // C source
 762                 2,    // num ops
 763                 1,0,  // dest, bit instruction
 764                 0,0,  // branch, skip
 765                 0,    // literal operand
 766                 POC_NOP,
 767                 PCC_REGISTER,   // inCond
 768                 PCC_Z // outCond
 769 };
 770
 771 pCodeInstruction pciMOVFW = {
 772         {PC_OPCODE, NULL, NULL, 0, 0, NULL,
 773                 //   genericAnalyze,
 774                 genericDestruct,
 775                 genericPrint},
 776                 POC_MOVFW,
 777                 "MOVF",
 778                 NULL, // from branch
 779                 NULL, // to branch
 780                 NULL, // label
 781                 NULL, // operand
 782                 NULL, // flow block
 783                 NULL, // C source
 784                 2,    // num ops
 785                 0,0,  // dest, bit instruction
 786                 0,0,  // branch, skip
 787                 0,    // literal operand
 788                 POC_NOP,
 789                 PCC_REGISTER,   // inCond
 790                 (PCC_W | PCC_Z) // outCond
 791 };
 792
 793 pCodeInstruction pciMOVWF = {
 794         {PC_OPCODE, NULL, NULL, 0, 0, NULL,
 795                 //   genericAnalyze,
 796                 genericDestruct,
 797                 genericPrint},
 798                 POC_MOVWF,
 799                 "MOVWF",
 800                 NULL, // from branch
 801                 NULL, // to branch
 802                 NULL, // label
 803                 NULL, // operand
 804                 NULL, // flow block
 805                 NULL, // C source
 806                 1,    // num ops
 807                 0,0,  // dest, bit instruction
 808                 0,0,  // branch, skip
 809                 0,    // literal operand
 810                 POC_NOP,
 811                 PCC_W,   // inCond
 812                 PCC_REGISTER // outCond
 813 };
 814
 815 pCodeInstruction pciMOVLW = {
 816         {PC_OPCODE, NULL, NULL, 0, 0, NULL,
 817                 genericDestruct,
 818                 genericPrint},
 819                 POC_MOVLW,
 820                 "MOVLW",
 821                 NULL, // from branch
 822                 NULL, // to branch
 823                 NULL, // label
 824                 NULL, // operand
 825                 NULL, // flow block
 826                 NULL, // C source
 827                 1,    // num ops
 828                 0,0,  // dest, bit instruction
 829                 0,0,  // branch, skip
 830                 1,    // literal operand
 831                 POC_NOP,
 832                 (PCC_NONE | PCC_LITERAL),   // inCond
 833                 PCC_W // outCond
 834 };
 835
 836 pCodeInstruction pciNOP = {
 837         {PC_OPCODE, NULL, NULL, 0, 0, NULL,
 838                 genericDestruct,
 839                 genericPrint},
 840                 POC_NOP,
 841                 "NOP",
 842                 NULL, // from branch
 843                 NULL, // to branch
 844                 NULL, // label
 845                 NULL, // operand
 846                 NULL, // flow block
 847                 NULL, // C source
 848                 0,    // num ops
 849                 0,0,  // dest, bit instruction
 850                 0,0,  // branch, skip
 851                 0,    // literal operand
 852                 POC_NOP,
 853                 PCC_NONE,   // inCond
 854                 PCC_NONE // outCond
 855 };
 856
 857 pCodeInstruction pciRETFIE = {
 858         {PC_OPCODE, NULL, NULL, 0, 0, NULL,
 859                 //   AnalyzeRETURN,
 860                 genericDestruct,
 861                 genericPrint},
 862                 POC_RETFIE,
 863                 "RETFIE",
 864                 NULL, // from branch
 865                 NULL, // to branch
 866                 NULL, // label
 867                 NULL, // operand
 868                 NULL, // flow block
 869                 NULL, // C source
 870                 0,    // num ops
 871                 0,0,  // dest, bit instruction
 872                 1,0,  // branch, skip
 873                 0,    // literal operand
 874                 POC_NOP,
 875                 PCC_NONE,   // inCond
 876                 (PCC_NONE | PCC_C | PCC_DC | PCC_Z) // outCond (not true... affects the GIE bit too), STATUS bit are retored
 877 };
 878
 879 pCodeInstruction pciRETLW = {
 880         {PC_OPCODE, NULL, NULL, 0, 0, NULL,
 881                 //   AnalyzeRETURN,
 882                 genericDestruct,
 883                 genericPrint},
 884                 POC_RETLW,
 885                 "RETLW",
 886                 NULL, // from branch
 887                 NULL, // to branch
 888                 NULL, // label
 889                 NULL, // operand
 890                 NULL, // flow block
 891                 NULL, // C source
 892                 1,    // num ops
 893                 0,0,  // dest, bit instruction
 894                 1,0,  // branch, skip
 895                 1,    // literal operand
 896                 POC_NOP,
 897                 PCC_LITERAL,   // inCond
 898                 (PCC_W| PCC_C | PCC_DC | PCC_Z) // outCond, STATUS bits are irrelevant after RETLW
 899 };
 900
 901 pCodeInstruction pciRETURN = {
 902         {PC_OPCODE, NULL, NULL, 0, 0, NULL,
 903                 //   AnalyzeRETURN,
 904                 genericDestruct,
 905                 genericPrint},
 906                 POC_RETURN,
 907                 "RETURN",
 908                 NULL, // from branch
 909                 NULL, // to branch
 910                 NULL, // label
 911                 NULL, // operand
 912                 NULL, // flow block
 913                 NULL, // C source
 914                 0,    // num ops
 915                 0,0,  // dest, bit instruction
 916                 1,0,  // branch, skip
 917                 0,    // literal operand
 918                 POC_NOP,
 919                 PCC_NONE | PCC_W,   // inCond, return value is possibly present in W
 920                 (PCC_NONE | PCC_C | PCC_DC | PCC_Z) // outCond, STATUS bits are irrelevant after RETURN
 921 };
 922
 923 pCodeInstruction pciRLF = {
 924         {PC_OPCODE, NULL, NULL, 0, 0, NULL,
 925                 //   genericAnalyze,
 926                 genericDestruct,
 927                 genericPrint},
 928                 POC_RLF,
 929                 "RLF",
 930                 NULL, // from branch
 931                 NULL, // to branch
 932                 NULL, // label
 933                 NULL, // operand
 934                 NULL, // flow block
 935                 NULL, // C source
 936                 2,    // num ops
 937                 1,0,  // dest, bit instruction
 938                 0,0,  // branch, skip
 939                 0,    // literal operand
 940                 POC_NOP,
 941                 (PCC_C | PCC_REGISTER),   // inCond
 942                 (PCC_REGISTER | PCC_C ) // outCond
 943 };
 944
 945 pCodeInstruction pciRLFW = {
 946         {PC_OPCODE, NULL, NULL, 0, 0, NULL,
 947                 //   genericAnalyze,
 948                 genericDestruct,
 949                 genericPrint},
 950                 POC_RLFW,
 951                 "RLF",
 952                 NULL, // from branch
 953                 NULL, // to branch
 954                 NULL, // label
 955                 NULL, // operand
 956                 NULL, // flow block
 957                 NULL, // C source
 958                 2,    // num ops
 959                 0,0,  // dest, bit instruction
 960                 0,0,  // branch, skip
 961                 0,    // literal operand
 962                 POC_NOP,
 963                 (PCC_C | PCC_REGISTER),   // inCond
 964                 (PCC_W | PCC_C) // outCond
 965 };
 966
 967 pCodeInstruction pciRRF = {
 968         {PC_OPCODE, NULL, NULL, 0, 0, NULL,
 969                 //   genericAnalyze,
 970                 genericDestruct,
 971                 genericPrint},
 972                 POC_RRF,
 973                 "RRF",
 974                 NULL, // from branch
 975                 NULL, // to branch
 976                 NULL, // label
 977                 NULL, // operand
 978                 NULL, // flow block
 979                 NULL, // C source
 980                 2,    // num ops
 981                 1,0,  // dest, bit instruction
 982                 0,0,  // branch, skip
 983                 0,    // literal operand
 984                 POC_NOP,
 985                 (PCC_C | PCC_REGISTER),   // inCond
 986                 (PCC_REGISTER | PCC_C) // outCond
 987 };
 988
 989 pCodeInstruction pciRRFW = {
 990         {PC_OPCODE, NULL, NULL, 0, 0, NULL,
 991                 //   genericAnalyze,
 992                 genericDestruct,
 993                 genericPrint},
 994                 POC_RRFW,
 995                 "RRF",
 996                 NULL, // from branch
 997                 NULL, // to branch
 998                 NULL, // label
 999                 NULL, // operand
1000                 NULL, // flow block
1001                 NULL, // C source
1002                 2,    // num ops
1003                 0,0,  // dest, bit instruction
1004                 0,0,  // branch, skip
1005                 0,    // literal operand
1006                 POC_NOP,
1007                 (PCC_C | PCC_REGISTER),   // inCond
1008                 (PCC_W | PCC_C) // outCond
1009 };
1010
1011 pCodeInstruction pciSUBWF = {
1012         {PC_OPCODE, NULL, NULL, 0, 0, NULL,
1013                 //   genericAnalyze,
1014                 genericDestruct,
1015                 genericPrint},
1016                 POC_SUBWF,
1017                 "SUBWF",
1018                 NULL, // from branch
1019                 NULL, // to branch
1020                 NULL, // label
1021                 NULL, // operand
1022                 NULL, // flow block
1023                 NULL, // C source
1024                 2,    // num ops
1025                 1,0,  // dest, bit instruction
1026                 0,0,  // branch, skip
1027                 0,    // literal operand
1028                 POC_NOP,
1029                 (PCC_W | PCC_REGISTER),   // inCond
1030                 (PCC_REGISTER | PCC_C | PCC_DC | PCC_Z) // outCond
1031 };
1032
1033 pCodeInstruction pciSUBFW = {
1034         {PC_OPCODE, NULL, NULL, 0, 0, NULL,
1035                 //   genericAnalyze,
1036                 genericDestruct,
1037                 genericPrint},
1038                 POC_SUBFW,
1039                 "SUBWF",
1040                 NULL, // from branch
1041                 NULL, // to branch
1042                 NULL, // label
1043                 NULL, // operand
1044                 NULL, // flow block
1045                 NULL, // C source
1046                 2,    // num ops
1047                 0,0,  // dest, bit instruction
1048                 0,0,  // branch, skip
1049                 0,    // literal operand
1050                 POC_NOP,
1051                 (PCC_W | PCC_REGISTER),   // inCond
1052                 (PCC_W | PCC_C | PCC_DC | PCC_Z) // outCond
1053 };
1054
1055 pCodeInstruction pciSUBLW = {
1056         {PC_OPCODE, NULL, NULL, 0, 0, NULL,
1057                 //   genericAnalyze,
1058                 genericDestruct,
1059                 genericPrint},
1060                 POC_SUBLW,
1061                 "SUBLW",
1062                 NULL, // from branch
1063                 NULL, // to branch
1064                 NULL, // label
1065                 NULL, // operand
1066                 NULL, // flow block
1067                 NULL, // C source
1068                 1,    // num ops
1069                 0,0,  // dest, bit instruction
1070                 0,0,  // branch, skip
1071                 1,    // literal operand
1072                 POC_NOP,
1073                 (PCC_W | PCC_LITERAL),   // inCond
1074                 (PCC_W | PCC_Z | PCC_C | PCC_DC) // outCond
1075 };
1076
1077 pCodeInstruction pciSWAPF = {
1078         {PC_OPCODE, NULL, NULL, 0, 0, NULL,
1079                 //   genericAnalyze,
1080                 genericDestruct,
1081                 genericPrint},
1082                 POC_SWAPF,
1083                 "SWAPF",
1084                 NULL, // from branch
1085                 NULL, // to branch
1086                 NULL, // label
1087                 NULL, // operand
1088                 NULL, // flow block
1089                 NULL, // C source
1090                 2,    // num ops
1091                 1,0,  // dest, bit instruction
1092                 0,0,  // branch, skip
1093                 0,    // literal operand
1094                 POC_NOP,
1095                 (PCC_REGISTER),   // inCond
1096                 (PCC_REGISTER) // outCond
1097 };
1098
1099 pCodeInstruction pciSWAPFW = {
1100         {PC_OPCODE, NULL, NULL, 0, 0, NULL,
1101                 //   genericAnalyze,
1102                 genericDestruct,
1103                 genericPrint},
1104                 POC_SWAPFW,
1105                 "SWAPF",
1106                 NULL, // from branch
1107                 NULL, // to branch
1108                 NULL, // label
1109                 NULL, // operand
1110                 NULL, // flow block
1111                 NULL, // C source
1112                 2,    // num ops
1113                 0,0,  // dest, bit instruction
1114                 0,0,  // branch, skip
1115                 0,    // literal operand
1116                 POC_NOP,
1117                 (PCC_REGISTER),   // inCond
1118                 (PCC_W) // outCond
1119 };
1120
1121 pCodeInstruction pciTRIS = {
1122         {PC_OPCODE, NULL, NULL, 0, 0, NULL,
1123                 //   genericAnalyze,
1124                 genericDestruct,
1125                 genericPrint},
1126                 POC_TRIS,
1127                 "TRIS",
1128                 NULL, // from branch
1129                 NULL, // to branch
1130                 NULL, // label
1131                 NULL, // operand
1132                 NULL, // flow block
1133                 NULL, // C source
1134                 1,    // num ops
1135                 0,0,  // dest, bit instruction
1136                 0,0,  // branch, skip
1137                 0,    // literal operand
1138                 POC_NOP,
1139                 PCC_NONE,   // inCond /* FIXME: what's TRIS doing? */
1140                 PCC_REGISTER // outCond /* FIXME: what's TRIS doing */
1141 };
1142
1143 pCodeInstruction pciXORWF = {
1144         {PC_OPCODE, NULL, NULL, 0, 0, NULL,
1145                 //   genericAnalyze,
1146                 genericDestruct,
1147                 genericPrint},
1148                 POC_XORWF,
1149                 "XORWF",
1150                 NULL, // from branch
1151                 NULL, // to branch
1152                 NULL, // label
1153                 NULL, // operand
1154                 NULL, // flow block
1155                 NULL, // C source
1156                 2,    // num ops
1157                 1,0,  // dest, bit instruction
1158                 0,0,  // branch, skip
1159                 0,    // literal operand
1160                 POC_NOP,
1161                 (PCC_W | PCC_REGISTER),   // inCond
1162                 (PCC_REGISTER | PCC_Z) // outCond
1163 };
1164
1165 pCodeInstruction pciXORFW = {
1166         {PC_OPCODE, NULL, NULL, 0, 0, NULL,
1167                 //   genericAnalyze,
1168                 genericDestruct,
1169                 genericPrint},
1170                 POC_XORFW,
1171                 "XORWF",
1172                 NULL, // from branch
1173                 NULL, // to branch
1174                 NULL, // label
1175                 NULL, // operand
1176                 NULL, // flow block
1177                 NULL, // C source
1178                 2,    // num ops
1179                 0,0,  // dest, bit instruction
1180                 0,0,  // branch, skip
1181                 0,    // literal operand
1182                 POC_NOP,
1183                 (PCC_W | PCC_REGISTER),   // inCond
1184                 (PCC_W | PCC_Z) // outCond
1185 };
1186
1187 pCodeInstruction pciXORLW = {
1188         {PC_OPCODE, NULL, NULL, 0, 0, NULL,
1189                 //   genericAnalyze,
1190                 genericDestruct,
1191                 genericPrint},
1192                 POC_XORLW,
1193                 "XORLW",
1194                 NULL, // from branch
1195                 NULL, // to branch
1196                 NULL, // label
1197                 NULL, // operand
1198                 NULL, // flow block
1199                 NULL, // C source
1200                 1,    // num ops
1201                 0,0,  // dest, bit instruction
1202                 0,0,  // branch, skip
1203                 1,    // literal operand
1204                 POC_NOP,
1205                 (PCC_W | PCC_LITERAL),   // inCond
1206                 (PCC_W | PCC_Z) // outCond
1207 };
1208
1209
1210 pCodeInstruction pciBANKSEL = {
1211         {PC_OPCODE, NULL, NULL, 0, 0, NULL,
1212                 //   genericAnalyze,
1213                 genericDestruct,
1214                 genericPrint},
1215                 POC_BANKSEL,
1216                 "BANKSEL",
1217                 NULL, // from branch
1218                 NULL, // to branch
1219                 NULL, // label
1220                 NULL, // operand
1221                 NULL, // flow block
1222                 NULL, // C source
1223                 1,    // num ops
1224                 0,0,  // dest, bit instruction
1225                 0,0,  // branch, skip
1226                 0,    // literal operand
1227                 POC_NOP,
1228                 PCC_NONE, // inCond
1229                 PCC_NONE  // outCond
1230 };
1231
1232 pCodeInstruction pciPAGESEL = {
1233         {PC_OPCODE, NULL, NULL, 0, 0, NULL,
1234                 //   genericAnalyze,
1235                 genericDestruct,
1236                 genericPrint},
1237                 POC_PAGESEL,
1238                 "PAGESEL",
1239                 NULL, // from branch
1240                 NULL, // to branch
1241                 NULL, // label
1242                 NULL, // operand
1243                 NULL, // flow block
1244                 NULL, // C source
1245                 1,    // num ops
1246                 0,0,  // dest, bit instruction
1247                 0,0,  // branch, skip
1248                 0,    // literal operand
1249                 POC_NOP,
1250                 PCC_NONE, // inCond
1251                 PCC_NONE  // outCond
1252 };
1253
1254 pCodeInstruction *pic14Mnemonics[MAX_PIC14MNEMONICS];
1255
1256
1257 /*-----------------------------------------------------------------*/
1258 /* return a unique ID number to assist pCodes debuging             */
1259 /*-----------------------------------------------------------------*/
1260 unsigned PCodeID(void) {
1261         static unsigned int pcodeId = 1; /* unique ID number to be assigned to all pCodes */
1262         /*
1263         static unsigned int stop;
1264         if (pcodeId == 1448)
1265                 stop++; // Place break point here
1266         */
1267         return pcodeId++;
1268 }
1269
1270 #ifdef HAVE_VSNPRINTF
1271 // Alas, vsnprintf is not ANSI standard, and does not exist
1272 // on Solaris (and probably other non-Gnu flavored Unixes).
1273
1274 /*-----------------------------------------------------------------*/
1275 /* SAFE_snprintf - like snprintf except the string pointer is      */
1276 /*                 after the string has been printed to. This is   */
1277 /*                 useful for printing to string as though if it   */
1278 /*                 were a stream.                                  */
1279 /*-----------------------------------------------------------------*/
1280 void SAFE_snprintf(char **str, size_t *size, const  char  *format, ...)
1281 {
1282         va_list val;
1283         int len;
1284
1285         if(!str || !*str)
1286                 return;
1287
1288         va_start(val, format);
1289
1290         vsnprintf(*str, *size, format, val);
1291
1292         va_end (val);
1293
1294         len = strlen(*str);
1295         if((size_t)len > *size) {
1296                 fprintf(stderr,"WARNING, it looks like %s has overflowed\n",__FUNCTION__);
1297                 fprintf(stderr,"len = %d is > str size %d\n",len,(int)*size);
1298         }
1299
1300         *str += len;
1301         *size -= len;
1302
1303 }
1304
1305 #else  //  HAVE_VSNPRINTF
1306
1307 // This version is *not* safe, despite the name.
1308
1309 void SAFE_snprintf(char **str, size_t *size, const  char  *format, ...)
1310 {
1311         va_list val;
1312         int len;
1313         static char buffer[1024]; /* grossly conservative, but still not inherently safe */
1314
1315         if(!str || !*str)
1316                 return;
1317
1318         va_start(val, format);
1319
1320         vsprintf(buffer, format, val);
1321         va_end (val);
1322
1323         len = strlen(buffer);
1324         if(len > *size) {
1325                 fprintf(stderr,"WARNING, it looks like %s has overflowed\n",__FUNCTION__);
1326                 fprintf(stderr,"len = %d is > str size %d\n",len,*size);
1327         }
1328
1329         strcpy(*str, buffer);
1330         *str += len;
1331         *size -= len;
1332
1333 }
1334
1335 #endif    //  HAVE_VSNPRINTF
1336
1337
1338 extern  void initStack(int base_address, int size, int shared);
1339 extern regs *allocProcessorRegister(int rIdx, char * name, short po_type, int alias);
1340 extern regs *allocInternalRegister(int rIdx, char * name, PIC_OPTYPE po_type, int alias);
1341 extern PIC_device *init_pic(char *);
1342
1343 void  pCodeInitRegisters(void)
1344 {
1345         static int initialized=0;
1346         int shareBankAddress, stkSize, haveShared;
1347         PIC_device *pic;
1348
1349         if(initialized)
1350                 return;
1351         initialized = 1;
1352
1353         pic = init_pic(port->processor);
1354         haveShared = pic14_getSharedStack(NULL, &shareBankAddress, &stkSize);
1355         /* Set pseudo stack size to SHAREBANKSIZE - 3.
1356          * On multi memory bank ICs this leaves room for WSAVE/SSAVE/PSAVE
1357          * (used for interrupts) to fit into the shared portion of the
1358          * memory bank. */
1359         stkSize = stkSize - 3;
1360         assert(stkSize >= 0);
1361         initStack(shareBankAddress, stkSize, haveShared);
1362
1363         /* TODO: Read aliases for SFRs from regmap lines in device description. */
1364         pc_status.r = allocProcessorRegister(IDX_STATUS,"STATUS", PO_STATUS, 0x180);
1365         pc_pcl.r = allocProcessorRegister(IDX_PCL,"PCL", PO_PCL, 0x80);
1366         pc_pclath.r = allocProcessorRegister(IDX_PCLATH,"PCLATH", PO_PCLATH, 0x180);
1367         pc_fsr.r = allocProcessorRegister(IDX_FSR,"FSR", PO_FSR, 0x180);
1368         pc_indf.r = allocProcessorRegister(IDX_INDF,"INDF", PO_INDF, 0x180);
1369         pc_intcon.r = allocProcessorRegister(IDX_INTCON,"INTCON", PO_INTCON, 0x180);
1370
1371         pc_status.rIdx = IDX_STATUS;
1372         pc_fsr.rIdx = IDX_FSR;
1373         pc_indf.rIdx = IDX_INDF;
1374         pc_intcon.rIdx = IDX_INTCON;
1375         pc_pcl.rIdx = IDX_PCL;
1376         pc_pclath.rIdx = IDX_PCLATH;
1377
1378         /* Interrupt storage for working register - must be same address in all banks ie section SHAREBANK. */
1379         pc_wsave.r = allocInternalRegister(IDX_WSAVE,pc_wsave.pcop.name,pc_wsave.pcop.type, pic ? pic->bankMask : 0x180);
1380         /* Interrupt storage for status register. */
1381         pc_ssave.r = allocInternalRegister(IDX_SSAVE,pc_ssave.pcop.name,pc_ssave.pcop.type, (pic && haveShared) ? pic->bankMask : 0);
1382         /* Interrupt storage for pclath register. */
1383         pc_psave.r = allocInternalRegister(IDX_PSAVE,pc_psave.pcop.name,pc_psave.pcop.type, (pic && haveShared) ? pic->bankMask : 0);
1384
1385         pc_wsave.rIdx = pc_wsave.r->rIdx;
1386         pc_ssave.rIdx = pc_ssave.r->rIdx;
1387         pc_psave.rIdx = pc_psave.r->rIdx;
1388
1389         pc_wsave.r->isFixed = 1; /* Some PIC ICs do not have a sharebank - this register needs to be reserved across all banks. */
1390         pc_wsave.r->address = shareBankAddress-stkSize;
1391         pc_ssave.r->isFixed = 1; /* This register must be in the first bank. */
1392         pc_ssave.r->address = shareBankAddress-stkSize-1;
1393         pc_psave.r->isFixed = 1; /* This register must be in the first bank. */
1394         pc_psave.r->address = shareBankAddress-stkSize-2;
1395
1396         /* probably should put this in a separate initialization routine */
1397         pb_dead_pcodes = newpBlock();
1398
1399 }
1400
1401 /*-----------------------------------------------------------------*/
1402 /*  mnem2key - convert a pic mnemonic into a hash key              */
1403 /*   (BTW - this spreads the mnemonics quite well)                 */
1404 /*                                                                 */
1405 /*-----------------------------------------------------------------*/
1406
1407 int mnem2key(unsigned char const *mnem)
1408 {
1409         int key = 0;
1410
1411         if(!mnem)
1412                 return 0;
1413
1414         while(*mnem) {
1415
1416                 key += toupper(*mnem++) +1;
1417
1418         }
1419
1420         return (key & 0x1f);
1421
1422 }
1423
1424 void pic14initMnemonics(void)
1425 {
1426         int i = 0;
1427         int key;
1428         //  char *str;
1429         pCodeInstruction *pci;
1430
1431         if(mnemonics_initialized)
1432                 return;
1433
1434         //FIXME - probably should NULL out the array before making the assignments
1435         //since we check the array contents below this initialization.
1436
1437         pic14Mnemonics[POC_ADDLW] = &pciADDLW;
1438         pic14Mnemonics[POC_ADDWF] = &pciADDWF;
1439         pic14Mnemonics[POC_ADDFW] = &pciADDFW;
1440         pic14Mnemonics[POC_ANDLW] = &pciANDLW;
1441         pic14Mnemonics[POC_ANDWF] = &pciANDWF;
1442         pic14Mnemonics[POC_ANDFW] = &pciANDFW;
1443         pic14Mnemonics[POC_BCF] = &pciBCF;
1444         pic14Mnemonics[POC_BSF] = &pciBSF;
1445         pic14Mnemonics[POC_BTFSC] = &pciBTFSC;
1446         pic14Mnemonics[POC_BTFSS] = &pciBTFSS;
1447         pic14Mnemonics[POC_CALL] = &pciCALL;
1448         pic14Mnemonics[POC_COMF] = &pciCOMF;
1449         pic14Mnemonics[POC_COMFW] = &pciCOMFW;
1450         pic14Mnemonics[POC_CLRF] = &pciCLRF;
1451         pic14Mnemonics[POC_CLRW] = &pciCLRW;
1452         pic14Mnemonics[POC_CLRWDT] = &pciCLRWDT;
1453         pic14Mnemonics[POC_DECF] = &pciDECF;
1454         pic14Mnemonics[POC_DECFW] = &pciDECFW;
1455         pic14Mnemonics[POC_DECFSZ] = &pciDECFSZ;
1456         pic14Mnemonics[POC_DECFSZW] = &pciDECFSZW;
1457         pic14Mnemonics[POC_GOTO] = &pciGOTO;
1458         pic14Mnemonics[POC_INCF] = &pciINCF;
1459         pic14Mnemonics[POC_INCFW] = &pciINCFW;
1460         pic14Mnemonics[POC_INCFSZ] = &pciINCFSZ;
1461         pic14Mnemonics[POC_INCFSZW] = &pciINCFSZW;
1462         pic14Mnemonics[POC_IORLW] = &pciIORLW;
1463         pic14Mnemonics[POC_IORWF] = &pciIORWF;
1464         pic14Mnemonics[POC_IORFW] = &pciIORFW;
1465         pic14Mnemonics[POC_MOVF] = &pciMOVF;
1466         pic14Mnemonics[POC_MOVFW] = &pciMOVFW;
1467         pic14Mnemonics[POC_MOVLW] = &pciMOVLW;
1468         pic14Mnemonics[POC_MOVWF] = &pciMOVWF;
1469         pic14Mnemonics[POC_NOP] = &pciNOP;
1470         pic14Mnemonics[POC_RETFIE] = &pciRETFIE;
1471         pic14Mnemonics[POC_RETLW] = &pciRETLW;
1472         pic14Mnemonics[POC_RETURN] = &pciRETURN;
1473         pic14Mnemonics[POC_RLF] = &pciRLF;
1474         pic14Mnemonics[POC_RLFW] = &pciRLFW;
1475         pic14Mnemonics[POC_RRF] = &pciRRF;
1476         pic14Mnemonics[POC_RRFW] = &pciRRFW;
1477         pic14Mnemonics[POC_SUBLW] = &pciSUBLW;
1478         pic14Mnemonics[POC_SUBWF] = &pciSUBWF;
1479         pic14Mnemonics[POC_SUBFW] = &pciSUBFW;
1480         pic14Mnemonics[POC_SWAPF] = &pciSWAPF;
1481         pic14Mnemonics[POC_SWAPFW] = &pciSWAPFW;
1482         pic14Mnemonics[POC_TRIS] = &pciTRIS;
1483         pic14Mnemonics[POC_XORLW] = &pciXORLW;
1484         pic14Mnemonics[POC_XORWF] = &pciXORWF;
1485         pic14Mnemonics[POC_XORFW] = &pciXORFW;
1486         pic14Mnemonics[POC_BANKSEL] = &pciBANKSEL;
1487         pic14Mnemonics[POC_PAGESEL] = &pciPAGESEL;
1488
1489         for(i=0; i<MAX_PIC14MNEMONICS; i++)
1490                 if(pic14Mnemonics[i])
1491                         hTabAddItem(&pic14MnemonicsHash, mnem2key((unsigned char *)pic14Mnemonics[i]->mnemonic), pic14Mnemonics[i]);
1492                 pci = hTabFirstItem(pic14MnemonicsHash, &key);
1493
1494                 while(pci) {
1495                         DFPRINTF((stderr, "element %d key %d, mnem %s\n",i++,key,pci->mnemonic));
1496                         pci = hTabNextItem(pic14MnemonicsHash, &key);
1497                 }
1498
1499                 mnemonics_initialized = 1;
1500 }
1501
1502 int getpCodePeepCommand(char *cmd);
1503
1504 int getpCode(char *mnem,unsigned dest)
1505 {
1506
1507         pCodeInstruction *pci;
1508         int key = mnem2key((unsigned char *)mnem);
1509
1510         if(!mnemonics_initialized)
1511                 pic14initMnemonics();
1512
1513         pci = hTabFirstItemWK(pic14MnemonicsHash, key);
1514
1515         while(pci) {
1516
1517                 if(STRCASECMP(pci->mnemonic, mnem) == 0) {
1518                         if((pci->num_ops <= 1) || (pci->isModReg == dest) || (pci->isBitInst))
1519                                 return(pci->op);
1520                 }
1521
1522                 pci = hTabNextItemWK (pic14MnemonicsHash);
1523
1524         }
1525
1526         return -1;
1527 }
1528
1529 /*-----------------------------------------------------------------*
1530 * pic14initpCodePeepCommands
1531 *
1532 *-----------------------------------------------------------------*/
1533 void pic14initpCodePeepCommands(void)
1534 {
1535
1536         int key, i;
1537         peepCommand *pcmd;
1538
1539         i = 0;
1540         do {
1541                 hTabAddItem(&pic14pCodePeepCommandsHash,
1542                         mnem2key((unsigned char *)peepCommands[i].cmd), &peepCommands[i]);
1543                 i++;
1544         } while (peepCommands[i].cmd);
1545
1546         pcmd = hTabFirstItem(pic14pCodePeepCommandsHash, &key);
1547
1548         while(pcmd) {
1549                 //fprintf(stderr, "peep command %s  key %d\n",pcmd->cmd,pcmd->id);
1550                 pcmd = hTabNextItem(pic14pCodePeepCommandsHash, &key);
1551         }
1552
1553 }
1554
1555 /*-----------------------------------------------------------------
1556 *
1557 *
1558 *-----------------------------------------------------------------*/
1559
1560 int getpCodePeepCommand(char *cmd)
1561 {
1562
1563         peepCommand *pcmd;
1564         int key = mnem2key((unsigned char *)cmd);
1565
1566
1567         pcmd = hTabFirstItemWK(pic14pCodePeepCommandsHash, key);
1568
1569         while(pcmd) {
1570                 // fprintf(stderr," comparing %s to %s\n",pcmd->cmd,cmd);
1571                 if(STRCASECMP(pcmd->cmd, cmd) == 0) {
1572                         return pcmd->id;
1573                 }
1574
1575                 pcmd = hTabNextItemWK (pic14pCodePeepCommandsHash);
1576
1577         }
1578
1579         return -1;
1580 }
1581
1582 char getpBlock_dbName(pBlock *pb)
1583 {
1584         if(!pb)
1585                 return 0;
1586
1587         if(pb->cmemmap)
1588                 return pb->cmemmap->dbName;
1589
1590         return pb->dbName;
1591 }
1592 void pBlockConvert2ISR(pBlock *pb)
1593 {
1594         if(!pb)
1595                 return;
1596
1597         if(pb->cmemmap)
1598                 pb->cmemmap = NULL;
1599
1600         pb->dbName = 'I';
1601 }
1602
1603 /*-----------------------------------------------------------------*/
1604 /* movepBlock2Head - given the dbname of a pBlock, move all        */
1605 /*                   instances to the front of the doubly linked   */
1606 /*                   list of pBlocks                               */
1607 /*-----------------------------------------------------------------*/
1608
1609 void movepBlock2Head(char dbName)
1610 {
1611         pBlock *pb;
1612
1613         if (!the_pFile)
1614                 return;
1615
1616         pb = the_pFile->pbHead;
1617
1618         while(pb) {
1619
1620                 if(getpBlock_dbName(pb) == dbName) {
1621                         pBlock *pbn = pb->next;
1622                         pb->next = the_pFile->pbHead;
1623                         the_pFile->pbHead->prev = pb;
1624                         the_pFile->pbHead = pb;
1625
1626                         if(pb->prev)
1627                                 pb->prev->next = pbn;
1628
1629                         // If the pBlock that we just moved was the last
1630                         // one in the link of all of the pBlocks, then we
1631                         // need to point the tail to the block just before
1632                         // the one we moved.
1633                         // Note: if pb->next is NULL, then pb must have
1634                         // been the last pBlock in the chain.
1635
1636                         if(pbn)
1637                                 pbn->prev = pb->prev;
1638                         else
1639                                 the_pFile->pbTail = pb->prev;
1640
1641                         pb = pbn;
1642
1643                 } else
1644                         pb = pb->next;
1645
1646         }
1647
1648 }
1649
1650 void copypCode(FILE *of, char dbName)
1651 {
1652         pBlock *pb;
1653
1654         if(!of || !the_pFile)
1655                 return;
1656
1657         for(pb = the_pFile->pbHead; pb; pb = pb->next) {
1658                 if(getpBlock_dbName(pb) == dbName) {
1659                         pBlockStats(of,pb);
1660                         printpBlock(of,pb);
1661                         fprintf (of, "\n");
1662                 }
1663         }
1664
1665 }
1666
1667 void resetpCodeStatistics (void)
1668 {
1669   pcode_insns = pcode_doubles = 0;
1670 }
1671
1672 void dumppCodeStatistics (FILE *of)
1673 {
1674         /* dump statistics */
1675         fprintf (of, "\n");
1676         fprintf (of, ";\tcode size estimation:\n");
1677         fprintf (of, ";\t%5u+%5u = %5u instructions (%5u byte)\n", pcode_insns, pcode_doubles, pcode_insns + pcode_doubles, 2*(pcode_insns + 2*pcode_doubles));
1678         fprintf (of, "\n");
1679 }
1680
1681 void pcode_test(void)
1682 {
1683
1684         DFPRINTF((stderr,"pcode is alive!\n"));
1685
1686         //initMnemonics();
1687
1688         if(the_pFile) {
1689
1690                 pBlock *pb;
1691                 FILE *pFile;
1692                 char buffer[100];
1693
1694                 /* create the file name */
1695                 strcpy(buffer,dstFileName);
1696                 strcat(buffer,".p");
1697
1698                 if( !(pFile = fopen(buffer, "w" ))) {
1699                         werror(E_FILE_OPEN_ERR,buffer);
1700                         exit(1);
1701                 }
1702
1703                 fprintf(pFile,"pcode dump\n\n");
1704
1705                 for(pb = the_pFile->pbHead; pb; pb = pb->next) {
1706                         fprintf(pFile,"\n\tNew pBlock\n\n");
1707                         if(pb->cmemmap)
1708                                 fprintf(pFile,"%s",pb->cmemmap->sname);
1709                         else
1710                                 fprintf(pFile,"internal pblock");
1711
1712                         fprintf(pFile,", dbName =%c\n",getpBlock_dbName(pb));
1713                         printpBlock(pFile,pb);
1714                 }
1715         }
1716 }
1717 /*-----------------------------------------------------------------*/
1718 /* int RegCond(pCodeOp *pcop) - if pcop points to the STATUS reg-  */
1719 /*      ister, RegCond will return the bit being referenced.       */
1720 /*                                                                 */
1721 /* fixme - why not just OR in the pcop bit field                   */
1722 /*-----------------------------------------------------------------*/
1723
1724 static int RegCond(pCodeOp *pcop)
1725 {
1726
1727         if(!pcop)
1728                 return 0;
1729
1730         if (pcop->type == PO_GPR_BIT) {
1731                 char *name = pcop->name;
1732                 if (!name)
1733                         name = PCOR(pcop)->r->name;
1734                 if (strcmp(name, pc_status.pcop.name) == 0)
1735                 {
1736                         switch(PCORB(pcop)->bit) {
1737                         case PIC_C_BIT:
1738                                 return PCC_C;
1739                         case PIC_DC_BIT:
1740                                 return PCC_DC;
1741                         case PIC_Z_BIT:
1742                                 return PCC_Z;
1743                         }
1744                 }
1745         }
1746
1747         return 0;
1748 }
1749
1750 /*-----------------------------------------------------------------*/
1751 /* newpCode - create and return a newly initialized pCode          */
1752 /*                                                                 */
1753 /*  fixme - rename this                                            */
1754 /*                                                                 */
1755 /* The purpose of this routine is to create a new Instruction      */
1756 /* pCode. This is called by gen.c while the assembly code is being */
1757 /* generated.                                                      */
1758 /*                                                                 */
1759 /* Inouts:                                                         */
1760 /*  PIC_OPCODE op - the assembly instruction we wish to create.    */
1761 /*                  (note that the op is analogous to but not the  */
1762 /*                  same thing as the opcode of the instruction.)  */
1763 /*  pCdoeOp *pcop - pointer to the operand of the instruction.     */
1764 /*                                                                 */
1765 /* Outputs:                                                        */
1766 /*  a pointer to the new malloc'd pCode is returned.               */
1767 /*                                                                 */
1768 /*                                                                 */
1769 /*                                                                 */
1770 /*-----------------------------------------------------------------*/
1771 pCode *newpCode (PIC_OPCODE op, pCodeOp *pcop)
1772 {
1773         pCodeInstruction *pci ;
1774
1775         if(!mnemonics_initialized)
1776                 pic14initMnemonics();
1777
1778         pci = Safe_calloc(1, sizeof(pCodeInstruction));
1779
1780         if((op>=0) && (op < MAX_PIC14MNEMONICS) && pic14Mnemonics[op]) {
1781                 memcpy(pci, pic14Mnemonics[op], sizeof(pCodeInstruction));
1782                 pci->pc.id = PCodeID();
1783                 pci->pcop = pcop;
1784
1785                 if(pci->inCond & PCC_EXAMINE_PCOP)
1786                         pci->inCond  |= RegCond(pcop);
1787
1788                 if(pci->outCond & PCC_EXAMINE_PCOP)
1789                         pci->outCond  |= RegCond(pcop);
1790
1791                 pci->pc.prev = pci->pc.next = NULL;
1792                 return (pCode *)pci;
1793         }
1794
1795         fprintf(stderr, "pCode mnemonic error %s,%d\n",__FUNCTION__,__LINE__);
1796         exit(1);
1797
1798         return NULL;
1799 }
1800
1801 /*-----------------------------------------------------------------*/
1802 /* newpCodeWild - create a "wild" as in wild card pCode            */
1803 /*                                                                 */
1804 /* Wild pcodes are used during the peep hole optimizer to serve    */
1805 /* as place holders for any instruction. When a snippet of code is */
1806 /* compared to a peep hole rule, the wild card opcode will match   */
1807 /* any instruction. However, the optional operand and label are    */
1808 /* additional qualifiers that must also be matched before the      */
1809 /* line (of assembly code) is declared matched. Note that the      */
1810 /* operand may be wild too.                                        */
1811 /*                                                                 */
1812 /*   Note, a wild instruction is specified just like a wild var:   */
1813 /*      %4     ; A wild instruction,                               */
1814 /*  See the peeph.def file for additional examples                 */
1815 /*                                                                 */
1816 /*-----------------------------------------------------------------*/
1817
1818 pCode *newpCodeWild(int pCodeID, pCodeOp *optional_operand, pCodeOp *optional_label)
1819 {
1820
1821         pCodeWild *pcw;
1822
1823         pcw = Safe_calloc(1,sizeof(pCodeWild));
1824
1825         pcw->pci.pc.type = PC_WILD;
1826         pcw->pci.pc.prev = pcw->pci.pc.next = NULL;
1827         pcw->id = PCodeID();
1828         pcw->pci.from = pcw->pci.to = pcw->pci.label = NULL;
1829         pcw->pci.pc.pb = NULL;
1830
1831         //  pcw->pci.pc.analyze = genericAnalyze;
1832         pcw->pci.pc.destruct = genericDestruct;
1833         pcw->pci.pc.print = genericPrint;
1834
1835         pcw->id = pCodeID;              // this is the 'n' in %n
1836         pcw->operand = optional_operand;
1837         pcw->label   = optional_label;
1838
1839         pcw->mustBeBitSkipInst = 0;
1840         pcw->mustNotBeBitSkipInst = 0;
1841         pcw->invertBitSkipInst = 0;
1842
1843         return ( (pCode *)pcw);
1844
1845 }
1846
1847 /*-----------------------------------------------------------------*/
1848 /* newPcodeInlineP - create a new pCode from a char string           */
1849 /*-----------------------------------------------------------------*/
1850
1851
1852 pCode *newpCodeInlineP(char *cP)
1853 {
1854
1855         pCodeComment *pcc ;
1856
1857         pcc = Safe_calloc(1,sizeof(pCodeComment));
1858
1859         pcc->pc.type = PC_INLINE;
1860         pcc->pc.prev = pcc->pc.next = NULL;
1861         pcc->pc.id = PCodeID();
1862         //pcc->pc.from = pcc->pc.to = pcc->pc.label = NULL;
1863         pcc->pc.pb = NULL;
1864
1865         //  pcc->pc.analyze = genericAnalyze;
1866         pcc->pc.destruct = genericDestruct;
1867         pcc->pc.print = genericPrint;
1868
1869         if(cP)
1870                 pcc->comment = Safe_strdup(cP);
1871         else
1872                 pcc->comment = NULL;
1873
1874         return ( (pCode *)pcc);
1875
1876 }
1877
1878 /*-----------------------------------------------------------------*/
1879 /* newPcodeCharP - create a new pCode from a char string           */
1880 /*-----------------------------------------------------------------*/
1881
1882 pCode *newpCodeCharP(char *cP)
1883 {
1884
1885         pCodeComment *pcc ;
1886
1887         pcc = Safe_calloc(1,sizeof(pCodeComment));
1888
1889         pcc->pc.type = PC_COMMENT;
1890         pcc->pc.prev = pcc->pc.next = NULL;
1891         pcc->pc.id = PCodeID();
1892         //pcc->pc.from = pcc->pc.to = pcc->pc.label = NULL;
1893         pcc->pc.pb = NULL;
1894
1895         //  pcc->pc.analyze = genericAnalyze;
1896         pcc->pc.destruct = genericDestruct;
1897         pcc->pc.print = genericPrint;
1898
1899         if(cP)
1900                 pcc->comment = Safe_strdup(cP);
1901         else
1902                 pcc->comment = NULL;
1903
1904         return ( (pCode *)pcc);
1905
1906 }
1907
1908 /*-----------------------------------------------------------------*/
1909 /* newpCodeFunction -                                              */
1910 /*-----------------------------------------------------------------*/
1911
1912
1913 pCode *newpCodeFunction(char *mod,char *f,int isPublic)
1914 {
1915         pCodeFunction *pcf;
1916
1917         pcf = Safe_calloc(1,sizeof(pCodeFunction));
1918         //_ALLOC(pcf,sizeof(pCodeFunction));
1919
1920         pcf->pc.type = PC_FUNCTION;
1921         pcf->pc.prev = pcf->pc.next = NULL;
1922         pcf->pc.id = PCodeID();
1923         //pcf->pc.from = pcf->pc.to = pcf->pc.label = NULL;
1924         pcf->pc.pb = NULL;
1925
1926         //  pcf->pc.analyze = genericAnalyze;
1927         pcf->pc.destruct = genericDestruct;
1928         pcf->pc.print = pCodePrintFunction;
1929
1930         pcf->ncalled = 0;
1931
1932         if(mod) {
1933                 //_ALLOC_ATOMIC(pcf->modname,strlen(mod)+1);
1934                 pcf->modname = Safe_calloc(1,strlen(mod)+1);
1935                 strcpy(pcf->modname,mod);
1936         } else
1937                 pcf->modname = NULL;
1938
1939         if(f) {
1940                 //_ALLOC_ATOMIC(pcf->fname,strlen(f)+1);
1941                 pcf->fname = Safe_calloc(1,strlen(f)+1);
1942                 strcpy(pcf->fname,f);
1943         } else
1944                 pcf->fname = NULL;
1945
1946         pcf->isPublic = (unsigned)isPublic;
1947
1948         return ( (pCode *)pcf);
1949
1950 }
1951
1952 /*-----------------------------------------------------------------*/
1953 /* newpCodeFlow                                                    */
1954 /*-----------------------------------------------------------------*/
1955 void destructpCodeFlow(pCode *pc)
1956 {
1957         if(!pc || !isPCFL(pc))
1958                 return;
1959
1960                 /*
1961                 if(PCFL(pc)->from)
1962                 if(PCFL(pc)->to)
1963         */
1964         unlinkpCode(pc);
1965
1966         deleteSet(&PCFL(pc)->registers);
1967         deleteSet(&PCFL(pc)->from);
1968         deleteSet(&PCFL(pc)->to);
1969         free(pc);
1970
1971 }
1972
1973 pCode *newpCodeFlow(void )
1974 {
1975         pCodeFlow *pcflow;
1976
1977         //_ALLOC(pcflow,sizeof(pCodeFlow));
1978         pcflow = Safe_calloc(1,sizeof(pCodeFlow));
1979
1980         pcflow->pc.type = PC_FLOW;
1981         pcflow->pc.prev = pcflow->pc.next = NULL;
1982         pcflow->pc.pb = NULL;
1983
1984         //  pcflow->pc.analyze = genericAnalyze;
1985         pcflow->pc.destruct = destructpCodeFlow;
1986         pcflow->pc.print = genericPrint;
1987
1988         pcflow->pc.seq = GpcFlowSeq++;
1989
1990         pcflow->from = pcflow->to = NULL;
1991
1992         pcflow->inCond = PCC_NONE;
1993         pcflow->outCond = PCC_NONE;
1994
1995         pcflow->firstBank = 'U'; /* Undetermined */
1996         pcflow->lastBank = 'U'; /* Undetermined */
1997
1998         pcflow->FromConflicts = 0;
1999         pcflow->ToConflicts = 0;
2000
2001         pcflow->end = NULL;
2002
2003         pcflow->registers = newSet();
2004
2005         return ( (pCode *)pcflow);
2006
2007 }
2008
2009 /*-----------------------------------------------------------------*/
2010 /*-----------------------------------------------------------------*/
2011 pCodeFlowLink *newpCodeFlowLink(pCodeFlow *pcflow)
2012 {
2013         pCodeFlowLink *pcflowLink;
2014
2015         pcflowLink = Safe_calloc(1,sizeof(pCodeFlowLink));
2016
2017         pcflowLink->pcflow = pcflow;
2018         pcflowLink->bank_conflict = 0;
2019
2020         return pcflowLink;
2021 }
2022
2023 /*-----------------------------------------------------------------*/
2024 /* newpCodeCSource - create a new pCode Source Symbol              */
2025 /*-----------------------------------------------------------------*/
2026
2027 pCode *newpCodeCSource(int ln, char *f, const char *l)
2028 {
2029
2030         pCodeCSource *pccs;
2031
2032         pccs = Safe_calloc(1,sizeof(pCodeCSource));
2033
2034         pccs->pc.type = PC_CSOURCE;
2035         pccs->pc.prev = pccs->pc.next = NULL;
2036         pccs->pc.id = PCodeID();
2037         pccs->pc.pb = NULL;
2038
2039         pccs->pc.destruct = genericDestruct;
2040         pccs->pc.print = genericPrint;
2041
2042         pccs->line_number = ln;
2043         if(l)
2044                 pccs->line = Safe_strdup(l);
2045         else
2046                 pccs->line = NULL;
2047
2048         if(f)
2049                 pccs->file_name = Safe_strdup(f);
2050         else
2051                 pccs->file_name = NULL;
2052
2053         return ( (pCode *)pccs);
2054
2055 }
2056
2057 /*******************************************************************/
2058 /* pic16_newpCodeAsmDir - create a new pCode Assembler Directive   */
2059 /*                        added by VR 6-Jun-2003                   */
2060 /*******************************************************************/
2061
2062 pCode *newpCodeAsmDir(char *asdir, char *argfmt, ...)
2063 {
2064   pCodeAsmDir *pcad;
2065   va_list ap;
2066   char buffer[512];
2067   char *lbp=buffer;
2068
2069   pcad = Safe_calloc(1, sizeof(pCodeAsmDir));
2070   pcad->pci.pc.type = PC_ASMDIR;
2071   pcad->pci.pc.prev = pcad->pci.pc.next = NULL;
2072   pcad->pci.pc.pb = NULL;
2073   pcad->pci.pc.destruct = genericDestruct;
2074   pcad->pci.pc.print = genericPrint;
2075
2076   if(asdir && *asdir) {
2077
2078     while(isspace((unsigned char)*asdir))asdir++;       // strip any white space from the beginning
2079
2080     pcad->directive = Safe_strdup( asdir );
2081   }
2082
2083   va_start(ap, argfmt);
2084
2085   memset(buffer, 0, sizeof(buffer));
2086   if(argfmt && *argfmt)
2087     vsprintf(buffer, argfmt, ap);
2088
2089   va_end(ap);
2090
2091   while(isspace((unsigned char)*lbp))lbp++;
2092
2093   if(lbp && *lbp)
2094     pcad->arg = Safe_strdup( lbp );
2095
2096   return ((pCode *)pcad);
2097 }
2098
2099 /*-----------------------------------------------------------------*/
2100 /* pCodeLabelDestruct - free memory used by a label.               */
2101 /*-----------------------------------------------------------------*/
2102 static void pCodeLabelDestruct(pCode *pc)
2103 {
2104
2105         if(!pc)
2106                 return;
2107
2108         if((pc->type == PC_LABEL) && PCL(pc)->label)
2109                 free(PCL(pc)->label);
2110
2111         free(pc);
2112
2113 }
2114
2115 pCode *newpCodeLabel(char *name, int key)
2116 {
2117
2118         char *s = buffer;
2119         pCodeLabel *pcl;
2120
2121         pcl = Safe_calloc(1,sizeof(pCodeLabel) );
2122
2123         pcl->pc.type = PC_LABEL;
2124         pcl->pc.prev = pcl->pc.next = NULL;
2125         pcl->pc.id = PCodeID();
2126         //pcl->pc.from = pcl->pc.to = pcl->pc.label = NULL;
2127         pcl->pc.pb = NULL;
2128
2129         //  pcl->pc.analyze = genericAnalyze;
2130         pcl->pc.destruct = pCodeLabelDestruct;
2131         pcl->pc.print = pCodePrintLabel;
2132
2133         pcl->key = key;
2134
2135         pcl->label = NULL;
2136         if(key>0) {
2137                 sprintf(s,"_%05d_DS_",key);
2138         } else
2139                 s = name;
2140
2141         if(s)
2142                 pcl->label = Safe_strdup(s);
2143
2144         //fprintf(stderr,"newpCodeLabel: key=%d, name=%s\n",key, ((s)?s:""));
2145         return ( (pCode *)pcl);
2146
2147 }
2148
2149
2150 /*-----------------------------------------------------------------*/
2151 /* newpBlock - create and return a pointer to a new pBlock         */
2152 /*-----------------------------------------------------------------*/
2153 pBlock *newpBlock(void)
2154 {
2155
2156         pBlock *PpB;
2157
2158         PpB = Safe_calloc(1,sizeof(pBlock) );
2159         PpB->next = PpB->prev = NULL;
2160
2161         PpB->function_entries = PpB->function_exits = PpB->function_calls = NULL;
2162         PpB->tregisters = NULL;
2163         PpB->visited = 0;
2164         PpB->FlowTree = NULL;
2165
2166         return PpB;
2167
2168 }
2169
2170 /*-----------------------------------------------------------------*/
2171 /* newpCodeChain - create a new chain of pCodes                    */
2172 /*-----------------------------------------------------------------*
2173 *
2174 *  This function will create a new pBlock and the pointer to the
2175 *  pCode that is passed in will be the first pCode in the block.
2176 *-----------------------------------------------------------------*/
2177
2178
2179 pBlock *newpCodeChain(memmap *cm,char c, pCode *pc)
2180 {
2181
2182         pBlock *pB  = newpBlock();
2183
2184         pB->pcHead  = pB->pcTail = pc;
2185         pB->cmemmap = cm;
2186         pB->dbName  = c;
2187
2188         return pB;
2189 }
2190
2191 /*-----------------------------------------------------------------*/
2192 /* newpCodeOpLabel - Create a new label given the key              */
2193 /*  Note, a negative key means that the label is part of wild card */
2194 /*  (and hence a wild card label) used in the pCodePeep            */
2195 /*   optimizations).                                               */
2196 /*-----------------------------------------------------------------*/
2197
2198 pCodeOp *newpCodeOpLabel(char *name, int key)
2199 {
2200         char *s=NULL;
2201         static int label_key=-1;
2202
2203         pCodeOp *pcop;
2204
2205         pcop = Safe_calloc(1,sizeof(pCodeOpLabel) );
2206         pcop->type = PO_LABEL;
2207
2208         pcop->name = NULL;
2209
2210         if(key>0)
2211                 sprintf(s=buffer,"_%05d_DS_",key);
2212         else
2213                 s = name, key = label_key--;
2214
2215         PCOLAB(pcop)->offset = 0;
2216         if(s)
2217                 pcop->name = Safe_strdup(s);
2218
2219         ((pCodeOpLabel *)pcop)->key = key;
2220
2221         //fprintf(stderr,"newpCodeOpLabel: key=%d, name=%s\n",key,((s)?s:""));
2222         return pcop;
2223 }
2224
2225 /*-----------------------------------------------------------------*/
2226 /*-----------------------------------------------------------------*/
2227 pCodeOp *newpCodeOpLit(int lit)
2228 {
2229         char *s = buffer;
2230         pCodeOp *pcop;
2231
2232
2233         pcop = Safe_calloc(1,sizeof(pCodeOpLit) );
2234         pcop->type = PO_LITERAL;
2235
2236         pcop->name = NULL;
2237         if(lit>=0) {
2238                 sprintf(s,"0x%02x", (unsigned char)lit);
2239                 if(s)
2240                         pcop->name = Safe_strdup(s);
2241         }
2242
2243         ((pCodeOpLit *)pcop)->lit = (unsigned char)lit;
2244
2245         return pcop;
2246 }
2247
2248 /*-----------------------------------------------------------------*/
2249 /*-----------------------------------------------------------------*/
2250 pCodeOp *newpCodeOpImmd(char *name, int offset, int index, int code_space, int is_func)
2251 {
2252         pCodeOp *pcop;
2253
2254         pcop = Safe_calloc(1,sizeof(pCodeOpImmd) );
2255         pcop->type = PO_IMMEDIATE;
2256         if(name) {
2257                 regs *r = NULL;
2258                 pcop->name = Safe_strdup(name);
2259
2260                 if(!is_func)
2261                         r = dirregWithName(name);
2262
2263                 PCOI(pcop)->r = r;
2264                 if(r) {
2265                         //fprintf(stderr, " newpCodeOpImmd reg %s exists\n",name);
2266                         PCOI(pcop)->rIdx = r->rIdx;
2267                 } else {
2268                         //fprintf(stderr, " newpCodeOpImmd reg %s doesn't exist\n",name);
2269                         PCOI(pcop)->rIdx = -1;
2270                 }
2271                 //fprintf(stderr,"%s %s %d\n",__FUNCTION__,name,offset);
2272         } else {
2273                 pcop->name = NULL;
2274         }
2275
2276         PCOI(pcop)->index = index;
2277         PCOI(pcop)->offset = offset;
2278         PCOI(pcop)->_const = code_space;
2279         PCOI(pcop)->_function = is_func;
2280
2281         return pcop;
2282 }
2283
2284 /*-----------------------------------------------------------------*/
2285 /*-----------------------------------------------------------------*/
2286 pCodeOp *newpCodeOpWild(int id, pCodeWildBlock *pcwb, pCodeOp *subtype)
2287 {
2288         char *s = buffer;
2289         pCodeOp *pcop;
2290
2291
2292         if(!pcwb || !subtype) {
2293                 fprintf(stderr, "Wild opcode declaration error: %s-%d\n",__FILE__,__LINE__);
2294                 exit(1);
2295         }
2296
2297         pcop = Safe_calloc(1,sizeof(pCodeOpWild));
2298         pcop->type = PO_WILD;
2299         sprintf(s,"%%%d",id);
2300         pcop->name = Safe_strdup(s);
2301
2302         PCOW(pcop)->id = id;
2303         PCOW(pcop)->pcwb = pcwb;
2304         PCOW(pcop)->subtype = subtype;
2305         PCOW(pcop)->matched = NULL;
2306
2307         return pcop;
2308 }
2309 /*-----------------------------------------------------------------*/
2310 /* Find a symbol with matching name                                */
2311 /*-----------------------------------------------------------------*/
2312 static symbol *symFindWithName(memmap * map, const char *name)
2313 {
2314         symbol *sym;
2315
2316         for (sym = setFirstItem(map->syms); sym; sym = setNextItem (map->syms)) {
2317                 if (sym->rname && (strcmp(sym->rname,name)==0))
2318                         return sym;
2319         }
2320         return 0;
2321 }
2322
2323 /*-----------------------------------------------------------------*/
2324 /*-----------------------------------------------------------------*/
2325 pCodeOp *newpCodeOpBit(char *name, int ibit, int inBitSpace)
2326 {
2327         pCodeOp *pcop;
2328         struct regs *r = 0;
2329
2330         pcop = Safe_calloc(1,sizeof(pCodeOpRegBit) );
2331         pcop->type = PO_GPR_BIT;
2332
2333         PCORB(pcop)->bit = ibit;
2334         PCORB(pcop)->inBitSpace = inBitSpace;
2335
2336         if (name) r = regFindWithName(name);
2337         if (!r) {
2338                 // Register has not been allocated - check for symbol information
2339                 symbol *sym;
2340                 sym = symFindWithName(bit, name);
2341                 if (!sym) sym = symFindWithName(sfrbit, name);
2342                 if (!sym) sym = symFindWithName(sfr, name);
2343                 if (!sym) sym = symFindWithName(reg, name);
2344                 // Hack to fix accesses to _INTCON_bits (e.g. GIE=0), see #1579535.
2345                 // XXX: This ignores nesting levels, but works for globals...
2346                 if (!sym) sym = findSym(SymbolTab, NULL, name);
2347                 if (!sym && name && name[0] == '_') sym = findSym(SymbolTab, NULL, &name[1]);
2348                 if (sym) {
2349                         r = allocNewDirReg(sym->etype,name);
2350                 }
2351         }
2352         if (r) {
2353                 pcop->name = NULL;
2354                 PCOR(pcop)->r = r;
2355                 PCOR(pcop)->rIdx = r->rIdx;
2356         } else {
2357                 pcop->name = Safe_strdup(name);
2358                 PCOR(pcop)->r = NULL;
2359                 PCOR(pcop)->rIdx = 0;
2360         }
2361         return pcop;
2362 }
2363
2364 #if 0
2365 pCodeOp *newpCodeOpBitReg(regs *reg, int ibit, int inBitSpace)
2366 {
2367     pCodeOp *pcop;
2368
2369     assert(reg);
2370
2371     pcop = Safe_calloc(1,sizeof(pCodeOpRegBit));
2372     pcop->name = reg->name;
2373     pcop->type = PO_GPR_BIT;
2374     PCORB(pcop)->bit = ibit;
2375     PCORB(pcop)->inBitSpace = inBitSpace;
2376     PCOR(pcop)->r = reg;
2377     PCOR(pcop)->index = 0;
2378     PCOR(pcop)->rIdx = reg->rIdx;
2379     return pcop;
2380 }
2381 #endif
2382
2383 /*-----------------------------------------------------------------*
2384 * pCodeOp *newpCodeOpReg(int rIdx) - allocate a new register
2385 *
2386 * If rIdx >=0 then a specific register from the set of registers
2387 * will be selected. If rIdx <0, then a new register will be searched
2388 * for.
2389 *-----------------------------------------------------------------*/
2390
2391 pCodeOp *newpCodeOpReg(int rIdx)
2392 {
2393         pCodeOp *pcop;
2394
2395         pcop = Safe_calloc(1,sizeof(pCodeOpReg) );
2396
2397         pcop->name = NULL;
2398
2399         if(rIdx >= 0) {
2400                 PCOR(pcop)->rIdx = rIdx;
2401                 PCOR(pcop)->r = pic14_regWithIdx(rIdx);
2402         } else {
2403                 PCOR(pcop)->r = pic14_findFreeReg(REG_GPR);
2404
2405                 if(PCOR(pcop)->r)
2406                         PCOR(pcop)->rIdx = PCOR(pcop)->r->rIdx;
2407         }
2408
2409         if(PCOR(pcop)->r)
2410                 pcop->type = PCOR(pcop)->r->pc_type;
2411
2412         return pcop;
2413 }
2414
2415 pCodeOp *newpCodeOpRegFromStr(char *name)
2416 {
2417         pCodeOp *pcop;
2418
2419         pcop = Safe_calloc(1,sizeof(pCodeOpReg) );
2420         PCOR(pcop)->r = allocRegByName(name, 1);
2421         PCOR(pcop)->rIdx = PCOR(pcop)->r->rIdx;
2422         pcop->type = PCOR(pcop)->r->pc_type;
2423         pcop->name = PCOR(pcop)->r->name;
2424
2425         return pcop;
2426 }
2427
2428 pCodeOp *newpCodeOpStr(char *name)
2429 {
2430         pCodeOp *pcop;
2431
2432         pcop = Safe_calloc(1,sizeof(pCodeOpStr));
2433         pcop->type = PO_STR;
2434         pcop->name = Safe_strdup(name);
2435
2436         PCOS(pcop)->isPublic = 0;
2437
2438         return pcop;
2439 }
2440
2441
2442 /*-----------------------------------------------------------------*/
2443 /*-----------------------------------------------------------------*/
2444
2445 pCodeOp *newpCodeOp(char *name, PIC_OPTYPE type)
2446 {
2447         pCodeOp *pcop;
2448
2449         switch(type) {
2450         case PO_BIT:
2451         case PO_GPR_BIT:
2452                 pcop = newpCodeOpBit(name, -1,0);
2453                 break;
2454
2455         case PO_LITERAL:
2456                 pcop = newpCodeOpLit(-1);
2457                 break;
2458
2459         case PO_LABEL:
2460                 pcop = newpCodeOpLabel(NULL,-1);
2461                 break;
2462
2463         case PO_GPR_TEMP:
2464                 pcop = newpCodeOpReg(-1);
2465                 break;
2466
2467         case PO_GPR_POINTER:
2468         case PO_GPR_REGISTER:
2469                 if(name)
2470                         pcop = newpCodeOpRegFromStr(name);
2471                 else
2472                         pcop = newpCodeOpReg(-1);
2473                 break;
2474
2475         case PO_STR:
2476                 pcop = newpCodeOpStr(name);
2477                 break;
2478
2479         default:
2480                 pcop = Safe_calloc(1,sizeof(pCodeOp) );
2481                 pcop->type = type;
2482                 if(name)
2483                         pcop->name = Safe_strdup(name);
2484                 else
2485                         pcop->name = NULL;
2486         }
2487
2488         return pcop;
2489 }
2490
2491 /*-----------------------------------------------------------------*/
2492 /*-----------------------------------------------------------------*/
2493 void pCodeConstString(char *name, char *value)
2494 {
2495         pBlock *pb;
2496         unsigned i;
2497
2498         //  fprintf(stderr, " %s  %s  %s\n",__FUNCTION__,name,value);
2499
2500         if(!name || !value)
2501                 return;
2502
2503         pb = newpCodeChain(NULL, 'P',newpCodeCharP("; Starting pCode block"));
2504
2505         addpBlock(pb);
2506
2507         sprintf(buffer,"; %s = %s",name,value);
2508         for (i=strlen(buffer); i--; ) {
2509                 unsigned char c = buffer[i];
2510                 if (c=='\r' || c=='\n') {
2511                         memmove(buffer+i+1,buffer+i,strlen(buffer)-i+1);
2512                         buffer[i] = '\\';
2513                         if (c=='\r') buffer[i+1] = 'r';
2514                         else if (c=='\n') buffer[i+1] = 'n';
2515                 }
2516         }
2517
2518         addpCode2pBlock(pb,newpCodeCharP(buffer));
2519         addpCode2pBlock(pb,newpCodeLabel(name,-1));
2520
2521         do {
2522                 addpCode2pBlock(pb,newpCode(POC_RETLW,newpCodeOpLit(*value)));
2523         }while (*value++);
2524
2525
2526 }
2527
2528 /*-----------------------------------------------------------------*/
2529 /*-----------------------------------------------------------------*/
2530 void pCodeReadCodeTable(void)
2531 {
2532         pBlock *pb;
2533
2534         fprintf(stderr, " %s\n",__FUNCTION__);
2535
2536         pb = newpCodeChain(NULL, 'P',newpCodeCharP("; Starting pCode block"));
2537
2538         addpBlock(pb);
2539
2540         addpCode2pBlock(pb,newpCodeCharP("; ReadCodeTable - built in function"));
2541         addpCode2pBlock(pb,newpCodeCharP("; Inputs: temp1,temp2 = code pointer"));
2542         addpCode2pBlock(pb,newpCodeCharP("; Outpus: W (from RETLW at temp2:temp1)"));
2543         addpCode2pBlock(pb,newpCodeLabel("ReadCodeTable:",-1));
2544
2545         addpCode2pBlock(pb,newpCode(POC_MOVFW,newpCodeOpRegFromStr("temp2")));
2546         addpCode2pBlock(pb,newpCode(POC_MOVWF,newpCodeOpRegFromStr("PCLATH")));
2547         addpCode2pBlock(pb,newpCode(POC_MOVFW,newpCodeOpRegFromStr("temp1")));
2548         addpCode2pBlock(pb,newpCode(POC_MOVWF,newpCodeOpRegFromStr("PCL")));
2549
2550
2551 }
2552
2553 /*-----------------------------------------------------------------*/
2554 /* addpCode2pBlock - place the pCode into the pBlock linked list   */
2555 /*-----------------------------------------------------------------*/
2556 void addpCode2pBlock(pBlock *pb, pCode *pc)
2557 {
2558
2559         if(!pc)
2560                 return;
2561
2562         if(!pb->pcHead) {
2563         /* If this is the first pcode to be added to a block that
2564         * was initialized with a NULL pcode, then go ahead and
2565                 * make this pcode the head and tail */
2566                 pb->pcHead  = pb->pcTail = pc;
2567         } else {
2568                 //    if(pb->pcTail)
2569                 pb->pcTail->next = pc;
2570
2571                 pc->prev = pb->pcTail;
2572                 pc->pb = pb;
2573
2574                 pb->pcTail = pc;
2575         }
2576 }
2577
2578 /*-----------------------------------------------------------------*/
2579 /* addpBlock - place a pBlock into the pFile                       */
2580 /*-----------------------------------------------------------------*/
2581 void addpBlock(pBlock *pb)
2582 {
2583         // fprintf(stderr," Adding pBlock: dbName =%c\n",getpBlock_dbName(pb));
2584
2585         if(!the_pFile) {
2586                 /* First time called, we'll pass through here. */
2587                 //_ALLOC(the_pFile,sizeof(pFile));
2588                 the_pFile = Safe_calloc(1,sizeof(pFile));
2589                 the_pFile->pbHead = the_pFile->pbTail = pb;
2590                 the_pFile->functions = NULL;
2591                 return;
2592         }
2593
2594         the_pFile->pbTail->next = pb;
2595         pb->prev = the_pFile->pbTail;
2596         pb->next = NULL;
2597         the_pFile->pbTail = pb;
2598 }
2599
2600 /*-----------------------------------------------------------------*/
2601 /* removepBlock - remove a pBlock from the pFile                   */
2602 /*-----------------------------------------------------------------*/
2603 void removepBlock(pBlock *pb)
2604 {
2605         pBlock *pbs;
2606
2607         if(!the_pFile)
2608                 return;
2609
2610
2611         //fprintf(stderr," Removing pBlock: dbName =%c\n",getpBlock_dbName(pb));
2612
2613         for(pbs = the_pFile->pbHead; pbs; pbs = pbs->next) {
2614                 if(pbs == pb) {
2615
2616                         if(pbs == the_pFile->pbHead)
2617                                 the_pFile->pbHead = pbs->next;
2618
2619                         if (pbs == the_pFile->pbTail)
2620                                 the_pFile->pbTail = pbs->prev;
2621
2622                         if(pbs->next)
2623                                 pbs->next->prev = pbs->prev;
2624
2625                         if(pbs->prev)
2626                                 pbs->prev->next = pbs->next;
2627
2628                         return;
2629
2630                 }
2631         }
2632
2633         fprintf(stderr, "Warning: call to %s:%s didn't find pBlock\n",__FILE__,__FUNCTION__);
2634
2635 }
2636
2637 /*-----------------------------------------------------------------*/
2638 /* printpCode - write the contents of a pCode to a file            */
2639 /*-----------------------------------------------------------------*/
2640 void printpCode(FILE *of, pCode *pc)
2641 {
2642
2643         if(!pc || !of)
2644                 return;
2645
2646         if(pc->print) {
2647                 pc->print(of,pc);
2648                 return;
2649         }
2650
2651         fprintf(of,"warning - unable to print pCode\n");
2652 }
2653
2654 /*-----------------------------------------------------------------*/
2655 /* printpBlock - write the contents of a pBlock to a file          */
2656 /*-----------------------------------------------------------------*/
2657 void printpBlock(FILE *of, pBlock *pb)
2658 {
2659         pCode *pc;
2660
2661         if(!pb)
2662                 return;
2663
2664         if(!of)
2665                 of = stderr;
2666
2667         for(pc = pb->pcHead; pc; pc = pc->next) {
2668                 printpCode(of,pc);
2669
2670                 if (isPCI(pc))
2671                 {
2672                         if (isPCI(pc) && (PCI(pc)->op == POC_PAGESEL || PCI(pc)->op == POC_BANKSEL)) {
2673                                 pcode_doubles++;
2674                         } else {
2675                                 pcode_insns++;
2676                         }
2677                 }
2678         } // for
2679
2680 }
2681
2682 /*-----------------------------------------------------------------*/
2683 /*                                                                 */
2684 /*       pCode processing                                          */
2685 /*                                                                 */
2686 /*                                                                 */
2687 /*                                                                 */
2688 /*-----------------------------------------------------------------*/
2689
2690 void unlinkpCode(pCode *pc)
2691 {
2692
2693
2694         if(pc) {
2695 #ifdef PCODE_DEBUG
2696                 fprintf(stderr,"Unlinking: ");
2697                 printpCode(stderr, pc);
2698 #endif
2699                 if(pc->prev)
2700                         pc->prev->next = pc->next;
2701                 if(pc->next)
2702                         pc->next->prev = pc->prev;
2703
2704 #if 0
2705                 /* RN: I believe this should be right here, but this did not
2706                  *     cure the bug I was hunting... */
2707                 /* must keep labels -- attach to following instruction */
2708                 if (isPCI(pc) && PCI(pc)->label && pc->next)
2709                 {
2710                   pCodeInstruction *pcnext = PCI(findNextInstruction (pc->next));
2711                   if (pcnext)
2712                   {
2713                     pBranchAppend (pcnext->label, PCI(pc)->label);
2714                   }
2715                 }
2716 #endif
2717                 pc->prev = pc->next = NULL;
2718         }
2719 }
2720
2721 /*-----------------------------------------------------------------*/
2722 /*-----------------------------------------------------------------*/
2723
2724 static void genericDestruct(pCode *pc)
2725 {
2726
2727         unlinkpCode(pc);
2728
2729         if(isPCI(pc)) {
2730         /* For instructions, tell the register (if there's one used)
2731                 * that it's no longer needed */
2732                 regs *reg = getRegFromInstruction(pc);
2733                 if(reg)
2734                         deleteSetItem (&(reg->reglives.usedpCodes),pc);
2735         }
2736
2737         /* Instead of deleting the memory used by this pCode, mark
2738         * the object as bad so that if there's a pointer to this pCode
2739         * dangling around somewhere then (hopefully) when the type is
2740         * checked we'll catch it.
2741         */
2742
2743         pc->type = PC_BAD;
2744
2745         addpCode2pBlock(pb_dead_pcodes, pc);
2746
2747         //free(pc);
2748
2749 }
2750
2751
2752 /*-----------------------------------------------------------------*/
2753 /*  Copies the pCodeInstruction flow pointer from source pCode     */
2754 /*-----------------------------------------------------------------*/
2755 static void CopyFlow(pCodeInstruction *pcd, pCode *pcs) {
2756         pCode *p;
2757         pCodeFlow *pcflow = 0;
2758         for (p=pcs; p; p=p->prev) {
2759                 if (isPCI(p)) {
2760                         pcflow = PCI(p)->pcflow;
2761                         break;
2762                 }
2763                 if (isPCF(p)) {
2764                         pcflow = (pCodeFlow*)p;
2765                         break;
2766                 }
2767         }
2768         PCI(pcd)->pcflow = pcflow;
2769 }
2770
2771 /*-----------------------------------------------------------------*/
2772 /*  pCodeInsertAfter - splice in the pCode chain starting with pc2 */
2773 /*                     into the pCode chain containing pc1         */
2774 /*-----------------------------------------------------------------*/
2775 void pCodeInsertAfter(pCode *pc1, pCode *pc2)
2776 {
2777
2778         if(!pc1 || !pc2)
2779                 return;
2780
2781         pc2->next = pc1->next;
2782         if(pc1->next)
2783                 pc1->next->prev = pc2;
2784
2785         pc2->pb = pc1->pb;
2786         pc2->prev = pc1;
2787         pc1->next = pc2;
2788
2789         /* If this is an instrution type propogate the flow */
2790         if (isPCI(pc2))
2791                 CopyFlow(PCI(pc2),pc1);
2792 }
2793
2794 /*------------------------------------------------------------------*/
2795 /*  pCodeInsertBefore - splice in the pCode chain starting with pc2 */
2796 /*                      into the pCode chain containing pc1         */
2797 /*------------------------------------------------------------------*/
2798 void pCodeInsertBefore(pCode *pc1, pCode *pc2)
2799 {
2800
2801         if(!pc1 || !pc2)
2802                 return;
2803
2804         pc2->prev = pc1->prev;
2805         if(pc1->prev)
2806                 pc1->prev->next = pc2;
2807
2808         pc2->pb = pc1->pb;
2809         pc2->next = pc1;
2810         pc1->prev = pc2;
2811
2812         /* If this is an instrution type propogate the flow */
2813         if (isPCI(pc2))
2814                 CopyFlow(PCI(pc2),pc1);
2815 }
2816
2817 /*-----------------------------------------------------------------*/
2818 /* pCodeOpCopy - copy a pcode operator                             */
2819 /*-----------------------------------------------------------------*/
2820 pCodeOp *pCodeOpCopy(pCodeOp *pcop)
2821 {
2822         pCodeOp *pcopnew=NULL;
2823
2824         if(!pcop)
2825                 return NULL;
2826
2827         switch(pcop->type) {
2828         case PO_NONE:
2829         case PO_STR:
2830                 pcopnew = Safe_calloc (1, sizeof (pCodeOp));
2831                 memcpy (pcopnew, pcop, sizeof (pCodeOp));
2832                 break;
2833
2834         case PO_W:
2835         case PO_STATUS:
2836         case PO_FSR:
2837         case PO_INDF:
2838         case PO_INTCON:
2839         case PO_GPR_REGISTER:
2840         case PO_GPR_TEMP:
2841         case PO_GPR_POINTER:
2842         case PO_SFR_REGISTER:
2843         case PO_PCL:
2844         case PO_PCLATH:
2845         case PO_DIR:
2846                 //DFPRINTF((stderr,"pCodeOpCopy GPR register\n"));
2847                 pcopnew = Safe_calloc(1,sizeof(pCodeOpReg) );
2848                 memcpy (pcopnew, pcop, sizeof (pCodeOpReg));
2849                 DFPRINTF((stderr," register index %d\n", PCOR(pcop)->r->rIdx));
2850                 break;
2851
2852         case PO_LITERAL:
2853                 //DFPRINTF((stderr,"pCodeOpCopy lit\n"));
2854                 pcopnew = Safe_calloc(1,sizeof(pCodeOpLit) );
2855                 memcpy (pcopnew, pcop, sizeof (pCodeOpLit));
2856                 break;
2857
2858         case PO_IMMEDIATE:
2859                 pcopnew = Safe_calloc(1,sizeof(pCodeOpImmd) );
2860                 memcpy (pcopnew, pcop, sizeof (pCodeOpImmd));
2861                 break;
2862
2863         case PO_GPR_BIT:
2864         case PO_CRY:
2865         case PO_BIT:
2866                 //DFPRINTF((stderr,"pCodeOpCopy bit\n"));
2867                 pcopnew = Safe_calloc(1,sizeof(pCodeOpRegBit) );
2868                 memcpy (pcopnew, pcop, sizeof (pCodeOpRegBit));
2869                 break;
2870
2871         case PO_LABEL:
2872                 //DFPRINTF((stderr,"pCodeOpCopy label\n"));
2873                 pcopnew = Safe_calloc(1,sizeof(pCodeOpLabel) );
2874                 memcpy (pcopnew, pcop, sizeof(pCodeOpLabel));
2875                 break;
2876
2877         case PO_WILD:
2878                 /* Here we expand the wild card into the appropriate type: */
2879                 /* By recursively calling pCodeOpCopy */
2880                 //DFPRINTF((stderr,"pCodeOpCopy wild\n"));
2881                 if(PCOW(pcop)->matched)
2882                         pcopnew = pCodeOpCopy(PCOW(pcop)->matched);
2883                 else {
2884                         // Probably a label
2885                         pcopnew = pCodeOpCopy(PCOW(pcop)->subtype);
2886                         pcopnew->name = Safe_strdup(PCOW(pcop)->pcwb->vars[PCOW(pcop)->id]);
2887                         //DFPRINTF((stderr,"copied a wild op named %s\n",pcopnew->name));
2888                 }
2889
2890                 return pcopnew;
2891                 break;
2892
2893         default:
2894                 assert ( !"unhandled pCodeOp type copied" );
2895                 break;
2896         } // switch
2897
2898         if(pcop->name)
2899                 pcopnew->name = Safe_strdup(pcop->name);
2900         else
2901                 pcopnew->name = NULL;
2902
2903         return pcopnew;
2904 }
2905
2906 /*-----------------------------------------------------------------*/
2907 /* popCopyReg - copy a pcode operator                              */
2908 /*-----------------------------------------------------------------*/
2909 pCodeOp *popCopyReg(pCodeOpReg *pc)
2910 {
2911         pCodeOpReg *pcor;
2912
2913         pcor = Safe_calloc(1,sizeof(pCodeOpReg) );
2914         pcor->pcop.type = pc->pcop.type;
2915         if(pc->pcop.name) {
2916                 if(!(pcor->pcop.name = Safe_strdup(pc->pcop.name)))
2917                         fprintf(stderr,"oops %s %d",__FILE__,__LINE__);
2918         } else
2919                 pcor->pcop.name = NULL;
2920
2921         if (pcor->pcop.type == PO_IMMEDIATE){
2922                 PCOL(pcor)->lit = PCOL(pc)->lit;
2923         } else {
2924                 pcor->r = pc->r;
2925                 pcor->rIdx = pc->rIdx;
2926                 if (pcor->r)
2927                         pcor->r->wasUsed=1;
2928         }
2929         //DEBUGpic14_emitcode ("; ***","%s  , copying %s, rIdx=%d",__FUNCTION__,pc->pcop.name,pc->rIdx);
2930
2931         return PCOP(pcor);
2932 }
2933
2934 /*-----------------------------------------------------------------*/
2935 /* pCodeInstructionCopy - copy a pCodeInstructionCopy              */
2936 /*-----------------------------------------------------------------*/
2937 pCode *pCodeInstructionCopy(pCodeInstruction *pci,int invert)
2938 {
2939         pCodeInstruction *new_pci;
2940
2941         if(invert)
2942                 new_pci = PCI(newpCode(pci->inverted_op,pci->pcop));
2943         else
2944                 new_pci = PCI(newpCode(pci->op,pci->pcop));
2945
2946         new_pci->pc.pb = pci->pc.pb;
2947         new_pci->from = pci->from;
2948         new_pci->to   = pci->to;
2949         new_pci->label = pci->label;
2950         new_pci->pcflow = pci->pcflow;
2951
2952         return PCODE(new_pci);
2953 }
2954
2955 /*-----------------------------------------------------------------*/
2956 /*-----------------------------------------------------------------*/
2957 void pCodeDeleteChain(pCode *f,pCode *t)
2958 {
2959         pCode *pc;
2960
2961         while(f && f!=t) {
2962                 DFPRINTF((stderr,"delete pCode:\n"));
2963                 pc = f->next;
2964                 //f->print(stderr,f);
2965                 //f->delete(f);  this dumps core...
2966                 f = pc;
2967         }
2968 }
2969
2970 /*-----------------------------------------------------------------*/
2971 /*-----------------------------------------------------------------*/
2972 void pBlockRegs(FILE *of, pBlock *pb)
2973 {
2974
2975         regs  *r;
2976
2977         r = setFirstItem(pb->tregisters);
2978         while (r) {
2979                 r = setNextItem(pb->tregisters);
2980         }
2981 }
2982
2983
2984 /*-----------------------------------------------------------------*/
2985 /*-----------------------------------------------------------------*/
2986 char *get_op(pCodeOp *pcop,char *buffer, size_t size)
2987 {
2988         regs *r;
2989         static char b[50];
2990         char *s;
2991         int use_buffer = 1;    // copy the string to the passed buffer pointer
2992
2993         if(!buffer) {
2994                 buffer = b;
2995                 size = sizeof(b);
2996                 use_buffer = 0;     // Don't bother copying the string to the buffer.
2997         }
2998
2999         if(pcop) {
3000                 switch(pcop->type) {
3001                 case PO_INDF:
3002                 case PO_FSR:
3003                         if(use_buffer) {
3004                                 SAFE_snprintf(&buffer,&size,"%s",PCOR(pcop)->r->name);
3005                                 return buffer;
3006                         }
3007                         //return PCOR(pcop)->r->name;
3008                         return pcop->name;
3009                         break;
3010                 case PO_GPR_TEMP:
3011                         if (PCOR(pcop)->r->type == REG_STK)
3012                                 r = typeRegWithIdx(PCOR(pcop)->r->rIdx,REG_STK,1);
3013                         else
3014                                 r = pic14_regWithIdx(PCOR(pcop)->r->rIdx);
3015
3016                         if(use_buffer) {
3017                                 SAFE_snprintf(&buffer,&size,"%s",r->name);
3018                                 return buffer;
3019                         }
3020
3021                         return r->name;
3022
3023
3024                 case PO_IMMEDIATE:
3025                         s = buffer;
3026                         if(PCOI(pcop)->_const) {
3027
3028                                 if( PCOI(pcop)->offset >= 0 && PCOI(pcop)->offset<4) {
3029                                         switch(PCOI(pcop)->offset) {
3030                                         case 0:
3031                                                 SAFE_snprintf(&s,&size,"low (%s+%d)",pcop->name, PCOI(pcop)->index);
3032                                                 break;
3033                                         case 1:
3034                                                 SAFE_snprintf(&s,&size,"high (%s+%d)",pcop->name, PCOI(pcop)->index);
3035                                                 break;
3036                                         default:
3037                                                 fprintf (stderr, "PO_IMMEDIATE/_const/offset=%d\n", PCOI(pcop)->offset);
3038                                                 assert ( !"offset too large" );
3039                                                 SAFE_snprintf(&s,&size,"(((%s+%d) >> %d)&0xff)",
3040                                                         pcop->name,
3041                                                         PCOI(pcop)->index,
3042                                                         8 * PCOI(pcop)->offset );
3043                                         }
3044                                 } else
3045                                         SAFE_snprintf(&s,&size,"LOW (%s+%d)",pcop->name,PCOI(pcop)->index);
3046                         } else {
3047                                 if( !PCOI(pcop)->offset) { // && PCOI(pcc->pcop)->offset<4)
3048                                         SAFE_snprintf(&s,&size,"(%s + %d)",
3049                                                 pcop->name,
3050                                                 PCOI(pcop)->index);
3051                                 } else {
3052                                         switch(PCOI(pcop)->offset) {
3053                                         case 0:
3054                                                 SAFE_snprintf(&s,&size,"(%s + %d)",pcop->name, PCOI(pcop)->index);
3055                                                 break;
3056                                         case 1:
3057                                                 SAFE_snprintf(&s,&size,"high (%s + %d)",pcop->name, PCOI(pcop)->index);
3058                                                 break;
3059                                         default:
3060                                                 fprintf (stderr, "PO_IMMEDIATE/mutable/offset=%d\n", PCOI(pcop)->offset);
3061                                                 assert ( !"offset too large" );
3062                                                 SAFE_snprintf(&s,&size,"((%s + %d) >> %d)&0xff",pcop->name, PCOI(pcop)->index, 8*PCOI(pcop)->offset);
3063                                                 break;
3064                                         }
3065                                 }
3066                         }
3067
3068                         return buffer;
3069
3070                 case PO_DIR:
3071                         s = buffer;
3072                         //size = sizeof(buffer);
3073                         if( PCOR(pcop)->instance) {
3074                                 SAFE_snprintf(&s,&size,"(%s + %d)",
3075                                         pcop->name,
3076                                         PCOR(pcop)->instance );
3077                                 //fprintf(stderr,"PO_DIR %s\n",buffer);
3078                         } else
3079                                 SAFE_snprintf(&s,&size,"%s",pcop->name);
3080                         return buffer;
3081
3082                 case PO_LABEL:
3083                         s = buffer;
3084                         if  (pcop->name) {
3085                                 if(PCOLAB(pcop)->offset == 1)
3086                                         SAFE_snprintf(&s,&size,"HIGH(%s)",pcop->name);
3087                                 else
3088                                         SAFE_snprintf(&s,&size,"%s",pcop->name);
3089                         }
3090                         return buffer;
3091
3092                 case PO_GPR_BIT:
3093                         if(PCOR(pcop)->r) {
3094                                 if(use_buffer) {
3095                                         SAFE_snprintf(&buffer,&size,"%s",PCOR(pcop)->r->name);
3096                                         return buffer;
3097                                 }
3098                                 return PCOR(pcop)->r->name;
3099                         }
3100
3101                         /* fall through to the default case */
3102                 default:
3103                         if(pcop->name) {
3104                                 if(use_buffer) {
3105                                         SAFE_snprintf(&buffer,&size,"%s",pcop->name);
3106                                         return buffer;
3107                                 }
3108                                 return pcop->name;
3109                         }
3110                 }
3111         }
3112
3113         printf("PIC port internal warning: (%s:%d(%s)) %s not found\n",
3114           __FILE__, __LINE__, __FUNCTION__,
3115           pCodeOpType(pcop));
3116
3117         return "NO operand";
3118
3119 }
3120
3121 /*-----------------------------------------------------------------*/
3122 /*-----------------------------------------------------------------*/
3123 static char *get_op_from_instruction( pCodeInstruction *pcc)
3124 {
3125
3126         if(pcc)
3127                 return get_op(pcc->pcop,NULL,0);
3128
3129         return ("ERROR Null: get_op_from_instruction");
3130
3131 }
3132
3133 /*-----------------------------------------------------------------*/
3134 /*-----------------------------------------------------------------*/
3135 static void pCodeOpPrint(FILE *of, pCodeOp *pcop)
3136 {
3137         fprintf(of,"pcodeopprint- not implemented\n");
3138 }
3139
3140 /*-----------------------------------------------------------------*/
3141 /* pCode2str - convert a pCode instruction to string               */
3142 /*-----------------------------------------------------------------*/
3143 char *pCode2str(char *str, size_t size, pCode *pc)
3144 {
3145   char *s = str;
3146
3147   switch(pc->type) {
3148
3149   case PC_OPCODE:
3150
3151     SAFE_snprintf(&s,&size, "\t%s\t", PCI(pc)->mnemonic);
3152
3153     if( (PCI(pc)->num_ops >= 1) && (PCI(pc)->pcop)) {
3154
3155       if(PCI(pc)->isBitInst) {
3156         if(PCI(pc)->pcop->type == PO_GPR_BIT) {
3157           char *name = PCI(pc)->pcop->name;
3158           if (!name)
3159             name = PCOR(PCI(pc)->pcop)->r->name;
3160           if( (((pCodeOpRegBit *)(PCI(pc)->pcop))->inBitSpace) )
3161             SAFE_snprintf(&s,&size,"(%s >> 3), (%s & 7)", name, name);
3162           else
3163             SAFE_snprintf(&s,&size,"%s,%d", name,
3164             (((pCodeOpRegBit *)(PCI(pc)->pcop))->bit)&7);
3165         } else if(PCI(pc)->pcop->type == PO_GPR_BIT) {
3166           SAFE_snprintf(&s,&size,"%s,%d", get_op_from_instruction(PCI(pc)),PCORB(PCI(pc)->pcop)->bit);
3167       } else
3168           SAFE_snprintf(&s,&size,"%s,0 ; ?bug", get_op_from_instruction(PCI(pc)));
3169         //PCI(pc)->pcop->t.bit );
3170       } else {
3171         if(PCI(pc)->pcop->type == PO_GPR_BIT) {
3172           if( PCI(pc)->num_ops == 2)
3173             SAFE_snprintf(&s,&size,"(%s >> 3),%c",get_op_from_instruction(PCI(pc)),((PCI(pc)->isModReg) ? 'F':'W'));
3174           else
3175             SAFE_snprintf(&s,&size,"(1 << (%s & 7))",get_op_from_instruction(PCI(pc)));
3176         } else {
3177           SAFE_snprintf(&s,&size,"%s",get_op_from_instruction(PCI(pc)));
3178           if( PCI(pc)->num_ops == 2)
3179             SAFE_snprintf(&s,&size,",%c", ( (PCI(pc)->isModReg) ? 'F':'W'));
3180         }
3181       }
3182     }
3183     break;
3184
3185   case PC_COMMENT:
3186     /* assuming that comment ends with a \n */
3187     SAFE_snprintf(&s,&size,";%s", ((pCodeComment *)pc)->comment);
3188     break;
3189
3190   case PC_INLINE:
3191     /* assuming that inline code ends with a \n */
3192     SAFE_snprintf(&s,&size,"%s", ((pCodeComment *)pc)->comment);
3193     break;
3194
3195   case PC_LABEL:
3196     SAFE_snprintf(&s,&size,";label=%s, key=%d\n",PCL(pc)->label,PCL(pc)->key);
3197     break;
3198   case PC_FUNCTION:
3199     SAFE_snprintf(&s,&size,";modname=%s,function=%s: id=%d\n",PCF(pc)->modname,PCF(pc)->fname);
3200     break;
3201   case PC_WILD:
3202     SAFE_snprintf(&s,&size,";\tWild opcode: id=%d\n",PCW(pc)->id);
3203     break;
3204   case PC_FLOW:
3205     SAFE_snprintf(&s,&size,";\t--FLOW change\n");
3206     break;
3207   case PC_CSOURCE:
3208 //    SAFE_snprintf(&s,&size,";#CSRC\t%s %d\n; %s\n", PCCS(pc)->file_name, PCCS(pc)->line_number, PCCS(pc)->line);
3209     SAFE_snprintf(&s,&size,"%s\t.line\t%d; \"%s\"\t%s\n",(options.debug?"":";"),PCCS(pc)->line_number, PCCS(pc)->file_name, PCCS(pc)->line);
3210     break;
3211   case PC_ASMDIR:
3212     if(PCAD(pc)->directive) {
3213       SAFE_snprintf(&s,&size,"\t%s%s%s\n", PCAD(pc)->directive, PCAD(pc)->arg?"\t":"", PCAD(pc)->arg?PCAD(pc)->arg:"");
3214     } else if(PCAD(pc)->arg) {
3215       /* special case to handle inline labels without a tab */
3216       SAFE_snprintf(&s,&size,"%s\n", PCAD(pc)->arg);
3217     }
3218     break;
3219
3220   case PC_BAD:
3221     SAFE_snprintf(&s,&size,";A bad pCode is being used\n");
3222   }
3223
3224   return str;
3225 }
3226
3227 /*-----------------------------------------------------------------*/
3228 /* genericPrint - the contents of a pCode to a file                */
3229 /*-----------------------------------------------------------------*/
3230 static void genericPrint(FILE *of, pCode *pc)
3231 {
3232   if(!pc || !of)
3233     return;
3234
3235   switch(pc->type) {
3236   case PC_COMMENT:
3237     fprintf(of,";%s\n", ((pCodeComment *)pc)->comment);
3238     break;
3239
3240   case PC_INLINE:
3241     fprintf(of,"%s\n", ((pCodeComment *)pc)->comment);
3242     break;
3243
3244   case PC_OPCODE:
3245     // If the opcode has a label, print that first
3246     {
3247       char str[256];
3248       pCodeInstruction *pci = PCI(pc);
3249       pBranch *pbl = pci->label;
3250       while(pbl && pbl->pc) {
3251         if(pbl->pc->type == PC_LABEL)
3252           pCodePrintLabel(of, pbl->pc);
3253         pbl = pbl->next;
3254       }
3255
3256       if(pci->cline)
3257         genericPrint(of,PCODE(pci->cline));
3258
3259
3260       pCode2str(str, 256, pc);
3261
3262       fprintf(of,"%s",str);
3263
3264       /* Debug */
3265       if(debug_verbose) {
3266         pCodeOpReg *pcor = PCOR(pci->pcop);
3267         fprintf(of, "\t;id=%u,key=%03x,inCond:%x,outCond:%x",pc->id,pc->seq, pci->inCond, pci->outCond);
3268         if(pci->pcflow)
3269           fprintf(of,",flow seq=%03x",pci->pcflow->pc.seq);
3270         if (pcor && pcor->pcop.type==PO_GPR_TEMP && !pcor->r->isFixed)
3271           fprintf(of,",rIdx=r0x%X",pcor->rIdx);
3272       }
3273     }
3274 #if 0
3275     {
3276       pBranch *dpb = pc->to;   // debug
3277       while(dpb) {
3278         switch ( dpb->pc->type) {
3279         case PC_OPCODE:
3280           fprintf(of, "\t;%s", PCI(dpb->pc)->mnemonic);
3281           break;
3282         case PC_LABEL:
3283           fprintf(of, "\t;label %d", PCL(dpb->pc)->key);
3284           break;
3285         case PC_FUNCTION:
3286           fprintf(of, "\t;function %s", ( (PCF(dpb->pc)->fname) ? (PCF(dpb->pc)->fname) : "[END]"));
3287           break;
3288         case PC_FLOW:
3289           fprintf(of, "\t;flow");
3290           break;
3291         case PC_COMMENT:
3292         case PC_WILD:
3293           break;
3294         }
3295         dpb = dpb->next;
3296       }
3297     }
3298 #endif
3299     fprintf(of,"\n");
3300     break;
3301
3302   case PC_WILD:
3303     fprintf(of,";\tWild opcode: id=%d\n",PCW(pc)->id);
3304     if(PCW(pc)->pci.label)
3305       pCodePrintLabel(of, PCW(pc)->pci.label->pc);
3306
3307     if(PCW(pc)->operand) {
3308       fprintf(of,";\toperand  ");
3309       pCodeOpPrint(of,PCW(pc)->operand );
3310     }
3311     break;
3312
3313   case PC_FLOW:
3314     if(debug_verbose) {
3315       fprintf(of,";<>Start of new flow, seq=0x%x",pc->seq);
3316       if(PCFL(pc)->ancestor)
3317         fprintf(of," ancestor = 0x%x", PCODE(PCFL(pc)->ancestor)->seq);
3318       fprintf(of,"\n");
3319       fprintf(of,";  from: ");
3320       {
3321         pCodeFlowLink *link;
3322         for (link = setFirstItem(PCFL(pc)->from); link; link = setNextItem (PCFL(pc)->from))
3323         {
3324           fprintf(of,"%03x ",link->pcflow->pc.seq);
3325         }
3326       }
3327       fprintf(of,"; to: ");
3328       {
3329         pCodeFlowLink *link;
3330         for (link = setFirstItem(PCFL(pc)->to); link; link = setNextItem (PCFL(pc)->to))
3331         {
3332           fprintf(of,"%03x ",link->pcflow->pc.seq);
3333         }
3334       }
3335       fprintf(of,"\n");
3336     }
3337     break;
3338
3339   case PC_CSOURCE:
3340 //    fprintf(of,";#CSRC\t%s %d\n;  %s\n", PCCS(pc)->file_name, PCCS(pc)->line_number, PCCS(pc)->line);
3341     fprintf(of,"%s\t.line\t%d; \"%s\"\t%s\n", (options.debug?"":";"), PCCS(pc)->line_number, PCCS(pc)->file_name, PCCS(pc)->line);
3342     break;
3343
3344   case PC_ASMDIR:
3345     {
3346       pBranch *pbl = PCAD(pc)->pci.label;
3347       while(pbl && pbl->pc) {
3348         if(pbl->pc->type == PC_LABEL)
3349           pCodePrintLabel(of, pbl->pc);
3350         pbl = pbl->next;
3351       }
3352     }
3353     if(PCAD(pc)->directive) {
3354       fprintf(of, "\t%s%s%s\n", PCAD(pc)->directive, PCAD(pc)->arg?"\t":"", PCAD(pc)->arg?PCAD(pc)->arg:"");
3355     } else
3356     if(PCAD(pc)->arg) {
3357       /* special case to handle inline labels without tab */
3358       fprintf(of, "%s\n", PCAD(pc)->arg);
3359     }
3360     break;
3361
3362   case PC_LABEL:
3363   default:
3364     fprintf(of,"unknown pCode type %d\n",pc->type);
3365   }
3366 }
3367
3368 /*-----------------------------------------------------------------*/
3369 /* pCodePrintFunction - prints function begin/end                  */
3370 /*-----------------------------------------------------------------*/
3371
3372 static void pCodePrintFunction(FILE *of, pCode *pc)
3373 {
3374
3375         if(!pc || !of)
3376                 return;
3377
3378         if( ((pCodeFunction *)pc)->modname)
3379                 fprintf(of,"F_%s",((pCodeFunction *)pc)->modname);
3380
3381         if(PCF(pc)->fname) {
3382                 pBranch *exits = PCF(pc)->to;
3383                 int i=0;
3384                 fprintf(of,"%s\t;Function start\n",PCF(pc)->fname);
3385                 while(exits) {
3386                         i++;
3387                         exits = exits->next;
3388                 }
3389                 //if(i) i--;
3390                 fprintf(of,"; %d exit point%c\n",i, ((i==1) ? ' ':'s'));
3391
3392         }else {
3393                 if((PCF(pc)->from &&
3394                         PCF(pc)->from->pc->type == PC_FUNCTION &&
3395                         PCF(PCF(pc)->from->pc)->fname) )
3396                         fprintf(of,"; exit point of %s\n",PCF(PCF(pc)->from->pc)->fname);
3397                 else
3398                         fprintf(of,"; exit point [can't find entry point]\n");
3399         }
3400 }
3401 /*-----------------------------------------------------------------*/
3402 /* pCodePrintLabel - prints label                                  */
3403 /*-----------------------------------------------------------------*/
3404
3405 static void pCodePrintLabel(FILE *of, pCode *pc)
3406 {
3407
3408         if(!pc || !of)
3409                 return;
3410
3411         if(PCL(pc)->label)
3412                 fprintf(of,"%s\n",PCL(pc)->label);
3413         else if (PCL(pc)->key >=0)
3414                 fprintf(of,"_%05d_DS_:\n",PCL(pc)->key);
3415         else
3416                 fprintf(of,";wild card label: id=%d\n",-PCL(pc)->key);
3417
3418 }
3419
3420 /*-----------------------------------------------------------------*/
3421 /* unlinkpCodeFromBranch - Search for a label in a pBranch and     */
3422 /*                         remove it if it is found.               */
3423 /*-----------------------------------------------------------------*/
3424 static void unlinkpCodeFromBranch(pCode *pcl , pCode *pc)
3425 {
3426   pBranch *b, *bprev;
3427
3428   bprev = NULL;
3429
3430   if(pcl->type == PC_OPCODE || pcl->type == PC_INLINE || pcl->type == PC_ASMDIR)
3431     b = PCI(pcl)->label;
3432   else {
3433     fprintf(stderr, "LINE %d. can't unlink from non opcode\n",__LINE__);
3434     exit(1);
3435   }
3436
3437   //fprintf (stderr, "%s \n",__FUNCTION__);
3438   //pcl->print(stderr,pcl);
3439   //pc->print(stderr,pc);
3440   while(b) {
3441     if(b->pc == pc) {
3442       //fprintf (stderr, "found label\n");
3443
3444       /* Found a label */
3445       if(bprev) {
3446         bprev->next = b->next;  /* Not first pCode in chain */
3447         free(b);
3448       } else {
3449         pc->destruct(pc);
3450         PCI(pcl)->label = b->next;   /* First pCode in chain */
3451         free(b);
3452       }
3453       return;  /* A label can't occur more than once */
3454     }
3455     bprev = b;
3456     b = b->next;
3457   }
3458 }
3459
3460 /*-----------------------------------------------------------------*/
3461 /*-----------------------------------------------------------------*/
3462 pBranch * pBranchAppend(pBranch *h, pBranch *n)
3463 {
3464         pBranch *b;
3465
3466         if(!h)
3467                 return n;
3468
3469         if(h == n)
3470                 return n;
3471
3472         b = h;
3473         while(b->next)
3474                 b = b->next;
3475
3476         b->next = n;
3477
3478         return h;
3479
3480 }
3481 /*-----------------------------------------------------------------*/
3482 /* pBranchLink - given two pcodes, this function will link them    */
3483 /*               together through their pBranches                  */
3484 /*-----------------------------------------------------------------*/
3485 static void pBranchLink(pCodeFunction *f, pCodeFunction *t)
3486 {
3487         pBranch *b;
3488
3489         // Declare a new branch object for the 'from' pCode.
3490
3491         //_ALLOC(b,sizeof(pBranch));
3492         b = Safe_calloc(1,sizeof(pBranch));
3493         b->pc = PCODE(t);             // The link to the 'to' pCode.
3494         b->next = NULL;
3495
3496         f->to = pBranchAppend(f->to,b);
3497
3498         // Now do the same for the 'to' pCode.
3499
3500         //_ALLOC(b,sizeof(pBranch));
3501         b = Safe_calloc(1,sizeof(pBranch));
3502         b->pc = PCODE(f);
3503         b->next = NULL;
3504
3505         t->from = pBranchAppend(t->from,b);
3506
3507 }
3508
3509 #if 0
3510 /*-----------------------------------------------------------------*/
3511 /* pBranchFind - find the pBranch in a pBranch chain that contains */
3512 /*               a pCode                                           */
3513 /*-----------------------------------------------------------------*/
3514 static pBranch *pBranchFind(pBranch *pb,pCode *pc)
3515 {
3516         while(pb) {
3517
3518                 if(pb->pc == pc)
3519                         return pb;
3520
3521                 pb = pb->next;
3522         }
3523
3524         return NULL;
3525 }
3526
3527 /*-----------------------------------------------------------------*/
3528 /* pCodeUnlink - Unlink the given pCode from its pCode chain.      */
3529 /*-----------------------------------------------------------------*/
3530 static void pCodeUnlink(pCode *pc)
3531 {
3532         pBranch *pb1,*pb2;
3533         pCode *pc1;
3534
3535         if(!pc->prev || !pc->next) {
3536                 fprintf(stderr,"unlinking bad pCode in %s:%d\n",__FILE__,__LINE__);
3537                 exit(1);
3538         }
3539
3540         /* first remove the pCode from the chain */
3541         pc->prev->next = pc->next;
3542         pc->next->prev = pc->prev;
3543
3544         /* Now for the hard part... */
3545
3546         /* Remove the branches */
3547
3548         pb1 = pc->from;
3549         while(pb1) {
3550         pc1 = pb1->pc;    /* Get the pCode that branches to the
3551         * one we're unlinking */
3552
3553         /* search for the link back to this pCode (the one we're
3554         * unlinking) */
3555         if(pb2 = pBranchFind(pc1->to,pc)) {
3556                 pb2->pc = pc->to->pc;  // make the replacement
3557
3558                                                            /* if the pCode we're unlinking contains multiple 'to'
3559                                                            * branches (e.g. this a skip instruction) then we need
3560                 * to copy these extra branches to the chain. */
3561                 if(pc->to->next)
3562                         pBranchAppend(pb2, pc->to->next);
3563         }
3564
3565         pb1 = pb1->next;
3566         }
3567
3568
3569 }
3570 #endif
3571 /*-----------------------------------------------------------------*/
3572 /*-----------------------------------------------------------------*/
3573 #if 0
3574 static void genericAnalyze(pCode *pc)
3575 {
3576         switch(pc->type) {
3577         case PC_WILD:
3578         case PC_COMMENT:
3579                 return;
3580         case PC_LABEL:
3581         case PC_FUNCTION:
3582         case PC_OPCODE:
3583                 {
3584                         // Go through the pCodes that are in pCode chain and link
3585                         // them together through the pBranches. Note, the pCodes
3586                         // are linked together as a contiguous stream like the
3587                         // assembly source code lines. The linking here mimics this
3588                         // except that comments are not linked in.
3589                         //
3590                         pCode *npc = pc->next;
3591                         while(npc) {
3592                                 if(npc->type == PC_OPCODE || npc->type == PC_LABEL) {
3593                                         pBranchLink(pc,npc);
3594                                         return;
3595                                 } else
3596                                         npc = npc->next;
3597                         }
3598                         /* reached the end of the pcode chain without finding
3599                         * an instruction we could link to. */
3600                 }
3601                 break;
3602         case PC_FLOW:
3603                 fprintf(stderr,"analyze PC_FLOW\n");
3604
3605                 return;
3606         case PC_BAD:
3607                 fprintf(stderr,";A bad pCode is being used\n");
3608
3609         }
3610 }
3611 #endif
3612
3613 /*-----------------------------------------------------------------*/
3614 /*-----------------------------------------------------------------*/
3615 int compareLabel(pCode *pc, pCodeOpLabel *pcop_label)
3616 {
3617   pBranch *pbr;
3618
3619   if(pc->type == PC_LABEL) {
3620     if( ((pCodeLabel *)pc)->key ==  pcop_label->key)
3621       return TRUE;
3622   }
3623   if(pc->type == PC_OPCODE || pc->type == PC_ASMDIR) {
3624     pbr = PCI(pc)->label;
3625     while(pbr) {
3626       if(pbr->pc->type == PC_LABEL) {
3627         if( ((pCodeLabel *)(pbr->pc))->key ==  pcop_label->key)
3628           return TRUE;
3629       }
3630       pbr = pbr->next;
3631     }
3632   }
3633
3634   return FALSE;
3635 }
3636
3637 /*-----------------------------------------------------------------*/
3638 /*-----------------------------------------------------------------*/
3639 int checkLabel(pCode *pc)
3640 {
3641         pBranch *pbr;
3642
3643         if(pc && isPCI(pc)) {
3644                 pbr = PCI(pc)->label;
3645                 while(pbr) {
3646                         if(isPCL(pbr->pc) && (PCL(pbr->pc)->key >= 0))
3647                                 return TRUE;
3648
3649                         pbr = pbr->next;
3650                 }
3651         }
3652
3653         return FALSE;
3654 }
3655
3656 /*-----------------------------------------------------------------*/
3657 /* findLabelinpBlock - Search the pCode for a particular label     */
3658 /*-----------------------------------------------------------------*/
3659 pCode * findLabelinpBlock(pBlock *pb,pCodeOpLabel *pcop_label)
3660 {
3661         pCode  *pc;
3662
3663         if(!pb)
3664                 return NULL;
3665
3666         for(pc = pb->pcHead; pc; pc = pc->next)
3667                 if(compareLabel(pc,pcop_label))
3668                         return pc;
3669
3670                 return NULL;
3671 }
3672
3673 /*-----------------------------------------------------------------*/
3674 /* findLabel - Search the pCode for a particular label             */
3675 /*-----------------------------------------------------------------*/
3676 pCode * findLabel(pCodeOpLabel *pcop_label)
3677 {
3678         pBlock *pb;
3679         pCode  *pc;
3680
3681         if(!the_pFile)
3682                 return NULL;
3683
3684         for(pb = the_pFile->pbHead; pb; pb = pb->next) {
3685                 if( (pc = findLabelinpBlock(pb,pcop_label)) != NULL)
3686                         return pc;
3687         }
3688
3689         fprintf(stderr,"Couldn't find label %s\n", pcop_label->pcop.name);
3690         return NULL;
3691 }
3692
3693 /*-----------------------------------------------------------------*/
3694 /* findNextpCode - given a pCode, find the next of type 'pct'      */
3695 /*                 in the linked list                              */
3696 /*-----------------------------------------------------------------*/
3697 pCode * findNextpCode(pCode *pc, PC_TYPE pct)
3698 {
3699
3700         while(pc) {
3701                 if(pc->type == pct)
3702                         return pc;
3703
3704                 pc = pc->next;
3705         }
3706
3707         return NULL;
3708 }
3709
3710 /*-----------------------------------------------------------------*/
3711 /* findPrevpCode - given a pCode, find the previous of type 'pct'  */
3712 /*                 in the linked list                              */
3713 /*-----------------------------------------------------------------*/
3714 pCode * findPrevpCode(pCode *pc, PC_TYPE pct)
3715 {
3716
3717         while(pc) {
3718                 if(pc->type == pct) {
3719                         /*
3720                         static unsigned int stop;
3721                         if (pc->id == 524)
3722                                 stop++; // Place break point here
3723                         */
3724                         return pc;
3725                 }
3726
3727                 pc = pc->prev;
3728         }
3729
3730         return NULL;
3731 }
3732
3733 /*-----------------------------------------------------------------*/
3734 /* findNextInstruction - given a pCode, find the next instruction  */
3735 /*                       in the linked list                        */
3736 /*-----------------------------------------------------------------*/
3737 pCode * findNextInstruction(pCode *pci)
3738 {
3739   pCode *pc = pci;
3740
3741   while(pc) {
3742   if((pc->type == PC_OPCODE)
3743     || (pc->type == PC_WILD)
3744     || (pc->type == PC_ASMDIR))
3745       return pc;
3746
3747 #ifdef PCODE_DEBUG
3748     fprintf(stderr,"findNextInstruction:  ");
3749     printpCode(stderr, pc);
3750 #endif
3751     pc = pc->next;
3752   }
3753
3754   //fprintf(stderr,"Couldn't find instruction\n");
3755   return NULL;
3756 }
3757
3758 /*-----------------------------------------------------------------*/
3759 /* findNextInstruction - given a pCode, find the next instruction  */
3760 /*                       in the linked list                        */
3761 /*-----------------------------------------------------------------*/
3762 pCode * findPrevInstruction(pCode *pci)
3763 {
3764   pCode *pc = pci;
3765
3766   while(pc) {
3767
3768     if((pc->type == PC_OPCODE)
3769       || (pc->type == PC_WILD)
3770       || (pc->type == PC_ASMDIR))
3771       return pc;
3772
3773
3774 #ifdef PCODE_DEBUG
3775     fprintf(stderr,"pic16_findPrevInstruction:  ");
3776     printpCode(stderr, pc);
3777 #endif
3778     pc = pc->prev;
3779   }
3780
3781   //fprintf(stderr,"Couldn't find instruction\n");
3782   return NULL;
3783 }
3784
3785 /*-----------------------------------------------------------------*/
3786 /* findFunctionEnd - given a pCode find the end of the function    */
3787 /*                   that contains it                              */
3788 /*-----------------------------------------------------------------*/
3789 pCode * findFunctionEnd(pCode *pc)
3790 {
3791         while(pc) {
3792                 if(pc->type == PC_FUNCTION &&  !(PCF(pc)->fname))
3793                         return pc;
3794
3795                 pc = pc->next;
3796         }
3797
3798         fprintf(stderr,"Couldn't find function end\n");
3799         return NULL;
3800 }
3801
3802 #if 0
3803 /*-----------------------------------------------------------------*/
3804 /* AnalyzeLabel - if the pCode is a label, then merge it with the  */
3805 /*                instruction with which it is associated.         */
3806 /*-----------------------------------------------------------------*/
3807 static void AnalyzeLabel(pCode *pc)
3808 {
3809
3810         pCodeUnlink(pc);
3811
3812 }
3813 #endif
3814
3815 #if 0
3816 static void AnalyzeGOTO(pCode *pc)
3817 {
3818
3819         pBranchLink(pc,findLabel( (pCodeOpLabel *) (PCI(pc)->pcop) ));
3820
3821 }
3822
3823 static void AnalyzeSKIP(pCode *pc)
3824 {
3825
3826         pBranchLink(pc,findNextInstruction(pc->next));
3827         pBranchLink(pc,findNextInstruction(pc->next->next));
3828
3829 }
3830
3831 static void AnalyzeRETURN(pCode *pc)
3832 {
3833
3834         //  branch_link(pc,findFunctionEnd(pc->next));
3835
3836 }
3837
3838 #endif
3839
3840 /*-----------------------------------------------------------------*/
3841 /*-----------------------------------------------------------------*/
3842 regs * getRegFromInstruction(pCode *pc)
3843 {
3844         regs *r;
3845         if(!pc                   ||
3846                 !isPCI(pc)            ||
3847                 !PCI(pc)->pcop        ||
3848                 PCI(pc)->num_ops == 0 )
3849                 return NULL;
3850
3851         switch(PCI(pc)->pcop->type) {
3852         case PO_STATUS:
3853         case PO_FSR:
3854         case PO_INDF:
3855         case PO_INTCON:
3856         case PO_BIT:
3857         case PO_GPR_TEMP:
3858         case PO_SFR_REGISTER:
3859         case PO_PCL:
3860         case PO_PCLATH:
3861                 return PCOR(PCI(pc)->pcop)->r;
3862
3863         case PO_GPR_REGISTER:
3864         case PO_GPR_BIT:
3865         case PO_DIR:
3866                 r = PCOR(PCI(pc)->pcop)->r;
3867                 if (r)
3868                         return r;
3869                 return dirregWithName(PCI(pc)->pcop->name);
3870
3871         case PO_LITERAL:
3872                 break;
3873
3874         case PO_IMMEDIATE:
3875                 r = PCOI(PCI(pc)->pcop)->r;
3876                 if (r)
3877                         return r;
3878                 return dirregWithName(PCI(pc)->pcop->name);
3879
3880         default:
3881                 break;
3882         }
3883
3884         return NULL;
3885
3886 }
3887
3888 /*-----------------------------------------------------------------*/
3889 /*-----------------------------------------------------------------*/
3890
3891 void AnalyzepBlock(pBlock *pb)
3892 {
3893         pCode *pc;
3894
3895         if(!pb)
3896                 return;
3897
3898                 /* Find all of the registers used in this pBlock
3899                 * by looking at each instruction and examining it's
3900                 * operands
3901         */
3902         for(pc = pb->pcHead; pc; pc = pc->next) {
3903
3904                 /* Is this an instruction with operands? */
3905                 if(pc->type == PC_OPCODE && PCI(pc)->pcop) {
3906
3907                         if((PCI(pc)->pcop->type == PO_GPR_TEMP)
3908                                 || ((PCI(pc)->pcop->type == PO_GPR_BIT) && PCOR(PCI(pc)->pcop)->r && (PCOR(PCI(pc)->pcop)->r->pc_type == PO_GPR_TEMP))) {
3909
3910                                 /* Loop through all of the registers declared so far in
3911                                 this block and see if we find this one there */
3912
3913                                 regs *r = setFirstItem(pb->tregisters);
3914
3915                                 while(r) {
3916                                         if((r->rIdx == PCOR(PCI(pc)->pcop)->r->rIdx) && (r->type == PCOR(PCI(pc)->pcop)->r->type)) {
3917                                                 PCOR(PCI(pc)->pcop)->r = r;
3918                                                 break;
3919                                         }
3920                                         r = setNextItem(pb->tregisters);
3921                                 }
3922
3923                                 if(!r) {
3924                                         /* register wasn't found */
3925                                         //r = Safe_calloc(1, sizeof(regs));
3926                                         //memcpy(r,PCOR(PCI(pc)->pcop)->r, sizeof(regs));
3927                                         //addSet(&pb->tregisters, r);
3928                                         addSet(&pb->tregisters, PCOR(PCI(pc)->pcop)->r);
3929                                         //PCOR(PCI(pc)->pcop)->r = r;
3930                                         //fprintf(stderr,"added register to pblock: reg %d\n",r->rIdx);
3931                                         }/* else
3932                                          fprintf(stderr,"found register in pblock: reg %d\n",r->rIdx);
3933                                 */
3934                         }
3935                         if(PCI(pc)->pcop->type == PO_GPR_REGISTER) {
3936                                 if(PCOR(PCI(pc)->pcop)->r) {
3937                                         pic14_allocWithIdx (PCOR(PCI(pc)->pcop)->r->rIdx);
3938                                         DFPRINTF((stderr,"found register in pblock: reg 0x%x\n",PCOR(PCI(pc)->pcop)->r->rIdx));
3939                                 } else {
3940                                         if(PCI(pc)->pcop->name)
3941                                                 fprintf(stderr,"ERROR: %s is a NULL register\n",PCI(pc)->pcop->name );
3942                                         else
3943                                                 fprintf(stderr,"ERROR: NULL register\n");
3944                                 }
3945                         }
3946                 }
3947
3948
3949         }
3950 }
3951
3952 /*-----------------------------------------------------------------*/
3953 /* */
3954 /*-----------------------------------------------------------------*/
3955 void InsertpFlow(pCode *pc, pCode **pflow)
3956 {
3957         if(*pflow)
3958                 PCFL(*pflow)->end = pc;
3959
3960         if(!pc || !pc->next)
3961                 return;
3962
3963         *pflow = newpCodeFlow();
3964         pCodeInsertAfter(pc, *pflow);
3965 }
3966
3967 /*-----------------------------------------------------------------*/
3968 /* BuildFlow(pBlock *pb) - examine the code in a pBlock and build  */
3969 /*                         the flow blocks.                        */
3970 /*
3971 * BuildFlow inserts pCodeFlow objects into the pCode chain at each
3972 * point the instruction flow changes.
3973 */
3974 /*-----------------------------------------------------------------*/
3975 void BuildFlow(pBlock *pb)
3976 {
3977         pCode *pc;
3978         pCode *last_pci=NULL;
3979         pCode *pflow=NULL;
3980         int seq = 0;
3981
3982         if(!pb)
3983                 return;
3984
3985         //fprintf (stderr,"build flow start seq %d  ",GpcFlowSeq);
3986         /* Insert a pCodeFlow object at the beginning of a pBlock */
3987
3988         InsertpFlow(pb->pcHead, &pflow);
3989
3990         //pflow = newpCodeFlow();    /* Create a new Flow object */
3991         //pflow->next = pb->pcHead;  /* Make the current head the next object */
3992         //pb->pcHead->prev = pflow;  /* let the current head point back to the flow object */
3993         //pb->pcHead = pflow;        /* Make the Flow object the head */
3994         //pflow->pb = pb;
3995
3996         for( pc = findNextInstruction(pb->pcHead);
3997         pc != NULL;
3998         pc=findNextInstruction(pc)) {
3999
4000                 pc->seq = seq++;
4001                 PCI(pc)->pcflow = PCFL(pflow);
4002
4003                 //fprintf(stderr," build: ");
4004                 //pc->print(stderr, pc);
4005                 //pflow->print(stderr,pflow);
4006
4007                 if (checkLabel(pc)) {
4008
4009                 /* This instruction marks the beginning of a
4010                         * new flow segment */
4011
4012                         pc->seq = 0;
4013                         seq = 1;
4014
4015                         /* If the previous pCode is not a flow object, then
4016                         * insert a new flow object. (This check prevents
4017                         * two consecutive flow objects from being insert in
4018                         * the case where a skip instruction preceeds an
4019                         * instruction containing a label.) */
4020
4021                         last_pci = findPrevInstruction (pc->prev);
4022
4023                         if(last_pci && (PCI(last_pci)->pcflow == PCFL(pflow)))
4024                                 InsertpFlow(last_pci, &pflow);
4025
4026                         PCI(pc)->pcflow = PCFL(pflow);
4027
4028                 }
4029
4030                 if(isPCI_SKIP(pc)) {
4031
4032                 /* The two instructions immediately following this one
4033                         * mark the beginning of a new flow segment */
4034
4035                         while(pc && isPCI_SKIP(pc)) {
4036
4037                                 PCI(pc)->pcflow = PCFL(pflow);
4038                                 pc->seq = seq-1;
4039                                 seq = 1;
4040
4041                                 InsertpFlow(pc, &pflow);
4042                                 pc=findNextInstruction(pc->next);
4043                         }
4044
4045                         seq = 0;
4046
4047                         if(!pc)
4048                                 break;
4049
4050                         PCI(pc)->pcflow = PCFL(pflow);
4051                         pc->seq = 0;
4052                         InsertpFlow(pc, &pflow);
4053
4054                 } else if ( isPCI_BRANCH(pc) && !checkLabel(findNextInstruction(pc->next)))  {
4055
4056                         InsertpFlow(pc, &pflow);
4057                         seq = 0;
4058
4059                 }
4060
4061                 last_pci = pc;
4062                 pc = pc->next;
4063         }
4064
4065         //fprintf (stderr,",end seq %d",GpcFlowSeq);
4066         if(pflow)
4067                 PCFL(pflow)->end = pb->pcTail;
4068 }
4069
4070 /*-------------------------------------------------------------------*/
4071 /* unBuildFlow(pBlock *pb) - examine the code in a pBlock and build  */
4072 /*                           the flow blocks.                        */
4073 /*
4074 * unBuildFlow removes pCodeFlow objects from a pCode chain
4075 */
4076 /*-----------------------------------------------------------------*/
4077 void unBuildFlow(pBlock *pb)
4078 {
4079         pCode *pc,*pcnext;
4080
4081         if(!pb)
4082                 return;
4083
4084         pc = pb->pcHead;
4085
4086         while(pc) {
4087                 pcnext = pc->next;
4088
4089                 if(isPCI(pc)) {
4090
4091                         pc->seq = 0;
4092                         if(PCI(pc)->pcflow) {
4093                                 //free(PCI(pc)->pcflow);
4094                                 PCI(pc)->pcflow = NULL;
4095                         }
4096
4097                 } else if(isPCFL(pc) )
4098                         pc->destruct(pc);
4099
4100                 pc = pcnext;
4101         }
4102
4103
4104 }
4105
4106 /*-----------------------------------------------------------------*/
4107 /*-----------------------------------------------------------------*/
4108 void dumpCond(int cond)
4109 {
4110
4111         static char *pcc_str[] = {
4112                 //"PCC_NONE",
4113                 "PCC_REGISTER",
4114                         "PCC_C",
4115                         "PCC_Z",
4116                         "PCC_DC",
4117                         "PCC_W",
4118                         "PCC_EXAMINE_PCOP",
4119                         "PCC_REG_BANK0",
4120                         "PCC_REG_BANK1",
4121                         "PCC_REG_BANK2",
4122                         "PCC_REG_BANK3"
4123         };
4124
4125         int ncond = sizeof(pcc_str) / sizeof(char *);
4126         int i,j;
4127
4128         fprintf(stderr, "0x%04X\n",cond);
4129
4130         for(i=0,j=1; i<ncond; i++, j<<=1)
4131                 if(cond & j)
4132                         fprintf(stderr, "  %s\n",pcc_str[i]);
4133
4134 }
4135
4136 /*-----------------------------------------------------------------*/
4137 /*-----------------------------------------------------------------*/
4138 void FlowStats(pCodeFlow *pcflow)
4139 {
4140
4141         pCode *pc;
4142
4143         if(!isPCFL(pcflow))
4144                 return;
4145
4146         fprintf(stderr, " FlowStats - flow block (seq=%d)\n", pcflow->pc.seq);
4147
4148         pc = findNextpCode(PCODE(pcflow), PC_OPCODE);
4149
4150         if(!pc) {
4151                 fprintf(stderr, " FlowStats - empty flow (seq=%d)\n", pcflow->pc.seq);
4152                 return;
4153         }
4154
4155
4156         fprintf(stderr, "  FlowStats inCond: ");
4157         dumpCond(pcflow->inCond);
4158         fprintf(stderr, "  FlowStats outCond: ");
4159         dumpCond(pcflow->outCond);
4160
4161 }
4162
4163 /*-----------------------------------------------------------------*
4164 * int isBankInstruction(pCode *pc) - examine the pCode *pc to determine
4165 *    if it affects the banking bits.
4166 *
4167 * return: -1 == Banking bits are unaffected by this pCode.
4168 *
4169 * return: > 0 == Banking bits are affected.
4170 *
4171 *  If the banking bits are affected, then the returned value describes
4172 * which bits are affected and how they're affected. The lower half
4173 * of the integer maps to the bits that are affected, the upper half
4174 * to whether they're set or cleared.
4175 *
4176 *-----------------------------------------------------------------*/
4177 /*
4178 #define SET_BANK_BIT (1 << 16)
4179 #define CLR_BANK_BIT 0
4180
4181 static int isBankInstruction(pCode *pc)
4182 {
4183         regs *reg;
4184         int bank = -1;
4185
4186         if(!isPCI(pc))
4187                 return -1;
4188
4189         if( ( (reg = getRegFromInstruction(pc)) != NULL) && isSTATUS_REG(reg)) {
4190
4191                 // Check to see if the register banks are changing
4192                 if(PCI(pc)->isModReg) {
4193
4194                         pCodeOp *pcop = PCI(pc)->pcop;
4195                         switch(PCI(pc)->op) {
4196
4197                         case POC_BSF:
4198                                 if(PCORB(pcop)->bit == PIC_RP0_BIT) {
4199                                         //fprintf(stderr, "  isBankInstruction - Set RP0\n");
4200                                         return  SET_BANK_BIT | PIC_RP0_BIT;
4201                                 }
4202
4203                                 if(PCORB(pcop)->bit == PIC_RP1_BIT) {
4204                                         //fprintf(stderr, "  isBankInstruction - Set RP1\n");
4205                                         return  CLR_BANK_BIT | PIC_RP0_BIT;
4206                                 }
4207                                 break;
4208
4209                         case POC_BCF:
4210                                 if(PCORB(pcop)->bit == PIC_RP0_BIT) {
4211                                         //fprintf(stderr, "  isBankInstruction - Clr RP0\n");
4212                                         return  CLR_BANK_BIT | PIC_RP1_BIT;
4213                                 }
4214                                 if(PCORB(pcop)->bit == PIC_RP1_BIT) {
4215                                         //fprintf(stderr, "  isBankInstruction - Clr RP1\n");
4216                                         return  CLR_BANK_BIT | PIC_RP1_BIT;
4217                                 }
4218                                 break;
4219                         default:
4220                                 //fprintf(stderr, "  isBankInstruction - Status register is getting Modified by:\n");
4221                                 //genericPrint(stderr, pc);
4222                                 ;
4223                         }
4224                 }
4225
4226                                 }
4227
4228         return bank;
4229 }
4230 */
4231
4232 /*-----------------------------------------------------------------*/
4233 /*-----------------------------------------------------------------*/
4234 /*
4235 static void FillFlow(pCodeFlow *pcflow)
4236 {
4237         pCode *pc;
4238         int cur_bank;
4239
4240         if(!isPCFL(pcflow))
4241                 return;
4242
4243         //  fprintf(stderr, " FillFlow - flow block (seq=%d)\n", pcflow->pc.seq);
4244
4245         pc = findNextpCode(PCODE(pcflow), PC_OPCODE);
4246
4247         if(!pc) {
4248                 //fprintf(stderr, " FillFlow - empty flow (seq=%d)\n", pcflow->pc.seq);
4249                 return;
4250         }
4251
4252         cur_bank = -1;
4253
4254         do {
4255                 isBankInstruction(pc);
4256                 pc = pc->next;
4257         } while (pc && (pc != pcflow->end) && !isPCFL(pc));
4258         / *
4259                 if(!pc ) {
4260                         fprintf(stderr, "  FillFlow - Bad end of flow\n");
4261                 } else {
4262                         fprintf(stderr, "  FillFlow - Ending flow with\n  ");
4263                         pc->print(stderr,pc);
4264                 }
4265
4266                 fprintf(stderr, "  FillFlow inCond: ");
4267                 dumpCond(pcflow->inCond);
4268                 fprintf(stderr, "  FillFlow outCond: ");
4269                 dumpCond(pcflow->outCond);
4270                 * /
4271 }
4272 */
4273
4274 /*-----------------------------------------------------------------*/
4275 /*-----------------------------------------------------------------*/
4276 void LinkFlow_pCode(pCodeInstruction *from, pCodeInstruction *to)
4277 {
4278         pCodeFlowLink *fromLink, *toLink;
4279 #if 0
4280         fprintf(stderr, "%s: linking ", __FUNCTION__ );
4281         if (from) from->pc.print(stderr, &from->pc);
4282         else fprintf(stderr, "(null)");
4283         fprintf(stderr, " -(%u)-> with -(%u)-> ",
4284                 from && from->pcflow ? from->pcflow->pc.seq : 0,
4285                 to && to->pcflow ? to->pcflow->pc.seq : 0);
4286         if (to) to->pc.print(stderr, &to->pc);
4287         else fprintf(stderr, "(null)");
4288 #endif
4289
4290         if(!from || !to || !to->pcflow || !from->pcflow)
4291                 return;
4292
4293         fromLink = newpCodeFlowLink(from->pcflow);
4294         toLink   = newpCodeFlowLink(to->pcflow);
4295
4296         addSetIfnotP(&(from->pcflow->to), toLink);   //to->pcflow);
4297         addSetIfnotP(&(to->pcflow->from), fromLink); //from->pcflow);
4298
4299 }
4300
4301 /*-----------------------------------------------------------------*
4302 * void LinkFlow(pBlock *pb)
4303 *
4304 * In BuildFlow, the PIC code has been partitioned into contiguous
4305 * non-branching segments. In LinkFlow, we determine the execution
4306 * order of these segments. For example, if one of the segments ends
4307 * with a skip, then we know that there are two possible flow segments
4308 * to which control may be passed.
4309 *-----------------------------------------------------------------*/
4310 void LinkFlow(pBlock *pb)
4311 {
4312         pCode *pc=NULL;
4313         pCode *pcflow;
4314         pCode *pct;
4315
4316         //fprintf(stderr,"linkflow \n");
4317
4318         for( pcflow = findNextpCode(pb->pcHead, PC_FLOW);
4319         pcflow != NULL;
4320         pcflow = findNextpCode(pcflow->next, PC_FLOW) ) {
4321
4322                 if(!isPCFL(pcflow))
4323                         fprintf(stderr, "LinkFlow - pcflow is not a flow object ");
4324
4325                 //fprintf(stderr," link: ");
4326                 //pcflow->print(stderr,pcflow);
4327
4328                 //FillFlow(PCFL(pcflow));
4329
4330                 /* find last instruction in flow */
4331                 pc = findPrevInstruction (PCFL(pcflow)->end);
4332                 if (!pc) {
4333                         fprintf(stderr, "%s: flow without end (%u)?\n",
4334                         __FUNCTION__, pcflow->seq );
4335                         continue;
4336                 }
4337
4338                 //fprintf(stderr, "LinkFlow - flow block (seq=%d) ", pcflow->seq);
4339                 //pc->print(stderr, pc);
4340                 if(isPCI_SKIP(pc)) {
4341                         //fprintf(stderr, "ends with skip\n");
4342                         //pc->print(stderr,pc);
4343                         pct=findNextInstruction(pc->next);
4344                         LinkFlow_pCode(PCI(pc),PCI(pct));
4345                         pct=findNextInstruction(pct->next);
4346                         LinkFlow_pCode(PCI(pc),PCI(pct));
4347                         continue;
4348                 }
4349
4350                 if(isPCI_BRANCH(pc)) {
4351                         pCodeOpLabel *pcol = PCOLAB(PCI(pc)->pcop);
4352
4353                         //fprintf(stderr, "ends with branch\n  ");
4354                         //pc->print(stderr,pc);
4355
4356                         if(!(pcol && isPCOLAB(pcol))) {
4357                                 if((PCI(pc)->op != POC_RETLW)
4358                                         && (PCI(pc)->op != POC_RETURN)
4359                                         && (PCI(pc)->op != POC_CALL)
4360                                         && (PCI(pc)->op != POC_RETFIE) )
4361                                 {
4362                                         pc->print(stderr,pc);
4363                                         fprintf(stderr, "ERROR: %s, branch instruction doesn't have label\n",__FUNCTION__);
4364                                 }
4365                         } else {
4366
4367                                 if( (pct = findLabelinpBlock(pb,pcol)) != NULL)
4368                                         LinkFlow_pCode(PCI(pc),PCI(pct));
4369                                 else
4370                                         fprintf(stderr, "ERROR: %s, couldn't find label. key=%d,lab=%s\n",
4371                                         __FUNCTION__,pcol->key,((PCOP(pcol)->name)?PCOP(pcol)->name:"-"));
4372                                 //fprintf(stderr,"newpCodeOpLabel: key=%d, name=%s\n",key,((s)?s:""));
4373                         }
4374                         /* link CALLs to next instruction */
4375                         if (PCI(pc)->op != POC_CALL) continue;
4376                 }
4377
4378                 if(isPCI(pc)) {
4379                         //fprintf(stderr, "ends with non-branching instruction:\n");
4380                         //pc->print(stderr,pc);
4381
4382                         LinkFlow_pCode(PCI(pc),PCI(findNextInstruction(pc->next)));
4383
4384                         continue;
4385                 }
4386
4387                 if(pc) {
4388                         //fprintf(stderr, "ends with unknown\n");
4389                         //pc->print(stderr,pc);
4390                         continue;
4391                 }
4392
4393                 fprintf(stderr, "ends with nothing: ERROR\n");
4394
4395         }
4396 }
4397 /*-----------------------------------------------------------------*/
4398 /*-----------------------------------------------------------------*/
4399
4400 /*-----------------------------------------------------------------*/
4401 /*-----------------------------------------------------------------*/
4402 int isPCinFlow(pCode *pc, pCode *pcflow)
4403 {
4404
4405         if(!pc || !pcflow)
4406                 return 0;
4407
4408         if(!isPCI(pc) || !PCI(pc)->pcflow || !isPCFL(pcflow) )
4409                 return 0;
4410
4411         if( PCI(pc)->pcflow->pc.seq == pcflow->seq)
4412                 return 1;
4413
4414         return 0;
4415 }
4416
4417 /*-----------------------------------------------------------------*/
4418 /*-----------------------------------------------------------------*/
4419 /*
4420 static void BanksUsedFlow2(pCode *pcflow)
4421 {
4422         pCode *pc=NULL;
4423
4424         int bank = -1;
4425         bool RegUsed = 0;
4426
4427         regs *reg;
4428
4429         if(!isPCFL(pcflow)) {
4430                 fprintf(stderr, "BanksUsed - pcflow is not a flow object ");
4431                 return;
4432         }
4433
4434         pc = findNextInstruction(pcflow->next);
4435
4436         PCFL(pcflow)->lastBank = -1;
4437
4438         while(isPCinFlow(pc,pcflow)) {
4439
4440                 int bank_selected = isBankInstruction(pc);
4441
4442                 //if(PCI(pc)->pcflow)
4443                 //fprintf(stderr,"BanksUsedFlow2, looking at seq %d\n",PCI(pc)->pcflow->pc.seq);
4444
4445                 if(bank_selected > 0) {
4446                         //fprintf(stderr,"BanksUsed - mucking with bank %d\n",bank_selected);
4447
4448                         // This instruction is modifying banking bits before accessing registers
4449                         if(!RegUsed)
4450                                 PCFL(pcflow)->firstBank = -1;
4451
4452                         if(PCFL(pcflow)->lastBank == -1)
4453                                 PCFL(pcflow)->lastBank = 0;
4454
4455                         bank = (1 << (bank_selected & (PIC_RP0_BIT | PIC_RP1_BIT)));
4456                         if(bank_selected & SET_BANK_BIT)
4457                                 PCFL(pcflow)->lastBank |= bank;
4458
4459
4460                 } else {
4461                         reg = getRegFromInstruction(pc);
4462
4463                         if(reg && !isREGinBank(reg, bank)) {
4464                                 int allbanks = REGallBanks(reg);
4465                                 if(bank == -1)
4466                                         PCFL(pcflow)->firstBank = allbanks;
4467
4468                                 PCFL(pcflow)->lastBank = allbanks;
4469
4470                                 bank = allbanks;
4471                         }
4472                         RegUsed = 1;
4473                                                                 }
4474
4475                 pc = findNextInstruction(pc->next);
4476         }
4477
4478         //  fprintf(stderr,"BanksUsedFlow2 flow seq=%3d, first bank = 0x%03x, Last bank 0x%03x\n",
4479         //    pcflow->seq,PCFL(pcflow)->firstBank,PCFL(pcflow)->lastBank);
4480 }
4481 */
4482 /*-----------------------------------------------------------------*/
4483 /*-----------------------------------------------------------------*/
4484 /*
4485 static void BanksUsedFlow(pBlock *pb)
4486 {
4487         pCode *pcflow;
4488
4489
4490         //pb->pcHead->print(stderr, pb->pcHead);
4491
4492         pcflow = findNextpCode(pb->pcHead, PC_FLOW);
4493         //pcflow->print(stderr,pcflow);
4494
4495         for( pcflow = findNextpCode(pb->pcHead, PC_FLOW);
4496         pcflow != NULL;
4497         pcflow = findNextpCode(pcflow->next, PC_FLOW) ) {
4498
4499                 BanksUsedFlow2(pcflow);
4500         }
4501
4502 }
4503 */
4504
4505 void pCodeReplace (pCode *old, pCode *new)
4506 {
4507         pCodeInsertAfter (old, new);
4508
4509         /* special handling for pCodeInstructions */
4510         if (isPCI(new) && isPCI(old))
4511         {
4512                 //assert (!PCI(new)->from && !PCI(new)->to && !PCI(new)->label && /*!PCI(new)->pcflow && */!PCI(new)->cline);
4513                 PCI(new)->from = PCI(old)->from;
4514                 PCI(new)->to = PCI(old)->to;
4515                 PCI(new)->label = PCI(old)->label;
4516                 PCI(new)->pcflow = PCI(old)->pcflow;
4517                 PCI(new)->cline = PCI(old)->cline;
4518         } // if
4519
4520         old->destruct (old);
4521 }
4522
4523 /*-----------------------------------------------------------------*/
4524 /*-----------------------------------------------------------------*/
4525 void addpCodeComment(pCode *pc, const char *fmt, ...)
4526 {
4527     va_list ap;
4528     char buffer[4096];
4529     pCode *newpc;
4530
4531     va_start(ap, fmt);
4532     if (options.verbose || debug_verbose) {
4533         buffer[0] = ';';
4534         buffer[1] = ' ';
4535         vsprintf(&buffer[2], fmt, ap);
4536
4537         newpc = newpCodeCharP(&buffer[0]); // strdup's the string
4538         pCodeInsertAfter(pc, newpc);
4539     }
4540     va_end(ap);
4541 }
4542
4543 void pBlockMergeLabels(pBlock *pb);
4544 /*-----------------------------------------------------------------*/
4545 /* Inserts a new pCodeInstruction before an existing one           */
4546 /*-----------------------------------------------------------------*/
4547 static void insertPCodeInstruction(pCodeInstruction *pci, pCodeInstruction *new_pci)
4548 {
4549         pCode *pcprev;
4550
4551         pcprev = findPrevInstruction(pci->pc.prev);
4552
4553         pCodeInsertAfter(pci->pc.prev, &new_pci->pc);
4554
4555         /* Move the label, if there is one */
4556
4557         if(pci->label) {
4558                 new_pci->label = pci->label;
4559                 pci->label = NULL;
4560         }
4561
4562         /* Move the C code comment, if there is one */
4563
4564         if(pci->cline) {
4565                 new_pci->cline = pci->cline;
4566                 pci->cline = NULL;
4567         }
4568
4569         /* The new instruction has the same pcflow block */
4570         new_pci->pcflow = pci->pcflow;
4571
4572         /* Arrrrg: is pci's previous instruction is a skip, we need to
4573          * change that into a jump (over pci and the new instruction) ... */
4574         if (pcprev && isPCI_SKIP(pcprev))
4575         {
4576                 symbol *lbl = newiTempLabel (NULL);
4577                 pCode *label = newpCodeLabel (NULL, lbl->key);
4578                 pCode *jump = newpCode(POC_GOTO, newpCodeOpLabel(NULL, lbl->key));
4579
4580                 pCodeInsertAfter (pcprev, jump);
4581
4582                 // Yuck: Cannot simply replace INCFSZ/INCFSZW/DECFSZ/DECFSZW
4583                 // We replace them with INCF/INCFW/DECF/DECFW followed by 'BTFSS STATUS, Z'
4584                 switch (PCI(pcprev)->op) {
4585                 case POC_INCFSZ:
4586                 case POC_INCFSZW:
4587                 case POC_DECFSZ:
4588                 case POC_DECFSZW:
4589                     // These are turned into non-skipping instructions, so
4590                     // insert 'BTFSC STATUS, Z' after pcprev
4591                     pCodeInsertAfter (jump->prev, newpCode(POC_BTFSC, popCopyGPR2Bit(PCOP(&pc_status), PIC_Z_BIT)));
4592                     break;
4593                 default:
4594                     // no special actions required
4595                     break;
4596                 }
4597                 pCodeReplace (pcprev, pCodeInstructionCopy (PCI(pcprev), 1));
4598                 pcprev = NULL;
4599                 pCodeInsertAfter((pCode*)pci, label);
4600                 pBlockMergeLabels(pci->pc.pb);
4601         }
4602 }
4603
4604 /*-----------------------------------------------------------------*/
4605 /*-----------------------------------------------------------------*/
4606 static void insertBankSel(pCodeInstruction  *pci, const char *name)
4607 {
4608         pCode *new_pc;
4609
4610         pCodeOp *pcop;
4611
4612         // Never BANKSEL STATUS, this breaks all kinds of code (e.g., interrupt handlers).
4613         if (!strcmp("STATUS", name) || !strcmp("_STATUS", name)) return;
4614
4615         pcop = popCopyReg(PCOR(pci->pcop));
4616         pcop->type = PO_GPR_REGISTER; // Sometimes the type is set to legacy 8051 - so override it
4617         if (pcop->name == 0)
4618                 pcop->name = strdup(name);
4619         new_pc = newpCode(POC_BANKSEL, pcop);
4620
4621         insertPCodeInstruction(pci, PCI(new_pc));
4622 }
4623
4624 /*-----------------------------------------------------------------*/
4625 /*-----------------------------------------------------------------*/
4626 static int sameBank(regs *reg, const char *new_bank, const char *cur_bank)
4627 {
4628     if (!cur_bank) return 0;
4629
4630     // identify '(regname + X)' and 'regname'
4631     if (reg && reg->name && reg->name[0] == '(' && !strncmp(&reg->name[1], cur_bank, strlen(cur_bank))) return 1;
4632     if (new_bank && new_bank[0] == '(' && !strncmp(&new_bank[1], cur_bank, strlen(cur_bank))) return 1;
4633     if (cur_bank[0] == '(' && reg && reg->name && !strncmp(reg->name, &cur_bank[1], strlen(reg->name))) return 1;
4634     if (cur_bank[0] == '(' && new_bank && !strncmp(new_bank, &cur_bank[1], strlen(new_bank))) return 1;
4635
4636     // XXX: identify '(regname + X)' and '(regname + Y)'
4637
4638     return ((reg && reg->name && !strcmp(reg->name, cur_bank)) || (new_bank && !strcmp(new_bank, cur_bank)));
4639 }
4640
4641 /*-----------------------------------------------------------------*/
4642 /*-----------------------------------------------------------------*/
4643 void FixRegisterBanking(pBlock *pb)
4644 {
4645     pCode *pc;
4646     pCodeInstruction *pci;
4647     regs *reg;
4648     const char *cur_bank, *new_bank;
4649     unsigned cur_mask, new_mask, max_mask;
4650     int allRAMmshared;
4651
4652     if (!pb) return;
4653
4654     max_mask = pic14_getPIC()->bankMask;
4655     cur_mask = max_mask;
4656     cur_bank = NULL;
4657
4658     allRAMmshared = pic14_allRAMShared();
4659
4660     for (pc = pb->pcHead; pc; pc = pc->next)
4661     {
4662         // this one has a label---might check bank at all jumps here...
4663         if (isPCI(pc) && (PCI(pc)->label || PCI(pc)->op == POC_CALL)) {
4664             addpCodeComment(pc->prev, "BANKOPT3 drop assumptions: PCI with label or call found");
4665             cur_bank = NULL; // start new flow
4666             cur_mask = max_mask;
4667         }
4668
4669         // this one is/might be a label or BANKSEL---assume nothing
4670         if (isPCL(pc) || isPCASMDIR(pc)) {
4671             addpCodeComment(pc->prev, "BANKOPT4 drop assumptions: label or ASMDIR found");
4672             cur_bank = NULL;
4673             cur_mask = max_mask;
4674         }
4675
4676         // this one modifies STATUS
4677         // XXX: this should be checked, but usually BANKSELs are not done this way in generated code
4678
4679         if (isPCI(pc)) {
4680             pci = PCI(pc);
4681             if ((pci->inCond | pci->outCond) & PCC_REGISTER) {
4682                 // might need a BANKSEL
4683                 reg = getRegFromInstruction(pc);
4684
4685                 if (reg) {
4686                     new_bank = reg->name;
4687                     // reg->alias == 0: reg is in only one bank, we do not know which (may be any bank)
4688                     // reg->alias != 0: reg is in 2/4/8/2**N banks, we select one of them
4689                     new_mask = reg->alias;
4690                 } else if (pci->pcop && pci->pcop->name) {
4691                     new_bank = pci->pcop->name;
4692                     new_mask = 0; // unknown, assume worst case
4693                 } else {
4694                     assert(!"Could not get register from instruction.");
4695                 }
4696
4697                 // optimizations...
4698                 // XXX: add switch to disable these
4699                 if (1) {
4700                     // reg present in all banks possibly selected?
4701                     if (new_mask == max_mask || (cur_mask && ((new_mask & cur_mask) == cur_mask))) {
4702                         // no BANKSEL required
4703                         addpCodeComment(pc->prev, "BANKOPT1 BANKSEL dropped; %s present in all of %s's banks", new_bank, cur_bank);
4704                         continue;
4705                     }
4706
4707                     // only one bank of memory and no SFR accessed?
4708                     // XXX: We can do better with fixed registers.
4709                     if (allRAMmshared && reg && (reg->type != REG_SFR) && (!reg->isFixed)) {
4710                         // no BANKSEL required
4711                         addpCodeComment(pc->prev, "BANKOPT1b BANKSEL dropped; %s present in all of %s's banks", new_bank, cur_bank);
4712                         continue;
4713                     }
4714
4715                     // restrict cur_mask to cover only the banks this register
4716                     // is in (as well as the previous registers)
4717                     cur_mask &= new_mask;
4718
4719                     if (sameBank(reg, new_bank, cur_bank)) {
4720                         // no BANKSEL required
4721                         addpCodeComment(pc->prev, "BANKOPT2 BANKSEL dropped; %s present in same bank as %s", new_bank, cur_bank);
4722                         continue;
4723                     }
4724                 } // if
4725
4726                 cur_mask = new_mask;
4727                 cur_bank = new_bank;
4728                 insertBankSel(pci, cur_bank);
4729             } // if
4730         } // if
4731     } // for
4732 }
4733
4734 /*-----------------------------------------------------------------*/
4735 /*-----------------------------------------------------------------*/
4736 int OptimizepBlock(pBlock *pb)
4737 {
4738         pCode *pc, *pcprev;
4739         int matches =0;
4740
4741         if(!pb || options.nopeep)
4742                 return 0;
4743
4744         DFPRINTF((stderr," Optimizing pBlock: %c\n",getpBlock_dbName(pb)));
4745         /*
4746         for(pc = pb->pcHead; pc; pc = pc->next)
4747         matches += pCodePeepMatchRule(pc);
4748         */
4749
4750         pc = findNextInstruction(pb->pcHead);
4751         if(!pc)
4752                 return 0;
4753
4754         pcprev = pc->prev;
4755         do {
4756
4757
4758                 if(pCodePeepMatchRule(pc)) {
4759
4760                         matches++;
4761
4762                         if(pcprev)
4763                                 pc = findNextInstruction(pcprev->next);
4764                         else
4765                                 pc = findNextInstruction(pb->pcHead);
4766                 } else
4767                         pc = findNextInstruction(pc->next);
4768         } while(pc);
4769
4770         if(matches)
4771                 DFPRINTF((stderr," Optimizing pBlock: %c - matches=%d\n",getpBlock_dbName(pb),matches));
4772         return matches;
4773
4774 }
4775
4776 /*-----------------------------------------------------------------*/
4777 /* pBlockRemoveUnusedLabels - remove the pCode labels from the     */
4778 /*-----------------------------------------------------------------*/
4779 pCode * findInstructionUsingLabel(pCodeLabel *pcl, pCode *pcs)
4780 {
4781   pCode *pc;
4782
4783   for(pc = pcs; pc; pc = pc->next) {
4784
4785     if(((pc->type == PC_OPCODE) || (pc->type == PC_INLINE) || (pc->type == PC_ASMDIR)) &&
4786       (PCI(pc)->pcop) &&
4787       (PCI(pc)->pcop->type == PO_LABEL) &&
4788       (PCOLAB(PCI(pc)->pcop)->key == pcl->key))
4789       return pc;
4790   }
4791
4792   return NULL;
4793 }
4794
4795 /*-----------------------------------------------------------------*/
4796 /*-----------------------------------------------------------------*/
4797 void exchangeLabels(pCodeLabel *pcl, pCode *pc)
4798 {
4799
4800         char *s=NULL;
4801
4802         if(isPCI(pc) &&
4803                 (PCI(pc)->pcop) &&
4804                 (PCI(pc)->pcop->type == PO_LABEL)) {
4805
4806                 pCodeOpLabel *pcol = PCOLAB(PCI(pc)->pcop);
4807
4808                 //fprintf(stderr,"changing label key from %d to %d\n",pcol->key, pcl->key);
4809                 if(pcol->pcop.name)
4810                         free(pcol->pcop.name);
4811
4812                         /* If the key is negative, then we (probably) have a label to
4813                 * a function and the name is already defined */
4814
4815                 if(pcl->key>0)
4816                         sprintf(s=buffer,"_%05d_DS_",pcl->key);
4817                 else
4818                         s = pcl->label;
4819
4820                 //sprintf(buffer,"_%05d_DS_",pcl->key);
4821                 if(!s) {
4822                         fprintf(stderr, "ERROR %s:%d function label is null\n",__FUNCTION__,__LINE__);
4823                 }
4824                 pcol->pcop.name = Safe_strdup(s);
4825                 pcol->key = pcl->key;
4826                 //pc->print(stderr,pc);
4827
4828         }
4829
4830
4831 }
4832
4833 /*-----------------------------------------------------------------*/
4834 /* pBlockRemoveUnusedLabels - remove the pCode labels from the     */
4835 /*                            pCode chain if they're not used.     */
4836 /*-----------------------------------------------------------------*/
4837 void pBlockRemoveUnusedLabels(pBlock *pb)
4838 {
4839         pCode *pc; pCodeLabel *pcl;
4840
4841         if(!pb)
4842                 return;
4843
4844         for(pc = pb->pcHead; (pc=findNextInstruction(pc->next)) != NULL; ) {
4845
4846                 pBranch *pbr = PCI(pc)->label;
4847                 if(pbr && pbr->next) {
4848                         pCode *pcd = pb->pcHead;
4849
4850                         //fprintf(stderr, "multiple labels\n");
4851                         //pc->print(stderr,pc);
4852
4853                         pbr = pbr->next;
4854                         while(pbr) {
4855
4856                                 while ( (pcd = findInstructionUsingLabel(PCL(PCI(pc)->label->pc), pcd)) != NULL) {
4857                                         //fprintf(stderr,"Used by:\n");
4858                                         //pcd->print(stderr,pcd);
4859
4860                                         exchangeLabels(PCL(pbr->pc),pcd);
4861
4862                                         pcd = pcd->next;
4863                                 }
4864                                 pbr = pbr->next;
4865                         }
4866                 }
4867         }
4868
4869         for(pc = pb->pcHead; pc; pc = pc->next) {
4870
4871                 if(isPCL(pc)) // Label pcode
4872                         pcl = PCL(pc);
4873                 else if (isPCI(pc) && PCI(pc)->label) // pcode instruction with a label
4874                         pcl = PCL(PCI(pc)->label->pc);
4875                 else continue;
4876
4877                 //fprintf(stderr," found  A LABEL !!! key = %d, %s\n", pcl->key,pcl->label);
4878
4879                 /* This pCode is a label, so search the pBlock to see if anyone
4880                 * refers to it */
4881
4882                 if( (pcl->key>0) && (!findInstructionUsingLabel(pcl, pb->pcHead))) {
4883                         //if( !findInstructionUsingLabel(pcl, pb->pcHead)) {
4884                         /* Couldn't find an instruction that refers to this label
4885                         * So, unlink the pCode label from it's pCode chain
4886                         * and destroy the label */
4887                         //fprintf(stderr," removed  A LABEL !!! key = %d, %s\n", pcl->key,pcl->label);
4888
4889                         DFPRINTF((stderr," !!! REMOVED A LABEL !!! key = %d, %s\n", pcl->key,pcl->label));
4890                         if(pc->type == PC_LABEL) {
4891                                 unlinkpCode(pc);
4892                                 pCodeLabelDestruct(pc);
4893                         } else {
4894                                 unlinkpCodeFromBranch(pc, PCODE(pcl));
4895                                 /*if(pc->label->next == NULL && pc->label->pc == NULL) {
4896                                 free(pc->label);
4897                         }*/
4898                         }
4899
4900                 }
4901         }
4902
4903 }
4904
4905
4906 /*-----------------------------------------------------------------*/
4907 /* pBlockMergeLabels - remove the pCode labels from the pCode      */
4908 /*                     chain and put them into pBranches that are  */
4909 /*                     associated with the appropriate pCode       */
4910 /*                     instructions.                               */
4911 /*-----------------------------------------------------------------*/
4912 void pBlockMergeLabels(pBlock *pb)
4913 {
4914         pBranch *pbr;
4915         pCode *pc, *pcnext=NULL;
4916
4917         if(!pb)
4918                 return;
4919
4920         /* First, Try to remove any unused labels */
4921         //pBlockRemoveUnusedLabels(pb);
4922
4923         /* Now loop through the pBlock and merge the labels with the opcodes */
4924
4925         pc = pb->pcHead;
4926         //  for(pc = pb->pcHead; pc; pc = pc->next) {
4927
4928         while(pc) {
4929                 pCode *pcn = pc->next;
4930
4931                 if(pc->type == PC_LABEL) {
4932
4933                         //fprintf(stderr," checking merging label %s\n",PCL(pc)->label);
4934                         //fprintf(stderr,"Checking label key = %d\n",PCL(pc)->key);
4935                         if((pcnext = findNextInstruction(pc) )) {
4936
4937                                 // Unlink the pCode label from it's pCode chain
4938                                 unlinkpCode(pc);
4939
4940                                 //fprintf(stderr,"Merged label key = %d\n",PCL(pc)->key);
4941                                 // And link it into the instruction's pBranch labels. (Note, since
4942                                 // it's possible to have multiple labels associated with one instruction
4943                                 // we must provide a means to accomodate the additional labels. Thus
4944                                 // the labels are placed into the singly-linked list "label" as
4945                                 // opposed to being a single member of the pCodeInstruction.)
4946
4947                                 //_ALLOC(pbr,sizeof(pBranch));
4948                                 pbr = Safe_calloc(1,sizeof(pBranch));
4949                                 pbr->pc = pc;
4950                                 pbr->next = NULL;
4951
4952                                 PCI(pcnext)->label = pBranchAppend(PCI(pcnext)->label,pbr);
4953
4954                         } else {
4955                                 fprintf(stderr, "WARNING: couldn't associate label %s with an instruction\n",PCL(pc)->label);
4956                         }
4957                 } else if(pc->type == PC_CSOURCE) {
4958
4959                         /* merge the source line symbolic info into the next instruction */
4960                         if((pcnext = findNextInstruction(pc) )) {
4961
4962                                 // Unlink the pCode label from it's pCode chain
4963                                 unlinkpCode(pc);
4964                                 PCI(pcnext)->cline = PCCS(pc);
4965                                 //fprintf(stderr, "merging CSRC\n");
4966                                 //genericPrint(stderr,pcnext);
4967                         }
4968
4969                 }
4970                 pc = pcn;
4971         }
4972         pBlockRemoveUnusedLabels(pb);
4973
4974 }
4975
4976 /*-----------------------------------------------------------------*/
4977 /*-----------------------------------------------------------------*/
4978 int OptimizepCode(char dbName)
4979 {
4980 #define MAX_PASSES 4
4981
4982         int matches = 0;
4983         int passes = 0;
4984         pBlock *pb;
4985
4986         if(!the_pFile)
4987                 return 0;
4988
4989         DFPRINTF((stderr," Optimizing pCode\n"));
4990
4991         do {
4992                 matches = 0;
4993                 for(pb = the_pFile->pbHead; pb; pb = pb->next) {
4994                         if('*' == dbName || getpBlock_dbName(pb) == dbName)
4995                                 matches += OptimizepBlock(pb);
4996                 }
4997         }
4998         while(matches && ++passes < MAX_PASSES);
4999
5000         return matches;
5001 }
5002
5003 /*-----------------------------------------------------------------*/
5004 /* popCopyGPR2Bit - copy a pcode operator                          */
5005 /*-----------------------------------------------------------------*/
5006
5007 pCodeOp *popCopyGPR2Bit(pCodeOp *pc, int bitval)
5008 {
5009         pCodeOp *pcop;
5010
5011         pcop = newpCodeOpBit(pc->name, bitval, 0);
5012
5013         if( !( (pcop->type == PO_LABEL) ||
5014                 (pcop->type == PO_LITERAL) ||
5015                 (pcop->type == PO_STR) ))
5016                 PCOR(pcop)->r = PCOR(pc)->r;  /* This is dangerous... */
5017
5018         return pcop;
5019 }
5020
5021 /*-----------------------------------------------------------------*/
5022 /*-----------------------------------------------------------------*/
5023 void pBlockDestruct(pBlock *pb)
5024 {
5025
5026         if(!pb)
5027                 return;
5028
5029
5030         free(pb);
5031
5032 }
5033
5034 /*-----------------------------------------------------------------*/
5035 /* void mergepBlocks(char dbName) - Search for all pBlocks with the*/
5036 /*                                  name dbName and combine them   */
5037 /*                                  into one block                 */
5038 /*-----------------------------------------------------------------*/
5039 void mergepBlocks(char dbName)
5040 {
5041
5042         pBlock *pb, *pbmerged = NULL,*pbn;
5043
5044         pb = the_pFile->pbHead;
5045
5046         //fprintf(stderr," merging blocks named %c\n",dbName);
5047         while(pb) {
5048
5049                 pbn = pb->next;
5050                 //fprintf(stderr,"looking at %c\n",getpBlock_dbName(pb));
5051                 if( getpBlock_dbName(pb) == dbName) {
5052
5053                         //fprintf(stderr," merged block %c\n",dbName);
5054
5055                         if(!pbmerged) {
5056                                 pbmerged = pb;
5057                         } else {
5058                                 addpCode2pBlock(pbmerged, pb->pcHead);
5059                                 /* addpCode2pBlock doesn't handle the tail: */
5060                                 pbmerged->pcTail = pb->pcTail;
5061
5062                                 pb->prev->next = pbn;
5063                                 if(pbn)
5064                                         pbn->prev = pb->prev;
5065
5066
5067                                 pBlockDestruct(pb);
5068                         }
5069                         //printpBlock(stderr, pbmerged);
5070                 }
5071                 pb = pbn;
5072         }
5073
5074 }
5075
5076 /*-----------------------------------------------------------------*/
5077 /* AnalyzeFlow - Examine the flow of the code and optimize         */
5078 /*                                                                 */
5079 /* level 0 == minimal optimization                                 */
5080 /*   optimize registers that are used only by two instructions     */
5081 /* level 1 == maximal optimization                                 */
5082 /*   optimize by looking at pairs of instructions that use the     */
5083 /*   register.                                                     */
5084 /*-----------------------------------------------------------------*/
5085
5086 void AnalyzeFlow(int level)
5087 {
5088         static int times_called=0;
5089
5090         pBlock *pb;
5091
5092         if(!the_pFile)
5093                 return;
5094
5095
5096                 /* if this is not the first time this function has been called,
5097         then clean up old flow information */
5098         if(times_called++) {
5099                 for(pb = the_pFile->pbHead; pb; pb = pb->next)
5100                         unBuildFlow(pb);
5101
5102                 RegsUnMapLiveRanges();
5103
5104         }
5105
5106         GpcFlowSeq = 1;
5107
5108         /* Phase 2 - Flow Analysis - Register Banking
5109         *
5110         * In this phase, the individual flow blocks are examined
5111         * and register banking is fixed.
5112         */
5113
5114         //for(pb = the_pFile->pbHead; pb; pb = pb->next)
5115         //FixRegisterBanking(pb);
5116
5117         /* Phase 2 - Flow Analysis
5118         *
5119         * In this phase, the pCode is partition into pCodeFlow
5120         * blocks. The flow blocks mark the points where a continuous
5121         * stream of instructions changes flow (e.g. because of
5122         * a call or goto or whatever).
5123         */
5124
5125         for(pb = the_pFile->pbHead; pb; pb = pb->next)
5126                 BuildFlow(pb);
5127
5128
5129                 /* Phase 2 - Flow Analysis - linking flow blocks
5130                 *
5131                 * In this phase, the individual flow blocks are examined
5132                 * to determine their order of excution.
5133         */
5134
5135         for(pb = the_pFile->pbHead; pb; pb = pb->next)
5136                 LinkFlow(pb);
5137
5138                 /* Phase 3 - Flow Analysis - Flow Tree
5139                 *
5140                 * In this phase, the individual flow blocks are examined
5141                 * to determine their order of excution.
5142         */
5143
5144         for(pb = the_pFile->pbHead; pb; pb = pb->next)
5145                 BuildFlowTree(pb);
5146
5147
5148                 /* Phase x - Flow Analysis - Used Banks
5149                 *
5150                 * In this phase, the individual flow blocks are examined
5151                 * to determine the Register Banks they use
5152         */
5153
5154         //  for(pb = the_pFile->pbHead; pb; pb = pb->next)
5155         //    FixBankFlow(pb);
5156
5157
5158         for(pb = the_pFile->pbHead; pb; pb = pb->next)
5159                 pCodeRegMapLiveRanges(pb);
5160
5161         RemoveUnusedRegisters();
5162
5163         //  for(pb = the_pFile->pbHead; pb; pb = pb->next)
5164         pCodeRegOptimizeRegUsage(level);
5165
5166         OptimizepCode('*');
5167
5168         /*
5169         for(pb = the_pFile->pbHead; pb; pb = pb->next)
5170         DumpFlow(pb);
5171         */
5172         /* debug stuff */
5173         /*
5174         for(pb = the_pFile->pbHead; pb; pb = pb->next) {
5175     pCode *pcflow;
5176     for( pcflow = findNextpCode(pb->pcHead, PC_FLOW);
5177     (pcflow = findNextpCode(pcflow, PC_FLOW)) != NULL;
5178     pcflow = pcflow->next) {
5179
5180           FillFlow(PCFL(pcflow));
5181           }
5182           }
5183         */
5184         /*
5185         for(pb = the_pFile->pbHead; pb; pb = pb->next) {
5186     pCode *pcflow;
5187     for( pcflow = findNextpCode(pb->pcHead, PC_FLOW);
5188     (pcflow = findNextpCode(pcflow, PC_FLOW)) != NULL;
5189     pcflow = pcflow->next) {
5190
5191           FlowStats(PCFL(pcflow));
5192           }
5193           }
5194         */
5195 }
5196
5197 /*-----------------------------------------------------------------*/
5198 /* AnalyzeBanking - Called after the memory addresses have been    */
5199 /*                  assigned to the registers.                     */
5200 /*                                                                 */
5201 /*-----------------------------------------------------------------*/
5202
5203 void AnalyzeBanking(void)
5204 {
5205         pBlock  *pb;
5206
5207         if(!picIsInitialized()) {
5208                 werror(E_FILE_OPEN_ERR, "no memory size is known for this processor");
5209                 exit(1);
5210         }
5211
5212         if (!the_pFile) return;
5213
5214         /* Phase x - Flow Analysis - Used Banks
5215         *
5216         * In this phase, the individual flow blocks are examined
5217         * to determine the Register Banks they use
5218         */
5219
5220         AnalyzeFlow(0);
5221         AnalyzeFlow(1);
5222
5223         //  for(pb = the_pFile->pbHead; pb; pb = pb->next)
5224         //    BanksUsedFlow(pb);
5225         for(pb = the_pFile->pbHead; pb; pb = pb->next)
5226                 FixRegisterBanking(pb);
5227
5228         AnalyzeFlow(0);
5229         AnalyzeFlow(1);
5230
5231 }
5232
5233 /*-----------------------------------------------------------------*/
5234 /*-----------------------------------------------------------------*/
5235 DEFSETFUNC (resetrIdx)
5236 {
5237         regs *r = (regs *)item;
5238         if (!r->isFixed) {
5239                 r->rIdx = 0;
5240         }
5241
5242         return 0;
5243 }
5244
5245 /*-----------------------------------------------------------------*/
5246 /* InitRegReuse - Initialises variables for code analyzer          */
5247 /*-----------------------------------------------------------------*/
5248
5249 void InitReuseReg(void)
5250 {
5251         /* Find end of statically allocated variables for start idx */
5252         /* Start from begining of GPR. Note may not be 0x20 on some PICs */
5253         /* XXX: Avoid clashes with fixed registers, start late. */
5254         unsigned maxIdx = 0x1000;
5255         regs *r;
5256         for (r = setFirstItem(dynDirectRegs); r; r = setNextItem(dynDirectRegs)) {
5257                 if (r->type != REG_SFR) {
5258                         maxIdx += r->size; /* Increment for all statically allocated variables */
5259                 }
5260         }
5261         peakIdx = maxIdx;
5262         applyToSet(dynAllocRegs,resetrIdx); /* Reset all rIdx to zero. */
5263 }
5264
5265 /*-----------------------------------------------------------------*/
5266 /*-----------------------------------------------------------------*/
5267 static unsigned register_reassign(pBlock *pb, unsigned idx)
5268 {
5269         pCode *pc;
5270
5271         /* check recursion */
5272         pc = setFirstItem(pb->function_entries);
5273         if(!pc)
5274                 return idx;
5275
5276         pb->visited = 1;
5277
5278         DFPRINTF((stderr," reassigning registers for function \"%s\"\n",PCF(pc)->fname));
5279
5280         if (pb->tregisters) {
5281                 regs *r;
5282                 for (r = setFirstItem(pb->tregisters); r; r = setNextItem(pb->tregisters)) {
5283                         if (r->type == REG_GPR) {
5284                                 if (!r->isFixed) {
5285                                         if (r->rIdx < (int)idx) {
5286                                                 char s[20];
5287                                                 r->rIdx = idx++;
5288                                                 if (peakIdx < idx) peakIdx = idx;
5289                                                 sprintf(s,"r0x%02X", r->rIdx);
5290                                                 DFPRINTF((stderr," reassigning register \"%s\" to \"%s\"\n",r->name,s));
5291                                                 free(r->name);
5292                                                 r->name = Safe_strdup(s);
5293                                         }
5294                                 }
5295                         }
5296                 }
5297         }
5298         for(pc = setFirstItem(pb->function_calls); pc; pc = setNextItem(pb->function_calls)) {
5299
5300                 if(pc->type == PC_OPCODE && PCI(pc)->op == POC_CALL) {
5301                         char *dest = get_op_from_instruction(PCI(pc));
5302
5303                         pCode *pcn = findFunction(dest);
5304                         if(pcn) {
5305                                 register_reassign(pcn->pb,idx);
5306                         }
5307                 }
5308
5309         }
5310
5311         return idx;
5312 }
5313
5314 /*------------------------------------------------------------------*/
5315 /* ReuseReg were call tree permits                                  */
5316 /*                                                                  */
5317 /*  Re-allocate the GPR for optimum reuse for a given pblock        */
5318 /*  eg  if a function m() calls function f1() and f2(), where f1    */
5319 /*  allocates a local variable vf1 and f2 allocates a local         */
5320 /*  variable vf2. Then providing f1 and f2 do not call each other   */
5321 /*  they may share the same general purpose registers for vf1 and   */
5322 /*  vf2.                                                            */
5323 /*  This is done by first setting the the regs rIdx to start after  */
5324 /*  all the global variables, then walking through the call tree    */
5325 /*  renaming the registers to match their new idx and incrementng   */
5326 /*  it as it goes. If a function has already been called it will    */
5327 /*  only rename the registers if it has already used up those       */
5328 /*  registers ie rIdx of the function's registers is lower than the */
5329 /*  current rIdx. That way the register will not be reused while    */
5330 /*  still being used by an eariler function call.                   */
5331 /*                                                                  */
5332 /*  Note for this to work the functions need to be declared static. */
5333 /*                                                                  */
5334 /*------------------------------------------------------------------*/
5335 void ReuseReg(void)
5336 {
5337         pBlock  *pb;
5338         if (!the_pFile) return;
5339         InitReuseReg();
5340         for(pb = the_pFile->pbHead; pb; pb = pb->next) {
5341                 /* Non static functions can be called from other modules so their registers must reassign */
5342                 if (pb->function_entries&&(PCF(setFirstItem(pb->function_entries))->isPublic||!pb->visited))
5343                         register_reassign(pb,peakIdx);
5344         }
5345 }
5346
5347 /*-----------------------------------------------------------------*/
5348 /* buildCallTree - look at the flow and extract all of the calls   */
5349 /*                                                                 */
5350 /*-----------------------------------------------------------------*/
5351
5352 void buildCallTree(void    )
5353 {
5354         pBranch *pbr;
5355         pBlock  *pb;
5356         pCode   *pc;
5357
5358         if(!the_pFile)
5359                 return;
5360
5361                 /* Now build the call tree.
5362                 First we examine all of the pCodes for functions.
5363                 Keep in mind that the function boundaries coincide
5364                 with pBlock boundaries.
5365
5366                   The algorithm goes something like this:
5367                   We have two nested loops. The outer loop iterates
5368                   through all of the pBlocks/functions. The inner
5369                   loop iterates through all of the pCodes for
5370                   a given pBlock. When we begin iterating through
5371                   a pBlock, the variable pc_fstart, pCode of the start
5372                   of a function, is cleared. We then search for pCodes
5373                   of type PC_FUNCTION. When one is encountered, we
5374                   initialize pc_fstart to this and at the same time
5375                   associate a new pBranch object that signifies a
5376                   branch entry. If a return is found, then this signifies
5377                   a function exit point. We'll link the pCodes of these
5378                   returns to the matching pc_fstart.
5379
5380                         When we're done, a doubly linked list of pBranches
5381                         will exist. The head of this list is stored in
5382                         `the_pFile', which is the meta structure for all
5383                         of the pCode. Look at the printCallTree function
5384                         on how the pBranches are linked together.
5385
5386         */
5387         for(pb = the_pFile->pbHead; pb; pb = pb->next) {
5388                 pCode *pc_fstart=NULL;
5389                 for(pc = pb->pcHead; pc; pc = pc->next) {
5390                         if(isPCF(pc)) {
5391                                 pCodeFunction *pcf = PCF(pc);
5392                                 if (pcf->fname) {
5393
5394                                         if(STRCASECMP(pcf->fname, "_main") == 0) {
5395                                                 //fprintf(stderr," found main \n");
5396                                                 pb->cmemmap = NULL;  /* FIXME do we need to free ? */
5397                                                 pb->dbName = 'M';
5398                                         }
5399
5400                                         pbr = Safe_calloc(1,sizeof(pBranch));
5401                                         pbr->pc = pc_fstart = pc;
5402                                         pbr->next = NULL;
5403
5404                                         the_pFile->functions = pBranchAppend(the_pFile->functions,pbr);
5405
5406                                         // Here's a better way of doing the same:
5407                                         addSet(&pb->function_entries, pc);
5408
5409                                 } else {
5410                                         // Found an exit point in a function, e.g. return
5411                                         // (Note, there may be more than one return per function)
5412                                         if(pc_fstart)
5413                                                 pBranchLink(PCF(pc_fstart), pcf);
5414
5415                                         addSet(&pb->function_exits, pc);
5416                                 }
5417                         } else if(isCALL(pc)) {
5418                                 addSet(&pb->function_calls,pc);
5419                         }
5420                 }
5421         }
5422 }
5423
5424 /*-----------------------------------------------------------------*/
5425 /* AnalyzepCode - parse the pCode that has been generated and form */
5426 /*                all of the logical connections.                  */
5427 /*                                                                 */
5428 /* Essentially what's done here is that the pCode flow is          */
5429 /* determined.                                                     */
5430 /*-----------------------------------------------------------------*/
5431
5432 void AnalyzepCode(char dbName)
5433 {
5434         pBlock *pb;
5435         int i,changes;
5436
5437         if(!the_pFile)
5438                 return;
5439
5440         mergepBlocks('D');
5441
5442
5443         /* Phase 1 - Register allocation and peep hole optimization
5444         *
5445         * The first part of the analysis is to determine the registers
5446         * that are used in the pCode. Once that is done, the peep rules
5447         * are applied to the code. We continue to loop until no more
5448         * peep rule optimizations are found (or until we exceed the
5449         * MAX_PASSES threshold).
5450         *
5451         * When done, the required registers will be determined.
5452         *
5453         */
5454         i = 0;
5455         do {
5456
5457                 DFPRINTF((stderr," Analyzing pCode: PASS #%d\n",i+1));
5458
5459                 /* First, merge the labels with the instructions */
5460                 for(pb = the_pFile->pbHead; pb; pb = pb->next) {
5461                         if('*' == dbName || getpBlock_dbName(pb) == dbName) {
5462
5463                                 DFPRINTF((stderr," analyze and merging block %c\n",dbName));
5464                                 pBlockMergeLabels(pb);
5465                                 AnalyzepBlock(pb);
5466                         } else {
5467                                 DFPRINTF((stderr," skipping block analysis dbName=%c blockname=%c\n",dbName,getpBlock_dbName(pb)));
5468                         }
5469                 }
5470
5471                 changes = OptimizepCode(dbName);
5472
5473         } while(changes && (i++ < MAX_PASSES));
5474
5475         buildCallTree();
5476 }
5477
5478 /*-----------------------------------------------------------------*/
5479 /* ispCodeFunction - returns true if *pc is the pCode of a         */
5480 /*                   function                                      */
5481 /*-----------------------------------------------------------------*/
5482 bool ispCodeFunction(pCode *pc)
5483 {
5484
5485         if(pc && pc->type == PC_FUNCTION && PCF(pc)->fname)
5486                 return 1;
5487
5488         return 0;
5489 }
5490
5491 /*-----------------------------------------------------------------*/
5492 /* findFunction - Search for a function by name (given the name)   */
5493 /*                in the set of all functions that are in a pBlock */
5494 /* (note - I expect this to change because I'm planning to limit   */
5495 /*  pBlock's to just one function declaration                      */
5496 /*-----------------------------------------------------------------*/
5497 pCode *findFunction(char *fname)
5498 {
5499         pBlock *pb;
5500         pCode *pc;
5501         if(!fname)
5502                 return NULL;
5503
5504         for(pb = the_pFile->pbHead; pb; pb = pb->next) {
5505
5506                 pc = setFirstItem(pb->function_entries);
5507                 while(pc) {
5508
5509                         if((pc->type == PC_FUNCTION) &&
5510                                 (PCF(pc)->fname) &&
5511                                 (strcmp(fname, PCF(pc)->fname)==0))
5512                                 return pc;
5513
5514                         pc = setNextItem(pb->function_entries);
5515
5516                 }
5517
5518         }
5519         return NULL;
5520 }
5521
5522 void MarkUsedRegisters(set *regset)
5523 {
5524
5525         regs *r1,*r2;
5526
5527         for(r1=setFirstItem(regset); r1; r1=setNextItem(regset)) {
5528                 r2 = pic14_regWithIdx(r1->rIdx);
5529                 if (r2) {
5530                         r2->isFree = 0;
5531                         r2->wasUsed = 1;
5532                 }
5533         }
5534 }
5535
5536 void pBlockStats(FILE *of, pBlock *pb)
5537 {
5538
5539         pCode *pc;
5540         regs  *r;
5541
5542         fprintf(of,";***\n;  pBlock Stats: dbName = %c\n;***\n",getpBlock_dbName(pb));
5543
5544         // for now just print the first element of each set
5545         pc = setFirstItem(pb->function_entries);
5546         if(pc) {
5547                 fprintf(of,";entry:  ");
5548                 pc->print(of,pc);
5549         }
5550         pc = setFirstItem(pb->function_exits);
5551         if(pc) {
5552                 fprintf(of,";has an exit\n");
5553                 //pc->print(of,pc);
5554         }
5555
5556         pc = setFirstItem(pb->function_calls);
5557         if(pc) {
5558                 fprintf(of,";functions called:\n");
5559
5560                 while(pc) {
5561                         if(pc->type == PC_OPCODE && PCI(pc)->op == POC_CALL) {
5562                                 fprintf(of,";   %s\n",get_op_from_instruction(PCI(pc)));
5563                         }
5564                         pc = setNextItem(pb->function_calls);
5565                 }
5566         }
5567
5568         r = setFirstItem(pb->tregisters);
5569         if(r) {
5570                 int n = elementsInSet(pb->tregisters);
5571
5572                 fprintf(of,";%d compiler assigned register%c:\n",n, ( (n!=1) ? 's' : ' '));
5573
5574                 while (r) {
5575                         fprintf(of,";   %s\n",r->name);
5576                         r = setNextItem(pb->tregisters);
5577                 }
5578         }
5579 }
5580
5581 /*-----------------------------------------------------------------*/
5582 /*-----------------------------------------------------------------*/
5583 #if 0
5584 static void sequencepCode(void)
5585 {
5586         pBlock *pb;
5587         pCode *pc;
5588
5589
5590         for(pb = the_pFile->pbHead; pb; pb = pb->next) {
5591
5592                 pb->seq = GpCodeSequenceNumber+1;
5593
5594                 for( pc = pb->pcHead; pc; pc = pc->next)
5595                         pc->seq = ++GpCodeSequenceNumber;
5596         }
5597
5598 }
5599 #endif
5600
5601 /*-----------------------------------------------------------------*/
5602 /*-----------------------------------------------------------------*/
5603 /*
5604 set *register_usage(pBlock *pb)
5605 {
5606         pCode *pc,*pcn;
5607         set *registers=NULL;
5608         set *registersInCallPath = NULL;
5609
5610         / * check recursion * /
5611
5612                 pc = setFirstItem(pb->function_entries);
5613
5614         if(!pc)
5615                 return registers;
5616
5617         pb->visited = 1;
5618
5619         if(pc->type != PC_FUNCTION)
5620                 fprintf(stderr,"%s, first pc is not a function???\n",__FUNCTION__);
5621
5622         pc = setFirstItem(pb->function_calls);
5623         for( ; pc; pc = setNextItem(pb->function_calls)) {
5624
5625                 if(pc->type == PC_OPCODE && PCI(pc)->op == POC_CALL) {
5626                         char *dest = get_op_from_instruction(PCI(pc));
5627
5628                         pcn = findFunction(dest);
5629                         if(pcn)
5630                                 registersInCallPath = register_usage(pcn->pb);
5631                 } else
5632                         fprintf(stderr,"BUG? pCode isn't a POC_CALL %d\n",__LINE__);
5633
5634         }
5635
5636 #ifdef PCODE_DEBUG
5637         pBlockStats(stderr,pb);  // debug
5638 #endif
5639
5640         // Mark the registers in this block as used.
5641
5642         MarkUsedRegisters(pb->tregisters);
5643         if(registersInCallPath) {
5644                 / * registers were used in the functions this pBlock has called * /
5645                 / * so now, we need to see if these collide with the ones we are * /
5646                 / * using here * /
5647
5648                         regs *r1,*r2, *newreg;
5649
5650                 DFPRINTF((stderr,"comparing registers\n"));
5651
5652                 r1 = setFirstItem(registersInCallPath);
5653                 while(r1) {
5654                         if (r1->type != REG_STK) {
5655                                 r2 = setFirstItem(pb->tregisters);
5656
5657                                 while(r2 && (r2->type != REG_STK)) {
5658
5659                                         if(r2->rIdx == r1->rIdx) {
5660                                                 newreg = pic14_findFreeReg(REG_GPR);
5661
5662
5663                                                 if(!newreg) {
5664                                                         DFPRINTF((stderr,"Bummer, no more registers.\n"));
5665                                                         exit(1);
5666                                                 }
5667
5668                                                 DFPRINTF((stderr,"Cool found register collision nIdx=%d moving to %d\n",
5669                                                         r1->rIdx, newreg->rIdx));
5670                                                 r2->rIdx = newreg->rIdx;
5671                                                 if(newreg->name)
5672                                                         r2->name = Safe_strdup(newreg->name);
5673                                                 else
5674                                                         r2->name = NULL;
5675                                                 newreg->isFree = 0;
5676                                                 newreg->wasUsed = 1;
5677                                         }
5678                                         r2 = setNextItem(pb->tregisters);
5679                                 }
5680                         }
5681
5682                         r1 = setNextItem(registersInCallPath);
5683                 }
5684
5685                 / * Collisions have been resolved. Now free the registers in the call path * /
5686                 r1 = setFirstItem(registersInCallPath);
5687                 while(r1) {
5688                         newreg = pic14_regWithIdx(r1->rIdx);
5689                         if (newreg) newreg->isFree = 1;
5690                         r1 = setNextItem(registersInCallPath);
5691                 }
5692
5693         }// else
5694         //      MarkUsedRegisters(pb->registers);
5695
5696         registers = unionSets(pb->tregisters, registersInCallPath, THROW_NONE);
5697 #ifdef PCODE_DEBUG
5698         if(registers)
5699                 DFPRINTF((stderr,"returning regs\n"));
5700         else
5701                 DFPRINTF((stderr,"not returning regs\n"));
5702
5703         DFPRINTF((stderr,"pBlock after register optim.\n"));
5704         pBlockStats(stderr,pb);  // debug
5705 #endif
5706
5707         return registers;
5708 }
5709 */
5710
5711 /*-----------------------------------------------------------------*/
5712 /* printCallTree - writes the call tree to a file                  */
5713 /*                                                                 */
5714 /*-----------------------------------------------------------------*/
5715 void pct2(FILE *of,pBlock *pb,int indent)
5716 {
5717         pCode *pc,*pcn;
5718         int i;
5719         //  set *registersInCallPath = NULL;
5720
5721         if(!of)
5722                 return;
5723
5724         if(indent > 10)
5725                 return; //recursion ?
5726
5727         pc = setFirstItem(pb->function_entries);
5728
5729         if(!pc)
5730                 return;
5731
5732         pb->visited = 0;
5733
5734         for(i=0;i<indent;i++)   // Indentation
5735                 fputc(' ',of);
5736
5737         if(pc->type == PC_FUNCTION)
5738                 fprintf(of,"%s\n",PCF(pc)->fname);
5739         else
5740                 return;  // ???
5741
5742
5743         pc = setFirstItem(pb->function_calls);
5744         for( ; pc; pc = setNextItem(pb->function_calls)) {
5745
5746                 if(pc->type == PC_OPCODE && PCI(pc)->op == POC_CALL) {
5747                         char *dest = get_op_from_instruction(PCI(pc));
5748
5749                         pcn = findFunction(dest);
5750                         if(pcn)
5751                                 pct2(of,pcn->pb,indent+1);
5752                 } else
5753                         fprintf(of,"BUG? pCode isn't a POC_CALL %d\n",__LINE__);
5754
5755         }
5756
5757
5758 }
5759
5760
5761 /*-----------------------------------------------------------------*/
5762 /* printCallTree - writes the call tree to a file                  */
5763 /*                                                                 */
5764 /*-----------------------------------------------------------------*/
5765
5766 void printCallTree(FILE *of)
5767 {
5768         pBranch *pbr;
5769         pBlock  *pb;
5770         pCode   *pc;
5771
5772         if(!the_pFile)
5773                 return;
5774
5775         if(!of)
5776                 of = stderr;
5777
5778         fprintf(of, "\npBlock statistics\n");
5779         for(pb = the_pFile->pbHead; pb;  pb = pb->next )
5780                 pBlockStats(of,pb);
5781
5782
5783
5784         fprintf(of,"Call Tree\n");
5785         pbr = the_pFile->functions;
5786         while(pbr) {
5787                 if(pbr->pc) {
5788                         pc = pbr->pc;
5789                         if(!ispCodeFunction(pc))
5790                                 fprintf(of,"bug in call tree");
5791
5792
5793                         fprintf(of,"Function: %s\n", PCF(pc)->fname);
5794
5795                         while(pc->next && !ispCodeFunction(pc->next)) {
5796                                 pc = pc->next;
5797                                 if(pc->type == PC_OPCODE && PCI(pc)->op == POC_CALL)
5798                                         fprintf(of,"\t%s\n",get_op_from_instruction(PCI(pc)));
5799                         }
5800                 }
5801
5802                 pbr = pbr->next;
5803         }
5804
5805
5806         fprintf(of,"\n**************\n\na better call tree\n");
5807         for(pb = the_pFile->pbHead; pb; pb = pb->next) {
5808                 if(pb->visited)
5809                         pct2(of,pb,0);
5810         }
5811
5812         for(pb = the_pFile->pbHead; pb; pb = pb->next) {
5813                 fprintf(of,"block dbname: %c\n", getpBlock_dbName(pb));
5814         }
5815 }
5816
5817
5818
5819 /*-----------------------------------------------------------------*/
5820 /*                                                                 */
5821 /*-----------------------------------------------------------------*/
5822
5823 void InlineFunction(pBlock *pb)
5824 {
5825         pCode *pc;
5826         pCode *pc_call;
5827
5828         if(!pb)
5829                 return;
5830
5831         pc = setFirstItem(pb->function_calls);
5832
5833         for( ; pc; pc = setNextItem(pb->function_calls)) {
5834
5835                 if(isCALL(pc)) {
5836                         pCode *pcn = findFunction(get_op_from_instruction(PCI(pc)));
5837                         pCode *pcp = pc->prev;
5838                         pCode *pct;
5839                         pCode *pce;
5840
5841                         pBranch *pbr;
5842
5843                         if(pcn && isPCF(pcn) && (PCF(pcn)->ncalled == 1) && !PCF(pcn)->isPublic && (pcp && (isPCI_BITSKIP(pcp)||!isPCI_SKIP(pcp)))) { /* Bit skips can be inverted other skips can not */
5844
5845                                 InlineFunction(pcn->pb);
5846
5847                                 /*
5848                                 At this point, *pc points to a CALL mnemonic, and
5849                                 *pcn points to the function that is being called.
5850
5851                                   To in-line this call, we need to remove the CALL
5852                                   and RETURN(s), and link the function pCode in with
5853                                   the CALLee pCode.
5854
5855                                 */
5856
5857                                 pc_call = pc;
5858
5859                                 /* Check if previous instruction was a bit skip */
5860                                 if (isPCI_BITSKIP(pcp)) {
5861                                         pCodeLabel *pcl;
5862                                         /* Invert skip instruction and add a goto */
5863                                         PCI(pcp)->op = (PCI(pcp)->op == POC_BTFSS) ? POC_BTFSC : POC_BTFSS;
5864
5865                                         if(isPCL(pc_call->next)) { // Label pcode
5866                                                 pcl = PCL(pc_call->next);
5867                                         } else if (isPCI(pc_call->next) && PCI(pc_call->next)->label) { // pcode instruction with a label
5868                                                 pcl = PCL(PCI(pc_call->next)->label->pc);
5869                                         } else {
5870                                                 pcl = PCL(newpCodeLabel(NULL, newiTempLabel(NULL)->key+100));
5871                                                 PCI(pc_call->next)->label->pc = (struct pCode*)pcl;
5872                                         }
5873                                         pCodeInsertAfter(pcp, newpCode(POC_GOTO, newpCodeOp(pcl->label,PO_STR)));
5874                                 }
5875
5876                                 /* remove callee pBlock from the pBlock linked list */
5877                                 removepBlock(pcn->pb);
5878
5879                                 pce = pcn;
5880                                 while(pce) {
5881                                         pce->pb = pb;
5882                                         pce = pce->next;
5883                                 }
5884
5885                                 /* Remove the Function pCode */
5886                                 pct = findNextInstruction(pcn->next);
5887
5888                                 /* Link the function with the callee */
5889                                 if (pcp) pcp->next = pcn->next;
5890                                 pcn->next->prev = pcp;
5891
5892                                 /* Convert the function name into a label */
5893
5894                                 pbr = Safe_calloc(1,sizeof(pBranch));
5895                                 pbr->pc = newpCodeLabel(PCF(pcn)->fname, -1);
5896                                 pbr->next = NULL;
5897                                 PCI(pct)->label = pBranchAppend(PCI(pct)->label,pbr);
5898                                 PCI(pct)->label = pBranchAppend(PCI(pct)->label,PCI(pc_call)->label);
5899
5900                                 /* turn all of the return's except the last into goto's */
5901                                 /* check case for 2 instruction pBlocks */
5902                                 pce = findNextInstruction(pcn->next);
5903                                 while(pce) {
5904                                         pCode *pce_next = findNextInstruction(pce->next);
5905
5906                                         if(pce_next == NULL) {
5907                                                 /* found the last return */
5908                                                 pCode *pc_call_next =  findNextInstruction(pc_call->next);
5909
5910                                                 //fprintf(stderr,"found last return\n");
5911                                                 //pce->print(stderr,pce);
5912                                                 pce->prev->next = pc_call->next;
5913                                                 pc_call->next->prev = pce->prev;
5914                                                 PCI(pc_call_next)->label = pBranchAppend(PCI(pc_call_next)->label,
5915                                                         PCI(pce)->label);
5916                                         }
5917
5918                                         pce = pce_next;
5919                                 }
5920
5921                         }
5922                 } else
5923                         fprintf(stderr,"BUG? pCode isn't a POC_CALL %d\n",__LINE__);
5924
5925         }
5926
5927 }
5928
5929 /*-----------------------------------------------------------------*/
5930 /*                                                                 */
5931 /*-----------------------------------------------------------------*/
5932
5933 void InlinepCode(void)
5934 {
5935
5936         pBlock  *pb;
5937         pCode   *pc;
5938
5939         if(!the_pFile)
5940                 return;
5941
5942         if(!functionInlining)
5943                 return;
5944
5945                 /* Loop through all of the function definitions and count the
5946         * number of times each one is called */
5947         //fprintf(stderr,"inlining %d\n",__LINE__);
5948
5949         for(pb = the_pFile->pbHead; pb; pb = pb->next) {
5950
5951                 pc = setFirstItem(pb->function_calls);
5952
5953                 for( ; pc; pc = setNextItem(pb->function_calls)) {
5954
5955                         if(isCALL(pc)) {
5956                                 pCode *pcn = findFunction(get_op_from_instruction(PCI(pc)));
5957                                 if(pcn && isPCF(pcn)) {
5958                                         PCF(pcn)->ncalled++;
5959                                 }
5960                         } else
5961                                 fprintf(stderr,"BUG? pCode isn't a POC_CALL %d\n",__LINE__);
5962
5963                 }
5964         }
5965
5966         //fprintf(stderr,"inlining %d\n",__LINE__);
5967
5968         /* Now, Loop through the function definitions again, but this
5969         * time inline those functions that have only been called once. */
5970
5971         InlineFunction(the_pFile->pbHead);
5972         //fprintf(stderr,"inlining %d\n",__LINE__);
5973
5974         for(pb = the_pFile->pbHead; pb; pb = pb->next)
5975                 unBuildFlow(pb);
5976
5977 }