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

   1 /*-------------------------------------------------------------------------
   2   gen.c - source file for code generation for 8051
   3
   4   Written By -  Sandeep Dutta . sandeep.dutta@usa.net (1998)
   5          and -  Jean-Louis VERN.jlvern@writeme.com (1999)
   6   Bug Fixes  -  Wojciech Stryjewski  wstryj1@tiger.lsu.edu (1999 v2.1.9a)
   7
   8   This program is free software; you can redistribute it and/or modify it
   9   under the terms of the GNU General Public License as published by the
  10   Free Software Foundation; either version 2, or (at your option) any
  11   later version.
  12
  13   This program is distributed in the hope that it will be useful,
  14   but WITHOUT ANY WARRANTY; without even the implied warranty of
  15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16   GNU General Public License for more details.
  17
  18   You should have received a copy of the GNU General Public License
  19   along with this program; if not, write to the Free Software
  20   Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  21
  22   In other words, you are welcome to use, share and improve this program.
  23   You are forbidden to forbid anyone else to use, share and improve
  24   what you give them.   Help stamp out software-hoarding!
  25
  26   Notes:
  27   000123 mlh    Moved aopLiteral to SDCCglue.c to help the split
  28                 Made everything static
  29 -------------------------------------------------------------------------*/
  30
  31 #include <stdio.h>
  32 #include <stdlib.h>
  33 #include <string.h>
  34 #include <ctype.h>
  35
  36 #include <common.h>
  37 #include "ralloc.h"
  38 #include "gen.h"
  39 #include "SDCCglobl.h"
  40 #include "newalloc.h"
  41
  42 #ifdef HAVE_SYS_ISA_DEFS_H
  43 #include <sys/isa_defs.h>
  44 #else
  45 #ifdef HAVE_ENDIAN_H
  46 #include <endian.h>
  47 #else
  48 #if !defined(__BORLANDC__) && !defined(_MSC_VER)
  49 #warning "Cannot determine ENDIANESS of this machine assuming LITTLE_ENDIAN"
  50 #warning "If you running sdcc on an INTEL 80x86 Platform you are okay"
  51 #endif
  52 #endif
  53 #endif
  54
  55 char *aopLiteral (value *val, int offset);
  56 #if 0
  57 //REMOVE ME!!!
  58 extern int allocInfo;
  59 #endif
  60
  61 /* this is the down and dirty file with all kinds of
  62    kludgy & hacky stuff. This is what it is all about
  63    CODE GENERATION for a specific MCU . some of the
  64    routines may be reusable, will have to see */
  65
  66 static char *zero = "#0x00";
  67 static char *one  = "#0x01";
  68 static char *spname ;
  69
  70 #define D(x) x
  71
  72 unsigned fReturnSize_390 = 5; /* shared with ralloc.c */
  73 static char *fReturn[] = {"dpl","dph","dpx", "b","a" };
  74 static char *accUse[] = {"a","b"};
  75
  76 static short rbank = -1;
  77
  78 static struct {
  79     short r0Pushed;
  80     short r1Pushed;
  81     short accInUse;
  82     short inLine;
  83     short debugLine;
  84     short nRegsSaved;
  85     set *sendSet;
  86 } _G;
  87
  88 static void saverbank (int, iCode *,bool);
  89
  90 #define RESULTONSTACK(x) \
  91                          (IC_RESULT(x) && IC_RESULT(x)->aop && \
  92                          IC_RESULT(x)->aop->type == AOP_STK )
  93
  94 /* #define MOVA(x) if (strcmp(x,"a") && strcmp(x,"acc")) emitcode("mov","a,%s",x); */
  95 #define MOVA(x) { char *_mova_tmp = strdup(x); \
  96                  if (strcmp(_mova_tmp,"a") && strcmp(_mova_tmp,"acc")) \
  97                  { \
  98                     emitcode("mov","a,%s",_mova_tmp); \
  99                  } \
 100                  free(_mova_tmp); \
 101                 }
 102 #define CLRC    emitcode("clr","c")
 103 #define SETC    emitcode("setb","c")
 104
 105 static lineNode *lineHead = NULL;
 106 static lineNode *lineCurr = NULL;
 107
 108 static unsigned char   SLMask[] = {0xFF ,0xFE, 0xFC, 0xF8, 0xF0,
 109 0xE0, 0xC0, 0x80, 0x00};
 110 static unsigned char   SRMask[] = {0xFF, 0x7F, 0x3F, 0x1F, 0x0F,
 111 0x07, 0x03, 0x01, 0x00};
 112
 113 #define LSB     0
 114 #define MSB16   1
 115 #define MSB24   2
 116 #define MSB32   3
 117
 118 /*-----------------------------------------------------------------*/
 119 /* emitcode - writes the code into a file : for now it is simple    */
 120 /*-----------------------------------------------------------------*/
 121 static void emitcode (char *inst,char *fmt, ...)
 122 {
 123     va_list ap;
 124     char lb[MAX_INLINEASM];
 125     char *lbp = lb;
 126
 127     va_start(ap,fmt);
 128
 129     if (inst && *inst) {
 130         if (fmt && *fmt)
 131             sprintf(lb,"%s\t",inst);
 132         else
 133             sprintf(lb,"%s",inst);
 134         vsprintf(lb+(strlen(lb)),fmt,ap);
 135     }  else
 136         vsprintf(lb,fmt,ap);
 137
 138     while (isspace(*lbp)) lbp++;
 139
 140     if (lbp && *lbp)
 141         lineCurr = (lineCurr ?
 142                     connectLine(lineCurr,newLineNode(lb)) :
 143                     (lineHead = newLineNode(lb)));
 144     lineCurr->isInline = _G.inLine;
 145     lineCurr->isDebug  = _G.debugLine;
 146     va_end(ap);
 147 }
 148
 149 /*-----------------------------------------------------------------*/
 150 /* getFreePtr - returns r0 or r1 whichever is free or can be pushed*/
 151 /*-----------------------------------------------------------------*/
 152 static regs *getFreePtr (iCode *ic, asmop **aopp, bool result)
 153 {
 154     bool r0iu = FALSE , r1iu = FALSE;
 155     bool r0ou = FALSE , r1ou = FALSE;
 156
 157     /* the logic: if r0 & r1 used in the instruction
 158     then we are in trouble otherwise */
 159
 160     /* first check if r0 & r1 are used by this
 161     instruction, in which case we are in trouble */
 162     if ((r0iu = bitVectBitValue(ic->rUsed,R0_IDX)) &&
 163         (r1iu = bitVectBitValue(ic->rUsed,R1_IDX)))
 164     {
 165         goto endOfWorld;
 166     }
 167
 168     r0ou = bitVectBitValue(ic->rMask,R0_IDX);
 169     r1ou = bitVectBitValue(ic->rMask,R1_IDX);
 170
 171     /* if no usage of r0 then return it */
 172     if (!r0iu && !r0ou) {
 173         ic->rUsed = bitVectSetBit(ic->rUsed,R0_IDX);
 174         (*aopp)->type = AOP_R0;
 175
 176         return (*aopp)->aopu.aop_ptr = ds390_regWithIdx(R0_IDX);
 177     }
 178
 179     /* if no usage of r1 then return it */
 180     if (!r1iu && !r1ou) {
 181         ic->rUsed = bitVectSetBit(ic->rUsed,R1_IDX);
 182         (*aopp)->type = AOP_R1;
 183
 184         return (*aopp)->aopu.aop_ptr = ds390_regWithIdx(R1_IDX);
 185     }
 186
 187     /* now we know they both have usage */
 188     /* if r0 not used in this instruction */
 189     if (!r0iu) {
 190         /* push it if not already pushed */
 191         if (!_G.r0Pushed) {
 192             emitcode ("push","%s",
 193                       ds390_regWithIdx(R0_IDX)->dname);
 194             _G.r0Pushed++ ;
 195         }
 196
 197         ic->rUsed = bitVectSetBit(ic->rUsed,R0_IDX);
 198         (*aopp)->type = AOP_R0;
 199
 200         return (*aopp)->aopu.aop_ptr = ds390_regWithIdx(R0_IDX);
 201     }
 202
 203     /* if r1 not used then */
 204
 205     if (!r1iu) {
 206         /* push it if not already pushed */
 207         if (!_G.r1Pushed) {
 208             emitcode ("push","%s",
 209                       ds390_regWithIdx(R1_IDX)->dname);
 210             _G.r1Pushed++ ;
 211         }
 212
 213         ic->rUsed = bitVectSetBit(ic->rUsed,R1_IDX);
 214         (*aopp)->type = AOP_R1;
 215         return ds390_regWithIdx(R1_IDX);
 216     }
 217
 218 endOfWorld :
 219     /* I said end of world but not quite end of world yet */
 220     /* if this is a result then we can push it on the stack*/
 221     if (result) {
 222         (*aopp)->type = AOP_STK;
 223         return NULL;
 224     }
 225
 226     piCode(ic,stdout);
 227     /* other wise this is true end of the world */
 228     werror(E_INTERNAL_ERROR,__FILE__,__LINE__,
 229            "getFreePtr should never reach here");
 230     exit(1);
 231 }
 232
 233 /*-----------------------------------------------------------------*/
 234 /* newAsmop - creates a new asmOp                                  */
 235 /*-----------------------------------------------------------------*/
 236 static asmop *newAsmop (short type)
 237 {
 238     asmop *aop;
 239
 240     aop = Safe_calloc(sizeof(asmop));
 241     aop->type = type;
 242     return aop;
 243 }
 244
 245 /* Turn this off if the world goes to hell. */
 246 #define LAZY_DPS_OPT
 247
 248 static int _currentDPS;   /* Current processor DPS. */
 249 static int _desiredDPS;   /* DPS value compiler thinks we should be using. */
 250 static int _lazyDPS = 0;  /* if non-zero, we are doing lazy evaluation of DPS changes. */
 251
 252 /*-----------------------------------------------------------------*/
 253 /* genSetDPTR: generate code to select which DPTR is in use (zero  */
 254 /* selects standard DPTR (DPL/DPH/DPX), non-zero selects DS390     */
 255 /* alternate DPTR (DPL1/DPH1/DPX1).                                */
 256 /*-----------------------------------------------------------------*/
 257 static void genSetDPTR(int n)
 258 {
 259
 260 #ifdef LAZY_DPS_OPT
 261     /* If we are doing lazy evaluation, simply note the desired
 262      * change, but don't emit any code yet.
 263      */
 264     if (_lazyDPS)
 265     {
 266         _desiredDPS = n;
 267         return;
 268     }
 269 #endif
 270
 271     if (!n)
 272     {
 273         emitcode("mov", "dps, #0x00");
 274     }
 275     else
 276     {
 277         emitcode("mov", "dps, #0x01");
 278     }
 279 }
 280
 281 /*-----------------------------------------------------------------*/
 282 /* _startLazyDPSEvaluation: call to start doing lazy DPS evaluation*/
 283 /*                                                                 */
 284 /* Any code that operates on DPTR (NB: not on the individual       */
 285 /* components, like DPH) *must* call _flushLazyDPS() before using  */
 286 /* DPTR within a lazy DPS evaluation block.                        */
 287 /*                                                                 */
 288 /* Note that aopPut and aopGet already contain the proper calls to */
 289 /* _flushLazyDPS, so it is safe to use these calls within a lazy   */
 290 /* DPS evaluation block.                                           */
 291 /*                                                                 */
 292 /* Also, _flushLazyDPS must be called before any flow control      */
 293 /* operations that could potentially branch out of the block.      */
 294 /*                                                                 */
 295 /* Lazy DPS evaluation is simply an optimization (though an        */
 296 /* important one), so if in doubt, leave it out.                   */
 297 /*-----------------------------------------------------------------*/
 298 static void _startLazyDPSEvaluation(void)
 299 {
 300    _currentDPS = 0;
 301    _desiredDPS = 0;
 302    _lazyDPS = 1;
 303 }
 304
 305 /*-----------------------------------------------------------------*/
 306 /* _flushLazyDPS: emit code to force the actual DPS setting to the */
 307 /* desired one. Call before using DPTR within a lazy DPS evaluation*/
 308 /* block.                                                          */
 309 /*-----------------------------------------------------------------*/
 310 static void _flushLazyDPS(void)
 311 {
 312     if (!_lazyDPS)
 313     {
 314         /* nothing to do. */
 315         return;
 316     }
 317
 318     if (_desiredDPS != _currentDPS)
 319     {
 320         if (_desiredDPS)
 321         {
 322             emitcode("inc", "dps");
 323         }
 324         else
 325         {
 326             emitcode("dec", "dps");
 327         }
 328         _currentDPS = _desiredDPS;
 329     }
 330 }
 331
 332 /*-----------------------------------------------------------------*/
 333 /* _endLazyDPSEvaluation: end lazy DPS evaluation block.           */
 334 /*                                                                 */
 335 /* Forces us back to the safe state (standard DPTR selected).      */
 336 /*-----------------------------------------------------------------*/
 337 static void _endLazyDPSEvaluation(void)
 338 {
 339    if (_currentDPS)
 340    {
 341        genSetDPTR(0);
 342        _flushLazyDPS();
 343    }
 344    _lazyDPS = 0;
 345    _currentDPS = 0;
 346    _desiredDPS = 0;
 347 }
 348
 349
 350
 351 /*-----------------------------------------------------------------*/
 352 /* pointerCode - returns the code for a pointer type               */
 353 /*-----------------------------------------------------------------*/
 354 static int pointerCode (sym_link *etype)
 355 {
 356
 357     return PTR_TYPE(SPEC_OCLS(etype));
 358
 359 }
 360
 361 /*-----------------------------------------------------------------*/
 362 /* aopForSym - for a true symbol                                   */
 363 /*-----------------------------------------------------------------*/
 364 static asmop *aopForSym (iCode *ic,symbol *sym,bool result, bool useDP2)
 365 {
 366     asmop *aop;
 367     memmap *space= SPEC_OCLS(sym->etype);
 368
 369     /* if already has one */
 370     if (sym->aop)
 371         return sym->aop;
 372
 373     /* assign depending on the storage class */
 374     /* if it is on the stack or indirectly addressable */
 375     /* space we need to assign either r0 or r1 to it   */
 376     if ((sym->onStack && !options.stack10bit) || sym->iaccess) {
 377         sym->aop = aop = newAsmop(0);
 378         aop->aopu.aop_ptr = getFreePtr(ic,&aop,result);
 379         aop->size = getSize(sym->type);
 380
 381         /* now assign the address of the variable to
 382         the pointer register */
 383         if (aop->type != AOP_STK) {
 384
 385             if (sym->onStack) {
 386                     if ( _G.accInUse )
 387                         emitcode("push","acc");
 388
 389                     emitcode("mov","a,_bp");
 390                     emitcode("add","a,#0x%02x",
 391                              ((sym->stack < 0) ?
 392                               ((char)(sym->stack - _G.nRegsSaved )) :
 393                               ((char)sym->stack)) & 0xff);
 394                     emitcode("mov","%s,a",
 395                              aop->aopu.aop_ptr->name);
 396
 397                     if ( _G.accInUse )
 398                         emitcode("pop","acc");
 399             } else
 400                 emitcode("mov","%s,#%s",
 401                          aop->aopu.aop_ptr->name,
 402                          sym->rname);
 403             aop->paged = space->paged;
 404         } else
 405             aop->aopu.aop_stk = sym->stack;
 406         return aop;
 407     }
 408
 409     if (sym->onStack && options.stack10bit)
 410     {
 411         /* It's on the 10 bit stack, which is located in
 412          * far data space.
 413          */
 414
 415         if ( _G.accInUse )
 416                 emitcode("push","acc");
 417
 418         emitcode("mov","a,_bp");
 419         emitcode("add","a,#0x%02x",
 420                  ((sym->stack < 0) ?
 421                    ((char)(sym->stack - _G.nRegsSaved )) :
 422                    ((char)sym->stack)) & 0xff);
 423
 424         if (useDP2)
 425         {
 426         /* genSetDPTR(1); */
 427         emitcode ("mov","dpx1,#0x40");
 428         emitcode ("mov","dph1,#0x00");
 429         emitcode ("mov","dpl1, a");
 430         /* genSetDPTR(0); */
 431         }
 432         else
 433         {
 434             emitcode ("mov","dpx,#0x40");
 435             emitcode ("mov","dph,#0x00");
 436             emitcode ("mov","dpl, a");
 437         }
 438
 439         if ( _G.accInUse )
 440             emitcode("pop","acc");
 441
 442         sym->aop = aop = newAsmop(useDP2 ? AOP_DPTR2 : AOP_DPTR);
 443         aop->size = getSize(sym->type);
 444         return aop;
 445     }
 446
 447     /* if in bit space */
 448     if (IN_BITSPACE(space)) {
 449         sym->aop = aop = newAsmop (AOP_CRY);
 450         aop->aopu.aop_dir = sym->rname ;
 451         aop->size = getSize(sym->type);
 452         return aop;
 453     }
 454     /* if it is in direct space */
 455     if (IN_DIRSPACE(space)) {
 456         sym->aop = aop = newAsmop (AOP_DIR);
 457         aop->aopu.aop_dir = sym->rname ;
 458         aop->size = getSize(sym->type);
 459         return aop;
 460     }
 461
 462     /* special case for a function */
 463     if (IS_FUNC(sym->type)) {
 464         sym->aop = aop = newAsmop(AOP_IMMD);
 465         aop->aopu.aop_immd = Safe_calloc(strlen(sym->rname)+1);
 466         strcpy(aop->aopu.aop_immd,sym->rname);
 467         aop->size = FPTRSIZE;
 468         return aop;
 469     }
 470
 471     /* only remaining is far space */
 472     /* in which case DPTR gets the address */
 473     sym->aop = aop = newAsmop(useDP2 ? AOP_DPTR2 : AOP_DPTR);
 474     if (useDP2)
 475     {
 476         genSetDPTR(1);
 477         _flushLazyDPS();
 478         emitcode ("mov","dptr,#%s", sym->rname);
 479         genSetDPTR(0);
 480     }
 481     else
 482     {
 483         emitcode ("mov","dptr,#%s", sym->rname);
 484     }
 485     aop->size = getSize(sym->type);
 486
 487     /* if it is in code space */
 488     if (IN_CODESPACE(space))
 489         aop->code = 1;
 490
 491     return aop;
 492 }
 493
 494 /*-----------------------------------------------------------------*/
 495 /* aopForRemat - rematerialzes an object                           */
 496 /*-----------------------------------------------------------------*/
 497 static asmop *aopForRemat (symbol *sym)
 498 {
 499     iCode *ic = sym->rematiCode;
 500     asmop *aop = newAsmop(AOP_IMMD);
 501
 502     int val = 0;
 503
 504     for (;;) {
 505         if (ic->op == '+')
 506             val += operandLitValue(IC_RIGHT(ic));
 507         else if (ic->op == '-')
 508             val -= operandLitValue(IC_RIGHT(ic));
 509         else
 510             break;
 511
 512         ic = OP_SYMBOL(IC_LEFT(ic))->rematiCode;
 513     }
 514
 515     if (val)
 516         sprintf(buffer,"(%s %c 0x%04x)",
 517                 OP_SYMBOL(IC_LEFT(ic))->rname,
 518                 val >= 0 ? '+' : '-',
 519                 abs(val) & 0xffff);
 520     else
 521         strcpy(buffer,OP_SYMBOL(IC_LEFT(ic))->rname);
 522
 523     aop->aopu.aop_immd = Safe_calloc(strlen(buffer)+1);
 524     strcpy(aop->aopu.aop_immd,buffer);
 525     return aop;
 526 }
 527
 528 /*-----------------------------------------------------------------*/
 529 /* regsInCommon - two operands have some registers in common       */
 530 /*-----------------------------------------------------------------*/
 531 static bool regsInCommon (operand *op1, operand *op2)
 532 {
 533     symbol *sym1, *sym2;
 534     int i;
 535
 536     /* if they have registers in common */
 537     if (!IS_SYMOP(op1) || !IS_SYMOP(op2))
 538         return FALSE ;
 539
 540     sym1 = OP_SYMBOL(op1);
 541     sym2 = OP_SYMBOL(op2);
 542
 543     if (sym1->nRegs == 0 || sym2->nRegs == 0)
 544         return FALSE ;
 545
 546     for (i = 0 ; i < sym1->nRegs ; i++) {
 547         int j;
 548         if (!sym1->regs[i])
 549             continue ;
 550
 551         for (j = 0 ; j < sym2->nRegs ;j++ ) {
 552             if (!sym2->regs[j])
 553                 continue ;
 554
 555             if (sym2->regs[j] == sym1->regs[i])
 556                 return TRUE ;
 557         }
 558     }
 559
 560     return FALSE ;
 561 }
 562
 563 /*-----------------------------------------------------------------*/
 564 /* operandsEqu - equivalent                                        */
 565 /*-----------------------------------------------------------------*/
 566 static bool operandsEqu ( operand *op1, operand *op2)
 567 {
 568     symbol *sym1, *sym2;
 569
 570     /* if they not symbols */
 571     if (!IS_SYMOP(op1) || !IS_SYMOP(op2))
 572         return FALSE;
 573
 574     sym1 = OP_SYMBOL(op1);
 575     sym2 = OP_SYMBOL(op2);
 576
 577     /* if both are itemps & one is spilt
 578        and the other is not then false */
 579     if (IS_ITEMP(op1) && IS_ITEMP(op2) &&
 580         sym1->isspilt != sym2->isspilt )
 581         return FALSE ;
 582
 583     /* if they are the same */
 584     if (sym1 == sym2)
 585         return TRUE ;
 586
 587     if (strcmp(sym1->rname,sym2->rname) == 0)
 588         return TRUE;
 589
 590
 591     /* if left is a tmp & right is not */
 592     if (IS_ITEMP(op1)  &&
 593         !IS_ITEMP(op2) &&
 594         sym1->isspilt  &&
 595         (sym1->usl.spillLoc == sym2))
 596         return TRUE;
 597
 598     if (IS_ITEMP(op2)  &&
 599         !IS_ITEMP(op1) &&
 600         sym2->isspilt  &&
 601         sym1->level > 0 &&
 602         (sym2->usl.spillLoc == sym1))
 603         return TRUE ;
 604
 605     return FALSE ;
 606 }
 607
 608 /*-----------------------------------------------------------------*/
 609 /* sameRegs - two asmops have the same registers                   */
 610 /*-----------------------------------------------------------------*/
 611 static bool sameRegs (asmop *aop1, asmop *aop2 )
 612 {
 613     int i;
 614
 615     if (aop1 == aop2)
 616     {
 617         if (aop1->type == AOP_DPTR || aop1->type == AOP_DPTR2)
 618         {
 619             return FALSE;
 620         }
 621         return TRUE ;
 622     }
 623
 624     if (aop1->type != AOP_REG ||
 625         aop2->type != AOP_REG )
 626         return FALSE ;
 627
 628     if (aop1->size != aop2->size )
 629         return FALSE ;
 630
 631     for (i = 0 ; i < aop1->size ; i++ )
 632         if (aop1->aopu.aop_reg[i] !=
 633             aop2->aopu.aop_reg[i] )
 634             return FALSE ;
 635
 636     return TRUE ;
 637 }
 638
 639 /*-----------------------------------------------------------------*/
 640 /* aopOp - allocates an asmop for an operand  :                    */
 641 /*-----------------------------------------------------------------*/
 642 static void aopOp (operand *op, iCode *ic, bool result, bool useDP2)
 643 {
 644     asmop *aop;
 645     symbol *sym;
 646     int i;
 647
 648     if (!op)
 649         return ;
 650
 651     /* if this a literal */
 652     if (IS_OP_LITERAL(op)) {
 653         op->aop = aop = newAsmop(AOP_LIT);
 654         aop->aopu.aop_lit = op->operand.valOperand;
 655         aop->size = getSize(operandType(op));
 656         return;
 657     }
 658
 659     /* if already has a asmop then continue */
 660     if (op->aop)
 661         return ;
 662
 663     /* if the underlying symbol has a aop */
 664     if (IS_SYMOP(op) && OP_SYMBOL(op)->aop) {
 665         op->aop = OP_SYMBOL(op)->aop;
 666         return;
 667     }
 668
 669     /* if this is a true symbol */
 670     if (IS_TRUE_SYMOP(op)) {
 671         op->aop = aopForSym(ic,OP_SYMBOL(op),result, useDP2);
 672         return ;
 673     }
 674
 675     /* this is a temporary : this has
 676     only four choices :
 677     a) register
 678     b) spillocation
 679     c) rematerialize
 680     d) conditional
 681     e) can be a return use only */
 682
 683     sym = OP_SYMBOL(op);
 684
 685
 686     /* if the type is a conditional */
 687     if (sym->regType == REG_CND) {
 688         aop = op->aop = sym->aop = newAsmop(AOP_CRY);
 689         aop->size = 0;
 690         return;
 691     }
 692
 693     /* if it is spilt then two situations
 694     a) is rematerialize
 695     b) has a spill location */
 696     if (sym->isspilt || sym->nRegs == 0) {
 697
 698         /* rematerialize it NOW */
 699         if (sym->remat) {
 700             sym->aop = op->aop = aop =
 701                                       aopForRemat (sym);
 702             aop->size = getSize(sym->type);
 703             return;
 704         }
 705
 706         if (sym->accuse) {
 707             int i;
 708             aop = op->aop = sym->aop = newAsmop(AOP_ACC);
 709             aop->size = getSize(sym->type);
 710             for ( i = 0 ; i < 2 ; i++ )
 711                 aop->aopu.aop_str[i] = accUse[i];
 712             return;
 713         }
 714
 715         if (sym->ruonly) {
 716             int i;
 717
 718             if (useDP2)
 719             {
 720                 /* a AOP_STR uses DPTR, but DPTR is already in use;
 721                  * we're just hosed.
 722                  */
 723                 fprintf(stderr, "*** Internal error: AOP_STR with DPTR in use!\n");
 724             }
 725
 726             aop = op->aop = sym->aop = newAsmop(AOP_STR);
 727             aop->size = getSize(sym->type);
 728             for ( i = 0 ; i < fReturnSize_390 ; i++ )
 729               aop->aopu.aop_str[i] = fReturn[i];
 730             return;
 731         }
 732
 733         /* else spill location  */
 734         sym->aop = op->aop = aop =
 735                 aopForSym(ic,sym->usl.spillLoc,result, useDP2);
 736         aop->size = getSize(sym->type);
 737         return;
 738     }
 739
 740     /* must be in a register */
 741     sym->aop = op->aop = aop = newAsmop(AOP_REG);
 742     aop->size = sym->nRegs;
 743     for ( i = 0 ; i < sym->nRegs ;i++)
 744         aop->aopu.aop_reg[i] = sym->regs[i];
 745 }
 746
 747 /*-----------------------------------------------------------------*/
 748 /* freeAsmop - free up the asmop given to an operand               */
 749 /*----------------------------------------------------------------*/
 750 static void freeAsmop (operand *op, asmop *aaop, iCode *ic, bool pop)
 751 {
 752     asmop *aop ;
 753
 754     if (!op)
 755         aop = aaop;
 756     else
 757         aop = op->aop;
 758
 759     if (!aop)
 760         return ;
 761
 762     if (aop->freed)
 763         goto dealloc;
 764
 765     aop->freed = 1;
 766
 767     /* depending on the asmop type only three cases need work AOP_RO
 768        , AOP_R1 && AOP_STK */
 769     switch (aop->type) {
 770         case AOP_R0 :
 771             if (_G.r0Pushed ) {
 772                 if (pop) {
 773                     emitcode ("pop","ar0");
 774                     _G.r0Pushed--;
 775                 }
 776             }
 777             bitVectUnSetBit(ic->rUsed,R0_IDX);
 778             break;
 779
 780         case AOP_R1 :
 781             if (_G.r1Pushed ) {
 782                 if (pop) {
 783                     emitcode ("pop","ar1");
 784                     _G.r1Pushed--;
 785                 }
 786             }
 787             bitVectUnSetBit(ic->rUsed,R1_IDX);
 788             break;
 789
 790         case AOP_STK :
 791         {
 792             int sz = aop->size;
 793             int stk = aop->aopu.aop_stk + aop->size;
 794             bitVectUnSetBit(ic->rUsed,R0_IDX);
 795             bitVectUnSetBit(ic->rUsed,R1_IDX);
 796
 797             getFreePtr(ic,&aop,FALSE);
 798
 799             if (options.stack10bit)
 800             {
 801                 /* I'm not sure what to do here yet... */
 802                 /* #STUB */
 803                 fprintf(stderr,
 804                         "*** Warning: probably generating bad code for "
 805                         "10 bit stack mode.\n");
 806             }
 807
 808             if (stk) {
 809                 emitcode ("mov","a,_bp");
 810                 emitcode ("add","a,#0x%02x",((char)stk) & 0xff);
 811                 emitcode ("mov","%s,a",aop->aopu.aop_ptr->name);
 812             } else {
 813                 emitcode ("mov","%s,_bp",aop->aopu.aop_ptr->name);
 814             }
 815
 816             while (sz--) {
 817                 emitcode("pop","acc");
 818                 emitcode("mov","@%s,a",aop->aopu.aop_ptr->name);
 819                 if (!sz) break;
 820                 emitcode("dec","%s",aop->aopu.aop_ptr->name);
 821             }
 822             op->aop = aop;
 823             freeAsmop(op,NULL,ic,TRUE);
 824             if (_G.r0Pushed) {
 825                 emitcode("pop","ar0");
 826                 _G.r0Pushed--;
 827             }
 828
 829             if (_G.r1Pushed) {
 830                 emitcode("pop","ar1");
 831                 _G.r1Pushed--;
 832             }
 833         }
 834     }
 835
 836 dealloc:
 837     /* all other cases just dealloc */
 838     if (op ) {
 839         op->aop = NULL;
 840         if (IS_SYMOP(op)) {
 841             OP_SYMBOL(op)->aop = NULL;
 842             /* if the symbol has a spill */
 843             if (SPIL_LOC(op))
 844                 SPIL_LOC(op)->aop = NULL;
 845         }
 846     }
 847 }
 848
 849 /*------------------------------------------------------------------*/
 850 /* aopGet - for fetching value of the aop                           */
 851 /*                                                                  */
 852 /* Set canClobberACC if you are aure it is OK to clobber the value  */
 853 /* in the accumulator. Set it FALSE otherwise; FALSE is always safe,*/
 854 /* just less efficient.                                             */
 855 /*------------------------------------------------------------------*/
 856
 857 static char *aopGet (asmop *aop,
 858                      int offset,
 859                      bool bit16,
 860                      bool dname,
 861                      bool canClobberACC)
 862 {
 863     char *s = buffer ;
 864     char *rs;
 865
 866     /* offset is greater than
 867     size then zero */
 868     if (offset > (aop->size - 1) &&
 869         aop->type != AOP_LIT)
 870         return zero;
 871
 872     /* depending on type */
 873     switch (aop->type) {
 874
 875     case AOP_R0:
 876     case AOP_R1:
 877         /* if we need to increment it */
 878         while (offset > aop->coff) {
 879             emitcode ("inc","%s",aop->aopu.aop_ptr->name);
 880             aop->coff++;
 881         }
 882
 883         while (offset < aop->coff) {
 884             emitcode("dec","%s",aop->aopu.aop_ptr->name);
 885             aop->coff--;
 886         }
 887
 888         aop->coff = offset ;
 889         if (aop->paged) {
 890             emitcode("movx","a,@%s",aop->aopu.aop_ptr->name);
 891             return (dname ? "acc" : "a");
 892         }
 893         sprintf(s,"@%s",aop->aopu.aop_ptr->name);
 894         rs = Safe_calloc(strlen(s)+1);
 895         strcpy(rs,s);
 896         return rs;
 897
 898     case AOP_DPTR:
 899     case AOP_DPTR2:
 900
 901         if (aop->type == AOP_DPTR2)
 902         {
 903             genSetDPTR(1);
 904
 905 #ifndef KEVIN_BROKE_IT
 906             if (!canClobberACC)
 907 #endif
 908             {
 909                 emitcode("xch", "a, ap");
 910             }
 911         }
 912
 913         _flushLazyDPS();
 914
 915         while (offset > aop->coff) {
 916             emitcode ("inc","dptr");
 917             aop->coff++;
 918         }
 919
 920         while (offset < aop->coff) {
 921             emitcode("lcall","__decdptr");
 922             aop->coff--;
 923         }
 924
 925         aop->coff = offset;
 926         if (aop->code) {
 927             emitcode("clr","a");
 928             emitcode("movc","a,@a+dptr");
 929         }
 930         else {
 931             emitcode("movx","a,@dptr");
 932         }
 933
 934         if (aop->type == AOP_DPTR2)
 935         {
 936             genSetDPTR(0);
 937
 938 #ifndef KEVIN_BROKE_IT
 939             if (!canClobberACC)
 940 #endif
 941             {
 942                 emitcode("xch", "a, ap");
 943                 return "ap";
 944             }
 945         }
 946
 947         return (dname ? "acc" : "a");
 948
 949     case AOP_IMMD:
 950         if (bit16)
 951             sprintf (s,"#%s",aop->aopu.aop_immd);
 952         else
 953             if (offset)
 954                 sprintf(s,"#(%s >> %d)",
 955                         aop->aopu.aop_immd,
 956                         offset*8);
 957             else
 958                 sprintf(s,"#%s",
 959                         aop->aopu.aop_immd);
 960         rs = Safe_calloc(strlen(s)+1);
 961         strcpy(rs,s);
 962         return rs;
 963
 964     case AOP_DIR:
 965         if (offset)
 966             sprintf(s,"(%s + %d)",
 967                     aop->aopu.aop_dir,
 968                     offset);
 969         else
 970             sprintf(s,"%s",aop->aopu.aop_dir);
 971         rs = Safe_calloc(strlen(s)+1);
 972         strcpy(rs,s);
 973         return rs;
 974
 975     case AOP_REG:
 976         if (dname)
 977             return aop->aopu.aop_reg[offset]->dname;
 978         else
 979             return aop->aopu.aop_reg[offset]->name;
 980
 981     case AOP_CRY:
 982         emitcode("clr","a");
 983         emitcode("mov","c,%s",aop->aopu.aop_dir);
 984         emitcode("rlc","a") ;
 985         return (dname ? "acc" : "a");
 986
 987     case AOP_ACC:
 988         if (!offset && dname)
 989             return "acc";
 990         return aop->aopu.aop_str[offset];
 991
 992     case AOP_LIT:
 993         return aopLiteral (aop->aopu.aop_lit,offset);
 994
 995     case AOP_STR:
 996         aop->coff = offset ;
 997         if (strcmp(aop->aopu.aop_str[offset],"a") == 0 &&
 998             dname)
 999             return "acc";
1000
1001         return aop->aopu.aop_str[offset];
1002
1003     }
1004
1005     werror(E_INTERNAL_ERROR,__FILE__,__LINE__,
1006            "aopget got unsupported aop->type");
1007     exit(1);
1008 }
1009 /*-----------------------------------------------------------------*/
1010 /* aopPut - puts a string for a aop                                */
1011 /*-----------------------------------------------------------------*/
1012 static void aopPut (asmop *aop, char *s, int offset)
1013 {
1014     char *d = buffer ;
1015     symbol *lbl ;
1016
1017     if (aop->size && offset > ( aop->size - 1)) {
1018         werror(E_INTERNAL_ERROR,__FILE__,__LINE__,
1019                "aopPut got offset > aop->size");
1020         exit(1);
1021     }
1022
1023     /* will assign value to value */
1024     /* depending on where it is ofcourse */
1025     switch (aop->type) {
1026     case AOP_DIR:
1027         if (offset)
1028             sprintf(d,"(%s + %d)",
1029                     aop->aopu.aop_dir,offset);
1030         else
1031             sprintf(d,"%s",aop->aopu.aop_dir);
1032
1033         if (strcmp(d,s))
1034             emitcode("mov","%s,%s",d,s);
1035
1036         break;
1037
1038     case AOP_REG:
1039         if (strcmp(aop->aopu.aop_reg[offset]->name,s) != 0 &&
1040             strcmp(aop->aopu.aop_reg[offset]->dname,s)!= 0){
1041             if (*s == '@'           ||
1042                 strcmp(s,"r0") == 0 ||
1043                 strcmp(s,"r1") == 0 ||
1044                 strcmp(s,"r2") == 0 ||
1045                 strcmp(s,"r3") == 0 ||
1046                 strcmp(s,"r4") == 0 ||
1047                 strcmp(s,"r5") == 0 ||
1048                 strcmp(s,"r6") == 0 ||
1049                 strcmp(s,"r7") == 0 )
1050                 emitcode("mov","%s,%s",
1051                          aop->aopu.aop_reg[offset]->dname,s);
1052             else
1053                 emitcode("mov","%s,%s",
1054                          aop->aopu.aop_reg[offset]->name,s);
1055         }
1056         break;
1057
1058     case AOP_DPTR:
1059     case AOP_DPTR2:
1060
1061         if (aop->type == AOP_DPTR2)
1062         {
1063             genSetDPTR(1);
1064         }
1065         _flushLazyDPS();
1066
1067         if (aop->code) {
1068             werror(E_INTERNAL_ERROR,__FILE__,__LINE__,
1069                    "aopPut writting to code space");
1070             exit(1);
1071         }
1072
1073         while (offset > aop->coff) {
1074             aop->coff++;
1075             emitcode ("inc","dptr");
1076         }
1077
1078         while (offset < aop->coff) {
1079             aop->coff-- ;
1080             emitcode("lcall","__decdptr");
1081         }
1082
1083         aop->coff = offset;
1084
1085         /* if not in accumulater */
1086         MOVA(s);
1087
1088         emitcode ("movx","@dptr,a");
1089
1090         if (aop->type == AOP_DPTR2)
1091         {
1092             genSetDPTR(0);
1093         }
1094         break;
1095
1096     case AOP_R0:
1097     case AOP_R1:
1098         while (offset > aop->coff) {
1099             aop->coff++;
1100             emitcode("inc","%s",aop->aopu.aop_ptr->name);
1101         }
1102         while (offset < aop->coff) {
1103             aop->coff-- ;
1104             emitcode ("dec","%s",aop->aopu.aop_ptr->name);
1105         }
1106         aop->coff = offset;
1107
1108         if (aop->paged) {
1109             MOVA(s);
1110             emitcode("movx","@%s,a",aop->aopu.aop_ptr->name);
1111
1112         } else
1113             if (*s == '@') {
1114                 MOVA(s);
1115                 emitcode("mov","@%s,a",aop->aopu.aop_ptr->name);
1116             } else
1117                 if (strcmp(s,"r0") == 0 ||
1118                     strcmp(s,"r1") == 0 ||
1119                     strcmp(s,"r2") == 0 ||
1120                     strcmp(s,"r3") == 0 ||
1121                     strcmp(s,"r4") == 0 ||
1122                     strcmp(s,"r5") == 0 ||
1123                     strcmp(s,"r6") == 0 ||
1124                     strcmp(s,"r7") == 0 ) {
1125                     char buffer[10];
1126                     sprintf(buffer,"a%s",s);
1127                     emitcode("mov","@%s,%s",
1128                              aop->aopu.aop_ptr->name,buffer);
1129                 } else
1130                     emitcode("mov","@%s,%s",aop->aopu.aop_ptr->name,s);
1131
1132         break;
1133
1134     case AOP_STK:
1135         if (strcmp(s,"a") == 0)
1136             emitcode("push","acc");
1137         else
1138             emitcode("push","%s",s);
1139
1140         break;
1141
1142     case AOP_CRY:
1143         /* if bit variable */
1144         if (!aop->aopu.aop_dir) {
1145             emitcode("clr","a");
1146             emitcode("rlc","a");
1147         } else {
1148             if (s == zero)
1149                 emitcode("clr","%s",aop->aopu.aop_dir);
1150             else
1151                 if (s == one)
1152                     emitcode("setb","%s",aop->aopu.aop_dir);
1153                 else
1154                     if (!strcmp(s,"c"))
1155                         emitcode("mov","%s,c",aop->aopu.aop_dir);
1156                     else {
1157                         lbl = newiTempLabel(NULL);
1158
1159                         if (strcmp(s,"a")) {
1160                             MOVA(s);
1161                         }
1162                         emitcode("clr","c");
1163                         emitcode("jz","%05d$",lbl->key+100);
1164                         emitcode("cpl","c");
1165                         emitcode("","%05d$:",lbl->key+100);
1166                         emitcode("mov","%s,c",aop->aopu.aop_dir);
1167                     }
1168         }
1169         break;
1170
1171     case AOP_STR:
1172         aop->coff = offset;
1173         if (strcmp(aop->aopu.aop_str[offset],s))
1174             emitcode ("mov","%s,%s",aop->aopu.aop_str[offset],s);
1175         break;
1176
1177     case AOP_ACC:
1178         aop->coff = offset;
1179         if (!offset && (strcmp(s,"acc") == 0))
1180             break;
1181
1182         if (strcmp(aop->aopu.aop_str[offset],s))
1183             emitcode ("mov","%s,%s",aop->aopu.aop_str[offset],s);
1184         break;
1185
1186     default :
1187         werror(E_INTERNAL_ERROR,__FILE__,__LINE__,
1188                "aopPut got unsupported aop->type");
1189         exit(1);
1190     }
1191
1192 }
1193
1194
1195 /*-----------------------------------------------------------------*/
1196 /* reAdjustPreg - points a register back to where it should        */
1197 /*-----------------------------------------------------------------*/
1198 static void reAdjustPreg (asmop *aop)
1199 {
1200     int size ;
1201
1202     aop->coff = 0;
1203     if ((size = aop->size) <= 1)
1204         return ;
1205     size-- ;
1206     switch (aop->type) {
1207         case AOP_R0 :
1208         case AOP_R1 :
1209             while (size--)
1210                 emitcode("dec","%s",aop->aopu.aop_ptr->name);
1211             break;
1212         case AOP_DPTR :
1213         case AOP_DPTR2:
1214             if (aop->type == AOP_DPTR2)
1215             {
1216                 genSetDPTR(1);
1217                 _flushLazyDPS();
1218             }
1219             while (size--)
1220             {
1221                 emitcode("lcall","__decdptr");
1222             }
1223
1224             if (aop->type == AOP_DPTR2)
1225             {
1226                 genSetDPTR(0);
1227             }
1228             break;
1229
1230     }
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 IS_AOP_PREG(x) (AOP(x) && (AOP_TYPE(x) == AOP_R1 || \
1238                        AOP_TYPE(x) == AOP_R0))
1239
1240 #define AOP_NEEDSACC(x) (AOP(x) && (AOP_TYPE(x) == AOP_CRY ||  \
1241                         AOP_TYPE(x) == AOP_DPTR || AOP_TYPE(x) == AOP_DPTR2 || \
1242                          AOP(x)->paged))
1243
1244 #define AOP_INPREG(x) (x && (x->type == AOP_REG &&                        \
1245                       (x->aopu.aop_reg[0] == ds390_regWithIdx(R0_IDX) || \
1246                       x->aopu.aop_reg[0] == ds390_regWithIdx(R1_IDX) )))
1247
1248 /* Workaround for DS80C390 bug: div ab may return bogus results
1249  * if A is accessed in instruction immediately before the div.
1250  *
1251  * Will be fixed in B4 rev of processor, Dallas claims.
1252  */
1253
1254 #define LOAD_AB_FOR_DIV(LEFT, RIGHT, L)                         \
1255     if (!AOP_NEEDSACC(RIGHT))                                   \
1256     {                                                           \
1257         /* We can load A first, then B, since                   \
1258          * B (the RIGHT operand) won't clobber A,               \
1259          * thus avoiding touching A right before the div.       \
1260          */                                                     \
1261         D(emitcode(";", "DS80C390 div bug: rearranged ops.");); \
1262         L = aopGet(AOP(LEFT),0,FALSE,FALSE,TRUE);               \
1263         MOVA(L);                                                \
1264         emitcode("mov","b,%s",aopGet(AOP(RIGHT),0,FALSE,FALSE,FALSE));\
1265     }                                                           \
1266     else                                                        \
1267     {                                                           \
1268         /* Just stuff in a nop after loading A. */              \
1269         emitcode("mov","b,%s",aopGet(AOP(RIGHT),0,FALSE,FALSE,FALSE));\
1270         L = aopGet(AOP(LEFT),0,FALSE,FALSE,TRUE);               \
1271         MOVA(L);                                                \
1272         emitcode("nop", "; workaround for DS80C390 div bug.");  \
1273     }
1274
1275 /*-----------------------------------------------------------------*/
1276 /* genNotFloat - generates not for float operations              */
1277 /*-----------------------------------------------------------------*/
1278 static void genNotFloat (operand *op, operand *res)
1279 {
1280     int size, offset;
1281     char *l;
1282     symbol *tlbl ;
1283
1284     D(emitcode(";", "genNotFloat "););
1285
1286     /* we will put 127 in the first byte of
1287     the result */
1288     aopPut(AOP(res),"#127",0);
1289     size = AOP_SIZE(op) - 1;
1290     offset = 1;
1291
1292     _startLazyDPSEvaluation();
1293     l = aopGet(op->aop,offset++,FALSE,FALSE,TRUE);
1294     MOVA(l);
1295
1296     while(size--) {
1297         emitcode("orl","a,%s",
1298                  aopGet(op->aop,
1299                         offset++,FALSE,FALSE,FALSE));
1300     }
1301     _endLazyDPSEvaluation();
1302     tlbl = newiTempLabel(NULL);
1303
1304     tlbl = newiTempLabel(NULL);
1305     aopPut(res->aop,one,1);
1306     emitcode("jz","%05d$",(tlbl->key+100));
1307     aopPut(res->aop,zero,1);
1308     emitcode("","%05d$:",(tlbl->key+100));
1309
1310     size = res->aop->size - 2;
1311     offset = 2;
1312     /* put zeros in the rest */
1313     while (size--)
1314         aopPut(res->aop,zero,offset++);
1315 }
1316
1317 /*-----------------------------------------------------------------*/
1318 /* opIsGptr: returns non-zero if the passed operand is             */
1319 /* a generic pointer type.                                         */
1320 /*-----------------------------------------------------------------*/
1321 static int opIsGptr(operand *op)
1322 {
1323     sym_link *type = operandType(op);
1324
1325     if ((AOP_SIZE(op) == GPTRSIZE) && IS_GENPTR(type))
1326     {
1327         return 1;
1328     }
1329     return 0;
1330 }
1331
1332 /*-----------------------------------------------------------------*/
1333 /* getDataSize - get the operand data size                         */
1334 /*-----------------------------------------------------------------*/
1335 static int getDataSize(operand *op)
1336 {
1337     int size;
1338     size = AOP_SIZE(op);
1339     if (size == GPTRSIZE)
1340     {
1341         sym_link *type = operandType(op);
1342         if (IS_GENPTR(type))
1343         {
1344             /* generic pointer; arithmetic operations
1345              * should ignore the high byte (pointer type).
1346              */
1347             size--;
1348         }
1349     }
1350     return size;
1351 }
1352
1353 /*-----------------------------------------------------------------*/
1354 /* outAcc - output Acc                                             */
1355 /*-----------------------------------------------------------------*/
1356 static void outAcc(operand *result)
1357 {
1358     int size, offset;
1359     size = getDataSize(result);
1360     if(size)
1361     {
1362         aopPut(AOP(result),"a",0);
1363         size--;
1364         offset = 1;
1365         /* unsigned or positive */
1366         while(size--){
1367             aopPut(AOP(result),zero,offset++);
1368         }
1369     }
1370 }
1371
1372 /*-----------------------------------------------------------------*/
1373 /* outBitC - output a bit C                                        */
1374 /*-----------------------------------------------------------------*/
1375 static void outBitC(operand *result)
1376 {
1377     /* if the result is bit */
1378     if (AOP_TYPE(result) == AOP_CRY)
1379     {
1380         aopPut(AOP(result),"c",0);
1381     }
1382     else
1383     {
1384         emitcode("clr","a");
1385         emitcode("rlc","a");
1386         outAcc(result);
1387     }
1388 }
1389
1390 /*-----------------------------------------------------------------*/
1391 /* toBoolean - emit code for orl a,operator(sizeop)                */
1392 /*-----------------------------------------------------------------*/
1393 static void toBoolean(operand *oper)
1394 {
1395     int size = AOP_SIZE(oper) - 1;
1396     int offset = 1;
1397
1398     /* The generic part of a generic pointer should
1399      * not participate in it's truth value.
1400      *
1401      * i.e. 0x10000000 is zero.
1402      */
1403     if (opIsGptr(oper))
1404     {
1405         D(emitcode(";", "toBoolean: generic ptr special case."););
1406         size--;
1407     }
1408
1409     _startLazyDPSEvaluation();
1410     if (AOP_NEEDSACC(oper))
1411     {
1412         emitcode("push", "b");
1413         emitcode("mov", "b, %s", aopGet(AOP(oper),0,FALSE,FALSE,FALSE));
1414     }
1415     else
1416     {
1417         MOVA(aopGet(AOP(oper),0,FALSE,FALSE,TRUE));
1418     }
1419     while (size--)
1420     {
1421         if (AOP_NEEDSACC(oper))
1422         {
1423             emitcode("orl","b,%s",aopGet(AOP(oper),offset++,FALSE,FALSE,FALSE));
1424         }
1425         else
1426         {
1427             emitcode("orl","a,%s",aopGet(AOP(oper),offset++,FALSE,FALSE,FALSE));
1428         }
1429     }
1430     _endLazyDPSEvaluation();
1431
1432     if (AOP_NEEDSACC(oper))
1433     {
1434         emitcode("mov", "a,b");
1435         emitcode("pop", "b");
1436     }
1437 }
1438
1439
1440 /*-----------------------------------------------------------------*/
1441 /* genNot - generate code for ! operation                          */
1442 /*-----------------------------------------------------------------*/
1443 static void genNot (iCode *ic)
1444 {
1445     symbol *tlbl;
1446     sym_link *optype = operandType(IC_LEFT(ic));
1447
1448     D(emitcode(";", "genNot "););
1449
1450     /* assign asmOps to operand & result */
1451     aopOp (IC_LEFT(ic),ic,FALSE, FALSE);
1452     aopOp (IC_RESULT(ic),ic,TRUE, AOP_TYPE(IC_LEFT(ic)) == AOP_DPTR);
1453
1454     /* if in bit space then a special case */
1455     if (AOP_TYPE(IC_LEFT(ic)) == AOP_CRY) {
1456         emitcode("mov","c,%s",IC_LEFT(ic)->aop->aopu.aop_dir);
1457         emitcode("cpl","c");
1458         outBitC(IC_RESULT(ic));
1459         goto release;
1460     }
1461
1462     /* if type float then do float */
1463     if (IS_FLOAT(optype)) {
1464         genNotFloat(IC_LEFT(ic),IC_RESULT(ic));
1465         goto release;
1466     }
1467
1468     toBoolean(IC_LEFT(ic));
1469
1470     tlbl = newiTempLabel(NULL);
1471     emitcode("cjne","a,#0x01,%05d$",tlbl->key+100);
1472     emitcode("","%05d$:",tlbl->key+100);
1473     outBitC(IC_RESULT(ic));
1474
1475 release:
1476     /* release the aops */
1477     freeAsmop(IC_LEFT(ic),NULL,ic,(RESULTONSTACK(ic) ? 0 : 1));
1478     freeAsmop(IC_RESULT(ic),NULL,ic,TRUE);
1479 }
1480
1481
1482 /*-----------------------------------------------------------------*/
1483 /* genCpl - generate code for complement                           */
1484 /*-----------------------------------------------------------------*/
1485 static void genCpl (iCode *ic)
1486 {
1487     int offset = 0;
1488     int size ;
1489
1490     D(emitcode(";", "genCpl "););
1491
1492
1493     /* assign asmOps to operand & result */
1494     aopOp (IC_LEFT(ic),ic,FALSE, FALSE);
1495     aopOp (IC_RESULT(ic),ic,TRUE, AOP_TYPE(IC_LEFT(ic)) == AOP_DPTR);
1496
1497     /* if both are in bit space then
1498     a special case */
1499     if (AOP_TYPE(IC_RESULT(ic)) == AOP_CRY &&
1500         AOP_TYPE(IC_LEFT(ic)) == AOP_CRY ) {
1501
1502         emitcode("mov","c,%s",IC_LEFT(ic)->aop->aopu.aop_dir);
1503         emitcode("cpl","c");
1504         emitcode("mov","%s,c",IC_RESULT(ic)->aop->aopu.aop_dir);
1505         goto release;
1506     }
1507
1508     size = AOP_SIZE(IC_RESULT(ic));
1509     _startLazyDPSEvaluation();
1510     while (size--) {
1511         char *l = aopGet(AOP(IC_LEFT(ic)),offset,FALSE,FALSE,TRUE);
1512         MOVA(l);
1513         emitcode("cpl","a");
1514         aopPut(AOP(IC_RESULT(ic)),"a",offset++);
1515     }
1516     _endLazyDPSEvaluation();
1517
1518
1519 release:
1520     /* release the aops */
1521     freeAsmop(IC_LEFT(ic),NULL,ic,(RESULTONSTACK(ic) ? 0 : 1));
1522     freeAsmop(IC_RESULT(ic),NULL,ic,TRUE);
1523 }
1524
1525 /*-----------------------------------------------------------------*/
1526 /* genUminusFloat - unary minus for floating points                */
1527 /*-----------------------------------------------------------------*/
1528 static void genUminusFloat(operand *op,operand *result)
1529 {
1530     int size ,offset =0 ;
1531     char *l;
1532     /* for this we just need to flip the
1533     first it then copy the rest in place */
1534     D(emitcode(";", "genUminusFloat"););
1535
1536     _startLazyDPSEvaluation();
1537     size = AOP_SIZE(op) - 1;
1538     l = aopGet(AOP(op),3,FALSE,FALSE,TRUE);
1539     MOVA(l);
1540
1541     emitcode("cpl","acc.7");
1542     aopPut(AOP(result),"a",3);
1543
1544     while(size--) {
1545         aopPut(AOP(result),
1546                aopGet(AOP(op),offset,FALSE,FALSE,FALSE),
1547                offset);
1548         offset++;
1549     }
1550     _endLazyDPSEvaluation();
1551 }
1552
1553 /*-----------------------------------------------------------------*/
1554 /* genUminus - unary minus code generation                         */
1555 /*-----------------------------------------------------------------*/
1556 static void genUminus (iCode *ic)
1557 {
1558     int offset ,size ;
1559     sym_link *optype, *rtype;
1560
1561     D(emitcode(";", "genUminus "););
1562
1563
1564     /* assign asmops */
1565     aopOp(IC_LEFT(ic),ic,FALSE, FALSE);
1566     aopOp(IC_RESULT(ic),ic,TRUE, AOP_TYPE(IC_LEFT(ic)) == AOP_DPTR);
1567
1568     /* if both in bit space then special
1569     case */
1570     if (AOP_TYPE(IC_RESULT(ic)) == AOP_CRY &&
1571         AOP_TYPE(IC_LEFT(ic)) == AOP_CRY ) {
1572
1573         emitcode("mov","c,%s",IC_LEFT(ic)->aop->aopu.aop_dir);
1574         emitcode("cpl","c");
1575         emitcode("mov","%s,c",IC_RESULT(ic)->aop->aopu.aop_dir);
1576         goto release;
1577     }
1578
1579     optype = operandType(IC_LEFT(ic));
1580     rtype = operandType(IC_RESULT(ic));
1581
1582     /* if float then do float stuff */
1583     if (IS_FLOAT(optype)) {
1584         genUminusFloat(IC_LEFT(ic),IC_RESULT(ic));
1585         goto release;
1586     }
1587
1588     /* otherwise subtract from zero */
1589     size = AOP_SIZE(IC_LEFT(ic));
1590     offset = 0 ;
1591     _startLazyDPSEvaluation();
1592     while(size--) {
1593         char *l = aopGet(AOP(IC_LEFT(ic)),offset,FALSE,FALSE,TRUE);
1594         if (!strcmp(l,"a")) {
1595           if (offset==0)
1596             SETC;
1597           emitcode("cpl","a");
1598           emitcode("addc", "a,#0");
1599         } else {
1600           if (offset==0)
1601             CLRC;
1602           emitcode("clr","a");
1603           emitcode("subb","a,%s",l);
1604         }
1605         aopPut(AOP(IC_RESULT(ic)),"a",offset++);
1606     }
1607     _endLazyDPSEvaluation();
1608
1609     /* if any remaining bytes in the result */
1610     /* we just need to propagate the sign   */
1611     if ((size = (AOP_SIZE(IC_RESULT(ic)) - AOP_SIZE(IC_LEFT(ic))))) {
1612         emitcode("rlc","a");
1613         emitcode("subb","a,acc");
1614         while (size--)
1615             aopPut(AOP(IC_RESULT(ic)),"a",offset++);
1616     }
1617
1618 release:
1619     /* release the aops */
1620     freeAsmop(IC_LEFT(ic),NULL,ic,(RESULTONSTACK(ic) ? 0 : 1));
1621     freeAsmop(IC_RESULT(ic),NULL,ic,TRUE);
1622 }
1623
1624 /*-----------------------------------------------------------------*/
1625 /* saveRegisters - will look for a call and save the registers     */
1626 /*-----------------------------------------------------------------*/
1627 static void saveRegisters(iCode *lic)
1628 {
1629     int i;
1630     iCode *ic;
1631     bitVect *rsave;
1632     sym_link *detype;
1633
1634     /* look for call */
1635     for (ic = lic ; ic ; ic = ic->next)
1636         if (ic->op == CALL || ic->op == PCALL)
1637             break;
1638
1639     if (!ic) {
1640         fprintf(stderr,"found parameter push with no function call\n");
1641         return ;
1642     }
1643
1644     /* if the registers have been saved already then
1645     do nothing */
1646     if (ic->regsSaved || (OP_SYMBOL(IC_LEFT(ic))->calleeSave))
1647         return ;
1648
1649     /* find the registers in use at this time
1650     and push them away to safety */
1651     rsave = bitVectCplAnd(bitVectCopy(ic->rMask),
1652                           ic->rUsed);
1653
1654     ic->regsSaved = 1;
1655     if (options.useXstack) {
1656         if (bitVectBitValue(rsave,R0_IDX))
1657             emitcode("mov","b,r0");
1658         emitcode("mov","r0,%s",spname);
1659         for (i = 0 ; i < ds390_nRegs ; i++) {
1660             if (bitVectBitValue(rsave,i)) {
1661                 if (i == R0_IDX)
1662                     emitcode("mov","a,b");
1663                 else
1664                     emitcode("mov","a,%s",ds390_regWithIdx(i)->name);
1665                 emitcode("movx","@r0,a");
1666                 emitcode("inc","r0");
1667             }
1668         }
1669         emitcode("mov","%s,r0",spname);
1670         if (bitVectBitValue(rsave,R0_IDX))
1671             emitcode("mov","r0,b");
1672     } else
1673         for (i = 0 ; i < ds390_nRegs ; i++) {
1674             if (bitVectBitValue(rsave,i))
1675                 emitcode("push","%s",ds390_regWithIdx(i)->dname);
1676         }
1677
1678     detype = getSpec(operandType(IC_LEFT(ic)));
1679     if (detype        &&
1680         (SPEC_BANK(currFunc->etype) != SPEC_BANK(detype)) &&
1681         IS_ISR(currFunc->etype) &&
1682         !ic->bankSaved)
1683
1684         saverbank(SPEC_BANK(detype),ic,TRUE);
1685
1686 }
1687 /*-----------------------------------------------------------------*/
1688 /* unsaveRegisters - pop the pushed registers                      */
1689 /*-----------------------------------------------------------------*/
1690 static void unsaveRegisters (iCode *ic)
1691 {
1692     int i;
1693     bitVect *rsave;
1694     /* find the registers in use at this time
1695     and push them away to safety */
1696     rsave = bitVectCplAnd(bitVectCopy(ic->rMask),
1697                           ic->rUsed);
1698
1699     if (options.useXstack) {
1700         emitcode("mov","r0,%s",spname);
1701         for (i =  ds390_nRegs ; i >= 0 ; i--) {
1702             if (bitVectBitValue(rsave,i)) {
1703                 emitcode("dec","r0");
1704                 emitcode("movx","a,@r0");
1705                 if (i == R0_IDX)
1706                     emitcode("mov","b,a");
1707                 else
1708                     emitcode("mov","%s,a",ds390_regWithIdx(i)->name);
1709             }
1710
1711         }
1712         emitcode("mov","%s,r0",spname);
1713         if (bitVectBitValue(rsave,R0_IDX))
1714             emitcode("mov","r0,b");
1715     } else
1716         for (i =  ds390_nRegs ; i >= 0 ; i--) {
1717             if (bitVectBitValue(rsave,i))
1718                 emitcode("pop","%s",ds390_regWithIdx(i)->dname);
1719         }
1720
1721 }
1722
1723
1724 /*-----------------------------------------------------------------*/
1725 /* pushSide -                                                      */
1726 /*-----------------------------------------------------------------*/
1727 static void pushSide(operand * oper, int size)
1728 {
1729         int offset = 0;
1730         _startLazyDPSEvaluation();
1731         while (size--) {
1732                 char *l = aopGet(AOP(oper),offset++,FALSE,TRUE,FALSE);
1733                 if (AOP_TYPE(oper) != AOP_REG &&
1734                     AOP_TYPE(oper) != AOP_DIR &&
1735                     strcmp(l,"a") ) {
1736                         emitcode("mov","a,%s",l);
1737                         emitcode("push","acc");
1738                 } else
1739                         emitcode("push","%s",l);
1740         }
1741         _endLazyDPSEvaluation();
1742 }
1743
1744 /*-----------------------------------------------------------------*/
1745 /* assignResultValue -                                             */
1746 /*-----------------------------------------------------------------*/
1747 static void assignResultValue(operand * oper)
1748 {
1749         int offset = 0;
1750         int size = AOP_SIZE(oper);
1751
1752         _startLazyDPSEvaluation();
1753         while (size--) {
1754                 aopPut(AOP(oper),fReturn[offset],offset);
1755                 offset++;
1756         }
1757         _endLazyDPSEvaluation();
1758 }
1759
1760
1761 /*-----------------------------------------------------------------*/
1762 /* genXpush - pushes onto the external stack                       */
1763 /*-----------------------------------------------------------------*/
1764 static void genXpush (iCode *ic)
1765 {
1766     asmop *aop = newAsmop(0);
1767     regs *r ;
1768     int size,offset = 0;
1769
1770     D(emitcode(";", "genXpush "););
1771
1772     aopOp(IC_LEFT(ic),ic,FALSE, FALSE);
1773     r = getFreePtr(ic,&aop,FALSE);
1774
1775
1776     emitcode("mov","%s,_spx",r->name);
1777
1778     size = AOP_SIZE(IC_LEFT(ic));
1779     _startLazyDPSEvaluation();
1780     while(size--) {
1781
1782         char *l = aopGet(AOP(IC_LEFT(ic)),
1783                          offset++,FALSE,FALSE,TRUE);
1784         MOVA(l);
1785         emitcode("movx","@%s,a",r->name);
1786         emitcode("inc","%s",r->name);
1787
1788     }
1789     _endLazyDPSEvaluation();
1790
1791
1792     emitcode("mov","_spx,%s",r->name);
1793
1794     freeAsmop(NULL,aop,ic,TRUE);
1795     freeAsmop(IC_LEFT(ic),NULL,ic,TRUE);
1796 }
1797
1798 /*-----------------------------------------------------------------*/
1799 /* genIpush - genrate code for pushing this gets a little complex  */
1800 /*-----------------------------------------------------------------*/
1801 static void genIpush (iCode *ic)
1802 {
1803     int size, offset = 0 ;
1804     char *l;
1805
1806     D(emitcode(";", "genIpush "););
1807
1808
1809     /* if this is not a parm push : ie. it is spill push
1810     and spill push is always done on the local stack */
1811     if (!ic->parmPush) {
1812
1813         /* and the item is spilt then do nothing */
1814         if (OP_SYMBOL(IC_LEFT(ic))->isspilt)
1815             return ;
1816
1817         aopOp(IC_LEFT(ic),ic,FALSE, FALSE);
1818         size = AOP_SIZE(IC_LEFT(ic));
1819         /* push it on the stack */
1820         _startLazyDPSEvaluation();
1821         while(size--) {
1822             l = aopGet(AOP(IC_LEFT(ic)),offset++,FALSE,TRUE,TRUE);
1823             if (*l == '#') {
1824                 MOVA(l);
1825                 l = "acc";
1826             }
1827             emitcode("push","%s",l);
1828         }
1829         _endLazyDPSEvaluation();
1830         return ;
1831     }
1832
1833     /* this is a paramter push: in this case we call
1834     the routine to find the call and save those
1835     registers that need to be saved */
1836     saveRegisters(ic);
1837
1838     /* if use external stack then call the external
1839     stack pushing routine */
1840     if (options.useXstack) {
1841         genXpush(ic);
1842         return ;
1843     }
1844
1845     /* then do the push */
1846     aopOp(IC_LEFT(ic),ic,FALSE, FALSE);
1847
1848     // pushSide(IC_LEFT(ic), AOP_SIZE(IC_LEFT(ic)));
1849     size = AOP_SIZE(IC_LEFT(ic));
1850
1851     _startLazyDPSEvaluation();
1852     while (size--) {
1853         l = aopGet(AOP(IC_LEFT(ic)),offset++,FALSE,TRUE,FALSE);
1854         if (AOP_TYPE(IC_LEFT(ic)) != AOP_REG &&
1855             AOP_TYPE(IC_LEFT(ic)) != AOP_DIR &&
1856             strcmp(l,"a") ) {
1857             emitcode("mov","a,%s",l);
1858             emitcode("push","acc");
1859         } else
1860             emitcode("push","%s",l);
1861     }
1862     _endLazyDPSEvaluation();
1863
1864     freeAsmop(IC_LEFT(ic),NULL,ic,TRUE);
1865 }
1866
1867 /*-----------------------------------------------------------------*/
1868 /* genIpop - recover the registers: can happen only for spilling   */
1869 /*-----------------------------------------------------------------*/
1870 static void genIpop (iCode *ic)
1871 {
1872     int size,offset ;
1873
1874     D(emitcode(";", "genIpop "););
1875
1876
1877     /* if the temp was not pushed then */
1878     if (OP_SYMBOL(IC_LEFT(ic))->isspilt)
1879         return ;
1880
1881     aopOp(IC_LEFT(ic),ic,FALSE, FALSE);
1882     size = AOP_SIZE(IC_LEFT(ic));
1883     offset = (size-1);
1884     _startLazyDPSEvaluation();
1885     while (size--)
1886     {
1887         emitcode("pop","%s",aopGet(AOP(IC_LEFT(ic)),offset--,
1888                                    FALSE,TRUE,TRUE));
1889     }
1890     _endLazyDPSEvaluation();
1891
1892     freeAsmop(IC_LEFT(ic),NULL,ic,TRUE);
1893 }
1894
1895 /*-----------------------------------------------------------------*/
1896 /* unsaverbank - restores the resgister bank from stack            */
1897 /*-----------------------------------------------------------------*/
1898 static void unsaverbank (int bank,iCode *ic,bool popPsw)
1899 {
1900     int i;
1901     asmop *aop ;
1902     regs *r = NULL;
1903
1904     if (popPsw) {
1905         if (options.useXstack) {
1906             aop = newAsmop(0);
1907             r = getFreePtr(ic,&aop,FALSE);
1908
1909
1910             emitcode("mov","%s,_spx",r->name);
1911             emitcode("movx","a,@%s",r->name);
1912             emitcode("mov","psw,a");
1913             emitcode("dec","%s",r->name);
1914
1915         }else
1916             emitcode ("pop","psw");
1917     }
1918
1919     for (i = (ds390_nRegs - 1) ; i >= 0 ;i--) {
1920         if (options.useXstack) {
1921             emitcode("movx","a,@%s",r->name);
1922             emitcode("mov","(%s+%d),a",
1923                      regs390[i].base,8*bank+regs390[i].offset);
1924             emitcode("dec","%s",r->name);
1925
1926         } else
1927             emitcode("pop","(%s+%d)",
1928                      regs390[i].base,8*bank+regs390[i].offset);
1929     }
1930
1931     if (options.useXstack) {
1932
1933         emitcode("mov","_spx,%s",r->name);
1934         freeAsmop(NULL,aop,ic,TRUE);
1935
1936     }
1937 }
1938
1939 /*-----------------------------------------------------------------*/
1940 /* saverbank - saves an entire register bank on the stack          */
1941 /*-----------------------------------------------------------------*/
1942 static void saverbank (int bank, iCode *ic, bool pushPsw)
1943 {
1944     int i;
1945     asmop *aop ;
1946     regs *r = NULL;
1947
1948     if (options.useXstack) {
1949
1950         aop = newAsmop(0);
1951         r = getFreePtr(ic,&aop,FALSE);
1952         emitcode("mov","%s,_spx",r->name);
1953
1954     }
1955
1956     for (i = 0 ; i < ds390_nRegs ;i++) {
1957         if (options.useXstack) {
1958             emitcode("inc","%s",r->name);
1959             emitcode("mov","a,(%s+%d)",
1960                      regs390[i].base,8*bank+regs390[i].offset);
1961             emitcode("movx","@%s,a",r->name);
1962         } else
1963             emitcode("push","(%s+%d)",
1964                      regs390[i].base,8*bank+regs390[i].offset);
1965     }
1966
1967     if (pushPsw) {
1968         if (options.useXstack) {
1969             emitcode("mov","a,psw");
1970             emitcode("movx","@%s,a",r->name);
1971             emitcode("inc","%s",r->name);
1972             emitcode("mov","_spx,%s",r->name);
1973             freeAsmop (NULL,aop,ic,TRUE);
1974
1975         } else
1976             emitcode("push","psw");
1977
1978         emitcode("mov","psw,#0x%02x",(bank << 3)&0x00ff);
1979     }
1980     ic->bankSaved = 1;
1981
1982 }
1983
1984 /*-----------------------------------------------------------------*/
1985 /* genCall - generates a call statement                            */
1986 /*-----------------------------------------------------------------*/
1987 static void genCall (iCode *ic)
1988 {
1989     sym_link *detype;
1990
1991     D(emitcode(";", "genCall "););
1992
1993     /* if caller saves & we have not saved then */
1994     if (!ic->regsSaved)
1995         saveRegisters(ic);
1996
1997     /* if we are calling a function that is not using
1998     the same register bank then we need to save the
1999     destination registers on the stack */
2000     detype = getSpec(operandType(IC_LEFT(ic)));
2001     if (detype        &&
2002         (SPEC_BANK(currFunc->etype) != SPEC_BANK(detype)) &&
2003         IS_ISR(currFunc->etype) &&
2004         !ic->bankSaved)
2005
2006         saverbank(SPEC_BANK(detype),ic,TRUE);
2007
2008     /* if send set is not empty the assign */
2009     if (_G.sendSet) {
2010         iCode *sic ;
2011
2012         for (sic = setFirstItem(_G.sendSet) ; sic ;
2013              sic = setNextItem(_G.sendSet))
2014         {
2015             int size, offset = 0;
2016
2017             aopOp(IC_LEFT(sic),sic,FALSE, TRUE);
2018             size = AOP_SIZE(IC_LEFT(sic));
2019
2020             _startLazyDPSEvaluation();
2021             while (size--) {
2022                 char *l = aopGet(AOP(IC_LEFT(sic)),offset,
2023                                 FALSE, FALSE, TRUE);
2024                 if (strcmp(l,fReturn[offset]))
2025                     emitcode("mov","%s,%s",
2026                              fReturn[offset],
2027                              l);
2028                 offset++;
2029             }
2030             _endLazyDPSEvaluation();
2031             freeAsmop (IC_LEFT(sic),NULL,sic,TRUE);
2032         }
2033         _G.sendSet = NULL;
2034     }
2035     /* make the call */
2036     emitcode("lcall","%s",(OP_SYMBOL(IC_LEFT(ic))->rname[0] ?
2037                            OP_SYMBOL(IC_LEFT(ic))->rname :
2038                            OP_SYMBOL(IC_LEFT(ic))->name));
2039
2040     /* if we need assign a result value */
2041     if ((IS_ITEMP(IC_RESULT(ic)) &&
2042          (OP_SYMBOL(IC_RESULT(ic))->nRegs ||
2043           OP_SYMBOL(IC_RESULT(ic))->spildir )) ||
2044         IS_TRUE_SYMOP(IC_RESULT(ic)) ) {
2045
2046 #ifdef LAZY_DPS_OPT
2047         /* Not really related to LAZY_DPS_OPT, but don't want
2048          * another testing flag right now...
2049          */
2050 #define FAR_RETURN_OPT
2051 #ifdef FAR_RETURN_OPT
2052         if (isOperandInFarSpace(IC_RESULT(ic))
2053          && getSize(operandType(IC_RESULT(ic))) <= 2)
2054         {
2055             int size =  getSize(operandType(IC_RESULT(ic)));
2056
2057              /* Special case for 1 or 2 byte return in far space. */
2058             emitcode(";", "Kevin function call abuse #1");
2059
2060             MOVA(fReturn[0]);
2061             if (size > 1)
2062             {
2063                 emitcode("mov", "b,%s", fReturn[1]);
2064             }
2065
2066             aopOp(IC_RESULT(ic),ic,FALSE, FALSE);
2067             aopPut(AOP(IC_RESULT(ic)),"a",0);
2068
2069             if (size > 1)
2070             {
2071                 aopPut(AOP(IC_RESULT(ic)),"b",1);
2072             }
2073             freeAsmop(IC_RESULT(ic),NULL,ic,TRUE);
2074         }
2075         else
2076 #endif
2077         {
2078             _G.accInUse++;
2079             aopOp(IC_RESULT(ic),ic,FALSE, TRUE);
2080             _G.accInUse--;
2081
2082             assignResultValue(IC_RESULT(ic));
2083
2084             freeAsmop(IC_RESULT(ic),NULL, ic,TRUE);
2085         }
2086 #else
2087         if (!isOperandInFarSpace(IC_RESULT(ic)))
2088         {
2089             _G.accInUse++;
2090             aopOp(IC_RESULT(ic),ic,FALSE, FALSE);
2091             _G.accInUse--;
2092
2093             assignResultValue(IC_RESULT(ic));
2094
2095             freeAsmop(IC_RESULT(ic),NULL, ic,TRUE);
2096         }
2097         else
2098         {
2099             /* Result is in far space, and requires DPTR to access
2100              * it. Push the result onto the stack and restore from
2101              * there.
2102              */
2103             int size = getSize(operandType(IC_RESULT(ic)));
2104             int offset = size - 1;
2105             char *l;
2106
2107             emitcode(";", "Kevin function call abuse #1");
2108
2109             /* first push the right side on to the stack */
2110             /* NB: this relies on the fact that "a" is the last
2111              * register in fReturn. If it were not, the MOVA
2112              * would potentially clobber a returned byte in A.
2113              */
2114             while (size--) {
2115                 l = fReturn[offset--];
2116                 MOVA(l);
2117                 emitcode ("push","acc");
2118             }
2119
2120             /* now assign DPTR to result */
2121             aopOp(IC_RESULT(ic),ic,FALSE, FALSE);
2122             size = AOP_SIZE(IC_RESULT(ic));
2123             aopOp(IC_RESULT(ic),ic,FALSE, FALSE); /* bug? */
2124             while (size--) {
2125                 emitcode ("pop","acc");
2126                 aopPut(AOP(IC_RESULT(ic)),"a",++offset);
2127             }
2128             freeAsmop(IC_RESULT(ic),NULL,ic,TRUE);
2129         }
2130 #endif
2131     }
2132
2133     /* adjust the stack for parameters if
2134     required */
2135     if (IC_LEFT(ic)->parmBytes) {
2136         int i;
2137         if (IC_LEFT(ic)->parmBytes > 3) {
2138             emitcode("mov","a,%s",spname);
2139             emitcode("add","a,#0x%02x", (- IC_LEFT(ic)->parmBytes) & 0xff);
2140             emitcode("mov","%s,a",spname);
2141         } else
2142             for ( i = 0 ; i <  IC_LEFT(ic)->parmBytes ;i++)
2143                 emitcode("dec","%s",spname);
2144
2145     }
2146
2147     /* if register bank was saved then pop them */
2148     if (ic->bankSaved)
2149         unsaverbank(SPEC_BANK(detype),ic,TRUE);
2150
2151     /* if we hade saved some registers then unsave them */
2152     if (ic->regsSaved && !(OP_SYMBOL(IC_LEFT(ic))->calleeSave))
2153         unsaveRegisters (ic);
2154
2155
2156 }
2157
2158 /*-----------------------------------------------------------------*/
2159 /* genPcall - generates a call by pointer statement                */
2160 /*-----------------------------------------------------------------*/
2161 static void genPcall (iCode *ic)
2162 {
2163     sym_link *detype;
2164     symbol *rlbl = newiTempLabel(NULL);
2165
2166     D(emitcode(";", "genPcall "););
2167
2168
2169     /* if caller saves & we have not saved then */
2170     if (!ic->regsSaved)
2171         saveRegisters(ic);
2172
2173     /* if we are calling a function that is not using
2174     the same register bank then we need to save the
2175     destination registers on the stack */
2176     detype = getSpec(operandType(IC_LEFT(ic)));
2177     if (detype        &&
2178         IS_ISR(currFunc->etype) &&
2179         (SPEC_BANK(currFunc->etype) != SPEC_BANK(detype)))
2180         saverbank(SPEC_BANK(detype),ic,TRUE);
2181
2182
2183     /* push the return address on to the stack */
2184     emitcode("mov","a,#%05d$",(rlbl->key+100));
2185     emitcode("push","acc");
2186     emitcode("mov","a,#(%05d$ >> 8)",(rlbl->key+100));
2187     emitcode("push","acc");
2188
2189     if (options.model == MODEL_FLAT24)
2190     {
2191         emitcode("mov","a,#(%05d$ >> 16)",(rlbl->key+100));
2192         emitcode("push","acc");
2193     }
2194
2195     /* now push the calling address */
2196     aopOp(IC_LEFT(ic),ic,FALSE, FALSE);
2197
2198     pushSide(IC_LEFT(ic), FPTRSIZE);
2199
2200     freeAsmop(IC_LEFT(ic),NULL,ic,TRUE);
2201
2202     /* if send set is not empty the assign */
2203     if (_G.sendSet) {
2204         iCode *sic ;
2205
2206         for (sic = setFirstItem(_G.sendSet) ; sic ;
2207              sic = setNextItem(_G.sendSet))
2208              {
2209                 int size, offset = 0;
2210
2211                 aopOp(IC_LEFT(sic),sic,FALSE, FALSE);
2212                 size = AOP_SIZE(IC_LEFT(sic));
2213                 _startLazyDPSEvaluation();
2214                 while (size--)
2215                 {
2216                         char *l = aopGet(AOP(IC_LEFT(sic)),offset,
2217                                          FALSE,FALSE,TRUE);
2218                         if (strcmp(l,fReturn[offset]))
2219                         {
2220                                 emitcode("mov","%s,%s",
2221                                          fReturn[offset],
2222                                          l);
2223                         }
2224                         offset++;
2225                 }
2226                 _endLazyDPSEvaluation();
2227                 freeAsmop (IC_LEFT(sic),NULL,sic,TRUE);
2228             }
2229             _G.sendSet = NULL;
2230     }
2231
2232     emitcode("ret","");
2233     emitcode("","%05d$:",(rlbl->key+100));
2234
2235
2236     /* if we need assign a result value */
2237     if ((IS_ITEMP(IC_RESULT(ic)) &&
2238          (OP_SYMBOL(IC_RESULT(ic))->nRegs ||
2239           OP_SYMBOL(IC_RESULT(ic))->spildir)) ||
2240         IS_TRUE_SYMOP(IC_RESULT(ic)) ) {
2241
2242         _G.accInUse++;
2243         aopOp(IC_RESULT(ic),ic,FALSE, TRUE);
2244         _G.accInUse--;
2245
2246         assignResultValue(IC_RESULT(ic));
2247
2248         freeAsmop(IC_RESULT(ic),NULL,ic,TRUE);
2249     }
2250
2251     /* adjust the stack for parameters if
2252     required */
2253     if (IC_LEFT(ic)->parmBytes) {
2254         int i;
2255         if (IC_LEFT(ic)->parmBytes > 3) {
2256             emitcode("mov","a,%s",spname);
2257             emitcode("add","a,#0x%02x", (- IC_LEFT(ic)->parmBytes) & 0xff);
2258             emitcode("mov","%s,a",spname);
2259         } else
2260             for ( i = 0 ; i <  IC_LEFT(ic)->parmBytes ;i++)
2261                 emitcode("dec","%s",spname);
2262
2263     }
2264
2265     /* if register bank was saved then unsave them */
2266     if (detype        &&
2267         (SPEC_BANK(currFunc->etype) !=
2268          SPEC_BANK(detype)))
2269         unsaverbank(SPEC_BANK(detype),ic,TRUE);
2270
2271     /* if we hade saved some registers then
2272     unsave them */
2273     if (ic->regsSaved)
2274         unsaveRegisters (ic);
2275
2276 }
2277
2278 /*-----------------------------------------------------------------*/
2279 /* resultRemat - result  is rematerializable                       */
2280 /*-----------------------------------------------------------------*/
2281 static int resultRemat (iCode *ic)
2282 {
2283     if (SKIP_IC(ic) || ic->op == IFX)
2284         return 0;
2285
2286     if (IC_RESULT(ic) && IS_ITEMP(IC_RESULT(ic))) {
2287         symbol *sym = OP_SYMBOL(IC_RESULT(ic));
2288         if (sym->remat && !POINTER_SET(ic))
2289             return 1;
2290     }
2291
2292     return 0;
2293 }
2294
2295 #if defined(__BORLANDC__) || defined(_MSC_VER)
2296 #define STRCASECMP stricmp
2297 #else
2298 #define STRCASECMP strcasecmp
2299 #endif
2300
2301 /*-----------------------------------------------------------------*/
2302 /* inExcludeList - return 1 if the string is in exclude Reg list   */
2303 /*-----------------------------------------------------------------*/
2304 static bool inExcludeList(char *s)
2305 {
2306     int i =0;
2307
2308     if (options.excludeRegs[i] &&
2309     STRCASECMP(options.excludeRegs[i],"none") == 0)
2310         return FALSE ;
2311
2312     for ( i = 0 ; options.excludeRegs[i]; i++) {
2313         if (options.excludeRegs[i] &&
2314         STRCASECMP(s,options.excludeRegs[i]) == 0)
2315             return TRUE;
2316     }
2317     return FALSE ;
2318 }
2319
2320 /*-----------------------------------------------------------------*/
2321 /* genFunction - generated code for function entry                 */
2322 /*-----------------------------------------------------------------*/
2323 static void genFunction (iCode *ic)
2324 {
2325     symbol *sym;
2326     sym_link *fetype;
2327
2328     D(emitcode(";", "genFunction "););
2329
2330     _G.nRegsSaved = 0;
2331     /* create the function header */
2332     emitcode(";","-----------------------------------------");
2333     emitcode(";"," function %s",(sym = OP_SYMBOL(IC_LEFT(ic)))->name);
2334     emitcode(";","-----------------------------------------");
2335
2336     emitcode("","%s:",sym->rname);
2337     fetype = getSpec(operandType(IC_LEFT(ic)));
2338
2339     /* if critical function then turn interrupts off */
2340     if (SPEC_CRTCL(fetype))
2341         emitcode("clr","ea");
2342
2343     /* here we need to generate the equates for the
2344        register bank if required */
2345     if (SPEC_BANK(fetype) != rbank) {
2346         int i ;
2347
2348         rbank = SPEC_BANK(fetype);
2349         for ( i = 0 ; i < ds390_nRegs ; i++ ) {
2350             if (strcmp(regs390[i].base,"0") == 0)
2351                 emitcode("","%s = 0x%02x",
2352                          regs390[i].dname,
2353                          8*rbank+regs390[i].offset);
2354             else
2355                 emitcode ("","%s = %s + 0x%02x",
2356                           regs390[i].dname,
2357                           regs390[i].base,
2358                           8*rbank+regs390[i].offset);
2359         }
2360     }
2361
2362     /* if this is an interrupt service routine then
2363     save acc, b, dpl, dph  */
2364     if (IS_ISR(sym->etype)) {
2365
2366         if (!inExcludeList("acc"))
2367             emitcode ("push","acc");
2368         if (!inExcludeList("b"))
2369             emitcode ("push","b");
2370         if (!inExcludeList("dpl"))
2371             emitcode ("push","dpl");
2372         if (!inExcludeList("dph"))
2373             emitcode ("push","dph");
2374         if (options.model == MODEL_FLAT24 && !inExcludeList("dpx"))
2375         {
2376             emitcode ("push", "dpx");
2377             /* Make sure we're using standard DPTR */
2378             emitcode ("push", "dps");
2379             emitcode ("mov", "dps, #0x00");
2380             if (options.stack10bit)
2381             {
2382                 /* This ISR could conceivably use DPTR2. Better save it. */
2383                 emitcode ("push", "dpl1");
2384                 emitcode ("push", "dph1");
2385                 emitcode ("push", "dpx1");
2386             emitcode ("push", "ap");
2387             }
2388         }
2389         /* if this isr has no bank i.e. is going to
2390            run with bank 0 , then we need to save more
2391            registers :-) */
2392         if (!SPEC_BANK(sym->etype)) {
2393
2394             /* if this function does not call any other
2395                function then we can be economical and
2396                save only those registers that are used */
2397             if (! sym->hasFcall) {
2398                 int i;
2399
2400                 /* if any registers used */
2401                 if (sym->regsUsed) {
2402                     /* save the registers used */
2403                     for ( i = 0 ; i < sym->regsUsed->size ; i++) {
2404                         if (bitVectBitValue(sym->regsUsed,i) ||
2405                           (ds390_ptrRegReq && (i == R0_IDX || i == R1_IDX)) )
2406                             emitcode("push","%s",ds390_regWithIdx(i)->dname);
2407                     }
2408                 }
2409
2410             } else {
2411                 /* this function has  a function call cannot
2412                    determines register usage so we will have the
2413                    entire bank */
2414                 saverbank(0,ic,FALSE);
2415             }
2416         }
2417     } else {
2418         /* if callee-save to be used for this function
2419            then save the registers being used in this function */
2420         if (sym->calleeSave) {
2421             int i;
2422
2423             /* if any registers used */
2424             if (sym->regsUsed) {
2425                 /* save the registers used */
2426                 for ( i = 0 ; i < sym->regsUsed->size ; i++) {
2427                     if (bitVectBitValue(sym->regsUsed,i) ||
2428                       (ds390_ptrRegReq && (i == R0_IDX || i == R1_IDX)) ) {
2429                         emitcode("push","%s",ds390_regWithIdx(i)->dname);
2430                         _G.nRegsSaved++;
2431                     }
2432                 }
2433             }
2434         }
2435     }
2436
2437     /* set the register bank to the desired value */
2438     if (SPEC_BANK(sym->etype) || IS_ISR(sym->etype)) {
2439         emitcode("push","psw");
2440         emitcode("mov","psw,#0x%02x",(SPEC_BANK(sym->etype) << 3)&0x00ff);
2441     }
2442
2443     if (IS_RENT(sym->etype) || options.stackAuto) {
2444
2445         if (options.useXstack) {
2446             emitcode("mov","r0,%s",spname);
2447             emitcode("mov","a,_bp");
2448             emitcode("movx","@r0,a");
2449             emitcode("inc","%s",spname);
2450         }
2451         else
2452         {
2453             /* set up the stack */
2454             emitcode ("push","_bp");     /* save the callers stack  */
2455         }
2456         emitcode ("mov","_bp,%s",spname);
2457     }
2458
2459     /* adjust the stack for the function */
2460     if (sym->stack) {
2461
2462         int i = sym->stack;
2463         if (i > 256 )
2464             werror(W_STACK_OVERFLOW,sym->name);
2465
2466         if (i > 3 && sym->recvSize < 4) {
2467
2468             emitcode ("mov","a,sp");
2469             emitcode ("add","a,#0x%02x",((char)sym->stack & 0xff));
2470             emitcode ("mov","sp,a");
2471
2472         }
2473         else
2474             while(i--)
2475                 emitcode("inc","sp");
2476     }
2477
2478      if (sym->xstack) {
2479
2480         emitcode ("mov","a,_spx");
2481         emitcode ("add","a,#0x%02x",((char)sym->xstack & 0xff));
2482         emitcode ("mov","_spx,a");
2483     }
2484
2485 }
2486
2487 /*-----------------------------------------------------------------*/
2488 /* genEndFunction - generates epilogue for functions               */
2489 /*-----------------------------------------------------------------*/
2490 static void genEndFunction (iCode *ic)
2491 {
2492     symbol *sym = OP_SYMBOL(IC_LEFT(ic));
2493
2494     D(emitcode(";", "genEndFunction "););
2495
2496     if (IS_RENT(sym->etype) || options.stackAuto)
2497     {
2498         emitcode ("mov","%s,_bp",spname);
2499     }
2500
2501     /* if use external stack but some variables were
2502     added to the local stack then decrement the
2503     local stack */
2504     if (options.useXstack && sym->stack) {
2505         emitcode("mov","a,sp");
2506         emitcode("add","a,#0x%02x",((char)-sym->stack) & 0xff);
2507         emitcode("mov","sp,a");
2508     }
2509
2510
2511     if ((IS_RENT(sym->etype) || options.stackAuto)) {
2512         if (options.useXstack) {
2513             emitcode("mov","r0,%s",spname);
2514             emitcode("movx","a,@r0");
2515             emitcode("mov","_bp,a");
2516             emitcode("dec","%s",spname);
2517         }
2518         else
2519         {
2520             emitcode ("pop","_bp");
2521         }
2522     }
2523
2524     /* restore the register bank  */
2525     if (SPEC_BANK(sym->etype) || IS_ISR(sym->etype))
2526         emitcode ("pop","psw");
2527
2528     if (IS_ISR(sym->etype)) {
2529
2530         /* now we need to restore the registers */
2531         /* if this isr has no bank i.e. is going to
2532            run with bank 0 , then we need to save more
2533            registers :-) */
2534         if (!SPEC_BANK(sym->etype)) {
2535
2536             /* if this function does not call any other
2537                function then we can be economical and
2538                save only those registers that are used */
2539             if (! sym->hasFcall) {
2540                 int i;
2541
2542                 /* if any registers used */
2543                 if (sym->regsUsed) {
2544                     /* save the registers used */
2545                     for ( i = sym->regsUsed->size ; i >= 0 ; i--) {
2546                         if (bitVectBitValue(sym->regsUsed,i) ||
2547                           (ds390_ptrRegReq && (i == R0_IDX || i == R1_IDX)) )
2548                             emitcode("pop","%s",ds390_regWithIdx(i)->dname);
2549                     }
2550                 }
2551
2552             } else {
2553                 /* this function has  a function call cannot
2554                    determines register usage so we will have the
2555                    entire bank */
2556                 unsaverbank(0,ic,FALSE);
2557             }
2558         }
2559
2560         if (options.model == MODEL_FLAT24 && !inExcludeList("dpx"))
2561         {
2562             if (options.stack10bit)
2563             {
2564             emitcode ("pop", "ap");
2565                 emitcode ("pop", "dpx1");
2566                 emitcode ("pop", "dph1");
2567                 emitcode ("pop", "dpl1");
2568             }
2569             emitcode ("pop", "dps");
2570             emitcode ("pop", "dpx");
2571         }
2572         if (!inExcludeList("dph"))
2573             emitcode ("pop","dph");
2574         if (!inExcludeList("dpl"))
2575             emitcode ("pop","dpl");
2576         if (!inExcludeList("b"))
2577             emitcode ("pop","b");
2578         if (!inExcludeList("acc"))
2579             emitcode ("pop","acc");
2580
2581         if (SPEC_CRTCL(sym->etype))
2582             emitcode("setb","ea");
2583
2584         /* if debug then send end of function */
2585 /*      if (options.debug && currFunc) { */
2586         if (currFunc) {
2587             _G.debugLine = 1;
2588             emitcode("","C$%s$%d$%d$%d ==.",
2589                      ic->filename,currFunc->lastLine,
2590                      ic->level,ic->block);
2591             if (IS_STATIC(currFunc->etype))
2592                 emitcode("","XF%s$%s$0$0 ==.",moduleName,currFunc->name);
2593             else
2594                 emitcode("","XG$%s$0$0 ==.",currFunc->name);
2595             _G.debugLine = 0;
2596         }
2597
2598         emitcode ("reti","");
2599     }
2600     else {
2601         if (SPEC_CRTCL(sym->etype))
2602             emitcode("setb","ea");
2603
2604         if (sym->calleeSave) {
2605             int i;
2606
2607             /* if any registers used */
2608             if (sym->regsUsed) {
2609                 /* save the registers used */
2610                 for ( i = sym->regsUsed->size ; i >= 0 ; i--) {
2611                     if (bitVectBitValue(sym->regsUsed,i) ||
2612                       (ds390_ptrRegReq && (i == R0_IDX || i == R1_IDX)) )
2613                         emitcode("pop","%s",ds390_regWithIdx(i)->dname);
2614                 }
2615             }
2616
2617         }
2618
2619         /* if debug then send end of function */
2620         if (currFunc) {
2621             _G.debugLine = 1;
2622             emitcode("","C$%s$%d$%d$%d ==.",
2623                      ic->filename,currFunc->lastLine,
2624                      ic->level,ic->block);
2625             if (IS_STATIC(currFunc->etype))
2626                 emitcode("","XF%s$%s$0$0 ==.",moduleName,currFunc->name);
2627             else
2628                 emitcode("","XG$%s$0$0 ==.",currFunc->name);
2629             _G.debugLine = 0;
2630         }
2631
2632         emitcode ("ret","");
2633     }
2634
2635 }
2636
2637 /*-----------------------------------------------------------------*/
2638 /* genRet - generate code for return statement                     */
2639 /*-----------------------------------------------------------------*/
2640 static void genRet (iCode *ic)
2641 {
2642     int size,offset = 0 , pushed = 0;
2643
2644     D(emitcode(";", "genRet "););
2645
2646     /* if we have no return value then
2647        just generate the "ret" */
2648     if (!IC_LEFT(ic))
2649         goto jumpret;
2650
2651     /* we have something to return then
2652        move the return value into place */
2653     aopOp(IC_LEFT(ic),ic,FALSE, TRUE);
2654     size = AOP_SIZE(IC_LEFT(ic));
2655
2656     _startLazyDPSEvaluation();
2657     while (size--) {
2658             char *l ;
2659             if (AOP_TYPE(IC_LEFT(ic)) == AOP_DPTR) {
2660                     l = aopGet(AOP(IC_LEFT(ic)),offset++,
2661                            FALSE,TRUE,FALSE);
2662                     emitcode("push","%s",l);
2663                     pushed++;
2664             } else {
2665                     l = aopGet(AOP(IC_LEFT(ic)),offset,
2666                                FALSE,FALSE,FALSE);
2667                     if (strcmp(fReturn[offset],l))
2668                             emitcode("mov","%s,%s",fReturn[offset++],l);
2669             }
2670     }
2671     _endLazyDPSEvaluation();
2672
2673     if (pushed) {
2674         while(pushed) {
2675             pushed--;
2676             if (strcmp(fReturn[pushed],"a"))
2677                 emitcode("pop",fReturn[pushed]);
2678             else
2679                 emitcode("pop","acc");
2680         }
2681     }
2682     freeAsmop (IC_LEFT(ic),NULL,ic,TRUE);
2683
2684  jumpret:
2685         /* generate a jump to the return label
2686            if the next is not the return statement */
2687     if (!(ic->next && ic->next->op == LABEL &&
2688           IC_LABEL(ic->next) == returnLabel))
2689
2690         emitcode("ljmp","%05d$",(returnLabel->key+100));
2691
2692 }
2693
2694 /*-----------------------------------------------------------------*/
2695 /* genLabel - generates a label                                    */
2696 /*-----------------------------------------------------------------*/
2697 static void genLabel (iCode *ic)
2698 {
2699     /* special case never generate */
2700     if (IC_LABEL(ic) == entryLabel)
2701         return ;
2702
2703     D(emitcode(";", "genLabel "););
2704
2705     emitcode("","%05d$:",(IC_LABEL(ic)->key+100));
2706 }
2707
2708 /*-----------------------------------------------------------------*/
2709 /* genGoto - generates a ljmp                                      */
2710 /*-----------------------------------------------------------------*/
2711 static void genGoto (iCode *ic)
2712 {
2713     D(emitcode(";", "genGoto "););
2714     emitcode ("ljmp","%05d$",(IC_LABEL(ic)->key+100));
2715 }
2716
2717 /*-----------------------------------------------------------------*/
2718 /* findLabelBackwards: walks back through the iCode chain looking  */
2719 /* for the given label. Returns number of iCode instructions       */
2720 /* between that label and given ic.                                */
2721 /* Returns zero if label not found.                                */
2722 /*-----------------------------------------------------------------*/
2723 static int findLabelBackwards(iCode *ic, int key)
2724 {
2725     int count = 0;
2726
2727     while (ic->prev)
2728     {
2729         ic = ic->prev;
2730         count++;
2731
2732         if (ic->op == LABEL && IC_LABEL(ic)->key == key)
2733         {
2734             /* printf("findLabelBackwards = %d\n", count); */
2735             return count;
2736         }
2737     }
2738
2739     return 0;
2740 }
2741
2742 /*-----------------------------------------------------------------*/
2743 /* genPlusIncr :- does addition with increment if possible         */
2744 /*-----------------------------------------------------------------*/
2745 static bool genPlusIncr (iCode *ic)
2746 {
2747     unsigned int icount ;
2748     unsigned int size = getDataSize(IC_RESULT(ic));
2749
2750     /* will try to generate an increment */
2751     /* if the right side is not a literal
2752        we cannot */
2753     if (AOP_TYPE(IC_RIGHT(ic)) != AOP_LIT)
2754         return FALSE ;
2755
2756     /* if the literal value of the right hand side
2757        is greater than 4 then it is not worth it */
2758     if ((icount =  floatFromVal (AOP(IC_RIGHT(ic))->aopu.aop_lit)) > 4)
2759         return FALSE ;
2760
2761     /* if increment 16 bits in register */
2762     if (
2763         AOP_TYPE(IC_LEFT(ic)) == AOP_REG &&
2764         AOP_TYPE(IC_RESULT(ic)) == AOP_REG &&
2765         sameRegs(AOP(IC_LEFT(ic)), AOP(IC_RESULT(ic))) &&
2766         (size > 1) &&
2767         (icount == 1)) {
2768         symbol *tlbl;
2769         int emitTlbl;
2770         int labelRange;
2771
2772         /* If the next instruction is a goto and the goto target
2773          * is <= 5 instructions previous to this, we can generate
2774          * jumps straight to that target.
2775          */
2776         if (ic->next && ic->next->op == GOTO
2777             && (labelRange = findLabelBackwards(ic, IC_LABEL(ic->next)->key)) != 0
2778             && labelRange <= 5 )
2779         {
2780            emitcode(";", "tail increment optimized (range %d)", labelRange);
2781            tlbl = IC_LABEL(ic->next);
2782            emitTlbl = 0;
2783         }
2784         else
2785         {
2786             tlbl = newiTempLabel(NULL);
2787             emitTlbl = 1;
2788         }
2789         emitcode("inc","%s",aopGet(AOP(IC_RESULT(ic)),LSB,FALSE,FALSE,FALSE));
2790         if(AOP_TYPE(IC_RESULT(ic)) == AOP_REG ||
2791            IS_AOP_PREG(IC_RESULT(ic)))
2792             emitcode("cjne","%s,#0x00,%05d$"
2793                      ,aopGet(AOP(IC_RESULT(ic)),LSB,FALSE,FALSE,FALSE)
2794                      ,tlbl->key+100);
2795         else {
2796             emitcode("clr","a");
2797             emitcode("cjne","a,%s,%05d$"
2798                      ,aopGet(AOP(IC_RESULT(ic)),LSB,FALSE,FALSE,FALSE)
2799                      ,tlbl->key+100);
2800         }
2801
2802         emitcode("inc","%s",aopGet(AOP(IC_RESULT(ic)),MSB16,FALSE,FALSE,FALSE));
2803         if (size > 2)
2804         {
2805             if(AOP_TYPE(IC_RESULT(ic)) == AOP_REG ||
2806                IS_AOP_PREG(IC_RESULT(ic)))
2807                 emitcode("cjne","%s,#0x00,%05d$"
2808                          ,aopGet(AOP(IC_RESULT(ic)),MSB16,FALSE,FALSE,FALSE)
2809                          ,tlbl->key+100);
2810             else
2811                 emitcode("cjne","a,%s,%05d$"
2812                          ,aopGet(AOP(IC_RESULT(ic)),MSB16,FALSE,FALSE,FALSE)
2813                          ,tlbl->key+100);
2814
2815             emitcode("inc","%s",aopGet(AOP(IC_RESULT(ic)),MSB24,FALSE,FALSE,FALSE));
2816        }
2817        if (size > 3)
2818        {
2819             if(AOP_TYPE(IC_RESULT(ic)) == AOP_REG ||
2820                IS_AOP_PREG(IC_RESULT(ic)))
2821                 emitcode("cjne","%s,#0x00,%05d$"
2822                          ,aopGet(AOP(IC_RESULT(ic)),MSB24,FALSE,FALSE,FALSE)
2823                          ,tlbl->key+100);
2824             else{
2825                 emitcode("cjne","a,%s,%05d$"
2826                          ,aopGet(AOP(IC_RESULT(ic)),MSB24,FALSE,FALSE,FALSE)
2827                          ,tlbl->key+100);
2828             }
2829             emitcode("inc","%s",aopGet(AOP(IC_RESULT(ic)),MSB32,FALSE,FALSE,FALSE));
2830         }
2831
2832         if (emitTlbl)
2833         {
2834             emitcode("","%05d$:",tlbl->key+100);
2835         }
2836         return TRUE;
2837     }
2838
2839     /* if the sizes are greater than 1 then we cannot */
2840     if (AOP_SIZE(IC_RESULT(ic)) > 1 ||
2841         AOP_SIZE(IC_LEFT(ic)) > 1   )
2842         return FALSE ;
2843
2844     /* we can if the aops of the left & result match or
2845        if they are in registers and the registers are the
2846        same */
2847     if (
2848         AOP_TYPE(IC_LEFT(ic)) == AOP_REG &&
2849         AOP_TYPE(IC_RESULT(ic)) == AOP_REG &&
2850         sameRegs(AOP(IC_LEFT(ic)), AOP(IC_RESULT(ic))) ) {
2851
2852         if (icount > 3) {
2853             MOVA(aopGet(AOP(IC_LEFT(ic)),0,FALSE,FALSE,TRUE));
2854             emitcode("add","a,#0x%02x",((char) icount) & 0xff);
2855             aopPut(AOP(IC_RESULT(ic)),"a",0);
2856         } else {
2857
2858             _startLazyDPSEvaluation();
2859             while (icount--)
2860             {
2861                 emitcode ("inc","%s",aopGet(AOP(IC_LEFT(ic)),0,FALSE,FALSE,FALSE));
2862             }
2863             _endLazyDPSEvaluation();
2864         }
2865
2866         return TRUE ;
2867     }
2868
2869     return FALSE ;
2870 }
2871
2872 /*-----------------------------------------------------------------*/
2873 /* outBitAcc - output a bit in acc                                 */
2874 /*-----------------------------------------------------------------*/
2875 static void outBitAcc(operand *result)
2876 {
2877     symbol *tlbl = newiTempLabel(NULL);
2878     /* if the result is a bit */
2879     if (AOP_TYPE(result) == AOP_CRY){
2880         aopPut(AOP(result),"a",0);
2881     }
2882     else {
2883         emitcode("jz","%05d$",tlbl->key+100);
2884         emitcode("mov","a,%s",one);
2885         emitcode("","%05d$:",tlbl->key+100);
2886         outAcc(result);
2887     }
2888 }
2889
2890 /*-----------------------------------------------------------------*/
2891 /* genPlusBits - generates code for addition of two bits           */
2892 /*-----------------------------------------------------------------*/
2893 static void genPlusBits (iCode *ic)
2894 {
2895     D(emitcode(";", "genPlusBits "););
2896     if (AOP_TYPE(IC_RESULT(ic)) == AOP_CRY){
2897         symbol *lbl = newiTempLabel(NULL);
2898         emitcode("mov","c,%s",AOP(IC_LEFT(ic))->aopu.aop_dir);
2899         emitcode("jnb","%s,%05d$",AOP(IC_RIGHT(ic))->aopu.aop_dir,(lbl->key+100));
2900         emitcode("cpl","c");
2901         emitcode("","%05d$:",(lbl->key+100));
2902         outBitC(IC_RESULT(ic));
2903     }
2904     else{
2905         emitcode("clr","a");
2906         emitcode("mov","c,%s",AOP(IC_LEFT(ic))->aopu.aop_dir);
2907         emitcode("rlc","a");
2908         emitcode("mov","c,%s",AOP(IC_RIGHT(ic))->aopu.aop_dir);
2909         emitcode("addc","a,#0x00");
2910         outAcc(IC_RESULT(ic));
2911     }
2912 }
2913
2914 static void adjustArithmeticResult(iCode *ic)
2915 {
2916     if (opIsGptr(IC_RESULT(ic)) &&
2917         opIsGptr(IC_LEFT(ic))   &&
2918         !sameRegs(AOP(IC_RESULT(ic)),AOP(IC_LEFT(ic))))
2919     {
2920         aopPut(AOP(IC_RESULT(ic)),
2921                aopGet(AOP(IC_LEFT(ic)), GPTRSIZE - 1,FALSE,FALSE,FALSE),
2922                GPTRSIZE - 1);
2923     }
2924
2925     if (opIsGptr(IC_RESULT(ic)) &&
2926         opIsGptr(IC_RIGHT(ic))   &&
2927         !sameRegs(AOP(IC_RESULT(ic)),AOP(IC_RIGHT(ic))))
2928     {
2929         aopPut(AOP(IC_RESULT(ic)),
2930                aopGet(AOP(IC_RIGHT(ic)),GPTRSIZE - 1,FALSE,FALSE,FALSE),
2931                GPTRSIZE - 1);
2932     }
2933
2934     if (opIsGptr(IC_RESULT(ic))            &&
2935         AOP_SIZE(IC_LEFT(ic)) < GPTRSIZE   &&
2936         AOP_SIZE(IC_RIGHT(ic)) < GPTRSIZE  &&
2937          !sameRegs(AOP(IC_RESULT(ic)),AOP(IC_LEFT(ic))) &&
2938          !sameRegs(AOP(IC_RESULT(ic)),AOP(IC_RIGHT(ic)))) {
2939          char buffer[5];
2940          sprintf(buffer,"#%d",pointerCode(getSpec(operandType(IC_LEFT(ic)))));
2941          aopPut(AOP(IC_RESULT(ic)),buffer,GPTRSIZE - 1);
2942      }
2943 }
2944
2945 #if 0
2946 #define AOP_OP_3(ic) \
2947     aopOp (IC_LEFT(ic),ic,FALSE, FALSE); \
2948     aopOp (IC_RIGHT(ic),ic,FALSE, TRUE); \
2949     aopOp (IC_RESULT(ic),ic,TRUE, AOP_TYPE(IC_LEFT(ic)) == AOP_DPTR); \
2950     if (AOP_TYPE(IC_RIGHT(ic)) == AOP_DPTR2 && \
2951         AOP_TYPE(IC_RESULT(ic)) == AOP_DPTR2) \
2952     { \
2953         /* werror(E_INTERNAL_ERROR,__FILE__,__LINE__, */ \
2954         fprintf(stderr,                                  \
2955                "Ack: three operands in far space! (%s:%d %s:%d)\n", __FILE__, __LINE__, ic->filename, ic->lineno);   \
2956     }
2957 #else
2958 #define AOP_OP_3(ic) \
2959     aopOp (IC_RIGHT(ic),ic,FALSE, FALSE); \
2960     aopOp (IC_LEFT(ic),ic,FALSE, (AOP_TYPE(IC_RIGHT(ic)) == AOP_DPTR)); \
2961     aopOp (IC_RESULT(ic),ic,TRUE, (AOP_TYPE(IC_LEFT(ic)) == AOP_DPTR) || \
2962                                   (AOP_TYPE(IC_RIGHT(ic)) == AOP_DPTR)); \
2963     if (AOP_TYPE(IC_LEFT(ic)) == AOP_DPTR2 && \
2964         AOP_TYPE(IC_RESULT(ic)) == AOP_DPTR2) \
2965     { \
2966         /* werror(E_INTERNAL_ERROR,__FILE__,__LINE__, */ \
2967         fprintf(stderr,                                  \
2968                "Ack: three operands in far space! (%s:%d %s:%d)\n", __FILE__, __LINE__, ic->filename, ic->lineno);   \
2969     }
2970
2971 #define AOP_OP_3_NOFATAL(ic, rc) \
2972     aopOp (IC_RIGHT(ic),ic,FALSE, FALSE); \
2973     aopOp (IC_LEFT(ic),ic,FALSE, (AOP_TYPE(IC_RIGHT(ic)) == AOP_DPTR)); \
2974     if (AOP_TYPE(IC_LEFT(ic)) == AOP_DPTR2 && \
2975         isOperandInFarSpace(IC_RESULT(ic))) \
2976     { \
2977        /* No can do; DPTR & DPTR2 in use, and we need another. */ \
2978        rc = TRUE; \
2979     }  \
2980     else \
2981     { \
2982        aopOp (IC_RESULT(ic),ic,TRUE, (AOP_TYPE(IC_LEFT(ic)) == AOP_DPTR) || \
2983                                      (AOP_TYPE(IC_RIGHT(ic)) == AOP_DPTR)); \
2984        rc = FALSE; \
2985        if (AOP_TYPE(IC_LEFT(ic)) == AOP_DPTR2 && \
2986            AOP_TYPE(IC_RESULT(ic)) == AOP_DPTR2) \
2987        { \
2988             /* werror(E_INTERNAL_ERROR,__FILE__,__LINE__, */ \
2989             fprintf(stderr,                                  \
2990                     "Ack: got unexpected DP2! (%s:%d %s:%d)\n", __FILE__, __LINE__, ic->filename, ic->lineno);   \
2991        } \
2992     }
2993
2994 #define AOP_OP_2(ic) \
2995     aopOp (IC_RIGHT(ic),ic,FALSE, FALSE); \
2996     aopOp (IC_LEFT(ic),ic,FALSE, (AOP_TYPE(IC_RIGHT(ic)) == AOP_DPTR));
2997
2998 #endif
2999
3000
3001 #define AOP_SET_LOCALS(ic) \
3002     left = IC_LEFT(ic); \
3003     right = IC_RIGHT(ic); \
3004     result = IC_RESULT(ic);
3005
3006 /*-----------------------------------------------------------------*/
3007 /* genPlus - generates code for addition                           */
3008 /*-----------------------------------------------------------------*/
3009 static void genPlus (iCode *ic)
3010 {
3011     int size, offset = 0;
3012     bool pushResult = FALSE;
3013     int  rSize;
3014
3015     D(emitcode(";", "genPlus "););
3016
3017     /* special cases :- */
3018
3019 #if 0
3020     aopOp (IC_RIGHT(ic),ic,FALSE, FALSE);
3021     aopOp (IC_LEFT(ic),ic,FALSE,
3022            (AOP_TYPE(IC_RIGHT(ic)) == AOP_DPTR));
3023     if ((AOP_TYPE(IC_LEFT(ic)) == AOP_DPTR2) &&
3024         (AOP_TYPE(IC_RIGHT(ic)) == AOP_DPTR))
3025     {
3026         pushResult = TRUE;
3027     }
3028     else
3029     {
3030         aopOp (IC_RESULT(ic),ic,TRUE,
3031                ((AOP_TYPE(IC_RIGHT(ic)) == AOP_DPTR)
3032              || (AOP_TYPE(IC_LEFT(ic)) == AOP_DPTR)));
3033     }
3034 #else
3035     AOP_OP_3_NOFATAL(ic, pushResult);
3036     if (pushResult)
3037     {
3038         D(emitcode(";", "genPlus: must push result: 3 ops in far space"););
3039     }
3040 #endif
3041
3042     if (!pushResult)
3043     {
3044     /* if literal, literal on the right or
3045        if left requires ACC or right is already
3046        in ACC */
3047     if ((AOP_TYPE(IC_LEFT(ic)) == AOP_LIT)
3048         || ((AOP_NEEDSACC(IC_LEFT(ic))) && !(AOP_NEEDSACC(IC_RIGHT(ic))))
3049         || AOP_TYPE(IC_RIGHT(ic)) == AOP_ACC )
3050     {
3051         operand *t = IC_RIGHT(ic);
3052         IC_RIGHT(ic) = IC_LEFT(ic);
3053         IC_LEFT(ic) = t;
3054         emitcode(";", "Swapped plus args.");
3055     }
3056
3057     /* if both left & right are in bit
3058     space */
3059     if (AOP_TYPE(IC_LEFT(ic)) == AOP_CRY &&
3060         AOP_TYPE(IC_RIGHT(ic)) == AOP_CRY) {
3061         genPlusBits (ic);
3062         goto release ;
3063     }
3064
3065     /* if left in bit space & right literal */
3066     if (AOP_TYPE(IC_LEFT(ic)) == AOP_CRY &&
3067         AOP_TYPE(IC_RIGHT(ic)) == AOP_LIT) {
3068         emitcode("mov","c,%s",AOP(IC_LEFT(ic))->aopu.aop_dir);
3069         /* if result in bit space */
3070         if(AOP_TYPE(IC_RESULT(ic)) == AOP_CRY){
3071             if((unsigned long)floatFromVal(AOP(IC_RIGHT(ic))->aopu.aop_lit) != 0L)
3072                 emitcode("cpl","c");
3073             outBitC(IC_RESULT(ic));
3074         } else {
3075             size = getDataSize(IC_RESULT(ic));
3076             _startLazyDPSEvaluation();
3077             while (size--) {
3078                 MOVA(aopGet(AOP(IC_RIGHT(ic)),offset,FALSE,FALSE,TRUE));
3079                 emitcode("addc","a,#00");
3080                 aopPut(AOP(IC_RESULT(ic)),"a",offset++);
3081             }
3082             _endLazyDPSEvaluation();
3083         }
3084         goto release ;
3085     }
3086
3087     /* if I can do an increment instead
3088     of add then GOOD for ME */
3089     if (genPlusIncr (ic) == TRUE)
3090     {
3091         emitcode(";", "did genPlusIncr");
3092         goto release;
3093     }
3094
3095     }
3096     size = getDataSize(pushResult ? IC_LEFT(ic) : IC_RESULT(ic));
3097
3098     _startLazyDPSEvaluation();
3099     while(size--)
3100     {
3101         if (AOP_TYPE(IC_LEFT(ic)) == AOP_ACC)
3102         {
3103             MOVA(aopGet(AOP(IC_LEFT(ic)),offset,FALSE,FALSE,TRUE));
3104             if(offset == 0)
3105                 emitcode("add","a,%s",
3106                          aopGet(AOP(IC_RIGHT(ic)),offset,FALSE,FALSE,FALSE));
3107             else
3108                 emitcode("addc","a,%s",
3109                          aopGet(AOP(IC_RIGHT(ic)),offset,FALSE,FALSE,FALSE));
3110         } else {
3111             MOVA(aopGet(AOP(IC_RIGHT(ic)),offset,FALSE,FALSE,TRUE));
3112             if(offset == 0)
3113                 emitcode("add","a,%s",
3114                          aopGet(AOP(IC_LEFT(ic)),offset,FALSE,FALSE,FALSE));
3115             else
3116                 emitcode("addc","a,%s",
3117                          aopGet(AOP(IC_LEFT(ic)),offset,FALSE,FALSE,FALSE));
3118         }
3119         if (!pushResult)
3120         {
3121             aopPut(AOP(IC_RESULT(ic)),"a",offset);
3122         }
3123         else
3124         {
3125             emitcode("push", "acc");
3126         }
3127         offset++;
3128     }
3129     _endLazyDPSEvaluation();
3130
3131     if (pushResult)
3132     {
3133         aopOp (IC_RESULT(ic),ic,TRUE, FALSE);
3134
3135         size = getDataSize(IC_LEFT(ic));
3136         rSize = getDataSize(IC_RESULT(ic));
3137
3138         /* If the pushed data is bigger than the result,
3139          * simply discard unused bytes. Icky, but works.
3140          *
3141          * Should we throw a warning here? We're losing data...
3142          */
3143         while (size > rSize)
3144         {
3145            D(emitcode(";", "discarding unused result byte."););
3146            emitcode("pop", "acc");
3147            size--;
3148            offset--;
3149         }
3150         if (size < rSize)
3151         {
3152             emitcode("clr", "a");
3153             /* Conversly, we haven't pushed enough here.
3154              * just zero-pad, and all is well.
3155              */
3156             while (size < rSize)
3157             {
3158                 emitcode("push", "acc");
3159                 size++;
3160                 offset++;
3161             }
3162         }
3163
3164         _startLazyDPSEvaluation();
3165         while(size--)
3166         {
3167             emitcode("pop", "acc");
3168             aopPut(AOP(IC_RESULT(ic)), "a", --offset);
3169         }
3170         _endLazyDPSEvaluation();
3171     }
3172
3173     adjustArithmeticResult(ic);
3174
3175 release:
3176     freeAsmop(IC_LEFT(ic),NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
3177     freeAsmop(IC_RIGHT(ic),NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
3178     freeAsmop(IC_RESULT(ic),NULL,ic,TRUE);
3179 }
3180
3181 /*-----------------------------------------------------------------*/
3182 /* genMinusDec :- does subtraction with deccrement if possible     */
3183 /*-----------------------------------------------------------------*/
3184 static bool genMinusDec (iCode *ic)
3185 {
3186     unsigned int icount ;
3187     unsigned int size = getDataSize(IC_RESULT(ic));
3188
3189     /* will try to generate an increment */
3190     /* if the right side is not a literal
3191     we cannot */
3192     if (AOP_TYPE(IC_RIGHT(ic)) != AOP_LIT)
3193         return FALSE ;
3194
3195     /* if the literal value of the right hand side
3196     is greater than 4 then it is not worth it */
3197     if ((icount = (unsigned int) floatFromVal (AOP(IC_RIGHT(ic))->aopu.aop_lit)) > 4)
3198         return FALSE ;
3199
3200     /* if decrement 16 bits in register */
3201     if (AOP_TYPE(IC_LEFT(ic)) == AOP_REG &&
3202         AOP_TYPE(IC_RESULT(ic)) == AOP_REG &&
3203         sameRegs(AOP(IC_LEFT(ic)), AOP(IC_RESULT(ic))) &&
3204         (size > 1) &&
3205         (icount == 1)) {
3206             symbol *tlbl;
3207             int emitTlbl;
3208             int labelRange;
3209
3210             /* If the next instruction is a goto and the goto target
3211          * is <= 5 instructions previous to this, we can generate
3212              * jumps straight to that target.
3213              */
3214             if (ic->next && ic->next->op == GOTO
3215                 && (labelRange = findLabelBackwards(ic, IC_LABEL(ic->next)->key)) != 0
3216                 && labelRange <= 5 )
3217             {
3218                emitcode(";", "tail decrement optimized (range %d)", labelRange);
3219                tlbl = IC_LABEL(ic->next);
3220                emitTlbl = 0;
3221             }
3222             else
3223             {
3224                 tlbl = newiTempLabel(NULL);
3225                 emitTlbl = 1;
3226             }
3227
3228                 emitcode("dec","%s",aopGet(AOP(IC_RESULT(ic)),LSB,FALSE,FALSE,FALSE));
3229                 if(AOP_TYPE(IC_RESULT(ic)) == AOP_REG ||
3230                    AOP_TYPE(IC_RESULT(ic)) == AOP_DPTR ||
3231                    IS_AOP_PREG(IC_RESULT(ic)))
3232                         emitcode("cjne","%s,#0xff,%05d$"
3233                                          ,aopGet(AOP(IC_RESULT(ic)),LSB,FALSE,FALSE,FALSE)
3234                                          ,tlbl->key+100);
3235                 else{
3236                         emitcode("mov","a,#0xff");
3237                         emitcode("cjne","a,%s,%05d$"
3238                                          ,aopGet(AOP(IC_RESULT(ic)),LSB,FALSE,FALSE,FALSE)
3239                                          ,tlbl->key+100);
3240                 }
3241                 emitcode("dec","%s",aopGet(AOP(IC_RESULT(ic)),MSB16,FALSE,FALSE,FALSE));
3242                 if (size > 2)
3243                 {
3244                         if(AOP_TYPE(IC_RESULT(ic)) == AOP_REG ||
3245                            AOP_TYPE(IC_RESULT(ic)) == AOP_DPTR ||
3246                            IS_AOP_PREG(IC_RESULT(ic)))
3247                                 emitcode("cjne","%s,#0xff,%05d$"
3248                                                  ,aopGet(AOP(IC_RESULT(ic)),MSB16,FALSE,FALSE,FALSE)
3249                                                  ,tlbl->key+100);
3250                         else{
3251                                 emitcode("cjne","a,%s,%05d$"
3252                                                  ,aopGet(AOP(IC_RESULT(ic)),MSB16,FALSE,FALSE,FALSE)
3253                                                  ,tlbl->key+100);
3254                         }
3255                         emitcode("dec","%s",aopGet(AOP(IC_RESULT(ic)),MSB24,FALSE,FALSE,FALSE));
3256                 }
3257                 if (size > 3)
3258                 {
3259                         if(AOP_TYPE(IC_RESULT(ic)) == AOP_REG ||
3260                            AOP_TYPE(IC_RESULT(ic)) == AOP_DPTR ||
3261                            IS_AOP_PREG(IC_RESULT(ic)))
3262                                 emitcode("cjne","%s,#0xff,%05d$"
3263                                                  ,aopGet(AOP(IC_RESULT(ic)),MSB24,FALSE,FALSE,FALSE)
3264                                                  ,tlbl->key+100);
3265                         else{
3266                                 emitcode("cjne","a,%s,%05d$"
3267                                                  ,aopGet(AOP(IC_RESULT(ic)),MSB24,FALSE,FALSE,FALSE)
3268                                                  ,tlbl->key+100);
3269                         }
3270                         emitcode("dec","%s",aopGet(AOP(IC_RESULT(ic)),MSB32,FALSE,FALSE,FALSE));
3271                 }
3272                 if (emitTlbl)
3273                 {
3274                     emitcode("","%05d$:",tlbl->key+100);
3275                 }
3276         return TRUE;
3277     }
3278
3279     /* if the sizes are greater than 1 then we cannot */
3280     if (AOP_SIZE(IC_RESULT(ic)) > 1 ||
3281         AOP_SIZE(IC_LEFT(ic)) > 1   )
3282         return FALSE ;
3283
3284     /* we can if the aops of the left & result match or
3285     if they are in registers and the registers are the
3286     same */
3287     if (
3288         AOP_TYPE(IC_LEFT(ic)) == AOP_REG &&
3289         AOP_TYPE(IC_RESULT(ic)) == AOP_REG &&
3290         sameRegs(AOP(IC_LEFT(ic)), AOP(IC_RESULT(ic)))) {
3291
3292         _startLazyDPSEvaluation();
3293         while (icount--)
3294         {
3295             emitcode ("dec","%s",aopGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE,FALSE));
3296         }
3297         _endLazyDPSEvaluation();
3298
3299         return TRUE ;
3300     }
3301
3302     return FALSE ;
3303 }
3304
3305 /*-----------------------------------------------------------------*/
3306 /* addSign - complete with sign                                    */
3307 /*-----------------------------------------------------------------*/
3308 static void addSign(operand *result, int offset, int sign)
3309 {
3310     int size = (getDataSize(result) - offset);
3311     if(size > 0){
3312         if(sign){
3313             emitcode("rlc","a");
3314             emitcode("subb","a,acc");
3315             while(size--)
3316                 aopPut(AOP(result),"a",offset++);
3317         } else
3318             while(size--)
3319                 aopPut(AOP(result),zero,offset++);
3320     }
3321 }
3322
3323 /*-----------------------------------------------------------------*/
3324 /* genMinusBits - generates code for subtraction  of two bits      */
3325 /*-----------------------------------------------------------------*/
3326 static void genMinusBits (iCode *ic)
3327 {
3328     symbol *lbl = newiTempLabel(NULL);
3329
3330     D(emitcode(";", "genMinusBits "););
3331
3332     if (AOP_TYPE(IC_RESULT(ic)) == AOP_CRY){
3333         emitcode("mov","c,%s",AOP(IC_LEFT(ic))->aopu.aop_dir);
3334         emitcode("jnb","%s,%05d$",AOP(IC_RIGHT(ic))->aopu.aop_dir,(lbl->key+100));
3335         emitcode("cpl","c");
3336         emitcode("","%05d$:",(lbl->key+100));
3337         outBitC(IC_RESULT(ic));
3338     }
3339     else{
3340         emitcode("mov","c,%s",AOP(IC_RIGHT(ic))->aopu.aop_dir);
3341         emitcode("subb","a,acc");
3342         emitcode("jnb","%s,%05d$",AOP(IC_LEFT(ic))->aopu.aop_dir,(lbl->key+100));
3343         emitcode("inc","a");
3344         emitcode("","%05d$:",(lbl->key+100));
3345         aopPut(AOP(IC_RESULT(ic)),"a",0);
3346         addSign(IC_RESULT(ic), MSB16, SPEC_USIGN(getSpec(operandType(IC_RESULT(ic)))));
3347     }
3348 }
3349
3350 /*-----------------------------------------------------------------*/
3351 /* genMinus - generates code for subtraction                       */
3352 /*-----------------------------------------------------------------*/
3353 static void genMinus (iCode *ic)
3354 {
3355     int size, offset = 0;
3356     int rSize;
3357     unsigned long lit = 0L;
3358     bool pushResult = FALSE;
3359
3360     D(emitcode(";", "genMinus "););
3361
3362     aopOp (IC_LEFT(ic),ic,FALSE, FALSE);
3363     aopOp (IC_RIGHT(ic),ic,FALSE, TRUE);
3364     if ((AOP_TYPE(IC_LEFT(ic)) == AOP_DPTR) &&
3365         (AOP_TYPE(IC_RIGHT(ic)) == AOP_DPTR2))
3366     {
3367         pushResult = TRUE;
3368     }
3369     else
3370     {
3371         aopOp (IC_RESULT(ic),ic,TRUE, AOP_TYPE(IC_LEFT(ic)) == AOP_DPTR);
3372
3373     /* special cases :- */
3374     /* if both left & right are in bit space */
3375     if (AOP_TYPE(IC_LEFT(ic)) == AOP_CRY &&
3376         AOP_TYPE(IC_RIGHT(ic)) == AOP_CRY) {
3377         genMinusBits (ic);
3378         goto release ;
3379     }
3380
3381     /* if I can do an decrement instead
3382     of subtract then GOOD for ME */
3383     if (genMinusDec (ic) == TRUE)
3384         goto release;
3385
3386     }
3387
3388     size = getDataSize(pushResult ? IC_LEFT(ic) : IC_RESULT(ic));
3389
3390     if (AOP_TYPE(IC_RIGHT(ic)) != AOP_LIT){
3391         CLRC;
3392     }
3393     else{
3394         lit = (unsigned long)floatFromVal(AOP(IC_RIGHT(ic))->aopu.aop_lit);
3395         lit = - (long)lit;
3396     }
3397
3398
3399     /* if literal, add a,#-lit, else normal subb */
3400     _startLazyDPSEvaluation();
3401     while (size--) {
3402         MOVA(aopGet(AOP(IC_LEFT(ic)),offset,FALSE,FALSE,TRUE));
3403         if (AOP_TYPE(IC_RIGHT(ic)) != AOP_LIT)
3404             emitcode("subb","a,%s",
3405                      aopGet(AOP(IC_RIGHT(ic)),offset,FALSE,FALSE,FALSE));
3406         else{
3407             /* first add without previous c */
3408             if(!offset)
3409                 emitcode("add","a,#0x%02x",
3410                          (unsigned int)(lit & 0x0FFL));
3411             else
3412                 emitcode("addc","a,#0x%02x",
3413                          (unsigned int)((lit >> (offset*8)) & 0x0FFL));
3414         }
3415
3416         if (pushResult)
3417         {
3418             emitcode("push", "acc");
3419         }
3420         else
3421         {
3422             aopPut(AOP(IC_RESULT(ic)),"a",offset);
3423         }
3424         offset++;
3425     }
3426     _endLazyDPSEvaluation();
3427
3428     if (pushResult)
3429     {
3430         aopOp (IC_RESULT(ic),ic,TRUE, FALSE);
3431
3432         size = getDataSize(IC_LEFT(ic));
3433         rSize = getDataSize(IC_RESULT(ic));
3434
3435         /* If the pushed data is bigger than the result,
3436          * simply discard unused bytes. Icky, but works.
3437          *
3438          * Should we throw a warning here? We're losing data...
3439          */
3440         while (size > getDataSize(IC_RESULT(ic)))
3441         {
3442            emitcode(";", "discarding unused result byte.");
3443            emitcode("pop", "acc");
3444            size--;
3445            offset--;
3446         }
3447         if (size < rSize)
3448         {
3449             emitcode("clr", "a");
3450             /* Conversly, we haven't pushed enough here.
3451              * just zero-pad, and all is well.
3452              */
3453             while (size < rSize)
3454             {
3455                 emitcode("push", "acc");
3456                 size++;
3457                 offset++;
3458             }
3459         }
3460
3461         while(size--)
3462         {
3463             emitcode("pop", "acc");
3464             aopPut(AOP(IC_RESULT(ic)), "a", --offset);
3465         }
3466     }
3467
3468     adjustArithmeticResult(ic);
3469
3470 release:
3471     freeAsmop(IC_LEFT(ic),NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
3472     freeAsmop(IC_RIGHT(ic),NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
3473     freeAsmop(IC_RESULT(ic),NULL,ic,TRUE);
3474 }
3475
3476
3477 /*-----------------------------------------------------------------*/
3478 /* genMultbits :- multiplication of bits                           */
3479 /*-----------------------------------------------------------------*/
3480 static void genMultbits (operand *left,
3481                          operand *right,
3482                          operand *result)
3483 {
3484     emitcode("mov","c,%s",AOP(left)->aopu.aop_dir);
3485     emitcode("anl","c,%s",AOP(right)->aopu.aop_dir);
3486     outBitC(result);
3487 }
3488
3489
3490 /*-----------------------------------------------------------------*/
3491 /* genMultOneByte : 8 bit multiplication & division                */
3492 /*-----------------------------------------------------------------*/
3493 static void genMultOneByte (operand *left,
3494                             operand *right,
3495                             operand *result)
3496 {
3497     sym_link *opetype = operandType(result);
3498     char *l ;
3499     symbol *lbl ;
3500     int size,offset;
3501
3502     /* (if two literals, the value is computed before) */
3503     /* if one literal, literal on the right */
3504     if (AOP_TYPE(left) == AOP_LIT){
3505         operand *t = right;
3506         right = left;
3507         left = t;
3508     }
3509
3510     size = AOP_SIZE(result);
3511     /* signed or unsigned */
3512     emitcode("mov","b,%s", aopGet(AOP(right),0,FALSE,FALSE,FALSE));
3513     l = aopGet(AOP(left),0,FALSE,FALSE,TRUE);
3514     MOVA(l);
3515     emitcode("mul","ab");
3516     /* if result size = 1, mul signed = mul unsigned */
3517     aopPut(AOP(result),"a",0);
3518     if (size > 1){
3519         if (SPEC_USIGN(opetype)){
3520             aopPut(AOP(result),"b",1);
3521             if (size > 2)
3522                 /* for filling the MSBs */
3523                 emitcode("clr","a");
3524         }
3525         else{
3526             emitcode("mov","a,b");
3527
3528             /* adjust the MSB if left or right neg */
3529
3530             /* if one literal */
3531             if (AOP_TYPE(right) == AOP_LIT){
3532                 /* AND literal negative */
3533                 if((int) floatFromVal (AOP(right)->aopu.aop_lit) < 0){
3534                     /* adjust MSB (c==0 after mul) */
3535                     emitcode("subb","a,%s", aopGet(AOP(left),0,FALSE,FALSE,FALSE));
3536                 }
3537             }
3538             else{
3539                 lbl = newiTempLabel(NULL);
3540                 emitcode("xch","a,%s",aopGet(AOP(right),0,FALSE,FALSE,FALSE));
3541                 emitcode("cjne","a,#0x80,%05d$", (lbl->key+100));
3542                 emitcode("","%05d$:",(lbl->key+100));
3543                 emitcode("xch","a,%s",aopGet(AOP(right),0,FALSE,FALSE,FALSE));
3544                 lbl = newiTempLabel(NULL);
3545                 emitcode("jc","%05d$",(lbl->key+100));
3546                 emitcode("subb","a,%s", aopGet(AOP(left),0,FALSE,FALSE,FALSE));
3547                 emitcode("","%05d$:",(lbl->key+100));
3548             }
3549
3550             lbl = newiTempLabel(NULL);
3551             emitcode("xch","a,%s",aopGet(AOP(left),0,FALSE,FALSE,FALSE));
3552             emitcode("cjne","a,#0x80,%05d$", (lbl->key+100));
3553             emitcode("","%05d$:",(lbl->key+100));
3554             emitcode("xch","a,%s",aopGet(AOP(left),0,FALSE,FALSE,FALSE));
3555             lbl = newiTempLabel(NULL);
3556             emitcode("jc","%05d$",(lbl->key+100));
3557             emitcode("subb","a,%s", aopGet(AOP(right),0,FALSE,FALSE,FALSE));
3558             emitcode("","%05d$:",(lbl->key+100));
3559
3560             aopPut(AOP(result),"a",1);
3561             if(size > 2){
3562                 /* get the sign */
3563                 emitcode("rlc","a");
3564                 emitcode("subb","a,acc");
3565             }
3566         }
3567         size -= 2;
3568         offset = 2;
3569         if (size > 0)
3570             while (size--)
3571                 aopPut(AOP(result),"a",offset++);
3572     }
3573 }
3574
3575 /*-----------------------------------------------------------------*/
3576 /* genMult - generates code for multiplication                     */
3577 /*-----------------------------------------------------------------*/
3578 static void genMult (iCode *ic)
3579 {
3580     operand *left = IC_LEFT(ic);
3581     operand *right = IC_RIGHT(ic);
3582     operand *result= IC_RESULT(ic);
3583
3584     D(emitcode(";", "genMult "););
3585
3586     /* assign the amsops */
3587     AOP_OP_3(ic);
3588 #if 0
3589     aopOp (left,ic,FALSE, FALSE);
3590     aopOp (right,ic,FALSE, TRUE);
3591     aopOp (result,ic,TRUE, FALSE);
3592 #endif
3593
3594     /* special cases first */
3595     /* both are bits */
3596     if (AOP_TYPE(left) == AOP_CRY &&
3597         AOP_TYPE(right)== AOP_CRY) {
3598         genMultbits(left,right,result);
3599         goto release ;
3600     }
3601
3602     /* if both are of size == 1 */
3603     if (AOP_SIZE(left) == 1 &&
3604         AOP_SIZE(right) == 1 ) {
3605         genMultOneByte(left,right,result);
3606         goto release ;
3607     }
3608
3609     /* should have been converted to function call */
3610     assert(1) ;
3611
3612 release :
3613     freeAsmop(left,NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
3614     freeAsmop(right,NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
3615     freeAsmop(result,NULL,ic,TRUE);
3616 }
3617
3618 /*-----------------------------------------------------------------*/
3619 /* genDivbits :- division of bits                                  */
3620 /*-----------------------------------------------------------------*/
3621 static void genDivbits (operand *left,
3622                         operand *right,
3623                         operand *result)
3624 {
3625
3626     char *l;
3627
3628     /* the result must be bit */
3629     LOAD_AB_FOR_DIV(left, right, l);
3630     emitcode("div","ab");
3631     emitcode("rrc","a");
3632     aopPut(AOP(result),"c",0);
3633 }
3634
3635 /*-----------------------------------------------------------------*/
3636 /* genDivOneByte : 8 bit division                                  */
3637 /*-----------------------------------------------------------------*/
3638 static void genDivOneByte (operand *left,
3639                            operand *right,
3640                            operand *result)
3641 {
3642     sym_link *opetype = operandType(result);
3643     char *l ;
3644     symbol *lbl ;
3645     int size,offset;
3646
3647     size = AOP_SIZE(result) - 1;
3648     offset = 1;
3649     /* signed or unsigned */
3650     if (SPEC_USIGN(opetype)) {
3651         /* unsigned is easy */
3652         LOAD_AB_FOR_DIV(left, right, l);
3653         emitcode("div","ab");
3654         aopPut(AOP(result),"a",0);
3655         while (size--)
3656             aopPut(AOP(result),zero,offset++);
3657         return ;
3658     }
3659
3660     /* signed is a little bit more difficult */
3661
3662     /* save the signs of the operands */
3663     l = aopGet(AOP(left),0,FALSE,FALSE,TRUE);
3664     MOVA(l);
3665     emitcode("xrl","a,%s",aopGet(AOP(right),0,FALSE,TRUE,FALSE));
3666     emitcode("push","acc"); /* save it on the stack */
3667
3668     /* now sign adjust for both left & right */
3669     l =  aopGet(AOP(right),0,FALSE,FALSE,TRUE);
3670     MOVA(l);
3671     lbl = newiTempLabel(NULL);
3672     emitcode("jnb","acc.7,%05d$",(lbl->key+100));
3673     emitcode("cpl","a");
3674     emitcode("inc","a");
3675     emitcode("","%05d$:",(lbl->key+100));
3676     emitcode("mov","b,a");
3677
3678     /* sign adjust left side */
3679     l =  aopGet(AOP(left),0,FALSE,FALSE,TRUE);
3680     MOVA(l);
3681
3682     lbl = newiTempLabel(NULL);
3683     emitcode("jnb","acc.7,%05d$",(lbl->key+100));
3684     emitcode("cpl","a");
3685     emitcode("inc","a");
3686     emitcode("","%05d$:",(lbl->key+100));
3687
3688     /* now the division */
3689     emitcode("nop", "; workaround for DS80C390 div bug.");
3690     emitcode("div","ab");
3691     /* we are interested in the lower order
3692     only */
3693     emitcode("mov","b,a");
3694     lbl = newiTempLabel(NULL);
3695     emitcode("pop","acc");
3696     /* if there was an over flow we don't
3697     adjust the sign of the result */
3698     emitcode("jb","ov,%05d$",(lbl->key+100));
3699     emitcode("jnb","acc.7,%05d$",(lbl->key+100));
3700     CLRC;
3701     emitcode("clr","a");
3702     emitcode("subb","a,b");
3703     emitcode("mov","b,a");
3704     emitcode("","%05d$:",(lbl->key+100));
3705
3706     /* now we are done */
3707     aopPut(AOP(result),"b",0);
3708     if(size > 0){
3709         emitcode("mov","c,b.7");
3710         emitcode("subb","a,acc");
3711     }
3712     while (size--)
3713         aopPut(AOP(result),"a",offset++);
3714
3715 }
3716
3717 /*-----------------------------------------------------------------*/
3718 /* genDiv - generates code for division                            */
3719 /*-----------------------------------------------------------------*/
3720 static void genDiv (iCode *ic)
3721 {
3722     operand *left = IC_LEFT(ic);
3723     operand *right = IC_RIGHT(ic);
3724     operand *result= IC_RESULT(ic);
3725
3726     D(emitcode(";", "genDiv "););
3727
3728     /* assign the amsops */
3729     AOP_OP_3(ic);
3730 #if 0
3731     aopOp (left,ic,FALSE, FALSE);
3732     aopOp (right,ic,FALSE, TRUE);
3733     aopOp (result,ic,TRUE, FALSE);
3734 #endif
3735
3736     /* special cases first */
3737     /* both are bits */
3738     if (AOP_TYPE(left) == AOP_CRY &&
3739         AOP_TYPE(right)== AOP_CRY) {
3740         genDivbits(left,right,result);
3741         goto release ;
3742     }
3743
3744     /* if both are of size == 1 */
3745     if (AOP_SIZE(left) == 1 &&
3746         AOP_SIZE(right) == 1 ) {
3747         genDivOneByte(left,right,result);
3748         goto release ;
3749     }
3750
3751     /* should have been converted to function call */
3752     assert(1);
3753 release :
3754     freeAsmop(left,NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
3755     freeAsmop(right,NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
3756     freeAsmop(result,NULL,ic,TRUE);
3757 }
3758
3759 /*-----------------------------------------------------------------*/
3760 /* genModbits :- modulus of bits                                   */
3761 /*-----------------------------------------------------------------*/
3762 static void genModbits (operand *left,
3763                         operand *right,
3764                         operand *result)
3765 {
3766
3767     char *l;
3768
3769     /* the result must be bit */
3770     LOAD_AB_FOR_DIV(left, right, l);
3771     emitcode("div","ab");
3772     emitcode("mov","a,b");
3773     emitcode("rrc","a");
3774     aopPut(AOP(result),"c",0);
3775 }
3776
3777 /*-----------------------------------------------------------------*/
3778 /* genModOneByte : 8 bit modulus                                   */
3779 /*-----------------------------------------------------------------*/
3780 static void genModOneByte (operand *left,
3781                            operand *right,
3782                            operand *result)
3783 {
3784     sym_link *opetype = operandType(result);
3785     char *l ;
3786     symbol *lbl ;
3787
3788     /* signed or unsigned */
3789     if (SPEC_USIGN(opetype)) {
3790         /* unsigned is easy */
3791         LOAD_AB_FOR_DIV(left, right, l);
3792         emitcode("div","ab");
3793         aopPut(AOP(result),"b",0);
3794         return ;
3795     }
3796
3797     /* signed is a little bit more difficult */
3798
3799     /* save the signs of the operands */
3800     l = aopGet(AOP(left),0,FALSE,FALSE,TRUE);
3801     MOVA(l);
3802
3803     emitcode("xrl","a,%s",aopGet(AOP(right),0,FALSE,FALSE,FALSE));
3804     emitcode("push","acc"); /* save it on the stack */
3805
3806     /* now sign adjust for both left & right */
3807     l =  aopGet(AOP(right),0,FALSE,FALSE,TRUE);
3808     MOVA(l);
3809
3810     lbl = newiTempLabel(NULL);
3811     emitcode("jnb","acc.7,%05d$",(lbl->key+100));
3812     emitcode("cpl","a");
3813     emitcode("inc","a");
3814     emitcode("","%05d$:",(lbl->key+100));
3815     emitcode("mov","b,a");
3816
3817     /* sign adjust left side */
3818     l =  aopGet(AOP(left),0,FALSE,FALSE,TRUE);
3819     MOVA(l);
3820
3821     lbl = newiTempLabel(NULL);
3822     emitcode("jnb","acc.7,%05d$",(lbl->key+100));
3823     emitcode("cpl","a");
3824     emitcode("inc","a");
3825     emitcode("","%05d$:",(lbl->key+100));
3826
3827     /* now the multiplication */
3828     emitcode("nop", "; workaround for DS80C390 div bug.");
3829     emitcode("div","ab");
3830     /* we are interested in the lower order
3831     only */
3832     lbl = newiTempLabel(NULL);
3833     emitcode("pop","acc");
3834     /* if there was an over flow we don't
3835     adjust the sign of the result */
3836     emitcode("jb","ov,%05d$",(lbl->key+100));
3837     emitcode("jnb","acc.7,%05d$",(lbl->key+100));
3838     CLRC ;
3839     emitcode("clr","a");
3840     emitcode("subb","a,b");
3841     emitcode("mov","b,a");
3842     emitcode("","%05d$:",(lbl->key+100));
3843
3844     /* now we are done */
3845     aopPut(AOP(result),"b",0);
3846
3847 }
3848
3849 /*-----------------------------------------------------------------*/
3850 /* genMod - generates code for division                            */
3851 /*-----------------------------------------------------------------*/
3852 static void genMod (iCode *ic)
3853 {
3854     operand *left = IC_LEFT(ic);
3855     operand *right = IC_RIGHT(ic);
3856     operand *result= IC_RESULT(ic);
3857
3858     D(emitcode(";", "genMod "););
3859
3860     /* assign the amsops */
3861     AOP_OP_3(ic);
3862 #if 0
3863     aopOp (left,ic,FALSE, FALSE);
3864     aopOp (right,ic,FALSE, TRUE);
3865     aopOp (result,ic,TRUE, FALSE);
3866 #endif
3867
3868     /* special cases first */
3869     /* both are bits */
3870     if (AOP_TYPE(left) == AOP_CRY &&
3871         AOP_TYPE(right)== AOP_CRY) {
3872         genModbits(left,right,result);
3873         goto release ;
3874     }
3875
3876     /* if both are of size == 1 */
3877     if (AOP_SIZE(left) == 1 &&
3878         AOP_SIZE(right) == 1 ) {
3879         genModOneByte(left,right,result);
3880         goto release ;
3881     }
3882
3883     /* should have been converted to function call */
3884     assert(1);
3885
3886 release :
3887     freeAsmop(left,NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
3888     freeAsmop(right,NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
3889     freeAsmop(result,NULL,ic,TRUE);
3890 }
3891
3892 /*-----------------------------------------------------------------*/
3893 /* genIfxJump :- will create a jump depending on the ifx           */
3894 /*-----------------------------------------------------------------*/
3895 static void genIfxJump (iCode *ic, char *jval)
3896 {
3897     symbol *jlbl ;
3898     symbol *tlbl = newiTempLabel(NULL);
3899     char *inst;
3900
3901     D(emitcode(";", "genIfxJump "););
3902
3903     /* if true label then we jump if condition
3904     supplied is true */
3905     if ( IC_TRUE(ic) ) {
3906         jlbl = IC_TRUE(ic);
3907         inst = ((strcmp(jval,"a") == 0 ? "jz" :
3908                  (strcmp(jval,"c") == 0 ? "jnc" : "jnb" )));
3909     }
3910     else {
3911         /* false label is present */
3912         jlbl = IC_FALSE(ic) ;
3913         inst = ((strcmp(jval,"a") == 0 ? "jnz" :
3914                  (strcmp(jval,"c") == 0 ? "jc" : "jb" )));
3915     }
3916     if (strcmp(inst,"jb") == 0 || strcmp(inst,"jnb") == 0)
3917         emitcode(inst,"%s,%05d$",jval,(tlbl->key+100));
3918     else
3919         emitcode(inst,"%05d$",tlbl->key+100);
3920     emitcode("ljmp","%05d$",jlbl->key+100);
3921     emitcode("","%05d$:",tlbl->key+100);
3922
3923     /* mark the icode as generated */
3924     ic->generated = 1;
3925 }
3926
3927 /*-----------------------------------------------------------------*/
3928 /* genCmp :- greater or less than comparison                       */
3929 /*-----------------------------------------------------------------*/
3930 static void genCmp (operand *left,operand *right,
3931                     iCode *ic, iCode *ifx, int sign)
3932 {
3933     int                 size, offset = 0 ;
3934     unsigned long       lit = 0L;
3935     operand             *result;
3936
3937     D(emitcode(";", "genCmp"););
3938
3939     result = IC_RESULT(ic);
3940
3941     /* if left & right are bit variables */
3942     if (AOP_TYPE(left) == AOP_CRY &&
3943         AOP_TYPE(right) == AOP_CRY ) {
3944         emitcode("mov","c,%s",AOP(right)->aopu.aop_dir);
3945         emitcode("anl","c,/%s",AOP(left)->aopu.aop_dir);
3946     } else {
3947         /* subtract right from left if at the
3948         end the carry flag is set then we know that
3949         left is greater than right */
3950         size = max(AOP_SIZE(left),AOP_SIZE(right));
3951
3952         /* if unsigned char cmp with lit, do cjne left,#right,zz */
3953         if((size == 1) && !sign &&
3954            (AOP_TYPE(right) == AOP_LIT && AOP_TYPE(left) != AOP_DIR )){
3955             symbol *lbl  = newiTempLabel(NULL);
3956             emitcode("cjne","%s,%s,%05d$",
3957                      aopGet(AOP(left),offset,FALSE,FALSE,FALSE),
3958                      aopGet(AOP(right),offset,FALSE,FALSE,FALSE),
3959                      lbl->key+100);
3960             emitcode("","%05d$:",lbl->key+100);
3961         } else {
3962             if (AOP_TYPE(right) == AOP_LIT)
3963             {
3964                 lit = (unsigned long)floatFromVal(AOP(right)->aopu.aop_lit);
3965                 /* optimize if(x < 0) or if(x >= 0) */
3966                 if(lit == 0L)
3967                 {
3968                     if(!sign)
3969                     {
3970                         CLRC;
3971                     }
3972                     else
3973                     {
3974                         MOVA(aopGet(AOP(left),AOP_SIZE(left)-1,FALSE,FALSE,TRUE));
3975
3976                         freeAsmop(left,NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
3977                         freeAsmop(right,NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
3978
3979                         aopOp(result,ic,FALSE, FALSE);
3980
3981                         if(!(AOP_TYPE(result) == AOP_CRY && AOP_SIZE(result)) && ifx)
3982                         {
3983                             freeAsmop(result,NULL,ic,TRUE);
3984                             genIfxJump (ifx,"acc.7");
3985                             return;
3986                         }
3987                         else
3988                         {
3989                             emitcode("rlc","a");
3990                         }
3991                         goto release_freedLR;
3992                     }
3993                     goto release;
3994                 }
3995             }
3996             CLRC;
3997             while (size--)
3998             {
3999                 emitcode(";", "genCmp #1: %d/%d/%d", size, sign, offset);
4000                 MOVA(aopGet(AOP(left),offset,FALSE,FALSE,TRUE));
4001                 emitcode(";", "genCmp #2");
4002                 if (sign && (size == 0))
4003                 {
4004                     emitcode(";", "genCmp #3");
4005                     emitcode("xrl","a,#0x80");
4006                     if (AOP_TYPE(right) == AOP_LIT)
4007                     {
4008                         unsigned long lit = (unsigned long)
4009                             floatFromVal(AOP(right)->aopu.aop_lit);
4010                         emitcode(";", "genCmp #3.1");
4011                         emitcode("subb","a,#0x%02x",
4012                             0x80 ^ (unsigned int)((lit >> (offset*8)) & 0x0FFL));
4013                     }
4014                     else
4015                     {
4016                         emitcode(";", "genCmp #3.2");
4017                         if (AOP_NEEDSACC(right))
4018                         {
4019                             emitcode("push", "acc");
4020                         }
4021                         emitcode("mov","b,%s",aopGet(AOP(right),offset++,
4022                                   FALSE,FALSE,FALSE));
4023                         emitcode("xrl","b,#0x80");
4024                         if (AOP_NEEDSACC(right))
4025                         {
4026                             emitcode("pop", "acc");
4027                         }
4028                         emitcode("subb","a,b");
4029                     }
4030                 }
4031                 else
4032                 {
4033                     const char *s;
4034
4035                     emitcode(";", "genCmp #4");
4036                     if (AOP_NEEDSACC(right))
4037                     {
4038                         /* Yuck!! */
4039                         emitcode(";", "genCmp #4.1");
4040                         emitcode("xch", "a, b");
4041                         MOVA(aopGet(AOP(right),offset++,FALSE,FALSE,TRUE));
4042                         emitcode("xch", "a, b");
4043                         s = "b";
4044                     }
4045                     else
4046                     {
4047                         emitcode(";", "genCmp #4.2");
4048                         s = aopGet(AOP(right),offset++,FALSE,FALSE,FALSE);
4049                     }
4050
4051                     emitcode("subb","a,%s",s);
4052                 }
4053             }
4054         }
4055     }
4056
4057 release:
4058 /* Don't need the left & right operands any more; do need the result. */
4059     freeAsmop(left,NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
4060     freeAsmop(right,NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
4061
4062     aopOp(result,ic,FALSE, FALSE);
4063
4064 release_freedLR:
4065
4066     if (AOP_TYPE(result) == AOP_CRY && AOP_SIZE(result))
4067     {
4068         outBitC(result);
4069     }
4070     else
4071     {
4072         /* if the result is used in the next
4073         ifx conditional branch then generate
4074         code a little differently */
4075         if (ifx )
4076         {
4077             genIfxJump (ifx,"c");
4078         }
4079         else
4080         {
4081             outBitC(result);
4082         }
4083         /* leave the result in acc */
4084     }
4085     freeAsmop(result,NULL,ic,TRUE);
4086 }
4087
4088 /*-----------------------------------------------------------------*/
4089 /* genCmpGt :- greater than comparison                             */
4090 /*-----------------------------------------------------------------*/
4091 static void genCmpGt (iCode *ic, iCode *ifx)
4092 {
4093     operand *left, *right;
4094     sym_link *letype , *retype;
4095     int sign ;
4096
4097     D(emitcode(";", "genCmpGt "););
4098
4099     left = IC_LEFT(ic);
4100     right= IC_RIGHT(ic);
4101
4102     letype = getSpec(operandType(left));
4103     retype =getSpec(operandType(right));
4104     sign =  !(SPEC_USIGN(letype) | SPEC_USIGN(retype));
4105
4106     /* assign the left & right amsops */
4107     AOP_OP_2(ic);
4108
4109     genCmp(right, left, ic, ifx, sign);
4110 }
4111
4112 /*-----------------------------------------------------------------*/
4113 /* genCmpLt - less than comparisons                                */
4114 /*-----------------------------------------------------------------*/
4115 static void genCmpLt (iCode *ic, iCode *ifx)
4116 {
4117     operand *left, *right;
4118     sym_link *letype , *retype;
4119     int sign ;
4120
4121     D(emitcode(";", "genCmpLt "););
4122
4123     left = IC_LEFT(ic);
4124     right= IC_RIGHT(ic);
4125
4126     letype = getSpec(operandType(left));
4127     retype =getSpec(operandType(right));
4128     sign =  !(SPEC_USIGN(letype) | SPEC_USIGN(retype));
4129
4130     /* assign the left & right amsops */
4131     AOP_OP_2(ic);
4132
4133     genCmp(left, right, ic, ifx, sign);
4134 }
4135
4136 /*-----------------------------------------------------------------*/
4137 /* gencjneshort - compare and jump if not equal                    */
4138 /*-----------------------------------------------------------------*/
4139 static void gencjneshort(operand *left, operand *right, symbol *lbl)
4140 {
4141     int size = max(AOP_SIZE(left),AOP_SIZE(right));
4142     int offset = 0;
4143     unsigned long lit = 0L;
4144
4145     D(emitcode(";", "gencjneshort"););
4146
4147     /* if the left side is a literal or
4148     if the right is in a pointer register and left
4149     is not */
4150     if ((AOP_TYPE(left) == AOP_LIT) ||
4151         (IS_AOP_PREG(right) && !IS_AOP_PREG(left))) {
4152         operand *t = right;
4153         right = left;
4154         left = t;
4155     }
4156
4157     if(AOP_TYPE(right) == AOP_LIT)
4158         lit = (unsigned long)floatFromVal(AOP(right)->aopu.aop_lit);
4159
4160     if (opIsGptr(left) || opIsGptr(right))
4161     {
4162         /* We are comparing a generic pointer to something.
4163          * Exclude the generic type byte from the comparison.
4164          */
4165         size--;
4166         D(emitcode(";", "cjneshort: generic ptr special case.");)
4167     }
4168
4169
4170     /* if the right side is a literal then anything goes */
4171     if (AOP_TYPE(right) == AOP_LIT &&
4172         AOP_TYPE(left) != AOP_DIR ) {
4173         while (size--) {
4174             char *l = aopGet(AOP(left), offset, FALSE, FALSE,TRUE);
4175             MOVA(l);
4176             emitcode("cjne","a,%s,%05d$",
4177                      aopGet(AOP(right),offset,FALSE,FALSE,FALSE),
4178                      lbl->key+100);
4179             offset++;
4180         }
4181     }
4182
4183     /* if the right side is in a register or in direct space or
4184     if the left is a pointer register & right is not */
4185     else if (AOP_TYPE(right) == AOP_REG ||
4186              AOP_TYPE(right) == AOP_DIR ||
4187              (AOP_TYPE(left) == AOP_DIR && AOP_TYPE(right) == AOP_LIT) ||
4188              (IS_AOP_PREG(left) && !IS_AOP_PREG(right)))
4189     {
4190         while (size--)
4191         {
4192             MOVA(aopGet(AOP(left),offset,FALSE,FALSE,TRUE));
4193             if((AOP_TYPE(left) == AOP_DIR && AOP_TYPE(right) == AOP_LIT) &&
4194                ((unsigned int)((lit >> (offset*8)) & 0x0FFL) == 0))
4195                 emitcode("jnz","%05d$",lbl->key+100);
4196             else
4197                 emitcode("cjne","a,%s,%05d$",
4198                          aopGet(AOP(right),offset,FALSE,TRUE,FALSE),
4199                          lbl->key+100);
4200             offset++;
4201         }
4202     } else {
4203         /* right is a pointer reg need both a & b */
4204         while(size--) {
4205             char *l = aopGet(AOP(left),offset,FALSE,FALSE,TRUE);
4206             if(strcmp(l,"b"))
4207                 emitcode("mov","b,%s",l);
4208             MOVA(aopGet(AOP(right),offset,FALSE,FALSE,TRUE));
4209             emitcode("cjne","a,b,%05d$",lbl->key+100);
4210             offset++;
4211         }
4212     }
4213 }
4214
4215 /*-----------------------------------------------------------------*/
4216 /* gencjne - compare and jump if not equal                         */
4217 /*-----------------------------------------------------------------*/
4218 static void gencjne(operand *left, operand *right, symbol *lbl)
4219 {
4220     symbol *tlbl  = newiTempLabel(NULL);
4221
4222     D(emitcode(";", "gencjne"););
4223
4224     gencjneshort(left, right, lbl);
4225
4226     emitcode("mov","a,%s",one);
4227     emitcode("sjmp","%05d$",tlbl->key+100);
4228     emitcode("","%05d$:",lbl->key+100);
4229     emitcode("clr","a");
4230     emitcode("","%05d$:",tlbl->key+100);
4231 }
4232
4233 /*-----------------------------------------------------------------*/
4234 /* genCmpEq - generates code for equal to                          */
4235 /*-----------------------------------------------------------------*/
4236 static void genCmpEq (iCode *ic, iCode *ifx)
4237 {
4238     operand *left, *right, *result;
4239
4240     D(emitcode(";", "genCmpEq "););
4241
4242     AOP_OP_2(ic);
4243     AOP_SET_LOCALS(ic);
4244 #if 0
4245     aopOp((left=IC_LEFT(ic)),ic,FALSE, FALSE);
4246     aopOp((right=IC_RIGHT(ic)),ic,FALSE, TRUE);
4247     aopOp((result=IC_RESULT(ic)),ic,TRUE, FALSE);
4248 #endif
4249
4250     /* if literal, literal on the right or
4251     if the right is in a pointer register and left
4252     is not */
4253     if ((AOP_TYPE(IC_LEFT(ic)) == AOP_LIT) ||
4254         (IS_AOP_PREG(right) && !IS_AOP_PREG(left))) {
4255         operand *t = IC_RIGHT(ic);
4256         IC_RIGHT(ic) = IC_LEFT(ic);
4257         IC_LEFT(ic) = t;
4258     }
4259
4260     if (ifx && /* !AOP_SIZE(result) */
4261        OP_SYMBOL(result) &&
4262        OP_SYMBOL(result)->regType == REG_CND)
4263     {
4264         symbol *tlbl;
4265         /* if they are both bit variables */
4266         if (AOP_TYPE(left) == AOP_CRY &&
4267             ((AOP_TYPE(right) == AOP_CRY) || (AOP_TYPE(right) == AOP_LIT))) {
4268             if(AOP_TYPE(right) == AOP_LIT){
4269                 unsigned long lit = (unsigned long)floatFromVal(AOP(IC_RIGHT(ic))->aopu.aop_lit);
4270                 if(lit == 0L){
4271                     emitcode("mov","c,%s",AOP(left)->aopu.aop_dir);
4272                     emitcode("cpl","c");
4273                 } else if(lit == 1L) {
4274                     emitcode("mov","c,%s",AOP(left)->aopu.aop_dir);
4275                 } else {
4276                     emitcode("clr","c");
4277                 }
4278                 /* AOP_TYPE(right) == AOP_CRY */
4279             } else {
4280                 symbol *lbl = newiTempLabel(NULL);
4281                 emitcode("mov","c,%s",AOP(left)->aopu.aop_dir);
4282                 emitcode("jb","%s,%05d$",AOP(right)->aopu.aop_dir,(lbl->key+100));
4283                 emitcode("cpl","c");
4284                 emitcode("","%05d$:",(lbl->key+100));
4285             }
4286             /* if true label then we jump if condition
4287             supplied is true */
4288             tlbl = newiTempLabel(NULL);
4289             if ( IC_TRUE(ifx) ) {
4290                 emitcode("jnc","%05d$",tlbl->key+100);
4291                 emitcode("ljmp","%05d$",IC_TRUE(ifx)->key+100);
4292             } else {
4293                 emitcode("jc","%05d$",tlbl->key+100);
4294                 emitcode("ljmp","%05d$",IC_FALSE(ifx)->key+100);
4295             }
4296             emitcode("","%05d$:",tlbl->key+100);
4297         } else {
4298             tlbl = newiTempLabel(NULL);
4299             gencjneshort(left, right, tlbl);
4300             if ( IC_TRUE(ifx) ) {
4301                 emitcode("ljmp","%05d$",IC_TRUE(ifx)->key+100);
4302                 emitcode("","%05d$:",tlbl->key+100);
4303             } else {
4304                 symbol *lbl = newiTempLabel(NULL);
4305                 emitcode("sjmp","%05d$",lbl->key+100);
4306                 emitcode("","%05d$:",tlbl->key+100);
4307                 emitcode("ljmp","%05d$",IC_FALSE(ifx)->key+100);
4308                 emitcode("","%05d$:",lbl->key+100);
4309             }
4310         }
4311         /* mark the icode as generated */
4312         ifx->generated = 1;
4313
4314         freeAsmop(left,NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
4315         freeAsmop(right,NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
4316         return ;
4317     }
4318
4319     /* if they are both bit variables */
4320     if (AOP_TYPE(left) == AOP_CRY &&
4321         ((AOP_TYPE(right) == AOP_CRY) || (AOP_TYPE(right) == AOP_LIT))) {
4322         if(AOP_TYPE(right) == AOP_LIT){
4323             unsigned long lit = (unsigned long)floatFromVal(AOP(IC_RIGHT(ic))->aopu.aop_lit);
4324             if(lit == 0L){
4325                 emitcode("mov","c,%s",AOP(left)->aopu.aop_dir);
4326                 emitcode("cpl","c");
4327             } else if(lit == 1L) {
4328                 emitcode("mov","c,%s",AOP(left)->aopu.aop_dir);
4329             } else {
4330                 emitcode("clr","c");
4331             }
4332             /* AOP_TYPE(right) == AOP_CRY */
4333         } else {
4334             symbol *lbl = newiTempLabel(NULL);
4335             emitcode("mov","c,%s",AOP(left)->aopu.aop_dir);
4336             emitcode("jb","%s,%05d$",AOP(right)->aopu.aop_dir,(lbl->key+100));
4337             emitcode("cpl","c");
4338             emitcode("","%05d$:",(lbl->key+100));
4339         }
4340
4341         freeAsmop(left,NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
4342         freeAsmop(right,NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
4343
4344         aopOp(result,ic,TRUE, FALSE);
4345
4346         /* c = 1 if egal */
4347         if (AOP_TYPE(result) == AOP_CRY && AOP_SIZE(result)){
4348             outBitC(result);
4349             goto release ;
4350         }
4351         if (ifx) {
4352             genIfxJump (ifx,"c");
4353             goto release ;
4354         }
4355         /* if the result is used in an arithmetic operation
4356         then put the result in place */
4357         outBitC(result);
4358     } else {
4359         gencjne(left,right,newiTempLabel(NULL));
4360
4361         freeAsmop(left,NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
4362         freeAsmop(right,NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
4363
4364         aopOp(result,ic,TRUE, FALSE);
4365
4366         if (AOP_TYPE(result) == AOP_CRY && AOP_SIZE(result)) {
4367             aopPut(AOP(result),"a",0);
4368             goto release ;
4369         }
4370         if (ifx) {
4371             genIfxJump (ifx,"a");
4372             goto release ;
4373         }
4374         /* if the result is used in an arithmetic operation
4375         then put the result in place */
4376         if (AOP_TYPE(result) != AOP_CRY)
4377             outAcc(result);
4378         /* leave the result in acc */
4379     }
4380
4381 release:
4382     freeAsmop(result,NULL,ic,TRUE);
4383 }
4384
4385 /*-----------------------------------------------------------------*/
4386 /* ifxForOp - returns the icode containing the ifx for operand     */
4387 /*-----------------------------------------------------------------*/
4388 static iCode *ifxForOp ( operand *op, iCode *ic )
4389 {
4390     /* if true symbol then needs to be assigned */
4391     if (IS_TRUE_SYMOP(op))
4392         return NULL ;
4393
4394     /* if this has register type condition and
4395     the next instruction is ifx with the same operand
4396     and live to of the operand is upto the ifx only then */
4397     if (ic->next &&
4398         ic->next->op == IFX &&
4399         IC_COND(ic->next)->key == op->key &&
4400         OP_SYMBOL(op)->liveTo <= ic->next->seq )
4401         return ic->next;
4402
4403     return NULL;
4404 }
4405 /*-----------------------------------------------------------------*/
4406 /* genAndOp - for && operation                                     */
4407 /*-----------------------------------------------------------------*/
4408 static void genAndOp (iCode *ic)
4409 {
4410     operand *left,*right, *result;
4411     symbol *tlbl;
4412
4413     D(emitcode(";", "genAndOp "););
4414
4415     /* note here that && operations that are in an
4416     if statement are taken away by backPatchLabels
4417     only those used in arthmetic operations remain */
4418     AOP_OP_3(ic);
4419     AOP_SET_LOCALS(ic);
4420 #if 0
4421     aopOp((left=IC_LEFT(ic)),ic,FALSE, FALSE);
4422     aopOp((right=IC_RIGHT(ic)),ic,FALSE, TRUE);
4423     aopOp((result=IC_RESULT(ic)),ic,FALSE, FALSE);
4424 #endif
4425
4426     /* if both are bit variables */
4427     if (AOP_TYPE(left) == AOP_CRY &&
4428         AOP_TYPE(right) == AOP_CRY ) {
4429         emitcode("mov","c,%s",AOP(left)->aopu.aop_dir);
4430         emitcode("anl","c,%s",AOP(right)->aopu.aop_dir);
4431         outBitC(result);
4432     } else {
4433         tlbl = newiTempLabel(NULL);
4434         toBoolean(left);
4435         emitcode("jz","%05d$",tlbl->key+100);
4436         toBoolean(right);
4437         emitcode("","%05d$:",tlbl->key+100);
4438         outBitAcc(result);
4439     }
4440
4441     freeAsmop(left,NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
4442     freeAsmop(right,NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
4443     freeAsmop(result,NULL,ic,TRUE);
4444 }
4445
4446
4447 /*-----------------------------------------------------------------*/
4448 /* genOrOp - for || operation                                      */
4449 /*-----------------------------------------------------------------*/
4450 static void genOrOp (iCode *ic)
4451 {
4452     operand *left,*right, *result;
4453     symbol *tlbl;
4454
4455     D(emitcode(";", "genOrOp "););
4456
4457     /* note here that || operations that are in an
4458     if statement are taken away by backPatchLabels
4459     only those used in arthmetic operations remain */
4460     AOP_OP_3(ic);
4461     AOP_SET_LOCALS(ic);
4462 #if 0
4463     aopOp((left=IC_LEFT(ic)),ic,FALSE, FALSE);
4464     aopOp((right=IC_RIGHT(ic)),ic,FALSE, TRUE);
4465     aopOp((result=IC_RESULT(ic)),ic,FALSE, FALSE);
4466 #endif
4467
4468     /* if both are bit variables */
4469     if (AOP_TYPE(left) == AOP_CRY &&
4470         AOP_TYPE(right) == AOP_CRY ) {
4471         emitcode("mov","c,%s",AOP(left)->aopu.aop_dir);
4472         emitcode("orl","c,%s",AOP(right)->aopu.aop_dir);
4473         outBitC(result);
4474     } else {
4475         tlbl = newiTempLabel(NULL);
4476         toBoolean(left);
4477         emitcode("jnz","%05d$",tlbl->key+100);
4478         toBoolean(right);
4479         emitcode("","%05d$:",tlbl->key+100);
4480         outBitAcc(result);
4481     }
4482
4483     freeAsmop(left,NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
4484     freeAsmop(right,NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
4485     freeAsmop(result,NULL,ic,TRUE);
4486 }
4487
4488 /*-----------------------------------------------------------------*/
4489 /* isLiteralBit - test if lit == 2^n                               */
4490 /*-----------------------------------------------------------------*/
4491 static int isLiteralBit(unsigned long lit)
4492 {
4493     unsigned long pw[32] = {1L,2L,4L,8L,16L,32L,64L,128L,
4494     0x100L,0x200L,0x400L,0x800L,
4495     0x1000L,0x2000L,0x4000L,0x8000L,
4496     0x10000L,0x20000L,0x40000L,0x80000L,
4497     0x100000L,0x200000L,0x400000L,0x800000L,
4498     0x1000000L,0x2000000L,0x4000000L,0x8000000L,
4499     0x10000000L,0x20000000L,0x40000000L,0x80000000L};
4500     int idx;
4501
4502     for(idx = 0; idx < 32; idx++)
4503         if(lit == pw[idx])
4504             return idx+1;
4505     return 0;
4506 }
4507
4508 /*-----------------------------------------------------------------*/
4509 /* continueIfTrue -                                                */
4510 /*-----------------------------------------------------------------*/
4511 static void continueIfTrue (iCode *ic)
4512 {
4513     if(IC_TRUE(ic))
4514         emitcode("ljmp","%05d$",IC_TRUE(ic)->key+100);
4515     ic->generated = 1;
4516 }
4517
4518 /*-----------------------------------------------------------------*/
4519 /* jmpIfTrue -                                                     */
4520 /*-----------------------------------------------------------------*/
4521 static void jumpIfTrue (iCode *ic)
4522 {
4523     if(!IC_TRUE(ic))
4524         emitcode("ljmp","%05d$",IC_FALSE(ic)->key+100);
4525     ic->generated = 1;
4526 }
4527
4528 /*-----------------------------------------------------------------*/
4529 /* jmpTrueOrFalse -                                                */
4530 /*-----------------------------------------------------------------*/
4531 static void jmpTrueOrFalse (iCode *ic, symbol *tlbl)
4532 {
4533     // ugly but optimized by peephole
4534     if(IC_TRUE(ic)){
4535         symbol *nlbl = newiTempLabel(NULL);
4536         emitcode("sjmp","%05d$",nlbl->key+100);
4537         emitcode("","%05d$:",tlbl->key+100);
4538         emitcode("ljmp","%05d$",IC_TRUE(ic)->key+100);
4539         emitcode("","%05d$:",nlbl->key+100);
4540     }
4541     else{
4542         emitcode("ljmp","%05d$",IC_FALSE(ic)->key+100);
4543         emitcode("","%05d$:",tlbl->key+100);
4544     }
4545     ic->generated = 1;
4546 }
4547
4548 /*-----------------------------------------------------------------*/
4549 /* genAnd  - code for and                                          */
4550 /*-----------------------------------------------------------------*/
4551 static void genAnd (iCode *ic, iCode *ifx)
4552 {
4553     operand *left, *right, *result;
4554     int size, offset=0;
4555     unsigned long lit = 0L;
4556     int bytelit = 0;
4557     char buffer[10];
4558
4559     D(emitcode(";", "genAnd "););
4560
4561     AOP_OP_3(ic);
4562     AOP_SET_LOCALS(ic);
4563 #if 0
4564     aopOp((left = IC_LEFT(ic)),ic,FALSE, FALSE);
4565     aopOp((right= IC_RIGHT(ic)),ic,FALSE, TRUE);
4566     aopOp((result=IC_RESULT(ic)),ic,TRUE, FALSE);
4567 #endif
4568
4569 #ifdef DEBUG_TYPE
4570     emitcode("","; Type res[%d] = l[%d]&r[%d]",
4571              AOP_TYPE(result),
4572              AOP_TYPE(left), AOP_TYPE(right));
4573     emitcode("","; Size res[%d] = l[%d]&r[%d]",
4574              AOP_SIZE(result),
4575              AOP_SIZE(left), AOP_SIZE(right));
4576 #endif
4577
4578     /* if left is a literal & right is not then exchange them */
4579     if ((AOP_TYPE(left) == AOP_LIT && AOP_TYPE(right) != AOP_LIT) ||
4580         AOP_NEEDSACC(left)) {
4581         operand *tmp = right ;
4582         right = left;
4583         left = tmp;
4584     }
4585
4586     /* if result = right then exchange them */
4587     if(sameRegs(AOP(result),AOP(right))){
4588         operand *tmp = right ;
4589         right = left;
4590         left = tmp;
4591     }
4592
4593     /* if right is bit then exchange them */
4594     if (AOP_TYPE(right) == AOP_CRY &&
4595         AOP_TYPE(left) != AOP_CRY){
4596         operand *tmp = right ;
4597         right = left;
4598         left = tmp;
4599     }
4600     if(AOP_TYPE(right) == AOP_LIT)
4601         lit = (unsigned long)floatFromVal (AOP(right)->aopu.aop_lit);
4602
4603     size = AOP_SIZE(result);
4604
4605     // if(bit & yy)
4606     // result = bit & yy;
4607     if (AOP_TYPE(left) == AOP_CRY){
4608         // c = bit & literal;
4609         if(AOP_TYPE(right) == AOP_LIT){
4610             if(lit & 1) {
4611                 if(size && sameRegs(AOP(result),AOP(left)))
4612                     // no change
4613                     goto release;
4614                 emitcode("mov","c,%s",AOP(left)->aopu.aop_dir);
4615             } else {
4616                 // bit(result) = 0;
4617                 if(size && (AOP_TYPE(result) == AOP_CRY)){
4618                     emitcode("clr","%s",AOP(result)->aopu.aop_dir);
4619                     goto release;
4620                 }
4621                 if((AOP_TYPE(result) == AOP_CRY) && ifx){
4622                     jumpIfTrue(ifx);
4623                     goto release;
4624                 }
4625                 emitcode("clr","c");
4626             }
4627         } else {
4628             if (AOP_TYPE(right) == AOP_CRY){
4629                 // c = bit & bit;
4630                 emitcode("mov","c,%s",AOP(right)->aopu.aop_dir);
4631                 emitcode("anl","c,%s",AOP(left)->aopu.aop_dir);
4632             } else {
4633                 // c = bit & val;
4634                 MOVA(aopGet(AOP(right),0,FALSE,FALSE,TRUE));
4635                 // c = lsb
4636                 emitcode("rrc","a");
4637                 emitcode("anl","c,%s",AOP(left)->aopu.aop_dir);
4638             }
4639         }
4640         // bit = c
4641         // val = c
4642         if(size)
4643             outBitC(result);
4644         // if(bit & ...)
4645         else if((AOP_TYPE(result) == AOP_CRY) && ifx)
4646             genIfxJump(ifx, "c");
4647         goto release ;
4648     }
4649
4650     // if(val & 0xZZ)       - size = 0, ifx != FALSE  -
4651     // bit = val & 0xZZ     - size = 1, ifx = FALSE -
4652     if((AOP_TYPE(right) == AOP_LIT) &&
4653        (AOP_TYPE(result) == AOP_CRY) &&
4654        (AOP_TYPE(left) != AOP_CRY)){
4655         int posbit = isLiteralBit(lit);
4656         /* left &  2^n */
4657         if(posbit){
4658             posbit--;
4659             MOVA(aopGet(AOP(left),posbit>>3,FALSE,FALSE,TRUE));
4660             // bit = left & 2^n
4661             if(size)
4662                 emitcode("mov","c,acc.%d",posbit&0x07);
4663             // if(left &  2^n)
4664             else{
4665                 if(ifx){
4666                     sprintf(buffer,"acc.%d",posbit&0x07);
4667                     genIfxJump(ifx, buffer);
4668                 }
4669                 goto release;
4670             }
4671         } else {
4672             symbol *tlbl = newiTempLabel(NULL);
4673             int sizel = AOP_SIZE(left);
4674             if(size)
4675                 emitcode("setb","c");
4676             while(sizel--){
4677                 if((bytelit = ((lit >> (offset*8)) & 0x0FFL)) != 0x0L){
4678                     MOVA( aopGet(AOP(left),offset,FALSE,FALSE,TRUE));
4679                     // byte ==  2^n ?
4680                     if((posbit = isLiteralBit(bytelit)) != 0)
4681                         emitcode("jb","acc.%d,%05d$",(posbit-1)&0x07,tlbl->key+100);
4682                     else{
4683                         if(bytelit != 0x0FFL)
4684                             emitcode("anl","a,%s",
4685                                      aopGet(AOP(right),offset,FALSE,TRUE,FALSE));
4686                         emitcode("jnz","%05d$",tlbl->key+100);
4687                     }
4688                 }
4689                 offset++;
4690             }
4691             // bit = left & literal
4692             if(size){
4693                 emitcode("clr","c");
4694                 emitcode("","%05d$:",tlbl->key+100);
4695             }
4696             // if(left & literal)
4697             else{
4698                 if(ifx)
4699                     jmpTrueOrFalse(ifx, tlbl);
4700                 goto release ;
4701             }
4702         }
4703         outBitC(result);
4704         goto release ;
4705     }
4706
4707     /* if left is same as result */
4708     if(sameRegs(AOP(result),AOP(left))){
4709         for(;size--; offset++) {
4710             if(AOP_TYPE(right) == AOP_LIT){
4711                 if((bytelit = (int)((lit >> (offset*8)) & 0x0FFL)) == 0x0FF)
4712                     continue;
4713                 else
4714                     if (bytelit == 0)
4715                         aopPut(AOP(result),zero,offset);
4716                     else
4717                         if (IS_AOP_PREG(result)) {
4718                             MOVA(aopGet(AOP(right),offset,FALSE,FALSE,TRUE));
4719                             emitcode("anl","a,%s",aopGet(AOP(left),offset,FALSE,TRUE,FALSE));
4720                             aopPut(AOP(result),"a",offset);
4721                         } else
4722                             emitcode("anl","%s,%s",
4723                                      aopGet(AOP(left),offset,FALSE,TRUE,FALSE),
4724                                      aopGet(AOP(right),offset,FALSE,FALSE,FALSE));
4725             } else {
4726                 if (AOP_TYPE(left) == AOP_ACC)
4727                     emitcode("anl","a,%s",aopGet(AOP(right),offset,FALSE,FALSE,FALSE));
4728                 else {
4729                     MOVA(aopGet(AOP(right),offset,FALSE,FALSE,TRUE));
4730                     if (IS_AOP_PREG(result)) {
4731                         emitcode("anl","a,%s",aopGet(AOP(left),offset,FALSE,TRUE,FALSE));
4732                         aopPut(AOP(result),"a",offset);
4733
4734                     } else
4735                         emitcode("anl","%s,a",
4736                                  aopGet(AOP(left),offset,FALSE,TRUE,FALSE));
4737                 }
4738             }
4739         }
4740     } else {
4741         // left & result in different registers
4742         if(AOP_TYPE(result) == AOP_CRY){
4743             // result = bit
4744             // if(size), result in bit
4745             // if(!size && ifx), conditional oper: if(left & right)
4746             symbol *tlbl = newiTempLabel(NULL);
4747             int sizer = min(AOP_SIZE(left),AOP_SIZE(right));
4748             if(size)
4749                 emitcode("setb","c");
4750             while(sizer--){
4751                 MOVA(aopGet(AOP(right),offset,FALSE,FALSE,TRUE));
4752                 emitcode("anl","a,%s",
4753                          aopGet(AOP(left),offset,FALSE,FALSE,FALSE));
4754                 emitcode("jnz","%05d$",tlbl->key+100);
4755                 offset++;
4756             }
4757             if(size){
4758                 CLRC;
4759                 emitcode("","%05d$:",tlbl->key+100);
4760                 outBitC(result);
4761             } else if(ifx)
4762                 jmpTrueOrFalse(ifx, tlbl);
4763         } else
4764         {
4765             for(;(size--);offset++)
4766             {
4767                 // normal case
4768                 // result = left & right
4769                 if(AOP_TYPE(right) == AOP_LIT)
4770                 {
4771                     if((bytelit = (int)((lit >> (offset*8)) & 0x0FFL)) == 0x0FF)
4772                     {
4773                         aopPut(AOP(result),
4774                                aopGet(AOP(left),offset,FALSE,FALSE,FALSE),
4775                                offset);
4776                         continue;
4777                     }
4778                     else if (bytelit == 0)
4779                     {
4780                         aopPut(AOP(result),zero,offset);
4781                         continue;
4782                     }
4783                     D(emitcode(";", "better literal AND."););
4784                     MOVA(aopGet(AOP(left),offset,FALSE,FALSE,TRUE));
4785                     emitcode("anl", "a, %s", aopGet(AOP(right),offset,
4786                                                 FALSE,FALSE,FALSE));
4787
4788                 }
4789                 else
4790                 {
4791                     // faster than result <- left, anl result,right
4792                     // and better if result is SFR
4793                     if (AOP_TYPE(left) == AOP_ACC)
4794                     {
4795                         emitcode("anl","a,%s",aopGet(AOP(right),offset,
4796                                                      FALSE,FALSE,FALSE));
4797                     }
4798                     else
4799                     {
4800                         MOVA(aopGet(AOP(right),offset,FALSE,FALSE,TRUE));
4801                         emitcode("anl","a,%s",
4802                                  aopGet(AOP(left),offset,FALSE,FALSE,FALSE));
4803                     }
4804                 }
4805                 aopPut(AOP(result),"a",offset);
4806             }
4807         }
4808     }
4809
4810 release :
4811     freeAsmop(left,NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
4812     freeAsmop(right,NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
4813     freeAsmop(result,NULL,ic,TRUE);
4814 }
4815
4816 /*-----------------------------------------------------------------*/
4817 /* genOr  - code for or                                            */
4818 /*-----------------------------------------------------------------*/
4819 static void genOr (iCode *ic, iCode *ifx)
4820 {
4821     operand *left, *right, *result;
4822     int size, offset=0;
4823     unsigned long lit = 0L;
4824
4825     D(emitcode(";", "genOr "););
4826
4827     AOP_OP_3(ic);
4828     AOP_SET_LOCALS(ic);
4829 #if 0
4830     aopOp((left = IC_LEFT(ic)),ic,FALSE, FALSE);
4831     aopOp((right= IC_RIGHT(ic)),ic,FALSE, TRUE);
4832     aopOp((result=IC_RESULT(ic)),ic,TRUE, FALSE);
4833 #endif
4834
4835 #ifdef DEBUG_TYPE
4836     emitcode("","; Type res[%d] = l[%d]&r[%d]",
4837              AOP_TYPE(result),
4838              AOP_TYPE(left), AOP_TYPE(right));
4839     emitcode("","; Size res[%d] = l[%d]&r[%d]",
4840              AOP_SIZE(result),
4841              AOP_SIZE(left), AOP_SIZE(right));
4842 #endif
4843
4844     /* if left is a literal & right is not then exchange them */
4845     if ((AOP_TYPE(left) == AOP_LIT && AOP_TYPE(right) != AOP_LIT) ||
4846         AOP_NEEDSACC(left)) {
4847         operand *tmp = right ;
4848         right = left;
4849         left = tmp;
4850     }
4851
4852     /* if result = right then exchange them */
4853     if(sameRegs(AOP(result),AOP(right))){
4854         operand *tmp = right ;
4855         right = left;
4856         left = tmp;
4857     }
4858
4859     /* if right is bit then exchange them */
4860     if (AOP_TYPE(right) == AOP_CRY &&
4861         AOP_TYPE(left) != AOP_CRY){
4862         operand *tmp = right ;
4863         right = left;
4864         left = tmp;
4865     }
4866     if(AOP_TYPE(right) == AOP_LIT)
4867         lit = (unsigned long)floatFromVal (AOP(right)->aopu.aop_lit);
4868
4869     size = AOP_SIZE(result);
4870
4871     // if(bit | yy)
4872     // xx = bit | yy;
4873     if (AOP_TYPE(left) == AOP_CRY){
4874         if(AOP_TYPE(right) == AOP_LIT){
4875             // c = bit & literal;
4876             if(lit){
4877                 // lit != 0 => result = 1
4878                 if(AOP_TYPE(result) == AOP_CRY){
4879                     if(size)
4880                         emitcode("setb","%s",AOP(result)->aopu.aop_dir);
4881                     else if(ifx)
4882                         continueIfTrue(ifx);
4883                     goto release;
4884                 }
4885                 emitcode("setb","c");
4886             } else {
4887                 // lit == 0 => result = left
4888                 if(size && sameRegs(AOP(result),AOP(left)))
4889                     goto release;
4890                 emitcode("mov","c,%s",AOP(left)->aopu.aop_dir);
4891             }
4892         } else {
4893             if (AOP_TYPE(right) == AOP_CRY){
4894                 // c = bit | bit;
4895                 emitcode("mov","c,%s",AOP(right)->aopu.aop_dir);
4896                 emitcode("orl","c,%s",AOP(left)->aopu.aop_dir);
4897             }
4898             else{
4899                 // c = bit | val;
4900                 symbol *tlbl = newiTempLabel(NULL);
4901                 if(!((AOP_TYPE(result) == AOP_CRY) && ifx))
4902                     emitcode("setb","c");
4903                 emitcode("jb","%s,%05d$",
4904                          AOP(left)->aopu.aop_dir,tlbl->key+100);
4905                 toBoolean(right);
4906                 emitcode("jnz","%05d$",tlbl->key+100);
4907                 if((AOP_TYPE(result) == AOP_CRY) && ifx){
4908                     jmpTrueOrFalse(ifx, tlbl);
4909                     goto release;
4910                 } else {
4911                     CLRC;
4912                     emitcode("","%05d$:",tlbl->key+100);
4913                 }
4914             }
4915         }
4916         // bit = c
4917         // val = c
4918         if(size)
4919             outBitC(result);
4920         // if(bit | ...)
4921         else if((AOP_TYPE(result) == AOP_CRY) && ifx)
4922             genIfxJump(ifx, "c");
4923         goto release ;
4924     }
4925
4926     // if(val | 0xZZ)       - size = 0, ifx != FALSE  -
4927     // bit = val | 0xZZ     - size = 1, ifx = FALSE -
4928     if((AOP_TYPE(right) == AOP_LIT) &&
4929        (AOP_TYPE(result) == AOP_CRY) &&
4930        (AOP_TYPE(left) != AOP_CRY)){
4931         if(lit){
4932             // result = 1
4933             if(size)
4934                 emitcode("setb","%s",AOP(result)->aopu.aop_dir);
4935             else
4936                 continueIfTrue(ifx);
4937             goto release;
4938         } else {
4939             // lit = 0, result = boolean(left)
4940             if(size)
4941                 emitcode("setb","c");
4942             toBoolean(right);
4943             if(size){
4944                 symbol *tlbl = newiTempLabel(NULL);
4945                 emitcode("jnz","%05d$",tlbl->key+100);
4946                 CLRC;
4947                 emitcode("","%05d$:",tlbl->key+100);
4948             } else {
4949                 genIfxJump (ifx,"a");
4950                 goto release;
4951             }
4952         }
4953         outBitC(result);
4954         goto release ;
4955     }
4956
4957     /* if left is same as result */
4958     if(sameRegs(AOP(result),AOP(left)))
4959     {
4960         for(;size--; offset++)
4961         {
4962             if(AOP_TYPE(right) == AOP_LIT){
4963                 if(((lit >> (offset*8)) & 0x0FFL) == 0x00L)
4964                 {
4965                     continue;
4966                 }
4967                 else
4968                 {
4969                     if (IS_AOP_PREG(left))
4970                     {
4971                         MOVA(aopGet(AOP(right),offset,FALSE,FALSE,TRUE));
4972                         emitcode("orl","a,%s",aopGet(AOP(left),offset,FALSE,TRUE,FALSE));
4973                         aopPut(AOP(result),"a",offset);
4974                     }
4975                     else
4976                     {
4977                         emitcode("orl","%s,%s",
4978                                  aopGet(AOP(left),offset,FALSE,TRUE,FALSE),
4979                                  aopGet(AOP(right),offset,FALSE,FALSE,FALSE));
4980                     }
4981                 }
4982             }
4983             else
4984             {
4985                 if (AOP_TYPE(left) == AOP_ACC)
4986                 {
4987                     emitcode("orl","a,%s",aopGet(AOP(right),offset,FALSE,FALSE,FALSE));
4988                 }
4989                 else
4990                 {
4991                     MOVA(aopGet(AOP(right),offset,FALSE,FALSE,TRUE));
4992                     if (IS_AOP_PREG(left))
4993                     {
4994                         emitcode("orl","a,%s",aopGet(AOP(left),offset,FALSE,TRUE,FALSE));
4995                         aopPut(AOP(result),"a",offset);
4996                     }
4997                     else
4998                     {
4999                         emitcode("orl","%s,a",
5000                                  aopGet(AOP(left),offset,FALSE,TRUE,FALSE));
5001                     }
5002                 }
5003             }
5004         }
5005     }
5006     else
5007     {
5008         // left & result in different registers
5009         if(AOP_TYPE(result) == AOP_CRY)
5010         {
5011             // result = bit
5012             // if(size), result in bit
5013             // if(!size && ifx), conditional oper: if(left | right)
5014             symbol *tlbl = newiTempLabel(NULL);
5015             int sizer = max(AOP_SIZE(left),AOP_SIZE(right));
5016             if(size)
5017                 emitcode("setb","c");
5018             while(sizer--){
5019                 MOVA(aopGet(AOP(right),offset,FALSE,FALSE,TRUE));
5020                 emitcode("orl","a,%s",
5021                          aopGet(AOP(left),offset,FALSE,FALSE,FALSE));
5022                 emitcode("jnz","%05d$",tlbl->key+100);
5023                 offset++;
5024             }
5025             if(size){
5026                 CLRC;
5027                 emitcode("","%05d$:",tlbl->key+100);
5028                 outBitC(result);
5029             } else if(ifx)
5030                 jmpTrueOrFalse(ifx, tlbl);
5031         }
5032         else
5033         {
5034             for(;(size--);offset++)
5035             {
5036                 // normal case
5037                 // result = left & right
5038                 if(AOP_TYPE(right) == AOP_LIT)
5039                 {
5040                     if(((lit >> (offset*8)) & 0x0FFL) == 0x00L)
5041                     {
5042                         aopPut(AOP(result),
5043                                aopGet(AOP(left),offset,FALSE,FALSE,FALSE),
5044                                offset);
5045                         continue;
5046                     }
5047                     D(emitcode(";", "better literal OR."););
5048                     MOVA(aopGet(AOP(left),offset,FALSE,FALSE,TRUE));
5049                     emitcode("orl", "a, %s", aopGet(AOP(right),offset,
5050                                                 FALSE,FALSE,FALSE));
5051
5052                 }
5053                 else
5054                 {
5055                     // faster than result <- left, anl result,right
5056                     // and better if result is SFR
5057                     if (AOP_TYPE(left) == AOP_ACC)
5058                     {
5059                         emitcode("orl","a,%s",aopGet(AOP(right),offset,
5060                                                      FALSE,FALSE,FALSE));
5061                     }
5062                     else
5063                     {
5064                         MOVA(aopGet(AOP(right),offset,FALSE,FALSE,TRUE));
5065                         emitcode("orl","a,%s",
5066                                  aopGet(AOP(left),offset,FALSE,FALSE,FALSE));
5067                     }
5068                 }
5069                 aopPut(AOP(result),"a",offset);
5070             }
5071         }
5072     }
5073
5074 release :
5075     freeAsmop(left,NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
5076     freeAsmop(right,NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
5077     freeAsmop(result,NULL,ic,TRUE);
5078 }
5079
5080 /*-----------------------------------------------------------------*/
5081 /* genXor - code for xclusive or                                   */
5082 /*-----------------------------------------------------------------*/
5083 static void genXor (iCode *ic, iCode *ifx)
5084 {
5085     operand *left, *right, *result;
5086     int size, offset=0;
5087     unsigned long lit = 0L;
5088
5089     D(emitcode(";", "genXor "););
5090
5091     AOP_OP_3(ic);
5092     AOP_SET_LOCALS(ic);
5093 #if 0
5094     aopOp((left = IC_LEFT(ic)),ic,FALSE, FALSE);
5095     aopOp((right= IC_RIGHT(ic)),ic,FALSE, TRUE);
5096     aopOp((result=IC_RESULT(ic)),ic,TRUE, FALSE);
5097 #endif
5098
5099 #ifdef DEBUG_TYPE
5100     emitcode("","; Type res[%d] = l[%d]&r[%d]",
5101              AOP_TYPE(result),
5102              AOP_TYPE(left), AOP_TYPE(right));
5103     emitcode("","; Size res[%d] = l[%d]&r[%d]",
5104              AOP_SIZE(result),
5105              AOP_SIZE(left), AOP_SIZE(right));
5106 #endif
5107
5108     /* if left is a literal & right is not ||
5109        if left needs acc & right does not */
5110     if ((AOP_TYPE(left) == AOP_LIT && AOP_TYPE(right) != AOP_LIT) ||
5111         (AOP_NEEDSACC(left) && !AOP_NEEDSACC(right))) {
5112         operand *tmp = right ;
5113         right = left;
5114         left = tmp;
5115     }
5116
5117     /* if result = right then exchange them */
5118     if(sameRegs(AOP(result),AOP(right))){
5119         operand *tmp = right ;
5120         right = left;
5121         left = tmp;
5122     }
5123
5124     /* if right is bit then exchange them */
5125     if (AOP_TYPE(right) == AOP_CRY &&
5126         AOP_TYPE(left) != AOP_CRY){
5127         operand *tmp = right ;
5128         right = left;
5129         left = tmp;
5130     }
5131     if(AOP_TYPE(right) == AOP_LIT)
5132         lit = (unsigned long)floatFromVal (AOP(right)->aopu.aop_lit);
5133
5134     size = AOP_SIZE(result);
5135
5136     // if(bit ^ yy)
5137     // xx = bit ^ yy;
5138     if (AOP_TYPE(left) == AOP_CRY){
5139         if(AOP_TYPE(right) == AOP_LIT){
5140             // c = bit & literal;
5141             if(lit>>1){
5142                 // lit>>1  != 0 => result = 1
5143                 if(AOP_TYPE(result) == AOP_CRY){
5144                     if(size)
5145                         emitcode("setb","%s",AOP(result)->aopu.aop_dir);
5146                     else if(ifx)
5147                         continueIfTrue(ifx);
5148                     goto release;
5149                 }
5150                 emitcode("setb","c");
5151             } else{
5152                 // lit == (0 or 1)
5153                 if(lit == 0){
5154                     // lit == 0, result = left
5155                     if(size && sameRegs(AOP(result),AOP(left)))
5156                         goto release;
5157                     emitcode("mov","c,%s",AOP(left)->aopu.aop_dir);
5158                 } else{
5159                     // lit == 1, result = not(left)
5160                     if(size && sameRegs(AOP(result),AOP(left))){
5161                         emitcode("cpl","%s",AOP(result)->aopu.aop_dir);
5162                         goto release;
5163                     } else {
5164                         emitcode("mov","c,%s",AOP(left)->aopu.aop_dir);
5165                         emitcode("cpl","c");
5166                     }
5167                 }
5168             }
5169
5170         } else {
5171             // right != literal
5172             symbol *tlbl = newiTempLabel(NULL);
5173             if (AOP_TYPE(right) == AOP_CRY){
5174                 // c = bit ^ bit;
5175                 emitcode("mov","c,%s",AOP(right)->aopu.aop_dir);
5176             }
5177             else{
5178                 int sizer = AOP_SIZE(right);
5179                 // c = bit ^ val
5180                 // if val>>1 != 0, result = 1
5181                 emitcode("setb","c");
5182                 while(sizer){
5183                     MOVA(aopGet(AOP(right),sizer-1,FALSE,FALSE,TRUE));
5184                     if(sizer == 1)
5185                         // test the msb of the lsb
5186                         emitcode("anl","a,#0xfe");
5187                     emitcode("jnz","%05d$",tlbl->key+100);
5188                     sizer--;
5189                 }
5190                 // val = (0,1)
5191                 emitcode("rrc","a");
5192             }
5193             emitcode("jnb","%s,%05d$",AOP(left)->aopu.aop_dir,(tlbl->key+100));
5194             emitcode("cpl","c");
5195             emitcode("","%05d$:",(tlbl->key+100));
5196         }
5197         // bit = c
5198         // val = c
5199         if(size)
5200             outBitC(result);
5201         // if(bit | ...)
5202         else if((AOP_TYPE(result) == AOP_CRY) && ifx)
5203             genIfxJump(ifx, "c");
5204         goto release ;
5205     }
5206
5207     if(sameRegs(AOP(result),AOP(left))){
5208         /* if left is same as result */
5209         for(;size--; offset++) {
5210             if(AOP_TYPE(right) == AOP_LIT){
5211                 if(((lit >> (offset*8)) & 0x0FFL) == 0x00L)
5212                     continue;
5213                 else
5214                     if (IS_AOP_PREG(left)) {
5215                         MOVA(aopGet(AOP(right),offset,FALSE,FALSE,TRUE));
5216                         emitcode("xrl","a,%s",aopGet(AOP(left),offset,FALSE,TRUE,FALSE));
5217                         aopPut(AOP(result),"a",offset);
5218                     } else
5219                         emitcode("xrl","%s,%s",
5220                                  aopGet(AOP(left),offset,FALSE,TRUE,FALSE),
5221                                  aopGet(AOP(right),offset,FALSE,FALSE,FALSE));
5222             } else {
5223                 if (AOP_TYPE(left) == AOP_ACC)
5224                     emitcode("xrl","a,%s",aopGet(AOP(right),offset,FALSE,FALSE,FALSE));
5225                 else {
5226                     MOVA(aopGet(AOP(right),offset,FALSE,FALSE,TRUE));
5227                     if (IS_AOP_PREG(left)) {
5228                         emitcode("xrl","a,%s",aopGet(AOP(left),offset,FALSE,TRUE,FALSE));
5229                         aopPut(AOP(result),"a",offset);
5230                     } else
5231                         emitcode("xrl","%s,a",
5232                                  aopGet(AOP(left),offset,FALSE,TRUE,FALSE));
5233                 }
5234             }
5235         }
5236     } else {
5237         // left & result in different registers
5238         if(AOP_TYPE(result) == AOP_CRY){
5239             // result = bit
5240             // if(size), result in bit
5241             // if(!size && ifx), conditional oper: if(left ^ right)
5242             symbol *tlbl = newiTempLabel(NULL);
5243             int sizer = max(AOP_SIZE(left),AOP_SIZE(right));
5244             if(size)
5245                 emitcode("setb","c");
5246             while(sizer--){
5247                 if((AOP_TYPE(right) == AOP_LIT) &&
5248                    (((lit >> (offset*8)) & 0x0FFL) == 0x00L)){
5249                     MOVA(aopGet(AOP(left),offset,FALSE,FALSE,TRUE));
5250                 } else {
5251                     MOVA(aopGet(AOP(right),offset,FALSE,FALSE,TRUE));
5252                     emitcode("xrl","a,%s",
5253                              aopGet(AOP(left),offset,FALSE,FALSE,FALSE));
5254                 }
5255                 emitcode("jnz","%05d$",tlbl->key+100);
5256                 offset++;
5257             }
5258             if(size){
5259                 CLRC;
5260                 emitcode("","%05d$:",tlbl->key+100);
5261                 outBitC(result);
5262             } else if(ifx)
5263                 jmpTrueOrFalse(ifx, tlbl);
5264         } else for(;(size--);offset++)
5265         {
5266             // normal case
5267             // result = left & right
5268             if(AOP_TYPE(right) == AOP_LIT)
5269             {
5270                 if(((lit >> (offset*8)) & 0x0FFL) == 0x00L)
5271                 {
5272                     aopPut(AOP(result),
5273                            aopGet(AOP(left),offset,FALSE,FALSE,FALSE),
5274                            offset);
5275                     continue;
5276                 }
5277                 D(emitcode(";", "better literal XOR."););
5278                 MOVA(aopGet(AOP(left),offset,FALSE,FALSE,TRUE));
5279                 emitcode("xrl", "a, %s", aopGet(AOP(right),offset,
5280                                                 FALSE,FALSE,FALSE));
5281             }
5282             else
5283             {
5284                 // faster than result <- left, anl result,right
5285                 // and better if result is SFR
5286                 if (AOP_TYPE(left) == AOP_ACC)
5287                 {
5288                     emitcode("xrl","a,%s",aopGet(AOP(right),offset,
5289                              FALSE,FALSE,FALSE));
5290                 }
5291                 else
5292                 {
5293                     MOVA(aopGet(AOP(right),offset,FALSE,FALSE,TRUE));
5294                     emitcode("xrl","a,%s",
5295                              aopGet(AOP(left),offset,FALSE,TRUE,FALSE));
5296                 }
5297             }
5298             aopPut(AOP(result),"a",offset);
5299         }
5300     }
5301
5302 release :
5303     freeAsmop(left,NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
5304     freeAsmop(right,NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
5305     freeAsmop(result,NULL,ic,TRUE);
5306 }
5307
5308 /*-----------------------------------------------------------------*/
5309 /* genInline - write the inline code out                           */
5310 /*-----------------------------------------------------------------*/
5311 static void genInline (iCode *ic)
5312 {
5313     char buffer[MAX_INLINEASM];
5314     char *bp = buffer;
5315     char *bp1= buffer;
5316
5317     D(emitcode(";", "genInline "););
5318
5319     _G.inLine += (!options.asmpeep);
5320     strcpy(buffer,IC_INLINE(ic));
5321
5322     /* emit each line as a code */
5323     while (*bp) {
5324         if (*bp == '\n') {
5325             *bp++ = '\0';
5326             emitcode(bp1,"");
5327             bp1 = bp;
5328         } else {
5329             if (*bp == ':') {
5330                 bp++;
5331                 *bp = '\0';
5332                 bp++;
5333                 emitcode(bp1,"");
5334                 bp1 = bp;
5335             } else
5336                 bp++;
5337         }
5338     }
5339     if (bp1 != bp)
5340         emitcode(bp1,"");
5341     /*     emitcode("",buffer); */
5342     _G.inLine -= (!options.asmpeep);
5343 }
5344
5345 /*-----------------------------------------------------------------*/
5346 /* genRRC - rotate right with carry                                */
5347 /*-----------------------------------------------------------------*/
5348 static void genRRC (iCode *ic)
5349 {
5350     operand *left , *result ;
5351     int size, offset = 0;
5352     char *l;
5353
5354     D(emitcode(";", "genRRC "););
5355
5356     /* rotate right with carry */
5357     left = IC_LEFT(ic);
5358     result=IC_RESULT(ic);
5359     aopOp (left,ic,FALSE, FALSE);
5360     aopOp (result,ic,FALSE, AOP_TYPE(left) == AOP_DPTR);
5361
5362     /* move it to the result */
5363     size = AOP_SIZE(result);
5364     offset = size - 1 ;
5365     CLRC;
5366
5367     _startLazyDPSEvaluation();
5368     while (size--) {
5369         l = aopGet(AOP(left),offset,FALSE,FALSE,TRUE);
5370         MOVA(l);
5371         emitcode("rrc","a");
5372         if (AOP_SIZE(result) > 1)
5373             aopPut(AOP(result),"a",offset--);
5374     }
5375     _endLazyDPSEvaluation();
5376
5377     /* now we need to put the carry into the
5378     highest order byte of the result */
5379     if (AOP_SIZE(result) > 1) {
5380         l = aopGet(AOP(result),AOP_SIZE(result)-1,FALSE,FALSE,TRUE);
5381         MOVA(l);
5382     }
5383     emitcode("mov","acc.7,c");
5384     aopPut(AOP(result),"a",AOP_SIZE(result)-1);
5385     freeAsmop(left,NULL,ic,TRUE);
5386     freeAsmop(result,NULL,ic,TRUE);
5387 }
5388
5389 /*-----------------------------------------------------------------*/
5390 /* genRLC - generate code for rotate left with carry               */
5391 /*-----------------------------------------------------------------*/
5392 static void genRLC (iCode *ic)
5393 {
5394     operand *left , *result ;
5395     int size, offset = 0;
5396     char *l;
5397
5398     D(emitcode(";", "genRLC "););
5399
5400     /* rotate right with carry */
5401     left = IC_LEFT(ic);
5402     result=IC_RESULT(ic);
5403     aopOp (left,ic,FALSE, FALSE);
5404     aopOp (result,ic,FALSE, AOP_TYPE(left) == AOP_DPTR);
5405
5406     /* move it to the result */
5407     size = AOP_SIZE(result);
5408     offset = 0 ;
5409     if (size--) {
5410         l = aopGet(AOP(left),offset,FALSE,FALSE,TRUE);
5411         MOVA(l);
5412         emitcode("add","a,acc");
5413         if (AOP_SIZE(result) > 1)
5414         {
5415             aopPut(AOP(result),"a",offset++);
5416         }
5417
5418         _startLazyDPSEvaluation();
5419         while (size--) {
5420             l = aopGet(AOP(left),offset,FALSE,FALSE,TRUE);
5421             MOVA(l);
5422             emitcode("rlc","a");
5423             if (AOP_SIZE(result) > 1)
5424                 aopPut(AOP(result),"a",offset++);
5425         }
5426         _endLazyDPSEvaluation();
5427     }
5428     /* now we need to put the carry into the
5429     highest order byte of the result */
5430     if (AOP_SIZE(result) > 1) {
5431         l = aopGet(AOP(result),0,FALSE,FALSE,TRUE);
5432         MOVA(l);
5433     }
5434     emitcode("mov","acc.0,c");
5435     aopPut(AOP(result),"a",0);
5436     freeAsmop(left,NULL,ic,TRUE);
5437     freeAsmop(result,NULL,ic,TRUE);
5438 }
5439
5440 /*-----------------------------------------------------------------*/
5441 /* genGetHbit - generates code get highest order bit               */
5442 /*-----------------------------------------------------------------*/
5443 static void genGetHbit (iCode *ic)
5444 {
5445     operand *left, *result;
5446     left = IC_LEFT(ic);
5447     result=IC_RESULT(ic);
5448     aopOp (left,ic,FALSE, FALSE);
5449     aopOp (result,ic,FALSE, AOP_TYPE(left) == AOP_DPTR);
5450
5451     D(emitcode(";", "genGetHbit "););
5452
5453     /* get the highest order byte into a */
5454     MOVA(aopGet(AOP(left),AOP_SIZE(left) - 1,FALSE,FALSE,TRUE));
5455     if(AOP_TYPE(result) == AOP_CRY){
5456         emitcode("rlc","a");
5457         outBitC(result);
5458     }
5459     else{
5460         emitcode("rl","a");
5461         emitcode("anl","a,#0x01");
5462         outAcc(result);
5463     }
5464
5465
5466     freeAsmop(left,NULL,ic,TRUE);
5467     freeAsmop(result,NULL,ic,TRUE);
5468 }
5469
5470 /*-----------------------------------------------------------------*/
5471 /* AccRol - rotate left accumulator by known count                 */
5472 /*-----------------------------------------------------------------*/
5473 static void AccRol (int shCount)
5474 {
5475     shCount &= 0x0007;              // shCount : 0..7
5476     switch(shCount){
5477         case 0 :
5478             break;
5479         case 1 :
5480             emitcode("rl","a");
5481             break;
5482         case 2 :
5483             emitcode("rl","a");
5484             emitcode("rl","a");
5485             break;
5486         case 3 :
5487             emitcode("swap","a");
5488             emitcode("rr","a");
5489             break;
5490         case 4 :
5491             emitcode("swap","a");
5492             break;
5493         case 5 :
5494             emitcode("swap","a");
5495             emitcode("rl","a");
5496             break;
5497         case 6 :
5498             emitcode("rr","a");
5499             emitcode("rr","a");
5500             break;
5501         case 7 :
5502             emitcode("rr","a");
5503             break;
5504     }
5505 }
5506
5507 /*-----------------------------------------------------------------*/
5508 /* AccLsh - left shift accumulator by known count                  */
5509 /*-----------------------------------------------------------------*/
5510 static void AccLsh (int shCount)
5511 {
5512     if(shCount != 0){
5513         if(shCount == 1)
5514             emitcode("add","a,acc");
5515         else
5516             if(shCount == 2) {
5517             emitcode("add","a,acc");
5518             emitcode("add","a,acc");
5519         } else {
5520             /* rotate left accumulator */
5521             AccRol(shCount);
5522             /* and kill the lower order bits */
5523             emitcode("anl","a,#0x%02x", SLMask[shCount]);
5524         }
5525     }
5526 }
5527
5528 /*-----------------------------------------------------------------*/
5529 /* AccRsh - right shift accumulator by known count                 */
5530 /*-----------------------------------------------------------------*/
5531 static void AccRsh (int shCount)
5532 {
5533     if(shCount != 0){
5534         if(shCount == 1){
5535             CLRC;
5536             emitcode("rrc","a");
5537         } else {
5538             /* rotate right accumulator */
5539             AccRol(8 - shCount);
5540             /* and kill the higher order bits */
5541             emitcode("anl","a,#0x%02x", SRMask[shCount]);
5542         }
5543     }
5544 }
5545
5546 #if 0
5547 //REMOVE ME!!!
5548 /*-----------------------------------------------------------------*/
5549 /* AccSRsh - signed right shift accumulator by known count                 */
5550 /*-----------------------------------------------------------------*/
5551 static void AccSRsh (int shCount)
5552 {
5553     symbol *tlbl ;
5554     if(shCount != 0){
5555         if(shCount == 1){
5556             emitcode("mov","c,acc.7");
5557             emitcode("rrc","a");
5558         } else if(shCount == 2){
5559             emitcode("mov","c,acc.7");
5560             emitcode("rrc","a");
5561             emitcode("mov","c,acc.7");
5562             emitcode("rrc","a");
5563         } else {
5564             tlbl = newiTempLabel(NULL);
5565             /* rotate right accumulator */
5566             AccRol(8 - shCount);
5567             /* and kill the higher order bits */
5568             emitcode("anl","a,#0x%02x", SRMask[shCount]);
5569             emitcode("jnb","acc.%d,%05d$",7-shCount,tlbl->key+100);
5570             emitcode("orl","a,#0x%02x",
5571                      (unsigned char)~SRMask[shCount]);
5572             emitcode("","%05d$:",tlbl->key+100);
5573         }
5574     }
5575 }
5576 #endif
5577
5578 #if 0
5579 //REMOVE ME!!!
5580 /*-----------------------------------------------------------------*/
5581 /* shiftR1Left2Result - shift right one byte from left to result   */
5582 /*-----------------------------------------------------------------*/
5583 static void shiftR1Left2Result (operand *left, int offl,
5584                                 operand *result, int offr,
5585                                 int shCount, int sign)
5586 {
5587     MOVA(aopGet(AOP(left),offl,FALSE,FALSE,TRUE));
5588     /* shift right accumulator */
5589     if(sign)
5590         AccSRsh(shCount);
5591     else
5592         AccRsh(shCount);
5593     aopPut(AOP(result),"a",offr);
5594 }
5595 #endif
5596
5597 #if 0
5598 //REMOVE ME!!!
5599 /*-----------------------------------------------------------------*/
5600 /* shiftL1Left2Result - shift left one byte from left to result    */
5601 /*-----------------------------------------------------------------*/
5602 static void shiftL1Left2Result (operand *left, int offl,
5603                                 operand *result, int offr, int shCount)
5604 {
5605     char *l;
5606     l = aopGet(AOP(left),offl,FALSE,FALSE,TRUE);
5607     MOVA(l);
5608     /* shift left accumulator */
5609     AccLsh(shCount);
5610     aopPut(AOP(result),"a",offr);
5611 }
5612 #endif
5613
5614 #if 0
5615 //REMOVE ME!!!
5616 /*-----------------------------------------------------------------*/
5617 /* movLeft2Result - move byte from left to result                  */
5618 /*-----------------------------------------------------------------*/
5619 static void movLeft2Result (operand *left, int offl,
5620                             operand *result, int offr, int sign)
5621 {
5622     char *l;
5623     if(!sameRegs(AOP(left),AOP(result)) || (offl != offr)){
5624         l = aopGet(AOP(left),offl,FALSE,FALSE,FALSE);
5625
5626         if (*l == '@' && (IS_AOP_PREG(result))) {
5627             emitcode("mov","a,%s",l);
5628             aopPut(AOP(result),"a",offr);
5629         } else {
5630             if(!sign)
5631                 aopPut(AOP(result),l,offr);
5632             else{
5633                 /* MSB sign in acc.7 ! */
5634                 if(getDataSize(left) == offl+1){
5635                     emitcode("mov","a,%s",l);
5636                     aopPut(AOP(result),"a",offr);
5637                 }
5638             }
5639         }
5640     }
5641 }
5642 #endif
5643
5644 #if 0
5645 //REMOVE ME!!!
5646 /*-----------------------------------------------------------------*/
5647 /* AccAXRrl1 - right rotate c->a:x->c by 1                         */
5648 /*-----------------------------------------------------------------*/
5649 static void AccAXRrl1 (char *x)
5650 {
5651     emitcode("rrc","a");
5652     emitcode("xch","a,%s", x);
5653     emitcode("rrc","a");
5654     emitcode("xch","a,%s", x);
5655 }
5656 #endif
5657
5658 #if 0
5659 //REMOVE ME!!!
5660 /*-----------------------------------------------------------------*/
5661 /* AccAXLrl1 - left rotate c<-a:x<-c by 1                          */
5662 /*-----------------------------------------------------------------*/
5663 static void AccAXLrl1 (char *x)
5664 {
5665     emitcode("xch","a,%s",x);
5666     emitcode("rlc","a");
5667     emitcode("xch","a,%s",x);
5668     emitcode("rlc","a");
5669 }
5670 #endif
5671
5672 #if 0
5673 //REMOVE ME!!!
5674 /*-----------------------------------------------------------------*/
5675 /* AccAXLsh1 - left shift a:x<-0 by 1                              */
5676 /*-----------------------------------------------------------------*/
5677 static void AccAXLsh1 (char *x)
5678 {
5679     emitcode("xch","a,%s",x);
5680     emitcode("add","a,acc");
5681     emitcode("xch","a,%s",x);
5682     emitcode("rlc","a");
5683 }
5684 #endif
5685
5686 #if 0
5687 //REMOVE ME!!!
5688 /*-----------------------------------------------------------------*/
5689 /* AccAXLsh - left shift a:x by known count (0..7)                 */
5690 /*-----------------------------------------------------------------*/
5691 static void AccAXLsh (char *x, int shCount)
5692 {
5693     switch(shCount){
5694         case 0 :
5695             break;
5696         case 1 :
5697             AccAXLsh1(x);
5698             break;
5699         case 2 :
5700             AccAXLsh1(x);
5701             AccAXLsh1(x);
5702             break;
5703         case 3 :
5704         case 4 :
5705         case 5 :                        // AAAAABBB:CCCCCDDD
5706             AccRol(shCount);            // BBBAAAAA:CCCCCDDD
5707             emitcode("anl","a,#0x%02x",
5708                      SLMask[shCount]);  // BBB00000:CCCCCDDD
5709             emitcode("xch","a,%s",x);   // CCCCCDDD:BBB00000
5710             AccRol(shCount);            // DDDCCCCC:BBB00000
5711             emitcode("xch","a,%s",x);   // BBB00000:DDDCCCCC
5712             emitcode("xrl","a,%s",x);   // (BBB^DDD)CCCCC:DDDCCCCC
5713             emitcode("xch","a,%s",x);   // DDDCCCCC:(BBB^DDD)CCCCC
5714             emitcode("anl","a,#0x%02x",
5715                      SLMask[shCount]);  // DDD00000:(BBB^DDD)CCCCC
5716             emitcode("xch","a,%s",x);   // (BBB^DDD)CCCCC:DDD00000
5717             emitcode("xrl","a,%s",x);   // BBBCCCCC:DDD00000
5718             break;
5719         case 6 :                        // AAAAAABB:CCCCCCDD
5720             emitcode("anl","a,#0x%02x",
5721                      SRMask[shCount]);  // 000000BB:CCCCCCDD
5722             emitcode("mov","c,acc.0");  // c = B
5723             emitcode("xch","a,%s",x);   // CCCCCCDD:000000BB
5724             AccAXRrl1(x);               // BCCCCCCD:D000000B
5725             AccAXRrl1(x);               // BBCCCCCC:DD000000
5726             break;
5727         case 7 :                        // a:x <<= 7
5728             emitcode("anl","a,#0x%02x",
5729                      SRMask[shCount]);  // 0000000B:CCCCCCCD
5730             emitcode("mov","c,acc.0");  // c = B
5731             emitcode("xch","a,%s",x);   // CCCCCCCD:0000000B
5732             AccAXRrl1(x);               // BCCCCCCC:D0000000
5733             break;
5734         default :
5735             break;
5736     }
5737 }
5738 #endif
5739
5740 #if 0
5741 //REMOVE ME!!!
5742 /*-----------------------------------------------------------------*/
5743 /* AccAXRsh - right shift a:x known count (0..7)                   */
5744 /*-----------------------------------------------------------------*/
5745 static void AccAXRsh (char *x, int shCount)
5746 {
5747     switch(shCount){
5748         case 0 :
5749             break;
5750         case 1 :
5751             CLRC;
5752             AccAXRrl1(x);               // 0->a:x
5753             break;
5754         case 2 :
5755             CLRC;
5756             AccAXRrl1(x);               // 0->a:x
5757             CLRC;
5758             AccAXRrl1(x);               // 0->a:x
5759             break;
5760         case 3 :
5761         case 4 :
5762         case 5 :                        // AAAAABBB:CCCCCDDD = a:x
5763             AccRol(8 - shCount);        // BBBAAAAA:DDDCCCCC
5764             emitcode("xch","a,%s",x);   // CCCCCDDD:BBBAAAAA
5765             AccRol(8 - shCount);        // DDDCCCCC:BBBAAAAA
5766             emitcode("anl","a,#0x%02x",
5767                      SRMask[shCount]);  // 000CCCCC:BBBAAAAA
5768             emitcode("xrl","a,%s",x);   // BBB(CCCCC^AAAAA):BBBAAAAA
5769             emitcode("xch","a,%s",x);   // BBBAAAAA:BBB(CCCCC^AAAAA)
5770             emitcode("anl","a,#0x%02x",
5771                      SRMask[shCount]);  // 000AAAAA:BBB(CCCCC^AAAAA)
5772             emitcode("xch","a,%s",x);   // BBB(CCCCC^AAAAA):000AAAAA
5773             emitcode("xrl","a,%s",x);   // BBBCCCCC:000AAAAA
5774             emitcode("xch","a,%s",x);   // 000AAAAA:BBBCCCCC
5775             break;
5776         case 6 :                        // AABBBBBB:CCDDDDDD
5777             emitcode("mov","c,acc.7");
5778             AccAXLrl1(x);               // ABBBBBBC:CDDDDDDA
5779             AccAXLrl1(x);               // BBBBBBCC:DDDDDDAA
5780             emitcode("xch","a,%s",x);   // DDDDDDAA:BBBBBBCC
5781             emitcode("anl","a,#0x%02x",
5782                      SRMask[shCount]);  // 000000AA:BBBBBBCC
5783             break;
5784         case 7 :                        // ABBBBBBB:CDDDDDDD
5785             emitcode("mov","c,acc.7");  // c = A
5786             AccAXLrl1(x);               // BBBBBBBC:DDDDDDDA
5787             emitcode("xch","a,%s",x);   // DDDDDDDA:BBBBBBCC
5788             emitcode("anl","a,#0x%02x",
5789                      SRMask[shCount]);  // 0000000A:BBBBBBBC
5790             break;
5791         default :
5792             break;
5793     }
5794 }
5795 #endif
5796
5797 #if 0
5798 //REMOVE ME!!!
5799 /*-----------------------------------------------------------------*/
5800 /* AccAXRshS - right shift signed a:x known count (0..7)           */
5801 /*-----------------------------------------------------------------*/
5802 static void AccAXRshS (char *x, int shCount)
5803 {
5804     symbol *tlbl ;
5805     switch(shCount){
5806         case 0 :
5807             break;
5808         case 1 :
5809             emitcode("mov","c,acc.7");
5810             AccAXRrl1(x);               // s->a:x
5811             break;
5812         case 2 :
5813             emitcode("mov","c,acc.7");
5814             AccAXRrl1(x);               // s->a:x
5815             emitcode("mov","c,acc.7");
5816             AccAXRrl1(x);               // s->a:x
5817             break;
5818         case 3 :
5819         case 4 :
5820         case 5 :                        // AAAAABBB:CCCCCDDD = a:x
5821             tlbl = newiTempLabel(NULL);
5822             AccRol(8 - shCount);        // BBBAAAAA:CCCCCDDD
5823             emitcode("xch","a,%s",x);   // CCCCCDDD:BBBAAAAA
5824             AccRol(8 - shCount);        // DDDCCCCC:BBBAAAAA
5825             emitcode("anl","a,#0x%02x",
5826                      SRMask[shCount]);  // 000CCCCC:BBBAAAAA
5827             emitcode("xrl","a,%s",x);   // BBB(CCCCC^AAAAA):BBBAAAAA
5828             emitcode("xch","a,%s",x);   // BBBAAAAA:BBB(CCCCC^AAAAA)
5829             emitcode("anl","a,#0x%02x",
5830                      SRMask[shCount]);  // 000AAAAA:BBB(CCCCC^AAAAA)
5831             emitcode("xch","a,%s",x);   // BBB(CCCCC^AAAAA):000AAAAA
5832             emitcode("xrl","a,%s",x);   // BBBCCCCC:000AAAAA
5833             emitcode("xch","a,%s",x);   // 000SAAAA:BBBCCCCC
5834             emitcode("jnb","acc.%d,%05d$",7-shCount,tlbl->key+100);
5835             emitcode("orl","a,#0x%02x",
5836                      (unsigned char)~SRMask[shCount]);  // 111AAAAA:BBBCCCCC
5837             emitcode("","%05d$:",tlbl->key+100);
5838             break;                      // SSSSAAAA:BBBCCCCC
5839         case 6 :                        // AABBBBBB:CCDDDDDD
5840             tlbl = newiTempLabel(NULL);
5841             emitcode("mov","c,acc.7");
5842             AccAXLrl1(x);               // ABBBBBBC:CDDDDDDA
5843             AccAXLrl1(x);               // BBBBBBCC:DDDDDDAA
5844             emitcode("xch","a,%s",x);   // DDDDDDAA:BBBBBBCC
5845             emitcode("anl","a,#0x%02x",
5846                      SRMask[shCount]);  // 000000AA:BBBBBBCC
5847             emitcode("jnb","acc.%d,%05d$",7-shCount,tlbl->key+100);
5848             emitcode("orl","a,#0x%02x",
5849                      (unsigned char)~SRMask[shCount]);  // 111111AA:BBBBBBCC
5850             emitcode("","%05d$:",tlbl->key+100);
5851             break;
5852         case 7 :                        // ABBBBBBB:CDDDDDDD
5853             tlbl = newiTempLabel(NULL);
5854             emitcode("mov","c,acc.7");  // c = A
5855             AccAXLrl1(x);               // BBBBBBBC:DDDDDDDA
5856             emitcode("xch","a,%s",x);   // DDDDDDDA:BBBBBBCC
5857             emitcode("anl","a,#0x%02x",
5858                      SRMask[shCount]);  // 0000000A:BBBBBBBC
5859             emitcode("jnb","acc.%d,%05d$",7-shCount,tlbl->key+100);
5860             emitcode("orl","a,#0x%02x",
5861                      (unsigned char)~SRMask[shCount]);  // 1111111A:BBBBBBBC
5862             emitcode("","%05d$:",tlbl->key+100);
5863             break;
5864         default :
5865             break;
5866     }
5867 }
5868 #endif
5869
5870 #if 0
5871 //REMOVE ME!!!
5872 /*-----------------------------------------------------------------*/
5873 /* shiftL2Left2Result - shift left two bytes from left to result   */
5874 /*-----------------------------------------------------------------*/
5875 static void shiftL2Left2Result (operand *left, int offl,
5876                                 operand *result, int offr, int shCount)
5877 {
5878     if(sameRegs(AOP(result), AOP(left)) &&
5879        ((offl + MSB16) == offr)){
5880         /* don't crash result[offr] */
5881         MOVA(aopGet(AOP(left),offl,FALSE,FALSE,TRUE));
5882         emitcode("xch","a,%s", aopGet(AOP(left),offl+MSB16,FALSE,FALSE,FALSE));
5883     } else {
5884         movLeft2Result(left,offl, result, offr, 0);
5885         MOVA(aopGet(AOP(left),offl+MSB16,FALSE,FALSE,TRUE));
5886     }
5887     /* ax << shCount (x = lsb(result))*/
5888     AccAXLsh( aopGet(AOP(result),offr,FALSE,FALSE,FALSE), shCount);
5889     aopPut(AOP(result),"a",offr+MSB16);
5890 }
5891 #endif
5892
5893 #if 0
5894 //REMOVE ME!!!
5895 /*-----------------------------------------------------------------*/
5896 /* shiftR2Left2Result - shift right two bytes from left to result  */
5897 /*-----------------------------------------------------------------*/
5898 static void shiftR2Left2Result (operand *left, int offl,
5899                                 operand *result, int offr,
5900                                 int shCount, int sign)
5901 {
5902     if(sameRegs(AOP(result), AOP(left)) &&
5903        ((offl + MSB16) == offr)){
5904         /* don't crash result[offr] */
5905         MOVA(aopGet(AOP(left),offl,FALSE,FALSE,TRUE));
5906         emitcode("xch","a,%s", aopGet(AOP(left),offl+MSB16,FALSE,FALSE,FALSE));
5907     } else {
5908         movLeft2Result(left,offl, result, offr, 0);
5909         MOVA(aopGet(AOP(left),offl+MSB16,FALSE,FALSE,TRUE));
5910     }
5911     /* a:x >> shCount (x = lsb(result))*/
5912     if(sign)
5913         AccAXRshS( aopGet(AOP(result),offr,FALSE,FALSE,FALSE) , shCount);
5914     else
5915         AccAXRsh( aopGet(AOP(result),offr,FALSE,FALSE,FALSE) , shCount);
5916     if(getDataSize(result) > 1)
5917         aopPut(AOP(result),"a",offr+MSB16);
5918 }
5919 #endif
5920
5921 #if 0
5922 //REMOVE ME!!!
5923 /*-----------------------------------------------------------------*/
5924 /* shiftLLeftOrResult - shift left one byte from left, or to result*/
5925 /*-----------------------------------------------------------------*/
5926 static void shiftLLeftOrResult (operand *left, int offl,
5927                                 operand *result, int offr, int shCount)
5928 {
5929     MOVA(aopGet(AOP(left),offl,FALSE,FALSE,TRUE));
5930     /* shift left accumulator */
5931     AccLsh(shCount);
5932     /* or with result */
5933     emitcode("orl","a,%s", aopGet(AOP(result),offr,FALSE,FALSE,FALSE));
5934     /* back to result */
5935     aopPut(AOP(result),"a",offr);
5936 }
5937 #endif
5938
5939 #if 0
5940 //REMOVE ME!!!
5941 /*-----------------------------------------------------------------*/
5942 /* shiftRLeftOrResult - shift right one byte from left,or to result*/
5943 /*-----------------------------------------------------------------*/
5944 static void shiftRLeftOrResult (operand *left, int offl,
5945                                 operand *result, int offr, int shCount)
5946 {
5947     MOVA(aopGet(AOP(left),offl,FALSE,FALSE,TRUE));
5948     /* shift right accumulator */
5949     AccRsh(shCount);
5950     /* or with result */
5951     emitcode("orl","a,%s", aopGet(AOP(result),offr,FALSE,FALSE,FALSE));
5952     /* back to result */
5953     aopPut(AOP(result),"a",offr);
5954 }
5955 #endif
5956
5957 #if 0
5958 //REMOVE ME!!!
5959 /*-----------------------------------------------------------------*/
5960 /* genlshOne - left shift a one byte quantity by known count       */
5961 /*-----------------------------------------------------------------*/
5962 static void genlshOne (operand *result, operand *left, int shCount)
5963 {
5964     D(emitcode(";", "genlshOne "););
5965     shiftL1Left2Result(left, LSB, result, LSB, shCount);
5966 }
5967 #endif
5968
5969 #if 0
5970 //REMOVE ME!!!
5971 /*-----------------------------------------------------------------*/
5972 /* genlshTwo - left shift two bytes by known amount != 0           */
5973 /*-----------------------------------------------------------------*/
5974 static void genlshTwo (operand *result,operand *left, int shCount)
5975 {
5976     int size;
5977
5978     D(emitcode(";", "genlshTwo "););
5979
5980     size = getDataSize(result);
5981
5982     /* if shCount >= 8 */
5983     if (shCount >= 8) {
5984         shCount -= 8 ;
5985
5986         if (size > 1){
5987             if (shCount)
5988                 shiftL1Left2Result(left, LSB, result, MSB16, shCount);
5989             else
5990                 movLeft2Result(left, LSB, result, MSB16, 0);
5991         }
5992         aopPut(AOP(result),zero,LSB);
5993     }
5994
5995     /*  1 <= shCount <= 7 */
5996     else {
5997         if(size == 1)
5998             shiftL1Left2Result(left, LSB, result, LSB, shCount);
5999         else
6000             shiftL2Left2Result(left, LSB, result, LSB, shCount);
6001     }
6002 }
6003 #endif
6004
6005 #if 0
6006 //REMOVE ME!!!
6007 /*-----------------------------------------------------------------*/
6008 /* shiftLLong - shift left one long from left to result            */
6009 /* offl = LSB or MSB16                                             */
6010 /*-----------------------------------------------------------------*/
6011 static void shiftLLong (operand *left, operand *result, int offr )
6012 {
6013     char *l;
6014     int size = AOP_SIZE(result);
6015
6016     if(size >= LSB+offr){
6017         l = aopGet(AOP(left),LSB,FALSE,FALSE,TRUE);
6018         MOVA(l);
6019         emitcode("add","a,acc");
6020         if (sameRegs(AOP(left),AOP(result)) &&
6021             size >= MSB16+offr && offr != LSB )
6022             emitcode("xch","a,%s",
6023                      aopGet(AOP(left),LSB+offr,FALSE,FALSE,FALSE));
6024         else
6025             aopPut(AOP(result),"a",LSB+offr);
6026     }
6027
6028     if(size >= MSB16+offr){
6029         if (!(sameRegs(AOP(result),AOP(left)) && size >= MSB16+offr && offr != LSB) ) {
6030             l = aopGet(AOP(left),MSB16,FALSE,FALSE,TRUE);
6031             MOVA(l);
6032         }
6033         emitcode("rlc","a");
6034         if (sameRegs(AOP(left),AOP(result)) &&
6035             size >= MSB24+offr && offr != LSB)
6036             emitcode("xch","a,%s",
6037                      aopGet(AOP(left),MSB16+offr,FALSE,FALSE,FALSE));
6038         else
6039             aopPut(AOP(result),"a",MSB16+offr);
6040     }
6041
6042     if(size >= MSB24+offr){
6043         if (!(sameRegs(AOP(left),AOP(left)) && size >= MSB24+offr && offr != LSB)) {
6044             l = aopGet(AOP(left),MSB24,FALSE,FALSE,TRUE);
6045             MOVA(l);
6046         }
6047         emitcode("rlc","a");
6048         if (sameRegs(AOP(left),AOP(result)) &&
6049             size >= MSB32+offr && offr != LSB )
6050             emitcode("xch","a,%s",
6051                      aopGet(AOP(left),MSB24+offr,FALSE,FALSE,FALSE));
6052         else
6053             aopPut(AOP(result),"a",MSB24+offr);
6054     }
6055
6056     if(size > MSB32+offr){
6057         if (!(sameRegs(AOP(result),AOP(left)) && size >= MSB32+offr && offr != LSB)) {
6058             l = aopGet(AOP(left),MSB32,FALSE,FALSE,TRUE);
6059             MOVA(l);
6060         }
6061         emitcode("rlc","a");
6062         aopPut(AOP(result),"a",MSB32+offr);
6063     }
6064     if(offr != LSB)
6065         aopPut(AOP(result),zero,LSB);
6066 }
6067 #endif
6068
6069 #if 0
6070 //REMOVE ME!!!
6071 /*-----------------------------------------------------------------*/
6072 /* genlshFour - shift four byte by a known amount != 0             */
6073 /*-----------------------------------------------------------------*/
6074 static void genlshFour (operand *result, operand *left, int shCount)
6075 {
6076     int size;
6077
6078     D(emitcode(";", "genlshFour "););
6079
6080     size = AOP_SIZE(result);
6081
6082     /* if shifting more that 3 bytes */
6083     if (shCount >= 24 ) {
6084         shCount -= 24;
6085         if (shCount)
6086             /* lowest order of left goes to the highest
6087             order of the destination */
6088             shiftL1Left2Result(left, LSB, result, MSB32, shCount);
6089         else
6090             movLeft2Result(left, LSB, result, MSB32, 0);
6091         aopPut(AOP(result),zero,LSB);
6092         aopPut(AOP(result),zero,MSB16);
6093         aopPut(AOP(result),zero,MSB32);
6094         return;
6095     }
6096
6097     /* more than two bytes */
6098     else if ( shCount >= 16 ) {
6099         /* lower order two bytes goes to higher order two bytes */
6100         shCount -= 16;
6101         /* if some more remaining */
6102         if (shCount)
6103             shiftL2Left2Result(left, LSB, result, MSB24, shCount);
6104         else {
6105             movLeft2Result(left, MSB16, result, MSB32, 0);
6106             movLeft2Result(left, LSB, result, MSB24, 0);
6107         }
6108         aopPut(AOP(result),zero,MSB16);
6109         aopPut(AOP(result),zero,LSB);
6110         return;
6111     }
6112
6113     /* if more than 1 byte */
6114     else if ( shCount >= 8 ) {
6115         /* lower order three bytes goes to higher order  three bytes */
6116         shCount -= 8;
6117         if(size == 2){
6118             if(shCount)
6119                 shiftL1Left2Result(left, LSB, result, MSB16, shCount);
6120             else
6121                 movLeft2Result(left, LSB, result, MSB16, 0);
6122         }
6123         else{   /* size = 4 */
6124             if(shCount == 0){
6125                 movLeft2Result(left, MSB24, result, MSB32, 0);
6126                 movLeft2Result(left, MSB16, result, MSB24, 0);
6127                 movLeft2Result(left, LSB, result, MSB16, 0);
6128                 aopPut(AOP(result),zero,LSB);
6129             }
6130             else if(shCount == 1)
6131                 shiftLLong(left, result, MSB16);
6132             else{
6133                 shiftL2Left2Result(left, MSB16, result, MSB24, shCount);
6134                 shiftL1Left2Result(left, LSB, result, MSB16, shCount);
6135                 shiftRLeftOrResult(left, LSB, result, MSB24, 8 - shCount);
6136                 aopPut(AOP(result),zero,LSB);
6137             }
6138         }
6139     }
6140
6141     /* 1 <= shCount <= 7 */
6142     else if(shCount <= 2){
6143         shiftLLong(left, result, LSB);
6144         if(shCount == 2)
6145             shiftLLong(result, result, LSB);
6146     }
6147     /* 3 <= shCount <= 7, optimize */
6148     else{
6149         shiftL2Left2Result(left, MSB24, result, MSB24, shCount);
6150         shiftRLeftOrResult(left, MSB16, result, MSB24, 8 - shCount);
6151         shiftL2Left2Result(left, LSB, result, LSB, shCount);
6152     }
6153 }
6154 #endif
6155
6156 #if 0
6157 //REMOVE ME!!!
6158 /*-----------------------------------------------------------------*/
6159 /* genLeftShiftLiteral - left shifting by known count              */
6160 /*-----------------------------------------------------------------*/
6161 static void genLeftShiftLiteral (operand *left,
6162                                  operand *right,
6163                                  operand *result,
6164                                  iCode *ic)
6165 {
6166     int shCount = (int) floatFromVal (AOP(right)->aopu.aop_lit);
6167     int size;
6168
6169     D(emitcode(";","genLeftShiftLiteral (%d)", shCount););
6170
6171     freeAsmop(right,NULL,ic,TRUE);
6172
6173     aopOp(left,ic,FALSE, FALSE);
6174     aopOp(result,ic,FALSE, TRUE);
6175
6176     size = getSize(operandType(result));
6177
6178 #if VIEW_SIZE
6179     emitcode("; shift left ","result %d, left %d",size,
6180              AOP_SIZE(left));
6181 #endif
6182
6183     /* I suppose that the left size >= result size */
6184     if(shCount == 0){
6185         while(size--){
6186             movLeft2Result(left, size, result, size, 0);
6187         }
6188     }
6189
6190     else if(shCount >= (size * 8))
6191         while(size--)
6192             aopPut(AOP(result),zero,size);
6193     else{
6194         switch (size) {
6195             case 1:
6196                 genlshOne (result,left,shCount);
6197                 break;
6198
6199             case 2:
6200             case 3: /* bug: this is for generic pointers, I bet. */
6201                 genlshTwo (result,left,shCount);
6202                 break;
6203
6204             case 4:
6205                 genlshFour (result,left,shCount);
6206                 break;
6207         }
6208     }
6209     freeAsmop(left,NULL,ic,TRUE);
6210     freeAsmop(result,NULL,ic,TRUE);
6211 }
6212 #endif
6213
6214 /*-----------------------------------------------------------------*/
6215 /* genLeftShift - generates code for left shifting                 */
6216 /*-----------------------------------------------------------------*/
6217 static void genLeftShift (iCode *ic)
6218 {
6219     operand *left,*right, *result;
6220     int size, offset;
6221     char *l;
6222     symbol *tlbl , *tlbl1;
6223
6224     D(emitcode(";", "genLeftShift "););
6225
6226     right = IC_RIGHT(ic);
6227     left  = IC_LEFT(ic);
6228     result = IC_RESULT(ic);
6229
6230     aopOp(right,ic,FALSE, FALSE);
6231
6232 #if 0
6233     /* if the shift count is known then do it
6234     as efficiently as possible */
6235     if (AOP_TYPE(right) == AOP_LIT) {
6236         genLeftShiftLiteral (left,right,result,ic);
6237         return ;
6238     }
6239 #endif
6240
6241     /* shift count is unknown then we have to form
6242     a loop get the loop count in B : Note: we take
6243     only the lower order byte since shifting
6244     more that 32 bits make no sense anyway, ( the
6245     largest size of an object can be only 32 bits ) */
6246
6247     emitcode("mov","b,%s",aopGet(AOP(right),0,FALSE,FALSE,FALSE));
6248     emitcode("inc","b");
6249     freeAsmop (right,NULL,ic,TRUE);
6250     aopOp(left,ic,FALSE, FALSE);
6251     aopOp(result,ic,FALSE, AOP_TYPE(left) == AOP_DPTR);
6252
6253     /* now move the left to the result if they are not the
6254     same */
6255     if (!sameRegs(AOP(left),AOP(result)) &&
6256         AOP_SIZE(result) > 1) {
6257
6258         size = AOP_SIZE(result);
6259         offset=0;
6260         _startLazyDPSEvaluation();
6261         while (size--) {
6262             l = aopGet(AOP(left),offset,FALSE,TRUE,FALSE);
6263             if (*l == '@' && (IS_AOP_PREG(result))) {
6264
6265                 emitcode("mov","a,%s",l);
6266                 aopPut(AOP(result),"a",offset);
6267             } else
6268                 aopPut(AOP(result),l,offset);
6269             offset++;
6270         }
6271         _endLazyDPSEvaluation();
6272     }
6273
6274     tlbl = newiTempLabel(NULL);
6275     size = AOP_SIZE(result);
6276     offset = 0 ;
6277     tlbl1 = newiTempLabel(NULL);
6278
6279     /* if it is only one byte then */
6280     if (size == 1) {
6281         symbol *tlbl1 = newiTempLabel(NULL);
6282
6283         l = aopGet(AOP(left),0,FALSE,FALSE,TRUE);
6284         MOVA(l);
6285         emitcode("sjmp","%05d$",tlbl1->key+100);
6286         emitcode("","%05d$:",tlbl->key+100);
6287         emitcode("add","a,acc");
6288         emitcode("","%05d$:",tlbl1->key+100);
6289         emitcode("djnz","b,%05d$",tlbl->key+100);
6290         aopPut(AOP(result),"a",0);
6291         goto release ;
6292     }
6293
6294     reAdjustPreg(AOP(result));
6295
6296     emitcode("sjmp","%05d$",tlbl1->key+100);
6297     emitcode("","%05d$:",tlbl->key+100);
6298     l = aopGet(AOP(result),offset,FALSE,FALSE,TRUE);
6299     MOVA(l);
6300     emitcode("add","a,acc");
6301     aopPut(AOP(result),"a",offset++);
6302     _startLazyDPSEvaluation();
6303     while (--size) {
6304         l = aopGet(AOP(result),offset,FALSE,FALSE,TRUE);
6305         MOVA(l);
6306         emitcode("rlc","a");
6307         aopPut(AOP(result),"a",offset++);
6308     }
6309     _endLazyDPSEvaluation();
6310     reAdjustPreg(AOP(result));
6311
6312     emitcode("","%05d$:",tlbl1->key+100);
6313     emitcode("djnz","b,%05d$",tlbl->key+100);
6314 release:
6315     freeAsmop(left,NULL,ic,TRUE);
6316     freeAsmop(result,NULL,ic,TRUE);
6317 }
6318
6319 #if 0
6320 //REMOVE ME!!!
6321 /*-----------------------------------------------------------------*/
6322 /* genrshOne - right shift a one byte quantity by known count      */
6323 /*-----------------------------------------------------------------*/
6324 static void genrshOne (operand *result, operand *left,
6325                        int shCount, int sign)
6326 {
6327     D(emitcode(";", "genrshOne"););
6328     shiftR1Left2Result(left, LSB, result, LSB, shCount, sign);
6329 }
6330 #endif
6331
6332 #if 0
6333 //REMOVE ME!!!
6334 /*-----------------------------------------------------------------*/
6335 /* genrshTwo - right shift two bytes by known amount != 0          */
6336 /*-----------------------------------------------------------------*/
6337 static void genrshTwo (operand *result,operand *left,
6338                        int shCount, int sign)
6339 {
6340     D(emitcode(";", "genrshTwo"););
6341
6342     /* if shCount >= 8 */
6343     if (shCount >= 8) {
6344         shCount -= 8 ;
6345         if (shCount)
6346             shiftR1Left2Result(left, MSB16, result, LSB,
6347                                shCount, sign);
6348         else
6349             movLeft2Result(left, MSB16, result, LSB, sign);
6350         addSign(result, MSB16, sign);
6351     }
6352
6353     /*  1 <= shCount <= 7 */
6354     else
6355         shiftR2Left2Result(left, LSB, result, LSB, shCount, sign);
6356 }
6357 #endif
6358
6359 #if 0
6360 //REMOVE ME!!!
6361 /*-----------------------------------------------------------------*/
6362 /* shiftRLong - shift right one long from left to result           */
6363 /* offl = LSB or MSB16                                             */
6364 /*-----------------------------------------------------------------*/
6365 static void shiftRLong (operand *left, int offl,
6366                         operand *result, int sign)
6367 {
6368     if(!sign)
6369         emitcode("clr","c");
6370     MOVA(aopGet(AOP(left),MSB32,FALSE,FALSE,TRUE));
6371     if(sign)
6372         emitcode("mov","c,acc.7");
6373     emitcode("rrc","a");
6374     aopPut(AOP(result),"a",MSB32-offl);
6375     if(offl == MSB16)
6376         /* add sign of "a" */
6377         addSign(result, MSB32, sign);
6378
6379     MOVA(aopGet(AOP(left),MSB24,FALSE,FALSE,TRUE));
6380     emitcode("rrc","a");
6381     aopPut(AOP(result),"a",MSB24-offl);
6382
6383     MOVA(aopGet(AOP(left),MSB16,FALSE,FALSE,TRUE));
6384     emitcode("rrc","a");
6385     aopPut(AOP(result),"a",MSB16-offl);
6386
6387     if(offl == LSB){
6388         MOVA(aopGet(AOP(left),LSB,FALSE,FALSE,TRUE));
6389         emitcode("rrc","a");
6390         aopPut(AOP(result),"a",LSB);
6391     }
6392 }
6393 #endif
6394
6395 #if 0
6396 //REMOVE ME!!!
6397 /*-----------------------------------------------------------------*/
6398 /* genrshFour - shift four byte by a known amount != 0             */
6399 /*-----------------------------------------------------------------*/
6400 static void genrshFour (operand *result, operand *left,
6401                         int shCount, int sign)
6402 {
6403     D(emitcode(";", "genrshFour"););
6404
6405     /* if shifting more that 3 bytes */
6406     if(shCount >= 24 ) {
6407         shCount -= 24;
6408         if(shCount)
6409             shiftR1Left2Result(left, MSB32, result, LSB, shCount, sign);
6410         else
6411             movLeft2Result(left, MSB32, result, LSB, sign);
6412         addSign(result, MSB16, sign);
6413     }
6414     else if(shCount >= 16){
6415         shCount -= 16;
6416         if(shCount)
6417             shiftR2Left2Result(left, MSB24, result, LSB, shCount, sign);
6418         else{
6419             movLeft2Result(left, MSB24, result, LSB, 0);
6420             movLeft2Result(left, MSB32, result, MSB16, sign);
6421         }
6422         addSign(result, MSB24, sign);
6423     }
6424     else if(shCount >= 8){
6425         shCount -= 8;
6426         if(shCount == 1)
6427             shiftRLong(left, MSB16, result, sign);
6428         else if(shCount == 0){
6429             movLeft2Result(left, MSB16, result, LSB, 0);
6430             movLeft2Result(left, MSB24, result, MSB16, 0);
6431             movLeft2Result(left, MSB32, result, MSB24, sign);
6432             addSign(result, MSB32, sign);
6433         }
6434         else{
6435             shiftR2Left2Result(left, MSB16, result, LSB, shCount, 0);
6436             shiftLLeftOrResult(left, MSB32, result, MSB16, 8 - shCount);
6437             /* the last shift is signed */
6438             shiftR1Left2Result(left, MSB32, result, MSB24, shCount, sign);
6439             addSign(result, MSB32, sign);
6440         }
6441     }
6442     else{   /* 1 <= shCount <= 7 */
6443         if(shCount <= 2){
6444             shiftRLong(left, LSB, result, sign);
6445             if(shCount == 2)
6446                 shiftRLong(result, LSB, result, sign);
6447         }
6448         else{
6449             shiftR2Left2Result(left, LSB, result, LSB, shCount, 0);
6450             shiftLLeftOrResult(left, MSB24, result, MSB16, 8 - shCount);
6451             shiftR2Left2Result(left, MSB24, result, MSB24, shCount, sign);
6452         }
6453     }
6454 }
6455 #endif
6456
6457 #if 0
6458 //REMOVE ME!!!
6459 /*-----------------------------------------------------------------*/
6460 /* genRightShiftLiteral - right shifting by known count            */
6461 /*-----------------------------------------------------------------*/
6462 static void genRightShiftLiteral (operand *left,
6463                                   operand *right,
6464                                   operand *result,
6465                                   iCode *ic,
6466                                   int sign)
6467 {
6468     int shCount = (int) floatFromVal (AOP(right)->aopu.aop_lit);
6469     int size;
6470
6471     D(emitcode(";", "genRightShiftLiteral"););
6472
6473     freeAsmop(right,NULL,ic,TRUE);
6474
6475     aopOp(left,ic,FALSE, FALSE);
6476     aopOp(result,ic,FALSE, AOP_TYPE(left) == AOP_DPTR);
6477
6478 #if VIEW_SIZE
6479     emitcode("; shift right ","result %d, left %d",AOP_SIZE(result),
6480              AOP_SIZE(left));
6481 #endif
6482
6483     size = getDataSize(left);
6484     /* test the LEFT size !!! */
6485
6486     /* I suppose that the left size >= result size */
6487     if(shCount == 0){
6488         size = getDataSize(result);
6489         while(size--)
6490             movLeft2Result(left, size, result, size, 0);
6491     }
6492
6493     else if(shCount >= (size * 8)){
6494         if(sign)
6495             /* get sign in acc.7 */
6496             MOVA(aopGet(AOP(left),size-1,FALSE,FALSE,TRUE));
6497         addSign(result, LSB, sign);
6498     } else{
6499         switch (size) {
6500             case 1:
6501                 genrshOne (result,left,shCount,sign);
6502                 break;
6503
6504             case 2:
6505                 genrshTwo (result,left,shCount,sign);
6506                 break;
6507
6508             case 4:
6509                 genrshFour (result,left,shCount,sign);
6510                 break;
6511             default :
6512                 break;
6513         }
6514
6515         freeAsmop(left,NULL,ic,TRUE);
6516         freeAsmop(result,NULL,ic,TRUE);
6517     }
6518 }
6519 #endif
6520
6521 /*-----------------------------------------------------------------*/
6522 /* genSignedRightShift - right shift of signed number              */
6523 /*-----------------------------------------------------------------*/
6524 static void genSignedRightShift (iCode *ic)
6525 {
6526     operand *right, *left, *result;
6527     int size, offset;
6528     char *l;
6529     symbol *tlbl, *tlbl1 ;
6530
6531     D(emitcode(";", "genSignedRightShift "););
6532
6533     /* we do it the hard way put the shift count in b
6534     and loop thru preserving the sign */
6535
6536     right = IC_RIGHT(ic);
6537     left  = IC_LEFT(ic);
6538     result = IC_RESULT(ic);
6539
6540     aopOp(right,ic,FALSE, FALSE);
6541
6542 #if 0
6543     if ( AOP_TYPE(right) == AOP_LIT) {
6544         genRightShiftLiteral (left,right,result,ic,1);
6545         return ;
6546     }
6547 #endif
6548     /* shift count is unknown then we have to form
6549        a loop get the loop count in B : Note: we take
6550        only the lower order byte since shifting
6551        more that 32 bits make no sense anyway, ( the
6552        largest size of an object can be only 32 bits ) */
6553
6554     emitcode("mov","b,%s",aopGet(AOP(right),0,FALSE,FALSE,FALSE));
6555     emitcode("inc","b");
6556     freeAsmop (right,NULL,ic,TRUE);
6557     aopOp(left,ic,FALSE, FALSE);
6558     aopOp(result,ic,FALSE, AOP_TYPE(left) == AOP_DPTR);
6559
6560     /* now move the left to the result if they are not the
6561     same */
6562     if (!sameRegs(AOP(left),AOP(result)) &&
6563         AOP_SIZE(result) > 1) {
6564
6565         size = AOP_SIZE(result);
6566         offset=0;
6567         _startLazyDPSEvaluation();
6568         while (size--) {
6569             l = aopGet(AOP(left),offset,FALSE,TRUE,FALSE);
6570             if (*l == '@' && IS_AOP_PREG(result)) {
6571
6572                 emitcode("mov","a,%s",l);
6573                 aopPut(AOP(result),"a",offset);
6574             } else
6575                 aopPut(AOP(result),l,offset);
6576             offset++;
6577         }
6578         _endLazyDPSEvaluation();
6579     }
6580
6581     /* mov the highest order bit to OVR */
6582     tlbl = newiTempLabel(NULL);
6583     tlbl1= newiTempLabel(NULL);
6584
6585     size = AOP_SIZE(result);
6586     offset = size - 1;
6587     emitcode("mov","a,%s",aopGet(AOP(left),offset,FALSE,FALSE,FALSE));
6588     emitcode("rlc","a");
6589     emitcode("mov","ov,c");
6590     /* if it is only one byte then */
6591     if (size == 1) {
6592         l = aopGet(AOP(left),0,FALSE,FALSE,TRUE);
6593         MOVA(l);
6594         emitcode("sjmp","%05d$",tlbl1->key+100);
6595         emitcode("","%05d$:",tlbl->key+100);
6596         emitcode("mov","c,ov");
6597         emitcode("rrc","a");
6598         emitcode("","%05d$:",tlbl1->key+100);
6599         emitcode("djnz","b,%05d$",tlbl->key+100);
6600         aopPut(AOP(result),"a",0);
6601         goto release ;
6602     }
6603
6604     reAdjustPreg(AOP(result));
6605     emitcode("sjmp","%05d$",tlbl1->key+100);
6606     emitcode("","%05d$:",tlbl->key+100);
6607     emitcode("mov","c,ov");
6608     _startLazyDPSEvaluation();
6609     while (size--) {
6610         l = aopGet(AOP(result),offset,FALSE,FALSE,TRUE);
6611         MOVA(l);
6612         emitcode("rrc","a");
6613         aopPut(AOP(result),"a",offset--);
6614     }
6615     _endLazyDPSEvaluation();
6616     reAdjustPreg(AOP(result));
6617     emitcode("","%05d$:",tlbl1->key+100);
6618     emitcode("djnz","b,%05d$",tlbl->key+100);
6619
6620 release:
6621     freeAsmop(left,NULL,ic,TRUE);
6622     freeAsmop(result,NULL,ic,TRUE);
6623 }
6624
6625 /*-----------------------------------------------------------------*/
6626 /* genRightShift - generate code for right shifting                */
6627 /*-----------------------------------------------------------------*/
6628 static void genRightShift (iCode *ic)
6629 {
6630     operand *right, *left, *result;
6631     sym_link *retype ;
6632     int size, offset;
6633     char *l;
6634     symbol *tlbl, *tlbl1 ;
6635
6636     D(emitcode(";", "genRightShift "););
6637
6638     /* if signed then we do it the hard way preserve the
6639     sign bit moving it inwards */
6640     retype = getSpec(operandType(IC_RESULT(ic)));
6641
6642     if (!SPEC_USIGN(retype)) {
6643         genSignedRightShift (ic);
6644         return ;
6645     }
6646
6647     /* signed & unsigned types are treated the same : i.e. the
6648     signed is NOT propagated inwards : quoting from the
6649     ANSI - standard : "for E1 >> E2, is equivalent to division
6650     by 2**E2 if unsigned or if it has a non-negative value,
6651     otherwise the result is implementation defined ", MY definition
6652     is that the sign does not get propagated */
6653
6654     right = IC_RIGHT(ic);
6655     left  = IC_LEFT(ic);
6656     result = IC_RESULT(ic);
6657
6658     aopOp(right,ic,FALSE, FALSE);
6659
6660 #if 0
6661     /* if the shift count is known then do it
6662     as efficiently as possible */
6663     if (AOP_TYPE(right) == AOP_LIT) {
6664         genRightShiftLiteral (left,right,result,ic, 0);
6665         return ;
6666     }
6667 #endif
6668
6669     /* shift count is unknown then we have to form
6670     a loop get the loop count in B : Note: we take
6671     only the lower order byte since shifting
6672     more that 32 bits make no sense anyway, ( the
6673     largest size of an object can be only 32 bits ) */
6674
6675     emitcode("mov","b,%s",aopGet(AOP(right),0,FALSE,FALSE,FALSE));
6676     emitcode("inc","b");
6677     freeAsmop (right,NULL,ic,TRUE);
6678     aopOp(left,ic,FALSE, FALSE);
6679     aopOp(result,ic,FALSE, AOP_TYPE(left) == AOP_DPTR);
6680
6681     /* now move the left to the result if they are not the
6682     same */
6683     if (!sameRegs(AOP(left),AOP(result)) &&
6684         AOP_SIZE(result) > 1) {
6685
6686         size = AOP_SIZE(result);
6687         offset=0;
6688         _startLazyDPSEvaluation();
6689         while (size--) {
6690             l = aopGet(AOP(left),offset,FALSE,TRUE,FALSE);
6691             if (*l == '@' && IS_AOP_PREG(result)) {
6692
6693                 emitcode("mov","a,%s",l);
6694                 aopPut(AOP(result),"a",offset);
6695             } else
6696                 aopPut(AOP(result),l,offset);
6697             offset++;
6698         }
6699         _endLazyDPSEvaluation();
6700     }
6701
6702     tlbl = newiTempLabel(NULL);
6703     tlbl1= newiTempLabel(NULL);
6704     size = AOP_SIZE(result);
6705     offset = size - 1;
6706
6707     /* if it is only one byte then */
6708     if (size == 1) {
6709         l = aopGet(AOP(left),0,FALSE,FALSE,TRUE);
6710         MOVA(l);
6711         emitcode("sjmp","%05d$",tlbl1->key+100);
6712         emitcode("","%05d$:",tlbl->key+100);
6713         CLRC;
6714         emitcode("rrc","a");
6715         emitcode("","%05d$:",tlbl1->key+100);
6716         emitcode("djnz","b,%05d$",tlbl->key+100);
6717         aopPut(AOP(result),"a",0);
6718         goto release ;
6719     }
6720
6721     reAdjustPreg(AOP(result));
6722     emitcode("sjmp","%05d$",tlbl1->key+100);
6723     emitcode("","%05d$:",tlbl->key+100);
6724     CLRC;
6725     _startLazyDPSEvaluation();
6726     while (size--) {
6727         l = aopGet(AOP(result),offset,FALSE,FALSE,TRUE);
6728         MOVA(l);
6729         emitcode("rrc","a");
6730         aopPut(AOP(result),"a",offset--);
6731     }
6732     _endLazyDPSEvaluation();
6733     reAdjustPreg(AOP(result));
6734
6735     emitcode("","%05d$:",tlbl1->key+100);
6736     emitcode("djnz","b,%05d$",tlbl->key+100);
6737
6738 release:
6739     freeAsmop(left,NULL,ic,TRUE);
6740     freeAsmop(result,NULL,ic,TRUE);
6741 }
6742
6743 /*-----------------------------------------------------------------*/
6744 /* genUnpackBits - generates code for unpacking bits               */
6745 /*-----------------------------------------------------------------*/
6746 static void genUnpackBits (operand *result, char *rname, int ptype)
6747 {
6748     int shCnt ;
6749     int rlen = 0 ;
6750     sym_link *etype;
6751     int offset = 0 ;
6752
6753     D(emitcode(";", "genUnpackBits "););
6754
6755     etype = getSpec(operandType(result));
6756
6757     /* read the first byte  */
6758     switch (ptype) {
6759
6760     case POINTER:
6761     case IPOINTER:
6762         emitcode("mov","a,@%s",rname);
6763         break;
6764
6765     case PPOINTER:
6766         emitcode("movx","a,@%s",rname);
6767         break;
6768
6769     case FPOINTER:
6770         emitcode("movx","a,@dptr");
6771         break;
6772
6773     case CPOINTER:
6774         emitcode("clr","a");
6775         emitcode("movc","a","@a+dptr");
6776         break;
6777
6778     case GPOINTER:
6779         emitcode("lcall","__gptrget");
6780         break;
6781     }
6782
6783     /* if we have bitdisplacement then it fits   */
6784     /* into this byte completely or if length is */
6785     /* less than a byte                          */
6786     if ((shCnt = SPEC_BSTR(etype)) ||
6787         (SPEC_BLEN(etype) <= 8))  {
6788
6789         /* shift right acc */
6790         AccRsh(shCnt);
6791
6792         emitcode("anl","a,#0x%02x",
6793                  ((unsigned char) -1)>>(8 - SPEC_BLEN(etype)));
6794         aopPut(AOP(result),"a",offset);
6795         return ;
6796     }
6797
6798     /* bit field did not fit in a byte  */
6799     rlen = SPEC_BLEN(etype) - 8;
6800     aopPut(AOP(result),"a",offset++);
6801
6802     while (1)  {
6803
6804         switch (ptype) {
6805         case POINTER:
6806         case IPOINTER:
6807             emitcode("inc","%s",rname);
6808             emitcode("mov","a,@%s",rname);
6809             break;
6810
6811         case PPOINTER:
6812             emitcode("inc","%s",rname);
6813             emitcode("movx","a,@%s",rname);
6814             break;
6815
6816         case FPOINTER:
6817             emitcode("inc","dptr");
6818             emitcode("movx","a,@dptr");
6819             break;
6820
6821         case CPOINTER:
6822             emitcode("clr","a");
6823             emitcode("inc","dptr");
6824             emitcode("movc","a","@a+dptr");
6825             break;
6826
6827         case GPOINTER:
6828             emitcode("inc","dptr");
6829             emitcode("lcall","__gptrget");
6830             break;
6831         }
6832
6833         rlen -= 8;
6834         /* if we are done */
6835         if ( rlen < 8 )
6836             break ;
6837
6838         aopPut(AOP(result),"a",offset++);
6839
6840     }
6841
6842     if (rlen) {
6843         emitcode("anl","a,#0x%02x",((unsigned char)-1)>>(rlen));
6844         aopPut(AOP(result),"a",offset);
6845     }
6846
6847     return ;
6848 }
6849
6850
6851 /*-----------------------------------------------------------------*/
6852 /* genDataPointerGet - generates code when ptr offset is known     */
6853 /*-----------------------------------------------------------------*/
6854 static void genDataPointerGet (operand *left,
6855                                operand *result,
6856                                iCode *ic)
6857 {
6858     char *l;
6859     char buffer[256];
6860     int size , offset = 0;
6861     aopOp(result,ic,TRUE, FALSE);
6862
6863     /* get the string representation of the name */
6864     l = aopGet(AOP(left),0,FALSE,TRUE,FALSE);
6865     size = AOP_SIZE(result);
6866     _startLazyDPSEvaluation();
6867     while (size--) {
6868         if (offset)
6869             sprintf(buffer,"(%s + %d)",l+1,offset);
6870         else
6871             sprintf(buffer,"%s",l+1);
6872         aopPut(AOP(result),buffer,offset++);
6873     }
6874     _endLazyDPSEvaluation();
6875
6876     freeAsmop(left,NULL,ic,TRUE);
6877     freeAsmop(result,NULL,ic,TRUE);
6878 }
6879
6880 /*-----------------------------------------------------------------*/
6881 /* genNearPointerGet - emitcode for near pointer fetch             */
6882 /*-----------------------------------------------------------------*/
6883 static void genNearPointerGet (operand *left,
6884                                operand *result,
6885                                iCode *ic)
6886 {
6887     asmop *aop = NULL;
6888     regs *preg = NULL ;
6889     char *rname ;
6890     sym_link *rtype, *retype, *letype;
6891     sym_link *ltype = operandType(left);
6892     char buffer[80];
6893
6894     rtype = operandType(result);
6895     retype= getSpec(rtype);
6896     letype= getSpec(ltype);
6897
6898     aopOp(left,ic,FALSE, FALSE);
6899
6900     /* if left is rematerialisable and
6901        result is not bit variable type and
6902        the left is pointer to data space i.e
6903        lower 128 bytes of space */
6904     if (AOP_TYPE(left) == AOP_IMMD &&
6905         !IS_BITVAR(retype)         &&
6906         !IS_BITVAR(letype)         &&
6907         DCL_TYPE(ltype) == POINTER) {
6908         genDataPointerGet (left,result,ic);
6909         return ;
6910     }
6911
6912         /* if the value is already in a pointer register
6913        then don't need anything more */
6914     if (!AOP_INPREG(AOP(left))) {
6915         /* otherwise get a free pointer register */
6916         aop = newAsmop(0);
6917         preg = getFreePtr(ic,&aop,FALSE);
6918         emitcode("mov","%s,%s",
6919                 preg->name,
6920                 aopGet(AOP(left),0,FALSE,TRUE,FALSE));
6921         rname = preg->name ;
6922     } else
6923         rname = aopGet(AOP(left),0,FALSE,FALSE,FALSE);
6924
6925     freeAsmop(left,NULL,ic,TRUE);
6926     aopOp (result,ic,FALSE, FALSE);
6927
6928       /* if bitfield then unpack the bits */
6929     if (IS_BITVAR(retype) || IS_BITVAR(letype))
6930         genUnpackBits (result,rname,POINTER);
6931     else {
6932         /* we have can just get the values */
6933         int size = AOP_SIZE(result);
6934         int offset = 0 ;
6935
6936         while (size--) {
6937             if (IS_AOP_PREG(result) || AOP_TYPE(result) == AOP_STK ) {
6938
6939                 emitcode("mov","a,@%s",rname);
6940                 aopPut(AOP(result),"a",offset);
6941             } else {
6942                 sprintf(buffer,"@%s",rname);
6943                 aopPut(AOP(result),buffer,offset);
6944             }
6945             offset++ ;
6946             if (size)
6947                 emitcode("inc","%s",rname);
6948         }
6949     }
6950
6951     /* now some housekeeping stuff */
6952     if (aop) {
6953         /* we had to allocate for this iCode */
6954         freeAsmop(NULL,aop,ic,TRUE);
6955     } else {
6956         /* we did not allocate which means left
6957            already in a pointer register, then
6958            if size > 0 && this could be used again
6959            we have to point it back to where it
6960            belongs */
6961         if (AOP_SIZE(result) > 1 &&
6962             !OP_SYMBOL(left)->remat &&
6963             ( OP_SYMBOL(left)->liveTo > ic->seq ||
6964               ic->depth )) {
6965             int size = AOP_SIZE(result) - 1;
6966             while (size--)
6967                 emitcode("dec","%s",rname);
6968         }
6969     }
6970
6971     /* done */
6972     freeAsmop(result,NULL,ic,TRUE);
6973
6974 }
6975
6976 /*-----------------------------------------------------------------*/
6977 /* genPagedPointerGet - emitcode for paged pointer fetch           */
6978 /*-----------------------------------------------------------------*/
6979 static void genPagedPointerGet (operand *left,
6980                                operand *result,
6981                                iCode *ic)
6982 {
6983     asmop *aop = NULL;
6984     regs *preg = NULL ;
6985     char *rname;
6986     sym_link *rtype, *retype, *letype;
6987
6988     rtype = operandType(result);
6989     retype= getSpec(rtype);
6990     letype= getSpec(operandType(left));
6991     aopOp(left,ic,FALSE, FALSE);
6992
6993   /* if the value is already in a pointer register
6994        then don't need anything more */
6995     if (!AOP_INPREG(AOP(left))) {
6996         /* otherwise get a free pointer register */
6997         aop = newAsmop(0);
6998         preg = getFreePtr(ic,&aop,FALSE);
6999         emitcode("mov","%s,%s",
7000                 preg->name,
7001                 aopGet(AOP(left),0,FALSE,TRUE,FALSE));
7002         rname = preg->name ;
7003     } else
7004         rname = aopGet(AOP(left),0,FALSE,FALSE,FALSE);
7005
7006     freeAsmop(left,NULL,ic,TRUE);
7007     aopOp (result,ic,FALSE, FALSE);
7008
7009     /* if bitfield then unpack the bits */
7010     if (IS_BITVAR(retype) || IS_BITVAR(letype))
7011         genUnpackBits (result,rname,PPOINTER);
7012     else {
7013         /* we have can just get the values */
7014         int size = AOP_SIZE(result);
7015         int offset = 0 ;
7016
7017         while (size--) {
7018
7019             emitcode("movx","a,@%s",rname);
7020             aopPut(AOP(result),"a",offset);
7021
7022             offset++ ;
7023
7024             if (size)
7025                 emitcode("inc","%s",rname);
7026         }
7027     }
7028
7029     /* now some housekeeping stuff */
7030     if (aop) {
7031         /* we had to allocate for this iCode */
7032         freeAsmop(NULL,aop,ic,TRUE);
7033     } else {
7034         /* we did not allocate which means left
7035            already in a pointer register, then
7036            if size > 0 && this could be used again
7037            we have to point it back to where it
7038            belongs */
7039         if (AOP_SIZE(result) > 1 &&
7040             !OP_SYMBOL(left)->remat &&
7041             ( OP_SYMBOL(left)->liveTo > ic->seq ||
7042               ic->depth )) {
7043             int size = AOP_SIZE(result) - 1;
7044             while (size--)
7045                 emitcode("dec","%s",rname);
7046         }
7047     }
7048
7049     /* done */
7050     freeAsmop(result,NULL,ic,TRUE);
7051
7052
7053 }
7054
7055 /*-----------------------------------------------------------------*/
7056 /* genFarPointerGet - gget value from far space                    */
7057 /*-----------------------------------------------------------------*/
7058 static void genFarPointerGet (operand *left,
7059                               operand *result, iCode *ic)
7060 {
7061     int size, offset ;
7062     sym_link *retype = getSpec(operandType(result));
7063     sym_link *letype = getSpec(operandType(left));
7064     D(emitcode(";", "genFarPointerGet"););
7065
7066     aopOp(left,ic,FALSE, FALSE);
7067
7068     /* if the operand is already in dptr
7069     then we do nothing else we move the value to dptr */
7070     if (AOP_TYPE(left) != AOP_STR) {
7071         /* if this is remateriazable */
7072         if (AOP_TYPE(left) == AOP_IMMD)
7073         {
7074             emitcode("mov","dptr,%s",aopGet(AOP(left),0,TRUE,FALSE,FALSE));
7075         }
7076         else
7077         {
7078             /* we need to get it byte by byte */
7079             _startLazyDPSEvaluation();
7080             if (AOP_TYPE(left) != AOP_DPTR)
7081             {
7082                 emitcode("mov","dpl,%s",aopGet(AOP(left),0,FALSE,FALSE,TRUE));
7083                 emitcode("mov","dph,%s",aopGet(AOP(left),1,FALSE,FALSE,TRUE));
7084                 emitcode("mov","dpx,%s",aopGet(AOP(left),2,FALSE,FALSE,TRUE));
7085             }
7086             else
7087             {
7088                  /* We need to generate a load to DPTR indirect through DPTR. */
7089                  D(emitcode(";", "genFarPointerGet -- indirection special case."););
7090                  emitcode("push", "%s", aopGet(AOP(left),0,FALSE,TRUE,TRUE));
7091                  emitcode("push", "%s", aopGet(AOP(left),1,FALSE,TRUE,TRUE));
7092                  emitcode("mov", "dpx,%s",aopGet(AOP(left),2,FALSE,FALSE,TRUE));
7093                  emitcode("pop", "dph");
7094                  emitcode("pop", "dpl");
7095             }
7096             _endLazyDPSEvaluation();
7097         }
7098     }
7099     /* so dptr know contains the address */
7100     freeAsmop(left,NULL,ic,TRUE);
7101     aopOp(result,ic,FALSE, TRUE);
7102
7103     /* if bit then unpack */
7104     if (IS_BITVAR(retype) || IS_BITVAR(letype))
7105         genUnpackBits(result,"dptr",FPOINTER);
7106     else {
7107         size = AOP_SIZE(result);
7108         offset = 0 ;
7109
7110         _startLazyDPSEvaluation();
7111         while (size--) {
7112
7113             genSetDPTR(0);
7114             _flushLazyDPS();
7115
7116             emitcode("movx","a,@dptr");
7117             if (size)
7118                 emitcode("inc","dptr");
7119
7120             aopPut(AOP(result),"a",offset++);
7121         }
7122         _endLazyDPSEvaluation();
7123     }
7124
7125     freeAsmop(result,NULL,ic,TRUE);
7126 }
7127
7128 /*-----------------------------------------------------------------*/
7129 /* emitcodePointerGet - gget value from code space                  */
7130 /*-----------------------------------------------------------------*/
7131 static void emitcodePointerGet (operand *left,
7132                                 operand *result, iCode *ic)
7133 {
7134     int size, offset ;
7135     sym_link *retype = getSpec(operandType(result));
7136
7137     aopOp(left,ic,FALSE, FALSE);
7138
7139     /* if the operand is already in dptr
7140     then we do nothing else we move the value to dptr */
7141     if (AOP_TYPE(left) != AOP_STR) {
7142         /* if this is remateriazable */
7143         if (AOP_TYPE(left) == AOP_IMMD)
7144         {
7145             emitcode("mov","dptr,%s",aopGet(AOP(left),0,TRUE,FALSE,FALSE));
7146         }
7147         else
7148         { /* we need to get it byte by byte */
7149             _startLazyDPSEvaluation();
7150             if (AOP_TYPE(left) != AOP_DPTR)
7151             {
7152                 emitcode("mov","dpl,%s",aopGet(AOP(left),0,FALSE,FALSE,TRUE));
7153                 emitcode("mov","dph,%s",aopGet(AOP(left),1,FALSE,FALSE,TRUE));
7154                 emitcode("mov","dpx,%s",aopGet(AOP(left),2,FALSE,FALSE,TRUE));
7155             }
7156             else
7157             {
7158                  /* We need to generate a load to DPTR indirect through DPTR. */
7159                  D(emitcode(";", "gencodePointerGet -- indirection special case."););
7160                  emitcode("push", "%s", aopGet(AOP(left),0,FALSE,TRUE,TRUE));
7161                  emitcode("push", "%s", aopGet(AOP(left),1,FALSE,TRUE,TRUE));
7162                  emitcode("mov", "dpx,%s",aopGet(AOP(left),2,FALSE,FALSE,TRUE));
7163                  emitcode("pop", "dph");
7164                  emitcode("pop", "dpl");
7165             }
7166             _endLazyDPSEvaluation();
7167         }
7168     }
7169     /* so dptr know contains the address */
7170     freeAsmop(left,NULL,ic,TRUE);
7171     aopOp(result,ic,FALSE, TRUE);
7172
7173     /* if bit then unpack */
7174     if (IS_BITVAR(retype))
7175         genUnpackBits(result,"dptr",CPOINTER);
7176     else {
7177         size = AOP_SIZE(result);
7178         offset = 0 ;
7179
7180         _startLazyDPSEvaluation();
7181         while (size--)
7182         {
7183             genSetDPTR(0);
7184             _flushLazyDPS();
7185
7186             emitcode("clr","a");
7187             emitcode("movc","a,@a+dptr");
7188             if (size)
7189                 emitcode("inc","dptr");
7190             aopPut(AOP(result),"a",offset++);
7191         }
7192         _endLazyDPSEvaluation();
7193     }
7194
7195     freeAsmop(result,NULL,ic,TRUE);
7196 }
7197
7198 /*-----------------------------------------------------------------*/
7199 /* genGenPointerGet - gget value from generic pointer space        */
7200 /*-----------------------------------------------------------------*/
7201 static void genGenPointerGet (operand *left,
7202                               operand *result, iCode *ic)
7203 {
7204     int size, offset ;
7205     sym_link *retype = getSpec(operandType(result));
7206     sym_link *letype = getSpec(operandType(left));
7207
7208     aopOp(left,ic,FALSE, TRUE);
7209
7210     /* if the operand is already in dptr
7211     then we do nothing else we move the value to dptr */
7212     if (AOP_TYPE(left) != AOP_STR) {
7213         /* if this is remateriazable */
7214         if (AOP_TYPE(left) == AOP_IMMD) {
7215             emitcode("mov","dptr,%s",aopGet(AOP(left),0,TRUE,FALSE,FALSE));
7216             emitcode("mov","b,#%d",pointerCode(retype));
7217         }
7218         else { /* we need to get it byte by byte */
7219             _startLazyDPSEvaluation();
7220             emitcode("mov","dpl,%s",aopGet(AOP(left),0,FALSE,FALSE,TRUE));
7221             emitcode("mov","dph,%s",aopGet(AOP(left),1,FALSE,FALSE,TRUE));
7222             emitcode("mov","dpx,%s",aopGet(AOP(left),2,FALSE,FALSE,TRUE));
7223             emitcode("mov","b,%s",aopGet(AOP(left),3,FALSE,FALSE,TRUE));
7224             _endLazyDPSEvaluation();
7225         }
7226     }
7227     /* so dptr know contains the address */
7228     freeAsmop(left,NULL,ic,TRUE);
7229     aopOp(result,ic,FALSE, TRUE);
7230
7231     /* if bit then unpack */
7232     if (IS_BITVAR(retype) || IS_BITVAR(letype))
7233         genUnpackBits(result,"dptr",GPOINTER);
7234     else {
7235         size = AOP_SIZE(result);
7236         offset = 0 ;
7237
7238         while (size--) {
7239             emitcode("lcall","__gptrget");
7240             aopPut(AOP(result),"a",offset++);
7241             if (size)
7242                 emitcode("inc","dptr");
7243         }
7244     }
7245
7246     freeAsmop(result,NULL,ic,TRUE);
7247 }
7248
7249 /*-----------------------------------------------------------------*/
7250 /* genPointerGet - generate code for pointer get                   */
7251 /*-----------------------------------------------------------------*/
7252 static void genPointerGet (iCode *ic)
7253 {
7254     operand *left, *result ;
7255     sym_link *type, *etype;
7256     int p_type;
7257
7258     D(emitcode(";", "genPointerGet "););
7259
7260     left = IC_LEFT(ic);
7261     result = IC_RESULT(ic) ;
7262
7263     /* depending on the type of pointer we need to
7264     move it to the correct pointer register */
7265     type = operandType(left);
7266     etype = getSpec(type);
7267     /* if left is of type of pointer then it is simple */
7268     if (IS_PTR(type) && !IS_FUNC(type->next))
7269         p_type = DCL_TYPE(type);
7270     else {
7271         /* we have to go by the storage class */
7272         p_type = PTR_TYPE(SPEC_OCLS(etype));
7273     }
7274
7275     /* now that we have the pointer type we assign
7276     the pointer values */
7277     switch (p_type) {
7278
7279     case POINTER:
7280     case IPOINTER:
7281         genNearPointerGet (left,result,ic);
7282         break;
7283
7284     case PPOINTER:
7285         genPagedPointerGet(left,result,ic);
7286         break;
7287
7288     case FPOINTER:
7289         genFarPointerGet (left,result,ic);
7290         break;
7291
7292     case CPOINTER:
7293         emitcodePointerGet (left,result,ic);
7294         break;
7295
7296     case GPOINTER:
7297         genGenPointerGet (left,result,ic);
7298         break;
7299     }
7300
7301 }
7302
7303 /*-----------------------------------------------------------------*/
7304 /* genPackBits - generates code for packed bit storage             */
7305 /*-----------------------------------------------------------------*/
7306 static void genPackBits (sym_link    *etype ,
7307                          operand *right ,
7308                          char *rname, int p_type)
7309 {
7310     int shCount = 0 ;
7311     int offset = 0  ;
7312     int rLen = 0 ;
7313     int blen, bstr ;
7314     char *l ;
7315
7316     blen = SPEC_BLEN(etype);
7317     bstr = SPEC_BSTR(etype);
7318
7319     l = aopGet(AOP(right),offset++,FALSE,FALSE,TRUE);
7320     MOVA(l);
7321
7322     /* if the bit lenth is less than or    */
7323     /* it exactly fits a byte then         */
7324     if (SPEC_BLEN(etype) <= 8 )  {
7325         shCount = SPEC_BSTR(etype) ;
7326
7327         /* shift left acc */
7328         AccLsh(shCount);
7329
7330         if (SPEC_BLEN(etype) < 8 ) { /* if smaller than a byte */
7331
7332
7333             switch (p_type) {
7334                 case POINTER:
7335                     emitcode ("mov","b,a");
7336                     emitcode("mov","a,@%s",rname);
7337                     break;
7338
7339                 case FPOINTER:
7340                     emitcode ("mov","b,a");
7341                     emitcode("movx","a,@dptr");
7342                     break;
7343
7344                 case GPOINTER:
7345                     emitcode ("push","b");
7346                     emitcode ("push","acc");
7347                     emitcode ("lcall","__gptrget");
7348                     emitcode ("pop","b");
7349                     break;
7350             }
7351
7352             emitcode ("anl","a,#0x%02x",(unsigned char)
7353                       ((unsigned char)(0xFF << (blen+bstr)) |
7354                        (unsigned char)(0xFF >> (8-bstr)) ) );
7355             emitcode ("orl","a,b");
7356             if (p_type == GPOINTER)
7357                 emitcode("pop","b");
7358         }
7359     }
7360
7361     switch (p_type) {
7362         case POINTER:
7363             emitcode("mov","@%s,a",rname);
7364             break;
7365
7366         case FPOINTER:
7367             emitcode("movx","@dptr,a");
7368             break;
7369
7370         case GPOINTER:
7371             emitcode("lcall","__gptrput");
7372             break;
7373     }
7374
7375     /* if we r done */
7376     if ( SPEC_BLEN(etype) <= 8 )
7377         return ;
7378
7379     emitcode("inc","%s",rname);
7380     rLen = SPEC_BLEN(etype) ;
7381
7382     /* now generate for lengths greater than one byte */
7383     while (1) {
7384
7385         l = aopGet(AOP(right),offset++,FALSE,TRUE,FALSE);
7386
7387         rLen -= 8 ;
7388         if (rLen < 8 )
7389             break ;
7390
7391         switch (p_type) {
7392             case POINTER:
7393                 if (*l == '@') {
7394                     MOVA(l);
7395                     emitcode("mov","@%s,a",rname);
7396                 } else
7397                     emitcode("mov","@%s,%s",rname,l);
7398                 break;
7399
7400             case FPOINTER:
7401                 MOVA(l);
7402                 emitcode("movx","@dptr,a");
7403                 break;
7404
7405             case GPOINTER:
7406                 MOVA(l);
7407                 emitcode("lcall","__gptrput");
7408                 break;
7409         }
7410         emitcode ("inc","%s",rname);
7411     }
7412
7413     MOVA(l);
7414
7415     /* last last was not complete */
7416     if (rLen)   {
7417         /* save the byte & read byte */
7418         switch (p_type) {
7419             case POINTER:
7420                 emitcode ("mov","b,a");
7421                 emitcode("mov","a,@%s",rname);
7422                 break;
7423
7424             case FPOINTER:
7425                 emitcode ("mov","b,a");
7426                 emitcode("movx","a,@dptr");
7427                 break;
7428
7429             case GPOINTER:
7430                 emitcode ("push","b");
7431                 emitcode ("push","acc");
7432                 emitcode ("lcall","__gptrget");
7433                 emitcode ("pop","b");
7434                 break;
7435         }
7436
7437         emitcode ("anl","a,#0x%02x",((unsigned char)-1 << rLen) );
7438         emitcode ("orl","a,b");
7439     }
7440
7441     if (p_type == GPOINTER)
7442         emitcode("pop","b");
7443
7444     switch (p_type) {
7445
7446     case POINTER:
7447         emitcode("mov","@%s,a",rname);
7448         break;
7449
7450     case FPOINTER:
7451         emitcode("movx","@dptr,a");
7452         break;
7453
7454     case GPOINTER:
7455         emitcode("lcall","__gptrput");
7456         break;
7457     }
7458 }
7459 /*-----------------------------------------------------------------*/
7460 /* genDataPointerSet - remat pointer to data space                 */
7461 /*-----------------------------------------------------------------*/
7462 static void genDataPointerSet(operand *right,
7463                               operand *result,
7464                               iCode *ic)
7465 {
7466     int size, offset = 0 ;
7467     char *l, buffer[256];
7468
7469     aopOp(right,ic,FALSE, FALSE);
7470
7471     l = aopGet(AOP(result),0,FALSE,TRUE,FALSE);
7472     size = AOP_SIZE(right);
7473     while (size--) {
7474         if (offset)
7475             sprintf(buffer,"(%s + %d)",l+1,offset);
7476         else
7477             sprintf(buffer,"%s",l+1);
7478         emitcode("mov","%s,%s",buffer,
7479                  aopGet(AOP(right),offset++,FALSE,FALSE,FALSE));
7480     }
7481
7482     freeAsmop(right,NULL,ic,TRUE);
7483     freeAsmop(result,NULL,ic,TRUE);
7484 }
7485
7486 /*-----------------------------------------------------------------*/
7487 /* genNearPointerSet - emitcode for near pointer put                */
7488 /*-----------------------------------------------------------------*/
7489 static void genNearPointerSet (operand *right,
7490                                operand *result,
7491                                iCode *ic)
7492 {
7493     asmop *aop = NULL;
7494     regs *preg = NULL ;
7495     char *rname , *l;
7496     sym_link *retype, *letype;
7497     sym_link *ptype = operandType(result);
7498
7499     retype= getSpec(operandType(right));
7500     letype= getSpec(ptype);
7501
7502     aopOp(result,ic,FALSE, FALSE);
7503
7504     /* if the result is rematerializable &
7505        in data space & not a bit variable */
7506     if (AOP_TYPE(result) == AOP_IMMD &&
7507         DCL_TYPE(ptype) == POINTER   &&
7508         !IS_BITVAR(retype) &&
7509         !IS_BITVAR(letype)) {
7510         genDataPointerSet (right,result,ic);
7511         return;
7512     }
7513
7514     /* if the value is already in a pointer register
7515     then don't need anything more */
7516     if (!AOP_INPREG(AOP(result))) {
7517         /* otherwise get a free pointer register */
7518         aop = newAsmop(0);
7519         preg = getFreePtr(ic,&aop,FALSE);
7520         emitcode("mov","%s,%s",
7521                  preg->name,
7522                  aopGet(AOP(result),0,FALSE,TRUE,FALSE));
7523         rname = preg->name ;
7524     } else
7525         rname = aopGet(AOP(result),0,FALSE,FALSE,FALSE);
7526
7527     freeAsmop(result,NULL,ic,TRUE);
7528     aopOp (right,ic,FALSE, FALSE);
7529
7530     /* if bitfield then unpack the bits */
7531     if (IS_BITVAR(retype) || IS_BITVAR(letype))
7532         genPackBits ((IS_BITVAR(retype) ? retype : letype),right,rname,POINTER);
7533     else {
7534         /* we have can just get the values */
7535         int size = AOP_SIZE(right);
7536         int offset = 0 ;
7537
7538         while (size--) {
7539             l = aopGet(AOP(right),offset,FALSE,TRUE,FALSE);
7540             if (*l == '@' ) {
7541                 MOVA(l);
7542                 emitcode("mov","@%s,a",rname);
7543             } else
7544                 emitcode("mov","@%s,%s",rname,l);
7545             if (size)
7546                 emitcode("inc","%s",rname);
7547             offset++;
7548         }
7549     }
7550
7551     /* now some housekeeping stuff */
7552     if (aop) {
7553         /* we had to allocate for this iCode */
7554         freeAsmop(NULL,aop,ic,TRUE);
7555     } else {
7556         /* we did not allocate which means left
7557         already in a pointer register, then
7558         if size > 0 && this could be used again
7559         we have to point it back to where it
7560         belongs */
7561         if (AOP_SIZE(right) > 1 &&
7562             !OP_SYMBOL(result)->remat &&
7563             ( OP_SYMBOL(result)->liveTo > ic->seq ||
7564               ic->depth )) {
7565             int size = AOP_SIZE(right) - 1;
7566             while (size--)
7567                 emitcode("dec","%s",rname);
7568         }
7569     }
7570
7571     /* done */
7572     freeAsmop(right,NULL,ic,TRUE);
7573
7574
7575 }
7576
7577 /*-----------------------------------------------------------------*/
7578 /* genPagedPointerSet - emitcode for Paged pointer put             */
7579 /*-----------------------------------------------------------------*/
7580 static void genPagedPointerSet (operand *right,
7581                                operand *result,
7582                                iCode *ic)
7583 {
7584     asmop *aop = NULL;
7585     regs *preg = NULL ;
7586     char *rname , *l;
7587     sym_link *retype, *letype;
7588
7589     retype= getSpec(operandType(right));
7590     letype= getSpec(operandType(result));
7591
7592     aopOp(result,ic,FALSE, FALSE);
7593
7594     /* if the value is already in a pointer register
7595        then don't need anything more */
7596     if (!AOP_INPREG(AOP(result))) {
7597         /* otherwise get a free pointer register */
7598         aop = newAsmop(0);
7599         preg = getFreePtr(ic,&aop,FALSE);
7600         emitcode("mov","%s,%s",
7601                 preg->name,
7602                 aopGet(AOP(result),0,FALSE,TRUE,FALSE));
7603         rname = preg->name ;
7604     } else
7605         rname = aopGet(AOP(result),0,FALSE,FALSE,FALSE);
7606
7607     freeAsmop(result,NULL,ic,TRUE);
7608     aopOp (right,ic,FALSE, FALSE);
7609
7610     /* if bitfield then unpack the bits */
7611     if (IS_BITVAR(retype) || IS_BITVAR(letype))
7612         genPackBits ((IS_BITVAR(retype) ? retype : letype) ,right,rname,PPOINTER);
7613     else {
7614         /* we have can just get the values */
7615         int size = AOP_SIZE(right);
7616         int offset = 0 ;
7617
7618         while (size--) {
7619             l = aopGet(AOP(right),offset,FALSE,TRUE,TRUE);
7620
7621             MOVA(l);
7622             emitcode("movx","@%s,a",rname);
7623
7624             if (size)
7625                 emitcode("inc","%s",rname);
7626
7627             offset++;
7628         }
7629     }
7630
7631     /* now some housekeeping stuff */
7632     if (aop) {
7633         /* we had to allocate for this iCode */
7634         freeAsmop(NULL,aop,ic,TRUE);
7635     } else {
7636         /* we did not allocate which means left
7637            already in a pointer register, then
7638            if size > 0 && this could be used again
7639            we have to point it back to where it
7640            belongs */
7641         if (AOP_SIZE(right) > 1 &&
7642             !OP_SYMBOL(result)->remat &&
7643             ( OP_SYMBOL(result)->liveTo > ic->seq ||
7644               ic->depth )) {
7645             int size = AOP_SIZE(right) - 1;
7646             while (size--)
7647                 emitcode("dec","%s",rname);
7648         }
7649     }
7650
7651     /* done */
7652     freeAsmop(right,NULL,ic,TRUE);
7653
7654
7655 }
7656
7657 /*-----------------------------------------------------------------*/
7658 /* genFarPointerSet - set value from far space                     */
7659 /*-----------------------------------------------------------------*/
7660 static void genFarPointerSet (operand *right,
7661                               operand *result, iCode *ic)
7662 {
7663     int size, offset ;
7664     sym_link *retype = getSpec(operandType(right));
7665     sym_link *letype = getSpec(operandType(result));
7666
7667     aopOp(result,ic,FALSE, FALSE);
7668
7669     /* if the operand is already in dptr
7670     then we do nothing else we move the value to dptr */
7671     if (AOP_TYPE(result) != AOP_STR) {
7672         /* if this is remateriazable */
7673         if (AOP_TYPE(result) == AOP_IMMD)
7674             emitcode("mov","dptr,%s",aopGet(AOP(result),0,TRUE,FALSE,FALSE));
7675         else
7676         {
7677             /* we need to get it byte by byte */
7678             _startLazyDPSEvaluation();
7679             if (AOP_TYPE(result) != AOP_DPTR)
7680             {
7681                 emitcode("mov","dpl,%s",aopGet(AOP(result),0,FALSE,FALSE,TRUE));
7682                 emitcode("mov","dph,%s",aopGet(AOP(result),1,FALSE,FALSE,TRUE));
7683                 emitcode("mov","dpx,%s",aopGet(AOP(result),2,FALSE,FALSE,TRUE));
7684             }
7685             else
7686             {
7687                  /* We need to generate a load to DPTR indirect through DPTR. */
7688                  D(emitcode(";", "genFarPointerSet -- indirection special case."););
7689                  emitcode("push", "%s", aopGet(AOP(result),0,FALSE,TRUE,TRUE));
7690                  emitcode("push", "%s", aopGet(AOP(result),1,FALSE,TRUE,TRUE));
7691                  emitcode("mov", "dpx,%s",aopGet(AOP(result),2,FALSE,FALSE,TRUE));
7692                  emitcode("pop", "dph");
7693                  emitcode("pop", "dpl");
7694             }
7695             _endLazyDPSEvaluation();
7696         }
7697     }
7698     /* so dptr know contains the address */
7699     freeAsmop(result,NULL,ic,TRUE);
7700     aopOp(right,ic,FALSE, TRUE);
7701
7702     /* if bit then unpack */
7703     if (IS_BITVAR(retype) || IS_BITVAR(letype))
7704         genPackBits((IS_BITVAR(retype)?retype:letype),right,"dptr",FPOINTER);
7705     else {
7706         size = AOP_SIZE(right);
7707         offset = 0 ;
7708
7709         _startLazyDPSEvaluation();
7710         while (size--) {
7711             char *l = aopGet(AOP(right),offset++,FALSE,FALSE,TRUE);
7712             MOVA(l);
7713
7714             genSetDPTR(0);
7715             _flushLazyDPS();
7716
7717             emitcode("movx","@dptr,a");
7718             if (size)
7719                 emitcode("inc","dptr");
7720         }
7721         _endLazyDPSEvaluation();
7722     }
7723
7724     freeAsmop(right,NULL,ic,TRUE);
7725 }
7726
7727 /*-----------------------------------------------------------------*/
7728 /* genGenPointerSet - set value from generic pointer space         */
7729 /*-----------------------------------------------------------------*/
7730 static void genGenPointerSet (operand *right,
7731                               operand *result, iCode *ic)
7732 {
7733     int size, offset ;
7734     sym_link *retype = getSpec(operandType(right));
7735     sym_link *letype = getSpec(operandType(result));
7736
7737     aopOp(result,ic,FALSE, TRUE);
7738
7739     /* if the operand is already in dptr
7740     then we do nothing else we move the value to dptr */
7741     if (AOP_TYPE(result) != AOP_STR) {
7742         _startLazyDPSEvaluation();
7743         /* if this is remateriazable */
7744         if (AOP_TYPE(result) == AOP_IMMD) {
7745             emitcode("mov","dptr,%s",aopGet(AOP(result),0,TRUE,FALSE,FALSE));
7746             emitcode("mov","b,%s + 1",aopGet(AOP(result),0,TRUE,FALSE,FALSE));
7747         }
7748         else { /* we need to get it byte by byte */
7749             emitcode("mov","dpl,%s",aopGet(AOP(result),0,FALSE,FALSE,TRUE));
7750             emitcode("mov","dph,%s",aopGet(AOP(result),1,FALSE,FALSE,TRUE));
7751             emitcode("mov","dpx,%s",aopGet(AOP(result),2,FALSE,FALSE,TRUE));
7752             emitcode("mov","b,%s",aopGet(AOP(result),3,FALSE,FALSE,TRUE));
7753         }
7754         _endLazyDPSEvaluation();
7755     }
7756     /* so dptr know contains the address */
7757     freeAsmop(result,NULL,ic,TRUE);
7758     aopOp(right,ic,FALSE, TRUE);
7759
7760     /* if bit then unpack */
7761     if (IS_BITVAR(retype) || IS_BITVAR(letype))
7762         genPackBits((IS_BITVAR(retype)?retype:letype),right,"dptr",GPOINTER);
7763     else {
7764         size = AOP_SIZE(right);
7765         offset = 0 ;
7766
7767         _startLazyDPSEvaluation();
7768         while (size--) {
7769             char *l = aopGet(AOP(right),offset++,FALSE,FALSE,TRUE);
7770             MOVA(l);
7771
7772             genSetDPTR(0);
7773             _flushLazyDPS();
7774
7775             emitcode("lcall","__gptrput");
7776             if (size)
7777                 emitcode("inc","dptr");
7778         }
7779         _endLazyDPSEvaluation();
7780     }
7781
7782     freeAsmop(right,NULL,ic,TRUE);
7783 }
7784
7785 /*-----------------------------------------------------------------*/
7786 /* genPointerSet - stores the value into a pointer location        */
7787 /*-----------------------------------------------------------------*/
7788 static void genPointerSet (iCode *ic)
7789 {
7790     operand *right, *result ;
7791     sym_link *type, *etype;
7792     int p_type;
7793
7794     D(emitcode(";", "genPointerSet "););
7795
7796     right = IC_RIGHT(ic);
7797     result = IC_RESULT(ic) ;
7798
7799     /* depending on the type of pointer we need to
7800     move it to the correct pointer register */
7801     type = operandType(result);
7802     etype = getSpec(type);
7803     /* if left is of type of pointer then it is simple */
7804     if (IS_PTR(type) && !IS_FUNC(type->next)) {
7805         p_type = DCL_TYPE(type);
7806     }
7807     else {
7808         /* we have to go by the storage class */
7809         p_type = PTR_TYPE(SPEC_OCLS(etype));
7810     }
7811
7812     /* now that we have the pointer type we assign
7813     the pointer values */
7814     switch (p_type) {
7815
7816     case POINTER:
7817     case IPOINTER:
7818         genNearPointerSet (right,result,ic);
7819         break;
7820
7821     case PPOINTER:
7822         genPagedPointerSet (right,result,ic);
7823         break;
7824
7825     case FPOINTER:
7826         genFarPointerSet (right,result,ic);
7827         break;
7828
7829     case GPOINTER:
7830         genGenPointerSet (right,result,ic);
7831         break;
7832     }
7833
7834 }
7835
7836 /*-----------------------------------------------------------------*/
7837 /* genIfx - generate code for Ifx statement                        */
7838 /*-----------------------------------------------------------------*/
7839 static void genIfx (iCode *ic, iCode *popIc)
7840 {
7841     operand *cond = IC_COND(ic);
7842     int isbit =0;
7843
7844     D(emitcode(";", "genIfx "););
7845
7846     aopOp(cond,ic,FALSE, FALSE);
7847
7848     /* get the value into acc */
7849     if (AOP_TYPE(cond) != AOP_CRY)
7850         toBoolean(cond);
7851     else
7852         isbit = 1;
7853     /* the result is now in the accumulator */
7854     freeAsmop(cond,NULL,ic,TRUE);
7855
7856     /* if there was something to be popped then do it */
7857     if (popIc)
7858         genIpop(popIc);
7859
7860     /* if the condition is  a bit variable */
7861     if (isbit && IS_ITEMP(cond) &&
7862         SPIL_LOC(cond))
7863         genIfxJump(ic,SPIL_LOC(cond)->rname);
7864     else
7865         if (isbit && !IS_ITEMP(cond))
7866             genIfxJump(ic,OP_SYMBOL(cond)->rname);
7867         else
7868             genIfxJump(ic,"a");
7869
7870     ic->generated = 1;
7871 }
7872
7873 /*-----------------------------------------------------------------*/
7874 /* genAddrOf - generates code for address of                       */
7875 /*-----------------------------------------------------------------*/
7876 static void genAddrOf (iCode *ic)
7877 {
7878     symbol *sym = OP_SYMBOL(IC_LEFT(ic));
7879     int size, offset ;
7880
7881     D(emitcode(";", "genAddrOf "););
7882
7883     aopOp(IC_RESULT(ic),ic,FALSE, FALSE);
7884
7885     /* if the operand is on the stack then we
7886     need to get the stack offset of this
7887     variable */
7888     if (sym->onStack) {
7889         /* if it has an offset then we need to compute
7890         it */
7891         if (sym->stack) {
7892             emitcode("mov","a,_bp");
7893             emitcode("add","a,#0x%02x",((char) sym->stack & 0xff));
7894             aopPut(AOP(IC_RESULT(ic)),"a",0);
7895         } else {
7896             /* we can just move _bp */
7897             aopPut(AOP(IC_RESULT(ic)),"_bp",0);
7898         }
7899         /* fill the result with zero */
7900         size = AOP_SIZE(IC_RESULT(ic)) - 1;
7901
7902
7903         if (options.stack10bit && size < (FPTRSIZE - 1))
7904         {
7905             fprintf(stderr,
7906                     "*** warning: pointer to stack var truncated.\n");
7907         }
7908
7909         offset = 1;
7910         while (size--)
7911         {
7912             /* Yuck! */
7913             if (options.stack10bit && offset == 2)
7914             {
7915                 aopPut(AOP(IC_RESULT(ic)),"#0x40", offset++);
7916             }
7917             else
7918             {
7919                 aopPut(AOP(IC_RESULT(ic)),zero,offset++);
7920             }
7921         }
7922
7923         goto release;
7924     }
7925
7926     /* object not on stack then we need the name */
7927     size = AOP_SIZE(IC_RESULT(ic));
7928     offset = 0;
7929
7930     while (size--) {
7931         char s[SDCC_NAME_MAX];
7932         if (offset)
7933             sprintf(s,"#(%s >> %d)",
7934                     sym->rname,
7935                     offset*8);
7936         else
7937             sprintf(s,"#%s",sym->rname);
7938         aopPut(AOP(IC_RESULT(ic)),s,offset++);
7939     }
7940
7941 release:
7942     freeAsmop(IC_RESULT(ic),NULL,ic,TRUE);
7943
7944 }
7945
7946 /*-----------------------------------------------------------------*/
7947 /* genFarFarAssign - assignment when both are in far space         */
7948 /*-----------------------------------------------------------------*/
7949 static void genFarFarAssign (operand *result, operand *right, iCode *ic)
7950 {
7951     int size = AOP_SIZE(right);
7952     int offset = 0;
7953     char *l;
7954
7955 #ifdef LAZY_DPS_OPT
7956     if (size > 1)
7957     {
7958         /* This is a net loss for size == 1, but a big gain
7959          * otherwise.
7960          */
7961         D(emitcode(";", "genFarFarAssign (improved)"););
7962
7963         aopOp(result,ic,TRUE, TRUE);
7964
7965         _startLazyDPSEvaluation();
7966         while (size--)
7967         {
7968             aopPut(AOP(result),
7969                    aopGet(AOP(right),offset,FALSE,FALSE,FALSE),
7970                    offset);
7971             offset++;
7972         }
7973         _endLazyDPSEvaluation();
7974         freeAsmop(result,NULL,ic,FALSE);
7975         freeAsmop(right,NULL,ic,FALSE);
7976     }
7977     else
7978 #endif
7979     {
7980     D(emitcode(";", "genFarFarAssign "););
7981
7982     /* first push the right side on to the stack */
7983     _startLazyDPSEvaluation();
7984     while (size--) {
7985         l = aopGet(AOP(right),offset++,FALSE,FALSE,TRUE);
7986         MOVA(l);
7987         emitcode ("push","acc");
7988     }
7989
7990     freeAsmop(right,NULL,ic,FALSE);
7991     /* now assign DPTR to result */
7992     aopOp(result,ic,FALSE, FALSE);
7993     size = AOP_SIZE(result);
7994     while (size--) {
7995         emitcode ("pop","acc");
7996         aopPut(AOP(result),"a",--offset);
7997     }
7998     freeAsmop(result,NULL,ic,FALSE);
7999     _endLazyDPSEvaluation();
8000     }
8001 }
8002
8003 /*-----------------------------------------------------------------*/
8004 /* genAssign - generate code for assignment                        */
8005 /*-----------------------------------------------------------------*/
8006 static void genAssign (iCode *ic)
8007 {
8008     operand *result, *right;
8009     int size, offset ;
8010         unsigned long lit = 0L;
8011
8012     D(emitcode(";", "genAssign "););
8013
8014     result = IC_RESULT(ic);
8015     right  = IC_RIGHT(ic) ;
8016
8017     /* if they are the same */
8018     if (operandsEqu (IC_RESULT(ic),IC_RIGHT(ic)))
8019         return ;
8020
8021     aopOp(right,ic,FALSE, FALSE);
8022
8023     emitcode(";", "genAssign: resultIsFar = %s",
8024              isOperandInFarSpace(result) ?
8025              "TRUE" : "FALSE");
8026
8027     /* special case both in far space */
8028     if ((AOP_TYPE(right) == AOP_DPTR ||
8029          AOP_TYPE(right) == AOP_DPTR2) &&
8030     /* IS_TRUE_SYMOP(result)       && */
8031     isOperandInFarSpace(result)) {
8032
8033         genFarFarAssign (result,right,ic);
8034         return ;
8035     }
8036
8037     aopOp(result,ic,TRUE, FALSE);
8038
8039     /* if they are the same registers */
8040     if (sameRegs(AOP(right),AOP(result)))
8041         goto release;
8042
8043     /* if the result is a bit */
8044     if (AOP_TYPE(result) == AOP_CRY) {
8045
8046         /* if the right size is a literal then
8047         we know what the value is */
8048         if (AOP_TYPE(right) == AOP_LIT) {
8049             if (((int) operandLitValue(right)))
8050                 aopPut(AOP(result),one,0);
8051             else
8052                 aopPut(AOP(result),zero,0);
8053             goto release;
8054         }
8055
8056         /* the right is also a bit variable */
8057         if (AOP_TYPE(right) == AOP_CRY) {
8058             emitcode("mov","c,%s",AOP(right)->aopu.aop_dir);
8059             aopPut(AOP(result),"c",0);
8060             goto release ;
8061         }
8062
8063         /* we need to or */
8064         toBoolean(right);
8065         aopPut(AOP(result),"a",0);
8066         goto release ;
8067     }
8068
8069     /* bit variables done */
8070     /* general case */
8071     size = AOP_SIZE(result);
8072     offset = 0 ;
8073     if(AOP_TYPE(right) == AOP_LIT)
8074         lit = (unsigned long)floatFromVal(AOP(right)->aopu.aop_lit);
8075
8076     if((size > 1) &&
8077        (AOP_TYPE(result) != AOP_REG) &&
8078        (AOP_TYPE(right) == AOP_LIT) &&
8079        !IS_FLOAT(operandType(right))
8080 #ifndef LAZY_DPS_OPT
8081        && (lit < 256L)
8082 #endif
8083        )
8084     {
8085 #ifdef LAZY_DPS_OPT
8086         D(emitcode(";", "Kevin's better literal load code"););
8087         _startLazyDPSEvaluation();
8088     while (size && ((unsigned int)(lit >> (offset*8)) != 0))
8089         {
8090             aopPut(AOP(result),
8091                    aopGet(AOP(right),offset,FALSE,FALSE,TRUE),
8092                    offset);
8093             offset++;
8094             size--;
8095         }
8096         /* And now fill the rest with zeros. */
8097         if (size)
8098         {
8099             emitcode("clr","a");
8100         }
8101         while (size--)
8102         {
8103             aopPut(AOP(result), "a", offset++);
8104         }
8105         _endLazyDPSEvaluation();
8106 #else
8107         emitcode("clr","a");
8108
8109         _startLazyDPSEvaluation();
8110         while (size--)
8111         {
8112             if((unsigned int)((lit >> (size*8)) & 0x0FFL)== 0)
8113                 aopPut(AOP(result),"a",size);
8114             else
8115                 aopPut(AOP(result),
8116                        aopGet(AOP(right),size,FALSE,FALSE,FALSE),
8117                        size);
8118         }
8119         _endLazyDPSEvaluation();
8120 #endif
8121     }
8122     else
8123     {
8124         _startLazyDPSEvaluation();
8125         while (size--)
8126         {
8127             aopPut(AOP(result),
8128                    aopGet(AOP(right),offset,FALSE,FALSE,FALSE),
8129                    offset);
8130             offset++;
8131         }
8132         _endLazyDPSEvaluation();
8133     }
8134
8135 release:
8136     freeAsmop (right,NULL,ic,FALSE);
8137     freeAsmop (result,NULL,ic,TRUE);
8138 }
8139
8140 /*-----------------------------------------------------------------*/
8141 /* genJumpTab - generates code for jump table                      */
8142 /*-----------------------------------------------------------------*/
8143 static void genJumpTab (iCode *ic)
8144 {
8145     symbol *jtab;
8146     char *l;
8147
8148     D(emitcode(";", "genJumpTab "););
8149
8150     aopOp(IC_JTCOND(ic),ic,FALSE, FALSE);
8151     /* get the condition into accumulator */
8152     l = aopGet(AOP(IC_JTCOND(ic)),0,FALSE,FALSE,TRUE);
8153     MOVA(l);
8154     /* multiply by four! */
8155     emitcode("add","a,acc");
8156     emitcode("add","a,acc");
8157     freeAsmop(IC_JTCOND(ic),NULL,ic,TRUE);
8158
8159     jtab = newiTempLabel(NULL);
8160     emitcode("mov","dptr,#%05d$",jtab->key+100);
8161     emitcode("jmp","@a+dptr");
8162     emitcode("","%05d$:",jtab->key+100);
8163     /* now generate the jump labels */
8164     for (jtab = setFirstItem(IC_JTLABELS(ic)) ; jtab;
8165          jtab = setNextItem(IC_JTLABELS(ic)))
8166         emitcode("ljmp","%05d$",jtab->key+100);
8167
8168 }
8169
8170 /*-----------------------------------------------------------------*/
8171 /* genCast - gen code for casting                                  */
8172 /*-----------------------------------------------------------------*/
8173 static void genCast (iCode *ic)
8174 {
8175     operand *result = IC_RESULT(ic);
8176     sym_link *ctype = operandType(IC_LEFT(ic));
8177     sym_link *rtype = operandType(IC_RIGHT(ic));
8178     operand *right = IC_RIGHT(ic);
8179     int size, offset ;
8180
8181     D(emitcode(";", "genCast "););
8182
8183     /* if they are equivalent then do nothing */
8184     if (operandsEqu(IC_RESULT(ic),IC_RIGHT(ic)))
8185         return ;
8186
8187     aopOp(right,ic,FALSE, FALSE) ;
8188     aopOp(result,ic,FALSE, AOP_TYPE(right) == AOP_DPTR);
8189
8190     /* if the result is a bit */
8191     if (AOP_TYPE(result) == AOP_CRY) {
8192         /* if the right size is a literal then
8193         we know what the value is */
8194         if (AOP_TYPE(right) == AOP_LIT) {
8195             if (((int) operandLitValue(right)))
8196                 aopPut(AOP(result),one,0);
8197             else
8198                 aopPut(AOP(result),zero,0);
8199
8200             goto release;
8201         }
8202
8203         /* the right is also a bit variable */
8204         if (AOP_TYPE(right) == AOP_CRY) {
8205             emitcode("mov","c,%s",AOP(right)->aopu.aop_dir);
8206             aopPut(AOP(result),"c",0);
8207             goto release ;
8208         }
8209
8210         /* we need to or */
8211         toBoolean(right);
8212         aopPut(AOP(result),"a",0);
8213         goto release ;
8214     }
8215
8216     /* if they are the same size : or less */
8217     if (AOP_SIZE(result) <= AOP_SIZE(right)) {
8218
8219         /* if they are in the same place */
8220         if (sameRegs(AOP(right),AOP(result)))
8221             goto release;
8222
8223         /* if they in different places then copy */
8224         size = AOP_SIZE(result);
8225         offset = 0 ;
8226         _startLazyDPSEvaluation();
8227         while (size--) {
8228             aopPut(AOP(result),
8229                    aopGet(AOP(right),offset,FALSE,FALSE,FALSE),
8230                    offset);
8231             offset++;
8232         }
8233         _endLazyDPSEvaluation();
8234         goto release;
8235     }
8236
8237
8238     /* if the result is of type pointer */
8239     if (IS_PTR(ctype)) {
8240
8241         int p_type;
8242         sym_link *type = operandType(right);
8243
8244         /* pointer to generic pointer */
8245         if (IS_GENPTR(ctype)) {
8246             char *l = zero;
8247
8248             if (IS_PTR(type))
8249             {
8250                 p_type = DCL_TYPE(type);
8251             }
8252             else
8253             {
8254 #if OLD_CAST_BEHAVIOR
8255                 /* KV: we are converting a non-pointer type to
8256                  * a generic pointer. This (ifdef'd out) code
8257                  * says that the resulting generic pointer
8258                  * should have the same class as the storage
8259                  * location of the non-pointer variable.
8260                  *
8261                  * For example, converting an int (which happens
8262                  * to be stored in DATA space) to a pointer results
8263                  * in a DATA generic pointer; if the original int
8264                  * in XDATA space, so will be the resulting pointer.
8265                  *
8266                  * I don't like that behavior, and thus this change:
8267                  * all such conversions will be forced to XDATA and
8268                  * throw a warning. If you want some non-XDATA
8269                  * type, or you want to suppress the warning, you
8270                  * must go through an intermediate cast, like so:
8271                  *
8272                  * char _generic *gp = (char _xdata *)(intVar);
8273                  */
8274                 sym_link *etype = getSpec(type);
8275
8276                 /* we have to go by the storage class */
8277                 if (SPEC_OCLS(etype) != generic)
8278                 {
8279                     p_type = PTR_TYPE(SPEC_OCLS(etype));
8280                 }
8281                 else
8282 #endif
8283                 {
8284                     /* Converting unknown class (i.e. register variable)
8285                      * to generic pointer. This is not good, but
8286                      * we'll make a guess (and throw a warning).
8287                      */
8288                     p_type = FPOINTER;
8289                     werror(W_INT_TO_GEN_PTR_CAST);
8290                 }
8291             }
8292
8293             /* the first two bytes are known */
8294             size = GPTRSIZE - 1;
8295             offset = 0 ;
8296             _startLazyDPSEvaluation();
8297             while (size--) {
8298                 aopPut(AOP(result),
8299                        aopGet(AOP(right),offset,FALSE,FALSE,FALSE),
8300                        offset);
8301                 offset++;
8302             }
8303             _endLazyDPSEvaluation();
8304
8305             /* the last byte depending on type */
8306             switch (p_type) {
8307             case IPOINTER:
8308             case POINTER:
8309                 l = zero;
8310                 break;
8311             case FPOINTER:
8312                 l = one;
8313                 break;
8314             case CPOINTER:
8315                 l = "#0x02";
8316                 break;
8317             case PPOINTER:
8318                 l = "#0x03";
8319                 break;
8320
8321             default:
8322                 /* this should never happen */
8323                 werror(E_INTERNAL_ERROR,__FILE__,__LINE__,
8324                        "got unknown pointer type");
8325                 exit(1);
8326             }
8327             aopPut(AOP(result),l, GPTRSIZE - 1);
8328             goto release ;
8329         }
8330
8331         /* just copy the pointers */
8332         size = AOP_SIZE(result);
8333         offset = 0 ;
8334         _startLazyDPSEvaluation();
8335         while (size--) {
8336             aopPut(AOP(result),
8337                    aopGet(AOP(right),offset,FALSE,FALSE,FALSE),
8338                    offset);
8339             offset++;
8340         }
8341         _endLazyDPSEvaluation();
8342         goto release ;
8343     }
8344
8345     /* so we now know that the size of destination is greater
8346     than the size of the source */
8347     /* we move to result for the size of source */
8348     size = AOP_SIZE(right);
8349     offset = 0 ;
8350     _startLazyDPSEvaluation();
8351     while (size--) {
8352         aopPut(AOP(result),
8353                aopGet(AOP(right),offset,FALSE,FALSE,FALSE),
8354                offset);
8355         offset++;
8356     }
8357     _endLazyDPSEvaluation();
8358
8359     /* now depending on the sign of the source && destination */
8360     size = AOP_SIZE(result) - AOP_SIZE(right);
8361     /* if unsigned or not an integral type */
8362     /* also, if the source is a bit, we don't need to sign extend, because
8363      * it can't possibly have set the sign bit.
8364      */
8365     if (SPEC_USIGN(rtype) || !IS_SPEC(rtype) || AOP_TYPE(right) == AOP_CRY)
8366     {
8367         while (size--)
8368         {
8369             aopPut(AOP(result),zero,offset++);
8370         }
8371     }
8372     else
8373     {
8374         /* we need to extend the sign :{ */
8375         char *l = aopGet(AOP(right),AOP_SIZE(right) - 1,
8376                          FALSE,FALSE,TRUE);
8377         MOVA(l);
8378         emitcode("rlc","a");
8379         emitcode("subb","a,acc");
8380         while (size--)
8381             aopPut(AOP(result),"a",offset++);
8382     }
8383
8384     /* we are done hurray !!!! */
8385
8386 release:
8387     freeAsmop(right,NULL,ic,TRUE);
8388     freeAsmop(result,NULL,ic,TRUE);
8389
8390 }
8391
8392 /*-----------------------------------------------------------------*/
8393 /* genDjnz - generate decrement & jump if not zero instrucion      */
8394 /*-----------------------------------------------------------------*/
8395 static int genDjnz (iCode *ic, iCode *ifx)
8396 {
8397     symbol *lbl, *lbl1;
8398     if (!ifx)
8399         return 0;
8400
8401     /* if the if condition has a false label
8402        then we cannot save */
8403     if (IC_FALSE(ifx))
8404         return 0;
8405
8406     /* if the minus is not of the form
8407        a = a - 1 */
8408     if (!isOperandEqual(IC_RESULT(ic),IC_LEFT(ic)) ||
8409         !IS_OP_LITERAL(IC_RIGHT(ic)))
8410         return 0;
8411
8412     if (operandLitValue(IC_RIGHT(ic)) != 1)
8413         return 0;
8414
8415     /* if the size of this greater than one then no
8416        saving */
8417     if (getSize(operandType(IC_RESULT(ic))) > 1)
8418         return 0;
8419
8420     /* otherwise we can save BIG */
8421     lbl = newiTempLabel(NULL);
8422     lbl1= newiTempLabel(NULL);
8423
8424     aopOp(IC_RESULT(ic),ic,FALSE, FALSE);
8425
8426     if (IS_AOP_PREG(IC_RESULT(ic))) {
8427         emitcode("dec","%s",
8428                  aopGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE,FALSE));
8429         emitcode("mov","a,%s",aopGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE,FALSE));
8430         emitcode("jnz","%05d$",lbl->key+100);
8431     } else {
8432         emitcode ("djnz","%s,%05d$",aopGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE,FALSE),
8433                   lbl->key+100);
8434     }
8435     emitcode ("sjmp","%05d$",lbl1->key+100);
8436     emitcode ("","%05d$:",lbl->key+100);
8437     emitcode ("ljmp","%05d$",IC_TRUE(ifx)->key+100);
8438     emitcode ("","%05d$:",lbl1->key+100);
8439
8440     freeAsmop(IC_RESULT(ic),NULL,ic,TRUE);
8441     ifx->generated = 1;
8442     return 1;
8443 }
8444
8445 /*-----------------------------------------------------------------*/
8446 /* genReceive - generate code for a receive iCode                  */
8447 /*-----------------------------------------------------------------*/
8448 static void genReceive (iCode *ic)
8449 {
8450
8451     D(emitcode(";", "genReceive "););
8452
8453     if (isOperandInFarSpace(IC_RESULT(ic)) &&
8454         ( OP_SYMBOL(IC_RESULT(ic))->isspilt ||
8455           IS_TRUE_SYMOP(IC_RESULT(ic))) ) {
8456         int size = getSize(operandType(IC_RESULT(ic)));
8457         int offset =  fReturnSize_390 - size;
8458         while (size--) {
8459             emitcode ("push","%s", (strcmp(fReturn[fReturnSize_390 - offset - 1],"a") ?
8460                                     fReturn[fReturnSize_390 - offset - 1] : "acc"));
8461             offset++;
8462         }
8463         aopOp(IC_RESULT(ic),ic,FALSE, FALSE);
8464         size = AOP_SIZE(IC_RESULT(ic));
8465         offset = 0;
8466         while (size--) {
8467             emitcode ("pop","acc");
8468             aopPut (AOP(IC_RESULT(ic)),"a",offset++);
8469         }
8470
8471     } else {
8472         _G.accInUse++;
8473         aopOp(IC_RESULT(ic),ic,FALSE, FALSE);
8474         _G.accInUse--;
8475         assignResultValue(IC_RESULT(ic));
8476     }
8477
8478     freeAsmop(IC_RESULT(ic),NULL,ic,TRUE);
8479 }
8480
8481 /*-----------------------------------------------------------------*/
8482 /* gen390Code - generate code for Dallas 390 based controllers     */
8483 /*-----------------------------------------------------------------*/
8484 void gen390Code (iCode *lic)
8485 {
8486     iCode *ic;
8487     int cln = 0;
8488
8489     lineHead = lineCurr = NULL;
8490
8491 #if 0
8492     //REMOVE ME!!!
8493     /* print the allocation information */
8494     if (allocInfo)
8495         printAllocInfo( currFunc, codeOutFile);
8496 #endif
8497     /* if debug information required */
8498     if (options.debug && currFunc) {
8499     //jwk if (currFunc) {
8500         cdbSymbol(currFunc,cdbFile,FALSE,TRUE);
8501         _G.debugLine = 1;
8502         if (IS_STATIC(currFunc->etype))
8503             emitcode("","F%s$%s$0$0 ==.",moduleName,currFunc->name);
8504         else
8505             emitcode("","G$%s$0$0 ==.",currFunc->name);
8506         _G.debugLine = 0;
8507     }
8508     /* stack pointer name */
8509     if (options.useXstack)
8510         spname = "_spx";
8511     else
8512         spname = "sp";
8513
8514
8515     for (ic = lic ; ic ; ic = ic->next ) {
8516
8517         if ( cln != ic->lineno ) {
8518             if ( options.debug ) {
8519                 _G.debugLine = 1;
8520                 emitcode("","C$%s$%d$%d$%d ==.",
8521                          ic->filename,ic->lineno,
8522                          ic->level,ic->block);
8523                 _G.debugLine = 0;
8524             }
8525             emitcode(";","%s %d",ic->filename,ic->lineno);
8526             cln = ic->lineno ;
8527         }
8528         /* if the result is marked as
8529            spilt and rematerializable or code for
8530            this has already been generated then
8531            do nothing */
8532         if (resultRemat(ic) || ic->generated )
8533             continue ;
8534
8535         /* depending on the operation */
8536         switch (ic->op) {
8537         case '!' :
8538             genNot(ic);
8539             break;
8540
8541         case '~' :
8542             genCpl(ic);
8543             break;
8544
8545         case UNARYMINUS:
8546             genUminus (ic);
8547             break;
8548
8549         case IPUSH:
8550             genIpush (ic);
8551             break;
8552
8553         case IPOP:
8554             /* IPOP happens only when trying to restore a
8555                spilt live range, if there is an ifx statement
8556                following this pop then the if statement might
8557                be using some of the registers being popped which
8558                would destory the contents of the register so
8559                we need to check for this condition and handle it */
8560             if (ic->next            &&
8561                 ic->next->op == IFX &&
8562                 regsInCommon(IC_LEFT(ic),IC_COND(ic->next)))
8563                 genIfx (ic->next,ic);
8564             else
8565                 genIpop (ic);
8566             break;
8567
8568         case CALL:
8569             genCall (ic);
8570             break;
8571
8572         case PCALL:
8573             genPcall (ic);
8574             break;
8575
8576         case FUNCTION:
8577             genFunction (ic);
8578             break;
8579
8580         case ENDFUNCTION:
8581             genEndFunction (ic);
8582             break;
8583
8584         case RETURN:
8585             genRet (ic);
8586             break;
8587
8588         case LABEL:
8589             genLabel (ic);
8590             break;
8591
8592         case GOTO:
8593             genGoto (ic);
8594             break;
8595
8596         case '+' :
8597             genPlus (ic) ;
8598             break;
8599
8600         case '-' :
8601             if ( ! genDjnz (ic,ifxForOp(IC_RESULT(ic),ic)))
8602                 genMinus (ic);
8603             break;
8604
8605         case '*' :
8606             genMult (ic);
8607             break;
8608
8609         case '/' :
8610             genDiv (ic) ;
8611             break;
8612
8613         case '%' :
8614             genMod (ic);
8615             break;
8616
8617         case '>' :
8618             genCmpGt (ic,ifxForOp(IC_RESULT(ic),ic));
8619             break;
8620
8621         case '<' :
8622             genCmpLt (ic,ifxForOp(IC_RESULT(ic),ic));
8623             break;
8624
8625         case LE_OP:
8626         case GE_OP:
8627         case NE_OP:
8628
8629             /* note these two are xlated by algebraic equivalence
8630                during parsing SDCC.y */
8631             werror(E_INTERNAL_ERROR,__FILE__,__LINE__,
8632                    "got '>=' or '<=' shouldn't have come here");
8633             break;
8634
8635         case EQ_OP:
8636             genCmpEq (ic,ifxForOp(IC_RESULT(ic),ic));
8637             break;
8638
8639         case AND_OP:
8640             genAndOp (ic);
8641             break;
8642
8643         case OR_OP:
8644             genOrOp (ic);
8645             break;
8646
8647         case '^' :
8648             genXor (ic,ifxForOp(IC_RESULT(ic),ic));
8649             break;
8650
8651         case '|' :
8652                 genOr (ic,ifxForOp(IC_RESULT(ic),ic));
8653             break;
8654
8655         case BITWISEAND:
8656             genAnd (ic,ifxForOp(IC_RESULT(ic),ic));
8657             break;
8658
8659         case INLINEASM:
8660             genInline (ic);
8661             break;
8662
8663         case RRC:
8664             genRRC (ic);
8665             break;
8666
8667         case RLC:
8668             genRLC (ic);
8669             break;
8670
8671         case GETHBIT:
8672             genGetHbit (ic);
8673             break;
8674
8675         case LEFT_OP:
8676             genLeftShift (ic);
8677             break;
8678
8679         case RIGHT_OP:
8680             genRightShift (ic);
8681             break;
8682
8683         case GET_VALUE_AT_ADDRESS:
8684             genPointerGet(ic);
8685             break;
8686
8687         case '=' :
8688             if (POINTER_SET(ic))
8689                 genPointerSet(ic);
8690             else
8691                 genAssign(ic);
8692             break;
8693
8694         case IFX:
8695             genIfx (ic,NULL);
8696             break;
8697
8698         case ADDRESS_OF:
8699             genAddrOf (ic);
8700             break;
8701
8702         case JUMPTABLE:
8703             genJumpTab (ic);
8704             break;
8705
8706         case CAST:
8707             genCast (ic);
8708             break;
8709
8710         case RECEIVE:
8711             genReceive(ic);
8712             break;
8713
8714         case SEND:
8715             addSet(&_G.sendSet,ic);
8716             break;
8717
8718         default :
8719             ic = ic;
8720             /*      piCode(ic,stdout); */
8721
8722         }
8723     }
8724
8725
8726     /* now we are ready to call the
8727        peep hole optimizer */
8728     if (!options.nopeep)
8729         peepHole (&lineHead);
8730
8731     /* now do the actual printing */
8732     printLine (lineHead,codeOutFile);
8733     return;
8734 }