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

   1 /*-------------------------------------------------------------------------
   2
   3   SDCCicode.c - intermediate code generation etc.
   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 /* global variables       */
  30
  31 set *iCodeChain = NULL ;
  32 int iTempNum = 0;
  33 int iTempLblNum = 0;
  34 int operandKey = 0 ;
  35 int iCodeKey = 0;
  36 char *filename ;
  37 int lineno ;
  38 int block;
  39 int scopeLevel;
  40 int lvaluereq;
  41
  42 symbol *returnLabel ; /* function return label */
  43 symbol *entryLabel  ; /* function entry  label */
  44 /*-----------------------------------------------------------------*/
  45 /* forward definition of some functions */
  46 operand *geniCodeDivision (operand *,operand *);
  47 operand *geniCodeAssign   (operand *,operand *,int);
  48 operand *geniCodeArray (operand *,operand *);
  49 operand *geniCodeArray2Ptr (operand *);
  50 operand *geniCodeRValue (operand *, bool );
  51 operand *geniCodeDerefPtr (operand *);
  52
  53 #define PRINTFUNC(x) void x (FILE *of, iCode *ic, char *s)
  54 /* forward definition of print functions */
  55 PRINTFUNC(picGetValueAtAddr);
  56 PRINTFUNC(picSetValueAtAddr);
  57 PRINTFUNC(picAddrOf);
  58 PRINTFUNC(picGeneric);
  59 PRINTFUNC(picGenericOne);
  60 PRINTFUNC(picCast);
  61 PRINTFUNC(picAssign);
  62 PRINTFUNC(picLabel);
  63 PRINTFUNC(picGoto);
  64 PRINTFUNC(picIfx);
  65 PRINTFUNC(picJumpTable);
  66 PRINTFUNC(picInline);
  67 PRINTFUNC(picReceive);
  68
  69 iCodeTable codeTable[] = {
  70   { '!'                 ,  "not", picGenericOne    , NULL },
  71   { '~'                 ,  "~"  , picGenericOne    , NULL },
  72   { RRC                 ,  "rrc", picGenericOne    , NULL },
  73   { RLC                 ,  "rlc", picGenericOne    , NULL },
  74   { GETHBIT             ,"ghbit", picGenericOne    , NULL },
  75   { UNARYMINUS          ,  "-"  , picGenericOne    , NULL },
  76   { IPUSH               ,  "push",picGenericOne    , NULL },
  77   { IPOP                ,  "pop", picGenericOne    , NULL },
  78   { CALL                ,  "call",picGenericOne    , NULL },
  79   { PCALL               , "pcall",picGenericOne    , NULL },
  80   { FUNCTION            , "proc", picGenericOne    , NULL },
  81   { ENDFUNCTION         ,"eproc", picGenericOne    , NULL },
  82   { RETURN              ,  "ret", picGenericOne    , NULL },
  83   { '+'                 ,  "+"  , picGeneric       , NULL },
  84   { '-'                 ,  "-"  , picGeneric       , NULL },
  85   { '*'                 ,  "*"  , picGeneric       , NULL },
  86   { '/'                 ,  "/"  , picGeneric       , NULL },
  87   { '%'                 ,  "%"  , picGeneric       , NULL },
  88   { '>'                 ,  ">"  , picGeneric       , NULL },
  89   { '<'                 ,  "<"  , picGeneric       , NULL },
  90   { LE_OP               ,  "<=" , picGeneric       , NULL },
  91   { GE_OP               ,  ">=" , picGeneric       , NULL },
  92   { EQ_OP               ,  "==" , picGeneric       , NULL },
  93   { NE_OP               ,  "!=" , picGeneric       , NULL },
  94   { AND_OP              ,  "&&" , picGeneric       , NULL },
  95   { OR_OP               ,  "||" , picGeneric       , NULL },
  96   { '^'                 ,  "^"  , picGeneric       , NULL },
  97   { '|'                 ,  "|"  , picGeneric       , NULL },
  98   { BITWISEAND          ,  "&"  , picGeneric       , NULL },
  99   { LEFT_OP             ,  "<<" , picGeneric       , NULL },
 100   { RIGHT_OP            ,  ">>" , picGeneric       , NULL },
 101   { GET_VALUE_AT_ADDRESS,  "@"  , picGetValueAtAddr, NULL },
 102   { ADDRESS_OF          ,  "&"  , picAddrOf        , NULL },
 103   { CAST                ,  "<>" , picCast          , NULL },
 104   { '='                 ,  ":=" , picAssign        , NULL },
 105   { LABEL               ,  ""   , picLabel         , NULL },
 106   { GOTO                ,  ""   , picGoto          , NULL },
 107   { JUMPTABLE           ,"jtab" , picJumpTable     , NULL },
 108   { IFX                 ,  "if" , picIfx           , NULL },
 109   { INLINEASM           , ""    , picInline        , NULL },
 110   { RECEIVE             , "recv", picReceive       , NULL },
 111   { SEND                , "send", picGenericOne    , NULL }
 112 };
 113
 114
 115 /*-----------------------------------------------------------------*/
 116 /* operandName - returns the name of the operand                   */
 117 /*-----------------------------------------------------------------*/
 118 int printOperand (operand *op, FILE *file)
 119 {
 120     sym_link *opetype;
 121     int pnl = 0;
 122
 123     if (!op)
 124   return 1;
 125
 126     if (!file) {
 127   file = stdout;
 128   pnl = 1;
 129     }
 130     switch (op->type) {
 131
 132     case VALUE:
 133   opetype = getSpec (operandType(op));
 134   if (SPEC_NOUN(opetype) == V_FLOAT)
 135       fprintf (file,"%g {", SPEC_CVAL(opetype).v_float);
 136   else
 137       fprintf (file,"0x%x {",(int) floatFromVal(op->operand.valOperand));
 138   printTypeChain(operandType(op),file);
 139   fprintf(file,"}");
 140   break;
 141
 142     case SYMBOL :
 143 #define REGA 1
 144 #ifdef REGA
 145   fprintf (file,"%s [k%d lr%d:%d so:%d]{ ia%d re%d rm%d}",/*{ar%d rm%d ru%d p%d a%d u%d i%d au%d k%d ks%d}"  ,*/
 146      (OP_SYMBOL(op)->rname[0] ? OP_SYMBOL(op)->rname : OP_SYMBOL(op)->name),
 147      op->key,
 148      OP_LIVEFROM(op),OP_LIVETO(op),
 149      OP_SYMBOL(op)->stack,
 150      op->isaddr, OP_SYMBOL(op)->isreqv,OP_SYMBOL(op)->remat
 151      );
 152   {
 153       fprintf(file,"{"); printTypeChain(operandType(op),file);
 154       if (SPIL_LOC(op) && IS_ITEMP(op))
 155     fprintf(file,"}{ sir@ %s",SPIL_LOC(op)->rname);
 156       fprintf(file,"}");
 157
 158   }
 159
 160   /* if assigned to registers */
 161   if (OP_SYMBOL(op)->nRegs) {
 162       if (OP_SYMBOL(op)->isspilt) {
 163     if (!OP_SYMBOL(op)->remat)
 164         if (OP_SYMBOL(op)->usl.spillLoc)
 165       fprintf(file,"[%s]",(OP_SYMBOL(op)->usl.spillLoc->rname[0] ?
 166                OP_SYMBOL(op)->usl.spillLoc->rname :
 167                OP_SYMBOL(op)->usl.spillLoc->name));
 168         else
 169       fprintf(file,"[err]");
 170     else
 171         fprintf(file,"[remat]");
 172       }
 173       else {
 174     int i;
 175     fprintf(file,"[");
 176     for(i=0;i<OP_SYMBOL(op)->nRegs;i++)
 177         fprintf(file,"%s ", port->getRegName(OP_SYMBOL(op)->regs[i]));
 178     fprintf(file,"]");
 179       }
 180   }
 181 #else
 182   fprintf(file,"%s",(OP_SYMBOL(op)->rname[0] ?
 183          OP_SYMBOL(op)->rname : OP_SYMBOL(op)->name));
 184   /* if assigned to registers */
 185   if (OP_SYMBOL(op)->nRegs && !OP_SYMBOL(op)->isspilt) {
 186       int i;
 187       fprintf(file,"[");
 188       for(i=0;i<OP_SYMBOL(op)->nRegs;i++)
 189     fprintf(file,"%s ",(OP_SYMBOL(op)->regs[i] ?
 190             OP_SYMBOL(op)->regs[i]->name :
 191             "err"));
 192       fprintf(file,"]");
 193   }
 194 #endif
 195   break ;
 196
 197     case TYPE:
 198   fprintf(file,"(");
 199   printTypeChain(op->operand.typeOperand,file);
 200   fprintf(file,")");
 201   break;
 202     }
 203
 204     if (pnl)
 205   fprintf(file,"\n");
 206     return 0;
 207 }
 208
 209
 210 /*-----------------------------------------------------------------*/
 211 /*                    print functions                              */
 212 /*-----------------------------------------------------------------*/
 213 PRINTFUNC(picGetValueAtAddr)
 214 {
 215     fprintf(of,"\t");
 216     printOperand (IC_RESULT(ic),of);
 217     fprintf (of," = ");
 218     fprintf (of,"@[");
 219     printOperand (IC_LEFT(ic), of);
 220     fprintf (of,"]");
 221
 222     fprintf(of,"\n");
 223 }
 224
 225 PRINTFUNC(picSetValueAtAddr)
 226 {
 227     fprintf(of,"\t");
 228     fprintf(of,"*[");
 229     printOperand(IC_LEFT(ic),of);
 230     fprintf(of,"] = ");
 231     printOperand(IC_RIGHT(ic),of);
 232     fprintf (of,"\n");
 233 }
 234
 235 PRINTFUNC(picAddrOf)
 236 {
 237     fprintf(of,"\t");
 238     printOperand(IC_RESULT(ic),of);
 239     if (IS_ITEMP(IC_LEFT(ic)))
 240   fprintf(of," = ");
 241     else
 242   fprintf(of," = &[");
 243     printOperand(IC_LEFT(ic),of);
 244     if (IC_RIGHT(ic)) {
 245   if (IS_ITEMP(IC_LEFT(ic)))
 246       fprintf(of," offsetAdd ");
 247   else
 248       fprintf(of," , ");
 249   printOperand(IC_RIGHT(ic),of);
 250     }
 251     if (IS_ITEMP(IC_LEFT(ic)))
 252   fprintf (of,"\n");
 253     else
 254   fprintf (of,"]\n");
 255 }
 256
 257 PRINTFUNC(picJumpTable)
 258 {
 259     symbol *sym;
 260
 261     fprintf(of,"\t");
 262     fprintf(of,"%s\t",s);
 263     printOperand(IC_JTCOND(ic),of);
 264     fprintf(of,"\n");
 265     for ( sym = setFirstItem(IC_JTLABELS(ic)); sym;
 266     sym = setNextItem(IC_JTLABELS(ic)))
 267   fprintf(of,"\t\t\t%s\n",sym->name);
 268 }
 269
 270 PRINTFUNC(picGeneric)
 271 {
 272     fprintf(of,"\t");
 273     printOperand(IC_RESULT(ic),of);
 274     fprintf(of," = ");
 275     printOperand(IC_LEFT(ic),of);
 276     fprintf(of," %s ",s);
 277     printOperand(IC_RIGHT(ic),of);
 278     fprintf(of,"\n");
 279 }
 280
 281 PRINTFUNC(picGenericOne)
 282 {
 283     fprintf(of,"\t");
 284     if ( IC_RESULT(ic) ) {
 285   printOperand(IC_RESULT(ic),of);
 286   fprintf (of," = ");
 287     }
 288
 289     if (IC_LEFT(ic)) {
 290   fprintf (of,"%s ",s);
 291   printOperand(IC_LEFT(ic),of);
 292     }
 293
 294     if (! IC_RESULT(ic) && !IC_LEFT(ic))
 295   fprintf (of,s);
 296
 297     fprintf(of,"\n");
 298 }
 299
 300 PRINTFUNC(picCast)
 301 {
 302     fprintf(of,"\t");
 303     printOperand(IC_RESULT(ic),of);
 304     fprintf (of," = ");
 305     printOperand(IC_LEFT(ic),of);
 306     printOperand(IC_RIGHT(ic),of);
 307     fprintf(of,"\n");
 308 }
 309
 310
 311 PRINTFUNC(picAssign)
 312 {
 313     fprintf(of,"\t");
 314
 315     if (IC_RESULT(ic)->isaddr && IS_ITEMP(IC_RESULT(ic)))
 316   fprintf(of,"*(");
 317
 318     printOperand(IC_RESULT(ic),of);
 319
 320     if (IC_RESULT(ic)->isaddr && IS_ITEMP(IC_RESULT(ic)))
 321   fprintf(of,")");
 322
 323     fprintf(of," %s ", s);
 324     printOperand (IC_RIGHT(ic),of);
 325
 326     fprintf(of,"\n");
 327 }
 328
 329 PRINTFUNC(picLabel)
 330 {
 331     fprintf(of," %s($%d) :\n",IC_LABEL(ic)->name,IC_LABEL(ic)->key);
 332 }
 333
 334 PRINTFUNC(picGoto)
 335 {
 336    fprintf(of,"\t");
 337    fprintf (of," goto %s($%d)\n", IC_LABEL(ic)->name,IC_LABEL(ic)->key);
 338 }
 339
 340 PRINTFUNC(picIfx)
 341 {
 342     fprintf(of,"\t");
 343     fprintf (of,"if ");
 344     printOperand(IC_COND(ic),of);
 345
 346     if ( ! IC_TRUE(ic) )
 347   fprintf (of," == 0 goto %s($%d)\n",IC_FALSE(ic)->name,IC_FALSE(ic)->key);
 348     else {
 349   fprintf (of," != 0 goto %s($%d)\n",IC_TRUE(ic)->name,IC_TRUE(ic)->key);
 350   if (IC_FALSE(ic))
 351       fprintf (of,"\tzzgoto %s\n",IC_FALSE(ic)->name);
 352     }
 353 }
 354
 355 PRINTFUNC(picInline)
 356 {
 357     fprintf(of,"%s",IC_INLINE(ic));
 358 }
 359
 360 PRINTFUNC(picReceive)
 361 {
 362     printOperand(IC_RESULT(ic),of);
 363     fprintf(of," = %s ",s);
 364     printOperand(IC_LEFT(ic),of);
 365     fprintf(of,"\n");
 366 }
 367
 368 /*-----------------------------------------------------------------*/
 369 /* piCode - prints one iCode                                       */
 370 /*-----------------------------------------------------------------*/
 371 int piCode (void *item, FILE *of)
 372 {
 373     iCode *ic = item;
 374     iCodeTable *icTab ;
 375
 376     if (!of)
 377   of = stdout;
 378
 379     icTab = getTableEntry(ic->op) ;
 380     fprintf(stdout,"%s(%d:%d:%d:%d:%d)\t",
 381         ic->filename,ic->lineno,
 382         ic->seq,ic->key,ic->depth,ic->supportRtn);
 383     icTab->iCodePrint(of,ic,icTab->printName);
 384     return 1;
 385 }
 386
 387 /*-----------------------------------------------------------------*/
 388 /* printiCChain - prints intermediate code for humans              */
 389 /*-----------------------------------------------------------------*/
 390 void printiCChain (iCode *icChain, FILE *of)
 391 {
 392     iCode *loop ;
 393     iCodeTable *icTab ;
 394
 395     if (!of)
 396   of = stdout;
 397     for ( loop = icChain ; loop ; loop = loop->next ) {
 398   if ((icTab = getTableEntry (loop->op ))) {
 399       fprintf(of,"%s(%d:%d:%d:%d:%d)\t",
 400         loop->filename,loop->lineno,
 401         loop->seq,loop->key,loop->depth,loop->supportRtn);
 402
 403       icTab->iCodePrint (of,loop,icTab->printName);
 404   }
 405     }
 406 }
 407
 408
 409 /*-----------------------------------------------------------------*/
 410 /* newOperand - allocate, init & return a new iCode                */
 411 /*-----------------------------------------------------------------*/
 412 operand *newOperand ()
 413 {
 414     operand *op ;
 415
 416     op = Safe_calloc(1,sizeof(operand));
 417
 418     op->key = 0 ;
 419     return op;
 420 }
 421
 422 /*-----------------------------------------------------------------*/
 423 /* newiCode - create and return a new iCode entry initialised      */
 424 /*-----------------------------------------------------------------*/
 425 iCode *newiCode (int op, operand *left, operand *right)
 426 {
 427     iCode *ic ;
 428
 429     ic = Safe_calloc(1,sizeof(iCode));
 430
 431     ic->lineno = lineno ;
 432     ic->filename= filename ;
 433     ic->block = block;
 434     ic->level = scopeLevel;
 435     ic->op = op;
 436     ic->key= iCodeKey++ ;
 437     IC_LEFT(ic) = left;
 438     IC_RIGHT(ic)= right;
 439
 440     return ic;
 441 }
 442
 443 /*-----------------------------------------------------------------*/
 444 /* newiCode for conditional statements                             */
 445 /*-----------------------------------------------------------------*/
 446 iCode *newiCodeCondition (operand *condition,
 447         symbol  *trueLabel,
 448         symbol  *falseLabel )
 449 {
 450     iCode *ic ;
 451
 452     ic = newiCode(IFX,NULL,NULL);
 453     IC_COND(ic) = condition ;
 454     IC_TRUE(ic) = trueLabel ;
 455     IC_FALSE(ic) = falseLabel;
 456     return ic;
 457 }
 458
 459 /*-----------------------------------------------------------------*/
 460 /* newiCodeLabelGoto - unconditional goto statement| label stmnt   */
 461 /*-----------------------------------------------------------------*/
 462 iCode *newiCodeLabelGoto (int op, symbol *label)
 463 {
 464     iCode *ic ;
 465
 466     ic = newiCode(op,NULL,NULL);
 467     ic->op = op ;
 468     ic->argLabel.label = label ;
 469     IC_LEFT(ic) = NULL ;
 470     IC_RIGHT(ic) = NULL ;
 471     IC_RESULT(ic) = NULL ;
 472     return ic;
 473 }
 474
 475 /*-----------------------------------------------------------------*/
 476 /* newiTemp - allocate & return a newItemp Variable                */
 477 /*-----------------------------------------------------------------*/
 478 symbol *newiTemp (char *s)
 479 {
 480     symbol *itmp;
 481
 482     if (s)
 483   sprintf(buffer,"%s",s);
 484     else
 485   sprintf (buffer,"iTemp%d",iTempNum++);
 486     itmp =  newSymbol (buffer,1);
 487     strcpy(itmp->rname,itmp->name);
 488     itmp->isitmp = 1;
 489
 490     return itmp;
 491 }
 492
 493 /*-----------------------------------------------------------------*/
 494 /* newiTempLabel - creates a temp variable label                   */
 495 /*-----------------------------------------------------------------*/
 496 symbol *newiTempLabel (char *s)
 497 {
 498     symbol *itmplbl;
 499
 500     /* check if this alredy exists */
 501     if (s && (itmplbl = findSym(LabelTab, NULL, s)))
 502   return itmplbl ;
 503
 504     if (s)
 505   itmplbl = newSymbol(s,1);
 506     else {
 507   sprintf(buffer,"iTempLbl%d",iTempLblNum++);
 508   itmplbl = newSymbol(buffer,1);
 509     }
 510
 511     itmplbl->isitmp = 1;
 512     itmplbl->islbl = 1;
 513     itmplbl->key = labelKey++ ;
 514     addSym (LabelTab, itmplbl, itmplbl->name,0,0);
 515     return itmplbl ;
 516 }
 517
 518 /*-----------------------------------------------------------------*/
 519 /* newiTempPreheaderLabel - creates a new preheader label          */
 520 /*-----------------------------------------------------------------*/
 521 symbol *newiTempPreheaderLabel()
 522 {
 523     symbol *itmplbl ;
 524
 525     sprintf(buffer,"preHeaderLbl%d",iTempLblNum++);
 526     itmplbl = newSymbol(buffer,1);
 527
 528     itmplbl->isitmp = 1;
 529     itmplbl->islbl = 1;
 530     itmplbl->key = labelKey++ ;
 531     addSym (LabelTab, itmplbl, itmplbl->name,0,0);
 532     return itmplbl ;
 533 }
 534
 535
 536 /*-----------------------------------------------------------------*/
 537 /* initiCode - initialises some iCode related stuff                */
 538 /*-----------------------------------------------------------------*/
 539 void initiCode ()
 540 {
 541
 542 }
 543
 544 /*-----------------------------------------------------------------*/
 545 /* copyiCode - make a copy of the iCode given                      */
 546 /*-----------------------------------------------------------------*/
 547 iCode *copyiCode (iCode *ic)
 548 {
 549     iCode *nic = newiCode(ic->op,NULL,NULL);
 550
 551     nic->lineno = ic->lineno ;
 552     nic->filename= ic->filename ;
 553     nic->block = ic->block;
 554     nic->level = ic->level;
 555
 556     /* deal with the special cases first */
 557     switch (ic->op) {
 558     case IFX:
 559   IC_COND(nic) = operandFromOperand(IC_COND(ic));
 560   IC_TRUE(nic) = IC_TRUE(ic);
 561   IC_FALSE(nic)= IC_FALSE(ic);
 562   break;
 563
 564     case JUMPTABLE:
 565   IC_JTCOND(nic) = operandFromOperand(IC_JTCOND(ic));
 566   IC_JTLABELS(nic) = IC_JTLABELS(ic);
 567   break;
 568
 569     case CALL:
 570     case PCALL:
 571   IC_RESULT(nic) = operandFromOperand(IC_RESULT(ic));
 572   IC_LEFT(nic)   = operandFromOperand(IC_LEFT(ic));
 573   IC_ARGS(nic)   = IC_ARGS(ic);
 574   break;
 575
 576     case INLINEASM:
 577   IC_INLINE(nic) = IC_INLINE(ic);
 578   break;
 579
 580     default:
 581   IC_RESULT(nic) = operandFromOperand(IC_RESULT(ic));
 582   IC_LEFT(nic) = operandFromOperand(IC_LEFT(ic));
 583   IC_RIGHT(nic)= operandFromOperand(IC_RIGHT(ic));
 584     }
 585
 586     return nic;
 587 }
 588
 589 /*-----------------------------------------------------------------*/
 590 /* getTableEntry - gets the table entry for the given operator     */
 591 /*-----------------------------------------------------------------*/
 592 iCodeTable *getTableEntry (int oper )
 593 {
 594     int i ;
 595
 596     for ( i = 0 ; i < (sizeof(codeTable)/sizeof(iCodeTable)); i++ )
 597   if (oper == codeTable[i].icode)
 598       return &codeTable[i] ;
 599
 600     return NULL ;
 601 }
 602
 603 /*-----------------------------------------------------------------*/
 604 /* newiTempOperand - new intermediate temp operand                 */
 605 /*-----------------------------------------------------------------*/
 606 operand *newiTempOperand (sym_link *type, char throwType)
 607 {
 608     symbol *itmp;
 609     operand *op = newOperand();
 610     sym_link *etype;
 611
 612     op->type = SYMBOL ;
 613     itmp = newiTemp(NULL);
 614
 615     etype = getSpec(type);
 616
 617     if (IS_LITERAL(etype) )
 618   throwType = 0 ;
 619
 620     /* copy the type information */
 621     if (type)
 622   itmp->etype = getSpec (itmp->type = (throwType ? type :
 623                copyLinkChain(type)));
 624     if (IS_LITERAL(itmp->etype)) {
 625   SPEC_SCLS(itmp->etype) = S_REGISTER ;
 626   SPEC_OCLS(itmp->etype) = reg;
 627     }
 628
 629     op->operand.symOperand = itmp;
 630     op->key = itmp->key = ++operandKey ;
 631     return op;
 632 }
 633
 634 /*-----------------------------------------------------------------*/
 635 /* operandType - returns the type chain for an operand             */
 636 /*-----------------------------------------------------------------*/
 637 sym_link *operandType (operand *op)
 638 {
 639     /* depending on type of operand */
 640     switch (op->type) {
 641
 642     case VALUE :
 643   return op->operand.valOperand->type ;
 644
 645     case SYMBOL:
 646   return op->operand.symOperand->type ;
 647
 648     case TYPE :
 649   return op->operand.typeOperand ;
 650     default:
 651   werror (E_INTERNAL_ERROR,__FILE__,__LINE__,
 652     " operand type not known ");
 653   assert (0) ; /* should never come here */
 654   /*  Just to keep the compiler happy */
 655   return (sym_link *)0;
 656     }
 657 }
 658
 659 /*-----------------------------------------------------------------*/
 660 /* isParamterToCall - will return 1 if op is a parameter to args   */
 661 /*-----------------------------------------------------------------*/
 662 int isParameterToCall (value *args, operand *op)
 663 {
 664     value *tval = args ;
 665
 666     while (tval) {
 667   if (tval->sym &&
 668       isSymbolEqual(op->operand.symOperand,tval->sym))
 669       return 1;
 670   tval = tval->next ;
 671     }
 672     return 0;
 673 }
 674
 675 /*-----------------------------------------------------------------*/
 676 /* isOperandGlobal   - return 1 if operand is a global variable    */
 677 /*-----------------------------------------------------------------*/
 678 int isOperandGlobal ( operand *op )
 679 {
 680     if (!op)
 681   return 0;
 682
 683     if (IS_ITEMP(op))
 684   return 0;
 685
 686     if (op->type == SYMBOL &&
 687    (op->operand.symOperand->level == 0 ||
 688    IS_STATIC(op->operand.symOperand->etype) ||
 689    IS_EXTERN(op->operand.symOperand->etype))
 690     )
 691   return 1;
 692
 693     return 0;
 694 }
 695
 696 /*-----------------------------------------------------------------*/
 697 /* isOperandVolatile - return 1 if the operand is volatile         */
 698 /*-----------------------------------------------------------------*/
 699 int isOperandVolatile ( operand *op , bool chkTemp)
 700 {
 701     sym_link *optype ;
 702     sym_link *opetype ;
 703
 704     if (IS_ITEMP(op) && !chkTemp)
 705   return 0;
 706
 707     opetype = getSpec(optype = operandType(op));
 708
 709     if (IS_PTR(optype) && DCL_PTR_VOLATILE(optype))
 710   return 1;
 711
 712     if (IS_VOLATILE(opetype))
 713   return 1;
 714     return 0;
 715 }
 716
 717 /*-----------------------------------------------------------------*/
 718 /* isOperandLiteral - returns 1 if an operand contains a literal   */
 719 /*-----------------------------------------------------------------*/
 720 int isOperandLiteral ( operand *op )
 721 {
 722     sym_link *opetype ;
 723
 724     if (!op)
 725   return 0;
 726
 727     opetype = getSpec (operandType(op));
 728
 729     if (IS_LITERAL(opetype))
 730   return 1;
 731
 732     return 0;
 733 }
 734 /*-----------------------------------------------------------------*/
 735 /* isOperandInFarSpace - will return true if operand is in farSpace*/
 736 /*-----------------------------------------------------------------*/
 737 bool isOperandInFarSpace (operand *op)
 738 {
 739     sym_link *etype;
 740
 741     if (!op)
 742   return FALSE;
 743
 744     if (!IS_SYMOP(op))
 745   return FALSE ;
 746
 747     if (!IS_TRUE_SYMOP(op)) {
 748   if (SPIL_LOC(op))
 749       etype = SPIL_LOC(op)->etype;
 750   else
 751       return FALSE;
 752     }
 753     else
 754     {
 755       etype = getSpec(operandType(op));
 756     }
 757     return (IN_FARSPACE(SPEC_OCLS(etype)) ? TRUE : FALSE);
 758 }
 759
 760 /*-----------------------------------------------------------------*/
 761 /* isOperandOnStack - will return true if operand is on stack      */
 762 /*-----------------------------------------------------------------*/
 763 bool isOperandOnStack(operand *op)
 764 {
 765     sym_link *etype;
 766
 767     if (!op)
 768   return FALSE;
 769
 770     if (!IS_SYMOP(op))
 771   return FALSE ;
 772
 773     etype = getSpec(operandType(op));
 774
 775     return ((IN_STACK(etype)) ? TRUE : FALSE);
 776 }
 777
 778 /*-----------------------------------------------------------------*/
 779 /* operandLitValue - literal value of an operand                   */
 780 /*-----------------------------------------------------------------*/
 781 double operandLitValue ( operand *op )
 782 {
 783     assert(isOperandLiteral(op));
 784
 785     return floatFromVal(op->operand.valOperand);
 786 }
 787
 788 /*-----------------------------------------------------------------*/
 789 /* operandOperation - perforoms operations on operands             */
 790 /*-----------------------------------------------------------------*/
 791 operand *operandOperation (operand *left,operand *right,
 792          int op, sym_link *type)
 793 {
 794     operand *retval = (operand *)0;
 795
 796     assert(isOperandLiteral(left));
 797     if (right)
 798   assert(isOperandLiteral(right));
 799
 800     switch (op) {
 801     case '+' :
 802   retval =  operandFromValue (valCastLiteral(type,
 803                operandLitValue(left) +
 804                operandLitValue(right)));
 805   break ;
 806     case '-' :
 807   retval = operandFromValue(valCastLiteral(type,
 808              operandLitValue(left) -
 809              operandLitValue(right)));
 810   break;
 811     case '*':
 812   retval = operandFromValue(valCastLiteral(type,
 813              operandLitValue(left) *
 814              operandLitValue(right)));
 815   break;
 816     case '/':
 817   if ((unsigned long) operandLitValue(right) == 0){
 818       werror(E_DIVIDE_BY_ZERO);
 819       retval = right;
 820
 821   }
 822   else
 823       retval = operandFromValue (valCastLiteral(type,
 824                   operandLitValue(left) /
 825                   operandLitValue(right)));
 826   break;
 827     case '%':
 828   if ((unsigned long) operandLitValue(right) == 0){
 829       werror(E_DIVIDE_BY_ZERO);
 830       retval = right;
 831   }
 832   else
 833       retval = operandFromLit ((unsigned long) operandLitValue(left) %
 834              (unsigned long) operandLitValue(right));
 835   break;
 836     case LEFT_OP :
 837   retval = operandFromLit ((unsigned long) operandLitValue(left) <<
 838          (unsigned long) operandLitValue(right));
 839   break;
 840     case RIGHT_OP :
 841   retval = operandFromLit ((unsigned long) operandLitValue(left) >>
 842          (unsigned long) operandLitValue(right));
 843   break;
 844     case EQ_OP :
 845   retval = operandFromLit (operandLitValue(left) ==
 846          operandLitValue(right));
 847   break;
 848     case '<' :
 849   retval = operandFromLit (operandLitValue(left) <
 850          operandLitValue(right));
 851   break;
 852     case LE_OP :
 853   retval = operandFromLit (operandLitValue(left) <=
 854          operandLitValue(right));
 855   break;
 856     case NE_OP :
 857   retval = operandFromLit (operandLitValue(left) !=
 858          operandLitValue(right));
 859   break;
 860     case '>' :
 861   retval = operandFromLit (operandLitValue(left) >
 862          operandLitValue(right));
 863   break;
 864     case GE_OP :
 865   retval = operandFromLit (operandLitValue(left) >=
 866          operandLitValue(right));
 867   break;
 868     case BITWISEAND :
 869   retval = operandFromLit ((unsigned long) operandLitValue(left) &
 870          (unsigned long) operandLitValue(right));
 871   break;
 872     case '|' :
 873   retval = operandFromLit ((unsigned long) operandLitValue(left) |
 874          (unsigned long) operandLitValue(right));
 875   break;
 876     case '^' :
 877   retval = operandFromLit ((unsigned long) operandLitValue(left) ^
 878          (unsigned long) operandLitValue(right));
 879   break;
 880     case AND_OP:
 881   retval = operandFromLit (operandLitValue(left) &&
 882          operandLitValue(right));
 883   break;
 884     case OR_OP:
 885   retval = operandFromLit (operandLitValue(left) ||
 886          operandLitValue(right));
 887   break;
 888     case RRC:
 889   {
 890       long i = operandLitValue(left);
 891
 892       retval = operandFromLit ((i >> (getSize(operandType(left))*8 - 1)) |
 893              (i << 1));
 894   }
 895   break;
 896     case RLC:
 897   {
 898       long i = operandLitValue(left);
 899
 900       retval = operandFromLit ((i << (getSize(operandType(left))*8 - 1)) |
 901              (i >> 1));
 902   }
 903   break;
 904
 905     case UNARYMINUS:
 906   retval = operandFromLit(-1 * operandLitValue(left));
 907   break;
 908
 909     case '~':
 910   retval = operandFromLit(~ ((long) operandLitValue(left)));
 911   break;
 912
 913     case '!':
 914   retval = operandFromLit(! operandLitValue(left));
 915   break;
 916
 917     default :
 918   werror(E_INTERNAL_ERROR,__FILE__,__LINE__,
 919          " operandOperation invalid operator ");
 920   assert (0);
 921     }
 922
 923     return retval;
 924 }
 925
 926
 927 /*-----------------------------------------------------------------*/
 928 /* isOperandEqual - compares two operand & return 1 if they r =    */
 929 /*-----------------------------------------------------------------*/
 930 int isOperandEqual (operand *left, operand *right)
 931 {
 932     /* if the pointers are equal then they are equal */
 933     if ( left == right )
 934   return 1;
 935
 936     /* if either of them null then false */
 937     if ( !left || !right)
 938   return 0;
 939
 940     if (left->type != right->type)
 941   return 0;
 942
 943     if (IS_SYMOP(left) && IS_SYMOP(right))
 944   return left->key == right->key ;
 945
 946     /* if types are the same */
 947     switch (left->type) {
 948     case SYMBOL :
 949   return isSymbolEqual(left->operand.symOperand,
 950            right->operand.symOperand);
 951     case VALUE :
 952   return (floatFromVal(left->operand.valOperand) ==
 953     floatFromVal(right->operand.valOperand));
 954     case TYPE :
 955   if (checkType(left->operand.typeOperand,
 956           right->operand.typeOperand) == 1)
 957       return 1;
 958     }
 959
 960     return 0;
 961 }
 962
 963 /*-----------------------------------------------------------------*/
 964 /* isiCodeEqual - comapres two iCodes are returns true if yes      */
 965 /*-----------------------------------------------------------------*/
 966 int isiCodeEqual (iCode *left, iCode *right)
 967 {
 968     /* if the same pointer */
 969     if (left == right)
 970   return 1;
 971
 972     /* if either of them null */
 973     if (!left || !right)
 974   return 0;
 975
 976     /* if operand are the same */
 977     if ( left->op == right->op ) {
 978
 979   /* compare all the elements depending on type */
 980   if (left->op != IFX ) {
 981       if (!isOperandEqual(IC_LEFT(left),IC_LEFT(right)))
 982     return 0;
 983       if (!isOperandEqual(IC_RIGHT(left),IC_RIGHT(right)))
 984     return 0;
 985
 986   } else {
 987       if (!isOperandEqual(IC_COND(left),IC_COND(right)))
 988     return 0;
 989       if (!isSymbolEqual (IC_TRUE(left),IC_TRUE(right)))
 990     return 0;
 991       if (!isSymbolEqual(IC_FALSE(left),IC_FALSE(right)))
 992     return 0;
 993   }
 994   return 1;
 995     }
 996     return 0;
 997 }
 998
 999 /*-----------------------------------------------------------------*/
