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

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