git.gag.com Git - fw/sdcc/blob - sim/ucsim/avr.src/avr.cc

   1 /*
   2  * Simulator of microcontrollers (avr.cc)
   3  *
   4  * Copyright (C) 1999,99 Drotos Daniel, Talker Bt.
   5  *
   6  * To contact author send email to drdani@mazsola.iit.uni-miskolc.hu
   7  *
   8  */
   9
  10 /* This file is part of microcontroller simulator: ucsim.
  11
  12 UCSIM is free software; you can redistribute it and/or modify
  13 it under the terms of the GNU General Public License as published by
  14 the Free Software Foundation; either version 2 of the License, or
  15 (at your option) any later version.
  16
  17 UCSIM is distributed in the hope that it will be useful,
  18 but WITHOUT ANY WARRANTY; without even the implied warranty of
  19 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20 GNU General Public License for more details.
  21
  22 You should have received a copy of the GNU General Public License
  23 along with UCSIM; see the file COPYING.  If not, write to the Free
  24 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
  25 02111-1307, USA. */
  26 /*@1@*/
  27
  28 #include "ddconfig.h"
  29
  30 #include <stdio.h>
  31 #include <stdlib.h>
  32 #include <ctype.h>
  33 #include "i_string.h"
  34
  35 // prj
  36 #include "pobjcl.h"
  37
  38 // sim
  39 #include "simcl.h"
  40
  41 // local
  42 #include "portcl.h"
  43 #include "avrcl.h"
  44 #include "glob.h"
  45 #include "regsavr.h"
  46
  47
  48 /*
  49  * Base type of AVR microcontrollers
  50  */
  51
  52 cl_avr::cl_avr(class cl_sim *asim):
  53   cl_uc(asim)
  54 {
  55   type= CPU_AVR;
  56   sleep_executed= 0;
  57 }
  58
  59 int
  60 cl_avr::init(void)
  61 {
  62   cl_uc::init(); /* Memories now exist */
  63   ram= mem(MEM_IRAM);
  64   rom= mem(MEM_ROM);
  65   return(0);
  66 }
  67
  68 char *
  69 cl_avr::id_string(void)
  70 {
  71   return("unspecified AVR");
  72 }
  73
  74
  75 /*
  76  * Making elements of the controller
  77  */
  78
  79 t_addr
  80 cl_avr::get_mem_size(enum mem_class type)
  81 {
  82   switch(type)
  83     {
  84     case MEM_ROM: return(8*1024);
  85     case MEM_IRAM: return(0x10000);
  86     default: return(0);
  87     }
  88   //return(0);
  89   //return(cl_uc::get_mem_size(type));
  90 }
  91
  92 int
  93 cl_avr::get_mem_width(enum mem_class type)
  94 {
  95   if (type == MEM_ROM)
  96     return(16);
  97   return(cl_uc::get_mem_width(type));
  98 }
  99
 100 void
 101 cl_avr::mk_hw_elements(void)
 102 {
 103   class cl_base *o;
 104   /* t_uc::mk_hw() does nothing */
 105   hws->add(o= new cl_port(this));
 106   o->init();
 107 }
 108
 109
 110 /*
 111  * Help command interpreter
 112  */
 113
 114 struct dis_entry *
 115 cl_avr::dis_tbl(void)
 116 {
 117   return(disass_avr);
 118 }
 119
 120 struct name_entry *
 121 cl_avr::sfr_tbl(void)
 122 {
 123   return(sfr_tabl);
 124 }
 125
 126 struct name_entry *
 127 cl_avr::bit_tbl(void)
 128 {
 129   //FIXME
 130   return(0);
 131 }
 132
 133 char *
 134 cl_avr::disass(t_addr addr, char *sep)
 135 {
 136   char work[256], temp[20];
 137   char *buf, *p, *b, *t;
 138   uint code, data= 0;
 139   int i;
 140
 141   p= work;
 142
 143   code= get_mem(MEM_ROM, addr);
 144   i= 0;
 145   while ((code & dis_tbl()[i].mask) != dis_tbl()[i].code &&
 146          dis_tbl()[i].mnemonic)
 147     i++;
 148   if (dis_tbl()[i].mnemonic == NULL)
 149     {
 150       buf= (char*)malloc(30);
 151       strcpy(buf, "UNKNOWN/INVALID");
 152       return(buf);
 153     }
 154   b= dis_tbl()[i].mnemonic;
 155
 156   while (*b)
 157     {
 158       if (*b == '%')
 159         {
 160           b++;
 161           switch (*(b++))
 162             {
 163             case 'd': // Rd   .... ...d dddd ....  0<=d<=31
 164               if (!get_name(data= (code&0x01f0)>>4, sfr_tbl(), temp))
 165                 sprintf(temp, "r%d", data);
 166               break;
 167             case 'D': // Rd   .... .... dddd ....  16<=d<=31
 168               if (!get_name(data= 16+((code&0xf0)>>4), sfr_tbl(), temp))
 169                 sprintf(temp, "r%d", data);
 170               break;
 171             case 'K': // K    .... KKKK .... KKKK  0<=K<=255
 172               sprintf(temp, "%d", ((code&0xf00)>>4)|(code&0xf));
 173               break;
 174             case 'r': // Rr   .... ..r. .... rrrr  0<=r<=31
 175               if (!get_name(data= ((code&0x0200)>>5)|(code&0x000f),
 176                             sfr_tbl(), temp))
 177                 sprintf(temp, "r%d", data);
 178               break;
 179             case '2': // Rdl  .... .... ..dd ....  dl= {24,26,28,30}
 180               if (!get_name(data= 24+(2*((code&0x0030)>>4)),
 181                             sfr_tbl(), temp))
 182                 sprintf(temp, "r%d", data);
 183               break;
 184             case '6': // K    .... .... KK.. KKKK  0<=K<=63
 185               sprintf(temp, "%d", ((code&0xc0)>>2)|(code&0xf));
 186               break;
 187             case 's': // s    .... .... .sss ....  0<=s<=7
 188               sprintf(temp, "%d", (code&0x70)>>4);
 189               break;
 190             case 'b': // b    .... .... .... .bbb  0<=b<=7
 191               sprintf(temp, "%d", code&0x7);
 192               break;
 193             case 'k': // k    .... ..kk kkkk k...  -64<=k<=+63
 194               {
 195                 int k= (code&0x3f8)>>3;
 196                 if (code&0x200)
 197                   k|= -128;
 198                 sprintf(temp, "0x%06x", k+1+(signed int)addr);
 199                 break;
 200               }
 201             case 'A': // k    .... ...k kkkk ...k  0<=k<=64K
 202                       //      kkkk kkkk kkkk kkkk  0<=k<=4M
 203               sprintf(temp, "0x%06x",
 204                       (((code&0x1f0)>>3)|(code&1))*0x10000+
 205                       (uint)get_mem(MEM_ROM, addr+1));
 206               break;
 207             case 'P': // P    .... .... pppp p...  0<=P<=31
 208               data= (code&0xf8)>>3;
 209               if (!get_name(data+0x20, sfr_tbl(), temp))
 210                 sprintf(temp, "%d", data);
 211               break;
 212             case 'p': // P    .... .PP. .... PPPP  0<=P<=63
 213               data= ((code&0x600)>>5)|(code&0xf);
 214               if (!get_name(data+0x20, sfr_tbl(), temp))
 215                 sprintf(temp, "%d", data);
 216               break;
 217             case 'q': // q    ..q. qq.. .... .qqq  0<=q<=63
 218               sprintf(temp, "%d",
 219                       ((code&0x2000)>>8)|((code&0xc00)>>7)|(code&7));
 220               break;
 221             case 'R': // k    SRAM address on second word 0<=k<=65535
 222               sprintf(temp, "0x%06x", (uint)get_mem(MEM_ROM, addr+1));
 223               break;
 224             case 'a': // k    .... kkkk kkkk kkkk  -2k<=k<=2k
 225               {
 226                 int k= code&0xfff;
 227                 if (code&0x800)
 228                   k|= -4096;
 229                 sprintf(temp, "0x%06lx",
 230                         (k+1+(signed int)addr) % rom->size);
 231                 break;
 232               }
 233             default:
 234               strcpy(temp, "?");
 235               break;
 236             }
 237           t= temp;
 238           while (*t)
 239             *(p++)= *(t++);
 240         }
 241       else
 242         *(p++)= *(b++);
 243     }
 244   *p= '\0';
 245
 246   p= strchr(work, ' ');
 247   if (!p)
 248     {
 249       buf= strdup(work);
 250       return(buf);
 251     }
 252   if (sep == NULL)
 253     buf= (char *)malloc(6+strlen(p)+1);
 254   else
 255     buf= (char *)malloc((p-work)+strlen(sep)+strlen(p)+1);
 256   for (p= work, b= buf; *p != ' '; p++, b++)
 257     *b= *p;
 258   p++;
 259   *b= '\0';
 260   if (sep == NULL)
 261     {
 262       while (strlen(buf) < 6)
 263         strcat(buf, " ");
 264     }
 265   else
 266     strcat(buf, sep);
 267   strcat(buf, p);
 268   return(buf);
 269 }
 270
 271
 272 void
 273 cl_avr::print_regs(class cl_console *con)
 274 {
 275   uchar data, sreg= ram->get(SREG);
 276   uint x, y, z;
 277
 278   ram->dump(0, 31, 16, con);
 279
 280   con->printf("ITHSVNZC  SREG= 0x%02x %3d %c\n",
 281               sreg, sreg, isprint(sreg)?sreg:'.');
 282   con->printf("%c%c%c%c%c%c%c%c  ",
 283               (sreg&BIT_I)?'1':'0',
 284               (sreg&BIT_T)?'1':'0',
 285               (sreg&BIT_H)?'1':'0',
 286               (sreg&BIT_S)?'1':'0',
 287               (sreg&BIT_V)?'1':'0',
 288               (sreg&BIT_N)?'1':'0',
 289               (sreg&BIT_Z)?'1':'0',
 290               (sreg&BIT_C)?'1':'0');
 291   con->printf("SP  = 0x%06x\n",
 292               ram->get(SPH)*256+ram->get(SPL));
 293
 294   x= ram->get(XH)*256 + ram->get(XL);
 295   data= ram->get(x);
 296   con->printf("X= 0x%04x [X]= 0x%02x %3d %c  ", x,
 297               data, data, isprint(data)?data:'.');
 298   y= ram->get(YH)*256 + ram->get(YL);
 299   data= ram->get(y);
 300   con->printf("Y= 0x%04x [Y]= 0x%02x %3d %c  ", y,
 301               data, data, isprint(data)?data:'.');
 302   z= ram->get(ZH)*256 + ram->get(ZL);
 303   data= ram->get(z);
 304   con->printf("Z= 0x%04x [Z]= 0x%02x %3d %c\n", z,
 305               data, data, isprint(data)?data:'.');
 306
 307   print_disass(PC, con);
 308 }
 309
 310
 311 /*
 312  * Execution
 313  */
 314
 315 int
 316 cl_avr::exec_inst(void)
 317 {
 318   t_mem code;
 319
 320   if (fetch(&code))
 321     return(resBREAKPOINT);
 322   tick(1);
 323   switch (code)
 324     {
 325     case 0x9419:
 326       return(eijmp(code));
 327     case 0x9519:
 328       return(eicall(code));
 329     case 0x9508: case 0x9528: case 0x9548: case 0x9568:
 330       return(ret(code));
 331     case 0x9518: case 0x9538: case 0x9558: case 0x9578:
 332       return(reti(code));
 333     case 0x95c8:
 334       return(lpm(code));
 335     case 0x95d8:
 336       return(elpm(code)); // in some devices equal to lpm
 337     case 0x95e8:
 338       return(spm(code));
 339     case 0x95f8:
 340       return(espm(code));
 341     case 0x9408:
 342       return(sec(code));
 343     case 0x9488:
 344       return(clc(code));
 345     case 0x9428:
 346       return(sen(code));
 347     case 0x94a8:
 348       return(cln(code));
 349     case 0x9418:
 350       return(sez(code));
 351     case 0x9498:
 352       return(clz(code));
 353     case 0x9478:
 354      return(sei(code));
 355     case 0x94f8:
 356       return(cli(code));
 357     case 0x9448:
 358       return(ses(code));
 359     case 0x94c8:
 360       return(cls(code));
 361     case 0x9438:
 362       return(sev(code));
 363     case 0x94b8:
 364       return(clv(code));
 365     case 0x9468:
 366       return(set(code));
 367     case 0x94e8:
 368       return(clt(code));
 369     case 0x9458:
 370       return(seh(code));
 371     case 0x94d8:
 372       return(clh(code));
 373     case 0x0000:
 374       return(nop(code));
 375     case 0x9588: case 0x9598:
 376       return(sleep(code));
 377     case 0x95a8: case 0x95b8:
 378       return(wdr(code));
 379     }
 380   switch (code & 0xf000)
 381     {
 382     case 0x3000: return(cpi_Rd_K(code));
 383     case 0x4000: return(sbci_Rd_K(code));
 384     case 0x5000: return(subi_Rd_K(code));
 385     case 0x6000: return(ori_Rd_K(code));
 386     case 0x7000: return(andi_Rd_K(code));
 387     case 0xc000: return(rjmp_k(code));
 388     case 0xd000: return(rcall_k(code));
 389     case 0xe000: return(ldi_Rd_K(code));
 390     }
 391   switch (code & 0xf000)
 392     {
 393     case 0x0000:
 394       // 0x0...
 395       switch (code & 0xfc00)
 396         {
 397         case 0x0000:
 398           switch (code & 0xff00)
 399             {
 400             case 0x0100: return(movw_Rd_Rr(code));
 401             case 0x0200: return(muls_Rd_Rr(code));
 402             case 0x0300:
 403               switch (code & 0xff88)
 404                 {
 405                 case 0x0300: return(mulsu_Rd_Rr(code));
 406                 case 0x0308: return(fmul_Rd_Rr(code));
 407                 case 0x0380: return(fmuls_Rd_Rr(code));
 408                 case 0x0388: return(fmulsu_Rd_Rr(code));
 409                 }
 410             }
 411         case 0x0400: return(cpc_Rd_Rr(code));
 412         case 0x0800: return(sbc_Rd_Rr(code));
 413         case 0x0c00: return(add_Rd_Rr(code));
 414         }
 415     case 0x1000:
 416       // 0x1...
 417       switch (code & 0xfc00)
 418         {
 419         case 0x1000: return(cpse_Rd_Rr(code));
 420         case 0x1400: return(cp_Rd_Rr(code));
 421         case 0x1800: return(sub_Rd_Rr(code));
 422         case 0x1c00: return(adc_Rd_Rr(code));
 423         }
 424     case 0x2000:
 425       // 0x2...
 426       switch (code & 0xfc00)
 427         {
 428         case 0x2000: return(and_Rd_Rr(code));
 429         case 0x2400: return(eor_Rd_Rr(code));
 430         case 0x2800: return(or_Rd_Rr(code));
 431         case 0x2c00: return(mov_Rd_Rr(code));
 432         }
 433     case 0x8000:
 434       // 0x8...
 435       switch (code &0xf208)
 436         {
 437         case 0x8000: return(ldd_Rd_Z_q(code));
 438         case 0x8008: return(ldd_Rd_Y_q(code));
 439         case 0x8200: return(std_Z_q_Rr(code));
 440         case 0x8208: return(std_Y_q_Rr(code));
 441         }
 442     case 0x9000:
 443       // 0x9...
 444       if ((code & 0xff0f) == 0x9509)
 445         return(icall(code));
 446       if ((code & 0xff0f) == 0x9409)
 447         return(ijmp(code));
 448       if ((code & 0xff00) == 0x9600)
 449         return(adiw_Rdl_K(code));
 450       if ((code & 0xff00) == 0x9700)
 451         return(sbiw_Rdl_K(code));
 452       switch (code & 0xfc00)
 453         {
 454         case 0x9000:
 455           switch (code & 0xfe0f)
 456             {
 457             case 0x9000: return(lds_Rd_k(code));
 458             case 0x9001: return(ld_Rd_Z$(code));
 459             case 0x9002: return(ld_Rd_$Z(code));
 460             case 0x9004: return(lpm_Rd_Z(code));
 461             case 0x9005: return(lpm_Rd_Z$(code));
 462             case 0x9006: return(elpm_Rd_Z(code));
 463             case 0x9007: return(elpm_Rd_Z$(code));
 464             case 0x9009: return(ld_Rd_Y$(code));
 465             case 0x900a: return(ld_Rd_$Y(code));
 466             case 0x900c: return(ld_Rd_X(code));
 467             case 0x900d: return(ld_Rd_X$(code));
 468             case 0x900e: return(ld_Rd_$X(code));
 469             case 0x900f: return(pop_Rd(code));
 470             case 0x9200: return(sts_k_Rr(code));
 471             case 0x9201: return(st_Z$_Rr(code));
 472             case 0x9202: return(st_$Z_Rr(code));
 473             case 0x9209: return(st_Y$_Rr(code));
 474             case 0x920a: return(st_$Y_Rr(code));
 475             case 0x920c: return(st_X_Rr(code));
 476             case 0x920d: return(st_X$_Rr(code));
 477             case 0x920e: return(st_$X_Rr(code));
 478             case 0x920f: return(push_Rr(code));
 479             }
 480         case 0x9400:
 481           switch (code & 0xfe0f)
 482             {
 483             case 0x9400: return(com_Rd(code));
 484             case 0x9401: return(neg_Rd(code));
 485             case 0x9402: return(swap_Rd(code));
 486             case 0x9403: return(inc_Rd(code));
 487             case 0x9405: return(asr_Rd(code));
 488             case 0x9406: return(lsr_Rd(code));
 489             case 0x9407: return(ror_Rd(code));
 490             case 0x940a: return(dec_Rd(code));
 491             case 0x940c: case 0x940d: return(jmp_k(code));
 492             case 0x940e: case 0x940f: return(call_k(code));
 493             }
 494         case 0x9800:
 495           switch (code & 0xff00)
 496             {
 497             case 0x9800: return(cbi_A_b(code));
 498             case 0x9900: return(sbic_P_b(code));
 499             case 0x9a00: return(sbi_A_b(code));
 500             case 0x9b00: return(sbis_P_b(code));
 501             }
 502         case 0x9c00: return(mul_Rd_Rr(code));
 503         }
 504     case 0xa000:
 505       // 0xa...
 506       switch (code &0xf208)
 507         {
 508         case 0xa000: return(ldd_Rd_Z_q(code));
 509         case 0xa008: return(ldd_Rd_Y_q(code));
 510         case 0xa200: return(std_Z_q_Rr(code));
 511         case 0xa208: return(std_Y_q_Rr(code));
 512         }
 513     case 0xb000:
 514       // 0xb...
 515       switch (code & 0xf800)
 516         {
 517         case 0xb000: return(in_Rd_A(code));
 518         case 0xb800: return(out_A_Rr(code));
 519         }
 520     case 0xe000:
 521       // 0xe...
 522       switch (code & 0xff0f)
 523         {
 524         case 0xef0f: return(ser_Rd(code));
 525         }
 526     case 0xf000:
 527       // 0xf...
 528       switch (code & 0xfc00)
 529         {
 530         case 0xf000: return(brbs_s_k(code));
 531         case 0xf400: return(brbc_s_k(code));
 532         case 0xf800: case 0xfc00:
 533           switch (code & 0xfe08)
 534             {
 535             case 0xf800: return(bld_Rd_b(code));
 536             case 0xfa00: return(bst_Rd_b(code));
 537             case 0xfc00: case 0xfc08: return(sbrc_Rr_b(code));
 538             case 0xfe00: case 0xfe08: return(sbrs_Rr_b(code));
 539             }
 540         }
 541     }
 542   if (PC)
 543     PC--;
 544   else
 545     PC= get_mem_size(MEM_ROM)-1;
 546   //tick(-clock_per_cycle());
 547   sim->stop(resINV_INST);
 548   return(resINV_INST);
 549 }
 550
 551
 552 /*
 553  */
 554
 555 int
 556 cl_avr::push_data(t_mem data)
 557 {
 558   t_addr sp;
 559   t_mem spl, sph;
 560
 561   spl= ram->read(SPL);
 562   sph= ram->read(SPH);
 563   sp= 0xffff & (256*sph + spl);
 564   ram->write(sp, &data);
 565   sp= 0xffff & (sp-1);
 566   spl= sp & 0xff;
 567   sph= (sp>>8) & 0xff;
 568   ram->write(SPL, &spl);
 569   ram->write(SPH, &sph);
 570   return(resGO);
 571 }
 572
 573 int
 574 cl_avr::push_addr(t_addr addr)
 575 {
 576   t_addr sp;
 577   t_mem spl, sph, al, ah;
 578
 579   spl= ram->read(SPL);
 580   sph= ram->read(SPH);
 581   sp= 0xffff & (256*sph + spl);
 582   al= addr & 0xff;
 583   ah= (addr>>8) & 0xff;
 584   ram->write(sp, &ah);
 585   sp= 0xffff & (sp-1);
 586   ram->write(sp, &al);
 587   sp= 0xffff & (sp-1);
 588   spl= sp & 0xff;
 589   sph= (sp>>8) & 0xff;
 590   ram->write(SPL, &spl);
 591   ram->write(SPH, &sph);
 592   return(resGO);
 593 }
 594
 595 int
 596 cl_avr::pop_data(t_mem *data)
 597 {
 598   t_addr sp;
 599   t_mem spl, sph;
 600
 601   spl= ram->read(SPL);
 602   sph= ram->read(SPH);
 603   sp= 256*sph + spl;
 604   sp= 0xffff & (sp+1);
 605   *data= ram->read(sp);
 606   spl= sp & 0xff;
 607   sph= (sp>>8) & 0xff;
 608   ram->write(SPL, &spl);
 609   ram->write(SPH, &sph);
 610
 611   return(resGO);
 612 }
 613
 614 int
 615 cl_avr::pop_addr(t_addr *addr)
 616 {
 617   t_addr sp;
 618   t_mem spl, sph, al, ah;
 619
 620   spl= ram->read(SPL);
 621   sph= ram->read(SPH);
 622   sp= 256*sph + spl;
 623   sp= 0xffff & (sp+1);
 624   al= ram->read(sp);
 625   sp= 0xffff & (sp+1);
 626   ah= ram->read(sp);
 627   *addr= ah*256 + al;
 628   spl= sp & 0xff;
 629   sph= (sp>>8) & 0xff;
 630   ram->write(SPL, &spl);
 631   ram->write(SPH, &sph);
 632
 633   return(resGO);
 634 }
 635
 636
 637 /*
 638  * Set Z, N, V, S bits of SREG after logic instructions and some others
 639  */
 640
 641 void
 642 cl_avr::set_zn0s(t_mem data)
 643 {
 644   t_mem sreg= ram->get(SREG) & ~BIT_V;
 645   data= data&0xff;
 646   if (!data)
 647     sreg|= BIT_Z;
 648   else
 649     sreg&= ~BIT_Z;
 650   if (data & 0x80)
 651     sreg|= (BIT_N|BIT_S);
 652   else
 653     sreg&= ~(BIT_N|BIT_S);
 654   ram->set(SREG, sreg);
 655 }
 656
 657
 658 /* End of avr.src/avr.cc */