From 2b68b820a9aef88c4c579072f05e8028b0b92ad9 Mon Sep 17 00:00:00 2001 From: Ken Raeburn Date: Wed, 7 Jul 1993 16:25:37 +0000 Subject: [PATCH] * symbols.c (symbol_new): Symbol value is type valueT. (S_SET_VALUE, S_GET_VALUE): Likewise. (S_IS_*): Specify int return type explicitly. * symbols.h (symbol_new, S_GET_VALUE, S_SET_VALUE): Fixed prototypes. --- gas/symbols.c | 485 +++++++++++++++++++++++++++++++++++----------------------- gas/symbols.h | 93 +++++------ 2 files changed, 328 insertions(+), 250 deletions(-) diff --git a/gas/symbols.c b/gas/symbols.c index 7196874..ade2aa5 100644 --- a/gas/symbols.c +++ b/gas/symbols.c @@ -1,6 +1,6 @@ /* symbols.c -symbol table- - Copyright (C) 1987, 1990, 1991, 1992 Free Software Foundation, Inc. + Copyright (C) 1987, 1990, 1991, 1992, 1993 Free Software Foundation, Inc. This file is part of GAS, the GNU Assembler. @@ -18,6 +18,8 @@ along with GAS; see the file COPYING. If not, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ +#define DEBUG + #include #include "as.h" @@ -28,13 +30,9 @@ #ifndef WORKING_DOT_WORD extern int new_broken_words; #endif -#ifdef VMS -extern char const_flag; -#endif -static -struct hash_control * - sy_hash; /* symbol-name => struct symbol pointer */ +/* symbol-name => struct symbol pointer */ +static struct hash_control *sy_hash; /* Below are commented in "symbols.h". */ symbolS *symbol_rootP; @@ -56,7 +54,12 @@ symbol_begin () symbol_rootP = NULL; /* In case we have 0 symbols (!!) */ sy_hash = hash_new (); memset ((char *) (&abs_symbol), '\0', sizeof (abs_symbol)); - S_SET_SEGMENT (&abs_symbol, SEG_ABSOLUTE); /* Can't initialise a union. Sigh. */ +#ifdef BFD_ASSEMBLER + abs_symbol.bsym = bfd_abs_section.symbol; +#else + /* Can't initialise a union. Sigh. */ + S_SET_SEGMENT (&abs_symbol, absolute_section); +#endif #ifdef LOCAL_LABELS_FB fb_label_init (); #endif /* LOCAL_LABELS_FB */ @@ -81,9 +84,9 @@ symbol_begin () symbolS * symbol_new (name, segment, value, frag) - char *name; /* It is copied, the caller can destroy/modify */ + CONST char *name; /* It is copied, the caller can destroy/modify */ segT segment; /* Segment identifier (SEG_) */ - long value; /* Symbol value */ + valueT value; /* Symbol value */ fragS *frag; /* Associated fragment */ { unsigned int name_length; @@ -93,42 +96,47 @@ symbol_new (name, segment, value, frag) name_length = strlen (name) + 1; /* +1 for \0 */ obstack_grow (¬es, name, name_length); preserved_copy_of_name = obstack_finish (¬es); +#ifdef STRIP_UNDERSCORE + if (preserved_copy_of_name[0] == '_') + preserved_copy_of_name++; +#endif symbolP = (symbolS *) obstack_alloc (¬es, sizeof (symbolS)); /* symbol must be born in some fixed state. This seems as good as any. */ memset (symbolP, 0, sizeof (symbolS)); -#ifdef STRIP_UNDERSCORE - S_SET_NAME (symbolP, (*preserved_copy_of_name == '_' - ? preserved_copy_of_name + 1 - : preserved_copy_of_name)); -#else /* STRIP_UNDERSCORE */ + +#ifdef BFD_ASSEMBLER + symbolP->bsym = bfd_make_empty_symbol (stdoutput); + assert (symbolP->bsym != 0); + symbolP->bsym->udata = (PTR) symbolP; +#endif S_SET_NAME (symbolP, preserved_copy_of_name); -#endif /* STRIP_UNDERSCORE */ S_SET_SEGMENT (symbolP, segment); S_SET_VALUE (symbolP, value); - /* symbol_clear_list_pointers(symbolP); uneeded if symbol is born zeroed. */ + symbol_clear_list_pointers(symbolP); symbolP->sy_frag = frag; - /* krm: uneeded if symbol is born zeroed. - symbolP->sy_forward = NULL; *//* JF */ + symbolP->sy_forward = NULL; +#ifndef BFD_ASSEMBLER symbolP->sy_number = ~0; symbolP->sy_name_offset = ~0; +#endif /* - * Link to end of symbol chain. - */ + * Link to end of symbol chain. + */ symbol_append (symbolP, symbol_lastP, &symbol_rootP, &symbol_lastP); obj_symbol_new_hook (symbolP); #ifdef DEBUG - /* verify_symbol_chain(symbol_rootP, symbol_lastP); */ + verify_symbol_chain(symbol_rootP, symbol_lastP); #endif /* DEBUG */ - return (symbolP); -} /* symbol_new() */ + return symbolP; +} /* @@ -148,7 +156,8 @@ colon (sym_name) /* just seen "x:" - rattle symbols & frags */ register symbolS *symbolP; /* symbol we are working with */ #ifdef LOCAL_LABELS_DOLLAR - /* Sun local labels go out of scope whenever a non-local symbol is defined. */ + /* Sun local labels go out of scope whenever a non-local symbol is + defined. */ if (*sym_name != 'L') dollar_label_clear (); @@ -162,9 +171,10 @@ colon (sym_name) /* just seen "x:" - rattle symbols & frags */ fragS *frag_tmp; char *frag_opcode; - extern md_short_jump_size; - extern md_long_jump_size; - possible_bytes = md_short_jump_size + new_broken_words * md_long_jump_size; + extern const int md_short_jump_size; + extern const int md_long_jump_size; + possible_bytes = (md_short_jump_size + + new_broken_words * md_long_jump_size); frag_tmp = frag_now; frag_opcode = frag_var (rs_broken_word, @@ -176,8 +186,11 @@ colon (sym_name) /* just seen "x:" - rattle symbols & frags */ NULL); /* We want to store the pointer to where to insert the jump table in the - fr_opcode of the rs_broken_word frag. This requires a little hackery */ - while (frag_tmp && (frag_tmp->fr_type != rs_broken_word || frag_tmp->fr_opcode)) + fr_opcode of the rs_broken_word frag. This requires a little + hackery. */ + while (frag_tmp + && (frag_tmp->fr_type != rs_broken_word + || frag_tmp->fr_opcode)) frag_tmp = frag_tmp->fr_next; know (frag_tmp); frag_tmp->fr_opcode = frag_opcode; @@ -190,40 +203,22 @@ colon (sym_name) /* just seen "x:" - rattle symbols & frags */ if ((symbolP = symbol_find (sym_name)) != 0) { -#ifdef VMS - /* - * If the new symbol is .comm AND it has a size of zero, - * we ignore it (i.e. the old symbol overrides it) - */ - if ((SEGMENT_TO_SYMBOL_TYPE ((int) now_seg) == (N_UNDF | N_EXT)) && - ((obstack_next_free (&frags) - frag_now->fr_literal) == 0)) +#ifdef RESOLVE_SYMBOL_REDEFINITION + if (RESOLVE_SYMBOL_REDEFINITION (symbolP)) return; +#endif /* - * If the old symbol is .comm and it has a size of zero, - * we override it with the new symbol value. - */ - if ((symbolP->sy_type == (N_UNDF | N_EXT)) - && (S_GET_VALUE (symbolP) == 0)) - { - symbolP->sy_frag = frag_now; - symbolP->sy_other = const_flag; - S_SET_VALUE (symbolP, obstack_next_free (&frags) - frag_now->fr_literal); - symbolP->sy_type |= SEGMENT_TO_SYMBOL_TYPE ((int) now_seg); /* keep N_EXT bit */ - return; - } -#endif /* VMS */ - /* - * Now check for undefined symbols - */ + * Now check for undefined symbols + */ if (!S_IS_DEFINED (symbolP)) { if (S_GET_VALUE (symbolP) == 0) { symbolP->sy_frag = frag_now; -#ifdef VMS - symbolP->sy_other = const_flag; +#ifdef OBJ_VMS + S_GET_OTHER(symbolP) = const_flag; #endif - S_SET_VALUE (symbolP, obstack_next_free (&frags) - frag_now->fr_literal); + S_SET_VALUE (symbolP, (valueT) ((char*)obstack_next_free (&frags) - frag_now->fr_literal)); S_SET_SEGMENT (symbolP, now_seg); #ifdef N_UNDF know (N_UNDF == 0); @@ -233,43 +228,38 @@ colon (sym_name) /* just seen "x:" - rattle symbols & frags */ else { /* - * There are still several cases to check: - * A .comm/.lcomm symbol being redefined as - * initialized data is OK - * A .comm/.lcomm symbol being redefined with - * a larger size is also OK - * - * This only used to be allowed on VMS gas, but Sun cc - * on the sparc also depends on it. - */ - /* char New_Type = SEGMENT_TO_SYMBOL_TYPE((int) now_seg); */ -#ifdef MANY_SEGMENTS -#define SEG_BSS SEG_E2 -#define SEG_DATA SEG_E1 -#endif - - if (((!S_IS_DEBUG (symbolP) && !S_IS_DEFINED (symbolP) && S_IS_EXTERNAL (symbolP)) - || (S_GET_SEGMENT (symbolP) == SEG_BSS)) - && ((now_seg == SEG_DATA) - || (now_seg == S_GET_SEGMENT (symbolP)))) + * There are still several cases to check: + * A .comm/.lcomm symbol being redefined as + * initialized data is OK + * A .comm/.lcomm symbol being redefined with + * a larger size is also OK + * + * This only used to be allowed on VMS gas, but Sun cc + * on the sparc also depends on it. + */ + + if (((!S_IS_DEBUG (symbolP) + && !S_IS_DEFINED (symbolP) + && S_IS_EXTERNAL (symbolP)) + || S_GET_SEGMENT (symbolP) == bss_section) + && (now_seg == data_section + || now_seg == S_GET_SEGMENT (symbolP))) { /* - * Select which of the 2 cases this is - */ - if (now_seg != SEG_DATA) + * Select which of the 2 cases this is + */ + if (now_seg != data_section) { /* - * New .comm for prev .comm symbol. - * If the new size is larger we just - * change its value. If the new size - * is smaller, we ignore this symbol - */ + * New .comm for prev .comm symbol. + * If the new size is larger we just + * change its value. If the new size + * is smaller, we ignore this symbol + */ if (S_GET_VALUE (symbolP) - < ((unsigned) (obstack_next_free (&frags) - frag_now->fr_literal))) + < ((unsigned) frag_now_fix ())) { - S_SET_VALUE (symbolP, - obstack_next_free (&frags) - - frag_now->fr_literal); + S_SET_VALUE (symbolP, (valueT) frag_now_fix ()); } } else @@ -277,27 +267,27 @@ colon (sym_name) /* just seen "x:" - rattle symbols & frags */ /* It is a .comm/.lcomm being converted to initialized data. */ symbolP->sy_frag = frag_now; -#ifdef VMS - symbolP->sy_other = const_flag; -#endif /* VMS */ - S_SET_VALUE (symbolP, obstack_next_free (&frags) - frag_now->fr_literal); +#ifdef OBJ_VMS + S_GET_OTHER(symbolP) = const_flag; +#endif /* OBJ_VMS */ + S_SET_VALUE (symbolP, (valueT) frag_now_fix ()); S_SET_SEGMENT (symbolP, now_seg); /* keep N_EXT bit */ } } else { -#ifdef OBJ_COFF - as_fatal ("Symbol \"%s\" is already defined as \"%s\"/%d.", +#if defined (S_GET_OTHER) && defined (S_GET_DESC) + as_fatal ("Symbol \"%s\" is already defined as \"%s\"/%d.%d.%ld.", sym_name, segment_name (S_GET_SEGMENT (symbolP)), - S_GET_VALUE (symbolP)); -#else /* OBJ_COFF */ - as_fatal ("Symbol \"%s\" is already defined as \"%s\"/%d.%d.%d.", + S_GET_OTHER (symbolP), S_GET_DESC (symbolP), + (long) S_GET_VALUE (symbolP)); +#else + as_fatal ("Symbol \"%s\" is already defined as \"%s\"/%d.", sym_name, segment_name (S_GET_SEGMENT (symbolP)), - S_GET_OTHER (symbolP), S_GET_DESC (symbolP), S_GET_VALUE (symbolP)); -#endif /* OBJ_COFF */ +#endif } } /* if the undefined symbol has no value */ } @@ -305,7 +295,7 @@ colon (sym_name) /* just seen "x:" - rattle symbols & frags */ { /* Don't blow up if the definition is the same */ if (!(frag_now == symbolP->sy_frag - && S_GET_VALUE (symbolP) == obstack_next_free (&frags) - frag_now->fr_literal + && S_GET_VALUE (symbolP) == (char*)obstack_next_free (&frags) - frag_now->fr_literal && S_GET_SEGMENT (symbolP) == now_seg)) as_fatal ("Symbol %s already defined.", sym_name); } /* if this symbol is not yet defined */ @@ -315,14 +305,17 @@ colon (sym_name) /* just seen "x:" - rattle symbols & frags */ { symbolP = symbol_new (sym_name, now_seg, - (valueT) (obstack_next_free (&frags) - frag_now->fr_literal), + (valueT) ((char*)obstack_next_free (&frags) - frag_now->fr_literal), frag_now); -#ifdef VMS +#ifdef OBJ_VMS S_SET_OTHER (symbolP, const_flag); -#endif /* VMS */ +#endif /* OBJ_VMS */ symbol_table_insert (symbolP); } /* if we have seen this symbol before */ +#ifdef TC_HPPA + pa_define_label(symbolP); +#endif return; } /* colon() */ @@ -377,20 +370,15 @@ symbol_find_or_make (name) symbolS * symbol_make (name) - char *name; + CONST char *name; { symbolS *symbolP; /* Let the machine description default it, e.g. for register names. */ - symbolP = md_undefined_symbol (name); + symbolP = md_undefined_symbol ((char *) name); if (!symbolP) - { - symbolP = symbol_new (name, - SEG_UNKNOWN, - 0, - &zero_address_frag); - } /* if md didn't build us a symbol */ + symbolP = symbol_new (name, undefined_section, (valueT) 0, &zero_address_frag); return (symbolP); } /* symbol_make() */ @@ -406,7 +394,7 @@ symbol_make (name) symbolS * symbol_find (name) - char *name; + CONST char *name; { #ifdef STRIP_UNDERSCORE return (symbol_find_base (name, 1)); @@ -417,7 +405,7 @@ symbol_find (name) symbolS * symbol_find_base (name, strip_underscore) - char *name; + CONST char *name; int strip_underscore; { if (strip_underscore && *name == '_') @@ -468,13 +456,7 @@ symbol_append (addme, target, rootPP, lastPP) #ifdef SYMBOLS_NEED_BACKPOINTERS addme->sy_previous = target; #endif /* SYMBOLS_NEED_BACKPOINTERS */ - -#ifdef DEBUG - /* verify_symbol_chain(*rootPP, *lastPP); */ -#endif /* DEBUG */ - - return; -} /* symbol_append() */ +} #ifdef SYMBOLS_NEED_BACKPOINTERS /* Remove SYMBOLP from the list. */ @@ -507,9 +489,7 @@ symbol_remove (symbolP, rootPP, lastPP) #ifdef DEBUG verify_symbol_chain (*rootPP, *lastPP); #endif /* DEBUG */ - - return; -} /* symbol_remove() */ +} /* Set the chain pointers of SYMBOL to null. */ void @@ -518,7 +498,7 @@ symbol_clear_list_pointers (symbolP) { symbolP->sy_next = NULL; symbolP->sy_previous = NULL; -} /* symbol_clear_list_pointers() */ +} /* Link symbol ADDME before symbol TARGET in the chain. */ void @@ -545,9 +525,7 @@ symbol_insert (addme, target, rootPP, lastPP) #ifdef DEBUG verify_symbol_chain (*rootPP, *lastPP); #endif /* DEBUG */ - - return; -} /* symbol_insert() */ +} #endif /* SYMBOLS_NEED_BACKPOINTERS */ @@ -559,29 +537,34 @@ verify_symbol_chain (rootP, lastP) symbolS *symbolP = rootP; if (symbolP == NULL) - { - return; - } /* empty chain */ + return; for (; symbol_next (symbolP) != NULL; symbolP = symbol_next (symbolP)) { #ifdef SYMBOLS_NEED_BACKPOINTERS - /*$if (symbolP->sy_previous) { - know(symbolP->sy_previous->sy_next == symbolP); - } else { - know(symbolP == rootP); - }$*//* both directions */ know (symbolP->sy_next->sy_previous == symbolP); -#else /* SYMBOLS_NEED_BACKPOINTERS */ - ; +#else + /* Walk the list anyways, to make sure pointers are still good. */ + *symbolP; #endif /* SYMBOLS_NEED_BACKPOINTERS */ - } /* verify pointers */ - - know (lastP == symbolP); + } - return; -} /* verify_symbol_chain() */ + assert (lastP == symbolP); +} +void +verify_symbol_chain_2 (sym) + symbolS *sym; +{ + symbolS *p = sym, *n = sym; +#ifdef SYMBOLS_NEED_BACKPOINTERS + while (symbol_previous (p)) + p = symbol_previous (p); +#endif + while (symbol_next (n)) + n = symbol_next (n); + verify_symbol_chain (p, n); +} #ifdef LOCAL_LABELS_DOLLAR @@ -592,11 +575,11 @@ verify_symbol_chain (rootP, lastP) the instance number, keep a list of defined symbols separate from the real symbol table, and we treat these buggers as a sparse array. */ -static long *dollar_labels = NULL; -static long *dollar_label_instances = NULL; -static char *dollar_label_defines = NULL; -static long dollar_label_count = 0; -static long dollar_label_max = 0; +static long *dollar_labels; +static long *dollar_label_instances; +static char *dollar_label_defines; +static long dollar_label_count; +static long dollar_label_max; int dollar_label_defined (label) @@ -607,15 +590,11 @@ dollar_label_defined (label) know ((dollar_labels != NULL) || (dollar_label_count == 0)); for (i = dollar_labels; i < dollar_labels + dollar_label_count; ++i) - { - if (*i == label) - { - return (dollar_label_defines[i - dollar_labels]); - } /* found it */ - } /* look for label */ + if (*i == label) + return dollar_label_defines[i - dollar_labels]; /* if we get here, label isn't defined */ - return (0); + return 0; } /* dollar_label_defined() */ static int @@ -627,24 +606,19 @@ dollar_label_instance (label) know ((dollar_labels != NULL) || (dollar_label_count == 0)); for (i = dollar_labels; i < dollar_labels + dollar_label_count; ++i) - { - if (*i == label) - { - return (dollar_label_instances[i - dollar_labels]); - } /* found it */ - } /* look for (the union :-) label */ + if (*i == label) + return (dollar_label_instances[i - dollar_labels]); - /* if we get here, we haven't seen the label before, therefor it's instance - count is zero. */ - return (0); -} /* dollar_label_instance() */ + /* If we get here, we haven't seen the label before, therefore its instance + count is zero. */ + return 0; +} void dollar_label_clear () { memset (dollar_label_defines, '\0', dollar_label_count); - return; -} /* clear_dollar_labels() */ +} #define DOLLAR_LABEL_BUMP_BY 10 @@ -655,14 +629,12 @@ define_dollar_label (label) long *i; for (i = dollar_labels; i < dollar_labels + dollar_label_count; ++i) - { - if (*i == label) - { - ++dollar_label_instances[i - dollar_labels]; - dollar_label_defines[i - dollar_labels] = 1; - return; - } /* if we find it */ - } /* for each existing label */ + if (*i == label) + { + ++dollar_label_instances[i - dollar_labels]; + dollar_label_defines[i - dollar_labels] = 1; + return; + } /* if we get to here, we don't have label listed yet. */ @@ -673,7 +645,6 @@ define_dollar_label (label) dollar_label_defines = xmalloc (DOLLAR_LABEL_BUMP_BY); dollar_label_max = DOLLAR_LABEL_BUMP_BY; dollar_label_count = 0; - } else if (dollar_label_count == dollar_label_max) { @@ -689,19 +660,18 @@ define_dollar_label (label) dollar_label_instances[dollar_label_count] = 1; dollar_label_defines[dollar_label_count] = 1; ++dollar_label_count; - return; -} /* define_dollar_label() */ +} /* * dollar_label_name() * * Caller must copy returned name: we re-use the area for the next name. * - * The mth occurence of label n: is turned into the symbol "Ln^Am" where - * n is the label number and m is the instance number. "L" makes it a label discarded - * unless debugging and "^A"('\1') ensures no ordinary symbol SHOULD get the - * same name as a local label symbol. The first "4:" is "L4^A1" - the m - * numbers begin at 1. + * The mth occurence of label n: is turned into the symbol "Ln^Am" + * where n is the label number and m is the instance number. "L" makes + * it a label discarded unless debugging and "^A"('\1') ensures no + * ordinary symbol SHOULD get the same name as a local label + * symbol. The first "4:" is "L4^A1" - the m numbers begin at 1. * * fb labels get the same treatment, except that ^B is used in place of ^A. */ @@ -746,8 +716,8 @@ dollar_label_name (n, augend) while ((*p++ = *--q) != '\0');; /* The label, as a '\0' ended string, starts at symbol_name_build. */ - return (symbol_name_build); -} /* dollar_label_name() */ + return symbol_name_build; +} #endif /* LOCAL_LABELS_DOLLAR */ @@ -855,22 +825,21 @@ fb_label_instance (label) } /* for each existing label */ /* NOTREACHED */ - know (0); -} /* fb_label_instance() */ + abort (); +} /* * fb_label_name() * * Caller must copy returned name: we re-use the area for the next name. * - * The mth occurence of label n: is turned into the symbol "Ln^Bm" where - * n is the label number and m is the instance number. "L" makes it a label discarded - * unless debugging and "^B"('\2') ensures no ordinary symbol SHOULD get the - * same name as a local label symbol. The first "4:" is "L4^B1" - the m - * numbers begin at 1. + * The mth occurence of label n: is turned into the symbol "Ln^Bm" + * where n is the label number and m is the instance number. "L" makes + * it a label discarded unless debugging and "^B"('\2') ensures no + * ordinary symbol SHOULD get the same name as a local label + * symbol. The first "4:" is "L4^B1" - the m numbers begin at 1. * - * dollar labels get the same treatment, except that ^A is used in place of ^B. - */ + * dollar labels get the same treatment, except that ^A is used in place of ^B. */ char * /* Return local label name. */ fb_label_name (n, augend) @@ -968,4 +937,136 @@ decode_local_label_name (s) return (symbol_decode); } /* decode_local_label_name() */ +#ifdef BFD_ASSEMBLER + +int +S_IS_EXTERNAL (s) + symbolS *s; +{ + flagword flags = s->bsym->flags; + + /* sanity check */ + if (flags & BSF_LOCAL && flags & (BSF_EXPORT | BSF_GLOBAL)) + abort (); + + return (flags & (BSF_EXPORT | BSF_GLOBAL)) != 0; +} + +int +S_IS_COMMON (s) + symbolS *s; +{ + return s->bsym->section == &bfd_com_section; +} + +int +S_IS_DEFINED (s) + symbolS *s; +{ + return s->bsym->section != undefined_section; +} + +int +S_IS_DEBUG (s) + symbolS *s; +{ + if (s->bsym->flags & BSF_DEBUGGING) + return 1; + return 0; +} + +int +S_IS_LOCAL (s) + symbolS *s; +{ + flagword flags = s->bsym->flags; + + /* sanity check */ + if (flags & BSF_LOCAL && flags & (BSF_EXPORT | BSF_GLOBAL)) + abort (); + + return (S_GET_NAME (s) + && ! S_IS_DEBUG (s) + && (strchr (S_GET_NAME (s), '\001') + || strchr (S_GET_NAME (s), '\002') + || (S_LOCAL_NAME (s) + && !flagseen['L']))); +} + +int +S_IS_EXTERN (s) + symbolS *s; +{ + return S_IS_EXTERNAL (s); +} + +int +S_IS_STABD (s) + symbolS *s; +{ + return S_GET_NAME (s) == 0; +} + +valueT +S_GET_VALUE (s) + symbolS *s; +{ + return s->bsym->value; +} + +CONST char * +S_GET_NAME (s) + symbolS *s; +{ + return s->bsym->name; +} + +segT +S_GET_SEGMENT (s) + symbolS *s; +{ + return s->bsym->section; +} + +void +S_SET_VALUE (s, val) + symbolS *s; + valueT val; +{ + s->bsym->value = val; +} + +void +S_SET_SEGMENT (s, seg) + symbolS *s; + segT seg; +{ + s->bsym->section = seg; +} + +void +S_SET_EXTERNAL (s) + symbolS *s; +{ + s->bsym->flags |= BSF_EXPORT | BSF_GLOBAL; + s->bsym->flags &= ~BSF_LOCAL; +} + +void +S_CLEAR_EXTERNAL (s) + symbolS *s; +{ + s->bsym->flags |= BSF_LOCAL; + s->bsym->flags &= ~(BSF_EXPORT | BSF_GLOBAL); +} + +void +S_SET_NAME (s, name) + symbolS *s; + char *name; +{ + s->bsym->name = name; +} +#endif /* BFD_ASSEMBLER */ + /* end of symbols.c */ diff --git a/gas/symbols.h b/gas/symbols.h index e1e7c7d..cbdafff 100644 --- a/gas/symbols.h +++ b/gas/symbols.h @@ -23,9 +23,6 @@ extern struct obstack notes; /* eg FixS live here. */ extern struct obstack cond_obstack; /* this is where we track .ifdef/.endif (if we do that at all). */ -extern unsigned int local_bss_counter; /* Zeroed before a pass. */ -/* Only used by .lcomm directive. */ - extern symbolS *symbol_rootP; /* all the symbol nodes */ extern symbolS *symbol_lastP; /* last struct symbol we made, or NULL */ @@ -35,67 +32,47 @@ extern symbolS *dot_text_symbol; extern symbolS *dot_data_symbol; extern symbolS *dot_bss_symbol; -#if __STDC__ == 1 - -char *decode_local_label_name (char *s); -symbolS *symbol_find (char *name); -symbolS *symbol_find_base (char *name, int strip_underscore); -symbolS *symbol_find_or_make (char *name); -symbolS *symbol_make (char *name); -symbolS *symbol_new (char *name, segT segment, long value, fragS * frag); -void colon (char *sym_name); -void local_colon (int n); -void symbol_begin (void); -void symbol_table_insert (symbolS * symbolP); -void verify_symbol_chain (symbolS * rootP, symbolS * lastP); - -#ifdef LOCAL_LABELS_DOLLAR -int dollar_label_defined (long l); -void dollar_label_clear (void); -void define_dollar_label (long l); -char *dollar_label_name (long l, int augend); -#endif /* LOCAL_LABELS_DOLLAR */ - -#ifdef LOCAL_LABELS_FB -void fb_label_instance_inc (long label); -char *fb_label_name (long n, long augend); -#endif /* LOCAL_LABELS_FB */ - -#else /* not __STDC__ */ - -char *decode_local_label_name (); -char *fb_label_name (); -symbolS *symbol_find (); -symbolS *symbol_find_base (); -symbolS *symbol_find_or_make (); -symbolS *symbol_make (); -symbolS *symbol_new (); -void colon (); -void local_colon (); -void symbol_begin (); -void symbol_table_insert (); -void verify_symbol_chain (); +char *decode_local_label_name PARAMS ((char *s)); +symbolS *symbol_find PARAMS ((CONST char *name)); +symbolS *symbol_find_base PARAMS ((CONST char *name, int strip_underscore)); +symbolS *symbol_find_or_make PARAMS ((char *name)); +symbolS *symbol_make PARAMS ((CONST char *name)); +symbolS *symbol_new PARAMS ((CONST char *name, segT segment, valueT value, + fragS * frag)); +void colon PARAMS ((char *sym_name)); +void local_colon PARAMS ((int n)); +void symbol_begin PARAMS ((void)); +void symbol_table_insert PARAMS ((symbolS * symbolP)); +void verify_symbol_chain PARAMS ((symbolS * rootP, symbolS * lastP)); #ifdef LOCAL_LABELS_DOLLAR -int dollar_label_defined (); -void dollar_label_clear (); -void define_dollar_label (); -char *dollar_label_name (); +int dollar_label_defined PARAMS ((long l)); +void dollar_label_clear PARAMS ((void)); +void define_dollar_label PARAMS ((long l)); +char *dollar_label_name PARAMS ((long l, int augend)); #endif /* LOCAL_LABELS_DOLLAR */ #ifdef LOCAL_LABELS_FB -void fb_label_instance_inc (); -char *fb_label_name (); +void fb_label_instance_inc PARAMS ((long label)); +char *fb_label_name PARAMS ((long n, long augend)); #endif /* LOCAL_LABELS_FB */ -#endif /* not __STDC__ */ - - -/* - * Local Variables: - * comment-column: 0 - * fill-column: 131 - * End: - */ +#ifdef BFD_ASSEMBLER +extern int S_IS_EXTERNAL PARAMS ((symbolS *)); +extern int S_IS_COMMON PARAMS ((symbolS *)); +extern int S_IS_DEFINED PARAMS ((symbolS *)); +extern int S_IS_DEBUG PARAMS ((symbolS *)); +extern int S_IS_LOCAL PARAMS ((symbolS *)); +extern int S_IS_EXTERN PARAMS ((symbolS *)); +extern int S_IS_STABD PARAMS ((symbolS *)); +extern valueT S_GET_VALUE PARAMS ((symbolS *)); +extern CONST char *S_GET_NAME PARAMS ((symbolS *)); +extern segT S_GET_SEGMENT PARAMS ((symbolS *)); +extern void S_SET_VALUE PARAMS ((symbolS *, valueT)); +extern void S_SET_SEGMENT PARAMS ((symbolS *, segT)); +extern void S_SET_EXTERNAL PARAMS ((symbolS *)); +extern void S_SET_NAME PARAMS ((symbolS *, char *)); +extern void S_CLEAR_EXTERNAL PARAMS ((symbolS *)); +#endif /* end of symbols.h */ -- 2.7.4