work in progress

git-svn-id: https://sdcc.svn.sourceforge.net/svnroot/sdcc/trunk/sdcc@1929 4a8a32a2-be11-0410-ad9d-d568d2c75423

diff --git a/as/xa51/xa_link.c b/as/xa51/xa_link.c
index 7eace8ddf19fc633afd77821906a3cd6e6a3a802..6eb90101b0f801635980904d17bae7322d58c0d0 100644 (file)
--- a/as/xa51/xa_link.c
+++ b/as/xa51/xa_link.c
@@ -29,7 +29,7 @@
    "T xxxx <how> <symbol> 0"
    "R xxxx <how> <symbol> <pc+>" the relocation info. xxxx is the address
      within relative code space. How is something like REL_FF, REL_FFFF, 
-     ABS_F0FF. Symbol is the referenced symbol and pc+ is the program 
+     ABS_70FF. Symbol is the referenced symbol and pc+ is the program 
      counter that will be used to calculate the relative address (that is
      the address of the following instruction).
 
@@ -63,13 +63,14 @@ enum {
 enum {
   REL_FF=1,
   REL_FFFF,
+  BIT_03FF,
+  DIR_07FF,
+  DIR_70FF,
+  DIR_0700FF,
   ABS_0F,
   ABS_FF,
-  ABS_03FF,
-  ABS_07FF,
-  ABS_F0FF,
   ABS_FFFF,
-  ABS_0F00FF,
+  ABS_PC,
   MAX_REFS
 };
 
@@ -77,13 +78,14 @@ char *refModes[]={
   "???",
   "REL_FF",
   "REL_FFFF",
+  "BIT_03FF",
+  "DIR_07FF",
+  "DIR_70FF",
+  "DIR_0700FF",
   "ABS_0F",
   "ABS_FF",
-  "ABS_03FF",
-  "ABS_07FF",
-  "ABS_F0FF",
   "ABS_FFFF",
-  "ABS_0F00FF",
+  "ABS_PC"
 };
 
 #define CODESIZE 0x10000
@@ -141,6 +143,7 @@ struct SYMBOL {
 struct REFERENCE {
   char *name;
   struct MODULE *module;
+  struct SEGMENT *segment;
   int lineno;
   unsigned address, pc;
   short how;
@@ -226,9 +229,13 @@ void addToRefs(char *ref, int address, char *how, int pc) {
   reference=calloc(1, sizeof(struct REFERENCE));
   reference->name=strdup(ref);
   reference->module=currentModule;
+  reference->segment=currentSegment;
   reference->lineno=currentLine;
   reference->address=address;
   reference->how=howToReference(how);
+  if (reference->how==ABS_PC) {
+    reference->resolved=1;
+  }
   reference->pc=pc;
   if (!references) {
     references=reference;
@@ -241,7 +248,7 @@ void addToRefs(char *ref, int address, char *how, int pc) {
 void resolve() {
   struct REFERENCE *reference;
   for (reference=references; reference; reference=reference->next) {
-    if (findSymbolByName(reference->name)) {
+    if ((reference->how==ABS_PC) || findSymbolByName(reference->name)) {
       reference->resolved=1;
     }
   }
@@ -467,22 +474,21 @@ void writeModule(char *outFileName) {
   if ((fOut=fopen(outFileName, "w"))==NULL) {
     perror (outFileName);
   }
-  fprintf (fOut, "Just for now, make it a little bit more readable\n");
 
   while (size) {
     len = size>16 ? 16 : size;
     size-=len;
-    fprintf (fOut, ":%02X.%04X.%02X >", len, address, 0);
+    fprintf (fOut, ":%02X%04X%02X", len, address, 0);
     checksum = len + (address>>8) + (address&0xff);
     while (len--) {
       checksum += gsfinalImage[address];
-      fprintf (fOut, " %02X", gsfinalImage[address++]);
+      fprintf (fOut, "%02X", gsfinalImage[address++]);
     }
     checksum &= 0xff;
     if (checksum) {
       checksum = 0x100 - checksum;
     }
-    fprintf (fOut, " < %02X\n", checksum);
+    fprintf (fOut, "%02X\n", checksum);
   }
   fprintf (fOut, ":00000001FF\n");
 
@@ -552,45 +558,66 @@ int relocate() {
   }
   // and the references
   for (reference=references; reference; reference=reference->next) {
-    if (!(symbol=findSymbolByName(reference->name))) {
-      // this reference isn't defined after all
+    symbol=findSymbolByName(reference->name);
+    if (!reference->resolved && !symbol && reference->how!=ABS_PC) {
+      // this reference isn't resolved after all
       fprintf (stderr, "*** %s:%d undefined symbol %s\n",
               reference->module->name, reference->lineno,
               reference->name);
       fatalErrors++;
     } else {
-      reference->address += symbol->segment->start;
-      reference->pc += symbol->segment->start;
+      reference->address += 
+       reference->module->offset[reference->segment->id]+
+       reference->segment->start;
+      reference->pc += 
+       reference->module->offset[reference->segment->id]+
+       reference->segment->start;
       switch (reference->how) 
        {
-       case REL_FFFF: {
-         int rel16 = symbol->address-reference->pc;
-         if (rel16<-65536 || rel16>65534) {
-           fprintf (stderr, 
-                    "rel16 target for %s is out of range in module %s\n",
+       case REL_FF: {
+         int rel8 = symbol->address-(reference->pc & ~1);
+         if (rel8<-256 || rel8>256) {
+           fprintf (stderr,
+                    "rel8 target for %s is out of range in module %s\n",
                     reference->name, reference->module->name);
            fatalErrors++;
          }
-         gsinitImage[reference->address+1]=(rel16/2)>>8;
-         gsinitImage[reference->address]=rel16/2;
+         gsfinalImage[reference->address]=rel8/2;
          break;
        }
-       case REL_FF: {
-         int rel8 = symbol->address-reference->pc;
-         if (rel8<-256 || rel8>256) {
-           fprintf (stderr,
-                    "rel8 target for %s is out of range in module %s\n",
+       case REL_FFFF: {
+         int rel16 = symbol->address-(reference->pc & ~1);
+         if (rel16<-65536 || rel16>65534) {
+           fprintf (stderr, 
+                    "rel16 target for %s is out of range in module %s\n",
                     reference->name, reference->module->name);
            fatalErrors++;
          }
-         gsinitImage[reference->address]=rel8/2;
+         gsfinalImage[reference->address]=(rel16/2)>>8;
+         gsfinalImage[reference->address+1]=rel16/2;
          break;
        }
+       case DIR_70FF:
+         gsfinalImage[reference->address] = (symbol->address<<4)&0x70;
+         gsfinalImage[reference->address+1] = symbol->address;
+         break;
        case ABS_FFFF:
-         gsinitImage[reference->address+1] = symbol->address>>8;
-         // fall through
+         gsfinalImage[reference->address] = symbol->address>>8;
+         gsfinalImage[reference->address+1] = symbol->address;
+         break;
        case ABS_FF:
-         gsinitImage[reference->address] = symbol->address;
+         gsfinalImage[reference->address] = symbol->address;
+         break;
+       case ABS_PC: 
+         {
+           unsigned int address=
+             (gsfinalImage[reference->address]<<8) +
+             gsfinalImage[reference->address+1];
+           address += reference->module->offset[reference->segment->id];
+           address += segments[reference->segment->id].start;
+           gsfinalImage[reference->address] = address>>8;
+           gsfinalImage[reference->address+1] = address;
+         };
          break;
        default:
          fprintf (stderr, "unsupported reference mode %d.\n",

diff --git a/as/xa51/xa_main.c b/as/xa51/xa_main.c
index aadba0f5468e1cb2990b5480c1617c6ec200a466..50c1d44d0c758c99251f831bb3c574694a5cf778 100644 (file)
--- a/as/xa51/xa_main.c
+++ b/as/xa51/xa_main.c
@@ -57,7 +57,7 @@ struct target *targ_list=NULL;
 int lineno=1;
 int p1=0, p2=0, p3=0;
 int expr_result, expr_ok, jump_dest, inst;
-int opcode, operand;
+int opcode;
 char symbol_name[1000];
 struct area_struct area[NUM_AREAS];
 int current_area=0;
@@ -76,9 +76,9 @@ char *areaToString (int area) {
     case AREA_XISEG: return "XISEG";
     case AREA_XINIT: return "XINIT";
     case AREA_GSINIT: return "GSINIT";
-    case AREA_GSFINAL: return "GSFINAL";
-    case AREA_HOME: return "HOME";
-    case AREA_SSEG: return "SSEG";
+      //case AREA_GSFINAL: return "GSFINAL";
+      //case AREA_HOME: return "HOME";
+      //case AREA_SSEG: return "SSEG";
     }
   return ("UNKNOW");
 }
@@ -96,9 +96,12 @@ struct symbol * build_sym_list(char *thename)
        struct symbol *new, *p;
 
        if ((p=findSymbol(thename))) {
-         p->area=current_area;
-         //fprintf (stderr, "warning, symbol %s already defined\n", thename);
-         return p;
+         if (p->isdef) {
+           fprintf (stderr, "error: symbol %s already defined\n", thename);
+           exit (1);
+         } else {
+           return p;
+         }
        }
 
        //printf("  Symbol: %s  Line: %d\n", thename, lineno);
@@ -131,22 +134,22 @@ struct symbol *findSymbol (char *thename) {
   return NULL;
 }
 
-int assign_value(char *thename, int thevalue, char mode)
-{
-       struct symbol *p;
-
-       p = sym_list;
-       while (p != NULL) {
-               if (!(strcasecmp(thename, p->name))) {
-                       p->value = thevalue;
-                       p->isdef = 1;
-                       p->mode = mode;
-                       return (0);
-               }
-               p = p->next;
-       }
-       fprintf(stderr, "Internal Error!  Couldn't find symbol\n");
-       exit(1);
+int assign_value(char *thename, int thevalue, char mode) {
+  struct symbol *p;
+  
+  p = sym_list;
+  while (p != NULL) {
+    if (!(strcasecmp(thename, p->name))) {
+      p->area=current_area;
+      p->value = thevalue;
+      p->isdef = 1;
+      p->mode = mode;
+      return (0);
+    }
+    p = p->next;
+  }
+  fprintf(stderr, "Internal Error!  Couldn't find symbol\n");
+  exit(1);
 }
 
 int mk_bit(char *thename, int area)
@@ -223,7 +226,7 @@ int get_value(char *thename)
   while (p != NULL) {
     if (!(strcasecmp(thename, p->name))) {
       if (p->mode=='=')
-       return 0;
+       ;//return 0;
       return (p->value);
     }
     p = p->next;
@@ -425,7 +428,6 @@ void out(int *byte_list, int num) {
   }
   if (current_area==AREA_CSEG ||
       current_area==AREA_GSINIT ||
-      current_area==AREA_GSFINAL ||
       current_area==AREA_XINIT) {
     if (num) {
       for (i=0; i<num; i++) {
@@ -460,8 +462,8 @@ void out(int *byte_list, int num) {
   } else {
     if (num % 4) fprintf(list_fp, "\n");
   }
-  expr_var[0][0]='\0';
-  expr_var[1][0]='\0';
+  operand[0][0]='\0';
+  operand[1][0]='\0';
   rel_line[0][0]='\0';
   rel_line[1][0]='\0';
 }
@@ -490,27 +492,6 @@ void boob_error()
        exit(1);
 }
 
-/* output the jump either direction on carry */
-/* jump_dest and MEM_POS must have the proper values */
-
-/* 
-void do_jump_on_carry()
-{
-       if (p3) {
-               operand = REL4(jump_dest, MEM_POS);
-               if (operand < 0) {
-                       operand *= -1;
-                       operand -= 1;
-                       if (operand > 15) boob_error();
-                       out(0x20 + (operand & 15));
-               } else {
-                       if (operand > 15) boob_error();
-                       out(0x30 + (operand & 15));
-               }
-       }
-}
-*/ 
-
 /* turn a string like "10010110b" into an int */
 
 int binary2int(char *str)

diff --git a/as/xa51/xa_main.h b/as/xa51/xa_main.h
index a5c0dfcb6f20a33208ab11f1ab8eab69b49befe7..400e7dcf9f620fc9ac577cb6e6b142f282b437ca 100644 (file)
--- a/as/xa51/xa_main.h
+++ b/as/xa51/xa_main.h
@@ -96,7 +96,7 @@ extern struct symbol * is_ref(char *thename);
 extern int get_value(char *thename);
 extern struct symbol *findSymbol (char *thename);
 extern char rel_line[2][132];
-extern char expr_var[2][MAX_SYMBOL];
+extern char operand[2][MAX_SYMBOL];
 extern void error(char*);
 int mk_bit(char*, int);
 int mk_sfr(char*);

diff --git a/as/xa51/xa_rasm.l b/as/xa51/xa_rasm.l
index 3f35c188a5ae6e10c46a327a704674575de23e39..8576b7349bde6b038239b64097d4db05f83c74aa 100755 (executable)
--- a/as/xa51/xa_rasm.l
+++ b/as/xa51/xa_rasm.l
@@ -247,6 +247,14 @@ R[0-7]H            {LIST; yylval = (yytext[1] - '0') * 2 + 1 + BYTE_REG; return REG;}
                                        if (is_bit(lex_sym_name)) return BIT;
                                        if (is_reg(lex_sym_name)) return REG;
                                }
+                                if (p3) {
+                                 if (*operand[0]) {
+                                   // first one in use
+                                   strcpy (operand[1], yytext);
+                                 } else {
+                                   strcpy (operand[0], yytext);
+                                 }
+                                }
                                return WORD;
                        }
 [0-9]+\$               {

diff --git a/as/xa51/xa_rasm.y b/as/xa51/xa_rasm.y
index 20d6da99dbc26bf95caccc4c35f06421b0802db9..c99078e2c8f74b00d4dff47031b65333803cac31 100755 (executable)
--- a/as/xa51/xa_rasm.y
+++ b/as/xa51/xa_rasm.y
@@ -33,7 +33,7 @@ int stack_addr_opcode, stack_reg_opcode, branch_opcode;
 int rlist_reg_bank, rlist_bitmask, rlist_size;
 int db_count, dw_count, i;
 char symbol_name[MAX_SYMBOL], base_symbol_name[MAX_SYMBOL]={'\0'};
-char expr_var[2][MAX_SYMBOL]={{'\0'},{'\0'}};
+char operand[2][MAX_SYMBOL]={{'\0'},{'\0'}};
 
 extern char lex_sym_name[];
 extern int yylex();
@@ -46,8 +46,8 @@ void error(char *s);
 void RELOC_FF(unsigned where, unsigned pc, short rl) {
   // pc = PC of the next instruction
   struct symbol *sym;
-  if ((sym=findSymbol(yytext))) {
-    if (sym->mode=='X') {
+  if ((sym=findSymbol(operand[0]))) {
+    if (sym->mode=='X' || sym->area!=current_area) {
       sprintf (rel_line[rl], "R %04x REL_FF %s %04x", 
               where, sym->name, pc);
     }
@@ -56,84 +56,78 @@ void RELOC_FF(unsigned where, unsigned pc, short rl) {
  
 void RELOC_FFFF(unsigned where, unsigned pc, short rl) {
   struct symbol *sym;
-  if ((sym=findSymbol(yytext))) {
-    if (sym->mode=='X') {
+  if ((sym=findSymbol(operand[0]))) {
+    if (sym->mode=='X' || sym->area!=current_area) {
       sprintf (rel_line[rl], "R %04x REL_FFFF %s %04x", 
               where, sym->name, pc);
     }
   }
 }
  
-void RELOC_ABS_0F(unsigned where, int expr) {
+void RELOC_ABS_0F(unsigned where, int seq) {
   struct symbol *sym;
-  if ((sym=findSymbol(expr_var[expr]))) {
-    if (sym->mode=='X') {
-      sprintf (rel_line[expr], "R %04x ABS_0F %s 0", where, sym->name);
-    }
+  if ((sym=findSymbol(operand[seq])) && sym->mode!='A') {
+    sprintf (rel_line[seq], "R %04x ABS_0F %s 0", where, sym->name);
   }
 }
 
-void RELOC_ABS_FF(unsigned where, int expr) {
+void RELOC_BIT_03FF(unsigned where, int seq) {
   struct symbol *sym;
-  if ((sym=findSymbol(expr_var[expr]))) {
-    if (sym->mode=='X') {
-      sprintf (rel_line[expr], "R %04x ABS_FF %s 0", where, sym->name);
-    }
+  if ((sym=findSymbol(operand[seq])) && sym->mode!='A') {
+    sprintf (rel_line[seq], "R %04x BIT_03FF %s 0", where, sym->name);
   }
 }
 
-void RELOC_ABS_03FF(unsigned where, int expr) {
+void RELOC_DIR_07FF(unsigned where, int seq) {
   struct symbol *sym;
-  if (expr_var[0]) {
-    if ((sym=findSymbol(expr_var[expr]))) {
-      if (sym->mode=='X') {
-       sprintf (rel_line[expr], "R %04x ABS_03FF %s 0", where, sym->name);
-      }
-    }
+  if ((sym=findSymbol(operand[seq])) && sym->mode!='A') {
+    sprintf (rel_line[seq], "R %04x DIR_07FF %s 0", where, sym->name);
   }
 }
 
-void RELOC_ABS_07ff(unsigned where, int expr) {
+void RELOC_DIR_70FF(unsigned where, int seq) {
   struct symbol *sym;
-  if (expr_var[0]) {
-    if ((sym=findSymbol(expr_var[expr]))) {
-      if (sym->mode=='X') {
-       sprintf (rel_line[expr], "R %04x ABS_07ff %s 0", where, sym->name);
-      }
-    }
+  if ((sym=findSymbol(operand[seq])) && sym->mode!='A') {
+    sprintf (rel_line[seq], "R %04x DIR_70FF %s 0", where, sym->name);
   }
 }
 
-void RELOC_ABS_F0FF(unsigned where, int expr) {
+void RELOC_ABS_FF(unsigned where, int seq) {
   struct symbol *sym;
-  if (expr_var[0]) {
-    if ((sym=findSymbol(expr_var[expr]))) {
-      if (sym->mode=='X') {
-       sprintf (rel_line[expr], "R %04x ABS_F0FF %s", where, sym->name);
-      }
-    }
+  if ((sym=findSymbol(operand[seq])) && sym->mode!='A') {
+    sprintf (rel_line[seq], "R %04x DIR_FF %s 0", where, sym->name);
   }
 }
- 
-void RELOC_ABS_FFFF(unsigned where, int expr) {
+
+void RELOC_ABS_FFFF(unsigned where, int seq) {
   struct symbol *sym;
-  if (expr_var[0]) {
-    if ((sym=findSymbol(expr_var[expr]))) {
-      if (sym->mode=='X') {
-       sprintf (rel_line[expr], "R %04x ABS_FFFF %s 0", where, sym->name);
-      }
+  if ((sym=findSymbol(operand[seq]))) {
+    switch (sym->mode) {
+    case 'A':
+      // sfr or sbit, already in instruction
+    case '=':
+      // equat, already in instruction
+      break;
+    case 'X':
+      // external reference
+      sprintf (rel_line[seq], "R %04x ABS_FFFF %s %04x", where, sym->name,
+              sym->value);
+      break;
+    case 'R':
+      // absolute in current segment
+      sprintf (rel_line[seq], "R %04x ABS_PC PC %04x", where, sym->value);
+      break;
+    default:
+      fprintf (stderr, "unknown ABS_FFFF\n");
+      exit (1);
     }
   }
 }
  
-void RELOC_ABS_0F00FF(unsigned where, int expr) {
+void RELOC_DIR_0700FF(unsigned where, int seq) {
   struct symbol *sym;
-  if (expr_var[0]) {
-    if ((sym=findSymbol(expr_var[expr]))) {
-      if (sym->mode=='X') {
-       sprintf (rel_line[expr], "R %04x ABS_0F00FF %s", where, sym->name);
-      }
-    }
+  if ((sym=findSymbol(operand[seq])) && sym->mode!='A') {
+    sprintf (rel_line[seq], "R %04x ABS_0700FF %s 0", where, sym->name);
   }
 }
  
@@ -159,7 +153,6 @@ void RELOC_ABS_0F00FF(unsigned where, int expr) {
 %nonassoc UNARY
 
 %%
-
 all:           line
              | line all;
 
@@ -408,15 +401,7 @@ expr:      value   {$$ = $1;}
 
 value:   NUMBER {$$ = $1;}
        | CHAR {$$ = $1;}
-       | WORD {
-         $$ = $1; 
-         if (expr_var[0][0]=='\0') {
-           strcpy(expr_var[0], yytext);
-         } else {
-           strcpy(expr_var[1], yytext);
-         }
-       }
-
+        | WORD { $$ = $1;}
 
 rlist: REG {
                rlist_bitmask = 1<<(reg($1) % 8);
@@ -507,7 +492,7 @@ instruction:
        op[0] = arith_opcode * 16 + size * 8 + 6;
        op[1] = reg($4) * 16 + 8 + msb(direct_addr($2));
        op[2] = lsb(direct_addr($2));
-       RELOC_ABS_07ff(MEM_POS+1, 0);
+       RELOC_DIR_07FF(MEM_POS+1, 0);
   }
 | arith_inst REG ',' WORD {
        $$ = 3;
@@ -515,7 +500,7 @@ instruction:
        op[0] = arith_opcode * 16 + size * 8 + 6;
        op[1] = reg($2) * 16 + msb(direct_addr($4));
        op[2] = lsb(direct_addr($4));
-       RELOC_ABS_07ff(MEM_POS+1, 0);
+       RELOC_DIR_07FF(MEM_POS+1, 0);
   }
 | arith_inst REG ',' '#' expr {
        size = find_size1(inst_size, $2);
@@ -620,7 +605,7 @@ instruction:
                op[1] = msb(direct_addr($2)) * 16 + arith_opcode;
                op[2] = lsb(direct_addr($2));
                op[3] = imm_data8($5);
-               RELOC_ABS_F0FF(MEM_POS+1,0);
+               RELOC_DIR_70FF(MEM_POS+1,0);
                RELOC_ABS_FF(MEM_POS+3,1);
        } else {
                $$ = 5;
@@ -629,7 +614,7 @@ instruction:
                op[2] = lsb(direct_addr($2));
                op[3] = msb(imm_data16($5));
                op[4] = lsb(imm_data16($5));
-               RELOC_ABS_F0FF(MEM_POS+1,0);
+               RELOC_DIR_70FF(MEM_POS+1,0);
                RELOC_ABS_FFFF (MEM_POS+3,1);
        }
   }
@@ -655,7 +640,7 @@ instruction:
        op[0] = 0xA0 + size * 8;
        op[1] = 128 + reg_indirect($5) * 16 + msb(direct_addr($2));
        op[2] = lsb(direct_addr($2));
-       RELOC_ABS_07ff(MEM_POS+1, 0);
+       RELOC_DIR_07FF(MEM_POS+1, 0);
   }
 | arith_inst '[' REG ']' ',' WORD {
        /* this addr mode is only valid for MOV */
@@ -665,7 +650,7 @@ instruction:
        op[0] = 0xA0 + size * 8;
        op[1] = reg_indirect($3) * 16 + msb(direct_addr($6));
        op[2] = lsb(direct_addr($6));
-       RELOC_ABS_07ff(MEM_POS+1, 0);
+       RELOC_DIR_07FF(MEM_POS+1, 0);
   }
 | arith_inst WORD ',' WORD {
        /* this addr mode is only valid for MOV */
@@ -676,8 +661,8 @@ instruction:
        op[1] = msb(direct_addr($2)) * 16 + msb(direct_addr($4));
        op[2] = lsb(direct_addr($2));
        op[3] = lsb(direct_addr($4));
-       RELOC_ABS_F0FF(MEM_POS+1, 0);
-       RELOC_ABS_0F00FF(MEM_POS+1, 1);
+       RELOC_DIR_70FF(MEM_POS+1, 0);
+       RELOC_DIR_0700FF(MEM_POS+1, 1);
   }
 | arith_inst REG ',' USP {
        /* this addr mode is only valid for MOV */
@@ -700,7 +685,7 @@ instruction:
        op[0] = 0x08;
        op[1] = 0x20 + msb(bit_addr($4));
        op[2] = lsb(bit_addr($4));
-       RELOC_ABS_03FF(MEM_POS+1, 0);
+       RELOC_BIT_03FF(MEM_POS+1, 0);
   }
 | arith_inst bit ',' C {
        /* this addr mode is only valid for MOV */
@@ -709,7 +694,7 @@ instruction:
        op[0] = 0x08;
        op[1] = 0x30 + msb(bit_addr($2));
        op[2] = lsb(bit_addr($2));
-       RELOC_ABS_03FF(MEM_POS+1, 0);
+       RELOC_BIT_03FF(MEM_POS+1, 0);
   }
 
 | MOVC REG ',' '[' REG '+' ']' {
@@ -758,7 +743,7 @@ instruction:
        op[0] = 0xA0 + size * 8;
        op[1] = reg($2) * 16 + msb(direct_addr($4));
         op[2] = lsb(direct_addr($4));
-       RELOC_ABS_07ff(MEM_POS+1, 0);
+       RELOC_DIR_07FF(MEM_POS+1, 0);
   }
 | short_data_inst REG ',' '#' expr {
        $$ = 2;
@@ -813,14 +798,14 @@ instruction:
        op[0] = 0x08;
        op[1] = 0x40 + msb(bit_addr($4));
        op[2] = lsb(bit_addr($4));
-       RELOC_ABS_03FF(MEM_POS+1, 0);
+       RELOC_BIT_03FF(MEM_POS+1, 0);
   }
 | ANL C ',' '/' bit {
        $$ = 3;
        op[0] = 0x08;
        op[1] = 0x50 + msb(bit_addr($5));
        op[2] = lsb(bit_addr($5));
-       RELOC_ABS_03FF(MEM_POS+1, 0);
+       RELOC_BIT_03FF(MEM_POS+1, 0);
   }
 
 | ORL C ',' bit {
@@ -828,28 +813,28 @@ instruction:
        op[0] = 0x08;
        op[1] = 0x60 + msb(bit_addr($4));
        op[2] = lsb(bit_addr($4));
-       RELOC_ABS_03FF(MEM_POS+1, 0);
+       RELOC_BIT_03FF(MEM_POS+1, 0);
   }
 | ORL C ',' '/' bit {
        $$ = 3;
        op[0] = 0x08;
        op[1] = 0x70 + msb(bit_addr($5));
        op[2] = lsb(bit_addr($5));
-       RELOC_ABS_03FF(MEM_POS+1, 0);
+       RELOC_BIT_03FF(MEM_POS+1, 0);
   }
 | CLR bit {
        $$ = 3;
        op[0] = 0x08;
        op[1] = msb(bit_addr($2));
        op[2] = lsb(bit_addr($2));
-       RELOC_ABS_03FF(MEM_POS+1, 0);
+       RELOC_BIT_03FF(MEM_POS+1, 0);
   }
 | SETB bit {
        $$ = 3;
        op[0] = 0x08;
        op[1] = 0x10 + msb(bit_addr($2));
        op[2] = lsb(bit_addr($2));
-       RELOC_ABS_03FF(MEM_POS+1, 0);
+       RELOC_BIT_03FF(MEM_POS+1, 0);
   }
 | logical_shift_inst REG ',' REG {
        size = find_size1(inst_size, $2);
@@ -949,7 +934,7 @@ instruction:
        op[0] = msb(stack_addr_opcode) + size * 8;
        op[1] = lsb(stack_addr_opcode) + msb(direct_addr($2));
        op[2] = lsb(direct_addr($2));
-       RELOC_ABS_07ff(MEM_POS+1, 0);
+       RELOC_DIR_07FF(MEM_POS+1, 0);
   }
 | stack_inst rlist {
        $$ = 2;
@@ -1008,7 +993,7 @@ instruction:
        size = find_size2(inst_size, $2, $4);
        switch (size) {
        case SIZE8:
-               error("Singed DIV can't be 8 bit size"); break;
+               error("Signed DIV can't be 8 bit size"); break;
        case SIZE16:
                op[0] = 0xE7;
                op[1] = reg($2) * 16 + reg($4);
@@ -1149,7 +1134,7 @@ instruction:
        op[1] = reg($2) * 16 + msb(direct_addr($4));
        op[2] = lsb(direct_addr($4));
        op[3] = rel8(MEM_POS + $$, $6);
-       RELOC_ABS_07ff(MEM_POS+1, 0);
+       RELOC_DIR_07FF(MEM_POS+1, 0);
        RELOC_FF(MEM_POS+3, MEM_POS + $$, 1);
   }
 | CJNE REG ',' '#' expr ',' jmpaddr {
@@ -1207,7 +1192,7 @@ instruction:
        op[1] = msb(direct_addr($2)) + 8;
        op[2] = lsb(direct_addr($2));
        op[3] = rel8(MEM_POS + $$, $4);
-       RELOC_ABS_07ff(MEM_POS+1, 0);
+       RELOC_DIR_07FF(MEM_POS+1, 0);
        RELOC_FF(MEM_POS+3, MEM_POS + $$, 1)
   }
 
@@ -1217,7 +1202,7 @@ instruction:
        op[1] = 0x80 + msb(bit_addr($2));
        op[2] = lsb(bit_addr($2));
        op[3] = rel8(MEM_POS + $$, $4);
-       RELOC_ABS_03FF(MEM_POS+1, 0);
+       RELOC_BIT_03FF(MEM_POS+1, 0);
        RELOC_FF(MEM_POS+3, MEM_POS + $$, 1);
   }
 
@@ -1227,7 +1212,7 @@ instruction:
        op[1] = 0xC0 + msb(bit_addr($2));
        op[2] = lsb(bit_addr($2));
        op[3] = rel8(MEM_POS + $$, $4);
-       RELOC_ABS_03FF(MEM_POS+1, 0);
+       RELOC_BIT_03FF(MEM_POS+1, 0);
        RELOC_FF(MEM_POS+3, MEM_POS + $$, 1);
   }
 
@@ -1237,7 +1222,7 @@ instruction:
        op[1] = 0xA0 + msb(bit_addr($2));
        op[2] = lsb(bit_addr($2));
        op[3] = rel8(MEM_POS + $$, $4);
-       RELOC_ABS_03FF(MEM_POS+1, 0);
+       RELOC_BIT_03FF(MEM_POS+1, 0);
        RELOC_FF(MEM_POS+3, MEM_POS + $$, 1);
   }
 

diff --git a/device/examples/xa51/hwinit.c b/device/examples/xa51/hwinit.c
index b7c79876195f34c1552c8faa7edda48d213e33bd..16510e676f8e77586442acd6f6c13c6bd1badb1a 100755 (executable)
--- a/device/examples/xa51/hwinit.c
+++ b/device/examples/xa51/hwinit.c
@@ -80,7 +80,7 @@ int kbhit(void) {
 int puts(char *string) {
   int chars=0;
   while (*string) {
-    putchar (*string);
+    putchar (*string++);
     chars++;
   }
   putchar ('\n');

diff --git a/sim/ucsim/xa.src/glob.cc b/sim/ucsim/xa.src/glob.cc
index 380810f219e49100b68968621a425fa246330820..f9e0fa97b4df4b98a0aeff9b94b8e779fa9214b9 100644 (file)
--- a/sim/ucsim/xa.src/glob.cc
+++ b/sim/ucsim/xa.src/glob.cc
@@ -229,8 +229,8 @@ struct xa_dis_entry disass_xa[]= {
  {1,0xf600,0xff00,' ',2,BPL, REL8            }, //  BPL rel8                   1 1 1 1 0 1 1 0  rel8
  {1,0xfe00,0xff00,' ',2,BR, REL8             }, //  BR rel8                    1 1 1 1 1 1 1 0  rel8
 
- {1,0xc500,0xff00,' ',3,CALL, REL16          }, //  CALL rel16                 1 1 0 0 0 1 0 1  rel16
- {0,0xc600,0xfff8,' ',2,CALL, IREG           }, //  CALL [Rs]                  1 1 0 0 0 1 1 0  0 0 0 0 0 s s s
+ {1,0xc500,0xff00,'l',3,CALL, REL16          }, //  CALL rel16                 1 1 0 0 0 1 0 1  rel16
+ {0,0xc600,0xfff8,'l',2,CALL, IREG           }, //  CALL [Rs]                  1 1 0 0 0 1 1 0  0 0 0 0 0 s s s
 
  {0,0xe200,0xf708,' ',4,CJNE, REG_DIRECT_REL8}, //  CJNE Rd, direct, rel8      1 1 1 0 S 0 1 0  d d d d 0 x x x
  {0,0xe300,0xff0f,' ',4,CJNE, REG_DATA8_REL8},  //  CJNE Rd, data8, rel8       1 1 1 0 0 0 1 1  d d d d 0 0 0 0

diff --git a/sim/ucsim/xa.src/inst.cc b/sim/ucsim/xa.src/inst.cc
index 1efe594caef32f84459acd439af2e040f2d88e95..f96a90022c09c75acb9a310924e36cbc1b20eb4c 100644 (file)
--- a/sim/ucsim/xa.src/inst.cc
+++ b/sim/ucsim/xa.src/inst.cc
@@ -791,7 +791,6 @@ int cl_xa::inst_NEG(uint code, int operands)
 }
 int cl_xa::inst_NOP(uint code, int operands)
 {
-  NOTDONE_ASSERT;
   return(resGO);
 }
 int cl_xa::inst_NORM(uint code, int operands)

diff --git a/sim/ucsim/xa.src/inst_gen.cc b/sim/ucsim/xa.src/inst_gen.cc
index 1165e4a5d3512aa3525319dfe04c2e8ebf67dbb4..76e39871b7e746a860ac1d73810b69c16eefa431 100644 (file)
--- a/sim/ucsim/xa.src/inst_gen.cc
+++ b/sim/ucsim/xa.src/inst_gen.cc
@@ -96,12 +96,11 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA
       }
       if (code & 0x0800) {  /* word op */
         t_mem addr = reg2(RI_07) + offset;
-        unsigned short wtmp, wtotal;
-        wtmp = get2(addr);
-        wtotal = FUNC2( wtmp, reg2(RI_F0) );
+        unsigned short wtotal;
+        wtotal = FUNC2( get2(addr), reg2(RI_F0) );
         store2(addr, wtotal);
       } else {
-        t_mem addr = reg2(RI_07) + ((short) fetch2());
+        t_mem addr = reg2(RI_07) + offset;
         unsigned char total;
         total = FUNC1( get1(addr), reg1(RI_F0) );
         store1(addr, total);

diff --git a/sim/ucsim/xa.src/xa.cc b/sim/ucsim/xa.src/xa.cc
index 41b840c7a2eb71eebc88c827b89a5a2ad236073c..0f5ed45498c77f9f6fd3834c79d0cebfbcbb8614 100644 (file)
--- a/sim/ucsim/xa.src/xa.cc
+++ b/sim/ucsim/xa.src/xa.cc
@@ -526,8 +526,15 @@ cl_xa::disass(t_addr addr, char *sep)
              get_bit_name((code&0x0003)<<8) + get_mem(MEM_ROM, addr+2),
              ((signed char)get_mem(MEM_ROM, addr+3)*2+addr+len)&0xfffe);
     break;
+    case DATA4:
+      sprintf(parm_str, "#0x%02x", code&0x0f);
+      break;
     case ADDR24 :
-      strcpy(parm_str, "ADDR24");
+      sprintf(parm_str, "0x%06x", 
+            (get_mem(MEM_ROM, addr+3)<<16) + 
+            (get_mem(MEM_ROM, addr+1)<<8) + 
+            get_mem(MEM_ROM, addr+2));
+      break;
     break;
     case REG_REL8 :
       sprintf(parm_str, "%s,0x%04x",

diff --git a/src/xa51/gen.c b/src/xa51/gen.c
index 57e8cf0fcbad0df28e393b518adced0eb4ed3027..aa05c37e10aa3c28815f4f2fa508f09fc24bd5c1 100755 (executable)
--- a/src/xa51/gen.c
+++ b/src/xa51/gen.c
@@ -1549,6 +1549,7 @@ static void genAssign (iCode * ic) {
     return;
   }
 
+  // TODO: if (-8 >= right==lit <= 7) instr=MOVS
   /* general case */
   if (size>1) {
     instr=MOVW;