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

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