git.gag.com Git - fw/sdcc/blob - as/xa51/xa_main.c

   1 /* Paul's XA51 Assembler, Copyright 1997,2002 Paul Stoffregen (paul@pjrc.com)
   2  *
   3  * Paul's XA51 Assembler is free software; you can redistribute it and/or modify
   4  * it under the terms of the GNU General Public License as published by
   5  * the Free Software Foundation; version 2.
   6  *
   7  * This program is distributed in the hope that it will be useful,
   8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
   9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  10  * GNU General Public License for more details.
  11
  12  * You should have received a copy of the GNU General Public License
  13  * along with this program; if not, write to the Free Software
  14  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  15  */
  16
  17 /* adapted from the osu8asm project, 1995 */
  18 /* http://www.pjrc.com/tech/osu8/index.html */
  19
  20 /*
  21    made "relocatable" by johan.knol@iduna.nl for sdcc
  22
  23    This isn't a standalone assembler anymore. It's only purpose is to
  24    create relocatable modules (that has to be processed with xa_link)
  25    out of sdcc-generated .xa files
  26 */
  27
  28 #define D(x) x
  29
  30 #include <stdio.h>
  31 #include <stdlib.h>
  32 #include <string.h>
  33 #include <limits.h>
  34
  35 #define printf(x...) fprintf(stderr,x)
  36
  37 #include "xa_main.h"
  38 #include "xa_version.h"
  39 extern void yyrestart(FILE *new_file);
  40 extern int yyparse();
  41
  42
  43 char modulename[PATH_MAX];
  44 char infilename[PATH_MAX];
  45 char outfilename[PATH_MAX];
  46 char listfilename[PATH_MAX];
  47 char symfilename[PATH_MAX];
  48
  49 /* global variables */
  50
  51 FILE *frel, *fmem, *list_fp, *sym_fp;
  52 extern FILE *yyin;
  53 extern char *yytext;
  54 extern char last_line_text[];
  55 struct symbol *sym_list=NULL;
  56 struct target *targ_list=NULL;
  57 int lineno=1;
  58 int p1=0, p2=0, p3=0;
  59 int expr_result, expr_ok, jump_dest, inst;
  60 int opcode, operand;
  61 char symbol_name[1000];
  62 struct area_struct area[NUM_AREAS];
  63 int current_area=0;
  64
  65 char rel_line[2][132];
  66
  67 char *areaToString (int area) {
  68   switch (area)
  69     {
  70     case AREA_CSEG: return "CSEG";
  71     case AREA_DSEG: return "DSEG";
  72       //case AREA_OSEG: return "OSEG";
  73       //case AREA_ISEG: return "ISEG";
  74     case AREA_BSEG: return "BSEG";
  75     case AREA_XSEG: return "XSEG";
  76     case AREA_XISEG: return "XISEG";
  77     case AREA_XINIT: return "XINIT";
  78     case AREA_GSINIT: return "GSINIT";
  79     case AREA_GSFINAL: return "GSFINAL";
  80     case AREA_HOME: return "HOME";
  81     case AREA_SSEG: return "SSEG";
  82     }
  83   return ("UNKNOW");
  84 }
  85
  86 /* "mem" is replaced by area[current_area].alloc_position */
  87 /* int mem=0; */   /* mem is location in memory */
  88
  89 /* add symbols to list when we find their definition in pass #1 */
  90 /* we will evaluate their values in pass #2, and figure out if */
  91 /* they are branch targets betweem passes 1 and 2.  Every symbol */
  92 /* should appear exactly once in this list, since it can't be redefined */
  93
  94 struct symbol * build_sym_list(char *thename)
  95 {
  96         struct symbol *new, *p;
  97
  98         if ((p=findSymbol(thename))) {
  99           p->area=current_area;
 100           //fprintf (stderr, "warning, symbol %s already defined\n", thename);
 101           return p;
 102         }
 103
 104         //printf("  Symbol: %s  Line: %d\n", thename, lineno);
 105         new = (struct symbol *) malloc(sizeof(struct symbol));
 106         new->name = (char *) malloc(strlen(thename)+1);
 107         strcpy(new->name, thename);
 108         new->value = 0;
 109         new->istarget = 0;
 110         new->isdef = 0;
 111         new->isbit = 0;
 112         new->isreg = 0;
 113         new->line_def = lineno - 1;
 114         new->area = current_area;
 115         new->mode = 'X'; // start with an external
 116         new->next = NULL;
 117         if (sym_list == NULL) return (sym_list = new);
 118         p = sym_list;
 119         while (p->next != NULL) p = p->next;
 120         p->next = new;
 121         return (new);
 122 }
 123
 124 struct symbol *findSymbol (char *thename) {
 125   struct symbol *p;
 126   for (p=sym_list; p; p=p->next) {
 127     if (strcasecmp(thename, p->name)==0) {
 128       return p;
 129     }
 130   }
 131   return NULL;
 132 }
 133
 134 int assign_value(char *thename, int thevalue, char mode)
 135 {
 136         struct symbol *p;
 137
 138         p = sym_list;
 139         while (p != NULL) {
 140                 if (!(strcasecmp(thename, p->name))) {
 141                         p->value = thevalue;
 142                         p->isdef = 1;
 143                         p->mode = mode;
 144                         return (0);
 145                 }
 146                 p = p->next;
 147         }
 148         fprintf(stderr, "Internal Error!  Couldn't find symbol\n");
 149         exit(1);
 150 }
 151
 152 int mk_bit(char *thename, int area)
 153 {
 154         struct symbol *p;
 155
 156         p = sym_list;
 157         while (p != NULL) {
 158                 if (!(strcasecmp(thename, p->name))) {
 159                         p->isbit = 1;
 160                         p->area = area;
 161                         return (0);
 162                 }
 163                 p = p->next;
 164         }
 165         fprintf(stderr, "Internal Error!  Couldn't find symbol\n");
 166         exit(1);
 167 }
 168
 169 int mk_sfr(char *thename)
 170 {
 171         struct symbol *p;
 172
 173         p = sym_list;
 174         while (p != NULL) {
 175                 if (!(strcasecmp(thename, p->name))) {
 176                         p->issfr = 1;
 177                         p->area = 0;
 178                         return (0);
 179                 }
 180                 p = p->next;
 181         }
 182         fprintf(stderr, "Internal Error!  Couldn't find symbol\n");
 183         exit(1);
 184 }
 185
 186
 187 int mk_reg(char *thename)
 188 {
 189         struct symbol *p;
 190
 191         p = sym_list;
 192         while (p != NULL) {
 193                 if (!(strcasecmp(thename, p->name))) {
 194                         p->isreg = 1;
 195                         return (0);
 196                 }
 197                 p = p->next;
 198         }
 199         fprintf(stderr, "Internal Error!  Couldn't find symbol\n");
 200         exit(1);
 201 }
 202
 203
 204
 205 int get_value(char *thename)
 206 {
 207         struct symbol *p;
 208         p = sym_list;
 209         while (p != NULL) {
 210                 if (!(strcasecmp(thename, p->name)))
 211                         return (p->value);
 212                 p = p->next;
 213         }
 214         fprintf(stderr, "Internal Error!  Couldn't find symbol value\n");
 215         exit(1);
 216 }
 217
 218
 219
 220 /* add every branch target to this list as we find them */
 221 /* ok if multiple entries of same symbol name in this list */
 222
 223 struct target * build_target_list(char *thename)
 224 {
 225         struct target *new, *p;
 226         new = (struct target *) malloc(sizeof(struct target));
 227         new->name = (char *) malloc(strlen(thename)+1);
 228         strcpy(new->name, thename);
 229         new->next = NULL;
 230         if (targ_list == NULL) return (targ_list = new);
 231         p = targ_list;
 232         while (p->next != NULL) p = p->next;
 233         p->next = new;
 234         return (new);
 235 }
 236
 237 /* figure out which symbols are branch targets */
 238
 239 void flag_targets()
 240 {
 241         struct symbol *p_sym;
 242         struct target *p_targ;
 243         p_targ = targ_list;
 244         while (p_targ != NULL) {
 245                 p_sym = sym_list;
 246                 while (p_sym != NULL) {
 247                         if (!strcasecmp(p_sym->name, p_targ->name))
 248                                 p_sym->istarget = 1;
 249                         p_sym = p_sym->next;
 250                 }
 251                 p_targ = p_targ->next;
 252         }
 253 }
 254
 255 void print_symbol_table()
 256 {
 257   struct symbol *p;
 258   p = sym_list;
 259   while (p != NULL) {
 260 #if 0
 261     fprintf(sym_fp, "Sym in %-5s: %s\n", areaToString(p->area), p->name);
 262     fprintf(sym_fp, "  at: 0x%04X (%5d)", p->value, p->value);
 263     fprintf(sym_fp, " Def:%s", p->isdef ? "Yes" : "No ");
 264     fprintf(sym_fp, " Bit:%s", p->isbit ? "Yes" : "No ");
 265     fprintf(sym_fp, " Target:%s", p->istarget ? "Yes" : "No ");
 266     fprintf(sym_fp, " Line %d\n", p->line_def);
 267 #else
 268     if (p->issfr) {
 269       fprintf (sym_fp, "%-5s", "SFR");
 270     } else if (p->isbit && !p->area) {
 271       fprintf (sym_fp, "%-5s", "SBIT");
 272     } else if (!p->isdef) {
 273       fprintf (sym_fp,"EXTRN");
 274     } else {
 275       fprintf (sym_fp, "%-5s", areaToString(p->area));
 276     }
 277     fprintf (sym_fp, " 0x%04x (%5d)", p->value, p->value);
 278     fprintf (sym_fp, " %s", p->isdef ? "D" : "-");
 279     fprintf (sym_fp, "%s", p->isbit ? "B" : "-");
 280     fprintf (sym_fp, "%s", p->istarget ? "T" : "-");
 281     fprintf (sym_fp, " %s\n", p->name);
 282 #endif
 283     p = p->next;
 284   }
 285 }
 286
 287 /* check that every symbol is in the table only once */
 288
 289 void check_redefine()
 290 {
 291   struct symbol *p1, *p2;
 292   p1 = sym_list;
 293   while (p1 != NULL) {
 294     p2 = p1->next;
 295     while (p2 != NULL) {
 296       if (!strcasecmp(p1->name, p2->name)) {
 297         fprintf(stderr, "Error: symbol '%s' redefined on line %d",
 298                 p1->name, p2->line_def);
 299         fprintf(stderr, ", first defined on line %d\n", p1->line_def);
 300         exit(1);
 301       }
 302       p2 = p2->next;
 303     }
 304     p1 = p1->next;
 305   }
 306 }
 307
 308 int is_target(char *thename)
 309 {
 310         struct symbol *p;
 311         p = sym_list;
 312         while (p != NULL) {
 313                 if (!strcasecmp(thename, p->name)) return (p->istarget);
 314                 p = p->next;
 315         }
 316         return (0);
 317 }
 318
 319 int is_bit(char *thename)
 320 {
 321         struct symbol *p;
 322         p = sym_list;
 323         while (p != NULL) {
 324                 if (!strcasecmp(thename, p->name)) return (p->isbit);
 325                 p = p->next;
 326         }
 327         return (0);
 328 }
 329
 330 int is_reg(char *thename)
 331 {
 332         struct symbol *p;
 333         p = sym_list;
 334         while (p != NULL) {
 335                 if (!strcasecmp(thename, p->name)) return (p->isreg);
 336                 p = p->next;
 337         }
 338         return (0);
 339 }
 340
 341
 342 struct symbol *is_def(char *thename)
 343 {
 344   struct symbol *p;
 345   p = sym_list;
 346   while (p != NULL) {
 347     if (!strcasecmp(thename, p->name) && p->isdef)
 348       return p;
 349     p = p->next;
 350   }
 351   return NULL;
 352 }
 353
 354 struct symbol *is_ref(char *thename) {
 355   struct symbol *p;
 356   p = sym_list;
 357   while (p != NULL) {
 358     if (strcasecmp(thename, p->name)==0)
 359       return p;
 360     p = p->next;
 361   }
 362   return NULL;
 363 }
 364
 365 /* this routine is used to dump a group of bytes to the output */
 366 /* it is responsible for generating the list file and sending */
 367 /* the bytes one at a time to the object code generator */
 368 /* this routine is also responsible for generatine the list file */
 369 /* though is it expected that the lexer has placed all the actual */
 370 /* original text from the line in "last_line_text" */
 371
 372 static short last_area=-1;
 373
 374 int debug=0;
 375
 376 void out(int *byte_list, int num) {
 377   struct symbol *p;
 378   int i, first=1;
 379
 380   if (num > 0) fprintf(list_fp, "%06X: ", MEM_POS);
 381   else fprintf(list_fp, "\t");
 382
 383   if (last_area!=current_area) {
 384     // emit area information
 385     fprintf (frel, "A %s size %d flags 0\n",
 386              areaToString(current_area),
 387              area[current_area].size);
 388     area[current_area].defsEmitted=1;
 389     if  (!area[current_area].defsEmitted) {
 390       for (p=sym_list; p; p=p->next) {
 391         if (p->isdef && p->area==current_area) {
 392           if (debug || p->name[strlen(p->name)-1]!='$') {
 393             fprintf (frel, "S %s Def%04x\n", p->name, p->value);
 394           }
 395         }
 396       }
 397     }
 398     last_area=current_area;
 399   }
 400   if (current_area==AREA_CSEG ||
 401       current_area==AREA_GSFINAL ||
 402       current_area==AREA_XINIT) {
 403     if (num) {
 404       fprintf (frel, "T %02x %02x", (MEM_POS>>16)&0xff, MEM_POS&0xff);
 405       for (i=0; i<num; i++) {
 406         fprintf (frel, " %02x", byte_list[i]);
 407       }
 408       fprintf (frel, "\n");
 409       if (rel_line[0][0]) {
 410         fprintf (frel, "%s\n", rel_line[0]);
 411         if (rel_line[1][0]) {
 412           fprintf (frel, "%s\n", rel_line[1]);
 413         }
 414       }
 415     }
 416     for (i=0; i<num; i++) {
 417       if (!first && (i % 4) == 0) fprintf(list_fp, "\t");
 418       fprintf(list_fp, "%02X", byte_list[i]);
 419       if ((i+1) % 4 == 0) {
 420         if (first) fprintf(list_fp, "\t%s\n", last_line_text);
 421         else fprintf(list_fp, "\n");
 422         first = 0;
 423       } else {
 424         if (i<num-1) fprintf(list_fp, " ");
 425       }
 426     }
 427   }
 428   if (first) {
 429     if (num < 3) fprintf(list_fp, "\t");
 430     fprintf(list_fp, "\t%s\n", last_line_text);
 431   } else {
 432     if (num % 4) fprintf(list_fp, "\n");
 433   }
 434   expr_var[0][0]='\0';
 435   expr_var[1][0]='\0';
 436   rel_line[0][0]='\0';
 437   rel_line[1][0]='\0';
 438 }
 439
 440
 441 /* add NOPs to align memory location on a valid branch target address */
 442
 443 void pad_with_nop()
 444 {
 445         static int nops[] = {NOP_OPCODE, NOP_OPCODE, NOP_OPCODE, NOP_OPCODE};
 446         int num;
 447
 448         last_line_text[0] = '\0';
 449
 450         for(num=0; (MEM_POS + num) % BRANCH_SPACING; num++) ;
 451         if (p3) out(nops, num);
 452         MEM_POS += num;
 453 }
 454
 455 /* print branch out of bounds error */
 456
 457 void boob_error()
 458 {
 459         fprintf(stderr, "Error: branch out of bounds");
 460         fprintf(stderr, " in line %d\n", lineno);
 461         exit(1);
 462 }
 463
 464 /* output the jump either direction on carry */
 465 /* jump_dest and MEM_POS must have the proper values */
 466
 467 /*
 468 void do_jump_on_carry()
 469 {
 470         if (p3) {
 471                 operand = REL4(jump_dest, MEM_POS);
 472                 if (operand < 0) {
 473                         operand *= -1;
 474                         operand -= 1;
 475                         if (operand > 15) boob_error();
 476                         out(0x20 + (operand & 15));
 477                 } else {
 478                         if (operand > 15) boob_error();
 479                         out(0x30 + (operand & 15));
 480                 }
 481         }
 482 }
 483 */
 484
 485 /* turn a string like "10010110b" into an int */
 486
 487 int binary2int(char *str)
 488 {
 489         register int i, j=1, sum=0;
 490
 491         for (i=strlen(str)-2; i >= 0; i--) {
 492                 sum += j * (str[i] == '1');
 493                 j *= 2;
 494         }
 495         return (sum);
 496 }
 497
 498 void print_usage(int);
 499
 500
 501 /* todo: someday this will allow the user to control where the */
 502 /* various memory areas go, and it will take care of assigning */
 503 /* positions to area which follow others (such as OSEG getting */
 504 /* set just after DSEG on the 2nd and 3rd passes when we have */
 505 /* leared the size needed for each segment */
 506
 507 void init_areas(void)
 508 {
 509   area[AREA_CSEG].start=area[AREA_CSEG].alloc_position = 0;
 510   area[AREA_DSEG].start=area[AREA_DSEG].alloc_position = 0x30;
 511   area[AREA_BSEG].start=area[AREA_BSEG].alloc_position = 0;
 512   area[AREA_XSEG].start=area[AREA_XSEG].alloc_position = 0;
 513   area[AREA_XISEG].start=area[AREA_XISEG].alloc_position = 0;
 514   area[AREA_XINIT].start=area[AREA_XINIT].alloc_position = 0;
 515   area[AREA_GSINIT].start=area[AREA_GSINIT].alloc_position = 0;
 516   area[AREA_GSFINAL].start=area[AREA_GSFINAL].alloc_position = 0;
 517   area[AREA_HOME].start=area[AREA_HOME].alloc_position = 0;
 518 }
 519
 520 void relPrelude() {
 521   //char buffer[132];
 522   int i, areas=0, globals=0;
 523   struct symbol *p;
 524
 525   fprintf (frel, "SDCCXA rel, version %1.1f\n", version);
 526   for (i=0; i<NUM_AREAS; i++) {
 527     if ((area[i].size=area[i].alloc_position-area[i].start)) {
 528       areas++;
 529     }
 530 #if 0
 531     current_area=i;
 532     sprintf (buffer, "s_%s", areaToString(i));
 533     build_sym_list (buffer);
 534     buffer[0]='l';
 535     build_sym_list (buffer);
 536 #endif
 537   }
 538   for (p=sym_list; p; p=p->next) {
 539     if (p->isdef) {
 540       if (debug || p->name[strlen(p->name)-1]!='$') {
 541         globals++;
 542       }
 543     }
 544   }
 545   fprintf (frel, "H %d areas %d global symbols\n", areas, globals);
 546   fprintf (frel, "M %s\n", modulename);
 547   for (p=sym_list; p; p=p->next) {
 548     if (!p->isdef) {
 549       fprintf (frel, "S %s Ref0000\n", p->name);
 550     }
 551   }
 552 }
 553
 554 void printVersion() {
 555   printf("\nPaul's XA51 Assembler\n");
 556   printf("Copyright 1997,2002 Paul Stoffregen\n\n");
 557   printf("This program is free software; you can redistribute it\n");
 558   printf("and/or modify it under the terms of the GNU General Public\n");
 559   printf("License, Version 2, published by the Free Software Foundation\n\n");
 560   printf("This program is distributed in the hope that it will be useful,\n");
 561   printf("but WITHOUT ANY WARRANTY; without even the implied warranty of\n");
 562   printf("MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\n");
 563 }
 564
 565 int verbose=0, createSymbolFile=0;
 566
 567 void process_args(int argc, char **argv)
 568 {
 569   int i=0;
 570
 571   if (argc < 2) print_usage(1);
 572
 573   while (++i<argc && *argv[i]=='-') {
 574     if (strcmp(argv[i], "--version")==0) {
 575       printVersion();
 576       exit (0);
 577     }
 578     if (strcmp(argv[i], "--help")==0) {
 579       print_usage(0);
 580     }
 581     if (strcmp(argv[i], "-v")==0) {
 582       verbose++;
 583       continue;
 584     }
 585     if (strcmp(argv[i], "-s")==0) {
 586       createSymbolFile++;
 587       continue;
 588     }
 589     print_usage(1);
 590   }
 591
 592   if (i!=argc-1) {
 593     // only 1 source file for now
 594     print_usage(1);
 595   }
 596
 597   strcpy(infilename, argv[i]);
 598
 599   if (strncasecmp(infilename+strlen(infilename)-3, ".xa", 3)) {
 600     fprintf (stderr, "unrecognized input file: \"%s\"\n", argv[i]);
 601     print_usage(1);
 602   }
 603
 604   strcpy(modulename, infilename);
 605   modulename[strlen(modulename)-3] = '\0';
 606   sprintf (outfilename, "%s.rel", modulename);
 607   sprintf (listfilename, "%s.lst", modulename);
 608   if (createSymbolFile) {
 609     sprintf (symfilename, "%s.sym", modulename);
 610   }
 611 }
 612
 613 /* pass #1 (p1=1) find all symbol defs and branch target names */
 614 /* pass #2 (p2=1) align branch targets, evaluate all symbols */
 615 /* pass #3 (p3=1) produce object code */
 616
 617 int main(int argc, char **argv)
 618 {
 619         process_args (argc, argv);
 620
 621         yyin = fopen(infilename, "r");
 622         if (yyin == NULL) {
 623                 fprintf(stderr, "Can't open file '%s'.\n", infilename);
 624                 exit(1);
 625         }
 626         frel = fopen(outfilename, "w");
 627         if (frel == NULL) {
 628                 fprintf(stderr, "Can't write file '%s'.\n", outfilename);
 629                 exit(1);
 630         }
 631         list_fp = fopen(listfilename, "w");
 632         if (list_fp == NULL) {
 633                 fprintf(stderr, "Can't write file '%s'.\n", listfilename);
 634                 exit(1);
 635         }
 636         if (createSymbolFile) {
 637           sym_fp = fopen(symfilename, "w");
 638           if (sym_fp == NULL) {
 639             fprintf(stderr, "Can't write file '%s'.\n", symfilename);
 640             exit(1);
 641           }
 642         }
 643
 644         if (verbose) printf("Pass 1: Building Symbol Table:\n");
 645         p1 = 1;
 646         init_areas();
 647         yyparse();
 648         flag_targets();
 649         check_redefine();
 650
 651         if (verbose) printf("Pass 2: Aligning Branch Targets:\n");
 652         p1 = 0;
 653         p2 = 1;
 654         rewind(yyin);
 655         yyrestart(yyin);
 656         lineno = 1;
 657         init_areas();
 658         yyparse();
 659
 660         relPrelude();
 661         if (createSymbolFile) print_symbol_table();
 662
 663         if (verbose) printf("Pass 3: Generating Object Code:\n");
 664         p2 = 0;
 665         p3 = 1;
 666         rewind(yyin);
 667         yyrestart(yyin);
 668         lineno = 1;
 669         init_areas();
 670         yyparse();
 671
 672         fclose(yyin);
 673         return 0;
 674 }
 675
 676
 677 void print_usage(int fatal)
 678 {
 679   FILE *out = fatal ? stderr : stdout;
 680
 681   fprintf (out, "Usage: xa_asm [-s] [-v] file.xa\n");
 682   fprintf (out, "  -v            verbose: show progress\n");
 683   fprintf (out, "  -s            create symbol file\n");
 684   fprintf (out, "  --version     show version/copyright info and exit\n");
 685   fprintf (out, "  --help        show this and exit\n");
 686 #if 0
 687   // some usefull options I can think of.
 688   fprintf (out, "  -m            create map file\n");
 689   fprintf (out, "  -ss           create symbol file sorted by symbol\n");
 690   fprintf (out, "  -sa           create symbol file sorted by segment/address\n");
 691   fprintf (out, "  --no-temps    supress temp symbols in map and sym file\n");
 692   fprintf (out, "  --code-loc=#  sets the start address of the code\n");
 693   fprintf (out, "  --xdata-loc=# sets the start address of the external data\n");
 694   fprintf (out, "  --stack-loc=# sets the start address of the stack\n");
 695 #endif
 696   exit(fatal);
 697 }
 698