view emu52/main.lst @ 42:792da050d8c4 tip

more dox
author james <jb302@eecs.qmul.ac.uk>
date Tue, 22 Apr 2014 14:25:14 +0100
parents 8205f1734ff2
children
line wrap: on
line source
C51 COMPILER V9.02   MAIN                                                                  04/17/2014 15:17:33 PAGE 1   


C51 COMPILER V9.02, COMPILATION OF MODULE MAIN
OBJECT MODULE PLACED IN main.obj
COMPILER INVOKED BY: C:\Keil\C51\BIN\C51.EXE src\main.c OMF2 BROWSE DEBUG PRINT(.\main.lst) OBJECT(main.obj)

line level    source

   1          #include <stdio.h>
   2          #include <reg52.h>
   3          
   4          #define MAIN
   5          #include "mem.h"
   6          #include "iset.h"
   7          
   8          /* fill instruction table 
   9           * MCS-51 - this needs to be stored in code memory */
  10          
  11          FUNCTION_TABLE const code iset = {
  12              NOP, NOP, NOP, NOP, NOP, NOP, NOP, NOP,
  13              SET, CLR, SET, CLR, SET, CLR, CPL, CPL,
  14              XCSD, SFA, LAF, MOV, MOV, MOV, MOV, MOV,
  15              MOV, MOV, MOV, MOV, MOV, MOV, MOV, MOV,
  16              MOV, MOV, MOV, MOV, MOV, MOV, MOV, MOV,
  17              MOV, MOV, MOV, MOV, MOV, MOV, MOV, MOV,
  18              MOV, MOV, MOV, MOV, MOV, MOV, MOV, MOV,
  19              MOV, MOV, MOV, MOV, MOV, MOV, MOV, MOV,
  20              MOV, MOV, MOV, MOV, MOV, MOV, MOV, MOV,
  21              MOV, MOV, MOV, MOV, MOV, MOV, MOV, MOV,
  22              MOV, MOV, MOV, MOV, MOV, MOV, MOV, MOV,
  23              MOV, MOV, MOV, MOV, MOV, MOV, MOV, MOV,
  24              MOV, MOV, MOV, MOV, MOV, MOV, MOV, MOV,
  25              MOV, MOV, MOV, MOV, MOV, MOV, MOV, MOV,
  26              MOV, MOV, MOV, MOV, MOV, MOV, MOV, MOV,
  27              MOV, MOV, MOV, MOV, MOV, MOV, MOV, MOV,
  28              ANL, ANL, ANL, ANL, ANL, ANL, ANL, ANL,
  29              ORL, ORL, ORL, ORL, ORL, ORL, ORL, ORL,
  30              XRL, XRL, XRL, XRL, XRL, XRL, XRL, XRL,
  31              RL, RLC, RR, RRC, INC, DEC, INC, DEC,
  32              ADD, ADD, ADD, ADD, ADD, ADD, ADD, ADD,
  33              ADDC, ADDC, ADDC, ADDC, ADDC, ADDC, ADDC, ADDC,
  34              SUB, SUB, SUB, SUB, SUB, SUB, SUB, SUB,
  35              SUBB, SUBB, SUBB, SUBB, SUBB, SUBB, SUBB, SUBB,
  36              PJMP, PJMP, PJMP, PJMP, PJMP, PJMP, PJMP, PJMP,
  37              PCALL, PCALL, PCALL, PCALL, PCALL, PCALL, PCALL, PCALL,
  38              DJNZ, DJNZ, DJNZ, DJNZ, CJNE, CJNE, CJNE, CJNE,
  39              LJMP, LCALL, RET, RETI, SJMP, JMP, JMP, CJNE,
  40              JZ, JNZ, JC, JNC, JPO, JPE, JS, JNS,
  41              PUSH, PUSH, PUSH, PUSH, PUSH, PUSH, PUSH, PUSH,
  42              POP, POP, POP, POP, POP, POP, POP, POP,
  43              MUL, DIV, DA, NOP, IN, OUT, INT, HLT
  44          }; 
  45          
  46          BYTE pause;     /* becomes 1 when we hit a break point in run mode */
  47          BYTE free_run;  /* free run if not 0 */
  48          BYTE pause;     /* pause flag */
  49          WIDE addrc;        /* address counter */
  50          BYTE args[4];   /* dbg args */
  51          
  52          WIDE bp[8] = {  0xFFFF,
  53                          0xFFFF,
  54                          0xFFFF,
  55                          0xFFFF,
C51 COMPILER V9.02   MAIN                                                                  04/17/2014 15:17:33 PAGE 2   

  56                          0xFFFF,
  57                          0xFFFF,
  58                          0xFFFF,
  59                          0xFFFF
  60          };
  61          
  62          
  63          void
  64          snd(BYTE c) {
  65   1      putchar(c);
  66   1      }
  67          
  68          BYTE
  69          rcv(void) {
  70   1          return getchar();
  71   1      }
  72          
  73          void
  74          step(void) {
  75   1          IR = fetch();
  76   1          iset.ops[IR]();  
  77   1      }
  78          
  79          void
  80          run(void) {
  81   1          while (pause != 1) {
  82   2              step();
  83   2              for (addrc = 0; addrc < 8; addrc++) {
  84   3                  if (bp[addrc] == get_wide(PC)) {
  85   4                      pause = 1;
  86   4                  }
  87   3              }
  88   2          }
  89   1      }
  90          
  91          void controller() {
  92   1          if (free_run == 0) {
  93   2                  switch (rcv()) {
  94   3      
  95   3                      /* step */
  96   3                      case 0x00:
  97   3                          step();
  98   3                          break;
  99   3      
 100   3                      /* run for length steps*/
 101   3                      case 0x01:
 102   3                          run();
 103   3                          break;
 104   3      
 105   3                      /* set reg */
 106   3                      case 0x02:
 107   3                          args[0] = rcv(); /* reg */
 108   3                          args[1] = rcv(); /* val */
 109   3                          regs[args[0]] = args[1];
 110   3                          break;
 111   3      
 112   3                      /* get reg */
 113   3                      case 0x03:
 114   3                          args[0] = rcv(); /* reg */
 115   3                          snd(regs[args[0]]);
 116   3                          break;
 117   3      
C51 COMPILER V9.02   MAIN                                                                  04/17/2014 15:17:33 PAGE 3   

 118   3                      /* set flag */
 119   3                      case 0x04:
 120   3                          args[0] = rcv(); /* flag */
 121   3                          args[1] = rcv(); /* on? */
 122   3                          set_flag(args[0], args[1]);
 123   3                          break;
 124   3              
 125   3                      /* get flag */
 126   3                      case 0x05:
 127   3                          args[0] = rcv(); /* flag */
 128   3                          snd(get_flag(args[0]));
 129   3                          break;
 130   3      
 131   3                      /* write mem block */
 132   3                      case 0x06:
 133   3                          args[0] = rcv(); /* addr high */
 134   3                          args[1] = rcv(); /* addr low */
 135   3                          args[2] = rcv(); /* length high */
 136   3                          args[3] = rcv(); /* length low */
 137   3                          tmpw = MWIDE(args[0], args[1]);         
 138   3                          for (addrc = tmpw; addrc < tmpw + MWIDE(args[2], args[3]); addrc++) { 
 139   4                              if (addrc >= 0xFFFF) {
 140   5                                  break;
 141   5                              }
 142   4                              mem[addrc] = rcv();
 143   4                          }
 144   3                          break;
 145   3      
 146   3                      /* read mem block */
 147   3                      case 0x07:
 148   3                          args[0] = rcv(); /* addr high */
 149   3                          args[1] = rcv(); /* addr low */
 150   3                          args[2] = rcv(); /* length high */
 151   3                          args[3] = rcv(); /* length low */
 152   3                          tmpw = MWIDE(args[0], args[1]);         
 153   3                          for (addrc = tmpw; addrc < tmpw + MWIDE(args[2], args[3]); addrc++) { 
 154   4                              if (addrc >= 0xFFFF) {
 155   5                                  break;
 156   5                              }
 157   4                              snd(mem[addrc]);
 158   4                          }
 159   3                          break;
 160   3      
 161   3                      /* get A */
 162   3                      case 0x09:
 163   3                          snd(A);
 164   3                          break;
 165   3                      
 166   3                      /* get flags */
 167   3                      case 0x0A:
 168   3                          snd(flags);
 169   3                          break;
 170   3                      
 171   3                      /* get instruction register */
 172   3                      case 0x0B:
 173   3                          snd(IR);
 174   3                          break;
 175   3                      
 176   3                      case 0x0C:
 177   3                          args[0] = rcv(); /* length high */
 178   3                          args[1] = rcv(); /* length low */
 179   3                          tmpw = get_wide(PC);
C51 COMPILER V9.02   MAIN                                                                  04/17/2014 15:17:33 PAGE 4   

 180   3                          for (addrc = tmpw ; addrc < tmpw + MWIDE(args[0], args[1]) ; addrc++) {
 181   4                              if (addrc == 0xFFFF) {
 182   5                                  break;
 183   5                              }
 184   4                              step();
 185   4                          }
 186   3                          break;
 187   3      
 188   3                      case 0x0D:
 189   3                          free_run = 1;
 190   3                          break;
 191   3                      
 192   3                      /* set break point */
 193   3                      case 0x0E:
 194   3                          args[0] = rcv(); /* bp index */
 195   3                          args[1] = rcv(); /* address high */
 196   3                          args[2] = rcv(); /* address low */
 197   3                          if (args[0] > 7) {
 198   4                              break;
 199   4                          }
 200   3                          bp[args[0]] = MWIDE(args[1], args[2]);
 201   3                          break;
 202   3                      
 203   3                      /* test cmd */
 204   3                      case 0x54:
 205   3                          snd('A');
 206   3                          break;
 207   3                 }
 208   2              }
 209   1          else {
 210   2              step();
 211   2          }
 212   1      }
 213          
 214          void 
 215          main(void) {
 216   1           /* serial set up
 217   1           * SCON - mode 1, 8-bit UART, enable rcvr
 218   1           * TMOD - timer 1, mode 2, 8-bit reload
 219   1           * TH1 - reload value for 1200 baud @ 12MHz
 220   1           * TR1 - timer 1 run
 221   1           * TI - set TI to send first char of UART */
 222   1          /* dont go into free run on restart */
 223   1          free_run = 0;
 224   1          SCON  = 0x50;
 225   1          TMOD |= 0x20;
 226   1          TH1   = 0xE8;
 227   1          TR1   = 1;
 228   1          TI    = 1;
 229   1          for (;;) {
 230   2              controller();
 231   2          }
 232   1      }
 233          


MODULE INFORMATION:   STATIC OVERLAYABLE
   CODE SIZE        =    600    ----
   CONSTANT SIZE    =    768    ----
   XDATA SIZE       =  32767    ----
   PDATA SIZE       =   ----    ----
   DATA SIZE        =     46    ----
C51 COMPILER V9.02   MAIN                                                                  04/17/2014 15:17:33 PAGE 5   

   IDATA SIZE       =   ----    ----
   BIT SIZE         =   ----    ----
   EDATA SIZE       =   ----    ----
   HDATA SIZE       =   ----    ----
   XDATA CONST SIZE =   ----    ----
   FAR CONST SIZE   =   ----    ----
END OF MODULE INFORMATION.


C51 COMPILATION COMPLETE.  0 WARNING(S),  0 ERROR(S)