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, 
    "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).
 
      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,
 enum {
   REL_FF=1,
   REL_FFFF,

+  BIT_03FF,
+  DIR_07FF,
+  DIR_70FF,
+  DIR_0700FF,

   ABS_0F,
   ABS_FF,
   ABS_0F,
   ABS_FF,

-  ABS_03FF,
-  ABS_07FF,
-  ABS_F0FF,

   ABS_FFFF,
   ABS_FFFF,

-  ABS_0F00FF,
+  ABS_PC,

   MAX_REFS
 };
 
   MAX_REFS
 };
 


@@ -77,13 +78,14 @@ char *refModes[]={
   "???",
   "REL_FF",
   "REL_FFFF",
   "???",
   "REL_FF",
   "REL_FFFF",

+  "BIT_03FF",
+  "DIR_07FF",
+  "DIR_70FF",
+  "DIR_0700FF",

   "ABS_0F",
   "ABS_FF",
   "ABS_0F",
   "ABS_FF",

-  "ABS_03FF",
-  "ABS_07FF",
-  "ABS_F0FF",

   "ABS_FFFF",
   "ABS_FFFF",

-  "ABS_0F00FF",
+  "ABS_PC"

 };
 
 #define CODESIZE 0x10000
 };
 
 #define CODESIZE 0x10000


@@ -141,6 +143,7 @@ struct SYMBOL {
 struct REFERENCE {
   char *name;
   struct MODULE *module;
 struct REFERENCE {
   char *name;
   struct MODULE *module;

+  struct SEGMENT *segment;

   int lineno;
   unsigned address, pc;
   short how;
   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=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);
   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;
   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) {
 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;
     }
   }
       reference->resolved=1;
     }
   }


@@ -467,22 +474,21 @@ void writeModule(char *outFileName) {
   if ((fOut=fopen(outFileName, "w"))==NULL) {
     perror (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;
 
   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];
     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;
     }
     }
     checksum &= 0xff;
     if (checksum) {
       checksum = 0x100 - checksum;
     }

-    fprintf (fOut, " < %02X\n", checksum);
+    fprintf (fOut, "%02X\n", checksum);

   }
   fprintf (fOut, ":00000001FF\n");
 
   }
   fprintf (fOut, ":00000001FF\n");
 


@@ -552,45 +558,66 @@ int relocate() {
   }
   // and the references
   for (reference=references; reference; reference=reference->next) {
   }
   // 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 {
       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) 
        {
       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++;
          }
                     reference->name, reference->module->name);
            fatalErrors++;
          }

-         gsinitImage[reference->address+1]=(rel16/2)>>8;
-         gsinitImage[reference->address]=rel16/2;
+         gsfinalImage[reference->address]=rel8/2;

          break;
        }
          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++;
          }
                     reference->name, reference->module->name);
            fatalErrors++;
          }

-         gsinitImage[reference->address]=rel8/2;
+         gsfinalImage[reference->address]=(rel16/2)>>8;
+         gsfinalImage[reference->address+1]=rel16/2;

          break;
        }
          break;
        }

+       case DIR_70FF:
+         gsfinalImage[reference->address] = (symbol->address<<4)&0x70;
+         gsfinalImage[reference->address+1] = symbol->address;
+         break;

        case ABS_FFFF:
        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:
        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",
          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 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;
 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_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");
 }
     }
   return ("UNKNOW");
 }


@@ -96,9 +96,12 @@ struct symbol * build_sym_list(char *thename)
        struct symbol *new, *p;
 
        if ((p=findSymbol(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);
        }
 
        //printf("  Symbol: %s  Line: %d\n", thename, lineno);


@@ -131,22 +134,22 @@ struct symbol *findSymbol (char *thename) {
   return NULL;
 }
 
   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)
 }
 
 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=='=')
   while (p != NULL) {
     if (!(strcasecmp(thename, p->name))) {
       if (p->mode=='=')

-       return 0;
+       ;//return 0;

       return (p->value);
     }
     p = p->next;
       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 ||
   }
   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++) {
       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");
   }
   } 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';
 }
   rel_line[0][0]='\0';
   rel_line[1][0]='\0';
 }


@@ -490,27 +492,6 @@ void boob_error()
        exit(1);
 }
 
        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)
 /* 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 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*);
 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 (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]+\$               {
                                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'};
 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();
 
 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;
 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);
     }
       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;
  
 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);
     }
   }
 }
  
       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;
   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;
   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;
   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;
   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;
   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;
   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;
   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
 
 %%
 %nonassoc UNARY
 
 %%

-

 all:           line
              | line all;
 
 all:           line
              | line all;
 


@@ -408,15 +401,7 @@ expr:      value   {$$ = $1;}
 
 value:   NUMBER {$$ = $1;}
        | CHAR {$$ = $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);
 
 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));
        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;
   }
 | 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));
        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);
   }
 | 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);
                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;
                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));
                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);
        }
   }
                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));
        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 */
   }
 | 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));
        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 */
   }
 | 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));
        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 */
   }
 | 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));
        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 */
   }
 | 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));
        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 '+' ']' {
   }
 
 | 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));
        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;
   }
 | 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));
        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));
   }
 | 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 {
   }
 
 | ORL C ',' bit {


@@ -828,28 +813,28 @@ instruction:
        op[0] = 0x08;
        op[1] = 0x60 + msb(bit_addr($4));
        op[2] = lsb(bit_addr($4));
        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));
   }
 | 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));
   }
 | 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));
   }
 | 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);
   }
 | 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));
        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;
   }
 | stack_inst rlist {
        $$ = 2;


@@ -1008,7 +993,7 @@ instruction:
        size = find_size2(inst_size, $2, $4);
        switch (size) {
        case SIZE8:
        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);
        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);
        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 {
        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);
        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)
   }
 
        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);
        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);
   }
 
        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);
        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);
   }
 
        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);
        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);
   }
 
        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) {
 int puts(char *string) {
   int chars=0;
   while (*string) {

-    putchar (*string);
+    putchar (*string++);

     chars++;
   }
   putchar ('\n');
     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,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
 
  {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)
 {
 }
 int cl_xa::inst_NOP(uint code, int operands)
 {

-  NOTDONE_ASSERT;

   return(resGO);
 }
 int cl_xa::inst_NORM(uint code, int operands)
   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;
       }
       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 {
         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);
         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;
              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 :
     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",
     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;
   }
 
     return;
   }
 

+  // TODO: if (-8 >= right==lit <= 7) instr=MOVS

   /* general case */
   if (size>1) {
     instr=MOVW;
   /* general case */
   if (size>1) {
     instr=MOVW;