1000 /* newiTempFromOp - create a temp Operand with same attributes     */
1001 /*-----------------------------------------------------------------*/
1002 operand *newiTempFromOp (operand *op)
1003 {
1004     operand *nop;
1005
1006     if (!op)
1007   return NULL;
1008
1009     if (!IS_ITEMP(op))
1010   return op;
1011
1012     nop = newiTempOperand(operandType(op),TRUE);
1013     nop->isaddr = op->isaddr ;
1014     nop->isvolatile = op->isvolatile ;
1015     nop->isGlobal = op->isGlobal ;
1016     nop->isLiteral= op->isLiteral ;
1017     nop->noSpilLoc= op->noSpilLoc;
1018     nop->usesDefs = op->usesDefs;
1019     nop->isParm = op->isParm;
1020     nop->parmBytes = op->parmBytes;
1021     return nop;
1022 }
1023
1024 /*-----------------------------------------------------------------*/
1025 /* operand from operand - creates an operand holder for the type   */
1026 /*-----------------------------------------------------------------*/
1027 operand *operandFromOperand (operand *op)
1028 {
1029     operand *nop ;
1030
1031     if (!op)
1032   return NULL;
1033     nop = newOperand();
1034     nop->type = op->type;
1035     nop->isaddr = op->isaddr ;
1036     nop->key = op->key ;
1037     nop->isvolatile = op->isvolatile ;
1038     nop->isGlobal = op->isGlobal ;
1039     nop->isLiteral= op->isLiteral ;
1040     nop->noSpilLoc= op->noSpilLoc;
1041     nop->usesDefs = op->usesDefs;
1042     nop->isParm = op->isParm;
1043     nop->parmBytes = op->parmBytes;
1044
1045     switch (nop->type) {
1046     case SYMBOL :
1047   nop->operand.symOperand = op->operand.symOperand ;
1048   break;
1049     case VALUE :
1050   nop->operand.valOperand = op->operand.valOperand;
1051   break;
1052     case TYPE :
1053   nop->operand.typeOperand = op->operand.typeOperand ;
1054   break ;
1055     }
1056
1057     return nop;
1058 }
1059
1060 /*-----------------------------------------------------------------*/
1061 /* opFromOpWithDU - makes a copy of the operand and DU chains      */
1062 /*-----------------------------------------------------------------*/
1063 operand *opFromOpWithDU (operand *op, bitVect *defs, bitVect *uses)
1064 {
1065     operand *nop = operandFromOperand(op);
1066
1067     if (nop->type == SYMBOL) {
1068   OP_SYMBOL(nop)->defs = bitVectCopy(defs);
1069   OP_SYMBOL(nop)->uses = bitVectCopy(uses);
1070     }
1071
1072     return nop;
1073 }
1074
1075 /*-----------------------------------------------------------------*/
1076 /* operandFromSymbol - creates an operand from a symbol            */
1077 /*-----------------------------------------------------------------*/
1078 operand *operandFromSymbol (symbol *sym)
1079 {
1080     operand *op ;
1081     iCode *ic ;
1082     int ok =1 ;
1083     /* if the symbol's type is a literal */
1084     /* then it is an enumerator type     */
1085     if (IS_LITERAL(sym->etype) && SPEC_ENUM(sym->etype))
1086   return operandFromValue (valFromType(sym->etype));
1087
1088     if (!sym->key)
1089   sym->key = ++operandKey ;
1090
1091     /* if this an implicit variable, means struct/union */
1092     /* member so just return it                         */
1093     if (sym->implicit || IS_FUNC(sym->type)) {
1094   op = newOperand();
1095   op->type = SYMBOL ;
1096   op->operand.symOperand = sym;
1097   op->key = sym->key ;
1098   op->isvolatile = isOperandVolatile(op,TRUE);
1099   op->isGlobal   = isOperandGlobal(op);
1100   op->parmBytes  = sym->argStack;
1101   return op;
1102     }
1103
1104     /* under the following conditions create a
1105        register equivalent for a local symbol */
1106     if (sym->level && sym->etype && SPEC_OCLS(sym->etype) &&
1107   (IN_FARSPACE(SPEC_OCLS(sym->etype)) && (!IS_DS390_PORT)) &&
1108   options.stackAuto == 0)
1109   ok =0;
1110
1111     if (!IS_AGGREGATE(sym->type) &&     /* not an aggregate */
1112   !IS_FUNC(sym->type)      &&     /* not a function   */
1113   !sym->_isparm            &&     /* not a parameter  */
1114   sym->level               &&     /* is a local variable */
1115   !sym->addrtaken          &&     /* whose address has not been taken */
1116   !sym->reqv               &&     /* does not already have a register euivalence */
1117   !IS_VOLATILE(sym->etype) &&     /* not declared as volatile */
1118   !IS_STATIC(sym->etype)   &&     /* and not declared static  */
1119   !sym->islbl              &&     /* not a label */
1120   ok                       &&     /* farspace check */
1121   !IS_BITVAR(sym->etype)          /* not a bit variable */
1122   ) {
1123
1124   /* we will use it after all optimizations
1125      and before liveRange calculation */
1126   sym->reqv = newiTempOperand(sym->type,0);
1127   sym->reqv->key = sym->key ;
1128   OP_SYMBOL(sym->reqv)->key = sym->key;
1129   OP_SYMBOL(sym->reqv)->isreqv = 1;
1130   OP_SYMBOL(sym->reqv)->islocal = 1;
1131   SPIL_LOC(sym->reqv) = sym;
1132     }
1133
1134     if (!IS_AGGREGATE(sym->type)) {
1135   op = newOperand();
1136   op->type = SYMBOL;
1137   op->operand.symOperand = sym;
1138   op->isaddr = 1;
1139   op->key = sym->key;
1140   op->isvolatile = isOperandVolatile(op,TRUE);
1141   op->isGlobal   = isOperandGlobal(op);
1142   op->isPtr = IS_PTR(operandType(op));
1143   op->isParm = sym->_isparm ;
1144   return op;
1145     }
1146
1147     /* create :-                     */
1148     /*    itemp = &[_symbol]         */
1149
1150     ic = newiCode(ADDRESS_OF,newOperand(),NULL);
1151     IC_LEFT(ic)->type = SYMBOL ;
1152     IC_LEFT(ic)->operand.symOperand = sym ;
1153     IC_LEFT(ic)->key = sym->key;
1154     (IC_LEFT(ic))->isvolatile = isOperandVolatile(IC_LEFT(ic),TRUE);
1155     (IC_LEFT(ic))->isGlobal   = isOperandGlobal(IC_LEFT(ic));
1156     IC_LEFT(ic)->isPtr = IS_PTR(operandType(IC_LEFT(ic)));
1157
1158     /* create result */
1159     IC_RESULT(ic) = newiTempOperand(sym->type,0);
1160     if (IS_ARRAY(sym->type)) {
1161   IC_RESULT(ic) = geniCodeArray2Ptr (IC_RESULT(ic));
1162   IC_RESULT(ic)->isaddr = 0;
1163     } else
1164   IC_RESULT(ic)->isaddr = (!IS_AGGREGATE(sym->type));
1165
1166     IC_RESULT(ic)->operand.symOperand->args = sym->args;
1167
1168     ADDTOCHAIN(ic);
1169
1170     return IC_RESULT(ic) ;
1171 }
1172
1173 /*-----------------------------------------------------------------*/
1174 /* operandFromValue - creates an operand from value                */
1175 /*-----------------------------------------------------------------*/
1176 operand *operandFromValue (value *val)
1177 {
1178     operand *op ;
1179
1180     /* if this is a symbol then do the symbol thing */
1181     if (val->sym)
1182   return operandFromSymbol (val->sym);
1183
1184     /* this is not a symbol */
1185     op = newOperand();
1186     op->type = VALUE ;
1187     op->operand.valOperand = val ;
1188     op->isLiteral = isOperandLiteral(op);
1189     return op;
1190 }
1191
1192 /*-----------------------------------------------------------------*/
1193 /* operandFromLink - operand from typeChain                        */
1194 /*-----------------------------------------------------------------*/
1195 operand *operandFromLink (sym_link *type)
1196 {
1197     operand *op ;
1198
1199     /* operand from sym_link */
1200     if ( ! type )
1201   return NULL ;
1202
1203     op = newOperand();
1204     op->type = TYPE ;
1205     op->operand.typeOperand = copyLinkChain(type);
1206     return op;
1207 }
1208
1209 /*-----------------------------------------------------------------*/
1210 /* operandFromLit - makes an operand from a literal value          */
1211 /*-----------------------------------------------------------------*/
1212 operand *operandFromLit ( float i)
1213 {
1214     return operandFromValue (valueFromLit (i));
1215 }
1216
1217 /*-----------------------------------------------------------------*/
1218 /* operandFromAst - creates an operand from an ast                 */
1219 /*-----------------------------------------------------------------*/
1220 operand *operandFromAst ( ast *tree )
1221 {
1222
1223     if (! tree )
1224   return NULL ;
1225
1226     /* depending on type do */
1227     switch (tree->type ) {
1228     case EX_OP :
1229   return ast2iCode (tree) ;
1230   break ;
1231
1232     case EX_VALUE :
1233   return operandFromValue(tree->opval.val) ;
1234   break ;
1235
1236     case EX_LINK :
1237   return operandFromLink (tree->opval.lnk) ;
1238     }
1239
1240     assert(0);
1241     /*  Just to keep the comiler happy */
1242     return (operand *)0;
1243 }
1244
1245 /*-----------------------------------------------------------------*/
1246 /* setOperandType - sets the operand's type to the given type      */
1247 /*-----------------------------------------------------------------*/
1248 void setOperandType (operand *op, sym_link *type)
1249 {
1250     /* depending on the type of operand */
1251     switch (op->type) {
1252
1253     case VALUE :
1254   op->operand.valOperand->etype =
1255       getSpec( op->operand.valOperand->type =
1256          copyLinkChain (type )) ;
1257   return ;
1258
1259     case SYMBOL :
1260   if (op->operand.symOperand->isitmp )
1261       op->operand.symOperand->etype =
1262     getSpec( op->operand.symOperand->type =
1263        copyLinkChain (type )) ;
1264   else
1265       werror (E_INTERNAL_ERROR,__FILE__,__LINE__,
1266         "attempt to modify type of source");
1267   return;
1268
1269     case TYPE:
1270   op->operand.typeOperand = copyLinkChain (type);
1271   return ;
1272     }
1273
1274 }
1275
1276 /*-----------------------------------------------------------------*/
1277 /* perform "usual unary conversions"                               */
1278 /*-----------------------------------------------------------------*/
1279 operand *usualUnaryConversions(operand *op)
1280 {
1281     if (IS_INTEGRAL(operandType(op)))
1282     {
1283         if (getSize(operandType(op)) < INTSIZE)
1284         {
1285             /* Widen to int. */
1286       return geniCodeCast(INTTYPE,op,TRUE);
1287         }
1288     }
1289     return op;
1290 }
1291
1292 /*-----------------------------------------------------------------*/
1293 /* perform "usual binary conversions"                              */
1294 /*-----------------------------------------------------------------*/
1295 sym_link * usualBinaryConversions(operand **op1, operand **op2)
1296 {
1297     if (!options.ANSIint)
1298     {
1299       /* "Classic" SDCC behavior. */
1300       sym_link *ctype;
1301       sym_link *rtype = operandType(*op2);
1302       sym_link *ltype = operandType(*op1);
1303
1304       ctype = computeType(ltype,rtype);
1305       *op1 = geniCodeCast(ctype,*op1,TRUE);
1306       *op2= geniCodeCast(ctype,*op2,TRUE);
1307
1308       return ctype;
1309     }
1310
1311     *op1 = usualUnaryConversions(*op1);
1312     *op2 = usualUnaryConversions(*op2);
1313
1314     /* Try to make the two operands of the same type, following
1315      * the "usual binary conversions" promotion rules.
1316      *
1317      * NB: floating point types are not yet properly handled; we
1318      * follow the "classic" behavior.
1319      */
1320
1321     if (IS_FLOAT(operandType(*op1)) || IS_FLOAT(operandType(*op2)))
1322     {
1323   return newFloatLink();
1324     }
1325
1326     if (!IS_INTEGRAL(operandType(*op1)) || !IS_INTEGRAL(operandType(*op2)))
1327     {
1328         /* if either is not an integer type, we're done. */
1329         return copyLinkChain(operandType(*op1)); /* Punt! we should never get here. */
1330     }
1331
1332     /* If either is an unsigned long, make sure both are. */
1333     if (SPEC_USIGN(operandType(*op1)) && IS_LONG(operandType(*op1)))
1334     {
1335         if (!SPEC_USIGN(operandType(*op2)) || !IS_LONG(operandType(*op2)))
1336         {
1337              *op2 = geniCodeCast(ULONGTYPE,*op2,TRUE);
1338         }
1339         return copyLinkChain(operandType(*op1));
1340     }
1341
1342     if (SPEC_USIGN(operandType(*op2)) && IS_LONG(operandType(*op2)))
1343     {
1344         if (!SPEC_USIGN(operandType(*op1)) || !IS_LONG(operandType(*op1)))
1345         {
1346              *op1 = geniCodeCast(ULONGTYPE,*op1,TRUE);
1347         }
1348         return copyLinkChain(operandType(*op2));
1349     }
1350
1351     /* Next, if one is long and the other is int (signed or un),
1352      * cast both to long.
1353      *
1354      * Note that because in our environment a long can hold all
1355      * the values of an unsigned int, the "long/unsigned int" pair
1356      * in the ANSI conversion table is unnecessary; this test
1357      * handles that case implicitly.
1358      */
1359     if (IS_LONG(operandType(*op1)))
1360     {
1361         /* NB: because of the unary conversions, op2 cannot
1362          * be smaller than int. Therefore, if it is not
1363          * long, it is a regular int.
1364          */
1365         if (!IS_LONG(operandType(*op2)))
1366         {
1367              *op2 = geniCodeCast(LONGTYPE,*op2,TRUE);
1368         }
1369         return copyLinkChain(operandType(*op1));
1370     }
1371
1372     if (IS_LONG(operandType(*op2)))
1373     {
1374         /* NB: because of the unary conversions, op2 cannot
1375          * be smaller than int. Therefore, if it is not
1376          * long, it is a regular int.
1377          */
1378         if (!IS_LONG(operandType(*op1)))
1379         {
1380              *op1 = geniCodeCast(LONGTYPE,*op1,TRUE);
1381         }
1382         return copyLinkChain(operandType(*op2));
1383     }
1384
1385     /* All right, neither is long; they must both be integers.
1386      *
1387      * Only remaining issue is signed vs. unsigned; if one is unsigned
1388      * and the other isn't, convert both to unsigned.
1389      */
1390     if (SPEC_USIGN(operandType(*op1)))
1391     {
1392         if (!SPEC_USIGN(operandType(*op2)))
1393         {
1394              *op2 = geniCodeCast(UINTTYPE,*op2,TRUE);
1395         }
1396         return copyLinkChain(operandType(*op1));
1397     }
1398
1399     if (SPEC_USIGN(operandType(*op2)))
1400     {
1401         if (!SPEC_USIGN(operandType(*op1)))
1402         {
1403              *op1 = geniCodeCast(UINTTYPE,*op1,TRUE);
1404         }
1405         return copyLinkChain(operandType(*op2));
1406     }
1407
1408     /* Done! */
1409     return copyLinkChain(operandType(*op1));
1410 }
1411
1412
1413 /*-----------------------------------------------------------------*/
1414 /* geniCodeValueAtAddress - generate intermeditate code for value  */
1415 /*                          at address                             */
1416 /*-----------------------------------------------------------------*/
1417 operand *geniCodeRValue (operand *op, bool force)
1418 {
1419     iCode *ic ;
1420     sym_link *type = operandType(op);
1421     sym_link *etype= getSpec(type);
1422
1423     /* if this is an array & already */
1424     /* an address then return this   */
1425     if (IS_AGGREGATE(type) ||
1426   (IS_PTR(type) && !force && !op->isaddr))
1427   return operandFromOperand(op);
1428
1429     /* if this is not an address then must be */
1430     /* rvalue already so return this one      */
1431     if (!op->isaddr)
1432   return op ;
1433
1434     /* if this is not a temp symbol then */
1435     if (!IS_ITEMP(op) &&
1436   !force &&
1437   !IN_FARSPACE(SPEC_OCLS(etype))) {
1438   op = operandFromOperand(op);
1439   op->isaddr = 0;
1440   return op;
1441     }
1442
1443     if (IS_SPEC(type) &&
1444   IS_TRUE_SYMOP(op) &&
1445   (!IN_FARSPACE(SPEC_OCLS(etype)) || IS_DS390_PORT)) {
1446   op = operandFromOperand(op);
1447   op->isaddr = 0;
1448   return op;
1449     }
1450
1451     ic = newiCode(GET_VALUE_AT_ADDRESS,op,NULL);
1452     if (IS_PTR(type) && op->isaddr && force)
1453   type = type->next;
1454
1455     type = copyLinkChain(type);
1456
1457     IC_RESULT(ic) = newiTempOperand (type,1);
1458     IC_RESULT(ic)->isaddr = 0;
1459
1460 /*     ic->supportRtn = ((IS_GENPTR(type) | op->isGptr) & op->isaddr); */
1461
1462     /* if the right is a symbol */
1463     if (op->type == SYMBOL)
1464   IC_RESULT(ic)->operand.symOperand->args =
1465       op->operand.symOperand->args ;
1466     ADDTOCHAIN(ic);
1467
1468     return IC_RESULT(ic) ;
1469 }
1470
1471 /*-----------------------------------------------------------------*/
1472 /* geniCodeCast - changes the value from one type to another       */
1473 /*-----------------------------------------------------------------*/
1474 operand *geniCodeCast (sym_link *type, operand *op, bool implicit)
1475 {
1476     iCode *ic ;
1477     sym_link *optype ;
1478     sym_link *opetype = getSpec(optype = operandType(op));
1479     sym_link *restype ;
1480
1481     /* one of them has size zero then error */
1482     if (IS_VOID(optype)) {
1483   werror(E_CAST_ZERO);
1484   return op;
1485     }
1486
1487     /* if the operand is already the desired type then do nothing */
1488     if ( checkType (type,optype) == 1)
1489   return op;
1490
1491     /* if this is a literal then just change the type & return */
1492     if (IS_LITERAL(opetype) && op->type == VALUE && !IS_PTR(type) && !IS_PTR(optype))
1493   return operandFromValue(valCastLiteral(type,
1494                  operandLitValue(op)));
1495
1496     /* if casting to some pointer type &&
1497        the destination is not a generic pointer
1498        then give a warning : (only for implicit casts)*/
1499     if (IS_PTR(optype) && implicit &&
1500   (DCL_TYPE(optype) != DCL_TYPE(type)) &&
1501   !IS_GENPTR(type)) {
1502   werror(E_INCOMPAT_CAST);
1503   werror(E_CONTINUE,"from type '");
1504   printTypeChain(optype,stderr);fprintf(stderr,"' to type '");
1505   printTypeChain(type,stderr);fprintf(stderr,"'\n");
1506     }
1507
1508     /* if they are the same size create an assignment */
1509     if (getSize(type) == getSize(optype) &&
1510   !IS_BITFIELD(type)               &&
1511   !IS_FLOAT(type)                  &&
1512   !IS_FLOAT(optype)                &&
1513   ((IS_SPEC(type) && IS_SPEC(optype)) ||
1514    (!IS_SPEC(type) && !IS_SPEC(optype)))) {
1515
1516   ic = newiCode('=',NULL,op);
1517   IC_RESULT(ic) = newiTempOperand(type,0);
1518    SPIL_LOC(IC_RESULT(ic))  =
1519        (IS_TRUE_SYMOP(op) ? OP_SYMBOL(op) : NULL);
1520   IC_RESULT(ic)->isaddr = 0;
1521     } else {
1522   ic = newiCode(CAST,operandFromLink(type),
1523           geniCodeRValue(op,FALSE));
1524
1525   IC_RESULT(ic)= newiTempOperand(type,0);
1526     }
1527
1528     /* preserve the storage class & output class */
1529     /* of the original variable                  */
1530     restype = getSpec(operandType(IC_RESULT(ic)));
1531     SPEC_SCLS(restype) = SPEC_SCLS(opetype);
1532     SPEC_OCLS(restype) = SPEC_OCLS(opetype);
1533
1534     ADDTOCHAIN(ic);
1535     return IC_RESULT(ic) ;
1536 }
1537
1538 /*-----------------------------------------------------------------*/
1539 /* geniCodeLabel - will create a Label                             */
1540 /*-----------------------------------------------------------------*/
1541 void geniCodeLabel (symbol *label)
1542 {
1543     iCode *ic;
1544
1545     ic = newiCodeLabelGoto(LABEL,label);
1546     ADDTOCHAIN(ic);
1547 }
1548
1549 /*-----------------------------------------------------------------*/
1550 /* geniCodeGoto  - will create a Goto                              */
1551 /*-----------------------------------------------------------------*/
1552 void geniCodeGoto (symbol *label)
1553 {
1554     iCode *ic;
1555
1556     ic = newiCodeLabelGoto(GOTO,label);
1557     ADDTOCHAIN(ic);
1558 }
1559
1560 /*-----------------------------------------------------------------*/
1561 /* geniCodeMultiply - gen intermediate code for multiplication     */
1562 /*-----------------------------------------------------------------*/
1563 operand *geniCodeMultiply (operand *left, operand *right)
1564 {
1565     iCode *ic ;
1566     int p2 = 0;
1567     sym_link *resType ;
1568     LRTYPE ;
1569
1570     /* if they are both literal then we know the result */
1571     if (IS_LITERAL(letype) && IS_LITERAL(retype))
1572   return operandFromValue (valMult(left->operand.valOperand,
1573            right->operand.valOperand));
1574
1575     resType = usualBinaryConversions(&left, &right);
1576
1577     /* if the right is a literal & power of 2 */
1578     /* then make it a left shift              */
1579     if (IS_LITERAL(retype) && !IS_FLOAT(letype) &&
1580   (p2 = powof2 ((unsigned long)floatFromVal(right->operand.valOperand))))
1581   ic = newiCode(LEFT_OP, left,operandFromLit(p2)); /* left shift */
1582     else {
1583   ic = newiCode('*',left,right);  /* normal multiplication */
1584   /* if the size left or right > 1 then support routine */
1585   if (getSize(ltype) > 1 || getSize(rtype) > 1)
1586       ic->supportRtn = 1;
1587
1588     }
1589     IC_RESULT(ic) = newiTempOperand(resType,1);
1590
1591     ADDTOCHAIN(ic);
1592     return IC_RESULT(ic) ;
1593 }
1594
1595 /*-----------------------------------------------------------------*/
1596 /* geniCodeDivision - gen intermediate code for division           */
1597 /*-----------------------------------------------------------------*/
1598 operand *geniCodeDivision (operand *left, operand *right)
1599 {
1600     iCode *ic ;
1601     int p2 = 0;
1602     sym_link *resType;
1603     sym_link *rtype = operandType(right);
1604     sym_link *retype= getSpec(rtype);
1605     sym_link *ltype = operandType(left);
1606     sym_link *letype= getSpec(ltype);
1607
1608     resType = usualBinaryConversions(&left, &right);
1609
1610     /* if the right is a literal & power of 2 */
1611     /* then make it a right shift             */
1612     if (IS_LITERAL(retype) &&
1613   !IS_FLOAT(letype)  &&
1614   (p2 = powof2 ((unsigned long)
1615           floatFromVal(right->operand.valOperand))))
1616   ic = newiCode(RIGHT_OP, left,operandFromLit(p2)); /* right shift */
1617     else {
1618   ic = newiCode('/',left,right);  /* normal division */
1619   /* if the size left or right > 1 then support routine */
1620   if (getSize(ltype) > 1 || getSize(rtype) > 1)
1621       ic->supportRtn = 1;
1622     }
1623     IC_RESULT(ic) = newiTempOperand(resType,0);
1624
1625     ADDTOCHAIN(ic);
1626     return IC_RESULT(ic) ;
1627 }
1628 /*-----------------------------------------------------------------*/
1629 /* geniCodeModulus  - gen intermediate code for modulus            */
1630 /*-----------------------------------------------------------------*/
1631 operand *geniCodeModulus (operand *left, operand *right)
1632 {
1633     iCode *ic ;
1634     sym_link *resType;
1635     LRTYPE ;
1636
1637     /* if they are both literal then we know the result */
1638     if (IS_LITERAL(letype) && IS_LITERAL(retype))
1639   return operandFromValue (valMod(left->operand.valOperand,
1640           right->operand.valOperand));
1641
1642     resType = usualBinaryConversions(&left, &right);
1643
1644     /* now they are the same size */
1645     ic = newiCode('%',left,right);
1646
1647     /* if the size left or right > 1 then support routine */
1648     if (getSize(ltype) > 1 || getSize(rtype) > 1)
1649   ic->supportRtn = 1;
1650     IC_RESULT(ic) = newiTempOperand(resType,0);
1651
1652     ADDTOCHAIN(ic);
1653     return IC_RESULT(ic) ;
1654 }
1655
1656 /*-----------------------------------------------------------------*/
1657 /* geniCodePtrPtrSubtract - subtracts pointer from pointer         */
1658 /*-----------------------------------------------------------------*/
1659 operand *geniCodePtrPtrSubtract (operand *left, operand *right)
1660 {
1661     iCode *ic ;
1662     operand *result;
1663     LRTYPE ;
1664
1665     /* if they are both literals then */
1666     if (IS_LITERAL(letype) && IS_LITERAL(retype)) {
1667   result = operandFromValue (valMinus(left->operand.valOperand,
1668               right->operand.valOperand));
1669   goto subtractExit;
1670     }
1671
1672     ic = newiCode('-',left,right);
1673
1674     IC_RESULT(ic) = result = newiTempOperand(newIntLink(),1);
1675     ADDTOCHAIN(ic);
1676
1677  subtractExit:
1678     return geniCodeDivision (result,
1679            operandFromLit(getSize(ltype->next)));
1680 }
1681
1682 /*-----------------------------------------------------------------*/
1683 /* geniCodeSubtract - generates code for subtraction               */
1684 /*-----------------------------------------------------------------*/
1685 operand *geniCodeSubtract (operand *left, operand *right)
1686 {
1687     iCode *ic ;
1688     int isarray= 0;
1689     sym_link *resType;
1690     LRTYPE ;
1691
1692     /* if they both pointers then */
1693     if ((IS_PTR(ltype) || IS_ARRAY(ltype)) &&
1694   (IS_PTR(rtype) || IS_ARRAY(rtype)))
1695   return geniCodePtrPtrSubtract (left,right);
1696
1697     /* if they are both literal then we know the result */
1698     if (IS_LITERAL(letype) && IS_LITERAL(retype)
1699   && left->isLiteral && right->isLiteral)
1700   return operandFromValue (valMinus(left->operand.valOperand,
1701             right->operand.valOperand));
1702
1703     /* if left is an array or pointer */
1704     if ( IS_PTR(ltype) || IS_ARRAY(ltype) ) {
1705   isarray = left->isaddr ;
1706   right = geniCodeMultiply (right,
1707           operandFromLit(getSize(ltype->next)));
1708   resType = copyLinkChain(IS_ARRAY(ltype) ? ltype->next : ltype);
1709     }
1710     else { /* make them the same size */
1711         resType = usualBinaryConversions(&left, &right);
1712     }
1713
1714     ic = newiCode('-',left,right);
1715
1716     IC_RESULT(ic)= newiTempOperand(resType,1);
1717     IC_RESULT(ic)->isaddr = (isarray ? 1 : 0);
1718
1719     /* if left or right is a float */
1720     if (IS_FLOAT(ltype) || IS_FLOAT(rtype))
1721   ic->supportRtn = 1;
1722
1723     ADDTOCHAIN(ic);
1724     return IC_RESULT(ic) ;
1725 }
1726
1727 /*-----------------------------------------------------------------*/
1728 /* geniCodeAdd - generates iCode for addition                      */
1729 /*-----------------------------------------------------------------*/
1730 operand *geniCodeAdd (operand *left, operand *right )
1731 {
1732     iCode *ic ;
1733     sym_link *resType ;
1734     operand *size ;
1735     int isarray = 0;
1736     LRTYPE ;
1737
1738     /* if left is an array then array access */
1739     if (IS_ARRAY(ltype))
1740   return geniCodeArray (left,right);
1741
1742     /* if the right side is LITERAL zero */
1743     /* return the left side              */
1744     if (IS_LITERAL(retype) && right->isLiteral && !floatFromVal(valFromType(retype)))
1745   return left;
1746
1747     /* if left is literal zero return right */
1748     if (IS_LITERAL(letype) && left->isLiteral && !floatFromVal(valFromType(letype)))
1749   return right ;
1750
1751     /* if left is an array or pointer then size */
1752     if (IS_PTR(ltype)) {
1753
1754   isarray = left->isaddr;
1755   size =
1756       operandFromLit(getSize(ltype->next));
1757   if (getSize(ltype) > 1 && (getSize(rtype) < INTSIZE))
1758   {
1759       right = geniCodeCast(INTTYPE,right,TRUE);
1760   }
1761   right = geniCodeMultiply (right ,size);
1762
1763   resType = copyLinkChain(ltype);
1764     }
1765     else { /* make them the same size */
1766         resType = usualBinaryConversions(&left, &right);
1767     }
1768
1769     /* if they are both literals then we know */
1770     if (IS_LITERAL(letype) && IS_LITERAL(retype)
1771   && left->isLiteral && right->isLiteral)
1772   return operandFromValue (valPlus(valFromType(letype),
1773            valFromType(retype)));
1774
1775     ic = newiCode('+',left,right);
1776
1777     IC_RESULT(ic) = newiTempOperand(resType,1);
1778     IC_RESULT(ic)->isaddr = ( isarray ? 1 : 0);
1779
1780     /* if left or right is a float then support
1781        routine */
1782     if (IS_FLOAT(ltype) || IS_FLOAT(rtype))
1783   ic->supportRtn = 1;
1784
1785     ADDTOCHAIN(ic);
1786
1787     return IC_RESULT(ic) ;
1788
1789 }
1790
1791 /*-----------------------------------------------------------------*/
1792 /* aggrToPtr - changes an aggregate to pointer to an aggregate     */
1793 /*-----------------------------------------------------------------*/
1794 sym_link *aggrToPtr ( sym_link *type, bool force)
1795 {
1796     sym_link *etype ;
1797     sym_link *ptype ;
1798
1799
1800     if (IS_PTR(type) && !force)
1801   return type;
1802
1803     etype = getSpec(type);
1804     ptype = newLink();
1805
1806     ptype->next = type;
1807     /* if the output class is generic */
1808     if ((DCL_TYPE(ptype) = PTR_TYPE(SPEC_OCLS(etype))) == CPOINTER)
1809   DCL_PTR_CONST(ptype) = port->mem.code_ro;
1810
1811     /* if the variable was declared a constant */
1812     /* then the pointer points to a constant */
1813     if (IS_CONSTANT(etype) )
1814   DCL_PTR_CONST(ptype) = 1;
1815
1816     /* the variable was volatile then pointer to volatile */
1817     if (IS_VOLATILE(etype))
1818   DCL_PTR_VOLATILE(ptype) = 1;
1819     return ptype;
1820 }
1821
1822 /*-----------------------------------------------------------------*/
1823 /* geniCodeArray2Ptr - array to pointer                            */
1824 /*-----------------------------------------------------------------*/
1825 operand *geniCodeArray2Ptr (operand *op)
1826 {
1827     sym_link *optype = operandType(op);
1828     sym_link *opetype = getSpec(optype);
1829
1830     /* set the pointer depending on the storage class */
1831     if ((DCL_TYPE(optype) = PTR_TYPE(SPEC_OCLS(opetype))) == CPOINTER)
1832   DCL_PTR_CONST(optype) = port->mem.code_ro;
1833
1834
1835     /* if the variable was declared a constant */
1836     /* then the pointer points to a constant */
1837     if (IS_CONSTANT(opetype) )
1838   DCL_PTR_CONST(optype) = 1;
1839
1840     /* the variable was volatile then pointer to volatile */
1841     if (IS_VOLATILE(opetype))
1842   DCL_PTR_VOLATILE(optype) = 1;
1843     op->isaddr = 0;
1844     return op;
1845 }
1846
1847
1848 /*-----------------------------------------------------------------*/
1849 /* geniCodeArray - array access                                    */
1850 /*-----------------------------------------------------------------*/
1851 operand *geniCodeArray (operand *left,operand *right)
1852 {
1853     iCode *ic;
1854     sym_link *ltype = operandType(left);
1855
1856     if (IS_PTR(ltype)) {
1857   if (IS_PTR(ltype->next) && left->isaddr)
1858   {
1859       left = geniCodeRValue(left,FALSE);
1860   }
1861   return geniCodeDerefPtr(geniCodeAdd(left,right));
1862     }
1863
1864     /* array access */
1865     right = usualUnaryConversions(right);
1866     right = geniCodeMultiply(right,
1867            operandFromLit(getSize(ltype->next)));
1868
1869     /* we can check for limits here */
1870     if (isOperandLiteral(right) &&
1871   IS_ARRAY(ltype)         &&
1872   DCL_ELEM(ltype)         &&
1873   (operandLitValue(right)/getSize(ltype->next)) >= DCL_ELEM(ltype)) {
1874   werror(E_ARRAY_BOUND);
1875   right = operandFromLit(0);
1876     }
1877
1878     ic = newiCode('+',left,right);
1879
1880     IC_RESULT(ic) = newiTempOperand(((IS_PTR(ltype) &&
1881               !IS_AGGREGATE(ltype->next) &&
1882               !IS_PTR(ltype->next))
1883              ? ltype : ltype->next),0);
1884
1885     IC_RESULT(ic)->isaddr = (!IS_AGGREGATE(ltype->next));
1886     ADDTOCHAIN(ic);
1887     return IC_RESULT(ic) ;
1888 }
1889
1890 /*-----------------------------------------------------------------*/
1891 /* geniCodeStruct - generates intermediate code for structres      */
1892 /*-----------------------------------------------------------------*/
1893 operand *geniCodeStruct (operand *left, operand *right, bool islval)
1894 {
1895     iCode *ic ;
1896     sym_link *type = operandType(left);
1897     sym_link *etype = getSpec(type);
1898     sym_link *retype ;
1899     symbol *element = getStructElement(SPEC_STRUCT(etype),
1900                right->operand.symOperand);
1901
1902     /* add the offset */
1903     ic = newiCode('+',left,operandFromLit(element->offset));
1904
1905     IC_RESULT(ic) = newiTempOperand(element->type,0);
1906
1907     /* preserve the storage & output class of the struct */
1908     /* as well as the volatile attribute */
1909     retype = getSpec(operandType(IC_RESULT(ic)));
1910     SPEC_SCLS(retype) = SPEC_SCLS(etype);
1911     SPEC_OCLS(retype) = SPEC_OCLS(etype);
1912     SPEC_VOLATILE(retype) |= SPEC_VOLATILE(etype);
1913
1914     if (IS_PTR(element->type))
1915   setOperandType(IC_RESULT(ic),aggrToPtr(operandType(IC_RESULT(ic)),TRUE));
1916
1917     IC_RESULT(ic)->isaddr = (!IS_AGGREGATE(element->type));
1918
1919
1920     ADDTOCHAIN(ic);
1921     return (islval ? IC_RESULT(ic) : geniCodeRValue(IC_RESULT(ic),TRUE));
1922 }
1923
1924 /*-----------------------------------------------------------------*/
1925 /* geniCodePostInc - generate int code for Post increment          */
1926 /*-----------------------------------------------------------------*/
1927 operand *geniCodePostInc (operand *op)
1928 {
1929     iCode *ic ;
1930     operand *rOp ;
1931     sym_link *optype = operandType(op);
1932     operand *result ;
1933     operand *rv = (IS_ITEMP(op) ?
1934        geniCodeRValue(op,(IS_PTR(optype) ? TRUE : FALSE)) :
1935        op);
1936     sym_link *rvtype = operandType(rv);
1937     int size = 0;
1938
1939     /* if this is not an address we have trouble */
1940     if ( ! op->isaddr ) {
1941   werror (E_LVALUE_REQUIRED,"++");
1942   return op ;
1943     }
1944
1945     rOp = newiTempOperand(rvtype,0);
1946     rOp->noSpilLoc = 1;
1947
1948     if (IS_ITEMP(rv))
1949   rv->noSpilLoc = 1;
1950
1951     geniCodeAssign(rOp,rv,0);
1952
1953     size = (IS_PTR(rvtype) ? getSize(rvtype->next) : 1);
1954     ic = newiCode('+',rv,operandFromLit(size));
1955     IC_RESULT(ic) = result =newiTempOperand(rvtype,0);
1956     ADDTOCHAIN(ic);
1957
1958     geniCodeAssign(op,result,0);
1959
1960     return rOp;
1961
1962 }
1963
1964 /*-----------------------------------------------------------------*/
1965 /* geniCodePreInc - generate code for preIncrement                 */
1966 /*-----------------------------------------------------------------*/
1967 operand *geniCodePreInc (operand *op)
1968 {
1969     iCode *ic ;
1970     sym_link *optype = operandType(op);
1971     operand *rop = (IS_ITEMP(op) ?
1972         geniCodeRValue (op,(IS_PTR(optype) ? TRUE : FALSE)) :
1973         op);
1974     sym_link *roptype = operandType(rop);
1975     operand *result;
1976     int size = 0;
1977
1978     if ( ! op->isaddr ) {
1979   werror(E_LVALUE_REQUIRED,"++");
1980   return op ;
1981     }
1982
1983
1984     size = (IS_PTR(roptype) ? getSize(roptype->next) : 1);
1985     ic = newiCode('+',rop,operandFromLit(size));
1986     IC_RESULT(ic) = result = newiTempOperand(roptype,0) ;
1987     ADDTOCHAIN(ic);
1988
1989
1990     return geniCodeAssign(op,result,0) ;
1991 }
1992
1993 /*-----------------------------------------------------------------*/
1994 /* geniCodePostDec - generates code for Post decrement             */
1995 /*-----------------------------------------------------------------*/
1996 operand *geniCodePostDec (operand *op)
1997 {
1998     iCode *ic ;
1999     operand *rOp ;
2000     sym_link *optype = operandType(op);
2001     operand *result ;
2002     operand *rv = (IS_ITEMP(op) ?
2003        geniCodeRValue(op,(IS_PTR(optype) ? TRUE : FALSE)) :
2004        op);
2005     sym_link *rvtype = operandType(rv);
2006     int size = 0;
2007
2008     /* if this is not an address we have trouble */
2009     if ( ! op->isaddr ) {
2010   werror (E_LVALUE_REQUIRED,"++");
2011   return op ;
2012     }
2013
2014     rOp = newiTempOperand(rvtype,0);
2015     rOp->noSpilLoc = 1;
2016
2017     if (IS_ITEMP(rv))
2018   rv->noSpilLoc = 1;
2019
2020     geniCodeAssign(rOp,rv,0);
2021
2022     size = (IS_PTR(rvtype) ? getSize(rvtype->next) : 1);
2023     ic = newiCode('-',rv,operandFromLit(size));
2024     IC_RESULT(ic) = result =newiTempOperand(rvtype,0);
2025     ADDTOCHAIN(ic);
2026
2027     geniCodeAssign(op,result,0);
2028
2029     return rOp;
2030
2031 }
2032
2033 /*-----------------------------------------------------------------*/
2034 /* geniCodePreDec - generate code for pre  decrement               */
2035 /*-----------------------------------------------------------------*/
2036 operand *geniCodePreDec (operand *op)
2037 {
2038     iCode *ic ;
2039     sym_link *optype = operandType(op);
2040     operand *rop = (IS_ITEMP(op) ?
2041         geniCodeRValue (op,(IS_PTR(optype) ? TRUE : FALSE)) :
2042         op);
2043     sym_link *roptype = operandType(rop);
2044     operand *result;
2045     int size = 0;
2046
2047     if ( ! op->isaddr ) {
2048   werror(E_LVALUE_REQUIRED,"++");
2049   return op ;
2050     }
2051
2052
2053     size = (IS_PTR(roptype) ? getSize(roptype->next) : 1);
2054     ic = newiCode('-',rop,operandFromLit(size));
2055     IC_RESULT(ic) = result = newiTempOperand(roptype,0) ;
2056     ADDTOCHAIN(ic);
2057
2058
2059     return geniCodeAssign(op,result,0) ;
2060 }
2061
2062
2063 /*-----------------------------------------------------------------*/
2064 /* geniCodeBitwise - gen int code for bitWise  operators           */
2065 /*-----------------------------------------------------------------*/
2066 operand *geniCodeBitwise (operand *left, operand *right,
2067         int oper, sym_link *resType)
2068 {
2069     iCode *ic;
2070
2071     left = geniCodeCast(resType,left,TRUE);
2072     right= geniCodeCast(resType,right,TRUE);
2073
2074     ic = newiCode(oper,left,right);
2075     IC_RESULT(ic) = newiTempOperand(resType,0);
2076
2077     ADDTOCHAIN(ic);
2078     return IC_RESULT(ic) ;
2079 }
2080
2081 /*-----------------------------------------------------------------*/
2082 /* geniCodeAddressOf - gens icode for '&' address of operator      */
2083 /*-----------------------------------------------------------------*/
2084 operand *geniCodeAddressOf (operand *op)
2085 {
2086     iCode *ic;
2087     sym_link *p ;
2088     sym_link *optype = operandType(op);
2089     sym_link *opetype= getSpec(optype);
2090
2091     /* lvalue check already done in decorateType */
2092     /* this must be a lvalue */
2093 /*     if (!op->isaddr && !IS_AGGREGATE(optype)) { */
2094 /*  werror (E_LVALUE_REQUIRED,"&"); */
2095 /*  return op; */
2096 /*     } */
2097
2098     p = newLink();
2099     p->class = DECLARATOR ;
2100
2101     /* set the pointer depending on the storage class */
2102     if ((DCL_TYPE(p) = PTR_TYPE(SPEC_OCLS(opetype))) == CPOINTER)
2103   DCL_PTR_CONST(p) = port->mem.code_ro;
2104
2105     /* make sure we preserve the const & volatile */
2106     if (IS_CONSTANT(opetype))
2107   DCL_PTR_CONST(p) = 1;
2108
2109     if (IS_VOLATILE(opetype))
2110   DCL_PTR_VOLATILE(p) = 1;
2111
2112     p->next = copyLinkChain(optype);
2113
2114     /* if already a temp */
2115     if (IS_ITEMP(op)) {
2116   setOperandType (op,p);
2117   op->isaddr= 0;
2118   return op;
2119     }
2120
2121     /* other wise make this of the type coming in */
2122     ic = newiCode(ADDRESS_OF,op,NULL);
2123     IC_RESULT(ic) = newiTempOperand(p,1);
2124     IC_RESULT(ic)->isaddr = 0;
2125     ADDTOCHAIN(ic);
2126     return IC_RESULT(ic);
2127 }
2128 /*-----------------------------------------------------------------*/
2129 /* setOClass - sets the output class depending on the pointer type */
2130 /*-----------------------------------------------------------------*/
2131 void setOClass (sym_link *ptr, sym_link *spec)
2132 {
2133     switch (DCL_TYPE(ptr)) {
2134     case POINTER:
2135   SPEC_OCLS(spec) = data ;
2136   break ;
2137
2138     case GPOINTER:
2139   SPEC_OCLS(spec) = generic;
2140   break;
2141
2142     case FPOINTER:
2143   SPEC_OCLS(spec) = xdata ;
2144   break ;
2145
2146     case CPOINTER:
2147   SPEC_OCLS(spec) = code ;
2148   break ;
2149
2150     case IPOINTER:
2151   SPEC_OCLS(spec) = idata;
2152   break;
2153
2154     case PPOINTER:
2155   SPEC_OCLS(spec) = xstack;
2156   break;
2157
2158     case EEPPOINTER:
2159   SPEC_OCLS(spec) = eeprom;
2160   break;
2161
2162     default:
2163   break;
2164
2165     }
2166 }
2167
2168 /*-----------------------------------------------------------------*/
2169 /* geniCodeDerefPtr - dereference pointer with '*'                 */
2170 /*-----------------------------------------------------------------*/
2171 operand *geniCodeDerefPtr (operand *op)
2172 {
2173     sym_link *rtype , *retype ;
2174     sym_link *optype = operandType(op);
2175
2176     /* if this is a pointer then generate the rvalue */
2177     if (IS_PTR(optype)) {
2178   if (IS_TRUE_SYMOP(op)) {
2179       op->isaddr = 1;
2180       op = geniCodeRValue(op,TRUE);
2181   }
2182   else
2183       op = geniCodeRValue(op,TRUE);
2184     }
2185
2186     /* now get rid of the pointer part */
2187     if (lvaluereq && IS_ITEMP(op) )
2188     {
2189   retype = getSpec(rtype = copyLinkChain(optype)) ;
2190     }
2191     else
2192     {
2193   retype = getSpec(rtype = copyLinkChain(optype->next)) ;
2194     }
2195
2196     /* if this is a pointer then outputclass needs 2b updated */
2197     if (IS_PTR(optype))
2198   setOClass(optype,retype);
2199
2200     op->isGptr = IS_GENPTR(optype);
2201
2202     /* if the pointer was declared as a constant */
2203     /* then we cannot allow assignment to the derefed */
2204     if (IS_PTR_CONST(optype))
2205   SPEC_CONST(retype) = 1;
2206
2207     op->isaddr = (IS_PTR(rtype)    ||
2208       IS_STRUCT(rtype) ||
2209       IS_INT(rtype)    ||
2210       IS_CHAR(rtype)   ||
2211       IS_FLOAT(rtype) );
2212
2213     if (!lvaluereq)
2214   op = geniCodeRValue(op,TRUE);
2215
2216     setOperandType(op,rtype);
2217
2218     return op;
2219 }
2220
2221 /*-----------------------------------------------------------------*/
2222 /* geniCodeUnaryMinus - does a unary minus of the operand          */
2223 /*-----------------------------------------------------------------*/
2224 operand *geniCodeUnaryMinus (operand *op)
2225 {
2226     iCode *ic ;
2227     sym_link *optype = operandType(op);
2228
2229     if (IS_LITERAL(optype))
2230   return operandFromLit(- floatFromVal(op->operand.valOperand));
2231
2232     ic = newiCode(UNARYMINUS,op,NULL);
2233     IC_RESULT(ic) = newiTempOperand(optype,0);
2234     ADDTOCHAIN(ic);
2235     return IC_RESULT(ic);
2236 }
2237
2238 /*-----------------------------------------------------------------*/
2239 /* geniCodeLeftShift - gen i code for left shift                   */
2240 /*-----------------------------------------------------------------*/
2241 operand *geniCodeLeftShift (operand *left, operand *right)
2242 {
2243     iCode *ic;
2244
2245     /* Note that we don't use the usual binary conversions for the
2246      * shift operations, in accordance with our ANSI friends.
2247      */
2248     if (options.ANSIint)
2249     {
2250       right = usualUnaryConversions(right);
2251       left = usualUnaryConversions(left);
2252     }
2253
2254     ic = newiCode(LEFT_OP,left,right);
2255     IC_RESULT(ic) = newiTempOperand(operandType(left),0);
2256     ADDTOCHAIN(ic);
2257     return IC_RESULT(ic) ;
2258 }
2259
2260 /*-----------------------------------------------------------------*/
2261 /* geniCodeRightShift - gen i code for right shift                 */
2262 /*-----------------------------------------------------------------*/
2263 operand *geniCodeRightShift (operand *left, operand *right)
2264 {
2265     iCode *ic;
2266
2267     /* Note that we don't use the usual binary conversions for the
2268      * shift operations, in accordance with our ANSI friends.
2269      */
2270     if (options.ANSIint)
2271     {
2272       right = usualUnaryConversions(right);
2273       left = usualUnaryConversions(left);
2274     }
2275
2276     ic = newiCode(RIGHT_OP,left,right);
2277     IC_RESULT(ic) = newiTempOperand(operandType(left),0);
2278     ADDTOCHAIN(ic);
2279     return IC_RESULT(ic) ;
2280 }
2281
2282 #if defined(__BORLANDC__) || defined(_MSC_VER)
2283 #define LONG_LONG __int64
2284 #else
2285 #define LONG_LONG long long
2286 #endif
2287
2288 /*-----------------------------------------------------------------*/
2289 /* geniCodeLogic- logic code                                       */
2290 /*-----------------------------------------------------------------*/
2291 operand *geniCodeLogic (operand *left, operand *right, int op )
2292 {
2293     iCode *ic ;
2294     sym_link *ctype;
2295     sym_link *rtype = operandType(right);
2296     sym_link *ltype = operandType(left);
2297
2298     /* left is integral type and right is literal then
2299        check if the literal value is within bounds */
2300     if (IS_INTEGRAL(ltype) && IS_LITERAL(rtype)) {
2301   int nbits = bitsForType(ltype);
2302   long v = operandLitValue(right);
2303
2304   if (v > ((LONG_LONG) 1 << nbits) && v > 0)
2305       werror(W_CONST_RANGE," compare operation ");
2306     }
2307
2308     ctype = usualBinaryConversions(&left, &right);
2309
2310     ic = newiCode(op,left,right);
2311     IC_RESULT(ic) = newiTempOperand (newCharLink(),1);
2312
2313     /* if comparing anything greater than one byte
2314        and not a '==' || '!=' || '&&' || '||' (these
2315        will be inlined */
2316     if (getSize(ctype) > 1 &&
2317   op != EQ_OP        &&
2318   op != NE_OP        &&
2319   op != AND_OP       &&
2320   op != OR_OP        )
2321   ic->supportRtn = 1;
2322
2323     ADDTOCHAIN(ic);
2324     return IC_RESULT(ic);
2325 }
2326
2327 /*-----------------------------------------------------------------*/
2328 /* geniCodeUnary - for a a generic unary operation                 */
2329 /*-----------------------------------------------------------------*/
2330 operand *geniCodeUnary (operand *op, int oper )
2331 {
2332     iCode *ic = newiCode (oper,op,NULL);
2333
2334     IC_RESULT(ic)= newiTempOperand(operandType(op),0);
2335     ADDTOCHAIN(ic);
2336     return IC_RESULT(ic) ;
2337 }
2338
2339 /*-----------------------------------------------------------------*/
2340 /* geniCodeConditional - geniCode for '?' ':' operation            */
2341 /*-----------------------------------------------------------------*/
2342 operand *geniCodeConditional (ast *tree)
2343 {
2344     iCode *ic ;
2345     symbol *falseLabel = newiTempLabel(NULL);
2346     symbol *exitLabel  = newiTempLabel(NULL);
2347     operand *cond = ast2iCode(tree->left);
2348     operand *true, *false , *result;
2349
2350     ic = newiCodeCondition(geniCodeRValue(cond,FALSE),
2351          NULL,falseLabel);
2352     ADDTOCHAIN(ic);
2353
2354     true = ast2iCode(tree->right->left);
2355
2356     /* move the value to a new Operand */
2357     result = newiTempOperand(operandType(true),0);
2358     geniCodeAssign(result,geniCodeRValue(true,FALSE),0);
2359
2360     /* generate an unconditional goto */
2361     geniCodeGoto(exitLabel);
2362
2363     /* now for the right side */
2364     geniCodeLabel(falseLabel);
2365
2366     false = ast2iCode(tree->right->right);
2367     geniCodeAssign(result,geniCodeRValue(false,FALSE),0);
2368
2369     /* create the exit label */
2370     geniCodeLabel(exitLabel);
2371
2372     return result ;
2373 }
2374
2375 /*-----------------------------------------------------------------*/
2376 /* geniCodeAssign - generate code for assignment                   */
2377 /*-----------------------------------------------------------------*/
2378 operand *geniCodeAssign (operand *left, operand *right, int nosupdate)
2379 {
2380     iCode *ic ;
2381     sym_link *ltype = operandType(left);
2382     sym_link *rtype = operandType(right);
2383
2384     if (!left->isaddr && !IS_ITEMP(left)) {
2385   werror(E_LVALUE_REQUIRED,"assignment");
2386   return left;
2387     }
2388
2389     /* left is integral type and right is literal then
2390        check if the literal value is within bounds */
2391     if (IS_INTEGRAL(ltype) && right->type == VALUE && IS_LITERAL(rtype)) {
2392   int nbits = bitsForType(ltype);
2393   long v = operandLitValue(right);
2394
2395   if (v > ((LONG_LONG)1 << nbits) && v > 0)
2396       werror(W_CONST_RANGE," = operation");
2397     }
2398
2399     /* if the left & right type don't exactly match */
2400     /* if pointer set then make sure the check is
2401        done with the type & not the pointer */
2402     /* then cast rights type to left */
2403
2404     /* first check the type for pointer assignement */
2405     if (left->isaddr && IS_PTR(ltype) && IS_ITEMP(left) &&
2406   checkType(ltype,rtype)<0) {
2407   if (checkType(ltype->next,rtype) < 0)
2408       right = geniCodeCast(ltype->next,right,TRUE);
2409     } else
2410   if (checkType(ltype,rtype) < 0 )
2411       right = geniCodeCast(ltype,right,TRUE);
2412
2413     /* if left is a true symbol & ! volatile
2414        create an assignment to temporary for
2415        the right & then assign this temporary
2416        to the symbol this is SSA . isn't it simple
2417        and folks have published mountains of paper on it */
2418     if (IS_TRUE_SYMOP(left) &&
2419   !isOperandVolatile(left,FALSE) &&
2420   isOperandGlobal(left)) {
2421   symbol *sym = NULL;
2422
2423   if (IS_TRUE_SYMOP(right))
2424       sym = OP_SYMBOL(right);
2425   ic = newiCode('=',NULL,right);
2426   IC_RESULT(ic) = right = newiTempOperand(ltype,0);
2427   SPIL_LOC(right)  = sym ;
2428   ADDTOCHAIN(ic);
2429     }
2430
2431     ic = newiCode('=',NULL,right);
2432     IC_RESULT(ic) = left;
2433     ADDTOCHAIN(ic);
2434
2435     /* if left isgptr flag is set then support
2436        routine will be required */
2437     if (left->isGptr)
2438   ic->supportRtn = 1;
2439
2440     ic->nosupdate = nosupdate;
2441     return left;
2442 }
2443
2444 /*-----------------------------------------------------------------*/
2445 /* geniCodeSEParms - generate code for side effecting fcalls       */
2446 /*-----------------------------------------------------------------*/
2447 static void geniCodeSEParms (ast *parms)
2448 {
2449     if (!parms)
2450   return ;
2451
2452     if (parms->type == EX_OP && parms->opval.op == PARAM) {
2453   geniCodeSEParms (parms->left) ;
2454   geniCodeSEParms (parms->right);
2455   return ;
2456     }
2457
2458     /* hack don't like this but too lazy to think of
2459        something better */
2460     if (IS_ADDRESS_OF_OP(parms))
2461   parms->left->lvalue = 1;
2462
2463     if (IS_CAST_OP(parms) &&
2464   IS_PTR(parms->ftype) &&
2465   IS_ADDRESS_OF_OP(parms->right))
2466   parms->right->left->lvalue = 1;
2467
2468     parms->opval.oprnd =
2469   geniCodeRValue(ast2iCode (parms),FALSE);
2470
2471     parms->type = EX_OPERAND ;
2472 }
2473
2474 /*-----------------------------------------------------------------*/
2475 /* geniCodeParms - generates parameters                            */
2476 /*-----------------------------------------------------------------*/
2477 static void geniCodeParms ( ast *parms , int *stack, sym_link *fetype, symbol *func)
2478 {
2479     iCode *ic ;
2480     operand *pval ;
2481
2482     if ( ! parms )
2483   return ;
2484
2485     /* if this is a param node then do the left & right */
2486     if (parms->type == EX_OP && parms->opval.op == PARAM) {
2487   geniCodeParms (parms->left, stack,fetype,func) ;
2488   geniCodeParms (parms->right, stack,fetype,func);
2489   return ;
2490     }
2491
2492     /* get the parameter value */
2493     if (parms->type == EX_OPERAND)
2494   pval = parms->opval.oprnd ;
2495     else {
2496   /* maybe this else should go away ?? */
2497   /* hack don't like this but too lazy to think of
2498      something better */
2499   if (IS_ADDRESS_OF_OP(parms))
2500       parms->left->lvalue = 1;
2501
2502   if (IS_CAST_OP(parms) &&
2503       IS_PTR(parms->ftype) &&
2504       IS_ADDRESS_OF_OP(parms->right))
2505       parms->right->left->lvalue = 1;
2506
2507   pval = geniCodeRValue(ast2iCode (parms),FALSE);
2508     }
2509
2510     /* if register parm then make it a send */
2511     if (((parms->argSym && IS_REGPARM(parms->argSym->etype)) ||
2512   IS_REGPARM(parms->etype)) && !func->hasVargs ) {
2513   ic = newiCode(SEND,pval,NULL);
2514   ADDTOCHAIN(ic);
2515     } else {
2516   /* now decide whether to push or assign */
2517   if (!(options.stackAuto || IS_RENT(fetype))) {
2518
2519       /* assign */
2520       operand *top = operandFromSymbol(parms->argSym);
2521       geniCodeAssign(top,pval,1);
2522   }
2523   else {
2524       sym_link *p = operandType(pval);
2525       /* push */
2526       ic = newiCode(IPUSH,pval,NULL);
2527       ic->parmPush = 1;
2528       /* update the stack adjustment */
2529       *stack += getSize(IS_AGGREGATE(p)? aggrToPtr(p,FALSE):p);
2530       ADDTOCHAIN(ic);
2531   }
2532     }
2533
2534 }
2535
2536 /*-----------------------------------------------------------------*/
2537 /* geniCodeCall - generates temp code for calling                  */
2538 /*-----------------------------------------------------------------*/
2539 operand *geniCodeCall (operand *left, ast *parms)
2540 {
2541     iCode *ic ;
2542     operand *result ;
2543     sym_link *type, *etype;
2544     int stack = 0 ;
2545
2546     /* take care of parameters with side-effecting
2547        function calls in them, this is required to take care
2548        of overlaying function parameters */
2549     geniCodeSEParms ( parms );
2550
2551     /* first the parameters */
2552     geniCodeParms ( parms , &stack , getSpec(operandType(left)), OP_SYMBOL(left));
2553
2554     /* now call : if symbol then pcall */
2555     if (IS_ITEMP(left))
2556   ic = newiCode(PCALL,left,NULL);
2557     else
2558   ic = newiCode(CALL,left,NULL);
2559
2560     IC_ARGS(ic) = left->operand.symOperand->args ;
2561     type = copyLinkChain(operandType(left)->next);
2562     etype = getSpec(type);
2563     SPEC_EXTR(etype) = 0;
2564     IC_RESULT(ic) = result = newiTempOperand(type,1);
2565
2566     ADDTOCHAIN(ic);
2567
2568     /* stack adjustment after call */
2569     left->parmBytes = stack;
2570
2571     return result;
2572 }
2573
2574 /*-----------------------------------------------------------------*/
2575 /* geniCodeReceive - generate intermediate code for "receive"      */
2576 /*-----------------------------------------------------------------*/
2577 static void geniCodeReceive (value *args)
2578 {
2579     /* for all arguments that are passed in registers */
2580     while (args) {
2581
2582   if (IS_REGPARM(args->etype)) {
2583       operand *opr = operandFromValue(args);
2584       operand *opl ;
2585       symbol *sym  = OP_SYMBOL(opr);
2586       iCode *ic ;
2587
2588       /* we will use it after all optimizations
2589          and before liveRange calculation */
2590       if (!sym->addrtaken && !IS_VOLATILE(sym->etype)) {
2591
2592     if (IN_FARSPACE(SPEC_OCLS(sym->etype)) &&
2593        options.stackAuto == 0 &&
2594        !IS_DS390_PORT) {
2595     } else {
2596         opl = newiTempOperand(args->type,0);
2597         sym->reqv = opl ;
2598         sym->reqv->key = sym->key ;
2599         OP_SYMBOL(sym->reqv)->key = sym->key;
2600         OP_SYMBOL(sym->reqv)->isreqv = 1;
2601         OP_SYMBOL(sym->reqv)->islocal= 0;
2602         SPIL_LOC(sym->reqv) =  sym;
2603     }
2604       }
2605
2606       ic = newiCode(RECEIVE,NULL,NULL);
2607       currFunc->recvSize = getSize(sym->etype);
2608       IC_RESULT(ic) = opr;
2609       ADDTOCHAIN(ic);
2610   }
2611
2612   args = args->next;
2613     }
2614 }
2615
2616 /*-----------------------------------------------------------------*/
2617 /* geniCodeFunctionBody - create the function body                 */
2618 /*-----------------------------------------------------------------*/
2619 void geniCodeFunctionBody (ast *tree)
2620 {
2621     iCode *ic ;
2622     operand *func ;
2623     sym_link *fetype  ;
2624     int savelineno ;
2625
2626     /* reset the auto generation */
2627     /* numbers */
2628     iTempNum = 0 ;
2629     iTempLblNum = 0;
2630     operandKey = 0 ;
2631     iCodeKey = 0 ;
2632     func  = ast2iCode(tree->left);
2633     fetype = getSpec(operandType(func));
2634
2635     savelineno = lineno;
2636     lineno = OP_SYMBOL(func)->lineDef;
2637     /* create an entry label */
2638     geniCodeLabel(entryLabel);
2639     lineno = savelineno;
2640
2641     /* create a proc icode */
2642     ic = newiCode(FUNCTION,func,NULL);
2643     /* if the function has parmas   then */
2644     /* save the parameters information    */
2645     ic->argLabel.args = tree->values.args ;
2646     ic->lineno = OP_SYMBOL(func)->lineDef;
2647
2648     ADDTOCHAIN(ic);
2649
2650     /* for all parameters that are passed
2651        on registers add a "receive" */
2652     geniCodeReceive( tree->values.args );
2653
2654     /* generate code for the body */
2655     ast2iCode(tree->right);
2656
2657     /* create a label for return */
2658     geniCodeLabel(returnLabel);
2659
2660     /* now generate the end proc */
2661     ic = newiCode(ENDFUNCTION,func,NULL);
2662     ADDTOCHAIN(ic);
2663     return ;
2664 }
2665
2666 /*-----------------------------------------------------------------*/
2667 /* geniCodeReturn - gen icode for 'return' statement               */
2668 /*-----------------------------------------------------------------*/
2669 void geniCodeReturn (operand *op)
2670 {
2671     iCode *ic;
2672
2673     /* if the operand is present force an rvalue */
2674     if (op)
2675   op = geniCodeRValue(op,FALSE);
2676
2677     ic = newiCode(RETURN,op,NULL);
2678     ADDTOCHAIN(ic);
2679 }
2680
2681 /*-----------------------------------------------------------------*/
2682 /* geniCodeIfx - generates code for extended if statement          */
2683 /*-----------------------------------------------------------------*/
2684 void geniCodeIfx (ast *tree)
2685 {
2686     iCode *ic;
2687     operand *condition = ast2iCode(tree->left);
2688     sym_link *cetype;
2689
2690     /* if condition is null then exit */
2691     if (!condition)
2692   goto exit ;
2693     else
2694   condition = geniCodeRValue(condition,FALSE);
2695
2696     cetype = getSpec(operandType(condition));
2697     /* if the condition is a literal */
2698     if (IS_LITERAL(cetype)) {
2699   if (floatFromVal(condition->operand.valOperand)) {
2700       if (tree->trueLabel)
2701     geniCodeGoto(tree->trueLabel);
2702       else
2703     assert(1);
2704   }
2705   else {
2706       if (tree->falseLabel)
2707     geniCodeGoto (tree->falseLabel);
2708       else
2709     assert(1);
2710   }
2711   goto exit;
2712     }
2713
2714     if ( tree->trueLabel ) {
2715   ic = newiCodeCondition(condition,
2716              tree->trueLabel,
2717              NULL );
2718   ADDTOCHAIN(ic);
2719
2720   if ( tree->falseLabel)
2721       geniCodeGoto(tree->falseLabel);
2722     }
2723     else {
2724   ic = newiCodeCondition (condition,
2725         NULL,
2726         tree->falseLabel);
2727   ADDTOCHAIN(ic);
2728     }
2729
2730  exit:
2731     ast2iCode(tree->right);
2732 }
2733
2734 /*-----------------------------------------------------------------*/
2735 /* geniCodeJumpTable - tries to create a jump table for switch     */
2736 /*-----------------------------------------------------------------*/
2737 int geniCodeJumpTable (operand *cond, value *caseVals, ast *tree)
2738 {
2739     int min = 0 ,max = 0, t, cnt = 0;
2740     value *vch;
2741     iCode *ic;
2742     operand *boundary;
2743     symbol *falseLabel;
2744     set *labels = NULL ;
2745
2746     if (!tree || !caseVals)
2747   return 0;
2748
2749     /* the criteria for creating a jump table is */
2750     /* all integer numbers between the maximum & minimum must */
2751     /* be present , the maximum value should not exceed 255 */
2752     min = max = (int)floatFromVal(vch = caseVals);
2753     sprintf(buffer,"_case_%d_%d",
2754       tree->values.switchVals.swNum,
2755       min);
2756     addSet(&labels,newiTempLabel(buffer));
2757
2758     /* if there is only one case value then no need */
2759     if (!(vch = vch->next ))
2760   return 0;
2761
2762     while (vch) {
2763   if (((t = (int)floatFromVal(vch)) - max) != 1)
2764       return 0;
2765   sprintf(buffer,"_case_%d_%d",
2766     tree->values.switchVals.swNum,
2767     t);
2768   addSet(&labels,newiTempLabel(buffer));
2769   max = t;
2770   cnt++ ;
2771   vch = vch->next ;
2772     }
2773
2774     /* if the number of case statements <= 2 then */
2775     /* it is not economical to create the jump table */
2776     /* since two compares are needed for boundary conditions */
2777     if ((! optimize.noJTabBoundary  && cnt <= 2) || max > (255/3))
2778   return 0;
2779
2780     if ( tree->values.switchVals.swDefault )
2781   sprintf (buffer,"_default_%d",tree->values.switchVals.swNum);
2782     else
2783   sprintf (buffer,"_swBrk_%d",tree->values.switchVals.swNum  );
2784
2785     falseLabel = newiTempLabel (buffer);
2786
2787     /* so we can create a jumptable */
2788     /* first we rule out the boundary conditions */
2789     /* if only optimization says so */
2790     if ( ! optimize.noJTabBoundary ) {
2791   sym_link *cetype = getSpec(operandType(cond));
2792   /* no need to check the lower bound if
2793      the condition is unsigned & minimum value is zero */
2794   if (!( min == 0  && SPEC_USIGN(cetype))) {
2795       boundary = geniCodeLogic (cond,operandFromLit(min),'<');
2796       ic = newiCodeCondition (boundary,falseLabel,NULL);
2797       ADDTOCHAIN(ic);
2798   }
2799
2800   /* now for upper bounds */
2801   boundary = geniCodeLogic(cond,operandFromLit(max),'>');
2802   ic = newiCodeCondition (boundary,falseLabel,NULL);
2803   ADDTOCHAIN(ic);
2804     }
2805
2806     /* if the min is not zero then we no make it zero */
2807     if (min) {
2808   cond = geniCodeSubtract(cond,operandFromLit(min));
2809   setOperandType(cond, UCHARTYPE);
2810     }
2811
2812     /* now create the jumptable */
2813     ic = newiCode(JUMPTABLE,NULL,NULL);
2814     IC_JTCOND(ic) = cond;
2815     IC_JTLABELS(ic) = labels;
2816     ADDTOCHAIN(ic);
2817     return 1;
2818 }
2819
2820 /*-----------------------------------------------------------------*/
2821 /* geniCodeSwitch - changes a switch to a if statement             */
2822 /*-----------------------------------------------------------------*/
2823 void geniCodeSwitch (ast *tree)
2824 {
2825     iCode *ic ;
2826     operand *cond = geniCodeRValue(ast2iCode (tree->left),FALSE);
2827     value *caseVals = tree->values.switchVals.swVals ;
2828     symbol *trueLabel , *falseLabel;
2829
2830     /* if we can make this a jump table */
2831     if ( geniCodeJumpTable (cond,caseVals,tree) )
2832   goto jumpTable ; /* no need for the comparison */
2833
2834     /* for the cases defined do */
2835     while (caseVals) {
2836
2837   operand *compare = geniCodeLogic (cond,
2838             operandFromValue(caseVals),
2839             EQ_OP);
2840
2841   sprintf(buffer,"_case_%d_%d",
2842     tree->values.switchVals.swNum,
2843     (int) floatFromVal(caseVals));
2844   trueLabel = newiTempLabel(buffer);
2845
2846   ic = newiCodeCondition(compare,trueLabel,NULL);
2847   ADDTOCHAIN(ic);
2848   caseVals = caseVals->next;
2849     }
2850
2851
2852
2853     /* if default is present then goto break else break */
2854     if ( tree->values.switchVals.swDefault )
2855   sprintf (buffer,"_default_%d",tree->values.switchVals.swNum);
2856     else
2857   sprintf (buffer,"_swBrk_%d",tree->values.switchVals.swNum  );
2858
2859     falseLabel = newiTempLabel (buffer);
2860     geniCodeGoto(falseLabel);
2861
2862  jumpTable:
2863     ast2iCode(tree->right);
2864 }
2865
2866 /*-----------------------------------------------------------------*/
2867 /* geniCodeInline - intermediate code for inline assembler         */
2868 /*-----------------------------------------------------------------*/
2869 static void geniCodeInline (ast *tree)
2870 {
2871     iCode *ic;
2872
2873     ic = newiCode(INLINEASM,NULL,NULL);
2874     IC_INLINE(ic) = tree->values.inlineasm;
2875     ADDTOCHAIN(ic);
2876 }
2877
2878 /*-----------------------------------------------------------------*/
2879 /* ast2iCode - creates an icodeList from an ast                    */
2880 /*-----------------------------------------------------------------*/
2881 operand *ast2iCode (ast *tree)
2882 {
2883     operand *left = NULL;
2884     operand *right= NULL;
2885
2886     if (!tree)
2887   return NULL ;
2888
2889     /* set the global variables for filename & line number */
2890     if ( tree->filename )
2891   filename =  tree->filename ;
2892     if ( tree->lineno)
2893   lineno   = tree->lineno ;
2894     if (tree->block)
2895   block = tree->block ;
2896     if (tree->level)
2897   scopeLevel = tree->level;
2898
2899     if (tree->type == EX_VALUE )
2900   return operandFromValue(tree->opval.val);
2901
2902     if (tree->type == EX_LINK )
2903   return operandFromLink (tree->opval.lnk);
2904
2905     /* if we find a nullop */
2906     if (tree->type == EX_OP &&
2907   ( tree->opval.op == NULLOP ||
2908     tree->opval.op == BLOCK )) {
2909   ast2iCode (tree->left);
2910   ast2iCode (tree->right);
2911   return NULL ;
2912     }
2913
2914     /* special cases for not evaluating */
2915     if ( tree->opval.op != ':'   &&
2916    tree->opval.op != '?'   &&
2917    tree->opval.op != CALL  &&
2918    tree->opval.op != IFX   &&
2919    tree->opval.op != LABEL &&
2920    tree->opval.op != GOTO  &&
2921    tree->opval.op != SWITCH &&
2922    tree->opval.op != FUNCTION &&
2923    tree->opval.op != INLINEASM ) {
2924
2925   if (IS_ASSIGN_OP(tree->opval.op) ||
2926       IS_DEREF_OP(tree)            ||
2927       (tree->opval.op == '&' && !tree->right) ||
2928       tree->opval.op == PTR_OP) {
2929       lvaluereq++;
2930       if ((IS_ARRAY_OP(tree->left) && IS_ARRAY_OP(tree->left->left)) ||
2931     (IS_DEREF_OP(tree) && IS_ARRAY_OP(tree->left)))
2932       {
2933     int olvr = lvaluereq ;
2934     lvaluereq = 0;
2935     left = operandFromAst(tree->left);
2936     lvaluereq = olvr - 1;
2937       } else {
2938     left = operandFromAst(tree->left);
2939     lvaluereq--;
2940       }
2941       if (IS_DEREF_OP(tree) && IS_DEREF_OP(tree->left))
2942         left = geniCodeRValue(left,TRUE);
2943   } else {
2944       left =  operandFromAst(tree->left);
2945   }
2946   if (tree->opval.op == INC_OP ||
2947       tree->opval.op == DEC_OP) {
2948       lvaluereq++;
2949       right= operandFromAst(tree->right);
2950       lvaluereq--;
2951   } else {
2952       right= operandFromAst(tree->right);
2953   }
2954     }
2955
2956     /* now depending on the type of operand */
2957     /* this will be a biggy                 */
2958     switch (tree->opval.op) {
2959
2960     case '[' :    /* array operation */
2961   {
2962       sym_link *ltype = operandType(left);
2963       left= geniCodeRValue (left,IS_PTR(ltype->next) ? TRUE : FALSE);
2964       right=geniCodeRValue (right,TRUE);
2965   }
2966
2967   return geniCodeArray (left,right);
2968
2969     case '.' :   /* structure dereference */
2970   if (IS_PTR(operandType(left)))
2971       left = geniCodeRValue(left,TRUE);
2972   else
2973       left = geniCodeRValue(left,FALSE);
2974
2975   return geniCodeStruct (left,right,tree->lvalue);
2976
2977     case PTR_OP: /* structure pointer dereference */
2978   {
2979       sym_link *pType;
2980       pType = operandType(left);
2981       left = geniCodeRValue(left,TRUE);
2982
2983       setOClass (pType,getSpec(operandType(left)));
2984   }
2985
2986   return geniCodeStruct (left, right,tree->lvalue);
2987
2988     case INC_OP: /* increment operator */
2989   if ( left )
2990       return geniCodePostInc (left);
2991   else
2992       return geniCodePreInc (right);
2993
2994     case DEC_OP: /* decrement operator */
2995   if ( left )
2996       return geniCodePostDec (left);
2997   else
2998       return geniCodePreDec (right);
2999
3000     case '&' : /* bitwise and or address of operator */
3001   if ( right ) { /* this is a bitwise operator   */
3002       left= geniCodeRValue(left,FALSE);
3003       right= geniCodeRValue(right,FALSE);
3004       return geniCodeBitwise (left,right,BITWISEAND,tree->ftype);
3005   } else
3006       return geniCodeAddressOf (left);
3007
3008     case '|': /* bitwise or & xor */
3009     case '^':
3010   return geniCodeBitwise (geniCodeRValue(left,FALSE),
3011         geniCodeRValue(right,FALSE),
3012         tree->opval.op,
3013         tree->ftype);
3014
3015     case '/':
3016   return geniCodeDivision (geniCodeRValue(left,FALSE),
3017          geniCodeRValue(right,FALSE));
3018
3019     case '%' :
3020   return geniCodeModulus (geniCodeRValue(left,FALSE),
3021         geniCodeRValue(right,FALSE));
3022     case '*':
3023   if ( right )
3024       return geniCodeMultiply (geniCodeRValue(left,FALSE),
3025              geniCodeRValue(right,FALSE));
3026   else
3027       return geniCodeDerefPtr (geniCodeRValue(left,FALSE));
3028
3029     case '-' :
3030   if ( right )
3031       return geniCodeSubtract (geniCodeRValue(left,FALSE),
3032              geniCodeRValue(right,FALSE));
3033   else
3034       return geniCodeUnaryMinus (geniCodeRValue(left,FALSE));
3035
3036     case '+' :
3037   if ( right )
3038       return geniCodeAdd (geniCodeRValue(left,FALSE),
3039         geniCodeRValue(right,FALSE));
3040   else
3041       return geniCodeRValue(left,FALSE) ; /* unary '+' has no meaning */
3042
3043     case LEFT_OP:
3044   return geniCodeLeftShift (geniCodeRValue(left,FALSE),
3045           geniCodeRValue(right,FALSE));
3046
3047     case RIGHT_OP:
3048   return geniCodeRightShift (geniCodeRValue(left,FALSE),
3049            geniCodeRValue(right,FALSE));
3050     case CAST:
3051   return geniCodeCast (operandType(left),
3052            geniCodeRValue(right,FALSE),FALSE);
3053
3054     case '~' :
3055     case '!' :
3056     case RRC:
3057     case RLC:
3058   return geniCodeUnary (geniCodeRValue(left,FALSE),tree->opval.op);
3059
3060     case GETHBIT:
3061   {
3062       operand *op = geniCodeUnary (geniCodeRValue(left,FALSE),tree->opval.op);
3063       setOperandType(op, UCHARTYPE);
3064       return op;
3065   }
3066     case '>' :
3067     case '<' :
3068     case LE_OP:
3069     case GE_OP:
3070     case EQ_OP:
3071     case NE_OP:
3072     case AND_OP:
3073     case OR_OP:
3074   return geniCodeLogic (geniCodeRValue(left,FALSE),
3075             geniCodeRValue(right,FALSE),
3076             tree->opval.op);
3077     case '?' :
3078   return geniCodeConditional (tree);
3079
3080     case SIZEOF:
3081   return operandFromLit(getSize(tree->right->ftype));
3082
3083     case '='        :
3084   {
3085       sym_link *rtype = operandType(right);
3086       sym_link *ltype = operandType(left);
3087       if (IS_PTR(rtype) && IS_ITEMP(right)
3088     && right->isaddr && checkType(rtype->next,ltype)==1)
3089     right =  geniCodeRValue(right,TRUE);
3090       else
3091     right = geniCodeRValue(right,FALSE);
3092
3093       geniCodeAssign (left,right,0);
3094       return right ;
3095   }
3096     case MUL_ASSIGN:
3097   return
3098       geniCodeAssign(left,
3099          geniCodeMultiply(geniCodeRValue (operandFromOperand(left),
3100                   FALSE),
3101               geniCodeRValue(right,FALSE)),0);
3102
3103     case DIV_ASSIGN:
3104   return
3105       geniCodeAssign(left,
3106          geniCodeDivision(geniCodeRValue(operandFromOperand(left),
3107                  FALSE),
3108               geniCodeRValue(right,FALSE)),0);
3109     case MOD_ASSIGN:
3110   return
3111       geniCodeAssign(left,
3112          geniCodeModulus(geniCodeRValue(operandFromOperand(left),
3113                 FALSE),
3114              geniCodeRValue(right,FALSE)),0);
3115     case ADD_ASSIGN:
3116   {
3117       sym_link *rtype = operandType(right);
3118       sym_link *ltype = operandType(left);
3119       if (IS_PTR(rtype) && IS_ITEMP(right)
3120     && right->isaddr && checkType(rtype->next,ltype)==1)
3121     right =  geniCodeRValue(right,TRUE);
3122       else
3123     right = geniCodeRValue(right,FALSE);
3124
3125
3126       return geniCodeAssign(left,
3127           geniCodeAdd (geniCodeRValue(operandFromOperand(left),
3128                     FALSE),
3129                  right),0);
3130   }
3131     case SUB_ASSIGN:
3132   {
3133       sym_link *rtype = operandType(right);
3134       sym_link *ltype = operandType(left);
3135       if (IS_PTR(rtype) && IS_ITEMP(right)
3136     && right->isaddr && checkType(rtype->next,ltype)==1) {
3137     right =  geniCodeRValue(right,TRUE);
3138       }
3139       else {
3140     right = geniCodeRValue(right,FALSE);
3141       }
3142       return
3143     geniCodeAssign (left,
3144         geniCodeSubtract(geniCodeRValue(operandFromOperand(left),
3145                 FALSE),
3146              right),0);
3147   }
3148     case LEFT_ASSIGN:
3149   return
3150       geniCodeAssign (left,
3151           geniCodeLeftShift(geniCodeRValue(operandFromOperand(left)
3152                    ,FALSE),
3153                 geniCodeRValue(right,FALSE)),0);
3154     case RIGHT_ASSIGN:
3155     return
3156       geniCodeAssign(left,
3157          geniCodeRightShift(geniCodeRValue(operandFromOperand(left)
3158                    ,FALSE),
3159                 geniCodeRValue(right,FALSE)),0);
3160     case AND_ASSIGN:
3161       return
3162       geniCodeAssign (left,
3163           geniCodeBitwise(geniCodeRValue(operandFromOperand(left),
3164                  FALSE),
3165               geniCodeRValue(right,FALSE),
3166               BITWISEAND,
3167               operandType(left)),0);
3168     case XOR_ASSIGN:
3169       return
3170       geniCodeAssign (left,
3171           geniCodeBitwise (geniCodeRValue(operandFromOperand(left),
3172                   FALSE),
3173                geniCodeRValue(right,FALSE),
3174                '^',
3175                operandType(left)),0);
3176     case OR_ASSIGN:
3177       return
3178       geniCodeAssign (left,
3179           geniCodeBitwise (geniCodeRValue(operandFromOperand(left)
3180                   ,FALSE),
3181                geniCodeRValue(right,FALSE),
3182                '|',
3183                operandType(left)),0);
3184     case ',' :
3185   return geniCodeRValue(right,FALSE);
3186
3187     case CALL:
3188   return geniCodeCall (ast2iCode(tree->left),
3189            tree->right);
3190     case LABEL:
3191   geniCodeLabel(ast2iCode(tree->left)->operand.symOperand);
3192   return ast2iCode (tree->right);
3193
3194     case GOTO:
3195   geniCodeGoto (ast2iCode(tree->left)->operand.symOperand);
3196   return ast2iCode (tree->right);
3197
3198     case FUNCTION:
3199   geniCodeFunctionBody ( tree );
3200   return NULL ;
3201
3202     case RETURN:
3203   geniCodeReturn (right);
3204   return NULL ;
3205
3206     case IFX:
3207   geniCodeIfx (tree);
3208   return NULL ;
3209
3210     case SWITCH:
3211   geniCodeSwitch (tree);
3212   return NULL;
3213
3214     case INLINEASM:
3215   geniCodeInline (tree);
3216   return NULL ;
3217     }
3218
3219     return NULL;
3220 }
3221
3222 /*-----------------------------------------------------------------*/
3223 /* reverseICChain - gets from the list and creates a linkedlist    */
3224 /*-----------------------------------------------------------------*/
3225 iCode *reverseiCChain ()
3226 {
3227     iCode *loop = NULL ;
3228     iCode *prev = NULL ;
3229
3230     while ((loop = getSet(&iCodeChain))) {
3231   loop->next = prev ;
3232   if ( prev )
3233       prev->prev = loop;
3234   prev = loop ;
3235     }
3236
3237     return prev;
3238 }
3239
3240
3241 /*-----------------------------------------------------------------*/
3242 /* iCodeFromAst - given an ast will convert it to iCode            */
3243 /*-----------------------------------------------------------------*/
3244 iCode *iCodeFromAst ( ast *tree )
3245 {
3246     returnLabel = newiTempLabel("_return");
3247     entryLabel  = newiTempLabel("_entry") ;
3248     ast2iCode (tree);
3249     return reverseiCChain ();
3250 }
3251