projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
merge from gcc
[deliverable/binutils-gdb.git] / gas / write.c
CommitLineData
252b5132 1/* write.c - emit .o file
f7e42eb4
NC		 2 Copyright 1986, 1987, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
3 1998, 1999, 2000, 2001
252b5132
RH		 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, 59 Temple Place - Suite 330, Boston, MA
21 02111-1307, USA. */
22
efaf0ba4 23/* This thing should be set up to do byteordering correctly. But... */
252b5132
RH		 24
25#include "as.h"
26#include "subsegs.h"
27#include "obstack.h"
28#include "output-file.h"
220e750f 29#include "dwarf2dbg.h"
252b5132
RH		 30
31/* This looks like a good idea. Let's try turning it on always, for now. */
32#undef BFD_FAST_SECTION_FILL
33#define BFD_FAST_SECTION_FILL
34
252b5132
RH		 35#ifndef TC_ADJUST_RELOC_COUNT
36#define TC_ADJUST_RELOC_COUNT(FIXP,COUNT)
37#endif
38
39#ifndef TC_FORCE_RELOCATION
40#define TC_FORCE_RELOCATION(FIXP) 0
41#endif
42
43#ifndef TC_FORCE_RELOCATION_SECTION
44#define TC_FORCE_RELOCATION_SECTION(FIXP,SEG) TC_FORCE_RELOCATION(FIXP)
45#endif
46
58a77e41
EC		 47#ifndef TC_LINKRELAX_FIXUP
48#define TC_LINKRELAX_FIXUP(SEG) 1
49#endif
50
8f36cd18
AO		 51#ifndef TC_FIX_ADJUSTABLE
52#define TC_FIX_ADJUSTABLE(fix) 1
53#endif
ef99799a 54
252b5132
RH		 55#ifndef MD_PCREL_FROM_SECTION
56#define MD_PCREL_FROM_SECTION(FIXP, SEC) md_pcrel_from(FIXP)
57#endif
58
59#ifndef WORKING_DOT_WORD
60extern CONST int md_short_jump_size;
61extern CONST int md_long_jump_size;
62#endif
63
e46d99eb
AM		 64/* Used to control final evaluation of expressions that are more
65 complex than symbol + constant. 1 means set final value for simple
66 expressions, 2 means set final value for more complex expressions. */
67int finalize_syms = 1;
68
252b5132
RH		 69int symbol_table_frozen;
70void print_fixup PARAMS ((fixS *));
71
72#ifdef BFD_ASSEMBLER
73static void renumber_sections PARAMS ((bfd *, asection *, PTR));
74
75/* We generally attach relocs to frag chains. However, after we have
76 chained these all together into a segment, any relocs we add after
77 that must be attached to a segment. This will include relocs added
78 in md_estimate_size_for_relax, for example. */
79static int frags_chained = 0;
80#endif
81
82#ifndef BFD_ASSEMBLER
83
84#ifndef MANY_SEGMENTS
85struct frag *text_frag_root;
86struct frag *data_frag_root;
87struct frag *bss_frag_root;
88
efaf0ba4
NC		 89struct frag *text_last_frag; /* Last frag in segment. */
90struct frag *data_last_frag; /* Last frag in segment. */
91static struct frag *bss_last_frag; /* Last frag in segment. */
252b5132
RH		 92#endif
93
94#ifndef BFD
95static object_headers headers;
96#endif
97
98long string_byte_count;
efaf0ba4 99char *next_object_file_charP; /* Tracks object file bytes. */
252b5132
RH		 100
101#ifndef OBJ_VMS
102int magic_number_for_object_file = DEFAULT_MAGIC_NUMBER_FOR_OBJECT_FILE;
103#endif
104
efaf0ba4 105#endif /* BFD_ASSEMBLER */
252b5132
RH		 106
107static int n_fixups;
108
109#ifdef BFD_ASSEMBLER
110static fixS *fix_new_internal PARAMS ((fragS *, int where, int size,
111 symbolS *add, symbolS *sub,
112 offsetT offset, int pcrel,
113 bfd_reloc_code_real_type r_type));
114#else
115static fixS *fix_new_internal PARAMS ((fragS *, int where, int size,
116 symbolS *add, symbolS *sub,
117 offsetT offset, int pcrel,
118 int r_type));
119#endif
120#if defined (BFD_ASSEMBLER) || (!defined (BFD) && !defined (OBJ_VMS))
121static long fixup_segment PARAMS ((fixS * fixP, segT this_segment_type));
122#endif
123static relax_addressT relax_align PARAMS ((relax_addressT addr, int align));
124#if defined (BFD_ASSEMBLER) || ! defined (BFD)
125static fragS *chain_frchains_together_1 PARAMS ((segT, struct frchain *));
126#endif
127#ifdef BFD_ASSEMBLER
128static void chain_frchains_together PARAMS ((bfd *, segT, PTR));
129static void cvt_frag_to_fill PARAMS ((segT, fragS *));
252b5132
RH		 130static void adjust_reloc_syms PARAMS ((bfd *, asection *, PTR));
131static void write_relocs PARAMS ((bfd *, asection *, PTR));
132static void write_contents PARAMS ((bfd *, asection *, PTR));
133static void set_symtab PARAMS ((void));
134#endif
135#if defined (BFD_ASSEMBLER) || (! defined (BFD) && ! defined (OBJ_AOUT))
136static void merge_data_into_text PARAMS ((void));
137#endif
138#if ! defined (BFD_ASSEMBLER) && ! defined (BFD)
139static void cvt_frag_to_fill PARAMS ((object_headers *, segT, fragS *));
140static void remove_subsegs PARAMS ((frchainS *, int, fragS **, fragS **));
141static void relax_and_size_all_segments PARAMS ((void));
142#endif
6aa4f516 143#if defined (BFD_ASSEMBLER) && defined (OBJ_COFF) && defined (TE_GO32)
dbddefbf
NC		 144static void set_segment_vma PARAMS ((bfd *, asection *, PTR));
145#endif
252b5132 146
efaf0ba4
NC		 147/* Create a fixS in obstack 'notes'. */
148
252b5132
RH		 149static fixS *
150fix_new_internal (frag, where, size, add_symbol, sub_symbol, offset, pcrel,
151 r_type)
efaf0ba4
NC		 152 fragS *frag; /* Which frag? */
153 int where; /* Where in that frag? */
154 int size; /* 1, 2, or 4 usually. */
155 symbolS *add_symbol; /* X_add_symbol. */
156 symbolS *sub_symbol; /* X_op_symbol. */
157 offsetT offset; /* X_add_number. */
158 int pcrel; /* TRUE if PC-relative relocation. */
252b5132 159#ifdef BFD_ASSEMBLER
efaf0ba4 160 bfd_reloc_code_real_type r_type; /* Relocation type. */
252b5132 161#else
efaf0ba4 162 int r_type; /* Relocation type. */
252b5132
RH		 163#endif
164{
165 fixS *fixP;
166
167 n_fixups++;
168
169 fixP = (fixS *) obstack_alloc (&notes, sizeof (fixS));
170
171 fixP->fx_frag = frag;
172 fixP->fx_where = where;
173 fixP->fx_size = size;
174 /* We've made fx_size a narrow field; check that it's wide enough. */
175 if (fixP->fx_size != size)
176 {
177 as_bad (_("field fx_size too small to hold %d"), size);
178 abort ();
179 }
180 fixP->fx_addsy = add_symbol;
181 fixP->fx_subsy = sub_symbol;
182 fixP->fx_offset = offset;
183 fixP->fx_pcrel = pcrel;
184 fixP->fx_plt = 0;
185#if defined(NEED_FX_R_TYPE) || defined (BFD_ASSEMBLER)
186 fixP->fx_r_type = r_type;
187#endif
188 fixP->fx_im_disp = 0;
189 fixP->fx_pcrel_adjust = 0;
190 fixP->fx_bit_fixP = 0;
191 fixP->fx_addnumber = 0;
192 fixP->fx_tcbit = 0;
193 fixP->fx_done = 0;
194 fixP->fx_no_overflow = 0;
195 fixP->fx_signed = 0;
196
197#ifdef USING_CGEN
198 fixP->fx_cgen.insn = NULL;
199 fixP->fx_cgen.opinfo = 0;
200#endif
201
202#ifdef TC_FIX_TYPE
efaf0ba4 203 TC_INIT_FIX_DATA (fixP);
252b5132
RH		 204#endif
205
206 as_where (&fixP->fx_file, &fixP->fx_line);
207
208 /* Usually, we want relocs sorted numerically, but while
209 comparing to older versions of gas that have relocs
210 reverse sorted, it is convenient to have this compile
efaf0ba4 211 time option. xoxorich. */
252b5132
RH		 212 {
213
214#ifdef BFD_ASSEMBLER
215 fixS **seg_fix_rootP = (frags_chained
216 ? &seg_info (now_seg)->fix_root
217 : &frchain_now->fix_root);
218 fixS **seg_fix_tailP = (frags_chained
219 ? &seg_info (now_seg)->fix_tail
220 : &frchain_now->fix_tail);
221#endif
222
223#ifdef REVERSE_SORT_RELOCS
224
225 fixP->fx_next = *seg_fix_rootP;
226 *seg_fix_rootP = fixP;
227
efaf0ba4 228#else /* REVERSE_SORT_RELOCS */
252b5132
RH		 229
230 fixP->fx_next = NULL;
231
232 if (*seg_fix_tailP)
233 (*seg_fix_tailP)->fx_next = fixP;
234 else
235 *seg_fix_rootP = fixP;
236 *seg_fix_tailP = fixP;
237
efaf0ba4 238#endif /* REVERSE_SORT_RELOCS */
252b5132
RH		 239 }
240
241 return fixP;
242}
243
244/* Create a fixup relative to a symbol (plus a constant). */
245
246fixS *
247fix_new (frag, where, size, add_symbol, offset, pcrel, r_type)
efaf0ba4
NC		 248 fragS *frag; /* Which frag? */
249 int where; /* Where in that frag? */
250 int size; /* 1, 2, or 4 usually. */
251 symbolS *add_symbol; /* X_add_symbol. */
252 offsetT offset; /* X_add_number. */
253 int pcrel; /* TRUE if PC-relative relocation. */
252b5132 254#ifdef BFD_ASSEMBLER
efaf0ba4 255 bfd_reloc_code_real_type r_type; /* Relocation type. */
252b5132 256#else
efaf0ba4 257 int r_type; /* Relocation type. */
252b5132
RH		 258#endif
259{
260 return fix_new_internal (frag, where, size, add_symbol,
261 (symbolS *) NULL, offset, pcrel, r_type);
262}
263
264/* Create a fixup for an expression. Currently we only support fixups
265 for difference expressions. That is itself more than most object
266 file formats support anyhow. */
267
268fixS *
269fix_new_exp (frag, where, size, exp, pcrel, r_type)
efaf0ba4
NC		 270 fragS *frag; /* Which frag? */
271 int where; /* Where in that frag? */
272 int size; /* 1, 2, or 4 usually. */
252b5132 273 expressionS *exp; /* Expression. */
efaf0ba4 274 int pcrel; /* TRUE if PC-relative relocation. */
252b5132 275#ifdef BFD_ASSEMBLER
efaf0ba4 276 bfd_reloc_code_real_type r_type; /* Relocation type. */
252b5132 277#else
efaf0ba4 278 int r_type; /* Relocation type. */
252b5132
RH		 279#endif
280{
281 symbolS *add = NULL;
282 symbolS *sub = NULL;
283 offsetT off = 0;
284
285 switch (exp->X_op)
286 {
287 case O_absent:
288 break;
289
37006e43
NC		 290 case O_register:
291 as_bad (_("register value used as expression"));
292 break;
293
252b5132
RH		 294 case O_add:
295 /* This comes up when _GLOBAL_OFFSET_TABLE_+(.-L0) is read, if
296 the difference expression cannot immediately be reduced. */
297 {
298 symbolS *stmp = make_expr_symbol (exp);
58a77e41 299
252b5132
RH		 300 exp->X_op = O_symbol;
301 exp->X_op_symbol = 0;
302 exp->X_add_symbol = stmp;
303 exp->X_add_number = 0;
58a77e41 304
252b5132
RH		 305 return fix_new_exp (frag, where, size, exp, pcrel, r_type);
306 }
307
308 case O_symbol_rva:
309 add = exp->X_add_symbol;
310 off = exp->X_add_number;
311
312#if defined(BFD_ASSEMBLER)
313 r_type = BFD_RELOC_RVA;
314#else
315#if defined(TC_RVA_RELOC)
316 r_type = TC_RVA_RELOC;
317#else
efaf0ba4 318 as_fatal (_("rva not supported"));
252b5132
RH		 319#endif
320#endif
321 break;
322
323 case O_uminus:
324 sub = exp->X_add_symbol;
325 off = exp->X_add_number;
326 break;
327
328 case O_subtract:
329 sub = exp->X_op_symbol;
330 /* Fall through. */
331 case O_symbol:
332 add = exp->X_add_symbol;
efaf0ba4 333 /* Fall through. */
252b5132
RH		 334 case O_constant:
335 off = exp->X_add_number;
336 break;
337
338 default:
339 add = make_expr_symbol (exp);
340 break;
341 }
342
efaf0ba4 343 return fix_new_internal (frag, where, size, add, sub, off, pcrel, r_type);
252b5132
RH		 344}
345
346/* Append a string onto another string, bumping the pointer along. */
347void
348append (charPP, fromP, length)
349 char **charPP;
350 char *fromP;
351 unsigned long length;
352{
efaf0ba4 353 /* Don't trust memcpy() of 0 chars. */
252b5132
RH		 354 if (length == 0)
355 return;
356
357 memcpy (*charPP, fromP, length);
358 *charPP += length;
359}
360
361#ifndef BFD_ASSEMBLER
362int section_alignment[SEG_MAXIMUM_ORDINAL];
363#endif
364
efaf0ba4
NC		 365/* This routine records the largest alignment seen for each segment.
366 If the beginning of the segment is aligned on the worst-case
367 boundary, all of the other alignments within it will work. At
368 least one object format really uses this info. */
369
252b5132
RH		 370void
371record_alignment (seg, align)
efaf0ba4 372 /* Segment to which alignment pertains. */
252b5132
RH		 373 segT seg;
374 /* Alignment, as a power of 2 (e.g., 1 => 2-byte boundary, 2 => 4-byte
375 boundary, etc.) */
376 int align;
377{
378 if (seg == absolute_section)
379 return;
380#ifdef BFD_ASSEMBLER
381 if ((unsigned int) align > bfd_get_section_alignment (stdoutput, seg))
382 bfd_set_section_alignment (stdoutput, seg, align);
383#else
384 if (align > section_alignment[(int) seg])
385 section_alignment[(int) seg] = align;
386#endif
387}
388
0a9ef439
RH		 389int
390get_recorded_alignment (seg)
391 segT seg;
392{
393 if (seg == absolute_section)
394 return 0;
395#ifdef BFD_ASSEMBLER
396 return bfd_get_section_alignment (stdoutput, seg);
397#else
398 return section_alignment[(int) seg];
399#endif
400}
401
252b5132
RH		 402#ifdef BFD_ASSEMBLER
403
404/* Reset the section indices after removing the gas created sections. */
405
406static void
407renumber_sections (abfd, sec, countparg)
ab9da554 408 bfd *abfd ATTRIBUTE_UNUSED;
252b5132
RH		 409 asection *sec;
410 PTR countparg;
411{
412 int *countp = (int *) countparg;
413
414 sec->index = *countp;
415 ++*countp;
416}
417
efaf0ba4 418#endif /* defined (BFD_ASSEMBLER) */
252b5132
RH		 419
420#if defined (BFD_ASSEMBLER) || ! defined (BFD)
421
422static fragS *
423chain_frchains_together_1 (section, frchp)
424 segT section;
425 struct frchain *frchp;
426{
427 fragS dummy, *prev_frag = &dummy;
428#ifdef BFD_ASSEMBLER
429 fixS fix_dummy, *prev_fix = &fix_dummy;
430#endif
431
432 for (; frchp && frchp->frch_seg == section; frchp = frchp->frch_next)
433 {
434 prev_frag->fr_next = frchp->frch_root;
435 prev_frag = frchp->frch_last;
436 assert (prev_frag->fr_type != 0);
437#ifdef BFD_ASSEMBLER
438 if (frchp->fix_root != (fixS *) NULL)
439 {
440 if (seg_info (section)->fix_root == (fixS *) NULL)
441 seg_info (section)->fix_root = frchp->fix_root;
442 prev_fix->fx_next = frchp->fix_root;
443 seg_info (section)->fix_tail = frchp->fix_tail;
444 prev_fix = frchp->fix_tail;
445 }
446#endif
447 }
448 assert (prev_frag->fr_type != 0);
449 prev_frag->fr_next = 0;
450 return prev_frag;
451}
452
453#endif
454
455#ifdef BFD_ASSEMBLER
456
457static void
458chain_frchains_together (abfd, section, xxx)
ab9da554 459 bfd *abfd ATTRIBUTE_UNUSED;
252b5132 460 segT section;
ab9da554 461 PTR xxx ATTRIBUTE_UNUSED;
252b5132
RH		 462{
463 segment_info_type *info;
464
465 /* BFD may have introduced its own sections without using
466 subseg_new, so it is possible that seg_info is NULL. */
467 info = seg_info (section);
468 if (info != (segment_info_type *) NULL)
efaf0ba4
NC		 469 info->frchainP->frch_last
470 = chain_frchains_together_1 (section, info->frchainP);
252b5132
RH		 471
472 /* Now that we've chained the frags together, we must add new fixups
473 to the segment, not to the frag chain. */
474 frags_chained = 1;
475}
476
477#endif
478
479#if !defined (BFD) && !defined (BFD_ASSEMBLER)
480
481static void
482remove_subsegs (head, seg, root, last)
483 frchainS *head;
484 int seg;
485 fragS **root;
486 fragS **last;
487{
488 *root = head->frch_root;
489 *last = chain_frchains_together_1 (seg, head);
490}
491
efaf0ba4 492#endif /* BFD */
252b5132
RH		 493
494#if defined (BFD_ASSEMBLER) || !defined (BFD)
495
496#ifdef BFD_ASSEMBLER
497static void
498cvt_frag_to_fill (sec, fragP)
efaf0ba4 499 segT sec ATTRIBUTE_UNUSED;
252b5132
RH		 500 fragS *fragP;
501#else
502static void
503cvt_frag_to_fill (headersP, sec, fragP)
504 object_headers *headersP;
505 segT sec;
506 fragS *fragP;
507#endif
508{
509 switch (fragP->fr_type)
510 {
511 case rs_align:
512 case rs_align_code:
0a9ef439 513 case rs_align_test:
252b5132
RH		 514 case rs_org:
515 case rs_space:
516#ifdef HANDLE_ALIGN
517 HANDLE_ALIGN (fragP);
518#endif
519 know (fragP->fr_next != NULL);
520 fragP->fr_offset = (fragP->fr_next->fr_address
521 - fragP->fr_address
522 - fragP->fr_fix) / fragP->fr_var;
523 if (fragP->fr_offset < 0)
524 {
14ad458a
ILT		 525 as_bad_where (fragP->fr_file, fragP->fr_line,
526 _("attempt to .org/.space backwards? (%ld)"),
527 (long) fragP->fr_offset);
252b5132
RH		 528 }
529 fragP->fr_type = rs_fill;
530 break;
531
532 case rs_fill:
533 break;
534
535 case rs_leb128:
536 {
537 valueT value = S_GET_VALUE (fragP->fr_symbol);
538 int size;
539
540 size = output_leb128 (fragP->fr_literal + fragP->fr_fix, value,
541 fragP->fr_subtype);
542
543 fragP->fr_fix += size;
544 fragP->fr_type = rs_fill;
545 fragP->fr_var = 0;
546 fragP->fr_offset = 0;
547 fragP->fr_symbol = NULL;
548 }
549 break;
550
551 case rs_cfa:
552 eh_frame_convert_frag (fragP);
553 break;
554
220e750f
RH		 555 case rs_dwarf2dbg:
556 dwarf2dbg_convert_frag (fragP);
557 break;
558
252b5132
RH		 559 case rs_machine_dependent:
560#ifdef BFD_ASSEMBLER
561 md_convert_frag (stdoutput, sec, fragP);
562#else
563 md_convert_frag (headersP, sec, fragP);
564#endif
565
566 assert (fragP->fr_next == NULL
567 || ((offsetT) (fragP->fr_next->fr_address - fragP->fr_address)
568 == fragP->fr_fix));
569
efaf0ba4
NC		 570 /* After md_convert_frag, we make the frag into a ".space 0".
571 md_convert_frag() should set up any fixSs and constants
572 required. */
252b5132
RH		 573 frag_wane (fragP);
574 break;
575
576#ifndef WORKING_DOT_WORD
577 case rs_broken_word:
578 {
579 struct broken_word *lie;
580
581 if (fragP->fr_subtype)
582 {
583 fragP->fr_fix += md_short_jump_size;
584 for (lie = (struct broken_word *) (fragP->fr_symbol);
585 lie && lie->dispfrag == fragP;
586 lie = lie->next_broken_word)
587 if (lie->added == 1)
588 fragP->fr_fix += md_long_jump_size;
589 }
590 frag_wane (fragP);
591 }
592 break;
593#endif
594
595 default:
596 BAD_CASE (fragP->fr_type);
597 break;
598 }
599}
600
efaf0ba4 601#endif /* defined (BFD_ASSEMBLER) || !defined (BFD) */
252b5132
RH		 602
603#ifdef BFD_ASSEMBLER
e46d99eb 604static void relax_seg PARAMS ((bfd *, asection *, PTR));
252b5132 605static void
e46d99eb
AM		 606relax_seg (abfd, sec, xxx)
607 bfd *abfd ATTRIBUTE_UNUSED;
608 asection *sec;
609 PTR xxx;
610{
611 segment_info_type *seginfo = seg_info (sec);
612
613 if (seginfo && seginfo->frchainP
614 && relax_segment (seginfo->frchainP->frch_root, sec))
615 {
616 int *result = (int *) xxx;
617 *result = 1;
618 }
619}
620
621static void size_seg PARAMS ((bfd *, asection *, PTR));
622static void
623size_seg (abfd, sec, xxx)
252b5132
RH		 624 bfd *abfd;
625 asection *sec;
ab9da554 626 PTR xxx ATTRIBUTE_UNUSED;
252b5132
RH		 627{
628 flagword flags;
629 fragS *fragp;
630 segment_info_type *seginfo;
631 int x;
632 valueT size, newsize;
633
634 subseg_change (sec, 0);
635
252b5132
RH		 636 seginfo = seg_info (sec);
637 if (seginfo && seginfo->frchainP)
638 {
252b5132
RH		 639 for (fragp = seginfo->frchainP->frch_root; fragp; fragp = fragp->fr_next)
640 cvt_frag_to_fill (sec, fragp);
641 for (fragp = seginfo->frchainP->frch_root;
642 fragp->fr_next;
643 fragp = fragp->fr_next)
efaf0ba4
NC		 644 /* Walk to last elt. */
645 ;
252b5132
RH		 646 size = fragp->fr_address + fragp->fr_fix;
647 }
648 else
649 size = 0;
650
e46d99eb
AM		 651 flags = bfd_get_section_flags (abfd, sec);
652
252b5132
RH		 653 if (size > 0 && ! seginfo->bss)
654 flags |= SEC_HAS_CONTENTS;
655
656 /* @@ This is just an approximation. */
657 if (seginfo && seginfo->fix_root)
658 flags |= SEC_RELOC;
659 else
660 flags &= ~SEC_RELOC;
661 x = bfd_set_section_flags (abfd, sec, flags);
662 assert (x == true);
663
664 newsize = md_section_align (sec, size);
665 x = bfd_set_section_size (abfd, sec, newsize);
666 assert (x == true);
667
668 /* If the size had to be rounded up, add some padding in the last
669 non-empty frag. */
670 assert (newsize >= size);
671 if (size != newsize)
672 {
673 fragS *last = seginfo->frchainP->frch_last;
674 fragp = seginfo->frchainP->frch_root;
675 while (fragp->fr_next != last)
676 fragp = fragp->fr_next;
677 last->fr_address = size;
678 fragp->fr_offset += newsize - size;
679 }
680
681#ifdef tc_frob_section
682 tc_frob_section (sec);
683#endif
684#ifdef obj_frob_section
685 obj_frob_section (sec);
686#endif
687}
688
689#ifdef DEBUG2
690static void
691dump_section_relocs (abfd, sec, stream_)
e723ef7c 692 bfd *abfd ATTRIBUTE_UNUSED;
252b5132
RH		 693 asection *sec;
694 char *stream_;
695{
696 FILE *stream = (FILE *) stream_;
697 segment_info_type *seginfo = seg_info (sec);
698 fixS *fixp = seginfo->fix_root;
699
700 if (!fixp)
701 return;
702
703 fprintf (stream, "sec %s relocs:\n", sec->name);
704 while (fixp)
705 {
706 symbolS *s = fixp->fx_addsy;
e723ef7c
ILT		 707
708 fprintf (stream, " %08lx: type %d ", (unsigned long) fixp,
709 (int) fixp->fx_r_type);
710 if (s == NULL)
711 fprintf (stream, "no sym\n");
712 else
252b5132 713 {
e723ef7c
ILT		 714 print_symbol_value_1 (stream, s);
715 fprintf (stream, "\n");
252b5132 716 }
252b5132
RH		 717 fixp = fixp->fx_next;
718 }
719}
720#else
721#define dump_section_relocs(ABFD,SEC,STREAM) ((void) 0)
722#endif
723
724#ifndef EMIT_SECTION_SYMBOLS
725#define EMIT_SECTION_SYMBOLS 1
726#endif
727
728static void
729adjust_reloc_syms (abfd, sec, xxx)
ab9da554 730 bfd *abfd ATTRIBUTE_UNUSED;
252b5132 731 asection *sec;
ab9da554 732 PTR xxx ATTRIBUTE_UNUSED;
252b5132
RH		 733{
734 segment_info_type *seginfo = seg_info (sec);
735 fixS *fixp;
736
737 if (seginfo == NULL)
738 return;
739
740 dump_section_relocs (abfd, sec, stderr);
741
742 for (fixp = seginfo->fix_root; fixp; fixp = fixp->fx_next)
743 if (fixp->fx_done)
efaf0ba4
NC		 744 /* Ignore it. */
745 ;
252b5132
RH		 746 else if (fixp->fx_addsy)
747 {
748 symbolS *sym;
749 asection *symsec;
750
751#ifdef DEBUG5
752 fprintf (stderr, "\n\nadjusting fixup:\n");
753 print_fixup (fixp);
754#endif
755
756 sym = fixp->fx_addsy;
757
758 /* All symbols should have already been resolved at this
759 point. It is possible to see unresolved expression
760 symbols, though, since they are not in the regular symbol
761 table. */
49309057 762 if (sym != NULL)
e46d99eb 763 resolve_symbol_value (sym, finalize_syms);
efaf0ba4 764
49309057 765 if (fixp->fx_subsy != NULL)
e46d99eb 766 resolve_symbol_value (fixp->fx_subsy, finalize_syms);
252b5132
RH		 767
768 /* If this symbol is equated to an undefined symbol, convert
769 the fixup to being against that symbol. */
49309057 770 if (sym != NULL && symbol_equated_p (sym)
252b5132
RH		 771 && (! S_IS_DEFINED (sym) || S_IS_COMMON (sym)))
772 {
49309057
ILT		 773 fixp->fx_offset += symbol_get_value_expression (sym)->X_add_number;
774 sym = symbol_get_value_expression (sym)->X_add_symbol;
252b5132
RH		 775 fixp->fx_addsy = sym;
776 }
777
49309057 778 if (sym != NULL && symbol_mri_common_p (sym))
252b5132
RH		 779 {
780 /* These symbols are handled specially in fixup_segment. */
781 goto done;
782 }
783
784 symsec = S_GET_SEGMENT (sym);
785
786 if (symsec == NULL)
787 abort ();
efaf0ba4 788
252b5132
RH		 789 if (bfd_is_abs_section (symsec))
790 {
791 /* The fixup_segment routine will not use this symbol in a
792 relocation unless TC_FORCE_RELOCATION returns 1. */
793 if (TC_FORCE_RELOCATION (fixp))
794 {
49309057 795 symbol_mark_used_in_reloc (fixp->fx_addsy);
252b5132
RH		 796#ifdef UNDEFINED_DIFFERENCE_OK
797 if (fixp->fx_subsy != NULL)
49309057 798 symbol_mark_used_in_reloc (fixp->fx_subsy);
252b5132
RH		 799#endif
800 }
801 goto done;
802 }
803
804 /* If it's one of these sections, assume the symbol is
805 definitely going to be output. The code in
806 md_estimate_size_before_relax in tc-mips.c uses this test
807 as well, so if you change this code you should look at that
808 code. */
809 if (bfd_is_und_section (symsec)
810 || bfd_is_com_section (symsec))
811 {
49309057 812 symbol_mark_used_in_reloc (fixp->fx_addsy);
252b5132
RH		 813#ifdef UNDEFINED_DIFFERENCE_OK
814 /* We have the difference of an undefined symbol and some
815 other symbol. Make sure to mark the other symbol as used
816 in a relocation so that it will always be output. */
817 if (fixp->fx_subsy)
49309057 818 symbol_mark_used_in_reloc (fixp->fx_subsy);
252b5132
RH		 819#endif
820 goto done;
821 }
822
7565ed77
ILT		 823 /* Don't try to reduce relocs which refer to non-local symbols
824 in .linkonce sections. It can lead to confusion when a
825 debugging section refers to a .linkonce section. I hope
826 this will always be correct. */
827 if (symsec != sec && ! S_IS_LOCAL (sym))
252b5132
RH		 828 {
829 boolean linkonce;
830
831 linkonce = false;
832#ifdef BFD_ASSEMBLER
833 if ((bfd_get_section_flags (stdoutput, symsec) & SEC_LINK_ONCE)
834 != 0)
835 linkonce = true;
836#endif
837#ifdef OBJ_ELF
838 /* The GNU toolchain uses an extension for ELF: a section
839 beginning with the magic string .gnu.linkonce is a
840 linkonce section. */
841 if (strncmp (segment_name (symsec), ".gnu.linkonce",
842 sizeof ".gnu.linkonce" - 1) == 0)
843 linkonce = true;
844#endif
845
846 if (linkonce)
847 {
49309057 848 symbol_mark_used_in_reloc (fixp->fx_addsy);
252b5132
RH		 849#ifdef UNDEFINED_DIFFERENCE_OK
850 if (fixp->fx_subsy != NULL)
49309057 851 symbol_mark_used_in_reloc (fixp->fx_subsy);
252b5132
RH		 852#endif
853 goto done;
854 }
855 }
856
857 /* Since we're reducing to section symbols, don't attempt to reduce
858 anything that's already using one. */
49309057 859 if (symbol_section_p (sym))
252b5132 860 {
49309057 861 symbol_mark_used_in_reloc (fixp->fx_addsy);
252b5132
RH		 862 goto done;
863 }
864
865#ifdef BFD_ASSEMBLER
866 /* We can never adjust a reloc against a weak symbol. If we
867 did, and the weak symbol was overridden by a real symbol
868 somewhere else, then our relocation would be pointing at
869 the wrong area of memory. */
870 if (S_IS_WEAK (sym))
871 {
49309057 872 symbol_mark_used_in_reloc (fixp->fx_addsy);
252b5132
RH		 873 goto done;
874 }
875#endif
876
877 /* Is there some other reason we can't adjust this one? (E.g.,
878 call/bal links in i960-bout symbols.) */
879#ifdef obj_fix_adjustable
880 if (! obj_fix_adjustable (fixp))
881 {
49309057 882 symbol_mark_used_in_reloc (fixp->fx_addsy);
252b5132
RH		 883 goto done;
884 }
885#endif
886
887 /* Is there some other (target cpu dependent) reason we can't adjust
888 this one? (E.g. relocations involving function addresses on
889 the PA. */
890#ifdef tc_fix_adjustable
891 if (! tc_fix_adjustable (fixp))
892 {
49309057 893 symbol_mark_used_in_reloc (fixp->fx_addsy);
252b5132
RH		 894 goto done;
895 }
896#endif
897
898 /* If the section symbol isn't going to be output, the relocs
899 at least should still work. If not, figure out what to do
900 when we run into that case.
901
902 We refetch the segment when calling section_symbol, rather
903 than using symsec, because S_GET_VALUE may wind up changing
efaf0ba4 904 the section when it calls resolve_symbol_value. */
252b5132
RH		 905 fixp->fx_offset += S_GET_VALUE (sym);
906 fixp->fx_addsy = section_symbol (S_GET_SEGMENT (sym));
49309057 907 symbol_mark_used_in_reloc (fixp->fx_addsy);
e723ef7c
ILT		 908#ifdef DEBUG5
909 fprintf (stderr, "\nadjusted fixup:\n");
910 print_fixup (fixp);
911#endif
252b5132
RH		 912
913 done:
914 ;
915 }
efaf0ba4 916#if 1 /* def RELOC_REQUIRES_SYMBOL */
252b5132
RH		 917 else
918 {
919 /* There was no symbol required by this relocation. However,
920 BFD doesn't really handle relocations without symbols well.
921 (At least, the COFF support doesn't.) So for now we fake up
922 a local symbol in the absolute section. */
923
924 fixp->fx_addsy = section_symbol (absolute_section);
efaf0ba4
NC		 925#if 0
926 fixp->fx_addsy->sy_used_in_reloc = 1;
927#endif
252b5132
RH		 928 }
929#endif
930
931 dump_section_relocs (abfd, sec, stderr);
932}
933
934static void
935write_relocs (abfd, sec, xxx)
936 bfd *abfd;
937 asection *sec;
ab9da554 938 PTR xxx ATTRIBUTE_UNUSED;
252b5132
RH		 939{
940 segment_info_type *seginfo = seg_info (sec);
927781e2 941 unsigned int i;
252b5132
RH		 942 unsigned int n;
943 arelent **relocs;
944 fixS *fixp;
945 char *err;
946
947 /* If seginfo is NULL, we did not create this section; don't do
948 anything with it. */
949 if (seginfo == NULL)
950 return;
951
952 fixup_segment (seginfo->fix_root, sec);
953
954 n = 0;
955 for (fixp = seginfo->fix_root; fixp; fixp = fixp->fx_next)
956 n++;
957
958#ifndef RELOC_EXPANSION_POSSIBLE
959 /* Set up reloc information as well. */
960 relocs = (arelent **) xmalloc (n * sizeof (arelent *));
efaf0ba4 961 memset ((char *) relocs, 0, n * sizeof (arelent *));
252b5132
RH		 962
963 i = 0;
964 for (fixp = seginfo->fix_root; fixp != (fixS *) NULL; fixp = fixp->fx_next)
965 {
966 arelent *reloc;
967 bfd_reloc_status_type s;
968 symbolS *sym;
969
970 if (fixp->fx_done)
971 {
972 n--;
973 continue;
974 }
975
976 /* If this is an undefined symbol which was equated to another
977 symbol, then use generate the reloc against the latter symbol
978 rather than the former. */
979 sym = fixp->fx_addsy;
49309057 980 while (symbol_equated_p (sym)
252b5132
RH		 981 && (! S_IS_DEFINED (sym) || S_IS_COMMON (sym)))
982 {
983 symbolS *n;
984
985 /* We must avoid looping, as that can occur with a badly
986 written program. */
49309057 987 n = symbol_get_value_expression (sym)->X_add_symbol;
252b5132
RH		 988 if (n == sym)
989 break;
49309057 990 fixp->fx_offset += symbol_get_value_expression (sym)->X_add_number;
252b5132
RH		 991 sym = n;
992 }
993 fixp->fx_addsy = sym;
994
995 reloc = tc_gen_reloc (sec, fixp);
996 if (!reloc)
997 {
998 n--;
999 continue;
1000 }
1001
1002#if 0
1003 /* This test is triggered inappropriately for the SH. */
1004 if (fixp->fx_where + fixp->fx_size
1005 > fixp->fx_frag->fr_fix + fixp->fx_frag->fr_offset)
1006 abort ();
1007#endif
1008
1009 s = bfd_install_relocation (stdoutput, reloc,
1010 fixp->fx_frag->fr_literal,
1011 fixp->fx_frag->fr_address,
1012 sec, &err);
1013 switch (s)
1014 {
1015 case bfd_reloc_ok:
1016 break;
1017 case bfd_reloc_overflow:
1018 as_bad_where (fixp->fx_file, fixp->fx_line, _("relocation overflow"));
1019 break;
1020 case bfd_reloc_outofrange:
1021 as_bad_where (fixp->fx_file, fixp->fx_line, _("relocation out of range"));
1022 break;
1023 default:
1024 as_fatal (_("%s:%u: bad return from bfd_install_relocation: %x"),
1025 fixp->fx_file, fixp->fx_line, s);
1026 }
1027 relocs[i++] = reloc;
1028 }
1029#else
1030 n = n * MAX_RELOC_EXPANSION;
1031 /* Set up reloc information as well. */
1032 relocs = (arelent **) xmalloc (n * sizeof (arelent *));
1033
1034 i = 0;
1035 for (fixp = seginfo->fix_root; fixp != (fixS *) NULL; fixp = fixp->fx_next)
1036 {
1037 arelent **reloc;
1038 char *data;
1039 bfd_reloc_status_type s;
1040 symbolS *sym;
1041 int j;
1042
1043 if (fixp->fx_done)
1044 {
1045 n--;
1046 continue;
1047 }
1048
1049 /* If this is an undefined symbol which was equated to another
44852b19 1050 symbol, then generate the reloc against the latter symbol
252b5132
RH		 1051 rather than the former. */
1052 sym = fixp->fx_addsy;
49309057 1053 while (symbol_equated_p (sym)
252b5132 1054 && (! S_IS_DEFINED (sym) || S_IS_COMMON (sym)))
49309057 1055 sym = symbol_get_value_expression (sym)->X_add_symbol;
252b5132
RH		 1056 fixp->fx_addsy = sym;
1057
1058 reloc = tc_gen_reloc (sec, fixp);
1059
1060 for (j = 0; reloc[j]; j++)
1061 {
efaf0ba4
NC		 1062 relocs[i++] = reloc[j];
1063 assert (i <= n);
252b5132
RH		 1064 }
1065 data = fixp->fx_frag->fr_literal + fixp->fx_where;
1066 if (fixp->fx_where + fixp->fx_size
1067 > fixp->fx_frag->fr_fix + fixp->fx_frag->fr_offset)
1068 as_bad_where (fixp->fx_file, fixp->fx_line,
1069 _("internal error: fixup not contained within frag"));
1070 for (j = 0; reloc[j]; j++)
efaf0ba4 1071 {
252b5132
RH		 1072 s = bfd_install_relocation (stdoutput, reloc[j],
1073 fixp->fx_frag->fr_literal,
1074 fixp->fx_frag->fr_address,
1075 sec, &err);
efaf0ba4 1076 switch (s)
252b5132
RH		 1077 {
1078 case bfd_reloc_ok:
1079 break;
1080 case bfd_reloc_overflow:
1081 as_bad_where (fixp->fx_file, fixp->fx_line,
1082 _("relocation overflow"));
1083 break;
1084 default:
1085 as_fatal (_("%s:%u: bad return from bfd_install_relocation"),
1086 fixp->fx_file, fixp->fx_line);
1087 }
efaf0ba4 1088 }
252b5132
RH		 1089 }
1090 n = i;
1091#endif
1092
1093#ifdef DEBUG4
1094 {
1095 int i, j, nsyms;
1096 asymbol **sympp;
1097 sympp = bfd_get_outsymbols (stdoutput);
1098 nsyms = bfd_get_symcount (stdoutput);
1099 for (i = 0; i < n; i++)
1100 if (((*relocs[i]->sym_ptr_ptr)->flags & BSF_SECTION_SYM) == 0)
1101 {
1102 for (j = 0; j < nsyms; j++)
1103 if (sympp[j] == *relocs[i]->sym_ptr_ptr)
1104 break;
1105 if (j == nsyms)
1106 abort ();
1107 }
1108 }
1109#endif
1110
1111 if (n)
1112 bfd_set_reloc (stdoutput, sec, relocs, n);
1113 else
1114 bfd_set_section_flags (abfd, sec,
1115 (bfd_get_section_flags (abfd, sec)
1116 & (flagword) ~SEC_RELOC));
1117
945a1a6b
ILT		 1118#ifdef SET_SECTION_RELOCS
1119 SET_SECTION_RELOCS (sec, relocs, n);
1120#endif
1121
252b5132
RH		 1122#ifdef DEBUG3
1123 {
1124 int i;
1125 arelent *r;
1126 asymbol *s;
1127 fprintf (stderr, "relocs for sec %s\n", sec->name);
1128 for (i = 0; i < n; i++)
1129 {
1130 r = relocs[i];
1131 s = *r->sym_ptr_ptr;
1132 fprintf (stderr, " reloc %2d @%08x off %4x : sym %-10s addend %x\n",
1133 i, r, r->address, s->name, r->addend);
1134 }
1135 }
1136#endif
1137}
1138
1139static void
1140write_contents (abfd, sec, xxx)
ab9da554 1141 bfd *abfd ATTRIBUTE_UNUSED;
252b5132 1142 asection *sec;
ab9da554 1143 PTR xxx ATTRIBUTE_UNUSED;
252b5132
RH		 1144{
1145 segment_info_type *seginfo = seg_info (sec);
1146 unsigned long offset = 0;
1147 fragS *f;
1148
1149 /* Write out the frags. */
1150 if (seginfo == NULL
efaf0ba4 1151 || !(bfd_get_section_flags (abfd, sec) & SEC_HAS_CONTENTS))
252b5132
RH		 1152 return;
1153
1154 for (f = seginfo->frchainP->frch_root;
1155 f;
1156 f = f->fr_next)
1157 {
1158 int x;
1159 unsigned long fill_size;
1160 char *fill_literal;
1161 long count;
1162
1163 assert (f->fr_type == rs_fill);
1164 if (f->fr_fix)
1165 {
1166 x = bfd_set_section_contents (stdoutput, sec,
1167 f->fr_literal, (file_ptr) offset,
1168 (bfd_size_type) f->fr_fix);
1169 if (x == false)
1170 {
1171 bfd_perror (stdoutput->filename);
1172 as_perror (_("FATAL: Can't write %s"), stdoutput->filename);
1173 exit (EXIT_FAILURE);
1174 }
1175 offset += f->fr_fix;
1176 }
1177 fill_literal = f->fr_literal + f->fr_fix;
1178 fill_size = f->fr_var;
1179 count = f->fr_offset;
1180 assert (count >= 0);
1181 if (fill_size && count)
1182 {
1183 char buf[256];
efaf0ba4 1184 if (fill_size > sizeof (buf))
252b5132 1185 {
efaf0ba4 1186 /* Do it the old way. Can this ever happen? */
252b5132
RH		 1187 while (count--)
1188 {
1189 x = bfd_set_section_contents (stdoutput, sec,
1190 fill_literal,
1191 (file_ptr) offset,
1192 (bfd_size_type) fill_size);
1193 if (x == false)
1194 {
1195 bfd_perror (stdoutput->filename);
efaf0ba4
NC		 1196 as_perror (_("FATAL: Can't write %s"),
1197 stdoutput->filename);
252b5132
RH		 1198 exit (EXIT_FAILURE);
1199 }
1200 offset += fill_size;
1201 }
1202 }
1203 else
1204 {
1205 /* Build a buffer full of fill objects and output it as
1206 often as necessary. This saves on the overhead of
1207 potentially lots of bfd_set_section_contents calls. */
1208 int n_per_buf, i;
1209 if (fill_size == 1)
1210 {
1211 n_per_buf = sizeof (buf);
1212 memset (buf, *fill_literal, n_per_buf);
1213 }
1214 else
1215 {
1216 char *bufp;
efaf0ba4 1217 n_per_buf = sizeof (buf) / fill_size;
252b5132 1218 for (i = n_per_buf, bufp = buf; i; i--, bufp += fill_size)
efaf0ba4 1219 memcpy (bufp, fill_literal, fill_size);
252b5132
RH		 1220 }
1221 for (; count > 0; count -= n_per_buf)
1222 {
1223 n_per_buf = n_per_buf > count ? count : n_per_buf;
efaf0ba4
NC		 1224 x = bfd_set_section_contents
1225 (stdoutput, sec, buf, (file_ptr) offset,
1226 (bfd_size_type) n_per_buf * fill_size);
252b5132
RH		 1227 if (x != true)
1228 as_fatal (_("Cannot write to output file."));
1229 offset += n_per_buf * fill_size;
1230 }
1231 }
1232 }
1233 }
1234}
1235#endif
1236
1237#if defined(BFD_ASSEMBLER) || (!defined (BFD) && !defined(OBJ_AOUT))
1238static void
1239merge_data_into_text ()
1240{
1241#if defined(BFD_ASSEMBLER) || defined(MANY_SEGMENTS)
1242 seg_info (text_section)->frchainP->frch_last->fr_next =
1243 seg_info (data_section)->frchainP->frch_root;
1244 seg_info (text_section)->frchainP->frch_last =
1245 seg_info (data_section)->frchainP->frch_last;
1246 seg_info (data_section)->frchainP = 0;
1247#else
1248 fixS *tmp;
1249
1250 text_last_frag->fr_next = data_frag_root;
1251 text_last_frag = data_last_frag;
1252 data_last_frag = NULL;
1253 data_frag_root = NULL;
1254 if (text_fix_root)
1255 {
1256 for (tmp = text_fix_root; tmp->fx_next; tmp = tmp->fx_next);;
1257 tmp->fx_next = data_fix_root;
1258 text_fix_tail = data_fix_tail;
1259 }
1260 else
1261 text_fix_root = data_fix_root;
1262 data_fix_root = NULL;
1263#endif
1264}
efaf0ba4 1265#endif /* BFD_ASSEMBLER || (! BFD && ! OBJ_AOUT) */
252b5132
RH		 1266
1267#if !defined (BFD_ASSEMBLER) && !defined (BFD)
1268static void
1269relax_and_size_all_segments ()
1270{
1271 fragS *fragP;
1272
1273 relax_segment (text_frag_root, SEG_TEXT);
1274 relax_segment (data_frag_root, SEG_DATA);
1275 relax_segment (bss_frag_root, SEG_BSS);
252b5132 1276
efaf0ba4 1277 /* Now the addresses of frags are correct within the segment. */
252b5132
RH		 1278 know (text_last_frag->fr_type == rs_fill && text_last_frag->fr_offset == 0);
1279 H_SET_TEXT_SIZE (&headers, text_last_frag->fr_address);
1280 text_last_frag->fr_address = H_GET_TEXT_SIZE (&headers);
1281
efaf0ba4
NC		 1282 /* Join the 2 segments into 1 huge segment.
1283 To do this, re-compute every rn_address in the SEG_DATA frags.
1284 Then join the data frags after the text frags.
58a77e41 1285
efaf0ba4 1286 Determine a_data [length of data segment]. */
252b5132
RH		 1287 if (data_frag_root)
1288 {
1289 register relax_addressT slide;
1290
efaf0ba4
NC		 1291 know ((text_last_frag->fr_type == rs_fill)
1292 && (text_last_frag->fr_offset == 0));
252b5132
RH		 1293
1294 H_SET_DATA_SIZE (&headers, data_last_frag->fr_address);
1295 data_last_frag->fr_address = H_GET_DATA_SIZE (&headers);
efaf0ba4 1296 slide = H_GET_TEXT_SIZE (&headers); /* & in file of the data segment. */
252b5132
RH		 1297#ifdef OBJ_BOUT
1298#define RoundUp(N,S) (((N)+(S)-1)&-(S))
1299 /* For b.out: If the data section has a strict alignment
1300 requirement, its load address in the .o file will be
1301 rounded up from the size of the text section. These
1302 two values are *not* the same! Similarly for the bss
1303 section.... */
1304 slide = RoundUp (slide, 1 << section_alignment[SEG_DATA]);
1305#endif
1306
1307 for (fragP = data_frag_root; fragP; fragP = fragP->fr_next)
efaf0ba4 1308 fragP->fr_address += slide;
252b5132
RH		 1309
1310 know (text_last_frag != 0);
1311 text_last_frag->fr_next = data_frag_root;
1312 }
1313 else
1314 {
1315 H_SET_DATA_SIZE (&headers, 0);
1316 }
1317
1318#ifdef OBJ_BOUT
1319 /* See above comments on b.out data section address. */
1320 {
1321 long bss_vma;
1322 if (data_last_frag == 0)
1323 bss_vma = H_GET_TEXT_SIZE (&headers);
1324 else
1325 bss_vma = data_last_frag->fr_address;
1326 bss_vma = RoundUp (bss_vma, 1 << section_alignment[SEG_BSS]);
1327 bss_address_frag.fr_address = bss_vma;
1328 }
efaf0ba4 1329#else /* ! OBJ_BOUT */
252b5132
RH		 1330 bss_address_frag.fr_address = (H_GET_TEXT_SIZE (&headers) +
1331 H_GET_DATA_SIZE (&headers));
1332
efaf0ba4 1333#endif /* ! OBJ_BOUT */
252b5132 1334
efaf0ba4 1335 /* Slide all the frags. */
252b5132
RH		 1336 if (bss_frag_root)
1337 {
1338 relax_addressT slide = bss_address_frag.fr_address;
1339
1340 for (fragP = bss_frag_root; fragP; fragP = fragP->fr_next)
efaf0ba4 1341 fragP->fr_address += slide;
252b5132
RH		 1342 }
1343
1344 if (bss_last_frag)
1345 H_SET_BSS_SIZE (&headers,
1346 bss_last_frag->fr_address - bss_frag_root->fr_address);
1347 else
1348 H_SET_BSS_SIZE (&headers, 0);
1349}
efaf0ba4 1350#endif /* ! BFD_ASSEMBLER && ! BFD */
252b5132
RH		 1351
1352#if defined (BFD_ASSEMBLER) || !defined (BFD)
1353
1354#ifdef BFD_ASSEMBLER
1355static void
1356set_symtab ()
1357{
1358 int nsyms;
1359 asymbol **asympp;
1360 symbolS *symp;
1361 boolean result;
1362 extern PTR bfd_alloc PARAMS ((bfd *, size_t));
1363
1364 /* Count symbols. We can't rely on a count made by the loop in
1365 write_object_file, because *_frob_file may add a new symbol or
1366 two. */
1367 nsyms = 0;
1368 for (symp = symbol_rootP; symp; symp = symbol_next (symp))
1369 nsyms++;
1370
1371 if (nsyms)
1372 {
1373 int i;
1374
1375 asympp = (asymbol **) bfd_alloc (stdoutput,
1376 nsyms * sizeof (asymbol *));
1377 symp = symbol_rootP;
1378 for (i = 0; i < nsyms; i++, symp = symbol_next (symp))
1379 {
49309057
ILT		 1380 asympp[i] = symbol_get_bfdsym (symp);
1381 symbol_mark_written (symp);
252b5132
RH		 1382 }
1383 }
1384 else
1385 asympp = 0;
1386 result = bfd_set_symtab (stdoutput, asympp, nsyms);
1387 assert (result == true);
1388 symbol_table_frozen = 1;
1389}
1390#endif
1391
6aa4f516 1392#if defined (BFD_ASSEMBLER) && defined (OBJ_COFF) && defined (TE_GO32)
dbddefbf
NC		 1393static void
1394set_segment_vma (abfd, sec, xxx)
1395 bfd *abfd;
1396 asection *sec;
1397 PTR xxx ATTRIBUTE_UNUSED;
1398{
1399 static bfd_vma addr = 0;
efaf0ba4 1400
dbddefbf
NC		 1401 bfd_set_section_vma (abfd, sec, addr);
1402 addr += bfd_section_size (abfd, sec);
1403}
efaf0ba4 1404#endif /* BFD_ASSEMBLER && OBJ_COFF && !TE_PE */
dbddefbf 1405
252b5132
RH		 1406/* Finish the subsegments. After every sub-segment, we fake an
1407 ".align ...". This conforms to BSD4.2 brane-damage. We then fake
1408 ".fill 0" because that is the kind of frag that requires least
1409 thought. ".align" frags like to have a following frag since that
1410 makes calculating their intended length trivial. */
1411
1412#ifndef SUB_SEGMENT_ALIGN
1413#ifdef BFD_ASSEMBLER
1414#define SUB_SEGMENT_ALIGN(SEG) (0)
1415#else
1416#define SUB_SEGMENT_ALIGN(SEG) (2)
1417#endif
1418#endif
1419
1420void
1421subsegs_finish ()
1422{
1423 struct frchain *frchainP;
1424
1425 for (frchainP = frchain_root; frchainP; frchainP = frchainP->frch_next)
1426 {
0a9ef439
RH		 1427 int alignment;
1428
252b5132
RH		 1429 subseg_set (frchainP->frch_seg, frchainP->frch_subseg);
1430
1431 /* This now gets called even if we had errors. In that case,
1432 any alignment is meaningless, and, moreover, will look weird
1433 if we are generating a listing. */
0a9ef439
RH		 1434 alignment = had_errors () ? 0 : SUB_SEGMENT_ALIGN (now_seg);
1435
1436 /* The last subsegment gets an aligment corresponding to the
1437 alignment of the section. This allows proper nop-filling
1438 at the end of code-bearing sections. */
1439 if (!frchainP->frch_next || frchainP->frch_next->frch_seg != now_seg)
1440 alignment = get_recorded_alignment (now_seg);
1441
799051fc
RH		 1442 if (subseg_text_p (now_seg))
1443 frag_align_code (alignment, 0);
1444 else
1445 frag_align (alignment, 0, 0);
252b5132
RH		 1446
1447 /* frag_align will have left a new frag.
1448 Use this last frag for an empty ".fill".
1449
1450 For this segment ...
1451 Create a last frag. Do not leave a "being filled in frag". */
252b5132
RH		 1452 frag_wane (frag_now);
1453 frag_now->fr_fix = 0;
1454 know (frag_now->fr_next == NULL);
1455 }
1456}
1457
1458/* Write the object file. */
1459
1460void
1461write_object_file ()
1462{
1463#if ! defined (BFD_ASSEMBLER) || ! defined (WORKING_DOT_WORD)
efaf0ba4 1464 fragS *fragP; /* Track along all frags. */
252b5132
RH		 1465#endif
1466
1467 /* Do we really want to write it? */
1468 {
1469 int n_warns, n_errs;
1470 n_warns = had_warnings ();
1471 n_errs = had_errors ();
1472 /* The -Z flag indicates that an object file should be generated,
1473 regardless of warnings and errors. */
1474 if (flag_always_generate_output)
1475 {
1476 if (n_warns || n_errs)
1477 as_warn (_("%d error%s, %d warning%s, generating bad object file.\n"),
1478 n_errs, n_errs == 1 ? "" : "s",
1479 n_warns, n_warns == 1 ? "" : "s");
1480 }
1481 else
1482 {
1483 if (n_errs)
1484 as_fatal (_("%d error%s, %d warning%s, no object file generated.\n"),
1485 n_errs, n_errs == 1 ? "" : "s",
1486 n_warns, n_warns == 1 ? "" : "s");
1487 }
1488 }
1489
1490#ifdef OBJ_VMS
1491 /* Under VMS we try to be compatible with VAX-11 "C". Thus, we call
1492 a routine to check for the definition of the procedure "_main",
efaf0ba4 1493 and if so -- fix it up so that it can be program entry point. */
252b5132 1494 vms_check_for_main ();
efaf0ba4 1495#endif /* OBJ_VMS */
252b5132
RH		 1496
1497 /* From now on, we don't care about sub-segments. Build one frag chain
1498 for each segment. Linked thru fr_next. */
1499
1500#ifdef BFD_ASSEMBLER
1501 /* Remove the sections created by gas for its own purposes. */
1502 {
1503 asection **seclist, *sec;
1504 int i;
1505
1506 seclist = &stdoutput->sections;
1507 while (seclist && *seclist)
1508 {
1509 sec = *seclist;
1510 while (sec == reg_section || sec == expr_section)
1511 {
1512 sec = sec->next;
1513 *seclist = sec;
1514 stdoutput->section_count--;
1515 if (!sec)
1516 break;
1517 }
1518 if (*seclist)
1519 seclist = &(*seclist)->next;
1520 }
1521 i = 0;
1522 bfd_map_over_sections (stdoutput, renumber_sections, &i);
1523 }
1524
1525 bfd_map_over_sections (stdoutput, chain_frchains_together, (char *) 0);
1526#else
1527 remove_subsegs (frchain_root, SEG_TEXT, &text_frag_root, &text_last_frag);
1528 remove_subsegs (data0_frchainP, SEG_DATA, &data_frag_root, &data_last_frag);
1529 remove_subsegs (bss0_frchainP, SEG_BSS, &bss_frag_root, &bss_last_frag);
1530#endif
1531
1532 /* We have two segments. If user gave -R flag, then we must put the
1533 data frags into the text segment. Do this before relaxing so
1534 we know to take advantage of -R and make shorter addresses. */
1535#if !defined (OBJ_AOUT) || defined (BFD_ASSEMBLER)
1536 if (flag_readonly_data_in_text)
1537 {
1538 merge_data_into_text ();
1539 }
1540#endif
1541
1542#ifdef BFD_ASSEMBLER
e46d99eb
AM		 1543 while (1)
1544 {
1545 int changed;
1546
1547 changed = 0;
1548 bfd_map_over_sections (stdoutput, relax_seg, &changed);
1549 if (!changed)
1550 break;
1551 }
1552 bfd_map_over_sections (stdoutput, size_seg, (char *) 0);
252b5132
RH		 1553#else
1554 relax_and_size_all_segments ();
efaf0ba4 1555#endif /* BFD_ASSEMBLER */
252b5132 1556
e46d99eb
AM		 1557 /* Relaxation has completed. Freeze all syms. */
1558 finalize_syms = 2;
1559
6aa4f516 1560#if defined (BFD_ASSEMBLER) && defined (OBJ_COFF) && defined (TE_GO32)
dbddefbf 1561 /* Now that the segments have their final sizes, run through the
6aa4f516
NC		 1562 sections and set their vma and lma. !BFD gas sets them, and BFD gas
1563 should too. Currently, only DJGPP uses this code, but other
1564 COFF targets may need to execute this too. */
dbddefbf
NC		 1565 bfd_map_over_sections (stdoutput, set_segment_vma, (char *) 0);
1566#endif
1567
252b5132 1568#ifndef BFD_ASSEMBLER
efaf0ba4 1569 /* Crawl the symbol chain.
58a77e41 1570
efaf0ba4
NC		 1571 For each symbol whose value depends on a frag, take the address of
1572 that frag and subsume it into the value of the symbol.
1573 After this, there is just one way to lookup a symbol value.
1574 Values are left in their final state for object file emission.
1575 We adjust the values of 'L' local symbols, even if we do
1576 not intend to emit them to the object file, because their values
1577 are needed for fix-ups.
58a77e41 1578
efaf0ba4
NC		 1579 Unless we saw a -L flag, remove all symbols that begin with 'L'
1580 from the symbol chain. (They are still pointed to by the fixes.)
58a77e41 1581
efaf0ba4
NC		 1582 Count the remaining symbols.
1583 Assign a symbol number to each symbol.
1584 Count the number of string-table chars we will emit.
1585 Put this info into the headers as appropriate. */
252b5132
RH		 1586 know (zero_address_frag.fr_address == 0);
1587 string_byte_count = sizeof (string_byte_count);
1588
1589 obj_crawl_symbol_chain (&headers);
1590
1591 if (string_byte_count == sizeof (string_byte_count))
1592 string_byte_count = 0;
1593
1594 H_SET_STRING_SIZE (&headers, string_byte_count);
1595
efaf0ba4
NC		 1596 /* Addresses of frags now reflect addresses we use in the object file.
1597 Symbol values are correct.
1598 Scan the frags, converting any ".org"s and ".align"s to ".fill"s.
1599 Also converting any machine-dependent frags using md_convert_frag(); */
252b5132
RH		 1600 subseg_change (SEG_TEXT, 0);
1601
1602 for (fragP = text_frag_root; fragP; fragP = fragP->fr_next)
1603 {
1604 /* At this point we have linked all the frags into a single
1605 chain. However, cvt_frag_to_fill may call md_convert_frag
1606 which may call fix_new. We need to ensure that fix_new adds
1607 the fixup to the right section. */
1608 if (fragP == data_frag_root)
1609 subseg_change (SEG_DATA, 0);
1610
1611 cvt_frag_to_fill (&headers, SEG_TEXT, fragP);
1612
1613 /* Some assert macros don't work with # directives mixed in. */
1614#ifndef NDEBUG
1615 if (!(fragP->fr_next == NULL
1616#ifdef OBJ_BOUT
1617 || fragP->fr_next == data_frag_root
1618#endif
1619 || ((fragP->fr_next->fr_address - fragP->fr_address)
1620 == (fragP->fr_fix + fragP->fr_offset * fragP->fr_var))))
1621 abort ();
1622#endif
1623 }
efaf0ba4 1624#endif /* ! BFD_ASSEMBLER */
252b5132
RH		 1625
1626#ifndef WORKING_DOT_WORD
1627 {
1628 struct broken_word *lie;
1629 struct broken_word **prevP;
1630
1631 prevP = &broken_words;
1632 for (lie = broken_words; lie; lie = lie->next_broken_word)
1633 if (!lie->added)
1634 {
1635 expressionS exp;
1636
1637 subseg_change (lie->seg, lie->subseg);
1638 exp.X_op = O_subtract;
1639 exp.X_add_symbol = lie->add;
1640 exp.X_op_symbol = lie->sub;
1641 exp.X_add_number = lie->addnum;
1642#ifdef BFD_ASSEMBLER
1643#ifdef TC_CONS_FIX_NEW
1644 TC_CONS_FIX_NEW (lie->frag,
efaf0ba4
NC		 1645 lie->word_goes_here - lie->frag->fr_literal,
1646 2, &exp);
252b5132
RH		 1647#else
1648 fix_new_exp (lie->frag,
1649 lie->word_goes_here - lie->frag->fr_literal,
1650 2, &exp, 0, BFD_RELOC_16);
1651#endif
1652#else
1653#if defined(TC_SPARC) || defined(TC_A29K) || defined(NEED_FX_R_TYPE)
1654 fix_new_exp (lie->frag,
1655 lie->word_goes_here - lie->frag->fr_literal,
1656 2, &exp, 0, NO_RELOC);
1657#else
1658#ifdef TC_NS32K
1659 fix_new_ns32k_exp (lie->frag,
1660 lie->word_goes_here - lie->frag->fr_literal,
1661 2, &exp, 0, 0, 2, 0, 0);
1662#else
1663 fix_new_exp (lie->frag,
1664 lie->word_goes_here - lie->frag->fr_literal,
1665 2, &exp, 0, 0);
efaf0ba4
NC		 1666#endif /* TC_NS32K */
1667#endif /* TC_SPARC|TC_A29K|NEED_FX_R_TYPE */
1668#endif /* BFD_ASSEMBLER */
252b5132
RH		 1669 *prevP = lie->next_broken_word;
1670 }
1671 else
1672 prevP = &(lie->next_broken_word);
1673
1674 for (lie = broken_words; lie;)
1675 {
1676 struct broken_word *untruth;
1677 char *table_ptr;
1678 addressT table_addr;
1679 addressT from_addr, to_addr;
1680 int n, m;
1681
1682 subseg_change (lie->seg, lie->subseg);
1683 fragP = lie->dispfrag;
1684
1685 /* Find out how many broken_words go here. */
1686 n = 0;
efaf0ba4
NC		 1687 for (untruth = lie;
1688 untruth && untruth->dispfrag == fragP;
1689 untruth = untruth->next_broken_word)
252b5132
RH		 1690 if (untruth->added == 1)
1691 n++;
1692
1693 table_ptr = lie->dispfrag->fr_opcode;
efaf0ba4
NC		 1694 table_addr = (lie->dispfrag->fr_address
1695 + (table_ptr - lie->dispfrag->fr_literal));
252b5132
RH		 1696 /* Create the jump around the long jumps. This is a short
1697 jump from table_ptr+0 to table_ptr+n*long_jump_size. */
1698 from_addr = table_addr;
1699 to_addr = table_addr + md_short_jump_size + n * md_long_jump_size;
efaf0ba4
NC		 1700 md_create_short_jump (table_ptr, from_addr, to_addr, lie->dispfrag,
1701 lie->add);
252b5132
RH		 1702 table_ptr += md_short_jump_size;
1703 table_addr += md_short_jump_size;
1704
efaf0ba4
NC		 1705 for (m = 0;
1706 lie && lie->dispfrag == fragP;
1707 m++, lie = lie->next_broken_word)
252b5132
RH		 1708 {
1709 if (lie->added == 2)
1710 continue;
efaf0ba4
NC		 1711 /* Patch the jump table. */
1712 /* This is the offset from ??? to table_ptr+0. */
252b5132
RH		 1713 to_addr = table_addr - S_GET_VALUE (lie->sub);
1714#ifdef BFD_ASSEMBLER
49309057 1715 to_addr -= symbol_get_frag (lie->sub)->fr_address;
753f6b12
HPN		 1716#endif
1717#ifdef TC_CHECK_ADJUSTED_BROKEN_DOT_WORD
1718 TC_CHECK_ADJUSTED_BROKEN_DOT_WORD (to_addr, lie);
252b5132
RH		 1719#endif
1720 md_number_to_chars (lie->word_goes_here, to_addr, 2);
efaf0ba4
NC		 1721 for (untruth = lie->next_broken_word;
1722 untruth && untruth->dispfrag == fragP;
1723 untruth = untruth->next_broken_word)
252b5132
RH		 1724 {
1725 if (untruth->use_jump == lie)
1726 md_number_to_chars (untruth->word_goes_here, to_addr, 2);
1727 }
1728
efaf0ba4
NC		 1729 /* Install the long jump. */
1730 /* This is a long jump from table_ptr+0 to the final target. */
252b5132
RH		 1731 from_addr = table_addr;
1732 to_addr = S_GET_VALUE (lie->add) + lie->addnum;
1733#ifdef BFD_ASSEMBLER
49309057 1734 to_addr += symbol_get_frag (lie->add)->fr_address;
252b5132 1735#endif
efaf0ba4
NC		 1736 md_create_long_jump (table_ptr, from_addr, to_addr, lie->dispfrag,
1737 lie->add);
252b5132
RH		 1738 table_ptr += md_long_jump_size;
1739 table_addr += md_long_jump_size;
1740 }
1741 }
1742 }
efaf0ba4 1743#endif /* not WORKING_DOT_WORD */
252b5132
RH		 1744
1745#ifndef BFD_ASSEMBLER
1746#ifndef OBJ_VMS
efaf0ba4 1747 { /* not vms */
252b5132
RH		 1748 char *the_object_file;
1749 long object_file_size;
efaf0ba4
NC		 1750 /* Scan every FixS performing fixups. We had to wait until now to
1751 do this because md_convert_frag() may have made some fixSs. */
252b5132
RH		 1752 int trsize, drsize;
1753
1754 subseg_change (SEG_TEXT, 0);
1755 trsize = md_reloc_size * fixup_segment (text_fix_root, SEG_TEXT);
1756 subseg_change (SEG_DATA, 0);
1757 drsize = md_reloc_size * fixup_segment (data_fix_root, SEG_DATA);
1758 H_SET_RELOCATION_SIZE (&headers, trsize, drsize);
1759
efaf0ba4 1760 /* FIXME: Move this stuff into the pre-write-hook. */
252b5132
RH		 1761 H_SET_MAGIC_NUMBER (&headers, magic_number_for_object_file);
1762 H_SET_ENTRY_POINT (&headers, 0);
1763
efaf0ba4 1764 obj_pre_write_hook (&headers); /* Extra coff stuff. */
252b5132
RH		 1765
1766 object_file_size = H_GET_FILE_SIZE (&headers);
1767 next_object_file_charP = the_object_file = xmalloc (object_file_size);
1768
1769 output_file_create (out_file_name);
1770
1771 obj_header_append (&next_object_file_charP, &headers);
1772
efaf0ba4
NC		 1773 know ((next_object_file_charP - the_object_file)
1774 == H_GET_HEADER_SIZE (&headers));
252b5132 1775
efaf0ba4 1776 /* Emit code. */
252b5132
RH		 1777 for (fragP = text_frag_root; fragP; fragP = fragP->fr_next)
1778 {
1779 register long count;
1780 register char *fill_literal;
1781 register long fill_size;
1782
1783 PROGRESS (1);
1784 know (fragP->fr_type == rs_fill);
efaf0ba4
NC		 1785 append (&next_object_file_charP, fragP->fr_literal,
1786 (unsigned long) fragP->fr_fix);
252b5132
RH		 1787 fill_literal = fragP->fr_literal + fragP->fr_fix;
1788 fill_size = fragP->fr_var;
1789 know (fragP->fr_offset >= 0);
1790
1791 for (count = fragP->fr_offset; count; count--)
efaf0ba4
NC		 1792 append (&next_object_file_charP, fill_literal,
1793 (unsigned long) fill_size);
1794 }
252b5132 1795
efaf0ba4
NC		 1796 know ((next_object_file_charP - the_object_file)
1797 == (H_GET_HEADER_SIZE (&headers)
1798 + H_GET_TEXT_SIZE (&headers)
1799 + H_GET_DATA_SIZE (&headers)));
1800
1801 /* Emit relocations. */
1802 obj_emit_relocations (&next_object_file_charP, text_fix_root,
1803 (relax_addressT) 0);
1804 know ((next_object_file_charP - the_object_file)
1805 == (H_GET_HEADER_SIZE (&headers)
1806 + H_GET_TEXT_SIZE (&headers)
1807 + H_GET_DATA_SIZE (&headers)
1808 + H_GET_TEXT_RELOCATION_SIZE (&headers)));
252b5132
RH		 1809#ifdef TC_I960
1810 /* Make addresses in data relocation directives relative to beginning of
efaf0ba4
NC		 1811 first data fragment, not end of last text fragment: alignment of the
1812 start of the data segment may place a gap between the segments. */
1813 obj_emit_relocations (&next_object_file_charP, data_fix_root,
1814 data0_frchainP->frch_root->fr_address);
1815#else /* TC_I960 */
1816 obj_emit_relocations (&next_object_file_charP, data_fix_root,
1817 text_last_frag->fr_address);
1818#endif /* TC_I960 */
1819
1820 know ((next_object_file_charP - the_object_file)
1821 == (H_GET_HEADER_SIZE (&headers)
1822 + H_GET_TEXT_SIZE (&headers)
1823 + H_GET_DATA_SIZE (&headers)
1824 + H_GET_TEXT_RELOCATION_SIZE (&headers)
1825 + H_GET_DATA_RELOCATION_SIZE (&headers)));
1826
1827 /* Emit line number entries. */
252b5132 1828 OBJ_EMIT_LINENO (&next_object_file_charP, lineno_rootP, the_object_file);
efaf0ba4
NC		 1829 know ((next_object_file_charP - the_object_file)
1830 == (H_GET_HEADER_SIZE (&headers)
1831 + H_GET_TEXT_SIZE (&headers)
1832 + H_GET_DATA_SIZE (&headers)
1833 + H_GET_TEXT_RELOCATION_SIZE (&headers)
1834 + H_GET_DATA_RELOCATION_SIZE (&headers)
1835 + H_GET_LINENO_SIZE (&headers)));
1836
1837 /* Emit symbols. */
252b5132 1838 obj_emit_symbols (&next_object_file_charP, symbol_rootP);
efaf0ba4
NC		 1839 know ((next_object_file_charP - the_object_file)
1840 == (H_GET_HEADER_SIZE (&headers)
1841 + H_GET_TEXT_SIZE (&headers)
1842 + H_GET_DATA_SIZE (&headers)
1843 + H_GET_TEXT_RELOCATION_SIZE (&headers)
1844 + H_GET_DATA_RELOCATION_SIZE (&headers)
1845 + H_GET_LINENO_SIZE (&headers)
1846 + H_GET_SYMBOL_TABLE_SIZE (&headers)));
1847
1848 /* Emit strings. */
252b5132 1849 if (string_byte_count > 0)
efaf0ba4 1850 obj_emit_strings (&next_object_file_charP);
252b5132
RH		 1851
1852#ifdef BFD_HEADERS
1853 bfd_seek (stdoutput, 0, 0);
1854 bfd_write (the_object_file, 1, object_file_size, stdoutput);
1855#else
1856
efaf0ba4 1857 /* Write the data to the file. */
252b5132
RH		 1858 output_file_append (the_object_file, object_file_size, out_file_name);
1859 free (the_object_file);
1860#endif
efaf0ba4
NC		 1861 }
1862#else /* OBJ_VMS */
1863 /* Now do the VMS-dependent part of writing the object file. */
252b5132
RH		 1864 vms_write_object_file (H_GET_TEXT_SIZE (&headers),
1865 H_GET_DATA_SIZE (&headers),
1866 H_GET_BSS_SIZE (&headers),
1867 text_frag_root, data_frag_root);
efaf0ba4
NC		 1868#endif /* OBJ_VMS */
1869#else /* BFD_ASSEMBLER */
252b5132
RH		 1870
1871 /* Resolve symbol values. This needs to be done before processing
1872 the relocations. */
1873 if (symbol_rootP)
1874 {
1875 symbolS *symp;
1876
1877 for (symp = symbol_rootP; symp; symp = symbol_next (symp))
e46d99eb 1878 resolve_symbol_value (symp, finalize_syms);
252b5132 1879 }
49309057 1880 resolve_local_symbol_values ();
252b5132
RH		 1881
1882 PROGRESS (1);
1883
1884#ifdef tc_frob_file_before_adjust
1885 tc_frob_file_before_adjust ();
1886#endif
1887#ifdef obj_frob_file_before_adjust
1888 obj_frob_file_before_adjust ();
1889#endif
1890
efaf0ba4 1891 bfd_map_over_sections (stdoutput, adjust_reloc_syms, (char *) 0);
252b5132
RH		 1892
1893 /* Set up symbol table, and write it out. */
1894 if (symbol_rootP)
1895 {
1896 symbolS *symp;
1897
1898 for (symp = symbol_rootP; symp; symp = symbol_next (symp))
1899 {
1900 int punt = 0;
1901 const char *name;
1902
49309057 1903 if (symbol_mri_common_p (symp))
252b5132
RH		 1904 {
1905 if (S_IS_EXTERNAL (symp))
1906 as_bad (_("%s: global symbols not supported in common sections"),
1907 S_GET_NAME (symp));
1908 symbol_remove (symp, &symbol_rootP, &symbol_lastP);
1909 continue;
1910 }
1911
1912 name = S_GET_NAME (symp);
1913 if (name)
1914 {
efaf0ba4
NC		 1915 const char *name2 =
1916 decode_local_label_name ((char *) S_GET_NAME (symp));
252b5132
RH		 1917 /* They only differ if `name' is a fb or dollar local
1918 label name. */
1919 if (name2 != name && ! S_IS_DEFINED (symp))
1920 as_bad (_("local label %s is not defined"), name2);
1921 }
1922
1923 /* Do it again, because adjust_reloc_syms might introduce
1924 more symbols. They'll probably only be section symbols,
1925 but they'll still need to have the values computed. */
e46d99eb 1926 resolve_symbol_value (symp, finalize_syms);
252b5132
RH		 1927
1928 /* Skip symbols which were equated to undefined or common
1929 symbols. */
49309057 1930 if (symbol_equated_p (symp)
252b5132
RH		 1931 && (! S_IS_DEFINED (symp) || S_IS_COMMON (symp)))
1932 {
1933 symbol_remove (symp, &symbol_rootP, &symbol_lastP);
1934 continue;
1935 }
1936
1937 /* So far, common symbols have been treated like undefined symbols.
1938 Put them in the common section now. */
1939 if (S_IS_DEFINED (symp) == 0
1940 && S_GET_VALUE (symp) != 0)
1941 S_SET_SEGMENT (symp, bfd_com_section_ptr);
1942#if 0
1943 printf ("symbol `%s'\n\t@%x: value=%d flags=%x seg=%s\n",
1944 S_GET_NAME (symp), symp,
1945 S_GET_VALUE (symp),
49309057
ILT		 1946 symbol_get_bfdsym (symp)->flags,
1947 segment_name (S_GET_SEGMENT (symp)));
252b5132
RH		 1948#endif
1949
1950#ifdef obj_frob_symbol
1951 obj_frob_symbol (symp, punt);
1952#endif
1953#ifdef tc_frob_symbol
49309057 1954 if (! punt || symbol_used_in_reloc_p (symp))
252b5132
RH		 1955 tc_frob_symbol (symp, punt);
1956#endif
1957
1958 /* If we don't want to keep this symbol, splice it out of
1959 the chain now. If EMIT_SECTION_SYMBOLS is 0, we never
1960 want section symbols. Otherwise, we skip local symbols
1961 and symbols that the frob_symbol macros told us to punt,
1962 but we keep such symbols if they are used in relocs. */
1963 if ((! EMIT_SECTION_SYMBOLS
49309057 1964 && symbol_section_p (symp))
252b5132
RH		 1965 /* Note that S_IS_EXTERN and S_IS_LOCAL are not always
1966 opposites. Sometimes the former checks flags and the
1967 latter examines the name... */
1968 || (!S_IS_EXTERN (symp)
1969 && (S_IS_LOCAL (symp) || punt)
49309057 1970 && ! symbol_used_in_reloc_p (symp)))
252b5132
RH		 1971 {
1972 symbol_remove (symp, &symbol_rootP, &symbol_lastP);
efaf0ba4 1973
252b5132
RH		 1974 /* After symbol_remove, symbol_next(symp) still returns
1975 the one that came after it in the chain. So we don't
1976 need to do any extra cleanup work here. */
252b5132
RH		 1977 continue;
1978 }
1979
1980 /* Make sure we really got a value for the symbol. */
49309057 1981 if (! symbol_resolved_p (symp))
252b5132
RH		 1982 {
1983 as_bad (_("can't resolve value for symbol \"%s\""),
1984 S_GET_NAME (symp));
49309057 1985 symbol_mark_resolved (symp);
252b5132
RH		 1986 }
1987
1988 /* Set the value into the BFD symbol. Up til now the value
1989 has only been kept in the gas symbolS struct. */
49309057 1990 symbol_get_bfdsym (symp)->value = S_GET_VALUE (symp);
252b5132
RH		 1991 }
1992 }
1993
1994 PROGRESS (1);
1995
1996 /* Now do any format-specific adjustments to the symbol table, such
1997 as adding file symbols. */
1998#ifdef tc_adjust_symtab
1999 tc_adjust_symtab ();
2000#endif
2001#ifdef obj_adjust_symtab
2002 obj_adjust_symtab ();
2003#endif
2004
2005 /* Now that all the sizes are known, and contents correct, we can
2006 start writing to the file. */
2007 set_symtab ();
2008
2009 /* If *_frob_file changes the symbol value at this point, it is
2010 responsible for moving the changed value into symp->bsym->value
2011 as well. Hopefully all symbol value changing can be done in
2012 *_frob_symbol. */
2013#ifdef tc_frob_file
2014 tc_frob_file ();
2015#endif
2016#ifdef obj_frob_file
2017 obj_frob_file ();
2018#endif
2019
2020 bfd_map_over_sections (stdoutput, write_relocs, (char *) 0);
2021
2022#ifdef tc_frob_file_after_relocs
2023 tc_frob_file_after_relocs ();
2024#endif
2025#ifdef obj_frob_file_after_relocs
2026 obj_frob_file_after_relocs ();
2027#endif
2028
2029 bfd_map_over_sections (stdoutput, write_contents, (char *) 0);
efaf0ba4 2030#endif /* BFD_ASSEMBLER */
252b5132 2031}
efaf0ba4 2032#endif /* ! BFD */
252b5132
RH		 2033
2034#ifdef TC_GENERIC_RELAX_TABLE
2035
252b5132
RH		 2036/* Relax a fragment by scanning TC_GENERIC_RELAX_TABLE. */
2037
2038long
c842b53a
ILT		 2039relax_frag (segment, fragP, stretch)
2040 segT segment;
252b5132
RH		 2041 fragS *fragP;
2042 long stretch;
2043{
2044 const relax_typeS *this_type;
2045 const relax_typeS *start_type;
2046 relax_substateT next_state;
2047 relax_substateT this_state;
38686296
AM		 2048 long growth;
2049 offsetT aim;
2050 addressT target;
2051 addressT address;
2052 symbolS *symbolP;
2053 const relax_typeS *table;
2054
2055 target = fragP->fr_offset;
2056 address = fragP->fr_address;
2057 table = TC_GENERIC_RELAX_TABLE;
252b5132
RH		 2058 this_state = fragP->fr_subtype;
2059 start_type = this_type = table + this_state;
38686296 2060 symbolP = fragP->fr_symbol;
252b5132
RH		 2061
2062 if (symbolP)
2063 {
c842b53a
ILT		 2064 fragS *sym_frag;
2065
2066 sym_frag = symbol_get_frag (symbolP);
2067
252b5132
RH		 2068#ifndef DIFF_EXPR_OK
2069#if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER)
2070 know ((S_GET_SEGMENT (symbolP) == SEG_ABSOLUTE)
2071 || (S_GET_SEGMENT (symbolP) == SEG_DATA)
2072 || (S_GET_SEGMENT (symbolP) == SEG_BSS)
2073 || (S_GET_SEGMENT (symbolP) == SEG_TEXT));
2074#endif
c842b53a 2075 know (sym_frag != NULL);
252b5132
RH		 2076#endif
2077 know (!(S_GET_SEGMENT (symbolP) == absolute_section)
c842b53a
ILT		 2078 || sym_frag == &zero_address_frag);
2079 target += S_GET_VALUE (symbolP) + sym_frag->fr_address;
252b5132
RH		 2080
2081 /* If frag has yet to be reached on this pass,
2082 assume it will move by STRETCH just as we did.
2083 If this is not so, it will be because some frag
38686296 2084 between grows, and that will force another pass. */
252b5132 2085
c842b53a 2086 if (stretch != 0
38686296
AM		 2087 && sym_frag->relax_marker != fragP->relax_marker
2088 && S_GET_SEGMENT (symbolP) == segment)
252b5132
RH		 2089 {
2090 target += stretch;
2091 }
2092 }
2093
2094 aim = target - address - fragP->fr_fix;
2095#ifdef TC_PCREL_ADJUST
efaf0ba4
NC		 2096 /* Currently only the ns32k family needs this. */
2097 aim += TC_PCREL_ADJUST (fragP);
2098/* #else */
252b5132
RH		 2099 /* This machine doesn't want to use pcrel_adjust.
2100 In that case, pcrel_adjust should be zero. */
efaf0ba4
NC		 2101#if 0
2102 assert (fragP->fr_targ.ns32k.pcrel_adjust == 0);
252b5132 2103#endif
efaf0ba4
NC		 2104#endif
2105#ifdef md_prepare_relax_scan /* formerly called M68K_AIM_KLUDGE */
252b5132
RH		 2106 md_prepare_relax_scan (fragP, address, aim, this_state, this_type);
2107#endif
2108
2109 if (aim < 0)
2110 {
efaf0ba4 2111 /* Look backwards. */
252b5132
RH		 2112 for (next_state = this_type->rlx_more; next_state;)
2113 if (aim >= this_type->rlx_backward)
2114 next_state = 0;
2115 else
2116 {
efaf0ba4 2117 /* Grow to next state. */
252b5132
RH		 2118 this_state = next_state;
2119 this_type = table + this_state;
2120 next_state = this_type->rlx_more;
2121 }
2122 }
2123 else
2124 {
efaf0ba4 2125 /* Look forwards. */
252b5132
RH		 2126 for (next_state = this_type->rlx_more; next_state;)
2127 if (aim <= this_type->rlx_forward)
2128 next_state = 0;
2129 else
2130 {
efaf0ba4 2131 /* Grow to next state. */
252b5132
RH		 2132 this_state = next_state;
2133 this_type = table + this_state;
2134 next_state = this_type->rlx_more;
2135 }
2136 }
2137
2138 growth = this_type->rlx_length - start_type->rlx_length;
2139 if (growth != 0)
2140 fragP->fr_subtype = this_state;
2141 return growth;
2142}
2143
efaf0ba4 2144#endif /* defined (TC_GENERIC_RELAX_TABLE) */
252b5132
RH		 2145
2146/* Relax_align. Advance location counter to next address that has 'alignment'
2147 lowest order bits all 0s, return size of adjustment made. */
2148static relax_addressT
2149relax_align (address, alignment)
efaf0ba4
NC		 2150 register relax_addressT address; /* Address now. */
2151 register int alignment; /* Alignment (binary). */
252b5132
RH		 2152{
2153 relax_addressT mask;
2154 relax_addressT new_address;
2155
2156 mask = ~((~0) << alignment);
2157 new_address = (address + mask) & (~mask);
2158#ifdef LINKER_RELAXING_SHRINKS_ONLY
2159 if (linkrelax)
2160 /* We must provide lots of padding, so the linker can discard it
2161 when needed. The linker will not add extra space, ever. */
2162 new_address += (1 << alignment);
2163#endif
2164 return (new_address - address);
2165}
2166
efaf0ba4
NC		 2167/* Now we have a segment, not a crowd of sub-segments, we can make
2168 fr_address values.
58a77e41 2169
efaf0ba4 2170 Relax the frags.
58a77e41 2171
efaf0ba4
NC		 2172 After this, all frags in this segment have addresses that are correct
2173 within the segment. Since segments live in different file addresses,
2174 these frag addresses may not be the same as final object-file
2175 addresses. */
2176
e46d99eb 2177int
252b5132
RH		 2178relax_segment (segment_frag_root, segment)
2179 struct frag *segment_frag_root;
2180 segT segment;
2181{
2182 register struct frag *fragP;
2183 register relax_addressT address;
e46d99eb
AM		 2184 int ret;
2185
252b5132
RH		 2186#if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER)
2187 know (segment == SEG_DATA || segment == SEG_TEXT || segment == SEG_BSS);
2188#endif
efaf0ba4 2189 /* In case md_estimate_size_before_relax() wants to make fixSs. */
252b5132
RH		 2190 subseg_change (segment, 0);
2191
2192 /* For each frag in segment: count and store (a 1st guess of)
2193 fr_address. */
2194 address = 0;
2195 for (fragP = segment_frag_root; fragP; fragP = fragP->fr_next)
2196 {
38686296 2197 fragP->relax_marker = 0;
252b5132
RH		 2198 fragP->fr_address = address;
2199 address += fragP->fr_fix;
2200
2201 switch (fragP->fr_type)
2202 {
2203 case rs_fill:
2204 address += fragP->fr_offset * fragP->fr_var;
2205 break;
2206
2207 case rs_align:
2208 case rs_align_code:
0a9ef439 2209 case rs_align_test:
252b5132
RH		 2210 {
2211 addressT offset = relax_align (address, (int) fragP->fr_offset);
2212
2213 if (fragP->fr_subtype != 0 && offset > fragP->fr_subtype)
2214 offset = 0;
2215
2216 if (offset % fragP->fr_var != 0)
2217 {
2218 as_bad (_("alignment padding (%lu bytes) not a multiple of %ld"),
2219 (unsigned long) offset, (long) fragP->fr_var);
2220 offset -= (offset % fragP->fr_var);
2221 }
2222
2223 address += offset;
2224 }
2225 break;
2226
2227 case rs_org:
2228 case rs_space:
2229 /* Assume .org is nugatory. It will grow with 1st relax. */
2230 break;
2231
2232 case rs_machine_dependent:
2233 address += md_estimate_size_before_relax (fragP, segment);
2234 break;
2235
2236#ifndef WORKING_DOT_WORD
efaf0ba4 2237 /* Broken words don't concern us yet. */
252b5132
RH		 2238 case rs_broken_word:
2239 break;
2240#endif
2241
2242 case rs_leb128:
efaf0ba4 2243 /* Initial guess is always 1; doing otherwise can result in
252b5132
RH		 2244 stable solutions that are larger than the minimum. */
2245 address += fragP->fr_offset = 1;
2246 break;
2247
2248 case rs_cfa:
2249 address += eh_frame_estimate_size_before_relax (fragP);
2250 break;
2251
220e750f
RH		 2252 case rs_dwarf2dbg:
2253 address += dwarf2dbg_estimate_size_before_relax (fragP);
2254 break;
2255
252b5132
RH		 2256 default:
2257 BAD_CASE (fragP->fr_type);
2258 break;
efaf0ba4
NC		 2259 }
2260 }
252b5132
RH		 2261
2262 /* Do relax(). */
2263 {
efaf0ba4
NC		 2264 long stretch; /* May be any size, 0 or negative. */
2265 /* Cumulative number of addresses we have relaxed this pass.
2266 We may have relaxed more than one address. */
e46d99eb 2267 int stretched; /* Have we stretched on this pass? */
252b5132
RH		 2268 /* This is 'cuz stretch may be zero, when, in fact some piece of code
2269 grew, and another shrank. If a branch instruction doesn't fit anymore,
2270 we could be scrod. */
2271
2272 do
2273 {
e46d99eb
AM		 2274 stretch = 0;
2275 stretched = 0;
58a77e41 2276
252b5132
RH		 2277 for (fragP = segment_frag_root; fragP; fragP = fragP->fr_next)
2278 {
2279 long growth = 0;
2280 addressT was_address;
2281 offsetT offset;
2282 symbolS *symbolP;
2283
38686296 2284 fragP->relax_marker ^= 1;
252b5132
RH		 2285 was_address = fragP->fr_address;
2286 address = fragP->fr_address += stretch;
2287 symbolP = fragP->fr_symbol;
2288 offset = fragP->fr_offset;
2289
2290 switch (fragP->fr_type)
2291 {
efaf0ba4 2292 case rs_fill: /* .fill never relaxes. */
252b5132
RH		 2293 growth = 0;
2294 break;
2295
2296#ifndef WORKING_DOT_WORD
2297 /* JF: This is RMS's idea. I do *NOT* want to be blamed
2298 for it I do not want to write it. I do not want to have
2299 anything to do with it. This is not the proper way to
2300 implement this misfeature. */
2301 case rs_broken_word:
2302 {
2303 struct broken_word *lie;
2304 struct broken_word *untruth;
2305
2306 /* Yes this is ugly (storing the broken_word pointer
2307 in the symbol slot). Still, this whole chunk of
2308 code is ugly, and I don't feel like doing anything
2309 about it. Think of it as stubbornness in action. */
2310 growth = 0;
2311 for (lie = (struct broken_word *) (fragP->fr_symbol);
2312 lie && lie->dispfrag == fragP;
2313 lie = lie->next_broken_word)
2314 {
2315
2316 if (lie->added)
2317 continue;
2318
49309057 2319 offset = (symbol_get_frag (lie->add)->fr_address
252b5132
RH		 2320 + S_GET_VALUE (lie->add)
2321 + lie->addnum
49309057 2322 - (symbol_get_frag (lie->sub)->fr_address
252b5132
RH		 2323 + S_GET_VALUE (lie->sub)));
2324 if (offset <= -32768 || offset >= 32767)
2325 {
2326 if (flag_warn_displacement)
2327 {
2328 char buf[50];
2329 sprint_value (buf, (addressT) lie->addnum);
2330 as_warn (_(".word %s-%s+%s didn't fit"),
2331 S_GET_NAME (lie->add),
2332 S_GET_NAME (lie->sub),
2333 buf);
2334 }
2335 lie->added = 1;
2336 if (fragP->fr_subtype == 0)
2337 {
2338 fragP->fr_subtype++;
2339 growth += md_short_jump_size;
2340 }
2341 for (untruth = lie->next_broken_word;
2342 untruth && untruth->dispfrag == lie->dispfrag;
2343 untruth = untruth->next_broken_word)
49309057
ILT		 2344 if ((symbol_get_frag (untruth->add)
2345 == symbol_get_frag (lie->add))
2346 && (S_GET_VALUE (untruth->add)
2347 == S_GET_VALUE (lie->add)))
252b5132
RH		 2348 {
2349 untruth->added = 2;
2350 untruth->use_jump = lie;
2351 }
2352 growth += md_long_jump_size;
2353 }
2354 }
2355
2356 break;
efaf0ba4 2357 } /* case rs_broken_word */
252b5132
RH		 2358#endif
2359 case rs_align:
2360 case rs_align_code:
0a9ef439 2361 case rs_align_test:
252b5132
RH		 2362 {
2363 addressT oldoff, newoff;
2364
2365 oldoff = relax_align (was_address + fragP->fr_fix,
2366 (int) offset);
2367 newoff = relax_align (address + fragP->fr_fix,
2368 (int) offset);
2369
2370 if (fragP->fr_subtype != 0)
2371 {
2372 if (oldoff > fragP->fr_subtype)
2373 oldoff = 0;
2374 if (newoff > fragP->fr_subtype)
2375 newoff = 0;
2376 }
2377
2378 growth = newoff - oldoff;
2379 }
2380 break;
2381
2382 case rs_org:
2383 {
e46d99eb
AM		 2384 addressT target = offset;
2385 addressT after;
252b5132
RH		 2386
2387 if (symbolP)
2388 {
2389#if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER)
2390 know ((S_GET_SEGMENT (symbolP) == SEG_ABSOLUTE)
2391 || (S_GET_SEGMENT (symbolP) == SEG_DATA)
2392 || (S_GET_SEGMENT (symbolP) == SEG_TEXT)
2393 || S_GET_SEGMENT (symbolP) == SEG_BSS);
2394 know (symbolP->sy_frag);
2395 know (!(S_GET_SEGMENT (symbolP) == SEG_ABSOLUTE)
2396 || (symbolP->sy_frag == &zero_address_frag));
2397#endif
49309057
ILT		 2398 target += (S_GET_VALUE (symbolP)
2399 + symbol_get_frag (symbolP)->fr_address);
efaf0ba4 2400 } /* if we have a symbol */
252b5132
RH		 2401
2402 know (fragP->fr_next);
2403 after = fragP->fr_next->fr_address;
2404 growth = target - after;
2405 if (growth < 0)
2406 {
2407 /* Growth may be negative, but variable part of frag
2408 cannot have fewer than 0 chars. That is, we can't
efaf0ba4 2409 .org backwards. */
14ad458a
ILT		 2410 as_bad_where (fragP->fr_file, fragP->fr_line,
2411 _("attempt to .org backwards ignored"));
2412
2413 /* We've issued an error message. Change the
2414 frag to avoid cascading errors. */
2415 fragP->fr_type = rs_align;
2416 fragP->fr_subtype = 0;
2417 fragP->fr_offset = 0;
2418 fragP->fr_fix = after - address;
2419 growth = stretch;
252b5132
RH		 2420 }
2421
efaf0ba4
NC		 2422 /* This is an absolute growth factor */
2423 growth -= stretch;
252b5132
RH		 2424 break;
2425 }
2426
2427 case rs_space:
2428 if (symbolP)
2429 {
2430 growth = S_GET_VALUE (symbolP);
49309057 2431 if (symbol_get_frag (symbolP) != &zero_address_frag
252b5132
RH		 2432 || S_IS_COMMON (symbolP)
2433 || ! S_IS_DEFINED (symbolP))
2434 as_bad_where (fragP->fr_file, fragP->fr_line,
2435 _(".space specifies non-absolute value"));
2436 fragP->fr_symbol = 0;
2437 if (growth < 0)
2438 {
2439 as_warn (_(".space or .fill with negative value, ignored"));
2440 growth = 0;
2441 }
2442 }
2443 else
2444 growth = 0;
2445 break;
2446
2447 case rs_machine_dependent:
2448#ifdef md_relax_frag
c842b53a 2449 growth = md_relax_frag (segment, fragP, stretch);
252b5132
RH		 2450#else
2451#ifdef TC_GENERIC_RELAX_TABLE
2452 /* The default way to relax a frag is to look through
2453 TC_GENERIC_RELAX_TABLE. */
c842b53a 2454 growth = relax_frag (segment, fragP, stretch);
efaf0ba4 2455#endif /* TC_GENERIC_RELAX_TABLE */
252b5132
RH		 2456#endif
2457 break;
2458
2459 case rs_leb128:
2460 {
2461 valueT value;
2462 int size;
2463
2464 value = resolve_symbol_value (fragP->fr_symbol, 0);
2465 size = sizeof_leb128 (value, fragP->fr_subtype);
2466 growth = size - fragP->fr_offset;
2467 fragP->fr_offset = size;
2468 }
2469 break;
2470
2471 case rs_cfa:
2472 growth = eh_frame_relax_frag (fragP);
2473 break;
2474
220e750f
RH		 2475 case rs_dwarf2dbg:
2476 growth = dwarf2dbg_relax_frag (fragP);
2477 break;
2478
252b5132
RH		 2479 default:
2480 BAD_CASE (fragP->fr_type);
2481 break;
2482 }
2483 if (growth)
2484 {
2485 stretch += growth;
e46d99eb 2486 stretched = 1;
252b5132 2487 }
efaf0ba4 2488 } /* For each frag in the segment. */
252b5132 2489 }
efaf0ba4
NC		 2490 while (stretched); /* Until nothing further to relax. */
2491 } /* do_relax */
252b5132 2492
e46d99eb
AM		 2493 ret = 0;
2494 for (fragP = segment_frag_root; fragP; fragP = fragP->fr_next)
2495 if (fragP->last_fr_address != fragP->fr_address)
2496 {
2497 fragP->last_fr_address = fragP->fr_address;
2498 ret = 1;
2499 }
2500 return ret;
efaf0ba4 2501}
252b5132
RH		 2502
2503#if defined (BFD_ASSEMBLER) || (!defined (BFD) && !defined (OBJ_VMS))
2504
2505#ifndef TC_RELOC_RTSYM_LOC_FIXUP
2506#define TC_RELOC_RTSYM_LOC_FIXUP(X) (1)
2507#endif
2508
2509/* fixup_segment()
2510
2511 Go through all the fixS's in a segment and see which ones can be
2512 handled now. (These consist of fixS where we have since discovered
2513 the value of a symbol, or the address of the frag involved.)
2514 For each one, call md_apply_fix to put the fix into the frag data.
2515
2516 Result is a count of how many relocation structs will be needed to
2517 handle the remaining fixS's that we couldn't completely handle here.
2518 These will be output later by emit_relocations(). */
2519
2520static long
2521fixup_segment (fixP, this_segment_type)
2522 register fixS *fixP;
efaf0ba4 2523 segT this_segment_type; /* N_TYPE bits for segment. */
252b5132
RH		 2524{
2525 long seg_reloc_count = 0;
2526 symbolS *add_symbolP;
2527 symbolS *sub_symbolP;
2528 valueT add_number;
2529 int size;
2530 char *place;
2531 long where;
2532 int pcrel, plt;
2533 fragS *fragP;
2534 segT add_symbol_segment = absolute_section;
2535
2536 /* If the linker is doing the relaxing, we must not do any fixups.
2537
2538 Well, strictly speaking that's not true -- we could do any that are
2539 PC-relative and don't cross regions that could change size. And for the
2540 i960 (the only machine for which we've got a relaxing linker right now),
2541 we might be able to turn callx/callj into bal anyways in cases where we
2542 know the maximum displacement. */
58a77e41 2543 if (linkrelax && TC_LINKRELAX_FIXUP (this_segment_type))
252b5132
RH		 2544 {
2545 for (; fixP; fixP = fixP->fx_next)
2546 seg_reloc_count++;
2547 TC_ADJUST_RELOC_COUNT (fixP, seg_reloc_count);
2548 return seg_reloc_count;
2549 }
2550
2551 for (; fixP; fixP = fixP->fx_next)
2552 {
252b5132
RH		 2553#ifdef DEBUG5
2554 fprintf (stderr, "\nprocessing fixup:\n");
2555 print_fixup (fixP);
2556#endif
2557
252b5132
RH		 2558 fragP = fixP->fx_frag;
2559 know (fragP);
2560 where = fixP->fx_where;
2561 place = fragP->fr_literal + where;
2562 size = fixP->fx_size;
2563 add_symbolP = fixP->fx_addsy;
2564#ifdef TC_VALIDATE_FIX
2565 TC_VALIDATE_FIX (fixP, this_segment_type, skip);
2566#endif
2567 sub_symbolP = fixP->fx_subsy;
2568 add_number = fixP->fx_offset;
2569 pcrel = fixP->fx_pcrel;
2570 plt = fixP->fx_plt;
2571
2572 if (add_symbolP != NULL
49309057 2573 && symbol_mri_common_p (add_symbolP))
252b5132
RH		 2574 {
2575 know (add_symbolP->sy_value.X_op == O_symbol);
2576 add_number += S_GET_VALUE (add_symbolP);
2577 fixP->fx_offset = add_number;
49309057
ILT		 2578 add_symbolP = fixP->fx_addsy =
2579 symbol_get_value_expression (add_symbolP)->X_add_symbol;
252b5132
RH		 2580 }
2581
2582 if (add_symbolP)
2583 add_symbol_segment = S_GET_SEGMENT (add_symbolP);
2584
2585 if (sub_symbolP)
2586 {
e46d99eb 2587 resolve_symbol_value (sub_symbolP, finalize_syms);
252b5132
RH		 2588 if (add_symbolP == NULL || add_symbol_segment == absolute_section)
2589 {
2590 if (add_symbolP != NULL)
2591 {
2592 add_number += S_GET_VALUE (add_symbolP);
2593 add_symbolP = NULL;
2594 fixP->fx_addsy = NULL;
2595 }
2596
efaf0ba4 2597 /* It's just -sym. */
252b5132
RH		 2598 if (S_GET_SEGMENT (sub_symbolP) == absolute_section)
2599 {
2600 add_number -= S_GET_VALUE (sub_symbolP);
2601 fixP->fx_subsy = NULL;
2602 }
2603 else if (pcrel
2604 && S_GET_SEGMENT (sub_symbolP) == this_segment_type)
2605 {
2606 /* Should try converting to a constant. */
2607 goto bad_sub_reloc;
2608 }
2609 else
2610 bad_sub_reloc:
2611 as_bad_where (fixP->fx_file, fixP->fx_line,
2612 _("Negative of non-absolute symbol %s"),
2613 S_GET_NAME (sub_symbolP));
2614 }
2615 else if (S_GET_SEGMENT (sub_symbolP) == add_symbol_segment
2616 && SEG_NORMAL (add_symbol_segment))
2617 {
2618 /* Difference of 2 symbols from same segment.
2619 Can't make difference of 2 undefineds: 'value' means
efaf0ba4 2620 something different for N_UNDF. */
252b5132
RH		 2621#ifdef TC_I960
2622 /* Makes no sense to use the difference of 2 arbitrary symbols
2623 as the target of a call instruction. */
2624 if (fixP->fx_tcbit)
2625 as_bad_where (fixP->fx_file, fixP->fx_line,
2626 _("callj to difference of 2 symbols"));
efaf0ba4 2627#endif /* TC_I960 */
252b5132
RH		 2628 add_number += S_GET_VALUE (add_symbolP) -
2629 S_GET_VALUE (sub_symbolP);
2630
2631 add_symbolP = NULL;
efaf0ba4 2632 pcrel = 0; /* No further pcrel processing. */
252b5132
RH		 2633
2634 /* Let the target machine make the final determination
2635 as to whether or not a relocation will be needed to
2636 handle this fixup. */
2637 if (!TC_FORCE_RELOCATION_SECTION (fixP, this_segment_type))
2638 {
2639 fixP->fx_pcrel = 0;
2640 fixP->fx_addsy = NULL;
2641 fixP->fx_subsy = NULL;
2642 }
2643 }
2644 else
2645 {
efaf0ba4 2646 /* Different segments in subtraction. */
252b5132
RH		 2647 know (!(S_IS_EXTERNAL (sub_symbolP)
2648 && (S_GET_SEGMENT (sub_symbolP) == absolute_section)));
2649
2650 if ((S_GET_SEGMENT (sub_symbolP) == absolute_section))
2651 add_number -= S_GET_VALUE (sub_symbolP);
2652
2653#ifdef DIFF_EXPR_OK
2654 else if (S_GET_SEGMENT (sub_symbolP) == this_segment_type
efaf0ba4
NC		 2655#if 0
2656 /* Do this even if it's already described as
2657 pc-relative. For example, on the m68k, an
2658 operand of "pc@(foo-.-2)" should address
2659 "foo" in a pc-relative mode. */
252b5132
RH		 2660 && pcrel
2661#endif
2662 )
2663 {
2664 /* Make it pc-relative. */
2665 add_number += (MD_PCREL_FROM_SECTION (fixP, this_segment_type)
2666 - S_GET_VALUE (sub_symbolP));
2667 pcrel = 1;
2668 fixP->fx_pcrel = 1;
2669 sub_symbolP = 0;
2670 fixP->fx_subsy = 0;
2671 }
2672#endif
2673#ifdef UNDEFINED_DIFFERENCE_OK
2674 /* The PA needs this for PIC code generation. We basically
2675 don't want to do anything if we have the difference of two
2676 symbols at this point. */
2677 else if (1)
2678 {
2679 /* Leave it alone. */
2680 }
2681#endif
2682#ifdef BFD_ASSEMBLER
2683 else if (fixP->fx_r_type == BFD_RELOC_GPREL32
2684 || fixP->fx_r_type == BFD_RELOC_GPREL16)
2685 {
2686 /* Leave it alone. */
2687 }
2688#endif
2689 else
2690 {
2691 char buf[50];
2692 sprint_value (buf, fragP->fr_address + where);
2693 as_bad_where (fixP->fx_file, fixP->fx_line,
2694 _("Subtraction of two symbols in different sections \"%s\" {%s section} - \"%s\" {%s section} at file address %s."),
2695 S_GET_NAME (add_symbolP),
2696 segment_name (S_GET_SEGMENT (add_symbolP)),
2697 S_GET_NAME (sub_symbolP),
2698 segment_name (S_GET_SEGMENT (sub_symbolP)),
2699 buf);
2700 }
2701 }
2702 }
2703
2704 if (add_symbolP)
2705 {
2706 if (add_symbol_segment == this_segment_type && pcrel && !plt
2707 && TC_RELOC_RTSYM_LOC_FIXUP (fixP))
2708 {
efaf0ba4
NC		 2709 /* This fixup was made when the symbol's segment was
2710 SEG_UNKNOWN, but it is now in the local segment.
2711 So we know how to do the address without relocation. */
252b5132
RH		 2712#ifdef TC_I960
2713 /* reloc_callj() may replace a 'call' with a 'calls' or a
2714 'bal', in which cases it modifies *fixP as appropriate.
2715 In the case of a 'calls', no further work is required,
2716 and *fixP has been set up to make the rest of the code
efaf0ba4 2717 below a no-op. */
252b5132 2718 reloc_callj (fixP);
efaf0ba4 2719#endif /* TC_I960 */
252b5132
RH		 2720
2721 add_number += S_GET_VALUE (add_symbolP);
2722 add_number -= MD_PCREL_FROM_SECTION (fixP, this_segment_type);
efaf0ba4
NC		 2723 /* Lie. Don't want further pcrel processing. */
2724 pcrel = 0;
252b5132
RH		 2725
2726 /* Let the target machine make the final determination
2727 as to whether or not a relocation will be needed to
2728 handle this fixup. */
2729 if (!TC_FORCE_RELOCATION (fixP))
2730 {
2731 fixP->fx_pcrel = 0;
2732 fixP->fx_addsy = NULL;
2733 }
2734 }
2735 else
2736 {
2737 if (add_symbol_segment == absolute_section
2738 && ! pcrel)
2739 {
2740#ifdef TC_I960
2741 /* See comment about reloc_callj() above. */
2742 reloc_callj (fixP);
efaf0ba4 2743#endif /* TC_I960 */
252b5132
RH		 2744 add_number += S_GET_VALUE (add_symbolP);
2745
2746 /* Let the target machine make the final determination
2747 as to whether or not a relocation will be needed to
2748 handle this fixup. */
2749
2750 if (!TC_FORCE_RELOCATION (fixP))
2751 {
2752 fixP->fx_addsy = NULL;
2753 add_symbolP = NULL;
2754 }
2755 }
2756 else if (add_symbol_segment == undefined_section
2757#ifdef BFD_ASSEMBLER
2758 || bfd_is_com_section (add_symbol_segment)
2759#endif
2760 )
2761 {
2762#ifdef TC_I960
2763 if ((int) fixP->fx_bit_fixP == 13)
2764 {
2765 /* This is a COBR instruction. They have only a
efaf0ba4
NC		 2766 13-bit displacement and are only to be used
2767 for local branches: flag as error, don't generate
2768 relocation. */
252b5132
RH		 2769 as_bad_where (fixP->fx_file, fixP->fx_line,
2770 _("can't use COBR format with external label"));
2771 fixP->fx_addsy = NULL;
2772 fixP->fx_done = 1;
2773 continue;
efaf0ba4
NC		 2774 } /* COBR. */
2775#endif /* TC_I960 */
252b5132
RH		 2776
2777#ifdef OBJ_COFF
2778#ifdef TE_I386AIX
2779 if (S_IS_COMMON (add_symbolP))
2780 add_number += S_GET_VALUE (add_symbolP);
efaf0ba4
NC		 2781#endif /* TE_I386AIX */
2782#endif /* OBJ_COFF */
252b5132
RH		 2783 ++seg_reloc_count;
2784 }
2785 else
2786 {
2787 seg_reloc_count++;
8f36cd18 2788 if (TC_FIX_ADJUSTABLE (fixP))
02198638 2789 add_number += S_GET_VALUE (add_symbolP);
252b5132
RH		 2790 }
2791 }
2792 }
2793
2794 if (pcrel)
2795 {
2796 add_number -= MD_PCREL_FROM_SECTION (fixP, this_segment_type);
2797 if (add_symbolP == 0)
2798 {
2799#ifndef BFD_ASSEMBLER
2800 fixP->fx_addsy = &abs_symbol;
2801#else
2802 fixP->fx_addsy = section_symbol (absolute_section);
2803#endif
49309057 2804 symbol_mark_used_in_reloc (fixP->fx_addsy);
252b5132
RH		 2805 ++seg_reloc_count;
2806 }
2807 }
2808
6d4d30bb
AM		 2809 if (!fixP->fx_done)
2810 {
2811#ifdef MD_APPLY_FIX3
2812 md_apply_fix3 (fixP, &add_number, this_segment_type);
2813#else
2814#ifdef BFD_ASSEMBLER
2815 md_apply_fix (fixP, &add_number);
2816#else
2817 md_apply_fix (fixP, add_number);
2818#endif
2819#endif
2820
2821#ifndef TC_HANDLES_FX_DONE
2822 /* If the tc-* files haven't been converted, assume it's handling
2823 it the old way, where a null fx_addsy means that the fix has
2824 been applied completely, and no further work is needed. */
2825 if (fixP->fx_addsy == 0 && fixP->fx_pcrel == 0)
2826 fixP->fx_done = 1;
2827#endif
2828 }
2829
252b5132
RH		 2830 if (!fixP->fx_bit_fixP && !fixP->fx_no_overflow && size > 0)
2831 {
2832 if ((size_t) size < sizeof (valueT))
2833 {
b77ad1d4 2834 valueT mask;
252b5132 2835
252b5132 2836 mask = 0;
efaf0ba4 2837 mask--; /* Set all bits to one. */
b77ad1d4
AM		 2838 mask <<= size * 8 - (fixP->fx_signed ? 1 : 0);
2839 if ((add_number & mask) != 0 && (add_number & mask) != mask)
252b5132
RH		 2840 {
2841 char buf[50], buf2[50];
2842 sprint_value (buf, fragP->fr_address + where);
2843 if (add_number > 1000)
2844 sprint_value (buf2, add_number);
2845 else
2846 sprintf (buf2, "%ld", (long) add_number);
2847 as_bad_where (fixP->fx_file, fixP->fx_line,
2848 _("Value of %s too large for field of %d bytes at %s"),
2849 buf2, size, buf);
efaf0ba4 2850 } /* Generic error checking. */
252b5132
RH		 2851 }
2852#ifdef WARN_SIGNED_OVERFLOW_WORD
2853 /* Warn if a .word value is too large when treated as a signed
2854 number. We already know it is not too negative. This is to
2855 catch over-large switches generated by gcc on the 68k. */
2856 if (!flag_signed_overflow_ok
2857 && size == 2
2858 && add_number > 0x7fff)
2859 as_bad_where (fixP->fx_file, fixP->fx_line,
2860 _("Signed .word overflow; switch may be too large; %ld at 0x%lx"),
2861 (long) add_number,
2862 (unsigned long) (fragP->fr_address + where));
2863#endif
efaf0ba4 2864 } /* Not a bit fix. */
252b5132 2865
252b5132 2866#ifdef TC_VALIDATE_FIX
ab9da554
ILT		 2867 skip: ATTRIBUTE_UNUSED_LABEL
2868 ;
252b5132
RH		 2869#endif
2870#ifdef DEBUG5
2871 fprintf (stderr, "result:\n");
2872 print_fixup (fixP);
2873#endif
efaf0ba4 2874 } /* For each fixS in this segment. */
252b5132
RH		 2875
2876 TC_ADJUST_RELOC_COUNT (fixP, seg_reloc_count);
2877 return seg_reloc_count;
2878}
2879
2880#endif /* defined (BFD_ASSEMBLER) || (!defined (BFD) && !defined (OBJ_VMS)) */
2881
2882void
2883number_to_chars_bigendian (buf, val, n)
2884 char *buf;
2885 valueT val;
2886 int n;
2887{
2888 if ((size_t) n > sizeof (val) || n <= 0)
2889 abort ();
2890 while (n--)
2891 {
2892 buf[n] = val & 0xff;
2893 val >>= 8;
2894 }
2895}
2896
2897void
2898number_to_chars_littleendian (buf, val, n)
2899 char *buf;
2900 valueT val;
2901 int n;
2902{
2903 if ((size_t) n > sizeof (val) || n <= 0)
2904 abort ();
2905 while (n--)
2906 {
2907 *buf++ = val & 0xff;
2908 val >>= 8;
2909 }
2910}
2911
2912void
2913write_print_statistics (file)
2914 FILE *file;
2915{
6d4d30bb 2916 fprintf (file, "fixups: %d\n", n_fixups);
252b5132
RH		 2917}
2918
efaf0ba4 2919/* For debugging. */
252b5132
RH		 2920extern int indent_level;
2921
2922void
2923print_fixup (fixp)
2924 fixS *fixp;
2925{
2926 indent_level = 1;
2927 fprintf (stderr, "fix %lx %s:%d", (long) fixp, fixp->fx_file, fixp->fx_line);
2928 if (fixp->fx_pcrel)
2929 fprintf (stderr, " pcrel");
2930 if (fixp->fx_pcrel_adjust)
2931 fprintf (stderr, " pcrel_adjust=%d", fixp->fx_pcrel_adjust);
2932 if (fixp->fx_im_disp)
2933 {
2934#ifdef TC_NS32K
2935 fprintf (stderr, " im_disp=%d", fixp->fx_im_disp);
2936#else
2937 fprintf (stderr, " im_disp");
2938#endif
2939 }
2940 if (fixp->fx_tcbit)
2941 fprintf (stderr, " tcbit");
2942 if (fixp->fx_done)
2943 fprintf (stderr, " done");
2944 fprintf (stderr, "\n size=%d frag=%lx where=%ld offset=%lx addnumber=%lx",
2945 fixp->fx_size, (long) fixp->fx_frag, (long) fixp->fx_where,
2946 (long) fixp->fx_offset, (long) fixp->fx_addnumber);
2947#ifdef BFD_ASSEMBLER
2948 fprintf (stderr, "\n %s (%d)", bfd_get_reloc_code_name (fixp->fx_r_type),
2949 fixp->fx_r_type);
2950#else
2951#ifdef NEED_FX_R_TYPE
2952 fprintf (stderr, " r_type=%d", fixp->fx_r_type);
2953#endif
2954#endif
2955 if (fixp->fx_addsy)
2956 {
2957 fprintf (stderr, "\n +<");
2958 print_symbol_value_1 (stderr, fixp->fx_addsy);
2959 fprintf (stderr, ">");
2960 }
2961 if (fixp->fx_subsy)
2962 {
2963 fprintf (stderr, "\n -<");
2964 print_symbol_value_1 (stderr, fixp->fx_subsy);
2965 fprintf (stderr, ">");
2966 }
2967 fprintf (stderr, "\n");
2968#ifdef TC_FIX_DATA_PRINT
2969 TC_FIX_DATA_PRINT (stderr, fixp);
2970#endif
2971}
GDB Binutils - Deliverables
This page took 0.20599 seconds and 4 git commands to generate.