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

   1 /*-------------------------------------------------------------------------
   2   gen.c - Z80 specific code generator.
   3
   4   Benchmarks on dhry.c 2.1 with 32766 loops and a 10ms clock:
   5             ticks dhry  size
   6   Base with asm strcpy / strcmp / memcpy: 23198 141 1A14
   7   Improved WORD push        22784 144 19AE
   8   With label1 on        22694 144 197E
   9   With label2 on        22743 144 198A
  10   With label3 on        22776 144 1999
  11   With label4 on        22776 144 1999
  12   With all 'label' on       22661 144 196F
  13   With loopInvariant on       20919 156 19AB
  14   With loopInduction on       Breaks    198B
  15   With all working on       20796 158 196C
  16   Slightly better genCmp(signed)    20597 159 195B
  17   Better reg packing, first peephole    20038 163 1873
  18   With assign packing       19281 165 1849
  19   5/3/00          17741 185 17B6
  20   With reg params for mul and div   16234 202 162D
  21
  22   Michael Hope <michaelh@earthling.net> 2000
  23   Based on the mcs51 generator -
  24       Sandeep Dutta . sandeep.dutta@usa.net (1998)
  25    and -  Jean-Louis VERN.jlvern@writeme.com (1999)
  26
  27   This program is free software; you can redistribute it and/or modify it
  28   under the terms of the GNU General Public License as published by the
  29   Free Software Foundation; either version 2, or (at your option) any
  30   later version.
  31
  32   This program is distributed in the hope that it will be useful,
  33   but WITHOUT ANY WARRANTY; without even the implied warranty of
  34   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  35   GNU General Public License for more details.
  36
  37
  38   You should have received a copy of the GNU General Public License
  39   along with this program; if not, write to the Free Software
  40   Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  41
  42   In other words, you are welcome to use, share and improve this program.
  43   You are forbidden to forbid anyone else to use, share and improve
  44   what you give them.   Help stamp out software-hoarding!
  45
  46 -------------------------------------------------------------------------*/
  47
  48 #include <stdio.h>
  49 #include <stdlib.h>
  50 #include <string.h>
  51 #include <ctype.h>
  52
  53 #ifdef HAVE_SYS_ISA_DEFS_H
  54 #include <sys/isa_defs.h>
  55 #endif
  56
  57 #include "z80.h"
  58 #include "SDCCglobl.h"
  59 #include "SDCCpeeph.h"
  60 #include "gen.h"
  61 #include "SDCCglue.h"
  62 #include "newalloc.h"
  63
  64 /* this is the down and dirty file with all kinds of kludgy & hacky
  65    stuff. This is what it is all about CODE GENERATION for a specific MCU.
  66    Some of the routines may be reusable, will have to see */
  67
  68 static char *spname ;
  69 static char *_z80_return[] = {"l", "h", "e", "d" };
  70 static char *_gbz80_return[] = { "e", "d", "l", "h" };
  71 static char **_fReturn;
  72 static char **_fTmp;
  73
  74 /* PENDING: messy */
  75 static char zero[20];
  76
  77 static char *accUse[] = {"a" };
  78 static char *hlUse[] = { "l", "h" };
  79 short rbank = -1;
  80 short accInUse = 0 ;
  81 short inLine = 0;
  82 short debugLine = 0;
  83 short nregssaved = 0;
  84 extern int ptrRegReq ;
  85 extern int nRegs;
  86 extern FILE *codeOutFile;
  87 set *sendSet = NULL;
  88
  89 typedef enum {
  90     PAIR_INVALID,
  91     PAIR_BC,
  92     PAIR_DE,
  93     PAIR_HL,
  94     PAIR_IY,
  95     PAIR_IX,
  96     NUM_PAIRS
  97 } PAIR_ID;
  98
  99 static struct {
 100     const char *name;
 101     const char *l;
 102     const char *h;
 103 } _pairs[NUM_PAIRS] = {
 104     { "??", "?", "?" },
 105     { "bc", "c", "b" },
 106     { "de", "e", "d" },
 107     { "hl", "l", "h" },
 108     { "iy", "iy.l?", "iy.h?" },
 109     { "ix", "ix.l?", "ix.h?" }
 110 };
 111
 112 #define RESULTONSTACK(x) \
 113                          (IC_RESULT(x) && IC_RESULT(x)->aop && \
 114                          IC_RESULT(x)->aop->type == AOP_STK )
 115
 116 #define MOVA(x) if (strcmp(x,"a")) emitcode("ld","a,%s",x);
 117 #define CLRC    emitcode("xor","a,a");
 118
 119 lineNode *lineHead = NULL;
 120 lineNode *lineCurr = NULL;
 121
 122 static const unsigned char SLMask[] =
 123 {0xFF ,0xFE, 0xFC, 0xF8, 0xF0, 0xE0, 0xC0, 0x80, 0x00};
 124 static const unsigned char SRMask[] =
 125 {0xFF, 0x7F, 0x3F, 0x1F, 0x0F, 0x07, 0x03, 0x01, 0x00};
 126
 127 #define LSB     0
 128 #define MSB16   1
 129 #define MSB24   2
 130 #define MSB32   3
 131
 132 /* Stack frame:
 133    IX+4   param0  LH
 134    IX+2   ret LH
 135    IX+0   ix  LH
 136    IX-2   temp0 LH
 137 */
 138
 139 static struct {
 140     struct {
 141   AOP_TYPE last_type;
 142   const char *lit;
 143   int offset;
 144     } pairs[NUM_PAIRS];
 145     struct {
 146   int last;
 147   int pushed;
 148   int param_offset;
 149   int offset;
 150   int pushed_bc;
 151   int pushed_de;
 152     } stack;
 153     int frameId;
 154     bool flush_statics;
 155     bool in_home;
 156 } _G;
 157
 158 static char *aopGet(asmop *aop, int offset, bool bit16);
 159
 160 static void _tidyUp(char *buf)
 161 {
 162     /* Clean up the line so that it is 'prettier' */
 163     if (strchr(buf, ':')) {
 164   /* Is a label - cant do anything */
 165   return;
 166     }
 167     /* Change the first (and probably only) ' ' to a tab so
 168        everything lines up.
 169     */
 170     while (*buf) {
 171   if (*buf == ' ') {
 172       *buf = '\t';
 173       return;
 174   }
 175   buf++;
 176     }
 177 }
 178
 179 static void emit2(const char *szFormat, ...)
 180 {
 181     char buffer[256];
 182     va_list ap;
 183
 184     va_start(ap, szFormat);
 185
 186     tvsprintf(buffer, szFormat, ap);
 187
 188     _tidyUp(buffer);
 189     lineCurr = (lineCurr ?
 190     connectLine(lineCurr,newLineNode(buffer)) :
 191     (lineHead = newLineNode(buffer)));
 192
 193     lineCurr->isInline = inLine;
 194     lineCurr->isDebug  = debugLine;
 195 }
 196
 197 /*-----------------------------------------------------------------*/
 198 /* emitcode - writes the code into a file : for now it is simple    */
 199 /*-----------------------------------------------------------------*/
 200 void emitcode (const char *inst, const char *fmt, ...)
 201 {
 202     va_list ap;
 203     char lb[MAX_INLINEASM];
 204     char *lbp = lb;
 205
 206     va_start(ap,fmt);
 207
 208     if (*inst != '\0') {
 209         sprintf(lb,"%s\t",inst);
 210         vsprintf(lb+(strlen(lb)),fmt,ap);
 211     }  else
 212         vsprintf(lb,fmt,ap);
 213
 214     while (isspace(*lbp)) lbp++;
 215
 216     if (lbp && *lbp)
 217         lineCurr = (lineCurr ?
 218                     connectLine(lineCurr,newLineNode(lb)) :
 219                     (lineHead = newLineNode(lb)));
 220     lineCurr->isInline = inLine;
 221     lineCurr->isDebug  = debugLine;
 222     va_end(ap);
 223 }
 224
 225 /* Z80:
 226     { "adjustsp",
 227       "\tld hl,#-%d\n"
 228       "\tadd hl,sp\n"
 229       "\tld sp,hl"
 230     }
 231     { "prelude",
 232   "push bc"
 233   "push de"
 234   "push ix"
 235   "ld ix,#0"
 236   "add ix,sp"
 237     { "leave"
 238     emitcode("ld", "sp,ix");
 239     emitcode("pop", "ix");
 240     emitcode("pop", "de");
 241     }
 242 }
 243 */
 244
 245 const char *getPairName(asmop *aop)
 246 {
 247     if (aop->type == AOP_REG) {
 248   switch (aop->aopu.aop_reg[0]->rIdx) {
 249   case C_IDX:
 250       return "bc";
 251       break;
 252   case E_IDX:
 253       return "de";
 254       break;
 255   case L_IDX:
 256       return "hl";
 257       break;
 258   }
 259     }
 260     else if (aop->type == AOP_STR) {
 261   switch (*aop->aopu.aop_str[0]) {
 262   case 'c':
 263       return "bc";
 264       break;
 265   case 'e':
 266       return "de";
 267       break;
 268   case 'l':
 269       return "hl";
 270       break;
 271   }
 272     }
 273     wassert(0);
 274     return NULL;
 275 }
 276
 277 static PAIR_ID getPairId(asmop *aop)
 278 {
 279     if (aop->size == 2) {
 280   if (aop->type == AOP_REG) {
 281       if ((aop->aopu.aop_reg[0]->rIdx == C_IDX)&&(aop->aopu.aop_reg[1]->rIdx == B_IDX)) {
 282     return PAIR_BC;
 283       }
 284       if ((aop->aopu.aop_reg[0]->rIdx == E_IDX)&&(aop->aopu.aop_reg[1]->rIdx == D_IDX)) {
 285     return PAIR_DE;
 286       }
 287       if ((aop->aopu.aop_reg[0]->rIdx == L_IDX)&&(aop->aopu.aop_reg[1]->rIdx == H_IDX)) {
 288     return PAIR_HL;
 289       }
 290   }
 291   if (aop->type == AOP_STR) {
 292       if (!strcmp(aop->aopu.aop_str[0], "c")&&!strcmp(aop->aopu.aop_str[1], "b")) {
 293     return PAIR_BC;
 294       }
 295       if (!strcmp(aop->aopu.aop_str[0], "e")&&!strcmp(aop->aopu.aop_str[1], "d")) {
 296     return PAIR_DE;
 297       }
 298       if (!strcmp(aop->aopu.aop_str[0], "l")&&!strcmp(aop->aopu.aop_str[1], "h")) {
 299     return PAIR_HL;
 300       }
 301   }
 302     }
 303     return PAIR_INVALID;
 304 }
 305
 306 /** Returns TRUE if the registers used in aop form a pair (BC, DE, HL) */
 307 bool isPair(asmop *aop)
 308 {
 309     return (getPairId(aop) != PAIR_INVALID);
 310 }
 311
 312 bool isPtrPair(asmop *aop)
 313 {
 314     PAIR_ID pairId = getPairId(aop);
 315     switch (pairId) {
 316     case PAIR_HL:
 317     case PAIR_IY:
 318     case PAIR_IX:
 319   return TRUE;
 320     default:
 321   return FALSE;
 322     }
 323 }
 324 /** Push a register pair onto the stack */
 325 void genPairPush(asmop *aop)
 326 {
 327     emitcode("push", "%s", getPairName(aop));
 328 }
 329
 330
 331 /*-----------------------------------------------------------------*/
 332 /* newAsmop - creates a new asmOp                                  */
 333 /*-----------------------------------------------------------------*/
 334 static asmop *newAsmop (short type)
 335 {
 336     asmop *aop;
 337
 338     aop = Safe_calloc(1,sizeof(asmop));
 339     aop->type = type;
 340     return aop;
 341 }
 342
 343 /*-----------------------------------------------------------------*/
 344 /* aopForSym - for a true symbol                                   */
 345 /*-----------------------------------------------------------------*/
 346 static asmop *aopForSym (iCode *ic,symbol *sym,bool result, bool requires_a)
 347 {
 348     asmop *aop;
 349     memmap *space;
 350
 351     wassert(ic);
 352     wassert(sym);
 353     wassert(sym->etype);
 354
 355     space = SPEC_OCLS(sym->etype);
 356
 357     /* if already has one */
 358     if (sym->aop)
 359         return sym->aop;
 360
 361     /* Assign depending on the storage class */
 362     if (sym->onStack || sym->iaccess) {
 363   emitcode("", "; AOP_STK for %s", sym->rname);
 364         sym->aop = aop = newAsmop(AOP_STK);
 365         aop->size = getSize(sym->type);
 366   aop->aopu.aop_stk = sym->stack;
 367         return aop;
 368     }
 369
 370     /* special case for a function */
 371     if (IS_FUNC(sym->type)) {
 372         sym->aop = aop = newAsmop(AOP_IMMD);
 373         aop->aopu.aop_immd = Safe_calloc(1,strlen(sym->rname)+1);
 374         strcpy(aop->aopu.aop_immd,sym->rname);
 375         aop->size = 2;
 376         return aop;
 377     }
 378
 379     if (IS_GB) {
 380   /* if it is in direct space */
 381   if (IN_REGSP(space) && !requires_a) {
 382       sym->aop = aop = newAsmop (AOP_SFR);
 383       aop->aopu.aop_dir = sym->rname ;
 384       aop->size = getSize(sym->type);
 385       emitcode("", "; AOP_SFR for %s", sym->rname);
 386       return aop;
 387   }
 388     }
 389
 390     /* only remaining is far space */
 391     /* in which case DPTR gets the address */
 392     if (IS_GB) {
 393   emitcode("", "; AOP_HL for %s", sym->rname);
 394   sym->aop = aop = newAsmop(AOP_HL);
 395     }
 396     else {
 397   sym->aop = aop = newAsmop(AOP_IY);
 398     }
 399     aop->size = getSize(sym->type);
 400     aop->aopu.aop_dir = sym->rname;
 401
 402     /* if it is in code space */
 403     if (IN_CODESPACE(space))
 404         aop->code = 1;
 405
 406     return aop;
 407 }
 408
 409 /*-----------------------------------------------------------------*/
 410 /* aopForRemat - rematerialzes an object                           */
 411 /*-----------------------------------------------------------------*/
 412 static asmop *aopForRemat (symbol *sym)
 413 {
 414     char *s = buffer;
 415     iCode *ic = sym->rematiCode;
 416     asmop *aop = newAsmop(AOP_IMMD);
 417
 418     while (1) {
 419         /* if plus or minus print the right hand side */
 420         if (ic->op == '+' || ic->op == '-') {
 421       /* PENDING: for re-target */
 422             sprintf(s,"0x%04x %c ",(int) operandLitValue(IC_RIGHT(ic)),
 423                     ic->op );
 424             s += strlen(s);
 425             ic = OP_SYMBOL(IC_LEFT(ic))->rematiCode;
 426             continue ;
 427         }
 428         /* we reached the end */
 429         sprintf(s,"%s",OP_SYMBOL(IC_LEFT(ic))->rname);
 430         break;
 431     }
 432
 433     aop->aopu.aop_immd = Safe_calloc(1,strlen(buffer)+1);
 434     strcpy(aop->aopu.aop_immd,buffer);
 435     return aop;
 436 }
 437
 438 /*-----------------------------------------------------------------*/
 439 /* regsInCommon - two operands have some registers in common       */
 440 /*-----------------------------------------------------------------*/
 441 bool regsInCommon (operand *op1, operand *op2)
 442 {
 443     symbol *sym1, *sym2;
 444     int i;
 445
 446     /* if they have registers in common */
 447     if (!IS_SYMOP(op1) || !IS_SYMOP(op2))
 448         return FALSE ;
 449
 450     sym1 = OP_SYMBOL(op1);
 451     sym2 = OP_SYMBOL(op2);
 452
 453     if (sym1->nRegs == 0 || sym2->nRegs == 0)
 454         return FALSE ;
 455
 456     for (i = 0 ; i < sym1->nRegs ; i++) {
 457         int j;
 458         if (!sym1->regs[i])
 459             continue ;
 460
 461         for (j = 0 ; j < sym2->nRegs ;j++ ) {
 462             if (!sym2->regs[j])
 463                 continue ;
 464
 465             if (sym2->regs[j] == sym1->regs[i])
 466                 return TRUE ;
 467         }
 468     }
 469
 470     return FALSE ;
 471 }
 472
 473 /*-----------------------------------------------------------------*/
 474 /* operandsEqu - equivalent                                        */
 475 /*-----------------------------------------------------------------*/
 476 bool operandsEqu ( operand *op1, operand *op2)
 477 {
 478     symbol *sym1, *sym2;
 479
 480     /* if they not symbols */
 481     if (!IS_SYMOP(op1) || !IS_SYMOP(op2))
 482         return FALSE;
 483
 484     sym1 = OP_SYMBOL(op1);
 485     sym2 = OP_SYMBOL(op2);
 486
 487     /* if both are itemps & one is spilt
 488        and the other is not then false */
 489     if (IS_ITEMP(op1) && IS_ITEMP(op2) &&
 490   sym1->isspilt != sym2->isspilt )
 491   return FALSE ;
 492
 493     /* if they are the same */
 494     if (sym1 == sym2)
 495         return 1;
 496
 497     if (strcmp(sym1->rname,sym2->rname) == 0)
 498         return 2;
 499
 500
 501     /* if left is a tmp & right is not */
 502     if (IS_ITEMP(op1)  &&
 503         !IS_ITEMP(op2) &&
 504         sym1->isspilt  &&
 505         (sym1->usl.spillLoc == sym2))
 506         return 3;
 507
 508     if (IS_ITEMP(op2)  &&
 509         !IS_ITEMP(op1) &&
 510         sym2->isspilt  &&
 511   sym1->level > 0 &&
 512         (sym2->usl.spillLoc == sym1))
 513         return 4;
 514
 515     return FALSE;
 516 }
 517
 518 /*-----------------------------------------------------------------*/
 519 /* sameRegs - two asmops have the same registers                   */
 520 /*-----------------------------------------------------------------*/
 521 bool sameRegs (asmop *aop1, asmop *aop2 )
 522 {
 523     int i;
 524
 525     if (aop1->type == AOP_SFR ||
 526   aop2->type == AOP_SFR)
 527   return FALSE;
 528
 529     if (aop1 == aop2)
 530         return TRUE;
 531
 532     if (aop1->type != AOP_REG ||
 533         aop2->type != AOP_REG )
 534         return FALSE;
 535
 536     if (aop1->size != aop2->size)
 537         return FALSE ;
 538
 539     for (i = 0 ; i < aop1->size ; i++ )
 540         if (aop1->aopu.aop_reg[i] !=
 541             aop2->aopu.aop_reg[i] )
 542             return FALSE ;
 543
 544     return TRUE ;
 545 }
 546
 547 /*-----------------------------------------------------------------*/
 548 /* aopOp - allocates an asmop for an operand  :                    */
 549 /*-----------------------------------------------------------------*/
 550 static void aopOp (operand *op, iCode *ic, bool result, bool requires_a)
 551 {
 552     asmop *aop;
 553     symbol *sym;
 554     int i;
 555
 556     if (!op)
 557         return ;
 558
 559     /* if this a literal */
 560     if (IS_OP_LITERAL(op)) {
 561         op->aop = aop = newAsmop(AOP_LIT);
 562         aop->aopu.aop_lit = op->operand.valOperand;
 563         aop->size = getSize(operandType(op));
 564         return;
 565     }
 566
 567     /* if already has a asmop then continue */
 568     if (op->aop)
 569         return ;
 570
 571     /* if the underlying symbol has a aop */
 572     if (IS_SYMOP(op) && OP_SYMBOL(op)->aop) {
 573         op->aop = OP_SYMBOL(op)->aop;
 574         return;
 575     }
 576
 577     /* if this is a true symbol */
 578     if (IS_TRUE_SYMOP(op)) {
 579         op->aop = aopForSym(ic, OP_SYMBOL(op), result, requires_a);
 580         return ;
 581     }
 582
 583     /* this is a temporary : this has
 584     only four choices :
 585     a) register
 586     b) spillocation
 587     c) rematerialize
 588     d) conditional
 589     e) can be a return use only */
 590
 591     sym = OP_SYMBOL(op);
 592
 593     /* if the type is a conditional */
 594     if (sym->regType == REG_CND) {
 595         aop = op->aop = sym->aop = newAsmop(AOP_CRY);
 596         aop->size = 0;
 597         return;
 598     }
 599
 600     /* if it is spilt then two situations
 601     a) is rematerialize
 602     b) has a spill location */
 603     if (sym->isspilt || sym->nRegs == 0) {
 604         /* rematerialize it NOW */
 605         if (sym->remat) {
 606             sym->aop = op->aop = aop =
 607                                       aopForRemat (sym);
 608             aop->size = getSize(sym->type);
 609             return;
 610         }
 611
 612   if (sym->accuse) {
 613       int i;
 614       if (sym->accuse == ACCUSE_A) {
 615     aop = op->aop = sym->aop = newAsmop(AOP_ACC);
 616     aop->size = getSize(sym->type);
 617     for ( i = 0 ; i < 2 ; i++ )
 618         aop->aopu.aop_str[i] = accUse[i];
 619       }
 620       else if (sym->accuse == ACCUSE_HL) {
 621     wassert(!IS_GB);
 622     aop = op->aop = sym->aop = newAsmop(AOP_HLREG);
 623     aop->size = getSize(sym->type);
 624     for ( i = 0 ; i < 2 ; i++ )
 625         aop->aopu.aop_str[i] = hlUse[i];
 626       }
 627       else
 628     wassert(0);
 629       return;
 630   }
 631
 632         if (sym->ruonly ) {
 633             int i;
 634             aop = op->aop = sym->aop = newAsmop(AOP_STR);
 635             aop->size = getSize(sym->type);
 636             for ( i = 0 ; i < 4 ; i++ )
 637                 aop->aopu.aop_str[i] = _fReturn[i];
 638             return;
 639         }
 640
 641         /* else spill location  */
 642         sym->aop = op->aop = aop =
 643                                   aopForSym(ic,sym->usl.spillLoc,result, requires_a);
 644         aop->size = getSize(sym->type);
 645         return;
 646     }
 647
 648     /* must be in a register */
 649     sym->aop = op->aop = aop = newAsmop(AOP_REG);
 650     aop->size = sym->nRegs;
 651     for ( i = 0 ; i < sym->nRegs ;i++)
 652         aop->aopu.aop_reg[i] = sym->regs[i];
 653 }
 654
 655 /*-----------------------------------------------------------------*/
 656 /* freeAsmop - free up the asmop given to an operand               */
 657 /*----------------------------------------------------------------*/
 658 static void freeAsmop (operand *op, asmop *aaop, iCode *ic)
 659 {
 660     asmop *aop ;
 661
 662     if (!op)
 663         aop = aaop;
 664     else
 665         aop = op->aop;
 666
 667     if (!aop)
 668         return ;
 669
 670     if (aop->freed)
 671         goto dealloc;
 672
 673     aop->freed = 1;
 674
 675 dealloc:
 676     /* all other cases just dealloc */
 677     if (op ) {
 678         op->aop = NULL;
 679         if (IS_SYMOP(op)) {
 680             OP_SYMBOL(op)->aop = NULL;
 681             /* if the symbol has a spill */
 682       if (SPIL_LOC(op))
 683                 SPIL_LOC(op)->aop = NULL;
 684         }
 685     }
 686 }
 687
 688 bool isLitWord(asmop *aop)
 689 {
 690     /*    if (aop->size != 2)
 691     return FALSE;*/
 692     switch (aop->type) {
 693     case AOP_IMMD:
 694     case AOP_LIT:
 695   return TRUE;
 696     default:
 697   return FALSE;
 698     }
 699 }
 700
 701 char *aopGetLitWordLong(asmop *aop, int offset, bool with_hash)
 702 {
 703     char *s = buffer ;
 704     char *rs;
 705
 706 #if 0
 707     if (aop->size != 2 && aop->type != AOP_HL)
 708   return NULL;
 709 #endif
 710     /* depending on type */
 711     switch (aop->type) {
 712     case AOP_HL:
 713     case AOP_IY:
 714     case AOP_IMMD:
 715   /* PENDING: for re-target */
 716   if (with_hash)
 717       tsprintf(s, "!hashedstr + %d", aop->aopu.aop_immd, offset);
 718   else
 719       tsprintf(s, "%s + %d", aop->aopu.aop_immd, offset);
 720   rs = Safe_calloc(1,strlen(s)+1);
 721   strcpy(rs,s);
 722   return rs;
 723     case AOP_LIT: {
 724   value * val = aop->aopu.aop_lit;
 725   /* if it is a float then it gets tricky */
 726   /* otherwise it is fairly simple */
 727   if (!IS_FLOAT(val->type)) {
 728       unsigned long v = floatFromVal(val);
 729
 730       if (offset == 2)
 731     v >>= 16;
 732
 733       if (with_hash)
 734     tsprintf(buffer, "!immedword", v);
 735       else
 736     tsprintf(buffer, "!constword", v);
 737       rs = Safe_calloc(1,strlen(buffer)+1);
 738       return strcpy (rs,buffer);
 739   }
 740   else {
 741       /* A float */
 742       Z80_FLOAT f;
 743       convertFloat(&f, floatFromVal(val));
 744       if (with_hash)
 745     tsprintf(buffer, "!immedword", f.w[offset/2]);
 746       else
 747     tsprintf(buffer, "!constword", f.w[offset/2]);
 748       rs = Safe_calloc(1,strlen(buffer)+1);
 749       return strcpy (rs,buffer);
 750   }
 751     }
 752     default:
 753   return NULL;
 754     }
 755 }
 756
 757 char *aopGetWord(asmop *aop, int offset)
 758 {
 759     return aopGetLitWordLong(aop, offset, TRUE);
 760 }
 761
 762 bool isPtr(const char *s)
 763 {
 764     if (!strcmp(s, "hl"))
 765   return TRUE;
 766     if (!strcmp(s, "ix"))
 767   return TRUE;
 768     if (!strcmp(s, "iy"))
 769   return TRUE;
 770     return FALSE;
 771 }
 772
 773 static void adjustPair(const char *pair, int *pold, int new)
 774 {
 775     wassert(pair);
 776
 777     while (*pold < new) {
 778   emitcode("inc", "%s", pair);
 779   (*pold)++;
 780     }
 781     while (*pold > new) {
 782   emitcode("dec", "%s", pair);
 783   (*pold)--;
 784     }
 785 }
 786
 787 static void spillPair(PAIR_ID pairId)
 788 {
 789     _G.pairs[pairId].last_type = AOP_INVALID;
 790     _G.pairs[pairId].lit = NULL;
 791 }
 792
 793 static void spillCached(void)
 794 {
 795     spillPair(PAIR_HL);
 796     spillPair(PAIR_IY);
 797 }
 798
 799 static bool requiresHL(asmop *aop)
 800 {
 801     switch (aop->type) {
 802     case AOP_HL:
 803     case AOP_STK:
 804   return TRUE;
 805     default:
 806   return FALSE;
 807     }
 808 }
 809
 810 static char *fetchLitSpecial(asmop *aop, bool negate, bool xor)
 811 {
 812     unsigned long v;
 813     value * val = aop->aopu.aop_lit;
 814
 815     wassert(aop->type == AOP_LIT);
 816     wassert(!IS_FLOAT(val->type));
 817
 818     v = floatFromVal(val);
 819
 820     if (xor)
 821   v ^= 0x8000;
 822     if (negate)
 823   v = -v;
 824     v &= 0xFFFF;
 825
 826     tsprintf(buffer, "!immedword", v);
 827     return gc_strdup(buffer);
 828 }
 829
 830 static void fetchLitPair(PAIR_ID pairId, asmop *left, int offset)
 831 {
 832     const char *l;
 833     const char *pair = _pairs[pairId].name;
 834     l = aopGetLitWordLong(left, 0, FALSE);
 835     wassert(l && pair);
 836
 837     if (isPtr(pair)) {
 838   if (pairId == PAIR_HL || pairId == PAIR_IY) {
 839       if (_G.pairs[pairId].last_type == left->type) {
 840     if (_G.pairs[pairId].lit && !strcmp(_G.pairs[pairId].lit, l)) {
 841         if (pairId == PAIR_HL && abs(_G.pairs[pairId].offset - offset) < 3) {
 842       adjustPair(pair, &_G.pairs[pairId].offset, offset);
 843       return;
 844         }
 845         if (pairId == PAIR_IY && abs(offset)<127) {
 846       return;
 847         }
 848     }
 849       }
 850   }
 851   _G.pairs[pairId].last_type = left->type;
 852   _G.pairs[pairId].lit = gc_strdup(l);
 853   _G.pairs[pairId].offset = offset;
 854     }
 855     if (IS_GB && pairId == PAIR_DE && 0) {
 856   if (_G.pairs[pairId].lit && !strcmp(_G.pairs[pairId].lit, l)) {
 857       if (abs(_G.pairs[pairId].offset - offset) < 3) {
 858     adjustPair(pair, &_G.pairs[pairId].offset, offset);
 859     return;
 860       }
 861   }
 862   _G.pairs[pairId].last_type = left->type;
 863   _G.pairs[pairId].lit = gc_strdup(l);
 864   _G.pairs[pairId].offset = offset;
 865     }
 866     /* Both a lit on the right and a true symbol on the left */
 867     if (offset)
 868   emit2("ld %s,!hashedstr + %u", pair, l, offset);
 869     else
 870   emit2("ld %s,!hashedstr", pair, l);
 871 }
 872
 873 static void fetchPairLong(PAIR_ID pairId, asmop *aop, int offset)
 874 {
 875     /* if this is remateriazable */
 876     if (isLitWord(aop)) {
 877   fetchLitPair(pairId, aop, offset);
 878     }
 879     else { /* we need to get it byte by byte */
 880   if (pairId == PAIR_HL && IS_GB && requiresHL(aop)) {
 881       aopGet(aop, offset, FALSE);
 882       switch (aop->size) {
 883       case 1:
 884     emit2("ld l,!*hl");
 885     emit2("ld h,!immedbyte", 0);
 886     break;
 887       case 2:
 888     emit2("!ldahli");
 889     emit2("ld h,!*hl");
 890     emit2("ld l,a");
 891     break;
 892       default:
 893     emit2("; WARNING: mlh woosed out.  This code is invalid.");
 894       }
 895   }
 896   else if (IS_Z80 && aop->type == AOP_IY) {
 897       /* Instead of fetching relative to IY, just grab directly
 898          from the address IY refers to */
 899       char *l = aopGetLitWordLong(aop, offset, FALSE);
 900       wassert(l);
 901       emit2("ld %s,(%s)", _pairs[pairId].name, l);
 902   }
 903   else {
 904       emitcode("ld", "%s,%s", _pairs[pairId].l, aopGet(aop, offset, FALSE));
 905       emitcode("ld", "%s,%s", _pairs[pairId].h, aopGet(aop, offset+1, FALSE));
 906   }
 907   /* PENDING: check? */
 908   if (pairId == PAIR_HL)
 909       spillPair(PAIR_HL);
 910     }
 911 }
 912
 913 static void fetchPair(PAIR_ID pairId, asmop *aop)
 914 {
 915     fetchPairLong(pairId, aop, 0);
 916 }
 917
 918 static void fetchHL(asmop *aop)
 919 {
 920     fetchPair(PAIR_HL, aop);
 921 }
 922
 923 static void setupPair(PAIR_ID pairId, asmop *aop, int offset)
 924 {
 925     assert(pairId == PAIR_HL || pairId == PAIR_IY);
 926
 927     switch (aop->type) {
 928     case AOP_IY:
 929   fetchLitPair(pairId, aop, 0);
 930   break;
 931     case AOP_HL:
 932   fetchLitPair(pairId, aop, offset);
 933   _G.pairs[pairId].offset = offset;
 934   break;
 935     case AOP_STK: {
 936   /* Doesnt include _G.stack.pushed */
 937   int abso = aop->aopu.aop_stk + offset + _G.stack.offset;
 938   if (aop->aopu.aop_stk > 0) {
 939       abso += _G.stack.param_offset;
 940   }
 941   assert(pairId == PAIR_HL);
 942   /* In some cases we can still inc or dec hl */
 943   if (_G.pairs[pairId].last_type == AOP_STK && abs(_G.pairs[pairId].offset - abso) < 3) {
 944       adjustPair(_pairs[pairId].name, &_G.pairs[pairId].offset, abso);
 945   }
 946   else {
 947       emit2("!ldahlsp", abso +_G.stack.pushed);
 948   }
 949   _G.pairs[pairId].offset = abso;
 950   break;
 951     }
 952     default:
 953   wassert(0);
 954     }
 955     _G.pairs[pairId].last_type = aop->type;
 956 }
 957
 958 static void emitLabel(int key)
 959 {
 960     emit2("!tlabeldef", key);
 961     spillCached();
 962 }
 963
 964 /*-----------------------------------------------------------------*/
 965 /* aopGet - for fetching value of the aop                          */
 966 /*-----------------------------------------------------------------*/
 967 static char *aopGet(asmop *aop, int offset, bool bit16)
 968 {
 969     char *s = buffer ;
 970     char *rs;
 971
 972     /* offset is greater than size then zero */
 973     /* PENDING: this seems a bit screwed in some pointer cases. */
 974     if (offset > (aop->size - 1) &&
 975         aop->type != AOP_LIT)
 976         return zero;
 977
 978     /* depending on type */
 979     switch (aop->type) {
 980     case AOP_IMMD:
 981   /* PENDING: re-target */
 982   if (bit16)
 983       tsprintf (s,"!immedwords", aop->aopu.aop_immd);
 984   else
 985       switch (offset) {
 986       case 2:
 987     tsprintf(s, "!bankimmeds", aop->aopu.aop_immd);
 988     break;
 989       case 1:
 990     tsprintf(s, "!msbimmeds", aop->aopu.aop_immd);
 991     break;
 992       case 0:
 993     tsprintf(s, "!lsbimmeds", aop->aopu.aop_immd);
 994     break;
 995       default:
 996     wassert(0);
 997       }
 998   rs = Safe_calloc(1,strlen(s)+1);
 999   strcpy(rs,s);
1000   return rs;
1001
1002     case AOP_DIR:
1003   wassert(IS_GB);
1004   emitcode("ld", "a,(%s+%d) ; x", aop->aopu.aop_dir, offset);
1005   sprintf(s, "a");
1006   rs = Safe_calloc(1,strlen(s)+1);
1007   strcpy(rs,s);
1008   return rs;
1009
1010     case AOP_SFR:
1011   wassert(IS_GB);
1012   emitcode("ldh", "a,(%s+%d) ; x", aop->aopu.aop_dir, offset);
1013   sprintf(s, "a");
1014   rs = Safe_calloc(1,strlen(s)+1);
1015   strcpy(rs,s);
1016   return rs;
1017
1018     case AOP_REG:
1019   return aop->aopu.aop_reg[offset]->name;
1020
1021     case AOP_HL:
1022   wassert(IS_GB);
1023   setupPair(PAIR_HL, aop, offset);
1024   tsprintf(s, "!*hl");
1025   return gc_strdup(s);
1026
1027     case AOP_IY:
1028   wassert(IS_Z80);
1029   setupPair(PAIR_IY, aop, offset);
1030   tsprintf(s,"!*iyx", offset);
1031   rs = Safe_calloc(1,strlen(s)+1);
1032   strcpy(rs,s);
1033   return rs;
1034
1035     case AOP_STK:
1036   if (IS_GB) {
1037       setupPair(PAIR_HL, aop, offset);
1038       tsprintf(s, "!*hl");
1039   }
1040   else {
1041       if (aop->aopu.aop_stk >= 0)
1042     offset += _G.stack.param_offset;
1043       tsprintf(s,"!*ixx ; x", aop->aopu.aop_stk+offset);
1044   }
1045   rs = Safe_calloc(1,strlen(s)+1);
1046   strcpy(rs,s);
1047   return rs;
1048
1049     case AOP_CRY:
1050   wassert(0);
1051
1052     case AOP_ACC:
1053   if (!offset) {
1054       return "a";
1055   }
1056   return "!zero";
1057
1058     case AOP_HLREG:
1059   wassert(offset < 2);
1060   return aop->aopu.aop_str[offset];
1061
1062     case AOP_LIT:
1063   return aopLiteral (aop->aopu.aop_lit,offset);
1064
1065     case AOP_STR:
1066   aop->coff = offset;
1067   return aop->aopu.aop_str[offset];
1068     default:
1069   break;
1070     }
1071     wassertl(0, "aopget got unsupported aop->type");
1072     exit(0);
1073 }
1074
1075 bool isRegString(const char *s)
1076 {
1077     if (!strcmp(s, "b") ||
1078   !strcmp(s, "c") ||
1079   !strcmp(s, "d") ||
1080   !strcmp(s, "e") ||
1081   !strcmp(s, "a") ||
1082   !strcmp(s, "h") ||
1083   !strcmp(s, "l"))
1084   return TRUE;
1085     return FALSE;
1086 }
1087
1088 bool isConstant(const char *s)
1089 {
1090     /* This is a bit of a hack... */
1091     return  (*s == '#' || *s == '$');
1092 }
1093
1094 bool canAssignToPtr(const char *s)
1095 {
1096     if (isRegString(s))
1097   return TRUE;
1098     if (isConstant(s))
1099   return TRUE;
1100     return FALSE;
1101 }
1102
1103 /*-----------------------------------------------------------------*/
1104 /* aopPut - puts a string for a aop                                */
1105 /*-----------------------------------------------------------------*/
1106 static void aopPut (asmop *aop, const char *s, int offset)
1107 {
1108     if (aop->size && offset > ( aop->size - 1)) {
1109         werror(E_INTERNAL_ERROR,__FILE__,__LINE__,
1110                "aopPut got offset > aop->size");
1111         exit(0);
1112     }
1113
1114     /* will assign value to value */
1115     /* depending on where it is ofcourse */
1116     switch (aop->type) {
1117     case AOP_DIR:
1118   /* Direct.  Hmmm. */
1119   wassert(IS_GB);
1120   if (strcmp(s, "a"))
1121       emitcode("ld", "a,%s", s);
1122   emitcode("ld", "(%s+%d),a", aop->aopu.aop_dir, offset);
1123   break;
1124
1125     case AOP_SFR:
1126   wassert(IS_GB);
1127   if (strcmp(s, "a"))
1128       emitcode("ld", "a,%s", s);
1129   emitcode("ldh", "(%s+%d),a", aop->aopu.aop_dir, offset);
1130   break;
1131
1132     case AOP_REG:
1133   if (!strcmp(s, "!*hl"))
1134       emit2("ld %s,!*hl", aop->aopu.aop_reg[offset]->name);
1135   else
1136       emit2("ld %s,%s",
1137       aop->aopu.aop_reg[offset]->name, s);
1138   break;
1139
1140     case AOP_IY:
1141   wassert(!IS_GB);
1142   setupPair(PAIR_IY, aop, offset);
1143   if (!canAssignToPtr(s)) {
1144       emit2("ld a,%s", s);
1145       emit2("ld !*iyx,a", offset);
1146   }
1147   else
1148       emit2("ld !*iyx,%s", offset, s);
1149   break;
1150
1151     case AOP_HL:
1152   wassert(IS_GB);
1153   /* PENDING: for re-target */
1154   if (!strcmp(s, "!*hl") || !strcmp(s, "(hl)") || !strcmp(s, "[hl]")) {
1155       emit2("ld a,!*hl");
1156       s = "a";
1157   }
1158   setupPair(PAIR_HL, aop, offset);
1159
1160   emit2("ld !*hl,%s", s);
1161   break;
1162
1163     case AOP_STK:
1164   if (IS_GB) {
1165       /* PENDING: re-target */
1166       if (!strcmp(s, "!*hl") || !strcmp(s, "(hl)") || !strcmp(s, "[hl]")) {
1167     emit2("ld a,!*hl");
1168     s = "a";
1169       }
1170       setupPair(PAIR_HL, aop, offset);
1171       if (!canAssignToPtr(s)) {
1172     emit2("ld a,%s", s);
1173     emit2("ld !*hl,a");
1174       }
1175       else
1176     emit2("ld !*hl,%s", s);
1177   }
1178   else {
1179       if (aop->aopu.aop_stk >= 0)
1180     offset += _G.stack.param_offset;
1181       if (!canAssignToPtr(s)) {
1182     emit2("ld a,%s", s);
1183     emit2("ld !*ixx,a", aop->aopu.aop_stk+offset);
1184       }
1185       else
1186     emit2("ld !*ixx,%s", aop->aopu.aop_stk+offset, s);
1187   }
1188   break;
1189
1190     case AOP_CRY:
1191   /* if bit variable */
1192   if (!aop->aopu.aop_dir) {
1193       emit2("ld a,#0");
1194       emit2("rla");
1195   } else {
1196       /* In bit space but not in C - cant happen */
1197       wassert(0);
1198   }
1199   break;
1200
1201     case AOP_STR:
1202   aop->coff = offset;
1203   if (strcmp(aop->aopu.aop_str[offset],s)) {
1204       emitcode ("ld","%s,%s",aop->aopu.aop_str[offset],s);
1205   }
1206   break;
1207
1208     case AOP_ACC:
1209   aop->coff = offset;
1210   if (!offset && (strcmp(s,"acc") == 0))
1211       break;
1212   if (offset>0) {
1213
1214       emitcode("", "; Error aopPut AOP_ACC");
1215   }
1216   else {
1217       if (strcmp(aop->aopu.aop_str[offset],s))
1218     emitcode ("ld","%s,%s",aop->aopu.aop_str[offset],s);
1219   }
1220   break;
1221
1222     case AOP_HLREG:
1223   wassert(offset < 2);
1224   emit2("ld %s,%s", aop->aopu.aop_str[offset], s);
1225   break;
1226
1227     default :
1228   werror(E_INTERNAL_ERROR,__FILE__,__LINE__,
1229          "aopPut got unsupported aop->type");
1230   exit(0);
1231     }
1232 }
1233
1234 #define AOP(op) op->aop
1235 #define AOP_TYPE(op) AOP(op)->type
1236 #define AOP_SIZE(op) AOP(op)->size
1237 #define AOP_NEEDSACC(x) (AOP(x) && (AOP_TYPE(x) == AOP_CRY))
1238
1239 static void commitPair(asmop *aop, PAIR_ID id)
1240 {
1241     if (id == PAIR_HL && requiresHL(aop)) {
1242   emit2("ld a,l");
1243   emit2("ld d,h");
1244   aopPut(aop, "a", 0);
1245   aopPut(aop, "d", 1);
1246     }
1247     else {
1248   aopPut(aop, _pairs[id].l, 0);
1249   aopPut(aop, _pairs[id].h, 1);
1250     }
1251 }
1252
1253 /*-----------------------------------------------------------------*/
1254 /* getDataSize - get the operand data size                         */
1255 /*-----------------------------------------------------------------*/
1256 int getDataSize(operand *op)
1257 {
1258     int size;
1259     size = AOP_SIZE(op);
1260     if(size == 3) {
1261         /* pointer */
1262   wassert(0);
1263     }
1264     return size;
1265 }
1266
1267 /*-----------------------------------------------------------------*/
1268 /* movLeft2Result - move byte from left to result                  */
1269 /*-----------------------------------------------------------------*/
1270 static void movLeft2Result (operand *left, int offl,
1271                             operand *result, int offr, int sign)
1272 {
1273     char *l;
1274     if(!sameRegs(AOP(left),AOP(result)) || (offl != offr)){
1275         l = aopGet(AOP(left),offl,FALSE);
1276
1277   if (!sign) {
1278       aopPut(AOP(result),l,offr);
1279   }
1280   else {
1281       wassert(0);
1282         }
1283     }
1284 }
1285
1286
1287 /** Put Acc into a register set
1288  */
1289 void outAcc(operand *result)
1290 {
1291     int size, offset;
1292     size = getDataSize(result);
1293     if (size){
1294         aopPut(AOP(result),"a",0);
1295         size--;
1296         offset = 1;
1297         /* unsigned or positive */
1298         while (size--){
1299             aopPut(AOP(result), zero, offset++);
1300         }
1301     }
1302 }
1303
1304 /** Take the value in carry and put it into a register
1305  */
1306 void outBitCLong(operand *result, bool swap_sense)
1307 {
1308     /* if the result is bit */
1309     if (AOP_TYPE(result) == AOP_CRY) {
1310   emitcode("", "; Note: outBitC form 1");
1311         aopPut(AOP(result),"blah",0);
1312     }
1313     else {
1314   emit2("ld a,!zero");
1315   emit2("rla");
1316   if (swap_sense)
1317       emit2("xor a,!immedbyte", 1);
1318         outAcc(result);
1319     }
1320 }
1321
1322 void outBitC(operand *result)
1323 {
1324     outBitCLong(result, FALSE);
1325 }
1326
1327 /*-----------------------------------------------------------------*/
1328 /* toBoolean - emit code for orl a,operator(sizeop)                */
1329 /*-----------------------------------------------------------------*/
1330 void toBoolean(operand *oper)
1331 {
1332     int size = AOP_SIZE(oper);
1333     int offset = 0;
1334     if (size>1) {
1335   emitcode("ld", "a,%s", aopGet(AOP(oper), offset++, FALSE));
1336   size--;
1337   while (size--)
1338       emitcode("or","a,%s",aopGet(AOP(oper),offset++,FALSE));
1339     }
1340     else {
1341   if (AOP(oper)->type != AOP_ACC) {
1342       CLRC;
1343       emitcode("or","a,%s",aopGet(AOP(oper),0,FALSE));
1344   }
1345     }
1346 }
1347
1348 /*-----------------------------------------------------------------*/
1349 /* genNot - generate code for ! operation                          */
1350 /*-----------------------------------------------------------------*/
1351 static void genNot (iCode *ic)
1352 {
1353     sym_link *optype = operandType(IC_LEFT(ic));
1354
1355     /* assign asmOps to operand & result */
1356     aopOp (IC_LEFT(ic),ic,FALSE, TRUE);
1357     aopOp (IC_RESULT(ic),ic,TRUE, FALSE);
1358
1359     /* if in bit space then a special case */
1360     if (AOP_TYPE(IC_LEFT(ic)) == AOP_CRY) {
1361   wassert(0);
1362     }
1363
1364     /* if type float then do float */
1365     if (IS_FLOAT(optype)) {
1366   wassert(0);
1367     }
1368
1369     toBoolean(IC_LEFT(ic));
1370
1371     /* Not of A:
1372        If A == 0, !A = 1
1373        else A = 0
1374        So if A = 0, A-1 = 0xFF and C is set, rotate C into reg. */
1375     emit2("sub a,!one");
1376     outBitC(IC_RESULT(ic));
1377
1378     /* release the aops */
1379     freeAsmop(IC_LEFT(ic),NULL,ic);
1380     freeAsmop(IC_RESULT(ic),NULL,ic);
1381 }
1382
1383 /*-----------------------------------------------------------------*/
1384 /* genCpl - generate code for complement                           */
1385 /*-----------------------------------------------------------------*/
1386 static void genCpl (iCode *ic)
1387 {
1388     int offset = 0;
1389     int size ;
1390
1391
1392     /* assign asmOps to operand & result */
1393     aopOp (IC_LEFT(ic),ic,FALSE, FALSE);
1394     aopOp (IC_RESULT(ic),ic,TRUE, FALSE);
1395
1396     /* if both are in bit space then
1397     a special case */
1398     if (AOP_TYPE(IC_RESULT(ic)) == AOP_CRY &&
1399         AOP_TYPE(IC_LEFT(ic)) == AOP_CRY ) {
1400   wassert(0);
1401     }
1402
1403     size = AOP_SIZE(IC_RESULT(ic));
1404     while (size--) {
1405         char *l = aopGet(AOP(IC_LEFT(ic)),offset,FALSE);
1406         MOVA(l);
1407         emitcode("cpl","");
1408         aopPut(AOP(IC_RESULT(ic)),"a",offset++);
1409     }
1410
1411     /* release the aops */
1412     freeAsmop(IC_LEFT(ic),NULL,ic);
1413     freeAsmop(IC_RESULT(ic),NULL,ic);
1414 }
1415
1416 /*-----------------------------------------------------------------*/
1417 /* genUminus - unary minus code generation                         */
1418 /*-----------------------------------------------------------------*/
1419 static void genUminus (iCode *ic)
1420 {
1421     int offset ,size ;
1422     sym_link *optype, *rtype;
1423
1424     /* assign asmops */
1425     aopOp(IC_LEFT(ic),ic,FALSE, FALSE);
1426     aopOp(IC_RESULT(ic),ic,TRUE, FALSE);
1427
1428     /* if both in bit space then special
1429     case */
1430     if (AOP_TYPE(IC_RESULT(ic)) == AOP_CRY &&
1431         AOP_TYPE(IC_LEFT(ic)) == AOP_CRY ) {
1432   wassert(0);
1433         goto release;
1434     }
1435
1436     optype = operandType(IC_LEFT(ic));
1437     rtype = operandType(IC_RESULT(ic));
1438
1439     /* if float then do float stuff */
1440     if (IS_FLOAT(optype)) {
1441   wassert(0);
1442         goto release;
1443     }
1444
1445     /* otherwise subtract from zero */
1446     size = AOP_SIZE(IC_LEFT(ic));
1447     offset = 0 ;
1448     CLRC ;
1449     while(size--) {
1450         char *l = aopGet(AOP(IC_LEFT(ic)),offset,FALSE);
1451   emit2("ld a,!zero");
1452   emit2("sbc a,%s",l);
1453         aopPut(AOP(IC_RESULT(ic)),"a",offset++);
1454     }
1455
1456     /* if any remaining bytes in the result */
1457     /* we just need to propagate the sign   */
1458     if ((size = (AOP_SIZE(IC_RESULT(ic)) - AOP_SIZE(IC_LEFT(ic))))) {
1459         emit2("rlc a");
1460         emit2("sbc a,a");
1461         while (size--)
1462             aopPut(AOP(IC_RESULT(ic)),"a",offset++);
1463     }
1464
1465 release:
1466     /* release the aops */
1467     freeAsmop(IC_LEFT(ic),NULL,ic);
1468     freeAsmop(IC_RESULT(ic),NULL,ic);
1469 }
1470
1471 static void _push(PAIR_ID pairId)
1472 {
1473     emit2("push %s", _pairs[pairId].name);
1474     _G.stack.pushed += 2;
1475 }
1476
1477 static void _pop(PAIR_ID pairId)
1478 {
1479     emit2("pop %s", _pairs[pairId].name);
1480     _G.stack.pushed -= 2;
1481 }
1482
1483
1484 /*-----------------------------------------------------------------*/
1485 /* assignResultValue -               */
1486 /*-----------------------------------------------------------------*/
1487 void assignResultValue(operand * oper)
1488 {
1489     int size = AOP_SIZE(oper);
1490     bool topInA = 0;
1491
1492     wassert(size <= 4);
1493     topInA = requiresHL(AOP(oper));
1494
1495 #if 0
1496     if (!IS_GB)
1497   wassert(size <= 2);
1498 #endif
1499     if (IS_GB && size == 4 && requiresHL(AOP(oper))) {
1500   /* We do it the hard way here. */
1501   _push(PAIR_HL);
1502   aopPut(AOP(oper), _fReturn[0], 0);
1503   aopPut(AOP(oper), _fReturn[1], 1);
1504   emitcode("pop", "de");
1505   _G.stack.pushed -= 2;
1506   aopPut(AOP(oper), _fReturn[0], 2);
1507   aopPut(AOP(oper), _fReturn[1], 3);
1508     }
1509     else {
1510   while (size--) {
1511       aopPut(AOP(oper), _fReturn[size], size);
1512   }
1513     }
1514 }
1515
1516 /*-----------------------------------------------------------------*/
1517 /* genIpush - genrate code for pushing this gets a little complex  */
1518 /*-----------------------------------------------------------------*/
1519 static void genIpush (iCode *ic)
1520 {
1521     int size, offset = 0 ;
1522     char *l;
1523
1524     /* if this is not a parm push : ie. it is spill push
1525        and spill push is always done on the local stack */
1526     if (!ic->parmPush) {
1527         /* and the item is spilt then do nothing */
1528         if (OP_SYMBOL(IC_LEFT(ic))->isspilt)
1529             return ;
1530
1531         aopOp(IC_LEFT(ic),ic,FALSE, FALSE);
1532         size = AOP_SIZE(IC_LEFT(ic));
1533         /* push it on the stack */
1534   if (isPair(AOP(IC_LEFT(ic)))) {
1535       emitcode("push", getPairName(AOP(IC_LEFT(ic))));
1536       _G.stack.pushed += 2;
1537   }
1538   else {
1539       offset = size;
1540       while (size--) {
1541     /* Simple for now - load into A and PUSH AF */
1542     if (AOP(IC_LEFT(ic))->type == AOP_IY) {
1543         char *l = aopGetLitWordLong(AOP(IC_LEFT(ic)), --offset, FALSE);
1544         wassert(l);
1545         emit2("ld a,(%s)", l);
1546     }
1547     else {
1548         l = aopGet(AOP(IC_LEFT(ic)), --offset, FALSE);
1549         emit2("ld a,%s", l);
1550     }
1551     emit2("push af");
1552     emit2("inc sp");
1553     _G.stack.pushed++;
1554       }
1555   }
1556   return ;
1557     }
1558
1559     /* Hmmm... what about saving the currently used registers
1560        at this point? */
1561
1562     /* then do the push */
1563     aopOp(IC_LEFT(ic),ic,FALSE, FALSE);
1564
1565     size = AOP_SIZE(IC_LEFT(ic));
1566
1567     if (isPair(AOP(IC_LEFT(ic)))) {
1568   _G.stack.pushed+=2;
1569   emitcode("push", "%s", getPairName(AOP(IC_LEFT(ic))));
1570     }
1571     else {
1572   if (size == 2) {
1573       fetchHL(AOP(IC_LEFT(ic)));
1574       emitcode("push", "hl");
1575       spillPair(PAIR_HL);
1576       _G.stack.pushed += 2;
1577       goto release;
1578   }
1579   if (size == 4) {
1580       fetchPairLong(PAIR_HL, AOP(IC_LEFT(ic)), 2);
1581       emitcode("push", "hl");
1582       spillPair(PAIR_HL);
1583       _G.stack.pushed += 2;
1584       fetchPairLong(PAIR_HL, AOP(IC_LEFT(ic)), 0);
1585       emitcode("push", "hl");
1586       spillPair(PAIR_HL);
1587       _G.stack.pushed += 2;
1588       goto release;
1589   }
1590   offset = size;
1591   while (size--) {
1592       if (AOP(IC_LEFT(ic))->type == AOP_IY) {
1593     char *l = aopGetLitWordLong(AOP(IC_LEFT(ic)), --offset, FALSE);
1594     wassert(l);
1595     emit2("ld a,(%s)", l);
1596       }
1597       else {
1598     l = aopGet(AOP(IC_LEFT(ic)), --offset, FALSE);
1599     emit2("ld a,%s", l);
1600       }
1601       emitcode("push", "af");
1602       emitcode("inc", "sp");
1603       _G.stack.pushed++;
1604   }
1605     }
1606  release:
1607     freeAsmop(IC_LEFT(ic),NULL,ic);
1608 }
1609
1610 /*-----------------------------------------------------------------*/
1611 /* genIpop - recover the registers: can happen only for spilling   */
1612 /*-----------------------------------------------------------------*/
1613 static void genIpop (iCode *ic)
1614 {
1615     int size,offset ;
1616
1617
1618     /* if the temp was not pushed then */
1619     if (OP_SYMBOL(IC_LEFT(ic))->isspilt)
1620         return ;
1621
1622     aopOp(IC_LEFT(ic),ic,FALSE, FALSE);
1623     size = AOP_SIZE(IC_LEFT(ic));
1624     offset = (size-1);
1625     if (isPair(AOP(IC_LEFT(ic)))) {
1626   emitcode("pop", getPairName(AOP(IC_LEFT(ic))));
1627     }
1628     else {
1629   while (size--) {
1630       emitcode("dec", "sp");
1631       emitcode("pop", "hl");
1632       spillPair(PAIR_HL);
1633       aopPut(AOP(IC_LEFT(ic)), "l", offset--);
1634   }
1635     }
1636
1637     freeAsmop(IC_LEFT(ic),NULL,ic);
1638 }
1639
1640 static int _isPairUsed(iCode *ic, PAIR_ID pairId)
1641 {
1642     int ret = 0;
1643     switch (pairId) {
1644     case PAIR_DE:
1645   if (bitVectBitValue(ic->rUsed, D_IDX))
1646       ret++;
1647   if (bitVectBitValue(ic->rUsed, E_IDX))
1648       ret++;
1649   break;
1650     default:
1651   wassert(0);
1652     }
1653     return ret;
1654 }
1655
1656 static int _opUsesPair(operand *op, iCode *ic, PAIR_ID pairId)
1657 {
1658     int ret = 0;
1659     asmop *aop;
1660     symbol *sym = OP_SYMBOL(op);
1661
1662     if (sym->isspilt || sym->nRegs == 0)
1663   return 0;
1664
1665     aopOp(op, ic, FALSE, FALSE);
1666
1667     aop = AOP(op);
1668     if (aop->type == AOP_REG) {
1669   int i;
1670   for (i=0; i < aop->size; i++) {
1671       if (pairId == PAIR_DE) {
1672     emit2("; name %s", aop->aopu.aop_reg[i]->name);
1673     if (!strcmp(aop->aopu.aop_reg[i]->name, "e"))
1674         ret++;
1675     if (!strcmp(aop->aopu.aop_reg[i]->name, "d"))
1676         ret++;
1677       }
1678       else {
1679     wassert(0);
1680       }
1681   }
1682     }
1683
1684     freeAsmop(IC_LEFT(ic),NULL,ic);
1685     return ret;
1686 }
1687
1688 /* This is quite unfortunate */
1689 static void setArea(int inHome)
1690 {
1691     static int lastArea = 0;
1692
1693     /*
1694     if (_G.in_home != inHome) {
1695   if (inHome) {
1696       const char *sz = port->mem.code_name;
1697       port->mem.code_name = "HOME";
1698       emit2("!area", CODE_NAME);
1699       port->mem.code_name = sz;
1700   }
1701   else
1702   emit2("!area", CODE_NAME);*/
1703   _G.in_home = inHome;
1704   //    }
1705 }
1706
1707 static bool isInHome(void)
1708 {
1709     return _G.in_home;
1710 }
1711
1712 /** Emit the code for a call statement
1713  */
1714 static void emitCall(iCode *ic, bool ispcall)
1715 {
1716     int pushed_de = 0;
1717     sym_link *detype = getSpec(operandType(IC_LEFT(ic)));
1718
1719     /* if caller saves & we have not saved then */
1720     if (!ic->regsSaved) {
1721   /* PENDING */
1722     }
1723
1724     /* if send set is not empty then assign */
1725     if (sendSet) {
1726   iCode *sic;
1727   int send = 0;
1728   int n = elementsInSet(sendSet);
1729   if (IS_Z80 && n == 2 && _isPairUsed(ic, PAIR_DE)) {
1730       /* Only push de if it is used and if it's not used
1731          in the return value */
1732       /* Panic if partly used */
1733       if (_opUsesPair(IC_RESULT(ic), ic, PAIR_DE) == 1) {
1734     emit2("; Warning: de crossover");
1735       }
1736       else if (!_opUsesPair(IC_RESULT(ic), ic, PAIR_DE)) {
1737     /* Store away de */
1738     _push(PAIR_DE);
1739     pushed_de = 1;
1740       }
1741   }
1742   /* PENDING: HACK */
1743   if (IS_Z80 && n == 2 ) {
1744       /* Want to load HL first, then DE as HL may = DE */
1745       sic = setFirstItem(sendSet);
1746       sic = setNextItem(sendSet);
1747       aopOp(IC_LEFT(sic),sic,FALSE, FALSE);
1748       fetchPair(PAIR_HL, AOP(IC_LEFT(sic)));
1749       send++;
1750       freeAsmop (IC_LEFT(sic),NULL,sic);
1751       sic = setFirstItem(sendSet);
1752       aopOp(IC_LEFT(sic),sic,FALSE, FALSE);
1753       fetchPair(PAIR_DE, AOP(IC_LEFT(sic)));
1754       send++;
1755       freeAsmop (IC_LEFT(sic),NULL,sic);
1756   }
1757   else {
1758       for (sic = setFirstItem(sendSet) ; sic ;
1759      sic = setNextItem(sendSet)) {
1760     int size;
1761     aopOp(IC_LEFT(sic),sic,FALSE, FALSE);
1762     size = AOP_SIZE(IC_LEFT(sic));
1763     wassert(size <= 2);
1764     /* Always send in pairs */
1765     switch (send) {
1766     case 0:
1767         if (IS_Z80 && n == 1)
1768       fetchPair(PAIR_HL, AOP(IC_LEFT(sic)));
1769         else
1770       fetchPair(PAIR_DE, AOP(IC_LEFT(sic)));
1771         break;
1772     case 1:
1773         fetchPair(PAIR_HL, AOP(IC_LEFT(sic)));
1774         break;
1775     default:
1776         /* Send set too big */
1777         wassert(0);
1778     }
1779     send++;
1780     freeAsmop (IC_LEFT(sic),NULL,sic);
1781       }
1782   }
1783   sendSet = NULL;
1784   if (pushed_de) {
1785   }
1786     }
1787
1788     if (ispcall) {
1789   if (IS_BANKEDCALL(detype)) {
1790       werror(W_INDIR_BANKED);
1791   }
1792   aopOp(IC_LEFT(ic),ic,FALSE, FALSE);
1793
1794   if (isLitWord(AOP(IC_LEFT(ic)))) {
1795       emitcode("", "; Special case where the pCall is to a constant");
1796       emitcode("call", aopGetLitWordLong(AOP(IC_LEFT(ic)), 0, FALSE));
1797   }
1798   else {
1799       symbol *rlbl = newiTempLabel(NULL);
1800       spillPair(PAIR_HL);
1801       emit2("ld hl,!immed!tlabel", (rlbl->key+100));
1802       emitcode("push", "hl");
1803       _G.stack.pushed += 2;
1804
1805       fetchHL(AOP(IC_LEFT(ic)));
1806       emit2("jp !*hl");
1807       emit2("!tlabeldef", (rlbl->key+100));
1808       _G.stack.pushed -= 2;
1809   }
1810   freeAsmop(IC_LEFT(ic),NULL,ic);
1811     }
1812     else {
1813   char *name = OP_SYMBOL(IC_LEFT(ic))->rname[0] ?
1814       OP_SYMBOL(IC_LEFT(ic))->rname :
1815       OP_SYMBOL(IC_LEFT(ic))->name;
1816   if (IS_BANKEDCALL(detype)) {
1817       emit2("call banked_call");
1818       emit2("!dws", name);
1819       emit2("!dw !bankimmeds", name);
1820   }
1821   else {
1822       /* make the call */
1823       emit2("call %s", name);
1824   }
1825     }
1826     spillCached();
1827
1828     /* if we need assign a result value */
1829     if ((IS_ITEMP(IC_RESULT(ic)) &&
1830          (OP_SYMBOL(IC_RESULT(ic))->nRegs ||
1831           OP_SYMBOL(IC_RESULT(ic))->spildir )) ||
1832         IS_TRUE_SYMOP(IC_RESULT(ic)) ) {
1833
1834         accInUse++;
1835         aopOp(IC_RESULT(ic),ic,FALSE, FALSE);
1836         accInUse--;
1837
1838   assignResultValue(IC_RESULT(ic));
1839
1840         freeAsmop(IC_RESULT(ic),NULL, ic);
1841     }
1842
1843     /* adjust the stack for parameters if required */
1844     if (IC_LEFT(ic)->parmBytes) {
1845   int i = IC_LEFT(ic)->parmBytes;
1846   _G.stack.pushed -= i;
1847   if (IS_GB) {
1848       emit2("!ldaspsp", i);
1849   }
1850   else {
1851       spillCached();
1852       if (i>6) {
1853     emitcode("ld", "hl,#%d", i);
1854     emitcode("add", "hl,sp");
1855     emitcode("ld", "sp,hl");
1856       }
1857       else {
1858     while (i>1) {
1859         emitcode("pop", "hl");
1860         i-=2;
1861     }
1862     if (i)
1863         emitcode("inc", "sp");
1864       }
1865       spillCached();
1866   }
1867     }
1868     if (pushed_de)
1869   _pop(PAIR_DE);
1870 }
1871
1872 /*-----------------------------------------------------------------*/
1873 /* genCall - generates a call statement                            */
1874 /*-----------------------------------------------------------------*/
1875 static void genCall (iCode *ic)
1876 {
1877     sym_link *detype = getSpec(operandType(IC_LEFT(ic)));
1878     emitCall(ic, FALSE);
1879 }
1880
1881 /*-----------------------------------------------------------------*/
1882 /* genPcall - generates a call by pointer statement                */
1883 /*-----------------------------------------------------------------*/
1884 static void genPcall (iCode *ic)
1885 {
1886     emitCall(ic, TRUE);
1887 }
1888
1889 /*-----------------------------------------------------------------*/
1890 /* resultRemat - result  is rematerializable                       */
1891 /*-----------------------------------------------------------------*/
1892 static int resultRemat (iCode *ic)
1893 {
1894     if (SKIP_IC(ic) || ic->op == IFX)
1895         return 0;
1896
1897     if (IC_RESULT(ic) && IS_ITEMP(IC_RESULT(ic))) {
1898         symbol *sym = OP_SYMBOL(IC_RESULT(ic));
1899         if (sym->remat && !POINTER_SET(ic))
1900             return 1;
1901     }
1902
1903     return 0;
1904 }
1905
1906 extern set *publics;
1907
1908 /*-----------------------------------------------------------------*/
1909 /* genFunction - generated code for function entry                 */
1910 /*-----------------------------------------------------------------*/
1911 static void genFunction (iCode *ic)
1912 {
1913     symbol *sym = OP_SYMBOL(IC_LEFT(ic));
1914     sym_link *fetype;
1915
1916     nregssaved = 0;
1917     setArea(IS_NONBANKED(sym->etype));
1918
1919     /* PENDING: hack */
1920     if (!IS_STATIC(sym->etype)) {
1921   addSetIfnotP(&publics, sym);
1922     }
1923
1924     /* create the function header */
1925     emit2("!functionheader", sym->name);
1926     /* PENDING: portability. */
1927     emit2("__%s_start:", sym->rname);
1928     emit2("!functionlabeldef", sym->rname);
1929
1930     fetype = getSpec(operandType(IC_LEFT(ic)));
1931
1932     /* if critical function then turn interrupts off */
1933     if (SPEC_CRTCL(fetype))
1934   emit2("!di");
1935
1936     /* if this is an interrupt service routine then
1937     save acc, b, dpl, dph  */
1938     if (IS_ISR(sym->etype)) {
1939   emit2("!pusha");
1940     }
1941     /* PENDING: callee-save etc */
1942
1943     /* If BC or DE are used, then push */
1944     _G.stack.pushed_bc = 0;
1945     _G.stack.pushed_de = 0;
1946     _G.stack.param_offset = 0;
1947     if (sym->regsUsed) {
1948   int i;
1949   for ( i = 0 ; i < sym->regsUsed->size ; i++) {
1950       if (bitVectBitValue(sym->regsUsed, i)) {
1951     switch (i) {
1952     case C_IDX:
1953     case B_IDX:
1954         _G.stack.pushed_bc = 1;
1955         break;
1956     case D_IDX:
1957     case E_IDX:
1958         if (IS_Z80)
1959       _G.stack.pushed_de = 1;
1960         break;
1961     }
1962       }
1963   }
1964   if (_G.stack.pushed_bc) {
1965       emit2("push bc");
1966       _G.stack.param_offset += 2;
1967   }
1968   if (_G.stack.pushed_de) {
1969       emit2("push de");
1970       _G.stack.param_offset += 2;
1971   }
1972     }
1973
1974     /* adjust the stack for the function */
1975     _G.stack.last = sym->stack;
1976
1977     if (sym->stack)
1978   emit2("!enterx", sym->stack);
1979     else
1980   emit2("!enter");
1981     _G.stack.offset = sym->stack;
1982 }
1983
1984 /*-----------------------------------------------------------------*/
1985 /* genEndFunction - generates epilogue for functions               */
1986 /*-----------------------------------------------------------------*/
1987 static void genEndFunction (iCode *ic)
1988 {
1989     symbol *sym = OP_SYMBOL(IC_LEFT(ic));
1990
1991     if (IS_ISR(sym->etype)) {
1992   wassert(0);
1993     }
1994     else {
1995         if (SPEC_CRTCL(sym->etype))
1996       emit2("!ei");
1997
1998   /* PENDING: calleeSave */
1999
2000   /* if debug then send end of function */
2001   if (options.debug && currFunc) {
2002       debugLine = 1;
2003       emitcode("","C$%s$%d$%d$%d ==.",
2004          ic->filename,currFunc->lastLine,
2005          ic->level,ic->block);
2006       if (IS_STATIC(currFunc->etype))
2007     emitcode("","XF%s$%s$0$0 ==.",moduleName,currFunc->name);
2008       else
2009     emitcode("","XG$%s$0$0 ==.",currFunc->name);
2010       debugLine = 0;
2011   }
2012   if (_G.stack.offset)
2013       emit2("!leavex", _G.stack.offset);
2014   else
2015       emit2("!leave");
2016
2017   if (_G.stack.pushed_de)
2018       emit2("pop de");
2019   if (_G.stack.pushed_bc)
2020       emit2("pop bc");
2021   /* Both baned and non-banked just ret */
2022   emit2("ret");
2023
2024   /* PENDING: portability. */
2025   emit2("__%s_end:", sym->rname);
2026     }
2027     _G.flush_statics = 1;
2028     _G.stack.pushed = 0;
2029     _G.stack.offset = 0;
2030 }
2031
2032 /*-----------------------------------------------------------------*/
2033 /* genRet - generate code for return statement                     */
2034 /*-----------------------------------------------------------------*/
2035 static void genRet (iCode *ic)
2036 {
2037     char *l;
2038     /* Errk.  This is a hack until I can figure out how
2039        to cause dehl to spill on a call */
2040     int size,offset = 0;
2041
2042     /* if we have no return value then
2043        just generate the "ret" */
2044     if (!IC_LEFT(ic))
2045   goto jumpret;
2046
2047     /* we have something to return then
2048        move the return value into place */
2049     aopOp(IC_LEFT(ic),ic,FALSE, FALSE);
2050     size = AOP_SIZE(IC_LEFT(ic));
2051
2052     if ((size == 2) && ((l = aopGetWord(AOP(IC_LEFT(ic)), 0)))) {
2053   if (IS_GB) {
2054       emitcode("ld", "de,%s", l);
2055   }
2056   else {
2057       emitcode("ld", "hl,%s", l);
2058   }
2059     }
2060     else {
2061   if (IS_GB && size == 4 && requiresHL(AOP(IC_LEFT(ic)))) {
2062       fetchPair(PAIR_DE, AOP(IC_LEFT(ic)));
2063       fetchPairLong(PAIR_HL, AOP(IC_LEFT(ic)), 2);
2064   }
2065   else {
2066       while (size--) {
2067     l = aopGet(AOP(IC_LEFT(ic)),offset,
2068          FALSE);
2069     if (strcmp(_fReturn[offset],l))
2070         emitcode("ld","%s,%s", _fReturn[offset++],l);
2071       }
2072   }
2073     }
2074     freeAsmop (IC_LEFT(ic),NULL,ic);
2075
2076  jumpret:
2077   /* generate a jump to the return label
2078      if the next is not the return statement */
2079     if (!(ic->next && ic->next->op == LABEL &&
2080     IC_LABEL(ic->next) == returnLabel))
2081
2082   emit2("jp !tlabel", returnLabel->key+100);
2083 }
2084
2085 /*-----------------------------------------------------------------*/
2086 /* genLabel - generates a label                                    */
2087 /*-----------------------------------------------------------------*/
2088 static void genLabel (iCode *ic)
2089 {
2090     /* special case never generate */
2091     if (IC_LABEL(ic) == entryLabel)
2092         return ;
2093
2094     emitLabel(IC_LABEL(ic)->key+100);
2095 }
2096
2097 /*-----------------------------------------------------------------*/
2098 /* genGoto - generates a ljmp                                      */
2099 /*-----------------------------------------------------------------*/
2100 static void genGoto (iCode *ic)
2101 {
2102     emit2("jp !tlabel", IC_LABEL(ic)->key+100);
2103 }
2104
2105 /*-----------------------------------------------------------------*/
2106 /* genPlusIncr :- does addition with increment if possible         */
2107 /*-----------------------------------------------------------------*/
2108 static bool genPlusIncr (iCode *ic)
2109 {
2110     unsigned int icount ;
2111     unsigned int size = getDataSize(IC_RESULT(ic));
2112     PAIR_ID resultId = getPairId(AOP(IC_RESULT(ic)));
2113
2114     /* will try to generate an increment */
2115     /* if the right side is not a literal
2116        we cannot */
2117     if (AOP_TYPE(IC_RIGHT(ic)) != AOP_LIT)
2118         return FALSE;
2119
2120     emitcode("", "; genPlusIncr");
2121
2122     icount = floatFromVal(AOP(IC_RIGHT(ic))->aopu.aop_lit);
2123
2124     /* If result is a pair */
2125     if (resultId != PAIR_INVALID) {
2126   if (isLitWord(AOP(IC_LEFT(ic)))) {
2127       fetchLitPair(getPairId(AOP(IC_RESULT(ic))), AOP(IC_LEFT(ic)), icount);
2128       return TRUE;
2129   }
2130   if (isPair(AOP(IC_LEFT(ic))) && resultId == PAIR_HL && icount > 2) {
2131       fetchPair(resultId, AOP(IC_RIGHT(ic)));
2132       emitcode("add", "hl,%s", getPairName(AOP(IC_LEFT(ic))));
2133       return TRUE;
2134   }
2135   if (icount > 5)
2136       return FALSE;
2137   /* Inc a pair */
2138   if (!sameRegs(AOP(IC_LEFT(ic)), AOP(IC_RESULT(ic)))) {
2139       if (icount > 2)
2140     return FALSE;
2141       movLeft2Result(IC_LEFT(ic), 0, IC_RESULT(ic), 0, 0);
2142       movLeft2Result(IC_LEFT(ic), 1, IC_RESULT(ic), 1, 0);
2143   }
2144   while (icount--) {
2145       emitcode("inc", "%s", getPairName(AOP(IC_RESULT(ic))));
2146   }
2147   return TRUE;
2148     }
2149
2150     /* if the literal value of the right hand side
2151        is greater than 4 then it is not worth it */
2152     if (icount > 4)
2153         return FALSE;
2154
2155     /* if increment 16 bits in register */
2156     if (sameRegs(AOP(IC_LEFT(ic)), AOP(IC_RESULT(ic))) &&
2157         size > 1 &&
2158         icount == 1
2159   ) {
2160   int offset = 0;
2161   symbol *tlbl = NULL;
2162   tlbl = newiTempLabel(NULL);
2163   while (size--) {
2164       emitcode("inc","%s",aopGet(AOP(IC_RESULT(ic)), offset++, FALSE));
2165       if (size) {
2166     emit2("!shortjp nz,!tlabel", tlbl->key+100);
2167       }
2168   }
2169   emitLabel(tlbl->key+100);
2170         return TRUE;
2171     }
2172
2173     /* if the sizes are greater than 1 then we cannot */
2174     if (AOP_SIZE(IC_RESULT(ic)) > 1 ||
2175         AOP_SIZE(IC_LEFT(ic)) > 1   )
2176         return FALSE ;
2177
2178     /* we can if the aops of the left & result match or
2179        if they are in registers and the registers are the
2180        same */
2181     if (sameRegs(AOP(IC_LEFT(ic)), AOP(IC_RESULT(ic))) ) {
2182   while (icount--)
2183       emitcode ("inc","%s",aopGet(AOP(IC_LEFT(ic)),0, FALSE));
2184         return TRUE ;
2185     }
2186
2187     return FALSE ;
2188 }
2189
2190 /*-----------------------------------------------------------------*/
2191 /* outBitAcc - output a bit in acc                                 */
2192 /*-----------------------------------------------------------------*/
2193 void outBitAcc(operand *result)
2194 {
2195     symbol *tlbl = newiTempLabel(NULL);
2196     /* if the result is a bit */
2197     if (AOP_TYPE(result) == AOP_CRY){
2198   wassert(0);
2199     }
2200     else {
2201         emit2("!shortjp z,!tlabel", tlbl->key+100);
2202   emit2("ld a,!one");
2203   emitLabel(tlbl->key+100);
2204         outAcc(result);
2205     }
2206 }
2207
2208 /*-----------------------------------------------------------------*/
2209 /* genPlus - generates code for addition                           */
2210 /*-----------------------------------------------------------------*/
2211 static void genPlus (iCode *ic)
2212 {
2213     int size, offset = 0;
2214
2215     /* special cases :- */
2216
2217     aopOp (IC_LEFT(ic),ic,FALSE, FALSE);
2218     aopOp (IC_RIGHT(ic),ic,FALSE, FALSE);
2219     aopOp (IC_RESULT(ic),ic,TRUE, FALSE);
2220
2221     /* Swap the left and right operands if:
2222
2223        if literal, literal on the right or
2224        if left requires ACC or right is already
2225        in ACC */
2226
2227     if ((AOP_TYPE(IC_LEFT(ic)) == AOP_LIT) ||
2228   (AOP_NEEDSACC(IC_LEFT(ic))) ||
2229   AOP_TYPE(IC_RIGHT(ic)) == AOP_ACC ){
2230         operand *t = IC_RIGHT(ic);
2231         IC_RIGHT(ic) = IC_LEFT(ic);
2232         IC_LEFT(ic) = t;
2233     }
2234
2235     /* if both left & right are in bit
2236     space */
2237     if (AOP_TYPE(IC_LEFT(ic)) == AOP_CRY &&
2238         AOP_TYPE(IC_RIGHT(ic)) == AOP_CRY) {
2239   /* Cant happen */
2240   wassert(0);
2241     }
2242
2243     /* if left in bit space & right literal */
2244     if (AOP_TYPE(IC_LEFT(ic)) == AOP_CRY &&
2245         AOP_TYPE(IC_RIGHT(ic)) == AOP_LIT) {
2246   /* Can happen I guess */
2247   wassert(0);
2248     }
2249
2250     /* if I can do an increment instead
2251     of add then GOOD for ME */
2252     if (genPlusIncr (ic) == TRUE)
2253         goto release;
2254
2255     emit2("; genPlusIncr failed");
2256
2257     size = getDataSize(IC_RESULT(ic));
2258
2259     /* Special case when left and right are constant */
2260     if (isPair(AOP(IC_RESULT(ic)))) {
2261   char *left, *right;
2262
2263   left = aopGetLitWordLong(AOP(IC_LEFT(ic)), 0, FALSE);
2264   right = aopGetLitWordLong(AOP(IC_RIGHT(ic)), 0, FALSE);
2265   if (left && right) {
2266       /* It's a pair */
2267       /* PENDING: fix */
2268       char buffer[100];
2269       sprintf(buffer, "#(%s + %s)", left, right);
2270       emitcode("ld", "%s,%s", getPairName(AOP(IC_RESULT(ic))), buffer);
2271       goto release;
2272   }
2273     }
2274
2275     if (isPair(AOP(IC_RIGHT(ic))) && getPairId(AOP(IC_RESULT(ic))) == PAIR_HL) {
2276   /* Fetch into HL then do the add */
2277   spillPair(PAIR_HL);
2278   fetchPair(PAIR_HL, AOP(IC_LEFT(ic)));
2279   emitcode("add", "hl,%s", getPairName(AOP(IC_RIGHT(ic))));
2280   goto release;
2281     }
2282
2283     /* Special case:
2284        ld hl,sp+n trashes C so we cant afford to do it during an
2285        add with stack based varibles.  Worst case is:
2286         ld  hl,sp+left
2287   ld  a,(hl)
2288   ld  hl,sp+right
2289   add (hl)
2290   ld  hl,sp+result
2291   ld  (hl),a
2292   ld  hl,sp+left+1
2293   ld  a,(hl)
2294   ld  hl,sp+right+1
2295   adc (hl)
2296   ld  hl,sp+result+1
2297   ld  (hl),a
2298   So you cant afford to load up hl if either left, right, or result
2299   is on the stack (*sigh*)  The alt is:
2300   ld  hl,sp+left
2301   ld  de,(hl)
2302   ld  hl,sp+right
2303   ld  hl,(hl)
2304   add hl,de
2305   ld  hl,sp+result
2306   ld  (hl),hl
2307   Combinations in here are:
2308    * If left or right are in bc then the loss is small - trap later
2309    * If the result is in bc then the loss is also small
2310     */
2311     if (IS_GB) {
2312   if (AOP_TYPE(IC_LEFT(ic)) == AOP_STK ||
2313       AOP_TYPE(IC_RIGHT(ic)) == AOP_STK ||
2314       AOP_TYPE(IC_RESULT(ic)) == AOP_STK) {
2315       if ((AOP_SIZE(IC_LEFT(ic)) == 2 ||
2316     AOP_SIZE(IC_RIGHT(ic)) == 2) &&
2317     (AOP_SIZE(IC_LEFT(ic)) <= 2 &&
2318      AOP_SIZE(IC_RIGHT(ic)) <= 2)) {
2319     if (getPairId(AOP(IC_RIGHT(ic))) == PAIR_BC) {
2320         /* Swap left and right */
2321         operand *t = IC_RIGHT(ic);
2322         IC_RIGHT(ic) = IC_LEFT(ic);
2323         IC_LEFT(ic) = t;
2324     }
2325     if (getPairId(AOP(IC_LEFT(ic))) == PAIR_BC) {
2326         fetchPair(PAIR_HL, AOP(IC_RIGHT(ic)));
2327         emit2("add hl,bc");
2328     }
2329     else {
2330         fetchPair(PAIR_DE, AOP(IC_LEFT(ic)));
2331         fetchPair(PAIR_HL, AOP(IC_RIGHT(ic)));
2332         emit2("add hl,de");
2333     }
2334     commitPair(AOP(IC_RESULT(ic)), PAIR_HL);
2335     goto release;
2336       }
2337       else if (size == 4) {
2338     emit2("; WARNING: This add is probably broken.\n");
2339       }
2340   }
2341     }
2342
2343     while(size--) {
2344   if (AOP_TYPE(IC_LEFT(ic)) == AOP_ACC) {
2345       MOVA(aopGet(AOP(IC_LEFT(ic)),offset,FALSE));
2346       if(offset == 0)
2347     emit2("add a,%s",
2348           aopGet(AOP(IC_RIGHT(ic)),offset,FALSE));
2349       else
2350     emit2("adc a,%s",
2351           aopGet(AOP(IC_RIGHT(ic)),offset,FALSE));
2352   } else {
2353       MOVA(aopGet(AOP(IC_LEFT(ic)),offset,FALSE));
2354       if(offset == 0)
2355     emit2("add a,%s",
2356           aopGet(AOP(IC_RIGHT(ic)),offset,FALSE));
2357       else
2358     emit2("adc a,%s",
2359           aopGet(AOP(IC_RIGHT(ic)),offset,FALSE));
2360   }
2361   aopPut(AOP(IC_RESULT(ic)),"a",offset++);
2362     }
2363
2364 release:
2365     freeAsmop(IC_LEFT(ic),NULL,ic);
2366     freeAsmop(IC_RIGHT(ic),NULL,ic);
2367     freeAsmop(IC_RESULT(ic),NULL,ic);
2368
2369 }
2370
2371 /*-----------------------------------------------------------------*/
2372 /* genMinusDec :- does subtraction with deccrement if possible     */
2373 /*-----------------------------------------------------------------*/
2374 static bool genMinusDec (iCode *ic)
2375 {
2376     unsigned int icount ;
2377     unsigned int size = getDataSize(IC_RESULT(ic));
2378
2379     /* will try to generate an increment */
2380     /* if the right side is not a literal we cannot */
2381     if (AOP_TYPE(IC_RIGHT(ic)) != AOP_LIT)
2382         return FALSE ;
2383
2384     /* if the literal value of the right hand side
2385     is greater than 4 then it is not worth it */
2386     if ((icount = (unsigned int) floatFromVal (AOP(IC_RIGHT(ic))->aopu.aop_lit)) > 2)
2387         return FALSE;
2388
2389     size = getDataSize(IC_RESULT(ic));
2390
2391 #if 0
2392     /* if increment 16 bits in register */
2393     if (sameRegs(AOP(IC_LEFT(ic)), AOP(IC_RESULT(ic))) &&
2394         (size > 1) &&
2395         (icount == 1)) {
2396         symbol *tlbl = newiTempLabel(NULL);
2397   emitcode("dec","%s",aopGet(AOP(IC_RESULT(ic)),LSB,FALSE));
2398   emitcode("jp", "np," LABEL_STR ,tlbl->key+100);
2399
2400   emitcode("dec","%s",aopGet(AOP(IC_RESULT(ic)),MSB16,FALSE));
2401   if(size == 4) {
2402       wassert(0);
2403   }
2404   emitLabel(tlbl->key+100);
2405         return TRUE;
2406     }
2407 #endif
2408
2409     /* if decrement 16 bits in register */
2410     if (sameRegs(AOP(IC_LEFT(ic)), AOP(IC_RESULT(ic))) &&
2411         (size > 1) && isPair(AOP(IC_RESULT(ic)))) {
2412   while (icount--)
2413       emitcode("dec", "%s", getPairName(AOP(IC_RESULT(ic))));
2414         return TRUE;
2415     }
2416
2417     /* If result is a pair */
2418     if (isPair(AOP(IC_RESULT(ic)))) {
2419   movLeft2Result(IC_LEFT(ic), 0, IC_RESULT(ic), 0, 0);
2420   movLeft2Result(IC_LEFT(ic), 1, IC_RESULT(ic), 1, 0);
2421   while (icount--)
2422       emitcode("dec", "%s", getPairName(AOP(IC_RESULT(ic))));
2423   return TRUE;
2424     }
2425
2426     /* if the sizes are greater than 1 then we cannot */
2427     if (AOP_SIZE(IC_RESULT(ic)) > 1 ||
2428         AOP_SIZE(IC_LEFT(ic)) > 1   )
2429         return FALSE ;
2430
2431     /* we can if the aops of the left & result match or if they are in
2432        registers and the registers are the same */
2433     if (sameRegs(AOP(IC_LEFT(ic)), AOP(IC_RESULT(ic)))) {
2434         while (icount--)
2435             emitcode ("dec","%s",aopGet(AOP(IC_RESULT(ic)),0,FALSE));
2436         return TRUE ;
2437     }
2438
2439     return FALSE ;
2440 }
2441
2442 /*-----------------------------------------------------------------*/
2443 /* genMinus - generates code for subtraction                       */
2444 /*-----------------------------------------------------------------*/
2445 static void genMinus (iCode *ic)
2446 {
2447     int size, offset = 0;
2448     unsigned long lit = 0L;
2449
2450     aopOp (IC_LEFT(ic),ic,FALSE, FALSE);
2451     aopOp (IC_RIGHT(ic),ic,FALSE, FALSE);
2452     aopOp (IC_RESULT(ic),ic,TRUE, FALSE);
2453
2454     /* special cases :- */
2455     /* if both left & right are in bit space */
2456     if (AOP_TYPE(IC_LEFT(ic)) == AOP_CRY &&
2457         AOP_TYPE(IC_RIGHT(ic)) == AOP_CRY) {
2458   wassert(0);
2459         goto release ;
2460     }
2461
2462     /* if I can do an decrement instead of subtract then GOOD for ME */
2463     if (genMinusDec (ic) == TRUE)
2464         goto release;
2465
2466     size = getDataSize(IC_RESULT(ic));
2467
2468     if (AOP_TYPE(IC_RIGHT(ic)) != AOP_LIT){
2469     }
2470     else{
2471         lit = (unsigned long)floatFromVal(AOP(IC_RIGHT(ic))->aopu.aop_lit);
2472         lit = - (long)lit;
2473     }
2474
2475     /* Same logic as genPlus */
2476     if (IS_GB) {
2477   if (AOP_TYPE(IC_LEFT(ic)) == AOP_STK ||
2478       AOP_TYPE(IC_RIGHT(ic)) == AOP_STK ||
2479       AOP_TYPE(IC_RESULT(ic)) == AOP_STK) {
2480       if ((AOP_SIZE(IC_LEFT(ic)) == 2 ||
2481     AOP_SIZE(IC_RIGHT(ic)) == 2) &&
2482     (AOP_SIZE(IC_LEFT(ic)) <= 2 &&
2483      AOP_SIZE(IC_RIGHT(ic)) <= 2)) {
2484     PAIR_ID left = getPairId(AOP(IC_LEFT(ic)));
2485     PAIR_ID right = getPairId(AOP(IC_RIGHT(ic)));
2486
2487     if (left == PAIR_INVALID && right == PAIR_INVALID) {
2488         left = PAIR_DE;
2489         right = PAIR_HL;
2490     }
2491     else if (right == PAIR_INVALID)
2492         right = PAIR_DE;
2493     else if (left == PAIR_INVALID)
2494         left = PAIR_DE;
2495
2496     fetchPair(left, AOP(IC_LEFT(ic)));
2497     /* Order is important.  Right may be HL */
2498     fetchPair(right, AOP(IC_RIGHT(ic)));
2499
2500     emit2("ld a,%s", _pairs[left].l);
2501     emit2("sub a,%s", _pairs[right].l);
2502     emit2("ld e,a");
2503     emit2("ld a,%s", _pairs[left].h);
2504     emit2("sbc a,%s", _pairs[right].h);
2505
2506     aopPut(AOP(IC_RESULT(ic)), "a", 1);
2507     aopPut(AOP(IC_RESULT(ic)), "e", 0);
2508     goto release;
2509       }
2510       else if (size == 4) {
2511     emit2("; WARNING: This sub is probably broken.\n");
2512       }
2513   }
2514     }
2515
2516     /* if literal, add a,#-lit, else normal subb */
2517     while (size--) {
2518   MOVA(aopGet(AOP(IC_LEFT(ic)),offset,FALSE));
2519   if (AOP_TYPE(IC_RIGHT(ic)) != AOP_LIT) {
2520       if (!offset)
2521     emitcode("sub","a,%s",
2522        aopGet(AOP(IC_RIGHT(ic)),offset,FALSE));
2523       else
2524     emitcode("sbc","a,%s",
2525        aopGet(AOP(IC_RIGHT(ic)),offset,FALSE));
2526   }
2527   else{
2528       /* first add without previous c */
2529       if (!offset)
2530     emit2("add a,!immedbyte", (unsigned int)(lit & 0x0FFL));
2531       else
2532     emit2("adc a,!immedbyte", (unsigned int)((lit >> (offset*8)) & 0x0FFL));
2533   }
2534   aopPut(AOP(IC_RESULT(ic)),"a",offset++);
2535     }
2536
2537     if (AOP_SIZE(IC_RESULT(ic)) == 3 &&
2538   AOP_SIZE(IC_LEFT(ic)) == 3   &&
2539   !sameRegs(AOP(IC_RESULT(ic)),AOP(IC_LEFT(ic))))
2540   wassert(0);
2541
2542 release:
2543     freeAsmop(IC_LEFT(ic),NULL,ic);
2544     freeAsmop(IC_RIGHT(ic),NULL,ic);
2545     freeAsmop(IC_RESULT(ic),NULL,ic);
2546 }
2547
2548 /*-----------------------------------------------------------------*/
2549 /* genMult - generates code for multiplication                     */
2550 /*-----------------------------------------------------------------*/
2551 static void genMult (iCode *ic)
2552 {
2553     /* Shouldn't occur - all done through function calls */
2554     wassert(0);
2555 }
2556
2557 /*-----------------------------------------------------------------*/
2558 /* genDiv - generates code for division                            */
2559 /*-----------------------------------------------------------------*/
2560 static void genDiv (iCode *ic)
2561 {
2562     /* Shouldn't occur - all done through function calls */
2563     wassert(0);
2564 }
2565
2566 /*-----------------------------------------------------------------*/
2567 /* genMod - generates code for division                            */
2568 /*-----------------------------------------------------------------*/
2569 static void genMod (iCode *ic)
2570 {
2571     /* Shouldn't occur - all done through function calls */
2572     wassert(0);
2573 }
2574
2575 /*-----------------------------------------------------------------*/
2576 /* genIfxJump :- will create a jump depending on the ifx           */
2577 /*-----------------------------------------------------------------*/
2578 static void genIfxJump (iCode *ic, char *jval)
2579 {
2580     symbol *jlbl ;
2581     const char *inst;
2582
2583     /* if true label then we jump if condition
2584     supplied is true */
2585     if (IC_TRUE(ic)) {
2586         jlbl = IC_TRUE(ic);
2587   if (!strcmp(jval, "a")) {
2588       inst = "nz";
2589   }
2590   else if (!strcmp(jval, "c")) {
2591       inst = "c";
2592   }
2593   else if (!strcmp(jval, "nc")) {
2594       inst = "nc";
2595   }
2596   else {
2597       /* The buffer contains the bit on A that we should test */
2598       inst = "nz";
2599   }
2600     }
2601     else {
2602         /* false label is present */
2603         jlbl = IC_FALSE(ic) ;
2604   if (!strcmp(jval, "a")) {
2605       inst = "z";
2606   }
2607   else if (!strcmp(jval, "c")) {
2608       inst = "nc";
2609   }
2610   else if (!strcmp(jval, "nc")) {
2611       inst = "c";
2612   }
2613   else {
2614       /* The buffer contains the bit on A that we should test */
2615       inst = "z";
2616   }
2617     }
2618     /* Z80 can do a conditional long jump */
2619     if (!strcmp(jval, "a")) {
2620   emitcode("or", "a,a");
2621     }
2622     else if (!strcmp(jval, "c")) {
2623     }
2624     else if (!strcmp(jval, "nc")) {
2625     }
2626     else {
2627   emitcode("bit", "%s,a", jval);
2628     }
2629     emit2("jp %s,!tlabel", inst, jlbl->key+100);
2630
2631     /* mark the icode as generated */
2632     ic->generated = 1;
2633 }
2634
2635 static const char *_getPairIdName(PAIR_ID id)
2636 {
2637     return _pairs[id].name;
2638 }
2639
2640 /** Generic compare for > or <
2641  */
2642 static void genCmp (operand *left,operand *right,
2643                     operand *result, iCode *ifx, int sign)
2644 {
2645     int size, offset = 0 ;
2646     unsigned long lit = 0L;
2647     bool swap_sense = FALSE;
2648
2649     /* if left & right are bit variables */
2650     if (AOP_TYPE(left) == AOP_CRY &&
2651         AOP_TYPE(right) == AOP_CRY ) {
2652   /* Cant happen on the Z80 */
2653   wassert(0);
2654     } else {
2655         /* subtract right from left if at the
2656         end the carry flag is set then we know that
2657         left is greater than right */
2658         size = max(AOP_SIZE(left),AOP_SIZE(right));
2659
2660         /* if unsigned char cmp with lit, just compare */
2661         if((size == 1) &&
2662            (AOP_TYPE(right) == AOP_LIT && AOP_TYPE(left) != AOP_DIR )){
2663       emitcode("ld", "a,%s", aopGet(AOP(left), offset, FALSE));
2664       if (sign) {
2665     emit2("xor a,!immedbyte", 0x80);
2666     emit2("cp %s^!constbyte", aopGet(AOP(right), offset, FALSE), 0x80);
2667       }
2668       else
2669     emitcode("cp", "%s", aopGet(AOP(right), offset, FALSE));
2670         }
2671   else {
2672       /* Special cases:
2673          On the GB:
2674             If the left or the right is a lit:
2675         Load -lit into HL, add to right via, check sense.
2676       */
2677       if (size == 2 && (AOP_TYPE(right) == AOP_LIT || AOP_TYPE(left) == AOP_LIT)) {
2678     PAIR_ID id = PAIR_DE;
2679     asmop *lit = AOP(right);
2680     asmop *op = AOP(left);
2681     swap_sense = TRUE;
2682
2683     if (AOP_TYPE(left) == AOP_LIT) {
2684         swap_sense = FALSE;
2685         lit = AOP(left);
2686         op = AOP(right);
2687     }
2688     if (sign) {
2689         emit2("ld e,%s", aopGet(op, 0, 0));
2690         emit2("ld a,%s", aopGet(op, 1, 0));
2691         emit2("xor a,!immedbyte", 0x80);
2692         emit2("ld d,a");
2693     }
2694     else {
2695         id = getPairId(op);
2696         if (id == PAIR_INVALID) {
2697       fetchPair(PAIR_DE, op);
2698       id = PAIR_DE;
2699         }
2700     }
2701     spillPair(PAIR_HL);
2702     emit2("ld hl,%s", fetchLitSpecial(lit, TRUE, sign));
2703     emit2("add hl,%s", _getPairIdName(id));
2704     goto release;
2705       }
2706             if(AOP_TYPE(right) == AOP_LIT) {
2707                 lit = (unsigned long)floatFromVal(AOP(right)->aopu.aop_lit);
2708                 /* optimize if(x < 0) or if(x >= 0) */
2709                 if (lit == 0L){
2710                     if (!sign) {
2711       /* No sign so it's always false */
2712                         CLRC;
2713                     }
2714                     else{
2715       /* Just load in the top most bit */
2716                         MOVA(aopGet(AOP(left),AOP_SIZE(left)-1,FALSE));
2717                         if(!(AOP_TYPE(result) == AOP_CRY && AOP_SIZE(result)) && ifx) {
2718                             genIfxJump (ifx,"7");
2719                             return;
2720                         }
2721                         else
2722                             emitcode("rlc","a");
2723                     }
2724                     goto release;
2725                 }
2726             }
2727       if (sign) {
2728     /* First setup h and l contaning the top most bytes XORed */
2729     bool fDidXor = FALSE;
2730     if (AOP_TYPE(left) == AOP_LIT){
2731         unsigned long lit = (unsigned long)
2732       floatFromVal(AOP(left)->aopu.aop_lit);
2733         emit2("ld %s,!immedbyte", _fTmp[0],
2734            0x80 ^ (unsigned int)((lit >> ((size-1)*8)) & 0x0FFL));
2735     }
2736     else {
2737         emitcode("ld", "a,%s", aopGet(AOP(left), size-1, FALSE));
2738         emit2("xor a,!immedbyte", 0x80);
2739         emitcode("ld", "%s,a", _fTmp[0]);
2740         fDidXor = TRUE;
2741     }
2742     if (AOP_TYPE(right) == AOP_LIT) {
2743         unsigned long lit = (unsigned long)
2744       floatFromVal(AOP(right)->aopu.aop_lit);
2745         emit2("ld %s,!immedbyte", _fTmp[1],
2746            0x80 ^ (unsigned int)((lit >> ((size-1)*8)) & 0x0FFL));
2747     }
2748     else {
2749         emitcode("ld", "a,%s", aopGet(AOP(right), size-1, FALSE));
2750         emit2("xor a,!immedbyte", 0x80);
2751         emitcode("ld", "%s,a", _fTmp[1]);
2752         fDidXor = TRUE;
2753     }
2754     if (!fDidXor)
2755         CLRC;
2756       }
2757       else {
2758     CLRC;
2759       }
2760             while (size--) {
2761     /* Do a long subtract */
2762     if (!sign || size ) {
2763         MOVA(aopGet(AOP(left),offset,FALSE));
2764     }
2765                 if (sign && size == 0) {
2766         emitcode("ld", "a,%s", _fTmp[0]);
2767         emitcode("sbc", "a,%s", _fTmp[1]);
2768     }
2769     else {
2770         /* Subtract through, propagating the carry */
2771         emitcode("sbc","a,%s ; 2",aopGet(AOP(right),offset++,FALSE));
2772     }
2773             }
2774         }
2775     }
2776
2777 release:
2778     if (AOP_TYPE(result) == AOP_CRY && AOP_SIZE(result)) {
2779         outBitCLong(result, swap_sense);
2780     } else {
2781         /* if the result is used in the next
2782         ifx conditional branch then generate
2783         code a little differently */
2784         if (ifx)
2785             genIfxJump(ifx, swap_sense ? "nc" : "c");
2786         else
2787             outBitCLong(result, swap_sense);
2788         /* leave the result in acc */
2789     }
2790 }
2791
2792 /*-----------------------------------------------------------------*/
2793 /* genCmpGt :- greater than comparison                             */
2794 /*-----------------------------------------------------------------*/
2795 static void genCmpGt (iCode *ic, iCode *ifx)
2796 {
2797     operand *left, *right, *result;
2798     sym_link *letype , *retype;
2799     int sign ;
2800
2801     left = IC_LEFT(ic);
2802     right= IC_RIGHT(ic);
2803     result = IC_RESULT(ic);
2804
2805     letype = getSpec(operandType(left));
2806     retype =getSpec(operandType(right));
2807     sign =  !(SPEC_USIGN(letype) | SPEC_USIGN(retype));
2808     /* assign the amsops */
2809     aopOp (left,ic,FALSE, FALSE);
2810     aopOp (right,ic,FALSE, FALSE);
2811     aopOp (result,ic,TRUE, FALSE);
2812
2813     genCmp(right, left, result, ifx, sign);
2814
2815     freeAsmop(left,NULL,ic);
2816     freeAsmop(right,NULL,ic);
2817     freeAsmop(result,NULL,ic);
2818 }
2819
2820 /*-----------------------------------------------------------------*/
2821 /* genCmpLt - less than comparisons                                */
2822 /*-----------------------------------------------------------------*/
2823 static void genCmpLt (iCode *ic, iCode *ifx)
2824 {
2825     operand *left, *right, *result;
2826     sym_link *letype , *retype;
2827     int sign ;
2828
2829     left = IC_LEFT(ic);
2830     right= IC_RIGHT(ic);
2831     result = IC_RESULT(ic);
2832
2833     letype = getSpec(operandType(left));
2834     retype =getSpec(operandType(right));
2835     sign =  !(SPEC_USIGN(letype) | SPEC_USIGN(retype));
2836
2837     /* assign the amsops */
2838     aopOp (left,ic,FALSE, FALSE);
2839     aopOp (right,ic,FALSE, FALSE);
2840     aopOp (result,ic,TRUE, FALSE);
2841
2842     genCmp(left, right, result, ifx, sign);
2843
2844     freeAsmop(left,NULL,ic);
2845     freeAsmop(right,NULL,ic);
2846     freeAsmop(result,NULL,ic);
2847 }
2848
2849 /*-----------------------------------------------------------------*/
2850 /* gencjneshort - compare and jump if not equal                    */
2851 /*-----------------------------------------------------------------*/
2852 static void gencjneshort(operand *left, operand *right, symbol *lbl)
2853 {
2854     int size = max(AOP_SIZE(left),AOP_SIZE(right));
2855     int offset = 0;
2856     unsigned long lit = 0L;
2857
2858     /* Swap the left and right if it makes the computation easier */
2859     if (AOP_TYPE(left) == AOP_LIT) {
2860         operand *t = right;
2861         right = left;
2862         left = t;
2863     }
2864
2865     if(AOP_TYPE(right) == AOP_LIT)
2866         lit = (unsigned long)floatFromVal(AOP(right)->aopu.aop_lit);
2867
2868     /* if the right side is a literal then anything goes */
2869     if (AOP_TYPE(right) == AOP_LIT &&
2870         AOP_TYPE(left) != AOP_DIR ) {
2871   if (lit == 0) {
2872       emitcode("ld", "a,%s", aopGet(AOP(left), offset, FALSE));
2873       if (size > 1) {
2874     size--;
2875     offset++;
2876     while (size--) {
2877         emitcode("or", "a,%s", aopGet(AOP(left), offset, FALSE));
2878     }
2879       }
2880       else {
2881     emitcode("or", "a,a");
2882       }
2883       emit2("jp nz,!tlabel", lbl->key+100);
2884   }
2885   else {
2886       while (size--) {
2887     emitcode("ld", "a,%s ; 2", aopGet(AOP(left),offset,FALSE));
2888     if ((AOP_TYPE(right) == AOP_LIT) && lit == 0)
2889         emitcode("or", "a,a");
2890     else
2891         emitcode("cp", "a,%s", aopGet(AOP(right),offset,FALSE));
2892     emit2("jp nz,!tlabel", lbl->key+100);
2893     offset++;
2894       }
2895   }
2896     }
2897     /* if the right side is in a register or in direct space or
2898     if the left is a pointer register & right is not */
2899     else if (AOP_TYPE(right) == AOP_REG ||
2900              AOP_TYPE(right) == AOP_DIR ||
2901              (AOP_TYPE(left) == AOP_DIR && AOP_TYPE(right) == AOP_LIT)) {
2902         while (size--) {
2903             MOVA(aopGet(AOP(left),offset,FALSE));
2904             if((AOP_TYPE(left) == AOP_DIR && AOP_TYPE(right) == AOP_LIT) &&
2905                ((unsigned int)((lit >> (offset*8)) & 0x0FFL) == 0))
2906     /* PENDING */
2907                 emit2("jp nz,!tlabel", lbl->key+100);
2908             else {
2909     emitcode("cp", "%s ; 4", aopGet(AOP(right),offset,FALSE));
2910     emit2("jp nz,!tlabel", lbl->key+100);
2911       }
2912             offset++;
2913         }
2914     } else {
2915         /* right is a pointer reg need both a & b */
2916   /* PENDING: is this required? */
2917         while(size--) {
2918             MOVA(aopGet(AOP(right),offset,FALSE));
2919       emitcode("cp", "%s ; 5", aopGet(AOP(left), offset, FALSE));
2920       emit2("!shortjp nz,!tlabel", lbl->key+100);
2921             offset++;
2922         }
2923     }
2924 }
2925
2926 /*-----------------------------------------------------------------*/
2927 /* gencjne - compare and jump if not equal                         */
2928 /*-----------------------------------------------------------------*/
2929 static void gencjne(operand *left, operand *right, symbol *lbl)
2930 {
2931     symbol *tlbl  = newiTempLabel(NULL);
2932
2933     gencjneshort(left, right, lbl);
2934
2935     /* PENDING: ?? */
2936     emit2("ld a,!one");
2937     emit2("!shortjp !tlabel", tlbl->key+100);
2938     emitLabel(lbl->key+100);
2939     emitcode("xor","a,a");
2940     emitLabel(tlbl->key+100);
2941 }
2942
2943 /*-----------------------------------------------------------------*/
2944 /* genCmpEq - generates code for equal to                          */
2945 /*-----------------------------------------------------------------*/
2946 static void genCmpEq (iCode *ic, iCode *ifx)
2947 {
2948     operand *left, *right, *result;
2949
2950     aopOp((left=IC_LEFT(ic)),ic,FALSE, FALSE);
2951     aopOp((right=IC_RIGHT(ic)),ic,FALSE, FALSE);
2952     aopOp((result=IC_RESULT(ic)),ic,TRUE, FALSE);
2953
2954     /* Swap operands if it makes the operation easier. ie if:
2955        1.  Left is a literal.
2956     */
2957     if (AOP_TYPE(IC_LEFT(ic)) == AOP_LIT) {
2958         operand *t = IC_RIGHT(ic);
2959         IC_RIGHT(ic) = IC_LEFT(ic);
2960         IC_LEFT(ic) = t;
2961     }
2962
2963     if (ifx && !AOP_SIZE(result)){
2964         symbol *tlbl;
2965         /* if they are both bit variables */
2966         if (AOP_TYPE(left) == AOP_CRY &&
2967             ((AOP_TYPE(right) == AOP_CRY) || (AOP_TYPE(right) == AOP_LIT))) {
2968       wassert(0);
2969         } else {
2970             tlbl = newiTempLabel(NULL);
2971             gencjneshort(left, right, tlbl);
2972             if ( IC_TRUE(ifx) ) {
2973     emit2("jp !tlabel", IC_TRUE(ifx)->key+100);
2974     emitLabel(tlbl->key+100);
2975             } else {
2976     /* PENDING: do this better */
2977                 symbol *lbl = newiTempLabel(NULL);
2978     emit2("!shortjp !tlabel", lbl->key+100);
2979                 emitLabel(tlbl->key+100);
2980                 emit2("jp !tlabel", IC_FALSE(ifx)->key+100);
2981     emitLabel(lbl->key+100);
2982             }
2983         }
2984         /* mark the icode as generated */
2985         ifx->generated = 1;
2986         goto release ;
2987     }
2988
2989     /* if they are both bit variables */
2990     if (AOP_TYPE(left) == AOP_CRY &&
2991         ((AOP_TYPE(right) == AOP_CRY) || (AOP_TYPE(right) == AOP_LIT))) {
2992   wassert(0);
2993     } else {
2994         gencjne(left,right,newiTempLabel(NULL));
2995         if (AOP_TYPE(result) == AOP_CRY && AOP_SIZE(result)) {
2996       wassert(0);
2997         }
2998         if (ifx) {
2999       genIfxJump(ifx,"a");
3000       goto release;
3001         }
3002         /* if the result is used in an arithmetic operation
3003         then put the result in place */
3004         if (AOP_TYPE(result) != AOP_CRY) {
3005             outAcc(result);
3006   }
3007         /* leave the result in acc */
3008     }
3009
3010 release:
3011     freeAsmop(left,NULL,ic);
3012     freeAsmop(right,NULL,ic);
3013     freeAsmop(result,NULL,ic);
3014 }
3015
3016 /*-----------------------------------------------------------------*/
3017 /* ifxForOp - returns the icode containing the ifx for operand     */
3018 /*-----------------------------------------------------------------*/
3019 static iCode *ifxForOp ( operand *op, iCode *ic )
3020 {
3021     /* if true symbol then needs to be assigned */
3022     if (IS_TRUE_SYMOP(op))
3023         return NULL ;
3024
3025     /* if this has register type condition and
3026     the next instruction is ifx with the same operand
3027     and live to of the operand is upto the ifx only then */
3028     if (ic->next &&
3029         ic->next->op == IFX &&
3030         IC_COND(ic->next)->key == op->key &&
3031         OP_SYMBOL(op)->liveTo <= ic->next->seq )
3032         return ic->next;
3033
3034     return NULL;
3035 }
3036
3037 /*-----------------------------------------------------------------*/
3038 /* genAndOp - for && operation                                     */
3039 /*-----------------------------------------------------------------*/
3040 static void genAndOp (iCode *ic)
3041 {
3042     operand *left,*right, *result;
3043     symbol *tlbl;
3044
3045     /* note here that && operations that are in an if statement are
3046        taken away by backPatchLabels only those used in arthmetic
3047        operations remain */
3048     aopOp((left=IC_LEFT(ic)),ic,FALSE, TRUE);
3049     aopOp((right=IC_RIGHT(ic)),ic,FALSE, TRUE);
3050     aopOp((result=IC_RESULT(ic)),ic,FALSE, FALSE);
3051
3052     /* if both are bit variables */
3053     if (AOP_TYPE(left) == AOP_CRY &&
3054         AOP_TYPE(right) == AOP_CRY ) {
3055   wassert(0);
3056     } else {
3057         tlbl = newiTempLabel(NULL);
3058         toBoolean(left);
3059   emit2("!shortjp z,!tlabel", tlbl->key+100);
3060         toBoolean(right);
3061   emitLabel(tlbl->key+100);
3062         outBitAcc(result);
3063     }
3064
3065     freeAsmop(left,NULL,ic);
3066     freeAsmop(right,NULL,ic);
3067     freeAsmop(result,NULL,ic);
3068 }
3069
3070 /*-----------------------------------------------------------------*/
3071 /* genOrOp - for || operation                                      */
3072 /*-----------------------------------------------------------------*/
3073 static void genOrOp (iCode *ic)
3074 {
3075     operand *left,*right, *result;
3076     symbol *tlbl;
3077
3078     /* note here that || operations that are in an
3079        if statement are taken away by backPatchLabels
3080        only those used in arthmetic operations remain */
3081     aopOp((left=IC_LEFT(ic)),ic,FALSE, TRUE);
3082     aopOp((right=IC_RIGHT(ic)),ic,FALSE, TRUE);
3083     aopOp((result=IC_RESULT(ic)),ic,FALSE, FALSE);
3084
3085     /* if both are bit variables */
3086     if (AOP_TYPE(left) == AOP_CRY &&
3087         AOP_TYPE(right) == AOP_CRY ) {
3088   wassert(0);
3089     } else {
3090         tlbl = newiTempLabel(NULL);
3091         toBoolean(left);
3092   emit2("!shortjp nz,!tlabel", tlbl->key+100);
3093         toBoolean(right);
3094   emitLabel(tlbl->key+100);
3095         outBitAcc(result);
3096     }
3097
3098     freeAsmop(left,NULL,ic);
3099     freeAsmop(right,NULL,ic);
3100     freeAsmop(result,NULL,ic);
3101 }
3102
3103 /*-----------------------------------------------------------------*/
3104 /* isLiteralBit - test if lit == 2^n                               */
3105 /*-----------------------------------------------------------------*/
3106 int isLiteralBit(unsigned long lit)
3107 {
3108     unsigned long pw[32] = {1L,2L,4L,8L,16L,32L,64L,128L,
3109     0x100L,0x200L,0x400L,0x800L,
3110     0x1000L,0x2000L,0x4000L,0x8000L,
3111     0x10000L,0x20000L,0x40000L,0x80000L,
3112     0x100000L,0x200000L,0x400000L,0x800000L,
3113     0x1000000L,0x2000000L,0x4000000L,0x8000000L,
3114     0x10000000L,0x20000000L,0x40000000L,0x80000000L};
3115     int idx;
3116
3117     for(idx = 0; idx < 32; idx++)
3118         if(lit == pw[idx])
3119             return idx+1;
3120     return 0;
3121 }
3122
3123 /*-----------------------------------------------------------------*/
3124 /* jmpTrueOrFalse -                                                */
3125 /*-----------------------------------------------------------------*/
3126 static void jmpTrueOrFalse (iCode *ic, symbol *tlbl)
3127 {
3128     // ugly but optimized by peephole
3129     if(IC_TRUE(ic)){
3130         symbol *nlbl = newiTempLabel(NULL);
3131   emit2("jp !tlabel", nlbl->key+100);
3132         emitLabel(tlbl->key+100);
3133   emit2("jp !tlabel", IC_TRUE(ic)->key+100);
3134         emitLabel(nlbl->key+100);
3135     }
3136     else{
3137   emit2("jp !tlabel", IC_FALSE(ic)->key+100);
3138         emitLabel(tlbl->key+100);
3139     }
3140     ic->generated = 1;
3141 }
3142
3143 /*-----------------------------------------------------------------*/
3144 /* genAnd  - code for and                                          */
3145 /*-----------------------------------------------------------------*/
3146 static void genAnd (iCode *ic, iCode *ifx)
3147 {
3148     operand *left, *right, *result;
3149     int size, offset=0;
3150     unsigned long lit = 0L;
3151     int bytelit = 0;
3152
3153     aopOp((left = IC_LEFT(ic)),ic,FALSE, FALSE);
3154     aopOp((right= IC_RIGHT(ic)),ic,FALSE, FALSE);
3155     aopOp((result=IC_RESULT(ic)),ic,TRUE, FALSE);
3156
3157 #ifdef DEBUG_TYPE
3158     emitcode("","; Type res[%d] = l[%d]&r[%d]",
3159              AOP_TYPE(result),
3160              AOP_TYPE(left), AOP_TYPE(right));
3161     emitcode("","; Size res[%d] = l[%d]&r[%d]",
3162              AOP_SIZE(result),
3163              AOP_SIZE(left), AOP_SIZE(right));
3164 #endif
3165
3166     /* if left is a literal & right is not then exchange them */
3167     if ((AOP_TYPE(left) == AOP_LIT && AOP_TYPE(right) != AOP_LIT) ||
3168   AOP_NEEDSACC(left)) {
3169         operand *tmp = right ;
3170         right = left;
3171         left = tmp;
3172     }
3173
3174     /* if result = right then exchange them */
3175     if(sameRegs(AOP(result),AOP(right))){
3176         operand *tmp = right ;
3177         right = left;
3178         left = tmp;
3179     }
3180
3181     /* if right is bit then exchange them */
3182     if (AOP_TYPE(right) == AOP_CRY &&
3183         AOP_TYPE(left) != AOP_CRY){
3184         operand *tmp = right ;
3185         right = left;
3186         left = tmp;
3187     }
3188     if(AOP_TYPE(right) == AOP_LIT)
3189         lit = (unsigned long)floatFromVal (AOP(right)->aopu.aop_lit);
3190
3191     size = AOP_SIZE(result);
3192
3193     if (AOP_TYPE(left) == AOP_CRY){
3194   wassert(0);
3195         goto release ;
3196     }
3197
3198     // if(val & 0xZZ)       - size = 0, ifx != FALSE  -
3199     // bit = val & 0xZZ     - size = 1, ifx = FALSE -
3200     if((AOP_TYPE(right) == AOP_LIT) &&
3201        (AOP_TYPE(result) == AOP_CRY) &&
3202        (AOP_TYPE(left) != AOP_CRY)) {
3203         int posbit = isLiteralBit(lit);
3204         /* left &  2^n */
3205         if(posbit){
3206             posbit--;
3207             MOVA(aopGet(AOP(left),posbit>>3,FALSE));
3208             // bit = left & 2^n
3209             if(size) {
3210     wassert(0);
3211                 emitcode("mov","c,acc.%d",posbit&0x07);
3212       }
3213             // if(left &  2^n)
3214             else{
3215                 if (ifx) {
3216                     sprintf(buffer, "%d", posbit&0x07);
3217                     genIfxJump(ifx, buffer);
3218                 }
3219     else {
3220         wassert(0);
3221     }
3222                 goto release;
3223             }
3224         } else {
3225             symbol *tlbl = newiTempLabel(NULL);
3226             int sizel = AOP_SIZE(left);
3227             if(size) {
3228     wassert(0);
3229                 emitcode("setb","c");
3230       }
3231             while(sizel--){
3232                 if((bytelit = ((lit >> (offset*8)) & 0x0FFL)) != 0x0L){
3233                     MOVA( aopGet(AOP(left),offset,FALSE));
3234                     // byte ==  2^n ?
3235                     if((posbit = isLiteralBit(bytelit)) != 0) {
3236       wassert(0);
3237                         emitcode("jb","acc.%d,%05d$",(posbit-1)&0x07,tlbl->key+100);
3238         }
3239                     else{
3240                         if(bytelit != 0x0FFL)
3241                             emitcode("and","a,%s",
3242                                      aopGet(AOP(right),offset,FALSE));
3243       else
3244           /* For the flags */
3245           emit2("or a,a");
3246                         emit2("!shortjp nz,!tlabel", tlbl->key+100);
3247                     }
3248                 }
3249                 offset++;
3250             }
3251             // bit = left & literal
3252             if (size){
3253                 emitcode("clr","c");
3254     emit2("!tlabeldef", tlbl->key+100);
3255             }
3256             // if(left & literal)
3257             else{
3258                 if(ifx)
3259                     jmpTrueOrFalse(ifx, tlbl);
3260                 goto release ;
3261             }
3262         }
3263         outBitC(result);
3264         goto release ;
3265     }
3266
3267     /* if left is same as result */
3268     if(sameRegs(AOP(result),AOP(left))){
3269         for(;size--; offset++) {
3270             if(AOP_TYPE(right) == AOP_LIT){
3271                 if((bytelit = (int)((lit >> (offset*8)) & 0x0FFL)) == 0x0FF)
3272                     continue;
3273                 else {
3274         if (bytelit == 0)
3275       aopPut(AOP(result),zero,offset);
3276         else {
3277       MOVA(aopGet(AOP(left),offset,FALSE));
3278       emitcode("and","a,%s",
3279          aopGet(AOP(right),offset,FALSE));
3280       aopPut(AOP(left), "a", offset);
3281         }
3282     }
3283
3284             } else {
3285     if (AOP_TYPE(left) == AOP_ACC) {
3286         wassert(0);
3287     }
3288     else {
3289         MOVA(aopGet(AOP(left),offset,FALSE));
3290         emitcode("and","a,%s",
3291            aopGet(AOP(right),offset,FALSE));
3292         aopPut(AOP(left), "a", offset);
3293     }
3294             }
3295         }
3296     } else {
3297         // left & result in different registers
3298         if(AOP_TYPE(result) == AOP_CRY){
3299       wassert(0);
3300         } else {
3301       for(;(size--);offset++) {
3302     // normal case
3303     // result = left & right
3304     if(AOP_TYPE(right) == AOP_LIT){
3305         if((bytelit = (int)((lit >> (offset*8)) & 0x0FFL)) == 0x0FF){
3306       aopPut(AOP(result),
3307              aopGet(AOP(left),offset,FALSE),
3308              offset);
3309       continue;
3310         } else if(bytelit == 0){
3311       aopPut(AOP(result),zero,offset);
3312       continue;
3313         }
3314     }
3315     // faster than result <- left, anl result,right
3316     // and better if result is SFR
3317     if (AOP_TYPE(left) == AOP_ACC)
3318         emitcode("and","a,%s",aopGet(AOP(right),offset,FALSE));
3319     else {
3320         MOVA(aopGet(AOP(left),offset,FALSE));
3321         emitcode("and","a,%s",
3322            aopGet(AOP(right),offset,FALSE));
3323     }
3324     aopPut(AOP(result),"a",offset);
3325       }
3326   }
3327
3328     }
3329
3330 release :
3331     freeAsmop(left,NULL,ic);
3332     freeAsmop(right,NULL,ic);
3333     freeAsmop(result,NULL,ic);
3334 }
3335
3336 /*-----------------------------------------------------------------*/
3337 /* genOr  - code for or                                            */
3338 /*-----------------------------------------------------------------*/
3339 static void genOr (iCode *ic, iCode *ifx)
3340 {
3341     operand *left, *right, *result;
3342     int size, offset=0;
3343     unsigned long lit = 0L;
3344
3345     aopOp((left = IC_LEFT(ic)),ic,FALSE, FALSE);
3346     aopOp((right= IC_RIGHT(ic)),ic,FALSE, FALSE);
3347     aopOp((result=IC_RESULT(ic)),ic,TRUE, FALSE);
3348
3349 #if 1
3350     emitcode("","; Type res[%d] = l[%d]&r[%d]",
3351              AOP_TYPE(result),
3352              AOP_TYPE(left), AOP_TYPE(right));
3353     emitcode("","; Size res[%d] = l[%d]&r[%d]",
3354              AOP_SIZE(result),
3355              AOP_SIZE(left), AOP_SIZE(right));
3356 #endif
3357
3358     /* if left is a literal & right is not then exchange them */
3359     if ((AOP_TYPE(left) == AOP_LIT && AOP_TYPE(right) != AOP_LIT) ||
3360   AOP_NEEDSACC(left)) {
3361         operand *tmp = right ;
3362         right = left;
3363         left = tmp;
3364     }
3365
3366     /* if result = right then exchange them */
3367     if(sameRegs(AOP(result),AOP(right))){
3368         operand *tmp = right ;
3369         right = left;
3370         left = tmp;
3371     }
3372
3373     /* if right is bit then exchange them */
3374     if (AOP_TYPE(right) == AOP_CRY &&
3375         AOP_TYPE(left) != AOP_CRY){
3376         operand *tmp = right ;
3377         right = left;
3378         left = tmp;
3379     }
3380     if(AOP_TYPE(right) == AOP_LIT)
3381         lit = (unsigned long)floatFromVal (AOP(right)->aopu.aop_lit);
3382
3383     size = AOP_SIZE(result);
3384
3385     if (AOP_TYPE(left) == AOP_CRY){
3386   wassert(0);
3387         goto release ;
3388     }
3389
3390     if((AOP_TYPE(right) == AOP_LIT) &&
3391        (AOP_TYPE(result) == AOP_CRY) &&
3392        (AOP_TYPE(left) != AOP_CRY)){
3393   wassert(0);
3394         goto release ;
3395     }
3396
3397     /* if left is same as result */
3398     if(sameRegs(AOP(result),AOP(left))){
3399         for(;size--; offset++) {
3400             if(AOP_TYPE(right) == AOP_LIT){
3401                 if(((lit >> (offset*8)) & 0x0FFL) == 0x00L)
3402                     continue;
3403                 else {
3404         MOVA(aopGet(AOP(left),offset,FALSE));
3405         emitcode("or","a,%s",
3406            aopGet(AOP(right),offset,FALSE));
3407         aopPut(AOP(result),"a", offset);
3408     }
3409             } else {
3410     if (AOP_TYPE(left) == AOP_ACC)
3411         emitcode("or","a,%s",aopGet(AOP(right),offset,FALSE));
3412     else {
3413         MOVA(aopGet(AOP(left),offset,FALSE));
3414         emitcode("or","a,%s",
3415            aopGet(AOP(right),offset,FALSE));
3416         aopPut(AOP(result),"a", offset);
3417     }
3418             }
3419         }
3420     } else {
3421         // left & result in different registers
3422         if(AOP_TYPE(result) == AOP_CRY){
3423       wassert(0);
3424         } else for(;(size--);offset++){
3425             // normal case
3426             // result = left & right
3427             if(AOP_TYPE(right) == AOP_LIT){
3428                 if(((lit >> (offset*8)) & 0x0FFL) == 0x00L){
3429                     aopPut(AOP(result),
3430                            aopGet(AOP(left),offset,FALSE),
3431                            offset);
3432                     continue;
3433                 }
3434             }
3435             // faster than result <- left, anl result,right
3436             // and better if result is SFR
3437       if (AOP_TYPE(left) == AOP_ACC)
3438     emitcode("or","a,%s",aopGet(AOP(right),offset,FALSE));
3439       else {
3440     MOVA(aopGet(AOP(left),offset,FALSE));
3441     emitcode("or","a,%s",
3442        aopGet(AOP(right),offset,FALSE));
3443       }
3444       aopPut(AOP(result),"a",offset);
3445       /* PENDING: something weird is going on here.  Add exception. */
3446       if (AOP_TYPE(result) == AOP_ACC)
3447     break;
3448         }
3449     }
3450
3451 release :
3452     freeAsmop(left,NULL,ic);
3453     freeAsmop(right,NULL,ic);
3454     freeAsmop(result,NULL,ic);
3455 }
3456
3457 /*-----------------------------------------------------------------*/
3458 /* genXor - code for xclusive or                                   */
3459 /*-----------------------------------------------------------------*/
3460 static void genXor (iCode *ic, iCode *ifx)
3461 {
3462     operand *left, *right, *result;
3463     int size, offset=0;
3464     unsigned long lit = 0L;
3465
3466     aopOp((left = IC_LEFT(ic)),ic,FALSE, FALSE);
3467     aopOp((right= IC_RIGHT(ic)),ic,FALSE, FALSE);
3468     aopOp((result=IC_RESULT(ic)),ic,TRUE, FALSE);
3469
3470     /* if left is a literal & right is not then exchange them */
3471     if ((AOP_TYPE(left) == AOP_LIT && AOP_TYPE(right) != AOP_LIT) ||
3472   AOP_NEEDSACC(left)) {
3473         operand *tmp = right ;
3474         right = left;
3475         left = tmp;
3476     }
3477
3478     /* if result = right then exchange them */
3479     if(sameRegs(AOP(result),AOP(right))){
3480         operand *tmp = right ;
3481         right = left;
3482         left = tmp;
3483     }
3484
3485     /* if right is bit then exchange them */
3486     if (AOP_TYPE(right) == AOP_CRY &&
3487         AOP_TYPE(left) != AOP_CRY){
3488         operand *tmp = right ;
3489         right = left;
3490         left = tmp;
3491     }
3492     if(AOP_TYPE(right) == AOP_LIT)
3493         lit = (unsigned long)floatFromVal (AOP(right)->aopu.aop_lit);
3494
3495     size = AOP_SIZE(result);
3496
3497     if (AOP_TYPE(left) == AOP_CRY){
3498   wassert(0);
3499         goto release ;
3500     }
3501
3502     if((AOP_TYPE(right) == AOP_LIT) &&
3503        (AOP_TYPE(result) == AOP_CRY) &&
3504        (AOP_TYPE(left) != AOP_CRY)){
3505   wassert(0);
3506         goto release ;
3507     }
3508
3509     /* if left is same as result */
3510     if(sameRegs(AOP(result),AOP(left))){
3511         for(;size--; offset++) {
3512             if(AOP_TYPE(right) == AOP_LIT){
3513                 if(((lit >> (offset*8)) & 0x0FFL) == 0x00L)
3514                     continue;
3515                 else {
3516         MOVA(aopGet(AOP(right),offset,FALSE));
3517         emitcode("xor","a,%s",
3518            aopGet(AOP(left),offset,FALSE));
3519         aopPut(AOP(result),"a",0);
3520     }
3521             } else {
3522     if (AOP_TYPE(left) == AOP_ACC)
3523         emitcode("xor","a,%s",aopGet(AOP(right),offset,FALSE));
3524     else {
3525         MOVA(aopGet(AOP(right),offset,FALSE));
3526         emitcode("xor","a,%s",
3527            aopGet(AOP(left),offset,FALSE));
3528         aopPut(AOP(result),"a",0);
3529     }
3530             }
3531         }
3532     } else {
3533         // left & result in different registers
3534         if(AOP_TYPE(result) == AOP_CRY){
3535       wassert(0);
3536         } else for(;(size--);offset++){
3537             // normal case
3538             // result = left & right
3539             if(AOP_TYPE(right) == AOP_LIT){
3540                 if(((lit >> (offset*8)) & 0x0FFL) == 0x00L){
3541                     aopPut(AOP(result),
3542                            aopGet(AOP(left),offset,FALSE),
3543                            offset);
3544                     continue;
3545                 }
3546             }
3547             // faster than result <- left, anl result,right
3548             // and better if result is SFR
3549       if (AOP_TYPE(left) == AOP_ACC)
3550     emitcode("xor","a,%s",aopGet(AOP(right),offset,FALSE));
3551       else {
3552     MOVA(aopGet(AOP(right),offset,FALSE));
3553     emitcode("xor","a,%s",
3554        aopGet(AOP(left),offset,FALSE));
3555     aopPut(AOP(result),"a",0);
3556       }
3557       aopPut(AOP(result),"a",offset);
3558         }
3559     }
3560
3561 release :
3562     freeAsmop(left,NULL,ic);
3563     freeAsmop(right,NULL,ic);
3564     freeAsmop(result,NULL,ic);
3565 }
3566
3567 /*-----------------------------------------------------------------*/
3568 /* genInline - write the inline code out                           */
3569 /*-----------------------------------------------------------------*/
3570 static void genInline (iCode *ic)
3571 {
3572     char buffer[MAX_INLINEASM];
3573     char *bp = buffer;
3574     char *bp1= buffer;
3575
3576     inLine += (!options.asmpeep);
3577     strcpy(buffer,IC_INLINE(ic));
3578
3579     /* emit each line as a code */
3580     while (*bp) {
3581         if (*bp == '\n') {
3582             *bp++ = '\0';
3583             emitcode(bp1,"");
3584             bp1 = bp;
3585         } else {
3586             if (*bp == ':') {
3587                 bp++;
3588                 *bp = '\0';
3589                 bp++;
3590                 emitcode(bp1,"");
3591                 bp1 = bp;
3592             } else
3593                 bp++;
3594         }
3595     }
3596     if (bp1 != bp)
3597         emitcode(bp1,"");
3598     /*     emitcode("",buffer); */
3599     inLine -= (!options.asmpeep);
3600 }
3601
3602 /*-----------------------------------------------------------------*/
3603 /* genRRC - rotate right with carry                                */
3604 /*-----------------------------------------------------------------*/
3605 static void genRRC (iCode *ic)
3606 {
3607     wassert(0);
3608 }
3609
3610 /*-----------------------------------------------------------------*/
3611 /* genRLC - generate code for rotate left with carry               */
3612 /*-----------------------------------------------------------------*/
3613 static void genRLC (iCode *ic)
3614 {
3615     wassert(0);
3616 }
3617
3618 /*-----------------------------------------------------------------*/
3619 /* shiftR2Left2Result - shift right two bytes from left to result  */
3620 /*-----------------------------------------------------------------*/
3621 static void shiftR2Left2Result (operand *left, int offl,
3622                                 operand *result, int offr,
3623                                 int shCount, int sign)
3624 {
3625     movLeft2Result(left, offl, result, offr, 0);
3626     movLeft2Result(left, offl+1, result, offr+1, 0);
3627
3628     if (sign) {
3629   wassert(0);
3630     }
3631     else {
3632   /*  if (AOP(result)->type == AOP_REG) {*/
3633       int size = 2;
3634       int offset = 0;
3635       symbol *tlbl , *tlbl1;
3636       char *l;
3637
3638       tlbl = newiTempLabel(NULL);
3639       tlbl1 = newiTempLabel(NULL);
3640
3641       /* Left is already in result - so now do the shift */
3642       if (shCount>1) {
3643     emit2("ld a,!immedbyte+1", shCount);
3644     emit2("!shortjp !tlabel", tlbl1->key+100);
3645     emitLabel(tlbl->key+100);
3646       }
3647
3648       emitcode("or", "a,a");
3649       offset = size;
3650       while (size--) {
3651     l = aopGet(AOP(result), --offset, FALSE);
3652     emitcode("rr","%s", l);
3653       }
3654       if (shCount>1) {
3655     emitLabel(tlbl1->key+100);
3656     emitcode("dec", "a");
3657     emit2("!shortjp nz,!tlabel", tlbl->key+100);
3658       }
3659     }
3660 }
3661
3662 /*-----------------------------------------------------------------*/
3663 /* shiftL2Left2Result - shift left two bytes from left to result   */
3664 /*-----------------------------------------------------------------*/
3665 static void shiftL2Left2Result (operand *left, int offl,
3666                                 operand *result, int offr, int shCount)
3667 {
3668     if(sameRegs(AOP(result), AOP(left)) &&
3669        ((offl + MSB16) == offr)){
3670   wassert(0);
3671     } else {
3672   /* Copy left into result */
3673   movLeft2Result(left, offl, result, offr, 0);
3674   movLeft2Result(left, offl+1, result, offr+1, 0);
3675     }
3676     /* PENDING: for now just see if it'll work. */
3677     /*if (AOP(result)->type == AOP_REG) { */
3678     {
3679   int size = 2;
3680   int offset = 0;
3681   symbol *tlbl , *tlbl1;
3682   char *l;
3683
3684   tlbl = newiTempLabel(NULL);
3685   tlbl1 = newiTempLabel(NULL);
3686
3687   /* Left is already in result - so now do the shift */
3688   if (shCount>1) {
3689       emit2("ld a,!immedbyte+1", shCount);
3690       emit2("!shortjp !tlabel", tlbl1->key+100);
3691       emitLabel(tlbl->key+100);
3692   }
3693
3694   emitcode("or", "a,a");
3695   while (size--) {
3696       l = aopGet(AOP(result),offset++,FALSE);
3697       emitcode("rl","%s", l);
3698   }
3699   if (shCount>1) {
3700       emitLabel(tlbl1->key+100);
3701       emitcode("dec", "a");
3702       emit2("!shortjp nz,!tlabel", tlbl->key+100);
3703   }
3704     }
3705 }
3706
3707 /*-----------------------------------------------------------------*/
3708 /* AccRol - rotate left accumulator by known count                 */
3709 /*-----------------------------------------------------------------*/
3710 static void AccRol (int shCount)
3711 {
3712     shCount &= 0x0007;              // shCount : 0..7
3713     switch(shCount){
3714         case 0 :
3715             break;
3716         case 1 :
3717             emitcode("rl","a");
3718             break;
3719         case 2 :
3720             emitcode("rl","a");
3721             emitcode("rl","a");
3722             break;
3723         case 3 :
3724             emitcode("rl","a");
3725             emitcode("rl","a");
3726             emitcode("rl","a");
3727             break;
3728         case 4 :
3729             emitcode("rl","a");
3730             emitcode("rl","a");
3731             emitcode("rl","a");
3732             emitcode("rl","a");
3733             break;
3734         case 5 :
3735             emitcode("rr","a");
3736             emitcode("rr","a");
3737             emitcode("rr","a");
3738             break;
3739         case 6 :
3740             emitcode("rr","a");
3741             emitcode("rr","a");
3742             break;
3743         case 7 :
3744             emitcode("rr","a");
3745             break;
3746     }
3747 }
3748
3749 /*-----------------------------------------------------------------*/
3750 /* AccLsh - left shift accumulator by known count                  */
3751 /*-----------------------------------------------------------------*/
3752 static void AccLsh (int shCount)
3753 {
3754     if(shCount != 0) {
3755         if(shCount == 1) {
3756             emitcode("add","a,a");
3757   }
3758         else if(shCount == 2) {
3759       emitcode("add","a,a");
3760       emitcode("add","a,a");
3761   } else {
3762       /* rotate left accumulator */
3763       AccRol(shCount);
3764       /* and kill the lower order bits */
3765       emit2("and a,!immedbyte", SLMask[shCount]);
3766   }
3767     }
3768 }
3769
3770 /*-----------------------------------------------------------------*/
3771 /* shiftL1Left2Result - shift left one byte from left to result    */
3772 /*-----------------------------------------------------------------*/
3773 static void shiftL1Left2Result (operand *left, int offl,
3774                                 operand *result, int offr, int shCount)
3775 {
3776     char *l;
3777     l = aopGet(AOP(left),offl,FALSE);
3778     MOVA(l);
3779     /* shift left accumulator */
3780     AccLsh(shCount);
3781     aopPut(AOP(result),"a",offr);
3782 }
3783
3784
3785 /*-----------------------------------------------------------------*/
3786 /* genlshTwo - left shift two bytes by known amount != 0           */
3787 /*-----------------------------------------------------------------*/
3788 static void genlshTwo (operand *result,operand *left, int shCount)
3789 {
3790     int size = AOP_SIZE(result);
3791
3792     wassert(size==2);
3793
3794     /* if shCount >= 8 */
3795     if (shCount >= 8) {
3796         shCount -= 8 ;
3797         if (size > 1){
3798             if (shCount) {
3799                 movLeft2Result(left, LSB, result, MSB16, 0);
3800     aopPut(AOP(result),zero, 0);
3801     shiftL1Left2Result(left, MSB16, result, MSB16, shCount);
3802       }
3803             else {
3804                 movLeft2Result(left, LSB, result, MSB16, 0);
3805     aopPut(AOP(result),zero, 0);
3806       }
3807         }
3808   else {
3809       aopPut(AOP(result),zero,LSB);
3810   }
3811     }
3812     /*  1 <= shCount <= 7 */
3813     else {
3814         if(size == 1) {
3815       wassert(0);
3816   }
3817         else {
3818             shiftL2Left2Result(left, LSB, result, LSB, shCount);
3819   }
3820     }
3821 }
3822
3823 /*-----------------------------------------------------------------*/
3824 /* genlshOne - left shift a one byte quantity by known count       */
3825 /*-----------------------------------------------------------------*/
3826 static void genlshOne (operand *result, operand *left, int shCount)
3827 {
3828     shiftL1Left2Result(left, LSB, result, LSB, shCount);
3829 }
3830
3831 /*-----------------------------------------------------------------*/
3832 /* genLeftShiftLiteral - left shifting by known count              */
3833 /*-----------------------------------------------------------------*/
3834 static void genLeftShiftLiteral (operand *left,
3835                                  operand *right,
3836                                  operand *result,
3837                                  iCode *ic)
3838 {
3839     int shCount = (int) floatFromVal (AOP(right)->aopu.aop_lit);
3840     int size;
3841
3842     freeAsmop(right,NULL,ic);
3843
3844     aopOp(left,ic,FALSE, FALSE);
3845     aopOp(result,ic,FALSE, FALSE);
3846
3847     size = getSize(operandType(result));
3848
3849 #if VIEW_SIZE
3850     emitcode("; shift left ","result %d, left %d",size,
3851              AOP_SIZE(left));
3852 #endif
3853
3854     /* I suppose that the left size >= result size */
3855     if (shCount == 0) {
3856   wassert(0);
3857     }
3858
3859     else if(shCount >= (size * 8))
3860         while(size--)
3861             aopPut(AOP(result),zero,size);
3862     else{
3863         switch (size) {
3864   case 1:
3865       genlshOne (result,left,shCount);
3866       break;
3867   case 2:
3868       genlshTwo (result,left,shCount);
3869       break;
3870   case 4:
3871       wassert(0);
3872       break;
3873   default:
3874       wassert(0);
3875         }
3876     }
3877     freeAsmop(left,NULL,ic);
3878     freeAsmop(result,NULL,ic);
3879 }
3880
3881 /*-----------------------------------------------------------------*/
3882 /* genLeftShift - generates code for left shifting                 */
3883 /*-----------------------------------------------------------------*/
3884 static void genLeftShift (iCode *ic)
3885 {
3886     int size, offset;
3887     char *l;
3888     symbol *tlbl , *tlbl1;
3889     operand *left,*right, *result;
3890
3891     right = IC_RIGHT(ic);
3892     left  = IC_LEFT(ic);
3893     result = IC_RESULT(ic);
3894
3895     aopOp(right,ic,FALSE, FALSE);
3896
3897     /* if the shift count is known then do it
3898     as efficiently as possible */
3899     if (AOP_TYPE(right) == AOP_LIT) {
3900         genLeftShiftLiteral (left,right,result,ic);
3901         return ;
3902     }
3903
3904     /* shift count is unknown then we have to form a loop get the loop
3905        count in B : Note: we take only the lower order byte since
3906        shifting more that 32 bits make no sense anyway, ( the largest
3907        size of an object can be only 32 bits ) */
3908     emitcode("ld","a,%s",aopGet(AOP(right),0,FALSE));
3909     emitcode("inc","a");
3910     freeAsmop (right,NULL,ic);
3911     aopOp(left,ic,FALSE, FALSE);
3912     aopOp(result,ic,FALSE, FALSE);
3913
3914     /* now move the left to the result if they are not the
3915        same */
3916 #if 1
3917     if (!sameRegs(AOP(left),AOP(result))) {
3918
3919         size = AOP_SIZE(result);
3920         offset = 0;
3921         while (size--) {
3922             l = aopGet(AOP(left),offset,FALSE);
3923       aopPut(AOP(result),l,offset);
3924             offset++;
3925         }
3926     }
3927 #else
3928     size = AOP_SIZE(result);
3929     offset = 0;
3930     while (size--) {
3931   l = aopGet(AOP(left),offset,FALSE);
3932   aopPut(AOP(result),l,offset);
3933   offset++;
3934     }
3935 #endif
3936
3937
3938     tlbl = newiTempLabel(NULL);
3939     size = AOP_SIZE(result);
3940     offset = 0 ;
3941     tlbl1 = newiTempLabel(NULL);
3942
3943     emit2("!shortjp !tlabel", tlbl1->key+100);
3944     emitLabel(tlbl->key+100);
3945     l = aopGet(AOP(result),offset,FALSE);
3946     emitcode("or", "a,a");
3947     while (size--) {
3948         l = aopGet(AOP(result),offset++,FALSE);
3949         emitcode("rl","%s", l);
3950     }
3951     emitLabel(tlbl1->key+100);
3952     emitcode("dec", "a");
3953     emit2("!shortjp nz,!tlabel", tlbl->key+100);
3954
3955     freeAsmop(left,NULL,ic);
3956     freeAsmop(result,NULL,ic);
3957 }
3958
3959 /*-----------------------------------------------------------------*/
3960 /* genrshOne - left shift two bytes by known amount != 0           */
3961 /*-----------------------------------------------------------------*/
3962 static void genrshOne (operand *result,operand *left, int shCount)
3963 {
3964     /* Errk */
3965     int size = AOP_SIZE(result);
3966     char *l;
3967
3968     wassert(size==1);
3969     wassert(shCount<8);
3970
3971     l = aopGet(AOP(left),0,FALSE);
3972     if (AOP(result)->type == AOP_REG) {
3973   aopPut(AOP(result), l, 0);
3974   l = aopGet(AOP(result), 0, FALSE);
3975   while (shCount--)
3976       emitcode("srl", "%s", l);
3977     }
3978     else {
3979   MOVA(l);
3980   while (shCount--) {
3981       emitcode("srl", "a");
3982   }
3983   aopPut(AOP(result),"a",0);
3984     }
3985 }
3986
3987 /*-----------------------------------------------------------------*/
3988 /* AccRsh - right shift accumulator by known count                 */
3989 /*-----------------------------------------------------------------*/
3990 static void AccRsh (int shCount)
3991 {
3992     if(shCount != 0){
3993   /* rotate right accumulator */
3994   AccRol(8 - shCount);
3995   /* and kill the higher order bits */
3996   emit2("and a,!immedbyte", SRMask[shCount]);
3997     }
3998 }
3999
4000 /*-----------------------------------------------------------------*/
4001 /* shiftR1Left2Result - shift right one byte from left to result   */
4002 /*-----------------------------------------------------------------*/
4003 static void shiftR1Left2Result (operand *left, int offl,
4004                                 operand *result, int offr,
4005                                 int shCount, int sign)
4006 {
4007     MOVA(aopGet(AOP(left),offl,FALSE));
4008     if (sign) {
4009   wassert(0);
4010     }
4011     else {
4012         AccRsh(shCount);
4013     }
4014     aopPut(AOP(result),"a",offr);
4015 }
4016
4017 /*-----------------------------------------------------------------*/
4018 /* genrshTwo - right shift two bytes by known amount != 0          */
4019 /*-----------------------------------------------------------------*/
4020 static void genrshTwo (operand *result,operand *left,
4021                        int shCount, int sign)
4022 {
4023     /* if shCount >= 8 */
4024     if (shCount >= 8) {
4025         shCount -= 8;
4026         if (shCount) {
4027             shiftR1Left2Result(left, MSB16, result, LSB,
4028                                shCount, sign);
4029   }
4030         else {
4031             movLeft2Result(left, MSB16, result, LSB, sign);
4032   }
4033   aopPut(AOP(result),zero,1);
4034     }
4035     /*  1 <= shCount <= 7 */
4036     else {
4037         shiftR2Left2Result(left, LSB, result, LSB, shCount, sign);
4038     }
4039 }
4040
4041 /*-----------------------------------------------------------------*/
4042 /* genRightShiftLiteral - left shifting by known count              */
4043 /*-----------------------------------------------------------------*/
4044 static void genRightShiftLiteral (operand *left,
4045                                  operand *right,
4046                                  operand *result,
4047                                  iCode *ic)
4048 {
4049     int shCount = (int) floatFromVal (AOP(right)->aopu.aop_lit);
4050     int size;
4051
4052     freeAsmop(right,NULL,ic);
4053
4054     aopOp(left,ic,FALSE, FALSE);
4055     aopOp(result,ic,FALSE, FALSE);
4056
4057     size = getSize(operandType(result));
4058
4059     emitcode("; shift right ","result %d, left %d",size,
4060              AOP_SIZE(left));
4061
4062     /* I suppose that the left size >= result size */
4063     if (shCount == 0) {
4064   wassert(0);
4065     }
4066
4067     else if(shCount >= (size * 8))
4068         while(size--)
4069             aopPut(AOP(result),zero,size);
4070     else{
4071         switch (size) {
4072   case 1:
4073       genrshOne(result, left, shCount);
4074       break;
4075   case 2:
4076       /* PENDING: sign support */
4077       genrshTwo(result, left, shCount, FALSE);
4078       break;
4079   case 4:
4080       wassert(0);
4081       break;
4082   default:
4083       wassert(0);
4084         }
4085     }
4086     freeAsmop(left,NULL,ic);
4087     freeAsmop(result,NULL,ic);
4088 }
4089
4090 /*-----------------------------------------------------------------*/
4091 /* genRightShift - generate code for right shifting                */
4092 /*-----------------------------------------------------------------*/
4093 static void genRightShift (iCode *ic)
4094 {
4095     operand *right, *left, *result;
4096     sym_link *retype ;
4097     int size, offset, first = 1;
4098     char *l;
4099     bool is_signed;
4100
4101     symbol *tlbl, *tlbl1 ;
4102
4103     /* if signed then we do it the hard way preserve the
4104     sign bit moving it inwards */
4105     retype = getSpec(operandType(IC_RESULT(ic)));
4106
4107     is_signed = !SPEC_USIGN(retype);
4108
4109     /* signed & unsigned types are treated the same : i.e. the
4110     signed is NOT propagated inwards : quoting from the
4111     ANSI - standard : "for E1 >> E2, is equivalent to division
4112     by 2**E2 if unsigned or if it has a non-negative value,
4113     otherwise the result is implementation defined ", MY definition
4114     is that the sign does not get propagated */
4115
4116     right = IC_RIGHT(ic);
4117     left  = IC_LEFT(ic);
4118     result = IC_RESULT(ic);
4119
4120     aopOp(right,ic,FALSE, FALSE);
4121
4122     /* if the shift count is known then do it
4123     as efficiently as possible */
4124     if (AOP_TYPE(right) == AOP_LIT) {
4125         genRightShiftLiteral(left,right,result,ic);
4126         return;
4127     }
4128
4129     aopOp(left,ic,FALSE, FALSE);
4130     aopOp(result,ic,FALSE, FALSE);
4131
4132     /* now move the left to the result if they are not the
4133     same */
4134     if (!sameRegs(AOP(left),AOP(result)) &&
4135         AOP_SIZE(result) > 1) {
4136
4137         size = AOP_SIZE(result);
4138         offset=0;
4139         while (size--) {
4140             l = aopGet(AOP(left),offset,FALSE);
4141       aopPut(AOP(result),l,offset);
4142             offset++;
4143         }
4144     }
4145
4146     emitcode("ld", "a,%s",aopGet(AOP(right),0,FALSE));
4147     emitcode("inc","a");
4148     freeAsmop (right, NULL, ic);
4149
4150     tlbl = newiTempLabel(NULL);
4151     tlbl1= newiTempLabel(NULL);
4152     size = AOP_SIZE(result);
4153     offset = size - 1;
4154
4155     emit2("!shortjp !tlabel", tlbl1->key+100);
4156     emitLabel(tlbl->key+100);
4157     while (size--) {
4158         l = aopGet(AOP(result),offset--,FALSE);
4159   if (first) {
4160       if (is_signed)
4161     emitcode("sra", "%s", l);
4162       else
4163     emitcode("srl", "%s", l);
4164       first = 0;
4165   }
4166   else
4167       emitcode("rr", "%s", l);
4168     }
4169     emitLabel(tlbl1->key+100);
4170     emitcode("dec", "a");
4171     emit2("!shortjp nz,!tlabel", tlbl->key+100);
4172
4173     freeAsmop(left,NULL,ic);
4174     freeAsmop(result,NULL,ic);
4175 }
4176
4177 /*-----------------------------------------------------------------*/
4178 /* genGenPointerGet -  get value from generic pointer space        */
4179 /*-----------------------------------------------------------------*/
4180 static void genGenPointerGet (operand *left,
4181                               operand *result, iCode *ic)
4182 {
4183     int size, offset ;
4184     sym_link *retype = getSpec(operandType(result));
4185     int pair = PAIR_HL;
4186
4187     if (IS_GB)
4188   pair = PAIR_DE;
4189
4190     aopOp(left,ic,FALSE, FALSE);
4191     aopOp(result,ic,FALSE, FALSE);
4192
4193     if (isPair(AOP(left)) && AOP_SIZE(result)==1) {
4194   /* Just do it */
4195   if (isPtrPair(AOP(left)))
4196       {
4197     tsprintf(buffer, "!*pair", getPairName(AOP(left)));
4198     aopPut(AOP(result), buffer, 0);
4199       }
4200   else {
4201       emit2("ld a,!*pair", getPairName(AOP(left)));
4202       aopPut(AOP(result),"a", 0);
4203   }
4204   freeAsmop(left,NULL,ic);
4205   goto release;
4206     }
4207
4208     /* For now we always load into IY */
4209     /* if this is remateriazable */
4210     fetchPair(pair, AOP(left));
4211
4212     /* so iy now contains the address */
4213     freeAsmop(left,NULL,ic);
4214
4215     /* if bit then unpack */
4216     if (IS_BITVAR(retype)) {
4217   wassert(0);
4218     }
4219     else {
4220         size = AOP_SIZE(result);
4221         offset = 0 ;
4222
4223         while (size--) {
4224       /* PENDING: make this better */
4225       if (!IS_GB && AOP(result)->type == AOP_REG) {
4226     aopPut(AOP(result), "!*hl", offset++);
4227       }
4228       else {
4229     emit2("ld a,!*pair", _pairs[pair].name);
4230     aopPut(AOP(result),"a",offset++);
4231       }
4232       if (size) {
4233     emit2("inc %s", _pairs[pair].name);
4234     _G.pairs[pair].offset++;
4235       }
4236         }
4237     }
4238
4239  release:
4240     freeAsmop(result,NULL,ic);
4241 }
4242
4243 /*-----------------------------------------------------------------*/
4244 /* genPointerGet - generate code for pointer get                   */
4245 /*-----------------------------------------------------------------*/
4246 static void genPointerGet (iCode *ic)
4247 {
4248     operand *left, *result ;
4249     sym_link *type, *etype;
4250
4251     left = IC_LEFT(ic);
4252     result = IC_RESULT(ic) ;
4253
4254     /* depending on the type of pointer we need to
4255     move it to the correct pointer register */
4256     type = operandType(left);
4257     etype = getSpec(type);
4258
4259     genGenPointerGet (left,result,ic);
4260 }
4261
4262 bool isRegOrLit(asmop *aop)
4263 {
4264     if (aop->type == AOP_REG || aop->type == AOP_LIT || aop->type == AOP_IMMD)
4265   return TRUE;
4266     return FALSE;
4267 }
4268
4269 /*-----------------------------------------------------------------*/
4270 /* genGenPointerSet - stores the value into a pointer location        */
4271 /*-----------------------------------------------------------------*/
4272 static void genGenPointerSet (operand *right,
4273                               operand *result, iCode *ic)
4274 {
4275     int size, offset ;
4276     sym_link *retype = getSpec(operandType(right));
4277     PAIR_ID pairId = PAIR_HL;
4278
4279     aopOp(result,ic,FALSE, FALSE);
4280     aopOp(right,ic,FALSE, FALSE);
4281
4282     if (IS_GB)
4283   pairId = PAIR_DE;
4284
4285     /* Handle the exceptions first */
4286     if (isPair(AOP(result)) && (AOP_SIZE(right)==1)) {
4287   /* Just do it */
4288   char *l = aopGet(AOP(right), 0, FALSE);
4289   const char *pair = getPairName(AOP(result));
4290   if (canAssignToPtr(l) && isPtr(pair)) {
4291       emit2("ld !*pair,%s", pair, l);
4292   }
4293   else {
4294       MOVA(l);
4295       emit2("ld !*pair,a", pair);
4296   }
4297   goto release;
4298     }
4299
4300     /* if the operand is already in dptr
4301        then we do nothing else we move the value to dptr */
4302     if (AOP_TYPE(result) != AOP_STR) {
4303   fetchPair(pairId, AOP(result));
4304     }
4305     /* so hl know contains the address */
4306     freeAsmop(result,NULL,ic);
4307
4308     /* if bit then unpack */
4309     if (IS_BITVAR(retype)) {
4310   wassert(0);
4311     }
4312     else {
4313         size = AOP_SIZE(right);
4314         offset = 0 ;
4315
4316         while (size--) {
4317             char *l = aopGet(AOP(right),offset,FALSE);
4318       if (isRegOrLit(AOP(right)) && !IS_GB) {
4319     emit2("ld !*pair,%s", _pairs[pairId].name, l);
4320       }
4321       else {
4322     MOVA(l);
4323     emit2("ld !*pair,a", _pairs[pairId].name);
4324       }
4325       if (size) {
4326     emitcode("inc", _pairs[pairId].name);
4327     _G.pairs[pairId].offset++;
4328       }
4329       offset++;
4330         }
4331     }
4332     release:
4333     freeAsmop(right,NULL,ic);
4334 }
4335
4336 /*-----------------------------------------------------------------*/
4337 /* genPointerSet - stores the value into a pointer location        */
4338 /*-----------------------------------------------------------------*/
4339 static void genPointerSet (iCode *ic)
4340 {
4341     operand *right, *result ;
4342     sym_link *type, *etype;
4343
4344     right = IC_RIGHT(ic);
4345     result = IC_RESULT(ic) ;
4346
4347     /* depending on the type of pointer we need to
4348     move it to the correct pointer register */
4349     type = operandType(result);
4350     etype = getSpec(type);
4351
4352     genGenPointerSet (right,result,ic);
4353 }
4354
4355 /*-----------------------------------------------------------------*/
4356 /* genIfx - generate code for Ifx statement                        */
4357 /*-----------------------------------------------------------------*/
4358 static void genIfx (iCode *ic, iCode *popIc)
4359 {
4360     operand *cond = IC_COND(ic);
4361     int isbit =0;
4362
4363     aopOp(cond,ic,FALSE, TRUE);
4364
4365     /* get the value into acc */
4366     if (AOP_TYPE(cond) != AOP_CRY)
4367         toBoolean(cond);
4368     else
4369         isbit = 1;
4370     /* the result is now in the accumulator */
4371     freeAsmop(cond,NULL,ic);
4372
4373     /* if there was something to be popped then do it */
4374     if (popIc)
4375         genIpop(popIc);
4376
4377     /* if the condition is  a bit variable */
4378     if (isbit && IS_ITEMP(cond) &&
4379   SPIL_LOC(cond))
4380   genIfxJump(ic,SPIL_LOC(cond)->rname);
4381     else
4382   if (isbit && !IS_ITEMP(cond))
4383       genIfxJump(ic,OP_SYMBOL(cond)->rname);
4384   else
4385       genIfxJump(ic,"a");
4386
4387     ic->generated = 1;
4388 }
4389
4390 /*-----------------------------------------------------------------*/
4391 /* genAddrOf - generates code for address of                       */
4392 /*-----------------------------------------------------------------*/
4393 static void genAddrOf (iCode *ic)
4394 {
4395     symbol *sym = OP_SYMBOL(IC_LEFT(ic));
4396
4397     aopOp(IC_RESULT(ic),ic,FALSE, FALSE);
4398
4399     /* if the operand is on the stack then we
4400     need to get the stack offset of this
4401     variable */
4402     if (IS_GB) {
4403   if (sym->onStack) {
4404       spillCached();
4405       if (sym->stack <= 0) {
4406     emit2("!ldahlsp", sym->stack + _G.stack.pushed + _G.stack.offset);
4407       }
4408       else {
4409     emit2("!ldahlsp", sym->stack + _G.stack.pushed + _G.stack.offset + _G.stack.param_offset);
4410       }
4411       emitcode("ld", "d,h");
4412       emitcode("ld", "e,l");
4413   }
4414   else {
4415       emit2("ld de,!hashedstr", sym->rname);
4416   }
4417   aopPut(AOP(IC_RESULT(ic)), "e", 0);
4418   aopPut(AOP(IC_RESULT(ic)), "d", 1);
4419     }
4420     else {
4421   spillCached();
4422   if (sym->onStack) {
4423       /* if it has an offset  then we need to compute it */
4424       if (sym->stack > 0)
4425     emitcode("ld", "hl,#%d+%d+%d+%d", sym->stack, _G.stack.pushed, _G.stack.offset, _G.stack.param_offset);
4426       else
4427     emitcode("ld", "hl,#%d+%d+%d", sym->stack, _G.stack.pushed, _G.stack.offset);
4428       emitcode("add", "hl,sp");
4429   }
4430   else {
4431       emitcode("ld", "hl,#%s", sym->rname);
4432   }
4433   aopPut(AOP(IC_RESULT(ic)), "l", 0);
4434   aopPut(AOP(IC_RESULT(ic)), "h", 1);
4435     }
4436     freeAsmop(IC_RESULT(ic),NULL,ic);
4437 }
4438
4439 /*-----------------------------------------------------------------*/
4440 /* genAssign - generate code for assignment                        */
4441 /*-----------------------------------------------------------------*/
4442 static void genAssign (iCode *ic)
4443 {
4444     operand *result, *right;
4445     int size, offset ;
4446     unsigned long lit = 0L;
4447
4448     result = IC_RESULT(ic);
4449     right  = IC_RIGHT(ic) ;
4450
4451 #if 1
4452     /* Dont bother assigning if they are the same */
4453     if (operandsEqu (IC_RESULT(ic),IC_RIGHT(ic))) {
4454   emitcode("", "; (operands are equal %u)", operandsEqu(IC_RESULT(ic),IC_RIGHT(ic)));
4455         return;
4456     }
4457 #endif
4458
4459     aopOp(right,ic,FALSE, FALSE);
4460     aopOp(result,ic,TRUE, FALSE);
4461
4462     /* if they are the same registers */
4463     if (sameRegs(AOP(right),AOP(result))) {
4464   emitcode("", "; (registers are the same)");
4465         goto release;
4466     }
4467
4468     /* if the result is a bit */
4469     if (AOP_TYPE(result) == AOP_CRY) {
4470   wassert(0);
4471     }
4472
4473     /* general case */
4474     size = AOP_SIZE(result);
4475     offset = 0;
4476
4477     if(AOP_TYPE(right) == AOP_LIT)
4478   lit = (unsigned long)floatFromVal(AOP(right)->aopu.aop_lit);
4479     if (isPair(AOP(result))) {
4480   fetchPair(getPairId(AOP(result)), AOP(right));
4481     }
4482     else if((size > 1) &&
4483        (AOP_TYPE(result) != AOP_REG) &&
4484        (AOP_TYPE(right) == AOP_LIT) &&
4485        !IS_FLOAT(operandType(right)) &&
4486        (lit < 256L)) {
4487   bool fXored = FALSE;
4488   offset = 0;
4489   /* Work from the top down.
4490      Done this way so that we can use the cached copy of 0
4491      in A for a fast clear */
4492   while (size--) {
4493       if((unsigned int)((lit >> (offset*8)) & 0x0FFL)== 0) {
4494     if (!fXored && size>1) {
4495         emitcode("xor", "a,a");
4496         fXored = TRUE;
4497     }
4498     if (fXored) {
4499         aopPut(AOP(result),"a",offset);
4500     }
4501     else {
4502         aopPut(AOP(result), zero, offset);
4503     }
4504       }
4505       else
4506     aopPut(AOP(result),
4507            aopGet(AOP(right),offset,FALSE),
4508            offset);
4509       offset++;
4510   }
4511     }
4512     else if (size == 2 && requiresHL(AOP(right)) && requiresHL(AOP(result)) && IS_GB) {
4513   /* Special case.  Load into a and d, then load out. */
4514   MOVA(aopGet(AOP(right), 0, FALSE));
4515   emitcode("ld", "e,%s", aopGet(AOP(right), 1, FALSE));
4516   aopPut(AOP(result), "a", 0);
4517   aopPut(AOP(result), "e", 1);
4518     } else {
4519   while (size--) {
4520       /* PENDING: do this check better */
4521       if (requiresHL(AOP(right)) && requiresHL(AOP(result))) {
4522     MOVA(aopGet(AOP(right), offset, FALSE));
4523     aopPut(AOP(result), "a", offset);
4524       }
4525       else
4526     aopPut(AOP(result),
4527            aopGet(AOP(right),offset,FALSE),
4528            offset);
4529       offset++;
4530   }
4531     }
4532
4533 release:
4534     freeAsmop(right,NULL,ic);
4535     freeAsmop(result,NULL,ic);
4536 }
4537
4538 /*-----------------------------------------------------------------*/
4539 /* genJumpTab - genrates code for jump table                       */
4540 /*-----------------------------------------------------------------*/
4541 static void genJumpTab (iCode *ic)
4542 {
4543     symbol *jtab;
4544     char *l;
4545
4546     aopOp(IC_JTCOND(ic),ic,FALSE, FALSE);
4547     /* get the condition into accumulator */
4548     l = aopGet(AOP(IC_JTCOND(ic)),0,FALSE);
4549     if (!IS_GB)
4550   emitcode("push", "de");
4551     emitcode("ld", "e,%s", l);
4552     emit2("ld d,!zero");
4553     jtab = newiTempLabel(NULL);
4554     spillCached();
4555     emit2("ld hl,!immed!tlabel", jtab->key+100);
4556     emitcode("add", "hl,de");
4557     emitcode("add", "hl,de");
4558     emitcode("add", "hl,de");
4559     freeAsmop(IC_JTCOND(ic),NULL,ic);
4560     if (!IS_GB)
4561   emitcode("pop", "de");
4562     emit2("jp !*hl");
4563     emitLabel(jtab->key+100);
4564     /* now generate the jump labels */
4565     for (jtab = setFirstItem(IC_JTLABELS(ic)) ; jtab;
4566          jtab = setNextItem(IC_JTLABELS(ic)))
4567   emit2("jp !tlabel", jtab->key+100);
4568 }
4569
4570 /*-----------------------------------------------------------------*/
4571 /* genCast - gen code for casting                                  */
4572 /*-----------------------------------------------------------------*/
4573 static void genCast (iCode *ic)
4574 {
4575     operand *result = IC_RESULT(ic);
4576     sym_link *ctype = operandType(IC_LEFT(ic));
4577     operand *right = IC_RIGHT(ic);
4578     int size, offset ;
4579
4580     /* if they are equivalent then do nothing */
4581     if (operandsEqu(IC_RESULT(ic),IC_RIGHT(ic)))
4582         return ;
4583
4584     aopOp(right,ic,FALSE, FALSE);
4585     aopOp(result,ic,FALSE, FALSE);
4586
4587     /* if the result is a bit */
4588     if (AOP_TYPE(result) == AOP_CRY) {
4589   wassert(0);
4590     }
4591
4592     /* if they are the same size : or less */
4593     if (AOP_SIZE(result) <= AOP_SIZE(right)) {
4594
4595         /* if they are in the same place */
4596         if (sameRegs(AOP(right),AOP(result)))
4597             goto release;
4598
4599         /* if they in different places then copy */
4600         size = AOP_SIZE(result);
4601         offset = 0 ;
4602         while (size--) {
4603             aopPut(AOP(result),
4604                    aopGet(AOP(right),offset,FALSE),
4605                    offset);
4606             offset++;
4607         }
4608         goto release;
4609     }
4610
4611     /* PENDING: should be OK. */
4612 #if 0
4613     /* if the result is of type pointer */
4614     if (IS_PTR(ctype)) {
4615   wassert(0);
4616     }
4617 #endif
4618
4619     /* so we now know that the size of destination is greater
4620     than the size of the source */
4621     /* we move to result for the size of source */
4622     size = AOP_SIZE(right);
4623     offset = 0 ;
4624     while (size--) {
4625         aopPut(AOP(result),
4626                aopGet(AOP(right),offset,FALSE),
4627                offset);
4628         offset++;
4629     }
4630
4631     /* now depending on the sign of the destination */
4632     size = AOP_SIZE(result) - AOP_SIZE(right);
4633     /* Unsigned or not an integral type - right fill with zeros */
4634     if (SPEC_USIGN(ctype) || !IS_SPEC(ctype)) {
4635         while (size--)
4636             aopPut(AOP(result),zero,offset++);
4637     } else {
4638         /* we need to extend the sign :{ */
4639         char *l = aopGet(AOP(right),AOP_SIZE(right) - 1,
4640                          FALSE);
4641         MOVA(l);
4642   emitcode("", "; genCast: sign extend untested.");
4643         emitcode("rla", "");
4644         emitcode("sbc", "a,a");
4645         while (size--)
4646             aopPut(AOP(result),"a",offset++);
4647     }
4648
4649 release:
4650     freeAsmop(right, NULL, ic);
4651     freeAsmop(result, NULL, ic);
4652 }
4653
4654 /*-----------------------------------------------------------------*/
4655 /* genReceive - generate code for a receive iCode                  */
4656 /*-----------------------------------------------------------------*/
4657 static void genReceive (iCode *ic)
4658 {
4659     if (isOperandInFarSpace(IC_RESULT(ic)) &&
4660   ( OP_SYMBOL(IC_RESULT(ic))->isspilt ||
4661     IS_TRUE_SYMOP(IC_RESULT(ic))) ) {
4662   wassert(0);
4663     } else {
4664   accInUse++;
4665   aopOp(IC_RESULT(ic),ic,FALSE, FALSE);
4666   accInUse--;
4667   assignResultValue(IC_RESULT(ic));
4668     }
4669
4670     freeAsmop(IC_RESULT(ic),NULL,ic);
4671 }
4672
4673 /*-----------------------------------------------------------------*/
4674 /* genZ80Code - generate code for Z80 based controllers            */
4675 /*-----------------------------------------------------------------*/
4676 void genZ80Code (iCode *lic)
4677 {
4678     iCode *ic;
4679     int cln = 0;
4680
4681     /* HACK */
4682     if (IS_GB) {
4683   _fReturn = _gbz80_return;
4684   _fTmp = _gbz80_return;
4685     }
4686     else {
4687   _fReturn = _z80_return;
4688   _fTmp = _z80_return;
4689     }
4690     tsprintf(zero, "!zero");
4691
4692     lineHead = lineCurr = NULL;
4693
4694     /* if debug information required */
4695     if (options.debug && currFunc) {
4696   cdbSymbol(currFunc,cdbFile,FALSE,TRUE);
4697   debugLine = 1;
4698   if (IS_STATIC(currFunc->etype))
4699       emitcode("","F%s$%s$0$0 ==.",moduleName,currFunc->name);
4700   else
4701       emitcode("","G$%s$0$0 ==.",currFunc->name);
4702   debugLine = 0;
4703     }
4704     /* stack pointer name */
4705     spname = "sp";
4706
4707
4708     for (ic = lic ; ic ; ic = ic->next ) {
4709
4710   if ( cln != ic->lineno ) {
4711       if ( options.debug ) {
4712     debugLine = 1;
4713     emitcode("","C$%s$%d$%d$%d ==.",
4714        ic->filename,ic->lineno,
4715        ic->level,ic->block);
4716     debugLine = 0;
4717       }
4718       emitcode(";","%s %d",ic->filename,ic->lineno);
4719       cln = ic->lineno ;
4720   }
4721   /* if the result is marked as
4722      spilt and rematerializable or code for
4723      this has already been generated then
4724      do nothing */
4725   if (resultRemat(ic) || ic->generated )
4726       continue ;
4727
4728   /* depending on the operation */
4729   switch (ic->op) {
4730   case '!' :
4731       emitcode("", "; genNot");
4732       genNot(ic);
4733       break;
4734
4735   case '~' :
4736       emitcode("", "; genCpl");
4737       genCpl(ic);
4738       break;
4739
4740   case UNARYMINUS:
4741       emitcode("", "; genUminus");
4742       genUminus (ic);
4743       break;
4744
4745   case IPUSH:
4746       emitcode("", "; genIpush");
4747       genIpush (ic);
4748       break;
4749
4750   case IPOP:
4751       /* IPOP happens only when trying to restore a
4752          spilt live range, if there is an ifx statement
4753          following this pop then the if statement might
4754          be using some of the registers being popped which
4755          would destory the contents of the register so
4756          we need to check for this condition and handle it */
4757       if (ic->next            &&
4758     ic->next->op == IFX &&
4759     regsInCommon(IC_LEFT(ic),IC_COND(ic->next))) {
4760     emitcode("", "; genIfx");
4761     genIfx (ic->next,ic);
4762       }
4763       else {
4764     emitcode("", "; genIpop");
4765     genIpop (ic);
4766       }
4767       break;
4768
4769   case CALL:
4770       emitcode("", "; genCall");
4771       genCall (ic);
4772       break;
4773
4774   case PCALL:
4775       emitcode("", "; genPcall");
4776       genPcall (ic);
4777       break;
4778
4779   case FUNCTION:
4780       emitcode("", "; genFunction");
4781       genFunction (ic);
4782       break;
4783
4784   case ENDFUNCTION:
4785       emitcode("", "; genEndFunction");
4786       genEndFunction (ic);
4787       break;
4788
4789   case RETURN:
4790       emitcode("", "; genRet");
4791       genRet (ic);
4792       break;
4793
4794   case LABEL:
4795       emitcode("", "; genLabel");
4796       genLabel (ic);
4797       break;
4798
4799   case GOTO:
4800       emitcode("", "; genGoto");
4801       genGoto (ic);
4802       break;
4803
4804   case '+' :
4805       emitcode("", "; genPlus");
4806       genPlus (ic) ;
4807       break;
4808
4809   case '-' :
4810       emitcode("", "; genMinus");
4811       genMinus (ic);
4812       break;
4813
4814   case '*' :
4815       emitcode("", "; genMult");
4816       genMult (ic);
4817       break;
4818
4819   case '/' :
4820       emitcode("", "; genDiv");
4821       genDiv (ic) ;
4822       break;
4823
4824   case '%' :
4825       emitcode("", "; genMod");
4826       genMod (ic);
4827       break;
4828
4829   case '>' :
4830       emitcode("", "; genCmpGt");
4831       genCmpGt (ic,ifxForOp(IC_RESULT(ic),ic));
4832       break;
4833
4834   case '<' :
4835       emitcode("", "; genCmpLt");
4836       genCmpLt (ic,ifxForOp(IC_RESULT(ic),ic));
4837       break;
4838
4839   case LE_OP:
4840   case GE_OP:
4841   case NE_OP:
4842
4843       /* note these two are xlated by algebraic equivalence
4844          during parsing SDCC.y */
4845       werror(E_INTERNAL_ERROR,__FILE__,__LINE__,
4846        "got '>=' or '<=' shouldn't have come here");
4847       break;
4848
4849   case EQ_OP:
4850       emitcode("", "; genCmpEq");
4851       genCmpEq (ic,ifxForOp(IC_RESULT(ic),ic));
4852       break;
4853
4854   case AND_OP:
4855       emitcode("", "; genAndOp");
4856       genAndOp (ic);
4857       break;
4858
4859   case OR_OP:
4860       emitcode("", "; genOrOp");
4861       genOrOp (ic);
4862       break;
4863
4864   case '^' :
4865       emitcode("", "; genXor");
4866       genXor (ic,ifxForOp(IC_RESULT(ic),ic));
4867       break;
4868
4869   case '|' :
4870       emitcode("", "; genOr");
4871       genOr (ic,ifxForOp(IC_RESULT(ic),ic));
4872       break;
4873
4874   case BITWISEAND:
4875       emitcode("", "; genAnd");
4876             genAnd (ic,ifxForOp(IC_RESULT(ic),ic));
4877       break;
4878
4879   case INLINEASM:
4880       emitcode("", "; genInline");
4881       genInline (ic);
4882       break;
4883
4884   case RRC:
4885       emitcode("", "; genRRC");
4886       genRRC (ic);
4887       break;
4888
4889   case RLC:
4890       emitcode("", "; genRLC");
4891       genRLC (ic);
4892       break;
4893
4894   case GETHBIT:
4895       emitcode("", "; genHBIT");
4896       wassert(0);
4897
4898   case LEFT_OP:
4899       emitcode("", "; genLeftShift");
4900       genLeftShift (ic);
4901       break;
4902
4903   case RIGHT_OP:
4904       emitcode("", "; genRightShift");
4905       genRightShift (ic);
4906       break;
4907
4908   case GET_VALUE_AT_ADDRESS:
4909       emitcode("", "; genPointerGet");
4910       genPointerGet(ic);
4911       break;
4912
4913   case '=' :
4914
4915       if (POINTER_SET(ic)) {
4916     emitcode("", "; genAssign (pointer)");
4917     genPointerSet(ic);
4918       }
4919       else {
4920     emitcode("", "; genAssign");
4921     genAssign(ic);
4922       }
4923       break;
4924
4925   case IFX:
4926       emitcode("", "; genIfx");
4927       genIfx (ic,NULL);
4928       break;
4929
4930   case ADDRESS_OF:
4931       emitcode("", "; genAddrOf");
4932       genAddrOf (ic);
4933       break;
4934
4935   case JUMPTABLE:
4936       emitcode("", "; genJumpTab");
4937       genJumpTab (ic);
4938       break;
4939
4940   case CAST:
4941       emitcode("", "; genCast");
4942       genCast (ic);
4943       break;
4944
4945   case RECEIVE:
4946       emitcode("", "; genReceive");
4947       genReceive(ic);
4948       break;
4949
4950   case SEND:
4951       emitcode("", "; addSet");
4952       addSet(&sendSet,ic);
4953       break;
4954
4955   default :
4956       ic = ic;
4957       /*      piCode(ic,stdout); */
4958
4959         }
4960     }
4961
4962
4963     /* now we are ready to call the
4964        peep hole optimizer */
4965     if (!options.nopeep)
4966   peepHole (&lineHead);
4967
4968     /* This is unfortunate */
4969     /* now do the actual printing */
4970     {
4971   FILE *fp = codeOutFile;
4972   if (isInHome() && codeOutFile == code->oFile)
4973       codeOutFile = home->oFile;
4974   printLine (lineHead, codeOutFile);
4975   if (_G.flush_statics) {
4976       flushStatics();
4977       _G.flush_statics = 0;
4978   }
4979   codeOutFile = fp;
4980     }
4981 }