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,  "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 = 1;        /* 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, 0x180);
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         if (pcor->pcop.type == PO_IMMEDIATE){
2810                 PCOL(pcor)->lit = PCOL(pc)->lit;
2811         } else {
2812                 pcor->r = pc->r;
2813                 pcor->rIdx = pc->rIdx;
2814                 pcor->r->wasUsed=1;
2815         }
2816         //DEBUGpic14_emitcode ("; ***","%s  , copying %s, rIdx=%d",__FUNCTION__,pc->pcop.name,pc->rIdx);
2817
2818         return PCOP(pcor);
2819 }
2820
2821 /*-----------------------------------------------------------------*/
2822 /* pCodeInstructionCopy - copy a pCodeInstructionCopy              */
2823 /*-----------------------------------------------------------------*/
2824 pCode *pCodeInstructionCopy(pCodeInstruction *pci,int invert)
2825 {
2826         pCodeInstruction *new_pci;
2827
2828         if(invert)
2829                 new_pci = PCI(newpCode(pci->inverted_op,pci->pcop));
2830         else
2831                 new_pci = PCI(newpCode(pci->op,pci->pcop));
2832
2833         new_pci->pc.pb = pci->pc.pb;
2834         new_pci->from = pci->from;
2835         new_pci->to   = pci->to;
2836         new_pci->label = pci->label;
2837         new_pci->pcflow = pci->pcflow;
2838
2839         return PCODE(new_pci);
2840 }
2841
2842 /*-----------------------------------------------------------------*/
2843 /*-----------------------------------------------------------------*/
2844 void pCodeDeleteChain(pCode *f,pCode *t)
2845 {
2846         pCode *pc;
2847
2848         while(f && f!=t) {
2849                 DFPRINTF((stderr,"delete pCode:\n"));
2850                 pc = f->next;
2851                 //f->print(stderr,f);
2852                 //f->delete(f);  this dumps core...
2853                 f = pc;
2854         }
2855 }
2856
2857 /*-----------------------------------------------------------------*/
2858 /*-----------------------------------------------------------------*/
2859 void pBlockRegs(FILE *of, pBlock *pb)
2860 {
2861
2862         regs  *r;
2863
2864         r = setFirstItem(pb->tregisters);
2865         while (r) {
2866                 r = setNextItem(pb->tregisters);
2867         }
2868 }
2869
2870
2871 /*-----------------------------------------------------------------*/
2872 /*-----------------------------------------------------------------*/
2873 char *get_op(pCodeOp *pcop,char *buffer, size_t size)
2874 {
2875         regs *r;
2876         static char b[50];
2877         char *s;
2878         int use_buffer = 1;    // copy the string to the passed buffer pointer
2879
2880         if(!buffer) {
2881                 buffer = b;
2882                 size = sizeof(b);
2883                 use_buffer = 0;     // Don't bother copying the string to the buffer.
2884         }
2885
2886         if(pcop) {
2887                 switch(pcop->type) {
2888                 case PO_INDF:
2889                 case PO_FSR:
2890                         if(use_buffer) {
2891                                 SAFE_snprintf(&buffer,&size,"%s",PCOR(pcop)->r->name);
2892                                 return buffer;
2893                         }
2894                         //return PCOR(pcop)->r->name;
2895                         return pcop->name;
2896                         break;
2897                 case PO_GPR_TEMP:
2898                         if (PCOR(pcop)->r->type == REG_STK)
2899                                 r = typeRegWithIdx(PCOR(pcop)->r->rIdx,REG_STK,1);
2900                         else
2901                                 r = pic14_regWithIdx(PCOR(pcop)->r->rIdx);
2902
2903                         if(use_buffer) {
2904                                 SAFE_snprintf(&buffer,&size,"%s",r->name);
2905                                 return buffer;
2906                         }
2907
2908                         return r->name;
2909
2910
2911                 case PO_IMMEDIATE:
2912                         s = buffer;
2913
2914                         if(PCOI(pcop)->_const) {
2915
2916                                 if( PCOI(pcop)->offset && PCOI(pcop)->offset<4) {
2917                                         switch(PCOI(pcop)->offset) {
2918                                         case 0:
2919                                                 SAFE_snprintf(&s,&size,"low %s",pcop->name);
2920                                                 break;
2921                                         case 1:
2922                                                 SAFE_snprintf(&s,&size,"high %s",pcop->name);
2923                                                 break;
2924                                         default:
2925                                                 SAFE_snprintf(&s,&size,"(((%s+%d) >> %d)&0xff)",
2926                                                         pcop->name,
2927                                                         PCOI(pcop)->index,
2928                                                         8 * PCOI(pcop)->offset );
2929                                         }
2930                                 } else
2931                                         SAFE_snprintf(&s,&size,"LOW(%s+%d)",pcop->name,PCOI(pcop)->index);
2932                         } else {
2933
2934                                 if( PCOI(pcop)->index) { // && PCOI(pcc->pcop)->offset<4) {
2935                                         SAFE_snprintf(&s,&size,"(%s + %d)",
2936                                                 pcop->name,
2937                                                 PCOI(pcop)->index );
2938                                 } else {
2939                                         switch(PCOI(pcop)->offset) {
2940                                         case 0:
2941                                                 SAFE_snprintf(&s,&size,"%s",pcop->name);
2942                                                 break;
2943                                         case 1:
2944                                                 SAFE_snprintf(&s,&size,"high %s",pcop->name);
2945                                                 break;
2946                                         default:
2947                                                 SAFE_snprintf(&s,&size,"(%s >> %d)&0xff",pcop->name, 8*PCOI(pcop)->offset);
2948                                         }
2949                                 }
2950                         }
2951
2952                         return buffer;
2953
2954                 case PO_DIR:
2955                         s = buffer;
2956                         //size = sizeof(buffer);
2957                         if( PCOR(pcop)->instance) {
2958                                 SAFE_snprintf(&s,&size,"(%s + %d)",
2959                                         pcop->name,
2960                                         PCOR(pcop)->instance );
2961                                 //fprintf(stderr,"PO_DIR %s\n",buffer);
2962                         } else
2963                                 SAFE_snprintf(&s,&size,"%s",pcop->name);
2964                         return buffer;
2965
2966                 case PO_LABEL:
2967                         s = buffer;
2968                         if  (pcop->name) {
2969                                 if(PCOLAB(pcop)->offset == 1)
2970                                         SAFE_snprintf(&s,&size,"HIGH(%s)",pcop->name);
2971                                 else
2972                                         SAFE_snprintf(&s,&size,"%s",pcop->name);
2973                         }
2974                         return buffer;
2975
2976                 case PO_GPR_BIT:
2977                         if(PCOR(pcop)->r) {
2978                                 if(use_buffer) {
2979                                         SAFE_snprintf(&buffer,&size,"%s",PCOR(pcop)->r->name);
2980                                         return buffer;
2981                                 }
2982                                 return PCOR(pcop)->r->name;
2983                         }
2984
2985                         /* fall through to the default case */
2986                 default:
2987                         if(pcop->name) {
2988                                 if(use_buffer) {
2989                                         SAFE_snprintf(&buffer,&size,"%s",pcop->name);
2990                                         return buffer;
2991                                 }
2992                                 return pcop->name;
2993                         }
2994                 }
2995         }
2996
2997         printf("PIC port internal warning: (%s:%d) %s not found\n",
2998           __FUNCTION__,
2999           __LINE__,
3000           pCodeOpType(pcop));
3001
3002         return "NO operand";
3003
3004 }
3005
3006 /*-----------------------------------------------------------------*/
3007 /*-----------------------------------------------------------------*/
3008 static char *get_op_from_instruction( pCodeInstruction *pcc)
3009 {
3010
3011         if(pcc)
3012                 return get_op(pcc->pcop,NULL,0);
3013
3014         return ("ERROR Null: get_op_from_instruction");
3015
3016 }
3017
3018 /*-----------------------------------------------------------------*/
3019 /*-----------------------------------------------------------------*/
3020 static void pCodeOpPrint(FILE *of, pCodeOp *pcop)
3021 {
3022         fprintf(of,"pcodeopprint- not implemented\n");
3023 }
3024
3025 /*-----------------------------------------------------------------*/
3026 /*-----------------------------------------------------------------*/
3027 char *pCode2str(char *str, size_t size, pCode *pc)
3028 {
3029         char *s = str;
3030
3031         switch(pc->type) {
3032
3033         case PC_OPCODE:
3034
3035                 SAFE_snprintf(&s,&size, "\t%s\t", PCI(pc)->mnemonic);
3036
3037                 if( (PCI(pc)->num_ops >= 1) && (PCI(pc)->pcop)) {
3038
3039                         if(PCI(pc)->isBitInst) {
3040                                 if(PCI(pc)->pcop->type == PO_GPR_BIT) {
3041                                         char *name = PCI(pc)->pcop->name;
3042                                         if (!name)
3043                                                 name = PCOR(PCI(pc)->pcop)->r->name;
3044                                         if( (((pCodeOpRegBit *)(PCI(pc)->pcop))->inBitSpace) )
3045                                                 SAFE_snprintf(&s,&size,"(%s >> 3), (%s & 7)", name, name);
3046                                         else
3047                                                 SAFE_snprintf(&s,&size,"%s,%d", name,
3048                                                 (((pCodeOpRegBit *)(PCI(pc)->pcop))->bit)&7);
3049                                 } else if(PCI(pc)->pcop->type == PO_GPR_BIT) {
3050                                         SAFE_snprintf(&s,&size,"%s,%d", get_op_from_instruction(PCI(pc)),PCORB(PCI(pc)->pcop)->bit);
3051                                 } else
3052                                         SAFE_snprintf(&s,&size,"%s,0 ; ?bug", get_op_from_instruction(PCI(pc)));
3053                                 //PCI(pc)->pcop->t.bit );
3054                         } else {
3055
3056                                 if(PCI(pc)->pcop->type == PO_GPR_BIT) {
3057                                         if( PCI(pc)->num_ops == 2)
3058                                                 SAFE_snprintf(&s,&size,"(%s >> 3),%c",get_op_from_instruction(PCI(pc)),((PCI(pc)->isModReg) ? 'F':'W'));
3059                                         else
3060                                                 SAFE_snprintf(&s,&size,"(1 << (%s & 7))",get_op_from_instruction(PCI(pc)));
3061
3062                                 } else {
3063                                         SAFE_snprintf(&s,&size,"%s",get_op_from_instruction(PCI(pc)));
3064
3065                                         if( PCI(pc)->num_ops == 2)
3066                                                 SAFE_snprintf(&s,&size,",%c", ( (PCI(pc)->isModReg) ? 'F':'W'));
3067                                 }
3068                         }
3069
3070                 }
3071                 break;
3072
3073         case PC_COMMENT:
3074                 /* assuming that comment ends with a \n */
3075                 SAFE_snprintf(&s,&size,";%s", ((pCodeComment *)pc)->comment);
3076                 break;
3077
3078         case PC_INLINE:
3079                 /* assuming that inline code ends with a \n */
3080                 SAFE_snprintf(&s,&size,"%s", ((pCodeComment *)pc)->comment);
3081                 break;
3082
3083         case PC_LABEL:
3084                 SAFE_snprintf(&s,&size,";label=%s, key=%d\n",PCL(pc)->label,PCL(pc)->key);
3085                 break;
3086         case PC_FUNCTION:
3087                 SAFE_snprintf(&s,&size,";modname=%s,function=%s: id=%d\n",PCF(pc)->modname,PCF(pc)->fname);
3088                 break;
3089         case PC_WILD:
3090                 SAFE_snprintf(&s,&size,";\tWild opcode: id=%d\n",PCW(pc)->id);
3091                 break;
3092         case PC_FLOW:
3093                 SAFE_snprintf(&s,&size,";\t--FLOW change\n");
3094                 break;
3095         case PC_CSOURCE:
3096                 SAFE_snprintf(&s,&size,";#CSRC\t%s %d\n; %s\n", PCCS(pc)->file_name, PCCS(pc)->line_number, PCCS(pc)->line);
3097                 break;
3098
3099         case PC_BAD:
3100                 SAFE_snprintf(&s,&size,";A bad pCode is being used\n");
3101         }
3102
3103         return str;
3104
3105 }
3106
3107 /*-----------------------------------------------------------------*/
3108 /* genericPrint - the contents of a pCode to a file                */
3109 /*-----------------------------------------------------------------*/
3110 static void genericPrint(FILE *of, pCode *pc)
3111 {
3112
3113         if(!pc || !of)
3114                 return;
3115
3116         switch(pc->type) {
3117         case PC_COMMENT:
3118                 fprintf(of,";%s\n", ((pCodeComment *)pc)->comment);
3119                 break;
3120
3121         case PC_INLINE:
3122                 fprintf(of,"%s\n", ((pCodeComment *)pc)->comment);
3123                 break;
3124
3125         case PC_OPCODE:
3126                 // If the opcode has a label, print that first
3127                 {
3128                         char str[256];
3129                         pCodeInstruction *pci = PCI(pc);
3130                         pBranch *pbl = pci->label;
3131                         while(pbl && pbl->pc) {
3132                                 if(pbl->pc->type == PC_LABEL)
3133                                         pCodePrintLabel(of, pbl->pc);
3134                                 pbl = pbl->next;
3135                         }
3136
3137                         if(pci->cline)
3138                                 genericPrint(of,PCODE(pci->cline));
3139
3140
3141                         pCode2str(str, 256, pc);
3142
3143                         fprintf(of,"%s",str);
3144
3145                         /* Debug */
3146                         if(debug_verbose) {
3147                                 pCodeOpReg *pcor = PCOR(pci->pcop);
3148                                 fprintf(of, "\t;id=%u,key=%03x",pc->id,pc->seq);
3149                                 if(pci->pcflow)
3150                                         fprintf(of,",flow seq=%03x",pci->pcflow->pc.seq);
3151                                 if (pcor && pcor->pcop.type==PO_GPR_TEMP && !pcor->r->isFixed)
3152                                         fprintf(of,",rIdx=r0x%X",pcor->rIdx);
3153                         }
3154                 }
3155 #if 0
3156                 {
3157                         pBranch *dpb = pc->to;   // debug
3158                         while(dpb) {
3159                                 switch ( dpb->pc->type) {
3160                                 case PC_OPCODE:
3161                                         fprintf(of, "\t;%s", PCI(dpb->pc)->mnemonic);
3162                                         break;
3163                                 case PC_LABEL:
3164                                         fprintf(of, "\t;label %d", PCL(dpb->pc)->key);
3165                                         break;
3166                                 case PC_FUNCTION:
3167                                         fprintf(of, "\t;function %s", ( (PCF(dpb->pc)->fname) ? (PCF(dpb->pc)->fname) : "[END]"));
3168                                         break;
3169                                 case PC_FLOW:
3170                                         fprintf(of, "\t;flow");
3171                                         break;
3172                                 case PC_COMMENT:
3173                                 case PC_WILD:
3174                                         break;
3175                                 }
3176                                 dpb = dpb->next;
3177                         }
3178                 }
3179 #endif
3180                 fprintf(of,"\n");
3181                 break;
3182
3183         case PC_WILD:
3184                 fprintf(of,";\tWild opcode: id=%d\n",PCW(pc)->id);
3185                 if(PCW(pc)->pci.label)
3186                         pCodePrintLabel(of, PCW(pc)->pci.label->pc);
3187
3188                 if(PCW(pc)->operand) {
3189                         fprintf(of,";\toperand  ");
3190                         pCodeOpPrint(of,PCW(pc)->operand );
3191                 }
3192                 break;
3193
3194         case PC_FLOW:
3195                 if(debug_verbose) {
3196                         fprintf(of,";<>Start of new flow, seq=0x%x",pc->seq);
3197                         if(PCFL(pc)->ancestor)
3198                                 fprintf(of," ancestor = 0x%x", PCODE(PCFL(pc)->ancestor)->seq);
3199                         fprintf(of,"\n");
3200
3201                 }
3202                 break;
3203
3204         case PC_CSOURCE:
3205                 fprintf(of,";#CSRC\t%s %d\n;  %s\n", PCCS(pc)->file_name, PCCS(pc)->line_number, PCCS(pc)->line);
3206                 break;
3207         case PC_LABEL:
3208         default:
3209                 fprintf(of,"unknown pCode type %d\n",pc->type);
3210         }
3211
3212 }
3213
3214 /*-----------------------------------------------------------------*/
3215 /* pCodePrintFunction - prints function begin/end                  */
3216 /*-----------------------------------------------------------------*/
3217
3218 static void pCodePrintFunction(FILE *of, pCode *pc)
3219 {
3220
3221         if(!pc || !of)
3222                 return;
3223
3224         if( ((pCodeFunction *)pc)->modname)
3225                 fprintf(of,"F_%s",((pCodeFunction *)pc)->modname);
3226
3227         if(PCF(pc)->fname) {
3228                 pBranch *exits = PCF(pc)->to;
3229                 int i=0;
3230                 fprintf(of,"%s\t;Function start\n",PCF(pc)->fname);
3231                 while(exits) {
3232                         i++;
3233                         exits = exits->next;
3234                 }
3235                 //if(i) i--;
3236                 fprintf(of,"; %d exit point%c\n",i, ((i==1) ? ' ':'s'));
3237
3238         }else {
3239                 if((PCF(pc)->from &&
3240                         PCF(pc)->from->pc->type == PC_FUNCTION &&
3241                         PCF(PCF(pc)->from->pc)->fname) )
3242                         fprintf(of,"; exit point of %s\n",PCF(PCF(pc)->from->pc)->fname);
3243                 else
3244                         fprintf(of,"; exit point [can't find entry point]\n");
3245         }
3246 }
3247 /*-----------------------------------------------------------------*/
3248 /* pCodePrintLabel - prints label                                  */
3249 /*-----------------------------------------------------------------*/
3250
3251 static void pCodePrintLabel(FILE *of, pCode *pc)
3252 {
3253
3254         if(!pc || !of)
3255                 return;
3256
3257         if(PCL(pc)->label)
3258                 fprintf(of,"%s\n",PCL(pc)->label);
3259         else if (PCL(pc)->key >=0)
3260                 fprintf(of,"_%05d_DS_:\n",PCL(pc)->key);
3261         else
3262                 fprintf(of,";wild card label: id=%d\n",-PCL(pc)->key);
3263
3264 }
3265 /*-----------------------------------------------------------------*/
3266 /* unlinkpCodeFromBranch - Search for a label in a pBranch and     */
3267 /*                         remove it if it is found.               */
3268 /*-----------------------------------------------------------------*/
3269 static void unlinkpCodeFromBranch(pCode *pcl , pCode *pc)
3270 {
3271         pBranch *b, *bprev;
3272
3273
3274         bprev = NULL;
3275
3276         if(pcl->type == PC_OPCODE)
3277                 b = PCI(pcl)->label;
3278         else {
3279                 fprintf(stderr, "LINE %d. can't unlink from non opcode\n",__LINE__);
3280                 exit(1);
3281
3282         }
3283
3284         //fprintf (stderr, "%s \n",__FUNCTION__);
3285         //pcl->print(stderr,pcl);
3286         //pc->print(stderr,pc);
3287         while(b) {
3288                 if(b->pc == pc) {
3289                         //fprintf (stderr, "found label\n");
3290
3291                         /* Found a label */
3292                         if(bprev) {
3293                                 bprev->next = b->next;  /* Not first pCode in chain */
3294                                 free(b);
3295                         } else {
3296                                 pc->destruct(pc);
3297                                 PCI(pcl)->label = b->next;   /* First pCode in chain */
3298                                 free(b);
3299                         }
3300                         return;  /* A label can't occur more than once */
3301                 }
3302                 bprev = b;
3303                 b = b->next;
3304         }
3305
3306 }
3307
3308 /*-----------------------------------------------------------------*/
3309 /*-----------------------------------------------------------------*/
3310 pBranch * pBranchAppend(pBranch *h, pBranch *n)
3311 {
3312         pBranch *b;
3313
3314         if(!h)
3315                 return n;
3316
3317         if(h == n)
3318                 return n;
3319
3320         b = h;
3321         while(b->next)
3322                 b = b->next;
3323
3324         b->next = n;
3325
3326         return h;
3327
3328 }
3329 /*-----------------------------------------------------------------*/
3330 /* pBranchLink - given two pcodes, this function will link them    */
3331 /*               together through their pBranches                  */
3332 /*-----------------------------------------------------------------*/
3333 static void pBranchLink(pCodeFunction *f, pCodeFunction *t)
3334 {
3335         pBranch *b;
3336
3337         // Declare a new branch object for the 'from' pCode.
3338
3339         //_ALLOC(b,sizeof(pBranch));
3340         b = Safe_calloc(1,sizeof(pBranch));
3341         b->pc = PCODE(t);             // The link to the 'to' pCode.
3342         b->next = NULL;
3343
3344         f->to = pBranchAppend(f->to,b);
3345
3346         // Now do the same for the 'to' pCode.
3347
3348         //_ALLOC(b,sizeof(pBranch));
3349         b = Safe_calloc(1,sizeof(pBranch));
3350         b->pc = PCODE(f);
3351         b->next = NULL;
3352
3353         t->from = pBranchAppend(t->from,b);
3354
3355 }
3356
3357 #if 0
3358 /*-----------------------------------------------------------------*/
3359 /* pBranchFind - find the pBranch in a pBranch chain that contains */
3360 /*               a pCode                                           */
3361 /*-----------------------------------------------------------------*/
3362 static pBranch *pBranchFind(pBranch *pb,pCode *pc)
3363 {
3364         while(pb) {
3365
3366                 if(pb->pc == pc)
3367                         return pb;
3368
3369                 pb = pb->next;
3370         }
3371
3372         return NULL;
3373 }
3374
3375 /*-----------------------------------------------------------------*/
3376 /* pCodeUnlink - Unlink the given pCode from its pCode chain.      */
3377 /*-----------------------------------------------------------------*/
3378 static void pCodeUnlink(pCode *pc)
3379 {
3380         pBranch *pb1,*pb2;
3381         pCode *pc1;
3382
3383         if(!pc->prev || !pc->next) {
3384                 fprintf(stderr,"unlinking bad pCode in %s:%d\n",__FILE__,__LINE__);
3385                 exit(1);
3386         }
3387
3388         /* first remove the pCode from the chain */
3389         pc->prev->next = pc->next;
3390         pc->next->prev = pc->prev;
3391
3392         /* Now for the hard part... */
3393
3394         /* Remove the branches */
3395
3396         pb1 = pc->from;
3397         while(pb1) {
3398         pc1 = pb1->pc;    /* Get the pCode that branches to the
3399         * one we're unlinking */
3400
3401         /* search for the link back to this pCode (the one we're
3402         * unlinking) */
3403         if(pb2 = pBranchFind(pc1->to,pc)) {
3404                 pb2->pc = pc->to->pc;  // make the replacement
3405
3406                                                            /* if the pCode we're unlinking contains multiple 'to'
3407                                                            * branches (e.g. this a skip instruction) then we need
3408                 * to copy these extra branches to the chain. */
3409                 if(pc->to->next)
3410                         pBranchAppend(pb2, pc->to->next);
3411         }
3412
3413         pb1 = pb1->next;
3414         }
3415
3416
3417 }
3418 #endif
3419 /*-----------------------------------------------------------------*/
3420 /*-----------------------------------------------------------------*/
3421 #if 0
3422 static void genericAnalyze(pCode *pc)
3423 {
3424         switch(pc->type) {
3425         case PC_WILD:
3426         case PC_COMMENT:
3427                 return;
3428         case PC_LABEL:
3429         case PC_FUNCTION:
3430         case PC_OPCODE:
3431                 {
3432                         // Go through the pCodes that are in pCode chain and link
3433                         // them together through the pBranches. Note, the pCodes
3434                         // are linked together as a contiguous stream like the
3435                         // assembly source code lines. The linking here mimics this
3436                         // except that comments are not linked in.
3437                         //
3438                         pCode *npc = pc->next;
3439                         while(npc) {
3440                                 if(npc->type == PC_OPCODE || npc->type == PC_LABEL) {
3441                                         pBranchLink(pc,npc);
3442                                         return;
3443                                 } else
3444                                         npc = npc->next;
3445                         }
3446                         /* reached the end of the pcode chain without finding
3447                         * an instruction we could link to. */
3448                 }
3449                 break;
3450         case PC_FLOW:
3451                 fprintf(stderr,"analyze PC_FLOW\n");
3452
3453                 return;
3454         case PC_BAD:
3455                 fprintf(stderr,";A bad pCode is being used\n");
3456
3457         }
3458 }
3459 #endif
3460
3461 /*-----------------------------------------------------------------*/
3462 /*-----------------------------------------------------------------*/
3463 int compareLabel(pCode *pc, pCodeOpLabel *pcop_label)
3464 {
3465         pBranch *pbr;
3466
3467         if(pc->type == PC_LABEL) {
3468                 if( ((pCodeLabel *)pc)->key ==  pcop_label->key)
3469                         return TRUE;
3470         }
3471         if(pc->type == PC_OPCODE) {
3472                 pbr = PCI(pc)->label;
3473                 while(pbr) {
3474                         if(pbr->pc->type == PC_LABEL) {
3475                                 if( ((pCodeLabel *)(pbr->pc))->key ==  pcop_label->key)
3476                                         return TRUE;
3477                         }
3478                         pbr = pbr->next;
3479                 }
3480         }
3481
3482         return FALSE;
3483 }
3484
3485 /*-----------------------------------------------------------------*/
3486 /*-----------------------------------------------------------------*/
3487 int checkLabel(pCode *pc)
3488 {
3489         pBranch *pbr;
3490
3491         if(pc && isPCI(pc)) {
3492                 pbr = PCI(pc)->label;
3493                 while(pbr) {
3494                         if(isPCL(pbr->pc) && (PCL(pbr->pc)->key >= 0))
3495                                 return TRUE;
3496
3497                         pbr = pbr->next;
3498                 }
3499         }
3500
3501         return FALSE;
3502 }
3503
3504 /*-----------------------------------------------------------------*/
3505 /* findLabelinpBlock - Search the pCode for a particular label     */
3506 /*-----------------------------------------------------------------*/
3507 pCode * findLabelinpBlock(pBlock *pb,pCodeOpLabel *pcop_label)
3508 {
3509         pCode  *pc;
3510
3511         if(!pb)
3512                 return NULL;
3513
3514         for(pc = pb->pcHead; pc; pc = pc->next)
3515                 if(compareLabel(pc,pcop_label))
3516                         return pc;
3517
3518                 return NULL;
3519 }
3520
3521 /*-----------------------------------------------------------------*/
3522 /* findLabel - Search the pCode for a particular label             */
3523 /*-----------------------------------------------------------------*/
3524 pCode * findLabel(pCodeOpLabel *pcop_label)
3525 {
3526         pBlock *pb;
3527         pCode  *pc;
3528
3529         if(!the_pFile)
3530                 return NULL;
3531
3532         for(pb = the_pFile->pbHead; pb; pb = pb->next) {
3533                 if( (pc = findLabelinpBlock(pb,pcop_label)) != NULL)
3534                         return pc;
3535         }
3536
3537         fprintf(stderr,"Couldn't find label %s", pcop_label->pcop.name);
3538         return NULL;
3539 }
3540
3541 /*-----------------------------------------------------------------*/
3542 /* findNextpCode - given a pCode, find the next of type 'pct'      */
3543 /*                 in the linked list                              */
3544 /*-----------------------------------------------------------------*/
3545 pCode * findNextpCode(pCode *pc, PC_TYPE pct)
3546 {
3547
3548         while(pc) {
3549                 if(pc->type == pct)
3550                         return pc;
3551
3552                 pc = pc->next;
3553         }
3554
3555         return NULL;
3556 }
3557
3558 /*-----------------------------------------------------------------*/
3559 /* findPrevpCode - given a pCode, find the previous of type 'pct'  */
3560 /*                 in the linked list                              */
3561 /*-----------------------------------------------------------------*/
3562 pCode * findPrevpCode(pCode *pc, PC_TYPE pct)
3563 {
3564
3565         while(pc) {
3566                 if(pc->type == pct) {
3567                         /*
3568                         static unsigned int stop;
3569                         if (pc->id == 524)
3570                                 stop++; // Place break point here
3571                         */
3572                         return pc;
3573                 }
3574
3575                 pc = pc->prev;
3576         }
3577
3578         return NULL;
3579 }
3580
3581 /*-----------------------------------------------------------------*/
3582 /* findNextInstruction - given a pCode, find the next instruction  */
3583 /*                       in the linked list                        */
3584 /*-----------------------------------------------------------------*/
3585 pCode * findNextInstruction(pCode *pci)
3586 {
3587         pCode *pc = pci;
3588
3589         while(pc) {
3590                 if((pc->type == PC_OPCODE) || (pc->type == PC_WILD)) {
3591                         /*
3592                         static unsigned int stop;
3593                         if (pc->id == 524)
3594                                 stop++; // Place break point here
3595                         */
3596                         return pc;
3597                 }
3598
3599 #ifdef PCODE_DEBUG
3600                 fprintf(stderr,"findNextInstruction:  ");
3601                 printpCode(stderr, pc);
3602 #endif
3603                 pc = pc->next;
3604         }
3605
3606         //fprintf(stderr,"Couldn't find instruction\n");
3607         return NULL;
3608 }
3609
3610 /*-----------------------------------------------------------------*/
3611 /* findNextInstruction - given a pCode, find the next instruction  */
3612 /*                       in the linked list                        */
3613 /*-----------------------------------------------------------------*/
3614 pCode * findPrevInstruction(pCode *pci)
3615 {
3616         return findPrevpCode(pci, PC_OPCODE);
3617 }
3618
3619 /*-----------------------------------------------------------------*/
3620 /* findFunctionEnd - given a pCode find the end of the function    */
3621 /*                   that contains it                              */
3622 /*-----------------------------------------------------------------*/
3623 pCode * findFunctionEnd(pCode *pc)
3624 {
3625
3626         while(pc) {
3627                 if(pc->type == PC_FUNCTION &&  !(PCF(pc)->fname))
3628                         return pc;
3629
3630                 pc = pc->next;
3631         }
3632
3633         fprintf(stderr,"Couldn't find function end\n");
3634         return NULL;
3635 }
3636
3637 #if 0
3638 /*-----------------------------------------------------------------*/
3639 /* AnalyzeLabel - if the pCode is a label, then merge it with the  */
3640 /*                instruction with which it is associated.         */
3641 /*-----------------------------------------------------------------*/
3642 static void AnalyzeLabel(pCode *pc)
3643 {
3644
3645         pCodeUnlink(pc);
3646
3647 }
3648 #endif
3649
3650 #if 0
3651 static void AnalyzeGOTO(pCode *pc)
3652 {
3653
3654         pBranchLink(pc,findLabel( (pCodeOpLabel *) (PCI(pc)->pcop) ));
3655
3656 }
3657
3658 static void AnalyzeSKIP(pCode *pc)
3659 {
3660
3661         pBranchLink(pc,findNextInstruction(pc->next));
3662         pBranchLink(pc,findNextInstruction(pc->next->next));
3663
3664 }
3665
3666 static void AnalyzeRETURN(pCode *pc)
3667 {
3668
3669         //  branch_link(pc,findFunctionEnd(pc->next));
3670
3671 }
3672
3673 #endif
3674
3675 /*-----------------------------------------------------------------*/
3676 /*-----------------------------------------------------------------*/
3677 regs * getRegFromInstruction(pCode *pc)
3678 {
3679
3680         if(!pc                   ||
3681                 !isPCI(pc)            ||
3682                 !PCI(pc)->pcop        ||
3683                 PCI(pc)->num_ops == 0 )
3684                 return NULL;
3685
3686         switch(PCI(pc)->pcop->type) {
3687         case PO_INDF:
3688         case PO_FSR:
3689                 return PCOR(PCI(pc)->pcop)->r;
3690
3691                 //    return typeRegWithIdx (PCOR(PCI(pc)->pcop)->rIdx, REG_SFR, 0);
3692
3693         case PO_BIT:
3694         case PO_GPR_TEMP:
3695                 //fprintf(stderr, "getRegFromInstruction - bit or temp\n");
3696                 return PCOR(PCI(pc)->pcop)->r;
3697
3698         case PO_IMMEDIATE:
3699                 if(PCOI(PCI(pc)->pcop)->r)
3700                         return (PCOI(PCI(pc)->pcop)->r);
3701
3702                 //fprintf(stderr, "getRegFromInstruction - immediate\n");
3703                 return dirregWithName(PCI(pc)->pcop->name);
3704                 //return NULL; // PCOR(PCI(pc)->pcop)->r;
3705
3706         case PO_GPR_BIT:
3707                 return PCOR(PCI(pc)->pcop)->r;
3708
3709         case PO_GPR_REGISTER:
3710         case PO_DIR:
3711                 //fprintf(stderr, "getRegFromInstruction - dir\n");
3712                 return PCOR(PCI(pc)->pcop)->r;
3713         case PO_LITERAL:
3714                 //fprintf(stderr, "getRegFromInstruction - literal\n");
3715                 break;
3716
3717         default:
3718                 //fprintf(stderr, "getRegFromInstruction - unknown reg type %d\n",PCI(pc)->pcop->type);
3719                 //genericPrint(stderr, pc);
3720                 break;
3721         }
3722
3723         return NULL;
3724
3725 }
3726
3727 /*-----------------------------------------------------------------*/
3728 /*-----------------------------------------------------------------*/
3729
3730 void AnalyzepBlock(pBlock *pb)
3731 {
3732         pCode *pc;
3733
3734         if(!pb)
3735                 return;
3736
3737                 /* Find all of the registers used in this pBlock
3738                 * by looking at each instruction and examining it's
3739                 * operands
3740         */
3741         for(pc = pb->pcHead; pc; pc = pc->next) {
3742
3743                 /* Is this an instruction with operands? */
3744                 if(pc->type == PC_OPCODE && PCI(pc)->pcop) {
3745
3746                         if((PCI(pc)->pcop->type == PO_GPR_TEMP)
3747                                 || ((PCI(pc)->pcop->type == PO_GPR_BIT) && PCOR(PCI(pc)->pcop)->r && (PCOR(PCI(pc)->pcop)->r->pc_type == PO_GPR_TEMP))) {
3748
3749                                 /* Loop through all of the registers declared so far in
3750                                 this block and see if we find this one there */
3751
3752                                 regs *r = setFirstItem(pb->tregisters);
3753
3754                                 while(r) {
3755                                         if((r->rIdx == PCOR(PCI(pc)->pcop)->r->rIdx) && (r->type == PCOR(PCI(pc)->pcop)->r->type)) {
3756                                                 PCOR(PCI(pc)->pcop)->r = r;
3757                                                 break;
3758                                         }
3759                                         r = setNextItem(pb->tregisters);
3760                                 }
3761
3762                                 if(!r) {
3763                                         /* register wasn't found */
3764                                         //r = Safe_calloc(1, sizeof(regs));
3765                                         //memcpy(r,PCOR(PCI(pc)->pcop)->r, sizeof(regs));
3766                                         //addSet(&pb->tregisters, r);
3767                                         addSet(&pb->tregisters, PCOR(PCI(pc)->pcop)->r);
3768                                         //PCOR(PCI(pc)->pcop)->r = r;
3769                                         //fprintf(stderr,"added register to pblock: reg %d\n",r->rIdx);
3770                                         }/* else
3771                                          fprintf(stderr,"found register in pblock: reg %d\n",r->rIdx);
3772                                 */
3773                         }
3774                         if(PCI(pc)->pcop->type == PO_GPR_REGISTER) {
3775                                 if(PCOR(PCI(pc)->pcop)->r) {
3776                                         pic14_allocWithIdx (PCOR(PCI(pc)->pcop)->r->rIdx);
3777                                         DFPRINTF((stderr,"found register in pblock: reg 0x%x\n",PCOR(PCI(pc)->pcop)->r->rIdx));
3778                                 } else {
3779                                         if(PCI(pc)->pcop->name)
3780                                                 fprintf(stderr,"ERROR: %s is a NULL register\n",PCI(pc)->pcop->name );
3781                                         else
3782                                                 fprintf(stderr,"ERROR: NULL register\n");
3783                                 }
3784                         }
3785                 }
3786
3787
3788         }
3789 }
3790
3791 /*-----------------------------------------------------------------*/
3792 /* */
3793 /*-----------------------------------------------------------------*/
3794 void InsertpFlow(pCode *pc, pCode **pflow)
3795 {
3796         if(*pflow)
3797                 PCFL(*pflow)->end = pc;
3798
3799         if(!pc || !pc->next)
3800                 return;
3801
3802         *pflow = newpCodeFlow();
3803         pCodeInsertAfter(pc, *pflow);
3804 }
3805
3806 /*-----------------------------------------------------------------*/
3807 /* BuildFlow(pBlock *pb) - examine the code in a pBlock and build  */
3808 /*                         the flow blocks.                        */
3809 /*
3810 * BuildFlow inserts pCodeFlow objects into the pCode chain at each
3811 * point the instruction flow changes.
3812 */
3813 /*-----------------------------------------------------------------*/
3814 void BuildFlow(pBlock *pb)
3815 {
3816         pCode *pc;
3817         pCode *last_pci=NULL;
3818         pCode *pflow=NULL;
3819         int seq = 0;
3820
3821         if(!pb)
3822                 return;
3823
3824         //fprintf (stderr,"build flow start seq %d  ",GpcFlowSeq);
3825         /* Insert a pCodeFlow object at the beginning of a pBlock */
3826
3827         InsertpFlow(pb->pcHead, &pflow);
3828
3829         //pflow = newpCodeFlow();    /* Create a new Flow object */
3830         //pflow->next = pb->pcHead;  /* Make the current head the next object */
3831         //pb->pcHead->prev = pflow;  /* let the current head point back to the flow object */
3832         //pb->pcHead = pflow;        /* Make the Flow object the head */
3833         //pflow->pb = pb;
3834
3835         for( pc = findNextInstruction(pb->pcHead);
3836         pc != NULL;
3837         pc=findNextInstruction(pc)) {
3838
3839                 pc->seq = seq++;
3840                 PCI(pc)->pcflow = PCFL(pflow);
3841
3842                 //fprintf(stderr," build: ");
3843                 //pflow->print(stderr,pflow);
3844
3845                 if( PCI(pc)->isSkip) {
3846
3847                 /* The two instructions immediately following this one
3848                         * mark the beginning of a new flow segment */
3849
3850                         while(pc && PCI(pc)->isSkip) {
3851
3852                                 PCI(pc)->pcflow = PCFL(pflow);
3853                                 pc->seq = seq-1;
3854                                 seq = 1;
3855
3856                                 InsertpFlow(pc, &pflow);
3857                                 pc=findNextInstruction(pc->next);
3858                         }
3859
3860                         seq = 0;
3861
3862                         if(!pc)
3863                                 break;
3864
3865                         PCI(pc)->pcflow = PCFL(pflow);
3866                         pc->seq = 0;
3867                         InsertpFlow(pc, &pflow);
3868
3869                 } else if ( PCI(pc)->isBranch && !checkLabel(findNextInstruction(pc->next)))  {
3870
3871                         InsertpFlow(pc, &pflow);
3872                         seq = 0;
3873
3874                 } else if (checkLabel(pc)) {
3875
3876                 /* This instruction marks the beginning of a
3877                         * new flow segment */
3878
3879                         pc->seq = 0;
3880                         seq = 1;
3881
3882                         /* If the previous pCode is not a flow object, then
3883                         * insert a new flow object. (This check prevents
3884                         * two consecutive flow objects from being insert in
3885                         * the case where a skip instruction preceeds an
3886                         * instruction containing a label.) */
3887
3888                         if(last_pci && (PCI(last_pci)->pcflow == PCFL(pflow)))
3889                                 InsertpFlow(findPrevInstruction(pc->prev), &pflow);
3890
3891                         PCI(pc)->pcflow = PCFL(pflow);
3892
3893                 }
3894                 last_pci = pc;
3895                 pc = pc->next;
3896         }
3897
3898         //fprintf (stderr,",end seq %d",GpcFlowSeq);
3899         if(pflow)
3900                 PCFL(pflow)->end = pb->pcTail;
3901 }
3902
3903 /*-------------------------------------------------------------------*/
3904 /* unBuildFlow(pBlock *pb) - examine the code in a pBlock and build  */
3905 /*                           the flow blocks.                        */
3906 /*
3907 * unBuildFlow removes pCodeFlow objects from a pCode chain
3908 */
3909 /*-----------------------------------------------------------------*/
3910 void unBuildFlow(pBlock *pb)
3911 {
3912         pCode *pc,*pcnext;
3913
3914         if(!pb)
3915                 return;
3916
3917         pc = pb->pcHead;
3918
3919         while(pc) {
3920                 pcnext = pc->next;
3921
3922                 if(isPCI(pc)) {
3923
3924                         pc->seq = 0;
3925                         if(PCI(pc)->pcflow) {
3926                                 //free(PCI(pc)->pcflow);
3927                                 PCI(pc)->pcflow = NULL;
3928                         }
3929
3930                 } else if(isPCFL(pc) )
3931                         pc->destruct(pc);
3932
3933                 pc = pcnext;
3934         }
3935
3936
3937 }
3938
3939 /*-----------------------------------------------------------------*/
3940 /*-----------------------------------------------------------------*/
3941 void dumpCond(int cond)
3942 {
3943
3944         static char *pcc_str[] = {
3945                 //"PCC_NONE",
3946                 "PCC_REGISTER",
3947                         "PCC_C",
3948                         "PCC_Z",
3949                         "PCC_DC",
3950                         "PCC_W",
3951                         "PCC_EXAMINE_PCOP",
3952                         "PCC_REG_BANK0",
3953                         "PCC_REG_BANK1",
3954                         "PCC_REG_BANK2",
3955                         "PCC_REG_BANK3"
3956         };
3957
3958         int ncond = sizeof(pcc_str) / sizeof(char *);
3959         int i,j;
3960
3961         fprintf(stderr, "0x%04X\n",cond);
3962
3963         for(i=0,j=1; i<ncond; i++, j<<=1)
3964                 if(cond & j)
3965                         fprintf(stderr, "  %s\n",pcc_str[i]);
3966
3967 }
3968
3969 /*-----------------------------------------------------------------*/
3970 /*-----------------------------------------------------------------*/
3971 void FlowStats(pCodeFlow *pcflow)
3972 {
3973
3974         pCode *pc;
3975
3976         if(!isPCFL(pcflow))
3977                 return;
3978
3979         fprintf(stderr, " FlowStats - flow block (seq=%d)\n", pcflow->pc.seq);
3980
3981         pc = findNextpCode(PCODE(pcflow), PC_OPCODE);
3982
3983         if(!pc) {
3984                 fprintf(stderr, " FlowStats - empty flow (seq=%d)\n", pcflow->pc.seq);
3985                 return;
3986         }
3987
3988
3989         fprintf(stderr, "  FlowStats inCond: ");
3990         dumpCond(pcflow->inCond);
3991         fprintf(stderr, "  FlowStats outCond: ");
3992         dumpCond(pcflow->outCond);
3993
3994 }
3995
3996 /*-----------------------------------------------------------------*
3997 * int isBankInstruction(pCode *pc) - examine the pCode *pc to determine
3998 *    if it affects the banking bits.
3999 *
4000 * return: -1 == Banking bits are unaffected by this pCode.
4001 *
4002 * return: > 0 == Banking bits are affected.
4003 *
4004 *  If the banking bits are affected, then the returned value describes
4005 * which bits are affected and how they're affected. The lower half
4006 * of the integer maps to the bits that are affected, the upper half
4007 * to whether they're set or cleared.
4008 *
4009 *-----------------------------------------------------------------*/
4010 /*
4011 #define SET_BANK_BIT (1 << 16)
4012 #define CLR_BANK_BIT 0
4013
4014 static int isBankInstruction(pCode *pc)
4015 {
4016         regs *reg;
4017         int bank = -1;
4018
4019         if(!isPCI(pc))
4020                 return -1;
4021
4022         if( ( (reg = getRegFromInstruction(pc)) != NULL) && isSTATUS_REG(reg)) {
4023
4024                 // Check to see if the register banks are changing
4025                 if(PCI(pc)->isModReg) {
4026
4027                         pCodeOp *pcop = PCI(pc)->pcop;
4028                         switch(PCI(pc)->op) {
4029
4030                         case POC_BSF:
4031                                 if(PCORB(pcop)->bit == PIC_RP0_BIT) {
4032                                         //fprintf(stderr, "  isBankInstruction - Set RP0\n");
4033                                         return  SET_BANK_BIT | PIC_RP0_BIT;
4034                                 }
4035
4036                                 if(PCORB(pcop)->bit == PIC_RP1_BIT) {
4037                                         //fprintf(stderr, "  isBankInstruction - Set RP1\n");
4038                                         return  CLR_BANK_BIT | PIC_RP0_BIT;
4039                                 }
4040                                 break;
4041
4042                         case POC_BCF:
4043                                 if(PCORB(pcop)->bit == PIC_RP0_BIT) {
4044                                         //fprintf(stderr, "  isBankInstruction - Clr RP0\n");
4045                                         return  CLR_BANK_BIT | PIC_RP1_BIT;
4046                                 }
4047                                 if(PCORB(pcop)->bit == PIC_RP1_BIT) {
4048                                         //fprintf(stderr, "  isBankInstruction - Clr RP1\n");
4049                                         return  CLR_BANK_BIT | PIC_RP1_BIT;
4050                                 }
4051                                 break;
4052                         default:
4053                                 //fprintf(stderr, "  isBankInstruction - Status register is getting Modified by:\n");
4054                                 //genericPrint(stderr, pc);
4055                                 ;
4056                         }
4057                 }
4058
4059                                 }
4060
4061         return bank;
4062 }
4063 */
4064
4065 /*-----------------------------------------------------------------*/
4066 /*-----------------------------------------------------------------*/
4067 /*
4068 static void FillFlow(pCodeFlow *pcflow)
4069 {
4070         pCode *pc;
4071         int cur_bank;
4072
4073         if(!isPCFL(pcflow))
4074                 return;
4075
4076         //  fprintf(stderr, " FillFlow - flow block (seq=%d)\n", pcflow->pc.seq);
4077
4078         pc = findNextpCode(PCODE(pcflow), PC_OPCODE);
4079
4080         if(!pc) {
4081                 //fprintf(stderr, " FillFlow - empty flow (seq=%d)\n", pcflow->pc.seq);
4082                 return;
4083         }
4084
4085         cur_bank = -1;
4086
4087         do {
4088                 isBankInstruction(pc);
4089                 pc = pc->next;
4090         } while (pc && (pc != pcflow->end) && !isPCFL(pc));
4091         / *
4092                 if(!pc ) {
4093                         fprintf(stderr, "  FillFlow - Bad end of flow\n");
4094                 } else {
4095                         fprintf(stderr, "  FillFlow - Ending flow with\n  ");
4096                         pc->print(stderr,pc);
4097                 }
4098
4099                 fprintf(stderr, "  FillFlow inCond: ");
4100                 dumpCond(pcflow->inCond);
4101                 fprintf(stderr, "  FillFlow outCond: ");
4102                 dumpCond(pcflow->outCond);
4103                 * /
4104 }
4105 */
4106
4107 /*-----------------------------------------------------------------*/
4108 /*-----------------------------------------------------------------*/
4109 void LinkFlow_pCode(pCodeInstruction *from, pCodeInstruction *to)
4110 {
4111         pCodeFlowLink *fromLink, *toLink;
4112
4113         if(!from || !to || !to->pcflow || !from->pcflow)
4114                 return;
4115
4116         fromLink = newpCodeFlowLink(from->pcflow);
4117         toLink   = newpCodeFlowLink(to->pcflow);
4118
4119         addSetIfnotP(&(from->pcflow->to), toLink);   //to->pcflow);
4120         addSetIfnotP(&(to->pcflow->from), fromLink); //from->pcflow);
4121
4122 }
4123
4124 /*-----------------------------------------------------------------*
4125 * void LinkFlow(pBlock *pb)
4126 *
4127 * In BuildFlow, the PIC code has been partitioned into contiguous
4128 * non-branching segments. In LinkFlow, we determine the execution
4129 * order of these segments. For example, if one of the segments ends
4130 * with a skip, then we know that there are two possible flow segments
4131 * to which control may be passed.
4132 *-----------------------------------------------------------------*/
4133 void LinkFlow(pBlock *pb)
4134 {
4135         pCode *pc=NULL;
4136         pCode *pcflow;
4137         pCode *pct;
4138
4139         //fprintf(stderr,"linkflow \n");
4140
4141         for( pcflow = findNextpCode(pb->pcHead, PC_FLOW);
4142         pcflow != NULL;
4143         pcflow = findNextpCode(pcflow->next, PC_FLOW) ) {
4144
4145                 if(!isPCFL(pcflow))
4146                         fprintf(stderr, "LinkFlow - pcflow is not a flow object ");
4147
4148                 //fprintf(stderr," link: ");
4149                 //pcflow->print(stderr,pcflow);
4150
4151                 //FillFlow(PCFL(pcflow));
4152
4153                 pc = PCFL(pcflow)->end;
4154
4155                 //fprintf(stderr, "LinkFlow - flow block (seq=%d) ", pcflow->seq);
4156                 if(isPCI_SKIP(pc)) {
4157                         //fprintf(stderr, "ends with skip\n");
4158                         //pc->print(stderr,pc);
4159                         pct=findNextInstruction(pc->next);
4160                         LinkFlow_pCode(PCI(pc),PCI(pct));
4161                         pct=findNextInstruction(pct->next);
4162                         LinkFlow_pCode(PCI(pc),PCI(pct));
4163                         continue;
4164                 }
4165
4166                 if(isPCI_BRANCH(pc)) {
4167                         pCodeOpLabel *pcol = PCOLAB(PCI(pc)->pcop);
4168
4169                         //fprintf(stderr, "ends with branch\n  ");
4170                         //pc->print(stderr,pc);
4171
4172                         if(!(pcol && isPCOLAB(pcol))) {
4173                                 if((PCI(pc)->op != POC_RETLW) && (PCI(pc)->op != POC_RETURN) && (PCI(pc)->op != POC_CALL) && (PCI(pc)->op != POC_RETFIE) ) {
4174                                         pc->print(stderr,pc);
4175                                         fprintf(stderr, "ERROR: %s, branch instruction doesn't have label\n",__FUNCTION__);
4176                                 }
4177                                 continue;
4178                         }
4179
4180                         if( (pct = findLabelinpBlock(pb,pcol)) != NULL)
4181                                 LinkFlow_pCode(PCI(pc),PCI(pct));
4182                         else
4183                                 fprintf(stderr, "ERROR: %s, couldn't find label. key=%d,lab=%s\n",
4184                                 __FUNCTION__,pcol->key,((PCOP(pcol)->name)?PCOP(pcol)->name:"-"));
4185                         //fprintf(stderr,"newpCodeOpLabel: key=%d, name=%s\n",key,((s)?s:""));
4186
4187                         continue;
4188                 }
4189
4190                 if(isPCI(pc)) {
4191                         //fprintf(stderr, "ends with non-branching instruction:\n");
4192                         //pc->print(stderr,pc);
4193
4194                         LinkFlow_pCode(PCI(pc),PCI(findNextInstruction(pc->next)));
4195
4196                         continue;
4197                 }
4198
4199                 if(pc) {
4200                         //fprintf(stderr, "ends with unknown\n");
4201                         //pc->print(stderr,pc);
4202                         continue;
4203                 }
4204
4205                 //fprintf(stderr, "ends with nothing: ERROR\n");
4206
4207         }
4208 }
4209 /*-----------------------------------------------------------------*/
4210 /*-----------------------------------------------------------------*/
4211
4212 /*-----------------------------------------------------------------*/
4213 /*-----------------------------------------------------------------*/
4214 int isPCinFlow(pCode *pc, pCode *pcflow)
4215 {
4216
4217         if(!pc || !pcflow)
4218                 return 0;
4219
4220         if(!isPCI(pc) || !PCI(pc)->pcflow || !isPCFL(pcflow) )
4221                 return 0;
4222
4223         if( PCI(pc)->pcflow->pc.seq == pcflow->seq)
4224                 return 1;
4225
4226         return 0;
4227 }
4228
4229 /*-----------------------------------------------------------------*/
4230 /*-----------------------------------------------------------------*/
4231 /*
4232 static void BanksUsedFlow2(pCode *pcflow)
4233 {
4234         pCode *pc=NULL;
4235
4236         int bank = -1;
4237         bool RegUsed = 0;
4238
4239         regs *reg;
4240
4241         if(!isPCFL(pcflow)) {
4242                 fprintf(stderr, "BanksUsed - pcflow is not a flow object ");
4243                 return;
4244         }
4245
4246         pc = findNextInstruction(pcflow->next);
4247
4248         PCFL(pcflow)->lastBank = -1;
4249
4250         while(isPCinFlow(pc,pcflow)) {
4251
4252                 int bank_selected = isBankInstruction(pc);
4253
4254                 //if(PCI(pc)->pcflow)
4255                 //fprintf(stderr,"BanksUsedFlow2, looking at seq %d\n",PCI(pc)->pcflow->pc.seq);
4256
4257                 if(bank_selected > 0) {
4258                         //fprintf(stderr,"BanksUsed - mucking with bank %d\n",bank_selected);
4259
4260                         // This instruction is modifying banking bits before accessing registers
4261                         if(!RegUsed)
4262                                 PCFL(pcflow)->firstBank = -1;
4263
4264                         if(PCFL(pcflow)->lastBank == -1)
4265                                 PCFL(pcflow)->lastBank = 0;
4266
4267                         bank = (1 << (bank_selected & (PIC_RP0_BIT | PIC_RP1_BIT)));
4268                         if(bank_selected & SET_BANK_BIT)
4269                                 PCFL(pcflow)->lastBank |= bank;
4270
4271
4272                 } else {
4273                         reg = getRegFromInstruction(pc);
4274
4275                         if(reg && !isREGinBank(reg, bank)) {
4276                                 int allbanks = REGallBanks(reg);
4277                                 if(bank == -1)
4278                                         PCFL(pcflow)->firstBank = allbanks;
4279
4280                                 PCFL(pcflow)->lastBank = allbanks;
4281
4282                                 bank = allbanks;
4283                         }
4284                         RegUsed = 1;
4285                                                                 }
4286
4287                 pc = findNextInstruction(pc->next);
4288         }
4289
4290         //  fprintf(stderr,"BanksUsedFlow2 flow seq=%3d, first bank = 0x%03x, Last bank 0x%03x\n",
4291         //    pcflow->seq,PCFL(pcflow)->firstBank,PCFL(pcflow)->lastBank);
4292 }
4293 */
4294 /*-----------------------------------------------------------------*/
4295 /*-----------------------------------------------------------------*/
4296 /*
4297 static void BanksUsedFlow(pBlock *pb)
4298 {
4299         pCode *pcflow;
4300
4301
4302         //pb->pcHead->print(stderr, pb->pcHead);
4303
4304         pcflow = findNextpCode(pb->pcHead, PC_FLOW);
4305         //pcflow->print(stderr,pcflow);
4306
4307         for( pcflow = findNextpCode(pb->pcHead, PC_FLOW);
4308         pcflow != NULL;
4309         pcflow = findNextpCode(pcflow->next, PC_FLOW) ) {
4310
4311                 BanksUsedFlow2(pcflow);
4312         }
4313
4314 }
4315 */
4316
4317 /*-----------------------------------------------------------------*/
4318 /*-----------------------------------------------------------------*/
4319 static void pCodeInstructionInsertAfter(pCodeInstruction *pci, pCodeInstruction *new_pci)
4320 {
4321
4322         pCodeInsertAfter(pci->pc.prev, &new_pci->pc);
4323
4324         /* Move the label, if there is one */
4325
4326         if(pci->label) {
4327                 new_pci->label = pci->label;
4328                 pci->label = NULL;
4329         }
4330
4331         /* Move the C code comment, if there is one */
4332
4333         if(pci->cline) {
4334                 new_pci->cline = pci->cline;
4335                 pci->cline = NULL;
4336         }
4337
4338         /* The new instruction has the same pcflow block */
4339         new_pci->pcflow = pci->pcflow;
4340
4341 }
4342
4343 /*-----------------------------------------------------------------*/
4344 /*-----------------------------------------------------------------*/
4345 static void insertBankSwitch(pCodeInstruction *pci, int Set_Clear, int RP_BankBit)
4346 {
4347         pCode *new_pc;
4348
4349         new_pc = newpCode((Set_Clear?POC_BSF:POC_BCF),popCopyGPR2Bit(PCOP(&pc_status),RP_BankBit));
4350
4351         pCodeInstructionInsertAfter(pci, PCI(new_pc));
4352 }
4353
4354 /*-----------------------------------------------------------------*/
4355 /*-----------------------------------------------------------------*/
4356 static void insertBankSel(pCodeInstruction  *pci, const char *name)
4357 {
4358         pCode *new_pc;
4359
4360         pCodeOp *pcop = popCopyReg(PCOR(pci->pcop));
4361         pcop->type = PO_GPR_REGISTER; // Sometimes the type is set to legacy 8051 - so override it
4362         if (pcop->name == 0)
4363                 pcop->name = strdup(name);
4364         new_pc = newpCode(POC_BANKSEL, pcop);
4365
4366         pCodeInstructionInsertAfter(pci, PCI(new_pc));
4367 }
4368
4369 /*-----------------------------------------------------------------*/
4370 /* If the register is a fixed known addess then we can assign the  */
4371 /* bank selection bits. Otherwise the linker is going to assign    */
4372 /* the register location and thus has to set bank selection bits   */
4373 /* through the banksel directive.                                  */
4374 /* One critical assumption here is that within this C module all   */
4375 /* the locally allocated registers are in the same udata sector.   */
4376 /* Therefore banksel is only called for external registers or the  */
4377 /* first time a local register is encountered.                     */
4378 /*-----------------------------------------------------------------*/
4379 static int LastRegIdx; /* If the previous register is the same one again then no need to change bank. */
4380 static int BankSelect(pCodeInstruction *pci, int cur_bank, regs *reg)
4381 {
4382         int bank;
4383         int a = reg->alias>>7;
4384         if ((a&3) == 3) {
4385                 return cur_bank; // This register is available in all banks
4386         } else if ((a&1)&&((cur_bank==0)||(cur_bank==1))) {
4387                 return cur_bank; // This register is available in banks 0 & 1
4388         } else if (a&2) {
4389                 if (reg->address&0x80) {
4390                         if ((cur_bank==1)||(cur_bank==3)) {
4391                                 return cur_bank; // This register is available in banks 1 & 3
4392                         }
4393                 } else {
4394                         if ((cur_bank==0)||(cur_bank==1)) {
4395                                 return cur_bank; // This register is available in banks 0 & 2
4396                         }
4397                 }
4398         }
4399
4400         if (LastRegIdx == reg->rIdx) // If this is the same register as last time then it is in same bank
4401                 return cur_bank;
4402         LastRegIdx = reg->rIdx;
4403
4404         if (reg->isFixed) {
4405                 bank = REG_BANK(reg);
4406         } else if (reg->isExtern) {
4407                 bank = 'E'; // Unfixed extern registers are allocated by the linker therefore its bank is unknown
4408         } else {
4409                 bank = 'L'; // Unfixed local registers are allocated by the linker therefore its bank is unknown
4410         }
4411         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.
4412                 return 'L'; // Local registers are presumed to be in same linker assigned bank
4413         } else if ((bank == 'L')&&(cur_bank != 'L')) { // Reg is now local and linker to assign bank
4414                 insertBankSel(pci, reg->name); // Let linker choose the bank selection
4415         } else if (bank == 'E') { // Reg is now extern and linker to assign bank
4416                 insertBankSel(pci, reg->name); // Let linker choose the bank selection
4417         } 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
4418                 insertBankSwitch(pci, bank&1, PIC_RP0_BIT);
4419                 if (getMaxRam()&0x100)
4420                         insertBankSwitch(pci, bank&2, PIC_RP1_BIT);
4421         } else { // Current bank and new register banks known - can set bank bits
4422                 switch((cur_bank^bank) & 3) {
4423                 case 0:
4424                         break;
4425                 case 1:
4426                         insertBankSwitch(pci, bank&1, PIC_RP0_BIT);
4427                         break;
4428                 case 2:
4429                         insertBankSwitch(pci, bank&2, PIC_RP1_BIT);
4430                         break;
4431                 case 3:
4432                         insertBankSwitch(pci, bank&1, PIC_RP0_BIT);
4433                         if (getMaxRam()&0x100)
4434                                 insertBankSwitch(pci, bank&2, PIC_RP1_BIT);
4435                         break;
4436                 }
4437         }
4438
4439         return bank;
4440 }
4441
4442 /*-----------------------------------------------------------------*/
4443 /* Check for bank selection pcodes instructions and modify         */
4444 /* cur_bank to match.                                              */
4445 /*-----------------------------------------------------------------*/
4446 static int IsBankChange(pCode *pc, regs *reg, int *cur_bank) {
4447
4448         if (isSTATUS_REG(reg)) {
4449
4450                 if (PCI(pc)->op == POC_BCF) {
4451                         int old_bank = *cur_bank;
4452                         if (PCORB(PCI(pc)->pcop)->bit == PIC_RP0_BIT) {
4453                                 /* If current bank is unknown or linker assigned then set to 0 else just change the bit */
4454                                 if (*cur_bank & ~(0x3))
4455                                         *cur_bank = 0;
4456                                 else
4457                                         *cur_bank = *cur_bank&0x2;
4458                                 LastRegIdx = reg->rIdx;
4459                         } else if (PCORB(PCI(pc)->pcop)->bit == PIC_RP1_BIT) {
4460                                 /* If current bank is unknown or linker assigned then set to 0 else just change the bit */
4461                                 if (*cur_bank & ~(0x3))
4462                                         *cur_bank = 0;
4463                                 else
4464                                         *cur_bank = *cur_bank&0x1;
4465                                 LastRegIdx = reg->rIdx;
4466                         }
4467                         return old_bank != *cur_bank;
4468                 }
4469
4470                 if (PCI(pc)->op == POC_BSF) {
4471                         int old_bank = *cur_bank;
4472                         if (PCORB(PCI(pc)->pcop)->bit == PIC_RP0_BIT) {
4473                                 /* If current bank is unknown or linker assigned then set to bit else just change the bit */
4474                                 if (*cur_bank & ~(0x3))
4475                                         *cur_bank = 0x1;
4476                                 else
4477                                         *cur_bank = (*cur_bank&0x2) | 0x1;
4478                                 LastRegIdx = reg->rIdx;
4479                         } else if (PCORB(PCI(pc)->pcop)->bit == PIC_RP1_BIT) {
4480                                 /* If current bank is unknown or linker assigned then set to bit else just change the bit */
4481                                 if (*cur_bank & ~(0x3))
4482                                         *cur_bank = 0x2;
4483                                 else
4484                                         *cur_bank = (*cur_bank&0x1) | 0x2;
4485                                 LastRegIdx = reg->rIdx;
4486                         }
4487                         return old_bank != *cur_bank;
4488                 }
4489
4490         } else if (PCI(pc)->op == POC_BANKSEL) {
4491                 int old_bank = *cur_bank;
4492                 *cur_bank = (PCOR(PCI(pc)->pcop)->r->isExtern) ? 'E' : 'L';
4493                 LastRegIdx = reg->rIdx;
4494                 return old_bank != *cur_bank;
4495         }
4496
4497         return 0;
4498 }
4499
4500 /*-----------------------------------------------------------------*/
4501 /* Set bank selection if necessary                                 */
4502 /*-----------------------------------------------------------------*/
4503 static int DoBankSelect(pCode *pc, int cur_bank) {
4504         pCode *pcprev;
4505         regs *reg;
4506
4507         if(!isPCI(pc))
4508                 return cur_bank;
4509
4510         if (isCALL(pc)) {
4511                 pCode *pcf = findFunction(get_op_from_instruction(PCI(pc)));
4512                 if (pcf && isPCF(pcf)) {
4513                         pCode *pcfr;
4514                         int rbank = 'U'; // Undetermined
4515                         FixRegisterBanking(pcf->pb,cur_bank); // Ensure this block has had its banks selection done
4516                         // Check all the returns to work out what bank is selected
4517                         for (pcfr=pcf->pb->pcHead; pcfr; pcfr=pcfr->next) {
4518                                 if (isPCI(pcfr)) {
4519                                         if ((PCI(pcfr)->op==POC_RETURN) || (PCI(pcfr)->op==POC_RETLW)) {
4520                                                 if (rbank == 'U')
4521                                                         rbank = PCFL(pcfr)->lastBank;
4522                                                 else
4523                                                         if (rbank != PCFL(pcfr)->lastBank)
4524                                                                 return -1; // Unknown bank - multiple returns with different banks
4525                                         }
4526                                 }
4527                         }
4528                         if (rbank == 'U')
4529                                 return -1; // Unknown bank
4530                         return rbank;
4531                 } else if (isPCOS(PCI(pc)->pcop) && PCOS(PCI(pc)->pcop)->isPublic) {
4532                         /* Extern functions may use registers in different bank - must call banksel */
4533                         return -1; /* Unknown bank */
4534                 }
4535         }
4536
4537         if ((isPCI(pc)) && (PCI(pc)->op == POC_BANKSEL)) {
4538                 return -1; /* New bank unknown - linkers choice. */
4539         }
4540
4541         reg = getRegFromInstruction(pc);
4542         if (reg) {
4543
4544                 if (IsBankChange(pc,reg,&cur_bank))
4545                         return cur_bank;
4546
4547                 if (!isPCI_LIT(pc)) {
4548
4549                         /* Examine the instruction before this one to make sure it is
4550                         * not a skip type instruction */
4551                         pcprev = findPrevpCode(pc->prev, PC_OPCODE);
4552
4553                         if(!pcprev || (pcprev && !isPCI_SKIP(pcprev))) {
4554                                 cur_bank = BankSelect(PCI(pc),cur_bank,reg);
4555                         } else {
4556                                 cur_bank = BankSelect(PCI(pcprev),cur_bank,reg);
4557                         }
4558                         if (!PCI(pc)->pcflow)
4559                                 fprintf(stderr,"PCI ID=%d missing flow pointer ???\n",pc->id);
4560                         else
4561                                 PCI(pc)->pcflow->lastBank = cur_bank; /* Maintain pCodeFlow lastBank state */
4562                 }
4563         }
4564         return cur_bank;
4565 }
4566
4567 /*-----------------------------------------------------------------*/
4568 /*-----------------------------------------------------------------*/
4569 /*
4570 static void FixRegisterBankingInFlow(pCodeFlow *pcfl, int cur_bank)
4571 {
4572         pCode *pc=NULL;
4573         pCode *pcprev=NULL;
4574
4575         if(!pcfl)
4576                 return;
4577
4578         pc = findNextInstruction(pcfl->pc.next);
4579
4580         while(isPCinFlow(pc,PCODE(pcfl))) {
4581
4582                 cur_bank = DoBankSelect(pc,cur_bank);
4583                 pcprev = pc;
4584                 pc = findNextInstruction(pc->next);
4585
4586         }
4587
4588         if(pcprev && cur_bank) {
4589                 // Set bank state to unknown at the end of each flow block
4590                 cur_bank = -1;
4591         }
4592
4593 }
4594 */
4595 /*-----------------------------------------------------------------*/
4596 /*int compareBankFlow - compare the banking requirements between   */
4597 /*  flow objects. */
4598 /*-----------------------------------------------------------------*/
4599 /*
4600 int compareBankFlow(pCodeFlow *pcflow, pCodeFlowLink *pcflowLink, int toORfrom)
4601 {
4602
4603         if(!pcflow || !pcflowLink || !pcflowLink->pcflow)
4604                 return 0;
4605
4606         if(!isPCFL(pcflow) || !isPCFL(pcflowLink->pcflow))
4607                 return 0;
4608
4609         if(pcflow->firstBank == -1)
4610                 return 0;
4611
4612
4613         if(pcflowLink->pcflow->firstBank == -1) {
4614                 pCodeFlowLink *pctl = setFirstItem( toORfrom ?
4615                         pcflowLink->pcflow->to :
4616                 pcflowLink->pcflow->from);
4617                 return compareBankFlow(pcflow, pctl, toORfrom);
4618         }
4619
4620         if(toORfrom) {
4621                 if(pcflow->lastBank == pcflowLink->pcflow->firstBank)
4622                         return 0;
4623
4624                 pcflowLink->bank_conflict++;
4625                 pcflowLink->pcflow->FromConflicts++;
4626                 pcflow->ToConflicts++;
4627         } else {
4628
4629                 if(pcflow->firstBank == pcflowLink->pcflow->lastBank)
4630                         return 0;
4631
4632                 pcflowLink->bank_conflict++;
4633                 pcflowLink->pcflow->ToConflicts++;
4634                 pcflow->FromConflicts++;
4635
4636         }
4637         / *
4638                 fprintf(stderr,"compare flow found conflict: seq %d from conflicts %d, to conflicts %d\n",
4639                 pcflowLink->pcflow->pc.seq,
4640                 pcflowLink->pcflow->FromConflicts,
4641                 pcflowLink->pcflow->ToConflicts);
4642         * /
4643                 return 1;
4644
4645 }
4646 */
4647 /*-----------------------------------------------------------------*/
4648 /*-----------------------------------------------------------------*/
4649 /*
4650 void FixBankFlow(pBlock *pb)
4651 {
4652         pCode *pc=NULL;
4653         pCode *pcflow;
4654         pCodeFlowLink *pcfl;
4655
4656         pCode *pcflow_max_To=NULL;
4657         pCode *pcflow_max_From=NULL;
4658         int max_ToConflicts=0;
4659         int max_FromConflicts=0;
4660
4661         /fprintf(stderr,"Fix Bank flow \n");
4662         pcflow = findNextpCode(pb->pcHead, PC_FLOW);
4663
4664
4665         / *
4666                 First loop through all of the flow objects in this pcode block
4667                 and fix the ones that have banking conflicts between the
4668                 entry and exit.
4669                 * /
4670
4671         //fprintf(stderr, "FixBankFlow - Phase 1\n");
4672
4673         for( pcflow = findNextpCode(pb->pcHead, PC_FLOW);
4674         pcflow != NULL;
4675         pcflow = findNextpCode(pcflow->next, PC_FLOW) ) {
4676
4677                 if(!isPCFL(pcflow)) {
4678                         fprintf(stderr, "FixBankFlow - pcflow is not a flow object ");
4679                         continue;
4680                 }
4681
4682                 if(PCFL(pcflow)->firstBank != PCFL(pcflow)->lastBank  &&
4683                         PCFL(pcflow)->firstBank >= 0 &&
4684                         PCFL(pcflow)->lastBank >= 0 ) {
4685
4686                         int cur_bank = (PCFL(pcflow)->firstBank < PCFL(pcflow)->lastBank) ?
4687                                 PCFL(pcflow)->firstBank : PCFL(pcflow)->lastBank;
4688
4689                         FixRegisterBankingInFlow(PCFL(pcflow),cur_bank);
4690                         BanksUsedFlow2(pcflow);
4691
4692                 }
4693         }
4694
4695         //fprintf(stderr, "FixBankFlow - Phase 2\n");
4696
4697         for( pcflow = findNextpCode(pb->pcHead, PC_FLOW);
4698         pcflow != NULL;
4699         pcflow = findNextpCode(pcflow->next, PC_FLOW) ) {
4700
4701                 int nFlows;
4702                 int nConflicts;
4703
4704                 if(!isPCFL(pcflow)) {
4705                         fprintf(stderr, "FixBankFlow - pcflow is not a flow object ");
4706                         continue;
4707                 }
4708
4709                 PCFL(pcflow)->FromConflicts = 0;
4710                 PCFL(pcflow)->ToConflicts = 0;
4711
4712                 nFlows = 0;
4713                 nConflicts = 0;
4714
4715                 //fprintf(stderr, " FixBankFlow flow seq %d\n",pcflow->seq);
4716                 pcfl = setFirstItem(PCFL(pcflow)->from);
4717                 while (pcfl) {
4718
4719                         pc = PCODE(pcfl->pcflow);
4720
4721                         if(!isPCFL(pc)) {
4722                                 fprintf(stderr,"oops dumpflow - to is not a pcflow\n");
4723                                 pc->print(stderr,pc);
4724                         }
4725
4726                         nConflicts += compareBankFlow(PCFL(pcflow), pcfl, 0);
4727                         nFlows++;
4728
4729                         pcfl=setNextItem(PCFL(pcflow)->from);
4730                 }
4731
4732                 if((nFlows >= 2) && nConflicts && (PCFL(pcflow)->firstBank>0)) {
4733                         //fprintf(stderr, " From conflicts flow seq %d, nflows %d ,nconflicts %d\n",pcflow->seq,nFlows, nConflicts);
4734
4735                         FixRegisterBankingInFlow(PCFL(pcflow),-1);
4736                         BanksUsedFlow2(pcflow);
4737
4738                         continue;  / * Don't need to check the flow from here - it's already been fixed * /
4739
4740                 }
4741
4742                 nFlows = 0;
4743                 nConflicts = 0;
4744
4745                 pcfl = setFirstItem(PCFL(pcflow)->to);
4746                 while (pcfl) {
4747
4748                         pc = PCODE(pcfl->pcflow);
4749                         if(!isPCFL(pc)) {
4750                                 fprintf(stderr,"oops dumpflow - to is not a pcflow\n");
4751                                 pc->print(stderr,pc);
4752                         }
4753
4754                         nConflicts += compareBankFlow(PCFL(pcflow), pcfl, 1);
4755                         nFlows++;
4756
4757                         pcfl=setNextItem(PCFL(pcflow)->to);
4758                 }
4759
4760                 if((nFlows >= 2) && nConflicts &&(nConflicts != nFlows) && (PCFL(pcflow)->lastBank>0)) {
4761                         //fprintf(stderr, " To conflicts flow seq %d, nflows %d ,nconflicts %d\n",pcflow->seq,nFlows, nConflicts);
4762
4763                         FixRegisterBankingInFlow(PCFL(pcflow),-1);
4764                         BanksUsedFlow2(pcflow);
4765                 }
4766         }
4767
4768         / *
4769                 Loop through the flow objects again and find the ones with the
4770                 maximum conflicts
4771                 * /
4772
4773                 for( pcflow = findNextpCode(pb->pcHead, PC_FLOW);
4774                 pcflow != NULL;
4775                 pcflow = findNextpCode(pcflow->next, PC_FLOW) ) {
4776
4777                         if(PCFL(pcflow)->ToConflicts > max_ToConflicts)
4778                                 pcflow_max_To = pcflow;
4779
4780                         if(PCFL(pcflow)->FromConflicts > max_FromConflicts)
4781                                 pcflow_max_From = pcflow;
4782                 }
4783                 / *
4784                         if(pcflow_max_To)
4785                                 fprintf(stderr,"compare flow Max To conflicts: seq %d conflicts %d\n",
4786                                 PCFL(pcflow_max_To)->pc.seq,
4787                                 PCFL(pcflow_max_To)->ToConflicts);
4788
4789                         if(pcflow_max_From)
4790                                 fprintf(stderr,"compare flow Max From conflicts: seq %d conflicts %d\n",
4791                                 PCFL(pcflow_max_From)->pc.seq,
4792                                 PCFL(pcflow_max_From)->FromConflicts);
4793                         * /
4794 }
4795 */
4796
4797 /*-----------------------------------------------------------------*/
4798 /*-----------------------------------------------------------------*/
4799 void DumpFlow(pBlock *pb)
4800 {
4801         pCode *pc=NULL;
4802         pCode *pcflow;
4803         pCodeFlowLink *pcfl;
4804
4805
4806         fprintf(stderr,"Dump flow \n");
4807         pb->pcHead->print(stderr, pb->pcHead);
4808
4809         pcflow = findNextpCode(pb->pcHead, PC_FLOW);
4810         pcflow->print(stderr,pcflow);
4811
4812         for( pcflow = findNextpCode(pb->pcHead, PC_FLOW);
4813         pcflow != NULL;
4814         pcflow = findNextpCode(pcflow->next, PC_FLOW) ) {
4815
4816                 if(!isPCFL(pcflow)) {
4817                         fprintf(stderr, "DumpFlow - pcflow is not a flow object ");
4818                         continue;
4819                 }
4820                 fprintf(stderr,"dumping: ");
4821                 pcflow->print(stderr,pcflow);
4822                 FlowStats(PCFL(pcflow));
4823
4824                 for(pcfl = setFirstItem(PCFL(pcflow)->to); pcfl; pcfl=setNextItem(PCFL(pcflow)->to)) {
4825
4826                         pc = PCODE(pcfl->pcflow);
4827
4828                         fprintf(stderr, "    from seq %d:\n",pc->seq);
4829                         if(!isPCFL(pc)) {
4830                                 fprintf(stderr,"oops dumpflow - from is not a pcflow\n");
4831                                 pc->print(stderr,pc);
4832                         }
4833
4834                 }
4835
4836                 for(pcfl = setFirstItem(PCFL(pcflow)->to); pcfl; pcfl=setNextItem(PCFL(pcflow)->to)) {
4837
4838                         pc = PCODE(pcfl->pcflow);
4839
4840                         fprintf(stderr, "    to seq %d:\n",pc->seq);
4841                         if(!isPCFL(pc)) {
4842                                 fprintf(stderr,"oops dumpflow - to is not a pcflow\n");
4843                                 pc->print(stderr,pc);
4844                         }
4845
4846                 }
4847
4848         }
4849
4850 }
4851
4852 /*-----------------------------------------------------------------*/
4853 /*-----------------------------------------------------------------*/
4854 int OptimizepBlock(pBlock *pb)
4855 {
4856         pCode *pc, *pcprev;
4857         int matches =0;
4858
4859         if(!pb || !peepOptimizing)
4860                 return 0;
4861
4862         DFPRINTF((stderr," Optimizing pBlock: %c\n",getpBlock_dbName(pb)));
4863         /*
4864         for(pc = pb->pcHead; pc; pc = pc->next)
4865         matches += pCodePeepMatchRule(pc);
4866         */
4867
4868         pc = findNextInstruction(pb->pcHead);
4869         if(!pc)
4870                 return 0;
4871
4872         pcprev = pc->prev;
4873         do {
4874
4875
4876                 if(pCodePeepMatchRule(pc)) {
4877
4878                         matches++;
4879
4880                         if(pcprev)
4881                                 pc = findNextInstruction(pcprev->next);
4882                         else
4883                                 pc = findNextInstruction(pb->pcHead);
4884                 } else
4885                         pc = findNextInstruction(pc->next);
4886         } while(pc);
4887
4888         if(matches)
4889                 DFPRINTF((stderr," Optimizing pBlock: %c - matches=%d\n",getpBlock_dbName(pb),matches));
4890         return matches;
4891
4892 }
4893
4894 /*-----------------------------------------------------------------*/
4895 /* pBlockRemoveUnusedLabels - remove the pCode labels from the     */
4896 /*-----------------------------------------------------------------*/
4897 pCode * findInstructionUsingLabel(pCodeLabel *pcl, pCode *pcs)
4898 {
4899         pCode *pc;
4900
4901         for(pc = pcs; pc; pc = pc->next) {
4902
4903                 if((pc->type == PC_OPCODE) &&
4904                         (PCI(pc)->pcop) &&
4905                         (PCI(pc)->pcop->type == PO_LABEL) &&
4906                         (PCOLAB(PCI(pc)->pcop)->key == pcl->key))
4907                         return pc;
4908         }
4909
4910
4911         return NULL;
4912 }
4913
4914 /*-----------------------------------------------------------------*/
4915 /*-----------------------------------------------------------------*/
4916 void exchangeLabels(pCodeLabel *pcl, pCode *pc)
4917 {
4918
4919         char *s=NULL;
4920
4921         if(isPCI(pc) &&
4922                 (PCI(pc)->pcop) &&
4923                 (PCI(pc)->pcop->type == PO_LABEL)) {
4924
4925                 pCodeOpLabel *pcol = PCOLAB(PCI(pc)->pcop);
4926
4927                 //fprintf(stderr,"changing label key from %d to %d\n",pcol->key, pcl->key);
4928                 if(pcol->pcop.name)
4929                         free(pcol->pcop.name);
4930
4931                         /* If the key is negative, then we (probably) have a label to
4932                 * a function and the name is already defined */
4933
4934                 if(pcl->key>0)
4935                         sprintf(s=buffer,"_%05d_DS_",pcl->key);
4936                 else
4937                         s = pcl->label;
4938
4939                 //sprintf(buffer,"_%05d_DS_",pcl->key);
4940                 if(!s) {
4941                         fprintf(stderr, "ERROR %s:%d function label is null\n",__FUNCTION__,__LINE__);
4942                 }
4943                 pcol->pcop.name = Safe_strdup(s);
4944                 pcol->key = pcl->key;
4945                 //pc->print(stderr,pc);
4946
4947         }
4948
4949
4950 }
4951
4952 /*-----------------------------------------------------------------*/
4953 /* pBlockRemoveUnusedLabels - remove the pCode labels from the     */
4954 /*                            pCode chain if they're not used.     */
4955 /*-----------------------------------------------------------------*/
4956 void pBlockRemoveUnusedLabels(pBlock *pb)
4957 {
4958         pCode *pc; pCodeLabel *pcl;
4959
4960         if(!pb)
4961                 return;
4962
4963         for(pc = pb->pcHead; (pc=findNextInstruction(pc->next)) != NULL; ) {
4964
4965                 pBranch *pbr = PCI(pc)->label;
4966                 if(pbr && pbr->next) {
4967                         pCode *pcd = pb->pcHead;
4968
4969                         //fprintf(stderr, "multiple labels\n");
4970                         //pc->print(stderr,pc);
4971
4972                         pbr = pbr->next;
4973                         while(pbr) {
4974
4975                                 while ( (pcd = findInstructionUsingLabel(PCL(PCI(pc)->label->pc), pcd)) != NULL) {
4976                                         //fprintf(stderr,"Used by:\n");
4977                                         //pcd->print(stderr,pcd);
4978
4979                                         exchangeLabels(PCL(pbr->pc),pcd);
4980
4981                                         pcd = pcd->next;
4982                                 }
4983                                 pbr = pbr->next;
4984                         }
4985                 }
4986         }
4987
4988         for(pc = pb->pcHead; pc; pc = pc->next) {
4989
4990                 if(isPCL(pc)) // Label pcode
4991                         pcl = PCL(pc);
4992                 else if (isPCI(pc) && PCI(pc)->label) // pcode instruction with a label
4993                         pcl = PCL(PCI(pc)->label->pc);
4994                 else continue;
4995
4996                 //fprintf(stderr," found  A LABEL !!! key = %d, %s\n", pcl->key,pcl->label);
4997
4998                 /* This pCode is a label, so search the pBlock to see if anyone
4999                 * refers to it */
5000
5001                 if( (pcl->key>0) && (!findInstructionUsingLabel(pcl, pb->pcHead))) {
5002                         //if( !findInstructionUsingLabel(pcl, pb->pcHead)) {
5003                         /* Couldn't find an instruction that refers to this label
5004                         * So, unlink the pCode label from it's pCode chain
5005                         * and destroy the label */
5006                         //fprintf(stderr," removed  A LABEL !!! key = %d, %s\n", pcl->key,pcl->label);
5007
5008                         DFPRINTF((stderr," !!! REMOVED A LABEL !!! key = %d, %s\n", pcl->key,pcl->label));
5009                         if(pc->type == PC_LABEL) {
5010                                 unlinkpCode(pc);
5011                                 pCodeLabelDestruct(pc);
5012                         } else {
5013                                 unlinkpCodeFromBranch(pc, PCODE(pcl));
5014                                 /*if(pc->label->next == NULL && pc->label->pc == NULL) {
5015                                 free(pc->label);
5016                         }*/
5017                         }
5018
5019                 }
5020         }
5021
5022 }
5023
5024
5025 /*-----------------------------------------------------------------*/
5026 /* pBlockMergeLabels - remove the pCode labels from the pCode      */
5027 /*                     chain and put them into pBranches that are  */
5028 /*                     associated with the appropriate pCode       */
5029 /*                     instructions.                               */
5030 /*-----------------------------------------------------------------*/
5031 void pBlockMergeLabels(pBlock *pb)
5032 {
5033         pBranch *pbr;
5034         pCode *pc, *pcnext=NULL;
5035
5036         if(!pb)
5037                 return;
5038
5039         /* First, Try to remove any unused labels */
5040         //pBlockRemoveUnusedLabels(pb);
5041
5042         /* Now loop through the pBlock and merge the labels with the opcodes */
5043
5044         pc = pb->pcHead;
5045         //  for(pc = pb->pcHead; pc; pc = pc->next) {
5046
5047         while(pc) {
5048                 pCode *pcn = pc->next;
5049
5050                 if(pc->type == PC_LABEL) {
5051
5052                         //fprintf(stderr," checking merging label %s\n",PCL(pc)->label);
5053                         //fprintf(stderr,"Checking label key = %d\n",PCL(pc)->key);
5054                         if((pcnext = findNextInstruction(pc) )) {
5055
5056                                 // Unlink the pCode label from it's pCode chain
5057                                 unlinkpCode(pc);
5058
5059                                 //fprintf(stderr,"Merged label key = %d\n",PCL(pc)->key);
5060                                 // And link it into the instruction's pBranch labels. (Note, since
5061                                 // it's possible to have multiple labels associated with one instruction
5062                                 // we must provide a means to accomodate the additional labels. Thus
5063                                 // the labels are placed into the singly-linked list "label" as
5064                                 // opposed to being a single member of the pCodeInstruction.)
5065
5066                                 //_ALLOC(pbr,sizeof(pBranch));
5067                                 pbr = Safe_calloc(1,sizeof(pBranch));
5068                                 pbr->pc = pc;
5069                                 pbr->next = NULL;
5070
5071                                 PCI(pcnext)->label = pBranchAppend(PCI(pcnext)->label,pbr);
5072
5073                         } else {
5074                                 fprintf(stderr, "WARNING: couldn't associate label %s with an instruction\n",PCL(pc)->label);
5075                         }
5076                 } else if(pc->type == PC_CSOURCE) {
5077
5078                         /* merge the source line symbolic info into the next instruction */
5079                         if((pcnext = findNextInstruction(pc) )) {
5080
5081                                 // Unlink the pCode label from it's pCode chain
5082                                 unlinkpCode(pc);
5083                                 PCI(pcnext)->cline = PCCS(pc);
5084                                 //fprintf(stderr, "merging CSRC\n");
5085                                 //genericPrint(stderr,pcnext);
5086                         }
5087
5088                 }
5089                 pc = pcn;
5090         }
5091         pBlockRemoveUnusedLabels(pb);
5092
5093 }
5094
5095 /*-----------------------------------------------------------------*/
5096 /*-----------------------------------------------------------------*/
5097 int OptimizepCode(char dbName)
5098 {
5099 #define MAX_PASSES 4
5100
5101         int matches = 0;
5102         int passes = 0;
5103         pBlock *pb;
5104
5105         if(!the_pFile)
5106                 return 0;
5107
5108         DFPRINTF((stderr," Optimizing pCode\n"));
5109
5110         do {
5111                 matches = 0;
5112                 for(pb = the_pFile->pbHead; pb; pb = pb->next) {
5113                         if('*' == dbName || getpBlock_dbName(pb) == dbName)
5114                                 matches += OptimizepBlock(pb);
5115                 }
5116         }
5117         while(matches && ++passes < MAX_PASSES);
5118
5119         return matches;
5120 }
5121
5122 /*-----------------------------------------------------------------*/
5123 /* popCopyGPR2Bit - copy a pcode operator                          */
5124 /*-----------------------------------------------------------------*/
5125
5126 pCodeOp *popCopyGPR2Bit(pCodeOp *pc, int bitval)
5127 {
5128         pCodeOp *pcop;
5129
5130         pcop = newpCodeOpBit(pc->name, bitval, 0);
5131
5132         if( !( (pcop->type == PO_LABEL) ||
5133                 (pcop->type == PO_LITERAL) ||
5134                 (pcop->type == PO_STR) ))
5135                 PCOR(pcop)->r = PCOR(pc)->r;  /* This is dangerous... */
5136
5137         return pcop;
5138 }
5139
5140
5141 /*-----------------------------------------------------------------*/
5142 /*-----------------------------------------------------------------*/
5143 static void FixRegisterBanking(pBlock *pb,int cur_bank)
5144 {
5145         pCode *pc;
5146         int firstBank = 'U';
5147
5148         if(!pb)
5149                 return;
5150
5151         for (pc=pb->pcHead; pc; pc=pc->next) {
5152                 if (isPCFL(pc)) {
5153                         firstBank = PCFL(pc)->firstBank;
5154                         break;
5155                 }
5156         }
5157         if (firstBank != 'U') {
5158                 /* This block has already been done */
5159                 if (firstBank != cur_bank) {
5160                         /* This block has started with a different bank - must adjust it */
5161                         if ((firstBank != -1)&&(firstBank != 'E')) { /* The first bank start off unknown or extern then need not worry as banksel will be called */
5162                                 while (pc) {
5163                                         if (isPCI(pc)) {
5164                                                 regs *reg = getRegFromInstruction(pc);
5165                                                 if (reg) {
5166                                                         DoBankSelect(pc,cur_bank);
5167                                                 }
5168                                         }
5169                                         pc = pc->next;
5170                                 }
5171                         }
5172                 }
5173                 return;
5174         }
5175
5176         /* loop through all of the pCodes within this pblock setting the bank selection, ignoring any branching */
5177         LastRegIdx = -1;
5178         cur_bank = -1;
5179         for (pc=pb->pcHead; pc; pc=pc->next) {
5180                 if (isPCFL(pc)) {
5181                         PCFL(pc)->firstBank = cur_bank;
5182                         continue;
5183                 }
5184                 cur_bank = DoBankSelect(pc,cur_bank);
5185         }
5186
5187         /* Trace through branches and set the bank selection as required. */
5188         LastRegIdx = -1;
5189         cur_bank = -1;
5190         for (pc=pb->pcHead; pc; pc=pc->next) {
5191                 if (isPCFL(pc)) {
5192                         PCFL(pc)->firstBank = cur_bank;
5193                         continue;
5194                 }
5195                 if (isPCI(pc)) {
5196                         if (PCI(pc)->op == POC_GOTO) {
5197                                 int lastRegIdx = LastRegIdx;
5198                                 pCode *pcb = pc;
5199                                 /* Trace through branch */
5200                                 pCode *pcl = findLabel(PCOLAB(PCI(pcb)->pcop));
5201                                 while (pcl) {
5202                                         if (isPCI(pcl)) {
5203                                                 regs *reg = getRegFromInstruction(pcl);
5204                                                 if (reg) {
5205                                                         int bankUnknown = -1;
5206                                                         if (IsBankChange(pcl,reg,&bankUnknown)) /* Look for any bank change */
5207                                                                 break;
5208                                                         if (cur_bank != DoBankSelect(pcl,cur_bank)) /* Set bank selection if necessary */
5209                                                                 break;
5210                                                 }
5211                                         }
5212                                         pcl = pcl->next;
5213                                 }
5214                                 LastRegIdx = lastRegIdx;
5215                         } else {
5216                                 /* Keep track out current bank */
5217                                 regs *reg = getRegFromInstruction(pc);
5218                                 if (reg)
5219                                         IsBankChange(pc,reg,&cur_bank);
5220                         }
5221                 }
5222         }
5223 }
5224
5225
5226 /*-----------------------------------------------------------------*/
5227 /*-----------------------------------------------------------------*/
5228 void pBlockDestruct(pBlock *pb)
5229 {
5230
5231         if(!pb)
5232                 return;
5233
5234
5235         free(pb);
5236
5237 }
5238
5239 /*-----------------------------------------------------------------*/
5240 /* void mergepBlocks(char dbName) - Search for all pBlocks with the*/
5241 /*                                  name dbName and combine them   */
5242 /*                                  into one block                 */
5243 /*-----------------------------------------------------------------*/
5244 void mergepBlocks(char dbName)
5245 {
5246
5247         pBlock *pb, *pbmerged = NULL,*pbn;
5248
5249         pb = the_pFile->pbHead;
5250
5251         //fprintf(stderr," merging blocks named %c\n",dbName);
5252         while(pb) {
5253
5254                 pbn = pb->next;
5255                 //fprintf(stderr,"looking at %c\n",getpBlock_dbName(pb));
5256                 if( getpBlock_dbName(pb) == dbName) {
5257
5258                         //fprintf(stderr," merged block %c\n",dbName);
5259
5260                         if(!pbmerged) {
5261                                 pbmerged = pb;
5262                         } else {
5263                                 addpCode2pBlock(pbmerged, pb->pcHead);
5264                                 /* addpCode2pBlock doesn't handle the tail: */
5265                                 pbmerged->pcTail = pb->pcTail;
5266
5267                                 pb->prev->next = pbn;
5268                                 if(pbn)
5269                                         pbn->prev = pb->prev;
5270
5271
5272                                 pBlockDestruct(pb);
5273                         }
5274                         //printpBlock(stderr, pbmerged);
5275                 }
5276                 pb = pbn;
5277         }
5278
5279 }
5280
5281 /*-----------------------------------------------------------------*/
5282 /* AnalyzeFlow - Examine the flow of the code and optimize         */
5283 /*                                                                 */
5284 /* level 0 == minimal optimization                                 */
5285 /*   optimize registers that are used only by two instructions     */
5286 /* level 1 == maximal optimization                                 */
5287 /*   optimize by looking at pairs of instructions that use the     */
5288 /*   register.                                                     */
5289 /*-----------------------------------------------------------------*/
5290
5291 void AnalyzeFlow(int level)
5292 {
5293         static int times_called=0;
5294
5295         pBlock *pb;
5296
5297         if(!the_pFile)
5298                 return;
5299
5300
5301                 /* if this is not the first time this function has been called,
5302         then clean up old flow information */
5303         if(times_called++) {
5304                 for(pb = the_pFile->pbHead; pb; pb = pb->next)
5305                         unBuildFlow(pb);
5306
5307                 RegsUnMapLiveRanges();
5308
5309         }
5310
5311         GpcFlowSeq = 1;
5312
5313         /* Phase 2 - Flow Analysis - Register Banking
5314         *
5315         * In this phase, the individual flow blocks are examined
5316         * and register banking is fixed.
5317         */
5318
5319         //for(pb = the_pFile->pbHead; pb; pb = pb->next)
5320         //FixRegisterBanking(pb);
5321
5322         /* Phase 2 - Flow Analysis
5323         *
5324         * In this phase, the pCode is partition into pCodeFlow
5325         * blocks. The flow blocks mark the points where a continuous
5326         * stream of instructions changes flow (e.g. because of
5327         * a call or goto or whatever).
5328         */
5329
5330         for(pb = the_pFile->pbHead; pb; pb = pb->next)
5331                 BuildFlow(pb);
5332
5333
5334                 /* Phase 2 - Flow Analysis - linking flow blocks
5335                 *
5336                 * In this phase, the individual flow blocks are examined
5337                 * to determine their order of excution.
5338         */
5339
5340         for(pb = the_pFile->pbHead; pb; pb = pb->next)
5341                 LinkFlow(pb);
5342
5343                 /* Phase 3 - Flow Analysis - Flow Tree
5344                 *
5345                 * In this phase, the individual flow blocks are examined
5346                 * to determine their order of excution.
5347         */
5348
5349         for(pb = the_pFile->pbHead; pb; pb = pb->next)
5350                 BuildFlowTree(pb);
5351
5352
5353                 /* Phase x - Flow Analysis - Used Banks
5354                 *
5355                 * In this phase, the individual flow blocks are examined
5356                 * to determine the Register Banks they use
5357         */
5358
5359         //  for(pb = the_pFile->pbHead; pb; pb = pb->next)
5360         //    FixBankFlow(pb);
5361
5362
5363         for(pb = the_pFile->pbHead; pb; pb = pb->next)
5364                 pCodeRegMapLiveRanges(pb);
5365
5366         RemoveUnusedRegisters();
5367
5368         //  for(pb = the_pFile->pbHead; pb; pb = pb->next)
5369         pCodeRegOptimizeRegUsage(level);
5370
5371         OptimizepCode('*');
5372
5373
5374         /*
5375         for(pb = the_pFile->pbHead; pb; pb = pb->next)
5376         DumpFlow(pb);
5377         */
5378         /* debug stuff */
5379         /*
5380         for(pb = the_pFile->pbHead; pb; pb = pb->next) {
5381     pCode *pcflow;
5382     for( pcflow = findNextpCode(pb->pcHead, PC_FLOW);
5383     (pcflow = findNextpCode(pcflow, PC_FLOW)) != NULL;
5384     pcflow = pcflow->next) {
5385
5386           FillFlow(PCFL(pcflow));
5387           }
5388           }
5389         */
5390         /*
5391         for(pb = the_pFile->pbHead; pb; pb = pb->next) {
5392     pCode *pcflow;
5393     for( pcflow = findNextpCode(pb->pcHead, PC_FLOW);
5394     (pcflow = findNextpCode(pcflow, PC_FLOW)) != NULL;
5395     pcflow = pcflow->next) {
5396
5397           FlowStats(PCFL(pcflow));
5398           }
5399           }
5400         */
5401 }
5402
5403 /*-----------------------------------------------------------------*/
5404 /* AnalyzeBanking - Called after the memory addresses have been    */
5405 /*                  assigned to the registers.                     */
5406 /*                                                                 */
5407 /*-----------------------------------------------------------------*/
5408
5409 void AnalyzeBanking(void)
5410 {
5411         pBlock  *pb;
5412
5413         if(!picIsInitialized()) {
5414                 setDefMaxRam(); // Max RAM has not been included, so use default setting
5415         }
5416
5417         /* Phase x - Flow Analysis - Used Banks
5418         *
5419         * In this phase, the individual flow blocks are examined
5420         * to determine the Register Banks they use
5421         */
5422
5423         AnalyzeFlow(0);
5424         AnalyzeFlow(1);
5425
5426         //  for(pb = the_pFile->pbHead; pb; pb = pb->next)
5427         //    BanksUsedFlow(pb);
5428         for(pb = the_pFile->pbHead; pb; pb = pb->next)
5429                 FixRegisterBanking(pb,-1); // cur_bank is unknown
5430
5431 }
5432
5433 /*-----------------------------------------------------------------*/
5434 /*-----------------------------------------------------------------*/
5435 DEFSETFUNC (resetrIdx)
5436 {
5437         regs *r = (regs *)item;
5438         if (!r->isFixed) {
5439                 r->rIdx = 0;
5440         }
5441
5442         return 0;
5443 }
5444
5445 /*-----------------------------------------------------------------*/
5446 /* InitRegReuse - Initialises variables for code analyzer          */
5447 /*-----------------------------------------------------------------*/
5448
5449 void InitReuseReg(void)
5450 {
5451         /* Find end of statically allocated variables for start idx */
5452         unsigned maxIdx = 0x20; /* Start from begining of GPR. Note may not be 0x20 on some PICs */
5453         regs *r;
5454         for (r = setFirstItem(dynDirectRegs); r; r = setNextItem(dynDirectRegs)) {
5455                 if (r->type != REG_SFR) {
5456                         maxIdx += r->size; /* Increment for all statically allocated variables */
5457                 }
5458         }
5459         peakIdx = maxIdx;
5460         applyToSet(dynAllocRegs,resetrIdx); /* Reset all rIdx to zero. */
5461 }
5462
5463 /*-----------------------------------------------------------------*/
5464 /*-----------------------------------------------------------------*/
5465 static unsigned register_reassign(pBlock *pb, unsigned idx)
5466 {
5467         pCode *pc;
5468
5469         /* check recursion */
5470         pc = setFirstItem(pb->function_entries);
5471         if(!pc)
5472                 return idx;
5473
5474         pb->visited = 1;
5475
5476         DFPRINTF((stderr," reassigning registers for function \"%s\"\n",PCF(pc)->fname));
5477
5478         if (pb->tregisters) {
5479                 regs *r;
5480                 for (r = setFirstItem(pb->tregisters); r; r = setNextItem(pb->tregisters)) {
5481                         if (r->type == REG_GPR) {
5482                                 if (!r->isFixed) {
5483                                         if (r->rIdx < (int)idx) {
5484                                                 char s[20];
5485                                                 r->rIdx = idx++;
5486                                                 if (peakIdx < idx) peakIdx = idx;
5487                                                 sprintf(s,"r0x%02X", r->rIdx);
5488                                                 DFPRINTF((stderr," reassigning register \"%s\" to \"%s\"\n",r->name,s));
5489                                                 free(r->name);
5490                                                 r->name = Safe_strdup(s);
5491                                         }
5492                                 }
5493                         }
5494                 }
5495         }
5496         for(pc = setFirstItem(pb->function_calls); pc; pc = setNextItem(pb->function_calls)) {
5497
5498                 if(pc->type == PC_OPCODE && PCI(pc)->op == POC_CALL) {
5499                         char *dest = get_op_from_instruction(PCI(pc));
5500
5501                         pCode *pcn = findFunction(dest);
5502                         if(pcn) {
5503                                 register_reassign(pcn->pb,idx);
5504                         }
5505                 }
5506
5507         }
5508
5509         return idx;
5510 }
5511
5512 /*------------------------------------------------------------------*/
5513 /* ReuseReg were call tree permits                                  */
5514 /*                                                                  */
5515 /*  Re-allocate the GPR for optimum reuse for a given pblock        */
5516 /*  eg  if a function m() calls function f1() and f2(), where f1    */
5517 /*  allocates a local variable vf1 and f2 allocates a local         */
5518 /*  variable vf2. Then providing f1 and f2 do not call each other   */
5519 /*  they may share the same general purpose registers for vf1 and   */
5520 /*  vf2.                                                            */
5521 /*  This is done by first setting the the regs rIdx to start after  */
5522 /*  all the global variables, then walking through the call tree    */
5523 /*  renaming the registers to match their new idx and incrementng   */
5524 /*  it as it goes. If a function has already been called it will    */
5525 /*  only rename the registers if it has already used up those       */
5526 /*  registers ie rIdx of the function's registers is lower than the */
5527 /*  current rIdx. That way the register will not be reused while    */
5528 /*  still being used by an eariler function call.                   */
5529 /*                                                                  */
5530 /*  Note for this to work the functions need to be declared static. */
5531 /*                                                                  */
5532 /*------------------------------------------------------------------*/
5533 void ReuseReg(void)
5534 {
5535         pBlock  *pb;
5536         InitReuseReg();
5537         for(pb = the_pFile->pbHead; pb; pb = pb->next) {
5538                 /* Non static functions can be called from other modules so their registers must reassign */
5539                 if (pb->function_entries&&(PCF(setFirstItem(pb->function_entries))->isPublic||!pb->visited))
5540                         register_reassign(pb,peakIdx);
5541         }
5542 }
5543
5544 /*-----------------------------------------------------------------*/
5545 /* buildCallTree - look at the flow and extract all of the calls   */
5546 /*                                                                 */
5547 /*-----------------------------------------------------------------*/
5548
5549 void buildCallTree(void    )
5550 {
5551         pBranch *pbr;
5552         pBlock  *pb;
5553         pCode   *pc;
5554
5555         if(!the_pFile)
5556                 return;
5557
5558                 /* Now build the call tree.
5559                 First we examine all of the pCodes for functions.
5560                 Keep in mind that the function boundaries coincide
5561                 with pBlock boundaries.
5562
5563                   The algorithm goes something like this:
5564                   We have two nested loops. The outer loop iterates
5565                   through all of the pBlocks/functions. The inner
5566                   loop iterates through all of the pCodes for
5567                   a given pBlock. When we begin iterating through
5568                   a pBlock, the variable pc_fstart, pCode of the start
5569                   of a function, is cleared. We then search for pCodes
5570                   of type PC_FUNCTION. When one is encountered, we
5571                   initialize pc_fstart to this and at the same time
5572                   associate a new pBranch object that signifies a
5573                   branch entry. If a return is found, then this signifies
5574                   a function exit point. We'll link the pCodes of these
5575                   returns to the matching pc_fstart.
5576
5577                         When we're done, a doubly linked list of pBranches
5578                         will exist. The head of this list is stored in
5579                         `the_pFile', which is the meta structure for all
5580                         of the pCode. Look at the printCallTree function
5581                         on how the pBranches are linked together.
5582
5583         */
5584         for(pb = the_pFile->pbHead; pb; pb = pb->next) {
5585                 pCode *pc_fstart=NULL;
5586                 for(pc = pb->pcHead; pc; pc = pc->next) {
5587                         if(isPCF(pc)) {
5588                                 pCodeFunction *pcf = PCF(pc);
5589                                 if (pcf->fname) {
5590
5591                                         if(STRCASECMP(pcf->fname, "_main") == 0) {
5592                                                 //fprintf(stderr," found main \n");
5593                                                 pb->cmemmap = NULL;  /* FIXME do we need to free ? */
5594                                                 pb->dbName = 'M';
5595                                         }
5596
5597                                         pbr = Safe_calloc(1,sizeof(pBranch));
5598                                         pbr->pc = pc_fstart = pc;
5599                                         pbr->next = NULL;
5600
5601                                         the_pFile->functions = pBranchAppend(the_pFile->functions,pbr);
5602
5603                                         // Here's a better way of doing the same:
5604                                         addSet(&pb->function_entries, pc);
5605
5606                                 } else {
5607                                         // Found an exit point in a function, e.g. return
5608                                         // (Note, there may be more than one return per function)
5609                                         if(pc_fstart)
5610                                                 pBranchLink(PCF(pc_fstart), pcf);
5611
5612                                         addSet(&pb->function_exits, pc);
5613                                 }
5614                         } else if(isCALL(pc)) {
5615                                 addSet(&pb->function_calls,pc);
5616                         }
5617                 }
5618         }
5619 }
5620
5621 /*-----------------------------------------------------------------*/
5622 /* AnalyzepCode - parse the pCode that has been generated and form */
5623 /*                all of the logical connections.                  */
5624 /*                                                                 */
5625 /* Essentially what's done here is that the pCode flow is          */
5626 /* determined.                                                     */
5627 /*-----------------------------------------------------------------*/
5628
5629 void AnalyzepCode(char dbName)
5630 {
5631         pBlock *pb;
5632         int i,changes;
5633
5634         if(!the_pFile)
5635                 return;
5636
5637         mergepBlocks('D');
5638
5639
5640         /* Phase 1 - Register allocation and peep hole optimization
5641         *
5642         * The first part of the analysis is to determine the registers
5643         * that are used in the pCode. Once that is done, the peep rules
5644         * are applied to the code. We continue to loop until no more
5645         * peep rule optimizations are found (or until we exceed the
5646         * MAX_PASSES threshold).
5647         *
5648         * When done, the required registers will be determined.
5649         *
5650         */
5651         i = 0;
5652         do {
5653
5654                 DFPRINTF((stderr," Analyzing pCode: PASS #%d\n",i+1));
5655
5656                 /* First, merge the labels with the instructions */
5657                 for(pb = the_pFile->pbHead; pb; pb = pb->next) {
5658                         if('*' == dbName || getpBlock_dbName(pb) == dbName) {
5659
5660                                 DFPRINTF((stderr," analyze and merging block %c\n",dbName));
5661                                 pBlockMergeLabels(pb);
5662                                 AnalyzepBlock(pb);
5663                         } else {
5664                                 DFPRINTF((stderr," skipping block analysis dbName=%c blockname=%c\n",dbName,getpBlock_dbName));
5665                         }
5666                 }
5667
5668                 changes = OptimizepCode(dbName);
5669
5670         } while(changes && (i++ < MAX_PASSES));
5671
5672         buildCallTree();
5673 }
5674
5675 /*-----------------------------------------------------------------*/
5676 /* ispCodeFunction - returns true if *pc is the pCode of a         */
5677 /*                   function                                      */
5678 /*-----------------------------------------------------------------*/
5679 bool ispCodeFunction(pCode *pc)
5680 {
5681
5682         if(pc && pc->type == PC_FUNCTION && PCF(pc)->fname)
5683                 return 1;
5684
5685         return 0;
5686 }
5687
5688 /*-----------------------------------------------------------------*/
5689 /* findFunction - Search for a function by name (given the name)   */
5690 /*                in the set of all functions that are in a pBlock */
5691 /* (note - I expect this to change because I'm planning to limit   */
5692 /*  pBlock's to just one function declaration                      */
5693 /*-----------------------------------------------------------------*/
5694 pCode *findFunction(char *fname)
5695 {
5696         pBlock *pb;
5697         pCode *pc;
5698         if(!fname)
5699                 return NULL;
5700
5701         for(pb = the_pFile->pbHead; pb; pb = pb->next) {
5702
5703                 pc = setFirstItem(pb->function_entries);
5704                 while(pc) {
5705
5706                         if((pc->type == PC_FUNCTION) &&
5707                                 (PCF(pc)->fname) &&
5708                                 (strcmp(fname, PCF(pc)->fname)==0))
5709                                 return pc;
5710
5711                         pc = setNextItem(pb->function_entries);
5712
5713                 }
5714
5715         }
5716         return NULL;
5717 }
5718
5719 void MarkUsedRegisters(set *regset)
5720 {
5721
5722         regs *r1,*r2;
5723
5724         for(r1=setFirstItem(regset); r1; r1=setNextItem(regset)) {
5725                 r2 = pic14_regWithIdx(r1->rIdx);
5726                 if (r2) {
5727                         r2->isFree = 0;
5728                         r2->wasUsed = 1;
5729                 }
5730         }
5731 }
5732
5733 void pBlockStats(FILE *of, pBlock *pb)
5734 {
5735
5736         pCode *pc;
5737         regs  *r;
5738
5739         fprintf(of,";***\n;  pBlock Stats: dbName = %c\n;***\n",getpBlock_dbName(pb));
5740
5741         // for now just print the first element of each set
5742         pc = setFirstItem(pb->function_entries);
5743         if(pc) {
5744                 fprintf(of,";entry:  ");
5745                 pc->print(of,pc);
5746         }
5747         pc = setFirstItem(pb->function_exits);
5748         if(pc) {
5749                 fprintf(of,";has an exit\n");
5750                 //pc->print(of,pc);
5751         }
5752
5753         pc = setFirstItem(pb->function_calls);
5754         if(pc) {
5755                 fprintf(of,";functions called:\n");
5756
5757                 while(pc) {
5758                         if(pc->type == PC_OPCODE && PCI(pc)->op == POC_CALL) {
5759                                 fprintf(of,";   %s\n",get_op_from_instruction(PCI(pc)));
5760                         }
5761                         pc = setNextItem(pb->function_calls);
5762                 }
5763         }
5764
5765         r = setFirstItem(pb->tregisters);
5766         if(r) {
5767                 int n = elementsInSet(pb->tregisters);
5768
5769                 fprintf(of,";%d compiler assigned register%c:\n",n, ( (n!=1) ? 's' : ' '));
5770
5771                 while (r) {
5772                         fprintf(of,";   %s\n",r->name);
5773                         r = setNextItem(pb->tregisters);
5774                 }
5775         }
5776 }
5777
5778 /*-----------------------------------------------------------------*/
5779 /*-----------------------------------------------------------------*/
5780 #if 0
5781 static void sequencepCode(void)
5782 {
5783         pBlock *pb;
5784         pCode *pc;
5785
5786
5787         for(pb = the_pFile->pbHead; pb; pb = pb->next) {
5788
5789                 pb->seq = GpCodeSequenceNumber+1;
5790
5791                 for( pc = pb->pcHead; pc; pc = pc->next)
5792                         pc->seq = ++GpCodeSequenceNumber;
5793         }
5794
5795 }
5796 #endif
5797
5798 /*-----------------------------------------------------------------*/
5799 /*-----------------------------------------------------------------*/
5800 /*
5801 set *register_usage(pBlock *pb)
5802 {
5803         pCode *pc,*pcn;
5804         set *registers=NULL;
5805         set *registersInCallPath = NULL;
5806
5807         / * check recursion * /
5808
5809                 pc = setFirstItem(pb->function_entries);
5810
5811         if(!pc)
5812                 return registers;
5813
5814         pb->visited = 1;
5815
5816         if(pc->type != PC_FUNCTION)
5817                 fprintf(stderr,"%s, first pc is not a function???\n",__FUNCTION__);
5818
5819         pc = setFirstItem(pb->function_calls);
5820         for( ; pc; pc = setNextItem(pb->function_calls)) {
5821
5822                 if(pc->type == PC_OPCODE && PCI(pc)->op == POC_CALL) {
5823                         char *dest = get_op_from_instruction(PCI(pc));
5824
5825                         pcn = findFunction(dest);
5826                         if(pcn)
5827                                 registersInCallPath = register_usage(pcn->pb);
5828                 } else
5829                         fprintf(stderr,"BUG? pCode isn't a POC_CALL %d\n",__LINE__);
5830
5831         }
5832
5833 #ifdef PCODE_DEBUG
5834         pBlockStats(stderr,pb);  // debug
5835 #endif
5836
5837         // Mark the registers in this block as used.
5838
5839         MarkUsedRegisters(pb->tregisters);
5840         if(registersInCallPath) {
5841                 / * registers were used in the functions this pBlock has called * /
5842                 / * so now, we need to see if these collide with the ones we are * /
5843                 / * using here * /
5844
5845                         regs *r1,*r2, *newreg;
5846
5847                 DFPRINTF((stderr,"comparing registers\n"));
5848
5849                 r1 = setFirstItem(registersInCallPath);
5850                 while(r1) {
5851                         if (r1->type != REG_STK) {
5852                                 r2 = setFirstItem(pb->tregisters);
5853
5854                                 while(r2 && (r2->type != REG_STK)) {
5855
5856                                         if(r2->rIdx == r1->rIdx) {
5857                                                 newreg = pic14_findFreeReg(REG_GPR);
5858
5859
5860                                                 if(!newreg) {
5861                                                         DFPRINTF((stderr,"Bummer, no more registers.\n"));
5862                                                         exit(1);
5863                                                 }
5864
5865                                                 DFPRINTF((stderr,"Cool found register collision nIdx=%d moving to %d\n",
5866                                                         r1->rIdx, newreg->rIdx));
5867                                                 r2->rIdx = newreg->rIdx;
5868                                                 if(newreg->name)
5869                                                         r2->name = Safe_strdup(newreg->name);
5870                                                 else
5871                                                         r2->name = NULL;
5872                                                 newreg->isFree = 0;
5873                                                 newreg->wasUsed = 1;
5874                                         }
5875                                         r2 = setNextItem(pb->tregisters);
5876                                 }
5877                         }
5878
5879                         r1 = setNextItem(registersInCallPath);
5880                 }
5881
5882                 / * Collisions have been resolved. Now free the registers in the call path * /
5883                 r1 = setFirstItem(registersInCallPath);
5884                 while(r1) {
5885                         newreg = pic14_regWithIdx(r1->rIdx);
5886                         if (newreg) newreg->isFree = 1;
5887                         r1 = setNextItem(registersInCallPath);
5888                 }
5889
5890         }// else
5891         //      MarkUsedRegisters(pb->registers);
5892
5893         registers = unionSets(pb->tregisters, registersInCallPath, THROW_NONE);
5894 #ifdef PCODE_DEBUG
5895         if(registers)
5896                 DFPRINTF((stderr,"returning regs\n"));
5897         else
5898                 DFPRINTF((stderr,"not returning regs\n"));
5899
5900         DFPRINTF((stderr,"pBlock after register optim.\n"));
5901         pBlockStats(stderr,pb);  // debug
5902 #endif
5903
5904         return registers;
5905 }
5906 */
5907
5908 /*-----------------------------------------------------------------*/
5909 /* printCallTree - writes the call tree to a file                  */
5910 /*                                                                 */
5911 /*-----------------------------------------------------------------*/
5912 void pct2(FILE *of,pBlock *pb,int indent)
5913 {
5914         pCode *pc,*pcn;
5915         int i;
5916         //  set *registersInCallPath = NULL;
5917
5918         if(!of)
5919                 return;
5920
5921         if(indent > 10)
5922                 return; //recursion ?
5923
5924         pc = setFirstItem(pb->function_entries);
5925
5926         if(!pc)
5927                 return;
5928
5929         pb->visited = 0;
5930
5931         for(i=0;i<indent;i++)   // Indentation
5932                 fputc(' ',of);
5933
5934         if(pc->type == PC_FUNCTION)
5935                 fprintf(of,"%s\n",PCF(pc)->fname);
5936         else
5937                 return;  // ???
5938
5939
5940         pc = setFirstItem(pb->function_calls);
5941         for( ; pc; pc = setNextItem(pb->function_calls)) {
5942
5943                 if(pc->type == PC_OPCODE && PCI(pc)->op == POC_CALL) {
5944                         char *dest = get_op_from_instruction(PCI(pc));
5945
5946                         pcn = findFunction(dest);
5947                         if(pcn)
5948                                 pct2(of,pcn->pb,indent+1);
5949                 } else
5950                         fprintf(of,"BUG? pCode isn't a POC_CALL %d\n",__LINE__);
5951
5952         }
5953
5954
5955 }
5956
5957
5958 /*-----------------------------------------------------------------*/
5959 /* printCallTree - writes the call tree to a file                  */
5960 /*                                                                 */
5961 /*-----------------------------------------------------------------*/
5962
5963 void printCallTree(FILE *of)
5964 {
5965         pBranch *pbr;
5966         pBlock  *pb;
5967         pCode   *pc;
5968
5969         if(!the_pFile)
5970                 return;
5971
5972         if(!of)
5973                 of = stderr;
5974
5975         fprintf(of, "\npBlock statistics\n");
5976         for(pb = the_pFile->pbHead; pb;  pb = pb->next )
5977                 pBlockStats(of,pb);
5978
5979
5980
5981         fprintf(of,"Call Tree\n");
5982         pbr = the_pFile->functions;
5983         while(pbr) {
5984                 if(pbr->pc) {
5985                         pc = pbr->pc;
5986                         if(!ispCodeFunction(pc))
5987                                 fprintf(of,"bug in call tree");
5988
5989
5990                         fprintf(of,"Function: %s\n", PCF(pc)->fname);
5991
5992                         while(pc->next && !ispCodeFunction(pc->next)) {
5993                                 pc = pc->next;
5994                                 if(pc->type == PC_OPCODE && PCI(pc)->op == POC_CALL)
5995                                         fprintf(of,"\t%s\n",get_op_from_instruction(PCI(pc)));
5996                         }
5997                 }
5998
5999                 pbr = pbr->next;
6000         }
6001
6002
6003         fprintf(of,"\n**************\n\na better call tree\n");
6004         for(pb = the_pFile->pbHead; pb; pb = pb->next) {
6005                 if(pb->visited)
6006                         pct2(of,pb,0);
6007         }
6008
6009         for(pb = the_pFile->pbHead; pb; pb = pb->next) {
6010                 fprintf(of,"block dbname: %c\n", getpBlock_dbName(pb));
6011         }
6012 }
6013
6014
6015
6016 /*-----------------------------------------------------------------*/
6017 /*                                                                 */
6018 /*-----------------------------------------------------------------*/
6019
6020 void InlineFunction(pBlock *pb)
6021 {
6022         pCode *pc;
6023         pCode *pc_call;
6024
6025         if(!pb)
6026                 return;
6027
6028         pc = setFirstItem(pb->function_calls);
6029
6030         for( ; pc; pc = setNextItem(pb->function_calls)) {
6031
6032                 if(isCALL(pc)) {
6033                         pCode *pcn = findFunction(get_op_from_instruction(PCI(pc)));
6034                         pCode *pcp = pc->prev;
6035                         pCode *pct;
6036                         pCode *pce;
6037
6038                         pBranch *pbr;
6039
6040                         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 */
6041
6042                                 InlineFunction(pcn->pb);
6043
6044                                 /*
6045                                 At this point, *pc points to a CALL mnemonic, and
6046                                 *pcn points to the function that is being called.
6047
6048                                   To in-line this call, we need to remove the CALL
6049                                   and RETURN(s), and link the function pCode in with
6050                                   the CALLee pCode.
6051
6052                                 */
6053
6054                                 pc_call = pc;
6055
6056                                 /* Check if previous instruction was a bit skip */
6057                                 if (isPCI_BITSKIP(pcp)) {
6058                                         pCodeLabel *pcl;
6059                                         /* Invert skip instruction and add a goto */
6060                                         PCI(pcp)->op = (PCI(pcp)->op == POC_BTFSS) ? POC_BTFSC : POC_BTFSS;
6061
6062                                         if(isPCL(pc_call->next)) { // Label pcode
6063                                                 pcl = PCL(pc_call->next);
6064                                         } else if (isPCI(pc_call->next) && PCI(pc_call->next)->label) { // pcode instruction with a label
6065                                                 pcl = PCL(PCI(pc_call->next)->label->pc);
6066                                         } else {
6067                                                 pcl = PCL(newpCodeLabel(NULL, newiTempLabel(NULL)->key+100));
6068                                                 PCI(pc_call->next)->label->pc = (struct pCode*)pcl;
6069                                         }
6070                                         pCodeInsertAfter(pcp, newpCode(POC_GOTO, newpCodeOp(pcl->label,PO_STR)));
6071                                 }
6072
6073                                 /* remove callee pBlock from the pBlock linked list */
6074                                 removepBlock(pcn->pb);
6075
6076                                 pce = pcn;
6077                                 while(pce) {
6078                                         pce->pb = pb;
6079                                         pce = pce->next;
6080                                 }
6081
6082                                 /* Remove the Function pCode */
6083                                 pct = findNextInstruction(pcn->next);
6084
6085                                 /* Link the function with the callee */
6086                                 if (pcp) pcp->next = pcn->next;
6087                                 pcn->next->prev = pcp;
6088
6089                                 /* Convert the function name into a label */
6090
6091                                 pbr = Safe_calloc(1,sizeof(pBranch));
6092                                 pbr->pc = newpCodeLabel(PCF(pcn)->fname, -1);
6093                                 pbr->next = NULL;
6094                                 PCI(pct)->label = pBranchAppend(PCI(pct)->label,pbr);
6095                                 PCI(pct)->label = pBranchAppend(PCI(pct)->label,PCI(pc_call)->label);
6096
6097                                 /* turn all of the return's except the last into goto's */
6098                                 /* check case for 2 instruction pBlocks */
6099                                 pce = findNextInstruction(pcn->next);
6100                                 while(pce) {
6101                                         pCode *pce_next = findNextInstruction(pce->next);
6102
6103                                         if(pce_next == NULL) {
6104                                                 /* found the last return */
6105                                                 pCode *pc_call_next =  findNextInstruction(pc_call->next);
6106
6107                                                 //fprintf(stderr,"found last return\n");
6108                                                 //pce->print(stderr,pce);
6109                                                 pce->prev->next = pc_call->next;
6110                                                 pc_call->next->prev = pce->prev;
6111                                                 PCI(pc_call_next)->label = pBranchAppend(PCI(pc_call_next)->label,
6112                                                         PCI(pce)->label);
6113                                         }
6114
6115                                         pce = pce_next;
6116                                 }
6117
6118                         }
6119                 } else
6120                         fprintf(stderr,"BUG? pCode isn't a POC_CALL %d\n",__LINE__);
6121
6122         }
6123
6124 }
6125
6126 /*-----------------------------------------------------------------*/
6127 /*                                                                 */
6128 /*-----------------------------------------------------------------*/
6129
6130 void InlinepCode(void)
6131 {
6132
6133         pBlock  *pb;
6134         pCode   *pc;
6135
6136         if(!the_pFile)
6137                 return;
6138
6139         if(!functionInlining)
6140                 return;
6141
6142                 /* Loop through all of the function definitions and count the
6143         * number of times each one is called */
6144         //fprintf(stderr,"inlining %d\n",__LINE__);
6145
6146         for(pb = the_pFile->pbHead; pb; pb = pb->next) {
6147
6148                 pc = setFirstItem(pb->function_calls);
6149
6150                 for( ; pc; pc = setNextItem(pb->function_calls)) {
6151
6152                         if(isCALL(pc)) {
6153                                 pCode *pcn = findFunction(get_op_from_instruction(PCI(pc)));
6154                                 if(pcn && isPCF(pcn)) {
6155                                         PCF(pcn)->ncalled++;
6156                                 }
6157                         } else
6158                                 fprintf(stderr,"BUG? pCode isn't a POC_CALL %d\n",__LINE__);
6159
6160                 }
6161         }
6162
6163         //fprintf(stderr,"inlining %d\n",__LINE__);
6164
6165         /* Now, Loop through the function definitions again, but this
6166         * time inline those functions that have only been called once. */
6167
6168         InlineFunction(the_pFile->pbHead);
6169         //fprintf(stderr,"inlining %d\n",__LINE__);
6170
6171         for(pb = the_pFile->pbHead; pb; pb = pb->next)
6172                 unBuildFlow(pb);
6173
6174 }