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