File: | src/gnu/usr.bin/binutils-2.17/gas/symbols.c |
Warning: | line 143, column 3 Null pointer passed as 1st argument to memory set function |
Press '?' to see keyboard shortcuts
Keyboard shortcuts:
1 | /* symbols.c -symbol table- | |||
2 | Copyright 1987, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, | |||
3 | 1999, 2000, 2001, 2002, 2003, 2004, 2005 | |||
4 | Free Software Foundation, Inc. | |||
5 | ||||
6 | This file is part of GAS, the GNU Assembler. | |||
7 | ||||
8 | GAS is free software; you can redistribute it and/or modify | |||
9 | it under the terms of the GNU General Public License as published by | |||
10 | the Free Software Foundation; either version 2, or (at your option) | |||
11 | any later version. | |||
12 | ||||
13 | GAS is distributed in the hope that it will be useful, | |||
14 | but WITHOUT ANY WARRANTY; without even the implied warranty of | |||
15 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |||
16 | GNU General Public License for more details. | |||
17 | ||||
18 | You should have received a copy of the GNU General Public License | |||
19 | along with GAS; see the file COPYING. If not, write to the Free | |||
20 | Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA | |||
21 | 02110-1301, USA. */ | |||
22 | ||||
23 | /* #define DEBUG_SYMS / * to debug symbol list maintenance. */ | |||
24 | ||||
25 | #include "as.h" | |||
26 | ||||
27 | #include "safe-ctype.h" | |||
28 | #include "obstack.h" /* For "symbols.h" */ | |||
29 | #include "subsegs.h" | |||
30 | ||||
31 | #include "struc-symbol.h" | |||
32 | ||||
33 | /* This is non-zero if symbols are case sensitive, which is the | |||
34 | default. */ | |||
35 | int symbols_case_sensitive = 1; | |||
36 | ||||
37 | #ifndef WORKING_DOT_WORD | |||
38 | extern int new_broken_words; | |||
39 | #endif | |||
40 | ||||
41 | /* symbol-name => struct symbol pointer */ | |||
42 | static struct hash_control *sy_hash; | |||
43 | ||||
44 | /* Table of local symbols. */ | |||
45 | static struct hash_control *local_hash; | |||
46 | ||||
47 | /* Below are commented in "symbols.h". */ | |||
48 | symbolS *symbol_rootP; | |||
49 | symbolS *symbol_lastP; | |||
50 | symbolS abs_symbol; | |||
51 | ||||
52 | #ifdef DEBUG_SYMS | |||
53 | #define debug_verify_symchain verify_symbol_chain | |||
54 | #else | |||
55 | #define debug_verify_symchain(root, last)((void) 0) ((void) 0) | |||
56 | #endif | |||
57 | ||||
58 | #define DOLLAR_LABEL_CHAR'\001' '\001' | |||
59 | #define LOCAL_LABEL_CHAR'\002' '\002' | |||
60 | ||||
61 | struct obstack notes; | |||
62 | #ifdef USE_UNIQUE | |||
63 | /* The name of an external symbol which is | |||
64 | used to make weak PE symbol names unique. */ | |||
65 | const char * an_external_name; | |||
66 | #endif | |||
67 | ||||
68 | static char *save_symbol_name (const char *); | |||
69 | static void fb_label_init (void); | |||
70 | static long dollar_label_instance (long); | |||
71 | static long fb_label_instance (long); | |||
72 | ||||
73 | static void print_binary (FILE *, const char *, expressionS *); | |||
74 | static void report_op_error (symbolS *, symbolS *, symbolS *); | |||
75 | ||||
76 | /* Return a pointer to a new symbol. Die if we can't make a new | |||
77 | symbol. Fill in the symbol's values. Add symbol to end of symbol | |||
78 | chain. | |||
79 | ||||
80 | This function should be called in the general case of creating a | |||
81 | symbol. However, if the output file symbol table has already been | |||
82 | set, and you are certain that this symbol won't be wanted in the | |||
83 | output file, you can call symbol_create. */ | |||
84 | ||||
85 | symbolS * | |||
86 | symbol_new (const char *name, segT segment, valueT valu, fragS *frag) | |||
87 | { | |||
88 | symbolS *symbolP = symbol_create (name, segment, valu, frag); | |||
89 | ||||
90 | /* Link to end of symbol chain. */ | |||
91 | { | |||
92 | extern int symbol_table_frozen; | |||
93 | if (symbol_table_frozen) | |||
94 | abort ()as_abort ("/usr/src/gnu/usr.bin/binutils-2.17/gas/symbols.c", 94, __PRETTY_FUNCTION__); | |||
95 | } | |||
96 | symbol_append (symbolP, symbol_lastP, &symbol_rootP, &symbol_lastP); | |||
97 | ||||
98 | return symbolP; | |||
99 | } | |||
100 | ||||
101 | /* Save a symbol name on a permanent obstack, and convert it according | |||
102 | to the object file format. */ | |||
103 | ||||
104 | static char * | |||
105 | save_symbol_name (const char *name) | |||
106 | { | |||
107 | unsigned int name_length; | |||
108 | char *ret; | |||
109 | ||||
110 | name_length = strlen (name) + 1; /* +1 for \0. */ | |||
111 | obstack_grow (¬es, name, name_length)__extension__ ({ struct obstack *__o = (¬es); int __len = (name_length); if (__o->next_free + __len > __o-> chunk_limit) _obstack_newchunk (__o, __len); memcpy ((__o-> next_free), ((name)), (__len)); __o->next_free += __len; ( void) 0; }); | |||
112 | ret = obstack_finish (¬es)__extension__ ({ struct obstack *__o1 = (¬es); void *value ; value = (void *) __o1->object_base; if (__o1->next_free == value) __o1->maybe_empty_object = 1; __o1->next_free = (((((__o1->next_free) - (char *) 0)+__o1->alignment_mask ) & ~ (__o1->alignment_mask)) + (char *) 0); if (__o1-> next_free - (char *)__o1->chunk > __o1->chunk_limit - (char *)__o1->chunk) __o1->next_free = __o1->chunk_limit ; __o1->object_base = __o1->next_free; value; }); | |||
113 | ||||
114 | #ifdef tc_canonicalize_symbol_name | |||
115 | ret = tc_canonicalize_symbol_name (ret); | |||
116 | #endif | |||
117 | ||||
118 | if (! symbols_case_sensitive) | |||
119 | { | |||
120 | char *s; | |||
121 | ||||
122 | for (s = ret; *s != '\0'; s++) | |||
123 | *s = TOUPPER (*s)_sch_toupper[(*s) & 0xff]; | |||
124 | } | |||
125 | ||||
126 | return ret; | |||
127 | } | |||
128 | ||||
129 | symbolS * | |||
130 | symbol_create (const char *name, /* It is copied, the caller can destroy/modify. */ | |||
131 | segT segment, /* Segment identifier (SEG_<something>). */ | |||
132 | valueT valu, /* Symbol value. */ | |||
133 | fragS *frag /* Associated fragment. */) | |||
134 | { | |||
135 | char *preserved_copy_of_name; | |||
136 | symbolS *symbolP; | |||
137 | ||||
138 | preserved_copy_of_name = save_symbol_name (name); | |||
139 | ||||
140 | symbolP = (symbolS *) obstack_alloc (¬es, sizeof (symbolS))__extension__ ({ struct obstack *__h = (¬es); __extension__ ({ struct obstack *__o = (__h); int __len = ((sizeof (symbolS ))); if (__o->chunk_limit - __o->next_free < __len) _obstack_newchunk (__o, __len); ((__o)->next_free += (__len)); (void) 0; }) ; __extension__ ({ struct obstack *__o1 = (__h); void *value; value = (void *) __o1->object_base; if (__o1->next_free == value) __o1->maybe_empty_object = 1; __o1->next_free = (((((__o1->next_free) - (char *) 0)+__o1->alignment_mask ) & ~ (__o1->alignment_mask)) + (char *) 0); if (__o1-> next_free - (char *)__o1->chunk > __o1->chunk_limit - (char *)__o1->chunk) __o1->next_free = __o1->chunk_limit ; __o1->object_base = __o1->next_free; value; }); }); | |||
141 | ||||
142 | /* symbol must be born in some fixed state. This seems as good as any. */ | |||
143 | memset (symbolP, 0, sizeof (symbolS)); | |||
| ||||
144 | ||||
145 | symbolP->bsym = bfd_make_empty_symbol (stdoutput)((*((stdoutput)->xvec->_bfd_make_empty_symbol)) (stdoutput )); | |||
146 | if (symbolP->bsym == NULL((void*)0)) | |||
147 | as_perror ("%s", "bfd_make_empty_symbol"); | |||
148 | symbolP->bsym->udata.p = (PTRvoid *) symbolP; | |||
149 | S_SET_NAME (symbolP, preserved_copy_of_name); | |||
150 | ||||
151 | S_SET_SEGMENT (symbolP, segment); | |||
152 | S_SET_VALUE (symbolP, valu); | |||
153 | symbol_clear_list_pointers (symbolP); | |||
154 | ||||
155 | symbolP->sy_frag = frag; | |||
156 | ||||
157 | obj_symbol_new_hookelf_obj_symbol_new_hook (symbolP); | |||
158 | ||||
159 | #ifdef tc_symbol_new_hook | |||
160 | tc_symbol_new_hook (symbolP); | |||
161 | #endif | |||
162 | ||||
163 | return symbolP; | |||
164 | } | |||
165 | ||||
166 | ||||
167 | /* Local symbol support. If we can get away with it, we keep only a | |||
168 | small amount of information for local symbols. */ | |||
169 | ||||
170 | static symbolS *local_symbol_convert (struct local_symbol *); | |||
171 | ||||
172 | /* Used for statistics. */ | |||
173 | ||||
174 | static unsigned long local_symbol_count; | |||
175 | static unsigned long local_symbol_conversion_count; | |||
176 | ||||
177 | /* This macro is called with a symbol argument passed by reference. | |||
178 | It returns whether this is a local symbol. If necessary, it | |||
179 | changes its argument to the real symbol. */ | |||
180 | ||||
181 | #define LOCAL_SYMBOL_CHECK(s)(s->bsym == ((void*)0) ? ((((struct local_symbol *) s)-> lsy_section == reg_section) ? (s = (((struct local_symbol *) s )->u.lsy_sym), 0) : 1) : 0) \ | |||
182 | (s->bsym == NULL((void*)0) \ | |||
183 | ? (local_symbol_converted_p ((struct local_symbol *) s)(((struct local_symbol *) s)->lsy_section == reg_section) \ | |||
184 | ? (s = local_symbol_get_real_symbol ((struct local_symbol *) s)(((struct local_symbol *) s)->u.lsy_sym), \ | |||
185 | 0) \ | |||
186 | : 1) \ | |||
187 | : 0) | |||
188 | ||||
189 | /* Create a local symbol and insert it into the local hash table. */ | |||
190 | ||||
191 | static struct local_symbol * | |||
192 | local_symbol_make (const char *name, segT section, valueT value, fragS *frag) | |||
193 | { | |||
194 | char *name_copy; | |||
195 | struct local_symbol *ret; | |||
196 | ||||
197 | ++local_symbol_count; | |||
198 | ||||
199 | name_copy = save_symbol_name (name); | |||
200 | ||||
201 | ret = (struct local_symbol *) obstack_alloc (¬es, sizeof *ret)__extension__ ({ struct obstack *__h = (¬es); __extension__ ({ struct obstack *__o = (__h); int __len = ((sizeof *ret)); if (__o->chunk_limit - __o->next_free < __len) _obstack_newchunk (__o, __len); ((__o)->next_free += (__len)); (void) 0; }) ; __extension__ ({ struct obstack *__o1 = (__h); void *value; value = (void *) __o1->object_base; if (__o1->next_free == value) __o1->maybe_empty_object = 1; __o1->next_free = (((((__o1->next_free) - (char *) 0)+__o1->alignment_mask ) & ~ (__o1->alignment_mask)) + (char *) 0); if (__o1-> next_free - (char *)__o1->chunk > __o1->chunk_limit - (char *)__o1->chunk) __o1->next_free = __o1->chunk_limit ; __o1->object_base = __o1->next_free; value; }); }); | |||
202 | ret->lsy_marker = NULL((void*)0); | |||
203 | ret->lsy_name = name_copy; | |||
204 | ret->lsy_section = section; | |||
205 | local_symbol_set_frag (ret, frag)((ret)->u.lsy_frag = (frag)); | |||
206 | ret->lsy_value = value; | |||
207 | ||||
208 | hash_jam (local_hash, name_copy, (PTRvoid *) ret); | |||
209 | ||||
210 | return ret; | |||
211 | } | |||
212 | ||||
213 | /* Convert a local symbol into a real symbol. Note that we do not | |||
214 | reclaim the space used by the local symbol. */ | |||
215 | ||||
216 | static symbolS * | |||
217 | local_symbol_convert (struct local_symbol *locsym) | |||
218 | { | |||
219 | symbolS *ret; | |||
220 | ||||
221 | assert (locsym->lsy_marker == NULL)((void) ((locsym->lsy_marker == ((void*)0)) ? 0 : (as_assert ("/usr/src/gnu/usr.bin/binutils-2.17/gas/symbols.c", 221, __PRETTY_FUNCTION__ ), 0))); | |||
222 | if (local_symbol_converted_p (locsym)((locsym)->lsy_section == reg_section)) | |||
223 | return local_symbol_get_real_symbol (locsym)((locsym)->u.lsy_sym); | |||
224 | ||||
225 | ++local_symbol_conversion_count; | |||
226 | ||||
227 | ret = symbol_new (locsym->lsy_name, locsym->lsy_section, locsym->lsy_value, | |||
228 | local_symbol_get_frag (locsym)((locsym)->u.lsy_frag)); | |||
229 | ||||
230 | if (local_symbol_resolved_p (locsym)((locsym)->u.lsy_frag == ((void*)0))) | |||
231 | ret->sy_resolved = 1; | |||
232 | ||||
233 | /* Local symbols are always either defined or used. */ | |||
234 | ret->sy_used = 1; | |||
235 | ||||
236 | #ifdef TC_LOCAL_SYMFIELD_CONVERT | |||
237 | TC_LOCAL_SYMFIELD_CONVERT (locsym, ret); | |||
238 | #endif | |||
239 | ||||
240 | symbol_table_insert (ret); | |||
241 | ||||
242 | local_symbol_mark_converted (locsym)((locsym)->lsy_section = reg_section); | |||
243 | local_symbol_set_real_symbol (locsym, ret)((locsym)->u.lsy_sym = (ret)); | |||
244 | ||||
245 | hash_jam (local_hash, locsym->lsy_name, NULL((void*)0)); | |||
246 | ||||
247 | return ret; | |||
248 | } | |||
249 | ||||
250 | /* We have just seen "<name>:". | |||
251 | Creates a struct symbol unless it already exists. | |||
252 | ||||
253 | Gripes if we are redefining a symbol incompatibly (and ignores it). */ | |||
254 | ||||
255 | symbolS * | |||
256 | colon (/* Just seen "x:" - rattle symbols & frags. */ | |||
257 | const char *sym_name /* Symbol name, as a cannonical string. */ | |||
258 | /* We copy this string: OK to alter later. */) | |||
259 | { | |||
260 | register symbolS *symbolP; /* Symbol we are working with. */ | |||
261 | ||||
262 | /* Sun local labels go out of scope whenever a non-local symbol is | |||
263 | defined. */ | |||
264 | if (LOCAL_LABELS_DOLLAR0 | |||
265 | && !bfd_is_local_label_name (stdoutput, sym_name)((*((stdoutput)->xvec->_bfd_is_local_label_name)) (stdoutput , sym_name))) | |||
266 | dollar_label_clear (); | |||
267 | ||||
268 | #ifndef WORKING_DOT_WORD | |||
269 | if (new_broken_words) | |||
270 | { | |||
271 | struct broken_word *a; | |||
272 | int possible_bytes; | |||
273 | fragS *frag_tmp; | |||
274 | char *frag_opcode; | |||
275 | ||||
276 | if (now_seg == absolute_section((asection *) &bfd_abs_section)) | |||
277 | { | |||
278 | as_bad (_("cannot define symbol `%s' in absolute section")("cannot define symbol `%s' in absolute section"), sym_name); | |||
279 | return NULL((void*)0); | |||
280 | } | |||
281 | ||||
282 | possible_bytes = (md_short_jump_size | |||
283 | + new_broken_words * md_long_jump_size); | |||
284 | ||||
285 | frag_tmp = frag_now; | |||
286 | frag_opcode = frag_var (rs_broken_word, | |||
287 | possible_bytes, | |||
288 | possible_bytes, | |||
289 | (relax_substateT) 0, | |||
290 | (symbolS *) broken_words, | |||
291 | (offsetT) 0, | |||
292 | NULL((void*)0)); | |||
293 | ||||
294 | /* We want to store the pointer to where to insert the jump | |||
295 | table in the fr_opcode of the rs_broken_word frag. This | |||
296 | requires a little hackery. */ | |||
297 | while (frag_tmp | |||
298 | && (frag_tmp->fr_type != rs_broken_word | |||
299 | || frag_tmp->fr_opcode)) | |||
300 | frag_tmp = frag_tmp->fr_next; | |||
301 | know (frag_tmp); | |||
302 | frag_tmp->fr_opcode = frag_opcode; | |||
303 | new_broken_words = 0; | |||
304 | ||||
305 | for (a = broken_words; a && a->dispfrag == 0; a = a->next_broken_word) | |||
306 | a->dispfrag = frag_tmp; | |||
307 | } | |||
308 | #endif /* WORKING_DOT_WORD */ | |||
309 | ||||
310 | if ((symbolP = symbol_find (sym_name)) != 0) | |||
311 | { | |||
312 | S_CLEAR_WEAKREFR (symbolP); | |||
313 | #ifdef RESOLVE_SYMBOL_REDEFINITION | |||
314 | if (RESOLVE_SYMBOL_REDEFINITION (symbolP)) | |||
315 | return symbolP; | |||
316 | #endif | |||
317 | /* Now check for undefined symbols. */ | |||
318 | if (LOCAL_SYMBOL_CHECK (symbolP)(symbolP->bsym == ((void*)0) ? ((((struct local_symbol *) symbolP )->lsy_section == reg_section) ? (symbolP = (((struct local_symbol *) symbolP)->u.lsy_sym), 0) : 1) : 0)) | |||
319 | { | |||
320 | struct local_symbol *locsym = (struct local_symbol *) symbolP; | |||
321 | ||||
322 | if (locsym->lsy_section != undefined_section((asection *) &bfd_und_section) | |||
323 | && (local_symbol_get_frag (locsym)((locsym)->u.lsy_frag) != frag_now | |||
324 | || locsym->lsy_section != now_seg | |||
325 | || locsym->lsy_value != frag_now_fix ())) | |||
326 | { | |||
327 | as_bad (_("symbol `%s' is already defined")("symbol `%s' is already defined"), sym_name); | |||
328 | return symbolP; | |||
329 | } | |||
330 | ||||
331 | locsym->lsy_section = now_seg; | |||
332 | local_symbol_set_frag (locsym, frag_now)((locsym)->u.lsy_frag = (frag_now)); | |||
333 | locsym->lsy_value = frag_now_fix (); | |||
334 | } | |||
335 | else if (!(S_IS_DEFINED (symbolP) || symbol_equated_p (symbolP)) | |||
336 | || S_IS_COMMON (symbolP) | |||
337 | || S_IS_VOLATILE (symbolP)) | |||
338 | { | |||
339 | if (S_IS_VOLATILE (symbolP) | |||
340 | /* This could be avoided when the symbol wasn't used so far, but | |||
341 | the comment in struc-symbol.h says this flag isn't reliable. */ | |||
342 | && (1 || !symbol_used_p (symbolP))) | |||
343 | { | |||
344 | symbolP = symbol_clone (symbolP, 1); | |||
345 | S_SET_VALUE (symbolP, 0); | |||
346 | S_CLEAR_VOLATILE (symbolP); | |||
347 | } | |||
348 | if (S_GET_VALUE (symbolP) == 0) | |||
349 | { | |||
350 | symbolP->sy_frag = frag_now; | |||
351 | #ifdef OBJ_VMS | |||
352 | S_SET_OTHER (symbolP, const_flag)(((elf_symbol_type *) (&(symbol_get_bfdsym (symbolP))-> the_bfd))->internal_elf_sym.st_other = (const_flag)); | |||
353 | #endif | |||
354 | S_SET_VALUE (symbolP, (valueT) frag_now_fix ()); | |||
355 | S_SET_SEGMENT (symbolP, now_seg); | |||
356 | #ifdef N_UNDF | |||
357 | know (N_UNDF == 0); | |||
358 | #endif /* if we have one, it better be zero. */ | |||
359 | ||||
360 | } | |||
361 | else | |||
362 | { | |||
363 | /* There are still several cases to check: | |||
364 | ||||
365 | A .comm/.lcomm symbol being redefined as initialized | |||
366 | data is OK | |||
367 | ||||
368 | A .comm/.lcomm symbol being redefined with a larger | |||
369 | size is also OK | |||
370 | ||||
371 | This only used to be allowed on VMS gas, but Sun cc | |||
372 | on the sparc also depends on it. */ | |||
373 | ||||
374 | if (((!S_IS_DEBUG (symbolP) | |||
375 | && (!S_IS_DEFINED (symbolP) || S_IS_COMMON (symbolP)) | |||
376 | && S_IS_EXTERNAL (symbolP)) | |||
377 | || S_GET_SEGMENT (symbolP) == bss_section) | |||
378 | && (now_seg == data_section | |||
379 | || now_seg == bss_section | |||
380 | || now_seg == S_GET_SEGMENT (symbolP))) | |||
381 | { | |||
382 | /* Select which of the 2 cases this is. */ | |||
383 | if (now_seg != data_section) | |||
384 | { | |||
385 | /* New .comm for prev .comm symbol. | |||
386 | ||||
387 | If the new size is larger we just change its | |||
388 | value. If the new size is smaller, we ignore | |||
389 | this symbol. */ | |||
390 | if (S_GET_VALUE (symbolP) | |||
391 | < ((unsigned) frag_now_fix ())) | |||
392 | { | |||
393 | S_SET_VALUE (symbolP, (valueT) frag_now_fix ()); | |||
394 | } | |||
395 | } | |||
396 | else | |||
397 | { | |||
398 | /* It is a .comm/.lcomm being converted to initialized | |||
399 | data. */ | |||
400 | symbolP->sy_frag = frag_now; | |||
401 | #ifdef OBJ_VMS | |||
402 | S_SET_OTHER (symbolP, const_flag)(((elf_symbol_type *) (&(symbol_get_bfdsym (symbolP))-> the_bfd))->internal_elf_sym.st_other = (const_flag)); | |||
403 | #endif | |||
404 | S_SET_VALUE (symbolP, (valueT) frag_now_fix ()); | |||
405 | S_SET_SEGMENT (symbolP, now_seg); /* Keep N_EXT bit. */ | |||
406 | } | |||
407 | } | |||
408 | else | |||
409 | { | |||
410 | #if (!defined (OBJ_AOUT) && !defined (OBJ_MAYBE_AOUT) \ | |||
411 | && !defined (OBJ_BOUT) && !defined (OBJ_MAYBE_BOUT)) | |||
412 | static const char *od_buf = ""; | |||
413 | #else | |||
414 | char od_buf[100]; | |||
415 | od_buf[0] = '\0'; | |||
416 | if (OUTPUT_FLAVORbfd_target_elf_flavour == bfd_target_aout_flavour) | |||
417 | sprintf (od_buf, "%d.%d.", | |||
418 | S_GET_OTHER (symbolP)(elf_s_get_other (symbolP)), | |||
419 | S_GET_DESC (symbolP)); | |||
420 | #endif | |||
421 | as_bad (_("symbol `%s' is already defined as \"%s\"/%s%ld")("symbol `%s' is already defined as \"%s\"/%s%ld"), | |||
422 | sym_name, | |||
423 | segment_name (S_GET_SEGMENT (symbolP))((S_GET_SEGMENT (symbolP))->name + 0), | |||
424 | od_buf, | |||
425 | (long) S_GET_VALUE (symbolP)); | |||
426 | } | |||
427 | } /* if the undefined symbol has no value */ | |||
428 | } | |||
429 | else | |||
430 | { | |||
431 | /* Don't blow up if the definition is the same. */ | |||
432 | if (!(frag_now == symbolP->sy_frag | |||
433 | && S_GET_VALUE (symbolP) == frag_now_fix () | |||
434 | && S_GET_SEGMENT (symbolP) == now_seg)) | |||
435 | { | |||
436 | as_bad (_("symbol `%s' is already defined")("symbol `%s' is already defined"), sym_name); | |||
437 | symbolP = symbol_clone (symbolP, 0); | |||
438 | } | |||
439 | } | |||
440 | ||||
441 | } | |||
442 | else if (! flag_keep_locals && bfd_is_local_label_name (stdoutput, sym_name)((*((stdoutput)->xvec->_bfd_is_local_label_name)) (stdoutput , sym_name))) | |||
443 | { | |||
444 | symbolP = (symbolS *) local_symbol_make (sym_name, now_seg, | |||
445 | (valueT) frag_now_fix (), | |||
446 | frag_now); | |||
447 | } | |||
448 | else | |||
449 | { | |||
450 | symbolP = symbol_new (sym_name, now_seg, (valueT) frag_now_fix (), | |||
451 | frag_now); | |||
452 | #ifdef OBJ_VMS | |||
453 | S_SET_OTHER (symbolP, const_flag)(((elf_symbol_type *) (&(symbol_get_bfdsym (symbolP))-> the_bfd))->internal_elf_sym.st_other = (const_flag)); | |||
454 | #endif /* OBJ_VMS */ | |||
455 | ||||
456 | symbol_table_insert (symbolP); | |||
457 | } | |||
458 | ||||
459 | if (mri_common_symbol != NULL((void*)0)) | |||
460 | { | |||
461 | /* This symbol is actually being defined within an MRI common | |||
462 | section. This requires special handling. */ | |||
463 | if (LOCAL_SYMBOL_CHECK (symbolP)(symbolP->bsym == ((void*)0) ? ((((struct local_symbol *) symbolP )->lsy_section == reg_section) ? (symbolP = (((struct local_symbol *) symbolP)->u.lsy_sym), 0) : 1) : 0)) | |||
464 | symbolP = local_symbol_convert ((struct local_symbol *) symbolP); | |||
465 | symbolP->sy_value.X_op = O_symbol; | |||
466 | symbolP->sy_value.X_add_symbol = mri_common_symbol; | |||
467 | symbolP->sy_value.X_add_number = S_GET_VALUE (mri_common_symbol); | |||
468 | symbolP->sy_frag = &zero_address_frag; | |||
469 | S_SET_SEGMENT (symbolP, expr_section); | |||
470 | symbolP->sy_mri_common = 1; | |||
471 | } | |||
472 | ||||
473 | #ifdef tc_frob_label | |||
474 | tc_frob_label (symbolP); | |||
475 | #endif | |||
476 | #ifdef obj_frob_labeldwarf2_emit_label | |||
477 | obj_frob_labeldwarf2_emit_label (symbolP); | |||
478 | #endif | |||
479 | ||||
480 | return symbolP; | |||
481 | } | |||
482 | ||||
483 | /* Die if we can't insert the symbol. */ | |||
484 | ||||
485 | void | |||
486 | symbol_table_insert (symbolS *symbolP) | |||
487 | { | |||
488 | register const char *error_string; | |||
489 | ||||
490 | know (symbolP); | |||
491 | know (S_GET_NAME (symbolP)); | |||
492 | ||||
493 | if (LOCAL_SYMBOL_CHECK (symbolP)(symbolP->bsym == ((void*)0) ? ((((struct local_symbol *) symbolP )->lsy_section == reg_section) ? (symbolP = (((struct local_symbol *) symbolP)->u.lsy_sym), 0) : 1) : 0)) | |||
494 | { | |||
495 | error_string = hash_jam (local_hash, S_GET_NAME (symbolP), | |||
496 | (PTRvoid *) symbolP); | |||
497 | if (error_string != NULL((void*)0)) | |||
498 | as_fatal (_("inserting \"%s\" into symbol table failed: %s")("inserting \"%s\" into symbol table failed: %s"), | |||
499 | S_GET_NAME (symbolP), error_string); | |||
500 | return; | |||
501 | } | |||
502 | ||||
503 | if ((error_string = hash_jam (sy_hash, S_GET_NAME (symbolP), (PTRvoid *) symbolP))) | |||
504 | { | |||
505 | as_fatal (_("inserting \"%s\" into symbol table failed: %s")("inserting \"%s\" into symbol table failed: %s"), | |||
506 | S_GET_NAME (symbolP), error_string); | |||
507 | } /* on error */ | |||
508 | } | |||
509 | ||||
510 | /* If a symbol name does not exist, create it as undefined, and insert | |||
511 | it into the symbol table. Return a pointer to it. */ | |||
512 | ||||
513 | symbolS * | |||
514 | symbol_find_or_make (const char *name) | |||
515 | { | |||
516 | register symbolS *symbolP; | |||
517 | ||||
518 | symbolP = symbol_find (name); | |||
519 | ||||
520 | if (symbolP == NULL((void*)0)) | |||
521 | { | |||
522 | if (! flag_keep_locals && bfd_is_local_label_name (stdoutput, name)((*((stdoutput)->xvec->_bfd_is_local_label_name)) (stdoutput , name))) | |||
523 | { | |||
524 | symbolP = md_undefined_symbol ((char *) name); | |||
525 | if (symbolP != NULL((void*)0)) | |||
526 | return symbolP; | |||
527 | ||||
528 | symbolP = (symbolS *) local_symbol_make (name, undefined_section((asection *) &bfd_und_section), | |||
529 | (valueT) 0, | |||
530 | &zero_address_frag); | |||
531 | return symbolP; | |||
532 | } | |||
533 | ||||
534 | symbolP = symbol_make (name); | |||
535 | ||||
536 | symbol_table_insert (symbolP); | |||
537 | } /* if symbol wasn't found */ | |||
538 | ||||
539 | return (symbolP); | |||
540 | } | |||
541 | ||||
542 | symbolS * | |||
543 | symbol_make (const char *name) | |||
544 | { | |||
545 | symbolS *symbolP; | |||
546 | ||||
547 | /* Let the machine description default it, e.g. for register names. */ | |||
548 | symbolP = md_undefined_symbol ((char *) name); | |||
549 | ||||
550 | if (!symbolP) | |||
551 | symbolP = symbol_new (name, undefined_section((asection *) &bfd_und_section), (valueT) 0, &zero_address_frag); | |||
552 | ||||
553 | return (symbolP); | |||
554 | } | |||
555 | ||||
556 | symbolS * | |||
557 | symbol_clone (symbolS *orgsymP, int replace) | |||
558 | { | |||
559 | symbolS *newsymP; | |||
560 | asymbol *bsymorg, *bsymnew; | |||
561 | ||||
562 | /* Running local_symbol_convert on a clone that's not the one currently | |||
563 | in local_hash would incorrectly replace the hash entry. Thus the | |||
564 | symbol must be converted here. Note that the rest of the function | |||
565 | depends on not encountering an unconverted symbol. */ | |||
566 | if (LOCAL_SYMBOL_CHECK (orgsymP)(orgsymP->bsym == ((void*)0) ? ((((struct local_symbol *) orgsymP )->lsy_section == reg_section) ? (orgsymP = (((struct local_symbol *) orgsymP)->u.lsy_sym), 0) : 1) : 0)) | |||
567 | orgsymP = local_symbol_convert ((struct local_symbol *) orgsymP); | |||
568 | bsymorg = orgsymP->bsym; | |||
569 | ||||
570 | know (S_IS_DEFINED (orgsymP)); | |||
571 | ||||
572 | newsymP = obstack_alloc (¬es, sizeof (*newsymP))__extension__ ({ struct obstack *__h = (¬es); __extension__ ({ struct obstack *__o = (__h); int __len = ((sizeof (*newsymP ))); if (__o->chunk_limit - __o->next_free < __len) _obstack_newchunk (__o, __len); ((__o)->next_free += (__len)); (void) 0; }) ; __extension__ ({ struct obstack *__o1 = (__h); void *value; value = (void *) __o1->object_base; if (__o1->next_free == value) __o1->maybe_empty_object = 1; __o1->next_free = (((((__o1->next_free) - (char *) 0)+__o1->alignment_mask ) & ~ (__o1->alignment_mask)) + (char *) 0); if (__o1-> next_free - (char *)__o1->chunk > __o1->chunk_limit - (char *)__o1->chunk) __o1->next_free = __o1->chunk_limit ; __o1->object_base = __o1->next_free; value; }); }); | |||
573 | *newsymP = *orgsymP; | |||
574 | bsymnew = bfd_make_empty_symbol (bfd_asymbol_bfd (bsymorg))((*((((bsymorg)->the_bfd))->xvec->_bfd_make_empty_symbol )) (((bsymorg)->the_bfd))); | |||
575 | if (bsymnew == NULL((void*)0)) | |||
576 | as_perror ("%s", "bfd_make_empty_symbol"); | |||
577 | newsymP->bsym = bsymnew; | |||
578 | bsymnew->name = bsymorg->name; | |||
579 | bsymnew->flags = bsymorg->flags; | |||
580 | bsymnew->section = bsymorg->section; | |||
581 | bsymnew->udata.p = (PTRvoid *) newsymP; | |||
582 | bfd_copy_private_symbol_data (bfd_asymbol_bfd (bsymorg), bsymorg,((*((((bsymnew)->the_bfd))->xvec->_bfd_copy_private_symbol_data )) (((bsymorg)->the_bfd), bsymorg, ((bsymnew)->the_bfd) , bsymnew)) | |||
583 | bfd_asymbol_bfd (bsymnew), bsymnew)((*((((bsymnew)->the_bfd))->xvec->_bfd_copy_private_symbol_data )) (((bsymorg)->the_bfd), bsymorg, ((bsymnew)->the_bfd) , bsymnew)); | |||
584 | ||||
585 | #ifdef obj_symbol_clone_hook | |||
586 | obj_symbol_clone_hook (newsymP, orgsymP); | |||
587 | #endif | |||
588 | ||||
589 | #ifdef tc_symbol_clone_hook | |||
590 | tc_symbol_clone_hook (newsymP, orgsymP); | |||
591 | #endif | |||
592 | ||||
593 | if (replace) | |||
594 | { | |||
595 | if (symbol_rootP == orgsymP) | |||
596 | symbol_rootP = newsymP; | |||
597 | else if (orgsymP->sy_previous) | |||
598 | { | |||
599 | orgsymP->sy_previous->sy_next = newsymP; | |||
600 | orgsymP->sy_previous = NULL((void*)0); | |||
601 | } | |||
602 | if (symbol_lastP == orgsymP) | |||
603 | symbol_lastP = newsymP; | |||
604 | else if (orgsymP->sy_next) | |||
605 | orgsymP->sy_next->sy_previous = newsymP; | |||
606 | orgsymP->sy_next = NULL((void*)0); | |||
607 | debug_verify_symchain (symbol_rootP, symbol_lastP)((void) 0); | |||
608 | ||||
609 | symbol_table_insert (newsymP); | |||
610 | } | |||
611 | ||||
612 | return newsymP; | |||
613 | } | |||
614 | ||||
615 | /* Referenced symbols, if they are forward references, need to be cloned | |||
616 | (without replacing the original) so that the value of the referenced | |||
617 | symbols at the point of use . */ | |||
618 | ||||
619 | #undef symbol_clone_if_forward_ref | |||
620 | symbolS * | |||
621 | symbol_clone_if_forward_ref (symbolS *symbolP, int is_forward) | |||
622 | { | |||
623 | if (symbolP && !LOCAL_SYMBOL_CHECK (symbolP)(symbolP->bsym == ((void*)0) ? ((((struct local_symbol *) symbolP )->lsy_section == reg_section) ? (symbolP = (((struct local_symbol *) symbolP)->u.lsy_sym), 0) : 1) : 0)) | |||
624 | { | |||
625 | symbolS *add_symbol = symbolP->sy_value.X_add_symbol; | |||
626 | symbolS *op_symbol = symbolP->sy_value.X_op_symbol; | |||
627 | ||||
628 | if (symbolP->sy_forward_ref) | |||
629 | is_forward = 1; | |||
630 | ||||
631 | if (is_forward) | |||
632 | { | |||
633 | /* assign_symbol() clones volatile symbols; pre-existing expressions | |||
634 | hold references to the original instance, but want the current | |||
635 | value. Just repeat the lookup. */ | |||
636 | if (add_symbol && S_IS_VOLATILE (add_symbol)) | |||
637 | add_symbol = symbol_find_exact (S_GET_NAME (add_symbol)); | |||
638 | if (op_symbol && S_IS_VOLATILE (op_symbol)) | |||
639 | op_symbol = symbol_find_exact (S_GET_NAME (op_symbol)); | |||
640 | } | |||
641 | ||||
642 | /* Re-using sy_resolving here, as this routine cannot get called from | |||
643 | symbol resolution code. */ | |||
644 | if (symbolP->bsym->section == expr_section && !symbolP->sy_resolving) | |||
645 | { | |||
646 | symbolP->sy_resolving = 1; | |||
647 | add_symbol = symbol_clone_if_forward_ref (add_symbol, is_forward); | |||
648 | op_symbol = symbol_clone_if_forward_ref (op_symbol, is_forward); | |||
649 | symbolP->sy_resolving = 0; | |||
650 | } | |||
651 | ||||
652 | if (symbolP->sy_forward_ref | |||
653 | || add_symbol != symbolP->sy_value.X_add_symbol | |||
654 | || op_symbol != symbolP->sy_value.X_op_symbol) | |||
655 | symbolP = symbol_clone (symbolP, 0); | |||
656 | ||||
657 | symbolP->sy_value.X_add_symbol = add_symbol; | |||
658 | symbolP->sy_value.X_op_symbol = op_symbol; | |||
659 | } | |||
660 | ||||
661 | return symbolP; | |||
662 | } | |||
663 | ||||
664 | symbolS * | |||
665 | symbol_temp_new (segT seg, valueT ofs, fragS *frag) | |||
666 | { | |||
667 | return symbol_new (FAKE_LABEL_NAME"L0\001", seg, ofs, frag); | |||
668 | } | |||
669 | ||||
670 | symbolS * | |||
671 | symbol_temp_new_now (void) | |||
672 | { | |||
673 | return symbol_temp_new (now_seg, frag_now_fix (), frag_now); | |||
674 | } | |||
675 | ||||
676 | symbolS * | |||
677 | symbol_temp_make (void) | |||
678 | { | |||
679 | return symbol_make (FAKE_LABEL_NAME"L0\001"); | |||
680 | } | |||
681 | ||||
682 | /* Implement symbol table lookup. | |||
683 | In: A symbol's name as a string: '\0' can't be part of a symbol name. | |||
684 | Out: NULL if the name was not in the symbol table, else the address | |||
685 | of a struct symbol associated with that name. */ | |||
686 | ||||
687 | symbolS * | |||
688 | symbol_find_exact (const char *name) | |||
689 | { | |||
690 | return symbol_find_exact_noref (name, 0); | |||
691 | } | |||
692 | ||||
693 | symbolS * | |||
694 | symbol_find_exact_noref (const char *name, int noref) | |||
695 | { | |||
696 | struct local_symbol *locsym; | |||
697 | symbolS* sym; | |||
698 | ||||
699 | locsym = (struct local_symbol *) hash_find (local_hash, name); | |||
700 | if (locsym != NULL((void*)0)) | |||
701 | return (symbolS *) locsym; | |||
702 | ||||
703 | sym = ((symbolS *) hash_find (sy_hash, name)); | |||
704 | ||||
705 | /* Any references to the symbol, except for the reference in | |||
706 | .weakref, must clear this flag, such that the symbol does not | |||
707 | turn into a weak symbol. Note that we don't have to handle the | |||
708 | local_symbol case, since a weakrefd is always promoted out of the | |||
709 | local_symbol table when it is turned into a weak symbol. */ | |||
710 | if (sym && ! noref) | |||
711 | S_CLEAR_WEAKREFD (sym); | |||
712 | ||||
713 | return sym; | |||
714 | } | |||
715 | ||||
716 | symbolS * | |||
717 | symbol_find (const char *name) | |||
718 | { | |||
719 | return symbol_find_noref (name, 0); | |||
720 | } | |||
721 | ||||
722 | symbolS * | |||
723 | symbol_find_noref (const char *name, int noref) | |||
724 | { | |||
725 | #ifdef tc_canonicalize_symbol_name | |||
726 | { | |||
727 | char *copy; | |||
728 | size_t len = strlen (name) + 1; | |||
729 | ||||
730 | copy = (char *) alloca (len)__builtin_alloca(len); | |||
731 | memcpy (copy, name, len); | |||
732 | name = tc_canonicalize_symbol_name (copy); | |||
733 | } | |||
734 | #endif | |||
735 | ||||
736 | if (! symbols_case_sensitive) | |||
737 | { | |||
738 | char *copy; | |||
739 | const char *orig; | |||
740 | unsigned char c; | |||
741 | ||||
742 | orig = name; | |||
743 | name = copy = (char *) alloca (strlen (name) + 1)__builtin_alloca(strlen (name) + 1); | |||
744 | ||||
745 | while ((c = *orig++) != '\0') | |||
746 | { | |||
747 | *copy++ = TOUPPER (c)_sch_toupper[(c) & 0xff]; | |||
748 | } | |||
749 | *copy = '\0'; | |||
750 | } | |||
751 | ||||
752 | return symbol_find_exact_noref (name, noref); | |||
753 | } | |||
754 | ||||
755 | /* Once upon a time, symbols were kept in a singly linked list. At | |||
756 | least coff needs to be able to rearrange them from time to time, for | |||
757 | which a doubly linked list is much more convenient. Loic did these | |||
758 | as macros which seemed dangerous to me so they're now functions. | |||
759 | xoxorich. */ | |||
760 | ||||
761 | /* Link symbol ADDME after symbol TARGET in the chain. */ | |||
762 | ||||
763 | void | |||
764 | symbol_append (symbolS *addme, symbolS *target, | |||
765 | symbolS **rootPP, symbolS **lastPP) | |||
766 | { | |||
767 | if (LOCAL_SYMBOL_CHECK (addme)(addme->bsym == ((void*)0) ? ((((struct local_symbol *) addme )->lsy_section == reg_section) ? (addme = (((struct local_symbol *) addme)->u.lsy_sym), 0) : 1) : 0)) | |||
768 | abort ()as_abort ("/usr/src/gnu/usr.bin/binutils-2.17/gas/symbols.c", 768, __PRETTY_FUNCTION__); | |||
769 | if (target != NULL((void*)0) && LOCAL_SYMBOL_CHECK (target)(target->bsym == ((void*)0) ? ((((struct local_symbol *) target )->lsy_section == reg_section) ? (target = (((struct local_symbol *) target)->u.lsy_sym), 0) : 1) : 0)) | |||
770 | abort ()as_abort ("/usr/src/gnu/usr.bin/binutils-2.17/gas/symbols.c", 770, __PRETTY_FUNCTION__); | |||
771 | ||||
772 | if (target == NULL((void*)0)) | |||
773 | { | |||
774 | know (*rootPP == NULL); | |||
775 | know (*lastPP == NULL); | |||
776 | addme->sy_next = NULL((void*)0); | |||
777 | addme->sy_previous = NULL((void*)0); | |||
778 | *rootPP = addme; | |||
779 | *lastPP = addme; | |||
780 | return; | |||
781 | } /* if the list is empty */ | |||
782 | ||||
783 | if (target->sy_next != NULL((void*)0)) | |||
784 | { | |||
785 | target->sy_next->sy_previous = addme; | |||
786 | } | |||
787 | else | |||
788 | { | |||
789 | know (*lastPP == target); | |||
790 | *lastPP = addme; | |||
791 | } /* if we have a next */ | |||
792 | ||||
793 | addme->sy_next = target->sy_next; | |||
794 | target->sy_next = addme; | |||
795 | addme->sy_previous = target; | |||
796 | ||||
797 | debug_verify_symchain (symbol_rootP, symbol_lastP)((void) 0); | |||
798 | } | |||
799 | ||||
800 | /* Set the chain pointers of SYMBOL to null. */ | |||
801 | ||||
802 | void | |||
803 | symbol_clear_list_pointers (symbolS *symbolP) | |||
804 | { | |||
805 | if (LOCAL_SYMBOL_CHECK (symbolP)(symbolP->bsym == ((void*)0) ? ((((struct local_symbol *) symbolP )->lsy_section == reg_section) ? (symbolP = (((struct local_symbol *) symbolP)->u.lsy_sym), 0) : 1) : 0)) | |||
806 | abort ()as_abort ("/usr/src/gnu/usr.bin/binutils-2.17/gas/symbols.c", 806, __PRETTY_FUNCTION__); | |||
807 | symbolP->sy_next = NULL((void*)0); | |||
808 | symbolP->sy_previous = NULL((void*)0); | |||
809 | } | |||
810 | ||||
811 | /* Remove SYMBOLP from the list. */ | |||
812 | ||||
813 | void | |||
814 | symbol_remove (symbolS *symbolP, symbolS **rootPP, symbolS **lastPP) | |||
815 | { | |||
816 | if (LOCAL_SYMBOL_CHECK (symbolP)(symbolP->bsym == ((void*)0) ? ((((struct local_symbol *) symbolP )->lsy_section == reg_section) ? (symbolP = (((struct local_symbol *) symbolP)->u.lsy_sym), 0) : 1) : 0)) | |||
817 | abort ()as_abort ("/usr/src/gnu/usr.bin/binutils-2.17/gas/symbols.c", 817, __PRETTY_FUNCTION__); | |||
818 | ||||
819 | if (symbolP == *rootPP) | |||
820 | { | |||
821 | *rootPP = symbolP->sy_next; | |||
822 | } /* if it was the root */ | |||
823 | ||||
824 | if (symbolP == *lastPP) | |||
825 | { | |||
826 | *lastPP = symbolP->sy_previous; | |||
827 | } /* if it was the tail */ | |||
828 | ||||
829 | if (symbolP->sy_next != NULL((void*)0)) | |||
830 | { | |||
831 | symbolP->sy_next->sy_previous = symbolP->sy_previous; | |||
832 | } /* if not last */ | |||
833 | ||||
834 | if (symbolP->sy_previous != NULL((void*)0)) | |||
835 | { | |||
836 | symbolP->sy_previous->sy_next = symbolP->sy_next; | |||
837 | } /* if not first */ | |||
838 | ||||
839 | debug_verify_symchain (*rootPP, *lastPP)((void) 0); | |||
840 | } | |||
841 | ||||
842 | /* Link symbol ADDME before symbol TARGET in the chain. */ | |||
843 | ||||
844 | void | |||
845 | symbol_insert (symbolS *addme, symbolS *target, | |||
846 | symbolS **rootPP, symbolS **lastPP ATTRIBUTE_UNUSED__attribute__ ((__unused__))) | |||
847 | { | |||
848 | if (LOCAL_SYMBOL_CHECK (addme)(addme->bsym == ((void*)0) ? ((((struct local_symbol *) addme )->lsy_section == reg_section) ? (addme = (((struct local_symbol *) addme)->u.lsy_sym), 0) : 1) : 0)) | |||
849 | abort ()as_abort ("/usr/src/gnu/usr.bin/binutils-2.17/gas/symbols.c", 849, __PRETTY_FUNCTION__); | |||
850 | if (LOCAL_SYMBOL_CHECK (target)(target->bsym == ((void*)0) ? ((((struct local_symbol *) target )->lsy_section == reg_section) ? (target = (((struct local_symbol *) target)->u.lsy_sym), 0) : 1) : 0)) | |||
851 | abort ()as_abort ("/usr/src/gnu/usr.bin/binutils-2.17/gas/symbols.c", 851, __PRETTY_FUNCTION__); | |||
852 | ||||
853 | if (target->sy_previous != NULL((void*)0)) | |||
854 | { | |||
855 | target->sy_previous->sy_next = addme; | |||
856 | } | |||
857 | else | |||
858 | { | |||
859 | know (*rootPP == target); | |||
860 | *rootPP = addme; | |||
861 | } /* if not first */ | |||
862 | ||||
863 | addme->sy_previous = target->sy_previous; | |||
864 | target->sy_previous = addme; | |||
865 | addme->sy_next = target; | |||
866 | ||||
867 | debug_verify_symchain (*rootPP, *lastPP)((void) 0); | |||
868 | } | |||
869 | ||||
870 | void | |||
871 | verify_symbol_chain (symbolS *rootP, symbolS *lastP) | |||
872 | { | |||
873 | symbolS *symbolP = rootP; | |||
874 | ||||
875 | if (symbolP == NULL((void*)0)) | |||
876 | return; | |||
877 | ||||
878 | for (; symbol_next (symbolP) != NULL((void*)0); symbolP = symbol_next (symbolP)) | |||
879 | { | |||
880 | assert (symbolP->bsym != NULL)((void) ((symbolP->bsym != ((void*)0)) ? 0 : (as_assert ("/usr/src/gnu/usr.bin/binutils-2.17/gas/symbols.c" , 880, __PRETTY_FUNCTION__), 0))); | |||
881 | assert (symbolP->sy_next->sy_previous == symbolP)((void) ((symbolP->sy_next->sy_previous == symbolP) ? 0 : (as_assert ("/usr/src/gnu/usr.bin/binutils-2.17/gas/symbols.c" , 881, __PRETTY_FUNCTION__), 0))); | |||
882 | } | |||
883 | ||||
884 | assert (lastP == symbolP)((void) ((lastP == symbolP) ? 0 : (as_assert ("/usr/src/gnu/usr.bin/binutils-2.17/gas/symbols.c" , 884, __PRETTY_FUNCTION__), 0))); | |||
885 | } | |||
886 | ||||
887 | static void | |||
888 | report_op_error (symbolS *symp, symbolS *left, symbolS *right) | |||
889 | { | |||
890 | char *file; | |||
891 | unsigned int line; | |||
892 | segT seg_left = S_GET_SEGMENT (left); | |||
893 | segT seg_right = right ? S_GET_SEGMENT (right) : 0; | |||
894 | ||||
895 | if (expr_symbol_where (symp, &file, &line)) | |||
896 | { | |||
897 | if (seg_left == undefined_section((asection *) &bfd_und_section)) | |||
898 | as_bad_where (file, line, | |||
899 | _("undefined symbol `%s' in operation")("undefined symbol `%s' in operation"), | |||
900 | S_GET_NAME (left)); | |||
901 | if (seg_right == undefined_section((asection *) &bfd_und_section)) | |||
902 | as_bad_where (file, line, | |||
903 | _("undefined symbol `%s' in operation")("undefined symbol `%s' in operation"), | |||
904 | S_GET_NAME (right)); | |||
905 | if (seg_left != undefined_section((asection *) &bfd_und_section) | |||
906 | && seg_right != undefined_section((asection *) &bfd_und_section)) | |||
907 | { | |||
908 | if (right) | |||
909 | as_bad_where (file, line, | |||
910 | _("invalid sections for operation on `%s' and `%s'")("invalid sections for operation on `%s' and `%s'"), | |||
911 | S_GET_NAME (left), S_GET_NAME (right)); | |||
912 | else | |||
913 | as_bad_where (file, line, | |||
914 | _("invalid section for operation on `%s'")("invalid section for operation on `%s'"), | |||
915 | S_GET_NAME (left)); | |||
916 | } | |||
917 | ||||
918 | } | |||
919 | else | |||
920 | { | |||
921 | if (seg_left == undefined_section((asection *) &bfd_und_section)) | |||
922 | as_bad (_("undefined symbol `%s' in operation setting `%s'")("undefined symbol `%s' in operation setting `%s'"), | |||
923 | S_GET_NAME (left), S_GET_NAME (symp)); | |||
924 | if (seg_right == undefined_section((asection *) &bfd_und_section)) | |||
925 | as_bad (_("undefined symbol `%s' in operation setting `%s'")("undefined symbol `%s' in operation setting `%s'"), | |||
926 | S_GET_NAME (right), S_GET_NAME (symp)); | |||
927 | if (seg_left != undefined_section((asection *) &bfd_und_section) | |||
928 | && seg_right != undefined_section((asection *) &bfd_und_section)) | |||
929 | { | |||
930 | if (right) | |||
931 | as_bad_where (file, line, | |||
932 | _("invalid sections for operation on `%s' and `%s' setting `%s'")("invalid sections for operation on `%s' and `%s' setting `%s'" ), | |||
933 | S_GET_NAME (left), S_GET_NAME (right), S_GET_NAME (symp)); | |||
934 | else | |||
935 | as_bad_where (file, line, | |||
936 | _("invalid section for operation on `%s' setting `%s'")("invalid section for operation on `%s' setting `%s'"), | |||
937 | S_GET_NAME (left), S_GET_NAME (symp)); | |||
938 | } | |||
939 | } | |||
940 | } | |||
941 | ||||
942 | /* Resolve the value of a symbol. This is called during the final | |||
943 | pass over the symbol table to resolve any symbols with complex | |||
944 | values. */ | |||
945 | ||||
946 | valueT | |||
947 | resolve_symbol_value (symbolS *symp) | |||
948 | { | |||
949 | int resolved; | |||
950 | valueT final_val = 0; | |||
951 | segT final_seg; | |||
952 | ||||
953 | if (LOCAL_SYMBOL_CHECK (symp)(symp->bsym == ((void*)0) ? ((((struct local_symbol *) symp )->lsy_section == reg_section) ? (symp = (((struct local_symbol *) symp)->u.lsy_sym), 0) : 1) : 0)) | |||
954 | { | |||
955 | struct local_symbol *locsym = (struct local_symbol *) symp; | |||
956 | ||||
957 | final_val = locsym->lsy_value; | |||
958 | if (local_symbol_resolved_p (locsym)((locsym)->u.lsy_frag == ((void*)0))) | |||
959 | return final_val; | |||
960 | ||||
961 | final_val += local_symbol_get_frag (locsym)((locsym)->u.lsy_frag)->fr_address / OCTETS_PER_BYTE(1<<0); | |||
962 | ||||
963 | if (finalize_syms) | |||
964 | { | |||
965 | locsym->lsy_value = final_val; | |||
966 | local_symbol_mark_resolved (locsym)((locsym)->u.lsy_frag = ((void*)0)); | |||
967 | } | |||
968 | ||||
969 | return final_val; | |||
970 | } | |||
971 | ||||
972 | if (symp->sy_resolved) | |||
973 | { | |||
974 | if (symp->sy_value.X_op == O_constant) | |||
975 | return (valueT) symp->sy_value.X_add_number; | |||
976 | else | |||
977 | return 0; | |||
978 | } | |||
979 | ||||
980 | resolved = 0; | |||
981 | final_seg = S_GET_SEGMENT (symp); | |||
982 | ||||
983 | if (symp->sy_resolving) | |||
984 | { | |||
985 | if (finalize_syms) | |||
986 | as_bad (_("symbol definition loop encountered at `%s'")("symbol definition loop encountered at `%s'"), | |||
987 | S_GET_NAME (symp)); | |||
988 | final_val = 0; | |||
989 | resolved = 1; | |||
990 | } | |||
991 | else | |||
992 | { | |||
993 | symbolS *add_symbol, *op_symbol; | |||
994 | offsetT left, right; | |||
995 | segT seg_left, seg_right; | |||
996 | operatorT op; | |||
997 | int move_seg_ok; | |||
998 | ||||
999 | symp->sy_resolving = 1; | |||
1000 | ||||
1001 | /* Help out with CSE. */ | |||
1002 | add_symbol = symp->sy_value.X_add_symbol; | |||
1003 | op_symbol = symp->sy_value.X_op_symbol; | |||
1004 | final_val = symp->sy_value.X_add_number; | |||
1005 | op = symp->sy_value.X_op; | |||
1006 | ||||
1007 | switch (op) | |||
1008 | { | |||
1009 | default: | |||
1010 | BAD_CASE (op){ as_fatal (("Case value %ld unexpected at line %d of file \"%s\"\n" ), (long) op, 1010, "/usr/src/gnu/usr.bin/binutils-2.17/gas/symbols.c" ); }; | |||
1011 | break; | |||
1012 | ||||
1013 | case O_absent: | |||
1014 | final_val = 0; | |||
1015 | /* Fall through. */ | |||
1016 | ||||
1017 | case O_constant: | |||
1018 | final_val += symp->sy_frag->fr_address / OCTETS_PER_BYTE(1<<0); | |||
1019 | if (final_seg == expr_section) | |||
1020 | final_seg = absolute_section((asection *) &bfd_abs_section); | |||
1021 | resolved = 1; | |||
1022 | break; | |||
1023 | ||||
1024 | case O_symbol: | |||
1025 | case O_symbol_rva: | |||
1026 | left = resolve_symbol_value (add_symbol); | |||
1027 | seg_left = S_GET_SEGMENT (add_symbol); | |||
1028 | if (finalize_syms) | |||
1029 | symp->sy_value.X_op_symbol = NULL((void*)0); | |||
1030 | ||||
1031 | do_symbol: | |||
1032 | if (S_IS_WEAKREFR (symp)) | |||
1033 | { | |||
1034 | assert (final_val == 0)((void) ((final_val == 0) ? 0 : (as_assert ("/usr/src/gnu/usr.bin/binutils-2.17/gas/symbols.c" , 1034, __PRETTY_FUNCTION__), 0))); | |||
1035 | if (S_IS_WEAKREFR (add_symbol)) | |||
1036 | { | |||
1037 | assert (add_symbol->sy_value.X_op == O_symbol((void) ((add_symbol->sy_value.X_op == O_symbol && add_symbol->sy_value.X_add_number == 0) ? 0 : (as_assert ( "/usr/src/gnu/usr.bin/binutils-2.17/gas/symbols.c", 1038, __PRETTY_FUNCTION__ ), 0))) | |||
1038 | && add_symbol->sy_value.X_add_number == 0)((void) ((add_symbol->sy_value.X_op == O_symbol && add_symbol->sy_value.X_add_number == 0) ? 0 : (as_assert ( "/usr/src/gnu/usr.bin/binutils-2.17/gas/symbols.c", 1038, __PRETTY_FUNCTION__ ), 0))); | |||
1039 | add_symbol = add_symbol->sy_value.X_add_symbol; | |||
1040 | assert (! S_IS_WEAKREFR (add_symbol))((void) ((! S_IS_WEAKREFR (add_symbol)) ? 0 : (as_assert ("/usr/src/gnu/usr.bin/binutils-2.17/gas/symbols.c" , 1040, __PRETTY_FUNCTION__), 0))); | |||
1041 | symp->sy_value.X_add_symbol = add_symbol; | |||
1042 | } | |||
1043 | } | |||
1044 | ||||
1045 | if (symp->sy_mri_common) | |||
1046 | { | |||
1047 | /* This is a symbol inside an MRI common section. The | |||
1048 | relocation routines are going to handle it specially. | |||
1049 | Don't change the value. */ | |||
1050 | resolved = symbol_resolved_p (add_symbol); | |||
1051 | break; | |||
1052 | } | |||
1053 | ||||
1054 | if (finalize_syms && final_val == 0) | |||
1055 | { | |||
1056 | if (LOCAL_SYMBOL_CHECK (add_symbol)(add_symbol->bsym == ((void*)0) ? ((((struct local_symbol * ) add_symbol)->lsy_section == reg_section) ? (add_symbol = (((struct local_symbol *) add_symbol)->u.lsy_sym), 0) : 1 ) : 0)) | |||
1057 | add_symbol = local_symbol_convert ((struct local_symbol *) | |||
1058 | add_symbol); | |||
1059 | copy_symbol_attributes (symp, add_symbol); | |||
1060 | } | |||
1061 | ||||
1062 | /* If we have equated this symbol to an undefined or common | |||
1063 | symbol, keep X_op set to O_symbol, and don't change | |||
1064 | X_add_number. This permits the routine which writes out | |||
1065 | relocation to detect this case, and convert the | |||
1066 | relocation to be against the symbol to which this symbol | |||
1067 | is equated. */ | |||
1068 | if (! S_IS_DEFINED (add_symbol) | |||
1069 | #if defined (OBJ_COFF) && defined (TE_PE) | |||
1070 | || S_IS_WEAK (add_symbol) | |||
1071 | #endif | |||
1072 | || S_IS_COMMON (add_symbol)) | |||
1073 | { | |||
1074 | if (finalize_syms) | |||
1075 | { | |||
1076 | symp->sy_value.X_op = O_symbol; | |||
1077 | symp->sy_value.X_add_symbol = add_symbol; | |||
1078 | symp->sy_value.X_add_number = final_val; | |||
1079 | /* Use X_op_symbol as a flag. */ | |||
1080 | symp->sy_value.X_op_symbol = add_symbol; | |||
1081 | final_seg = seg_left; | |||
1082 | } | |||
1083 | final_val = 0; | |||
1084 | resolved = symbol_resolved_p (add_symbol); | |||
1085 | symp->sy_resolving = 0; | |||
1086 | goto exit_dont_set_value; | |||
1087 | } | |||
1088 | else if (finalize_syms && final_seg == expr_section | |||
1089 | && seg_left != expr_section) | |||
1090 | { | |||
1091 | /* If the symbol is an expression symbol, do similarly | |||
1092 | as for undefined and common syms above. Handles | |||
1093 | "sym +/- expr" where "expr" cannot be evaluated | |||
1094 | immediately, and we want relocations to be against | |||
1095 | "sym", eg. because it is weak. */ | |||
1096 | symp->sy_value.X_op = O_symbol; | |||
1097 | symp->sy_value.X_add_symbol = add_symbol; | |||
1098 | symp->sy_value.X_add_number = final_val; | |||
1099 | symp->sy_value.X_op_symbol = add_symbol; | |||
1100 | final_seg = seg_left; | |||
1101 | final_val += symp->sy_frag->fr_address + left; | |||
1102 | resolved = symbol_resolved_p (add_symbol); | |||
1103 | symp->sy_resolving = 0; | |||
1104 | goto exit_dont_set_value; | |||
1105 | } | |||
1106 | else | |||
1107 | { | |||
1108 | final_val += symp->sy_frag->fr_address + left; | |||
1109 | if (final_seg == expr_section || final_seg == undefined_section((asection *) &bfd_und_section)) | |||
1110 | final_seg = seg_left; | |||
1111 | } | |||
1112 | ||||
1113 | resolved = symbol_resolved_p (add_symbol); | |||
1114 | if (S_IS_WEAKREFR (symp)) | |||
1115 | goto exit_dont_set_value; | |||
1116 | break; | |||
1117 | ||||
1118 | case O_uminus: | |||
1119 | case O_bit_not: | |||
1120 | case O_logical_not: | |||
1121 | left = resolve_symbol_value (add_symbol); | |||
1122 | seg_left = S_GET_SEGMENT (add_symbol); | |||
1123 | ||||
1124 | /* By reducing these to the relevant dyadic operator, we get | |||
1125 | !S -> S == 0 permitted on anything, | |||
1126 | -S -> 0 - S only permitted on absolute | |||
1127 | ~S -> S ^ ~0 only permitted on absolute */ | |||
1128 | if (op != O_logical_not && seg_left != absolute_section((asection *) &bfd_abs_section) | |||
1129 | && finalize_syms) | |||
1130 | report_op_error (symp, add_symbol, NULL((void*)0)); | |||
1131 | ||||
1132 | if (final_seg == expr_section || final_seg == undefined_section((asection *) &bfd_und_section)) | |||
1133 | final_seg = absolute_section((asection *) &bfd_abs_section); | |||
1134 | ||||
1135 | if (op == O_uminus) | |||
1136 | left = -left; | |||
1137 | else if (op == O_logical_not) | |||
1138 | left = !left; | |||
1139 | else | |||
1140 | left = ~left; | |||
1141 | ||||
1142 | final_val += left + symp->sy_frag->fr_address; | |||
1143 | ||||
1144 | resolved = symbol_resolved_p (add_symbol); | |||
1145 | break; | |||
1146 | ||||
1147 | case O_multiply: | |||
1148 | case O_divide: | |||
1149 | case O_modulus: | |||
1150 | case O_left_shift: | |||
1151 | case O_right_shift: | |||
1152 | case O_bit_inclusive_or: | |||
1153 | case O_bit_or_not: | |||
1154 | case O_bit_exclusive_or: | |||
1155 | case O_bit_and: | |||
1156 | case O_add: | |||
1157 | case O_subtract: | |||
1158 | case O_eq: | |||
1159 | case O_ne: | |||
1160 | case O_lt: | |||
1161 | case O_le: | |||
1162 | case O_ge: | |||
1163 | case O_gt: | |||
1164 | case O_logical_and: | |||
1165 | case O_logical_or: | |||
1166 | left = resolve_symbol_value (add_symbol); | |||
1167 | right = resolve_symbol_value (op_symbol); | |||
1168 | seg_left = S_GET_SEGMENT (add_symbol); | |||
1169 | seg_right = S_GET_SEGMENT (op_symbol); | |||
1170 | ||||
1171 | /* Simplify addition or subtraction of a constant by folding the | |||
1172 | constant into X_add_number. */ | |||
1173 | if (op == O_add) | |||
1174 | { | |||
1175 | if (seg_right == absolute_section((asection *) &bfd_abs_section)) | |||
1176 | { | |||
1177 | final_val += right; | |||
1178 | goto do_symbol; | |||
1179 | } | |||
1180 | else if (seg_left == absolute_section((asection *) &bfd_abs_section)) | |||
1181 | { | |||
1182 | final_val += left; | |||
1183 | add_symbol = op_symbol; | |||
1184 | left = right; | |||
1185 | seg_left = seg_right; | |||
1186 | goto do_symbol; | |||
1187 | } | |||
1188 | } | |||
1189 | else if (op == O_subtract) | |||
1190 | { | |||
1191 | if (seg_right == absolute_section((asection *) &bfd_abs_section)) | |||
1192 | { | |||
1193 | final_val -= right; | |||
1194 | goto do_symbol; | |||
1195 | } | |||
1196 | } | |||
1197 | ||||
1198 | move_seg_ok = 1; | |||
1199 | /* Equality and non-equality tests are permitted on anything. | |||
1200 | Subtraction, and other comparison operators are permitted if | |||
1201 | both operands are in the same section. Otherwise, both | |||
1202 | operands must be absolute. We already handled the case of | |||
1203 | addition or subtraction of a constant above. This will | |||
1204 | probably need to be changed for an object file format which | |||
1205 | supports arbitrary expressions, such as IEEE-695. */ | |||
1206 | if (!(seg_left == absolute_section((asection *) &bfd_abs_section) | |||
1207 | && seg_right == absolute_section((asection *) &bfd_abs_section)) | |||
1208 | && !(op == O_eq || op == O_ne) | |||
1209 | && !((op == O_subtract | |||
1210 | || op == O_lt || op == O_le || op == O_ge || op == O_gt) | |||
1211 | && seg_left == seg_right | |||
1212 | && (seg_left != undefined_section((asection *) &bfd_und_section) | |||
1213 | || add_symbol == op_symbol))) | |||
1214 | { | |||
1215 | /* Don't emit messages unless we're finalizing the symbol value, | |||
1216 | otherwise we may get the same message multiple times. */ | |||
1217 | if (finalize_syms) | |||
1218 | report_op_error (symp, add_symbol, op_symbol); | |||
1219 | /* However do not move the symbol into the absolute section | |||
1220 | if it cannot currently be resolved - this would confuse | |||
1221 | other parts of the assembler into believing that the | |||
1222 | expression had been evaluated to zero. */ | |||
1223 | else | |||
1224 | move_seg_ok = 0; | |||
1225 | } | |||
1226 | ||||
1227 | if (move_seg_ok | |||
1228 | && (final_seg == expr_section || final_seg == undefined_section((asection *) &bfd_und_section))) | |||
1229 | final_seg = absolute_section((asection *) &bfd_abs_section); | |||
1230 | ||||
1231 | /* Check for division by zero. */ | |||
1232 | if ((op == O_divide || op == O_modulus) && right == 0) | |||
1233 | { | |||
1234 | /* If seg_right is not absolute_section, then we've | |||
1235 | already issued a warning about using a bad symbol. */ | |||
1236 | if (seg_right == absolute_section((asection *) &bfd_abs_section) && finalize_syms) | |||
1237 | { | |||
1238 | char *file; | |||
1239 | unsigned int line; | |||
1240 | ||||
1241 | if (expr_symbol_where (symp, &file, &line)) | |||
1242 | as_bad_where (file, line, _("division by zero")("division by zero")); | |||
1243 | else | |||
1244 | as_bad (_("division by zero when setting `%s'")("division by zero when setting `%s'"), | |||
1245 | S_GET_NAME (symp)); | |||
1246 | } | |||
1247 | ||||
1248 | right = 1; | |||
1249 | } | |||
1250 | ||||
1251 | switch (symp->sy_value.X_op) | |||
1252 | { | |||
1253 | case O_multiply: left *= right; break; | |||
1254 | case O_divide: left /= right; break; | |||
1255 | case O_modulus: left %= right; break; | |||
1256 | case O_left_shift: left <<= right; break; | |||
1257 | case O_right_shift: left >>= right; break; | |||
1258 | case O_bit_inclusive_or: left |= right; break; | |||
1259 | case O_bit_or_not: left |= ~right; break; | |||
1260 | case O_bit_exclusive_or: left ^= right; break; | |||
1261 | case O_bit_and: left &= right; break; | |||
1262 | case O_add: left += right; break; | |||
1263 | case O_subtract: left -= right; break; | |||
1264 | case O_eq: | |||
1265 | case O_ne: | |||
1266 | left = (left == right && seg_left == seg_right | |||
1267 | && (seg_left != undefined_section((asection *) &bfd_und_section) | |||
1268 | || add_symbol == op_symbol) | |||
1269 | ? ~ (offsetT) 0 : 0); | |||
1270 | if (symp->sy_value.X_op == O_ne) | |||
1271 | left = ~left; | |||
1272 | break; | |||
1273 | case O_lt: left = left < right ? ~ (offsetT) 0 : 0; break; | |||
1274 | case O_le: left = left <= right ? ~ (offsetT) 0 : 0; break; | |||
1275 | case O_ge: left = left >= right ? ~ (offsetT) 0 : 0; break; | |||
1276 | case O_gt: left = left > right ? ~ (offsetT) 0 : 0; break; | |||
1277 | case O_logical_and: left = left && right; break; | |||
1278 | case O_logical_or: left = left || right; break; | |||
1279 | default: abort ()as_abort ("/usr/src/gnu/usr.bin/binutils-2.17/gas/symbols.c", 1279, __PRETTY_FUNCTION__); | |||
1280 | } | |||
1281 | ||||
1282 | final_val += symp->sy_frag->fr_address + left; | |||
1283 | if (final_seg == expr_section || final_seg == undefined_section((asection *) &bfd_und_section)) | |||
1284 | { | |||
1285 | if (seg_left == undefined_section((asection *) &bfd_und_section) | |||
1286 | || seg_right == undefined_section((asection *) &bfd_und_section)) | |||
1287 | final_seg = undefined_section((asection *) &bfd_und_section); | |||
1288 | else if (seg_left == absolute_section((asection *) &bfd_abs_section)) | |||
1289 | final_seg = seg_right; | |||
1290 | else | |||
1291 | final_seg = seg_left; | |||
1292 | } | |||
1293 | resolved = (symbol_resolved_p (add_symbol) | |||
1294 | && symbol_resolved_p (op_symbol)); | |||
1295 | break; | |||
1296 | ||||
1297 | case O_register: | |||
1298 | case O_big: | |||
1299 | case O_illegal: | |||
1300 | /* Give an error (below) if not in expr_section. We don't | |||
1301 | want to worry about expr_section symbols, because they | |||
1302 | are fictional (they are created as part of expression | |||
1303 | resolution), and any problems may not actually mean | |||
1304 | anything. */ | |||
1305 | break; | |||
1306 | } | |||
1307 | ||||
1308 | symp->sy_resolving = 0; | |||
1309 | } | |||
1310 | ||||
1311 | if (finalize_syms) | |||
1312 | S_SET_VALUE (symp, final_val); | |||
1313 | ||||
1314 | exit_dont_set_value: | |||
1315 | /* Always set the segment, even if not finalizing the value. | |||
1316 | The segment is used to determine whether a symbol is defined. */ | |||
1317 | S_SET_SEGMENT (symp, final_seg); | |||
1318 | ||||
1319 | /* Don't worry if we can't resolve an expr_section symbol. */ | |||
1320 | if (finalize_syms) | |||
1321 | { | |||
1322 | if (resolved) | |||
1323 | symp->sy_resolved = 1; | |||
1324 | else if (S_GET_SEGMENT (symp) != expr_section) | |||
1325 | { | |||
1326 | as_bad (_("can't resolve value for symbol `%s'")("can't resolve value for symbol `%s'"), | |||
1327 | S_GET_NAME (symp)); | |||
1328 | symp->sy_resolved = 1; | |||
1329 | } | |||
1330 | } | |||
1331 | ||||
1332 | return final_val; | |||
1333 | } | |||
1334 | ||||
1335 | static void resolve_local_symbol (const char *, PTRvoid *); | |||
1336 | ||||
1337 | /* A static function passed to hash_traverse. */ | |||
1338 | ||||
1339 | static void | |||
1340 | resolve_local_symbol (const char *key ATTRIBUTE_UNUSED__attribute__ ((__unused__)), PTRvoid * value) | |||
1341 | { | |||
1342 | if (value != NULL((void*)0)) | |||
1343 | resolve_symbol_value (value); | |||
1344 | } | |||
1345 | ||||
1346 | /* Resolve all local symbols. */ | |||
1347 | ||||
1348 | void | |||
1349 | resolve_local_symbol_values (void) | |||
1350 | { | |||
1351 | hash_traverse (local_hash, resolve_local_symbol); | |||
1352 | } | |||
1353 | ||||
1354 | /* Obtain the current value of a symbol without changing any | |||
1355 | sub-expressions used. */ | |||
1356 | ||||
1357 | int | |||
1358 | snapshot_symbol (symbolS **symbolPP, valueT *valueP, segT *segP, fragS **fragPP) | |||
1359 | { | |||
1360 | symbolS *symbolP = *symbolPP; | |||
1361 | ||||
1362 | if (LOCAL_SYMBOL_CHECK (symbolP)(symbolP->bsym == ((void*)0) ? ((((struct local_symbol *) symbolP )->lsy_section == reg_section) ? (symbolP = (((struct local_symbol *) symbolP)->u.lsy_sym), 0) : 1) : 0)) | |||
1363 | { | |||
1364 | struct local_symbol *locsym = (struct local_symbol *) symbolP; | |||
1365 | ||||
1366 | *valueP = locsym->lsy_value; | |||
1367 | *segP = locsym->lsy_section; | |||
1368 | *fragPP = local_symbol_get_frag (locsym)((locsym)->u.lsy_frag); | |||
1369 | } | |||
1370 | else | |||
1371 | { | |||
1372 | expressionS expr = symbolP->sy_value; | |||
1373 | ||||
1374 | if (!symbolP->sy_resolved && expr.X_op != O_illegal) | |||
1375 | { | |||
1376 | int resolved; | |||
1377 | ||||
1378 | if (symbolP->sy_resolving) | |||
1379 | return 0; | |||
1380 | symbolP->sy_resolving = 1; | |||
1381 | resolved = resolve_expression (&expr); | |||
1382 | symbolP->sy_resolving = 0; | |||
1383 | if (!resolved) | |||
1384 | return 0; | |||
1385 | ||||
1386 | switch (expr.X_op) | |||
1387 | { | |||
1388 | case O_constant: | |||
1389 | case O_register: | |||
1390 | if (!symbol_equated_p (symbolP)) | |||
1391 | break; | |||
1392 | /* Fall thru. */ | |||
1393 | case O_symbol: | |||
1394 | case O_symbol_rva: | |||
1395 | symbolP = expr.X_add_symbol; | |||
1396 | break; | |||
1397 | default: | |||
1398 | return 0; | |||
1399 | } | |||
1400 | } | |||
1401 | ||||
1402 | /* Never change a defined symbol. */ | |||
1403 | if (symbolP->bsym->section == undefined_section((asection *) &bfd_und_section) | |||
1404 | || symbolP->bsym->section == expr_section) | |||
1405 | *symbolPP = symbolP; | |||
1406 | *valueP = expr.X_add_number; | |||
1407 | *segP = symbolP->bsym->section; | |||
1408 | *fragPP = symbolP->sy_frag; | |||
1409 | ||||
1410 | if (*segP == expr_section) | |||
1411 | switch (expr.X_op) | |||
1412 | { | |||
1413 | case O_constant: *segP = absolute_section((asection *) &bfd_abs_section); break; | |||
1414 | case O_register: *segP = reg_section; break; | |||
1415 | default: break; | |||
1416 | } | |||
1417 | } | |||
1418 | ||||
1419 | return 1; | |||
1420 | } | |||
1421 | ||||
1422 | /* Dollar labels look like a number followed by a dollar sign. Eg, "42$". | |||
1423 | They are *really* local. That is, they go out of scope whenever we see a | |||
1424 | label that isn't local. Also, like fb labels, there can be multiple | |||
1425 | instances of a dollar label. Therefor, we name encode each instance with | |||
1426 | the instance number, keep a list of defined symbols separate from the real | |||
1427 | symbol table, and we treat these buggers as a sparse array. */ | |||
1428 | ||||
1429 | static long *dollar_labels; | |||
1430 | static long *dollar_label_instances; | |||
1431 | static char *dollar_label_defines; | |||
1432 | static unsigned long dollar_label_count; | |||
1433 | static unsigned long dollar_label_max; | |||
1434 | ||||
1435 | int | |||
1436 | dollar_label_defined (long label) | |||
1437 | { | |||
1438 | long *i; | |||
1439 | ||||
1440 | know ((dollar_labels != NULL) || (dollar_label_count == 0)); | |||
1441 | ||||
1442 | for (i = dollar_labels; i < dollar_labels + dollar_label_count; ++i) | |||
1443 | if (*i == label) | |||
1444 | return dollar_label_defines[i - dollar_labels]; | |||
1445 | ||||
1446 | /* If we get here, label isn't defined. */ | |||
1447 | return 0; | |||
1448 | } | |||
1449 | ||||
1450 | static long | |||
1451 | dollar_label_instance (long label) | |||
1452 | { | |||
1453 | long *i; | |||
1454 | ||||
1455 | know ((dollar_labels != NULL) || (dollar_label_count == 0)); | |||
1456 | ||||
1457 | for (i = dollar_labels; i < dollar_labels + dollar_label_count; ++i) | |||
1458 | if (*i == label) | |||
1459 | return (dollar_label_instances[i - dollar_labels]); | |||
1460 | ||||
1461 | /* If we get here, we haven't seen the label before. | |||
1462 | Therefore its instance count is zero. */ | |||
1463 | return 0; | |||
1464 | } | |||
1465 | ||||
1466 | void | |||
1467 | dollar_label_clear (void) | |||
1468 | { | |||
1469 | memset (dollar_label_defines, '\0', (unsigned int) dollar_label_count); | |||
1470 | } | |||
1471 | ||||
1472 | #define DOLLAR_LABEL_BUMP_BY10 10 | |||
1473 | ||||
1474 | void | |||
1475 | define_dollar_label (long label) | |||
1476 | { | |||
1477 | long *i; | |||
1478 | ||||
1479 | for (i = dollar_labels; i < dollar_labels + dollar_label_count; ++i) | |||
1480 | if (*i == label) | |||
1481 | { | |||
1482 | ++dollar_label_instances[i - dollar_labels]; | |||
1483 | dollar_label_defines[i - dollar_labels] = 1; | |||
1484 | return; | |||
1485 | } | |||
1486 | ||||
1487 | /* If we get to here, we don't have label listed yet. */ | |||
1488 | ||||
1489 | if (dollar_labels == NULL((void*)0)) | |||
1490 | { | |||
1491 | dollar_labels = (long *) xmalloc (DOLLAR_LABEL_BUMP_BY10 * sizeof (long)); | |||
1492 | dollar_label_instances = (long *) xmalloc (DOLLAR_LABEL_BUMP_BY10 * sizeof (long)); | |||
1493 | dollar_label_defines = xmalloc (DOLLAR_LABEL_BUMP_BY10); | |||
1494 | dollar_label_max = DOLLAR_LABEL_BUMP_BY10; | |||
1495 | dollar_label_count = 0; | |||
1496 | } | |||
1497 | else if (dollar_label_count == dollar_label_max) | |||
1498 | { | |||
1499 | dollar_label_max += DOLLAR_LABEL_BUMP_BY10; | |||
1500 | dollar_labels = (long *) xrealloc ((char *) dollar_labels, | |||
1501 | dollar_label_max * sizeof (long)); | |||
1502 | dollar_label_instances = (long *) xrealloc ((char *) dollar_label_instances, | |||
1503 | dollar_label_max * sizeof (long)); | |||
1504 | dollar_label_defines = xrealloc (dollar_label_defines, dollar_label_max); | |||
1505 | } /* if we needed to grow */ | |||
1506 | ||||
1507 | dollar_labels[dollar_label_count] = label; | |||
1508 | dollar_label_instances[dollar_label_count] = 1; | |||
1509 | dollar_label_defines[dollar_label_count] = 1; | |||
1510 | ++dollar_label_count; | |||
1511 | } | |||
1512 | ||||
1513 | /* Caller must copy returned name: we re-use the area for the next name. | |||
1514 | ||||
1515 | The mth occurence of label n: is turned into the symbol "Ln^Am" | |||
1516 | where n is the label number and m is the instance number. "L" makes | |||
1517 | it a label discarded unless debugging and "^A"('\1') ensures no | |||
1518 | ordinary symbol SHOULD get the same name as a local label | |||
1519 | symbol. The first "4:" is "L4^A1" - the m numbers begin at 1. | |||
1520 | ||||
1521 | fb labels get the same treatment, except that ^B is used in place | |||
1522 | of ^A. */ | |||
1523 | ||||
1524 | char * /* Return local label name. */ | |||
1525 | dollar_label_name (register long n, /* we just saw "n$:" : n a number. */ | |||
1526 | register int augend /* 0 for current instance, 1 for new instance. */) | |||
1527 | { | |||
1528 | long i; | |||
1529 | /* Returned to caller, then copied. Used for created names ("4f"). */ | |||
1530 | static char symbol_name_build[24]; | |||
1531 | register char *p; | |||
1532 | register char *q; | |||
1533 | char symbol_name_temporary[20]; /* Build up a number, BACKWARDS. */ | |||
1534 | ||||
1535 | know (n >= 0); | |||
1536 | know (augend == 0 || augend == 1); | |||
1537 | p = symbol_name_build; | |||
1538 | #ifdef LOCAL_LABEL_PREFIX | |||
1539 | *p++ = LOCAL_LABEL_PREFIX; | |||
1540 | #endif | |||
1541 | *p++ = 'L'; | |||
1542 | ||||
1543 | /* Next code just does sprintf( {}, "%d", n); */ | |||
1544 | /* Label number. */ | |||
1545 | q = symbol_name_temporary; | |||
1546 | for (*q++ = 0, i = n; i; ++q) | |||
1547 | { | |||
1548 | *q = i % 10 + '0'; | |||
1549 | i /= 10; | |||
1550 | } | |||
1551 | while ((*p = *--q) != '\0') | |||
1552 | ++p; | |||
1553 | ||||
1554 | *p++ = DOLLAR_LABEL_CHAR'\001'; /* ^A */ | |||
1555 | ||||
1556 | /* Instance number. */ | |||
1557 | q = symbol_name_temporary; | |||
1558 | for (*q++ = 0, i = dollar_label_instance (n) + augend; i; ++q) | |||
1559 | { | |||
1560 | *q = i % 10 + '0'; | |||
1561 | i /= 10; | |||
1562 | } | |||
1563 | while ((*p++ = *--q) != '\0') | |||
1564 | ; | |||
1565 | ||||
1566 | /* The label, as a '\0' ended string, starts at symbol_name_build. */ | |||
1567 | return symbol_name_build; | |||
1568 | } | |||
1569 | ||||
1570 | /* Somebody else's idea of local labels. They are made by "n:" where n | |||
1571 | is any decimal digit. Refer to them with | |||
1572 | "nb" for previous (backward) n: | |||
1573 | or "nf" for next (forward) n:. | |||
1574 | ||||
1575 | We do a little better and let n be any number, not just a single digit, but | |||
1576 | since the other guy's assembler only does ten, we treat the first ten | |||
1577 | specially. | |||
1578 | ||||
1579 | Like someone else's assembler, we have one set of local label counters for | |||
1580 | entire assembly, not one set per (sub)segment like in most assemblers. This | |||
1581 | implies that one can refer to a label in another segment, and indeed some | |||
1582 | crufty compilers have done just that. | |||
1583 | ||||
1584 | Since there could be a LOT of these things, treat them as a sparse | |||
1585 | array. */ | |||
1586 | ||||
1587 | #define FB_LABEL_SPECIAL(10) (10) | |||
1588 | ||||
1589 | static long fb_low_counter[FB_LABEL_SPECIAL(10)]; | |||
1590 | static long *fb_labels; | |||
1591 | static long *fb_label_instances; | |||
1592 | static long fb_label_count; | |||
1593 | static long fb_label_max; | |||
1594 | ||||
1595 | /* This must be more than FB_LABEL_SPECIAL. */ | |||
1596 | #define FB_LABEL_BUMP_BY((10) + 6) (FB_LABEL_SPECIAL(10) + 6) | |||
1597 | ||||
1598 | static void | |||
1599 | fb_label_init (void) | |||
1600 | { | |||
1601 | memset ((void *) fb_low_counter, '\0', sizeof (fb_low_counter)); | |||
1602 | } | |||
1603 | ||||
1604 | /* Add one to the instance number of this fb label. */ | |||
1605 | ||||
1606 | void | |||
1607 | fb_label_instance_inc (long label) | |||
1608 | { | |||
1609 | long *i; | |||
1610 | ||||
1611 | if (label < FB_LABEL_SPECIAL(10)) | |||
1612 | { | |||
1613 | ++fb_low_counter[label]; | |||
1614 | return; | |||
1615 | } | |||
1616 | ||||
1617 | if (fb_labels != NULL((void*)0)) | |||
1618 | { | |||
1619 | for (i = fb_labels + FB_LABEL_SPECIAL(10); | |||
1620 | i < fb_labels + fb_label_count; ++i) | |||
1621 | { | |||
1622 | if (*i == label) | |||
1623 | { | |||
1624 | ++fb_label_instances[i - fb_labels]; | |||
1625 | return; | |||
1626 | } /* if we find it */ | |||
1627 | } /* for each existing label */ | |||
1628 | } | |||
1629 | ||||
1630 | /* If we get to here, we don't have label listed yet. */ | |||
1631 | ||||
1632 | if (fb_labels == NULL((void*)0)) | |||
1633 | { | |||
1634 | fb_labels = (long *) xmalloc (FB_LABEL_BUMP_BY((10) + 6) * sizeof (long)); | |||
1635 | fb_label_instances = (long *) xmalloc (FB_LABEL_BUMP_BY((10) + 6) * sizeof (long)); | |||
1636 | fb_label_max = FB_LABEL_BUMP_BY((10) + 6); | |||
1637 | fb_label_count = FB_LABEL_SPECIAL(10); | |||
1638 | ||||
1639 | } | |||
1640 | else if (fb_label_count == fb_label_max) | |||
1641 | { | |||
1642 | fb_label_max += FB_LABEL_BUMP_BY((10) + 6); | |||
1643 | fb_labels = (long *) xrealloc ((char *) fb_labels, | |||
1644 | fb_label_max * sizeof (long)); | |||
1645 | fb_label_instances = (long *) xrealloc ((char *) fb_label_instances, | |||
1646 | fb_label_max * sizeof (long)); | |||
1647 | } /* if we needed to grow */ | |||
1648 | ||||
1649 | fb_labels[fb_label_count] = label; | |||
1650 | fb_label_instances[fb_label_count] = 1; | |||
1651 | ++fb_label_count; | |||
1652 | } | |||
1653 | ||||
1654 | static long | |||
1655 | fb_label_instance (long label) | |||
1656 | { | |||
1657 | long *i; | |||
1658 | ||||
1659 | if (label < FB_LABEL_SPECIAL(10)) | |||
1660 | { | |||
1661 | return (fb_low_counter[label]); | |||
1662 | } | |||
1663 | ||||
1664 | if (fb_labels != NULL((void*)0)) | |||
1665 | { | |||
1666 | for (i = fb_labels + FB_LABEL_SPECIAL(10); | |||
1667 | i < fb_labels + fb_label_count; ++i) | |||
1668 | { | |||
1669 | if (*i == label) | |||
1670 | { | |||
1671 | return (fb_label_instances[i - fb_labels]); | |||
1672 | } /* if we find it */ | |||
1673 | } /* for each existing label */ | |||
1674 | } | |||
1675 | ||||
1676 | /* We didn't find the label, so this must be a reference to the | |||
1677 | first instance. */ | |||
1678 | return 0; | |||
1679 | } | |||
1680 | ||||
1681 | /* Caller must copy returned name: we re-use the area for the next name. | |||
1682 | ||||
1683 | The mth occurence of label n: is turned into the symbol "Ln^Bm" | |||
1684 | where n is the label number and m is the instance number. "L" makes | |||
1685 | it a label discarded unless debugging and "^B"('\2') ensures no | |||
1686 | ordinary symbol SHOULD get the same name as a local label | |||
1687 | symbol. The first "4:" is "L4^B1" - the m numbers begin at 1. | |||
1688 | ||||
1689 | dollar labels get the same treatment, except that ^A is used in | |||
1690 | place of ^B. */ | |||
1691 | ||||
1692 | char * /* Return local label name. */ | |||
1693 | fb_label_name (long n, /* We just saw "n:", "nf" or "nb" : n a number. */ | |||
1694 | long augend /* 0 for nb, 1 for n:, nf. */) | |||
1695 | { | |||
1696 | long i; | |||
1697 | /* Returned to caller, then copied. Used for created names ("4f"). */ | |||
1698 | static char symbol_name_build[24]; | |||
1699 | register char *p; | |||
1700 | register char *q; | |||
1701 | char symbol_name_temporary[20]; /* Build up a number, BACKWARDS. */ | |||
1702 | ||||
1703 | know (n >= 0); | |||
1704 | #ifdef TC_MMIX | |||
1705 | know ((unsigned long) augend <= 2 /* See mmix_fb_label. */); | |||
1706 | #else | |||
1707 | know ((unsigned long) augend <= 1); | |||
1708 | #endif | |||
1709 | p = symbol_name_build; | |||
1710 | #ifdef LOCAL_LABEL_PREFIX | |||
1711 | *p++ = LOCAL_LABEL_PREFIX; | |||
1712 | #endif | |||
1713 | *p++ = 'L'; | |||
1714 | ||||
1715 | /* Next code just does sprintf( {}, "%d", n); */ | |||
1716 | /* Label number. */ | |||
1717 | q = symbol_name_temporary; | |||
1718 | for (*q++ = 0, i = n; i; ++q) | |||
1719 | { | |||
1720 | *q = i % 10 + '0'; | |||
1721 | i /= 10; | |||
1722 | } | |||
1723 | while ((*p = *--q) != '\0') | |||
1724 | ++p; | |||
1725 | ||||
1726 | *p++ = LOCAL_LABEL_CHAR'\002'; /* ^B */ | |||
1727 | ||||
1728 | /* Instance number. */ | |||
1729 | q = symbol_name_temporary; | |||
1730 | for (*q++ = 0, i = fb_label_instance (n) + augend; i; ++q) | |||
1731 | { | |||
1732 | *q = i % 10 + '0'; | |||
1733 | i /= 10; | |||
1734 | } | |||
1735 | while ((*p++ = *--q) != '\0') | |||
1736 | ; | |||
1737 | ||||
1738 | /* The label, as a '\0' ended string, starts at symbol_name_build. */ | |||
1739 | return (symbol_name_build); | |||
1740 | } | |||
1741 | ||||
1742 | /* Decode name that may have been generated by foo_label_name() above. | |||
1743 | If the name wasn't generated by foo_label_name(), then return it | |||
1744 | unaltered. This is used for error messages. */ | |||
1745 | ||||
1746 | char * | |||
1747 | decode_local_label_name (char *s) | |||
1748 | { | |||
1749 | char *p; | |||
1750 | char *symbol_decode; | |||
1751 | int label_number; | |||
1752 | int instance_number; | |||
1753 | char *type; | |||
1754 | const char *message_format; | |||
1755 | int index = 0; | |||
1756 | ||||
1757 | #ifdef LOCAL_LABEL_PREFIX | |||
1758 | if (s[index] == LOCAL_LABEL_PREFIX) | |||
1759 | ++index; | |||
1760 | #endif | |||
1761 | ||||
1762 | if (s[index] != 'L') | |||
1763 | return s; | |||
1764 | ||||
1765 | for (label_number = 0, p = s + index + 1; ISDIGIT (*p)(_sch_istable[(*p) & 0xff] & (unsigned short)(_sch_isdigit )); ++p) | |||
1766 | label_number = (10 * label_number) + *p - '0'; | |||
1767 | ||||
1768 | if (*p == DOLLAR_LABEL_CHAR'\001') | |||
1769 | type = "dollar"; | |||
1770 | else if (*p == LOCAL_LABEL_CHAR'\002') | |||
1771 | type = "fb"; | |||
1772 | else | |||
1773 | return s; | |||
1774 | ||||
1775 | for (instance_number = 0, p++; ISDIGIT (*p)(_sch_istable[(*p) & 0xff] & (unsigned short)(_sch_isdigit )); ++p) | |||
1776 | instance_number = (10 * instance_number) + *p - '0'; | |||
1777 | ||||
1778 | message_format = _("\"%d\" (instance number %d of a %s label)")("\"%d\" (instance number %d of a %s label)"); | |||
1779 | symbol_decode = obstack_alloc (¬es, strlen (message_format) + 30)__extension__ ({ struct obstack *__h = (¬es); __extension__ ({ struct obstack *__o = (__h); int __len = ((strlen (message_format ) + 30)); if (__o->chunk_limit - __o->next_free < __len ) _obstack_newchunk (__o, __len); ((__o)->next_free += (__len )); (void) 0; }); __extension__ ({ struct obstack *__o1 = (__h ); void *value; value = (void *) __o1->object_base; if (__o1 ->next_free == value) __o1->maybe_empty_object = 1; __o1 ->next_free = (((((__o1->next_free) - (char *) 0)+__o1-> alignment_mask) & ~ (__o1->alignment_mask)) + (char *) 0); if (__o1->next_free - (char *)__o1->chunk > __o1 ->chunk_limit - (char *)__o1->chunk) __o1->next_free = __o1->chunk_limit; __o1->object_base = __o1->next_free ; value; }); }); | |||
1780 | sprintf (symbol_decode, message_format, label_number, instance_number, type); | |||
1781 | ||||
1782 | return symbol_decode; | |||
1783 | } | |||
1784 | ||||
1785 | /* Get the value of a symbol. */ | |||
1786 | ||||
1787 | valueT | |||
1788 | S_GET_VALUE (symbolS *s) | |||
1789 | { | |||
1790 | if (LOCAL_SYMBOL_CHECK (s)(s->bsym == ((void*)0) ? ((((struct local_symbol *) s)-> lsy_section == reg_section) ? (s = (((struct local_symbol *) s )->u.lsy_sym), 0) : 1) : 0)) | |||
1791 | return resolve_symbol_value (s); | |||
1792 | ||||
1793 | if (!s->sy_resolved) | |||
1794 | { | |||
1795 | valueT val = resolve_symbol_value (s); | |||
1796 | if (!finalize_syms) | |||
1797 | return val; | |||
1798 | } | |||
1799 | if (S_IS_WEAKREFR (s)) | |||
1800 | return S_GET_VALUE (s->sy_value.X_add_symbol); | |||
1801 | ||||
1802 | if (s->sy_value.X_op != O_constant) | |||
1803 | { | |||
1804 | if (! s->sy_resolved | |||
1805 | || s->sy_value.X_op != O_symbol | |||
1806 | || (S_IS_DEFINED (s) && ! S_IS_COMMON (s))) | |||
1807 | as_bad (_("attempt to get value of unresolved symbol `%s'")("attempt to get value of unresolved symbol `%s'"), | |||
1808 | S_GET_NAME (s)); | |||
1809 | } | |||
1810 | return (valueT) s->sy_value.X_add_number; | |||
1811 | } | |||
1812 | ||||
1813 | /* Set the value of a symbol. */ | |||
1814 | ||||
1815 | void | |||
1816 | S_SET_VALUE (symbolS *s, valueT val) | |||
1817 | { | |||
1818 | if (LOCAL_SYMBOL_CHECK (s)(s->bsym == ((void*)0) ? ((((struct local_symbol *) s)-> lsy_section == reg_section) ? (s = (((struct local_symbol *) s )->u.lsy_sym), 0) : 1) : 0)) | |||
1819 | { | |||
1820 | ((struct local_symbol *) s)->lsy_value = val; | |||
1821 | return; | |||
1822 | } | |||
1823 | ||||
1824 | s->sy_value.X_op = O_constant; | |||
1825 | s->sy_value.X_add_number = (offsetT) val; | |||
1826 | s->sy_value.X_unsigned = 0; | |||
1827 | S_CLEAR_WEAKREFR (s); | |||
1828 | } | |||
1829 | ||||
1830 | void | |||
1831 | copy_symbol_attributes (symbolS *dest, symbolS *src) | |||
1832 | { | |||
1833 | if (LOCAL_SYMBOL_CHECK (dest)(dest->bsym == ((void*)0) ? ((((struct local_symbol *) dest )->lsy_section == reg_section) ? (dest = (((struct local_symbol *) dest)->u.lsy_sym), 0) : 1) : 0)) | |||
1834 | dest = local_symbol_convert ((struct local_symbol *) dest); | |||
1835 | if (LOCAL_SYMBOL_CHECK (src)(src->bsym == ((void*)0) ? ((((struct local_symbol *) src) ->lsy_section == reg_section) ? (src = (((struct local_symbol *) src)->u.lsy_sym), 0) : 1) : 0)) | |||
1836 | src = local_symbol_convert ((struct local_symbol *) src); | |||
1837 | ||||
1838 | /* In an expression, transfer the settings of these flags. | |||
1839 | The user can override later, of course. */ | |||
1840 | #define COPIED_SYMFLAGS(0x10 | 0x10000) (BSF_FUNCTION0x10 | BSF_OBJECT0x10000) | |||
1841 | dest->bsym->flags |= src->bsym->flags & COPIED_SYMFLAGS(0x10 | 0x10000); | |||
1842 | ||||
1843 | #ifdef OBJ_COPY_SYMBOL_ATTRIBUTES | |||
1844 | OBJ_COPY_SYMBOL_ATTRIBUTES (dest, src)(elf_copy_symbol_attributes (dest, src)); | |||
1845 | #endif | |||
1846 | } | |||
1847 | ||||
1848 | int | |||
1849 | S_IS_FUNCTION (symbolS *s) | |||
1850 | { | |||
1851 | flagword flags; | |||
1852 | ||||
1853 | if (LOCAL_SYMBOL_CHECK (s)(s->bsym == ((void*)0) ? ((((struct local_symbol *) s)-> lsy_section == reg_section) ? (s = (((struct local_symbol *) s )->u.lsy_sym), 0) : 1) : 0)) | |||
1854 | return 0; | |||
1855 | ||||
1856 | flags = s->bsym->flags; | |||
1857 | ||||
1858 | return (flags & BSF_FUNCTION0x10) != 0; | |||
1859 | } | |||
1860 | ||||
1861 | int | |||
1862 | S_IS_EXTERNAL (symbolS *s) | |||
1863 | { | |||
1864 | flagword flags; | |||
1865 | ||||
1866 | if (LOCAL_SYMBOL_CHECK (s)(s->bsym == ((void*)0) ? ((((struct local_symbol *) s)-> lsy_section == reg_section) ? (s = (((struct local_symbol *) s )->u.lsy_sym), 0) : 1) : 0)) | |||
1867 | return 0; | |||
1868 | ||||
1869 | flags = s->bsym->flags; | |||
1870 | ||||
1871 | /* Sanity check. */ | |||
1872 | if ((flags & BSF_LOCAL0x01) && (flags & BSF_GLOBAL0x02)) | |||
1873 | abort ()as_abort ("/usr/src/gnu/usr.bin/binutils-2.17/gas/symbols.c", 1873, __PRETTY_FUNCTION__); | |||
1874 | ||||
1875 | return (flags & BSF_GLOBAL0x02) != 0; | |||
1876 | } | |||
1877 | ||||
1878 | int | |||
1879 | S_IS_WEAK (symbolS *s) | |||
1880 | { | |||
1881 | if (LOCAL_SYMBOL_CHECK (s)(s->bsym == ((void*)0) ? ((((struct local_symbol *) s)-> lsy_section == reg_section) ? (s = (((struct local_symbol *) s )->u.lsy_sym), 0) : 1) : 0)) | |||
1882 | return 0; | |||
1883 | /* Conceptually, a weakrefr is weak if the referenced symbol is. We | |||
1884 | could probably handle a WEAKREFR as always weak though. E.g., if | |||
1885 | the referenced symbol has lost its weak status, there's no reason | |||
1886 | to keep handling the weakrefr as if it was weak. */ | |||
1887 | if (S_IS_WEAKREFR (s)) | |||
1888 | return S_IS_WEAK (s->sy_value.X_add_symbol); | |||
1889 | return (s->bsym->flags & BSF_WEAK0x80) != 0; | |||
1890 | } | |||
1891 | ||||
1892 | int | |||
1893 | S_IS_WEAKREFR (symbolS *s) | |||
1894 | { | |||
1895 | if (LOCAL_SYMBOL_CHECK (s)(s->bsym == ((void*)0) ? ((((struct local_symbol *) s)-> lsy_section == reg_section) ? (s = (((struct local_symbol *) s )->u.lsy_sym), 0) : 1) : 0)) | |||
1896 | return 0; | |||
1897 | return s->sy_weakrefr != 0; | |||
1898 | } | |||
1899 | ||||
1900 | int | |||
1901 | S_IS_WEAKREFD (symbolS *s) | |||
1902 | { | |||
1903 | if (LOCAL_SYMBOL_CHECK (s)(s->bsym == ((void*)0) ? ((((struct local_symbol *) s)-> lsy_section == reg_section) ? (s = (((struct local_symbol *) s )->u.lsy_sym), 0) : 1) : 0)) | |||
1904 | return 0; | |||
1905 | return s->sy_weakrefd != 0; | |||
1906 | } | |||
1907 | ||||
1908 | int | |||
1909 | S_IS_COMMON (symbolS *s) | |||
1910 | { | |||
1911 | if (LOCAL_SYMBOL_CHECK (s)(s->bsym == ((void*)0) ? ((((struct local_symbol *) s)-> lsy_section == reg_section) ? (s = (((struct local_symbol *) s )->u.lsy_sym), 0) : 1) : 0)) | |||
1912 | return 0; | |||
1913 | return bfd_is_com_section (s->bsym->section)(((s->bsym->section)->flags & 0x1000) != 0); | |||
1914 | } | |||
1915 | ||||
1916 | int | |||
1917 | S_IS_DEFINED (symbolS *s) | |||
1918 | { | |||
1919 | if (LOCAL_SYMBOL_CHECK (s)(s->bsym == ((void*)0) ? ((((struct local_symbol *) s)-> lsy_section == reg_section) ? (s = (((struct local_symbol *) s )->u.lsy_sym), 0) : 1) : 0)) | |||
1920 | return ((struct local_symbol *) s)->lsy_section != undefined_section((asection *) &bfd_und_section); | |||
1921 | return s->bsym->section != undefined_section((asection *) &bfd_und_section); | |||
1922 | } | |||
1923 | ||||
1924 | ||||
1925 | #ifndef EXTERN_FORCE_RELOC(bfd_target_elf_flavour == bfd_target_elf_flavour) | |||
1926 | #define EXTERN_FORCE_RELOC(bfd_target_elf_flavour == bfd_target_elf_flavour) IS_ELF1 | |||
1927 | #endif | |||
1928 | ||||
1929 | /* Return true for symbols that should not be reduced to section | |||
1930 | symbols or eliminated from expressions, because they may be | |||
1931 | overridden by the linker. */ | |||
1932 | int | |||
1933 | S_FORCE_RELOC (symbolS *s, int strict) | |||
1934 | { | |||
1935 | if (LOCAL_SYMBOL_CHECK (s)(s->bsym == ((void*)0) ? ((((struct local_symbol *) s)-> lsy_section == reg_section) ? (s = (((struct local_symbol *) s )->u.lsy_sym), 0) : 1) : 0)) | |||
1936 | return ((struct local_symbol *) s)->lsy_section == undefined_section((asection *) &bfd_und_section); | |||
1937 | ||||
1938 | return ((strict | |||
1939 | && ((s->bsym->flags & BSF_WEAK0x80) != 0 | |||
1940 | || (EXTERN_FORCE_RELOC(bfd_target_elf_flavour == bfd_target_elf_flavour) | |||
1941 | && (s->bsym->flags & BSF_GLOBAL0x02) != 0))) | |||
1942 | || s->bsym->section == undefined_section((asection *) &bfd_und_section) | |||
1943 | || bfd_is_com_section (s->bsym->section)(((s->bsym->section)->flags & 0x1000) != 0)); | |||
1944 | } | |||
1945 | ||||
1946 | int | |||
1947 | S_IS_DEBUG (symbolS *s) | |||
1948 | { | |||
1949 | if (LOCAL_SYMBOL_CHECK (s)(s->bsym == ((void*)0) ? ((((struct local_symbol *) s)-> lsy_section == reg_section) ? (s = (((struct local_symbol *) s )->u.lsy_sym), 0) : 1) : 0)) | |||
1950 | return 0; | |||
1951 | if (s->bsym->flags & BSF_DEBUGGING0x08) | |||
1952 | return 1; | |||
1953 | return 0; | |||
1954 | } | |||
1955 | ||||
1956 | int | |||
1957 | S_IS_LOCAL (symbolS *s) | |||
1958 | { | |||
1959 | flagword flags; | |||
1960 | const char *name; | |||
1961 | ||||
1962 | if (LOCAL_SYMBOL_CHECK (s)(s->bsym == ((void*)0) ? ((((struct local_symbol *) s)-> lsy_section == reg_section) ? (s = (((struct local_symbol *) s )->u.lsy_sym), 0) : 1) : 0)) | |||
1963 | return 1; | |||
1964 | ||||
1965 | flags = s->bsym->flags; | |||
1966 | ||||
1967 | /* Sanity check. */ | |||
1968 | if ((flags & BSF_LOCAL0x01) && (flags & BSF_GLOBAL0x02)) | |||
1969 | abort ()as_abort ("/usr/src/gnu/usr.bin/binutils-2.17/gas/symbols.c", 1969, __PRETTY_FUNCTION__); | |||
1970 | ||||
1971 | if (bfd_get_section (s->bsym)((s->bsym)->section) == reg_section) | |||
1972 | return 1; | |||
1973 | ||||
1974 | if (flag_strip_local_absolute | |||
1975 | /* Keep BSF_FILE symbols in order to allow debuggers to identify | |||
1976 | the source file even when the object file is stripped. */ | |||
1977 | && (flags & (BSF_GLOBAL0x02 | BSF_FILE0x4000)) == 0 | |||
1978 | && bfd_get_section (s->bsym)((s->bsym)->section) == absolute_section((asection *) &bfd_abs_section)) | |||
1979 | return 1; | |||
1980 | ||||
1981 | name = S_GET_NAME (s); | |||
1982 | return (name != NULL((void*)0) | |||
1983 | && ! S_IS_DEBUG (s) | |||
1984 | && (strchr (name, DOLLAR_LABEL_CHAR'\001') | |||
1985 | || strchr (name, LOCAL_LABEL_CHAR'\002') | |||
1986 | || (! flag_keep_locals | |||
1987 | && (bfd_is_local_label (stdoutput, s->bsym) | |||
1988 | || (flag_mri | |||
1989 | && name[0] == '?' | |||
1990 | && name[1] == '?'))))); | |||
1991 | } | |||
1992 | ||||
1993 | int | |||
1994 | S_IS_STABD (symbolS *s) | |||
1995 | { | |||
1996 | return S_GET_NAME (s) == 0; | |||
1997 | } | |||
1998 | ||||
1999 | int | |||
2000 | S_IS_VOLATILE (const symbolS *s) | |||
2001 | { | |||
2002 | if (LOCAL_SYMBOL_CHECK (s)(s->bsym == ((void*)0) ? ((((struct local_symbol *) s)-> lsy_section == reg_section) ? (s = (((struct local_symbol *) s )->u.lsy_sym), 0) : 1) : 0)) | |||
2003 | return 0; | |||
2004 | return s->sy_volatile; | |||
2005 | } | |||
2006 | ||||
2007 | int | |||
2008 | S_IS_FORWARD_REF (const symbolS *s) | |||
2009 | { | |||
2010 | if (LOCAL_SYMBOL_CHECK (s)(s->bsym == ((void*)0) ? ((((struct local_symbol *) s)-> lsy_section == reg_section) ? (s = (((struct local_symbol *) s )->u.lsy_sym), 0) : 1) : 0)) | |||
2011 | return 0; | |||
2012 | return s->sy_forward_ref; | |||
2013 | } | |||
2014 | ||||
2015 | const char * | |||
2016 | S_GET_NAME (symbolS *s) | |||
2017 | { | |||
2018 | if (LOCAL_SYMBOL_CHECK (s)(s->bsym == ((void*)0) ? ((((struct local_symbol *) s)-> lsy_section == reg_section) ? (s = (((struct local_symbol *) s )->u.lsy_sym), 0) : 1) : 0)) | |||
2019 | return ((struct local_symbol *) s)->lsy_name; | |||
2020 | return s->bsym->name; | |||
2021 | } | |||
2022 | ||||
2023 | segT | |||
2024 | S_GET_SEGMENT (symbolS *s) | |||
2025 | { | |||
2026 | if (LOCAL_SYMBOL_CHECK (s)(s->bsym == ((void*)0) ? ((((struct local_symbol *) s)-> lsy_section == reg_section) ? (s = (((struct local_symbol *) s )->u.lsy_sym), 0) : 1) : 0)) | |||
2027 | return ((struct local_symbol *) s)->lsy_section; | |||
2028 | return s->bsym->section; | |||
2029 | } | |||
2030 | ||||
2031 | void | |||
2032 | S_SET_SEGMENT (symbolS *s, segT seg) | |||
2033 | { | |||
2034 | /* Don't reassign section symbols. The direct reason is to prevent seg | |||
2035 | faults assigning back to const global symbols such as *ABS*, but it | |||
2036 | shouldn't happen anyway. */ | |||
2037 | ||||
2038 | if (LOCAL_SYMBOL_CHECK (s)(s->bsym == ((void*)0) ? ((((struct local_symbol *) s)-> lsy_section == reg_section) ? (s = (((struct local_symbol *) s )->u.lsy_sym), 0) : 1) : 0)) | |||
2039 | { | |||
2040 | if (seg == reg_section) | |||
2041 | s = local_symbol_convert ((struct local_symbol *) s); | |||
2042 | else | |||
2043 | { | |||
2044 | ((struct local_symbol *) s)->lsy_section = seg; | |||
2045 | return; | |||
2046 | } | |||
2047 | } | |||
2048 | ||||
2049 | if (s->bsym->flags & BSF_SECTION_SYM0x100) | |||
2050 | { | |||
2051 | if (s->bsym->section != seg) | |||
2052 | abort ()as_abort ("/usr/src/gnu/usr.bin/binutils-2.17/gas/symbols.c", 2052, __PRETTY_FUNCTION__); | |||
2053 | } | |||
2054 | else | |||
2055 | s->bsym->section = seg; | |||
2056 | } | |||
2057 | ||||
2058 | void | |||
2059 | S_SET_EXTERNAL (symbolS *s) | |||
2060 | { | |||
2061 | if (LOCAL_SYMBOL_CHECK (s)(s->bsym == ((void*)0) ? ((((struct local_symbol *) s)-> lsy_section == reg_section) ? (s = (((struct local_symbol *) s )->u.lsy_sym), 0) : 1) : 0)) | |||
2062 | s = local_symbol_convert ((struct local_symbol *) s); | |||
2063 | if ((s->bsym->flags & BSF_WEAK0x80) != 0) | |||
2064 | { | |||
2065 | /* Let .weak override .global. */ | |||
2066 | return; | |||
2067 | } | |||
2068 | if (s->bsym->flags & BSF_SECTION_SYM0x100) | |||
2069 | { | |||
2070 | char * file; | |||
2071 | unsigned int line; | |||
2072 | ||||
2073 | /* Do not reassign section symbols. */ | |||
2074 | as_where (& file, & line); | |||
2075 | as_warn_where (file, line, | |||
2076 | _("section symbols are already global")("section symbols are already global")); | |||
2077 | return; | |||
2078 | } | |||
2079 | s->bsym->flags |= BSF_GLOBAL0x02; | |||
2080 | s->bsym->flags &= ~(BSF_LOCAL0x01 | BSF_WEAK0x80); | |||
2081 | ||||
2082 | #ifdef USE_UNIQUE | |||
2083 | if (! an_external_name && S_GET_NAME(s)[0] != '.') | |||
2084 | an_external_name = S_GET_NAME (s); | |||
2085 | #endif | |||
2086 | } | |||
2087 | ||||
2088 | void | |||
2089 | S_CLEAR_EXTERNAL (symbolS *s) | |||
2090 | { | |||
2091 | if (LOCAL_SYMBOL_CHECK (s)(s->bsym == ((void*)0) ? ((((struct local_symbol *) s)-> lsy_section == reg_section) ? (s = (((struct local_symbol *) s )->u.lsy_sym), 0) : 1) : 0)) | |||
2092 | return; | |||
2093 | if ((s->bsym->flags & BSF_WEAK0x80) != 0) | |||
2094 | { | |||
2095 | /* Let .weak override. */ | |||
2096 | return; | |||
2097 | } | |||
2098 | s->bsym->flags |= BSF_LOCAL0x01; | |||
2099 | s->bsym->flags &= ~(BSF_GLOBAL0x02 | BSF_WEAK0x80); | |||
2100 | } | |||
2101 | ||||
2102 | void | |||
2103 | S_SET_WEAK (symbolS *s) | |||
2104 | { | |||
2105 | if (LOCAL_SYMBOL_CHECK (s)(s->bsym == ((void*)0) ? ((((struct local_symbol *) s)-> lsy_section == reg_section) ? (s = (((struct local_symbol *) s )->u.lsy_sym), 0) : 1) : 0)) | |||
2106 | s = local_symbol_convert ((struct local_symbol *) s); | |||
2107 | #ifdef obj_set_weak_hook | |||
2108 | obj_set_weak_hook (s); | |||
2109 | #endif | |||
2110 | s->bsym->flags |= BSF_WEAK0x80; | |||
2111 | s->bsym->flags &= ~(BSF_GLOBAL0x02 | BSF_LOCAL0x01); | |||
2112 | } | |||
2113 | ||||
2114 | void | |||
2115 | S_SET_WEAKREFR (symbolS *s) | |||
2116 | { | |||
2117 | if (LOCAL_SYMBOL_CHECK (s)(s->bsym == ((void*)0) ? ((((struct local_symbol *) s)-> lsy_section == reg_section) ? (s = (((struct local_symbol *) s )->u.lsy_sym), 0) : 1) : 0)) | |||
2118 | s = local_symbol_convert ((struct local_symbol *) s); | |||
2119 | s->sy_weakrefr = 1; | |||
2120 | /* If the alias was already used, make sure we mark the target as | |||
2121 | used as well, otherwise it might be dropped from the symbol | |||
2122 | table. This may have unintended side effects if the alias is | |||
2123 | later redirected to another symbol, such as keeping the unused | |||
2124 | previous target in the symbol table. Since it will be weak, it's | |||
2125 | not a big deal. */ | |||
2126 | if (s->sy_used) | |||
2127 | symbol_mark_used (s->sy_value.X_add_symbol); | |||
2128 | } | |||
2129 | ||||
2130 | void | |||
2131 | S_CLEAR_WEAKREFR (symbolS *s) | |||
2132 | { | |||
2133 | if (LOCAL_SYMBOL_CHECK (s)(s->bsym == ((void*)0) ? ((((struct local_symbol *) s)-> lsy_section == reg_section) ? (s = (((struct local_symbol *) s )->u.lsy_sym), 0) : 1) : 0)) | |||
2134 | return; | |||
2135 | s->sy_weakrefr = 0; | |||
2136 | } | |||
2137 | ||||
2138 | void | |||
2139 | S_SET_WEAKREFD (symbolS *s) | |||
2140 | { | |||
2141 | if (LOCAL_SYMBOL_CHECK (s)(s->bsym == ((void*)0) ? ((((struct local_symbol *) s)-> lsy_section == reg_section) ? (s = (((struct local_symbol *) s )->u.lsy_sym), 0) : 1) : 0)) | |||
2142 | s = local_symbol_convert ((struct local_symbol *) s); | |||
2143 | s->sy_weakrefd = 1; | |||
2144 | S_SET_WEAK (s); | |||
2145 | } | |||
2146 | ||||
2147 | void | |||
2148 | S_CLEAR_WEAKREFD (symbolS *s) | |||
2149 | { | |||
2150 | if (LOCAL_SYMBOL_CHECK (s)(s->bsym == ((void*)0) ? ((((struct local_symbol *) s)-> lsy_section == reg_section) ? (s = (((struct local_symbol *) s )->u.lsy_sym), 0) : 1) : 0)) | |||
2151 | return; | |||
2152 | if (s->sy_weakrefd) | |||
2153 | { | |||
2154 | s->sy_weakrefd = 0; | |||
2155 | /* If a weakref target symbol is weak, then it was never | |||
2156 | referenced directly before, not even in a .global directive, | |||
2157 | so decay it to local. If it remains undefined, it will be | |||
2158 | later turned into a global, like any other undefined | |||
2159 | symbol. */ | |||
2160 | if (s->bsym->flags & BSF_WEAK0x80) | |||
2161 | { | |||
2162 | #ifdef obj_clear_weak_hook | |||
2163 | obj_clear_weak_hook (s); | |||
2164 | #endif | |||
2165 | s->bsym->flags &= ~BSF_WEAK0x80; | |||
2166 | s->bsym->flags |= BSF_LOCAL0x01; | |||
2167 | } | |||
2168 | } | |||
2169 | } | |||
2170 | ||||
2171 | void | |||
2172 | S_SET_THREAD_LOCAL (symbolS *s) | |||
2173 | { | |||
2174 | if (LOCAL_SYMBOL_CHECK (s)(s->bsym == ((void*)0) ? ((((struct local_symbol *) s)-> lsy_section == reg_section) ? (s = (((struct local_symbol *) s )->u.lsy_sym), 0) : 1) : 0)) | |||
2175 | s = local_symbol_convert ((struct local_symbol *) s); | |||
2176 | if (bfd_is_com_section (s->bsym->section)(((s->bsym->section)->flags & 0x1000) != 0) | |||
2177 | && (s->bsym->flags & BSF_THREAD_LOCAL0x40000) != 0) | |||
2178 | return; | |||
2179 | s->bsym->flags |= BSF_THREAD_LOCAL0x40000; | |||
2180 | if ((s->bsym->flags & BSF_FUNCTION0x10) != 0) | |||
2181 | as_bad (_("Accessing function `%s' as thread-local object")("Accessing function `%s' as thread-local object"), | |||
2182 | S_GET_NAME (s)); | |||
2183 | else if (! bfd_is_und_section (s->bsym->section)((s->bsym->section) == ((asection *) &bfd_und_section )) | |||
2184 | && (s->bsym->section->flags & SEC_THREAD_LOCAL0x400) == 0) | |||
2185 | as_bad (_("Accessing `%s' as thread-local object")("Accessing `%s' as thread-local object"), | |||
2186 | S_GET_NAME (s)); | |||
2187 | } | |||
2188 | ||||
2189 | void | |||
2190 | S_SET_NAME (symbolS *s, const char *name) | |||
2191 | { | |||
2192 | if (LOCAL_SYMBOL_CHECK (s)(s->bsym == ((void*)0) ? ((((struct local_symbol *) s)-> lsy_section == reg_section) ? (s = (((struct local_symbol *) s )->u.lsy_sym), 0) : 1) : 0)) | |||
2193 | { | |||
2194 | ((struct local_symbol *) s)->lsy_name = name; | |||
2195 | return; | |||
2196 | } | |||
2197 | s->bsym->name = name; | |||
2198 | } | |||
2199 | ||||
2200 | void | |||
2201 | S_SET_VOLATILE (symbolS *s) | |||
2202 | { | |||
2203 | if (LOCAL_SYMBOL_CHECK (s)(s->bsym == ((void*)0) ? ((((struct local_symbol *) s)-> lsy_section == reg_section) ? (s = (((struct local_symbol *) s )->u.lsy_sym), 0) : 1) : 0)) | |||
2204 | s = local_symbol_convert ((struct local_symbol *) s); | |||
2205 | s->sy_volatile = 1; | |||
2206 | } | |||
2207 | ||||
2208 | void | |||
2209 | S_CLEAR_VOLATILE (symbolS *s) | |||
2210 | { | |||
2211 | if (!LOCAL_SYMBOL_CHECK (s)(s->bsym == ((void*)0) ? ((((struct local_symbol *) s)-> lsy_section == reg_section) ? (s = (((struct local_symbol *) s )->u.lsy_sym), 0) : 1) : 0)) | |||
2212 | s->sy_volatile = 0; | |||
2213 | } | |||
2214 | ||||
2215 | void | |||
2216 | S_SET_FORWARD_REF (symbolS *s) | |||
2217 | { | |||
2218 | if (LOCAL_SYMBOL_CHECK (s)(s->bsym == ((void*)0) ? ((((struct local_symbol *) s)-> lsy_section == reg_section) ? (s = (((struct local_symbol *) s )->u.lsy_sym), 0) : 1) : 0)) | |||
2219 | s = local_symbol_convert ((struct local_symbol *) s); | |||
2220 | s->sy_forward_ref = 1; | |||
2221 | } | |||
2222 | ||||
2223 | /* Return the previous symbol in a chain. */ | |||
2224 | ||||
2225 | symbolS * | |||
2226 | symbol_previous (symbolS *s) | |||
2227 | { | |||
2228 | if (LOCAL_SYMBOL_CHECK (s)(s->bsym == ((void*)0) ? ((((struct local_symbol *) s)-> lsy_section == reg_section) ? (s = (((struct local_symbol *) s )->u.lsy_sym), 0) : 1) : 0)) | |||
2229 | abort ()as_abort ("/usr/src/gnu/usr.bin/binutils-2.17/gas/symbols.c", 2229, __PRETTY_FUNCTION__); | |||
2230 | return s->sy_previous; | |||
2231 | } | |||
2232 | ||||
2233 | /* Return the next symbol in a chain. */ | |||
2234 | ||||
2235 | symbolS * | |||
2236 | symbol_next (symbolS *s) | |||
2237 | { | |||
2238 | if (LOCAL_SYMBOL_CHECK (s)(s->bsym == ((void*)0) ? ((((struct local_symbol *) s)-> lsy_section == reg_section) ? (s = (((struct local_symbol *) s )->u.lsy_sym), 0) : 1) : 0)) | |||
2239 | abort ()as_abort ("/usr/src/gnu/usr.bin/binutils-2.17/gas/symbols.c", 2239, __PRETTY_FUNCTION__); | |||
2240 | return s->sy_next; | |||
2241 | } | |||
2242 | ||||
2243 | /* Return a pointer to the value of a symbol as an expression. */ | |||
2244 | ||||
2245 | expressionS * | |||
2246 | symbol_get_value_expression (symbolS *s) | |||
2247 | { | |||
2248 | if (LOCAL_SYMBOL_CHECK (s)(s->bsym == ((void*)0) ? ((((struct local_symbol *) s)-> lsy_section == reg_section) ? (s = (((struct local_symbol *) s )->u.lsy_sym), 0) : 1) : 0)) | |||
2249 | s = local_symbol_convert ((struct local_symbol *) s); | |||
2250 | return &s->sy_value; | |||
2251 | } | |||
2252 | ||||
2253 | /* Set the value of a symbol to an expression. */ | |||
2254 | ||||
2255 | void | |||
2256 | symbol_set_value_expression (symbolS *s, const expressionS *exp) | |||
2257 | { | |||
2258 | if (LOCAL_SYMBOL_CHECK (s)(s->bsym == ((void*)0) ? ((((struct local_symbol *) s)-> lsy_section == reg_section) ? (s = (((struct local_symbol *) s )->u.lsy_sym), 0) : 1) : 0)) | |||
2259 | s = local_symbol_convert ((struct local_symbol *) s); | |||
2260 | s->sy_value = *exp; | |||
2261 | S_CLEAR_WEAKREFR (s); | |||
2262 | } | |||
2263 | ||||
2264 | /* Return a pointer to the X_add_number component of a symbol. */ | |||
2265 | ||||
2266 | offsetT * | |||
2267 | symbol_X_add_number (symbolS *s) | |||
2268 | { | |||
2269 | if (LOCAL_SYMBOL_CHECK (s)(s->bsym == ((void*)0) ? ((((struct local_symbol *) s)-> lsy_section == reg_section) ? (s = (((struct local_symbol *) s )->u.lsy_sym), 0) : 1) : 0)) | |||
2270 | return (offsetT *) &((struct local_symbol *) s)->lsy_value; | |||
2271 | ||||
2272 | return &s->sy_value.X_add_number; | |||
2273 | } | |||
2274 | ||||
2275 | /* Set the value of SYM to the current position in the current segment. */ | |||
2276 | ||||
2277 | void | |||
2278 | symbol_set_value_now (symbolS *sym) | |||
2279 | { | |||
2280 | S_SET_SEGMENT (sym, now_seg); | |||
2281 | S_SET_VALUE (sym, frag_now_fix ()); | |||
2282 | symbol_set_frag (sym, frag_now); | |||
2283 | } | |||
2284 | ||||
2285 | /* Set the frag of a symbol. */ | |||
2286 | ||||
2287 | void | |||
2288 | symbol_set_frag (symbolS *s, fragS *f) | |||
2289 | { | |||
2290 | if (LOCAL_SYMBOL_CHECK (s)(s->bsym == ((void*)0) ? ((((struct local_symbol *) s)-> lsy_section == reg_section) ? (s = (((struct local_symbol *) s )->u.lsy_sym), 0) : 1) : 0)) | |||
2291 | { | |||
2292 | local_symbol_set_frag ((struct local_symbol *) s, f)(((struct local_symbol *) s)->u.lsy_frag = (f)); | |||
2293 | return; | |||
2294 | } | |||
2295 | s->sy_frag = f; | |||
2296 | S_CLEAR_WEAKREFR (s); | |||
2297 | } | |||
2298 | ||||
2299 | /* Return the frag of a symbol. */ | |||
2300 | ||||
2301 | fragS * | |||
2302 | symbol_get_frag (symbolS *s) | |||
2303 | { | |||
2304 | if (LOCAL_SYMBOL_CHECK (s)(s->bsym == ((void*)0) ? ((((struct local_symbol *) s)-> lsy_section == reg_section) ? (s = (((struct local_symbol *) s )->u.lsy_sym), 0) : 1) : 0)) | |||
2305 | return local_symbol_get_frag ((struct local_symbol *) s)(((struct local_symbol *) s)->u.lsy_frag); | |||
2306 | return s->sy_frag; | |||
2307 | } | |||
2308 | ||||
2309 | /* Mark a symbol as having been used. */ | |||
2310 | ||||
2311 | void | |||
2312 | symbol_mark_used (symbolS *s) | |||
2313 | { | |||
2314 | if (LOCAL_SYMBOL_CHECK (s)(s->bsym == ((void*)0) ? ((((struct local_symbol *) s)-> lsy_section == reg_section) ? (s = (((struct local_symbol *) s )->u.lsy_sym), 0) : 1) : 0)) | |||
2315 | return; | |||
2316 | s->sy_used = 1; | |||
2317 | if (S_IS_WEAKREFR (s)) | |||
2318 | symbol_mark_used (s->sy_value.X_add_symbol); | |||
2319 | } | |||
2320 | ||||
2321 | /* Clear the mark of whether a symbol has been used. */ | |||
2322 | ||||
2323 | void | |||
2324 | symbol_clear_used (symbolS *s) | |||
2325 | { | |||
2326 | if (LOCAL_SYMBOL_CHECK (s)(s->bsym == ((void*)0) ? ((((struct local_symbol *) s)-> lsy_section == reg_section) ? (s = (((struct local_symbol *) s )->u.lsy_sym), 0) : 1) : 0)) | |||
2327 | s = local_symbol_convert ((struct local_symbol *) s); | |||
2328 | s->sy_used = 0; | |||
2329 | } | |||
2330 | ||||
2331 | /* Return whether a symbol has been used. */ | |||
2332 | ||||
2333 | int | |||
2334 | symbol_used_p (symbolS *s) | |||
2335 | { | |||
2336 | if (LOCAL_SYMBOL_CHECK (s)(s->bsym == ((void*)0) ? ((((struct local_symbol *) s)-> lsy_section == reg_section) ? (s = (((struct local_symbol *) s )->u.lsy_sym), 0) : 1) : 0)) | |||
2337 | return 1; | |||
2338 | return s->sy_used; | |||
2339 | } | |||
2340 | ||||
2341 | /* Mark a symbol as having been used in a reloc. */ | |||
2342 | ||||
2343 | void | |||
2344 | symbol_mark_used_in_reloc (symbolS *s) | |||
2345 | { | |||
2346 | if (LOCAL_SYMBOL_CHECK (s)(s->bsym == ((void*)0) ? ((((struct local_symbol *) s)-> lsy_section == reg_section) ? (s = (((struct local_symbol *) s )->u.lsy_sym), 0) : 1) : 0)) | |||
2347 | s = local_symbol_convert ((struct local_symbol *) s); | |||
2348 | s->sy_used_in_reloc = 1; | |||
2349 | } | |||
2350 | ||||
2351 | /* Clear the mark of whether a symbol has been used in a reloc. */ | |||
2352 | ||||
2353 | void | |||
2354 | symbol_clear_used_in_reloc (symbolS *s) | |||
2355 | { | |||
2356 | if (LOCAL_SYMBOL_CHECK (s)(s->bsym == ((void*)0) ? ((((struct local_symbol *) s)-> lsy_section == reg_section) ? (s = (((struct local_symbol *) s )->u.lsy_sym), 0) : 1) : 0)) | |||
2357 | return; | |||
2358 | s->sy_used_in_reloc = 0; | |||
2359 | } | |||
2360 | ||||
2361 | /* Return whether a symbol has been used in a reloc. */ | |||
2362 | ||||
2363 | int | |||
2364 | symbol_used_in_reloc_p (symbolS *s) | |||
2365 | { | |||
2366 | if (LOCAL_SYMBOL_CHECK (s)(s->bsym == ((void*)0) ? ((((struct local_symbol *) s)-> lsy_section == reg_section) ? (s = (((struct local_symbol *) s )->u.lsy_sym), 0) : 1) : 0)) | |||
2367 | return 0; | |||
2368 | return s->sy_used_in_reloc; | |||
2369 | } | |||
2370 | ||||
2371 | /* Mark a symbol as an MRI common symbol. */ | |||
2372 | ||||
2373 | void | |||
2374 | symbol_mark_mri_common (symbolS *s) | |||
2375 | { | |||
2376 | if (LOCAL_SYMBOL_CHECK (s)(s->bsym == ((void*)0) ? ((((struct local_symbol *) s)-> lsy_section == reg_section) ? (s = (((struct local_symbol *) s )->u.lsy_sym), 0) : 1) : 0)) | |||
2377 | s = local_symbol_convert ((struct local_symbol *) s); | |||
2378 | s->sy_mri_common = 1; | |||
2379 | } | |||
2380 | ||||
2381 | /* Clear the mark of whether a symbol is an MRI common symbol. */ | |||
2382 | ||||
2383 | void | |||
2384 | symbol_clear_mri_common (symbolS *s) | |||
2385 | { | |||
2386 | if (LOCAL_SYMBOL_CHECK (s)(s->bsym == ((void*)0) ? ((((struct local_symbol *) s)-> lsy_section == reg_section) ? (s = (((struct local_symbol *) s )->u.lsy_sym), 0) : 1) : 0)) | |||
2387 | return; | |||
2388 | s->sy_mri_common = 0; | |||
2389 | } | |||
2390 | ||||
2391 | /* Return whether a symbol is an MRI common symbol. */ | |||
2392 | ||||
2393 | int | |||
2394 | symbol_mri_common_p (symbolS *s) | |||
2395 | { | |||
2396 | if (LOCAL_SYMBOL_CHECK (s)(s->bsym == ((void*)0) ? ((((struct local_symbol *) s)-> lsy_section == reg_section) ? (s = (((struct local_symbol *) s )->u.lsy_sym), 0) : 1) : 0)) | |||
2397 | return 0; | |||
2398 | return s->sy_mri_common; | |||
2399 | } | |||
2400 | ||||
2401 | /* Mark a symbol as having been written. */ | |||
2402 | ||||
2403 | void | |||
2404 | symbol_mark_written (symbolS *s) | |||
2405 | { | |||
2406 | if (LOCAL_SYMBOL_CHECK (s)(s->bsym == ((void*)0) ? ((((struct local_symbol *) s)-> lsy_section == reg_section) ? (s = (((struct local_symbol *) s )->u.lsy_sym), 0) : 1) : 0)) | |||
2407 | return; | |||
2408 | s->written = 1; | |||
2409 | } | |||
2410 | ||||
2411 | /* Clear the mark of whether a symbol has been written. */ | |||
2412 | ||||
2413 | void | |||
2414 | symbol_clear_written (symbolS *s) | |||
2415 | { | |||
2416 | if (LOCAL_SYMBOL_CHECK (s)(s->bsym == ((void*)0) ? ((((struct local_symbol *) s)-> lsy_section == reg_section) ? (s = (((struct local_symbol *) s )->u.lsy_sym), 0) : 1) : 0)) | |||
2417 | return; | |||
2418 | s->written = 0; | |||
2419 | } | |||
2420 | ||||
2421 | /* Return whether a symbol has been written. */ | |||
2422 | ||||
2423 | int | |||
2424 | symbol_written_p (symbolS *s) | |||
2425 | { | |||
2426 | if (LOCAL_SYMBOL_CHECK (s)(s->bsym == ((void*)0) ? ((((struct local_symbol *) s)-> lsy_section == reg_section) ? (s = (((struct local_symbol *) s )->u.lsy_sym), 0) : 1) : 0)) | |||
2427 | return 0; | |||
2428 | return s->written; | |||
2429 | } | |||
2430 | ||||
2431 | /* Mark a symbol has having been resolved. */ | |||
2432 | ||||
2433 | void | |||
2434 | symbol_mark_resolved (symbolS *s) | |||
2435 | { | |||
2436 | if (LOCAL_SYMBOL_CHECK (s)(s->bsym == ((void*)0) ? ((((struct local_symbol *) s)-> lsy_section == reg_section) ? (s = (((struct local_symbol *) s )->u.lsy_sym), 0) : 1) : 0)) | |||
2437 | { | |||
2438 | local_symbol_mark_resolved ((struct local_symbol *) s)(((struct local_symbol *) s)->u.lsy_frag = ((void*)0)); | |||
2439 | return; | |||
2440 | } | |||
2441 | s->sy_resolved = 1; | |||
2442 | } | |||
2443 | ||||
2444 | /* Return whether a symbol has been resolved. */ | |||
2445 | ||||
2446 | int | |||
2447 | symbol_resolved_p (symbolS *s) | |||
2448 | { | |||
2449 | if (LOCAL_SYMBOL_CHECK (s)(s->bsym == ((void*)0) ? ((((struct local_symbol *) s)-> lsy_section == reg_section) ? (s = (((struct local_symbol *) s )->u.lsy_sym), 0) : 1) : 0)) | |||
2450 | return local_symbol_resolved_p ((struct local_symbol *) s)(((struct local_symbol *) s)->u.lsy_frag == ((void*)0)); | |||
2451 | return s->sy_resolved; | |||
2452 | } | |||
2453 | ||||
2454 | /* Return whether a symbol is a section symbol. */ | |||
2455 | ||||
2456 | int | |||
2457 | symbol_section_p (symbolS *s ATTRIBUTE_UNUSED__attribute__ ((__unused__))) | |||
2458 | { | |||
2459 | if (LOCAL_SYMBOL_CHECK (s)(s->bsym == ((void*)0) ? ((((struct local_symbol *) s)-> lsy_section == reg_section) ? (s = (((struct local_symbol *) s )->u.lsy_sym), 0) : 1) : 0)) | |||
2460 | return 0; | |||
2461 | return (s->bsym->flags & BSF_SECTION_SYM0x100) != 0; | |||
2462 | } | |||
2463 | ||||
2464 | /* Return whether a symbol is equated to another symbol. */ | |||
2465 | ||||
2466 | int | |||
2467 | symbol_equated_p (symbolS *s) | |||
2468 | { | |||
2469 | if (LOCAL_SYMBOL_CHECK (s)(s->bsym == ((void*)0) ? ((((struct local_symbol *) s)-> lsy_section == reg_section) ? (s = (((struct local_symbol *) s )->u.lsy_sym), 0) : 1) : 0)) | |||
2470 | return 0; | |||
2471 | return s->sy_value.X_op == O_symbol; | |||
2472 | } | |||
2473 | ||||
2474 | /* Return whether a symbol is equated to another symbol, and should be | |||
2475 | treated specially when writing out relocs. */ | |||
2476 | ||||
2477 | int | |||
2478 | symbol_equated_reloc_p (symbolS *s) | |||
2479 | { | |||
2480 | if (LOCAL_SYMBOL_CHECK (s)(s->bsym == ((void*)0) ? ((((struct local_symbol *) s)-> lsy_section == reg_section) ? (s = (((struct local_symbol *) s )->u.lsy_sym), 0) : 1) : 0)) | |||
2481 | return 0; | |||
2482 | /* X_op_symbol, normally not used for O_symbol, is set by | |||
2483 | resolve_symbol_value to flag expression syms that have been | |||
2484 | equated. */ | |||
2485 | return (s->sy_value.X_op == O_symbol | |||
2486 | #if defined (OBJ_COFF) && defined (TE_PE) | |||
2487 | && ! S_IS_WEAK (s) | |||
2488 | #endif | |||
2489 | && ((s->sy_resolved && s->sy_value.X_op_symbol != NULL((void*)0)) | |||
2490 | || ! S_IS_DEFINED (s) | |||
2491 | || S_IS_COMMON (s))); | |||
2492 | } | |||
2493 | ||||
2494 | /* Return whether a symbol has a constant value. */ | |||
2495 | ||||
2496 | int | |||
2497 | symbol_constant_p (symbolS *s) | |||
2498 | { | |||
2499 | if (LOCAL_SYMBOL_CHECK (s)(s->bsym == ((void*)0) ? ((((struct local_symbol *) s)-> lsy_section == reg_section) ? (s = (((struct local_symbol *) s )->u.lsy_sym), 0) : 1) : 0)) | |||
2500 | return 1; | |||
2501 | return s->sy_value.X_op == O_constant; | |||
2502 | } | |||
2503 | ||||
2504 | /* Return the BFD symbol for a symbol. */ | |||
2505 | ||||
2506 | asymbol * | |||
2507 | symbol_get_bfdsym (symbolS *s) | |||
2508 | { | |||
2509 | if (LOCAL_SYMBOL_CHECK (s)(s->bsym == ((void*)0) ? ((((struct local_symbol *) s)-> lsy_section == reg_section) ? (s = (((struct local_symbol *) s )->u.lsy_sym), 0) : 1) : 0)) | |||
2510 | s = local_symbol_convert ((struct local_symbol *) s); | |||
2511 | return s->bsym; | |||
2512 | } | |||
2513 | ||||
2514 | /* Set the BFD symbol for a symbol. */ | |||
2515 | ||||
2516 | void | |||
2517 | symbol_set_bfdsym (symbolS *s, asymbol *bsym) | |||
2518 | { | |||
2519 | if (LOCAL_SYMBOL_CHECK (s)(s->bsym == ((void*)0) ? ((((struct local_symbol *) s)-> lsy_section == reg_section) ? (s = (((struct local_symbol *) s )->u.lsy_sym), 0) : 1) : 0)) | |||
2520 | s = local_symbol_convert ((struct local_symbol *) s); | |||
2521 | /* Usually, it is harmless to reset a symbol to a BFD section | |||
2522 | symbol. For example, obj_elf_change_section sets the BFD symbol | |||
2523 | of an old symbol with the newly created section symbol. But when | |||
2524 | we have multiple sections with the same name, the newly created | |||
2525 | section may have the same name as an old section. We check if the | |||
2526 | old symbol has been already marked as a section symbol before | |||
2527 | resetting it. */ | |||
2528 | if ((s->bsym->flags & BSF_SECTION_SYM0x100) == 0) | |||
2529 | s->bsym = bsym; | |||
2530 | /* else XXX - What do we do now ? */ | |||
2531 | } | |||
2532 | ||||
2533 | #ifdef OBJ_SYMFIELD_TYPEstruct elf_obj_sy | |||
2534 | ||||
2535 | /* Get a pointer to the object format information for a symbol. */ | |||
2536 | ||||
2537 | OBJ_SYMFIELD_TYPEstruct elf_obj_sy * | |||
2538 | symbol_get_obj (symbolS *s) | |||
2539 | { | |||
2540 | if (LOCAL_SYMBOL_CHECK (s)(s->bsym == ((void*)0) ? ((((struct local_symbol *) s)-> lsy_section == reg_section) ? (s = (((struct local_symbol *) s )->u.lsy_sym), 0) : 1) : 0)) | |||
2541 | s = local_symbol_convert ((struct local_symbol *) s); | |||
2542 | return &s->sy_obj; | |||
2543 | } | |||
2544 | ||||
2545 | /* Set the object format information for a symbol. */ | |||
2546 | ||||
2547 | void | |||
2548 | symbol_set_obj (symbolS *s, OBJ_SYMFIELD_TYPEstruct elf_obj_sy *o) | |||
2549 | { | |||
2550 | if (LOCAL_SYMBOL_CHECK (s)(s->bsym == ((void*)0) ? ((((struct local_symbol *) s)-> lsy_section == reg_section) ? (s = (((struct local_symbol *) s )->u.lsy_sym), 0) : 1) : 0)) | |||
| ||||
2551 | s = local_symbol_convert ((struct local_symbol *) s); | |||
2552 | s->sy_obj = *o; | |||
2553 | } | |||
2554 | ||||
2555 | #endif /* OBJ_SYMFIELD_TYPE */ | |||
2556 | ||||
2557 | #ifdef TC_SYMFIELD_TYPE | |||
2558 | ||||
2559 | /* Get a pointer to the processor information for a symbol. */ | |||
2560 | ||||
2561 | TC_SYMFIELD_TYPE * | |||
2562 | symbol_get_tc (symbolS *s) | |||
2563 | { | |||
2564 | if (LOCAL_SYMBOL_CHECK (s)(s->bsym == ((void*)0) ? ((((struct local_symbol *) s)-> lsy_section == reg_section) ? (s = (((struct local_symbol *) s )->u.lsy_sym), 0) : 1) : 0)) | |||
2565 | s = local_symbol_convert ((struct local_symbol *) s); | |||
2566 | return &s->sy_tc; | |||
2567 | } | |||
2568 | ||||
2569 | /* Set the processor information for a symbol. */ | |||
2570 | ||||
2571 | void | |||
2572 | symbol_set_tc (symbolS *s, TC_SYMFIELD_TYPE *o) | |||
2573 | { | |||
2574 | if (LOCAL_SYMBOL_CHECK (s)(s->bsym == ((void*)0) ? ((((struct local_symbol *) s)-> lsy_section == reg_section) ? (s = (((struct local_symbol *) s )->u.lsy_sym), 0) : 1) : 0)) | |||
2575 | s = local_symbol_convert ((struct local_symbol *) s); | |||
2576 | s->sy_tc = *o; | |||
2577 | } | |||
2578 | ||||
2579 | #endif /* TC_SYMFIELD_TYPE */ | |||
2580 | ||||
2581 | void | |||
2582 | symbol_begin (void) | |||
2583 | { | |||
2584 | symbol_lastP = NULL((void*)0); | |||
2585 | symbol_rootP = NULL((void*)0); /* In case we have 0 symbols (!!) */ | |||
2586 | sy_hash = hash_new (); | |||
2587 | local_hash = hash_new (); | |||
2588 | ||||
2589 | memset ((char *) (&abs_symbol), '\0', sizeof (abs_symbol)); | |||
2590 | #if defined (EMIT_SECTION_SYMBOLS) || !defined (RELOC_REQUIRES_SYMBOL) | |||
2591 | abs_symbol.bsym = bfd_abs_section.symbol; | |||
2592 | #endif | |||
2593 | abs_symbol.sy_value.X_op = O_constant; | |||
2594 | abs_symbol.sy_frag = &zero_address_frag; | |||
2595 | ||||
2596 | if (LOCAL_LABELS_FB1) | |||
2597 | fb_label_init (); | |||
2598 | } | |||
2599 | ||||
2600 | int indent_level; | |||
2601 | ||||
2602 | /* Maximum indent level. | |||
2603 | Available for modification inside a gdb session. */ | |||
2604 | static int max_indent_level = 8; | |||
2605 | ||||
2606 | void | |||
2607 | print_symbol_value_1 (FILE *file, symbolS *sym) | |||
2608 | { | |||
2609 | const char *name = S_GET_NAME (sym); | |||
2610 | if (!name || !name[0]) | |||
2611 | name = "(unnamed)"; | |||
2612 | fprintf (file, "sym %lx %s", (unsigned long) sym, name); | |||
2613 | ||||
2614 | if (LOCAL_SYMBOL_CHECK (sym)(sym->bsym == ((void*)0) ? ((((struct local_symbol *) sym) ->lsy_section == reg_section) ? (sym = (((struct local_symbol *) sym)->u.lsy_sym), 0) : 1) : 0)) | |||
2615 | { | |||
2616 | struct local_symbol *locsym = (struct local_symbol *) sym; | |||
2617 | if (local_symbol_get_frag (locsym)((locsym)->u.lsy_frag) != &zero_address_frag | |||
2618 | && local_symbol_get_frag (locsym)((locsym)->u.lsy_frag) != NULL((void*)0)) | |||
2619 | fprintf (file, " frag %lx", (long) local_symbol_get_frag (locsym)((locsym)->u.lsy_frag)); | |||
2620 | if (local_symbol_resolved_p (locsym)((locsym)->u.lsy_frag == ((void*)0))) | |||
2621 | fprintf (file, " resolved"); | |||
2622 | fprintf (file, " local"); | |||
2623 | } | |||
2624 | else | |||
2625 | { | |||
2626 | if (sym->sy_frag != &zero_address_frag) | |||
2627 | fprintf (file, " frag %lx", (long) sym->sy_frag); | |||
2628 | if (sym->written) | |||
2629 | fprintf (file, " written"); | |||
2630 | if (sym->sy_resolved) | |||
2631 | fprintf (file, " resolved"); | |||
2632 | else if (sym->sy_resolving) | |||
2633 | fprintf (file, " resolving"); | |||
2634 | if (sym->sy_used_in_reloc) | |||
2635 | fprintf (file, " used-in-reloc"); | |||
2636 | if (sym->sy_used) | |||
2637 | fprintf (file, " used"); | |||
2638 | if (S_IS_LOCAL (sym)) | |||
2639 | fprintf (file, " local"); | |||
2640 | if (S_IS_EXTERNAL (sym)) | |||
2641 | fprintf (file, " extern"); | |||
2642 | if (S_IS_WEAK (sym)) | |||
2643 | fprintf (file, " weak"); | |||
2644 | if (S_IS_DEBUG (sym)) | |||
2645 | fprintf (file, " debug"); | |||
2646 | if (S_IS_DEFINED (sym)) | |||
2647 | fprintf (file, " defined"); | |||
2648 | } | |||
2649 | if (S_IS_WEAKREFR (sym)) | |||
2650 | fprintf (file, " weakrefr"); | |||
2651 | if (S_IS_WEAKREFD (sym)) | |||
2652 | fprintf (file, " weakrefd"); | |||
2653 | fprintf (file, " %s", segment_name (S_GET_SEGMENT (sym))((S_GET_SEGMENT (sym))->name + 0)); | |||
2654 | if (symbol_resolved_p (sym)) | |||
2655 | { | |||
2656 | segT s = S_GET_SEGMENT (sym); | |||
2657 | ||||
2658 | if (s != undefined_section((asection *) &bfd_und_section) | |||
2659 | && s != expr_section) | |||
2660 | fprintf (file, " %lx", (long) S_GET_VALUE (sym)); | |||
2661 | } | |||
2662 | else if (indent_level < max_indent_level | |||
2663 | && S_GET_SEGMENT (sym) != undefined_section((asection *) &bfd_und_section)) | |||
2664 | { | |||
2665 | indent_level++; | |||
2666 | fprintf (file, "\n%*s<", indent_level * 4, ""); | |||
2667 | if (LOCAL_SYMBOL_CHECK (sym)(sym->bsym == ((void*)0) ? ((((struct local_symbol *) sym) ->lsy_section == reg_section) ? (sym = (((struct local_symbol *) sym)->u.lsy_sym), 0) : 1) : 0)) | |||
2668 | fprintf (file, "constant %lx", | |||
2669 | (long) ((struct local_symbol *) sym)->lsy_value); | |||
2670 | else | |||
2671 | print_expr_1 (file, &sym->sy_value); | |||
2672 | fprintf (file, ">"); | |||
2673 | indent_level--; | |||
2674 | } | |||
2675 | fflush (file); | |||
2676 | } | |||
2677 | ||||
2678 | void | |||
2679 | print_symbol_value (symbolS *sym) | |||
2680 | { | |||
2681 | indent_level = 0; | |||
2682 | print_symbol_value_1 (stderr(&__sF[2]), sym); | |||
2683 | fprintf (stderr(&__sF[2]), "\n"); | |||
2684 | } | |||
2685 | ||||
2686 | static void | |||
2687 | print_binary (FILE *file, const char *name, expressionS *exp) | |||
2688 | { | |||
2689 | indent_level++; | |||
2690 | fprintf (file, "%s\n%*s<", name, indent_level * 4, ""); | |||
2691 | print_symbol_value_1 (file, exp->X_add_symbol); | |||
2692 | fprintf (file, ">\n%*s<", indent_level * 4, ""); | |||
2693 | print_symbol_value_1 (file, exp->X_op_symbol); | |||
2694 | fprintf (file, ">"); | |||
2695 | indent_level--; | |||
2696 | } | |||
2697 | ||||
2698 | void | |||
2699 | print_expr_1 (FILE *file, expressionS *exp) | |||
2700 | { | |||
2701 | fprintf (file, "expr %lx ", (long) exp); | |||
2702 | switch (exp->X_op) | |||
2703 | { | |||
2704 | case O_illegal: | |||
2705 | fprintf (file, "illegal"); | |||
2706 | break; | |||
2707 | case O_absent: | |||
2708 | fprintf (file, "absent"); | |||
2709 | break; | |||
2710 | case O_constant: | |||
2711 | fprintf (file, "constant %lx", (long) exp->X_add_number); | |||
2712 | break; | |||
2713 | case O_symbol: | |||
2714 | indent_level++; | |||
2715 | fprintf (file, "symbol\n%*s<", indent_level * 4, ""); | |||
2716 | print_symbol_value_1 (file, exp->X_add_symbol); | |||
2717 | fprintf (file, ">"); | |||
2718 | maybe_print_addnum: | |||
2719 | if (exp->X_add_number) | |||
2720 | fprintf (file, "\n%*s%lx", indent_level * 4, "", | |||
2721 | (long) exp->X_add_number); | |||
2722 | indent_level--; | |||
2723 | break; | |||
2724 | case O_register: | |||
2725 | fprintf (file, "register #%d", (int) exp->X_add_number); | |||
2726 | break; | |||
2727 | case O_big: | |||
2728 | fprintf (file, "big"); | |||
2729 | break; | |||
2730 | case O_uminus: | |||
2731 | fprintf (file, "uminus -<"); | |||
2732 | indent_level++; | |||
2733 | print_symbol_value_1 (file, exp->X_add_symbol); | |||
2734 | fprintf (file, ">"); | |||
2735 | goto maybe_print_addnum; | |||
2736 | case O_bit_not: | |||
2737 | fprintf (file, "bit_not"); | |||
2738 | break; | |||
2739 | case O_multiply: | |||
2740 | print_binary (file, "multiply", exp); | |||
2741 | break; | |||
2742 | case O_divide: | |||
2743 | print_binary (file, "divide", exp); | |||
2744 | break; | |||
2745 | case O_modulus: | |||
2746 | print_binary (file, "modulus", exp); | |||
2747 | break; | |||
2748 | case O_left_shift: | |||
2749 | print_binary (file, "lshift", exp); | |||
2750 | break; | |||
2751 | case O_right_shift: | |||
2752 | print_binary (file, "rshift", exp); | |||
2753 | break; | |||
2754 | case O_bit_inclusive_or: | |||
2755 | print_binary (file, "bit_ior", exp); | |||
2756 | break; | |||
2757 | case O_bit_exclusive_or: | |||
2758 | print_binary (file, "bit_xor", exp); | |||
2759 | break; | |||
2760 | case O_bit_and: | |||
2761 | print_binary (file, "bit_and", exp); | |||
2762 | break; | |||
2763 | case O_eq: | |||
2764 | print_binary (file, "eq", exp); | |||
2765 | break; | |||
2766 | case O_ne: | |||
2767 | print_binary (file, "ne", exp); | |||
2768 | break; | |||
2769 | case O_lt: | |||
2770 | print_binary (file, "lt", exp); | |||
2771 | break; | |||
2772 | case O_le: | |||
2773 | print_binary (file, "le", exp); | |||
2774 | break; | |||
2775 | case O_ge: | |||
2776 | print_binary (file, "ge", exp); | |||
2777 | break; | |||
2778 | case O_gt: | |||
2779 | print_binary (file, "gt", exp); | |||
2780 | break; | |||
2781 | case O_logical_and: | |||
2782 | print_binary (file, "logical_and", exp); | |||
2783 | break; | |||
2784 | case O_logical_or: | |||
2785 | print_binary (file, "logical_or", exp); | |||
2786 | break; | |||
2787 | case O_add: | |||
2788 | indent_level++; | |||
2789 | fprintf (file, "add\n%*s<", indent_level * 4, ""); | |||
2790 | print_symbol_value_1 (file, exp->X_add_symbol); | |||
2791 | fprintf (file, ">\n%*s<", indent_level * 4, ""); | |||
2792 | print_symbol_value_1 (file, exp->X_op_symbol); | |||
2793 | fprintf (file, ">"); | |||
2794 | goto maybe_print_addnum; | |||
2795 | case O_subtract: | |||
2796 | indent_level++; | |||
2797 | fprintf (file, "subtract\n%*s<", indent_level * 4, ""); | |||
2798 | print_symbol_value_1 (file, exp->X_add_symbol); | |||
2799 | fprintf (file, ">\n%*s<", indent_level * 4, ""); | |||
2800 | print_symbol_value_1 (file, exp->X_op_symbol); | |||
2801 | fprintf (file, ">"); | |||
2802 | goto maybe_print_addnum; | |||
2803 | default: | |||
2804 | fprintf (file, "{unknown opcode %d}", (int) exp->X_op); | |||
2805 | break; | |||
2806 | } | |||
2807 | fflush (stdout(&__sF[1])); | |||
2808 | } | |||
2809 | ||||
2810 | void | |||
2811 | print_expr (expressionS *exp) | |||
2812 | { | |||
2813 | print_expr_1 (stderr(&__sF[2]), exp); | |||
2814 | fprintf (stderr(&__sF[2]), "\n"); | |||
2815 | } | |||
2816 | ||||
2817 | void | |||
2818 | symbol_print_statistics (FILE *file) | |||
2819 | { | |||
2820 | hash_print_statistics (file, "symbol table", sy_hash); | |||
2821 | hash_print_statistics (file, "mini local symbol table", local_hash); | |||
2822 | fprintf (file, "%lu mini local symbols created, %lu converted\n", | |||
2823 | local_symbol_count, local_symbol_conversion_count); | |||
2824 | } |