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

   1 /*-------------------------------------------------------------------------
   2
   3    pcodepeep.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 #include <stdlib.h>
  23
  24 #include "common.h"   // Include everything in the SDCC src directory
  25 #include "newalloc.h"
  26
  27
  28 #include "pcode.h"
  29 #include "ralloc.h"
  30
  31 #if defined(__BORLANDC__) || defined(_MSC_VER)
  32 #define STRCASECMP stricmp
  33 #else
  34 #define STRCASECMP strcasecmp
  35 #endif
  36
  37 pCodeOp *popCopyGPR2Bit(pCodeOpReg *pc, int bitval);
  38
  39
  40 pCodeOp *newpCodeOpWild(int id, pCodePeep *pcp, pCodeOp *subtype);
  41 pCode *newpCodeWild(int pCodeID, pCodeOp *optional_operand, pCodeOp *optional_label);
  42 pCode * findNextInstruction(pCode *pc);
  43 int getpCode(char *mnem,int dest);
  44 void pBlockMergeLabels(pBlock *pb);
  45 char *pCode2str(char *str, int size, pCode *pc);
  46
  47 extern pCodeInstruction *pic14Mnemonics[];
  48
  49
  50 /****************************************************************/
  51 /*
  52  * rootRules - defined in SDCCpeep.c
  53  *  This is a pointer to the (parsed) peephole rules that are
  54  * defined in peep.def.
  55  */
  56
  57 //extern peepRule *rootRules;
  58
  59
  60
  61
  62 /****************************************************************/
  63 /****************************************************************/
  64 typedef struct _DLL {
  65   struct _DLL *prev;
  66   struct _DLL *next;
  67   //  void *data;
  68 } _DLL;
  69
  70
  71 typedef struct pCodePeepSnippets
  72 {
  73   _DLL dll;
  74   pCodePeep *peep;
  75 } pCodePeepSnippets;
  76
  77
  78 /****************************************************************/
  79 /*                                                              */
  80 /* peepSnippets -                                               */
  81 /*                                                              */
  82 /****************************************************************/
  83
  84 static pCodePeepSnippets  *peepSnippets=NULL;
  85
  86 /****************************************************************/
  87 /*                                                              */
  88 /* curPeep                                                      */
  89 /*                                                              */
  90 /****************************************************************/
  91
  92 static pCodePeep          *curPeep=NULL;
  93
  94 /****************************************************************/
  95 /*                                                              */
  96 /* curBlock                                                     */
  97 /*                                                              */
  98 /****************************************************************/
  99
 100 static pBlock             *curBlock=NULL;
 101
 102
 103 /****************************************************************/
 104 /*                                                              */
 105 /* max wild cards in a peep rule                                */
 106 /*                                                              */
 107 /****************************************************************/
 108
 109 static int                sMaxWildVar   = 0;
 110 static int                sMaxWildMnem  = 0;
 111
 112
 113 typedef struct pCodeToken
 114 {
 115   int tt;  // token type;
 116   union {
 117     char c;  // character
 118     int  n;  // number
 119     char *s; // string
 120   } tok;
 121
 122 } pCodeToken;
 123
 124 pCodeToken tokArr[50];
 125 unsigned   tokIdx=0;
 126
 127
 128 typedef enum  {
 129   PCT_NULL=0,
 130   PCT_SPACE=1,
 131   PCT_PERCENT,
 132   PCT_COLON,
 133   PCT_COMMA,
 134   PCT_COMMENT,
 135   PCT_STRING,
 136   PCT_NUMBER
 137
 138 } pCodeTokens;
 139
 140
 141 typedef struct parsedPattern {
 142   struct pcPattern *pcp;
 143   pCodeToken *pct;
 144 } parsedPattern;
 145
 146 #define MAX_PARSEDPATARR 50
 147 parsedPattern parsedPatArr[MAX_PARSEDPATARR];
 148 unsigned int parsedPatIdx=0;
 149
 150
 151 typedef enum {
 152   PCP_LABEL=1,
 153   PCP_NUMBER,
 154   PCP_STR,
 155   PCP_WILDVAR,
 156   PCP_WILDSTR,
 157   PCP_COMMA,
 158   PCP_COMMENT
 159 } pCodePatterns;
 160
 161 static char pcpat_label[]      = {PCT_PERCENT, PCT_NUMBER, PCT_COLON, 0};
 162 static char pcpat_number[]     = {PCT_NUMBER, 0};
 163 static char pcpat_string[]     = {PCT_STRING, 0};
 164 static char pcpat_wildString[] = {PCT_PERCENT, PCT_STRING, 0};
 165 static char pcpat_wildVar[]    = {PCT_PERCENT, PCT_NUMBER, 0};
 166 static char pcpat_comma[]      = {PCT_COMMA, 0};
 167 static char pcpat_comment[]    = {PCT_COMMENT, 0};
 168
 169
 170 typedef struct pcPattern {
 171   char pt;                 // Pattern type
 172   char *tokens;           // list of tokens that describe the pattern
 173   void * (*f) (void *);
 174 } pcPattern;
 175
 176 pcPattern pcpArr[] = {
 177   {PCP_LABEL,     pcpat_label,      NULL},
 178   {PCP_WILDSTR,   pcpat_wildString, NULL},
 179   {PCP_STR,       pcpat_string,     NULL},
 180   {PCP_WILDVAR,   pcpat_wildVar,    NULL},
 181   {PCP_COMMA,     pcpat_comma,      NULL},
 182   {PCP_COMMENT,   pcpat_comment,    NULL},
 183   {PCP_NUMBER,    pcpat_number,     NULL}
 184 };
 185
 186 #define PCPATTERNS (sizeof(pcpArr)/sizeof(pcPattern))
 187
 188 // Assembly Line Token
 189 typedef enum {
 190   ALT_LABEL=1,
 191   ALT_COMMENT,
 192   ALT_MNEM0,
 193   ALT_MNEM0A,
 194   ALT_MNEM1,
 195   ALT_MNEM1A,
 196   ALT_MNEM1B,
 197   ALT_MNEM2,
 198   ALT_MNEM2A
 199 } altPatterns;
 200
 201 static char alt_comment[]   = { PCP_COMMENT, 0};
 202 static char alt_label[]     = { PCP_LABEL, 0};
 203 static char alt_mnem0[]     = { PCP_STR, 0};
 204 static char alt_mnem0a[]    = { PCP_WILDVAR, 0};
 205 static char alt_mnem1[]     = { PCP_STR, PCP_STR, 0};
 206 static char alt_mnem1a[]    = { PCP_STR, PCP_WILDVAR, 0};
 207 static char alt_mnem1b[]    = { PCP_STR, PCP_NUMBER, 0};
 208 static char alt_mnem2[]     = { PCP_STR, PCP_STR, PCP_COMMA, PCP_STR, 0};
 209 static char alt_mnem2a[]    = { PCP_STR, PCP_WILDVAR, PCP_COMMA, PCP_STR, 0};
 210
 211 static void * cvt_altpat_label(void *pp);
 212 static void * cvt_altpat_comment(void *pp);
 213 static void * cvt_altpat_mnem0(void *pp);
 214 static void * cvt_altpat_mnem0a(void *pp);
 215 static void * cvt_altpat_mnem1(void *pp);
 216 static void * cvt_altpat_mnem1a(void *pp);
 217 static void * cvt_altpat_mnem1b(void *pp);
 218 static void * cvt_altpat_mnem2(void *pp);
 219 static void * cvt_altpat_mnem2a(void *pp);
 220
 221 pcPattern altArr[] = {
 222   {ALT_LABEL,        alt_label,  cvt_altpat_label},
 223   {ALT_COMMENT,      alt_comment,cvt_altpat_comment},
 224   {ALT_MNEM2A,       alt_mnem2a, cvt_altpat_mnem2a},
 225   {ALT_MNEM2,        alt_mnem2,  cvt_altpat_mnem2},
 226   {ALT_MNEM1B,       alt_mnem1b, cvt_altpat_mnem1b},
 227   {ALT_MNEM1A,       alt_mnem1a, cvt_altpat_mnem1a},
 228   {ALT_MNEM1,        alt_mnem1,  cvt_altpat_mnem1},
 229   {ALT_MNEM0A,       alt_mnem0a, cvt_altpat_mnem0a},
 230   {ALT_MNEM0,        alt_mnem0,  cvt_altpat_mnem0},
 231
 232 };
 233
 234 #define ALTPATTERNS (sizeof(altArr)/sizeof(pcPattern))
 235
 236 // forward declarations
 237 static void * DLL_append(_DLL *list, _DLL *next);
 238
 239 /*-----------------------------------------------------------------*/
 240 /* cvt_extract_destination - helper function extracts the register */
 241 /*                           destination from a parsedPattern.     */
 242 /*                                                                 */
 243 /*-----------------------------------------------------------------*/
 244 static int cvt_extract_destination(parsedPattern *pp)
 245 {
 246
 247   if(pp->pct[0].tt == PCT_STRING) {
 248
 249     // just check first letter for now
 250
 251     if(toupper(*pp->pct[0].tok.s) == 'F')
 252       return 1;
 253
 254   } else if (pp->pct[0].tt == PCT_NUMBER) {
 255
 256     if(pp->pct[0].tok.n)
 257       return 1;
 258   }
 259
 260   return 0;
 261
 262 }
 263
 264 /*-----------------------------------------------------------------*/
 265 /*  pCodeOp *cvt_extract_status(char *reg, char *bit)              */
 266 /*     if *reg is the "status" register and *bit is one of the     */
 267 /*     status bits, then this function will create a new pCode op  */
 268 /*     containing the status register.                             */
 269 /*-----------------------------------------------------------------*/
 270
 271 static pCodeOp *cvt_extract_status(char *reg, char *bit)
 272 {
 273   int len;
 274
 275   if(STRCASECMP(reg, pc_status.pcop.name))
 276     return NULL;
 277
 278   len = strlen(bit);
 279
 280   if(len == 1) {
 281     // check C,Z
 282     if(toupper(*bit) == 'C')
 283       return PCOP(popCopyGPR2Bit(&pc_status,PIC_C_BIT));
 284     if(toupper(*bit) == 'Z')
 285       return PCOP(popCopyGPR2Bit(&pc_status,PIC_Z_BIT));
 286   }
 287
 288   // Check DC
 289   if(len ==2 && toupper(bit[0]) == 'D' && toupper(bit[1]) == 'C')
 290     return PCOP(popCopyGPR2Bit(&pc_status,PIC_DC_BIT));
 291
 292   return NULL;
 293
 294 }
 295
 296 /*-----------------------------------------------------------------*/
 297 /* cvt_altpat_label - convert assembly line type to a pCode label  */
 298 /* INPUT: pointer to the parsedPattern                             */
 299 /*                                                                 */
 300 /*  pp[0] - label                                                  */
 301 /*                                                                 */
 302 /* label pattern => '%' number ':'                                 */
 303 /* at this point, we wish to extract only the 'number'             */
 304 /*                                                                 */
 305 /*-----------------------------------------------------------------*/
 306 static void * cvt_altpat_label(void *pp)
 307 {
 308   parsedPattern *p = pp;
 309
 310   fprintf(stderr,"altpat_label with ID = %d\n",p->pct[1].tok.n);
 311   return newpCodeLabel(-p->pct[1].tok.n);
 312
 313 }
 314
 315 /*-----------------------------------------------------------------*/
 316 /* cvt_altpat_comment - convert assembly line type to a comment    */
 317 /* INPUT: pointer to the parsedPattern                             */
 318 /*                                                                 */
 319 /*  pp[0] - comment                                                */
 320 /*                                                                 */
 321 /*                                                                 */
 322 /*-----------------------------------------------------------------*/
 323 static void * cvt_altpat_comment(void *pp)
 324 {
 325   parsedPattern *p = pp;
 326
 327   fprintf(stderr,"altpat_comment  = %s\n",p->pct[0].tok.s);
 328   return newpCodeCharP(p->pct[0].tok.s);
 329
 330 }
 331
 332 /*-----------------------------------------------------------------*/
 333 /*-----------------------------------------------------------------*/
 334 static void * cvt_altpat_mnem0(void *pp)
 335 {
 336   parsedPattern *p = pp;
 337   int opcode;
 338
 339   pCodeInstruction *pci=NULL;
 340
 341   fprintf(stderr,"altpat_mnem0 %s\n",  p->pct[0].tok.s);
 342
 343   opcode = getpCode(p->pct[0].tok.s,0);
 344   if(opcode < 0) {
 345     fprintf(stderr, "Bad mnemonic\n");
 346     return NULL;
 347   }
 348
 349   pci = PCI(newpCode(opcode, NULL));
 350
 351   if(!pci)
 352     fprintf(stderr,"couldn't find mnemonic\n");
 353
 354
 355   return pci;
 356 }
 357
 358 /*-----------------------------------------------------------------*/
 359 /* cvt_altpat_mem0a - convert assembly line type to a wild pCode   */
 360 /*                    instruction                                  */
 361 /*                                                                 */
 362 /*  pp[0] - wild var                                               */
 363 /*                                                                 */
 364 /*-----------------------------------------------------------------*/
 365 static void * cvt_altpat_mnem0a(void *pp)
 366 {
 367   parsedPattern *p = pp;
 368
 369   fprintf(stderr,"altpat_mnem0a wild mnem # %d\n",  p[0].pct[1].tok.n);
 370
 371   /* Save the index of the maximum wildcard mnemonic */
 372
 373   if(p[0].pct[1].tok.n > sMaxWildVar)
 374     sMaxWildMnem = p[0].pct[1].tok.n;
 375
 376   return newpCodeWild(p[0].pct[1].tok.n,NULL,NULL);
 377
 378 }
 379
 380 /*-----------------------------------------------------------------*/
 381 /* cvt_altpat_mem1 - convert assembly line type to a pCode         */
 382 /*                   instruction with 1 operand.                   */
 383 /*                                                                 */
 384 /*  pp[0] - mnem                                                   */
 385 /*  pp[1] - Operand                                                */
 386 /*                                                                 */
 387 /*-----------------------------------------------------------------*/
 388 static void * cvt_altpat_mnem1(void *pp)
 389 {
 390
 391   parsedPattern *p = pp;
 392   int opcode;
 393
 394   pCodeInstruction *pci=NULL;
 395   pCodeOp *pcosubtype;
 396
 397   fprintf(stderr,"altpat_mnem1 %s var %s\n",  p->pct[0].tok.s,p[1].pct[0].tok.s);
 398
 399   opcode = getpCode(p->pct[0].tok.s,0);
 400   if(opcode < 0) {
 401     fprintf(stderr, "Bad mnemonic\n");
 402     return NULL;
 403   }
 404
 405   if(pic14Mnemonics[opcode]->bit_inst)
 406     pcosubtype = newpCodeOp(p[1].pct[0].tok.s,PO_BIT);
 407   else
 408     pcosubtype = newpCodeOp(p[1].pct[0].tok.s,PO_GPR_REGISTER);
 409
 410
 411   pci = PCI(newpCode(opcode, pcosubtype));
 412
 413   if(!pci)
 414     fprintf(stderr,"couldn't find mnemonic\n");
 415
 416
 417   return pci;
 418 }
 419
 420 /*-----------------------------------------------------------------*/
 421 /* cvt_altpat_mem1a - convert assembly line type to a pCode        */
 422 /*                    instruction with 1 wild operand.             */
 423 /*                                                                 */
 424 /*  pp[0] - mnem                                                   */
 425 /*  pp[1] - wild var                                               */
 426 /*                                                                 */
 427 /*-----------------------------------------------------------------*/
 428 static void * cvt_altpat_mnem1a(void *pp)
 429 {
 430   parsedPattern *p = pp;
 431   int opcode;
 432
 433   pCodeInstruction *pci=NULL;
 434   pCodeOp *pcosubtype;
 435
 436   fprintf(stderr,"altpat_mnem1a %s var %d\n",  p->pct[0].tok.s,p[1].pct[1].tok.n);
 437
 438   opcode = getpCode(p->pct[0].tok.s,0);
 439   if(opcode < 0) {
 440     fprintf(stderr, "Bad mnemonic\n");
 441     return NULL;
 442   }
 443
 444   if(pic14Mnemonics[opcode]->bit_inst)
 445     pcosubtype = newpCodeOpBit(NULL,-1,0);
 446   else
 447     pcosubtype = newpCodeOp(NULL,PO_GPR_REGISTER);
 448
 449
 450   pci = PCI(newpCode(opcode,
 451                      newpCodeOpWild(p[1].pct[1].tok.n, curPeep, pcosubtype)));
 452
 453   /* Save the index of the maximum wildcard variable */
 454   if(p[1].pct[1].tok.n > sMaxWildVar)
 455     sMaxWildVar = p[1].pct[1].tok.n;
 456
 457   if(!pci)
 458     fprintf(stderr,"couldn't find mnemonic\n");
 459
 460
 461   return pci;
 462 }
 463
 464 /*-----------------------------------------------------------------*/
 465 /*-----------------------------------------------------------------*/
 466 static void * cvt_altpat_mnem1b(void *pp)
 467 {
 468   parsedPattern *p = pp;
 469   int opcode;
 470
 471   pCodeInstruction *pci=NULL;
 472
 473   fprintf(stderr,"altpat_mnem1b %s var %d\n",  p->pct[0].tok.s,p[1].pct[0].tok.n);
 474
 475   opcode = getpCode(p->pct[0].tok.s,0);
 476   if(opcode < 0) {
 477     fprintf(stderr, "Bad mnemonic\n");
 478     return NULL;
 479   }
 480
 481   pci = PCI(newpCode(opcode, newpCodeOpLit(p[1].pct[0].tok.n) ));
 482
 483   if(!pci)
 484     fprintf(stderr,"couldn't find mnemonic\n");
 485
 486
 487   return pci;
 488 }
 489
 490 /*-----------------------------------------------------------------*/
 491 /*-----------------------------------------------------------------*/
 492 static void * cvt_altpat_mnem2(void *pp)
 493 {
 494   parsedPattern *p = pp;
 495   int opcode;
 496   int dest;
 497
 498   pCodeInstruction *pci=NULL;
 499   pCodeOp *pcosubtype;
 500
 501   dest = cvt_extract_destination(&p[3]);
 502
 503   fprintf(stderr,"altpat_mnem2 %s var %s destination %s(%d)\n",
 504           p->pct[0].tok.s,
 505           p[1].pct[0].tok.s,
 506           p[3].pct[0].tok.s,
 507           dest);
 508
 509
 510   opcode = getpCode(p->pct[0].tok.s,dest);
 511   if(opcode < 0) {
 512     fprintf(stderr, "Bad mnemonic\n");
 513     return NULL;
 514   }
 515
 516   if(pic14Mnemonics[opcode]->bit_inst) {
 517     pcosubtype = cvt_extract_status(p[1].pct[0].tok.s, p[3].pct[0].tok.s);
 518     if(pcosubtype == NULL) {
 519       fprintf(stderr, "bad operand?\n");
 520       return NULL;
 521     }
 522
 523   } else
 524     pcosubtype = newpCodeOp(p[1].pct[0].tok.s,PO_GPR_REGISTER);
 525
 526
 527   pci = PCI(newpCode(opcode,pcosubtype));
 528
 529   if(!pci)
 530     fprintf(stderr,"couldn't find mnemonic\n");
 531
 532   return pci;
 533
 534 }
 535
 536 /*-----------------------------------------------------------------*/
 537 /* cvt_altpat_mem2a - convert assembly line type to a pCode        */
 538 /*                    instruction with 1 wild operand and a        */
 539 /*                    destination operand (e.g. w or f)            */
 540 /*                                                                 */
 541 /*  pp[0] - mnem                                                   */
 542 /*  pp[1] - wild var                                               */
 543 /*  pp[2] - comma                                                  */
 544 /*  pp[3] - destination                                            */
 545 /*                                                                 */
 546 /*-----------------------------------------------------------------*/
 547 static void * cvt_altpat_mnem2a(void *pp)
 548 {
 549   parsedPattern *p = pp;
 550   int opcode;
 551   int dest;
 552
 553   pCodeInstruction *pci=NULL;
 554   pCodeOp *pcosubtype;
 555
 556   dest = cvt_extract_destination(&p[3]);
 557
 558   fprintf(stderr,"altpat_mnem2a %s var %d destination %s(%d)\n",
 559           p->pct[0].tok.s,
 560           p[1].pct[1].tok.n,
 561           p[3].pct[0].tok.s,
 562           dest);
 563
 564
 565   opcode = getpCode(p->pct[0].tok.s,dest);
 566   if(opcode < 0) {
 567     fprintf(stderr, "Bad mnemonic\n");
 568     return NULL;
 569   }
 570
 571   if(pic14Mnemonics[opcode]->bit_inst)
 572     pcosubtype = newpCodeOp(NULL,PO_BIT);
 573   else
 574     pcosubtype = newpCodeOp(NULL,PO_GPR_REGISTER);
 575
 576
 577   pci = PCI(newpCode(opcode,
 578                      newpCodeOpWild(p[1].pct[1].tok.n, curPeep, pcosubtype)));
 579
 580   /* Save the index of the maximum wildcard variable */
 581   if(p[1].pct[1].tok.n > sMaxWildVar)
 582     sMaxWildVar = p[1].pct[1].tok.n;
 583
 584   if(!pci)
 585     fprintf(stderr,"couldn't find mnemonic\n");
 586
 587   return pci;
 588
 589 }
 590
 591 /*-----------------------------------------------------------------*/
 592 /* tokenizeLineNode - Convert a string (of char's) that was parsed */
 593 /*                    by SDCCpeeph.c into a string of tokens.      */
 594 /*                                                                 */
 595 /*                                                                 */
 596 /* The tokenizer is of the classic type. When an item is encounterd*/
 597 /* it is converted into a token. The token is a structure that     */
 598 /* encodes the item's type and it's value (when appropriate).      */
 599 /*                                                                 */
 600 /* Accepted token types:                                           */
 601 /*    SPACE  NUMBER STRING  %  : ,  ;                              */
 602 /*                                                                 */
 603 /*                                                                 */
 604 /*                                                                 */
 605 /*-----------------------------------------------------------------*/
 606
 607
 608 static void tokenizeLineNode(char *ln)
 609 {
 610
 611   tokIdx = 0;               // Starting off at the beginning
 612   tokArr[0].tt = PCT_NULL;  // and assume invalid character for first token.
 613
 614   if(!ln || !*ln)
 615     return;
 616
 617   while(*ln) {
 618
 619     if(isspace(*ln)) {
 620       // add a SPACE token and eat the extra spaces.
 621       tokArr[tokIdx++].tt = PCT_SPACE;
 622       while (isspace (*ln))
 623         ln++;
 624       continue;
 625     }
 626
 627     if(isdigit(*ln)) {
 628
 629       tokArr[tokIdx].tt = PCT_NUMBER;
 630       tokArr[tokIdx++].tok.n = strtol(ln, &ln, 0);
 631
 632       continue;
 633
 634     }
 635
 636     switch(*ln) {
 637     case '%':
 638       tokArr[tokIdx++].tt = PCT_PERCENT;
 639       break;
 640     case ':':
 641       tokArr[tokIdx++].tt = PCT_COLON;
 642       break;
 643     case ';':
 644       tokArr[tokIdx].tok.s = Safe_strdup(ln);
 645       tokArr[tokIdx++].tt = PCT_COMMENT;
 646       tokArr[tokIdx].tt = PCT_NULL;
 647       return;
 648     case ',':
 649       tokArr[tokIdx++].tt = PCT_COMMA;
 650       break;
 651
 652
 653     default:
 654       if(isalpha(*ln)) {
 655         char buffer[50];
 656         int i=0;
 657
 658         while( (isalpha(*ln)  ||  isdigit(*ln)) && i<49)
 659           buffer[i++] = *ln++;
 660
 661         ln--;
 662         buffer[i] = 0;
 663
 664         tokArr[tokIdx].tok.s = Safe_strdup(buffer);
 665         tokArr[tokIdx++].tt = PCT_STRING;
 666
 667       }
 668     }
 669
 670     /* Advance to next character in input string .
 671      * Note, if none of the tests passed above, then
 672      * we effectively ignore the `bad' character.
 673      * Since the line has already been parsed by SDCCpeeph,
 674      * chance are that there are no invalid characters... */
 675
 676     ln++;
 677
 678   }
 679
 680   tokArr[tokIdx].tt = 0;
 681 }
 682
 683
 684 /*-----------------------------------------------------------------*/
 685 /*-----------------------------------------------------------------*/
 686
 687
 688
 689 void dump1Token(pCodeTokens tt)
 690 {
 691
 692   switch(tt) {
 693   case PCT_SPACE:
 694     fprintf(stderr, " space ");
 695     break;
 696   case PCT_PERCENT:
 697     fprintf(stderr, " pct ");
 698     fputc('%', stderr);
 699     break;
 700   case PCT_COLON:
 701     fprintf(stderr, " col ");
 702     fputc(':',stderr);
 703     break;
 704   case PCT_COMMA:
 705     fprintf(stderr, " comma , ");
 706     break;
 707   case PCT_COMMENT:
 708     fprintf(stderr, " comment ");
 709     //fprintf(stderr,"%s",tokArr[i].tok.s);
 710     break;
 711   case PCT_STRING:
 712     fprintf(stderr, " str ");
 713     //fprintf(stderr,"%s",tokArr[i].tok.s);
 714     break;
 715   case PCT_NUMBER:
 716     fprintf(stderr, " num ");
 717     //fprintf(stderr,"%d",tokArr[i].tok.n);
 718     break;
 719   case PCT_NULL:
 720     fprintf(stderr, " null ");
 721
 722   }
 723 }
 724
 725
 726 /*-----------------------------------------------------------------*/
 727 /*-----------------------------------------------------------------*/
 728
 729 int pcComparePattern(pCodeToken *pct, char *pat, int max_tokens)
 730 {
 731   int i=0;
 732
 733   if(!pct || !pat || !*pat)
 734     return 0;
 735
 736   //fprintf(stderr,"comparing against:\n");
 737
 738   while(i < max_tokens) {
 739
 740     if(*pat == 0){
 741       //fprintf(stderr,"matched\n");
 742       return (i+1);
 743     }
 744
 745     //dump1Token(*pat); fprintf(stderr,"\n");
 746
 747     if(pct->tt != *pat)
 748       return 0;
 749
 750
 751     pct++;
 752     pat++;
 753   }
 754
 755   return 0;
 756
 757 }
 758
 759 /*-----------------------------------------------------------------*/
 760 /*-----------------------------------------------------------------*/
 761
 762 int altComparePattern( char *pct, parsedPattern *pat, int max_tokens)
 763 {
 764   int i=0;
 765
 766   if(!pct || !pat || !*pct)
 767     return 0;
 768
 769
 770   while(i < max_tokens) {
 771
 772     if(*pct == 0) {
 773       //fprintf(stderr,"matched\n");
 774       return i;
 775     }
 776
 777     //dump1Token(*pat); fprintf(stderr,"\n");
 778
 779     if( !pat || !pat->pcp )
 780       return 0;
 781
 782     if (pat->pcp->pt != *pct)
 783       return 0;
 784
 785     //fprintf(stderr," pct=%d\n",*pct);
 786     pct++;
 787     pat++;
 788     i++;
 789   }
 790
 791   return 0;
 792
 793 }
 794 /*-----------------------------------------------------------------*/
 795 /*-----------------------------------------------------------------*/
 796
 797 int advTokIdx(int *v, int amt)
 798 {
 799
 800   if((unsigned) (*v + amt) > tokIdx)
 801     return 1;
 802
 803   *v += amt;
 804   return 0;
 805
 806 }
 807
 808 /*-----------------------------------------------------------------*/
 809 /* parseTokens - convert the tokens corresponding to a single line */
 810 /*               of a peep hole assembly into a pCode object.      */
 811 /*                                                                 */
 812 /*                                                                 */
 813 /*                                                                 */
 814 /*                                                                 */
 815 /* This is a simple parser that looks for strings of the type      */
 816 /* allowed in the peep hole definition file. Essentially the format*/
 817 /* is the same as a line of assembly:                              */
 818 /*                                                                 */
 819 /*  label:    mnemonic   op1, op2, op3    ; comment                */
 820 /*                                                                 */
 821 /* Some of these items aren't present. It's the job of the parser  */
 822 /* to determine which are and convert those into the appropriate   */
 823 /* pcode.                                                          */
 824 /*-----------------------------------------------------------------*/
 825
 826 void parseTokens(void)
 827 {
 828   unsigned i;
 829   pCode *pc;
 830
 831   if(!tokIdx)
 832     return;
 833
 834   for(i=0; i<=tokIdx; i++)
 835     dump1Token(tokArr[i].tt);
 836
 837   fputc('\n',stderr);
 838
 839   {
 840     int lparsedPatIdx=0;
 841     int lpcpIdx;
 842     int ltokIdx =0;
 843     int matching = 0;
 844     int j=0;
 845     int k=0;
 846
 847     char * cPmnem  = NULL;     // Pointer to non-wild mnemonic (if any)
 848     char * cP1stop = NULL;
 849     char * cP2ndop = NULL;
 850
 851     //pCodeOp *pcl   = NULL;       // Storage for a label
 852     //pCodeOp *pco1  = NULL;       // 1st operand
 853     //pCodeOp *pco2  = NULL;       // 2nd operand
 854     //pCode   *pc    = NULL;       // Mnemonic
 855
 856     typedef enum {
 857       PS_START,
 858       PS_HAVE_LABEL,
 859       PS_HAVE_MNEM,
 860       PS_HAVE_1OPERAND,
 861       PS_HAVE_COMMA,
 862       PS_HAVE_2OPERANDS
 863     } ParseStates;
 864
 865     ParseStates state = PS_START;
 866
 867     do {
 868
 869       lpcpIdx=0;
 870       matching = 0;
 871
 872       if(  ((tokArr[ltokIdx].tt == PCT_SPACE) )
 873            && (advTokIdx(&ltokIdx, 1)) ) // eat space
 874         break;
 875
 876       do {
 877         j = pcComparePattern(&tokArr[ltokIdx], pcpArr[lpcpIdx].tokens, tokIdx +1);
 878         if( j ) {
 879
 880           switch(pcpArr[lpcpIdx].pt) {
 881           case  PCP_LABEL:
 882             if(state == PS_START){
 883               fprintf(stderr,"  label\n");
 884               state = PS_HAVE_LABEL;
 885             } else
 886               fprintf(stderr,"  bad state (%d) for label\n",state);
 887             break;
 888
 889           case  PCP_STR:
 890             fprintf(stderr,"  %s is",tokArr[ltokIdx].tok.s);
 891             switch(state) {
 892             case PS_START:
 893             case PS_HAVE_LABEL:
 894               fprintf(stderr,"  mnem\n");
 895               cPmnem = tokArr[ltokIdx].tok.s;
 896               state = PS_HAVE_MNEM;
 897               break;
 898             case PS_HAVE_MNEM:
 899               fprintf(stderr,"  1st operand\n");
 900               cP1stop = tokArr[ltokIdx].tok.s;
 901               //pco1 = newpCodeOp(NULL,PO_GPR_REGISTER);
 902               state = PS_HAVE_1OPERAND;
 903               break;
 904             case PS_HAVE_1OPERAND:
 905               fprintf(stderr,"  error expecting comma\n");
 906               break;
 907             case PS_HAVE_COMMA:
 908               fprintf(stderr,"  2 operands\n");
 909               cP2ndop = tokArr[ltokIdx].tok.s;
 910               break;
 911             case PS_HAVE_2OPERANDS:
 912               break;
 913             }
 914             break;
 915
 916           case  PCP_WILDVAR:
 917             switch(state) {
 918             case PS_START:
 919             case PS_HAVE_LABEL:
 920               fprintf(stderr,"  wild mnem\n");
 921               state = PS_HAVE_MNEM;
 922               break;
 923             case PS_HAVE_MNEM:
 924               fprintf(stderr,"  1st operand is wild\n");
 925               state = PS_HAVE_1OPERAND;
 926               break;
 927             case PS_HAVE_1OPERAND:
 928               fprintf(stderr,"  error expecting comma\n");
 929               break;
 930             case PS_HAVE_COMMA:
 931               fprintf(stderr,"  2nd operand is wild\n");
 932               break;
 933             case PS_HAVE_2OPERANDS:
 934               break;
 935             }
 936             break;
 937
 938           case  PCP_NUMBER:
 939             switch(state) {
 940             case PS_START:
 941             case PS_HAVE_LABEL:
 942               fprintf(stderr,"  ERROR number\n");
 943               break;
 944             case PS_HAVE_MNEM:
 945               fprintf(stderr,"  1st operand is a number\n");
 946               state = PS_HAVE_1OPERAND;
 947               break;
 948             case PS_HAVE_1OPERAND:
 949               fprintf(stderr,"  error expecting comma\n");
 950               break;
 951             case PS_HAVE_COMMA:
 952               fprintf(stderr,"  2nd operand is a number\n");
 953               break;
 954             case PS_HAVE_2OPERANDS:
 955               break;
 956             }
 957             break;
 958
 959           case  PCP_WILDSTR:
 960             break;
 961           case  PCP_COMMA:
 962             if(state == PS_HAVE_1OPERAND){
 963               fprintf(stderr,"  got a comma\n");
 964               state = PS_HAVE_COMMA;
 965             } else
 966               fprintf(stderr,"  unexpected comma\n");
 967           }
 968
 969           matching = 1;
 970           parsedPatArr[lparsedPatIdx].pcp = &pcpArr[lpcpIdx];
 971           parsedPatArr[lparsedPatIdx].pct = &tokArr[ltokIdx];
 972           lparsedPatIdx++;
 973
 974           //dump1Token(tokArr[ltokIdx].tt);
 975
 976           if(advTokIdx(&ltokIdx, strlen(pcpArr[lpcpIdx].tokens) ) ) {
 977             fprintf(stderr," reached end \n");
 978             matching = 0;
 979             //return;
 980           }
 981         }
 982
 983
 984       } while ((++lpcpIdx < PCPATTERNS) && !matching);
 985
 986     } while (matching);
 987
 988     parsedPatArr[lparsedPatIdx].pcp = NULL;
 989     parsedPatArr[lparsedPatIdx].pct = NULL;
 990
 991     j=k=0;
 992     do {
 993       int c;
 994
 995       if( (c=altComparePattern( altArr[k].tokens, &parsedPatArr[j],10) ) ) {
 996
 997         if( altArr[k].f) {
 998           pc = altArr[k].f(&parsedPatArr[j]);
 999           //if(pc && pc->print)
1000           //  pc->print(stderr,pc);
1001           //if(pc && pc->destruct) pc->destruct(pc); dumps core?
1002           if(curBlock && pc)
1003             addpCode2pBlock(curBlock, pc);
1004         }
1005         j += c;
1006       }
1007       k++;
1008     }
1009     while(j<=lparsedPatIdx && k<ALTPATTERNS);
1010
1011 /*
1012     fprintf(stderr,"\nConverting parsed line to pCode:\n\n");
1013
1014     j = 0;
1015     do {
1016       if(parsedPatArr[j].pcp && parsedPatArr[j].pcp->f )
1017         parsedPatArr[j].pcp->f(&parsedPatArr[j]);
1018       fprintf(stderr,"  %d",parsedPatArr[j].pcp->pt);
1019       j++;
1020     }
1021     while(j<lparsedPatIdx);
1022 */
1023     fprintf(stderr,"\n");
1024
1025   }
1026
1027
1028 }
1029
1030 /*-----------------------------------------------------------------*/
1031 /*                                                                 */
1032 /*-----------------------------------------------------------------*/
1033 void  peepRuleBlock2pCodeBlock(  lineNode *ln)
1034 {
1035
1036   if(!ln)
1037     return;
1038
1039   for( ; ln; ln = ln->next) {
1040
1041     //fprintf(stderr,"%s\n",ln->line);
1042
1043     tokenizeLineNode(ln->line);
1044     parseTokens();
1045
1046   }
1047 }
1048
1049 /*-----------------------------------------------------------------*/
1050 /* peepRuleCondition                                               */
1051 /*-----------------------------------------------------------------*/
1052 static void   peepRuleCondition(char *cond)
1053 {
1054   if(!cond)
1055     return;
1056
1057   //fprintf(stderr,"\nCondition:  %s\n",cond);
1058
1059   /* brute force compares for now */
1060
1061   if(STRCASECMP(cond, "NZ") == 0) {
1062     //fprintf(stderr,"found NZ\n");
1063     curPeep->postFalseCond = PCC_Z;
1064
1065   }
1066
1067 }
1068 /*-----------------------------------------------------------------*/
1069 /* peepRules2pCode - parse the "parsed" peep hole rules to generate*/
1070 /*                   pCode.                                        */
1071 /*                                                                 */
1072 /* SDCCpeeph parses the peep rules file and extracts variables,    */
1073 /* removes white space, and checks the syntax. This function       */
1074 /* extends that processing to produce pCode objects. You can kind  */
1075 /* think of this function as an "assembler", though instead of     */
1076 /* taking raw text to produce machine code, it produces pCode.     */
1077 /*                                                                 */
1078 /*-----------------------------------------------------------------*/
1079
1080 void  peepRules2pCode(peepRule *rules)
1081 {
1082   peepRule *pr;
1083
1084   pCodePeepSnippets *pcps;
1085
1086   /* The rules are in a linked-list. Each rule has two portions */
1087   /* There's the `target' and there's the `replace'. The target */
1088   /* is compared against the SDCC generated code and if it      */
1089   /* matches, it gets replaced by the `replace' block of code.  */
1090   /*                                                            */
1091   /* Here we loop through each rule and convert the target's and*/
1092   /* replace's into pCode target and replace blocks             */
1093
1094   for (pr = rules; pr; pr = pr->next) {
1095
1096     //fprintf(stderr,"\nRule:\n\n");
1097
1098     pcps = Safe_calloc(1,sizeof(pCodePeepSnippets));
1099     curPeep = pcps->peep  = Safe_calloc(1,sizeof(pCodePeep));
1100
1101     curPeep->vars = NULL;
1102     curPeep->wildpCodes = NULL; curPeep->wildpCodeOps = NULL;
1103     curPeep->postFalseCond = PCC_NONE;
1104     curPeep->postTrueCond  = PCC_NONE;
1105
1106     peepSnippets = DLL_append((_DLL*)peepSnippets,(_DLL*)pcps);
1107
1108     curPeep->target = curBlock = newpCodeChain(NULL, 'W', NULL);
1109     sMaxWildVar  = 0;
1110     sMaxWildMnem = 0;
1111
1112     /* Convert the target block */
1113     peepRuleBlock2pCodeBlock(pr->match);
1114
1115     //fprintf(stderr,"finished target, here it is in pcode form:\n");
1116     //printpBlock(stderr, curBlock);
1117
1118     //fprintf(stderr,"target with labels merged:\n");
1119     pBlockMergeLabels(curBlock);
1120     printpBlock(stderr, curBlock);
1121
1122     //fprintf(stderr,"\nReplaced by:\n");
1123
1124
1125     curPeep->replace = curBlock = newpCodeChain(NULL, 'W', NULL);
1126
1127     /* Convert the replace block */
1128     peepRuleBlock2pCodeBlock(pr->replace);
1129
1130     //fprintf(stderr,"finished replace block, here it is in pcode form:\n");
1131     //printpBlock(stderr, curBlock);
1132
1133     //fprintf(stderr,"replace with labels merged:\n");
1134     pBlockMergeLabels(curBlock);
1135     //printpBlock(stderr, curBlock);
1136
1137     peepRuleCondition(pr->cond);
1138
1139     /* The rule has been converted to pCode. Now allocate
1140      * space for the wildcards */
1141
1142      ++sMaxWildVar;
1143     curPeep->nvars = sMaxWildVar;
1144     curPeep->vars = Safe_calloc(sMaxWildVar, sizeof(char *));
1145
1146     curPeep->nops = sMaxWildVar;
1147     curPeep->wildpCodeOps = Safe_calloc(sMaxWildVar, sizeof(pCodeOp *));
1148
1149     curPeep->nwildpCodes = ++sMaxWildMnem;
1150     curPeep->wildpCodes = Safe_calloc(sMaxWildMnem, sizeof(char *));
1151
1152
1153     //return; // debug ... don't want to go through all the rules yet
1154   }
1155
1156 }
1157
1158 void printpCodeString(FILE *of, pCode *pc, int max)
1159 {
1160   int i=0;
1161
1162   while(pc && (i++<max)) {
1163     pc->print(of,pc);
1164     pc = pc->next;
1165   }
1166 }
1167
1168 /*-----------------------------------------------------------------*/
1169 /* _DLL * DLL_append                                               */
1170 /*                                                                 */
1171 /*  Append a _DLL object to the end of a _DLL (doubly linked list) */
1172 /* If The list to which we want to append is non-existant then one */
1173 /* is created. Other wise, the end of the list is sought out and   */
1174 /* a new DLL object is appended to it. In either case, the void    */
1175 /* *data is added to the newly created DLL object.                 */
1176 /*-----------------------------------------------------------------*/
1177
1178 static void * DLL_append(_DLL *list, _DLL *next)
1179 {
1180   _DLL *b;
1181
1182
1183   /* If there's no list, then create one: */
1184   if(!list) {
1185     next->next = next->prev = NULL;
1186     return next;
1187   }
1188
1189
1190   /* Search for the end of the list. */
1191   b = list;
1192   while(b->next)
1193     b = b->next;
1194
1195   /* Now append the new DLL object */
1196   b->next = next;
1197   b->next->prev = b;
1198   b = b->next;
1199   b->next = NULL;
1200
1201   return list;
1202
1203 }
1204
1205
1206 /*-----------------------------------------------------------------
1207
1208   pCode peephole optimization
1209
1210
1211   The pCode "peep hole" optimization is not too unlike the peep hole
1212   optimization in SDCCpeeph.c. The major difference is that here we
1213   use pCode's whereas there we use ASCII strings. The advantage with
1214   pCode's is that we can ascertain flow information in the instructions
1215   being optimized.
1216
1217
1218 <FIX ME> - elaborate...
1219
1220   -----------------------------------------------------------------*/
1221
1222
1223
1224 /*-----------------------------------------------------------------*/
1225 /* pCodeSearchCondition - Search a pCode chain for a 'condition'   */
1226 /*                                                                 */
1227 /* return conditions                                               */
1228 /*  1 - The Condition was found for a pCode's input                */
1229 /*  0 - No matching condition was found for the whole chain        */
1230 /* -1 - The Condition was found for a pCode's output               */
1231 /*                                                                 */
1232 /*-----------------------------------------------------------------*/
1233 int pCodeSearchCondition(pCode *pc, unsigned int cond)
1234 {
1235
1236   while(pc) {
1237
1238     /* If we reach a function end (presumably an end since we most
1239        probably began the search in the middle of a function), then
1240        the condition was not found. */
1241     if(pc->type == PC_FUNCTION)
1242       return 0;
1243
1244     if(pc->type == PC_OPCODE) {
1245       if(PCI(pc)->inCond & cond)
1246         return 1;
1247       if(PCI(pc)->outCond & cond)
1248         return -1;
1249     }
1250
1251     pc = pc->next;
1252   }
1253
1254   return 0;
1255 }
1256
1257 int pCodePeepMatchLabels(pCodePeep *peepBlock, pCode *pcs, pCode *pcd)
1258 {
1259   int labindex;
1260
1261   /* Check for a label associated with this wild pCode */
1262   // If the wild card has a label, make sure the source code does too.
1263   if(pcd->label) {
1264     pCode *pcl;
1265
1266     if(!pcs->label)
1267       return 0;
1268
1269     pcl = pcd->label->pc;
1270
1271     labindex = -PCL(pcl)->key;
1272     //fprintf(stderr,"label id = %d (labindex = %d)\n",PCL(pcl)->key,labindex);
1273     if(peepBlock->vars[labindex] == NULL) {
1274       // First time to encounter this label
1275       peepBlock->vars[labindex] = PCL(pcs->label->pc)->label;
1276       //fprintf(stderr,"first time for a label: %d %s\n",labindex, peepBlock->vars[labindex]);
1277     } else {
1278       if(strcmp(peepBlock->vars[labindex],PCL(pcs->label->pc)->label) != 0) {
1279         // fprintf(stderr,"labels don't match\n");
1280         return 0;
1281       }
1282       //fprintf(stderr,"matched a label\n");
1283     }
1284   } else {
1285     // fprintf(stderr,"destination doesn't have a label\n");
1286
1287     if(pcs->label)
1288       return 0;
1289   }
1290
1291   return 1;
1292
1293 }
1294
1295 /*-----------------------------------------------------------------*/
1296 /* pCodePeepMatchLine - Compare source and destination pCodes to   */
1297 /*                      see they're the same.                      */
1298 /*                                                                 */
1299 /* In this context, "source" refers to the coded generated by gen.c*/
1300 /* and "destination" refers to a pcode in a peep rule. If the dest-*/
1301 /* ination has no wild cards, then MatchLine will compare the two  */
1302 /* pcodes (src and dest) for a one-to-one match. If the destination*/
1303 /* has wildcards, then those get expanded. When a wild card is     */
1304 /* encountered for the first time it autmatically is considered a  */
1305 /* match and the object that matches it is referenced in the       */
1306 /* variables or opcodes array (depending on the type of match).    */
1307 /*                                                                 */
1308 /*                                                                 */
1309 /* Inputs:                                                         */
1310 /*  *peepBlock - A pointer to the peepBlock that contains the      */
1311 /*               entire rule to which the destination pcode belongs*/
1312 /*  *pcs - a pointer to the source pcode                           */
1313 /*  *pcd - a pointer to the destination pcode                      */
1314 /*                                                                 */
1315 /* Returns:                                                        */
1316 /*  1 - pcodes match                                               */
1317 /*  0 - pcodes don't match                                         */
1318 /*                                                                 */
1319 /*                                                                 */
1320 /*-----------------------------------------------------------------*/
1321
1322 int pCodePeepMatchLine(pCodePeep *peepBlock, pCode *pcs, pCode *pcd)
1323 {
1324   int index;   // index into wild card arrays
1325
1326   if(pcs->type == pcd->type) {
1327
1328     if(pcs->type == PC_OPCODE) {
1329
1330       /* If the opcodes don't match then the line doesn't match */
1331       if(PCI(pcs)->op != PCI(pcd)->op)
1332         return 0;
1333
1334       /*
1335       fprintf(stderr,"%s comparing\n",__FUNCTION__);
1336       pcs->print(stderr,pcs);
1337       pcd->print(stderr,pcd);
1338       */
1339
1340       if(!pCodePeepMatchLabels(peepBlock, pcs, pcd))
1341         return 0;
1342
1343       /* Compare the operands */
1344       if(PCI(pcd)->pcop) {
1345         if (PCI(pcd)->pcop->type == PO_WILD) {
1346           index = PCOW(PCI(pcd)->pcop)->id;
1347
1348           //fprintf(stderr,"destination is wild\n");
1349 #ifdef DEBUG_PCODEPEEP
1350           if (index > peepBlock->nops) {
1351             fprintf(stderr,"%s - variables exceeded\n",__FUNCTION__);
1352             exit(1);
1353           }
1354 #endif
1355           PCOW(PCI(pcd)->pcop)->matched = PCI(pcs)->pcop;
1356           if(!peepBlock->wildpCodeOps[index]) {
1357             peepBlock->wildpCodeOps[index] = PCI(pcs)->pcop;
1358
1359             //if(PCI(pcs)->pcop->type == PO_GPR_TEMP)
1360
1361           }
1362           {
1363             char *n;
1364
1365             switch(PCI(pcs)->pcop->type) {
1366             case PO_GPR_TEMP:
1367             case PO_FSR:
1368               //case PO_INDF:
1369               n = PCOR(PCI(pcs)->pcop)->r->name;
1370
1371               break;
1372             default:
1373               n = PCI(pcs)->pcop->name;
1374             }
1375
1376             if(peepBlock->vars[index])
1377               return  (strcmp(peepBlock->vars[index],n) == 0);
1378             else {
1379               // fprintf(stderr,"first time for a variable: %d, %s\n",index,n);
1380               peepBlock->vars[index] = n;
1381               return 1;
1382             }
1383           }
1384         }
1385         /* FIXME - need an else to check the case when the destination
1386          * isn't a wild card */
1387       } else
1388         /* The pcd has no operand. Lines match if pcs has no operand either*/
1389         return (PCI(pcs)->pcop == NULL);
1390     }
1391   }
1392
1393
1394   if((pcd->type == PC_WILD) && (pcs->type == PC_OPCODE)) {
1395
1396
1397     index = PCW(pcd)->id;
1398
1399     //    fprintf(stderr,"%s comparing wild cards\n",__FUNCTION__);
1400     //pcs->print(stderr,pcs);
1401     //pcd->print(stderr,pcd);
1402
1403     peepBlock->wildpCodes[PCW(pcd)->id] = pcs;
1404
1405     if(!pCodePeepMatchLabels(peepBlock, pcs, pcd))
1406       return 0;
1407
1408     if(PCW(pcd)->operand) {
1409       PCOW(PCI(pcd)->pcop)->matched = PCI(pcs)->pcop;
1410       if(peepBlock->vars[index]) {
1411         int i = (strcmp(peepBlock->vars[index],PCI(pcs)->pcop->name) == 0);
1412         /*
1413         if(i)
1414           fprintf(stderr," (matched)\n");
1415         else {
1416           fprintf(stderr," (no match: wild card operand mismatch\n");
1417           fprintf(stderr,"  peepblock= %s,  pcodeop= %s\n",
1418                   peepBlock->vars[index],
1419                   PCI(pcs)->pcop->name);
1420         }
1421         */
1422         return i;
1423       } else {
1424         peepBlock->vars[index] = PCI(pcs)->pcop->name;
1425         return 1;
1426       }
1427     }
1428
1429     pcs = findNextInstruction(pcs->next);
1430     if(pcs) {
1431       //fprintf(stderr," (next to match)\n");
1432       //pcs->print(stderr,pcs);
1433     } else if(pcd->next) {
1434       /* oops, we ran out of code, but there's more to the rule */
1435       return 0;
1436     }
1437
1438     return 1; /*  wild card matches */
1439   }
1440
1441   return 0;
1442 }
1443
1444 /*-----------------------------------------------------------------*/
1445 /*-----------------------------------------------------------------*/
1446 void pCodePeepClrVars(pCodePeep *pcp)
1447 {
1448
1449   int i;
1450   if(!pcp)
1451     return;
1452
1453   for(i=0;i<pcp->nvars; i++) {
1454     pcp->vars[i] = NULL;
1455     pcp->wildpCodeOps[i] = NULL;
1456   }
1457 }
1458
1459 /*-----------------------------------------------------------------*/
1460 /*  pCodeInsertAfter - splice in the pCode chain starting with pc2 */
1461 /*                     into the pCode chain containing pc1         */
1462 /*-----------------------------------------------------------------*/
1463 void pCodeInsertAfter(pCode *pc1, pCode *pc2)
1464 {
1465
1466   if(!pc1 || !pc2)
1467     return;
1468
1469   pc2->next = pc1->next;
1470   if(pc1->next)
1471     pc1->next->prev = pc2;
1472
1473   pc2->pb = pc1->pb;
1474   pc2->prev = pc1;
1475   pc1->next = pc2;
1476
1477 }
1478
1479 /*-----------------------------------------------------------------*/
1480 /* pCodeOpCopy - copy a pcode operator                             */
1481 /*-----------------------------------------------------------------*/
1482 static pCodeOp *pCodeOpCopy(pCodeOp *pcop)
1483 {
1484   pCodeOp *pcopnew=NULL;
1485
1486   if(!pcop)
1487     return NULL;
1488
1489   switch(pcop->type) {
1490   case PO_CRY:
1491   case PO_BIT:
1492     //fprintf(stderr,"pCodeOpCopy bit\n");
1493     pcopnew = Safe_calloc(1,sizeof(pCodeOpBit) );
1494     PCOB(pcopnew)->bit = PCOB(pcop)->bit;
1495     PCOB(pcopnew)->inBitSpace = PCOB(pcop)->inBitSpace;
1496
1497     break;
1498
1499   case PO_WILD:
1500     /* Here we expand the wild card into the appropriate type: */
1501     /* By recursively calling pCodeOpCopy */
1502     //fprintf(stderr,"pCodeOpCopy wild\n");
1503     if(PCOW(pcop)->matched)
1504       pcopnew = pCodeOpCopy(PCOW(pcop)->matched);
1505     else {
1506       // Probably a label
1507       pcopnew = pCodeOpCopy(PCOW(pcop)->subtype);
1508       pcopnew->name = Safe_strdup(PCOW(pcop)->pcp->vars[PCOW(pcop)->id]);
1509       //fprintf(stderr,"copied a wild op named %s\n",pcopnew->name);
1510     }
1511
1512     return pcopnew;
1513     break;
1514
1515   case PO_LABEL:
1516     //fprintf(stderr,"pCodeOpCopy label\n");
1517     pcopnew = Safe_calloc(1,sizeof(pCodeOpLabel) );
1518     PCOLAB(pcopnew)->key =  PCOLAB(pcop)->key;
1519     break;
1520
1521   case PO_LITERAL:
1522   case PO_IMMEDIATE:
1523     //fprintf(stderr,"pCodeOpCopy lit\n");
1524     pcopnew = Safe_calloc(1,sizeof(pCodeOpLit) );
1525     PCOL(pcopnew)->lit = PCOL(pcop)->lit;
1526     break;
1527
1528   case PO_GPR_REGISTER:
1529   case PO_GPR_TEMP:
1530   case PO_GPR_BIT:
1531   case PO_FSR:
1532   case PO_INDF:
1533     //fprintf(stderr,"pCodeOpCopy GPR register\n");
1534     pcopnew = Safe_calloc(1,sizeof(pCodeOpReg) );
1535     PCOR(pcopnew)->r = PCOR(pcop)->r;
1536     PCOR(pcopnew)->rIdx = PCOR(pcop)->rIdx;
1537     fprintf(stderr," register index %d\n", PCOR(pcop)->r->rIdx);
1538     break;
1539
1540   case PO_DIR:
1541     //fprintf(stderr,"pCodeOpCopy PO_DIR\n");
1542   case PO_SFR_REGISTER:
1543   case PO_STR:
1544   case PO_NONE:
1545   case PO_W:
1546   case PO_STATUS:
1547   case PO_PCL:
1548   case PO_PCLATH:
1549
1550     //fprintf(stderr,"pCodeOpCopy register type %d\n", pcop->type);
1551     pcopnew = Safe_calloc(1,sizeof(pCodeOp) );
1552
1553   }
1554
1555   pcopnew->type = pcop->type;
1556   if(pcop->name)
1557     pcopnew->name = Safe_strdup(pcop->name);
1558   else
1559     pcopnew->name = NULL;
1560
1561   return pcopnew;
1562 }
1563
1564 #if 0
1565 /*-----------------------------------------------------------------*/
1566 /* pCodeCopy - copy a pcode                                        */
1567 /*-----------------------------------------------------------------*/
1568 static pCode *pCodeCopy(pCode *pc)
1569 {
1570
1571   pCode *pcnew;
1572
1573   pcnew = newpCode(pc->type,pc->pcop);
1574 }
1575 #endif
1576 /*-----------------------------------------------------------------*/
1577 /*-----------------------------------------------------------------*/
1578 void pCodeDeleteChain(pCode *f,pCode *t)
1579 {
1580   pCode *pc;
1581
1582
1583   while(f && f!=t) {
1584     fprintf(stderr,"delete pCode:\n");
1585     pc = f->next;
1586     f->print(stderr,f);
1587     //f->delete(f);  this dumps core...
1588
1589     f = pc;
1590
1591   }
1592
1593 }
1594 /*-----------------------------------------------------------------*/
1595 /*-----------------------------------------------------------------*/
1596 int pCodePeepMatchRule(pCode *pc)
1597 {
1598   pCodePeep *peepBlock;
1599   pCode *pct, *pcin;
1600   _DLL *peeprules;
1601   int matched;
1602
1603   peeprules = (_DLL *)peepSnippets;
1604
1605   while(peeprules) {
1606     peepBlock = ((pCodePeepSnippets*)peeprules)->peep;
1607     if(!peepBlock || !peepBlock->target || !peepBlock->target->pcHead)
1608       goto next_rule;
1609
1610     pCodePeepClrVars(peepBlock);
1611
1612     pcin = pc;
1613     pct = peepBlock->target->pcHead;
1614     matched = 0;
1615     while(pct && pcin) {
1616
1617       if(! (matched = pCodePeepMatchLine(peepBlock, pcin,pct)))
1618         break;
1619
1620       pcin = findNextInstruction(pcin->next);
1621       pct = pct->next;
1622       //debug:
1623       //fprintf(stderr,"    matched\n");
1624       if(!pcin)
1625         fprintf(stderr," end of code\n");
1626       if(!pct)
1627         fprintf(stderr," end of rule\n");
1628     }
1629
1630     if(matched) {
1631
1632       /* So far we matched the rule up to the point of the conditions .
1633        * In other words, all of the opcodes match. Now we need to see
1634        * if the post conditions are satisfied.
1635        * First we check the 'postFalseCond'. This means that we check
1636        * to see if any of the subsequent pCode's in the pCode chain
1637        * following the point just past where we have matched depend on
1638        * the `postFalseCond' as input then we abort the match
1639        */
1640       fprintf(stderr,"    matched rule so far, now checking conditions\n");
1641       if (pcin && peepBlock->postFalseCond &&
1642           (pCodeSearchCondition(pcin,peepBlock->postFalseCond) > 0) )
1643         matched = 0;
1644     }
1645
1646     if(matched) {
1647
1648       pCode *pcprev;
1649       pCode *pcr;
1650
1651
1652       /* We matched a rule! Now we have to go through and remove the
1653          inefficient code with the optimized version */
1654
1655       fprintf(stderr, "Found a pcode peep match:\nRule:\n");
1656       printpCodeString(stderr,peepBlock->target->pcHead,10);
1657       fprintf(stderr,"first thing matched\n");
1658       pc->print(stderr,pc);
1659       if(pcin) {
1660         fprintf(stderr,"last thing matched\n");
1661         pcin->print(stderr,pcin);
1662       }
1663
1664       /* Unlink the original code */
1665       pcprev = pc->prev;
1666       pcprev->next = pcin;
1667       if(pcin)
1668         pcin->prev = pc->prev;
1669
1670       {
1671         /*     DEBUG    */
1672         /* Converted the deleted pCodes into comments */
1673
1674         char buf[256];
1675
1676         buf[0] = ';';
1677         buf[1] = '#';
1678
1679         while(pc &&  pc!=pcin) {
1680           pCode2str(&buf[2], 254, pc);
1681           pCodeInsertAfter(pcprev, newpCodeCharP(buf));
1682           pcprev = pcprev->next;
1683           pc = pc->next;
1684         }
1685       }
1686
1687       if(pcin)
1688         pCodeDeleteChain(pc,pcin);
1689
1690       /* Generate the replacement code */
1691       pc = pcprev;
1692       pcr = peepBlock->replace->pcHead;  // This is the replacement code
1693       while (pcr) {
1694         pCodeOp *pcop=NULL;
1695         /* If the replace pcode is an instruction with an operand, */
1696         /* then duplicate the operand (and expand wild cards in the process). */
1697         if(pcr->type == PC_OPCODE) {
1698           if(PCI(pcr)->pcop) {
1699             /* The replacing instruction has an operand.
1700              * Is it wild? */
1701             if(PCI(pcr)->pcop->type == PO_WILD) {
1702               int index = PCOW(PCI(pcr)->pcop)->id;
1703               //fprintf(stderr,"copying wildopcode\n");
1704               if(peepBlock->wildpCodeOps[index])
1705                 pcop = pCodeOpCopy(peepBlock->wildpCodeOps[index]);
1706               else
1707                 fprintf(stderr,"error, wildopcode in replace but not source?\n");
1708             } else
1709               pcop = pCodeOpCopy(PCI(pcr)->pcop);
1710           }
1711           //fprintf(stderr,"inserting pCode\n");
1712           pCodeInsertAfter(pc, newpCode(PCI(pcr)->op,pcop));
1713         } else if (pcr->type == PC_WILD) {
1714           pCodeInsertAfter(pc,peepBlock->wildpCodes[PCW(pcr)->id]);
1715         } else if (pcr->type == PC_COMMENT) {
1716           pCodeInsertAfter(pc, newpCodeCharP( ((pCodeComment *)(pcr))->comment));
1717         }
1718
1719
1720         pc = pc->next;
1721         //if(pc)
1722         //  pc->print(stderr,pc);
1723         pcr = pcr->next;
1724       }
1725
1726       return 1;
1727     }
1728   next_rule:
1729     peeprules = peeprules->next;
1730   }
1731
1732   return 0;
1733 }