File: | src/gnu/usr.bin/binutils-2.17/gas/write.c |
Warning: | line 2034, column 7 Access to field 'fr_address' results in a dereference of a null pointer (loaded from field 'fr_next') |
Press '?' to see keyboard shortcuts
Keyboard shortcuts:
1 | /* write.c - emit .o file | |||
2 | Copyright 1986, 1987, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, | |||
3 | 1998, 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 | /* This thing should be set up to do byteordering correctly. But... */ | |||
24 | ||||
25 | #include "as.h" | |||
26 | #include "subsegs.h" | |||
27 | #include "obstack.h" | |||
28 | #include "output-file.h" | |||
29 | #include "dwarf2dbg.h" | |||
30 | ||||
31 | #ifndef TC_ADJUST_RELOC_COUNT | |||
32 | #define TC_ADJUST_RELOC_COUNT(FIX, COUNT) | |||
33 | #endif | |||
34 | ||||
35 | #ifndef TC_FORCE_RELOCATION | |||
36 | #define TC_FORCE_RELOCATION(FIX)(generic_force_reloc (FIX)) \ | |||
37 | (generic_force_reloc (FIX)) | |||
38 | #endif | |||
39 | ||||
40 | #ifndef TC_FORCE_RELOCATION_ABS | |||
41 | #define TC_FORCE_RELOCATION_ABS(FIX)((generic_force_reloc (FIX))) \ | |||
42 | (TC_FORCE_RELOCATION (FIX)(generic_force_reloc (FIX))) | |||
43 | #endif | |||
44 | ||||
45 | #ifndef TC_FORCE_RELOCATION_LOCAL | |||
46 | #define TC_FORCE_RELOCATION_LOCAL(FIX)(!(FIX)->fx_pcrel || (FIX)->fx_plt || (FIX)->fx_r_type == BFD_RELOC_386_PLT32 || (FIX)->fx_r_type == BFD_RELOC_386_GOT32 || (FIX)->fx_r_type == BFD_RELOC_386_GOTPC || (FIX)->fx_r_type == BFD_RELOC_X86_64_GOTPCREL || (generic_force_reloc (FIX))) \ | |||
47 | (!(FIX)->fx_pcrel \ | |||
48 | || (FIX)->fx_plt \ | |||
49 | || TC_FORCE_RELOCATION (FIX)(generic_force_reloc (FIX))) | |||
50 | #endif | |||
51 | ||||
52 | #ifndef TC_FORCE_RELOCATION_SUB_SAME | |||
53 | #define TC_FORCE_RELOCATION_SUB_SAME(FIX, SEG)(! ( (SEG) != ((asection *) &bfd_abs_section) && ( SEG) != ((asection *) &bfd_und_section) && (SEG) != reg_section && (SEG) != expr_section)) \ | |||
54 | (! SEG_NORMAL (SEG)( (SEG) != ((asection *) &bfd_abs_section) && (SEG ) != ((asection *) &bfd_und_section) && (SEG) != reg_section && (SEG) != expr_section)) | |||
55 | #endif | |||
56 | ||||
57 | #ifndef TC_FORCE_RELOCATION_SUB_ABS | |||
58 | #define TC_FORCE_RELOCATION_SUB_ABS(FIX)0 0 | |||
59 | #endif | |||
60 | ||||
61 | #ifndef TC_FORCE_RELOCATION_SUB_LOCAL | |||
62 | #ifdef DIFF_EXPR_OK | |||
63 | #define TC_FORCE_RELOCATION_SUB_LOCAL(FIX)0 0 | |||
64 | #else | |||
65 | #define TC_FORCE_RELOCATION_SUB_LOCAL(FIX)0 1 | |||
66 | #endif | |||
67 | #endif | |||
68 | ||||
69 | #ifndef TC_VALIDATE_FIX_SUB | |||
70 | #ifdef UNDEFINED_DIFFERENCE_OK | |||
71 | /* The PA needs this for PIC code generation. */ | |||
72 | #define TC_VALIDATE_FIX_SUB(FIX)((FIX)->fx_r_type == BFD_RELOC_GPREL32 || (FIX)->fx_r_type == BFD_RELOC_GPREL16) 1 | |||
73 | #else | |||
74 | #define TC_VALIDATE_FIX_SUB(FIX)((FIX)->fx_r_type == BFD_RELOC_GPREL32 || (FIX)->fx_r_type == BFD_RELOC_GPREL16) \ | |||
75 | ((FIX)->fx_r_type == BFD_RELOC_GPREL32 \ | |||
76 | || (FIX)->fx_r_type == BFD_RELOC_GPREL16) | |||
77 | #endif | |||
78 | #endif | |||
79 | ||||
80 | #ifndef TC_LINKRELAX_FIXUP | |||
81 | #define TC_LINKRELAX_FIXUP(SEG)1 1 | |||
82 | #endif | |||
83 | ||||
84 | #ifndef MD_APPLY_SYM_VALUE | |||
85 | #define MD_APPLY_SYM_VALUE(FIX)0 1 | |||
86 | #endif | |||
87 | ||||
88 | #ifndef TC_FINALIZE_SYMS_BEFORE_SIZE_SEG1 | |||
89 | #define TC_FINALIZE_SYMS_BEFORE_SIZE_SEG1 1 | |||
90 | #endif | |||
91 | ||||
92 | #ifndef MD_PCREL_FROM_SECTION | |||
93 | #define MD_PCREL_FROM_SECTION(FIX, SEC)md_pcrel_from (FIX) md_pcrel_from (FIX) | |||
94 | #endif | |||
95 | ||||
96 | #ifndef TC_FAKE_LABEL | |||
97 | #define TC_FAKE_LABEL(NAME)(strcmp ((NAME), "L0\001") == 0) (strcmp ((NAME), FAKE_LABEL_NAME"L0\001") == 0) | |||
98 | #endif | |||
99 | ||||
100 | /* Used to control final evaluation of expressions. */ | |||
101 | int finalize_syms = 0; | |||
102 | ||||
103 | int symbol_table_frozen; | |||
104 | ||||
105 | symbolS *abs_section_sym; | |||
106 | ||||
107 | /* Remember the value of dot when parsing expressions. */ | |||
108 | addressT dot_value; | |||
109 | ||||
110 | void print_fixup (fixS *); | |||
111 | ||||
112 | static void renumber_sections (bfd *, asection *, PTRvoid *); | |||
113 | ||||
114 | /* We generally attach relocs to frag chains. However, after we have | |||
115 | chained these all together into a segment, any relocs we add after | |||
116 | that must be attached to a segment. This will include relocs added | |||
117 | in md_estimate_size_for_relax, for example. */ | |||
118 | static int frags_chained = 0; | |||
119 | ||||
120 | static int n_fixups; | |||
121 | ||||
122 | #define RELOC_ENUMenum bfd_reloc_code_real enum bfd_reloc_code_real | |||
123 | ||||
124 | static fixS *fix_new_internal (fragS *, int where, int size, | |||
125 | symbolS *add, symbolS *sub, | |||
126 | offsetT offset, int pcrel, | |||
127 | RELOC_ENUMenum bfd_reloc_code_real r_type); | |||
128 | static long fixup_segment (fixS *, segT); | |||
129 | static relax_addressT relax_align (relax_addressT addr, int align); | |||
130 | static fragS *chain_frchains_together_1 (segT, struct frchain *); | |||
131 | static void chain_frchains_together (bfd *, segT, PTRvoid *); | |||
132 | static void cvt_frag_to_fill (segT, fragS *); | |||
133 | static void adjust_reloc_syms (bfd *, asection *, PTRvoid *); | |||
134 | static void fix_segment (bfd *, asection *, PTRvoid *); | |||
135 | static void write_relocs (bfd *, asection *, PTRvoid *); | |||
136 | static void write_contents (bfd *, asection *, PTRvoid *); | |||
137 | static void set_symtab (void); | |||
138 | static void merge_data_into_text (void); | |||
139 | ||||
140 | /* Create a fixS in obstack 'notes'. */ | |||
141 | ||||
142 | static fixS * | |||
143 | fix_new_internal (fragS *frag, /* Which frag? */ | |||
144 | int where, /* Where in that frag? */ | |||
145 | int size, /* 1, 2, or 4 usually. */ | |||
146 | symbolS *add_symbol, /* X_add_symbol. */ | |||
147 | symbolS *sub_symbol, /* X_op_symbol. */ | |||
148 | offsetT offset, /* X_add_number. */ | |||
149 | int pcrel, /* TRUE if PC-relative relocation. */ | |||
150 | RELOC_ENUMenum bfd_reloc_code_real r_type ATTRIBUTE_UNUSED__attribute__ ((__unused__)) /* Relocation type. */) | |||
151 | { | |||
152 | fixS *fixP; | |||
153 | ||||
154 | n_fixups++; | |||
155 | ||||
156 | fixP = (fixS *) obstack_alloc (¬es, sizeof (fixS))__extension__ ({ struct obstack *__h = (¬es); __extension__ ({ struct obstack *__o = (__h); int __len = ((sizeof (fixS)) ); 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; }); }); | |||
157 | ||||
158 | fixP->fx_frag = frag; | |||
159 | fixP->fx_where = where; | |||
160 | fixP->fx_size = size; | |||
161 | /* We've made fx_size a narrow field; check that it's wide enough. */ | |||
162 | if (fixP->fx_size != size) | |||
163 | { | |||
164 | as_bad (_("field fx_size too small to hold %d")("field fx_size too small to hold %d"), size); | |||
165 | abort ()as_abort ("/usr/src/gnu/usr.bin/binutils-2.17/gas/write.c", 165 , __PRETTY_FUNCTION__); | |||
166 | } | |||
167 | fixP->fx_addsy = add_symbol; | |||
168 | fixP->fx_subsy = sub_symbol; | |||
169 | fixP->fx_offset = offset; | |||
170 | fixP->fx_dot_value = dot_value; | |||
171 | fixP->fx_pcrel = pcrel; | |||
172 | fixP->fx_plt = 0; | |||
173 | fixP->fx_r_type = r_type; | |||
174 | fixP->fx_im_disp = 0; | |||
175 | fixP->fx_pcrel_adjust = 0; | |||
176 | fixP->fx_bit_fixP = 0; | |||
177 | fixP->fx_addnumber = 0; | |||
178 | fixP->fx_tcbit = 0; | |||
179 | fixP->fx_done = 0; | |||
180 | fixP->fx_no_overflow = 0; | |||
181 | fixP->fx_signed = 0; | |||
182 | ||||
183 | #ifdef USING_CGEN | |||
184 | fixP->fx_cgen.insn = NULL((void*)0); | |||
185 | fixP->fx_cgen.opinfo = 0; | |||
186 | #endif | |||
187 | ||||
188 | #ifdef TC_FIX_TYPE | |||
189 | TC_INIT_FIX_DATA (fixP); | |||
190 | #endif | |||
191 | ||||
192 | as_where (&fixP->fx_file, &fixP->fx_line); | |||
193 | ||||
194 | /* Usually, we want relocs sorted numerically, but while | |||
195 | comparing to older versions of gas that have relocs | |||
196 | reverse sorted, it is convenient to have this compile | |||
197 | time option. xoxorich. */ | |||
198 | { | |||
199 | ||||
200 | fixS **seg_fix_rootP = (frags_chained | |||
201 | ? &seg_info (now_seg)->fix_root | |||
202 | : &frchain_now->fix_root); | |||
203 | fixS **seg_fix_tailP = (frags_chained | |||
204 | ? &seg_info (now_seg)->fix_tail | |||
205 | : &frchain_now->fix_tail); | |||
206 | ||||
207 | #ifdef REVERSE_SORT_RELOCS | |||
208 | ||||
209 | fixP->fx_next = *seg_fix_rootP; | |||
210 | *seg_fix_rootP = fixP; | |||
211 | ||||
212 | #else /* REVERSE_SORT_RELOCS */ | |||
213 | ||||
214 | fixP->fx_next = NULL((void*)0); | |||
215 | ||||
216 | if (*seg_fix_tailP) | |||
217 | (*seg_fix_tailP)->fx_next = fixP; | |||
218 | else | |||
219 | *seg_fix_rootP = fixP; | |||
220 | *seg_fix_tailP = fixP; | |||
221 | ||||
222 | #endif /* REVERSE_SORT_RELOCS */ | |||
223 | } | |||
224 | ||||
225 | return fixP; | |||
226 | } | |||
227 | ||||
228 | /* Create a fixup relative to a symbol (plus a constant). */ | |||
229 | ||||
230 | fixS * | |||
231 | fix_new (fragS *frag, /* Which frag? */ | |||
232 | int where, /* Where in that frag? */ | |||
233 | int size, /* 1, 2, or 4 usually. */ | |||
234 | symbolS *add_symbol, /* X_add_symbol. */ | |||
235 | offsetT offset, /* X_add_number. */ | |||
236 | int pcrel, /* TRUE if PC-relative relocation. */ | |||
237 | RELOC_ENUMenum bfd_reloc_code_real r_type /* Relocation type. */) | |||
238 | { | |||
239 | return fix_new_internal (frag, where, size, add_symbol, | |||
240 | (symbolS *) NULL((void*)0), offset, pcrel, r_type); | |||
241 | } | |||
242 | ||||
243 | /* Create a fixup for an expression. Currently we only support fixups | |||
244 | for difference expressions. That is itself more than most object | |||
245 | file formats support anyhow. */ | |||
246 | ||||
247 | fixS * | |||
248 | fix_new_exp (fragS *frag, /* Which frag? */ | |||
249 | int where, /* Where in that frag? */ | |||
250 | int size, /* 1, 2, or 4 usually. */ | |||
251 | expressionS *exp, /* Expression. */ | |||
252 | int pcrel, /* TRUE if PC-relative relocation. */ | |||
253 | RELOC_ENUMenum bfd_reloc_code_real r_type /* Relocation type. */) | |||
254 | { | |||
255 | symbolS *add = NULL((void*)0); | |||
256 | symbolS *sub = NULL((void*)0); | |||
257 | offsetT off = 0; | |||
258 | ||||
259 | switch (exp->X_op) | |||
260 | { | |||
261 | case O_absent: | |||
262 | break; | |||
263 | ||||
264 | case O_register: | |||
265 | as_bad (_("register value used as expression")("register value used as expression")); | |||
266 | break; | |||
267 | ||||
268 | case O_add: | |||
269 | /* This comes up when _GLOBAL_OFFSET_TABLE_+(.-L0) is read, if | |||
270 | the difference expression cannot immediately be reduced. */ | |||
271 | { | |||
272 | symbolS *stmp = make_expr_symbol (exp); | |||
273 | ||||
274 | exp->X_op = O_symbol; | |||
275 | exp->X_op_symbol = 0; | |||
276 | exp->X_add_symbol = stmp; | |||
277 | exp->X_add_number = 0; | |||
278 | ||||
279 | return fix_new_exp (frag, where, size, exp, pcrel, r_type); | |||
280 | } | |||
281 | ||||
282 | case O_symbol_rva: | |||
283 | add = exp->X_add_symbol; | |||
284 | off = exp->X_add_number; | |||
285 | r_type = BFD_RELOC_RVA; | |||
286 | break; | |||
287 | ||||
288 | case O_uminus: | |||
289 | sub = exp->X_add_symbol; | |||
290 | off = exp->X_add_number; | |||
291 | break; | |||
292 | ||||
293 | case O_subtract: | |||
294 | sub = exp->X_op_symbol; | |||
295 | /* Fall through. */ | |||
296 | case O_symbol: | |||
297 | add = exp->X_add_symbol; | |||
298 | /* Fall through. */ | |||
299 | case O_constant: | |||
300 | off = exp->X_add_number; | |||
301 | break; | |||
302 | ||||
303 | default: | |||
304 | add = make_expr_symbol (exp); | |||
305 | break; | |||
306 | } | |||
307 | ||||
308 | return fix_new_internal (frag, where, size, add, sub, off, pcrel, r_type); | |||
309 | } | |||
310 | ||||
311 | /* Generic function to determine whether a fixup requires a relocation. */ | |||
312 | int | |||
313 | generic_force_reloc (fixS *fix) | |||
314 | { | |||
315 | if (fix->fx_r_type == BFD_RELOC_VTABLE_INHERIT | |||
316 | || fix->fx_r_type == BFD_RELOC_VTABLE_ENTRY) | |||
317 | return 1; | |||
318 | ||||
319 | if (fix->fx_addsy == NULL((void*)0)) | |||
320 | return 0; | |||
321 | ||||
322 | return S_FORCE_RELOC (fix->fx_addsy, fix->fx_subsy == NULL((void*)0)); | |||
323 | } | |||
324 | ||||
325 | /* Append a string onto another string, bumping the pointer along. */ | |||
326 | void | |||
327 | append (char **charPP, char *fromP, unsigned long length) | |||
328 | { | |||
329 | /* Don't trust memcpy() of 0 chars. */ | |||
330 | if (length == 0) | |||
331 | return; | |||
332 | ||||
333 | memcpy (*charPP, fromP, length); | |||
334 | *charPP += length; | |||
335 | } | |||
336 | ||||
337 | /* This routine records the largest alignment seen for each segment. | |||
338 | If the beginning of the segment is aligned on the worst-case | |||
339 | boundary, all of the other alignments within it will work. At | |||
340 | least one object format really uses this info. */ | |||
341 | ||||
342 | void | |||
343 | record_alignment (/* Segment to which alignment pertains. */ | |||
344 | segT seg, | |||
345 | /* Alignment, as a power of 2 (e.g., 1 => 2-byte | |||
346 | boundary, 2 => 4-byte boundary, etc.) */ | |||
347 | int align) | |||
348 | { | |||
349 | if (seg == absolute_section((asection *) &bfd_abs_section)) | |||
350 | return; | |||
351 | ||||
352 | if ((unsigned int) align > bfd_get_section_alignment (stdoutput, seg)((seg)->alignment_power + 0)) | |||
353 | bfd_set_section_alignment (stdoutput, seg, align)(((seg)->alignment_power = (align)),1); | |||
354 | } | |||
355 | ||||
356 | int | |||
357 | get_recorded_alignment (segT seg) | |||
358 | { | |||
359 | if (seg == absolute_section((asection *) &bfd_abs_section)) | |||
360 | return 0; | |||
361 | ||||
362 | return bfd_get_section_alignment (stdoutput, seg)((seg)->alignment_power + 0); | |||
363 | } | |||
364 | ||||
365 | /* Reset the section indices after removing the gas created sections. */ | |||
366 | ||||
367 | static void | |||
368 | renumber_sections (bfd *abfd ATTRIBUTE_UNUSED__attribute__ ((__unused__)), asection *sec, PTRvoid * countparg) | |||
369 | { | |||
370 | int *countp = (int *) countparg; | |||
371 | ||||
372 | sec->index = *countp; | |||
373 | ++*countp; | |||
374 | } | |||
375 | ||||
376 | static fragS * | |||
377 | chain_frchains_together_1 (segT section, struct frchain *frchp) | |||
378 | { | |||
379 | fragS dummy, *prev_frag = &dummy; | |||
380 | fixS fix_dummy, *prev_fix = &fix_dummy; | |||
381 | ||||
382 | for (; frchp && frchp->frch_seg == section; frchp = frchp->frch_next) | |||
383 | { | |||
384 | prev_frag->fr_next = frchp->frch_root; | |||
385 | prev_frag = frchp->frch_last; | |||
386 | assert (prev_frag->fr_type != 0)((void) ((prev_frag->fr_type != 0) ? 0 : (as_assert ("/usr/src/gnu/usr.bin/binutils-2.17/gas/write.c" , 386, __PRETTY_FUNCTION__), 0))); | |||
387 | if (frchp->fix_root != (fixS *) NULL((void*)0)) | |||
388 | { | |||
389 | if (seg_info (section)->fix_root == (fixS *) NULL((void*)0)) | |||
390 | seg_info (section)->fix_root = frchp->fix_root; | |||
391 | prev_fix->fx_next = frchp->fix_root; | |||
392 | seg_info (section)->fix_tail = frchp->fix_tail; | |||
393 | prev_fix = frchp->fix_tail; | |||
394 | } | |||
395 | } | |||
396 | assert (prev_frag->fr_type != 0)((void) ((prev_frag->fr_type != 0) ? 0 : (as_assert ("/usr/src/gnu/usr.bin/binutils-2.17/gas/write.c" , 396, __PRETTY_FUNCTION__), 0))); | |||
397 | prev_frag->fr_next = 0; | |||
398 | return prev_frag; | |||
399 | } | |||
400 | ||||
401 | static void | |||
402 | chain_frchains_together (bfd *abfd ATTRIBUTE_UNUSED__attribute__ ((__unused__)), | |||
403 | segT section, | |||
404 | PTRvoid * xxx ATTRIBUTE_UNUSED__attribute__ ((__unused__))) | |||
405 | { | |||
406 | segment_info_type *info; | |||
407 | ||||
408 | /* BFD may have introduced its own sections without using | |||
409 | subseg_new, so it is possible that seg_info is NULL. */ | |||
410 | info = seg_info (section); | |||
411 | if (info != (segment_info_type *) NULL((void*)0)) | |||
412 | info->frchainP->frch_last | |||
413 | = chain_frchains_together_1 (section, info->frchainP); | |||
414 | ||||
415 | /* Now that we've chained the frags together, we must add new fixups | |||
416 | to the segment, not to the frag chain. */ | |||
417 | frags_chained = 1; | |||
418 | } | |||
419 | ||||
420 | static void | |||
421 | cvt_frag_to_fill (segT sec ATTRIBUTE_UNUSED__attribute__ ((__unused__)), fragS *fragP) | |||
422 | { | |||
423 | switch (fragP->fr_type) | |||
424 | { | |||
425 | case rs_align: | |||
426 | case rs_align_code: | |||
427 | case rs_align_test: | |||
428 | case rs_org: | |||
429 | case rs_space: | |||
430 | #ifdef HANDLE_ALIGN | |||
431 | HANDLE_ALIGN (fragP)if (fragP->fr_type == rs_align_code) i386_align_code (fragP , (fragP->fr_next->fr_address - fragP->fr_address - fragP ->fr_fix));; | |||
432 | #endif | |||
433 | know (fragP->fr_next != NULL); | |||
434 | fragP->fr_offset = (fragP->fr_next->fr_address | |||
435 | - fragP->fr_address | |||
436 | - fragP->fr_fix) / fragP->fr_var; | |||
437 | if (fragP->fr_offset < 0) | |||
438 | { | |||
439 | as_bad_where (fragP->fr_file, fragP->fr_line, | |||
440 | _("attempt to .org/.space backwards? (%ld)")("attempt to .org/.space backwards? (%ld)"), | |||
441 | (long) fragP->fr_offset); | |||
442 | fragP->fr_offset = 0; | |||
443 | } | |||
444 | fragP->fr_type = rs_fill; | |||
445 | break; | |||
446 | ||||
447 | case rs_fill: | |||
448 | break; | |||
449 | ||||
450 | case rs_leb128: | |||
451 | { | |||
452 | valueT value = S_GET_VALUE (fragP->fr_symbol); | |||
453 | int size; | |||
454 | ||||
455 | size = output_leb128 (fragP->fr_literal + fragP->fr_fix, value, | |||
456 | fragP->fr_subtype); | |||
457 | ||||
458 | fragP->fr_fix += size; | |||
459 | fragP->fr_type = rs_fill; | |||
460 | fragP->fr_var = 0; | |||
461 | fragP->fr_offset = 0; | |||
462 | fragP->fr_symbol = NULL((void*)0); | |||
463 | } | |||
464 | break; | |||
465 | ||||
466 | case rs_cfa: | |||
467 | eh_frame_convert_frag (fragP); | |||
468 | break; | |||
469 | ||||
470 | case rs_dwarf2dbg: | |||
471 | dwarf2dbg_convert_frag (fragP); | |||
472 | break; | |||
473 | ||||
474 | case rs_machine_dependent: | |||
475 | md_convert_frag (stdoutput, sec, fragP); | |||
476 | ||||
477 | assert (fragP->fr_next == NULL((void) ((fragP->fr_next == ((void*)0) || ((offsetT) (fragP ->fr_next->fr_address - fragP->fr_address) == fragP-> fr_fix)) ? 0 : (as_assert ("/usr/src/gnu/usr.bin/binutils-2.17/gas/write.c" , 479, __PRETTY_FUNCTION__), 0))) | |||
478 | || ((offsetT) (fragP->fr_next->fr_address - fragP->fr_address)((void) ((fragP->fr_next == ((void*)0) || ((offsetT) (fragP ->fr_next->fr_address - fragP->fr_address) == fragP-> fr_fix)) ? 0 : (as_assert ("/usr/src/gnu/usr.bin/binutils-2.17/gas/write.c" , 479, __PRETTY_FUNCTION__), 0))) | |||
479 | == fragP->fr_fix))((void) ((fragP->fr_next == ((void*)0) || ((offsetT) (fragP ->fr_next->fr_address - fragP->fr_address) == fragP-> fr_fix)) ? 0 : (as_assert ("/usr/src/gnu/usr.bin/binutils-2.17/gas/write.c" , 479, __PRETTY_FUNCTION__), 0))); | |||
480 | ||||
481 | /* After md_convert_frag, we make the frag into a ".space 0". | |||
482 | md_convert_frag() should set up any fixSs and constants | |||
483 | required. */ | |||
484 | frag_wane (fragP); | |||
485 | break; | |||
486 | ||||
487 | #ifndef WORKING_DOT_WORD | |||
488 | case rs_broken_word: | |||
489 | { | |||
490 | struct broken_word *lie; | |||
491 | ||||
492 | if (fragP->fr_subtype) | |||
493 | { | |||
494 | fragP->fr_fix += md_short_jump_size; | |||
495 | for (lie = (struct broken_word *) (fragP->fr_symbol); | |||
496 | lie && lie->dispfrag == fragP; | |||
497 | lie = lie->next_broken_word) | |||
498 | if (lie->added == 1) | |||
499 | fragP->fr_fix += md_long_jump_size; | |||
500 | } | |||
501 | frag_wane (fragP); | |||
502 | } | |||
503 | break; | |||
504 | #endif | |||
505 | ||||
506 | default: | |||
507 | BAD_CASE (fragP->fr_type){ as_fatal (("Case value %ld unexpected at line %d of file \"%s\"\n" ), (long) fragP->fr_type, 507, "/usr/src/gnu/usr.bin/binutils-2.17/gas/write.c" ); }; | |||
508 | break; | |||
509 | } | |||
510 | #ifdef md_frag_check | |||
511 | md_frag_check (fragP); | |||
512 | #endif | |||
513 | } | |||
514 | ||||
515 | struct relax_seg_info | |||
516 | { | |||
517 | int pass; | |||
518 | int changed; | |||
519 | }; | |||
520 | ||||
521 | static void | |||
522 | relax_seg (bfd *abfd ATTRIBUTE_UNUSED__attribute__ ((__unused__)), asection *sec, void *xxx) | |||
523 | { | |||
524 | segment_info_type *seginfo = seg_info (sec); | |||
525 | struct relax_seg_info *info = (struct relax_seg_info *) xxx; | |||
526 | ||||
527 | if (seginfo && seginfo->frchainP | |||
528 | && relax_segment (seginfo->frchainP->frch_root, sec, info->pass)) | |||
529 | info->changed = 1; | |||
530 | } | |||
531 | ||||
532 | static void size_seg (bfd *, asection *, PTRvoid *); | |||
533 | ||||
534 | static void | |||
535 | size_seg (bfd *abfd, asection *sec, PTRvoid * xxx ATTRIBUTE_UNUSED__attribute__ ((__unused__))) | |||
536 | { | |||
537 | flagword flags; | |||
538 | fragS *fragp; | |||
539 | segment_info_type *seginfo; | |||
540 | int x; | |||
541 | valueT size, newsize; | |||
542 | ||||
543 | subseg_change (sec, 0); | |||
544 | ||||
545 | seginfo = seg_info (sec); | |||
546 | if (seginfo && seginfo->frchainP) | |||
547 | { | |||
548 | for (fragp = seginfo->frchainP->frch_root; fragp; fragp = fragp->fr_next) | |||
549 | cvt_frag_to_fill (sec, fragp); | |||
550 | for (fragp = seginfo->frchainP->frch_root; | |||
551 | fragp->fr_next; | |||
552 | fragp = fragp->fr_next) | |||
553 | /* Walk to last elt. */ | |||
554 | ; | |||
555 | size = fragp->fr_address + fragp->fr_fix; | |||
556 | } | |||
557 | else | |||
558 | size = 0; | |||
559 | ||||
560 | flags = bfd_get_section_flags (abfd, sec)((sec)->flags + 0); | |||
561 | ||||
562 | if (size > 0 && ! seginfo->bss) | |||
563 | flags |= SEC_HAS_CONTENTS0x100; | |||
564 | ||||
565 | /* @@ This is just an approximation. */ | |||
566 | if (seginfo && seginfo->fix_root) | |||
567 | flags |= SEC_RELOC0x004; | |||
568 | else | |||
569 | flags &= ~SEC_RELOC0x004; | |||
570 | x = bfd_set_section_flags (abfd, sec, flags); | |||
571 | assert (x)((void) ((x) ? 0 : (as_assert ("/usr/src/gnu/usr.bin/binutils-2.17/gas/write.c" , 571, __PRETTY_FUNCTION__), 0))); | |||
572 | ||||
573 | newsize = md_section_align (sec, size); | |||
574 | x = bfd_set_section_size (abfd, sec, newsize); | |||
575 | assert (x)((void) ((x) ? 0 : (as_assert ("/usr/src/gnu/usr.bin/binutils-2.17/gas/write.c" , 575, __PRETTY_FUNCTION__), 0))); | |||
576 | ||||
577 | /* If the size had to be rounded up, add some padding in the last | |||
578 | non-empty frag. */ | |||
579 | assert (newsize >= size)((void) ((newsize >= size) ? 0 : (as_assert ("/usr/src/gnu/usr.bin/binutils-2.17/gas/write.c" , 579, __PRETTY_FUNCTION__), 0))); | |||
580 | if (size != newsize) | |||
581 | { | |||
582 | fragS *last = seginfo->frchainP->frch_last; | |||
583 | fragp = seginfo->frchainP->frch_root; | |||
584 | while (fragp->fr_next != last) | |||
585 | fragp = fragp->fr_next; | |||
586 | last->fr_address = size; | |||
587 | if ((newsize - size) % fragp->fr_var == 0) | |||
588 | fragp->fr_offset += (newsize - size) / fragp->fr_var; | |||
589 | else | |||
590 | /* If we hit this abort, it's likely due to subsegs_finish not | |||
591 | providing sufficient alignment on the last frag, and the | |||
592 | machine dependent code using alignment frags with fr_var | |||
593 | greater than 1. */ | |||
594 | abort ()as_abort ("/usr/src/gnu/usr.bin/binutils-2.17/gas/write.c", 594 , __PRETTY_FUNCTION__); | |||
595 | } | |||
596 | ||||
597 | #ifdef tc_frob_section | |||
598 | tc_frob_section (sec); | |||
599 | #endif | |||
600 | #ifdef obj_frob_section | |||
601 | obj_frob_section (sec); | |||
602 | #endif | |||
603 | } | |||
604 | ||||
605 | #ifdef DEBUG2 | |||
606 | static void | |||
607 | dump_section_relocs (bfd *abfd ATTRIBUTE_UNUSED, asection *sec, FILE *stream)((void) 0) | |||
608 | { | |||
609 | segment_info_type *seginfo = seg_info (sec); | |||
610 | fixS *fixp = seginfo->fix_root; | |||
611 | ||||
612 | if (!fixp) | |||
613 | return; | |||
614 | ||||
615 | fprintf (stream, "sec %s relocs:\n", sec->name); | |||
616 | while (fixp) | |||
617 | { | |||
618 | symbolS *s = fixp->fx_addsy; | |||
619 | ||||
620 | fprintf (stream, " %08lx: type %d ", (unsigned long) fixp, | |||
621 | (int) fixp->fx_r_type); | |||
622 | if (s == NULL((void*)0)) | |||
623 | fprintf (stream, "no sym\n"); | |||
624 | else | |||
625 | { | |||
626 | print_symbol_value_1 (stream, s); | |||
627 | fprintf (stream, "\n"); | |||
628 | } | |||
629 | fixp = fixp->fx_next; | |||
630 | } | |||
631 | } | |||
632 | #else | |||
633 | #define dump_section_relocs(ABFD,SEC,STREAM)((void) 0) ((void) 0) | |||
634 | #endif | |||
635 | ||||
636 | #ifndef EMIT_SECTION_SYMBOLS1 | |||
637 | #define EMIT_SECTION_SYMBOLS1 1 | |||
638 | #endif | |||
639 | ||||
640 | /* This pass over fixups decides whether symbols can be replaced with | |||
641 | section symbols. */ | |||
642 | ||||
643 | static void | |||
644 | adjust_reloc_syms (bfd *abfd ATTRIBUTE_UNUSED__attribute__ ((__unused__)), | |||
645 | asection *sec, | |||
646 | PTRvoid * xxx ATTRIBUTE_UNUSED__attribute__ ((__unused__))) | |||
647 | { | |||
648 | segment_info_type *seginfo = seg_info (sec); | |||
649 | fixS *fixp; | |||
650 | ||||
651 | if (seginfo == NULL((void*)0)) | |||
652 | return; | |||
653 | ||||
654 | dump_section_relocs (abfd, sec, stderr)((void) 0); | |||
655 | ||||
656 | for (fixp = seginfo->fix_root; fixp; fixp = fixp->fx_next) | |||
657 | if (fixp->fx_done) | |||
658 | /* Ignore it. */ | |||
659 | ; | |||
660 | else if (fixp->fx_addsy) | |||
661 | { | |||
662 | symbolS *sym; | |||
663 | asection *symsec; | |||
664 | ||||
665 | #ifdef DEBUG5 | |||
666 | fprintf (stderr(&__sF[2]), "\n\nadjusting fixup:\n"); | |||
667 | print_fixup (fixp); | |||
668 | #endif | |||
669 | ||||
670 | sym = fixp->fx_addsy; | |||
671 | ||||
672 | /* All symbols should have already been resolved at this | |||
673 | point. It is possible to see unresolved expression | |||
674 | symbols, though, since they are not in the regular symbol | |||
675 | table. */ | |||
676 | resolve_symbol_value (sym); | |||
677 | ||||
678 | if (fixp->fx_subsy != NULL((void*)0)) | |||
679 | resolve_symbol_value (fixp->fx_subsy); | |||
680 | ||||
681 | /* If this symbol is equated to an undefined or common symbol, | |||
682 | convert the fixup to being against that symbol. */ | |||
683 | if (symbol_equated_reloc_p (sym) | |||
684 | || S_IS_WEAKREFR (sym)) | |||
685 | { | |||
686 | fixp->fx_offset += symbol_get_value_expression (sym)->X_add_number; | |||
687 | sym = symbol_get_value_expression (sym)->X_add_symbol; | |||
688 | fixp->fx_addsy = sym; | |||
689 | } | |||
690 | ||||
691 | if (symbol_mri_common_p (sym)) | |||
692 | { | |||
693 | /* These symbols are handled specially in fixup_segment. */ | |||
694 | continue; | |||
695 | } | |||
696 | ||||
697 | /* If the symbol is undefined, common, weak, or global (ELF | |||
698 | shared libs), we can't replace it with the section symbol. */ | |||
699 | if (S_FORCE_RELOC (fixp->fx_addsy, 1)) | |||
700 | continue; | |||
701 | ||||
702 | /* Is there some other (target cpu dependent) reason we can't adjust | |||
703 | this one? (E.g. relocations involving function addresses on | |||
704 | the PA. */ | |||
705 | #ifdef tc_fix_adjustable | |||
706 | if (! tc_fix_adjustable (fixp)tc_i386_fix_adjustable(fixp)) | |||
707 | continue; | |||
708 | #endif | |||
709 | ||||
710 | /* Since we're reducing to section symbols, don't attempt to reduce | |||
711 | anything that's already using one. */ | |||
712 | if (symbol_section_p (sym)) | |||
713 | continue; | |||
714 | ||||
715 | symsec = S_GET_SEGMENT (sym); | |||
716 | if (symsec == NULL((void*)0)) | |||
717 | abort ()as_abort ("/usr/src/gnu/usr.bin/binutils-2.17/gas/write.c", 717 , __PRETTY_FUNCTION__); | |||
718 | ||||
719 | if (bfd_is_abs_section (symsec)((symsec) == ((asection *) &bfd_abs_section))) | |||
720 | { | |||
721 | /* The fixup_segment routine normally will not use this | |||
722 | symbol in a relocation. */ | |||
723 | continue; | |||
724 | } | |||
725 | ||||
726 | /* Don't try to reduce relocs which refer to non-local symbols | |||
727 | in .linkonce sections. It can lead to confusion when a | |||
728 | debugging section refers to a .linkonce section. I hope | |||
729 | this will always be correct. */ | |||
730 | if (symsec != sec && ! S_IS_LOCAL (sym)) | |||
731 | { | |||
732 | if ((symsec->flags & SEC_LINK_ONCE0x20000) != 0 | |||
733 | || (IS_ELF1 | |||
734 | /* The GNU toolchain uses an extension for ELF: a | |||
735 | section beginning with the magic string | |||
736 | .gnu.linkonce is a linkonce section. */ | |||
737 | && strncmp (segment_name (symsec)((symsec)->name + 0), ".gnu.linkonce", | |||
738 | sizeof ".gnu.linkonce" - 1) == 0)) | |||
739 | continue; | |||
740 | } | |||
741 | ||||
742 | /* Never adjust a reloc against local symbol in a merge section | |||
743 | with non-zero addend. */ | |||
744 | if ((symsec->flags & SEC_MERGE0x1000000) != 0 | |||
745 | && (fixp->fx_offset != 0 || fixp->fx_subsy != NULL((void*)0))) | |||
746 | continue; | |||
747 | ||||
748 | /* Never adjust a reloc against TLS local symbol. */ | |||
749 | if ((symsec->flags & SEC_THREAD_LOCAL0x400) != 0) | |||
750 | continue; | |||
751 | ||||
752 | /* We refetch the segment when calling section_symbol, rather | |||
753 | than using symsec, because S_GET_VALUE may wind up changing | |||
754 | the section when it calls resolve_symbol_value. */ | |||
755 | fixp->fx_offset += S_GET_VALUE (sym); | |||
756 | fixp->fx_addsy = section_symbol (S_GET_SEGMENT (sym)); | |||
757 | #ifdef DEBUG5 | |||
758 | fprintf (stderr(&__sF[2]), "\nadjusted fixup:\n"); | |||
759 | print_fixup (fixp); | |||
760 | #endif | |||
761 | } | |||
762 | ||||
763 | dump_section_relocs (abfd, sec, stderr)((void) 0); | |||
764 | } | |||
765 | ||||
766 | static void | |||
767 | fix_segment (bfd *abfd ATTRIBUTE_UNUSED__attribute__ ((__unused__)), | |||
768 | asection *sec, | |||
769 | PTRvoid * xxx ATTRIBUTE_UNUSED__attribute__ ((__unused__))) | |||
770 | { | |||
771 | segment_info_type *seginfo = seg_info (sec); | |||
772 | ||||
773 | fixup_segment (seginfo->fix_root, sec); | |||
774 | } | |||
775 | ||||
776 | static void | |||
777 | write_relocs (bfd *abfd, asection *sec, PTRvoid * xxx ATTRIBUTE_UNUSED__attribute__ ((__unused__))) | |||
778 | { | |||
779 | segment_info_type *seginfo = seg_info (sec); | |||
780 | unsigned int i; | |||
781 | unsigned int n; | |||
782 | arelent **relocs; | |||
783 | fixS *fixp; | |||
784 | char *err; | |||
785 | ||||
786 | /* If seginfo is NULL, we did not create this section; don't do | |||
787 | anything with it. */ | |||
788 | if (seginfo == NULL((void*)0)) | |||
789 | return; | |||
790 | ||||
791 | n = 0; | |||
792 | for (fixp = seginfo->fix_root; fixp; fixp = fixp->fx_next) | |||
793 | n++; | |||
794 | ||||
795 | #ifndef RELOC_EXPANSION_POSSIBLE | |||
796 | /* Set up reloc information as well. */ | |||
797 | relocs = (arelent **) xcalloc (n, sizeof (arelent *)); | |||
798 | ||||
799 | i = 0; | |||
800 | for (fixp = seginfo->fix_root; fixp != (fixS *) NULL((void*)0); fixp = fixp->fx_next) | |||
801 | { | |||
802 | arelent *reloc; | |||
803 | bfd_reloc_status_type s; | |||
804 | symbolS *sym; | |||
805 | ||||
806 | if (fixp->fx_done) | |||
807 | { | |||
808 | n--; | |||
809 | continue; | |||
810 | } | |||
811 | ||||
812 | /* If this is an undefined symbol which was equated to another | |||
813 | symbol, then generate the reloc against the latter symbol | |||
814 | rather than the former. */ | |||
815 | sym = fixp->fx_addsy; | |||
816 | while (symbol_equated_reloc_p (sym)) | |||
817 | { | |||
818 | symbolS *n; | |||
819 | ||||
820 | /* We must avoid looping, as that can occur with a badly | |||
821 | written program. */ | |||
822 | n = symbol_get_value_expression (sym)->X_add_symbol; | |||
823 | if (n == sym) | |||
824 | break; | |||
825 | fixp->fx_offset += symbol_get_value_expression (sym)->X_add_number; | |||
826 | sym = n; | |||
827 | } | |||
828 | fixp->fx_addsy = sym; | |||
829 | ||||
830 | reloc = tc_gen_reloc (sec, fixp); | |||
831 | if (!reloc) | |||
832 | { | |||
833 | n--; | |||
834 | continue; | |||
835 | } | |||
836 | ||||
837 | /* | |||
838 | This test is triggered inappropriately for the SH: | |||
839 | if (fixp->fx_where + fixp->fx_size | |||
840 | > fixp->fx_frag->fr_fix + fixp->fx_frag->fr_offset) | |||
841 | abort (); | |||
842 | */ | |||
843 | ||||
844 | s = bfd_install_relocation (stdoutput, reloc, | |||
845 | fixp->fx_frag->fr_literal, | |||
846 | fixp->fx_frag->fr_address, | |||
847 | sec, &err); | |||
848 | switch (s) | |||
849 | { | |||
850 | case bfd_reloc_ok: | |||
851 | break; | |||
852 | case bfd_reloc_overflow: | |||
853 | as_bad_where (fixp->fx_file, fixp->fx_line, | |||
854 | _("relocation overflow")("relocation overflow")); | |||
855 | break; | |||
856 | case bfd_reloc_outofrange: | |||
857 | as_bad_where (fixp->fx_file, fixp->fx_line, | |||
858 | _("relocation out of range")("relocation out of range")); | |||
859 | break; | |||
860 | default: | |||
861 | as_fatal (_("%s:%u: bad return from bfd_install_relocation: %x")("%s:%u: bad return from bfd_install_relocation: %x"), | |||
862 | fixp->fx_file, fixp->fx_line, s); | |||
863 | } | |||
864 | relocs[i++] = reloc; | |||
865 | } | |||
866 | #else | |||
867 | n = n * MAX_RELOC_EXPANSION; | |||
868 | /* Set up reloc information as well. */ | |||
869 | relocs = (arelent **) xcalloc (n, sizeof (arelent *)); | |||
870 | ||||
871 | i = 0; | |||
872 | for (fixp = seginfo->fix_root; fixp != (fixS *) NULL((void*)0); fixp = fixp->fx_next) | |||
873 | { | |||
874 | arelent **reloc; | |||
875 | bfd_reloc_status_type s; | |||
876 | symbolS *sym; | |||
877 | int j; | |||
878 | ||||
879 | if (fixp->fx_done) | |||
880 | { | |||
881 | n--; | |||
882 | continue; | |||
883 | } | |||
884 | ||||
885 | /* If this is an undefined symbol which was equated to another | |||
886 | symbol, then generate the reloc against the latter symbol | |||
887 | rather than the former. */ | |||
888 | sym = fixp->fx_addsy; | |||
889 | while (symbol_equated_reloc_p (sym)) | |||
890 | { | |||
891 | symbolS *n; | |||
892 | ||||
893 | /* We must avoid looping, as that can occur with a badly | |||
894 | written program. */ | |||
895 | n = symbol_get_value_expression (sym)->X_add_symbol; | |||
896 | if (n == sym) | |||
897 | break; | |||
898 | fixp->fx_offset += symbol_get_value_expression (sym)->X_add_number; | |||
899 | sym = n; | |||
900 | } | |||
901 | fixp->fx_addsy = sym; | |||
902 | ||||
903 | reloc = tc_gen_reloc (sec, fixp); | |||
904 | ||||
905 | for (j = 0; reloc[j]; j++) | |||
906 | { | |||
907 | relocs[i++] = reloc[j]; | |||
908 | assert (i <= n)((void) ((i <= n) ? 0 : (as_assert ("/usr/src/gnu/usr.bin/binutils-2.17/gas/write.c" , 908, __PRETTY_FUNCTION__), 0))); | |||
909 | } | |||
910 | if (fixp->fx_where + fixp->fx_size | |||
911 | > fixp->fx_frag->fr_fix + fixp->fx_frag->fr_offset) | |||
912 | as_bad_where (fixp->fx_file, fixp->fx_line, | |||
913 | _("internal error: fixup not contained within frag")("internal error: fixup not contained within frag")); | |||
914 | for (j = 0; reloc[j]; j++) | |||
915 | { | |||
916 | s = bfd_install_relocation (stdoutput, reloc[j], | |||
917 | fixp->fx_frag->fr_literal, | |||
918 | fixp->fx_frag->fr_address, | |||
919 | sec, &err); | |||
920 | switch (s) | |||
921 | { | |||
922 | case bfd_reloc_ok: | |||
923 | break; | |||
924 | case bfd_reloc_overflow: | |||
925 | as_bad_where (fixp->fx_file, fixp->fx_line, | |||
926 | _("relocation overflow")("relocation overflow")); | |||
927 | break; | |||
928 | case bfd_reloc_outofrange: | |||
929 | as_bad_where (fixp->fx_file, fixp->fx_line, | |||
930 | _("relocation out of range")("relocation out of range")); | |||
931 | break; | |||
932 | default: | |||
933 | as_fatal (_("%s:%u: bad return from bfd_install_relocation: %x")("%s:%u: bad return from bfd_install_relocation: %x"), | |||
934 | fixp->fx_file, fixp->fx_line, s); | |||
935 | } | |||
936 | } | |||
937 | } | |||
938 | n = i; | |||
939 | #endif | |||
940 | ||||
941 | #ifdef DEBUG4 | |||
942 | { | |||
943 | unsigned int i, j, nsyms; | |||
944 | asymbol **sympp; | |||
945 | sympp = bfd_get_outsymbols (stdoutput)((stdoutput)->outsymbols); | |||
946 | nsyms = bfd_get_symcount (stdoutput)((stdoutput)->symcount); | |||
947 | for (i = 0; i < n; i++) | |||
948 | if (((*relocs[i]->sym_ptr_ptr)->flags & BSF_SECTION_SYM0x100) == 0) | |||
949 | { | |||
950 | for (j = 0; j < nsyms; j++) | |||
951 | if (sympp[j] == *relocs[i]->sym_ptr_ptr) | |||
952 | break; | |||
953 | if (j == nsyms) | |||
954 | abort ()as_abort ("/usr/src/gnu/usr.bin/binutils-2.17/gas/write.c", 954 , __PRETTY_FUNCTION__); | |||
955 | } | |||
956 | } | |||
957 | #endif | |||
958 | ||||
959 | if (n) | |||
960 | bfd_set_reloc (stdoutput, sec, relocs, n); | |||
961 | else | |||
962 | bfd_set_section_flags (abfd, sec, | |||
963 | (bfd_get_section_flags (abfd, sec)((sec)->flags + 0) | |||
964 | & (flagword) ~SEC_RELOC0x004)); | |||
965 | ||||
966 | #ifdef SET_SECTION_RELOCS | |||
967 | SET_SECTION_RELOCS (sec, relocs, n); | |||
968 | #endif | |||
969 | ||||
970 | #ifdef DEBUG3 | |||
971 | { | |||
972 | unsigned int i; | |||
973 | arelent *r; | |||
974 | asymbol *s; | |||
975 | fprintf (stderr(&__sF[2]), "relocs for sec %s\n", sec->name); | |||
976 | for (i = 0; i < n; i++) | |||
977 | { | |||
978 | r = relocs[i]; | |||
979 | s = *r->sym_ptr_ptr; | |||
980 | fprintf (stderr(&__sF[2]), " reloc %2d @%p off %4lx : sym %-10s addend %lx\n", | |||
981 | i, r, (unsigned long)r->address, s->name, (unsigned long)r->addend); | |||
982 | } | |||
983 | } | |||
984 | #endif | |||
985 | } | |||
986 | ||||
987 | static void | |||
988 | write_contents (bfd *abfd ATTRIBUTE_UNUSED__attribute__ ((__unused__)), | |||
989 | asection *sec, | |||
990 | PTRvoid * xxx ATTRIBUTE_UNUSED__attribute__ ((__unused__))) | |||
991 | { | |||
992 | segment_info_type *seginfo = seg_info (sec); | |||
993 | addressT offset = 0; | |||
994 | fragS *f; | |||
995 | ||||
996 | /* Write out the frags. */ | |||
997 | if (seginfo == NULL((void*)0) | |||
998 | || !(bfd_get_section_flags (abfd, sec)((sec)->flags + 0) & SEC_HAS_CONTENTS0x100)) | |||
999 | return; | |||
1000 | ||||
1001 | for (f = seginfo->frchainP->frch_root; | |||
1002 | f; | |||
1003 | f = f->fr_next) | |||
1004 | { | |||
1005 | int x; | |||
1006 | addressT fill_size; | |||
1007 | char *fill_literal; | |||
1008 | offsetT count; | |||
1009 | ||||
1010 | assert (f->fr_type == rs_fill)((void) ((f->fr_type == rs_fill) ? 0 : (as_assert ("/usr/src/gnu/usr.bin/binutils-2.17/gas/write.c" , 1010, __PRETTY_FUNCTION__), 0))); | |||
1011 | if (f->fr_fix) | |||
1012 | { | |||
1013 | x = bfd_set_section_contents (stdoutput, sec, | |||
1014 | f->fr_literal, (file_ptr) offset, | |||
1015 | (bfd_size_type) f->fr_fix); | |||
1016 | if (!x) | |||
1017 | { | |||
1018 | bfd_perror (stdoutput->filename); | |||
1019 | as_perror (_("FATAL: Can't write %s")("FATAL: Can't write %s"), stdoutput->filename); | |||
1020 | exit (EXIT_FAILURE1); | |||
1021 | } | |||
1022 | offset += f->fr_fix; | |||
1023 | } | |||
1024 | fill_literal = f->fr_literal + f->fr_fix; | |||
1025 | fill_size = f->fr_var; | |||
1026 | count = f->fr_offset; | |||
1027 | assert (count >= 0)((void) ((count >= 0) ? 0 : (as_assert ("/usr/src/gnu/usr.bin/binutils-2.17/gas/write.c" , 1027, __PRETTY_FUNCTION__), 0))); | |||
1028 | if (fill_size && count) | |||
1029 | { | |||
1030 | char buf[256]; | |||
1031 | if (fill_size > sizeof (buf)) | |||
1032 | { | |||
1033 | /* Do it the old way. Can this ever happen? */ | |||
1034 | while (count--) | |||
1035 | { | |||
1036 | x = bfd_set_section_contents (stdoutput, sec, | |||
1037 | fill_literal, | |||
1038 | (file_ptr) offset, | |||
1039 | (bfd_size_type) fill_size); | |||
1040 | if (!x) | |||
1041 | { | |||
1042 | bfd_perror (stdoutput->filename); | |||
1043 | as_perror (_("FATAL: Can't write %s")("FATAL: Can't write %s"), | |||
1044 | stdoutput->filename); | |||
1045 | exit (EXIT_FAILURE1); | |||
1046 | } | |||
1047 | offset += fill_size; | |||
1048 | } | |||
1049 | } | |||
1050 | else | |||
1051 | { | |||
1052 | /* Build a buffer full of fill objects and output it as | |||
1053 | often as necessary. This saves on the overhead of | |||
1054 | potentially lots of bfd_set_section_contents calls. */ | |||
1055 | int n_per_buf, i; | |||
1056 | if (fill_size == 1) | |||
1057 | { | |||
1058 | n_per_buf = sizeof (buf); | |||
1059 | memset (buf, *fill_literal, n_per_buf); | |||
1060 | } | |||
1061 | else | |||
1062 | { | |||
1063 | char *bufp; | |||
1064 | n_per_buf = sizeof (buf) / fill_size; | |||
1065 | for (i = n_per_buf, bufp = buf; i; i--, bufp += fill_size) | |||
1066 | memcpy (bufp, fill_literal, fill_size); | |||
1067 | } | |||
1068 | for (; count > 0; count -= n_per_buf) | |||
1069 | { | |||
1070 | n_per_buf = n_per_buf > count ? count : n_per_buf; | |||
1071 | x = bfd_set_section_contents | |||
1072 | (stdoutput, sec, buf, (file_ptr) offset, | |||
1073 | (bfd_size_type) n_per_buf * fill_size); | |||
1074 | if (!x) | |||
1075 | as_fatal (_("cannot write to output file")("cannot write to output file")); | |||
1076 | offset += n_per_buf * fill_size; | |||
1077 | } | |||
1078 | } | |||
1079 | } | |||
1080 | } | |||
1081 | } | |||
1082 | ||||
1083 | static void | |||
1084 | merge_data_into_text (void) | |||
1085 | { | |||
1086 | seg_info (text_section)->frchainP->frch_last->fr_next = | |||
1087 | seg_info (data_section)->frchainP->frch_root; | |||
1088 | seg_info (text_section)->frchainP->frch_last = | |||
1089 | seg_info (data_section)->frchainP->frch_last; | |||
1090 | seg_info (data_section)->frchainP = 0; | |||
1091 | } | |||
1092 | ||||
1093 | static void | |||
1094 | set_symtab (void) | |||
1095 | { | |||
1096 | int nsyms; | |||
1097 | asymbol **asympp; | |||
1098 | symbolS *symp; | |||
1099 | bfd_boolean result; | |||
1100 | extern PTRvoid * bfd_alloc (bfd *, bfd_size_type); | |||
1101 | ||||
1102 | /* Count symbols. We can't rely on a count made by the loop in | |||
1103 | write_object_file, because *_frob_file may add a new symbol or | |||
1104 | two. */ | |||
1105 | nsyms = 0; | |||
1106 | for (symp = symbol_rootP; symp; symp = symbol_next (symp)) | |||
1107 | nsyms++; | |||
1108 | ||||
1109 | if (nsyms) | |||
1110 | { | |||
1111 | int i; | |||
1112 | bfd_size_type amt = (bfd_size_type) nsyms * sizeof (asymbol *); | |||
1113 | ||||
1114 | asympp = (asymbol **) bfd_alloc (stdoutput, amt); | |||
1115 | symp = symbol_rootP; | |||
1116 | for (i = 0; i < nsyms; i++, symp = symbol_next (symp)) | |||
1117 | { | |||
1118 | asympp[i] = symbol_get_bfdsym (symp); | |||
1119 | symbol_mark_written (symp); | |||
1120 | } | |||
1121 | } | |||
1122 | else | |||
1123 | asympp = 0; | |||
1124 | result = bfd_set_symtab (stdoutput, asympp, nsyms); | |||
1125 | assert (result)((void) ((result) ? 0 : (as_assert ("/usr/src/gnu/usr.bin/binutils-2.17/gas/write.c" , 1125, __PRETTY_FUNCTION__), 0))); | |||
1126 | symbol_table_frozen = 1; | |||
1127 | } | |||
1128 | ||||
1129 | /* Finish the subsegments. After every sub-segment, we fake an | |||
1130 | ".align ...". This conforms to BSD4.2 brane-damage. We then fake | |||
1131 | ".fill 0" because that is the kind of frag that requires least | |||
1132 | thought. ".align" frags like to have a following frag since that | |||
1133 | makes calculating their intended length trivial. */ | |||
1134 | ||||
1135 | #ifndef SUB_SEGMENT_ALIGN | |||
1136 | #ifdef HANDLE_ALIGN | |||
1137 | /* The last subsegment gets an alignment corresponding to the alignment | |||
1138 | of the section. This allows proper nop-filling at the end of | |||
1139 | code-bearing sections. */ | |||
1140 | #define SUB_SEGMENT_ALIGN(SEG, FRCHAIN)0 \ | |||
1141 | (!(FRCHAIN)->frch_next || (FRCHAIN)->frch_next->frch_seg != (SEG) \ | |||
1142 | ? get_recorded_alignment (SEG) : 0) | |||
1143 | #else | |||
1144 | #define SUB_SEGMENT_ALIGN(SEG, FRCHAIN)0 0 | |||
1145 | #endif | |||
1146 | #endif | |||
1147 | ||||
1148 | void | |||
1149 | subsegs_finish (void) | |||
1150 | { | |||
1151 | struct frchain *frchainP; | |||
1152 | ||||
1153 | for (frchainP = frchain_root; frchainP; frchainP = frchainP->frch_next) | |||
1154 | { | |||
1155 | int alignment = 0; | |||
1156 | ||||
1157 | subseg_set (frchainP->frch_seg, frchainP->frch_subseg); | |||
1158 | ||||
1159 | /* This now gets called even if we had errors. In that case, | |||
1160 | any alignment is meaningless, and, moreover, will look weird | |||
1161 | if we are generating a listing. */ | |||
1162 | if (!had_errors ()) | |||
1163 | { | |||
1164 | alignment = SUB_SEGMENT_ALIGN (now_seg, frchainP)0; | |||
1165 | if ((bfd_get_section_flags (now_seg->owner, now_seg)((now_seg)->flags + 0) & SEC_MERGE0x1000000) | |||
1166 | && now_seg->entsize) | |||
1167 | { | |||
1168 | unsigned int entsize = now_seg->entsize; | |||
1169 | int entalign = 0; | |||
1170 | ||||
1171 | while ((entsize & 1) == 0) | |||
1172 | { | |||
1173 | ++entalign; | |||
1174 | entsize >>= 1; | |||
1175 | } | |||
1176 | if (entalign > alignment) | |||
1177 | alignment = entalign; | |||
1178 | } | |||
1179 | } | |||
1180 | ||||
1181 | if (subseg_text_p (now_seg)) | |||
1182 | frag_align_code (alignment, 0); | |||
1183 | else | |||
1184 | frag_align (alignment, 0, 0); | |||
1185 | ||||
1186 | /* frag_align will have left a new frag. | |||
1187 | Use this last frag for an empty ".fill". | |||
1188 | ||||
1189 | For this segment ... | |||
1190 | Create a last frag. Do not leave a "being filled in frag". */ | |||
1191 | frag_wane (frag_now); | |||
1192 | frag_now->fr_fix = 0; | |||
1193 | know (frag_now->fr_next == NULL); | |||
1194 | } | |||
1195 | } | |||
1196 | ||||
1197 | /* Write the object file. */ | |||
1198 | ||||
1199 | void | |||
1200 | write_object_file (void) | |||
1201 | { | |||
1202 | struct relax_seg_info rsi; | |||
1203 | #ifndef WORKING_DOT_WORD | |||
1204 | fragS *fragP; /* Track along all frags. */ | |||
1205 | #endif | |||
1206 | ||||
1207 | /* Do we really want to write it? */ | |||
1208 | { | |||
1209 | int n_warns, n_errs; | |||
1210 | n_warns = had_warnings (); | |||
1211 | n_errs = had_errors (); | |||
1212 | /* The -Z flag indicates that an object file should be generated, | |||
1213 | regardless of warnings and errors. */ | |||
1214 | if (flag_always_generate_output) | |||
1215 | { | |||
1216 | if (n_warns || n_errs) | |||
1217 | as_warn (_("%d error%s, %d warning%s, generating bad object file")("%d error%s, %d warning%s, generating bad object file"), | |||
1218 | n_errs, n_errs == 1 ? "" : "s", | |||
1219 | n_warns, n_warns == 1 ? "" : "s"); | |||
1220 | } | |||
1221 | else | |||
1222 | { | |||
1223 | if (n_errs) | |||
1224 | as_fatal (_("%d error%s, %d warning%s, no object file generated")("%d error%s, %d warning%s, no object file generated"), | |||
1225 | n_errs, n_errs == 1 ? "" : "s", | |||
1226 | n_warns, n_warns == 1 ? "" : "s"); | |||
1227 | } | |||
1228 | } | |||
1229 | ||||
1230 | #ifdef OBJ_VMS | |||
1231 | /* Under VMS we try to be compatible with VAX-11 "C". Thus, we call | |||
1232 | a routine to check for the definition of the procedure "_main", | |||
1233 | and if so -- fix it up so that it can be program entry point. */ | |||
1234 | vms_check_for_main (); | |||
1235 | #endif /* OBJ_VMS */ | |||
1236 | ||||
1237 | /* From now on, we don't care about sub-segments. Build one frag chain | |||
1238 | for each segment. Linked thru fr_next. */ | |||
1239 | ||||
1240 | /* Remove the sections created by gas for its own purposes. */ | |||
1241 | { | |||
1242 | int i; | |||
1243 | ||||
1244 | bfd_section_list_remove (stdoutput, reg_section)do { asection *_s = reg_section; asection *_next = _s->next ; asection *_prev = _s->prev; if (_prev) _prev->next = _next ; else (stdoutput)->sections = _next; if (_next) _next-> prev = _prev; else (stdoutput)->section_last = _prev; } while (0); | |||
1245 | bfd_section_list_remove (stdoutput, expr_section)do { asection *_s = expr_section; asection *_next = _s->next ; asection *_prev = _s->prev; if (_prev) _prev->next = _next ; else (stdoutput)->sections = _next; if (_next) _next-> prev = _prev; else (stdoutput)->section_last = _prev; } while (0); | |||
1246 | stdoutput->section_count -= 2; | |||
1247 | i = 0; | |||
1248 | bfd_map_over_sections (stdoutput, renumber_sections, &i); | |||
1249 | } | |||
1250 | ||||
1251 | bfd_map_over_sections (stdoutput, chain_frchains_together, (char *) 0); | |||
1252 | ||||
1253 | /* We have two segments. If user gave -R flag, then we must put the | |||
1254 | data frags into the text segment. Do this before relaxing so | |||
1255 | we know to take advantage of -R and make shorter addresses. */ | |||
1256 | if (flag_readonly_data_in_text) | |||
1257 | { | |||
1258 | merge_data_into_text (); | |||
1259 | } | |||
1260 | ||||
1261 | rsi.pass = 0; | |||
1262 | while (1) | |||
1263 | { | |||
1264 | #ifndef WORKING_DOT_WORD | |||
1265 | /* We need to reset the markers in the broken word list and | |||
1266 | associated frags between calls to relax_segment (via | |||
1267 | relax_seg). Since the broken word list is global, we do it | |||
1268 | once per round, rather than locally in relax_segment for each | |||
1269 | segment. */ | |||
1270 | struct broken_word *brokp; | |||
1271 | ||||
1272 | for (brokp = broken_words; | |||
1273 | brokp != (struct broken_word *) NULL((void*)0); | |||
1274 | brokp = brokp->next_broken_word) | |||
1275 | { | |||
1276 | brokp->added = 0; | |||
1277 | ||||
1278 | if (brokp->dispfrag != (fragS *) NULL((void*)0) | |||
1279 | && brokp->dispfrag->fr_type == rs_broken_word) | |||
1280 | brokp->dispfrag->fr_subtype = 0; | |||
1281 | } | |||
1282 | #endif | |||
1283 | ||||
1284 | rsi.changed = 0; | |||
1285 | bfd_map_over_sections (stdoutput, relax_seg, &rsi); | |||
1286 | rsi.pass++; | |||
1287 | if (!rsi.changed) | |||
1288 | break; | |||
1289 | } | |||
1290 | ||||
1291 | /* Note - Most ports will use the default value of | |||
1292 | TC_FINALIZE_SYMS_BEFORE_SIZE_SEG, which 1. This will force | |||
1293 | local symbols to be resolved, removing their frag information. | |||
1294 | Some ports however, will not have finished relaxing all of | |||
1295 | their frags and will still need the local symbol frag | |||
1296 | information. These ports can set | |||
1297 | TC_FINALIZE_SYMS_BEFORE_SIZE_SEG to 0. */ | |||
1298 | finalize_syms = TC_FINALIZE_SYMS_BEFORE_SIZE_SEG1; | |||
1299 | ||||
1300 | bfd_map_over_sections (stdoutput, size_seg, (char *) 0); | |||
1301 | ||||
1302 | /* Relaxation has completed. Freeze all syms. */ | |||
1303 | finalize_syms = 1; | |||
1304 | ||||
1305 | #ifdef md_post_relax_hook | |||
1306 | md_post_relax_hook; | |||
1307 | #endif | |||
1308 | ||||
1309 | #ifndef WORKING_DOT_WORD | |||
1310 | { | |||
1311 | struct broken_word *lie; | |||
1312 | struct broken_word **prevP; | |||
1313 | ||||
1314 | prevP = &broken_words; | |||
1315 | for (lie = broken_words; lie; lie = lie->next_broken_word) | |||
1316 | if (!lie->added) | |||
1317 | { | |||
1318 | expressionS exp; | |||
1319 | ||||
1320 | subseg_change (lie->seg, lie->subseg); | |||
1321 | exp.X_op = O_subtract; | |||
1322 | exp.X_add_symbol = lie->add; | |||
1323 | exp.X_op_symbol = lie->sub; | |||
1324 | exp.X_add_number = lie->addnum; | |||
1325 | #ifdef TC_CONS_FIX_NEW | |||
1326 | TC_CONS_FIX_NEW (lie->frag,x86_cons_fix_new(lie->frag, lie->word_goes_here - lie-> frag->fr_literal, 2, &exp) | |||
1327 | lie->word_goes_here - lie->frag->fr_literal,x86_cons_fix_new(lie->frag, lie->word_goes_here - lie-> frag->fr_literal, 2, &exp) | |||
1328 | 2, &exp)x86_cons_fix_new(lie->frag, lie->word_goes_here - lie-> frag->fr_literal, 2, &exp); | |||
1329 | #else | |||
1330 | fix_new_exp (lie->frag, | |||
1331 | lie->word_goes_here - lie->frag->fr_literal, | |||
1332 | 2, &exp, 0, BFD_RELOC_16); | |||
1333 | #endif | |||
1334 | *prevP = lie->next_broken_word; | |||
1335 | } | |||
1336 | else | |||
1337 | prevP = &(lie->next_broken_word); | |||
1338 | ||||
1339 | for (lie = broken_words; lie;) | |||
1340 | { | |||
1341 | struct broken_word *untruth; | |||
1342 | char *table_ptr; | |||
1343 | addressT table_addr; | |||
1344 | addressT from_addr, to_addr; | |||
1345 | int n, m; | |||
1346 | ||||
1347 | subseg_change (lie->seg, lie->subseg); | |||
1348 | fragP = lie->dispfrag; | |||
1349 | ||||
1350 | /* Find out how many broken_words go here. */ | |||
1351 | n = 0; | |||
1352 | for (untruth = lie; | |||
1353 | untruth && untruth->dispfrag == fragP; | |||
1354 | untruth = untruth->next_broken_word) | |||
1355 | if (untruth->added == 1) | |||
1356 | n++; | |||
1357 | ||||
1358 | table_ptr = lie->dispfrag->fr_opcode; | |||
1359 | table_addr = (lie->dispfrag->fr_address | |||
1360 | + (table_ptr - lie->dispfrag->fr_literal)); | |||
1361 | /* Create the jump around the long jumps. This is a short | |||
1362 | jump from table_ptr+0 to table_ptr+n*long_jump_size. */ | |||
1363 | from_addr = table_addr; | |||
1364 | to_addr = table_addr + md_short_jump_size + n * md_long_jump_size; | |||
1365 | md_create_short_jump (table_ptr, from_addr, to_addr, lie->dispfrag, | |||
1366 | lie->add); | |||
1367 | table_ptr += md_short_jump_size; | |||
1368 | table_addr += md_short_jump_size; | |||
1369 | ||||
1370 | for (m = 0; | |||
1371 | lie && lie->dispfrag == fragP; | |||
1372 | m++, lie = lie->next_broken_word) | |||
1373 | { | |||
1374 | if (lie->added == 2) | |||
1375 | continue; | |||
1376 | /* Patch the jump table. */ | |||
1377 | /* This is the offset from ??? to table_ptr+0. */ | |||
1378 | to_addr = table_addr - S_GET_VALUE (lie->sub); | |||
1379 | #ifdef TC_CHECK_ADJUSTED_BROKEN_DOT_WORD | |||
1380 | TC_CHECK_ADJUSTED_BROKEN_DOT_WORD (to_addr, lie); | |||
1381 | #endif | |||
1382 | md_number_to_charsnumber_to_chars_littleendian (lie->word_goes_here, to_addr, 2); | |||
1383 | for (untruth = lie->next_broken_word; | |||
1384 | untruth && untruth->dispfrag == fragP; | |||
1385 | untruth = untruth->next_broken_word) | |||
1386 | { | |||
1387 | if (untruth->use_jump == lie) | |||
1388 | md_number_to_charsnumber_to_chars_littleendian (untruth->word_goes_here, to_addr, 2); | |||
1389 | } | |||
1390 | ||||
1391 | /* Install the long jump. */ | |||
1392 | /* This is a long jump from table_ptr+0 to the final target. */ | |||
1393 | from_addr = table_addr; | |||
1394 | to_addr = S_GET_VALUE (lie->add) + lie->addnum; | |||
1395 | md_create_long_jump (table_ptr, from_addr, to_addr, lie->dispfrag, | |||
1396 | lie->add); | |||
1397 | table_ptr += md_long_jump_size; | |||
1398 | table_addr += md_long_jump_size; | |||
1399 | } | |||
1400 | } | |||
1401 | } | |||
1402 | #endif /* not WORKING_DOT_WORD */ | |||
1403 | ||||
1404 | /* Resolve symbol values. This needs to be done before processing | |||
1405 | the relocations. */ | |||
1406 | if (symbol_rootP) | |||
1407 | { | |||
1408 | symbolS *symp; | |||
1409 | ||||
1410 | for (symp = symbol_rootP; symp; symp = symbol_next (symp)) | |||
1411 | resolve_symbol_value (symp); | |||
1412 | } | |||
1413 | resolve_local_symbol_values (); | |||
1414 | ||||
1415 | PROGRESS (1); | |||
1416 | ||||
1417 | #ifdef tc_frob_file_before_adjust | |||
1418 | tc_frob_file_before_adjust (); | |||
1419 | #endif | |||
1420 | #ifdef obj_frob_file_before_adjustelf_frob_file_before_adjust | |||
1421 | obj_frob_file_before_adjustelf_frob_file_before_adjust (); | |||
1422 | #endif | |||
1423 | ||||
1424 | bfd_map_over_sections (stdoutput, adjust_reloc_syms, (char *) 0); | |||
1425 | ||||
1426 | #ifdef tc_frob_file_before_fix | |||
1427 | tc_frob_file_before_fix (); | |||
1428 | #endif | |||
1429 | #ifdef obj_frob_file_before_fix | |||
1430 | obj_frob_file_before_fix (); | |||
1431 | #endif | |||
1432 | ||||
1433 | bfd_map_over_sections (stdoutput, fix_segment, (char *) 0); | |||
1434 | ||||
1435 | /* Set up symbol table, and write it out. */ | |||
1436 | if (symbol_rootP) | |||
1437 | { | |||
1438 | symbolS *symp; | |||
1439 | bfd_boolean skip_next_symbol = FALSE0; | |||
1440 | ||||
1441 | for (symp = symbol_rootP; symp; symp = symbol_next (symp)) | |||
1442 | { | |||
1443 | int punt = 0; | |||
1444 | const char *name; | |||
1445 | ||||
1446 | if (skip_next_symbol) | |||
1447 | { | |||
1448 | /* Don't do anything besides moving the value of the | |||
1449 | symbol from the GAS value-field to the BFD value-field. */ | |||
1450 | symbol_get_bfdsym (symp)->value = S_GET_VALUE (symp); | |||
1451 | skip_next_symbol = FALSE0; | |||
1452 | continue; | |||
1453 | } | |||
1454 | ||||
1455 | if (symbol_mri_common_p (symp)) | |||
1456 | { | |||
1457 | if (S_IS_EXTERNAL (symp)) | |||
1458 | as_bad (_("%s: global symbols not supported in common sections")("%s: global symbols not supported in common sections"), | |||
1459 | S_GET_NAME (symp)); | |||
1460 | symbol_remove (symp, &symbol_rootP, &symbol_lastP); | |||
1461 | continue; | |||
1462 | } | |||
1463 | ||||
1464 | name = S_GET_NAME (symp); | |||
1465 | if (name) | |||
1466 | { | |||
1467 | const char *name2 = | |||
1468 | decode_local_label_name ((char *) S_GET_NAME (symp)); | |||
1469 | /* They only differ if `name' is a fb or dollar local | |||
1470 | label name. */ | |||
1471 | if (name2 != name && ! S_IS_DEFINED (symp)) | |||
1472 | as_bad (_("local label `%s' is not defined")("local label `%s' is not defined"), name2); | |||
1473 | } | |||
1474 | ||||
1475 | /* Do it again, because adjust_reloc_syms might introduce | |||
1476 | more symbols. They'll probably only be section symbols, | |||
1477 | but they'll still need to have the values computed. */ | |||
1478 | resolve_symbol_value (symp); | |||
1479 | ||||
1480 | /* Skip symbols which were equated to undefined or common | |||
1481 | symbols. */ | |||
1482 | if (symbol_equated_reloc_p (symp) | |||
1483 | || S_IS_WEAKREFR (symp)) | |||
1484 | { | |||
1485 | const char *name = S_GET_NAME (symp); | |||
1486 | if (S_IS_COMMON (symp) | |||
1487 | && !TC_FAKE_LABEL (name)(strcmp ((name), "L0\001") == 0) | |||
1488 | && !S_IS_WEAKREFR (symp) | |||
1489 | && (!S_IS_EXTERNAL (symp) || S_IS_LOCAL (symp))) | |||
1490 | { | |||
1491 | expressionS *e = symbol_get_value_expression (symp); | |||
1492 | as_bad (_("Local symbol `%s' can't be equated to common symbol `%s'")("Local symbol `%s' can't be equated to common symbol `%s'"), | |||
1493 | name, S_GET_NAME (e->X_add_symbol)); | |||
1494 | } | |||
1495 | symbol_remove (symp, &symbol_rootP, &symbol_lastP); | |||
1496 | continue; | |||
1497 | } | |||
1498 | ||||
1499 | #ifdef obj_frob_symbol | |||
1500 | obj_frob_symbol (symp, punt)elf_frob_symbol (symp, &punt); | |||
1501 | #endif | |||
1502 | #ifdef tc_frob_symbol | |||
1503 | if (! punt || symbol_used_in_reloc_p (symp)) | |||
1504 | tc_frob_symbol (symp, punt); | |||
1505 | #endif | |||
1506 | ||||
1507 | /* If we don't want to keep this symbol, splice it out of | |||
1508 | the chain now. If EMIT_SECTION_SYMBOLS is 0, we never | |||
1509 | want section symbols. Otherwise, we skip local symbols | |||
1510 | and symbols that the frob_symbol macros told us to punt, | |||
1511 | but we keep such symbols if they are used in relocs. */ | |||
1512 | if (symp == abs_section_sym | |||
1513 | || (! EMIT_SECTION_SYMBOLS1 | |||
1514 | && symbol_section_p (symp)) | |||
1515 | /* Note that S_IS_EXTERNAL and S_IS_LOCAL are not always | |||
1516 | opposites. Sometimes the former checks flags and the | |||
1517 | latter examines the name... */ | |||
1518 | || (!S_IS_EXTERNAL (symp) | |||
1519 | && (punt || S_IS_LOCAL (symp) || | |||
1520 | (S_IS_WEAKREFD (symp) && ! symbol_used_p (symp))) | |||
1521 | && ! symbol_used_in_reloc_p (symp))) | |||
1522 | { | |||
1523 | symbol_remove (symp, &symbol_rootP, &symbol_lastP); | |||
1524 | ||||
1525 | /* After symbol_remove, symbol_next(symp) still returns | |||
1526 | the one that came after it in the chain. So we don't | |||
1527 | need to do any extra cleanup work here. */ | |||
1528 | continue; | |||
1529 | } | |||
1530 | ||||
1531 | /* Make sure we really got a value for the symbol. */ | |||
1532 | if (! symbol_resolved_p (symp)) | |||
1533 | { | |||
1534 | as_bad (_("can't resolve value for symbol `%s'")("can't resolve value for symbol `%s'"), | |||
1535 | S_GET_NAME (symp)); | |||
1536 | symbol_mark_resolved (symp); | |||
1537 | } | |||
1538 | ||||
1539 | /* Set the value into the BFD symbol. Up til now the value | |||
1540 | has only been kept in the gas symbolS struct. */ | |||
1541 | symbol_get_bfdsym (symp)->value = S_GET_VALUE (symp); | |||
1542 | ||||
1543 | /* A warning construct is a warning symbol followed by the | |||
1544 | symbol warned about. Don't let anything object-format or | |||
1545 | target-specific muck with it; it's ready for output. */ | |||
1546 | if (symbol_get_bfdsym (symp)->flags & BSF_WARNING0x1000) | |||
1547 | skip_next_symbol = TRUE1; | |||
1548 | } | |||
1549 | } | |||
1550 | ||||
1551 | PROGRESS (1); | |||
1552 | ||||
1553 | /* Now do any format-specific adjustments to the symbol table, such | |||
1554 | as adding file symbols. */ | |||
1555 | #ifdef tc_adjust_symtab | |||
1556 | tc_adjust_symtab (); | |||
1557 | #endif | |||
1558 | #ifdef obj_adjust_symtab | |||
1559 | obj_adjust_symtab (); | |||
1560 | #endif | |||
1561 | ||||
1562 | /* Now that all the sizes are known, and contents correct, we can | |||
1563 | start writing to the file. */ | |||
1564 | set_symtab (); | |||
1565 | ||||
1566 | /* If *_frob_file changes the symbol value at this point, it is | |||
1567 | responsible for moving the changed value into symp->bsym->value | |||
1568 | as well. Hopefully all symbol value changing can be done in | |||
1569 | *_frob_symbol. */ | |||
1570 | #ifdef tc_frob_file | |||
1571 | tc_frob_file (); | |||
1572 | #endif | |||
1573 | #ifdef obj_frob_fileelf_frob_file | |||
1574 | obj_frob_fileelf_frob_file (); | |||
1575 | #endif | |||
1576 | ||||
1577 | bfd_map_over_sections (stdoutput, write_relocs, (char *) 0); | |||
1578 | ||||
1579 | #ifdef tc_frob_file_after_relocs | |||
1580 | tc_frob_file_after_relocs (); | |||
1581 | #endif | |||
1582 | #ifdef obj_frob_file_after_relocself_frob_file_after_relocs | |||
1583 | obj_frob_file_after_relocself_frob_file_after_relocs (); | |||
1584 | #endif | |||
1585 | ||||
1586 | bfd_map_over_sections (stdoutput, write_contents, (char *) 0); | |||
1587 | } | |||
1588 | ||||
1589 | #ifdef TC_GENERIC_RELAX_TABLEmd_relax_table | |||
1590 | /* Relax a fragment by scanning TC_GENERIC_RELAX_TABLE. */ | |||
1591 | ||||
1592 | long | |||
1593 | relax_frag (segT segment, fragS *fragP, long stretch) | |||
1594 | { | |||
1595 | const relax_typeS *this_type; | |||
1596 | const relax_typeS *start_type; | |||
1597 | relax_substateT next_state; | |||
1598 | relax_substateT this_state; | |||
1599 | offsetT growth; | |||
1600 | offsetT aim; | |||
1601 | addressT target; | |||
1602 | addressT address; | |||
1603 | symbolS *symbolP; | |||
1604 | const relax_typeS *table; | |||
1605 | ||||
1606 | target = fragP->fr_offset; | |||
1607 | address = fragP->fr_address; | |||
1608 | table = TC_GENERIC_RELAX_TABLEmd_relax_table; | |||
1609 | this_state = fragP->fr_subtype; | |||
1610 | start_type = this_type = table + this_state; | |||
1611 | symbolP = fragP->fr_symbol; | |||
1612 | ||||
1613 | if (symbolP) | |||
1614 | { | |||
1615 | fragS *sym_frag; | |||
1616 | ||||
1617 | sym_frag = symbol_get_frag (symbolP); | |||
1618 | ||||
1619 | #ifndef DIFF_EXPR_OK | |||
1620 | know (sym_frag != NULL); | |||
1621 | #endif | |||
1622 | know (S_GET_SEGMENT (symbolP) != absolute_section | |||
1623 | || sym_frag == &zero_address_frag); | |||
1624 | target += S_GET_VALUE (symbolP); | |||
1625 | ||||
1626 | /* If frag has yet to be reached on this pass, | |||
1627 | assume it will move by STRETCH just as we did. | |||
1628 | If this is not so, it will be because some frag | |||
1629 | between grows, and that will force another pass. */ | |||
1630 | ||||
1631 | if (stretch != 0 | |||
1632 | && sym_frag->relax_marker != fragP->relax_marker | |||
1633 | && S_GET_SEGMENT (symbolP) == segment) | |||
1634 | { | |||
1635 | target += stretch; | |||
1636 | } | |||
1637 | } | |||
1638 | ||||
1639 | aim = target - address - fragP->fr_fix; | |||
1640 | #ifdef TC_PCREL_ADJUST | |||
1641 | /* Currently only the ns32k family needs this. */ | |||
1642 | aim += TC_PCREL_ADJUST (fragP); | |||
1643 | #endif | |||
1644 | ||||
1645 | #ifdef md_prepare_relax_scan | |||
1646 | /* Formerly called M68K_AIM_KLUDGE. */ | |||
1647 | md_prepare_relax_scan (fragP, address, aim, this_state, this_type); | |||
1648 | #endif | |||
1649 | ||||
1650 | if (aim < 0) | |||
1651 | { | |||
1652 | /* Look backwards. */ | |||
1653 | for (next_state = this_type->rlx_more; next_state;) | |||
1654 | if (aim >= this_type->rlx_backward) | |||
1655 | next_state = 0; | |||
1656 | else | |||
1657 | { | |||
1658 | /* Grow to next state. */ | |||
1659 | this_state = next_state; | |||
1660 | this_type = table + this_state; | |||
1661 | next_state = this_type->rlx_more; | |||
1662 | } | |||
1663 | } | |||
1664 | else | |||
1665 | { | |||
1666 | /* Look forwards. */ | |||
1667 | for (next_state = this_type->rlx_more; next_state;) | |||
1668 | if (aim <= this_type->rlx_forward) | |||
1669 | next_state = 0; | |||
1670 | else | |||
1671 | { | |||
1672 | /* Grow to next state. */ | |||
1673 | this_state = next_state; | |||
1674 | this_type = table + this_state; | |||
1675 | next_state = this_type->rlx_more; | |||
1676 | } | |||
1677 | } | |||
1678 | ||||
1679 | growth = this_type->rlx_length - start_type->rlx_length; | |||
1680 | if (growth != 0) | |||
1681 | fragP->fr_subtype = this_state; | |||
1682 | return growth; | |||
1683 | } | |||
1684 | ||||
1685 | #endif /* defined (TC_GENERIC_RELAX_TABLE) */ | |||
1686 | ||||
1687 | /* Relax_align. Advance location counter to next address that has 'alignment' | |||
1688 | lowest order bits all 0s, return size of adjustment made. */ | |||
1689 | static relax_addressT | |||
1690 | relax_align (register relax_addressT address, /* Address now. */ | |||
1691 | register int alignment /* Alignment (binary). */) | |||
1692 | { | |||
1693 | relax_addressT mask; | |||
1694 | relax_addressT new_address; | |||
1695 | ||||
1696 | mask = ~((~0) << alignment); | |||
1697 | new_address = (address + mask) & (~mask); | |||
1698 | #ifdef LINKER_RELAXING_SHRINKS_ONLY | |||
1699 | if (linkrelax) | |||
1700 | /* We must provide lots of padding, so the linker can discard it | |||
1701 | when needed. The linker will not add extra space, ever. */ | |||
1702 | new_address += (1 << alignment); | |||
1703 | #endif | |||
1704 | return (new_address - address); | |||
1705 | } | |||
1706 | ||||
1707 | /* Now we have a segment, not a crowd of sub-segments, we can make | |||
1708 | fr_address values. | |||
1709 | ||||
1710 | Relax the frags. | |||
1711 | ||||
1712 | After this, all frags in this segment have addresses that are correct | |||
1713 | within the segment. Since segments live in different file addresses, | |||
1714 | these frag addresses may not be the same as final object-file | |||
1715 | addresses. */ | |||
1716 | ||||
1717 | int | |||
1718 | relax_segment (struct frag *segment_frag_root, segT segment, int pass) | |||
1719 | { | |||
1720 | unsigned long frag_count; | |||
1721 | struct frag *fragP; | |||
1722 | relax_addressT address; | |||
1723 | int ret; | |||
1724 | ||||
1725 | /* In case md_estimate_size_before_relax() wants to make fixSs. */ | |||
1726 | subseg_change (segment, 0); | |||
1727 | ||||
1728 | /* For each frag in segment: count and store (a 1st guess of) | |||
1729 | fr_address. */ | |||
1730 | address = 0; | |||
1731 | for (frag_count = 0, fragP = segment_frag_root; | |||
| ||||
1732 | fragP; | |||
1733 | fragP = fragP->fr_next, frag_count ++) | |||
1734 | { | |||
1735 | fragP->relax_marker = 0; | |||
1736 | fragP->fr_address = address; | |||
1737 | address += fragP->fr_fix; | |||
1738 | ||||
1739 | switch (fragP->fr_type) | |||
1740 | { | |||
1741 | case rs_fill: | |||
1742 | address += fragP->fr_offset * fragP->fr_var; | |||
1743 | break; | |||
1744 | ||||
1745 | case rs_align: | |||
1746 | case rs_align_code: | |||
1747 | case rs_align_test: | |||
1748 | { | |||
1749 | addressT offset = relax_align (address, (int) fragP->fr_offset); | |||
1750 | ||||
1751 | if (fragP->fr_subtype != 0 && offset > fragP->fr_subtype) | |||
1752 | offset = 0; | |||
1753 | ||||
1754 | if (offset % fragP->fr_var != 0) | |||
1755 | { | |||
1756 | as_bad_where (fragP->fr_file, fragP->fr_line, | |||
1757 | _("alignment padding (%lu bytes) not a multiple of %ld")("alignment padding (%lu bytes) not a multiple of %ld"), | |||
1758 | (unsigned long) offset, (long) fragP->fr_var); | |||
1759 | offset -= (offset % fragP->fr_var); | |||
1760 | } | |||
1761 | ||||
1762 | address += offset; | |||
1763 | } | |||
1764 | break; | |||
1765 | ||||
1766 | case rs_org: | |||
1767 | case rs_space: | |||
1768 | /* Assume .org is nugatory. It will grow with 1st relax. */ | |||
1769 | break; | |||
1770 | ||||
1771 | case rs_machine_dependent: | |||
1772 | /* If fr_symbol is an expression, this call to | |||
1773 | resolve_symbol_value sets up the correct segment, which will | |||
1774 | likely be needed in md_estimate_size_before_relax. */ | |||
1775 | if (fragP->fr_symbol) | |||
1776 | resolve_symbol_value (fragP->fr_symbol); | |||
1777 | ||||
1778 | address += md_estimate_size_before_relax (fragP, segment); | |||
1779 | break; | |||
1780 | ||||
1781 | #ifndef WORKING_DOT_WORD | |||
1782 | /* Broken words don't concern us yet. */ | |||
1783 | case rs_broken_word: | |||
1784 | break; | |||
1785 | #endif | |||
1786 | ||||
1787 | case rs_leb128: | |||
1788 | /* Initial guess is always 1; doing otherwise can result in | |||
1789 | stable solutions that are larger than the minimum. */ | |||
1790 | address += fragP->fr_offset = 1; | |||
1791 | break; | |||
1792 | ||||
1793 | case rs_cfa: | |||
1794 | address += eh_frame_estimate_size_before_relax (fragP); | |||
1795 | break; | |||
1796 | ||||
1797 | case rs_dwarf2dbg: | |||
1798 | address += dwarf2dbg_estimate_size_before_relax (fragP); | |||
1799 | break; | |||
1800 | ||||
1801 | default: | |||
1802 | BAD_CASE (fragP->fr_type){ as_fatal (("Case value %ld unexpected at line %d of file \"%s\"\n" ), (long) fragP->fr_type, 1802, "/usr/src/gnu/usr.bin/binutils-2.17/gas/write.c" ); }; | |||
1803 | break; | |||
1804 | } | |||
1805 | } | |||
1806 | ||||
1807 | /* Do relax(). */ | |||
1808 | { | |||
1809 | unsigned long max_iterations; | |||
1810 | offsetT stretch; /* May be any size, 0 or negative. */ | |||
1811 | /* Cumulative number of addresses we have relaxed this pass. | |||
1812 | We may have relaxed more than one address. */ | |||
1813 | int stretched; /* Have we stretched on this pass? */ | |||
1814 | /* This is 'cuz stretch may be zero, when, in fact some piece of code | |||
1815 | grew, and another shrank. If a branch instruction doesn't fit anymore, | |||
1816 | we could be scrod. */ | |||
1817 | ||||
1818 | /* We want to prevent going into an infinite loop where one frag grows | |||
1819 | depending upon the location of a symbol which is in turn moved by | |||
1820 | the growing frag. eg: | |||
1821 | ||||
1822 | foo = . | |||
1823 | .org foo+16 | |||
1824 | foo = . | |||
1825 | ||||
1826 | So we dictate that this algorithm can be at most O2. */ | |||
1827 | max_iterations = frag_count * frag_count; | |||
1828 | /* Check for overflow. */ | |||
1829 | if (max_iterations
| |||
1830 | max_iterations = frag_count; | |||
1831 | ||||
1832 | ret = 0; | |||
1833 | do | |||
1834 | { | |||
1835 | stretch = 0; | |||
1836 | stretched = 0; | |||
1837 | ||||
1838 | for (fragP = segment_frag_root; fragP; fragP = fragP->fr_next) | |||
1839 | { | |||
1840 | offsetT growth = 0; | |||
1841 | addressT was_address; | |||
1842 | offsetT offset; | |||
1843 | symbolS *symbolP; | |||
1844 | ||||
1845 | fragP->relax_marker ^= 1; | |||
1846 | was_address = fragP->fr_address; | |||
1847 | address = fragP->fr_address += stretch; | |||
1848 | symbolP = fragP->fr_symbol; | |||
1849 | offset = fragP->fr_offset; | |||
1850 | ||||
1851 | switch (fragP->fr_type) | |||
1852 | { | |||
1853 | case rs_fill: /* .fill never relaxes. */ | |||
1854 | growth = 0; | |||
1855 | break; | |||
1856 | ||||
1857 | #ifndef WORKING_DOT_WORD | |||
1858 | /* JF: This is RMS's idea. I do *NOT* want to be blamed | |||
1859 | for it I do not want to write it. I do not want to have | |||
1860 | anything to do with it. This is not the proper way to | |||
1861 | implement this misfeature. */ | |||
1862 | case rs_broken_word: | |||
1863 | { | |||
1864 | struct broken_word *lie; | |||
1865 | struct broken_word *untruth; | |||
1866 | ||||
1867 | /* Yes this is ugly (storing the broken_word pointer | |||
1868 | in the symbol slot). Still, this whole chunk of | |||
1869 | code is ugly, and I don't feel like doing anything | |||
1870 | about it. Think of it as stubbornness in action. */ | |||
1871 | growth = 0; | |||
1872 | for (lie = (struct broken_word *) (fragP->fr_symbol); | |||
1873 | lie && lie->dispfrag == fragP; | |||
1874 | lie = lie->next_broken_word) | |||
1875 | { | |||
1876 | ||||
1877 | if (lie->added) | |||
1878 | continue; | |||
1879 | ||||
1880 | offset = (S_GET_VALUE (lie->add) | |||
1881 | + lie->addnum | |||
1882 | - S_GET_VALUE (lie->sub)); | |||
1883 | if (offset <= -32768 || offset >= 32767) | |||
1884 | { | |||
1885 | if (flag_warn_displacement) | |||
1886 | { | |||
1887 | char buf[50]; | |||
1888 | sprint_value (buf, (addressT) lie->addnum); | |||
1889 | as_warn_where (fragP->fr_file, fragP->fr_line, | |||
1890 | _(".word %s-%s+%s didn't fit")(".word %s-%s+%s didn't fit"), | |||
1891 | S_GET_NAME (lie->add), | |||
1892 | S_GET_NAME (lie->sub), | |||
1893 | buf); | |||
1894 | } | |||
1895 | lie->added = 1; | |||
1896 | if (fragP->fr_subtype == 0) | |||
1897 | { | |||
1898 | fragP->fr_subtype++; | |||
1899 | growth += md_short_jump_size; | |||
1900 | } | |||
1901 | for (untruth = lie->next_broken_word; | |||
1902 | untruth && untruth->dispfrag == lie->dispfrag; | |||
1903 | untruth = untruth->next_broken_word) | |||
1904 | if ((symbol_get_frag (untruth->add) | |||
1905 | == symbol_get_frag (lie->add)) | |||
1906 | && (S_GET_VALUE (untruth->add) | |||
1907 | == S_GET_VALUE (lie->add))) | |||
1908 | { | |||
1909 | untruth->added = 2; | |||
1910 | untruth->use_jump = lie; | |||
1911 | } | |||
1912 | growth += md_long_jump_size; | |||
1913 | } | |||
1914 | } | |||
1915 | ||||
1916 | break; | |||
1917 | } /* case rs_broken_word */ | |||
1918 | #endif | |||
1919 | case rs_align: | |||
1920 | case rs_align_code: | |||
1921 | case rs_align_test: | |||
1922 | { | |||
1923 | addressT oldoff, newoff; | |||
1924 | ||||
1925 | oldoff = relax_align (was_address + fragP->fr_fix, | |||
1926 | (int) offset); | |||
1927 | newoff = relax_align (address + fragP->fr_fix, | |||
1928 | (int) offset); | |||
1929 | ||||
1930 | if (fragP->fr_subtype != 0) | |||
1931 | { | |||
1932 | if (oldoff > fragP->fr_subtype) | |||
1933 | oldoff = 0; | |||
1934 | if (newoff > fragP->fr_subtype) | |||
1935 | newoff = 0; | |||
1936 | } | |||
1937 | ||||
1938 | growth = newoff - oldoff; | |||
1939 | } | |||
1940 | break; | |||
1941 | ||||
1942 | case rs_org: | |||
1943 | { | |||
1944 | addressT target = offset; | |||
1945 | addressT after; | |||
1946 | ||||
1947 | if (symbolP) | |||
1948 | { | |||
1949 | /* Convert from an actual address to an octet offset | |||
1950 | into the section. Here it is assumed that the | |||
1951 | section's VMA is zero, and can omit subtracting it | |||
1952 | from the symbol's value to get the address offset. */ | |||
1953 | know (S_GET_SEGMENT (symbolP)->vma == 0); | |||
1954 | target += S_GET_VALUE (symbolP) * OCTETS_PER_BYTE(1<<0); | |||
1955 | } | |||
1956 | ||||
1957 | know (fragP->fr_next); | |||
1958 | after = fragP->fr_next->fr_address; | |||
1959 | growth = target - after; | |||
1960 | if (growth < 0) | |||
1961 | { | |||
1962 | growth = 0; | |||
1963 | ||||
1964 | /* Don't error on first few frag relax passes. | |||
1965 | The symbol might be an expression involving | |||
1966 | symbol values from other sections. If those | |||
1967 | sections have not yet been processed their | |||
1968 | frags will all have zero addresses, so we | |||
1969 | will calculate incorrect values for them. The | |||
1970 | number of passes we allow before giving an | |||
1971 | error is somewhat arbitrary. It should be at | |||
1972 | least one, with larger values requiring | |||
1973 | increasingly contrived dependencies between | |||
1974 | frags to trigger a false error. */ | |||
1975 | if (pass < 2) | |||
1976 | { | |||
1977 | /* Force another pass. */ | |||
1978 | ret = 1; | |||
1979 | break; | |||
1980 | } | |||
1981 | ||||
1982 | /* Growth may be negative, but variable part of frag | |||
1983 | cannot have fewer than 0 chars. That is, we can't | |||
1984 | .org backwards. */ | |||
1985 | as_bad_where (fragP->fr_file, fragP->fr_line, | |||
1986 | _("attempt to move .org backwards")("attempt to move .org backwards")); | |||
1987 | ||||
1988 | /* We've issued an error message. Change the | |||
1989 | frag to avoid cascading errors. */ | |||
1990 | fragP->fr_type = rs_align; | |||
1991 | fragP->fr_subtype = 0; | |||
1992 | fragP->fr_offset = 0; | |||
1993 | fragP->fr_fix = after - was_address; | |||
1994 | break; | |||
1995 | } | |||
1996 | ||||
1997 | /* This is an absolute growth factor */ | |||
1998 | growth -= stretch; | |||
1999 | break; | |||
2000 | } | |||
2001 | ||||
2002 | case rs_space: | |||
2003 | growth = 0; | |||
2004 | if (symbolP) | |||
2005 | { | |||
2006 | offsetT amount; | |||
2007 | ||||
2008 | amount = S_GET_VALUE (symbolP); | |||
2009 | if (S_GET_SEGMENT (symbolP) != absolute_section((asection *) &bfd_abs_section) | |||
2010 | || S_IS_COMMON (symbolP) | |||
2011 | || ! S_IS_DEFINED (symbolP)) | |||
2012 | { | |||
2013 | as_bad_where (fragP->fr_file, fragP->fr_line, | |||
2014 | _(".space specifies non-absolute value")(".space specifies non-absolute value")); | |||
2015 | /* Prevent repeat of this error message. */ | |||
2016 | fragP->fr_symbol = 0; | |||
2017 | } | |||
2018 | else if (amount
| |||
2019 | { | |||
2020 | /* Don't error on first few frag relax passes. | |||
2021 | See rs_org comment for a longer explanation. */ | |||
2022 | if (pass < 2) | |||
2023 | { | |||
2024 | ret = 1; | |||
2025 | break; | |||
2026 | } | |||
2027 | ||||
2028 | as_warn_where (fragP->fr_file, fragP->fr_line, | |||
2029 | _(".space or .fill with negative value, ignored")(".space or .fill with negative value, ignored")); | |||
2030 | fragP->fr_symbol = 0; | |||
2031 | } | |||
2032 | else | |||
2033 | growth = (was_address + fragP->fr_fix + amount | |||
2034 | - fragP->fr_next->fr_address); | |||
| ||||
2035 | } | |||
2036 | break; | |||
2037 | ||||
2038 | case rs_machine_dependent: | |||
2039 | #ifdef md_relax_frag | |||
2040 | growth = md_relax_frag (segment, fragP, stretch); | |||
2041 | #else | |||
2042 | #ifdef TC_GENERIC_RELAX_TABLEmd_relax_table | |||
2043 | /* The default way to relax a frag is to look through | |||
2044 | TC_GENERIC_RELAX_TABLE. */ | |||
2045 | growth = relax_frag (segment, fragP, stretch); | |||
2046 | #endif /* TC_GENERIC_RELAX_TABLE */ | |||
2047 | #endif | |||
2048 | break; | |||
2049 | ||||
2050 | case rs_leb128: | |||
2051 | { | |||
2052 | valueT value; | |||
2053 | offsetT size; | |||
2054 | ||||
2055 | value = resolve_symbol_value (fragP->fr_symbol); | |||
2056 | size = sizeof_leb128 (value, fragP->fr_subtype); | |||
2057 | growth = size - fragP->fr_offset; | |||
2058 | fragP->fr_offset = size; | |||
2059 | } | |||
2060 | break; | |||
2061 | ||||
2062 | case rs_cfa: | |||
2063 | growth = eh_frame_relax_frag (fragP); | |||
2064 | break; | |||
2065 | ||||
2066 | case rs_dwarf2dbg: | |||
2067 | growth = dwarf2dbg_relax_frag (fragP); | |||
2068 | break; | |||
2069 | ||||
2070 | default: | |||
2071 | BAD_CASE (fragP->fr_type){ as_fatal (("Case value %ld unexpected at line %d of file \"%s\"\n" ), (long) fragP->fr_type, 2071, "/usr/src/gnu/usr.bin/binutils-2.17/gas/write.c" ); }; | |||
2072 | break; | |||
2073 | } | |||
2074 | if (growth) | |||
2075 | { | |||
2076 | stretch += growth; | |||
2077 | stretched = 1; | |||
2078 | } | |||
2079 | } | |||
2080 | } | |||
2081 | /* Until nothing further to relax. */ | |||
2082 | while (stretched && -- max_iterations); | |||
2083 | ||||
2084 | if (stretched) | |||
2085 | as_fatal (_("Infinite loop encountered whilst attempting to compute the addresses of symbols in section %s")("Infinite loop encountered whilst attempting to compute the addresses of symbols in section %s" ), | |||
2086 | segment_name (segment)((segment)->name + 0)); | |||
2087 | } | |||
2088 | ||||
2089 | for (fragP = segment_frag_root; fragP; fragP = fragP->fr_next) | |||
2090 | if (fragP->last_fr_address != fragP->fr_address) | |||
2091 | { | |||
2092 | fragP->last_fr_address = fragP->fr_address; | |||
2093 | ret = 1; | |||
2094 | } | |||
2095 | return ret; | |||
2096 | } | |||
2097 | ||||
2098 | /* fixup_segment() | |||
2099 | ||||
2100 | Go through all the fixS's in a segment and see which ones can be | |||
2101 | handled now. (These consist of fixS where we have since discovered | |||
2102 | the value of a symbol, or the address of the frag involved.) | |||
2103 | For each one, call md_apply_fix to put the fix into the frag data. | |||
2104 | ||||
2105 | Result is a count of how many relocation structs will be needed to | |||
2106 | handle the remaining fixS's that we couldn't completely handle here. | |||
2107 | These will be output later by emit_relocations(). */ | |||
2108 | ||||
2109 | static long | |||
2110 | fixup_segment (fixS *fixP, segT this_segment) | |||
2111 | { | |||
2112 | long seg_reloc_count = 0; | |||
2113 | valueT add_number; | |||
2114 | fragS *fragP; | |||
2115 | segT add_symbol_segment = absolute_section((asection *) &bfd_abs_section); | |||
2116 | ||||
2117 | if (fixP != NULL((void*)0) && abs_section_sym == NULL((void*)0)) | |||
2118 | abs_section_sym = section_symbol (absolute_section((asection *) &bfd_abs_section)); | |||
2119 | ||||
2120 | /* If the linker is doing the relaxing, we must not do any fixups. | |||
2121 | ||||
2122 | Well, strictly speaking that's not true -- we could do any that | |||
2123 | are PC-relative and don't cross regions that could change size. | |||
2124 | And for the i960 we might be able to turn callx/callj into bal | |||
2125 | anyways in cases where we know the maximum displacement. */ | |||
2126 | if (linkrelax && TC_LINKRELAX_FIXUP (this_segment)1) | |||
2127 | { | |||
2128 | for (; fixP; fixP = fixP->fx_next) | |||
2129 | if (!fixP->fx_done) | |||
2130 | { | |||
2131 | if (fixP->fx_addsy == NULL((void*)0)) | |||
2132 | { | |||
2133 | /* There was no symbol required by this relocation. | |||
2134 | However, BFD doesn't really handle relocations | |||
2135 | without symbols well. So fake up a local symbol in | |||
2136 | the absolute section. */ | |||
2137 | fixP->fx_addsy = abs_section_sym; | |||
2138 | } | |||
2139 | symbol_mark_used_in_reloc (fixP->fx_addsy); | |||
2140 | if (fixP->fx_subsy != NULL((void*)0)) | |||
2141 | symbol_mark_used_in_reloc (fixP->fx_subsy); | |||
2142 | seg_reloc_count++; | |||
2143 | } | |||
2144 | TC_ADJUST_RELOC_COUNT (fixP, seg_reloc_count); | |||
2145 | return seg_reloc_count; | |||
2146 | } | |||
2147 | ||||
2148 | for (; fixP; fixP = fixP->fx_next) | |||
2149 | { | |||
2150 | #ifdef DEBUG5 | |||
2151 | fprintf (stderr(&__sF[2]), "\nprocessing fixup:\n"); | |||
2152 | print_fixup (fixP); | |||
2153 | #endif | |||
2154 | ||||
2155 | fragP = fixP->fx_frag; | |||
2156 | know (fragP); | |||
2157 | #ifdef TC_VALIDATE_FIX | |||
2158 | TC_VALIDATE_FIX (fixP, this_segment, skip)i386_validate_fix(fixP); | |||
2159 | #endif | |||
2160 | add_number = fixP->fx_offset; | |||
2161 | ||||
2162 | if (fixP->fx_addsy != NULL((void*)0) | |||
2163 | && symbol_mri_common_p (fixP->fx_addsy)) | |||
2164 | { | |||
2165 | add_number += S_GET_VALUE (fixP->fx_addsy); | |||
2166 | fixP->fx_offset = add_number; | |||
2167 | fixP->fx_addsy | |||
2168 | = symbol_get_value_expression (fixP->fx_addsy)->X_add_symbol; | |||
2169 | } | |||
2170 | ||||
2171 | if (fixP->fx_addsy != NULL((void*)0)) | |||
2172 | add_symbol_segment = S_GET_SEGMENT (fixP->fx_addsy); | |||
2173 | ||||
2174 | if (fixP->fx_subsy != NULL((void*)0)) | |||
2175 | { | |||
2176 | segT sub_symbol_segment; | |||
2177 | resolve_symbol_value (fixP->fx_subsy); | |||
2178 | sub_symbol_segment = S_GET_SEGMENT (fixP->fx_subsy); | |||
2179 | if (fixP->fx_addsy != NULL((void*)0) | |||
2180 | && sub_symbol_segment == add_symbol_segment | |||
2181 | && !TC_FORCE_RELOCATION_SUB_SAME (fixP, add_symbol_segment)(! ( (add_symbol_segment) != ((asection *) &bfd_abs_section ) && (add_symbol_segment) != ((asection *) &bfd_und_section ) && (add_symbol_segment) != reg_section && ( add_symbol_segment) != expr_section))) | |||
2182 | { | |||
2183 | add_number += S_GET_VALUE (fixP->fx_addsy); | |||
2184 | add_number -= S_GET_VALUE (fixP->fx_subsy); | |||
2185 | fixP->fx_offset = add_number; | |||
2186 | fixP->fx_addsy = NULL((void*)0); | |||
2187 | fixP->fx_subsy = NULL((void*)0); | |||
2188 | #ifdef TC_M68K | |||
2189 | /* See the comment below about 68k weirdness. */ | |||
2190 | fixP->fx_pcrel = 0; | |||
2191 | #endif | |||
2192 | } | |||
2193 | else if (sub_symbol_segment == absolute_section((asection *) &bfd_abs_section) | |||
2194 | && !TC_FORCE_RELOCATION_SUB_ABS (fixP)0) | |||
2195 | { | |||
2196 | add_number -= S_GET_VALUE (fixP->fx_subsy); | |||
2197 | fixP->fx_offset = add_number; | |||
2198 | fixP->fx_subsy = NULL((void*)0); | |||
2199 | } | |||
2200 | else if (sub_symbol_segment == this_segment | |||
2201 | && !TC_FORCE_RELOCATION_SUB_LOCAL (fixP)0) | |||
2202 | { | |||
2203 | add_number -= S_GET_VALUE (fixP->fx_subsy); | |||
2204 | fixP->fx_offset = (add_number + fixP->fx_dot_value | |||
2205 | + fixP->fx_frag->fr_address); | |||
2206 | ||||
2207 | /* Make it pc-relative. If the back-end code has not | |||
2208 | selected a pc-relative reloc, cancel the adjustment | |||
2209 | we do later on all pc-relative relocs. */ | |||
2210 | if (0 | |||
2211 | #ifdef TC_M68K | |||
2212 | /* Do this for m68k even if it's already described | |||
2213 | as pc-relative. On the m68k, an operand of | |||
2214 | "pc@(foo-.-2)" should address "foo" in a | |||
2215 | pc-relative mode. */ | |||
2216 | || 1 | |||
2217 | #endif | |||
2218 | || !fixP->fx_pcrel) | |||
2219 | add_number += MD_PCREL_FROM_SECTION (fixP, this_segment)md_pcrel_from (fixP); | |||
2220 | fixP->fx_subsy = NULL((void*)0); | |||
2221 | fixP->fx_pcrel = 1; | |||
2222 | } | |||
2223 | else if (!TC_VALIDATE_FIX_SUB (fixP)((fixP)->fx_r_type == BFD_RELOC_GPREL32 || (fixP)->fx_r_type == BFD_RELOC_GPREL16)) | |||
2224 | { | |||
2225 | as_bad_where (fixP->fx_file, fixP->fx_line, | |||
2226 | _("can't resolve `%s' {%s section} - `%s' {%s section}")("can't resolve `%s' {%s section} - `%s' {%s section}"), | |||
2227 | fixP->fx_addsy ? S_GET_NAME (fixP->fx_addsy) : "0", | |||
2228 | segment_name (add_symbol_segment)((add_symbol_segment)->name + 0), | |||
2229 | S_GET_NAME (fixP->fx_subsy), | |||
2230 | segment_name (sub_symbol_segment)((sub_symbol_segment)->name + 0)); | |||
2231 | } | |||
2232 | } | |||
2233 | ||||
2234 | if (fixP->fx_addsy) | |||
2235 | { | |||
2236 | if (add_symbol_segment == this_segment | |||
2237 | && !TC_FORCE_RELOCATION_LOCAL (fixP)(!(fixP)->fx_pcrel || (fixP)->fx_plt || (fixP)->fx_r_type == BFD_RELOC_386_PLT32 || (fixP)->fx_r_type == BFD_RELOC_386_GOT32 || (fixP)->fx_r_type == BFD_RELOC_386_GOTPC || (fixP)-> fx_r_type == BFD_RELOC_X86_64_GOTPCREL || (generic_force_reloc (fixP)))) | |||
2238 | { | |||
2239 | /* This fixup was made when the symbol's segment was | |||
2240 | SEG_UNKNOWN, but it is now in the local segment. | |||
2241 | So we know how to do the address without relocation. */ | |||
2242 | add_number += S_GET_VALUE (fixP->fx_addsy); | |||
2243 | fixP->fx_offset = add_number; | |||
2244 | if (fixP->fx_pcrel) | |||
2245 | add_number -= MD_PCREL_FROM_SECTION (fixP, this_segment)md_pcrel_from (fixP); | |||
2246 | fixP->fx_addsy = NULL((void*)0); | |||
2247 | fixP->fx_pcrel = 0; | |||
2248 | } | |||
2249 | else if (add_symbol_segment == absolute_section((asection *) &bfd_abs_section) | |||
2250 | && !TC_FORCE_RELOCATION_ABS (fixP)((generic_force_reloc (fixP)))) | |||
2251 | { | |||
2252 | add_number += S_GET_VALUE (fixP->fx_addsy); | |||
2253 | fixP->fx_offset = add_number; | |||
2254 | fixP->fx_addsy = NULL((void*)0); | |||
2255 | } | |||
2256 | else if (add_symbol_segment != undefined_section((asection *) &bfd_und_section) | |||
2257 | && ! bfd_is_com_section (add_symbol_segment)(((add_symbol_segment)->flags & 0x1000) != 0) | |||
2258 | && MD_APPLY_SYM_VALUE (fixP)0) | |||
2259 | add_number += S_GET_VALUE (fixP->fx_addsy); | |||
2260 | } | |||
2261 | ||||
2262 | if (fixP->fx_pcrel) | |||
2263 | { | |||
2264 | add_number -= MD_PCREL_FROM_SECTION (fixP, this_segment)md_pcrel_from (fixP); | |||
2265 | if (!fixP->fx_done && fixP->fx_addsy == NULL((void*)0)) | |||
2266 | { | |||
2267 | /* There was no symbol required by this relocation. | |||
2268 | However, BFD doesn't really handle relocations | |||
2269 | without symbols well. So fake up a local symbol in | |||
2270 | the absolute section. */ | |||
2271 | fixP->fx_addsy = abs_section_sym; | |||
2272 | } | |||
2273 | } | |||
2274 | ||||
2275 | if (!fixP->fx_done) | |||
2276 | md_apply_fix (fixP, &add_number, this_segment); | |||
2277 | ||||
2278 | if (!fixP->fx_done) | |||
2279 | { | |||
2280 | ++seg_reloc_count; | |||
2281 | if (fixP->fx_addsy == NULL((void*)0)) | |||
2282 | fixP->fx_addsy = abs_section_sym; | |||
2283 | symbol_mark_used_in_reloc (fixP->fx_addsy); | |||
2284 | if (fixP->fx_subsy != NULL((void*)0)) | |||
2285 | symbol_mark_used_in_reloc (fixP->fx_subsy); | |||
2286 | } | |||
2287 | ||||
2288 | if (!fixP->fx_bit_fixP && !fixP->fx_no_overflow && fixP->fx_size != 0) | |||
2289 | { | |||
2290 | if (fixP->fx_size < sizeof (valueT)) | |||
2291 | { | |||
2292 | valueT mask; | |||
2293 | ||||
2294 | mask = 0; | |||
2295 | mask--; /* Set all bits to one. */ | |||
2296 | mask <<= fixP->fx_size * 8 - (fixP->fx_signed ? 1 : 0); | |||
2297 | if ((add_number & mask) != 0 && (add_number & mask) != mask) | |||
2298 | { | |||
2299 | char buf[50], buf2[50]; | |||
2300 | sprint_value (buf, fragP->fr_address + fixP->fx_where); | |||
2301 | if (add_number > 1000) | |||
2302 | sprint_value (buf2, add_number); | |||
2303 | else | |||
2304 | sprintf (buf2, "%ld", (long) add_number); | |||
2305 | as_bad_where (fixP->fx_file, fixP->fx_line, | |||
2306 | _("value of %s too large for field of %d bytes at %s")("value of %s too large for field of %d bytes at %s"), | |||
2307 | buf2, fixP->fx_size, buf); | |||
2308 | } /* Generic error checking. */ | |||
2309 | } | |||
2310 | #ifdef WARN_SIGNED_OVERFLOW_WORD | |||
2311 | /* Warn if a .word value is too large when treated as a signed | |||
2312 | number. We already know it is not too negative. This is to | |||
2313 | catch over-large switches generated by gcc on the 68k. */ | |||
2314 | if (!flag_signed_overflow_ok | |||
2315 | && fixP->fx_size == 2 | |||
2316 | && add_number > 0x7fff) | |||
2317 | as_bad_where (fixP->fx_file, fixP->fx_line, | |||
2318 | _("signed .word overflow; switch may be too large; %ld at 0x%lx")("signed .word overflow; switch may be too large; %ld at 0x%lx" ), | |||
2319 | (long) add_number, | |||
2320 | (long) (fragP->fr_address + fixP->fx_where)); | |||
2321 | #endif | |||
2322 | } /* Not a bit fix. */ | |||
2323 | ||||
2324 | #ifdef TC_VALIDATE_FIX | |||
2325 | skip: ATTRIBUTE_UNUSED_LABEL__attribute__ ((__unused__)) | |||
2326 | ; | |||
2327 | #endif | |||
2328 | #ifdef DEBUG5 | |||
2329 | fprintf (stderr(&__sF[2]), "result:\n"); | |||
2330 | print_fixup (fixP); | |||
2331 | #endif | |||
2332 | } /* For each fixS in this segment. */ | |||
2333 | ||||
2334 | TC_ADJUST_RELOC_COUNT (fixP, seg_reloc_count); | |||
2335 | return seg_reloc_count; | |||
2336 | } | |||
2337 | ||||
2338 | void | |||
2339 | number_to_chars_bigendian (char *buf, valueT val, int n) | |||
2340 | { | |||
2341 | if (n <= 0) | |||
2342 | abort ()as_abort ("/usr/src/gnu/usr.bin/binutils-2.17/gas/write.c", 2342 , __PRETTY_FUNCTION__); | |||
2343 | while (n--) | |||
2344 | { | |||
2345 | buf[n] = val & 0xff; | |||
2346 | val >>= 8; | |||
2347 | } | |||
2348 | } | |||
2349 | ||||
2350 | void | |||
2351 | number_to_chars_littleendian (char *buf, valueT val, int n) | |||
2352 | { | |||
2353 | if (n <= 0) | |||
2354 | abort ()as_abort ("/usr/src/gnu/usr.bin/binutils-2.17/gas/write.c", 2354 , __PRETTY_FUNCTION__); | |||
2355 | while (n--) | |||
2356 | { | |||
2357 | *buf++ = val & 0xff; | |||
2358 | val >>= 8; | |||
2359 | } | |||
2360 | } | |||
2361 | ||||
2362 | void | |||
2363 | write_print_statistics (FILE *file) | |||
2364 | { | |||
2365 | fprintf (file, "fixups: %d\n", n_fixups); | |||
2366 | } | |||
2367 | ||||
2368 | /* For debugging. */ | |||
2369 | extern int indent_level; | |||
2370 | ||||
2371 | void | |||
2372 | print_fixup (fixS *fixp) | |||
2373 | { | |||
2374 | indent_level = 1; | |||
2375 | fprintf (stderr(&__sF[2]), "fix %lx %s:%d", (long) fixp, fixp->fx_file, fixp->fx_line); | |||
2376 | if (fixp->fx_pcrel) | |||
2377 | fprintf (stderr(&__sF[2]), " pcrel"); | |||
2378 | if (fixp->fx_pcrel_adjust) | |||
2379 | fprintf (stderr(&__sF[2]), " pcrel_adjust=%d", fixp->fx_pcrel_adjust); | |||
2380 | if (fixp->fx_im_disp) | |||
2381 | { | |||
2382 | #ifdef TC_NS32K | |||
2383 | fprintf (stderr(&__sF[2]), " im_disp=%d", fixp->fx_im_disp); | |||
2384 | #else | |||
2385 | fprintf (stderr(&__sF[2]), " im_disp"); | |||
2386 | #endif | |||
2387 | } | |||
2388 | if (fixp->fx_tcbit) | |||
2389 | fprintf (stderr(&__sF[2]), " tcbit"); | |||
2390 | if (fixp->fx_done) | |||
2391 | fprintf (stderr(&__sF[2]), " done"); | |||
2392 | fprintf (stderr(&__sF[2]), "\n size=%d frag=%lx where=%ld offset=%lx addnumber=%lx", | |||
2393 | fixp->fx_size, (long) fixp->fx_frag, (long) fixp->fx_where, | |||
2394 | (long) fixp->fx_offset, (long) fixp->fx_addnumber); | |||
2395 | fprintf (stderr(&__sF[2]), "\n %s (%d)", bfd_get_reloc_code_name (fixp->fx_r_type), | |||
2396 | fixp->fx_r_type); | |||
2397 | if (fixp->fx_addsy) | |||
2398 | { | |||
2399 | fprintf (stderr(&__sF[2]), "\n +<"); | |||
2400 | print_symbol_value_1 (stderr(&__sF[2]), fixp->fx_addsy); | |||
2401 | fprintf (stderr(&__sF[2]), ">"); | |||
2402 | } | |||
2403 | if (fixp->fx_subsy) | |||
2404 | { | |||
2405 | fprintf (stderr(&__sF[2]), "\n -<"); | |||
2406 | print_symbol_value_1 (stderr(&__sF[2]), fixp->fx_subsy); | |||
2407 | fprintf (stderr(&__sF[2]), ">"); | |||
2408 | } | |||
2409 | fprintf (stderr(&__sF[2]), "\n"); | |||
2410 | #ifdef TC_FIX_DATA_PRINT | |||
2411 | TC_FIX_DATA_PRINT (stderr(&__sF[2]), fixp); | |||
2412 | #endif | |||
2413 | } |