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