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