Mercurial > hg > index.cgi
view lwasm/symbol.c @ 333:507f442dc71e
Add support for 6800 compatibility instructions.
The occasional program uses the 6800 compatibility instructions since they
are actually specified by Motorola in at least some documentation. They
advertised the 6809 as source compatible with the 6800.
This mode is not enabled by default, however. It is my belief that receiving
an error when using a non-6809 instruction is more useful since it is
unlikely that much 6800 source code is being assembled for the 6809 these
days. Nevertheless, the --6809compat option is present for just those
purposes so one does not have to resort to using macros (which would work
equally well in most cases).
author | William Astle <lost@l-w.ca> |
---|---|
date | Tue, 15 Apr 2014 10:57:34 -0600 |
parents | f45b2a68c3da |
children | d149e2b56981 |
line wrap: on
line source
/* symbol.c Copyright © 2010 William Astle This file is part of LWTOOLS. LWTOOLS is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include <stdio.h> #include <stdlib.h> #include <string.h> #include <lw_alloc.h> #include <lw_expr.h> #include <lw_string.h> #include "lwasm.h" #if 0 struct symtabe *symbol_findprev(asmstate_t *as, struct symtabe *se) { struct symtabe *se1, *se2; int i; for (se2 = NULL, se1 = as -> symtab.head; se1; se1 = se1 -> next) { debug_message(as, 200, "Sorting; looking at symbol %s (%p) for %s", se1 -> symbol, se1, se -> symbol); /* compare se with se1 */ i = strcasecmp(se -> symbol, se1 -> symbol); /* if the symbol sorts before se1, we just need to return */ if (i < 0) return se2; if (i == 0) { /* symbol name matches; compare other things */ /*if next version is greater than this one, return */ if (se -> version > se1 -> version) return se2; /* if next context is great than this one, return */ if (se -> context > se1 -> context) return se2; /* if section name is greater, return */ /* if se has no section but se1 does, we go first */ if (se -> section == NULL && se1 -> section != NULL) return se2; if (se -> section != NULL && se1 -> section != NULL) { /* compare section names and if se < se1, return */ i = strcasecmp(se -> section -> name, se1 -> section -> name); if (i < 0) return se2; } } se2 = se1; } return se2; } #endif struct symtabe *register_symbol(asmstate_t *as, line_t *cl, char *sym, lw_expr_t val, int flags) { struct symtabe *se, *nse; struct symtabe *sprev; int islocal = 0; int context = -1; int version = -1; char *cp; int cdir; debug_message(as, 200, "Register symbol %s (%02X), %s", sym, flags, lw_expr_print(val)); if (!(flags & symbol_flag_nocheck)) { if (!sym || !*sym) { lwasm_register_error(as, cl, "Bad symbol (%s)", sym); return NULL; } if (*sym < 0x80 && (!strchr(SSYMCHARS, *sym) && !strchr(sym + 1, '$') && !strchr(sym + 1, '@') && !strchr(sym + 1, '?'))) { lwasm_register_error(as, cl, "Bad symbol (%s)", sym); return NULL; } if ((*sym == '$' || *sym == '@') && (sym[1] >= '0' && sym[1] <= '9')) { lwasm_register_error(as, cl, "Bad symbol (%s)", sym); return NULL; } } for (cp = sym; *cp; cp++) { if (*cp == '@' || *cp == '?') islocal = 1; if (*cp == '$' && !(CURPRAGMA(cl, PRAGMA_DOLLARNOTLOCAL))) islocal = 1; // bad symbol if (!(flags & symbol_flag_nocheck) && *cp < 0x80 && !strchr(SYMCHARS, *cp)) { lwasm_register_error(as, cl, "Bad symbol (%s)", sym); return NULL; } } if (islocal) context = cl -> context; // first, look up symbol to see if it is already defined cdir = 0; for (se = as -> symtab.head, sprev = NULL; se; ) { int ndir; debug_message(as, 300, "Symbol add lookup: %p", se); ndir = strcasecmp(sym, se -> symbol); // if (!ndir && !CURPRAGMA(cl, PRAGMA_SYMBOLNOCASE) && !(se -> flags & symbol_flag_set)) if (!ndir && !(se -> flags & symbol_flag_set)) { if (strcmp(sym, se -> symbol)) { if (!CURPRAGMA(cl, PRAGMA_SYMBOLNOCASE) && !(se -> flags & symbol_flag_nocase)) ndir = 1; } } if (!ndir && se -> context != context) { ndir = (context < se -> context) ? -1 : 1; } if (!ndir) { if ((flags & symbol_flag_set) && (se -> flags & symbol_flag_set)) { version = se -> version; } break; } cdir = ndir; sprev = se; if (cdir < 0) se = se -> left; else se = se -> right; } if (se && version == -1) { // multiply defined symbol lwasm_register_error(as, cl, "Multiply defined symbol (%s)", sym); return NULL; } if (flags & symbol_flag_set) { version++; } // symplify the symbol expression - replaces "SET" symbols with // symbol table entries lwasm_reduce_expr(as, val); nse = lw_alloc(sizeof(struct symtabe)); nse -> context = context; nse -> version = version; nse -> flags = flags; if (CURPRAGMA(cl, PRAGMA_NOLIST)) { nse -> flags |= symbol_flag_nolist; } if (CURPRAGMA(cl, PRAGMA_SYMBOLNOCASE)) { nse -> flags |= symbol_flag_nocase; } if (!cl && (as -> pragmas & PRAGMA_SYMBOLNOCASE)) { nse -> flags |= symbol_flag_nocase; } nse -> value = lw_expr_copy(val); nse -> symbol = lw_strdup(sym); nse -> right = NULL; nse -> left = NULL; nse -> nextver = NULL; if (se) { nse -> nextver = se; nse -> left = se -> left; nse -> right = se -> right; se -> left = NULL; se -> right = NULL; } if (cl) nse -> section = cl -> csect; else nse -> section = NULL; if (!sprev) { debug_message(as, 200, "Adding symbol at head of symbol table"); as -> symtab.head = nse; } else { debug_message(as, 200, "Adding symbol in middle of symbol table"); if (cdir < 0) sprev -> left = nse; else sprev -> right = nse; } if (CURPRAGMA(cl, PRAGMA_EXPORT) && cl -> csect && !islocal) { exportlist_t *e; /* export symbol if not already exported */ e = lw_alloc(sizeof(exportlist_t)); e -> next = as -> exportlist; e -> symbol = lw_strdup(sym); e -> line = cl; e -> se = nse; as -> exportlist = e; } return nse; } // for "SET" symbols, always returns the LAST definition of the // symbol. This works because the lwasm_reduce_expr() call in // register_symbol will ensure there are no lingering "var" references // to the set symbol anywhere in the symbol table; they will all be // converted to direct references // NOTE: this means that for a forward reference to a SET symbol, // the LAST definition will be the one used. // This arrangement also ensures that any reference to the symbol // itself inside a "set" definition will refer to the previous version // of the symbol. struct symtabe * lookup_symbol(asmstate_t *as, line_t *cl, char *sym) { int local = 0; struct symtabe *s; int cdir; // check if this is a local symbol if (strchr(sym, '@') || strchr(sym, '?')) local = 1; if (cl && !CURPRAGMA(cl, PRAGMA_DOLLARNOTLOCAL) && strchr(sym, '$')) local = 1; if (!cl && !(as -> pragmas & PRAGMA_DOLLARNOTLOCAL) && strchr(sym, '$')) local = 1; // cannot look up local symbol in global context!!!!! if (!cl && local) return NULL; for (s = as -> symtab.head; s; ) { cdir = strcasecmp(sym, s -> symbol); if (!cdir && !(s->flags & symbol_flag_nocase)) { if (strcmp(sym, s -> symbol)) cdir = 1; } if (!cdir) { if (local && s -> context != cl -> context) { cdir = (cl -> context < s -> context) ? -1 : 1; } } if (!cdir) return s; if (cdir < 0) s = s -> left; else s = s -> right; } return NULL; } struct listinfo { sectiontab_t *sect; asmstate_t *as; int complex; }; int list_symbols_test(lw_expr_t e, void *p) { struct listinfo *li = p; if (li -> complex) return 0; if (lw_expr_istype(e, lw_expr_type_special)) { if (lw_expr_specint(e) == lwasm_expr_secbase) { if (li -> sect) { li -> complex = 1; } else { li -> sect = lw_expr_specptr(e); } } } return 0; } void list_symbols_aux(asmstate_t *as, FILE *of, struct symtabe *se) { struct symtabe *s; lw_expr_t te; struct listinfo li; li.as = as; if (!se) return; list_symbols_aux(as, of, se -> left); for (s = se; s; s = s -> nextver) { if (s -> flags & symbol_flag_nolist) continue; lwasm_reduce_expr(as, s -> value); fputc('[', of); if (s -> flags & symbol_flag_set) fputc('S', of); else fputc(' ', of); if (as -> output_format == OUTPUT_OBJ) { if (lw_expr_istype(s -> value, lw_expr_type_int)) fputc('c', of); else fputc('s', of); } if (s -> context < 0) fputc('G', of); else fputc('L', of); fputc(']', of); fputc(' ', of); fprintf(of, "%-32s ", s -> symbol); te = lw_expr_copy(s -> value); li.complex = 0; li.sect = NULL; lw_expr_testterms(te, list_symbols_test, &li); if (li.sect) { as -> exportcheck = 1; as -> csect = li.sect; lwasm_reduce_expr(as, te); as -> exportcheck = 0; } if (lw_expr_istype(te, lw_expr_type_int)) { fprintf(of, "%04X", lw_expr_intval(te)); if (li.sect) { fprintf(of, " (%s)", li.sect -> name); } fprintf(of, "\n"); } else { fprintf(of, "<<incomplete>>\n"); // fprintf(of, "%s\n", lw_expr_print(s -> value)); } lw_expr_destroy(te); } list_symbols_aux(as, of, se -> right); } void list_symbols(asmstate_t *as, FILE *of) { fprintf(of, "\nSymbol Table:\n"); list_symbols_aux(as, of, as -> symtab.head); }