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     //labindex = PCOW(pcl)->id;
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       fprintf(stderr,"%s comparing\n",__FUNCTION__);
1335       pcs->print(stderr,pcs);
1336       pcd->print(stderr,pcd);
1337
1338       if(!pCodePeepMatchLabels(peepBlock, pcs, pcd))
1339         return 0;
1340
1341       /* Compare the operands */
1342       if(PCI(pcd)->pcop) {
1343         if (PCI(pcd)->pcop->type == PO_WILD) {
1344           index = PCOW(PCI(pcd)->pcop)->id;
1345
1346           fprintf(stderr,"destination is wild\n");
1347 #ifdef DEBUG_PCODEPEEP
1348           if (index > peepBlock->nops) {
1349             fprintf(stderr,"%s - variables exceeded\n",__FUNCTION__);
1350             exit(1);
1351           }
1352 #endif
1353           PCOW(PCI(pcd)->pcop)->matched = PCI(pcs)->pcop;
1354           if(!peepBlock->wildpCodeOps[index]) {
1355             peepBlock->wildpCodeOps[index] = PCI(pcs)->pcop;
1356
1357             //if(PCI(pcs)->pcop->type == PO_GPR_TEMP)
1358
1359           }
1360           {
1361             char *n;
1362
1363               fprintf(stderr,"line %d\n",__LINE__);
1364             switch(PCI(pcs)->pcop->type) {
1365             case PO_GPR_TEMP:
1366             case PO_FSR:
1367               //case PO_INDF:
1368               n = PCOR(PCI(pcs)->pcop)->r->name;
1369
1370               break;
1371             default:
1372               fprintf(stderr,"line %d\n",__LINE__);
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; //PCI(pcs)->pcop->name;
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         if(i)
1413           fprintf(stderr," (matched)\n");
1414         else {
1415           fprintf(stderr," (no match: wild card operand mismatch\n");
1416           fprintf(stderr,"  peepblock= %s,  pcodeop= %s\n",
1417                   peepBlock->vars[index],
1418                   PCI(pcs)->pcop->name);
1419         }
1420         return i;
1421       } else {
1422         peepBlock->vars[index] = PCI(pcs)->pcop->name;
1423         return 1;
1424       }
1425     }
1426
1427     pcs = findNextInstruction(pcs->next);
1428     if(pcs) {
1429       fprintf(stderr," (next to match)\n");
1430       pcs->print(stderr,pcs);
1431     } else if(pcd->next) {
1432       /* oops, we ran out of code, but there's more to the rule */
1433       return 0;
1434     }
1435
1436     return 1; /*  wild card matches */
1437   }
1438
1439   return 0;
1440 }
1441
1442 /*-----------------------------------------------------------------*/
1443 /*-----------------------------------------------------------------*/
1444 void pCodePeepClrVars(pCodePeep *pcp)
1445 {
1446
1447   int i;
1448   if(!pcp)
1449     return;
1450
1451   for(i=0;i<pcp->nvars; i++) {
1452     pcp->vars[i] = NULL;
1453     pcp->wildpCodeOps[i] = NULL;
1454   }
1455 }
1456
1457 /*-----------------------------------------------------------------*/
1458 /*  pCodeInsertAfter - splice in the pCode chain starting with pc2 */
1459 /*                     into the pCode chain containing pc1         */
1460 /*-----------------------------------------------------------------*/
1461 void pCodeInsertAfter(pCode *pc1, pCode *pc2)
1462 {
1463
1464   if(!pc1 || !pc2)
1465     return;
1466
1467   pc2->next = pc1->next;
1468   if(pc1->next)
1469     pc1->next->prev = pc2;
1470
1471   pc2->pb = pc1->pb;
1472   pc2->prev = pc1;
1473   pc1->next = pc2;
1474
1475 }
1476
1477 /*-----------------------------------------------------------------*/
1478 /* pCodeOpCopy - copy a pcode operator                             */
1479 /*-----------------------------------------------------------------*/
1480 static pCodeOp *pCodeOpCopy(pCodeOp *pcop)
1481 {
1482   pCodeOp *pcopnew=NULL;
1483
1484   if(!pcop)
1485     return NULL;
1486
1487   switch(pcop->type) {
1488   case PO_CRY:
1489   case PO_BIT:
1490     fprintf(stderr,"pCodeOpCopy bit\n");
1491     pcopnew = Safe_calloc(1,sizeof(pCodeOpBit) );
1492     PCOB(pcopnew)->bit = PCOB(pcop)->bit;
1493     PCOB(pcopnew)->inBitSpace = PCOB(pcop)->inBitSpace;
1494
1495     break;
1496
1497   case PO_WILD:
1498     /* Here we expand the wild card into the appropriate type: */
1499     /* By recursively calling pCodeOpCopy */
1500     fprintf(stderr,"pCodeOpCopy wild\n");
1501     if(PCOW(pcop)->matched)
1502       pcopnew = pCodeOpCopy(PCOW(pcop)->matched);
1503     else {
1504       // Probably a label
1505       pcopnew = pCodeOpCopy(PCOW(pcop)->subtype);
1506       pcopnew->name = Safe_strdup(PCOW(pcop)->pcp->vars[PCOW(pcop)->id]);
1507       fprintf(stderr,"copied a wild op named %s\n",pcopnew->name);
1508     }
1509
1510     return pcopnew;
1511     break;
1512
1513   case PO_LABEL:
1514     fprintf(stderr,"pCodeOpCopy label\n");
1515     pcopnew = Safe_calloc(1,sizeof(pCodeOpLabel) );
1516     PCOLAB(pcopnew)->key =  PCOLAB(pcop)->key;
1517     break;
1518
1519   case PO_LITERAL:
1520   case PO_IMMEDIATE:
1521     fprintf(stderr,"pCodeOpCopy lit\n");
1522     pcopnew = Safe_calloc(1,sizeof(pCodeOpLit) );
1523     PCOL(pcopnew)->lit = PCOL(pcop)->lit;
1524     break;
1525
1526   case PO_GPR_REGISTER:
1527   case PO_GPR_TEMP:
1528   case PO_GPR_BIT:
1529   case PO_FSR:
1530   case PO_INDF:
1531     fprintf(stderr,"pCodeOpCopy GPR register\n");
1532     pcopnew = Safe_calloc(1,sizeof(pCodeOpReg) );
1533     PCOR(pcopnew)->r = PCOR(pcop)->r;
1534     PCOR(pcopnew)->rIdx = PCOR(pcop)->rIdx;
1535     fprintf(stderr," register index %d\n", PCOR(pcop)->r->rIdx);
1536     break;
1537
1538   case PO_DIR:
1539     fprintf(stderr,"pCodeOpCopy PO_DIR\n");
1540   case PO_SFR_REGISTER:
1541   case PO_STR:
1542   case PO_NONE:
1543   case PO_W:
1544   case PO_STATUS:
1545   case PO_PCL:
1546   case PO_PCLATH:
1547
1548     fprintf(stderr,"pCodeOpCopy register type %d\n", pcop->type);
1549     pcopnew = Safe_calloc(1,sizeof(pCodeOp) );
1550
1551   }
1552
1553   pcopnew->type = pcop->type;
1554   if(pcop->name)
1555     pcopnew->name = Safe_strdup(pcop->name);
1556   else
1557     pcopnew->name = NULL;
1558
1559   return pcopnew;
1560 }
1561
1562 #if 0
1563 /*-----------------------------------------------------------------*/
1564 /* pCodeCopy - copy a pcode                                        */
1565 /*-----------------------------------------------------------------*/
1566 static pCode *pCodeCopy(pCode *pc)
1567 {
1568
1569   pCode *pcnew;
1570
1571   pcnew = newpCode(pc->type,pc->pcop);
1572 }
1573 #endif
1574 /*-----------------------------------------------------------------*/
1575 /*-----------------------------------------------------------------*/
1576 void pCodeDeleteChain(pCode *f,pCode *t)
1577 {
1578   pCode *pc;
1579
1580
1581   while(f && f!=t) {
1582     fprintf(stderr,"delete pCode:\n");
1583     pc = f->next;
1584     f->print(stderr,f);
1585     //f->delete(f);  this dumps core...
1586
1587     f = pc;
1588
1589   }
1590
1591 }
1592 /*-----------------------------------------------------------------*/
1593 /*-----------------------------------------------------------------*/
1594 int pCodePeepMatchRule(pCode *pc)
1595 {
1596   pCodePeep *peepBlock;
1597   pCode *pct, *pcin;
1598   _DLL *peeprules;
1599   int matched;
1600
1601   peeprules = (_DLL *)peepSnippets;
1602
1603   while(peeprules) {
1604     peepBlock = ((pCodePeepSnippets*)peeprules)->peep;
1605     if(!peepBlock || !peepBlock->target || !peepBlock->target->pcHead)
1606       goto next_rule;
1607
1608     pCodePeepClrVars(peepBlock);
1609
1610     pcin = pc;
1611     pct = peepBlock->target->pcHead;
1612     matched = 0;
1613     while(pct && pcin) {
1614
1615       if(! (matched = pCodePeepMatchLine(peepBlock, pcin,pct)))
1616         break;
1617
1618       pcin = findNextInstruction(pcin->next);
1619       pct = pct->next;
1620       //debug:
1621       fprintf(stderr,"    matched\n");
1622       if(!pcin)
1623         fprintf(stderr," end of code\n");
1624       if(!pct)
1625         fprintf(stderr," end of rule\n");
1626     }
1627
1628     if(matched) {
1629
1630       /* So far we matched the rule up to the point of the conditions .
1631        * In other words, all of the opcodes match. Now we need to see
1632        * if the post conditions are satisfied.
1633        * First we check the 'postFalseCond'. This means that we check
1634        * to see if any of the subsequent pCode's in the pCode chain
1635        * following the point just past where we have matched depend on
1636        * the `postFalseCond' as input then we abort the match
1637        */
1638       fprintf(stderr,"    matched rule so far, now checking conditions\n");
1639       if (pcin && peepBlock->postFalseCond &&
1640           (pCodeSearchCondition(pcin,peepBlock->postFalseCond) > 0) )
1641         matched = 0;
1642     }
1643
1644     if(matched) {
1645
1646       pCode *pcprev;
1647       pCode *pcr;
1648
1649
1650       /* We matched a rule! Now we have to go through and remove the
1651          inefficient code with the optimized version */
1652
1653       fprintf(stderr, "Found a pcode peep match:\nRule:\n");
1654       printpCodeString(stderr,peepBlock->target->pcHead,10);
1655       fprintf(stderr,"first thing matched\n");
1656       pc->print(stderr,pc);
1657       if(pcin) {
1658         fprintf(stderr,"last thing matched\n");
1659         pcin->print(stderr,pcin);
1660       }
1661
1662       /* Unlink the original code */
1663       pcprev = pc->prev;
1664       pcprev->next = pcin;
1665       if(pcin)
1666         pcin->prev = pc->prev;
1667
1668       {
1669         /*     DEBUG    */
1670         /* Converted the deleted pCodes into comments */
1671
1672         char buf[256];
1673
1674         buf[0] = ';';
1675         buf[1] = '#';
1676
1677         while(pc &&  pc!=pcin) {
1678           pCode2str(&buf[2], 254, pc);
1679           pCodeInsertAfter(pcprev, newpCodeCharP(buf));
1680           pcprev = pcprev->next;
1681           pc = pc->next;
1682         }
1683       }
1684
1685       if(pcin)
1686         pCodeDeleteChain(pc,pcin);
1687
1688       /* Generate the replacement code */
1689       pc = pcprev;
1690       pcr = peepBlock->replace->pcHead;  // This is the replacement code
1691       while (pcr) {
1692         pCodeOp *pcop=NULL;
1693         /* If the replace pcode is an instruction with an operand, */
1694         /* then duplicate the operand (and expand wild cards in the process). */
1695         if(pcr->type == PC_OPCODE) {
1696           if(PCI(pcr)->pcop) {
1697             /* The replacing instruction has an operand.
1698              * Is it wild? */
1699             if(PCI(pcr)->pcop->type == PO_WILD) {
1700               int index = PCOW(PCI(pcr)->pcop)->id;
1701               fprintf(stderr,"copying wildopcode\n");
1702               if(peepBlock->wildpCodeOps[index])
1703                 pcop = pCodeOpCopy(peepBlock->wildpCodeOps[index]);
1704               else
1705                 fprintf(stderr,"error, wildopcode in replace but not source?\n");
1706             } else
1707               pcop = pCodeOpCopy(PCI(pcr)->pcop);
1708           }
1709           fprintf(stderr,"inserting pCode\n");
1710           pCodeInsertAfter(pc, newpCode(PCI(pcr)->op,pcop));
1711         } else if (pcr->type == PC_WILD) {
1712           pCodeInsertAfter(pc,peepBlock->wildpCodes[PCW(pcr)->id]);
1713         } else if (pcr->type == PC_COMMENT) {
1714           pCodeInsertAfter(pc, newpCodeCharP( ((pCodeComment *)(pcr))->comment));
1715         }
1716
1717
1718         pc = pc->next;
1719         if(pc)
1720           pc->print(stderr,pc);
1721         pcr = pcr->next;
1722       }
1723
1724       return 1;
1725     }
1726   next_rule:
1727     peeprules = peeprules->next;
1728   }
1729
1730   return 0;
1731 }
1732
1733
1734
1735
1736
1737
1738
1739
1740
1741
1742 #if 0
1743 /*******************/
1744 pCode *parseLineNode(char *ln)
1745 {
1746   char buffer[50], *s;
1747   int state=0;          //0 label, 1 mnemonic, 2 operand, 3 operand, 4 comment
1748   int var;
1749   pCode *pc = NULL;
1750   //  pCodeLabel *pcl = NULL;
1751
1752   if(!ln || !*ln)
1753     return pc;
1754
1755   s = buffer;
1756   *s = 0;
1757
1758   while(*ln) {
1759
1760     /* skip white space */
1761     while (isspace (*ln))
1762       ln++;
1763
1764     switch(state) {
1765
1766     case 0:   // look for a label
1767     case 1:   // look for mnemonic
1768
1769       if(*ln == '%') {
1770
1771         // Wild
1772
1773         ln++;
1774         if(!isdigit(*ln) )
1775           break;
1776           //goto next_state;
1777
1778         var = strtol(ln, &ln, 10);
1779         if(*ln  == ':') {
1780           // valid wild card label
1781           fprintf(stderr, " wildcard label: %d\n",var);
1782           ln++;
1783         } else
1784           fprintf(stderr, " wild opcode: %d\n",var), state++;
1785
1786       } else {
1787         // not wild
1788         // Extract the label/mnemonic from the line
1789
1790         s = buffer;
1791         while(*ln && !(isspace(*ln) || *ln == ':'))
1792           *s++ = *ln++;
1793
1794         *s = 0;
1795         if(*ln == ':')
1796           fprintf(stderr," regular label: %s\n",buffer), ln++;
1797         else
1798           fprintf(stderr," regular mnem: %s\n",buffer), state++;
1799       }
1800       state++;
1801       break;
1802
1803     default:
1804       ln++;
1805
1806     }
1807   }
1808
1809   return pc;
1810
1811 }
1812 #endif