X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gas%2Fstruc-symbol.h;h=201671346c5bc7c26c4abee8de4e4cec3d07e53e;hb=e5e27b0769acf1c864ac9e41544c0747d1058cd5;hp=541f65c3fb554c67a38a4773ccc347dfeb23f792;hpb=3340f7e5fdd11b6c544714500fca870707793fd0;p=deliverable%2Fbinutils-gdb.git diff --git a/gas/struc-symbol.h b/gas/struc-symbol.h index 541f65c3fb..201671346c 100644 --- a/gas/struc-symbol.h +++ b/gas/struc-symbol.h @@ -1,113 +1,158 @@ /* struct_symbol.h - Internal symbol structure - Copyright (C) 1987, 1992 Free Software Foundation, Inc. - + Copyright (C) 1987-2016 Free Software Foundation, Inc. + This file is part of GAS, the GNU Assembler. - + GAS 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 2, or (at your option) + the Free Software Foundation; either version 3, or (at your option) any later version. - + GAS 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. - - oYou should have received a copy of the GNU General Public License - along with GAS; see the file COPYING. If not, write to - the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ -struct symbol /* our version of an nlist node */ -{ - obj_symbol_type sy_symbol; /* what we write in .o file (if permitted) */ - unsigned long sy_name_offset; /* 4-origin position of sy_name in symbols */ - /* part of object file. */ - /* 0 for (nameless) .stabd symbols. */ - /* Not used until write_object_file() time. */ - long sy_number; /* 24 bit symbol number. */ - /* Symbol numbers start at 0 and are */ - /* unsigned. */ - struct symbol *sy_next; /* forward chain, or NULL */ -#ifdef SYMBOLS_NEED_BACKPOINTERS - struct symbol *sy_previous; /* backward chain, or NULL */ -#endif /* SYMBOLS_NEED_BACKPOINTERS */ - struct frag *sy_frag; /* NULL or -> frag this symbol attaches to. */ - struct symbol *sy_forward; /* value is really that of this other symbol */ - /* We will probably want to add a sy_segment here soon. */ -}; - -typedef struct symbol symbolS; - -typedef unsigned valueT; /* The type of n_value. Helps casting. */ - -#ifndef WORKING_DOT_WORD -struct broken_word { - struct broken_word *next_broken_word;/* One of these strucs per .word x-y */ - fragS *frag; /* Which frag its in */ - char *word_goes_here;/* Where in the frag it is */ - fragS *dispfrag; /* where to add the break */ - symbolS *add; /* symbol_x */ - symbolS *sub; /* - symbol_y */ - long addnum; /* + addnum */ - int added; /* nasty thing happend yet? */ - /* 1: added and has a long-jump */ - /* 2: added but uses someone elses long-jump */ - struct broken_word *use_jump; /* points to broken_word with a similar - long-jump */ -}; -extern struct broken_word *broken_words; -#endif /* ndef WORKING_DOT_WORD */ + You should have received a copy of the GNU General Public License + along with GAS; see the file COPYING. If not, write to the Free + Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA + 02110-1301, USA. */ -/* - * Current means for getting from symbols to segments and vice verse. - * This will change for infinite-segments support (e.g. COFF). - */ -/* #define SYMBOL_TYPE_TO_SEGMENT(symP) ( N_TYPE_seg [(int) (symP)->sy_type & N_TYPE] ) */ -extern segT N_TYPE_seg[]; /* subseg.c */ +#ifndef __struc_symbol_h__ +#define __struc_symbol_h__ -#define SEGMENT_TO_SYMBOL_TYPE(seg) ( seg_N_TYPE [(int) (seg)] ) -extern const short seg_N_TYPE[]; /* subseg.c */ +struct symbol_flags +{ + /* Wether the symbol is a local_symbol. */ + unsigned int sy_local_symbol : 1; + + /* Wether symbol has been written. */ + unsigned int sy_written : 1; + + /* Whether symbol value has been completely resolved (used during + final pass over symbol table). */ + unsigned int sy_resolved : 1; + + /* Whether the symbol value is currently being resolved (used to + detect loops in symbol dependencies). */ + unsigned int sy_resolving : 1; + + /* Whether the symbol value is used in a reloc. This is used to + ensure that symbols used in relocs are written out, even if they + are local and would otherwise not be. */ + unsigned int sy_used_in_reloc : 1; + + /* Whether the symbol is used as an operand or in an expression. + NOTE: Not all the backends keep this information accurate; + backends which use this bit are responsible for setting it when + a symbol is used in backend routines. */ + unsigned int sy_used : 1; + + /* Whether the symbol can be re-defined. */ + unsigned int sy_volatile : 1; + + /* Whether the symbol is a forward reference. */ + unsigned int sy_forward_ref : 1; + + /* This is set if the symbol is defined in an MRI common section. + We handle such sections as single common symbols, so symbols + defined within them must be treated specially by the relocation + routines. */ + unsigned int sy_mri_common : 1; + + /* This is set if the symbol is set with a .weakref directive. */ + unsigned int sy_weakrefr : 1; + + /* This is set when the symbol is referenced as part of a .weakref + directive, but only if the symbol was not in the symbol table + before. It is cleared as soon as any direct reference to the + symbol is present. */ + unsigned int sy_weakrefd : 1; +}; -#define N_REGISTER 30 /* Fake N_TYPE value for SEG_REGISTER */ +/* The information we keep for a symbol. Note that the symbol table + holds pointers both to this and to local_symbol structures. See + below. */ -#ifdef SYMBOLS_NEED_BACKPOINTERS -#if __STDC__ == 1 +struct symbol +{ + /* Symbol flags. */ + struct symbol_flags sy_flags; -void symbol_clear_list_pointers(symbolS *symbolP); -void symbol_insert(symbolS *addme, symbolS *target, symbolS **rootP, symbolS **lastP); -void symbol_remove(symbolS *symbolP, symbolS **rootP, symbolS **lastP); -void verify_symbol_chain(symbolS *rootP, symbolS *lastP); + /* BFD symbol */ + asymbol *bsym; -#else /* not __STDC__ */ + /* The value of the symbol. */ + expressionS sy_value; -void symbol_clear_list_pointers(); -void symbol_insert(); -void symbol_remove(); -void verify_symbol_chain(); + /* Forwards and (optionally) backwards chain pointers. */ + struct symbol *sy_next; + struct symbol *sy_previous; -#endif /* not __STDC__ */ + /* Pointer to the frag this symbol is attached to, if any. + Otherwise, NULL. */ + struct frag *sy_frag; -#define symbol_previous(s) ((s)->sy_previous) +#ifdef OBJ_SYMFIELD_TYPE + OBJ_SYMFIELD_TYPE sy_obj; +#endif -#else /* SYMBOLS_NEED_BACKPOINTERS */ +#ifdef TC_SYMFIELD_TYPE + TC_SYMFIELD_TYPE sy_tc; +#endif -#define symbol_clear_list_pointers(clearme) {clearme->sy_next = NULL;} +#ifdef TARGET_SYMBOL_FIELDS + TARGET_SYMBOL_FIELDS +#endif +}; -#endif /* SYMBOLS_NEED_BACKPOINTERS */ +/* A pointer in the symbol may point to either a complete symbol + (struct symbol above) or to a local symbol (struct local_symbol + defined here). The symbol code can detect the case by examining + the first field. It is always NULL for a local symbol. -#if __STDC__ == 1 -void symbol_append(symbolS *addme, symbolS *target, symbolS **rootP, symbolS **lastP); -#else /* not __STDC__ */ -void symbol_append(); -#endif /* not __STDC__ */ + We do this because we ordinarily only need a small amount of + information for a local symbol. The symbol table takes up a lot of + space, and storing less information for a local symbol can make a + big difference in assembler memory usage when assembling a large + file. */ -#define symbol_next(s) ((s)->sy_next) +struct local_symbol +{ + /* Symbol flags. Only sy_local_symbol and sy_resolved are relevant. */ + struct symbol_flags lsy_flags; + + /* The symbol section. This also serves as a flag. If this is + reg_section, then this symbol has been converted into a regular + symbol, and lsy_sym points to it. */ + segT lsy_section; + + /* The symbol name. */ + const char *lsy_name; + + /* The symbol frag or the real symbol, depending upon the value in + lsy_section. */ + union + { + fragS *lsy_frag; + symbolS *lsy_sym; + } u; + + /* The value of the symbol. */ + valueT lsy_value; + +#ifdef TC_LOCAL_SYMFIELD_TYPE + TC_LOCAL_SYMFIELD_TYPE lsy_tc; +#endif +}; -/* - * Local Variables: - * comment-column: 0 - * fill-column: 131 - * End: - */ +#define local_symbol_converted_p(l) ((l)->lsy_section == reg_section) +#define local_symbol_mark_converted(l) ((l)->lsy_section = reg_section) +#define local_symbol_resolved_p(l) ((l)->lsy_flags.sy_resolved) +#define local_symbol_mark_resolved(l) ((l)->lsy_flags.sy_resolved = 1) +#define local_symbol_get_frag(l) ((l)->u.lsy_frag) +#define local_symbol_set_frag(l, f) ((l)->u.lsy_frag = (f)) +#define local_symbol_get_real_symbol(l) ((l)->u.lsy_sym) +#define local_symbol_set_real_symbol(l, s) ((l)->u.lsy_sym = (s)) -/* end of struc-symbol.h */ +#endif /* __struc_symbol_h__ */