projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
* config/tc-hppa.c (pa_parse_nonneg_cmpsub_cmpltr): Remove
[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
RH		 1752 to_addr = table_addr - S_GET_VALUE (lie->sub);
1753#ifdef BFD_ASSEMBLER
49309057 1754 to_addr -= symbol_get_frag (lie->sub)->fr_address;
753f6b12
HPN		 1755#endif
1756#ifdef TC_CHECK_ADJUSTED_BROKEN_DOT_WORD
1757 TC_CHECK_ADJUSTED_BROKEN_DOT_WORD (to_addr, lie);
252b5132
RH		 1758#endif
1759 md_number_to_chars (lie->word_goes_here, to_addr, 2);
efaf0ba4
NC		 1760 for (untruth = lie->next_broken_word;
1761 untruth && untruth->dispfrag == fragP;
1762 untruth = untruth->next_broken_word)
252b5132
RH		 1763 {
1764 if (untruth->use_jump == lie)
1765 md_number_to_chars (untruth->word_goes_here, to_addr, 2);
1766 }
1767
efaf0ba4
NC		 1768 /* Install the long jump. */
1769 /* This is a long jump from table_ptr+0 to the final target. */
252b5132
RH		 1770 from_addr = table_addr;
1771 to_addr = S_GET_VALUE (lie->add) + lie->addnum;
1772#ifdef BFD_ASSEMBLER
49309057 1773 to_addr += symbol_get_frag (lie->add)->fr_address;
252b5132 1774#endif
efaf0ba4
NC		 1775 md_create_long_jump (table_ptr, from_addr, to_addr, lie->dispfrag,
1776 lie->add);
252b5132
RH		 1777 table_ptr += md_long_jump_size;
1778 table_addr += md_long_jump_size;
1779 }
1780 }
1781 }
efaf0ba4 1782#endif /* not WORKING_DOT_WORD */
252b5132
RH		 1783
1784#ifndef BFD_ASSEMBLER
1785#ifndef OBJ_VMS
efaf0ba4 1786 { /* not vms */
252b5132
RH		 1787 char *the_object_file;
1788 long object_file_size;
efaf0ba4
NC		 1789 /* Scan every FixS performing fixups. We had to wait until now to
1790 do this because md_convert_frag() may have made some fixSs. */
252b5132
RH		 1791 int trsize, drsize;
1792
1793 subseg_change (SEG_TEXT, 0);
1794 trsize = md_reloc_size * fixup_segment (text_fix_root, SEG_TEXT);
1795 subseg_change (SEG_DATA, 0);
1796 drsize = md_reloc_size * fixup_segment (data_fix_root, SEG_DATA);
1797 H_SET_RELOCATION_SIZE (&headers, trsize, drsize);
1798
efaf0ba4 1799 /* FIXME: Move this stuff into the pre-write-hook. */
252b5132
RH		 1800 H_SET_MAGIC_NUMBER (&headers, magic_number_for_object_file);
1801 H_SET_ENTRY_POINT (&headers, 0);
1802
efaf0ba4 1803 obj_pre_write_hook (&headers); /* Extra coff stuff. */
252b5132
RH		 1804
1805 object_file_size = H_GET_FILE_SIZE (&headers);
1806 next_object_file_charP = the_object_file = xmalloc (object_file_size);
1807
1808 output_file_create (out_file_name);
1809
1810 obj_header_append (&next_object_file_charP, &headers);
1811
efaf0ba4
NC		 1812 know ((next_object_file_charP - the_object_file)
1813 == H_GET_HEADER_SIZE (&headers));
252b5132 1814
efaf0ba4 1815 /* Emit code. */
252b5132
RH		 1816 for (fragP = text_frag_root; fragP; fragP = fragP->fr_next)
1817 {
1818 register long count;
1819 register char *fill_literal;
1820 register long fill_size;
1821
1822 PROGRESS (1);
1823 know (fragP->fr_type == rs_fill);
efaf0ba4
NC		 1824 append (&next_object_file_charP, fragP->fr_literal,
1825 (unsigned long) fragP->fr_fix);
252b5132
RH		 1826 fill_literal = fragP->fr_literal + fragP->fr_fix;
1827 fill_size = fragP->fr_var;
1828 know (fragP->fr_offset >= 0);
1829
1830 for (count = fragP->fr_offset; count; count--)
efaf0ba4
NC		 1831 append (&next_object_file_charP, fill_literal,
1832 (unsigned long) fill_size);
1833 }
252b5132 1834
efaf0ba4
NC		 1835 know ((next_object_file_charP - the_object_file)
1836 == (H_GET_HEADER_SIZE (&headers)
1837 + H_GET_TEXT_SIZE (&headers)
1838 + H_GET_DATA_SIZE (&headers)));
1839
1840 /* Emit relocations. */
1841 obj_emit_relocations (&next_object_file_charP, text_fix_root,
1842 (relax_addressT) 0);
1843 know ((next_object_file_charP - the_object_file)
1844 == (H_GET_HEADER_SIZE (&headers)
1845 + H_GET_TEXT_SIZE (&headers)
1846 + H_GET_DATA_SIZE (&headers)
1847 + H_GET_TEXT_RELOCATION_SIZE (&headers)));
252b5132
RH		 1848#ifdef TC_I960
1849 /* Make addresses in data relocation directives relative to beginning of
efaf0ba4
NC		 1850 first data fragment, not end of last text fragment: alignment of the
1851 start of the data segment may place a gap between the segments. */
1852 obj_emit_relocations (&next_object_file_charP, data_fix_root,
1853 data0_frchainP->frch_root->fr_address);
1854#else /* TC_I960 */
1855 obj_emit_relocations (&next_object_file_charP, data_fix_root,
1856 text_last_frag->fr_address);
1857#endif /* TC_I960 */
1858
1859 know ((next_object_file_charP - the_object_file)
1860 == (H_GET_HEADER_SIZE (&headers)
1861 + H_GET_TEXT_SIZE (&headers)
1862 + H_GET_DATA_SIZE (&headers)
1863 + H_GET_TEXT_RELOCATION_SIZE (&headers)
1864 + H_GET_DATA_RELOCATION_SIZE (&headers)));
1865
1866 /* Emit line number entries. */
252b5132 1867 OBJ_EMIT_LINENO (&next_object_file_charP, lineno_rootP, the_object_file);
efaf0ba4
NC		 1868 know ((next_object_file_charP - the_object_file)
1869 == (H_GET_HEADER_SIZE (&headers)
1870 + H_GET_TEXT_SIZE (&headers)
1871 + H_GET_DATA_SIZE (&headers)
1872 + H_GET_TEXT_RELOCATION_SIZE (&headers)
1873 + H_GET_DATA_RELOCATION_SIZE (&headers)
1874 + H_GET_LINENO_SIZE (&headers)));
1875
1876 /* Emit symbols. */
252b5132 1877 obj_emit_symbols (&next_object_file_charP, symbol_rootP);
efaf0ba4
NC		 1878 know ((next_object_file_charP - the_object_file)
1879 == (H_GET_HEADER_SIZE (&headers)
1880 + H_GET_TEXT_SIZE (&headers)
1881 + H_GET_DATA_SIZE (&headers)
1882 + H_GET_TEXT_RELOCATION_SIZE (&headers)
1883 + H_GET_DATA_RELOCATION_SIZE (&headers)
1884 + H_GET_LINENO_SIZE (&headers)
1885 + H_GET_SYMBOL_TABLE_SIZE (&headers)));
1886
1887 /* Emit strings. */
252b5132 1888 if (string_byte_count > 0)
efaf0ba4 1889 obj_emit_strings (&next_object_file_charP);
252b5132
RH		 1890
1891#ifdef BFD_HEADERS
1892 bfd_seek (stdoutput, 0, 0);
1893 bfd_write (the_object_file, 1, object_file_size, stdoutput);
1894#else
1895
efaf0ba4 1896 /* Write the data to the file. */
252b5132
RH		 1897 output_file_append (the_object_file, object_file_size, out_file_name);
1898 free (the_object_file);
1899#endif
efaf0ba4
NC		 1900 }
1901#else /* OBJ_VMS */
1902 /* Now do the VMS-dependent part of writing the object file. */
252b5132
RH		 1903 vms_write_object_file (H_GET_TEXT_SIZE (&headers),
1904 H_GET_DATA_SIZE (&headers),
1905 H_GET_BSS_SIZE (&headers),
1906 text_frag_root, data_frag_root);
efaf0ba4
NC		 1907#endif /* OBJ_VMS */
1908#else /* BFD_ASSEMBLER */
252b5132
RH		 1909
1910 /* Resolve symbol values. This needs to be done before processing
1911 the relocations. */
1912 if (symbol_rootP)
1913 {
1914 symbolS *symp;
1915
1916 for (symp = symbol_rootP; symp; symp = symbol_next (symp))
6386f3a7 1917 resolve_symbol_value (symp);
252b5132 1918 }
49309057 1919 resolve_local_symbol_values ();
252b5132
RH		 1920
1921 PROGRESS (1);
1922
1923#ifdef tc_frob_file_before_adjust
1924 tc_frob_file_before_adjust ();
1925#endif
1926#ifdef obj_frob_file_before_adjust
1927 obj_frob_file_before_adjust ();
1928#endif
1929
efaf0ba4 1930 bfd_map_over_sections (stdoutput, adjust_reloc_syms, (char *) 0);
252b5132
RH		 1931
1932 /* Set up symbol table, and write it out. */
1933 if (symbol_rootP)
1934 {
1935 symbolS *symp;
1936
1937 for (symp = symbol_rootP; symp; symp = symbol_next (symp))
1938 {
1939 int punt = 0;
1940 const char *name;
1941
49309057 1942 if (symbol_mri_common_p (symp))
252b5132
RH		 1943 {
1944 if (S_IS_EXTERNAL (symp))
1945 as_bad (_("%s: global symbols not supported in common sections"),
1946 S_GET_NAME (symp));
1947 symbol_remove (symp, &symbol_rootP, &symbol_lastP);
1948 continue;
1949 }
1950
1951 name = S_GET_NAME (symp);
1952 if (name)
1953 {
efaf0ba4
NC		 1954 const char *name2 =
1955 decode_local_label_name ((char *) S_GET_NAME (symp));
252b5132
RH		 1956 /* They only differ if `name' is a fb or dollar local
1957 label name. */
1958 if (name2 != name && ! S_IS_DEFINED (symp))
1959 as_bad (_("local label %s is not defined"), name2);
1960 }
1961
1962 /* Do it again, because adjust_reloc_syms might introduce
1963 more symbols. They'll probably only be section symbols,
1964 but they'll still need to have the values computed. */
6386f3a7 1965 resolve_symbol_value (symp);
252b5132
RH		 1966
1967 /* Skip symbols which were equated to undefined or common
1968 symbols. */
49309057 1969 if (symbol_equated_p (symp)
252b5132
RH		 1970 && (! S_IS_DEFINED (symp) || S_IS_COMMON (symp)))
1971 {
1972 symbol_remove (symp, &symbol_rootP, &symbol_lastP);
1973 continue;
1974 }
1975
1976 /* So far, common symbols have been treated like undefined symbols.
1977 Put them in the common section now. */
1978 if (S_IS_DEFINED (symp) == 0
1979 && S_GET_VALUE (symp) != 0)
1980 S_SET_SEGMENT (symp, bfd_com_section_ptr);
1981#if 0
1982 printf ("symbol `%s'\n\t@%x: value=%d flags=%x seg=%s\n",
1983 S_GET_NAME (symp), symp,
1984 S_GET_VALUE (symp),
49309057
ILT		 1985 symbol_get_bfdsym (symp)->flags,
1986 segment_name (S_GET_SEGMENT (symp)));
252b5132
RH		 1987#endif
1988
1989#ifdef obj_frob_symbol
1990 obj_frob_symbol (symp, punt);
1991#endif
1992#ifdef tc_frob_symbol
49309057 1993 if (! punt || symbol_used_in_reloc_p (symp))
252b5132
RH		 1994 tc_frob_symbol (symp, punt);
1995#endif
1996
1997 /* If we don't want to keep this symbol, splice it out of
1998 the chain now. If EMIT_SECTION_SYMBOLS is 0, we never
1999 want section symbols. Otherwise, we skip local symbols
2000 and symbols that the frob_symbol macros told us to punt,
2001 but we keep such symbols if they are used in relocs. */
2002 if ((! EMIT_SECTION_SYMBOLS
49309057 2003 && symbol_section_p (symp))
252b5132
RH		 2004 /* Note that S_IS_EXTERN and S_IS_LOCAL are not always
2005 opposites. Sometimes the former checks flags and the
2006 latter examines the name... */
2007 || (!S_IS_EXTERN (symp)
2008 && (S_IS_LOCAL (symp) || punt)
49309057 2009 && ! symbol_used_in_reloc_p (symp)))
252b5132
RH		 2010 {
2011 symbol_remove (symp, &symbol_rootP, &symbol_lastP);
efaf0ba4 2012
252b5132
RH		 2013 /* After symbol_remove, symbol_next(symp) still returns
2014 the one that came after it in the chain. So we don't
2015 need to do any extra cleanup work here. */
252b5132
RH		 2016 continue;
2017 }
2018
2019 /* Make sure we really got a value for the symbol. */
49309057 2020 if (! symbol_resolved_p (symp))
252b5132
RH		 2021 {
2022 as_bad (_("can't resolve value for symbol \"%s\""),
2023 S_GET_NAME (symp));
49309057 2024 symbol_mark_resolved (symp);
252b5132
RH		 2025 }
2026
2027 /* Set the value into the BFD symbol. Up til now the value
2028 has only been kept in the gas symbolS struct. */
49309057 2029 symbol_get_bfdsym (symp)->value = S_GET_VALUE (symp);
252b5132
RH		 2030 }
2031 }
2032
2033 PROGRESS (1);
2034
2035 /* Now do any format-specific adjustments to the symbol table, such
2036 as adding file symbols. */
2037#ifdef tc_adjust_symtab
2038 tc_adjust_symtab ();
2039#endif
2040#ifdef obj_adjust_symtab
2041 obj_adjust_symtab ();
2042#endif
2043
2044 /* Now that all the sizes are known, and contents correct, we can
2045 start writing to the file. */
2046 set_symtab ();
2047
2048 /* If *_frob_file changes the symbol value at this point, it is
2049 responsible for moving the changed value into symp->bsym->value
2050 as well. Hopefully all symbol value changing can be done in
2051 *_frob_symbol. */
2052#ifdef tc_frob_file
2053 tc_frob_file ();
2054#endif
2055#ifdef obj_frob_file
2056 obj_frob_file ();
2057#endif
2058
2059 bfd_map_over_sections (stdoutput, write_relocs, (char *) 0);
2060
2061#ifdef tc_frob_file_after_relocs
2062 tc_frob_file_after_relocs ();
2063#endif
2064#ifdef obj_frob_file_after_relocs
2065 obj_frob_file_after_relocs ();
2066#endif
2067
2068 bfd_map_over_sections (stdoutput, write_contents, (char *) 0);
efaf0ba4 2069#endif /* BFD_ASSEMBLER */
252b5132 2070}
efaf0ba4 2071#endif /* ! BFD */
252b5132
RH		 2072
2073#ifdef TC_GENERIC_RELAX_TABLE
2074
252b5132
RH		 2075/* Relax a fragment by scanning TC_GENERIC_RELAX_TABLE. */
2076
2077long
c842b53a
ILT		 2078relax_frag (segment, fragP, stretch)
2079 segT segment;
252b5132
RH		 2080 fragS *fragP;
2081 long stretch;
2082{
2083 const relax_typeS *this_type;
2084 const relax_typeS *start_type;
2085 relax_substateT next_state;
2086 relax_substateT this_state;
38686296
AM		 2087 long growth;
2088 offsetT aim;
2089 addressT target;
2090 addressT address;
2091 symbolS *symbolP;
2092 const relax_typeS *table;
2093
2094 target = fragP->fr_offset;
2095 address = fragP->fr_address;
2096 table = TC_GENERIC_RELAX_TABLE;
252b5132
RH		 2097 this_state = fragP->fr_subtype;
2098 start_type = this_type = table + this_state;
38686296 2099 symbolP = fragP->fr_symbol;
252b5132
RH		 2100
2101 if (symbolP)
2102 {
c842b53a
ILT		 2103 fragS *sym_frag;
2104
2105 sym_frag = symbol_get_frag (symbolP);
2106
252b5132
RH		 2107#ifndef DIFF_EXPR_OK
2108#if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER)
2109 know ((S_GET_SEGMENT (symbolP) == SEG_ABSOLUTE)
2110 || (S_GET_SEGMENT (symbolP) == SEG_DATA)
2111 || (S_GET_SEGMENT (symbolP) == SEG_BSS)
2112 || (S_GET_SEGMENT (symbolP) == SEG_TEXT));
2113#endif
c842b53a 2114 know (sym_frag != NULL);
252b5132
RH		 2115#endif
2116 know (!(S_GET_SEGMENT (symbolP) == absolute_section)
c842b53a
ILT		 2117 || sym_frag == &zero_address_frag);
2118 target += S_GET_VALUE (symbolP) + sym_frag->fr_address;
252b5132
RH		 2119
2120 /* If frag has yet to be reached on this pass,
2121 assume it will move by STRETCH just as we did.
2122 If this is not so, it will be because some frag
38686296 2123 between grows, and that will force another pass. */
252b5132 2124
c842b53a 2125 if (stretch != 0
38686296
AM		 2126 && sym_frag->relax_marker != fragP->relax_marker
2127 && S_GET_SEGMENT (symbolP) == segment)
252b5132
RH		 2128 {
2129 target += stretch;
2130 }
2131 }
2132
2133 aim = target - address - fragP->fr_fix;
2134#ifdef TC_PCREL_ADJUST
efaf0ba4
NC		 2135 /* Currently only the ns32k family needs this. */
2136 aim += TC_PCREL_ADJUST (fragP);
2137/* #else */
252b5132
RH		 2138 /* This machine doesn't want to use pcrel_adjust.
2139 In that case, pcrel_adjust should be zero. */
efaf0ba4
NC		 2140#if 0
2141 assert (fragP->fr_targ.ns32k.pcrel_adjust == 0);
252b5132 2142#endif
efaf0ba4
NC		 2143#endif
2144#ifdef md_prepare_relax_scan /* formerly called M68K_AIM_KLUDGE */
252b5132
RH		 2145 md_prepare_relax_scan (fragP, address, aim, this_state, this_type);
2146#endif
2147
2148 if (aim < 0)
2149 {
efaf0ba4 2150 /* Look backwards. */
252b5132
RH		 2151 for (next_state = this_type->rlx_more; next_state;)
2152 if (aim >= this_type->rlx_backward)
2153 next_state = 0;
2154 else
2155 {
efaf0ba4 2156 /* Grow to next state. */
252b5132
RH		 2157 this_state = next_state;
2158 this_type = table + this_state;
2159 next_state = this_type->rlx_more;
2160 }
2161 }
2162 else
2163 {
efaf0ba4 2164 /* Look forwards. */
252b5132
RH		 2165 for (next_state = this_type->rlx_more; next_state;)
2166 if (aim <= this_type->rlx_forward)
2167 next_state = 0;
2168 else
2169 {
efaf0ba4 2170 /* Grow to next state. */
252b5132
RH		 2171 this_state = next_state;
2172 this_type = table + this_state;
2173 next_state = this_type->rlx_more;
2174 }
2175 }
2176
2177 growth = this_type->rlx_length - start_type->rlx_length;
2178 if (growth != 0)
2179 fragP->fr_subtype = this_state;
2180 return growth;
2181}
2182
efaf0ba4 2183#endif /* defined (TC_GENERIC_RELAX_TABLE) */
252b5132
RH		 2184
2185/* Relax_align. Advance location counter to next address that has 'alignment'
2186 lowest order bits all 0s, return size of adjustment made. */
2187static relax_addressT
2188relax_align (address, alignment)
efaf0ba4
NC		 2189 register relax_addressT address; /* Address now. */
2190 register int alignment; /* Alignment (binary). */
252b5132
RH		 2191{
2192 relax_addressT mask;
2193 relax_addressT new_address;
2194
2195 mask = ~((~0) << alignment);
2196 new_address = (address + mask) & (~mask);
2197#ifdef LINKER_RELAXING_SHRINKS_ONLY
2198 if (linkrelax)
2199 /* We must provide lots of padding, so the linker can discard it
2200 when needed. The linker will not add extra space, ever. */
2201 new_address += (1 << alignment);
2202#endif
2203 return (new_address - address);
2204}
2205
efaf0ba4
NC		 2206/* Now we have a segment, not a crowd of sub-segments, we can make
2207 fr_address values.
58a77e41 2208
efaf0ba4 2209 Relax the frags.
58a77e41 2210
efaf0ba4
NC		 2211 After this, all frags in this segment have addresses that are correct
2212 within the segment. Since segments live in different file addresses,
2213 these frag addresses may not be the same as final object-file
2214 addresses. */
2215
e46d99eb 2216int
252b5132
RH		 2217relax_segment (segment_frag_root, segment)
2218 struct frag *segment_frag_root;
2219 segT segment;
2220{
2221 register struct frag *fragP;
2222 register relax_addressT address;
e46d99eb
AM		 2223 int ret;
2224
252b5132
RH		 2225#if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER)
2226 know (segment == SEG_DATA || segment == SEG_TEXT || segment == SEG_BSS);
2227#endif
efaf0ba4 2228 /* In case md_estimate_size_before_relax() wants to make fixSs. */
252b5132
RH		 2229 subseg_change (segment, 0);
2230
2231 /* For each frag in segment: count and store (a 1st guess of)
2232 fr_address. */
2233 address = 0;
2234 for (fragP = segment_frag_root; fragP; fragP = fragP->fr_next)
2235 {
38686296 2236 fragP->relax_marker = 0;
252b5132
RH		 2237 fragP->fr_address = address;
2238 address += fragP->fr_fix;
2239
2240 switch (fragP->fr_type)
2241 {
2242 case rs_fill:
2243 address += fragP->fr_offset * fragP->fr_var;
2244 break;
2245
2246 case rs_align:
2247 case rs_align_code:
0a9ef439 2248 case rs_align_test:
252b5132
RH		 2249 {
2250 addressT offset = relax_align (address, (int) fragP->fr_offset);
2251
2252 if (fragP->fr_subtype != 0 && offset > fragP->fr_subtype)
2253 offset = 0;
2254
2255 if (offset % fragP->fr_var != 0)
2256 {
54d3cad9
AM		 2257 as_bad_where (fragP->fr_file, fragP->fr_line,
2258 _("alignment padding (%lu bytes) not a multiple of %ld"),
2259 (unsigned long) offset, (long) fragP->fr_var);
252b5132
RH		 2260 offset -= (offset % fragP->fr_var);
2261 }
2262
2263 address += offset;
2264 }
2265 break;
2266
2267 case rs_org:
2268 case rs_space:
2269 /* Assume .org is nugatory. It will grow with 1st relax. */
2270 break;
2271
2272 case rs_machine_dependent:
2273 address += md_estimate_size_before_relax (fragP, segment);
2274 break;
2275
2276#ifndef WORKING_DOT_WORD
efaf0ba4 2277 /* Broken words don't concern us yet. */
252b5132
RH		 2278 case rs_broken_word:
2279 break;
2280#endif
2281
2282 case rs_leb128:
efaf0ba4 2283 /* Initial guess is always 1; doing otherwise can result in
252b5132
RH		 2284 stable solutions that are larger than the minimum. */
2285 address += fragP->fr_offset = 1;
2286 break;
2287
2288 case rs_cfa:
2289 address += eh_frame_estimate_size_before_relax (fragP);
2290 break;
2291
220e750f
RH		 2292 case rs_dwarf2dbg:
2293 address += dwarf2dbg_estimate_size_before_relax (fragP);
2294 break;
2295
252b5132
RH		 2296 default:
2297 BAD_CASE (fragP->fr_type);
2298 break;
efaf0ba4
NC		 2299 }
2300 }
252b5132
RH		 2301
2302 /* Do relax(). */
2303 {
efaf0ba4
NC		 2304 long stretch; /* May be any size, 0 or negative. */
2305 /* Cumulative number of addresses we have relaxed this pass.
2306 We may have relaxed more than one address. */
e46d99eb 2307 int stretched; /* Have we stretched on this pass? */
252b5132
RH		 2308 /* This is 'cuz stretch may be zero, when, in fact some piece of code
2309 grew, and another shrank. If a branch instruction doesn't fit anymore,
2310 we could be scrod. */
2311
2312 do
2313 {
e46d99eb
AM		 2314 stretch = 0;
2315 stretched = 0;
58a77e41 2316
252b5132
RH		 2317 for (fragP = segment_frag_root; fragP; fragP = fragP->fr_next)
2318 {
2319 long growth = 0;
2320 addressT was_address;
2321 offsetT offset;
2322 symbolS *symbolP;
2323
38686296 2324 fragP->relax_marker ^= 1;
252b5132
RH		 2325 was_address = fragP->fr_address;
2326 address = fragP->fr_address += stretch;
2327 symbolP = fragP->fr_symbol;
2328 offset = fragP->fr_offset;
2329
2330 switch (fragP->fr_type)
2331 {
efaf0ba4 2332 case rs_fill: /* .fill never relaxes. */
252b5132
RH		 2333 growth = 0;
2334 break;
2335
2336#ifndef WORKING_DOT_WORD
2337 /* JF: This is RMS's idea. I do *NOT* want to be blamed
2338 for it I do not want to write it. I do not want to have
2339 anything to do with it. This is not the proper way to
2340 implement this misfeature. */
2341 case rs_broken_word:
2342 {
2343 struct broken_word *lie;
2344 struct broken_word *untruth;
2345
2346 /* Yes this is ugly (storing the broken_word pointer
2347 in the symbol slot). Still, this whole chunk of
2348 code is ugly, and I don't feel like doing anything
2349 about it. Think of it as stubbornness in action. */
2350 growth = 0;
2351 for (lie = (struct broken_word *) (fragP->fr_symbol);
2352 lie && lie->dispfrag == fragP;
2353 lie = lie->next_broken_word)
2354 {
2355
2356 if (lie->added)
2357 continue;
2358
49309057 2359 offset = (symbol_get_frag (lie->add)->fr_address
252b5132
RH		 2360 + S_GET_VALUE (lie->add)
2361 + lie->addnum
49309057 2362 - (symbol_get_frag (lie->sub)->fr_address
252b5132
RH		 2363 + S_GET_VALUE (lie->sub)));
2364 if (offset <= -32768 || offset >= 32767)
2365 {
2366 if (flag_warn_displacement)
2367 {
2368 char buf[50];
2369 sprint_value (buf, (addressT) lie->addnum);
54d3cad9
AM		 2370 as_warn_where (fragP->fr_file, fragP->fr_line,
2371 _(".word %s-%s+%s didn't fit"),
2372 S_GET_NAME (lie->add),
2373 S_GET_NAME (lie->sub),
2374 buf);
252b5132
RH		 2375 }
2376 lie->added = 1;
2377 if (fragP->fr_subtype == 0)
2378 {
2379 fragP->fr_subtype++;
2380 growth += md_short_jump_size;
2381 }
2382 for (untruth = lie->next_broken_word;
2383 untruth && untruth->dispfrag == lie->dispfrag;
2384 untruth = untruth->next_broken_word)
49309057
ILT		 2385 if ((symbol_get_frag (untruth->add)
2386 == symbol_get_frag (lie->add))
2387 && (S_GET_VALUE (untruth->add)
2388 == S_GET_VALUE (lie->add)))
252b5132
RH		 2389 {
2390 untruth->added = 2;
2391 untruth->use_jump = lie;
2392 }
2393 growth += md_long_jump_size;
2394 }
2395 }
2396
2397 break;
efaf0ba4 2398 } /* case rs_broken_word */
252b5132
RH		 2399#endif
2400 case rs_align:
2401 case rs_align_code:
0a9ef439 2402 case rs_align_test:
252b5132
RH		 2403 {
2404 addressT oldoff, newoff;
2405
2406 oldoff = relax_align (was_address + fragP->fr_fix,
2407 (int) offset);
2408 newoff = relax_align (address + fragP->fr_fix,
2409 (int) offset);
2410
2411 if (fragP->fr_subtype != 0)
2412 {
2413 if (oldoff > fragP->fr_subtype)
2414 oldoff = 0;
2415 if (newoff > fragP->fr_subtype)
2416 newoff = 0;
2417 }
2418
2419 growth = newoff - oldoff;
2420 }
2421 break;
2422
2423 case rs_org:
2424 {
e46d99eb
AM		 2425 addressT target = offset;
2426 addressT after;
252b5132
RH		 2427
2428 if (symbolP)
2429 {
2430#if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER)
2431 know ((S_GET_SEGMENT (symbolP) == SEG_ABSOLUTE)
2432 || (S_GET_SEGMENT (symbolP) == SEG_DATA)
2433 || (S_GET_SEGMENT (symbolP) == SEG_TEXT)
2434 || S_GET_SEGMENT (symbolP) == SEG_BSS);
2435 know (symbolP->sy_frag);
2436 know (!(S_GET_SEGMENT (symbolP) == SEG_ABSOLUTE)
2437 || (symbolP->sy_frag == &zero_address_frag));
2438#endif
49309057
ILT		 2439 target += (S_GET_VALUE (symbolP)
2440 + symbol_get_frag (symbolP)->fr_address);
efaf0ba4 2441 } /* if we have a symbol */
252b5132
RH		 2442
2443 know (fragP->fr_next);
2444 after = fragP->fr_next->fr_address;
2445 growth = target - after;
2446 if (growth < 0)
2447 {
2448 /* Growth may be negative, but variable part of frag
2449 cannot have fewer than 0 chars. That is, we can't
efaf0ba4 2450 .org backwards. */
14ad458a
ILT		 2451 as_bad_where (fragP->fr_file, fragP->fr_line,
2452 _("attempt to .org backwards ignored"));
2453
2454 /* We've issued an error message. Change the
2455 frag to avoid cascading errors. */
2456 fragP->fr_type = rs_align;
2457 fragP->fr_subtype = 0;
2458 fragP->fr_offset = 0;
2459 fragP->fr_fix = after - address;
2460 growth = stretch;
252b5132
RH		 2461 }
2462
efaf0ba4
NC		 2463 /* This is an absolute growth factor */
2464 growth -= stretch;
252b5132
RH		 2465 break;
2466 }
2467
2468 case rs_space:
54d3cad9 2469 growth = 0;
252b5132
RH		 2470 if (symbolP)
2471 {
766c03c9
AM		 2472 offsetT amount;
2473
2474 amount = S_GET_VALUE (symbolP);
9e40345d 2475 if (S_GET_SEGMENT (symbolP) != absolute_section
252b5132
RH		 2476 || S_IS_COMMON (symbolP)
2477 || ! S_IS_DEFINED (symbolP))
252b5132 2478 {
54d3cad9
AM		 2479 as_bad_where (fragP->fr_file, fragP->fr_line,
2480 _(".space specifies non-absolute value"));
2481 /* Prevent repeat of this error message. */
2482 fragP->fr_symbol = 0;
2483 }
2484 else if (amount < 0)
2485 {
2486 as_warn_where (fragP->fr_file, fragP->fr_line,
2487 _(".space or .fill with negative value, ignored"));
766c03c9 2488 fragP->fr_symbol = 0;
252b5132 2489 }
54d3cad9
AM		 2490 else
2491 growth = (was_address + amount
2492 - fragP->fr_next->fr_address);
252b5132 2493 }
252b5132
RH		 2494 break;
2495
2496 case rs_machine_dependent:
2497#ifdef md_relax_frag
c842b53a 2498 growth = md_relax_frag (segment, fragP, stretch);
252b5132
RH		 2499#else
2500#ifdef TC_GENERIC_RELAX_TABLE
2501 /* The default way to relax a frag is to look through
2502 TC_GENERIC_RELAX_TABLE. */
c842b53a 2503 growth = relax_frag (segment, fragP, stretch);
efaf0ba4 2504#endif /* TC_GENERIC_RELAX_TABLE */
252b5132
RH		 2505#endif
2506 break;
2507
2508 case rs_leb128:
2509 {
2510 valueT value;
2511 int size;
2512
6386f3a7 2513 value = resolve_symbol_value (fragP->fr_symbol);
252b5132
RH		 2514 size = sizeof_leb128 (value, fragP->fr_subtype);
2515 growth = size - fragP->fr_offset;
2516 fragP->fr_offset = size;
2517 }
2518 break;
2519
2520 case rs_cfa:
2521 growth = eh_frame_relax_frag (fragP);
2522 break;
2523
220e750f
RH		 2524 case rs_dwarf2dbg:
2525 growth = dwarf2dbg_relax_frag (fragP);
2526 break;
2527
252b5132
RH		 2528 default:
2529 BAD_CASE (fragP->fr_type);
2530 break;
2531 }
2532 if (growth)
2533 {
2534 stretch += growth;
e46d99eb 2535 stretched = 1;
252b5132 2536 }
efaf0ba4 2537 } /* For each frag in the segment. */
252b5132 2538 }
efaf0ba4
NC		 2539 while (stretched); /* Until nothing further to relax. */
2540 } /* do_relax */
252b5132 2541
e46d99eb
AM		 2542 ret = 0;
2543 for (fragP = segment_frag_root; fragP; fragP = fragP->fr_next)
2544 if (fragP->last_fr_address != fragP->fr_address)
2545 {
2546 fragP->last_fr_address = fragP->fr_address;
2547 ret = 1;
2548 }
2549 return ret;
efaf0ba4 2550}
252b5132
RH		 2551
2552#if defined (BFD_ASSEMBLER) || (!defined (BFD) && !defined (OBJ_VMS))
2553
2554#ifndef TC_RELOC_RTSYM_LOC_FIXUP
2555#define TC_RELOC_RTSYM_LOC_FIXUP(X) (1)
2556#endif
2557
2558/* fixup_segment()
2559
2560 Go through all the fixS's in a segment and see which ones can be
2561 handled now. (These consist of fixS where we have since discovered
2562 the value of a symbol, or the address of the frag involved.)
2563 For each one, call md_apply_fix to put the fix into the frag data.
2564
2565 Result is a count of how many relocation structs will be needed to
2566 handle the remaining fixS's that we couldn't completely handle here.
2567 These will be output later by emit_relocations(). */
2568
2569static long
2570fixup_segment (fixP, this_segment_type)
2571 register fixS *fixP;
efaf0ba4 2572 segT this_segment_type; /* N_TYPE bits for segment. */
252b5132
RH		 2573{
2574 long seg_reloc_count = 0;
2575 symbolS *add_symbolP;
2576 symbolS *sub_symbolP;
2577 valueT add_number;
2578 int size;
2579 char *place;
2580 long where;
2581 int pcrel, plt;
2582 fragS *fragP;
2583 segT add_symbol_segment = absolute_section;
2584
2585 /* If the linker is doing the relaxing, we must not do any fixups.
2586
2587 Well, strictly speaking that's not true -- we could do any that are
2588 PC-relative and don't cross regions that could change size. And for the
2589 i960 (the only machine for which we've got a relaxing linker right now),
2590 we might be able to turn callx/callj into bal anyways in cases where we
2591 know the maximum displacement. */
58a77e41 2592 if (linkrelax && TC_LINKRELAX_FIXUP (this_segment_type))
252b5132
RH		 2593 {
2594 for (; fixP; fixP = fixP->fx_next)
2595 seg_reloc_count++;
2596 TC_ADJUST_RELOC_COUNT (fixP, seg_reloc_count);
2597 return seg_reloc_count;
2598 }
2599
2600 for (; fixP; fixP = fixP->fx_next)
2601 {
252b5132
RH		 2602#ifdef DEBUG5
2603 fprintf (stderr, "\nprocessing fixup:\n");
2604 print_fixup (fixP);
2605#endif
2606
252b5132
RH		 2607 fragP = fixP->fx_frag;
2608 know (fragP);
2609 where = fixP->fx_where;
2610 place = fragP->fr_literal + where;
2611 size = fixP->fx_size;
2612 add_symbolP = fixP->fx_addsy;
2613#ifdef TC_VALIDATE_FIX
2614 TC_VALIDATE_FIX (fixP, this_segment_type, skip);
2615#endif
2616 sub_symbolP = fixP->fx_subsy;
2617 add_number = fixP->fx_offset;
2618 pcrel = fixP->fx_pcrel;
2619 plt = fixP->fx_plt;
2620
2621 if (add_symbolP != NULL
49309057 2622 && symbol_mri_common_p (add_symbolP))
252b5132
RH		 2623 {
2624 know (add_symbolP->sy_value.X_op == O_symbol);
2625 add_number += S_GET_VALUE (add_symbolP);
2626 fixP->fx_offset = add_number;
49309057
ILT		 2627 add_symbolP = fixP->fx_addsy =
2628 symbol_get_value_expression (add_symbolP)->X_add_symbol;
252b5132
RH		 2629 }
2630
2631 if (add_symbolP)
2632 add_symbol_segment = S_GET_SEGMENT (add_symbolP);
2633
2634 if (sub_symbolP)
2635 {
6386f3a7 2636 resolve_symbol_value (sub_symbolP);
252b5132
RH		 2637 if (add_symbolP == NULL || add_symbol_segment == absolute_section)
2638 {
2639 if (add_symbolP != NULL)
2640 {
2641 add_number += S_GET_VALUE (add_symbolP);
2642 add_symbolP = NULL;
2643 fixP->fx_addsy = NULL;
2644 }
2645
efaf0ba4 2646 /* It's just -sym. */
252b5132
RH		 2647 if (S_GET_SEGMENT (sub_symbolP) == absolute_section)
2648 {
2649 add_number -= S_GET_VALUE (sub_symbolP);
2650 fixP->fx_subsy = NULL;
2651 }
2652 else if (pcrel
2653 && S_GET_SEGMENT (sub_symbolP) == this_segment_type)
2654 {
2655 /* Should try converting to a constant. */
2656 goto bad_sub_reloc;
2657 }
2658 else
2659 bad_sub_reloc:
2660 as_bad_where (fixP->fx_file, fixP->fx_line,
2661 _("Negative of non-absolute symbol %s"),
2662 S_GET_NAME (sub_symbolP));
2663 }
2664 else if (S_GET_SEGMENT (sub_symbolP) == add_symbol_segment
2665 && SEG_NORMAL (add_symbol_segment))
2666 {
2667 /* Difference of 2 symbols from same segment.
2668 Can't make difference of 2 undefineds: 'value' means
efaf0ba4 2669 something different for N_UNDF. */
252b5132
RH		 2670#ifdef TC_I960
2671 /* Makes no sense to use the difference of 2 arbitrary symbols
2672 as the target of a call instruction. */
2673 if (fixP->fx_tcbit)
2674 as_bad_where (fixP->fx_file, fixP->fx_line,
2675 _("callj to difference of 2 symbols"));
efaf0ba4 2676#endif /* TC_I960 */
d48019e0
AM		 2677 add_number += (S_GET_VALUE (add_symbolP)
2678 - S_GET_VALUE (sub_symbolP));
1a16aca4
AM		 2679 if (1
2680#ifdef TC_M68K
2681 /* See the comment below about 68k weirdness. */
2682 && 0
2683#endif
2684 && pcrel)
d48019e0 2685 add_number -= MD_PCREL_FROM_SECTION (fixP, this_segment_type);
252b5132
RH		 2686
2687 add_symbolP = NULL;
efaf0ba4 2688 pcrel = 0; /* No further pcrel processing. */
252b5132
RH		 2689
2690 /* Let the target machine make the final determination
2691 as to whether or not a relocation will be needed to
2692 handle this fixup. */
2693 if (!TC_FORCE_RELOCATION_SECTION (fixP, this_segment_type))
2694 {
2695 fixP->fx_pcrel = 0;
2696 fixP->fx_addsy = NULL;
2697 fixP->fx_subsy = NULL;
2698 }
2699 }
2700 else
2701 {
efaf0ba4 2702 /* Different segments in subtraction. */
252b5132
RH		 2703 know (!(S_IS_EXTERNAL (sub_symbolP)
2704 && (S_GET_SEGMENT (sub_symbolP) == absolute_section)));
2705
2706 if ((S_GET_SEGMENT (sub_symbolP) == absolute_section))
2707 add_number -= S_GET_VALUE (sub_symbolP);
2708
2709#ifdef DIFF_EXPR_OK
1a16aca4 2710 else if (S_GET_SEGMENT (sub_symbolP) == this_segment_type)
252b5132
RH		 2711 {
2712 /* Make it pc-relative. */
1a16aca4
AM		 2713 if (0
2714#ifdef TC_M68K
2715 /* Do this for m68k even if it's already described
2716 as pc-relative. On the m68k, an operand of
2717 "pc@(foo-.-2)" should address "foo" in a
2718 pc-relative mode. */
2719 || 1
2720#endif
2721 || !pcrel)
2722 {
2723 add_number += MD_PCREL_FROM_SECTION (fixP,
2724 this_segment_type);
2725 pcrel = 1;
2726 fixP->fx_pcrel = 1;
2727 }
2728
2729 add_number -= S_GET_VALUE (sub_symbolP);
252b5132
RH		 2730 sub_symbolP = 0;
2731 fixP->fx_subsy = 0;
2732 }
2733#endif
2734#ifdef UNDEFINED_DIFFERENCE_OK
2735 /* The PA needs this for PIC code generation. We basically
2736 don't want to do anything if we have the difference of two
2737 symbols at this point. */
2738 else if (1)
2739 {
2740 /* Leave it alone. */
2741 }
2742#endif
2743#ifdef BFD_ASSEMBLER
2744 else if (fixP->fx_r_type == BFD_RELOC_GPREL32
2745 || fixP->fx_r_type == BFD_RELOC_GPREL16)
2746 {
2747 /* Leave it alone. */
2748 }
2749#endif
2750 else
2751 {
2752 char buf[50];
2753 sprint_value (buf, fragP->fr_address + where);
2754 as_bad_where (fixP->fx_file, fixP->fx_line,
2755 _("Subtraction of two symbols in different sections \"%s\" {%s section} - \"%s\" {%s section} at file address %s."),
2756 S_GET_NAME (add_symbolP),
2757 segment_name (S_GET_SEGMENT (add_symbolP)),
2758 S_GET_NAME (sub_symbolP),
2759 segment_name (S_GET_SEGMENT (sub_symbolP)),
2760 buf);
2761 }
2762 }
2763 }
2764
2765 if (add_symbolP)
2766 {
2767 if (add_symbol_segment == this_segment_type && pcrel && !plt
2768 && TC_RELOC_RTSYM_LOC_FIXUP (fixP))
2769 {
efaf0ba4
NC		 2770 /* This fixup was made when the symbol's segment was
2771 SEG_UNKNOWN, but it is now in the local segment.
2772 So we know how to do the address without relocation. */
252b5132
RH		 2773#ifdef TC_I960
2774 /* reloc_callj() may replace a 'call' with a 'calls' or a
2775 'bal', in which cases it modifies *fixP as appropriate.
2776 In the case of a 'calls', no further work is required,
2777 and *fixP has been set up to make the rest of the code
efaf0ba4 2778 below a no-op. */
252b5132 2779 reloc_callj (fixP);
efaf0ba4 2780#endif /* TC_I960 */
252b5132
RH		 2781
2782 add_number += S_GET_VALUE (add_symbolP);
2783 add_number -= MD_PCREL_FROM_SECTION (fixP, this_segment_type);
efaf0ba4
NC		 2784 /* Lie. Don't want further pcrel processing. */
2785 pcrel = 0;
252b5132
RH		 2786
2787 /* Let the target machine make the final determination
2788 as to whether or not a relocation will be needed to
2789 handle this fixup. */
2790 if (!TC_FORCE_RELOCATION (fixP))
2791 {
2792 fixP->fx_pcrel = 0;
2793 fixP->fx_addsy = NULL;
2794 }
2795 }
2796 else
2797 {
2798 if (add_symbol_segment == absolute_section
2799 && ! pcrel)
2800 {
2801#ifdef TC_I960
2802 /* See comment about reloc_callj() above. */
2803 reloc_callj (fixP);
efaf0ba4 2804#endif /* TC_I960 */
252b5132
RH		 2805 add_number += S_GET_VALUE (add_symbolP);
2806
2807 /* Let the target machine make the final determination
2808 as to whether or not a relocation will be needed to
2809 handle this fixup. */
2810
2811 if (!TC_FORCE_RELOCATION (fixP))
2812 {
2813 fixP->fx_addsy = NULL;
2814 add_symbolP = NULL;
2815 }
2816 }
2817 else if (add_symbol_segment == undefined_section
2818#ifdef BFD_ASSEMBLER
2819 || bfd_is_com_section (add_symbol_segment)
2820#endif
2821 )
2822 {
2823#ifdef TC_I960
2824 if ((int) fixP->fx_bit_fixP == 13)
2825 {
2826 /* This is a COBR instruction. They have only a
efaf0ba4
NC		 2827 13-bit displacement and are only to be used
2828 for local branches: flag as error, don't generate
2829 relocation. */
252b5132
RH		 2830 as_bad_where (fixP->fx_file, fixP->fx_line,
2831 _("can't use COBR format with external label"));
2832 fixP->fx_addsy = NULL;
2833 fixP->fx_done = 1;
2834 continue;
efaf0ba4
NC		 2835 } /* COBR. */
2836#endif /* TC_I960 */
252b5132
RH		 2837
2838#ifdef OBJ_COFF
2839#ifdef TE_I386AIX
2840 if (S_IS_COMMON (add_symbolP))
2841 add_number += S_GET_VALUE (add_symbolP);
efaf0ba4
NC		 2842#endif /* TE_I386AIX */
2843#endif /* OBJ_COFF */
252b5132
RH		 2844 ++seg_reloc_count;
2845 }
2846 else
2847 {
2848 seg_reloc_count++;
8f36cd18 2849 if (TC_FIX_ADJUSTABLE (fixP))
02198638 2850 add_number += S_GET_VALUE (add_symbolP);
252b5132
RH		 2851 }
2852 }
2853 }
2854
2855 if (pcrel)
2856 {
2857 add_number -= MD_PCREL_FROM_SECTION (fixP, this_segment_type);
2858 if (add_symbolP == 0)
2859 {
2860#ifndef BFD_ASSEMBLER
2861 fixP->fx_addsy = &abs_symbol;
2862#else
2863 fixP->fx_addsy = section_symbol (absolute_section);
2864#endif
49309057 2865 symbol_mark_used_in_reloc (fixP->fx_addsy);
252b5132
RH		 2866 ++seg_reloc_count;
2867 }
2868 }
2869
6d4d30bb
AM		 2870 if (!fixP->fx_done)
2871 {
2872#ifdef MD_APPLY_FIX3
2873 md_apply_fix3 (fixP, &add_number, this_segment_type);
2874#else
2875#ifdef BFD_ASSEMBLER
2876 md_apply_fix (fixP, &add_number);
2877#else
2878 md_apply_fix (fixP, add_number);
2879#endif
2880#endif
2881
2882#ifndef TC_HANDLES_FX_DONE
2883 /* If the tc-* files haven't been converted, assume it's handling
2884 it the old way, where a null fx_addsy means that the fix has
2885 been applied completely, and no further work is needed. */
2886 if (fixP->fx_addsy == 0 && fixP->fx_pcrel == 0)
2887 fixP->fx_done = 1;
2888#endif
2889 }
2890
252b5132
RH		 2891 if (!fixP->fx_bit_fixP && !fixP->fx_no_overflow && size > 0)
2892 {
2893 if ((size_t) size < sizeof (valueT))
2894 {
b77ad1d4 2895 valueT mask;
252b5132 2896
252b5132 2897 mask = 0;
efaf0ba4 2898 mask--; /* Set all bits to one. */
b77ad1d4
AM		 2899 mask <<= size * 8 - (fixP->fx_signed ? 1 : 0);
2900 if ((add_number & mask) != 0 && (add_number & mask) != mask)
252b5132
RH		 2901 {
2902 char buf[50], buf2[50];
2903 sprint_value (buf, fragP->fr_address + where);
2904 if (add_number > 1000)
2905 sprint_value (buf2, add_number);
2906 else
2907 sprintf (buf2, "%ld", (long) add_number);
2908 as_bad_where (fixP->fx_file, fixP->fx_line,
2909 _("Value of %s too large for field of %d bytes at %s"),
2910 buf2, size, buf);
efaf0ba4 2911 } /* Generic error checking. */
252b5132
RH		 2912 }
2913#ifdef WARN_SIGNED_OVERFLOW_WORD
2914 /* Warn if a .word value is too large when treated as a signed
2915 number. We already know it is not too negative. This is to
2916 catch over-large switches generated by gcc on the 68k. */
2917 if (!flag_signed_overflow_ok
2918 && size == 2
2919 && add_number > 0x7fff)
2920 as_bad_where (fixP->fx_file, fixP->fx_line,
2921 _("Signed .word overflow; switch may be too large; %ld at 0x%lx"),
2922 (long) add_number,
2923 (unsigned long) (fragP->fr_address + where));
2924#endif
efaf0ba4 2925 } /* Not a bit fix. */
252b5132 2926
252b5132 2927#ifdef TC_VALIDATE_FIX
ab9da554
ILT		 2928 skip: ATTRIBUTE_UNUSED_LABEL
2929 ;
252b5132
RH		 2930#endif
2931#ifdef DEBUG5
2932 fprintf (stderr, "result:\n");
2933 print_fixup (fixP);
2934#endif
efaf0ba4 2935 } /* For each fixS in this segment. */
252b5132
RH		 2936
2937 TC_ADJUST_RELOC_COUNT (fixP, seg_reloc_count);
2938 return seg_reloc_count;
2939}
2940
2941#endif /* defined (BFD_ASSEMBLER) || (!defined (BFD) && !defined (OBJ_VMS)) */
2942
2943void
2944number_to_chars_bigendian (buf, val, n)
2945 char *buf;
2946 valueT val;
2947 int n;
2948{
2949 if ((size_t) n > sizeof (val) || n <= 0)
2950 abort ();
2951 while (n--)
2952 {
2953 buf[n] = val & 0xff;
2954 val >>= 8;
2955 }
2956}
2957
2958void
2959number_to_chars_littleendian (buf, val, n)
2960 char *buf;
2961 valueT val;
2962 int n;
2963{
2964 if ((size_t) n > sizeof (val) || n <= 0)
2965 abort ();
2966 while (n--)
2967 {
2968 *buf++ = val & 0xff;
2969 val >>= 8;
2970 }
2971}
2972
2973void
2974write_print_statistics (file)
2975 FILE *file;
2976{
6d4d30bb 2977 fprintf (file, "fixups: %d\n", n_fixups);
252b5132
RH		 2978}
2979
efaf0ba4 2980/* For debugging. */
252b5132
RH		 2981extern int indent_level;
2982
2983void
2984print_fixup (fixp)
2985 fixS *fixp;
2986{
2987 indent_level = 1;
2988 fprintf (stderr, "fix %lx %s:%d", (long) fixp, fixp->fx_file, fixp->fx_line);
2989 if (fixp->fx_pcrel)
2990 fprintf (stderr, " pcrel");
2991 if (fixp->fx_pcrel_adjust)
2992 fprintf (stderr, " pcrel_adjust=%d", fixp->fx_pcrel_adjust);
2993 if (fixp->fx_im_disp)
2994 {
2995#ifdef TC_NS32K
2996 fprintf (stderr, " im_disp=%d", fixp->fx_im_disp);
2997#else
2998 fprintf (stderr, " im_disp");
2999#endif
3000 }
3001 if (fixp->fx_tcbit)
3002 fprintf (stderr, " tcbit");
3003 if (fixp->fx_done)
3004 fprintf (stderr, " done");
3005 fprintf (stderr, "\n size=%d frag=%lx where=%ld offset=%lx addnumber=%lx",
3006 fixp->fx_size, (long) fixp->fx_frag, (long) fixp->fx_where,
3007 (long) fixp->fx_offset, (long) fixp->fx_addnumber);
3008#ifdef BFD_ASSEMBLER
3009 fprintf (stderr, "\n %s (%d)", bfd_get_reloc_code_name (fixp->fx_r_type),
3010 fixp->fx_r_type);
3011#else
3012#ifdef NEED_FX_R_TYPE
3013 fprintf (stderr, " r_type=%d", fixp->fx_r_type);
3014#endif
3015#endif
3016 if (fixp->fx_addsy)
3017 {
3018 fprintf (stderr, "\n +<");
3019 print_symbol_value_1 (stderr, fixp->fx_addsy);
3020 fprintf (stderr, ">");
3021 }
3022 if (fixp->fx_subsy)
3023 {
3024 fprintf (stderr, "\n -<");
3025 print_symbol_value_1 (stderr, fixp->fx_subsy);
3026 fprintf (stderr, ">");
3027 }
3028 fprintf (stderr, "\n");
3029#ifdef TC_FIX_DATA_PRINT
3030 TC_FIX_DATA_PRINT (stderr, fixp);
3031#endif
3032}
GDB Binutils - Deliverables
This page took 0.220464 seconds and 4 git commands to generate.