libyasm/symrec.c

   1 /*
   2  * Symbol table handling
   3  *
   4  *  Copyright (C) 2001-2007  Michael Urman, Peter Johnson
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND OTHER CONTRIBUTORS ``AS IS''
  16  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  17  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  18  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR OTHER CONTRIBUTORS BE
  19  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  20  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  21  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  22  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  23  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  24  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  25  * POSSIBILITY OF SUCH DAMAGE.
  26  */
  27 #include "util.h"
  28
  29 #include <limits.h>
  30 #include <ctype.h>
  31
  32 #include "libyasm-stdint.h"
  33 #include "coretype.h"
  34 #include "valparam.h"
  35 #include "hamt.h"
  36 #include "assocdat.h"
  37
  38 #include "errwarn.h"
  39 #include "intnum.h"
  40 #include "floatnum.h"
  41 #include "expr.h"
  42 #include "symrec.h"
  43
  44 #include "bytecode.h"
  45 #include "section.h"
  46 #include "objfmt.h"
  47
  48
  49 typedef enum {
  50     SYM_UNKNOWN,                /* for unknown type (COMMON/EXTERN) */
  51     SYM_EQU,                    /* for EQU defined symbols (expressions) */
  52     SYM_LABEL,                  /* for labels */
  53     SYM_CURPOS,                 /* for labels representing the current
  54                                    assembly position */
  55     SYM_SPECIAL                 /* for special symbols that need to be in
  56                                    the symbol table but otherwise have no
  57                                    purpose */
  58 } sym_type;
  59
  60 struct yasm_symrec {
  61     char *name;
  62     sym_type type;
  63     yasm_sym_status status;
  64     yasm_sym_vis visibility;
  65     unsigned long def_line;     /* line where symbol was first defined */
  66     unsigned long decl_line;    /* line where symbol was first declared */
  67     unsigned long use_line;     /* line where symbol was first used */
  68     union {
  69         yasm_expr *expn;        /* equ value */
  70
  71         /* bytecode immediately preceding a label */
  72         /*@dependent@*/ yasm_bytecode *precbc;
  73     } value;
  74     unsigned int size;          /* 0 if not user-defined */
  75     const char *segment;        /* for segmented systems like DOS */
  76
  77     /* associated data; NULL if none */
  78     /*@null@*/ /*@only@*/ yasm__assoc_data *assoc_data;
  79 };
  80
  81 /* Linked list of symbols not in the symbol table. */
  82 typedef struct non_table_symrec_s {
  83      /*@reldef@*/ SLIST_ENTRY(non_table_symrec_s) link;
  84      /*@owned@*/ yasm_symrec *rec;
  85 } non_table_symrec;
  86
  87 struct yasm_symtab {
  88     /* The symbol table: a hash array mapped trie (HAMT). */
  89     /*@only@*/ HAMT *sym_table;
  90     /* Symbols not in the table */
  91     SLIST_HEAD(nontablesymhead_s, non_table_symrec_s) non_table_syms;
  92
  93     int case_sensitive;
  94 };
  95
  96 static void
  97 objext_valparams_destroy(void *data)
  98 {
  99     yasm_vps_destroy((yasm_valparamhead *)data);
 100 }
 101
 102 static void
 103 objext_valparams_print(void *data, FILE *f, int indent_level)
 104 {
 105     yasm_vps_print((yasm_valparamhead *)data, f);
 106 }
 107
 108 static yasm_assoc_data_callback objext_valparams_cb = {
 109     objext_valparams_destroy,
 110     objext_valparams_print
 111 };
 112
 113 static void
 114 common_size_destroy(void *data)
 115 {
 116     yasm_expr **e = (yasm_expr **)data;
 117     yasm_expr_destroy(*e);
 118     yasm_xfree(data);
 119 }
 120
 121 static void
 122 common_size_print(void *data, FILE *f, int indent_level)
 123 {
 124     yasm_expr **e = (yasm_expr **)data;
 125     yasm_expr_print(*e, f);
 126 }
 127
 128 static yasm_assoc_data_callback common_size_cb = {
 129     common_size_destroy,
 130     common_size_print
 131 };
 132
 133 yasm_symtab *
 134 yasm_symtab_create(void)
 135 {
 136     yasm_symtab *symtab = yasm_xmalloc(sizeof(yasm_symtab));
 137     symtab->sym_table = HAMT_create(0, yasm_internal_error_);
 138     SLIST_INIT(&symtab->non_table_syms);
 139     symtab->case_sensitive = 1;
 140     return symtab;
 141 }
 142
 143 void
 144 yasm_symtab_set_case_sensitive(yasm_symtab *symtab, int sensitive)
 145 {
 146     symtab->case_sensitive = sensitive;
 147 }
 148
 149 static void
 150 symrec_destroy_one(/*@only@*/ void *d)
 151 {
 152     yasm_symrec *sym = d;
 153     yasm_xfree(sym->name);
 154     if (sym->type == SYM_EQU && (sym->status & YASM_SYM_VALUED))
 155         yasm_expr_destroy(sym->value.expn);
 156     yasm__assoc_data_destroy(sym->assoc_data);
 157     yasm_xfree(sym);
 158 }
 159
 160 static /*@partial@*/ yasm_symrec *
 161 symrec_new_common(/*@keep@*/ char *name, int case_sensitive)
 162 {
 163     yasm_symrec *rec = yasm_xmalloc(sizeof(yasm_symrec));
 164
 165     if (!case_sensitive) {
 166         char *c;
 167         for (c=name; *c; c++)
 168             *c = tolower(*c);
 169     }
 170
 171     rec->name = name;
 172     rec->type = SYM_UNKNOWN;
 173     rec->def_line = 0;
 174     rec->decl_line = 0;
 175     rec->use_line = 0;
 176     rec->visibility = YASM_SYM_LOCAL;
 177     rec->size = 0;
 178     rec->segment = NULL;
 179     rec->assoc_data = NULL;
 180     return rec;
 181 }
 182
 183 static /*@partial@*/ /*@dependent@*/ yasm_symrec *
 184 symtab_get_or_new_in_table(yasm_symtab *symtab, /*@only@*/ char *name)
 185 {
 186     yasm_symrec *rec = symrec_new_common(name, symtab->case_sensitive);
 187     int replace = 0;
 188
 189     rec->status = YASM_SYM_NOSTATUS;
 190
 191     if (!symtab->case_sensitive) {
 192         char *c;
 193         for (c=name; *c; c++)
 194             *c = tolower(*c);
 195     }
 196
 197     return HAMT_insert(symtab->sym_table, name, rec, &replace,
 198                        symrec_destroy_one);
 199 }
 200
 201 static /*@partial@*/ /*@dependent@*/ yasm_symrec *
 202 symtab_get_or_new_not_in_table(yasm_symtab *symtab, /*@only@*/ char *name)
 203 {
 204     non_table_symrec *sym = yasm_xmalloc(sizeof(non_table_symrec));
 205     sym->rec = symrec_new_common(name, symtab->case_sensitive);
 206
 207     sym->rec->status = YASM_SYM_NOTINTABLE;
 208
 209     SLIST_INSERT_HEAD(&symtab->non_table_syms, sym, link);
 210
 211     return sym->rec;
 212 }
 213
 214 /* create a new symrec */
 215 /*@-freshtrans -mustfree@*/
 216 static /*@partial@*/ /*@dependent@*/ yasm_symrec *
 217 symtab_get_or_new(yasm_symtab *symtab, const char *name, int in_table)
 218 {
 219     char *symname = yasm__xstrdup(name);
 220
 221     if (in_table)
 222         return symtab_get_or_new_in_table(symtab, symname);
 223     else
 224         return symtab_get_or_new_not_in_table(symtab, symname);
 225 }
 226 /*@=freshtrans =mustfree@*/
 227
 228 int
 229 yasm_symtab_traverse(yasm_symtab *symtab, void *d,
 230                      int (*func) (yasm_symrec *sym, void *d))
 231 {
 232     return HAMT_traverse(symtab->sym_table, d, (int (*) (void *, void *))func);
 233 }
 234
 235 const yasm_symtab_iter *
 236 yasm_symtab_first(const yasm_symtab *symtab)
 237 {
 238     return (const yasm_symtab_iter *)HAMT_first(symtab->sym_table);
 239 }
 240
 241 /*@null@*/ const yasm_symtab_iter *
 242 yasm_symtab_next(const yasm_symtab_iter *prev)
 243 {
 244     return (const yasm_symtab_iter *)HAMT_next((const HAMTEntry *)prev);
 245 }
 246
 247 yasm_symrec *
 248 yasm_symtab_iter_value(const yasm_symtab_iter *cur)
 249 {
 250     return (yasm_symrec *)HAMTEntry_get_data((const HAMTEntry *)cur);
 251 }
 252
 253 yasm_symrec *
 254 yasm_symtab_abs_sym(yasm_symtab *symtab)
 255 {
 256     yasm_symrec *rec = symtab_get_or_new(symtab, "", 1);
 257     rec->def_line = 0;
 258     rec->decl_line = 0;
 259     rec->use_line = 0;
 260     rec->type = SYM_EQU;
 261     rec->value.expn =
 262         yasm_expr_create_ident(yasm_expr_int(yasm_intnum_create_uint(0)), 0);
 263     rec->status |= YASM_SYM_DEFINED|YASM_SYM_VALUED|YASM_SYM_USED;
 264     return rec;
 265 }
 266
 267 yasm_symrec *
 268 yasm_symtab_use(yasm_symtab *symtab, const char *name, unsigned long line)
 269 {
 270     yasm_symrec *rec = symtab_get_or_new(symtab, name, 1);
 271     if (rec->use_line == 0)
 272         rec->use_line = line;   /* set line number of first use */
 273     rec->status |= YASM_SYM_USED;
 274     return rec;
 275 }
 276
 277 yasm_symrec *
 278 yasm_symtab_get(yasm_symtab *symtab, const char *name)
 279 {
 280     if (!symtab->case_sensitive) {
 281         char *_name = yasm__xstrdup(name);
 282         char *c;
 283         yasm_symrec *ret;
 284         for (c=_name; *c; c++)
 285             *c = tolower(*c);
 286         ret = HAMT_search(symtab->sym_table, _name);
 287         yasm_xfree(_name);
 288         return ret;
 289     } else
 290       return HAMT_search(symtab->sym_table, name);
 291 }
 292
 293 static /*@dependent@*/ yasm_symrec *
 294 symtab_define(yasm_symtab *symtab, const char *name, sym_type type,
 295               int in_table, unsigned long line)
 296 {
 297     yasm_symrec *rec = symtab_get_or_new(symtab, name, in_table);
 298
 299     /* Has it been defined before (either by DEFINED or COMMON/EXTERN)? */
 300     if (rec->status & YASM_SYM_DEFINED) {
 301         yasm_error_set_xref(rec->def_line!=0 ? rec->def_line : rec->decl_line,
 302                             N_("`%s' previously defined here"), name);
 303         yasm_error_set(YASM_ERROR_GENERAL, N_("redefinition of `%s'"),
 304                        name);
 305     } else {
 306         if (rec->visibility & YASM_SYM_EXTERN)
 307             yasm_warn_set(YASM_WARN_GENERAL,
 308                           N_("`%s' both defined and declared extern"), name);
 309         rec->def_line = line;   /* set line number of definition */
 310         rec->type = type;
 311         rec->status |= YASM_SYM_DEFINED;
 312         rec->size = 0;
 313         rec->segment = NULL;
 314     }
 315     return rec;
 316 }
 317
 318 yasm_symrec *
 319 yasm_symtab_define_equ(yasm_symtab *symtab, const char *name, yasm_expr *e,
 320                        unsigned long line)
 321 {
 322     yasm_symrec *rec = symtab_define(symtab, name, SYM_EQU, 1, line);
 323     if (yasm_error_occurred())
 324         return rec;
 325     rec->value.expn = e;
 326     rec->status |= YASM_SYM_VALUED;
 327     return rec;
 328 }
 329
 330 yasm_symrec *
 331 yasm_symtab_define_label(yasm_symtab *symtab, const char *name,
 332                          yasm_bytecode *precbc, int in_table,
 333                          unsigned long line)
 334 {
 335     yasm_symrec *rec = symtab_define(symtab, name, SYM_LABEL, in_table, line);
 336     if (yasm_error_occurred())
 337         return rec;
 338     rec->value.precbc = precbc;
 339     if (in_table && precbc)
 340         yasm_bc__add_symrec(precbc, rec);
 341     return rec;
 342 }
 343
 344 yasm_symrec *
 345 yasm_symtab_define_curpos(yasm_symtab *symtab, const char *name,
 346                           yasm_bytecode *precbc, unsigned long line)
 347 {
 348     yasm_symrec *rec = symtab_define(symtab, name, SYM_CURPOS, 0, line);
 349     if (yasm_error_occurred())
 350         return rec;
 351     rec->value.precbc = precbc;
 352     return rec;
 353 }
 354
 355 yasm_symrec *
 356 yasm_symtab_define_special(yasm_symtab *symtab, const char *name,
 357                            yasm_sym_vis vis)
 358 {
 359     yasm_symrec *rec = symtab_define(symtab, name, SYM_SPECIAL, 1, 0);
 360     if (yasm_error_occurred())
 361         return rec;
 362     rec->status |= YASM_SYM_VALUED;
 363     rec->visibility = vis;
 364     return rec;
 365 }
 366
 367 yasm_symrec *
 368 yasm_symtab_declare(yasm_symtab *symtab, const char *name, yasm_sym_vis vis,
 369                     unsigned long line)
 370 {
 371     yasm_symrec *rec = symtab_get_or_new(symtab, name, 1);
 372     yasm_symrec_declare(rec, vis, line);
 373     return rec;
 374 }
 375
 376 void
 377 yasm_symrec_declare(yasm_symrec *rec, yasm_sym_vis vis, unsigned long line)
 378 {
 379     /* Allowable combinations:
 380      *  Existing State--------------  vis  New State-------------------
 381      *  DEFINED GLOBAL COMMON EXTERN  GCE  DEFINED GLOBAL COMMON EXTERN
 382      *     0      -      0      0     GCE     0      G      C      E
 383      *     0      -      0      1     GE      0      G      0      E
 384      *     0      -      1      0     GC      0      G      C      0
 385      * X   0      -      1      1
 386      *     1      -      0      0      G      1      G      0      0
 387      * X   1      -      -      1
 388      * X   1      -      1      -
 389      */
 390     if ((vis == YASM_SYM_GLOBAL) ||
 391         (!(rec->status & YASM_SYM_DEFINED) &&
 392          (!(rec->visibility & (YASM_SYM_COMMON | YASM_SYM_EXTERN)) ||
 393           ((rec->visibility & YASM_SYM_COMMON) && (vis == YASM_SYM_COMMON)) ||
 394           ((rec->visibility & YASM_SYM_EXTERN) && (vis == YASM_SYM_EXTERN))))) {
 395         rec->decl_line = line;
 396         rec->visibility |= vis;
 397     } else
 398         yasm_error_set(YASM_ERROR_GENERAL,
 399             N_("duplicate definition of `%s'; first defined on line %lu"),
 400             rec->name, rec->def_line!=0 ? rec->def_line : rec->decl_line);
 401 }
 402
 403 typedef struct symtab_finalize_info {
 404     unsigned long firstundef_line;
 405     int undef_extern;
 406     yasm_errwarns *errwarns;
 407 } symtab_finalize_info;
 408
 409 static int
 410 symtab_parser_finalize_checksym(yasm_symrec *sym, /*@null@*/ void *d)
 411 {
 412     symtab_finalize_info *info = (symtab_finalize_info *)d;
 413
 414     /* error if a symbol is used but never defined or extern/common declared */
 415     if ((sym->status & YASM_SYM_USED) && !(sym->status & YASM_SYM_DEFINED) &&
 416         !(sym->visibility & (YASM_SYM_EXTERN | YASM_SYM_COMMON))) {
 417         if (info->undef_extern)
 418             sym->visibility |= YASM_SYM_EXTERN;
 419         else {
 420             yasm_error_set(YASM_ERROR_GENERAL,
 421                            N_("undefined symbol `%s' (first use)"), sym->name);
 422             yasm_errwarn_propagate(info->errwarns, sym->use_line);
 423             if (sym->use_line < info->firstundef_line)
 424                 info->firstundef_line = sym->use_line;
 425         }
 426     }
 427
 428     return 0;
 429 }
 430
 431 void
 432 yasm_symtab_parser_finalize(yasm_symtab *symtab, int undef_extern,
 433                             yasm_errwarns *errwarns)
 434 {
 435     symtab_finalize_info info;
 436     info.firstundef_line = ULONG_MAX;
 437     info.undef_extern = undef_extern;
 438     info.errwarns = errwarns;
 439     yasm_symtab_traverse(symtab, &info, symtab_parser_finalize_checksym);
 440     if (info.firstundef_line < ULONG_MAX) {
 441         yasm_error_set(YASM_ERROR_GENERAL,
 442                        N_(" (Each undefined symbol is reported only once.)"));
 443         yasm_errwarn_propagate(errwarns, info.firstundef_line);
 444     }
 445 }
 446
 447 void
 448 yasm_symtab_destroy(yasm_symtab *symtab)
 449 {
 450     HAMT_destroy(symtab->sym_table, symrec_destroy_one);
 451
 452     while (!SLIST_EMPTY(&symtab->non_table_syms)) {
 453         non_table_symrec *sym = SLIST_FIRST(&symtab->non_table_syms);
 454         SLIST_REMOVE_HEAD(&symtab->non_table_syms, link);
 455         symrec_destroy_one(sym->rec);
 456         yasm_xfree(sym);
 457     }
 458
 459     yasm_xfree(symtab);
 460 }
 461
 462 typedef struct symrec_print_data {
 463     FILE *f;
 464     int indent_level;
 465 } symrec_print_data;
 466
 467 /*@+voidabstract@*/
 468 static int
 469 symrec_print_wrapper(yasm_symrec *sym, /*@null@*/ void *d)
 470 {
 471     symrec_print_data *data = (symrec_print_data *)d;
 472     assert(data != NULL);
 473     fprintf(data->f, "%*sSymbol `%s'\n", data->indent_level, "", sym->name);
 474     yasm_symrec_print(sym, data->f, data->indent_level+1);
 475     return 0;
 476 }
 477
 478 void
 479 yasm_symtab_print(yasm_symtab *symtab, FILE *f, int indent_level)
 480 {
 481     symrec_print_data data;
 482     data.f = f;
 483     data.indent_level = indent_level;
 484     yasm_symtab_traverse(symtab, &data, symrec_print_wrapper);
 485 }
 486 /*@=voidabstract@*/
 487
 488 const char *
 489 yasm_symrec_get_name(const yasm_symrec *sym)
 490 {
 491     return sym->name;
 492 }
 493
 494 char *
 495 yasm_symrec_get_global_name(const yasm_symrec *sym, const yasm_object *object)
 496 {
 497     if (sym->visibility & (YASM_SYM_GLOBAL|YASM_SYM_COMMON|YASM_SYM_EXTERN)) {
 498         char *name = yasm_xmalloc(strlen(object->global_prefix) +
 499                                   strlen(sym->name) +
 500                                   strlen(object->global_suffix) + 1);
 501         strcpy(name, object->global_prefix);
 502         strcat(name, sym->name);
 503         strcat(name, object->global_suffix);
 504         return name;
 505     }
 506     return yasm__xstrdup(sym->name);
 507 }
 508
 509 yasm_sym_vis
 510 yasm_symrec_get_visibility(const yasm_symrec *sym)
 511 {
 512     return sym->visibility;
 513 }
 514
 515 yasm_sym_status
 516 yasm_symrec_get_status(const yasm_symrec *sym)
 517 {
 518     return sym->status;
 519 }
 520
 521 unsigned long
 522 yasm_symrec_get_def_line(const yasm_symrec *sym)
 523 {
 524     return sym->def_line;
 525 }
 526
 527 unsigned long
 528 yasm_symrec_get_decl_line(const yasm_symrec *sym)
 529 {
 530     return sym->decl_line;
 531 }
 532
 533 unsigned long
 534 yasm_symrec_get_use_line(const yasm_symrec *sym)
 535 {
 536     return sym->use_line;
 537 }
 538
 539 const yasm_expr *
 540 yasm_symrec_get_equ(const yasm_symrec *sym)
 541 {
 542     if (sym->type == SYM_EQU && (sym->status & YASM_SYM_VALUED))
 543         return sym->value.expn;
 544     return (const yasm_expr *)NULL;
 545 }
 546
 547 int
 548 yasm_symrec_get_label(const yasm_symrec *sym,
 549                       yasm_symrec_get_label_bytecodep *precbc)
 550 {
 551     if (!(sym->type == SYM_LABEL || sym->type == SYM_CURPOS)
 552         || !sym->value.precbc) {
 553         *precbc = (yasm_symrec_get_label_bytecodep)0xDEADBEEF;
 554         return 0;
 555     }
 556     *precbc = sym->value.precbc;
 557     return 1;
 558 }
 559
 560 void
 561 yasm_symrec_set_size(yasm_symrec *sym, int size)
 562 {
 563     sym->size = size;
 564 }
 565
 566 int
 567 yasm_symrec_get_size(const yasm_symrec *sym)
 568 {
 569     return sym->size;
 570 }
 571
 572 void
 573 yasm_symrec_set_segment(yasm_symrec *sym, const char *segment)
 574 {
 575     sym->segment = segment;
 576 }
 577
 578 const char *
 579 yasm_symrec_get_segment(const yasm_symrec *sym)
 580 {
 581     return sym->segment;
 582 }
 583
 584 int
 585 yasm_symrec_is_abs(const yasm_symrec *sym)
 586 {
 587     return (sym->def_line == 0 && sym->type == SYM_EQU &&
 588             sym->name[0] == '\0');
 589 }
 590
 591 int
 592 yasm_symrec_is_special(const yasm_symrec *sym)
 593 {
 594     return (sym->type == SYM_SPECIAL);
 595 }
 596
 597 int
 598 yasm_symrec_is_curpos(const yasm_symrec *sym)
 599 {
 600     return (sym->type == SYM_CURPOS);
 601 }
 602
 603 void
 604 yasm_symrec_set_objext_valparams(yasm_symrec *sym,
 605                                  /*@only@*/ yasm_valparamhead *objext_valparams)
 606 {
 607     yasm_symrec_add_data(sym, &objext_valparams_cb, objext_valparams);
 608 }
 609
 610 yasm_valparamhead *
 611 yasm_symrec_get_objext_valparams(yasm_symrec *sym)
 612 {
 613     return yasm_symrec_get_data(sym, &objext_valparams_cb);
 614 }
 615
 616 void
 617 yasm_symrec_set_common_size(yasm_symrec *sym,
 618                             /*@only@*/ yasm_expr *common_size)
 619 {
 620     yasm_expr **ep = yasm_xmalloc(sizeof(yasm_expr *));
 621     *ep = common_size;
 622     yasm_symrec_add_data(sym, &common_size_cb, ep);
 623 }
 624
 625 yasm_expr **
 626 yasm_symrec_get_common_size(yasm_symrec *sym)
 627 {
 628     return (yasm_expr **)yasm_symrec_get_data(sym, &common_size_cb);
 629 }
 630
 631 void *
 632 yasm_symrec_get_data(yasm_symrec *sym,
 633                      const yasm_assoc_data_callback *callback)
 634 {
 635     return yasm__assoc_data_get(sym->assoc_data, callback);
 636 }
 637
 638 void
 639 yasm_symrec_add_data(yasm_symrec *sym,
 640                      const yasm_assoc_data_callback *callback, void *data)
 641 {
 642     sym->assoc_data = yasm__assoc_data_add(sym->assoc_data, callback, data);
 643 }
 644
 645 void
 646 yasm_symrec_print(const yasm_symrec *sym, FILE *f, int indent_level)
 647 {
 648     switch (sym->type) {
 649         case SYM_UNKNOWN:
 650             fprintf(f, "%*s-Unknown (Common/Extern)-\n", indent_level, "");
 651             break;
 652         case SYM_EQU:
 653             fprintf(f, "%*s_EQU_\n", indent_level, "");
 654             fprintf(f, "%*sExpn=", indent_level, "");
 655             if (sym->status & YASM_SYM_VALUED)
 656                 yasm_expr_print(sym->value.expn, f);
 657             else
 658                 fprintf(f, "***UNVALUED***");
 659             fprintf(f, "\n");
 660             break;
 661         case SYM_LABEL:
 662         case SYM_CURPOS:
 663             fprintf(f, "%*s_%s_\n%*sSection:\n", indent_level, "",
 664                     sym->type == SYM_LABEL ? "Label" : "CurPos",
 665                     indent_level, "");
 666             yasm_section_print(yasm_bc_get_section(sym->value.precbc), f,
 667                                indent_level+1, 0);
 668             fprintf(f, "%*sPreceding bytecode:\n", indent_level, "");
 669             yasm_bc_print(sym->value.precbc, f, indent_level+1);
 670             break;
 671         case SYM_SPECIAL:
 672             fprintf(f, "%*s-Special-\n", indent_level, "");
 673             break;
 674     }
 675
 676     fprintf(f, "%*sStatus=", indent_level, "");
 677     if (sym->status == YASM_SYM_NOSTATUS)
 678         fprintf(f, "None\n");
 679     else {
 680         if (sym->status & YASM_SYM_USED)
 681             fprintf(f, "Used,");
 682         if (sym->status & YASM_SYM_DEFINED)
 683             fprintf(f, "Defined,");
 684         if (sym->status & YASM_SYM_VALUED)
 685             fprintf(f, "Valued,");
 686         if (sym->status & YASM_SYM_NOTINTABLE)
 687             fprintf(f, "Not in Table,");
 688         fprintf(f, "\n");
 689     }
 690
 691     fprintf(f, "%*sVisibility=", indent_level, "");
 692     if (sym->visibility == YASM_SYM_LOCAL)
 693         fprintf(f, "Local\n");
 694     else {
 695         if (sym->visibility & YASM_SYM_GLOBAL)
 696             fprintf(f, "Global,");
 697         if (sym->visibility & YASM_SYM_COMMON)
 698             fprintf(f, "Common,");
 699         if (sym->visibility & YASM_SYM_EXTERN)
 700             fprintf(f, "Extern,");
 701         fprintf(f, "\n");
 702     }
 703
 704     if (sym->assoc_data) {
 705         fprintf(f, "%*sAssociated data:\n", indent_level, "");
 706         yasm__assoc_data_print(sym->assoc_data, f, indent_level+1);
 707     }
 708
 709     fprintf(f, "%*sLine Index (Defined)=%lu\n", indent_level, "",
 710             sym->def_line);
 711     fprintf(f, "%*sLine Index (Declared)=%lu\n", indent_level, "",
 712             sym->decl_line);
 713     fprintf(f, "%*sLine Index (Used)=%lu\n", indent_level, "", sym->use_line);
 714 }