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 "pcodeflow.h"
  30 #include "ralloc.h"
  31
  32 #if defined(__BORLANDC__) || defined(_MSC_VER)
  33 #define STRCASECMP stricmp
  34 #else
  35 #define STRCASECMP strcasecmp
  36 #endif
  37
  38 pCodeOp *popCopyGPR2Bit(pCodeOpReg *pc, int bitval);
  39
  40
  41 pCodeOp *newpCodeOpWild(int id, pCodeWildBlock *pcwb, pCodeOp *subtype);
  42 pCode *newpCodeWild(int pCodeID, pCodeOp *optional_operand, pCodeOp *optional_label);
  43 pCode * findNextInstruction(pCode *pc);
  44 int getpCode(char *mnem,int dest);
  45 int getpCodePeepCommand(char *cmd);
  46 void pBlockMergeLabels(pBlock *pb);
  47 char *pCode2str(char *str, int size, pCode *pc);
  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->nvars)
 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->nvars)
 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++;
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++;
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 /*
1224     curPeep = pcps->peep  = Safe_calloc(1,sizeof(pCodePeep));
1225
1226     curPeep->vars = NULL;
1227     curPeep->wildpCodes = NULL; curPeep->wildpCodeOps = NULL;
1228     curPeep->postFalseCond = PCC_NONE;
1229     curPeep->postTrueCond  = PCC_NONE;
1230
1231
1232     curPeep->target = curBlock = newpCodeChain(NULL, 'W', NULL);
1233     sMaxWildVar  = 0;
1234     sMaxWildMnem = 0;
1235 */
1236     currentRule = pcps->peep  = Safe_calloc(1,sizeof(pCodePeep));
1237     initpCodePeep(currentRule);
1238
1239     /* Convert the target block */
1240     peepRuleBlock2pCodeBlock(pr->match, &currentRule->target);
1241
1242     //DFPRINTF((stderr,"finished target, here it is in pcode form:\n"));
1243     //printpBlock(stderr, curBlock);
1244
1245     //DFPRINTF((stderr,"target with labels merged:\n"));
1246     //pBlockMergeLabels(curBlock);
1247     pBlockMergeLabels(currentRule->target.pb);
1248     //printpBlock(stderr, currentRule->replace.pb);
1249
1250     //#ifdef PCODE_DEBUG
1251     //    printpBlock(stderr, curBlock);
1252     //#endif
1253     //DFPRINTF((stderr,"\nReplaced by:\n"));
1254
1255
1256     //curPeep->replace = curBlock = newpCodeChain(NULL, 'W', NULL);
1257
1258     /* Convert the replace block */
1259     peepRuleBlock2pCodeBlock(pr->replace, &currentRule->replace);
1260
1261     //DFPRINTF((stderr,"finished replace block, here it is in pcode form:\n"));
1262     //printpBlock(stderr, curBlock);
1263
1264     //DFPRINTF((stderr,"replace with labels merged:\n"));
1265     //pBlockMergeLabels(curBlock);
1266     pBlockMergeLabels(currentRule->replace.pb);
1267     //printpBlock(stderr, currentRule->replace.pb);
1268
1269     peepRuleCondition(pr->cond,currentRule);
1270
1271     /* The rule has been converted to pCode. Now allocate
1272      * space for the wildcards */
1273
1274 /*
1275      ++sMaxWildVar;
1276     curPeep->nvars = sMaxWildVar;
1277     curPeep->vars = Safe_calloc(sMaxWildVar, sizeof(char *));
1278
1279     curPeep->nops = sMaxWildVar;
1280     curPeep->wildpCodeOps = Safe_calloc(sMaxWildVar, sizeof(pCodeOp *));
1281
1282     curPeep->nwildpCodes = ++sMaxWildMnem;
1283     curPeep->wildpCodes = Safe_calloc(sMaxWildMnem, sizeof(char *));
1284 */
1285     postinit_pCodeWildBlock(&currentRule->target);
1286
1287     //return; // debug ... don't want to go through all the rules yet
1288   }
1289
1290   {
1291     pCodePeep *peepBlock;
1292     _DLL *peeprules;
1293
1294     peeprules = (_DLL *)peepSnippets;
1295     //fprintf(stderr,"target rules\n");
1296     while(peeprules) {
1297       //fprintf(stderr,"   rule:\n");
1298       peepBlock = ((pCodePeepSnippets*)peeprules)->peep;
1299       //printpBlock(stderr, peepBlock->target.pb);
1300       peeprules = peeprules->next;
1301     }
1302     //fprintf(stderr," ... done\n");
1303   }
1304
1305 }
1306
1307 void printpCodeString(FILE *of, pCode *pc, int max)
1308 {
1309   int i=0;
1310
1311   while(pc && (i++<max)) {
1312     pc->print(of,pc);
1313     pc = pc->next;
1314   }
1315 }
1316
1317 /*-----------------------------------------------------------------*/
1318 /* _DLL * DLL_append                                               */
1319 /*                                                                 */
1320 /*  Append a _DLL object to the end of a _DLL (doubly linked list) */
1321 /* If The list to which we want to append is non-existant then one */
1322 /* is created. Other wise, the end of the list is sought out and   */
1323 /* a new DLL object is appended to it. In either case, the void    */
1324 /* *data is added to the newly created DLL object.                 */
1325 /*-----------------------------------------------------------------*/
1326
1327 static void * DLL_append(_DLL *list, _DLL *next)
1328 {
1329   _DLL *b;
1330
1331
1332   /* If there's no list, then create one: */
1333   if(!list) {
1334     next->next = next->prev = NULL;
1335     return next;
1336   }
1337
1338
1339   /* Search for the end of the list. */
1340   b = list;
1341   while(b->next)
1342     b = b->next;
1343
1344   /* Now append the new DLL object */
1345   b->next = next;
1346   b->next->prev = b;
1347   b = b->next;
1348   b->next = NULL;
1349
1350   return list;
1351
1352 }
1353
1354
1355 /*-----------------------------------------------------------------
1356
1357   pCode peephole optimization
1358
1359
1360   The pCode "peep hole" optimization is not too unlike the peep hole
1361   optimization in SDCCpeeph.c. The major difference is that here we
1362   use pCode's whereas there we use ASCII strings. The advantage with
1363   pCode's is that we can ascertain flow information in the instructions
1364   being optimized.
1365
1366
1367 <FIX ME> - elaborate...
1368
1369   -----------------------------------------------------------------*/
1370
1371
1372
1373 /*-----------------------------------------------------------------*/
1374 /* pCodeSearchCondition - Search a pCode chain for a 'condition'   */
1375 /*                                                                 */
1376 /* return conditions                                               */
1377 /*  1 - The Condition was found for a pCode's input                */
1378 /*  0 - No matching condition was found for the whole chain        */
1379 /* -1 - The Condition was found for a pCode's output               */
1380 /*                                                                 */
1381 /*-----------------------------------------------------------------*/
1382 int pCodeSearchCondition(pCode *pc, unsigned int cond)
1383 {
1384
1385   while(pc) {
1386
1387     /* If we reach a function end (presumably an end since we most
1388        probably began the search in the middle of a function), then
1389        the condition was not found. */
1390     if(pc->type == PC_FUNCTION)
1391       return 0;
1392
1393     if(pc->type == PC_OPCODE) {
1394       if(PCI(pc)->inCond & cond)
1395         return 1;
1396       if(PCI(pc)->outCond & cond)
1397         return -1;
1398     }
1399
1400     pc = pc->next;
1401   }
1402
1403   return 0;
1404 }
1405
1406 int pCodePeepMatchLabels(pCodePeep *peepBlock, pCode *pcs, pCode *pcd)
1407 {
1408   int labindex;
1409
1410   /* Check for a label associated with this wild pCode */
1411   // If the wild card has a label, make sure the source code does too.
1412   if(PCI(pcd)->label) {
1413     pCode *pcl;
1414
1415     if(!PCI(pcs)->label)
1416       return 0;
1417
1418     pcl = PCI(pcd)->label->pc;
1419
1420     labindex = -PCL(pcl)->key;
1421     //DFPRINTF((stderr,"label id = %d (labindex = %d)\n",PCL(pcl)->key,labindex));
1422     if(peepBlock->target.vars[labindex] == NULL) {
1423       // First time to encounter this label
1424       peepBlock->target.vars[labindex] = PCL(PCI(pcs)->label->pc)->label;
1425       //DFPRINTF((stderr,"first time for a label: %d %s\n",labindex, peepBlock->vars[labindex]));
1426     } else {
1427       if(strcmp(peepBlock->target.vars[labindex],PCL(PCI(pcs)->label->pc)->label) != 0) {
1428         // DFPRINTF((stderr,"labels don't match\n"));
1429         return 0;
1430       }
1431       //DFPRINTF((stderr,"matched a label\n"));
1432     }
1433   } else {
1434     // DFPRINTF((stderr,"destination doesn't have a label\n"));
1435
1436     if(PCI(pcs)->label)
1437       return 0;
1438   }
1439
1440   return 1;
1441
1442 }
1443
1444 /*-----------------------------------------------------------------*/
1445 /* pCodePeepMatchLine - Compare source and destination pCodes to   */
1446 /*                      see they're the same.                      */
1447 /*                                                                 */
1448 /* In this context, "source" refers to the coded generated by gen.c*/
1449 /* and "destination" refers to a pcode in a peep rule. If the dest-*/
1450 /* ination has no wild cards, then MatchLine will compare the two  */
1451 /* pcodes (src and dest) for a one-to-one match. If the destination*/
1452 /* has wildcards, then those get expanded. When a wild card is     */
1453 /* encountered for the first time it autmatically is considered a  */
1454 /* match and the object that matches it is referenced in the       */
1455 /* variables or opcodes array (depending on the type of match).    */
1456 /*                                                                 */
1457 /*                                                                 */
1458 /* Inputs:                                                         */
1459 /*  *peepBlock - A pointer to the peepBlock that contains the      */
1460 /*               entire rule to which the destination pcode belongs*/
1461 /*  *pcs - a pointer to the source pcode                           */
1462 /*  *pcd - a pointer to the destination pcode                      */
1463 /*                                                                 */
1464 /* Returns:                                                        */
1465 /*  1 - pcodes match                                               */
1466 /*  0 - pcodes don't match                                         */
1467 /*                                                                 */
1468 /*                                                                 */
1469 /*-----------------------------------------------------------------*/
1470
1471 int pCodePeepMatchLine(pCodePeep *peepBlock, pCode *pcs, pCode *pcd)
1472 {
1473   int index;   // index into wild card arrays
1474
1475   /* one-for-one match. Here the source and destination opcodes
1476    * are not wild. However, there may be a label or a wild operand */
1477
1478   if(pcs->type == pcd->type) {
1479
1480     if(pcs->type == PC_OPCODE) {
1481
1482       /* If the opcodes don't match then the line doesn't match */
1483       if(PCI(pcs)->op != PCI(pcd)->op)
1484         return 0;
1485
1486       /*
1487       DFPRINTF((stderr,"%s comparing\n",__FUNCTION__));
1488       pcs->print(stderr,pcs);
1489       pcd->print(stderr,pcd);
1490       */
1491
1492       if(!pCodePeepMatchLabels(peepBlock, pcs, pcd))
1493         return 0;
1494
1495       /* Compare the operands */
1496       if(PCI(pcd)->pcop) {
1497         if (PCI(pcd)->pcop->type == PO_WILD) {
1498           index = PCOW(PCI(pcd)->pcop)->id;
1499
1500           //DFPRINTF((stderr,"destination is wild\n"));
1501 #ifdef DEBUG_PCODEPEEP
1502           if (index > peepBlock->nops) {
1503             DFPRINTF((stderr,"%s - variables exceeded\n",__FUNCTION__));
1504             exit(1);
1505           }
1506 #endif
1507           PCOW(PCI(pcd)->pcop)->matched = PCI(pcs)->pcop;
1508           if(!peepBlock->target.wildpCodeOps[index]) {
1509             peepBlock->target.wildpCodeOps[index] = PCI(pcs)->pcop;
1510
1511             //if(PCI(pcs)->pcop->type == PO_GPR_TEMP)
1512
1513           }
1514           {
1515             char *n;
1516
1517             switch(PCI(pcs)->pcop->type) {
1518             case PO_GPR_TEMP:
1519             case PO_FSR:
1520               //case PO_INDF:
1521               n = PCOR(PCI(pcs)->pcop)->r->name;
1522
1523               break;
1524             default:
1525               n = PCI(pcs)->pcop->name;
1526             }
1527
1528             if(peepBlock->target.vars[index])
1529               return  (strcmp(peepBlock->target.vars[index],n) == 0);
1530             else {
1531               // DFPRINTF((stderr,"first time for a variable: %d, %s\n",index,n));
1532               peepBlock->target.vars[index] = n;
1533               return 1;
1534             }
1535           }
1536         }
1537         /* FIXME - need an else to check the case when the destination
1538          * isn't a wild card */
1539       } else
1540         /* The pcd has no operand. Lines match if pcs has no operand either*/
1541         return (PCI(pcs)->pcop == NULL);
1542     }
1543   }
1544
1545   /* Compare a wild instruction to a regular one. */
1546
1547   if((pcd->type == PC_WILD) && (pcs->type == PC_OPCODE)) {
1548
1549
1550     index = PCW(pcd)->id;
1551
1552     //    DFPRINTF((stderr,"%s comparing wild cards\n",__FUNCTION__));
1553     //pcs->print(stderr,pcs);
1554     //pcd->print(stderr,pcd);
1555
1556     peepBlock->target.wildpCodes[PCW(pcd)->id] = pcs;
1557
1558     if(!pCodePeepMatchLabels(peepBlock, pcs, pcd))
1559       return 0;
1560
1561     if(PCW(pcd)->mustBeBitSkipInst & !(PCI(pcs)->isBitInst && PCI(pcs)->isSkip)) {
1562       // doesn't match because the wild pcode must be a bit skip
1563       //fprintf(stderr," Failing match because bit skip is req:\n");
1564       //pcd->print(stderr,pcd);
1565       //pcs->print(stderr,pcs);
1566       return 0;
1567     }
1568
1569     if(PCW(pcd)->mustNotBeBitSkipInst & (PCI(pcs)->isBitInst && PCI(pcs)->isSkip)) {
1570       // doesn't match because the wild pcode must *not* be a bit skip
1571       //fprintf(stderr," Failing match because don't want skip :\n");
1572       //pcd->print(stderr,pcd);
1573       //pcs->print(stderr,pcs);
1574       return 0;
1575     }
1576
1577     if(PCW(pcd)->operand) {
1578       PCOW(PCI(pcd)->pcop)->matched = PCI(pcs)->pcop;
1579       if(peepBlock->target.vars[index]) {
1580         int i = (strcmp(peepBlock->target.vars[index],PCI(pcs)->pcop->name) == 0);
1581         /*
1582         if(i)
1583           DFPRINTF((stderr," (matched)\n"));
1584         else {
1585           DFPRINTF((stderr," (no match: wild card operand mismatch\n"));
1586           DFPRINTF((stderr,"  peepblock= %s,  pcodeop= %s\n"),
1587                   peepBlock->vars[index],
1588                   PCI(pcs)->pcop->name);
1589         }
1590         */
1591         return i;
1592       } else {
1593         peepBlock->target.vars[index] = PCI(pcs)->pcop->name;
1594         return 1;
1595       }
1596     }
1597
1598     pcs = findNextInstruction(pcs->next);
1599     if(pcs) {
1600       //DFPRINTF((stderr," (next to match)\n"));
1601       //pcs->print(stderr,pcs);
1602     } else if(pcd->next) {
1603       /* oops, we ran out of code, but there's more to the rule */
1604       return 0;
1605     }
1606
1607     return 1; /*  wild card matches */
1608   }
1609
1610   return 0;
1611 }
1612
1613 /*-----------------------------------------------------------------*/
1614 /*-----------------------------------------------------------------*/
1615 void pCodePeepClrVars(pCodePeep *pcp)
1616 {
1617
1618   int i;
1619   if(!pcp)
1620     return;
1621
1622   for(i=0;i<pcp->target.nvars; i++) {
1623     pcp->target.vars[i] = NULL;
1624     pcp->target.wildpCodeOps[i] = NULL;
1625   }
1626 }
1627
1628 /*-----------------------------------------------------------------*/
1629 /*  pCodeInsertAfter - splice in the pCode chain starting with pc2 */
1630 /*                     into the pCode chain containing pc1         */
1631 /*-----------------------------------------------------------------*/
1632 void pCodeInsertAfter(pCode *pc1, pCode *pc2)
1633 {
1634
1635   if(!pc1 || !pc2)
1636     return;
1637
1638   pc2->next = pc1->next;
1639   if(pc1->next)
1640     pc1->next->prev = pc2;
1641
1642   pc2->pb = pc1->pb;
1643   pc2->prev = pc1;
1644   pc1->next = pc2;
1645
1646 }
1647
1648 /*-----------------------------------------------------------------*/
1649 /* pCodeOpCopy - copy a pcode operator                             */
1650 /*-----------------------------------------------------------------*/
1651 pCodeOp *pCodeOpCopy(pCodeOp *pcop)
1652 {
1653   pCodeOp *pcopnew=NULL;
1654
1655   if(!pcop)
1656     return NULL;
1657
1658   switch(pcop->type) {
1659   case PO_CRY:
1660   case PO_BIT:
1661     //DFPRINTF((stderr,"pCodeOpCopy bit\n"));
1662     pcopnew = Safe_calloc(1,sizeof(pCodeOpRegBit) );
1663     PCORB(pcopnew)->bit = PCORB(pcop)->bit;
1664     PCORB(pcopnew)->inBitSpace = PCORB(pcop)->inBitSpace;
1665
1666     break;
1667
1668   case PO_WILD:
1669     /* Here we expand the wild card into the appropriate type: */
1670     /* By recursively calling pCodeOpCopy */
1671     //DFPRINTF((stderr,"pCodeOpCopy wild\n"));
1672     if(PCOW(pcop)->matched)
1673       pcopnew = pCodeOpCopy(PCOW(pcop)->matched);
1674     else {
1675       // Probably a label
1676       pcopnew = pCodeOpCopy(PCOW(pcop)->subtype);
1677       pcopnew->name = Safe_strdup(PCOW(pcop)->pcwb->vars[PCOW(pcop)->id]);
1678       //DFPRINTF((stderr,"copied a wild op named %s\n",pcopnew->name));
1679     }
1680
1681     return pcopnew;
1682     break;
1683
1684   case PO_LABEL:
1685     //DFPRINTF((stderr,"pCodeOpCopy label\n"));
1686     pcopnew = Safe_calloc(1,sizeof(pCodeOpLabel) );
1687     PCOLAB(pcopnew)->key =  PCOLAB(pcop)->key;
1688     break;
1689
1690   case PO_IMMEDIATE:
1691     pcopnew = Safe_calloc(1,sizeof(pCodeOpImmd) );
1692     PCOI(pcopnew)->offset = PCOI(pcop)->offset;
1693     break;
1694
1695   case PO_LITERAL:
1696     //DFPRINTF((stderr,"pCodeOpCopy lit\n"));
1697     pcopnew = Safe_calloc(1,sizeof(pCodeOpLit) );
1698     PCOL(pcopnew)->lit = PCOL(pcop)->lit;
1699     break;
1700
1701   case PO_GPR_BIT:
1702
1703     pcopnew = newpCodeOpBit(pcop->name, PCORB(pcop)->bit,PCORB(pcop)->inBitSpace);
1704     PCOR(pcopnew)->r = PCOR(pcop)->r;
1705     PCOR(pcopnew)->rIdx = PCOR(pcop)->rIdx;
1706     DFPRINTF((stderr," pCodeOpCopy Bit -register index\n"));
1707     return pcopnew;
1708     break;
1709
1710   case PO_GPR_REGISTER:
1711   case PO_GPR_TEMP:
1712   case PO_FSR:
1713   case PO_INDF:
1714     //DFPRINTF((stderr,"pCodeOpCopy GPR register\n"));
1715     pcopnew = Safe_calloc(1,sizeof(pCodeOpReg) );
1716     PCOR(pcopnew)->r = PCOR(pcop)->r;
1717     PCOR(pcopnew)->rIdx = PCOR(pcop)->rIdx;
1718     DFPRINTF((stderr," register index %d\n", PCOR(pcop)->r->rIdx));
1719     break;
1720
1721   case PO_DIR:
1722     fprintf(stderr,"pCodeOpCopy PO_DIR\n");
1723     pcopnew = Safe_calloc(1,sizeof(pCodeOpReg) );
1724     break;
1725   case PO_STATUS:
1726     DFPRINTF((stderr,"pCodeOpCopy PO_STATUS\n"));
1727   case PO_SFR_REGISTER:
1728   case PO_STR:
1729   case PO_NONE:
1730   case PO_W:
1731   case PO_INTCON:
1732   case PO_PCL:
1733   case PO_PCLATH:
1734
1735     //DFPRINTF((stderr,"pCodeOpCopy register type %d\n", pcop->type));
1736     pcopnew = Safe_calloc(1,sizeof(pCodeOp) );
1737
1738   }
1739
1740   pcopnew->type = pcop->type;
1741   if(pcop->name)
1742     pcopnew->name = Safe_strdup(pcop->name);
1743   else
1744     pcopnew->name = NULL;
1745
1746   return pcopnew;
1747 }
1748
1749
1750 /*-----------------------------------------------------------------*/
1751 /* pCodeCopy - copy a pcode                                        */
1752 /*-----------------------------------------------------------------*/
1753 static pCode *pCodeInstructionCopy(pCodeInstruction *pci,int invert)
1754 {
1755   pCodeInstruction *new_pci;
1756
1757   if(invert)
1758     new_pci = PCI(newpCode(pci->inverted_op,pci->pcop));
1759   else
1760     new_pci = PCI(newpCode(pci->op,pci->pcop));
1761
1762   new_pci->pc.pb = pci->pc.pb;
1763   new_pci->from = pci->from;
1764   new_pci->to   = pci->to;
1765   new_pci->label = pci->label;
1766   new_pci->pcflow = pci->pcflow;
1767
1768   return PCODE(new_pci);
1769 }
1770
1771 /*-----------------------------------------------------------------*/
1772 /*-----------------------------------------------------------------*/
1773 void pCodeDeleteChain(pCode *f,pCode *t)
1774 {
1775   pCode *pc;
1776
1777
1778   while(f && f!=t) {
1779     DFPRINTF((stderr,"delete pCode:\n"));
1780     pc = f->next;
1781     f->print(stderr,f);
1782     //f->delete(f);  this dumps core...
1783
1784     f = pc;
1785
1786   }
1787
1788 }
1789 /*-----------------------------------------------------------------*/
1790 /*-----------------------------------------------------------------*/
1791 int pCodePeepMatchRule(pCode *pc)
1792 {
1793   pCodePeep *peepBlock;
1794   pCode *pct, *pcin;
1795   _DLL *peeprules;
1796   int matched;
1797
1798   peeprules = (_DLL *)peepSnippets;
1799
1800   while(peeprules) {
1801     peepBlock = ((pCodePeepSnippets*)peeprules)->peep;
1802
1803     if(!peepBlock || /*!peepBlock->target ||*/ !peepBlock->target.pb->pcHead) {
1804       fprintf(stderr, "skipping rule because target pb is NULL\n");
1805       goto next_rule;
1806     }
1807
1808     pCodePeepClrVars(peepBlock);
1809
1810     pcin = pc;
1811     if(IS_PCCOMMENT(pcin))
1812       pc = pcin = findNextInstruction(pcin->next);
1813
1814     pct = peepBlock->target.pb->pcHead;
1815     matched = 0;
1816     while(pct && pcin) {
1817
1818       if(! (matched = pCodePeepMatchLine(peepBlock, pcin,pct)))
1819         break;
1820
1821       pcin = findNextInstruction(pcin->next);
1822       pct = pct->next;
1823       //debug:
1824       //DFPRINTF((stderr,"    matched\n"));
1825       if(!pcin)
1826         DFPRINTF((stderr," end of code\n"));
1827       if(!pct)
1828         DFPRINTF((stderr," end of rule\n"));
1829     }
1830
1831     if(matched) {
1832
1833       /* So far we matched the rule up to the point of the conditions .
1834        * In other words, all of the opcodes match. Now we need to see
1835        * if the post conditions are satisfied.
1836        * First we check the 'postFalseCond'. This means that we check
1837        * to see if any of the subsequent pCode's in the pCode chain
1838        * following the point just past where we have matched depend on
1839        * the `postFalseCond' as input then we abort the match
1840        */
1841       DFPRINTF((stderr,"    matched rule so far, now checking conditions\n"));
1842       if (pcin && peepBlock->postFalseCond &&
1843           (pCodeSearchCondition(pcin,peepBlock->postFalseCond) > 0) )
1844         matched = 0;
1845     }
1846
1847     if(matched) {
1848
1849       pCode *pcprev;
1850       pCode *pcr;
1851
1852
1853       /* We matched a rule! Now we have to go through and remove the
1854          inefficient code with the optimized version */
1855 #ifdef PCODE_DEBUG
1856       DFPRINTF((stderr, "Found a pcode peep match:\nRule:\n"));
1857       printpCodeString(stderr,peepBlock->target.pb->pcHead,10);
1858       DFPRINTF((stderr,"first thing matched\n"));
1859       pc->print(stderr,pc);
1860 #endif
1861       if(pcin) {
1862         DFPRINTF((stderr,"last thing matched\n"));
1863         pcin->print(stderr,pcin);
1864       }
1865
1866       /* Unlink the original code */
1867       pcprev = pc->prev;
1868       pcprev->next = pcin;
1869       if(pcin)
1870         pcin->prev = pc->prev;
1871
1872       {
1873         /*     DEBUG    */
1874         /* Converted the deleted pCodes into comments */
1875
1876         char buf[256];
1877
1878         buf[0] = ';';
1879         buf[1] = '#';
1880
1881         while(pc &&  pc!=pcin) {
1882           pCode2str(&buf[2], 254, pc);
1883           pCodeInsertAfter(pcprev, newpCodeCharP(buf));
1884           pcprev = pcprev->next;
1885           pc = pc->next;
1886         }
1887       }
1888
1889       if(pcin)
1890         pCodeDeleteChain(pc,pcin);
1891
1892       /* Generate the replacement code */
1893       pc = pcprev;
1894       pcr = peepBlock->replace.pb->pcHead;  // This is the replacement code
1895       while (pcr) {
1896         pCodeOp *pcop=NULL;
1897         /* If the replace pcode is an instruction with an operand, */
1898         /* then duplicate the operand (and expand wild cards in the process). */
1899         if(pcr->type == PC_OPCODE) {
1900           if(PCI(pcr)->pcop) {
1901             /* The replacing instruction has an operand.
1902              * Is it wild? */
1903             if(PCI(pcr)->pcop->type == PO_WILD) {
1904               int index = PCOW(PCI(pcr)->pcop)->id;
1905               //DFPRINTF((stderr,"copying wildopcode\n"));
1906               if(peepBlock->target.wildpCodeOps[index])
1907                 pcop = pCodeOpCopy(peepBlock->target.wildpCodeOps[index]);
1908               else
1909                 DFPRINTF((stderr,"error, wildopcode in replace but not source?\n"));
1910             } else
1911               pcop = pCodeOpCopy(PCI(pcr)->pcop);
1912           }
1913           //DFPRINTF((stderr,"inserting pCode\n"));
1914           pCodeInsertAfter(pc, newpCode(PCI(pcr)->op,pcop));
1915         } else if (pcr->type == PC_WILD) {
1916           if(PCW(pcr)->invertBitSkipInst)
1917             DFPRINTF((stderr,"We need to invert the bit skip instruction\n"));
1918           pCodeInsertAfter(pc,
1919                            pCodeInstructionCopy(PCI(peepBlock->target.wildpCodes[PCW(pcr)->id]),
1920                                                 PCW(pcr)->invertBitSkipInst));
1921         } else if (pcr->type == PC_COMMENT) {
1922           pCodeInsertAfter(pc, newpCodeCharP( ((pCodeComment *)(pcr))->comment));
1923         }
1924
1925
1926         pc = pc->next;
1927         //if(pc)
1928         //  pc->print(stderr,pc);
1929         pcr = pcr->next;
1930       }
1931
1932       return 1;
1933     }
1934   next_rule:
1935     peeprules = peeprules->next;
1936   }
1937
1938   return 0;
1939 }