projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
* infptrace.c (child_xfer_memory): Add cast to CORE_ADDR.
[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. */
49309057 772 if (sym != NULL && symbol_equated_p (sym)
252b5132
RH		 773 && (! S_IS_DEFINED (sym) || S_IS_COMMON (sym)))
774 {
49309057
ILT		 775 fixp->fx_offset += symbol_get_value_expression (sym)->X_add_number;
776 sym = symbol_get_value_expression (sym)->X_add_symbol;
252b5132
RH		 777 fixp->fx_addsy = sym;
778 }
779
49309057 780 if (sym != NULL && symbol_mri_common_p (sym))
252b5132
RH		 781 {
782 /* These symbols are handled specially in fixup_segment. */
783 goto done;
784 }
785
786 symsec = S_GET_SEGMENT (sym);
787
788 if (symsec == NULL)
789 abort ();
efaf0ba4 790
252b5132
RH		 791 if (bfd_is_abs_section (symsec))
792 {
793 /* The fixup_segment routine will not use this symbol in a
794 relocation unless TC_FORCE_RELOCATION returns 1. */
795 if (TC_FORCE_RELOCATION (fixp))
796 {
49309057 797 symbol_mark_used_in_reloc (fixp->fx_addsy);
252b5132
RH		 798#ifdef UNDEFINED_DIFFERENCE_OK
799 if (fixp->fx_subsy != NULL)
49309057 800 symbol_mark_used_in_reloc (fixp->fx_subsy);
252b5132
RH		 801#endif
802 }
803 goto done;
804 }
805
806 /* If it's one of these sections, assume the symbol is
807 definitely going to be output. The code in
808 md_estimate_size_before_relax in tc-mips.c uses this test
809 as well, so if you change this code you should look at that
810 code. */
811 if (bfd_is_und_section (symsec)
812 || bfd_is_com_section (symsec))
813 {
49309057 814 symbol_mark_used_in_reloc (fixp->fx_addsy);
252b5132
RH		 815#ifdef UNDEFINED_DIFFERENCE_OK
816 /* We have the difference of an undefined symbol and some
817 other symbol. Make sure to mark the other symbol as used
818 in a relocation so that it will always be output. */
819 if (fixp->fx_subsy)
49309057 820 symbol_mark_used_in_reloc (fixp->fx_subsy);
252b5132
RH		 821#endif
822 goto done;
823 }
824
7565ed77
ILT		 825 /* Don't try to reduce relocs which refer to non-local symbols
826 in .linkonce sections. It can lead to confusion when a
827 debugging section refers to a .linkonce section. I hope
828 this will always be correct. */
829 if (symsec != sec && ! S_IS_LOCAL (sym))
252b5132
RH		 830 {
831 boolean linkonce;
832
833 linkonce = false;
834#ifdef BFD_ASSEMBLER
835 if ((bfd_get_section_flags (stdoutput, symsec) & SEC_LINK_ONCE)
836 != 0)
837 linkonce = true;
838#endif
839#ifdef OBJ_ELF
840 /* The GNU toolchain uses an extension for ELF: a section
841 beginning with the magic string .gnu.linkonce is a
842 linkonce section. */
843 if (strncmp (segment_name (symsec), ".gnu.linkonce",
844 sizeof ".gnu.linkonce" - 1) == 0)
845 linkonce = true;
846#endif
847
848 if (linkonce)
849 {
49309057 850 symbol_mark_used_in_reloc (fixp->fx_addsy);
252b5132
RH		 851#ifdef UNDEFINED_DIFFERENCE_OK
852 if (fixp->fx_subsy != NULL)
49309057 853 symbol_mark_used_in_reloc (fixp->fx_subsy);
252b5132
RH		 854#endif
855 goto done;
856 }
857 }
858
859 /* Since we're reducing to section symbols, don't attempt to reduce
860 anything that's already using one. */
49309057 861 if (symbol_section_p (sym))
252b5132 862 {
49309057 863 symbol_mark_used_in_reloc (fixp->fx_addsy);
252b5132
RH		 864 goto done;
865 }
866
867#ifdef BFD_ASSEMBLER
868 /* We can never adjust a reloc against a weak symbol. If we
869 did, and the weak symbol was overridden by a real symbol
870 somewhere else, then our relocation would be pointing at
871 the wrong area of memory. */
872 if (S_IS_WEAK (sym))
873 {
49309057 874 symbol_mark_used_in_reloc (fixp->fx_addsy);
252b5132
RH		 875 goto done;
876 }
f5fa8ca2
JJ		 877
878 /* Never adjust a reloc against local symbol in a merge section. */
879 if (symsec->flags & SEC_MERGE)
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
986 symbol, then use generate the reloc against the latter symbol
987 rather than the former. */
988 sym = fixp->fx_addsy;
49309057 989 while (symbol_equated_p (sym)
252b5132
RH		 990 && (! S_IS_DEFINED (sym) || S_IS_COMMON (sym)))
991 {
992 symbolS *n;
993
994 /* We must avoid looping, as that can occur with a badly
995 written program. */
49309057 996 n = symbol_get_value_expression (sym)->X_add_symbol;
252b5132
RH		 997 if (n == sym)
998 break;
49309057 999 fixp->fx_offset += symbol_get_value_expression (sym)->X_add_number;
252b5132
RH		 1000 sym = n;
1001 }
1002 fixp->fx_addsy = sym;
1003
1004 reloc = tc_gen_reloc (sec, fixp);
1005 if (!reloc)
1006 {
1007 n--;
1008 continue;
1009 }
1010
1011#if 0
1012 /* This test is triggered inappropriately for the SH. */
1013 if (fixp->fx_where + fixp->fx_size
1014 > fixp->fx_frag->fr_fix + fixp->fx_frag->fr_offset)
1015 abort ();
1016#endif
1017
1018 s = bfd_install_relocation (stdoutput, reloc,
1019 fixp->fx_frag->fr_literal,
1020 fixp->fx_frag->fr_address,
1021 sec, &err);
1022 switch (s)
1023 {
1024 case bfd_reloc_ok:
1025 break;
1026 case bfd_reloc_overflow:
1027 as_bad_where (fixp->fx_file, fixp->fx_line, _("relocation overflow"));
1028 break;
1029 case bfd_reloc_outofrange:
1030 as_bad_where (fixp->fx_file, fixp->fx_line, _("relocation out of range"));
1031 break;
1032 default:
1033 as_fatal (_("%s:%u: bad return from bfd_install_relocation: %x"),
1034 fixp->fx_file, fixp->fx_line, s);
1035 }
1036 relocs[i++] = reloc;
1037 }
1038#else
1039 n = n * MAX_RELOC_EXPANSION;
1040 /* Set up reloc information as well. */
1041 relocs = (arelent **) xmalloc (n * sizeof (arelent *));
1042
1043 i = 0;
1044 for (fixp = seginfo->fix_root; fixp != (fixS *) NULL; fixp = fixp->fx_next)
1045 {
1046 arelent **reloc;
1047 char *data;
1048 bfd_reloc_status_type s;
1049 symbolS *sym;
1050 int j;
1051
1052 if (fixp->fx_done)
1053 {
1054 n--;
1055 continue;
1056 }
1057
1058 /* If this is an undefined symbol which was equated to another
44852b19 1059 symbol, then generate the reloc against the latter symbol
252b5132
RH		 1060 rather than the former. */
1061 sym = fixp->fx_addsy;
49309057 1062 while (symbol_equated_p (sym)
252b5132 1063 && (! S_IS_DEFINED (sym) || S_IS_COMMON (sym)))
49309057 1064 sym = symbol_get_value_expression (sym)->X_add_symbol;
252b5132
RH		 1065 fixp->fx_addsy = sym;
1066
1067 reloc = tc_gen_reloc (sec, fixp);
1068
1069 for (j = 0; reloc[j]; j++)
1070 {
efaf0ba4
NC		 1071 relocs[i++] = reloc[j];
1072 assert (i <= n);
252b5132
RH		 1073 }
1074 data = fixp->fx_frag->fr_literal + fixp->fx_where;
1075 if (fixp->fx_where + fixp->fx_size
1076 > fixp->fx_frag->fr_fix + fixp->fx_frag->fr_offset)
1077 as_bad_where (fixp->fx_file, fixp->fx_line,
1078 _("internal error: fixup not contained within frag"));
1079 for (j = 0; reloc[j]; j++)
efaf0ba4 1080 {
252b5132
RH		 1081 s = bfd_install_relocation (stdoutput, reloc[j],
1082 fixp->fx_frag->fr_literal,
1083 fixp->fx_frag->fr_address,
1084 sec, &err);
efaf0ba4 1085 switch (s)
252b5132
RH		 1086 {
1087 case bfd_reloc_ok:
1088 break;
1089 case bfd_reloc_overflow:
1090 as_bad_where (fixp->fx_file, fixp->fx_line,
1091 _("relocation overflow"));
1092 break;
1093 default:
1094 as_fatal (_("%s:%u: bad return from bfd_install_relocation"),
1095 fixp->fx_file, fixp->fx_line);
1096 }
efaf0ba4 1097 }
252b5132
RH		 1098 }
1099 n = i;
1100#endif
1101
1102#ifdef DEBUG4
1103 {
1104 int i, j, nsyms;
1105 asymbol **sympp;
1106 sympp = bfd_get_outsymbols (stdoutput);
1107 nsyms = bfd_get_symcount (stdoutput);
1108 for (i = 0; i < n; i++)
1109 if (((*relocs[i]->sym_ptr_ptr)->flags & BSF_SECTION_SYM) == 0)
1110 {
1111 for (j = 0; j < nsyms; j++)
1112 if (sympp[j] == *relocs[i]->sym_ptr_ptr)
1113 break;
1114 if (j == nsyms)
1115 abort ();
1116 }
1117 }
1118#endif
1119
1120 if (n)
1121 bfd_set_reloc (stdoutput, sec, relocs, n);
1122 else
1123 bfd_set_section_flags (abfd, sec,
1124 (bfd_get_section_flags (abfd, sec)
1125 & (flagword) ~SEC_RELOC));
1126
945a1a6b
ILT		 1127#ifdef SET_SECTION_RELOCS
1128 SET_SECTION_RELOCS (sec, relocs, n);
1129#endif
1130
252b5132
RH		 1131#ifdef DEBUG3
1132 {
1133 int i;
1134 arelent *r;
1135 asymbol *s;
1136 fprintf (stderr, "relocs for sec %s\n", sec->name);
1137 for (i = 0; i < n; i++)
1138 {
1139 r = relocs[i];
1140 s = *r->sym_ptr_ptr;
1141 fprintf (stderr, " reloc %2d @%08x off %4x : sym %-10s addend %x\n",
1142 i, r, r->address, s->name, r->addend);
1143 }
1144 }
1145#endif
1146}
1147
1148static void
1149write_contents (abfd, sec, xxx)
ab9da554 1150 bfd *abfd ATTRIBUTE_UNUSED;
252b5132 1151 asection *sec;
ab9da554 1152 PTR xxx ATTRIBUTE_UNUSED;
252b5132
RH		 1153{
1154 segment_info_type *seginfo = seg_info (sec);
1155 unsigned long offset = 0;
1156 fragS *f;
1157
1158 /* Write out the frags. */
1159 if (seginfo == NULL
efaf0ba4 1160 || !(bfd_get_section_flags (abfd, sec) & SEC_HAS_CONTENTS))
252b5132
RH		 1161 return;
1162
1163 for (f = seginfo->frchainP->frch_root;
1164 f;
1165 f = f->fr_next)
1166 {
1167 int x;
1168 unsigned long fill_size;
1169 char *fill_literal;
1170 long count;
1171
1172 assert (f->fr_type == rs_fill);
1173 if (f->fr_fix)
1174 {
1175 x = bfd_set_section_contents (stdoutput, sec,
1176 f->fr_literal, (file_ptr) offset,
1177 (bfd_size_type) f->fr_fix);
1178 if (x == false)
1179 {
1180 bfd_perror (stdoutput->filename);
1181 as_perror (_("FATAL: Can't write %s"), stdoutput->filename);
1182 exit (EXIT_FAILURE);
1183 }
1184 offset += f->fr_fix;
1185 }
1186 fill_literal = f->fr_literal + f->fr_fix;
1187 fill_size = f->fr_var;
1188 count = f->fr_offset;
1189 assert (count >= 0);
1190 if (fill_size && count)
1191 {
1192 char buf[256];
efaf0ba4 1193 if (fill_size > sizeof (buf))
252b5132 1194 {
efaf0ba4 1195 /* Do it the old way. Can this ever happen? */
252b5132
RH		 1196 while (count--)
1197 {
1198 x = bfd_set_section_contents (stdoutput, sec,
1199 fill_literal,
1200 (file_ptr) offset,
1201 (bfd_size_type) fill_size);
1202 if (x == false)
1203 {
1204 bfd_perror (stdoutput->filename);
efaf0ba4
NC		 1205 as_perror (_("FATAL: Can't write %s"),
1206 stdoutput->filename);
252b5132
RH		 1207 exit (EXIT_FAILURE);
1208 }
1209 offset += fill_size;
1210 }
1211 }
1212 else
1213 {
1214 /* Build a buffer full of fill objects and output it as
1215 often as necessary. This saves on the overhead of
1216 potentially lots of bfd_set_section_contents calls. */
1217 int n_per_buf, i;
1218 if (fill_size == 1)
1219 {
1220 n_per_buf = sizeof (buf);
1221 memset (buf, *fill_literal, n_per_buf);
1222 }
1223 else
1224 {
1225 char *bufp;
efaf0ba4 1226 n_per_buf = sizeof (buf) / fill_size;
252b5132 1227 for (i = n_per_buf, bufp = buf; i; i--, bufp += fill_size)
efaf0ba4 1228 memcpy (bufp, fill_literal, fill_size);
252b5132
RH		 1229 }
1230 for (; count > 0; count -= n_per_buf)
1231 {
1232 n_per_buf = n_per_buf > count ? count : n_per_buf;
efaf0ba4
NC		 1233 x = bfd_set_section_contents
1234 (stdoutput, sec, buf, (file_ptr) offset,
1235 (bfd_size_type) n_per_buf * fill_size);
252b5132
RH		 1236 if (x != true)
1237 as_fatal (_("Cannot write to output file."));
1238 offset += n_per_buf * fill_size;
1239 }
1240 }
1241 }
1242 }
1243}
1244#endif
1245
1246#if defined(BFD_ASSEMBLER) || (!defined (BFD) && !defined(OBJ_AOUT))
1247static void
1248merge_data_into_text ()
1249{
1250#if defined(BFD_ASSEMBLER) || defined(MANY_SEGMENTS)
1251 seg_info (text_section)->frchainP->frch_last->fr_next =
1252 seg_info (data_section)->frchainP->frch_root;
1253 seg_info (text_section)->frchainP->frch_last =
1254 seg_info (data_section)->frchainP->frch_last;
1255 seg_info (data_section)->frchainP = 0;
1256#else
1257 fixS *tmp;
1258
1259 text_last_frag->fr_next = data_frag_root;
1260 text_last_frag = data_last_frag;
1261 data_last_frag = NULL;
1262 data_frag_root = NULL;
1263 if (text_fix_root)
1264 {
1265 for (tmp = text_fix_root; tmp->fx_next; tmp = tmp->fx_next);;
1266 tmp->fx_next = data_fix_root;
1267 text_fix_tail = data_fix_tail;
1268 }
1269 else
1270 text_fix_root = data_fix_root;
1271 data_fix_root = NULL;
1272#endif
1273}
efaf0ba4 1274#endif /* BFD_ASSEMBLER || (! BFD && ! OBJ_AOUT) */
252b5132
RH		 1275
1276#if !defined (BFD_ASSEMBLER) && !defined (BFD)
1277static void
1278relax_and_size_all_segments ()
1279{
1280 fragS *fragP;
1281
1282 relax_segment (text_frag_root, SEG_TEXT);
1283 relax_segment (data_frag_root, SEG_DATA);
1284 relax_segment (bss_frag_root, SEG_BSS);
252b5132 1285
efaf0ba4 1286 /* Now the addresses of frags are correct within the segment. */
252b5132
RH		 1287 know (text_last_frag->fr_type == rs_fill && text_last_frag->fr_offset == 0);
1288 H_SET_TEXT_SIZE (&headers, text_last_frag->fr_address);
1289 text_last_frag->fr_address = H_GET_TEXT_SIZE (&headers);
1290
efaf0ba4
NC		 1291 /* Join the 2 segments into 1 huge segment.
1292 To do this, re-compute every rn_address in the SEG_DATA frags.
1293 Then join the data frags after the text frags.
58a77e41 1294
efaf0ba4 1295 Determine a_data [length of data segment]. */
252b5132
RH		 1296 if (data_frag_root)
1297 {
1298 register relax_addressT slide;
1299
efaf0ba4
NC		 1300 know ((text_last_frag->fr_type == rs_fill)
1301 && (text_last_frag->fr_offset == 0));
252b5132
RH		 1302
1303 H_SET_DATA_SIZE (&headers, data_last_frag->fr_address);
1304 data_last_frag->fr_address = H_GET_DATA_SIZE (&headers);
efaf0ba4 1305 slide = H_GET_TEXT_SIZE (&headers); /* & in file of the data segment. */
252b5132
RH		 1306#ifdef OBJ_BOUT
1307#define RoundUp(N,S) (((N)+(S)-1)&-(S))
1308 /* For b.out: If the data section has a strict alignment
1309 requirement, its load address in the .o file will be
1310 rounded up from the size of the text section. These
1311 two values are *not* the same! Similarly for the bss
1312 section.... */
1313 slide = RoundUp (slide, 1 << section_alignment[SEG_DATA]);
1314#endif
1315
1316 for (fragP = data_frag_root; fragP; fragP = fragP->fr_next)
efaf0ba4 1317 fragP->fr_address += slide;
252b5132
RH		 1318
1319 know (text_last_frag != 0);
1320 text_last_frag->fr_next = data_frag_root;
1321 }
1322 else
1323 {
1324 H_SET_DATA_SIZE (&headers, 0);
1325 }
1326
1327#ifdef OBJ_BOUT
1328 /* See above comments on b.out data section address. */
1329 {
1330 long bss_vma;
1331 if (data_last_frag == 0)
1332 bss_vma = H_GET_TEXT_SIZE (&headers);
1333 else
1334 bss_vma = data_last_frag->fr_address;
1335 bss_vma = RoundUp (bss_vma, 1 << section_alignment[SEG_BSS]);
1336 bss_address_frag.fr_address = bss_vma;
1337 }
efaf0ba4 1338#else /* ! OBJ_BOUT */
252b5132
RH		 1339 bss_address_frag.fr_address = (H_GET_TEXT_SIZE (&headers) +
1340 H_GET_DATA_SIZE (&headers));
1341
efaf0ba4 1342#endif /* ! OBJ_BOUT */
252b5132 1343
efaf0ba4 1344 /* Slide all the frags. */
252b5132
RH		 1345 if (bss_frag_root)
1346 {
1347 relax_addressT slide = bss_address_frag.fr_address;
1348
1349 for (fragP = bss_frag_root; fragP; fragP = fragP->fr_next)
efaf0ba4 1350 fragP->fr_address += slide;
252b5132
RH		 1351 }
1352
1353 if (bss_last_frag)
1354 H_SET_BSS_SIZE (&headers,
1355 bss_last_frag->fr_address - bss_frag_root->fr_address);
1356 else
1357 H_SET_BSS_SIZE (&headers, 0);
1358}
efaf0ba4 1359#endif /* ! BFD_ASSEMBLER && ! BFD */
252b5132
RH		 1360
1361#if defined (BFD_ASSEMBLER) || !defined (BFD)
1362
1363#ifdef BFD_ASSEMBLER
1364static void
1365set_symtab ()
1366{
1367 int nsyms;
1368 asymbol **asympp;
1369 symbolS *symp;
1370 boolean result;
1371 extern PTR bfd_alloc PARAMS ((bfd *, size_t));
1372
1373 /* Count symbols. We can't rely on a count made by the loop in
1374 write_object_file, because *_frob_file may add a new symbol or
1375 two. */
1376 nsyms = 0;
1377 for (symp = symbol_rootP; symp; symp = symbol_next (symp))
1378 nsyms++;
1379
1380 if (nsyms)
1381 {
1382 int i;
1383
1384 asympp = (asymbol **) bfd_alloc (stdoutput,
1385 nsyms * sizeof (asymbol *));
1386 symp = symbol_rootP;
1387 for (i = 0; i < nsyms; i++, symp = symbol_next (symp))
1388 {
49309057
ILT		 1389 asympp[i] = symbol_get_bfdsym (symp);
1390 symbol_mark_written (symp);
252b5132
RH		 1391 }
1392 }
1393 else
1394 asympp = 0;
1395 result = bfd_set_symtab (stdoutput, asympp, nsyms);
1396 assert (result == true);
1397 symbol_table_frozen = 1;
1398}
1399#endif
1400
6aa4f516 1401#if defined (BFD_ASSEMBLER) && defined (OBJ_COFF) && defined (TE_GO32)
dbddefbf
NC		 1402static void
1403set_segment_vma (abfd, sec, xxx)
1404 bfd *abfd;
1405 asection *sec;
1406 PTR xxx ATTRIBUTE_UNUSED;
1407{
1408 static bfd_vma addr = 0;
efaf0ba4 1409
dbddefbf
NC		 1410 bfd_set_section_vma (abfd, sec, addr);
1411 addr += bfd_section_size (abfd, sec);
1412}
efaf0ba4 1413#endif /* BFD_ASSEMBLER && OBJ_COFF && !TE_PE */
dbddefbf 1414
252b5132
RH		 1415/* Finish the subsegments. After every sub-segment, we fake an
1416 ".align ...". This conforms to BSD4.2 brane-damage. We then fake
1417 ".fill 0" because that is the kind of frag that requires least
1418 thought. ".align" frags like to have a following frag since that
1419 makes calculating their intended length trivial. */
1420
1421#ifndef SUB_SEGMENT_ALIGN
1422#ifdef BFD_ASSEMBLER
1423#define SUB_SEGMENT_ALIGN(SEG) (0)
1424#else
1425#define SUB_SEGMENT_ALIGN(SEG) (2)
1426#endif
1427#endif
1428
1429void
1430subsegs_finish ()
1431{
1432 struct frchain *frchainP;
1433
1434 for (frchainP = frchain_root; frchainP; frchainP = frchainP->frch_next)
1435 {
0a9ef439
RH		 1436 int alignment;
1437
252b5132
RH		 1438 subseg_set (frchainP->frch_seg, frchainP->frch_subseg);
1439
1440 /* This now gets called even if we had errors. In that case,
1441 any alignment is meaningless, and, moreover, will look weird
1442 if we are generating a listing. */
0a9ef439
RH		 1443 alignment = had_errors () ? 0 : SUB_SEGMENT_ALIGN (now_seg);
1444
1445 /* The last subsegment gets an aligment corresponding to the
1446 alignment of the section. This allows proper nop-filling
1447 at the end of code-bearing sections. */
1448 if (!frchainP->frch_next || frchainP->frch_next->frch_seg != now_seg)
1449 alignment = get_recorded_alignment (now_seg);
1450
799051fc
RH		 1451 if (subseg_text_p (now_seg))
1452 frag_align_code (alignment, 0);
1453 else
1454 frag_align (alignment, 0, 0);
252b5132
RH		 1455
1456 /* frag_align will have left a new frag.
1457 Use this last frag for an empty ".fill".
1458
1459 For this segment ...
1460 Create a last frag. Do not leave a "being filled in frag". */
252b5132
RH		 1461 frag_wane (frag_now);
1462 frag_now->fr_fix = 0;
1463 know (frag_now->fr_next == NULL);
1464 }
1465}
1466
1467/* Write the object file. */
1468
1469void
1470write_object_file ()
1471{
1472#if ! defined (BFD_ASSEMBLER) || ! defined (WORKING_DOT_WORD)
efaf0ba4 1473 fragS *fragP; /* Track along all frags. */
252b5132
RH		 1474#endif
1475
1476 /* Do we really want to write it? */
1477 {
1478 int n_warns, n_errs;
1479 n_warns = had_warnings ();
1480 n_errs = had_errors ();
1481 /* The -Z flag indicates that an object file should be generated,
1482 regardless of warnings and errors. */
1483 if (flag_always_generate_output)
1484 {
1485 if (n_warns || n_errs)
1486 as_warn (_("%d error%s, %d warning%s, generating bad object file.\n"),
1487 n_errs, n_errs == 1 ? "" : "s",
1488 n_warns, n_warns == 1 ? "" : "s");
1489 }
1490 else
1491 {
1492 if (n_errs)
1493 as_fatal (_("%d error%s, %d warning%s, no object file generated.\n"),
1494 n_errs, n_errs == 1 ? "" : "s",
1495 n_warns, n_warns == 1 ? "" : "s");
1496 }
1497 }
1498
1499#ifdef OBJ_VMS
1500 /* Under VMS we try to be compatible with VAX-11 "C". Thus, we call
1501 a routine to check for the definition of the procedure "_main",
efaf0ba4 1502 and if so -- fix it up so that it can be program entry point. */
252b5132 1503 vms_check_for_main ();
efaf0ba4 1504#endif /* OBJ_VMS */
252b5132
RH		 1505
1506 /* From now on, we don't care about sub-segments. Build one frag chain
1507 for each segment. Linked thru fr_next. */
1508
1509#ifdef BFD_ASSEMBLER
1510 /* Remove the sections created by gas for its own purposes. */
1511 {
1512 asection **seclist, *sec;
1513 int i;
1514
1515 seclist = &stdoutput->sections;
1516 while (seclist && *seclist)
1517 {
1518 sec = *seclist;
1519 while (sec == reg_section || sec == expr_section)
1520 {
1521 sec = sec->next;
1522 *seclist = sec;
1523 stdoutput->section_count--;
1524 if (!sec)
1525 break;
1526 }
1527 if (*seclist)
1528 seclist = &(*seclist)->next;
1529 }
1530 i = 0;
1531 bfd_map_over_sections (stdoutput, renumber_sections, &i);
1532 }
1533
1534 bfd_map_over_sections (stdoutput, chain_frchains_together, (char *) 0);
1535#else
1536 remove_subsegs (frchain_root, SEG_TEXT, &text_frag_root, &text_last_frag);
1537 remove_subsegs (data0_frchainP, SEG_DATA, &data_frag_root, &data_last_frag);
1538 remove_subsegs (bss0_frchainP, SEG_BSS, &bss_frag_root, &bss_last_frag);
1539#endif
1540
1541 /* We have two segments. If user gave -R flag, then we must put the
1542 data frags into the text segment. Do this before relaxing so
1543 we know to take advantage of -R and make shorter addresses. */
1544#if !defined (OBJ_AOUT) || defined (BFD_ASSEMBLER)
1545 if (flag_readonly_data_in_text)
1546 {
1547 merge_data_into_text ();
1548 }
1549#endif
1550
1551#ifdef BFD_ASSEMBLER
e46d99eb
AM		 1552 while (1)
1553 {
1554 int changed;
1555
aacb5251
HPN		 1556#ifndef WORKING_DOT_WORD
1557 /* We need to reset the markers in the broken word list and
1558 associated frags between calls to relax_segment (via
1559 relax_seg). Since the broken word list is global, we do it
1560 once per round, rather than locally in relax_segment for each
1561 segment. */
1562 struct broken_word *brokp;
1563
1564 for (brokp = broken_words;
1565 brokp != (struct broken_word *) NULL;
1566 brokp = brokp->next_broken_word)
1567 {
1568 brokp->added = 0;
1569
1570 if (brokp->dispfrag != (fragS *) NULL
1571 && brokp->dispfrag->fr_type == rs_broken_word)
1572 brokp->dispfrag->fr_subtype = 0;
1573 }
1574#endif
1575
e46d99eb
AM		 1576 changed = 0;
1577 bfd_map_over_sections (stdoutput, relax_seg, &changed);
1578 if (!changed)
1579 break;
1580 }
e027f3e8 1581
87548816
NC		 1582 /* Note - Most ports will use the default value of
1583 TC_FINALIZE_SYMS_BEFORE_SIZE_SEG, which 1. This will force
1584 local symbols to be resolved, removing their frag information.
1585 Some ports however, will not have finished relaxing all of
1586 their frags and will still need the local symbol frag
1587 information. These ports can set
1588 TC_FINALIZE_SYMS_BEFORE_SIZE_SEG to 0. */
1589 finalize_syms = TC_FINALIZE_SYMS_BEFORE_SIZE_SEG;
1590
e46d99eb 1591 bfd_map_over_sections (stdoutput, size_seg, (char *) 0);
252b5132
RH		 1592#else
1593 relax_and_size_all_segments ();
e027f3e8 1594#endif /* BFD_ASSEMBLER */
e46d99eb 1595
38b87a1b
NC		 1596 /* Relaxation has completed. Freeze all syms. */
1597 finalize_syms = 1;
1598
6aa4f516 1599#if defined (BFD_ASSEMBLER) && defined (OBJ_COFF) && defined (TE_GO32)
dbddefbf 1600 /* Now that the segments have their final sizes, run through the
6aa4f516
NC		 1601 sections and set their vma and lma. !BFD gas sets them, and BFD gas
1602 should too. Currently, only DJGPP uses this code, but other
1603 COFF targets may need to execute this too. */
dbddefbf
NC		 1604 bfd_map_over_sections (stdoutput, set_segment_vma, (char *) 0);
1605#endif
1606
252b5132 1607#ifndef BFD_ASSEMBLER
efaf0ba4 1608 /* Crawl the symbol chain.
58a77e41 1609
efaf0ba4
NC		 1610 For each symbol whose value depends on a frag, take the address of
1611 that frag and subsume it into the value of the symbol.
1612 After this, there is just one way to lookup a symbol value.
1613 Values are left in their final state for object file emission.
1614 We adjust the values of 'L' local symbols, even if we do
1615 not intend to emit them to the object file, because their values
1616 are needed for fix-ups.
58a77e41 1617
efaf0ba4
NC		 1618 Unless we saw a -L flag, remove all symbols that begin with 'L'
1619 from the symbol chain. (They are still pointed to by the fixes.)
58a77e41 1620
efaf0ba4
NC		 1621 Count the remaining symbols.
1622 Assign a symbol number to each symbol.
1623 Count the number of string-table chars we will emit.
1624 Put this info into the headers as appropriate. */
252b5132
RH		 1625 know (zero_address_frag.fr_address == 0);
1626 string_byte_count = sizeof (string_byte_count);
1627
1628 obj_crawl_symbol_chain (&headers);
1629
1630 if (string_byte_count == sizeof (string_byte_count))
1631 string_byte_count = 0;
1632
1633 H_SET_STRING_SIZE (&headers, string_byte_count);
1634
efaf0ba4
NC		 1635 /* Addresses of frags now reflect addresses we use in the object file.
1636 Symbol values are correct.
1637 Scan the frags, converting any ".org"s and ".align"s to ".fill"s.
1638 Also converting any machine-dependent frags using md_convert_frag(); */
252b5132
RH		 1639 subseg_change (SEG_TEXT, 0);
1640
1641 for (fragP = text_frag_root; fragP; fragP = fragP->fr_next)
1642 {
1643 /* At this point we have linked all the frags into a single
1644 chain. However, cvt_frag_to_fill may call md_convert_frag
1645 which may call fix_new. We need to ensure that fix_new adds
1646 the fixup to the right section. */
1647 if (fragP == data_frag_root)
1648 subseg_change (SEG_DATA, 0);
1649
1650 cvt_frag_to_fill (&headers, SEG_TEXT, fragP);
1651
1652 /* Some assert macros don't work with # directives mixed in. */
1653#ifndef NDEBUG
1654 if (!(fragP->fr_next == NULL
1655#ifdef OBJ_BOUT
1656 || fragP->fr_next == data_frag_root
1657#endif
1658 || ((fragP->fr_next->fr_address - fragP->fr_address)
1659 == (fragP->fr_fix + fragP->fr_offset * fragP->fr_var))))
1660 abort ();
1661#endif
1662 }
efaf0ba4 1663#endif /* ! BFD_ASSEMBLER */
252b5132
RH		 1664
1665#ifndef WORKING_DOT_WORD
1666 {
1667 struct broken_word *lie;
1668 struct broken_word **prevP;
1669
1670 prevP = &broken_words;
1671 for (lie = broken_words; lie; lie = lie->next_broken_word)
1672 if (!lie->added)
1673 {
1674 expressionS exp;
1675
1676 subseg_change (lie->seg, lie->subseg);
1677 exp.X_op = O_subtract;
1678 exp.X_add_symbol = lie->add;
1679 exp.X_op_symbol = lie->sub;
1680 exp.X_add_number = lie->addnum;
1681#ifdef BFD_ASSEMBLER
1682#ifdef TC_CONS_FIX_NEW
1683 TC_CONS_FIX_NEW (lie->frag,
efaf0ba4
NC		 1684 lie->word_goes_here - lie->frag->fr_literal,
1685 2, &exp);
252b5132
RH		 1686#else
1687 fix_new_exp (lie->frag,
1688 lie->word_goes_here - lie->frag->fr_literal,
1689 2, &exp, 0, BFD_RELOC_16);
1690#endif
1691#else
1692#if defined(TC_SPARC) || defined(TC_A29K) || defined(NEED_FX_R_TYPE)
1693 fix_new_exp (lie->frag,
1694 lie->word_goes_here - lie->frag->fr_literal,
1695 2, &exp, 0, NO_RELOC);
1696#else
1697#ifdef TC_NS32K
1698 fix_new_ns32k_exp (lie->frag,
1699 lie->word_goes_here - lie->frag->fr_literal,
1700 2, &exp, 0, 0, 2, 0, 0);
1701#else
1702 fix_new_exp (lie->frag,
1703 lie->word_goes_here - lie->frag->fr_literal,
1704 2, &exp, 0, 0);
efaf0ba4
NC		 1705#endif /* TC_NS32K */
1706#endif /* TC_SPARC|TC_A29K|NEED_FX_R_TYPE */
1707#endif /* BFD_ASSEMBLER */
252b5132
RH		 1708 *prevP = lie->next_broken_word;
1709 }
1710 else
1711 prevP = &(lie->next_broken_word);
1712
1713 for (lie = broken_words; lie;)
1714 {
1715 struct broken_word *untruth;
1716 char *table_ptr;
1717 addressT table_addr;
1718 addressT from_addr, to_addr;
1719 int n, m;
1720
1721 subseg_change (lie->seg, lie->subseg);
1722 fragP = lie->dispfrag;
1723
1724 /* Find out how many broken_words go here. */
1725 n = 0;
efaf0ba4
NC		 1726 for (untruth = lie;
1727 untruth && untruth->dispfrag == fragP;
1728 untruth = untruth->next_broken_word)
252b5132
RH		 1729 if (untruth->added == 1)
1730 n++;
1731
1732 table_ptr = lie->dispfrag->fr_opcode;
efaf0ba4
NC		 1733 table_addr = (lie->dispfrag->fr_address
1734 + (table_ptr - lie->dispfrag->fr_literal));
252b5132
RH		 1735 /* Create the jump around the long jumps. This is a short
1736 jump from table_ptr+0 to table_ptr+n*long_jump_size. */
1737 from_addr = table_addr;
1738 to_addr = table_addr + md_short_jump_size + n * md_long_jump_size;
efaf0ba4
NC		 1739 md_create_short_jump (table_ptr, from_addr, to_addr, lie->dispfrag,
1740 lie->add);
252b5132
RH		 1741 table_ptr += md_short_jump_size;
1742 table_addr += md_short_jump_size;
1743
efaf0ba4
NC		 1744 for (m = 0;
1745 lie && lie->dispfrag == fragP;
1746 m++, lie = lie->next_broken_word)
252b5132
RH		 1747 {
1748 if (lie->added == 2)
1749 continue;
efaf0ba4
NC		 1750 /* Patch the jump table. */
1751 /* This is the offset from ??? to table_ptr+0. */
252b5132 1752 to_addr = table_addr - S_GET_VALUE (lie->sub);
753f6b12
HPN		 1753#ifdef TC_CHECK_ADJUSTED_BROKEN_DOT_WORD
1754 TC_CHECK_ADJUSTED_BROKEN_DOT_WORD (to_addr, lie);
252b5132
RH		 1755#endif
1756 md_number_to_chars (lie->word_goes_here, to_addr, 2);
efaf0ba4
NC		 1757 for (untruth = lie->next_broken_word;
1758 untruth && untruth->dispfrag == fragP;
1759 untruth = untruth->next_broken_word)
252b5132
RH		 1760 {
1761 if (untruth->use_jump == lie)
1762 md_number_to_chars (untruth->word_goes_here, to_addr, 2);
1763 }
1764
efaf0ba4
NC		 1765 /* Install the long jump. */
1766 /* This is a long jump from table_ptr+0 to the final target. */
252b5132
RH		 1767 from_addr = table_addr;
1768 to_addr = S_GET_VALUE (lie->add) + lie->addnum;
efaf0ba4
NC		 1769 md_create_long_jump (table_ptr, from_addr, to_addr, lie->dispfrag,
1770 lie->add);
252b5132
RH		 1771 table_ptr += md_long_jump_size;
1772 table_addr += md_long_jump_size;
1773 }
1774 }
1775 }
efaf0ba4 1776#endif /* not WORKING_DOT_WORD */
252b5132
RH		 1777
1778#ifndef BFD_ASSEMBLER
1779#ifndef OBJ_VMS
efaf0ba4 1780 { /* not vms */
252b5132
RH		 1781 char *the_object_file;
1782 long object_file_size;
efaf0ba4
NC		 1783 /* Scan every FixS performing fixups. We had to wait until now to
1784 do this because md_convert_frag() may have made some fixSs. */
252b5132
RH		 1785 int trsize, drsize;
1786
1787 subseg_change (SEG_TEXT, 0);
1788 trsize = md_reloc_size * fixup_segment (text_fix_root, SEG_TEXT);
1789 subseg_change (SEG_DATA, 0);
1790 drsize = md_reloc_size * fixup_segment (data_fix_root, SEG_DATA);
1791 H_SET_RELOCATION_SIZE (&headers, trsize, drsize);
1792
efaf0ba4 1793 /* FIXME: Move this stuff into the pre-write-hook. */
252b5132
RH		 1794 H_SET_MAGIC_NUMBER (&headers, magic_number_for_object_file);
1795 H_SET_ENTRY_POINT (&headers, 0);
1796
efaf0ba4 1797 obj_pre_write_hook (&headers); /* Extra coff stuff. */
252b5132
RH		 1798
1799 object_file_size = H_GET_FILE_SIZE (&headers);
1800 next_object_file_charP = the_object_file = xmalloc (object_file_size);
1801
1802 output_file_create (out_file_name);
1803
1804 obj_header_append (&next_object_file_charP, &headers);
1805
efaf0ba4
NC		 1806 know ((next_object_file_charP - the_object_file)
1807 == H_GET_HEADER_SIZE (&headers));
252b5132 1808
efaf0ba4 1809 /* Emit code. */
252b5132
RH		 1810 for (fragP = text_frag_root; fragP; fragP = fragP->fr_next)
1811 {
1812 register long count;
1813 register char *fill_literal;
1814 register long fill_size;
1815
1816 PROGRESS (1);
1817 know (fragP->fr_type == rs_fill);
efaf0ba4
NC		 1818 append (&next_object_file_charP, fragP->fr_literal,
1819 (unsigned long) fragP->fr_fix);
252b5132
RH		 1820 fill_literal = fragP->fr_literal + fragP->fr_fix;
1821 fill_size = fragP->fr_var;
1822 know (fragP->fr_offset >= 0);
1823
1824 for (count = fragP->fr_offset; count; count--)
efaf0ba4
NC		 1825 append (&next_object_file_charP, fill_literal,
1826 (unsigned long) fill_size);
1827 }
252b5132 1828
efaf0ba4
NC		 1829 know ((next_object_file_charP - the_object_file)
1830 == (H_GET_HEADER_SIZE (&headers)
1831 + H_GET_TEXT_SIZE (&headers)
1832 + H_GET_DATA_SIZE (&headers)));
1833
1834 /* Emit relocations. */
1835 obj_emit_relocations (&next_object_file_charP, text_fix_root,
1836 (relax_addressT) 0);
1837 know ((next_object_file_charP - the_object_file)
1838 == (H_GET_HEADER_SIZE (&headers)
1839 + H_GET_TEXT_SIZE (&headers)
1840 + H_GET_DATA_SIZE (&headers)
1841 + H_GET_TEXT_RELOCATION_SIZE (&headers)));
252b5132
RH		 1842#ifdef TC_I960
1843 /* Make addresses in data relocation directives relative to beginning of
efaf0ba4
NC		 1844 first data fragment, not end of last text fragment: alignment of the
1845 start of the data segment may place a gap between the segments. */
1846 obj_emit_relocations (&next_object_file_charP, data_fix_root,
1847 data0_frchainP->frch_root->fr_address);
1848#else /* TC_I960 */
1849 obj_emit_relocations (&next_object_file_charP, data_fix_root,
1850 text_last_frag->fr_address);
1851#endif /* TC_I960 */
1852
1853 know ((next_object_file_charP - the_object_file)
1854 == (H_GET_HEADER_SIZE (&headers)
1855 + H_GET_TEXT_SIZE (&headers)
1856 + H_GET_DATA_SIZE (&headers)
1857 + H_GET_TEXT_RELOCATION_SIZE (&headers)
1858 + H_GET_DATA_RELOCATION_SIZE (&headers)));
1859
1860 /* Emit line number entries. */
252b5132 1861 OBJ_EMIT_LINENO (&next_object_file_charP, lineno_rootP, the_object_file);
efaf0ba4
NC		 1862 know ((next_object_file_charP - the_object_file)
1863 == (H_GET_HEADER_SIZE (&headers)
1864 + H_GET_TEXT_SIZE (&headers)
1865 + H_GET_DATA_SIZE (&headers)
1866 + H_GET_TEXT_RELOCATION_SIZE (&headers)
1867 + H_GET_DATA_RELOCATION_SIZE (&headers)
1868 + H_GET_LINENO_SIZE (&headers)));
1869
1870 /* Emit symbols. */
252b5132 1871 obj_emit_symbols (&next_object_file_charP, symbol_rootP);
efaf0ba4
NC		 1872 know ((next_object_file_charP - the_object_file)
1873 == (H_GET_HEADER_SIZE (&headers)
1874 + H_GET_TEXT_SIZE (&headers)
1875 + H_GET_DATA_SIZE (&headers)
1876 + H_GET_TEXT_RELOCATION_SIZE (&headers)
1877 + H_GET_DATA_RELOCATION_SIZE (&headers)
1878 + H_GET_LINENO_SIZE (&headers)
1879 + H_GET_SYMBOL_TABLE_SIZE (&headers)));
1880
1881 /* Emit strings. */
252b5132 1882 if (string_byte_count > 0)
efaf0ba4 1883 obj_emit_strings (&next_object_file_charP);
252b5132
RH		 1884
1885#ifdef BFD_HEADERS
1886 bfd_seek (stdoutput, 0, 0);
1887 bfd_write (the_object_file, 1, object_file_size, stdoutput);
1888#else
1889
efaf0ba4 1890 /* Write the data to the file. */
252b5132
RH		 1891 output_file_append (the_object_file, object_file_size, out_file_name);
1892 free (the_object_file);
1893#endif
efaf0ba4
NC		 1894 }
1895#else /* OBJ_VMS */
1896 /* Now do the VMS-dependent part of writing the object file. */
252b5132
RH		 1897 vms_write_object_file (H_GET_TEXT_SIZE (&headers),
1898 H_GET_DATA_SIZE (&headers),
1899 H_GET_BSS_SIZE (&headers),
1900 text_frag_root, data_frag_root);
efaf0ba4
NC		 1901#endif /* OBJ_VMS */
1902#else /* BFD_ASSEMBLER */
252b5132
RH		 1903
1904 /* Resolve symbol values. This needs to be done before processing
1905 the relocations. */
1906 if (symbol_rootP)
1907 {
1908 symbolS *symp;
1909
1910 for (symp = symbol_rootP; symp; symp = symbol_next (symp))
6386f3a7 1911 resolve_symbol_value (symp);
252b5132 1912 }
49309057 1913 resolve_local_symbol_values ();
252b5132
RH		 1914
1915 PROGRESS (1);
1916
1917#ifdef tc_frob_file_before_adjust
1918 tc_frob_file_before_adjust ();
1919#endif
1920#ifdef obj_frob_file_before_adjust
1921 obj_frob_file_before_adjust ();
1922#endif
1923
efaf0ba4 1924 bfd_map_over_sections (stdoutput, adjust_reloc_syms, (char *) 0);
252b5132
RH		 1925
1926 /* Set up symbol table, and write it out. */
1927 if (symbol_rootP)
1928 {
1929 symbolS *symp;
1930
1931 for (symp = symbol_rootP; symp; symp = symbol_next (symp))
1932 {
1933 int punt = 0;
1934 const char *name;
1935
49309057 1936 if (symbol_mri_common_p (symp))
252b5132
RH		 1937 {
1938 if (S_IS_EXTERNAL (symp))
1939 as_bad (_("%s: global symbols not supported in common sections"),
1940 S_GET_NAME (symp));
1941 symbol_remove (symp, &symbol_rootP, &symbol_lastP);
1942 continue;
1943 }
1944
1945 name = S_GET_NAME (symp);
1946 if (name)
1947 {
efaf0ba4
NC		 1948 const char *name2 =
1949 decode_local_label_name ((char *) S_GET_NAME (symp));
252b5132
RH		 1950 /* They only differ if `name' is a fb or dollar local
1951 label name. */
1952 if (name2 != name && ! S_IS_DEFINED (symp))
1953 as_bad (_("local label %s is not defined"), name2);
1954 }
1955
1956 /* Do it again, because adjust_reloc_syms might introduce
1957 more symbols. They'll probably only be section symbols,
1958 but they'll still need to have the values computed. */
6386f3a7 1959 resolve_symbol_value (symp);
252b5132
RH		 1960
1961 /* Skip symbols which were equated to undefined or common
1962 symbols. */
49309057 1963 if (symbol_equated_p (symp)
252b5132
RH		 1964 && (! S_IS_DEFINED (symp) || S_IS_COMMON (symp)))
1965 {
1966 symbol_remove (symp, &symbol_rootP, &symbol_lastP);
1967 continue;
1968 }
1969
1970 /* So far, common symbols have been treated like undefined symbols.
1971 Put them in the common section now. */
1972 if (S_IS_DEFINED (symp) == 0
1973 && S_GET_VALUE (symp) != 0)
1974 S_SET_SEGMENT (symp, bfd_com_section_ptr);
1975#if 0
1976 printf ("symbol `%s'\n\t@%x: value=%d flags=%x seg=%s\n",
1977 S_GET_NAME (symp), symp,
1978 S_GET_VALUE (symp),
49309057
ILT		 1979 symbol_get_bfdsym (symp)->flags,
1980 segment_name (S_GET_SEGMENT (symp)));
252b5132
RH		 1981#endif
1982
1983#ifdef obj_frob_symbol
1984 obj_frob_symbol (symp, punt);
1985#endif
1986#ifdef tc_frob_symbol
49309057 1987 if (! punt || symbol_used_in_reloc_p (symp))
252b5132
RH		 1988 tc_frob_symbol (symp, punt);
1989#endif
1990
1991 /* If we don't want to keep this symbol, splice it out of
1992 the chain now. If EMIT_SECTION_SYMBOLS is 0, we never
1993 want section symbols. Otherwise, we skip local symbols
1994 and symbols that the frob_symbol macros told us to punt,
1995 but we keep such symbols if they are used in relocs. */
1996 if ((! EMIT_SECTION_SYMBOLS
49309057 1997 && symbol_section_p (symp))
252b5132
RH		 1998 /* Note that S_IS_EXTERN and S_IS_LOCAL are not always
1999 opposites. Sometimes the former checks flags and the
2000 latter examines the name... */
2001 || (!S_IS_EXTERN (symp)
2002 && (S_IS_LOCAL (symp) || punt)
49309057 2003 && ! symbol_used_in_reloc_p (symp)))
252b5132
RH		 2004 {
2005 symbol_remove (symp, &symbol_rootP, &symbol_lastP);
efaf0ba4 2006
252b5132
RH		 2007 /* After symbol_remove, symbol_next(symp) still returns
2008 the one that came after it in the chain. So we don't
2009 need to do any extra cleanup work here. */
252b5132
RH		 2010 continue;
2011 }
2012
2013 /* Make sure we really got a value for the symbol. */
49309057 2014 if (! symbol_resolved_p (symp))
252b5132
RH		 2015 {
2016 as_bad (_("can't resolve value for symbol \"%s\""),
2017 S_GET_NAME (symp));
49309057 2018 symbol_mark_resolved (symp);
252b5132
RH		 2019 }
2020
2021 /* Set the value into the BFD symbol. Up til now the value
2022 has only been kept in the gas symbolS struct. */
49309057 2023 symbol_get_bfdsym (symp)->value = S_GET_VALUE (symp);
252b5132
RH		 2024 }
2025 }
2026
2027 PROGRESS (1);
2028
2029 /* Now do any format-specific adjustments to the symbol table, such
2030 as adding file symbols. */
2031#ifdef tc_adjust_symtab
2032 tc_adjust_symtab ();
2033#endif
2034#ifdef obj_adjust_symtab
2035 obj_adjust_symtab ();
2036#endif
2037
2038 /* Now that all the sizes are known, and contents correct, we can
2039 start writing to the file. */
2040 set_symtab ();
2041
2042 /* If *_frob_file changes the symbol value at this point, it is
2043 responsible for moving the changed value into symp->bsym->value
2044 as well. Hopefully all symbol value changing can be done in
2045 *_frob_symbol. */
2046#ifdef tc_frob_file
2047 tc_frob_file ();
2048#endif
2049#ifdef obj_frob_file
2050 obj_frob_file ();
2051#endif
2052
2053 bfd_map_over_sections (stdoutput, write_relocs, (char *) 0);
2054
2055#ifdef tc_frob_file_after_relocs
2056 tc_frob_file_after_relocs ();
2057#endif
2058#ifdef obj_frob_file_after_relocs
2059 obj_frob_file_after_relocs ();
2060#endif
2061
2062 bfd_map_over_sections (stdoutput, write_contents, (char *) 0);
efaf0ba4 2063#endif /* BFD_ASSEMBLER */
252b5132 2064}
efaf0ba4 2065#endif /* ! BFD */
252b5132
RH		 2066
2067#ifdef TC_GENERIC_RELAX_TABLE
2068
252b5132
RH		 2069/* Relax a fragment by scanning TC_GENERIC_RELAX_TABLE. */
2070
2071long
c842b53a
ILT		 2072relax_frag (segment, fragP, stretch)
2073 segT segment;
252b5132
RH		 2074 fragS *fragP;
2075 long stretch;
2076{
2077 const relax_typeS *this_type;
2078 const relax_typeS *start_type;
2079 relax_substateT next_state;
2080 relax_substateT this_state;
38686296
AM		 2081 long growth;
2082 offsetT aim;
2083 addressT target;
2084 addressT address;
2085 symbolS *symbolP;
2086 const relax_typeS *table;
2087
2088 target = fragP->fr_offset;
2089 address = fragP->fr_address;
2090 table = TC_GENERIC_RELAX_TABLE;
252b5132
RH		 2091 this_state = fragP->fr_subtype;
2092 start_type = this_type = table + this_state;
38686296 2093 symbolP = fragP->fr_symbol;
252b5132
RH		 2094
2095 if (symbolP)
2096 {
c842b53a
ILT		 2097 fragS *sym_frag;
2098
2099 sym_frag = symbol_get_frag (symbolP);
2100
252b5132
RH		 2101#ifndef DIFF_EXPR_OK
2102#if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER)
2103 know ((S_GET_SEGMENT (symbolP) == SEG_ABSOLUTE)
2104 || (S_GET_SEGMENT (symbolP) == SEG_DATA)
2105 || (S_GET_SEGMENT (symbolP) == SEG_BSS)
2106 || (S_GET_SEGMENT (symbolP) == SEG_TEXT));
2107#endif
c842b53a 2108 know (sym_frag != NULL);
252b5132
RH		 2109#endif
2110 know (!(S_GET_SEGMENT (symbolP) == absolute_section)
c842b53a 2111 || sym_frag == &zero_address_frag);
ac62c346 2112 target += S_GET_VALUE (symbolP);
252b5132
RH		 2113
2114 /* If frag has yet to be reached on this pass,
2115 assume it will move by STRETCH just as we did.
2116 If this is not so, it will be because some frag
38686296 2117 between grows, and that will force another pass. */
252b5132 2118
c842b53a 2119 if (stretch != 0
38686296
AM		 2120 && sym_frag->relax_marker != fragP->relax_marker
2121 && S_GET_SEGMENT (symbolP) == segment)
252b5132
RH		 2122 {
2123 target += stretch;
2124 }
2125 }
2126
2127 aim = target - address - fragP->fr_fix;
2128#ifdef TC_PCREL_ADJUST
efaf0ba4
NC		 2129 /* Currently only the ns32k family needs this. */
2130 aim += TC_PCREL_ADJUST (fragP);
2131/* #else */
252b5132
RH		 2132 /* This machine doesn't want to use pcrel_adjust.
2133 In that case, pcrel_adjust should be zero. */
efaf0ba4
NC		 2134#if 0
2135 assert (fragP->fr_targ.ns32k.pcrel_adjust == 0);
252b5132 2136#endif
efaf0ba4
NC		 2137#endif
2138#ifdef md_prepare_relax_scan /* formerly called M68K_AIM_KLUDGE */
252b5132
RH		 2139 md_prepare_relax_scan (fragP, address, aim, this_state, this_type);
2140#endif
2141
2142 if (aim < 0)
2143 {
efaf0ba4 2144 /* Look backwards. */
252b5132
RH		 2145 for (next_state = this_type->rlx_more; next_state;)
2146 if (aim >= this_type->rlx_backward)
2147 next_state = 0;
2148 else
2149 {
efaf0ba4 2150 /* Grow to next state. */
252b5132
RH		 2151 this_state = next_state;
2152 this_type = table + this_state;
2153 next_state = this_type->rlx_more;
2154 }
2155 }
2156 else
2157 {
efaf0ba4 2158 /* Look forwards. */
252b5132
RH		 2159 for (next_state = this_type->rlx_more; next_state;)
2160 if (aim <= this_type->rlx_forward)
2161 next_state = 0;
2162 else
2163 {
efaf0ba4 2164 /* Grow to next state. */
252b5132
RH		 2165 this_state = next_state;
2166 this_type = table + this_state;
2167 next_state = this_type->rlx_more;
2168 }
2169 }
2170
2171 growth = this_type->rlx_length - start_type->rlx_length;
2172 if (growth != 0)
2173 fragP->fr_subtype = this_state;
2174 return growth;
2175}
2176
efaf0ba4 2177#endif /* defined (TC_GENERIC_RELAX_TABLE) */
252b5132
RH		 2178
2179/* Relax_align. Advance location counter to next address that has 'alignment'
2180 lowest order bits all 0s, return size of adjustment made. */
2181static relax_addressT
2182relax_align (address, alignment)
efaf0ba4
NC		 2183 register relax_addressT address; /* Address now. */
2184 register int alignment; /* Alignment (binary). */
252b5132
RH		 2185{
2186 relax_addressT mask;
2187 relax_addressT new_address;
2188
2189 mask = ~((~0) << alignment);
2190 new_address = (address + mask) & (~mask);
2191#ifdef LINKER_RELAXING_SHRINKS_ONLY
2192 if (linkrelax)
2193 /* We must provide lots of padding, so the linker can discard it
2194 when needed. The linker will not add extra space, ever. */
2195 new_address += (1 << alignment);
2196#endif
2197 return (new_address - address);
2198}
2199
efaf0ba4
NC		 2200/* Now we have a segment, not a crowd of sub-segments, we can make
2201 fr_address values.
58a77e41 2202
efaf0ba4 2203 Relax the frags.
58a77e41 2204
efaf0ba4
NC		 2205 After this, all frags in this segment have addresses that are correct
2206 within the segment. Since segments live in different file addresses,
2207 these frag addresses may not be the same as final object-file
2208 addresses. */
2209
e46d99eb 2210int
252b5132
RH		 2211relax_segment (segment_frag_root, segment)
2212 struct frag *segment_frag_root;
2213 segT segment;
2214{
2215 register struct frag *fragP;
2216 register relax_addressT address;
e46d99eb
AM		 2217 int ret;
2218
252b5132
RH		 2219#if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER)
2220 know (segment == SEG_DATA || segment == SEG_TEXT || segment == SEG_BSS);
2221#endif
efaf0ba4 2222 /* In case md_estimate_size_before_relax() wants to make fixSs. */
252b5132
RH		 2223 subseg_change (segment, 0);
2224
2225 /* For each frag in segment: count and store (a 1st guess of)
2226 fr_address. */
2227 address = 0;
2228 for (fragP = segment_frag_root; fragP; fragP = fragP->fr_next)
2229 {
38686296 2230 fragP->relax_marker = 0;
252b5132
RH		 2231 fragP->fr_address = address;
2232 address += fragP->fr_fix;
2233
2234 switch (fragP->fr_type)
2235 {
2236 case rs_fill:
2237 address += fragP->fr_offset * fragP->fr_var;
2238 break;
2239
2240 case rs_align:
2241 case rs_align_code:
0a9ef439 2242 case rs_align_test:
252b5132
RH		 2243 {
2244 addressT offset = relax_align (address, (int) fragP->fr_offset);
2245
2246 if (fragP->fr_subtype != 0 && offset > fragP->fr_subtype)
2247 offset = 0;
2248
2249 if (offset % fragP->fr_var != 0)
2250 {
54d3cad9
AM		 2251 as_bad_where (fragP->fr_file, fragP->fr_line,
2252 _("alignment padding (%lu bytes) not a multiple of %ld"),
2253 (unsigned long) offset, (long) fragP->fr_var);
252b5132
RH		 2254 offset -= (offset % fragP->fr_var);
2255 }
2256
2257 address += offset;
2258 }
2259 break;
2260
2261 case rs_org:
2262 case rs_space:
2263 /* Assume .org is nugatory. It will grow with 1st relax. */
2264 break;
2265
2266 case rs_machine_dependent:
2267 address += md_estimate_size_before_relax (fragP, segment);
2268 break;
2269
2270#ifndef WORKING_DOT_WORD
efaf0ba4 2271 /* Broken words don't concern us yet. */
252b5132
RH		 2272 case rs_broken_word:
2273 break;
2274#endif
2275
2276 case rs_leb128:
efaf0ba4 2277 /* Initial guess is always 1; doing otherwise can result in
252b5132
RH		 2278 stable solutions that are larger than the minimum. */
2279 address += fragP->fr_offset = 1;
2280 break;
2281
2282 case rs_cfa:
2283 address += eh_frame_estimate_size_before_relax (fragP);
2284 break;
2285
220e750f
RH		 2286 case rs_dwarf2dbg:
2287 address += dwarf2dbg_estimate_size_before_relax (fragP);
2288 break;
2289
252b5132
RH		 2290 default:
2291 BAD_CASE (fragP->fr_type);
2292 break;
efaf0ba4
NC		 2293 }
2294 }
252b5132
RH		 2295
2296 /* Do relax(). */
2297 {
efaf0ba4
NC		 2298 long stretch; /* May be any size, 0 or negative. */
2299 /* Cumulative number of addresses we have relaxed this pass.
2300 We may have relaxed more than one address. */
e46d99eb 2301 int stretched; /* Have we stretched on this pass? */
252b5132
RH		 2302 /* This is 'cuz stretch may be zero, when, in fact some piece of code
2303 grew, and another shrank. If a branch instruction doesn't fit anymore,
2304 we could be scrod. */
2305
2306 do
2307 {
e46d99eb
AM		 2308 stretch = 0;
2309 stretched = 0;
58a77e41 2310
252b5132
RH		 2311 for (fragP = segment_frag_root; fragP; fragP = fragP->fr_next)
2312 {
2313 long growth = 0;
2314 addressT was_address;
2315 offsetT offset;
2316 symbolS *symbolP;
2317
38686296 2318 fragP->relax_marker ^= 1;
252b5132
RH		 2319 was_address = fragP->fr_address;
2320 address = fragP->fr_address += stretch;
2321 symbolP = fragP->fr_symbol;
2322 offset = fragP->fr_offset;
2323
2324 switch (fragP->fr_type)
2325 {
efaf0ba4 2326 case rs_fill: /* .fill never relaxes. */
252b5132
RH		 2327 growth = 0;
2328 break;
2329
2330#ifndef WORKING_DOT_WORD
2331 /* JF: This is RMS's idea. I do *NOT* want to be blamed
2332 for it I do not want to write it. I do not want to have
2333 anything to do with it. This is not the proper way to
2334 implement this misfeature. */
2335 case rs_broken_word:
2336 {
2337 struct broken_word *lie;
2338 struct broken_word *untruth;
2339
2340 /* Yes this is ugly (storing the broken_word pointer
2341 in the symbol slot). Still, this whole chunk of
2342 code is ugly, and I don't feel like doing anything
2343 about it. Think of it as stubbornness in action. */
2344 growth = 0;
2345 for (lie = (struct broken_word *) (fragP->fr_symbol);
2346 lie && lie->dispfrag == fragP;
2347 lie = lie->next_broken_word)
2348 {
2349
2350 if (lie->added)
2351 continue;
2352
ac62c346 2353 offset = (S_GET_VALUE (lie->add)
252b5132 2354 + lie->addnum
ac62c346 2355 - S_GET_VALUE (lie->sub));
252b5132
RH		 2356 if (offset <= -32768 || offset >= 32767)
2357 {
2358 if (flag_warn_displacement)
2359 {
2360 char buf[50];
2361 sprint_value (buf, (addressT) lie->addnum);
54d3cad9
AM		 2362 as_warn_where (fragP->fr_file, fragP->fr_line,
2363 _(".word %s-%s+%s didn't fit"),
2364 S_GET_NAME (lie->add),
2365 S_GET_NAME (lie->sub),
2366 buf);
252b5132
RH		 2367 }
2368 lie->added = 1;
2369 if (fragP->fr_subtype == 0)
2370 {
2371 fragP->fr_subtype++;
2372 growth += md_short_jump_size;
2373 }
2374 for (untruth = lie->next_broken_word;
2375 untruth && untruth->dispfrag == lie->dispfrag;
2376 untruth = untruth->next_broken_word)
49309057
ILT		 2377 if ((symbol_get_frag (untruth->add)
2378 == symbol_get_frag (lie->add))
2379 && (S_GET_VALUE (untruth->add)
2380 == S_GET_VALUE (lie->add)))
252b5132
RH		 2381 {
2382 untruth->added = 2;
2383 untruth->use_jump = lie;
2384 }
2385 growth += md_long_jump_size;
2386 }
2387 }
2388
2389 break;
efaf0ba4 2390 } /* case rs_broken_word */
252b5132
RH		 2391#endif
2392 case rs_align:
2393 case rs_align_code:
0a9ef439 2394 case rs_align_test:
252b5132
RH		 2395 {
2396 addressT oldoff, newoff;
2397
2398 oldoff = relax_align (was_address + fragP->fr_fix,
2399 (int) offset);
2400 newoff = relax_align (address + fragP->fr_fix,
2401 (int) offset);
2402
2403 if (fragP->fr_subtype != 0)
2404 {
2405 if (oldoff > fragP->fr_subtype)
2406 oldoff = 0;
2407 if (newoff > fragP->fr_subtype)
2408 newoff = 0;
2409 }
2410
2411 growth = newoff - oldoff;
2412 }
2413 break;
2414
2415 case rs_org:
2416 {
e46d99eb
AM		 2417 addressT target = offset;
2418 addressT after;
252b5132
RH		 2419
2420 if (symbolP)
2421 {
2422#if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER)
2423 know ((S_GET_SEGMENT (symbolP) == SEG_ABSOLUTE)
2424 || (S_GET_SEGMENT (symbolP) == SEG_DATA)
2425 || (S_GET_SEGMENT (symbolP) == SEG_TEXT)
2426 || S_GET_SEGMENT (symbolP) == SEG_BSS);
2427 know (symbolP->sy_frag);
2428 know (!(S_GET_SEGMENT (symbolP) == SEG_ABSOLUTE)
2429 || (symbolP->sy_frag == &zero_address_frag));
2430#endif
ac62c346
AM		 2431 target += S_GET_VALUE (symbolP);
2432 }
252b5132
RH		 2433
2434 know (fragP->fr_next);
2435 after = fragP->fr_next->fr_address;
2436 growth = target - after;
2437 if (growth < 0)
2438 {
2439 /* Growth may be negative, but variable part of frag
2440 cannot have fewer than 0 chars. That is, we can't
efaf0ba4 2441 .org backwards. */
14ad458a
ILT		 2442 as_bad_where (fragP->fr_file, fragP->fr_line,
2443 _("attempt to .org backwards ignored"));
2444
2445 /* We've issued an error message. Change the
2446 frag to avoid cascading errors. */
2447 fragP->fr_type = rs_align;
2448 fragP->fr_subtype = 0;
2449 fragP->fr_offset = 0;
2450 fragP->fr_fix = after - address;
2451 growth = stretch;
252b5132
RH		 2452 }
2453
efaf0ba4
NC		 2454 /* This is an absolute growth factor */
2455 growth -= stretch;
252b5132
RH		 2456 break;
2457 }
2458
2459 case rs_space:
54d3cad9 2460 growth = 0;
252b5132
RH		 2461 if (symbolP)
2462 {
766c03c9
AM		 2463 offsetT amount;
2464
2465 amount = S_GET_VALUE (symbolP);
9e40345d 2466 if (S_GET_SEGMENT (symbolP) != absolute_section
252b5132
RH		 2467 || S_IS_COMMON (symbolP)
2468 || ! S_IS_DEFINED (symbolP))
252b5132 2469 {
54d3cad9
AM		 2470 as_bad_where (fragP->fr_file, fragP->fr_line,
2471 _(".space specifies non-absolute value"));
2472 /* Prevent repeat of this error message. */
2473 fragP->fr_symbol = 0;
2474 }
2475 else if (amount < 0)
2476 {
2477 as_warn_where (fragP->fr_file, fragP->fr_line,
2478 _(".space or .fill with negative value, ignored"));
766c03c9 2479 fragP->fr_symbol = 0;
252b5132 2480 }
54d3cad9
AM		 2481 else
2482 growth = (was_address + amount
2483 - fragP->fr_next->fr_address);
252b5132 2484 }
252b5132
RH		 2485 break;
2486
2487 case rs_machine_dependent:
2488#ifdef md_relax_frag
c842b53a 2489 growth = md_relax_frag (segment, fragP, stretch);
252b5132
RH		 2490#else
2491#ifdef TC_GENERIC_RELAX_TABLE
2492 /* The default way to relax a frag is to look through
2493 TC_GENERIC_RELAX_TABLE. */
c842b53a 2494 growth = relax_frag (segment, fragP, stretch);
efaf0ba4 2495#endif /* TC_GENERIC_RELAX_TABLE */
252b5132
RH		 2496#endif
2497 break;
2498
2499 case rs_leb128:
2500 {
2501 valueT value;
2502 int size;
2503
6386f3a7 2504 value = resolve_symbol_value (fragP->fr_symbol);
252b5132
RH		 2505 size = sizeof_leb128 (value, fragP->fr_subtype);
2506 growth = size - fragP->fr_offset;
2507 fragP->fr_offset = size;
2508 }
2509 break;
2510
2511 case rs_cfa:
2512 growth = eh_frame_relax_frag (fragP);
2513 break;
2514
220e750f
RH		 2515 case rs_dwarf2dbg:
2516 growth = dwarf2dbg_relax_frag (fragP);
2517 break;
2518
252b5132
RH		 2519 default:
2520 BAD_CASE (fragP->fr_type);
2521 break;
2522 }
2523 if (growth)
2524 {
2525 stretch += growth;
e46d99eb 2526 stretched = 1;
252b5132 2527 }
efaf0ba4 2528 } /* For each frag in the segment. */
252b5132 2529 }
efaf0ba4
NC		 2530 while (stretched); /* Until nothing further to relax. */
2531 } /* do_relax */
252b5132 2532
e46d99eb
AM		 2533 ret = 0;
2534 for (fragP = segment_frag_root; fragP; fragP = fragP->fr_next)
2535 if (fragP->last_fr_address != fragP->fr_address)
2536 {
2537 fragP->last_fr_address = fragP->fr_address;
2538 ret = 1;
2539 }
2540 return ret;
efaf0ba4 2541}
252b5132
RH		 2542
2543#if defined (BFD_ASSEMBLER) || (!defined (BFD) && !defined (OBJ_VMS))
2544
2545#ifndef TC_RELOC_RTSYM_LOC_FIXUP
2546#define TC_RELOC_RTSYM_LOC_FIXUP(X) (1)
2547#endif
2548
2549/* fixup_segment()
2550
2551 Go through all the fixS's in a segment and see which ones can be
2552 handled now. (These consist of fixS where we have since discovered
2553 the value of a symbol, or the address of the frag involved.)
2554 For each one, call md_apply_fix to put the fix into the frag data.
2555
2556 Result is a count of how many relocation structs will be needed to
2557 handle the remaining fixS's that we couldn't completely handle here.
2558 These will be output later by emit_relocations(). */
2559
2560static long
2561fixup_segment (fixP, this_segment_type)
2562 register fixS *fixP;
efaf0ba4 2563 segT this_segment_type; /* N_TYPE bits for segment. */
252b5132
RH		 2564{
2565 long seg_reloc_count = 0;
2566 symbolS *add_symbolP;
2567 symbolS *sub_symbolP;
2568 valueT add_number;
2569 int size;
2570 char *place;
2571 long where;
2572 int pcrel, plt;
2573 fragS *fragP;
2574 segT add_symbol_segment = absolute_section;
2575
2576 /* If the linker is doing the relaxing, we must not do any fixups.
2577
2578 Well, strictly speaking that's not true -- we could do any that are
2579 PC-relative and don't cross regions that could change size. And for the
2580 i960 (the only machine for which we've got a relaxing linker right now),
2581 we might be able to turn callx/callj into bal anyways in cases where we
2582 know the maximum displacement. */
58a77e41 2583 if (linkrelax && TC_LINKRELAX_FIXUP (this_segment_type))
252b5132
RH		 2584 {
2585 for (; fixP; fixP = fixP->fx_next)
2586 seg_reloc_count++;
2587 TC_ADJUST_RELOC_COUNT (fixP, seg_reloc_count);
2588 return seg_reloc_count;
2589 }
2590
2591 for (; fixP; fixP = fixP->fx_next)
2592 {
252b5132
RH		 2593#ifdef DEBUG5
2594 fprintf (stderr, "\nprocessing fixup:\n");
2595 print_fixup (fixP);
2596#endif
2597
252b5132
RH		 2598 fragP = fixP->fx_frag;
2599 know (fragP);
2600 where = fixP->fx_where;
2601 place = fragP->fr_literal + where;
2602 size = fixP->fx_size;
2603 add_symbolP = fixP->fx_addsy;
2604#ifdef TC_VALIDATE_FIX
2605 TC_VALIDATE_FIX (fixP, this_segment_type, skip);
2606#endif
2607 sub_symbolP = fixP->fx_subsy;
2608 add_number = fixP->fx_offset;
2609 pcrel = fixP->fx_pcrel;
2610 plt = fixP->fx_plt;
2611
2612 if (add_symbolP != NULL
49309057 2613 && symbol_mri_common_p (add_symbolP))
252b5132
RH		 2614 {
2615 know (add_symbolP->sy_value.X_op == O_symbol);
2616 add_number += S_GET_VALUE (add_symbolP);
2617 fixP->fx_offset = add_number;
49309057
ILT		 2618 add_symbolP = fixP->fx_addsy =
2619 symbol_get_value_expression (add_symbolP)->X_add_symbol;
252b5132
RH		 2620 }
2621
2622 if (add_symbolP)
2623 add_symbol_segment = S_GET_SEGMENT (add_symbolP);
2624
2625 if (sub_symbolP)
2626 {
6386f3a7 2627 resolve_symbol_value (sub_symbolP);
252b5132
RH		 2628 if (add_symbolP == NULL || add_symbol_segment == absolute_section)
2629 {
2630 if (add_symbolP != NULL)
2631 {
2632 add_number += S_GET_VALUE (add_symbolP);
2633 add_symbolP = NULL;
2634 fixP->fx_addsy = NULL;
2635 }
2636
efaf0ba4 2637 /* It's just -sym. */
252b5132
RH		 2638 if (S_GET_SEGMENT (sub_symbolP) == absolute_section)
2639 {
2640 add_number -= S_GET_VALUE (sub_symbolP);
2641 fixP->fx_subsy = NULL;
2642 }
2643 else if (pcrel
2644 && S_GET_SEGMENT (sub_symbolP) == this_segment_type)
2645 {
2646 /* Should try converting to a constant. */
2647 goto bad_sub_reloc;
2648 }
2649 else
2650 bad_sub_reloc:
2651 as_bad_where (fixP->fx_file, fixP->fx_line,
2652 _("Negative of non-absolute symbol %s"),
2653 S_GET_NAME (sub_symbolP));
2654 }
2655 else if (S_GET_SEGMENT (sub_symbolP) == add_symbol_segment
2656 && SEG_NORMAL (add_symbol_segment))
2657 {
2658 /* Difference of 2 symbols from same segment.
2659 Can't make difference of 2 undefineds: 'value' means
efaf0ba4 2660 something different for N_UNDF. */
252b5132
RH		 2661#ifdef TC_I960
2662 /* Makes no sense to use the difference of 2 arbitrary symbols
2663 as the target of a call instruction. */
2664 if (fixP->fx_tcbit)
2665 as_bad_where (fixP->fx_file, fixP->fx_line,
2666 _("callj to difference of 2 symbols"));
efaf0ba4 2667#endif /* TC_I960 */
d48019e0
AM		 2668 add_number += (S_GET_VALUE (add_symbolP)
2669 - S_GET_VALUE (sub_symbolP));
1a16aca4
AM		 2670 if (1
2671#ifdef TC_M68K
2672 /* See the comment below about 68k weirdness. */
2673 && 0
2674#endif
2675 && pcrel)
d48019e0 2676 add_number -= MD_PCREL_FROM_SECTION (fixP, this_segment_type);
252b5132
RH		 2677
2678 add_symbolP = NULL;
efaf0ba4 2679 pcrel = 0; /* No further pcrel processing. */
252b5132
RH		 2680
2681 /* Let the target machine make the final determination
2682 as to whether or not a relocation will be needed to
2683 handle this fixup. */
2684 if (!TC_FORCE_RELOCATION_SECTION (fixP, this_segment_type))
2685 {
2686 fixP->fx_pcrel = 0;
2687 fixP->fx_addsy = NULL;
2688 fixP->fx_subsy = NULL;
2689 }
2690 }
2691 else
2692 {
efaf0ba4 2693 /* Different segments in subtraction. */
252b5132
RH		 2694 know (!(S_IS_EXTERNAL (sub_symbolP)
2695 && (S_GET_SEGMENT (sub_symbolP) == absolute_section)));
2696
2697 if ((S_GET_SEGMENT (sub_symbolP) == absolute_section))
2698 add_number -= S_GET_VALUE (sub_symbolP);
2699
2700#ifdef DIFF_EXPR_OK
1a16aca4 2701 else if (S_GET_SEGMENT (sub_symbolP) == this_segment_type)
252b5132
RH		 2702 {
2703 /* Make it pc-relative. */
1a16aca4
AM		 2704 if (0
2705#ifdef TC_M68K
2706 /* Do this for m68k even if it's already described
2707 as pc-relative. On the m68k, an operand of
2708 "pc@(foo-.-2)" should address "foo" in a
2709 pc-relative mode. */
2710 || 1
2711#endif
2712 || !pcrel)
2713 {
2714 add_number += MD_PCREL_FROM_SECTION (fixP,
2715 this_segment_type);
2716 pcrel = 1;
2717 fixP->fx_pcrel = 1;
2718 }
2719
2720 add_number -= S_GET_VALUE (sub_symbolP);
252b5132
RH		 2721 sub_symbolP = 0;
2722 fixP->fx_subsy = 0;
2723 }
2724#endif
2725#ifdef UNDEFINED_DIFFERENCE_OK
2726 /* The PA needs this for PIC code generation. We basically
2727 don't want to do anything if we have the difference of two
2728 symbols at this point. */
2729 else if (1)
2730 {
2731 /* Leave it alone. */
2732 }
2733#endif
2734#ifdef BFD_ASSEMBLER
2735 else if (fixP->fx_r_type == BFD_RELOC_GPREL32
2736 || fixP->fx_r_type == BFD_RELOC_GPREL16)
2737 {
2738 /* Leave it alone. */
2739 }
2740#endif
2741 else
2742 {
2743 char buf[50];
2744 sprint_value (buf, fragP->fr_address + where);
2745 as_bad_where (fixP->fx_file, fixP->fx_line,
2746 _("Subtraction of two symbols in different sections \"%s\" {%s section} - \"%s\" {%s section} at file address %s."),
2747 S_GET_NAME (add_symbolP),
2748 segment_name (S_GET_SEGMENT (add_symbolP)),
2749 S_GET_NAME (sub_symbolP),
2750 segment_name (S_GET_SEGMENT (sub_symbolP)),
2751 buf);
2752 }
2753 }
2754 }
2755
2756 if (add_symbolP)
2757 {
2758 if (add_symbol_segment == this_segment_type && pcrel && !plt
2759 && TC_RELOC_RTSYM_LOC_FIXUP (fixP))
2760 {
efaf0ba4
NC		 2761 /* This fixup was made when the symbol's segment was
2762 SEG_UNKNOWN, but it is now in the local segment.
2763 So we know how to do the address without relocation. */
252b5132
RH		 2764#ifdef TC_I960
2765 /* reloc_callj() may replace a 'call' with a 'calls' or a
2766 'bal', in which cases it modifies *fixP as appropriate.
2767 In the case of a 'calls', no further work is required,
2768 and *fixP has been set up to make the rest of the code
efaf0ba4 2769 below a no-op. */
252b5132 2770 reloc_callj (fixP);
efaf0ba4 2771#endif /* TC_I960 */
252b5132
RH		 2772
2773 add_number += S_GET_VALUE (add_symbolP);
2774 add_number -= MD_PCREL_FROM_SECTION (fixP, this_segment_type);
efaf0ba4
NC		 2775 /* Lie. Don't want further pcrel processing. */
2776 pcrel = 0;
252b5132
RH		 2777
2778 /* Let the target machine make the final determination
2779 as to whether or not a relocation will be needed to
2780 handle this fixup. */
2781 if (!TC_FORCE_RELOCATION (fixP))
2782 {
2783 fixP->fx_pcrel = 0;
2784 fixP->fx_addsy = NULL;
2785 }
2786 }
2787 else
2788 {
2789 if (add_symbol_segment == absolute_section
2790 && ! pcrel)
2791 {
2792#ifdef TC_I960
2793 /* See comment about reloc_callj() above. */
2794 reloc_callj (fixP);
efaf0ba4 2795#endif /* TC_I960 */
252b5132
RH		 2796 add_number += S_GET_VALUE (add_symbolP);
2797
2798 /* Let the target machine make the final determination
2799 as to whether or not a relocation will be needed to
2800 handle this fixup. */
2801
2802 if (!TC_FORCE_RELOCATION (fixP))
2803 {
2804 fixP->fx_addsy = NULL;
2805 add_symbolP = NULL;
2806 }
2807 }
2808 else if (add_symbol_segment == undefined_section
2809#ifdef BFD_ASSEMBLER
2810 || bfd_is_com_section (add_symbol_segment)
2811#endif
2812 )
2813 {
2814#ifdef TC_I960
2815 if ((int) fixP->fx_bit_fixP == 13)
2816 {
2817 /* This is a COBR instruction. They have only a
efaf0ba4
NC		 2818 13-bit displacement and are only to be used
2819 for local branches: flag as error, don't generate
2820 relocation. */
252b5132
RH		 2821 as_bad_where (fixP->fx_file, fixP->fx_line,
2822 _("can't use COBR format with external label"));
2823 fixP->fx_addsy = NULL;
2824 fixP->fx_done = 1;
2825 continue;
efaf0ba4
NC		 2826 } /* COBR. */
2827#endif /* TC_I960 */
252b5132
RH		 2828
2829#ifdef OBJ_COFF
2830#ifdef TE_I386AIX
2831 if (S_IS_COMMON (add_symbolP))
2832 add_number += S_GET_VALUE (add_symbolP);
efaf0ba4
NC		 2833#endif /* TE_I386AIX */
2834#endif /* OBJ_COFF */
252b5132
RH		 2835 ++seg_reloc_count;
2836 }
2837 else
2838 {
2839 seg_reloc_count++;
8f36cd18 2840 if (TC_FIX_ADJUSTABLE (fixP))
02198638 2841 add_number += S_GET_VALUE (add_symbolP);
252b5132
RH		 2842 }
2843 }
2844 }
2845
2846 if (pcrel)
2847 {
2848 add_number -= MD_PCREL_FROM_SECTION (fixP, this_segment_type);
2849 if (add_symbolP == 0)
2850 {
2851#ifndef BFD_ASSEMBLER
2852 fixP->fx_addsy = &abs_symbol;
2853#else
2854 fixP->fx_addsy = section_symbol (absolute_section);
2855#endif
49309057 2856 symbol_mark_used_in_reloc (fixP->fx_addsy);
252b5132
RH		 2857 ++seg_reloc_count;
2858 }
2859 }
2860
6d4d30bb
AM		 2861 if (!fixP->fx_done)
2862 {
2863#ifdef MD_APPLY_FIX3
2864 md_apply_fix3 (fixP, &add_number, this_segment_type);
2865#else
2866#ifdef BFD_ASSEMBLER
2867 md_apply_fix (fixP, &add_number);
2868#else
2869 md_apply_fix (fixP, add_number);
2870#endif
2871#endif
2872
2873#ifndef TC_HANDLES_FX_DONE
2874 /* If the tc-* files haven't been converted, assume it's handling
2875 it the old way, where a null fx_addsy means that the fix has
2876 been applied completely, and no further work is needed. */
2877 if (fixP->fx_addsy == 0 && fixP->fx_pcrel == 0)
2878 fixP->fx_done = 1;
2879#endif
2880 }
2881
252b5132
RH		 2882 if (!fixP->fx_bit_fixP && !fixP->fx_no_overflow && size > 0)
2883 {
2884 if ((size_t) size < sizeof (valueT))
2885 {
b77ad1d4 2886 valueT mask;
252b5132 2887
252b5132 2888 mask = 0;
efaf0ba4 2889 mask--; /* Set all bits to one. */
b77ad1d4
AM		 2890 mask <<= size * 8 - (fixP->fx_signed ? 1 : 0);
2891 if ((add_number & mask) != 0 && (add_number & mask) != mask)
252b5132
RH		 2892 {
2893 char buf[50], buf2[50];
2894 sprint_value (buf, fragP->fr_address + where);
2895 if (add_number > 1000)
2896 sprint_value (buf2, add_number);
2897 else
2898 sprintf (buf2, "%ld", (long) add_number);
2899 as_bad_where (fixP->fx_file, fixP->fx_line,
2900 _("Value of %s too large for field of %d bytes at %s"),
2901 buf2, size, buf);
efaf0ba4 2902 } /* Generic error checking. */
252b5132
RH		 2903 }
2904#ifdef WARN_SIGNED_OVERFLOW_WORD
2905 /* Warn if a .word value is too large when treated as a signed
2906 number. We already know it is not too negative. This is to
2907 catch over-large switches generated by gcc on the 68k. */
2908 if (!flag_signed_overflow_ok
2909 && size == 2
2910 && add_number > 0x7fff)
2911 as_bad_where (fixP->fx_file, fixP->fx_line,
2912 _("Signed .word overflow; switch may be too large; %ld at 0x%lx"),
2913 (long) add_number,
2914 (unsigned long) (fragP->fr_address + where));
2915#endif
efaf0ba4 2916 } /* Not a bit fix. */
252b5132 2917
252b5132 2918#ifdef TC_VALIDATE_FIX
ab9da554
ILT		 2919 skip: ATTRIBUTE_UNUSED_LABEL
2920 ;
252b5132
RH		 2921#endif
2922#ifdef DEBUG5
2923 fprintf (stderr, "result:\n");
2924 print_fixup (fixP);
2925#endif
efaf0ba4 2926 } /* For each fixS in this segment. */
252b5132
RH		 2927
2928 TC_ADJUST_RELOC_COUNT (fixP, seg_reloc_count);
2929 return seg_reloc_count;
2930}
2931
2932#endif /* defined (BFD_ASSEMBLER) || (!defined (BFD) && !defined (OBJ_VMS)) */
2933
2934void
2935number_to_chars_bigendian (buf, val, n)
2936 char *buf;
2937 valueT val;
2938 int n;
2939{
2940 if ((size_t) n > sizeof (val) || n <= 0)
2941 abort ();
2942 while (n--)
2943 {
2944 buf[n] = val & 0xff;
2945 val >>= 8;
2946 }
2947}
2948
2949void
2950number_to_chars_littleendian (buf, val, n)
2951 char *buf;
2952 valueT val;
2953 int n;
2954{
2955 if ((size_t) n > sizeof (val) || n <= 0)
2956 abort ();
2957 while (n--)
2958 {
2959 *buf++ = val & 0xff;
2960 val >>= 8;
2961 }
2962}
2963
2964void
2965write_print_statistics (file)
2966 FILE *file;
2967{
6d4d30bb 2968 fprintf (file, "fixups: %d\n", n_fixups);
252b5132
RH		 2969}
2970
efaf0ba4 2971/* For debugging. */
252b5132
RH		 2972extern int indent_level;
2973
2974void
2975print_fixup (fixp)
2976 fixS *fixp;
2977{
2978 indent_level = 1;
2979 fprintf (stderr, "fix %lx %s:%d", (long) fixp, fixp->fx_file, fixp->fx_line);
2980 if (fixp->fx_pcrel)
2981 fprintf (stderr, " pcrel");
2982 if (fixp->fx_pcrel_adjust)
2983 fprintf (stderr, " pcrel_adjust=%d", fixp->fx_pcrel_adjust);
2984 if (fixp->fx_im_disp)
2985 {
2986#ifdef TC_NS32K
2987 fprintf (stderr, " im_disp=%d", fixp->fx_im_disp);
2988#else
2989 fprintf (stderr, " im_disp");
2990#endif
2991 }
2992 if (fixp->fx_tcbit)
2993 fprintf (stderr, " tcbit");
2994 if (fixp->fx_done)
2995 fprintf (stderr, " done");
2996 fprintf (stderr, "\n size=%d frag=%lx where=%ld offset=%lx addnumber=%lx",
2997 fixp->fx_size, (long) fixp->fx_frag, (long) fixp->fx_where,
2998 (long) fixp->fx_offset, (long) fixp->fx_addnumber);
2999#ifdef BFD_ASSEMBLER
3000 fprintf (stderr, "\n %s (%d)", bfd_get_reloc_code_name (fixp->fx_r_type),
3001 fixp->fx_r_type);
3002#else
3003#ifdef NEED_FX_R_TYPE
3004 fprintf (stderr, " r_type=%d", fixp->fx_r_type);
3005#endif
3006#endif
3007 if (fixp->fx_addsy)
3008 {
3009 fprintf (stderr, "\n +<");
3010 print_symbol_value_1 (stderr, fixp->fx_addsy);
3011 fprintf (stderr, ">");
3012 }
3013 if (fixp->fx_subsy)
3014 {
3015 fprintf (stderr, "\n -<");
3016 print_symbol_value_1 (stderr, fixp->fx_subsy);
3017 fprintf (stderr, ">");
3018 }
3019 fprintf (stderr, "\n");
3020#ifdef TC_FIX_DATA_PRINT
3021 TC_FIX_DATA_PRINT (stderr, fixp);
3022#endif
3023}
GDB Binutils - Deliverables
This page took 0.247619 seconds and 4 git commands to generate.