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