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

   1 /*-------------------------------------------------------------------------
   2   SDCCcse.c - source file for Common Subexpressions and other utility
   3
   4              Written By -  Sandeep Dutta . sandeep.dutta@usa.net (1998)
   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    In other words, you are welcome to use, share and improve this program.
  21    You are forbidden to forbid anyone else to use, share and improve
  22    what you give them.   Help stamp out software-hoarding!
  23 -------------------------------------------------------------------------*/
  24
  25 #include "common.h"
  26 #include "newalloc.h"
  27
  28 /*-----------------------------------------------------------------*/
  29 /* newCseDef - new cseDef                                          */
  30 /*-----------------------------------------------------------------*/
  31 cseDef *newCseDef (operand *sym, iCode *ic)
  32 {
  33     cseDef *cdp ;
  34
  35     assert (sym);
  36     cdp = Safe_calloc(1,sizeof(cseDef));
  37
  38     cdp->sym = sym;
  39     cdp->diCode = ic;
  40     cdp->key = sym->key;
  41
  42     return cdp;
  43 }
  44
  45
  46
  47 /*-----------------------------------------------------------------*/
  48 /* int isCseDefEqual - two definitions are equal                   */
  49 /*-----------------------------------------------------------------*/
  50 int isCseDefEqual ( void *vsrc, void *vdest)
  51 {
  52     cseDef *src = vsrc;
  53     cseDef *dest = vdest;
  54
  55     if (src == dest)
  56   return 1;
  57
  58     return (src->key == dest->key &&
  59       src->diCode == dest->diCode ) ;
  60
  61 }
  62
  63 /*-----------------------------------------------------------------*/
  64 /* pcseDef - in the cseDef                                         */
  65 /*-----------------------------------------------------------------*/
  66 int pcseDef (void *item, va_list ap)
  67 {
  68     cseDef *cdp = item;
  69     iCodeTable *icTab ;
  70
  71     (void)ap;
  72
  73     if (!cdp->sym)
  74   fprintf(stdout,"**null op**");
  75     printOperand(cdp->sym,stdout);
  76     icTab = getTableEntry(cdp->diCode->op) ;
  77     icTab->iCodePrint(stdout,cdp->diCode,icTab->printName);
  78     return 1;
  79 }
  80
  81 /*-----------------------------------------------------------------*/
  82 /* replaceAllSymBySym - replaces all operands by operand in an     */
  83 /*                      instruction chain                          */
  84 /*-----------------------------------------------------------------*/
  85 void replaceAllSymBySym (iCode *ic, operand *from , operand *to, bitVect **ndpset)
  86 {
  87     iCode *lic;
  88
  89     for (lic = ic ; lic ; lic = lic->next ) {
  90   int siaddr ;
  91
  92   /* do the special cases first */
  93   if (lic->op == IFX) {
  94     if (IS_SYMOP(to) &&
  95         IC_COND(lic)->key == from->key) {
  96
  97       bitVectUnSetBit (OP_USES(from),lic->key);
  98       OP_USES(to) = bitVectSetBit(OP_USES(to),lic->key);
  99       siaddr = IC_COND(lic)->isaddr ;
 100       IC_COND(lic) = operandFromOperand(to);
 101       IC_COND(lic)->isaddr = siaddr ;
 102
 103     }
 104     continue ;
 105   }
 106
 107   if (lic->op == JUMPTABLE) {
 108     if (IS_SYMOP(to) &&
 109         IC_JTCOND(lic)->key == from->key) {
 110
 111       bitVectUnSetBit (OP_USES(from),lic->key);
 112       OP_USES(to) = bitVectSetBit(OP_USES(to),lic->key);
 113       siaddr = IC_COND(lic)->isaddr ;
 114       IC_JTCOND(lic) = operandFromOperand(to);
 115       IC_JTCOND(lic)->isaddr = siaddr ;
 116
 117     }
 118     continue ;
 119   }
 120
 121   if (IC_RESULT(lic) && IC_RESULT(lic)->key == from->key ) {
 122       /* maintain du chains */
 123       if (POINTER_SET(lic)) {
 124     bitVectUnSetBit (OP_USES(from),lic->key);
 125     OP_USES(to) = bitVectSetBit (OP_USES(to),lic->key);
 126
 127     /* also check if the "from" was in the non-dominating
 128        pointer sets and replace it with "to" in the bitVector */
 129     if (bitVectBitValue(*ndpset,from->key)) {
 130         bitVectUnSetBit(*ndpset,from->key);
 131         bitVectSetBit(*ndpset,to->key);
 132     }
 133
 134       }
 135       else {
 136     bitVectUnSetBit (OP_DEFS(from),lic->key);
 137     OP_DEFS(to) = bitVectSetBit (OP_DEFS(to),lic->key);
 138       }
 139       siaddr = IC_RESULT(lic)->isaddr ;
 140       IC_RESULT(lic) = operandFromOperand(to);
 141       IC_RESULT(lic)->isaddr = siaddr ;
 142   }
 143
 144   if (IS_SYMOP(to) &&
 145       IC_RIGHT(lic) && IC_RIGHT(lic)->key == from->key ) {
 146       bitVectUnSetBit (OP_USES(from),lic->key);
 147       OP_USES(to) = bitVectSetBit(OP_USES(to),lic->key);
 148       siaddr = IC_RIGHT(lic)->isaddr ;
 149       IC_RIGHT(lic) = operandFromOperand(to);
 150       IC_RIGHT(lic)->isaddr = siaddr ;
 151   }
 152
 153   if (IS_SYMOP(to) &&
 154       IC_LEFT(lic) && IC_LEFT(lic)->key == from->key ) {
 155       bitVectUnSetBit (OP_USES(from),lic->key);
 156       OP_USES(to) = bitVectSetBit(OP_USES(to),lic->key);
 157       siaddr = IC_LEFT(lic)->isaddr ;
 158       IC_LEFT(lic) = operandFromOperand(to);
 159       IC_LEFT(lic)->isaddr = siaddr ;
 160   }
 161     }
 162 }
 163
 164 /*-----------------------------------------------------------------*/
 165 /* iCodeKeyIs - if the icode keys match then return 1              */
 166 /*-----------------------------------------------------------------*/
 167 DEFSETFUNC(iCodeKeyIs)
 168 {
 169     cseDef *cdp = item;
 170     V_ARG(int,key);
 171
 172     if (cdp->diCode->key == key)
 173   return 1;
 174     else
 175   return 0;
 176 }
 177
 178 /*-----------------------------------------------------------------*/
 179 /* removeFromInExprs - removes an icode from inexpressions         */
 180 /*-----------------------------------------------------------------*/
 181 DEFSETFUNC(removeFromInExprs)
 182 {
 183     eBBlock *ebp = item;
 184     V_ARG(iCode *,ic);
 185     V_ARG(operand *,from);
 186     V_ARG(operand *,to);
 187     V_ARG(eBBlock *,cbp);
 188
 189     if (ebp->visited)
 190   return 0;
 191
 192     ebp->visited = 1;
 193     deleteItemIf(&ebp->inExprs,iCodeKeyIs,ic->key);
 194     if (ebp != cbp && !bitVectBitValue(cbp->domVect,ebp->bbnum))
 195   replaceAllSymBySym(ebp->sch,from,to,&ebp->ndompset);
 196
 197     applyToSet(ebp->succList,removeFromInExprs,ic,from,to,cbp);
 198     return 0;
 199 }
 200
 201 /*-----------------------------------------------------------------*/
 202 /* isGlobalInNearSpace - return TRUE if valriable is a globalin data */
 203 /*-----------------------------------------------------------------*/
 204 static bool isGlobalInNearSpace (operand *op)
 205 {
 206     sym_link *type = getSpec(operandType(op));
 207     /* this is 8051 specific: optimization
 208        suggested by Jean-Louis VERN, with 8051s we have no
 209        advantage of putting variables in near space into
 210        registers */
 211     if (isOperandGlobal(op)  && !IN_FARSPACE(SPEC_OCLS(type)) &&
 212   IN_DIRSPACE(SPEC_OCLS(type)))
 213   return TRUE;
 214     else
 215   return FALSE;
 216 }
 217
 218 /*-----------------------------------------------------------------*/
 219 /* findCheaperOp - cseBBlock support routine, will check to see if */
 220 /*              we have a operand previously defined               */
 221 /*-----------------------------------------------------------------*/
 222 DEFSETFUNC(findCheaperOp)
 223 {
 224     cseDef *cdp = item ;
 225     V_ARG(operand *,cop);
 226     V_ARG(operand **,opp);
 227
 228     /* if we have already found it */
 229     if (*opp)
 230   return 1;
 231
 232     /* not found it yet check if this is the one */
 233     /* and this is not the defining one          */
 234     if (cop->key == cdp->key) {
 235
 236   /* do a special check this will help in */
 237   /* constant propagation & dead code elim*/
 238   /* for assignments only                 */
 239   if (cdp->diCode->op == '=') {
 240       /* if the result is volatile then return result */
 241       if (IS_OP_VOLATILE (IC_RESULT(cdp->diCode)))
 242     *opp = IC_RESULT(cdp->diCode);
 243       else
 244     /* if this is a straight assignment and
 245        left is a temp then prefer the temporary to the
 246        true symbol */
 247     if (!POINTER_SET(cdp->diCode) &&
 248         IS_ITEMP(IC_RESULT(cdp->diCode)) &&
 249         IS_TRUE_SYMOP(IC_RIGHT(cdp->diCode)))
 250         *opp = IC_RESULT(cdp->diCode);
 251     else
 252         /* if straight assignement && and both
 253            are temps then prefer the one that
 254            will not need extra space to spil, also
 255            take into consideration if right side
 256            an induction variable
 257         */
 258         if (!POINTER_SET(cdp->diCode) &&
 259       IS_ITEMP(IC_RESULT(cdp->diCode)) &&
 260       IS_ITEMP(IC_RIGHT(cdp->diCode))  &&
 261       !OP_SYMBOL(IC_RIGHT(cdp->diCode))->isind &&
 262       ( (!SPIL_LOC(IC_RIGHT(cdp->diCode)) &&
 263          SPIL_LOC(IC_RESULT(cdp->diCode))) ||
 264         ( SPIL_LOC(IC_RESULT(cdp->diCode)) &&
 265           SPIL_LOC(IC_RESULT(cdp->diCode)) ==
 266           SPIL_LOC(IC_RIGHT(cdp->diCode))) )
 267       )
 268       *opp = IC_RESULT(cdp->diCode);
 269         else
 270       *opp = IC_RIGHT(cdp->diCode);
 271   }
 272   else
 273       *opp = IC_RESULT(cdp->diCode) ;
 274     }
 275
 276     /* if this is an assign to a temp. then check
 277        if the right side is this then return this */
 278     if (IS_TRUE_SYMOP(cop) &&
 279   cdp->diCode->op == '=' &&
 280   !POINTER_SET(cdp->diCode) &&
 281   cop->key == IC_RIGHT(cdp->diCode)->key &&
 282   !isGlobalInNearSpace (IC_RIGHT(cdp->diCode)) &&
 283   IS_ITEMP(IC_RESULT(cdp->diCode)))
 284   *opp = IC_RESULT(cdp->diCode);
 285
 286     if (*opp) {
 287
 288   if ((isGlobalInNearSpace(cop) &&
 289       !isOperandLiteral(*opp)) ||
 290       isOperandVolatile(*opp,FALSE)
 291       ) {
 292       *opp = NULL;
 293       return 0;
 294   }
 295
 296   if (cop->key == (*opp)->key )  {
 297       *opp = NULL ;
 298       return 0;
 299   }
 300
 301   if ((*opp)->isaddr != cop->isaddr && IS_ITEMP(cop)) {
 302       *opp = operandFromOperand(*opp);
 303       (*opp)->isaddr = cop->isaddr;
 304   }
 305
 306   return 1;
 307
 308     }
 309
 310     return 0;
 311 }
 312
 313 /*-----------------------------------------------------------------*/
 314 /* findPointerSet - finds the right side of a pointer set op       */
 315 /*-----------------------------------------------------------------*/
 316 DEFSETFUNC(findPointerSet)
 317 {
 318     cseDef *cdp = item;
 319     V_ARG(operand *,op);
 320     V_ARG(operand **,opp);
 321     V_ARG(operand *,rop);
 322
 323     if (POINTER_SET(cdp->diCode)               &&
 324   IC_RESULT(cdp->diCode)->key == op->key &&
 325   !isOperandVolatile(IC_RESULT(cdp->diCode),TRUE) &&
 326   !isOperandVolatile(IC_RIGHT(cdp->diCode),TRUE)  &&
 327   getSize(operandType(IC_RIGHT(cdp->diCode))) ==
 328   getSize(operandType(rop))) {
 329   *opp = IC_RIGHT(cdp->diCode);
 330   return 1;
 331     }
 332
 333     return 0;
 334 }
 335
 336 /*-----------------------------------------------------------------*/
 337 /* findPrevIc - cseBBlock support function will return the iCode   */
 338 /*              which matches the current one                      */
 339 /*-----------------------------------------------------------------*/
 340 DEFSETFUNC(findPrevIc)
 341 {
 342     cseDef *cdp = item ;
 343     V_ARG(iCode *,ic);
 344     V_ARG(iCode **,icp);
 345
 346     /* if already found */
 347     if (*icp)
 348   return 1;
 349
 350     /* if the iCodes are the same */
 351     if (isiCodeEqual(ic,cdp->diCode) &&
 352   isOperandEqual(cdp->sym,IC_RESULT(cdp->diCode))) {
 353   *icp = cdp->diCode ;
 354   return 1;
 355     }
 356
 357     /* if iCodes are not the same */
 358     /* see the operands maybe interchanged */
 359     if (ic->op == cdp->diCode->op          &&
 360   ( ic->op == '+' || ic->op == '*' ) &&
 361   isOperandEqual(IC_LEFT(ic),IC_RIGHT(cdp->diCode)) &&
 362   isOperandEqual(IC_RIGHT(ic),IC_LEFT(cdp->diCode))) {
 363   *icp = cdp->diCode ;
 364   return 1;
 365     }
 366
 367     return 0;
 368 }
 369
 370 /*-----------------------------------------------------------------*/
 371 /* ifDefGlobal - if definition is global                           */
 372 /*-----------------------------------------------------------------*/
 373 DEFSETFUNC(ifDefGlobal)
 374 {
 375     cseDef *cdp = item;
 376
 377     return (isOperandGlobal(cdp->sym));
 378 }
 379
 380 /*-----------------------------------------------------------------*/
 381 /* ifAnyGetPointer - if get pointer icode                          */
 382 /*-----------------------------------------------------------------*/
 383 DEFSETFUNC(ifAnyGetPointer)
 384 {
 385     cseDef *cdp = item;
 386
 387     if (cdp->diCode && POINTER_GET(cdp->diCode)) return 1;
 388     return 0;
 389 }
 390
 391 /*-----------------------------------------------------------------*/
 392 /* ifOperandsHave - if any of the operand are the same as this     */
 393 /*-----------------------------------------------------------------*/
 394 DEFSETFUNC(ifOperandsHave)
 395 {
 396     cseDef *cdp = item;
 397     V_ARG(operand *,op);
 398
 399
 400     if (IC_LEFT(cdp->diCode) &&
 401   IS_SYMOP(IC_LEFT(cdp->diCode)) &&
 402   IC_LEFT(cdp->diCode)->key == op->key)
 403   return 1;
 404
 405     if (IC_RIGHT(cdp->diCode)  &&
 406   IS_SYMOP(IC_RIGHT(cdp->diCode)) &&
 407   IC_RIGHT(cdp->diCode)->key == op->key)
 408   return 1;
 409
 410     /* or if any of the operands are volatile */
 411     if (IC_LEFT(cdp->diCode) &&
 412   IS_OP_VOLATILE(IC_LEFT(cdp->diCode)))
 413   return 1;
 414
 415     if (IC_RIGHT(cdp->diCode) &&
 416   IS_OP_VOLATILE(IC_RIGHT(cdp->diCode)))
 417   return 1;
 418
 419
 420     if (IC_RESULT(cdp->diCode) &&
 421   IS_OP_VOLATILE(IC_RESULT(cdp->diCode)))
 422   return 1;
 423
 424     return 0;
 425 }
 426
 427 /*-----------------------------------------------------------------*/
 428 /* ifDefSymIs - if a definition is found in the set                */
 429 /*-----------------------------------------------------------------*/
 430  int ifDefSymIs (set *cseSet, operand *sym)
 431 {
 432     cseDef *loop ;
 433     set *sl ;
 434
 435     if (!sym || !IS_SYMOP(sym))
 436   return 0;
 437     for (sl = cseSet ; sl ; sl = sl->next ) {
 438   loop = sl->item;
 439   if (loop->sym->key == sym->key )
 440       return 1;
 441     }
 442     return 0;
 443 }
 444
 445
 446 /*-----------------------------------------------------------------*/
 447 /* ifDefSymIsX - will return 1 if the symbols match                */
 448 /*-----------------------------------------------------------------*/
 449 DEFSETFUNC(ifDefSymIsX)
 450 {
 451     cseDef *cdp  = item;
 452     V_ARG(operand *,op);
 453
 454     if (op && cdp->sym)
 455   return cdp->sym->key == op->key ;
 456     else
 457   return ( isOperandEqual(cdp->sym,op) );
 458
 459 }
 460
 461
 462 /*-----------------------------------------------------------------*/
 463 /* ifDiCodeIs - returns truw if diCode is same                     */
 464 /*-----------------------------------------------------------------*/
 465  int ifDiCodeIs (set *cseSet, iCode *ic)
 466 {
 467     cseDef *loop;
 468     set *sl;
 469
 470     if (!ic)
 471   return 0;
 472
 473     for (sl = cseSet ; sl ; sl = sl->next ) {
 474   loop = sl->item ;
 475   if (loop->diCode == ic)
 476       return 1;
 477     }
 478     return 0;
 479
 480 }
 481
 482 /*-----------------------------------------------------------------*/
 483 /* ifPointerGet - returns true if the icode is pointer get sym     */
 484 /*-----------------------------------------------------------------*/
 485 DEFSETFUNC(ifPointerGet)
 486 {
 487     cseDef *cdp = item;
 488     V_ARG(operand *,op);
 489     iCode *dic = cdp->diCode;
 490     operand *left = IC_LEFT(cdp->diCode);
 491
 492     if (POINTER_GET(dic) && left->key == op->key)
 493   return 1;
 494
 495     return 0;
 496 }
 497
 498 /*-----------------------------------------------------------------*/
 499 /* ifPointerSet - returns true if the icode is pointer set sym     */
 500 /*-----------------------------------------------------------------*/
 501 DEFSETFUNC(ifPointerSet)
 502 {
 503     cseDef *cdp = item;
 504     V_ARG(operand *,op);
 505
 506     if (POINTER_SET(cdp->diCode) &&
 507   IC_RESULT(cdp->diCode)->key == op->key)
 508   return 1;
 509
 510     return 0;
 511 }
 512
 513 /*-----------------------------------------------------------------*/
 514 /* ifDiCodeIsX - will return 1 if the symbols match                 */
 515 /*-----------------------------------------------------------------*/
 516 DEFSETFUNC(ifDiCodeIsX)
 517 {
 518     cseDef *cdp  = item;
 519     V_ARG(iCode *,ic);
 520
 521     return cdp->diCode == ic;
 522
 523 }
 524
 525 /*-----------------------------------------------------------------*/
 526 /* algebraicOpts - does some algebraic optimizations               */
 527 /*-----------------------------------------------------------------*/
 528 void algebraicOpts (iCode *ic)
 529 {
 530     /* we don't deal with the following iCodes
 531        here */
 532     if (ic->op == IFX   ||
 533   ic->op == IPUSH ||
 534   ic->op == IPOP  ||
 535   ic->op == CALL  ||
 536   ic->op == PCALL ||
 537   ic->op == RETURN ||
 538   POINTER_GET(ic))
 539   return ;
 540
 541     /* if both operands present & ! IFX */
 542     /* then if they are both literal we */
 543     /* perform the operation right now  */
 544     if (IC_RESULT(ic) &&
 545   IC_RIGHT(ic)  &&
 546   IC_LEFT(ic)   &&
 547   IS_OP_LITERAL(IC_LEFT(ic)) &&
 548   IS_OP_LITERAL(IC_RIGHT(ic))) {
 549
 550   IC_RIGHT(ic) = operandOperation (IC_LEFT(ic),
 551            IC_RIGHT(ic),
 552            ic->op,
 553            operandType(IC_RESULT(ic)));
 554   ic->op = '=';
 555   IC_LEFT(ic) = NULL ;
 556   SET_RESULT_RIGHT(ic);
 557   return ;
 558
 559     }
 560     /* if not ifx & only one operand present */
 561     if (IC_RESULT(ic) &&
 562   IC_LEFT(ic)   &&
 563   IS_OP_LITERAL(IC_LEFT(ic)) &&
 564   !IC_RIGHT(ic)) {
 565
 566   IC_RIGHT(ic) = operandOperation (IC_LEFT(ic),
 567            IC_RIGHT(ic),
 568            ic->op,
 569            operandType(IC_RESULT(ic)));
 570   ic->op = '=';
 571   IC_LEFT(ic) = NULL ;
 572   SET_RESULT_RIGHT(ic);
 573   return ;
 574     }
 575
 576
 577     /* a special case : or in short a kludgy solution will think
 578        about a better solution over a glass of wine someday */
 579     if ( ic->op == GET_VALUE_AT_ADDRESS ) {
 580
 581   if (IS_ITEMP(IC_RESULT(ic)) &&
 582       IS_TRUE_SYMOP(IC_LEFT(ic))) {
 583
 584       ic->op = '=' ;
 585       IC_RIGHT(ic) = operandFromOperand(IC_LEFT(ic));
 586       IC_RIGHT(ic)->isaddr = 0;
 587       IC_LEFT(ic) = NULL;
 588       IC_RESULT(ic) = operandFromOperand(IC_RESULT(ic));
 589       IC_RESULT(ic)->isaddr = 0;
 590       setOperandType(IC_RESULT(ic),operandType(IC_RIGHT(ic)));
 591       return;
 592   }
 593
 594   if (IS_ITEMP(IC_LEFT(ic)) &&
 595       IS_ITEMP(IC_RESULT(ic)) &&
 596 /*      !OP_SYMBOL(IC_RESULT(ic))->isreqv && */
 597 /*      !OP_SYMBOL(IC_LEFT(ic))->isreqv && */
 598       !IC_LEFT(ic)->isaddr ) {
 599       ic->op = '=' ;
 600       IC_RIGHT(ic) = operandFromOperand(IC_LEFT(ic));
 601       IC_RIGHT(ic)->isaddr = 0;
 602       IC_RESULT(ic) = operandFromOperand(IC_RESULT(ic));
 603       IC_RESULT(ic)->isaddr = 0;
 604       IC_LEFT(ic) = NULL;
 605       return;
 606   }
 607
 608     }
 609
 610
 611     /* depending on the operation */
 612     switch (ic->op) {
 613     case '+' :
 614   /* if adding the same thing change to left shift by 1*/
 615   if (IC_LEFT(ic)->key == IC_RIGHT(ic)->key &&
 616       !IS_FLOAT(operandType(IC_RESULT(ic)))) {
 617       ic->op = LEFT_OP ;
 618       IC_RIGHT(ic) = operandFromLit(1);
 619       return;
 620   }
 621   /* if addition then check if one of them is a zero */
 622   /* if yes turn it  into assignmnt*/
 623   if (IS_OP_LITERAL(IC_LEFT(ic)) &&
 624       operandLitValue(IC_LEFT(ic)) == 0.0 ) {
 625
 626       ic->op = '=' ;
 627       IC_LEFT(ic) = NULL ;
 628       SET_ISADDR(IC_RESULT(ic),0);
 629       SET_ISADDR(IC_RIGHT(ic),0);
 630       return ;
 631   }
 632   if (IS_OP_LITERAL(IC_RIGHT(ic)) &&
 633       operandLitValue(IC_RIGHT(ic)) == 0.0 ) {
 634
 635       ic->op = '=' ;
 636       IC_RIGHT(ic) = IC_LEFT(ic) ;
 637       IC_LEFT(ic) = 0;
 638       SET_ISADDR(IC_RIGHT(ic),0);
 639       SET_ISADDR(IC_RESULT(ic),0);
 640       return ;
 641   }
 642   break ;
 643     case '-' :
 644   /* if subtracting the the same thing then zero     */
 645   if ( IC_LEFT(ic)->key == IC_RIGHT(ic)->key ) {
 646       ic->op = '=';
 647       IC_RIGHT(ic) = operandFromLit(0);
 648       IC_LEFT(ic) = NULL ;
 649       IC_RESULT(ic) = operandFromOperand(IC_RESULT(ic));
 650       IC_RESULT(ic)->isaddr = 0;
 651       return ;
 652   }
 653
 654   /* if subtraction then check if one of the operand */
 655   /* is zero then depending on which operand change  */
 656   /* to assignment or unary minus                    */
 657   if (IS_OP_LITERAL(IC_RIGHT(ic)) &&
 658       operandLitValue(IC_RIGHT(ic)) == 0.0 ) {
 659       /* right size zero change to assignment */
 660       ic->op = '=' ;
 661       IC_RIGHT(ic) = IC_LEFT(ic);
 662       IC_LEFT(ic) = NULL;
 663       SET_ISADDR(IC_RIGHT(ic),0);
 664       SET_ISADDR(IC_RESULT(ic),0);
 665       return ;
 666   }
 667   if (IS_OP_LITERAL(IC_LEFT(ic)) &&
 668       operandLitValue (IC_LEFT(ic)) == 0.0) {
 669       /* left zero turn into an unary minus */
 670       ic->op = UNARYMINUS ;
 671       IC_LEFT(ic) = IC_RIGHT(ic);
 672       IC_RIGHT(ic) = NULL ;
 673       return ;
 674   }
 675   break;
 676   /* if multiplication then check if either of */
 677   /* them is zero then the result is zero      */
 678   /* if either of them is one then result is   */
 679   /* the other one                             */
 680     case '*' :
 681   if (IS_OP_LITERAL(IC_LEFT(ic))) {
 682
 683       if (operandLitValue(IC_LEFT(ic)) == 0.0) {
 684     ic->op = '=' ;
 685     IC_RIGHT(ic) = IC_LEFT(ic);
 686     IC_LEFT(ic) = NULL;
 687     SET_RESULT_RIGHT(ic);
 688     return ;
 689       }
 690       if ( operandLitValue(IC_LEFT(ic)) == 1.0) {
 691     ic->op = '=' ;
 692     IC_LEFT(ic) = NULL ;
 693     SET_RESULT_RIGHT(ic);
 694     return ;
 695       }
 696   }
 697
 698   if (IS_OP_LITERAL(IC_RIGHT(ic))) {
 699
 700       if (operandLitValue(IC_RIGHT(ic)) == 0.0 ) {
 701     ic->op = '=';
 702     IC_LEFT(ic) = NULL ;
 703     SET_RESULT_RIGHT(ic);
 704     return ;
 705       }
 706
 707       if (operandLitValue(IC_RIGHT(ic)) == 1.0) {
 708     ic->op = '=' ;
 709     IC_RIGHT(ic) = IC_LEFT(ic);
 710     IC_LEFT(ic) = NULL ;
 711     SET_RESULT_RIGHT(ic);
 712     return ;
 713       }
 714   }
 715   break ;
 716     case '/':
 717   /* if division by self then 1 */
 718   if (IC_LEFT(ic)->key == IC_RIGHT(ic)->key) {
 719       ic->op = '=';
 720       IC_RIGHT(ic) = operandFromLit(1);
 721       IC_LEFT(ic) = NULL;
 722       IC_RESULT(ic) = operandFromOperand(IC_RESULT(ic));
 723       IC_RESULT(ic)->isaddr = 0;
 724   }
 725   /* if this is a division then check if right */
 726   /* is one then change it to an assignment    */
 727   if (IS_OP_LITERAL(IC_RIGHT(ic)) &&
 728       operandLitValue(IC_RIGHT(ic)) == 1.0 ) {
 729
 730       ic->op = '=' ;
 731       IC_RIGHT(ic) = IC_LEFT(ic);
 732       IC_LEFT(ic) = NULL;
 733       SET_RESULT_RIGHT(ic);
 734       return ;
 735   }
 736   break;
 737   /* if both are the same for an comparison operators */
 738     case EQ_OP :
 739     case LE_OP :
 740     case GE_OP :
 741   if (isOperandEqual(IC_LEFT(ic),IC_RIGHT(ic))) {
 742       ic->op = '=';
 743       IC_RIGHT(ic) = operandFromLit(1);
 744       IC_LEFT(ic) = NULL;
 745       SET_RESULT_RIGHT(ic);
 746   }
 747   break;
 748     case NE_OP :
 749     case '>' :
 750     case '<' :
 751   if (isOperandEqual(IC_LEFT(ic),IC_RIGHT(ic))) {
 752       ic->op = '=';
 753       IC_RIGHT(ic) = operandFromLit(0);
 754       IC_LEFT(ic) = NULL ;
 755       SET_RESULT_RIGHT(ic);
 756   }
 757   break ;
 758     case CAST :
 759   /* if this is a cast of a literal value */
 760   if ( IS_OP_LITERAL(IC_RIGHT(ic))) {
 761       ic->op = '=' ;
 762       IC_RIGHT(ic) =
 763     operandFromValue (valCastLiteral(operandType(IC_LEFT(ic)),
 764              operandLitValue(IC_RIGHT(ic))));
 765       IC_LEFT(ic) = NULL;
 766       SET_ISADDR(IC_RESULT(ic),0);
 767   }
 768   /* if casting to the same */
 769   if ( checkType(operandType(IC_RESULT(ic)),
 770            operandType(IC_RIGHT(ic))) == 1) {
 771       ic->op = '=';
 772       IC_LEFT(ic) = NULL;
 773       SET_ISADDR(IC_RESULT(ic),0);
 774   }
 775   break;
 776     case '!' :
 777   if (IS_OP_LITERAL(IC_LEFT(ic))) {
 778       ic->op = '=' ;
 779       IC_RIGHT(ic) =
 780          (operandLitValue(IC_LEFT(ic)) == 0 ?
 781     operandFromLit(1) : operandFromLit(0));
 782       IC_LEFT(ic) = NULL;
 783       SET_ISADDR(IC_RESULT(ic),0);
 784   }
 785     }
 786
 787     return ;
 788 }
 789 #define OTHERS_PARM(s) (s->_isparm && !s->ismyparm)
 790 /*-----------------------------------------------------------------*/
 791 /* updateSpillLocation - keeps track of register spill location    */
 792 /*-----------------------------------------------------------------*/
 793 void updateSpillLocation ( iCode *ic)
 794 {
 795
 796     sym_link *setype;
 797
 798     if (POINTER_SET(ic))
 799   return;
 800
 801     if (ic->nosupdate)
 802   return;
 803
 804     /* for the form true_symbol := iTempNN */
 805     if (ASSIGN_ITEMP_TO_SYM(ic)
 806   && !SPIL_LOC(IC_RIGHT(ic))) {
 807
 808   setype = getSpec(operandType(IC_RESULT(ic)));
 809
 810         if (!IC_RIGHT(ic)->noSpilLoc           &&
 811       !IS_VOLATILE(setype)               &&
 812       !IN_FARSPACE(SPEC_OCLS(setype))    &&
 813       !OTHERS_PARM(OP_SYMBOL(IC_RESULT(ic))) )
 814
 815       SPIL_LOC(IC_RIGHT(ic))  =
 816     IC_RESULT(ic)->operand.symOperand;
 817     }
 818
 819     if (ASSIGN_ITEMP_TO_ITEMP(ic) &&
 820   !SPIL_LOC(IC_RIGHT(ic))   &&
 821         !bitVectBitsInCommon(OP_DEFS(IC_RIGHT(ic)),OP_USES(IC_RESULT(ic))) &&
 822   OP_SYMBOL(IC_RESULT(ic))->isreqv) {
 823
 824   setype = getSpec(operandType(IC_RESULT(ic)));
 825
 826         if (!IC_RIGHT(ic)->noSpilLoc           &&
 827       !IS_VOLATILE(setype)               &&
 828       !IN_FARSPACE(SPEC_OCLS(setype))    &&
 829       !OTHERS_PARM(OP_SYMBOL(IC_RESULT(ic))) )
 830
 831       SPIL_LOC(IC_RIGHT(ic)) =
 832     SPIL_LOC(IC_RESULT(ic));
 833     }
 834 }
 835
 836 /*-----------------------------------------------------------------*/
 837 /* setUsesDef - sets the uses def bitvector for a given operand    */
 838 /*-----------------------------------------------------------------*/
 839 void setUsesDefs (operand *op, bitVect *bdefs,
 840       bitVect *idefs, bitVect **oud)
 841 {
 842     /* compute the definitions alive at this point */
 843     bitVect *adefs = bitVectUnion(bdefs,idefs);
 844
 845     /* of these definitions find the ones that are */
 846     /* for this operand */
 847     adefs = bitVectIntersect(adefs,OP_DEFS(op));
 848
 849     /* these are the definitions that this operand can use */
 850     op->usesDefs = adefs;
 851
 852     /* the out defs is an union */
 853     *oud = bitVectUnion(*oud,adefs);
 854 }
 855
 856 /*-----------------------------------------------------------------*/
 857 /* unsetDefsAndUses - clear this operation for the operands        */
 858 /*-----------------------------------------------------------------*/
 859 void unsetDefsAndUses ( iCode *ic )
 860 {
 861     if ( ic->op == JUMPTABLE)
 862   return ;
 863
 864     /* take away this definition from the def chain of the */
 865     /* result & take away from use set of the operands */
 866     if (ic->op != IFX) {
 867   /* turn off def set */
 868   if (IS_SYMOP(IC_RESULT(ic))) {
 869       if ( !POINTER_SET(ic))
 870     bitVectUnSetBit(OP_DEFS(IC_RESULT(ic)),ic->key);
 871       else
 872     bitVectUnSetBit(OP_USES(IC_RESULT(ic)),ic->key);
 873   }
 874   /* turn off the useSet for the operands */
 875   if (IS_SYMOP(IC_LEFT(ic)))
 876       bitVectUnSetBit (OP_USES(IC_LEFT(ic)),ic->key);
 877
 878   if (IS_SYMOP(IC_RIGHT(ic)))
 879       bitVectUnSetBit (OP_USES(IC_RIGHT(ic)),ic->key);
 880     }
 881     else /* must be ifx turn off the use */
 882   if (IS_SYMOP(IC_COND(ic)))
 883       bitVectUnSetBit (OP_USES(IC_COND(ic)),ic->key);
 884 }
 885
 886 /*-----------------------------------------------------------------*/
 887 /* ifxOptimize - changes ifx conditions if it can                  */
 888 /*-----------------------------------------------------------------*/
 889 void ifxOptimize (iCode *ic, set *cseSet,
 890        int computeOnly ,
 891        eBBlock *ebb, int *change,
 892        eBBlock **ebbs, int count)
 893 {
 894     operand *pdop ;
 895     symbol *label;
 896
 897     /* if the condition can be replaced */
 898     if (!computeOnly) {
 899   pdop = NULL ;
 900   applyToSetFTrue (cseSet,findCheaperOp,IC_COND(ic),&pdop);
 901   if (pdop) {
 902       IC_COND(ic) = pdop ;
 903       (*change)++;
 904   }
 905     }
 906
 907     /* if the conditional is a literal then */
 908     if (IS_OP_LITERAL(IC_COND(ic))) {
 909
 910   if ( (operandLitValue(IC_COND(ic)) != 0.0) && IC_TRUE(ic)) {
 911
 912       /* change to a goto */
 913       ic->op = GOTO ;
 914       IC_LABEL(ic) = IC_TRUE(ic);
 915       (*change)++;
 916
 917   } else {
 918
 919       if (!operandLitValue(IC_COND(ic)) && IC_FALSE(ic)) {
 920     ic->op = GOTO ;
 921     IC_LABEL(ic) = IC_FALSE(ic);
 922     (*change)++;
 923
 924       } else {
 925     /* then kill this if condition */
 926     remiCodeFromeBBlock (ebb,ic);
 927       }
 928   }
 929
 930   /* now we need to recompute the control flow */
 931   /* since the control flow has changed        */
 932   /* this is very expensive but it does not happen */
 933   /* too often, if it does happen then the user pays */
 934   /* the price */
 935   computeControlFlow (ebbs,count,1);
 936   werror (W_CONTROL_FLOW,ic->filename,ic->lineno);
 937   return ;
 938     }
 939
 940     /* if there is only one successor and that successor
 941        is the same one we are conditionally going to then
 942        we can remove this conditional statement */
 943     label = (IC_TRUE(ic) ? IC_TRUE(ic) : IC_FALSE(ic));
 944     if (elementsInSet(ebb->succList) == 1 &&
 945   isinSet(ebb->succList,eBBWithEntryLabel(ebbs,label,count))) {
 946
 947   remiCodeFromeBBlock(ebb,ic);
 948   computeControlFlow (ebbs,count,1);
 949   werror (W_CONTROL_FLOW,ic->filename,ic->lineno);
 950   return ;
 951     }
 952
 953
 954     /* if it remains an IFX the update the use Set */
 955     OP_USES(IC_COND(ic)) = bitVectSetBit(OP_USES(IC_COND(ic)),ic->key);
 956     setUsesDefs(IC_COND(ic),ebb->defSet,ebb->outDefs,&ebb->usesDefs);
 957     return ;
 958 }
 959
 960 /*-----------------------------------------------------------------*/
 961 /* diCodeForSym - finds the definiting instruction for a symbol    */
 962 /*-----------------------------------------------------------------*/
 963 DEFSETFUNC(diCodeForSym)
 964 {
 965     cseDef *cdp = item;
 966     V_ARG(operand *,sym);
 967     V_ARG(iCode **,dic);
 968
 969     /* if already found */
 970     if (*dic)
 971   return 0;
 972
 973     /* if not if this is the defining iCode */
 974     if (sym->key == cdp->key) {
 975   *dic = cdp->diCode ;
 976   return 1;
 977     }
 978
 979     return 0;
 980 }
 981
 982 /*-----------------------------------------------------------------*/
 983 /* constFold - does some constant folding                          */
 984 /*-----------------------------------------------------------------*/
 985 int constFold (iCode *ic, set *cseSet)
 986 {
 987     iCode *dic = NULL;
 988     iCode *ldic= NULL;
 989     /* this routine will change
 990        a = b + 10;
 991        c = a + 10;
 992        to
 993        c = b + 20; */
 994
 995     /* deal with only + & - */
 996     if (ic->op != '+' &&
 997   ic->op != '-' )
 998   return 0;
 999
1000     /* this check is a hueristic to prevent live ranges
1001        from becoming too long */
1002     if (IS_PTR(operandType(IC_RESULT(ic))))
1003   return 0;
1004
1005     /* check if operation with a literal */
1006     if (!IS_OP_LITERAL(IC_RIGHT(ic)))
1007   return 0;
1008
1009     /* check if we can find a definition for the
1010        right hand side */
1011     if (!(applyToSet(cseSet,diCodeForSym,IC_LEFT(ic),&dic)))
1012   return 0;
1013
1014     /* check that this is also a +/-  */
1015     if (dic->op != '+' && dic->op != '-')
1016   return 0;
1017
1018     /* with a literal */
1019     if (!IS_OP_LITERAL(IC_RIGHT(dic)))
1020   return 0;
1021
1022     /* find the definition of the left operand
1023        of dic.then check if this defined with a
1024        get_pointer return 0 if the pointer size is
1025        less than 2 (MCS51 specific) */
1026     if (!(applyToSet(cseSet,diCodeForSym,IC_LEFT(dic),&ldic)))
1027   return 0;
1028
1029     if (POINTER_GET(ldic) && getSize(operandType(IC_LEFT(ldic))) <= 1)
1030   return 0;
1031
1032     /* it is if the operations are the same*/
1033     /* the literal parts need to be added  */
1034     IC_LEFT(ic) = operandFromOperand(IC_LEFT(dic));
1035     if (ic->op == dic->op )
1036   IC_RIGHT(ic) = operandFromLit(operandLitValue(IC_RIGHT(ic))+
1037               operandLitValue(IC_RIGHT(dic)));
1038     else
1039   IC_RIGHT(ic) = operandFromLit(operandLitValue(IC_RIGHT(ic)) -
1040               operandLitValue(IC_RIGHT(dic)));
1041
1042     if (IS_ITEMP(IC_RESULT(ic))) {
1043   SPIL_LOC(IC_RESULT(ic)) = NULL;
1044   IC_RESULT(ic)->noSpilLoc = 1;
1045     }
1046
1047
1048     return 1;
1049 }
1050
1051 /*-----------------------------------------------------------------*/
1052 /* deleteGetPointers - called when a pointer is passed as parm     */
1053 /* will delete from cseSet all get pointers computed from this     */
1054 /* pointer. A simple ifOperandsHave is not good enough here        */
1055 /*-----------------------------------------------------------------*/
1056 static void deleteGetPointers (set **cseSet, set **pss, operand *op,eBBlock *ebb)
1057 {
1058     set *compItems = NULL;
1059     cseDef *cdp ;
1060     operand *cop;
1061
1062     /* easy return */
1063     if (!*cseSet && !*pss)
1064   return ;
1065
1066     /* first find all items computed from this operand .
1067        This done fairly simply go thru the list and find
1068        those that are computed by arthimetic with this
1069        op */
1070     for (cdp = setFirstItem(*cseSet); cdp ; cdp = setNextItem(*cseSet)) {
1071   if (IS_ARITHMETIC_OP(cdp->diCode)) {
1072       if (isOperandEqual(IC_LEFT(cdp->diCode),op) ||
1073     isOperandEqual(IC_RIGHT(cdp->diCode),op)) {
1074         /* save it in our list of items */
1075     addSet(&compItems,IC_RESULT(cdp->diCode));
1076       }
1077       /* also check for those computed from our computed
1078          list . This will take care of situations like
1079          iTemp1 = iTemp0 + 8;
1080          iTemp2 = iTemp1 + 8; */
1081       if (isinSetWith(compItems,IC_LEFT(cdp->diCode),isOperandEqual) ||
1082     isinSetWith(compItems,IC_RIGHT(cdp->diCode),isOperandEqual)) {
1083         addSet(&compItems,IC_RESULT(cdp->diCode));
1084       }
1085   }
1086     }
1087
1088     /* now delete all pointer gets with this op */
1089     deleteItemIf(cseSet,ifPointerGet,op);
1090     deleteItemIf(pss,ifPointerSet,op);
1091
1092     /* set the bit vector used by dataFlow computation later */
1093     ebb->ptrsSet = bitVectSetBit(ebb->ptrsSet,op->key);
1094     /* now for the computed items */
1095     for (cop = setFirstItem(compItems); cop ; cop = setNextItem(compItems)) {
1096   ebb->ptrsSet = bitVectSetBit(ebb->ptrsSet,cop->key);
1097   deleteItemIf(cseSet,ifPointerGet,cop);
1098   deleteItemIf(pss,ifPointerSet,cop);
1099     }
1100 }
1101
1102 /*-----------------------------------------------------------------*/
1103 /* delGetPointerSucc - delete get pointer from inExprs of succ with*/
1104 /*                     dfnum > supplied                            */
1105 /*-----------------------------------------------------------------*/
1106 DEFSETFUNC(delGetPointerSucc)
1107 {
1108     eBBlock *ebp = item;
1109     V_ARG(operand *,op);
1110     V_ARG(int,dfnum);
1111
1112     if (ebp->visited)
1113   return 0;
1114
1115     ebp->visited = 1;
1116     if (ebp->dfnum > dfnum) {
1117   deleteItemIf(&ebp->inExprs,ifPointerGet,op);
1118     }
1119
1120     return applyToSet(ebp->succList,delGetPointerSucc,op,dfnum);
1121 }
1122
1123 /*-----------------------------------------------------------------*/
1124 /* fixUpTypes - KLUGE HACK fixup a lowering problem                */
1125 /*-----------------------------------------------------------------*/
1126 static void fixUpTypes(iCode *ic)
1127 {
1128   sym_link *t1 = operandType(IC_LEFT(ic)) ,*t2;
1129
1130   if (IS_DS390_PORT)
1131   {
1132       /* hack-o-matic! */
1133       return;
1134   }
1135
1136   /* for pointer_gets if the types of result & left r the
1137      same then change it type of result to next */
1138   if (IS_PTR(t1) &&
1139       checkType(t2=operandType(IC_RESULT(ic)),t1) == 1) {
1140     setOperandType(IC_RESULT(ic),t2->next);
1141   }
1142 }
1143
1144 /*-----------------------------------------------------------------*/
1145 /* cseBBlock - common subexpression elimination for basic blocks   */
1146 /*             this is the hackiest kludgiest routine in the whole */
1147 /*             system. also the most important, since almost all   */
1148 /*             data flow related information is computed by it     */
1149 /*-----------------------------------------------------------------*/
1150 int cseBBlock ( eBBlock *ebb, int computeOnly,
1151     eBBlock **ebbs, int count)
1152 {
1153     set *cseSet ;
1154     iCode *ic ;
1155     int change = 0 ;
1156     int i;
1157     set *ptrSetSet = NULL;
1158
1159     /* if this block is not reachable */
1160     if (ebb->noPath)
1161   return change;
1162
1163    /* set of common subexpressions */
1164     cseSet = setFromSet (ebb->inExprs) ;
1165
1166     /* these will be computed by this routine */
1167     setToNull ((void **)&ebb->outDefs);
1168     setToNull ((void **)&ebb->defSet);
1169     setToNull ((void **)&ebb->usesDefs);
1170     setToNull ((void **)&ebb->ptrsSet);
1171     setToNull ((void **)&ebb->addrOf);
1172     setToNull ((void **)&ebb->ldefs);
1173
1174     ebb->outDefs = bitVectCopy (ebb->inDefs);
1175     bitVectDefault = iCodeKey;
1176     ebb->defSet = newBitVect(iCodeKey);
1177     ebb->usesDefs=newBitVect(iCodeKey);
1178
1179     /* for all the instructions in this block do */
1180     for (ic = ebb->sch ; ic ; ic = ic->next ) {
1181
1182   iCode *pdic;
1183   operand *pdop ;
1184   iCode *defic;
1185
1186   if (SKIP_IC2(ic))
1187       continue ;
1188
1189   /* if this is an assignment from true symbol
1190      to a temp then do pointer post inc/dec optimzation */
1191   if (ic->op == '=' && !POINTER_SET(ic) &&
1192       IS_PTR(operandType(IC_RESULT(ic)))) {
1193       ptrPostIncDecOpt(ic);
1194   }
1195
1196   /* clear the def & use chains for the operands involved */
1197   /* in this operation . since it can change due to opts  */
1198   unsetDefsAndUses (ic);
1199
1200       if ( ic->op == PCALL || ic->op == CALL || ic->op == RECEIVE) {
1201       /* add to defSet of the symbol */
1202       OP_DEFS(IC_RESULT(ic)) =
1203     bitVectSetBit (OP_DEFS(IC_RESULT(ic)),ic->key);
1204       /* add to the definition set of this block */
1205       ebb->defSet = bitVectSetBit (ebb->defSet,ic->key);
1206       ebb->ldefs  = bitVectSetBit (ebb->ldefs,ic->key);
1207       ebb->outDefs= bitVectCplAnd (ebb->outDefs,OP_DEFS(IC_RESULT(ic)));
1208       setUsesDefs(IC_RESULT(ic),ebb->defSet,ebb->outDefs,&ebb->usesDefs);
1209       /* delete global variables from the cseSet
1210          since they can be modified by the function call */
1211       deleteItemIf(&cseSet,ifDefGlobal);
1212       /* delete all getpointer iCodes from cseSet, this should
1213          be done only for global arrays & pointers but at this
1214          point we don't know if globals, so to be safe do all*/
1215       deleteItemIf(&cseSet,ifAnyGetPointer);
1216   }
1217
1218   /* for pcall & ipush we need to add to the useSet */
1219   if ((ic->op == PCALL ||
1220        ic->op == IPUSH ||
1221        ic->op == IPOP  ||
1222        ic->op == SEND) &&
1223       IS_SYMOP(IC_LEFT(ic))) {
1224
1225       /* check if they can be replaced */
1226       if ( !computeOnly ) {
1227     pdop = NULL ;
1228     applyToSetFTrue(cseSet,findCheaperOp,IC_LEFT(ic),&pdop);
1229     if (pdop)
1230         IC_LEFT(ic) = pdop ;
1231       }
1232       /* the lookup could have changed it*/
1233       if (IS_SYMOP(IC_LEFT(ic))) {
1234     OP_USES(IC_LEFT(ic)) =
1235         bitVectSetBit(OP_USES(IC_LEFT(ic)),ic->key);
1236     setUsesDefs(IC_LEFT(ic),ebb->defSet,
1237           ebb->outDefs,&ebb->usesDefs);
1238       }
1239
1240
1241       /* if we a sending a pointer as a parameter
1242          then kill all cse since the pointed to item
1243          might be changed in the function being called */
1244       if ((ic->op == IPUSH || ic->op == SEND) &&
1245     IS_PTR(operandType(IC_LEFT(ic)))) {
1246     deleteGetPointers(&cseSet,&ptrSetSet,IC_LEFT(ic),ebb);
1247     ebb->ptrsSet = bitVectSetBit(ebb->ptrsSet,IC_LEFT(ic)->key);
1248     for (i = 0 ; i < count ;ebbs[i++]->visited = 0);
1249     applyToSet(ebb->succList,delGetPointerSucc,
1250          IC_LEFT(ic),ebb->dfnum);
1251       }
1252       continue;
1253   }
1254
1255   /* if jumptable then mark the usage */
1256   if (ic->op == JUMPTABLE ) {
1257       OP_USES(IC_JTCOND(ic)) =
1258     bitVectSetBit(OP_USES(IC_JTCOND(ic)),ic->key);
1259       setUsesDefs(IC_JTCOND(ic),ebb->defSet,
1260       ebb->outDefs,&ebb->usesDefs);
1261       continue;
1262   }
1263
1264   if (SKIP_IC(ic))
1265       continue ;
1266
1267   /* do some algebraic optimizations if possible */
1268   algebraicOpts (ic);
1269   while (constFold(ic,cseSet));
1270
1271   /* small klugde */
1272   if (POINTER_GET(ic) && !IS_PTR(operandType(IC_LEFT(ic)))) {
1273       setOperandType(IC_LEFT(ic),
1274          aggrToPtr(operandType(IC_LEFT(ic)),FALSE));
1275       fixUpTypes(ic);
1276
1277   }
1278   if (POINTER_SET(ic) && !IS_PTR(operandType(IC_RESULT(ic)))) {
1279       setOperandType(IC_RESULT(ic),
1280          aggrToPtr(operandType(IC_RESULT(ic)),FALSE));
1281   }
1282
1283   /* if this is a condition statment then */
1284   /* check if the condition can be replaced */
1285   if (ic->op == IFX ) {
1286       ifxOptimize (ic, cseSet, computeOnly,
1287        ebb, &change,
1288        ebbs, count);
1289       continue ;
1290   }
1291
1292   /* if the assignment & result is a temp */
1293   /* see if we can replace it             */
1294   if (ic->op == '=') {
1295
1296       /* update the spill location for this */
1297       updateSpillLocation (ic);
1298
1299       if (POINTER_SET(ic) &&
1300     !(IS_BITFIELD(OP_SYMBOL(IC_RESULT(ic))->etype))) {
1301     pdop = NULL ;
1302     applyToSetFTrue (cseSet,findCheaperOp,IC_RESULT(ic),&pdop);
1303     if (pdop && IS_ITEMP(pdop) && !computeOnly)
1304         IC_RESULT(ic) = pdop;
1305       }
1306   }
1307
1308   /* do the operand lookup i.e. for both the */
1309   /* right & left operand : check the cseSet */
1310   /* to see if they have been replaced if yes*/
1311   /* then replace them with those from cseSet*/
1312   /* left operand */
1313   /* and left is a symbol  */
1314   if (IS_SYMOP(IC_LEFT(ic)) &&
1315       !computeOnly && ic->op != ADDRESS_OF ) {
1316
1317       pdop = NULL;
1318       applyToSetFTrue (cseSet,findCheaperOp,IC_LEFT(ic),&pdop) ;
1319       if (pdop)  {
1320     if (POINTER_GET(ic)) {
1321         if (IS_ITEMP(pdop) || IS_OP_LITERAL(pdop)) {
1322       IC_LEFT(ic) = pdop;
1323       change = 1;
1324         }
1325         /* check if there is a pointer set
1326            for the same pointer visible if yes
1327            then change this into an assignment */
1328         pdop = NULL;
1329         if (applyToSetFTrue(cseSet,findPointerSet,IC_LEFT(ic),&pdop,IC_RESULT(ic)) &&
1330       !bitVectBitValue(ebb->ptrsSet,pdop->key)){
1331       ic->op = '=';
1332       IC_LEFT(ic) = NULL;
1333       IC_RIGHT(ic) = pdop;
1334       SET_ISADDR(IC_RESULT(ic),0);
1335         }
1336
1337     }
1338     else {
1339         IC_LEFT(ic)  = pdop ;
1340         change = 1;
1341     }
1342       }
1343   }
1344
1345   /*right operand */
1346   if (IS_SYMOP(IC_RIGHT(ic)) && !computeOnly) {
1347
1348       pdop = NULL ;
1349       applyToSetFTrue (cseSet,findCheaperOp,IC_RIGHT(ic),&pdop);
1350       if (pdop) {
1351
1352     IC_RIGHT(ic) = pdop;
1353     change = 1;
1354       }
1355   }
1356
1357   /* if left or right changed then do algebraic */
1358   if (change) {
1359       algebraicOpts(ic);
1360       while(constFold(ic,cseSet));
1361   }
1362
1363   /* if after all this it becomes a assignment to self
1364      then delete it and continue */
1365   if (ASSIGNMENT_TO_SELF(ic)) {
1366       remiCodeFromeBBlock(ebb,ic);
1367       continue;
1368   }
1369
1370   /* now we will check to see if the entire */
1371   /* operation has been performed before    */
1372   /* and is available                       */
1373   /* don't do assignments they will be killed */
1374   /* by dead code elimination if required  do */
1375   /* it only if result is a temporary         */
1376   pdic = NULL ;
1377   if (!( POINTER_GET(ic)                      &&
1378          (IS_BITFIELD(OP_SYMBOL(IC_RESULT(ic))->etype) ||
1379          isOperandVolatile(IC_LEFT(ic),TRUE)           ||
1380          bitVectBitValue(ebb->ndompset,IC_LEFT(ic)->key))) &&
1381       ! ASSIGNMENT(ic)                        &&
1382         IS_ITEMP(IC_RESULT(ic))               &&
1383       ! computeOnly) {
1384       applyToSet (cseSet,findPrevIc,ic,&pdic);
1385       if (pdic && checkType(operandType(IC_RESULT(pdic)),
1386           operandType(IC_RESULT(ic))) != 1)
1387         pdic = NULL;
1388   }
1389
1390   /* if found then eliminate this and add to*/
1391   /* to cseSet an element containing result */
1392   /* of this with previous opcode           */
1393   if (pdic) {
1394
1395       if (IS_ITEMP(IC_RESULT(ic))) {
1396
1397     /* replace in the remaining of this block */
1398     replaceAllSymBySym(ic->next,IC_RESULT(ic),IC_RESULT(pdic),&ebb->ndompset);
1399     /* remove this iCode from inexpressions of all
1400        its successors, it cannot be in the in expressions
1401        of any of the predecessors */
1402     for (i = 0 ; i < count ;ebbs[i++]->visited = 0);
1403     applyToSet(ebb->succList,removeFromInExprs,ic,IC_RESULT(ic),
1404          IC_RESULT(pdic),ebb);
1405
1406     /* if this was moved from another block */
1407     /* then replace in those blocks too     */
1408     if ( ic->movedFrom ) {
1409         eBBlock *owner ;
1410         for (owner = setFirstItem(ic->movedFrom); owner ;
1411        owner = setNextItem(ic->movedFrom))
1412       replaceAllSymBySym(owner->sch,IC_RESULT(ic),IC_RESULT(pdic),&owner->ndompset);
1413     }
1414     pdic->movedFrom = unionSets(pdic->movedFrom,ic->movedFrom,THROW_NONE);
1415       }
1416       else
1417     addSetHead (&cseSet,newCseDef(IC_RESULT(ic),pdic));
1418
1419       if (!computeOnly)
1420     /* eliminate this */
1421     remiCodeFromeBBlock (ebb,ic);
1422
1423       defic = pdic ;
1424       change++ ;
1425
1426       if (IS_ITEMP(IC_RESULT(ic)))
1427     continue ;
1428
1429   } else {
1430
1431       /* just add this as a previous expression except in */
1432       /* case of a pointer access in which case this is a */
1433       /* usage not a definition                           */
1434       if (! (POINTER_SET(ic)) && IC_RESULT(ic)){
1435     deleteItemIf (&cseSet, ifDefSymIsX,IC_RESULT(ic));
1436     addSetHead(&cseSet,newCseDef(IC_RESULT(ic),ic));
1437       }
1438       defic = ic;
1439
1440   }
1441
1442   /* if assignment to a parameter which is not
1443      mine and type is a pointer then delete
1444      pointerGets to take care of aliasing */
1445   if (ASSIGNMENT(ic)                        &&
1446       OTHERS_PARM(OP_SYMBOL(IC_RESULT(ic))) &&
1447       IS_PTR(operandType(IC_RESULT(ic)))) {
1448       deleteGetPointers(&cseSet,&ptrSetSet,IC_RIGHT(ic),ebb);
1449       for (i = 0 ; i < count ;ebbs[i++]->visited = 0);
1450       applyToSet(ebb->succList,delGetPointerSucc,IC_RIGHT(ic),ebb->dfnum);
1451       ebb->ptrsSet = bitVectSetBit(ebb->ptrsSet,IC_RIGHT(ic)->key);
1452   }
1453
1454   /* if this is a pointerget then see if we can replace
1455      this with a previously assigned pointer value */
1456   if (POINTER_GET(ic) &&
1457       !(IS_BITFIELD(OP_SYMBOL(IC_RESULT(ic))->etype) ||
1458          isOperandVolatile(IC_LEFT(ic),TRUE))) {
1459       pdop = NULL;
1460       applyToSet(ptrSetSet,findPointerSet,IC_LEFT(ic),&pdop,IC_RESULT(ic));
1461       /* if we find it then locally replace all
1462          references to the result with what we assigned */
1463       if (pdop) {
1464     replaceAllSymBySym(ic->next,IC_RESULT(ic),pdop,&ebb->ndompset);
1465       }
1466   }
1467
1468   /* delete from the cseSet anything that has */
1469   /* operands matching the result of this     */
1470   /* except in case of pointer access         */
1471   if (!(POINTER_SET(ic)) && IC_RESULT(ic)) {
1472       deleteItemIf (&cseSet,ifOperandsHave,IC_RESULT(ic));
1473       /* delete any previous definitions */
1474       ebb->defSet = bitVectCplAnd (ebb->defSet,OP_DEFS(IC_RESULT(ic)));
1475
1476   }
1477
1478   /* add the left & right to the defUse set */
1479   if (IC_LEFT(ic) && IS_SYMOP(IC_LEFT(ic))) {
1480       OP_USES(IC_LEFT(ic)) =
1481     bitVectSetBit (OP_USES(IC_LEFT(ic)),ic->key);
1482       setUsesDefs(IC_LEFT(ic),ebb->defSet,ebb->outDefs,&ebb->usesDefs);
1483
1484   }
1485
1486   if (IC_RIGHT(ic) && IS_SYMOP(IC_RIGHT(ic))) {
1487       OP_USES(IC_RIGHT(ic)) =
1488     bitVectSetBit (OP_USES(IC_RIGHT(ic)),ic->key);
1489       setUsesDefs(IC_RIGHT(ic),ebb->defSet,ebb->outDefs,&ebb->usesDefs);
1490
1491   }
1492
1493   /* for the result it is special case, put the result */
1494   /* in the defuseSet if it a pointer or array access  */
1495   if ( POINTER_SET(defic) ) {
1496       OP_USES(IC_RESULT(ic)) =
1497     bitVectSetBit (OP_USES(IC_RESULT(ic)),ic->key);
1498       setUsesDefs(IC_RESULT(ic),ebb->defSet,ebb->outDefs,&ebb->usesDefs);
1499       deleteItemIf(&cseSet,ifPointerGet,IC_RESULT(ic));
1500       ebb->ptrsSet = bitVectSetBit(ebb->ptrsSet,IC_RESULT(ic)->key);
1501       /* delete from inexpressions of all successors which
1502          have dfNum > than this block */
1503       for (i = 0 ; i < count ;ebbs[i++]->visited = 0);
1504       applyToSet(ebb->succList,delGetPointerSucc,IC_RESULT(ic),ebb->dfnum);
1505
1506       /* delete from cseSet all other pointer sets
1507          for this operand */
1508       deleteItemIf(&ptrSetSet,ifPointerSet,IC_RESULT(ic));
1509       /* add to the local pointerset set */
1510       addSetHead(&ptrSetSet,newCseDef(IC_RESULT(ic),ic));
1511   }
1512   else /* add the result to defintion set */
1513       if (IC_RESULT(ic)) {
1514     OP_DEFS(IC_RESULT(ic)) =
1515         bitVectSetBit (OP_DEFS(IC_RESULT(ic)),ic->key);
1516     ebb->defSet = bitVectSetBit (ebb->defSet,ic->key);
1517     ebb->outDefs= bitVectCplAnd (ebb->outDefs,OP_DEFS(IC_RESULT(ic)));
1518     ebb->ldefs  = bitVectSetBit (ebb->ldefs,ic->key);
1519       }
1520
1521
1522   /* if this is an addressof instruction then */
1523   /* put the symbol in the address of list &  */
1524   /* delete it from the cseSet                */
1525   if (defic->op == ADDRESS_OF) {
1526       addSetHead (&ebb->addrOf, IC_LEFT(ic));
1527       deleteItemIf(&cseSet,ifDefSymIsX,IC_LEFT(ic));
1528   }
1529     }
1530
1531     setToNull ((void **)&ebb->outExprs);
1532     ebb->outExprs = cseSet;
1533     ebb->outDefs = bitVectUnion (ebb->outDefs,ebb->defSet);
1534     ebb->ptrsSet = bitVectUnion (ebb->ptrsSet,ebb->inPtrsSet);
1535     return change ;
1536 }
1537
1538 /*-----------------------------------------------------------------*/
1539 /* cseAllBlocks - will sequentially go thru & do cse for all blocks*/
1540 /*-----------------------------------------------------------------*/
1541 int cseAllBlocks (eBBlock **ebbs,int count)
1542 {
1543     int i;
1544     int change = 0 ;
1545
1546     /* if optimization turned off */
1547
1548     for (i = 0 ; i < count ;i++ )
1549   change += cseBBlock (ebbs[i],FALSE,ebbs,count);
1550
1551     return change;
1552 }
1553