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