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

   1 /*-------------------------------------------------------------------------
   2   SDCCopt.c - calls all the optimizations routines and does some of the
   3               hackier transformations, these include translating iCodes
   4               to function calls and replacing local variables with their
   5               register equivalents etc. Also contains the driver routine
   6               for dead code elimination
   7
   8              Written By -  Sandeep Dutta . sandeep.dutta@usa.net (1998)
   9
  10    This program is free software; you can redistribute it and/or modify it
  11    under the terms of the GNU General Public License as published by the
  12    Free Software Foundation; either version 2, or (at your option) any
  13    later version.
  14
  15    This program is distributed in the hope that it will be useful,
  16    but WITHOUT ANY WARRANTY; without even the implied warranty of
  17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18    GNU General Public License for more details.
  19
  20    You should have received a copy of the GNU General Public License
  21    along with this program; if not, write to the Free Software
  22    Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  23
  24    In other words, you are welcome to use, share and improve this program.
  25    You are forbidden to forbid anyone else to use, share and improve
  26    what you give them.   Help stamp out software-hoarding!
  27 -------------------------------------------------------------------------*/
  28
  29 #include "common.h"
  30
  31 /*-----------------------------------------------------------------*/
  32 /* global variables */
  33 int cseDefNum = 0;
  34
  35 char flowChanged = 0;
  36
  37
  38 /*-----------------------------------------------------------------*/
  39 /* printSymName - prints the symbol names                          */
  40 /*-----------------------------------------------------------------*/
  41 int
  42 printSymName (void *vsym)
  43 {
  44   symbol *sym = vsym;
  45   fprintf (stdout, " %s ", sym->name);
  46   return 0;
  47 }
  48
  49 /*-----------------------------------------------------------------*/
  50 /* cnvToFcall - does the actual conversion to function call        */
  51 /*-----------------------------------------------------------------*/
  52 static void
  53 cnvToFcall (iCode * ic, eBBlock * ebp)
  54 {
  55   iCode *ip;
  56   iCode *newic;
  57   operand *left;
  58   operand *right;
  59   symbol *func = NULL;
  60   int lineno = ic->lineno;
  61   int bytesPushed=0;
  62
  63   ip = ic->next;                /* insertion point */
  64   /* remove it from the iCode */
  65   remiCodeFromeBBlock (ebp, ic);
  66
  67   left = IC_LEFT (ic);
  68   right = IC_RIGHT (ic);
  69
  70   switch (ic->op)
  71     {
  72     case '+':
  73       func = __fsadd;
  74       break;
  75     case '-':
  76       func = __fssub;
  77       break;
  78     case '/':
  79       func = __fsdiv;
  80       break;
  81     case '*':
  82       func = __fsmul;
  83       break;
  84     case EQ_OP:
  85       func = __fseq;
  86       break;
  87     case NE_OP:
  88       func = __fsneq;
  89       break;
  90     case '<':
  91       func = __fslt;
  92       break;
  93     case '>':
  94       func = __fsgt;
  95       break;
  96     case LE_OP:
  97       func = __fslteq;
  98       break;
  99     case GE_OP:
 100       func = __fsgteq;
 101       break;
 102     }
 103
 104   /* if float support routines NOT compiled as reentrant */
 105   if (!options.float_rent)
 106     {
 107
 108       /* first one */
 109       if (IS_REGPARM (FUNC_ARGS(func->type)->etype))
 110         {
 111           newic = newiCode (SEND, IC_LEFT (ic), NULL);
 112           newic->argreg = SPEC_ARGREG(FUNC_ARGS(func->type)->etype);
 113         }
 114       else
 115         {
 116           newic = newiCode ('=', NULL, IC_LEFT (ic));
 117           IC_RESULT (newic) = operandFromValue (FUNC_ARGS(func->type));
 118         }
 119
 120       addiCodeToeBBlock (ebp, newic, ip);
 121       newic->lineno = lineno;
 122
 123       /* second one */
 124       if (IS_REGPARM (FUNC_ARGS(func->type)->next->etype))
 125         {
 126           newic = newiCode (SEND, IC_RIGHT (ic), NULL);
 127           newic->argreg = SPEC_ARGREG(FUNC_ARGS(func->type)->next->etype);
 128         }
 129       else
 130         {
 131           newic = newiCode ('=', NULL, IC_RIGHT (ic));
 132           IC_RESULT (newic) = operandFromValue (FUNC_ARGS(func->type)->next);
 133         }
 134       addiCodeToeBBlock (ebp, newic, ip);
 135       newic->lineno = lineno;
 136
 137     }
 138   else
 139     {
 140
 141       /* push right */
 142       if (IS_REGPARM (FUNC_ARGS(func->type)->next->etype))
 143         {
 144           newic = newiCode (SEND, right, NULL);
 145           newic->argreg = SPEC_ARGREG(FUNC_ARGS(func->type)->next->etype);
 146         }
 147       else
 148         {
 149           newic = newiCode (IPUSH, right, NULL);
 150           newic->parmPush = 1;
 151           //bytesPushed+=4;
 152           bytesPushed += getSize(operandType(right));
 153         }
 154
 155       addiCodeToeBBlock (ebp, newic, ip);
 156       newic->lineno = lineno;
 157
 158       /* insert push left */
 159       if (IS_REGPARM (FUNC_ARGS(func->type)->etype))
 160         {
 161           newic = newiCode (SEND, left, NULL);
 162           newic->argreg = SPEC_ARGREG(FUNC_ARGS(func->type)->etype);
 163         }
 164       else
 165         {
 166           newic = newiCode (IPUSH, left, NULL);
 167           newic->parmPush = 1;
 168           //bytesPushed+=4;
 169           bytesPushed += getSize(operandType(left));
 170         }
 171       addiCodeToeBBlock (ebp, newic, ip);
 172       newic->lineno = lineno;
 173     }
 174   /* insert the call */
 175   newic = newiCode (CALL, operandFromSymbol (func), NULL);
 176   IC_RESULT (newic) = IC_RESULT (ic);
 177   newic->lineno = lineno;
 178   newic->parmBytes+=bytesPushed;
 179   addiCodeToeBBlock (ebp, newic, ip);
 180 }
 181
 182 /*-----------------------------------------------------------------*/
 183 /* cnvToFloatCast - converts casts to floats to function calls     */
 184 /*-----------------------------------------------------------------*/
 185 static void
 186 cnvToFloatCast (iCode * ic, eBBlock * ebp)
 187 {
 188   iCode *ip, *newic;
 189   symbol *func = NULL;
 190   sym_link *type = operandType (IC_RIGHT (ic));
 191   int linenno = ic->lineno;
 192   int bwd, su;
 193   int bytesPushed=0;
 194
 195   ip = ic->next;
 196   /* remove it from the iCode */
 197   remiCodeFromeBBlock (ebp, ic);
 198   /* depending on the type */
 199   for (bwd = 0; bwd < 3; bwd++)
 200     {
 201       for (su = 0; su < 2; su++)
 202         {
 203           if (compareType (type, __multypes[bwd][su]) == 1)
 204             {
 205               func = __conv[0][bwd][su];
 206               goto found;
 207             }
 208         }
 209     }
 210   assert (0);
 211 found:
 212
 213   /* if float support routines NOT compiled as reentrant */
 214   if (!options.float_rent)
 215     {
 216       /* first one */
 217         if (IS_REGPARM (FUNC_ARGS(func->type)->etype))
 218             {
 219                 newic = newiCode (SEND, IC_RIGHT (ic), NULL);
 220                 newic->argreg = SPEC_ARGREG(FUNC_ARGS(func->type)->etype);
 221             }
 222       else
 223         {
 224           newic = newiCode ('=', NULL, IC_RIGHT (ic));
 225           IC_RESULT (newic) = operandFromValue (FUNC_ARGS(func->type));
 226         }
 227       addiCodeToeBBlock (ebp, newic, ip);
 228       newic->lineno = linenno;
 229
 230     }
 231   else
 232     {
 233       /* push the left */
 234         if (IS_REGPARM (FUNC_ARGS(func->type)->etype)) {
 235             newic = newiCode (SEND, IC_RIGHT (ic), NULL);
 236             newic->argreg = SPEC_ARGREG(FUNC_ARGS(func->type)->etype);
 237         }
 238       else
 239         {
 240           newic = newiCode (IPUSH, IC_RIGHT (ic), NULL);
 241           newic->parmPush = 1;
 242           bytesPushed += getSize(operandType(IC_RIGHT(ic)));
 243         }
 244       addiCodeToeBBlock (ebp, newic, ip);
 245       newic->lineno = linenno;
 246
 247     }
 248
 249   /* make the call */
 250   newic = newiCode (CALL, operandFromSymbol (func), NULL);
 251   IC_RESULT (newic) = IC_RESULT (ic);
 252   newic->parmBytes+=bytesPushed;
 253   addiCodeToeBBlock (ebp, newic, ip);
 254   newic->lineno = linenno;
 255
 256 }
 257
 258 /*-----------------------------------------------------------------*/
 259 /* cnvFromFloatCast - converts casts From floats to function calls */
 260 /*-----------------------------------------------------------------*/
 261 static void
 262 cnvFromFloatCast (iCode * ic, eBBlock * ebp)
 263 {
 264   iCode *ip, *newic;
 265   symbol *func = NULL;
 266   sym_link *type = operandType (IC_LEFT (ic));
 267   int lineno = ic->lineno;
 268   int bwd, su;
 269   int bytesPushed=0;
 270
 271   ip = ic->next;
 272   /* remove it from the iCode */
 273   remiCodeFromeBBlock (ebp, ic);
 274
 275   /* depending on the type */
 276   for (bwd = 0; bwd < 3; bwd++)
 277     {
 278       for (su = 0; su < 2; su++)
 279         {
 280           if (compareType (type, __multypes[bwd][su]) == 1)
 281             {
 282               func = __conv[1][bwd][su];
 283               goto found;
 284             }
 285         }
 286     }
 287   assert (0);
 288 found:
 289
 290   /* if float support routines NOT compiled as reentrant */
 291   if (!options.float_rent)
 292     {
 293       /* first one */
 294         if (IS_REGPARM (FUNC_ARGS(func->type)->etype)) {
 295             newic = newiCode (SEND, IC_RIGHT (ic), NULL);
 296             newic->argreg = SPEC_ARGREG(FUNC_ARGS(func->type)->etype);
 297         }
 298       else
 299         {
 300           newic = newiCode ('=', NULL, IC_RIGHT (ic));
 301           IC_RESULT (newic) = operandFromValue (FUNC_ARGS(func->type));
 302         }
 303       addiCodeToeBBlock (ebp, newic, ip);
 304       newic->lineno = lineno;
 305
 306     }
 307   else
 308     {
 309
 310       /* push the left */
 311         if (IS_REGPARM (FUNC_ARGS(func->type)->etype)) {
 312             newic = newiCode (SEND, IC_RIGHT (ic), NULL);
 313             newic->argreg = SPEC_ARGREG(FUNC_ARGS(func->type)->etype);
 314         }
 315       else
 316         {
 317           newic = newiCode (IPUSH, IC_RIGHT (ic), NULL);
 318           newic->parmPush = 1;
 319           bytesPushed += getSize(operandType(IC_RIGHT(ic)));
 320         }
 321       addiCodeToeBBlock (ebp, newic, ip);
 322       newic->lineno = lineno;
 323
 324     }
 325
 326   /* make the call */
 327   newic = newiCode (CALL, operandFromSymbol (func), NULL);
 328   IC_RESULT (newic) = IC_RESULT (ic);
 329   newic->parmBytes+=bytesPushed;
 330   addiCodeToeBBlock (ebp, newic, ip);
 331   newic->lineno = lineno;
 332
 333 }
 334
 335 extern operand *geniCodeRValue (operand *, bool);
 336
 337 /*-----------------------------------------------------------------*/
 338 /* convilong - converts int or long mults or divs to fcalls        */
 339 /*-----------------------------------------------------------------*/
 340 static void
 341 convilong (iCode * ic, eBBlock * ebp, sym_link * type, int op)
 342 {
 343   symbol *func = NULL;
 344   iCode *ip = ic->next;
 345   iCode *newic;
 346   int lineno = ic->lineno;
 347   int bwd;
 348   int su;
 349   int bytesPushed=0;
 350
 351   // Easy special case which avoids function call: modulo by a literal power
 352   // of two can be replaced by a bitwise AND.
 353   if (op == '%' && isOperandLiteral(IC_RIGHT(ic)))
 354   {
 355       unsigned litVal = (unsigned)(operandLitValue(IC_RIGHT(ic)));
 356
 357       // See if literal value is a power of 2.
 358       while (litVal && !(litVal & 1))
 359       {
 360           litVal >>= 1;
 361       }
 362       if (litVal)
 363       {
 364           // discard first high bit set.
 365           litVal >>= 1;
 366       }
 367
 368       if (!litVal)
 369       {
 370           ic->op = BITWISEAND;
 371           IC_RIGHT(ic) = operandFromLit(operandLitValue(IC_RIGHT(ic)) - 1);
 372           return;
 373       }
 374   }
 375
 376   remiCodeFromeBBlock (ebp, ic);
 377
 378
 379   /* depending on the type */
 380   for (bwd = 0; bwd < 3; bwd++)
 381     {
 382       for (su = 0; su < 2; su++)
 383         {
 384           if (compareType (type, __multypes[bwd][su]) == 1)
 385             {
 386               if (op == '*')
 387                 func = __muldiv[0][bwd][su];
 388               else if (op == '/')
 389                 func = __muldiv[1][bwd][su];
 390               else if (op == '%')
 391                 func = __muldiv[2][bwd][su];
 392               else if (op == RRC)
 393                 func = __rlrr[1][bwd][su];
 394               else if (op == RLC)
 395                 func = __rlrr[0][bwd][su];
 396               else if (op == RIGHT_OP)
 397                 func = __rlrr[1][bwd][su];
 398               else if (op == LEFT_OP)
 399                 func = __rlrr[0][bwd][su];
 400               else
 401                 assert (0);
 402               goto found;
 403             }
 404         }
 405     }
 406   assert (0);
 407 found:
 408   /* if int & long support routines NOT compiled as reentrant */
 409   if (!options.intlong_rent)
 410     {
 411       /* first one */
 412         if (IS_REGPARM (FUNC_ARGS(func->type)->etype)) {
 413             newic = newiCode (SEND, IC_LEFT (ic), NULL);
 414             newic->argreg = SPEC_ARGREG(FUNC_ARGS(func->type)->etype);
 415         }
 416       else
 417         {
 418           newic = newiCode ('=', NULL, IC_LEFT (ic));
 419           IC_RESULT (newic) = operandFromValue (FUNC_ARGS(func->type));
 420         }
 421       addiCodeToeBBlock (ebp, newic, ip);
 422       newic->lineno = lineno;
 423
 424       /* second one */
 425       if (IS_REGPARM (FUNC_ARGS(func->type)->next->etype)) {
 426           newic = newiCode (SEND, IC_RIGHT (ic), NULL);
 427           newic->argreg = SPEC_ARGREG(FUNC_ARGS(func->type)->next->etype);
 428       }
 429       else
 430         {
 431           newic = newiCode ('=', NULL, IC_RIGHT (ic));
 432           IC_RESULT (newic) = operandFromValue (FUNC_ARGS(func->type)->next);
 433         }
 434       addiCodeToeBBlock (ebp, newic, ip);
 435       newic->lineno = lineno;
 436
 437     }
 438   else
 439     {
 440       /* compiled as reentrant then push */
 441       /* push right */
 442       if (IS_REGPARM (FUNC_ARGS(func->type)->next->etype))
 443         {
 444           newic = newiCode (SEND, IC_RIGHT (ic), NULL);
 445           newic->argreg = SPEC_ARGREG(FUNC_ARGS(func->type)->next->etype);
 446         }
 447       else
 448         {
 449           newic = newiCode (IPUSH, IC_RIGHT (ic), NULL);
 450           newic->parmPush = 1;
 451
 452           bytesPushed += getSize(operandType(IC_RIGHT(ic)));
 453         }
 454       addiCodeToeBBlock (ebp, newic, ip);
 455       newic->lineno = lineno;
 456
 457       /* insert push left */
 458       if (IS_REGPARM (FUNC_ARGS(func->type)->etype))
 459         {
 460           newic = newiCode (SEND, IC_LEFT (ic), NULL);
 461           newic->argreg = SPEC_ARGREG(FUNC_ARGS(func->type)->etype);
 462         }
 463       else
 464         {
 465           newic = newiCode (IPUSH, IC_LEFT (ic), NULL);
 466           newic->parmPush = 1;
 467
 468           bytesPushed += getSize(operandType(IC_LEFT(ic)));
 469         }
 470       addiCodeToeBBlock (ebp, newic, ip);
 471       newic->lineno = lineno;
 472
 473     }
 474
 475   /* for the result */
 476   newic = newiCode (CALL, operandFromSymbol (func), NULL);
 477   IC_RESULT (newic) = IC_RESULT (ic);
 478   newic->lineno = lineno;
 479   newic->parmBytes+=bytesPushed; // to clear the stack after the call
 480   addiCodeToeBBlock (ebp, newic, ip);
 481 }
 482
 483 /*-----------------------------------------------------------------*/
 484 /* convertToFcall - converts some operations to fcalls             */
 485 /*-----------------------------------------------------------------*/
 486 static void
 487 convertToFcall (eBBlock ** ebbs, int count)
 488 {
 489   int i;
 490
 491   /* for all blocks do */
 492   for (i = 0; i < count; i++)
 493     {
 494       iCode *ic;
 495
 496       /* for all instructions in the block do */
 497       for (ic = ebbs[i]->sch; ic; ic = ic->next)
 498         {
 499
 500           /* floating point operations are
 501              converted to function calls */
 502           if ((IS_CONDITIONAL (ic) ||
 503                IS_ARITHMETIC_OP (ic)) &&
 504               (IS_FLOAT (operandType (IC_RIGHT (ic)))))
 505             {
 506
 507               cnvToFcall (ic, ebbs[i]);
 508             }
 509
 510           /* casting is a little different */
 511           if (ic->op == CAST)
 512             {
 513               if (IS_FLOAT (operandType (IC_RIGHT (ic))))
 514                 cnvFromFloatCast (ic, ebbs[i]);
 515               else if (IS_FLOAT (operandType (IC_LEFT (ic))))
 516                 cnvToFloatCast (ic, ebbs[i]);
 517             }
 518
 519           /* if long / int mult or divide or mod */
 520           if (ic->op == '*' || ic->op == '/' || ic->op == '%')
 521             {
 522               sym_link *leftType = operandType (IC_LEFT (ic));
 523
 524               if (IS_INTEGRAL (leftType) && getSize (leftType) > port->support.muldiv)
 525                 {
 526                   sym_link *rightType = operandType (IC_RIGHT (ic));
 527
 528                   if (port->hasNativeMulFor != NULL &&
 529                       port->hasNativeMulFor (ic, leftType, rightType))
 530                     {
 531                       /* Leave as native */
 532                     }
 533                   else
 534                     {
 535                       convilong (ic, ebbs[i], leftType, ic->op);
 536                     }
 537                 }
 538             }
 539
 540           if (ic->op == RRC || ic->op == RLC || ic->op == LEFT_OP || ic->op == RIGHT_OP)
 541             {
 542               sym_link *type = operandType (IC_LEFT (ic));
 543
 544               if (IS_INTEGRAL (type) && getSize (type) > port->support.shift && port->support.shift >= 0)
 545                 {
 546                   convilong (ic, ebbs[i], type, ic->op);
 547                 }
 548             }
 549         }
 550     }
 551 }
 552
 553 /*-----------------------------------------------------------------*/
 554 /* replaceRegEqv - replace all local variables with their reqv     */
 555 /*-----------------------------------------------------------------*/
 556 static void
 557 replaceRegEqv (eBBlock ** ebbs, int count)
 558 {
 559   int i;
 560
 561   for (i = 0; i < count; i++)
 562     {
 563
 564       iCode *ic;
 565
 566       for (ic = ebbs[i]->sch; ic; ic = ic->next)
 567         {
 568
 569           if (SKIP_IC2 (ic))
 570             continue;
 571
 572           if (ic->op == IFX)
 573             {
 574
 575               if (IS_TRUE_SYMOP (IC_COND (ic)) &&
 576                   OP_REQV (IC_COND (ic)))
 577                 IC_COND (ic) = opFromOpWithDU (OP_REQV (IC_COND (ic)),
 578                                              OP_SYMBOL (IC_COND (ic))->defs,
 579                                             OP_SYMBOL (IC_COND (ic))->uses);
 580
 581               continue;
 582             }
 583
 584           if (ic->op == JUMPTABLE)
 585             {
 586               if (IS_TRUE_SYMOP (IC_JTCOND (ic)) &&
 587                   OP_REQV (IC_JTCOND (ic)))
 588                 IC_JTCOND (ic) = opFromOpWithDU (OP_REQV (IC_JTCOND (ic)),
 589                                            OP_SYMBOL (IC_JTCOND (ic))->defs,
 590                                           OP_SYMBOL (IC_JTCOND (ic))->uses);
 591               continue;
 592             }
 593
 594           if (ic->op == RECEIVE)
 595             {
 596               if (OP_SYMBOL (IC_RESULT (ic))->addrtaken)
 597                 OP_SYMBOL (IC_RESULT (ic))->isspilt = 1;
 598             }
 599
 600           /* general case */
 601           if (IC_RESULT (ic) &&
 602               IS_TRUE_SYMOP (IC_RESULT (ic)) &&
 603               OP_REQV (IC_RESULT (ic)))
 604             {
 605               if (POINTER_SET (ic))
 606                 {
 607                   IC_RESULT (ic) = opFromOpWithDU (OP_REQV (IC_RESULT (ic)),
 608                                            OP_SYMBOL (IC_RESULT (ic))->defs,
 609                                           OP_SYMBOL (IC_RESULT (ic))->uses);
 610                   IC_RESULT (ic)->isaddr = 1;
 611                 }
 612               else
 613                 IC_RESULT (ic) = opFromOpWithDU (OP_REQV (IC_RESULT (ic)),
 614                                            OP_SYMBOL (IC_RESULT (ic))->defs,
 615                                           OP_SYMBOL (IC_RESULT (ic))->uses);
 616             }
 617
 618           if (IC_RIGHT (ic) &&
 619               IS_TRUE_SYMOP (IC_RIGHT (ic)) &&
 620               OP_REQV (IC_RIGHT (ic)))
 621             {
 622               IC_RIGHT (ic) = opFromOpWithDU (OP_REQV (IC_RIGHT (ic)),
 623                                             OP_SYMBOL (IC_RIGHT (ic))->defs,
 624                                            OP_SYMBOL (IC_RIGHT (ic))->uses);
 625               IC_RIGHT (ic)->isaddr = 0;
 626             }
 627
 628           if (IC_LEFT (ic) &&
 629               IS_TRUE_SYMOP (IC_LEFT (ic)) &&
 630               OP_REQV (IC_LEFT (ic)))
 631             {
 632               IC_LEFT (ic) = opFromOpWithDU (OP_REQV (IC_LEFT (ic)),
 633                                              OP_SYMBOL (IC_LEFT (ic))->defs,
 634                                              OP_SYMBOL (IC_LEFT (ic))->uses);
 635               IC_LEFT (ic)->isaddr = 0;
 636             }
 637         }
 638     }
 639 }
 640
 641 /*-----------------------------------------------------------------*/
 642 /* killDeadCode - eliminates dead assignments                      */
 643 /*-----------------------------------------------------------------*/
 644 int
 645 killDeadCode (eBBlock ** ebbs, int count)
 646 {
 647   int change = 1;
 648   int gchange = 0;
 649   int i = 0;
 650
 651
 652   /* basic algorithm :-                                          */
 653   /* first the exclusion rules :-                                */
 654   /*  1. if result is a global or volatile then skip             */
 655   /*  2. if assignment and result is a temp & isaddr  then skip  */
 656   /*     since this means array & pointer access, will be taken  */
 657   /*     care of by alias analysis.                              */
 658   /*  3. if the result is used in the remainder of the block skip */
 659   /*  4. if this definition does not reach the end of the block  */
 660   /*     i.e. the result is not present in the outExprs then KILL */
 661   /*  5. if it reaches the end of block & is used by some success */
 662   /*     or then skip                                            */
 663   /*     else            KILL                                    */
 664   /* this whole process is carried on iteratively till no change */
 665   while (1)
 666     {
 667
 668       change = 0;
 669       /* for all blocks do */
 670       for (i = 0; i < count; i++)
 671         {
 672           iCode *ic;
 673
 674           /* for all instructions in the block do */
 675           for (ic = ebbs[i]->sch; ic; ic = ic->next)
 676             {
 677               int kill, j;
 678               kill = 0;
 679
 680               if (SKIP_IC (ic) ||
 681                   ic->op == IFX ||
 682                   ic->op == RETURN ||
 683                   ic->op == DUMMY_READ_VOLATILE)
 684                 continue;
 685
 686               /* if the result is volatile then continue */
 687               if (IC_RESULT (ic) && isOperandVolatile (IC_RESULT (ic), FALSE))
 688                 continue;
 689
 690               /* if the result is a temp & isaddr then skip */
 691               if (IC_RESULT (ic) && POINTER_SET (ic))
 692                 continue;
 693
 694               if (POINTER_GET (ic) && IS_VOLATILE (operandType (IC_LEFT (ic))->next))
 695                 continue;
 696
 697               /* if the result is used in the remainder of the */
 698               /* block then skip */
 699               if (usedInRemaining (IC_RESULT (ic), ic->next))
 700                 continue;
 701
 702               /* does this definition reach the end of the block
 703                  or the usage is zero then we can kill */
 704               if (!bitVectBitValue (ebbs[i]->outDefs, ic->key))
 705                 kill = 1;       /* if not we can kill it */
 706               else
 707                 {
 708                   /* if this is a global variable or function parameter */
 709                   /* we cannot kill anyway             */
 710                   if (isOperandGlobal (IC_RESULT (ic)) ||
 711                       (OP_SYMBOL (IC_RESULT (ic))->_isparm &&
 712                        !OP_SYMBOL (IC_RESULT (ic))->ismyparm))
 713                     continue;
 714
 715                   /* if we are sure there are no usages */
 716                   if (bitVectIsZero (OP_USES (IC_RESULT (ic))))
 717                     {
 718                       kill = 1;
 719                       goto kill;
 720                     }
 721
 722                   /* reset visited flag */
 723                   for (j = 0; j < count; ebbs[j++]->visited = 0);
 724
 725                   /* find out if this definition is alive */
 726                   if (applyToSet (ebbs[i]->succList,
 727                                   isDefAlive,
 728                                   ic))
 729                     continue;
 730
 731                   kill = 1;
 732                 }
 733
 734             kill:
 735               /* kill this one if required */
 736               if (kill)
 737                 {
 738                   change = 1;
 739                   gchange++;
 740                   /* eliminate this */
 741                   remiCodeFromeBBlock (ebbs[i], ic);
 742
 743                   /* now delete from defUseSet */
 744                   deleteItemIf (&ebbs[i]->outExprs, ifDiCodeIsX, ic);
 745                   bitVectUnSetBit (ebbs[i]->outDefs, ic->key);
 746
 747                   /* and defset of the block */
 748                   bitVectUnSetBit (ebbs[i]->defSet, ic->key);
 749
 750                   /* for the left & right remove the usage */
 751                   if (IS_SYMOP (IC_LEFT (ic)))
 752                     bitVectUnSetBit (OP_USES (IC_LEFT (ic)), ic->key);
 753
 754                   if (IS_SYMOP (IC_RIGHT (ic)))
 755                     bitVectUnSetBit (OP_USES (IC_RIGHT (ic)), ic->key);
 756                 }
 757
 758             }                   /* end of all instructions */
 759
 760           if (!ebbs[i]->sch && !ebbs[i]->noPath)
 761             disconBBlock (ebbs[i], ebbs, count);
 762
 763         }                       /* end of for all blocks */
 764
 765       if (!change)
 766         break;
 767     }                           /* end of while(1) */
 768
 769   return gchange;
 770 }
 771
 772 /*-----------------------------------------------------------------*/
 773 /* printCyclomatic - prints the cyclomatic information             */
 774 /*-----------------------------------------------------------------*/
 775 static void
 776 printCyclomatic (eBBlock ** ebbs, int count)
 777 {
 778   int nEdges = elementsInSet (graphEdges);
 779   int i, nNodes = 0;
 780
 781   for (i = 0; i < count; i++)
 782     nNodes += (!ebbs[i]->noPath);
 783
 784   /* print the information */
 785   werror (I_CYCLOMATIC, currFunc->name, nEdges, nNodes, nEdges - nNodes + 2);
 786 }
 787
 788 /*-----------------------------------------------------------------*/
 789 /* discardDeadParamReceives - remove any RECEIVE opcodes which     */
 790 /* refer to dead variables.                                        */
 791 /*-----------------------------------------------------------------*/
 792 static void
 793 discardDeadParamReceives (eBBlock ** ebbs, int count)
 794 {
 795   int i;
 796   iCode *ic;
 797   iCode dummyIcode;
 798
 799   for (i = 0; i < count; i++)
 800     {
 801       for (ic = ebbs[i]->sch; ic; ic = ic->next)
 802         {
 803           if (ic->op == RECEIVE)
 804             {
 805               if (IC_RESULT (ic) && OP_SYMBOL (IC_RESULT (ic))
 806                   && !OP_SYMBOL (IC_RESULT (ic))->used)
 807                 {
 808 #if 0
 809                   fprintf (stderr, "discarding dead receive for %s\n",
 810                            OP_SYMBOL (IC_RESULT (ic))->name);
 811 #endif
 812                   dummyIcode.next = ic->next;
 813                   remiCodeFromeBBlock (ebbs[i], ic);
 814                   ic = &dummyIcode;
 815                 }
 816             }
 817         }
 818     }
 819 }
 820
 821 /*-----------------------------------------------------------------*/
 822 /* eBBlockFromiCode - creates extended basic blocks from iCode     */
 823 /*                    will return an array of eBBlock pointers     */
 824 /*-----------------------------------------------------------------*/
 825 eBBlock **
 826 eBBlockFromiCode (iCode * ic)
 827 {
 828   eBBlock **ebbs = NULL;
 829   int count = 0;
 830   int saveCount = 0;
 831   int change = 1;
 832   int lchange = 0;
 833   int kchange = 0;
 834   hTab *loops;
 835
 836   /* if nothing passed then return nothing */
 837   if (!ic)
 838     return NULL;
 839
 840   count = 0;
 841   eBBNum = 0;
 842
 843   /* optimize the chain for labels & gotos
 844      this will eliminate redundant labels and
 845      will change jump to jumps by jumps */
 846   ic = iCodeLabelOptimize (ic);
 847
 848   /* break it down into basic blocks */
 849   ebbs = iCodeBreakDown (ic, &count);
 850   saveCount = count;
 851
 852   /* compute the control flow */
 853   computeControlFlow (ebbs, count, 0);
 854
 855   /* dumpraw if asked for */
 856   if (options.dump_raw)
 857     dumpEbbsToFileExt (DUMP_RAW0, ebbs, count);
 858
 859   /* replace the local variables with their
 860      register equivalents : the liveRange computation
 861      along with the register allocation will determine
 862      if it finally stays in the registers */
 863   replaceRegEqv (ebbs, count);
 864
 865   /* create loop regions */
 866   loops = createLoopRegions (ebbs, count);
 867
 868   /* dumpraw if asked for */
 869   if (options.dump_raw)
 870     dumpEbbsToFileExt (DUMP_RAW1, ebbs, count);
 871
 872   /* do common subexpression elimination for each block */
 873   change = cseAllBlocks (ebbs, saveCount, FALSE);
 874
 875   /* dumpraw if asked for */
 876   if (options.dump_raw)
 877     dumpEbbsToFileExt (DUMP_CSE, ebbs, count);
 878
 879   /* compute the data flow */
 880   computeDataFlow (ebbs, saveCount);
 881
 882   /* dumpraw if asked for */
 883   if (options.dump_raw)
 884     dumpEbbsToFileExt (DUMP_DFLOW, ebbs, count);
 885
 886   /* global common subexpression elimination  */
 887   if (optimize.global_cse)
 888     {
 889       change += cseAllBlocks (ebbs, saveCount, FALSE);
 890       if (options.dump_gcse)
 891         dumpEbbsToFileExt (DUMP_GCSE, ebbs, saveCount);
 892     }
 893   else
 894     {
 895       // compute the dataflow only
 896       assert(cseAllBlocks (ebbs, saveCount, TRUE)==0);
 897     }
 898   /* kill dead code */
 899   kchange = killDeadCode (ebbs, saveCount);
 900
 901   if (options.dump_kill)
 902     dumpEbbsToFileExt (DUMP_DEADCODE, ebbs, count);
 903
 904   /* do loop optimizations */
 905   change += (lchange = loopOptimizations (loops, ebbs, count));
 906   if (options.dump_loop)
 907     dumpEbbsToFileExt (DUMP_LOOP, ebbs, count);
 908
 909   /* recompute the data flow and apply global cse again
 910      if loops optimizations or dead code caused a change:
 911      loops will brings out of the loop which then may be
 912      available for use in the later blocks: dead code
 913      elimination could potentially disconnect some blocks
 914      conditional flow may be efected so we need to apply
 915      subexpression once more */
 916   if (lchange || kchange)
 917     {
 918       computeDataFlow (ebbs, saveCount);
 919       change += cseAllBlocks (ebbs, saveCount, FALSE);
 920       if (options.dump_loop)
 921         dumpEbbsToFileExt (DUMP_LOOPG, ebbs, count);
 922
 923       /* if loop optimizations caused a change then do
 924          dead code elimination once more : this will
 925          get rid of the extra assignments to the induction
 926          variables created during loop optimizations */
 927       killDeadCode (ebbs, saveCount);
 928
 929       if (options.dump_loop)
 930         dumpEbbsToFileExt (DUMP_LOOPD, ebbs, count);
 931
 932     }
 933
 934   /* sort it back by block number */
 935   qsort (ebbs, saveCount, sizeof (eBBlock *), bbNumCompare);
 936
 937   if (!options.lessPedantic) {
 938     // this is a good place to check missing return values
 939     if (currFunc) {
 940       // the user is on his own with naked functions...
 941       if (!IS_VOID(currFunc->etype)
 942        && !FUNC_ISNAKED(currFunc->type)) {
 943         eBBlock *bp;
 944         // make sure all predecessors of the last block end in a return
 945         for (bp=setFirstItem(ebbs[saveCount-1]->predList);
 946              bp;
 947              bp=setNextItem(ebbs[saveCount-1]->predList)) {
 948           if (bp->ech->op != RETURN) {
 949             werror (W_VOID_FUNC, currFunc->name);
 950           }
 951         }
 952       }
 953     }
 954   }
 955
 956   /* if cyclomatic info requested then print it */
 957   if (options.cyclomatic)
 958     printCyclomatic (ebbs, saveCount);
 959
 960   /* convert operations with support routines
 961      written in C to function calls : Iam doing
 962      this at this point since I want all the
 963      operations to be as they are for optimzations */
 964   convertToFcall (ebbs, count);
 965
 966   /* compute the live ranges */
 967   computeLiveRanges (ebbs, count);
 968
 969   if (options.dump_range)
 970     dumpEbbsToFileExt (DUMP_RANGE, ebbs, count);
 971
 972   /* Now that we have the live ranges, discard parameter
 973    * receives for unused parameters.
 974    */
 975   discardDeadParamReceives (ebbs, count);
 976
 977   /* allocate registers & generate code */
 978   port->assignRegisters (ebbs, count);
 979
 980   /* throw away blocks */
 981   setToNull ((void **) &graphEdges);
 982   ebbs = NULL;
 983
 984   return NULL;
 985 }
 986
 987
 988 /* (add-hook 'c-mode-hook (lambda () (setq c-basic-offset 4))) */