Import binutils-2.20
[dragonfly.git] / contrib / binutils-2.20 / gas / write.c
1 /* write.c - emit .o file
2    Copyright 1986, 1987, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
3    1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
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 3, 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, 51 Franklin Street - Fifth Floor, Boston, MA
21    02110-1301, USA.  */
22
23 /* This thing should be set up to do byteordering correctly.  But...  */
24
25 #include "as.h"
26 #include "subsegs.h"
27 #include "obstack.h"
28 #include "output-file.h"
29 #include "dwarf2dbg.h"
30 #include "libbfd.h"
31
32 #ifndef TC_ADJUST_RELOC_COUNT
33 #define TC_ADJUST_RELOC_COUNT(FIX, COUNT)
34 #endif
35
36 #ifndef TC_FORCE_RELOCATION
37 #define TC_FORCE_RELOCATION(FIX)                \
38   (generic_force_reloc (FIX))
39 #endif
40
41 #ifndef TC_FORCE_RELOCATION_ABS
42 #define TC_FORCE_RELOCATION_ABS(FIX)            \
43   (TC_FORCE_RELOCATION (FIX))
44 #endif
45
46 #ifndef TC_FORCE_RELOCATION_LOCAL
47 #define TC_FORCE_RELOCATION_LOCAL(FIX)          \
48   (!(FIX)->fx_pcrel                             \
49    || TC_FORCE_RELOCATION (FIX))
50 #endif
51
52 #ifndef TC_FORCE_RELOCATION_SUB_SAME
53 #define TC_FORCE_RELOCATION_SUB_SAME(FIX, SEG)  \
54   (! SEG_NORMAL (SEG))
55 #endif
56
57 #ifndef md_register_arithmetic
58 # define md_register_arithmetic 1
59 #endif
60
61 #ifndef TC_FORCE_RELOCATION_SUB_ABS
62 #define TC_FORCE_RELOCATION_SUB_ABS(FIX, SEG)   \
63   (!md_register_arithmetic && (SEG) == reg_section)
64 #endif
65
66 #ifndef TC_FORCE_RELOCATION_SUB_LOCAL
67 #ifdef DIFF_EXPR_OK
68 #define TC_FORCE_RELOCATION_SUB_LOCAL(FIX, SEG) \
69   (!md_register_arithmetic && (SEG) == reg_section)
70 #else
71 #define TC_FORCE_RELOCATION_SUB_LOCAL(FIX, SEG) 1
72 #endif
73 #endif
74
75 #ifndef TC_VALIDATE_FIX_SUB
76 #ifdef UNDEFINED_DIFFERENCE_OK
77 /* The PA needs this for PIC code generation.  */
78 #define TC_VALIDATE_FIX_SUB(FIX, SEG)                   \
79   (md_register_arithmetic || (SEG) != reg_section)
80 #else
81 #define TC_VALIDATE_FIX_SUB(FIX, SEG)                   \
82   ((md_register_arithmetic || (SEG) != reg_section)     \
83    && ((FIX)->fx_r_type == BFD_RELOC_GPREL32            \
84        || (FIX)->fx_r_type == BFD_RELOC_GPREL16))
85 #endif
86 #endif
87
88 #ifndef TC_LINKRELAX_FIXUP
89 #define TC_LINKRELAX_FIXUP(SEG) 1
90 #endif
91
92 #ifndef MD_APPLY_SYM_VALUE
93 #define MD_APPLY_SYM_VALUE(FIX) 1
94 #endif
95
96 #ifndef TC_FINALIZE_SYMS_BEFORE_SIZE_SEG
97 #define TC_FINALIZE_SYMS_BEFORE_SIZE_SEG 1
98 #endif
99
100 #ifndef MD_PCREL_FROM_SECTION
101 #define MD_PCREL_FROM_SECTION(FIX, SEC) md_pcrel_from (FIX)
102 #endif
103
104 #ifndef TC_FAKE_LABEL
105 #define TC_FAKE_LABEL(NAME) (strcmp ((NAME), FAKE_LABEL_NAME) == 0)
106 #endif
107
108 /* Positive values of TC_FX_SIZE_SLACK allow a target to define
109    fixups that far past the end of a frag.  Having such fixups
110    is of course most most likely a bug in setting fx_size correctly.
111    A negative value disables the fixup check entirely, which is
112    appropriate for something like the Renesas / SuperH SH_COUNT
113    reloc.  */
114 #ifndef TC_FX_SIZE_SLACK
115 #define TC_FX_SIZE_SLACK(FIX) 0
116 #endif
117
118 /* Used to control final evaluation of expressions.  */
119 int finalize_syms = 0;
120
121 int symbol_table_frozen;
122
123 symbolS *abs_section_sym;
124
125 /* Remember the value of dot when parsing expressions.  */
126 addressT dot_value;
127
128 /* Relocs generated by ".reloc" pseudo.  */
129 struct reloc_list* reloc_list;
130
131 void print_fixup (fixS *);
132
133 /* We generally attach relocs to frag chains.  However, after we have
134    chained these all together into a segment, any relocs we add after
135    that must be attached to a segment.  This will include relocs added
136    in md_estimate_size_for_relax, for example.  */
137 static int frags_chained = 0;
138
139 static int n_fixups;
140
141 #define RELOC_ENUM enum bfd_reloc_code_real
142
143 /* Create a fixS in obstack 'notes'.  */
144
145 static fixS *
146 fix_new_internal (fragS *frag,          /* Which frag?  */
147                   int where,            /* Where in that frag?  */
148                   int size,             /* 1, 2, or 4 usually.  */
149                   symbolS *add_symbol,  /* X_add_symbol.  */
150                   symbolS *sub_symbol,  /* X_op_symbol.  */
151                   offsetT offset,       /* X_add_number.  */
152                   int pcrel,            /* TRUE if PC-relative relocation.  */
153                   RELOC_ENUM r_type ATTRIBUTE_UNUSED /* Relocation type.  */)
154 {
155   fixS *fixP;
156
157   n_fixups++;
158
159   fixP = (fixS *) obstack_alloc (&notes, sizeof (fixS));
160
161   fixP->fx_frag = frag;
162   fixP->fx_where = where;
163   fixP->fx_size = size;
164   /* We've made fx_size a narrow field; check that it's wide enough.  */
165   if (fixP->fx_size != size)
166     {
167       as_bad (_("field fx_size too small to hold %d"), size);
168       abort ();
169     }
170   fixP->fx_addsy = add_symbol;
171   fixP->fx_subsy = sub_symbol;
172   fixP->fx_offset = offset;
173   fixP->fx_dot_value = dot_value;
174   fixP->fx_pcrel = pcrel;
175   fixP->fx_r_type = r_type;
176   fixP->fx_im_disp = 0;
177   fixP->fx_pcrel_adjust = 0;
178   fixP->fx_bit_fixP = 0;
179   fixP->fx_addnumber = 0;
180   fixP->fx_tcbit = 0;
181   fixP->fx_tcbit2 = 0;
182   fixP->fx_done = 0;
183   fixP->fx_no_overflow = 0;
184   fixP->fx_signed = 0;
185
186 #ifdef USING_CGEN
187   fixP->fx_cgen.insn = NULL;
188   fixP->fx_cgen.opinfo = 0;
189 #endif
190
191 #ifdef TC_FIX_TYPE
192   TC_INIT_FIX_DATA (fixP);
193 #endif
194
195   as_where (&fixP->fx_file, &fixP->fx_line);
196
197   /* Usually, we want relocs sorted numerically, but while
198      comparing to older versions of gas that have relocs
199      reverse sorted, it is convenient to have this compile
200      time option.  xoxorich.  */
201   {
202
203     fixS **seg_fix_rootP = (frags_chained
204                             ? &seg_info (now_seg)->fix_root
205                             : &frchain_now->fix_root);
206     fixS **seg_fix_tailP = (frags_chained
207                             ? &seg_info (now_seg)->fix_tail
208                             : &frchain_now->fix_tail);
209
210 #ifdef REVERSE_SORT_RELOCS
211
212     fixP->fx_next = *seg_fix_rootP;
213     *seg_fix_rootP = fixP;
214
215 #else /* REVERSE_SORT_RELOCS  */
216
217     fixP->fx_next = NULL;
218
219     if (*seg_fix_tailP)
220       (*seg_fix_tailP)->fx_next = fixP;
221     else
222       *seg_fix_rootP = fixP;
223     *seg_fix_tailP = fixP;
224
225 #endif /* REVERSE_SORT_RELOCS  */
226   }
227
228   return fixP;
229 }
230
231 /* Create a fixup relative to a symbol (plus a constant).  */
232
233 fixS *
234 fix_new (fragS *frag,           /* Which frag?  */
235          int where,                     /* Where in that frag?  */
236          int size,                      /* 1, 2, or 4 usually.  */
237          symbolS *add_symbol,   /* X_add_symbol.  */
238          offsetT offset,                /* X_add_number.  */
239          int pcrel,                     /* TRUE if PC-relative relocation.  */
240          RELOC_ENUM r_type              /* Relocation type.  */)
241 {
242   return fix_new_internal (frag, where, size, add_symbol,
243                            (symbolS *) NULL, offset, pcrel, r_type);
244 }
245
246 /* Create a fixup for an expression.  Currently we only support fixups
247    for difference expressions.  That is itself more than most object
248    file formats support anyhow.  */
249
250 fixS *
251 fix_new_exp (fragS *frag,               /* Which frag?  */
252              int where,                 /* Where in that frag?  */
253              int size,                  /* 1, 2, or 4 usually.  */
254              expressionS *exp,          /* Expression.  */
255              int pcrel,                 /* TRUE if PC-relative relocation.  */
256              RELOC_ENUM r_type          /* Relocation type.  */)
257 {
258   symbolS *add = NULL;
259   symbolS *sub = NULL;
260   offsetT off = 0;
261
262   switch (exp->X_op)
263     {
264     case O_absent:
265       break;
266
267     case O_register:
268       as_bad (_("register value used as expression"));
269       break;
270
271     case O_add:
272       /* This comes up when _GLOBAL_OFFSET_TABLE_+(.-L0) is read, if
273          the difference expression cannot immediately be reduced.  */
274       {
275         symbolS *stmp = make_expr_symbol (exp);
276
277         exp->X_op = O_symbol;
278         exp->X_op_symbol = 0;
279         exp->X_add_symbol = stmp;
280         exp->X_add_number = 0;
281
282         return fix_new_exp (frag, where, size, exp, pcrel, r_type);
283       }
284
285     case O_symbol_rva:
286       add = exp->X_add_symbol;
287       off = exp->X_add_number;
288       r_type = BFD_RELOC_RVA;
289       break;
290
291     case O_uminus:
292       sub = exp->X_add_symbol;
293       off = exp->X_add_number;
294       break;
295
296     case O_subtract:
297       sub = exp->X_op_symbol;
298       /* Fall through.  */
299     case O_symbol:
300       add = exp->X_add_symbol;
301       /* Fall through.  */
302     case O_constant:
303       off = exp->X_add_number;
304       break;
305
306     default:
307       add = make_expr_symbol (exp);
308       break;
309     }
310
311   return fix_new_internal (frag, where, size, add, sub, off, pcrel, r_type);
312 }
313
314 /* Generic function to determine whether a fixup requires a relocation.  */
315 int
316 generic_force_reloc (fixS *fix)
317 {
318   if (fix->fx_r_type == BFD_RELOC_VTABLE_INHERIT
319       || fix->fx_r_type == BFD_RELOC_VTABLE_ENTRY)
320     return 1;
321
322   if (fix->fx_addsy == NULL)
323     return 0;
324
325   return S_FORCE_RELOC (fix->fx_addsy, fix->fx_subsy == NULL);
326 }
327
328 /* Append a string onto another string, bumping the pointer along.  */
329 void
330 append (char **charPP, char *fromP, unsigned long length)
331 {
332   /* Don't trust memcpy() of 0 chars.  */
333   if (length == 0)
334     return;
335
336   memcpy (*charPP, fromP, length);
337   *charPP += length;
338 }
339
340 /* This routine records the largest alignment seen for each segment.
341    If the beginning of the segment is aligned on the worst-case
342    boundary, all of the other alignments within it will work.  At
343    least one object format really uses this info.  */
344
345 void
346 record_alignment (/* Segment to which alignment pertains.  */
347                   segT seg,
348                   /* Alignment, as a power of 2 (e.g., 1 => 2-byte
349                      boundary, 2 => 4-byte boundary, etc.)  */
350                   int align)
351 {
352   if (seg == absolute_section)
353     return;
354
355   if ((unsigned int) align > bfd_get_section_alignment (stdoutput, seg))
356     bfd_set_section_alignment (stdoutput, seg, align);
357 }
358
359 int
360 get_recorded_alignment (segT seg)
361 {
362   if (seg == absolute_section)
363     return 0;
364
365   return bfd_get_section_alignment (stdoutput, seg);
366 }
367
368 /* Reset the section indices after removing the gas created sections.  */
369
370 static void
371 renumber_sections (bfd *abfd ATTRIBUTE_UNUSED, asection *sec, void *countparg)
372 {
373   int *countp = (int *) countparg;
374
375   sec->index = *countp;
376   ++*countp;
377 }
378
379 static fragS *
380 chain_frchains_together_1 (segT section, struct frchain *frchp)
381 {
382   fragS dummy, *prev_frag = &dummy;
383   fixS fix_dummy, *prev_fix = &fix_dummy;
384
385   for (; frchp; frchp = frchp->frch_next)
386     {
387       prev_frag->fr_next = frchp->frch_root;
388       prev_frag = frchp->frch_last;
389       gas_assert (prev_frag->fr_type != 0);
390       if (frchp->fix_root != (fixS *) NULL)
391         {
392           if (seg_info (section)->fix_root == (fixS *) NULL)
393             seg_info (section)->fix_root = frchp->fix_root;
394           prev_fix->fx_next = frchp->fix_root;
395           seg_info (section)->fix_tail = frchp->fix_tail;
396           prev_fix = frchp->fix_tail;
397         }
398     }
399   gas_assert (prev_frag->fr_type != 0);
400   gas_assert (prev_frag != &dummy);
401   prev_frag->fr_next = 0;
402   return prev_frag;
403 }
404
405 static void
406 chain_frchains_together (bfd *abfd ATTRIBUTE_UNUSED,
407                          segT section,
408                          void *xxx ATTRIBUTE_UNUSED)
409 {
410   segment_info_type *info;
411
412   /* BFD may have introduced its own sections without using
413      subseg_new, so it is possible that seg_info is NULL.  */
414   info = seg_info (section);
415   if (info != (segment_info_type *) NULL)
416     info->frchainP->frch_last
417       = chain_frchains_together_1 (section, info->frchainP);
418
419   /* Now that we've chained the frags together, we must add new fixups
420      to the segment, not to the frag chain.  */
421   frags_chained = 1;
422 }
423
424 static void
425 cvt_frag_to_fill (segT sec ATTRIBUTE_UNUSED, fragS *fragP)
426 {
427   switch (fragP->fr_type)
428     {
429     case rs_align:
430     case rs_align_code:
431     case rs_align_test:
432     case rs_org:
433     case rs_space:
434 #ifdef HANDLE_ALIGN
435       HANDLE_ALIGN (fragP);
436 #endif
437       know (fragP->fr_next != NULL);
438       fragP->fr_offset = (fragP->fr_next->fr_address
439                           - fragP->fr_address
440                           - fragP->fr_fix) / fragP->fr_var;
441       if (fragP->fr_offset < 0)
442         {
443           as_bad_where (fragP->fr_file, fragP->fr_line,
444                         _("attempt to .org/.space backwards? (%ld)"),
445                         (long) fragP->fr_offset);
446           fragP->fr_offset = 0;
447         }
448       fragP->fr_type = rs_fill;
449       break;
450
451     case rs_fill:
452       break;
453
454     case rs_leb128:
455       {
456         valueT value = S_GET_VALUE (fragP->fr_symbol);
457         int size;
458
459         size = output_leb128 (fragP->fr_literal + fragP->fr_fix, value,
460                               fragP->fr_subtype);
461
462         fragP->fr_fix += size;
463         fragP->fr_type = rs_fill;
464         fragP->fr_var = 0;
465         fragP->fr_offset = 0;
466         fragP->fr_symbol = NULL;
467       }
468       break;
469
470     case rs_cfa:
471       eh_frame_convert_frag (fragP);
472       break;
473
474     case rs_dwarf2dbg:
475       dwarf2dbg_convert_frag (fragP);
476       break;
477
478     case rs_machine_dependent:
479       md_convert_frag (stdoutput, sec, fragP);
480
481       gas_assert (fragP->fr_next == NULL
482               || ((offsetT) (fragP->fr_next->fr_address - fragP->fr_address)
483                   == fragP->fr_fix));
484
485       /* After md_convert_frag, we make the frag into a ".space 0".
486          md_convert_frag() should set up any fixSs and constants
487          required.  */
488       frag_wane (fragP);
489       break;
490
491 #ifndef WORKING_DOT_WORD
492     case rs_broken_word:
493       {
494         struct broken_word *lie;
495
496         if (fragP->fr_subtype)
497           {
498             fragP->fr_fix += md_short_jump_size;
499             for (lie = (struct broken_word *) (fragP->fr_symbol);
500                  lie && lie->dispfrag == fragP;
501                  lie = lie->next_broken_word)
502               if (lie->added == 1)
503                 fragP->fr_fix += md_long_jump_size;
504           }
505         frag_wane (fragP);
506       }
507       break;
508 #endif
509
510     default:
511       BAD_CASE (fragP->fr_type);
512       break;
513     }
514 #ifdef md_frag_check
515   md_frag_check (fragP);
516 #endif
517 }
518
519 struct relax_seg_info
520 {
521   int pass;
522   int changed;
523 };
524
525 static void
526 relax_seg (bfd *abfd ATTRIBUTE_UNUSED, asection *sec, void *xxx)
527 {
528   segment_info_type *seginfo = seg_info (sec);
529   struct relax_seg_info *info = (struct relax_seg_info *) xxx;
530
531   if (seginfo && seginfo->frchainP
532       && relax_segment (seginfo->frchainP->frch_root, sec, info->pass))
533     info->changed = 1;
534 }
535
536 static void
537 size_seg (bfd *abfd, asection *sec, void *xxx ATTRIBUTE_UNUSED)
538 {
539   flagword flags;
540   fragS *fragp;
541   segment_info_type *seginfo;
542   int x;
543   valueT size, newsize;
544
545   subseg_change (sec, 0);
546
547   seginfo = seg_info (sec);
548   if (seginfo && seginfo->frchainP)
549     {
550       for (fragp = seginfo->frchainP->frch_root; fragp; fragp = fragp->fr_next)
551         cvt_frag_to_fill (sec, fragp);
552       for (fragp = seginfo->frchainP->frch_root;
553            fragp->fr_next;
554            fragp = fragp->fr_next)
555         /* Walk to last elt.  */
556         ;
557       size = fragp->fr_address + fragp->fr_fix;
558     }
559   else
560     size = 0;
561
562   flags = bfd_get_section_flags (abfd, sec);
563   if (size == 0 && bfd_get_section_size (sec) != 0 &&
564     (flags & SEC_HAS_CONTENTS) != 0)
565     return;
566
567   if (size > 0 && ! seginfo->bss)
568     flags |= SEC_HAS_CONTENTS;
569
570   flags &= ~SEC_RELOC;
571   x = bfd_set_section_flags (abfd, sec, flags);
572   gas_assert (x);
573
574   newsize = md_section_align (sec, size);
575   x = bfd_set_section_size (abfd, sec, newsize);
576   gas_assert (x);
577
578   /* If the size had to be rounded up, add some padding in the last
579      non-empty frag.  */
580   gas_assert (newsize >= size);
581   if (size != newsize)
582     {
583       fragS *last = seginfo->frchainP->frch_last;
584       fragp = seginfo->frchainP->frch_root;
585       while (fragp->fr_next != last)
586         fragp = fragp->fr_next;
587       last->fr_address = size;
588       if ((newsize - size) % fragp->fr_var == 0)
589         fragp->fr_offset += (newsize - size) / fragp->fr_var;
590       else
591         /* If we hit this abort, it's likely due to subsegs_finish not
592            providing sufficient alignment on the last frag, and the
593            machine dependent code using alignment frags with fr_var
594            greater than 1.  */
595         abort ();
596     }
597
598 #ifdef tc_frob_section
599   tc_frob_section (sec);
600 #endif
601 #ifdef obj_frob_section
602   obj_frob_section (sec);
603 #endif
604 }
605
606 #ifdef DEBUG2
607 static void
608 dump_section_relocs (bfd *abfd ATTRIBUTE_UNUSED, asection *sec, FILE *stream)
609 {
610   segment_info_type *seginfo = seg_info (sec);
611   fixS *fixp = seginfo->fix_root;
612
613   if (!fixp)
614     return;
615
616   fprintf (stream, "sec %s relocs:\n", sec->name);
617   while (fixp)
618     {
619       symbolS *s = fixp->fx_addsy;
620
621       fprintf (stream, "  %08lx: type %d ", (unsigned long) fixp,
622                (int) fixp->fx_r_type);
623       if (s == NULL)
624         fprintf (stream, "no sym\n");
625       else
626         {
627           print_symbol_value_1 (stream, s);
628           fprintf (stream, "\n");
629         }
630       fixp = fixp->fx_next;
631     }
632 }
633 #else
634 #define dump_section_relocs(ABFD,SEC,STREAM)    ((void) 0)
635 #endif
636
637 #ifndef EMIT_SECTION_SYMBOLS
638 #define EMIT_SECTION_SYMBOLS 1
639 #endif
640
641 /* Resolve U.A.OFFSET_SYM and U.A.SYM fields of RELOC_LIST entries,
642    and check for validity.  Convert RELOC_LIST from using U.A fields
643    to U.B fields.  */
644 static void
645 resolve_reloc_expr_symbols (void)
646 {
647   struct reloc_list *r;
648
649   for (r = reloc_list; r; r = r->next)
650     {
651       expressionS *symval;
652       symbolS *sym;
653       bfd_vma offset, addend;
654       asection *sec;
655       reloc_howto_type *howto;
656
657       resolve_symbol_value (r->u.a.offset_sym);
658       symval = symbol_get_value_expression (r->u.a.offset_sym);
659
660       offset = 0;
661       sym = NULL;
662       if (symval->X_op == O_constant)
663         sym = r->u.a.offset_sym;
664       else if (symval->X_op == O_symbol)
665         {
666           sym = symval->X_add_symbol;
667           offset = symval->X_add_number;
668           symval = symbol_get_value_expression (symval->X_add_symbol);
669         }
670       if (sym == NULL
671           || symval->X_op != O_constant
672           || (sec = S_GET_SEGMENT (sym)) == NULL
673           || !SEG_NORMAL (sec))
674         {
675           as_bad_where (r->file, r->line, _("invalid offset expression"));
676           sec = NULL;
677         }
678       else
679         offset += S_GET_VALUE (sym);
680
681       sym = NULL;
682       addend = r->u.a.addend;
683       if (r->u.a.sym != NULL)
684         {
685           resolve_symbol_value (r->u.a.sym);
686           symval = symbol_get_value_expression (r->u.a.sym);
687           if (symval->X_op == O_constant)
688             sym = r->u.a.sym;
689           else if (symval->X_op == O_symbol)
690             {
691               sym = symval->X_add_symbol;
692               addend += symval->X_add_number;
693               symval = symbol_get_value_expression (symval->X_add_symbol);
694             }
695           if (symval->X_op != O_constant)
696             {
697               as_bad_where (r->file, r->line, _("invalid reloc expression"));
698               sec = NULL;
699             }
700           else if (sym != NULL)
701             symbol_mark_used_in_reloc (sym);
702         }
703       if (sym == NULL)
704         {
705           if (abs_section_sym == NULL)
706             abs_section_sym = section_symbol (absolute_section);
707           sym = abs_section_sym;
708         }
709
710       howto = r->u.a.howto;
711
712       r->u.b.sec = sec;
713       r->u.b.s = symbol_get_bfdsym (sym);
714       r->u.b.r.sym_ptr_ptr = &r->u.b.s;
715       r->u.b.r.address = offset;
716       r->u.b.r.addend = addend;
717       r->u.b.r.howto = howto;
718     }
719 }
720
721 /* This pass over fixups decides whether symbols can be replaced with
722    section symbols.  */
723
724 static void
725 adjust_reloc_syms (bfd *abfd ATTRIBUTE_UNUSED,
726                    asection *sec,
727                    void *xxx ATTRIBUTE_UNUSED)
728 {
729   segment_info_type *seginfo = seg_info (sec);
730   fixS *fixp;
731
732   if (seginfo == NULL)
733     return;
734
735   dump_section_relocs (abfd, sec, stderr);
736
737   for (fixp = seginfo->fix_root; fixp; fixp = fixp->fx_next)
738     if (fixp->fx_done)
739       /* Ignore it.  */
740       ;
741     else if (fixp->fx_addsy)
742       {
743         symbolS *sym;
744         asection *symsec;
745
746 #ifdef DEBUG5
747         fprintf (stderr, "\n\nadjusting fixup:\n");
748         print_fixup (fixp);
749 #endif
750
751         sym = fixp->fx_addsy;
752
753         /* All symbols should have already been resolved at this
754            point.  It is possible to see unresolved expression
755            symbols, though, since they are not in the regular symbol
756            table.  */
757         resolve_symbol_value (sym);
758
759         if (fixp->fx_subsy != NULL)
760           resolve_symbol_value (fixp->fx_subsy);
761
762         /* If this symbol is equated to an undefined or common symbol,
763            convert the fixup to being against that symbol.  */
764         while (symbol_equated_reloc_p (sym)
765                || S_IS_WEAKREFR (sym))
766           {
767             symbolS *newsym = symbol_get_value_expression (sym)->X_add_symbol;
768             if (sym == newsym)
769               break;
770             fixp->fx_offset += symbol_get_value_expression (sym)->X_add_number;
771             fixp->fx_addsy = newsym;
772             sym = newsym;
773           }
774
775         if (symbol_mri_common_p (sym))
776           {
777             fixp->fx_offset += S_GET_VALUE (sym);
778             fixp->fx_addsy = symbol_get_value_expression (sym)->X_add_symbol;
779             continue;
780           }
781
782         /* If the symbol is undefined, common, weak, or global (ELF
783            shared libs), we can't replace it with the section symbol.  */
784         if (S_FORCE_RELOC (fixp->fx_addsy, 1))
785           continue;
786
787         /* Is there some other (target cpu dependent) reason we can't adjust
788            this one?  (E.g. relocations involving function addresses on
789            the PA.  */
790 #ifdef tc_fix_adjustable
791         if (! tc_fix_adjustable (fixp))
792           continue;
793 #endif
794
795         /* Since we're reducing to section symbols, don't attempt to reduce
796            anything that's already using one.  */
797         if (symbol_section_p (sym))
798           continue;
799
800         symsec = S_GET_SEGMENT (sym);
801         if (symsec == NULL)
802           abort ();
803
804         if (bfd_is_abs_section (symsec))
805           {
806             /* The fixup_segment routine normally will not use this
807                symbol in a relocation.  */
808             continue;
809           }
810
811         /* Don't try to reduce relocs which refer to non-local symbols
812            in .linkonce sections.  It can lead to confusion when a
813            debugging section refers to a .linkonce section.  I hope
814            this will always be correct.  */
815         if (symsec != sec && ! S_IS_LOCAL (sym))
816           {
817             if ((symsec->flags & SEC_LINK_ONCE) != 0
818                 || (IS_ELF
819                     /* The GNU toolchain uses an extension for ELF: a
820                        section beginning with the magic string
821                        .gnu.linkonce is a linkonce section.  */
822                     && strncmp (segment_name (symsec), ".gnu.linkonce",
823                                 sizeof ".gnu.linkonce" - 1) == 0))
824               continue;
825           }
826
827         /* Never adjust a reloc against local symbol in a merge section
828            with non-zero addend.  */
829         if ((symsec->flags & SEC_MERGE) != 0
830             && (fixp->fx_offset != 0 || fixp->fx_subsy != NULL))
831           continue;
832
833         /* Never adjust a reloc against TLS local symbol.  */
834         if ((symsec->flags & SEC_THREAD_LOCAL) != 0)
835           continue;
836
837         /* We refetch the segment when calling section_symbol, rather
838            than using symsec, because S_GET_VALUE may wind up changing
839            the section when it calls resolve_symbol_value.  */
840         fixp->fx_offset += S_GET_VALUE (sym);
841         fixp->fx_addsy = section_symbol (S_GET_SEGMENT (sym));
842 #ifdef DEBUG5
843         fprintf (stderr, "\nadjusted fixup:\n");
844         print_fixup (fixp);
845 #endif
846       }
847
848   dump_section_relocs (abfd, sec, stderr);
849 }
850
851 /* fixup_segment()
852
853    Go through all the fixS's in a segment and see which ones can be
854    handled now.  (These consist of fixS where we have since discovered
855    the value of a symbol, or the address of the frag involved.)
856    For each one, call md_apply_fix to put the fix into the frag data.
857
858    Result is a count of how many relocation structs will be needed to
859    handle the remaining fixS's that we couldn't completely handle here.
860    These will be output later by emit_relocations().  */
861
862 static long
863 fixup_segment (fixS *fixP, segT this_segment)
864 {
865   long seg_reloc_count = 0;
866   valueT add_number;
867   fragS *fragP;
868   segT add_symbol_segment = absolute_section;
869
870   if (fixP != NULL && abs_section_sym == NULL)
871     abs_section_sym = section_symbol (absolute_section);
872
873   /* If the linker is doing the relaxing, we must not do any fixups.
874
875      Well, strictly speaking that's not true -- we could do any that
876      are PC-relative and don't cross regions that could change size.
877      And for the i960 we might be able to turn callx/callj into bal
878      anyways in cases where we know the maximum displacement.  */
879   if (linkrelax && TC_LINKRELAX_FIXUP (this_segment))
880     {
881       for (; fixP; fixP = fixP->fx_next)
882         if (!fixP->fx_done)
883           {
884             if (fixP->fx_addsy == NULL)
885               {
886                 /* There was no symbol required by this relocation.
887                    However, BFD doesn't really handle relocations
888                    without symbols well. So fake up a local symbol in
889                    the absolute section.  */
890                 fixP->fx_addsy = abs_section_sym;
891               }
892             symbol_mark_used_in_reloc (fixP->fx_addsy);
893             if (fixP->fx_subsy != NULL)
894               symbol_mark_used_in_reloc (fixP->fx_subsy);
895             seg_reloc_count++;
896           }
897       TC_ADJUST_RELOC_COUNT (fixP, seg_reloc_count);
898       return seg_reloc_count;
899     }
900
901   for (; fixP; fixP = fixP->fx_next)
902     {
903 #ifdef DEBUG5
904       fprintf (stderr, "\nprocessing fixup:\n");
905       print_fixup (fixP);
906 #endif
907
908       fragP = fixP->fx_frag;
909       know (fragP);
910 #ifdef TC_VALIDATE_FIX
911       TC_VALIDATE_FIX (fixP, this_segment, skip);
912 #endif
913       add_number = fixP->fx_offset;
914
915       if (fixP->fx_addsy != NULL)
916         add_symbol_segment = S_GET_SEGMENT (fixP->fx_addsy);
917
918       if (fixP->fx_subsy != NULL)
919         {
920           segT sub_symbol_segment;
921           resolve_symbol_value (fixP->fx_subsy);
922           sub_symbol_segment = S_GET_SEGMENT (fixP->fx_subsy);
923           if (fixP->fx_addsy != NULL
924               && sub_symbol_segment == add_symbol_segment
925               && !TC_FORCE_RELOCATION_SUB_SAME (fixP, add_symbol_segment))
926             {
927               add_number += S_GET_VALUE (fixP->fx_addsy);
928               add_number -= S_GET_VALUE (fixP->fx_subsy);
929               fixP->fx_offset = add_number;
930               fixP->fx_addsy = NULL;
931               fixP->fx_subsy = NULL;
932 #ifdef TC_M68K
933               /* See the comment below about 68k weirdness.  */
934               fixP->fx_pcrel = 0;
935 #endif
936             }
937           else if (sub_symbol_segment == absolute_section
938                    && !TC_FORCE_RELOCATION_SUB_ABS (fixP, add_symbol_segment))
939             {
940               add_number -= S_GET_VALUE (fixP->fx_subsy);
941               fixP->fx_offset = add_number;
942               fixP->fx_subsy = NULL;
943             }
944           else if (sub_symbol_segment == this_segment
945                    && !TC_FORCE_RELOCATION_SUB_LOCAL (fixP, add_symbol_segment))
946             {
947               add_number -= S_GET_VALUE (fixP->fx_subsy);
948               fixP->fx_offset = (add_number + fixP->fx_dot_value
949                                  + fixP->fx_frag->fr_address);
950
951               /* Make it pc-relative.  If the back-end code has not
952                  selected a pc-relative reloc, cancel the adjustment
953                  we do later on all pc-relative relocs.  */
954               if (0
955 #ifdef TC_M68K
956                   /* Do this for m68k even if it's already described
957                      as pc-relative.  On the m68k, an operand of
958                      "pc@(foo-.-2)" should address "foo" in a
959                      pc-relative mode.  */
960                   || 1
961 #endif
962                   || !fixP->fx_pcrel)
963                 add_number += MD_PCREL_FROM_SECTION (fixP, this_segment);
964               fixP->fx_subsy = NULL;
965               fixP->fx_pcrel = 1;
966             }
967           else if (!TC_VALIDATE_FIX_SUB (fixP, add_symbol_segment))
968             {
969               if (!md_register_arithmetic
970                   && (add_symbol_segment == reg_section
971                       || sub_symbol_segment == reg_section))
972                 as_bad_where (fixP->fx_file, fixP->fx_line,
973                               _("register value used as expression"));
974               else
975                 as_bad_where (fixP->fx_file, fixP->fx_line,
976                               _("can't resolve `%s' {%s section} - `%s' {%s section}"),
977                               fixP->fx_addsy ? S_GET_NAME (fixP->fx_addsy) : "0",
978                               segment_name (add_symbol_segment),
979                               S_GET_NAME (fixP->fx_subsy),
980                               segment_name (sub_symbol_segment));
981             }
982         }
983
984       if (fixP->fx_addsy)
985         {
986           if (add_symbol_segment == this_segment
987               && !TC_FORCE_RELOCATION_LOCAL (fixP))
988             {
989               /* This fixup was made when the symbol's segment was
990                  SEG_UNKNOWN, but it is now in the local segment.
991                  So we know how to do the address without relocation.  */
992               add_number += S_GET_VALUE (fixP->fx_addsy);
993               fixP->fx_offset = add_number;
994               if (fixP->fx_pcrel)
995                 add_number -= MD_PCREL_FROM_SECTION (fixP, this_segment);
996               fixP->fx_addsy = NULL;
997               fixP->fx_pcrel = 0;
998             }
999           else if (add_symbol_segment == absolute_section
1000                    && !TC_FORCE_RELOCATION_ABS (fixP))
1001             {
1002               add_number += S_GET_VALUE (fixP->fx_addsy);
1003               fixP->fx_offset = add_number;
1004               fixP->fx_addsy = NULL;
1005             }
1006           else if (add_symbol_segment != undefined_section
1007                    && ! bfd_is_com_section (add_symbol_segment)
1008                    && MD_APPLY_SYM_VALUE (fixP))
1009             add_number += S_GET_VALUE (fixP->fx_addsy);
1010         }
1011
1012       if (fixP->fx_pcrel)
1013         {
1014           add_number -= MD_PCREL_FROM_SECTION (fixP, this_segment);
1015           if (!fixP->fx_done && fixP->fx_addsy == NULL)
1016             {
1017               /* There was no symbol required by this relocation.
1018                  However, BFD doesn't really handle relocations
1019                  without symbols well. So fake up a local symbol in
1020                  the absolute section.  */
1021               fixP->fx_addsy = abs_section_sym;
1022             }
1023         }
1024
1025       if (!fixP->fx_done)
1026         md_apply_fix (fixP, &add_number, this_segment);
1027
1028       if (!fixP->fx_done)
1029         {
1030           ++seg_reloc_count;
1031           if (fixP->fx_addsy == NULL)
1032             fixP->fx_addsy = abs_section_sym;
1033           symbol_mark_used_in_reloc (fixP->fx_addsy);
1034           if (fixP->fx_subsy != NULL)
1035             symbol_mark_used_in_reloc (fixP->fx_subsy);
1036         }
1037
1038       if (!fixP->fx_bit_fixP && !fixP->fx_no_overflow && fixP->fx_size != 0)
1039         {
1040           if (fixP->fx_size < sizeof (valueT))
1041             {
1042               valueT mask;
1043
1044               mask = 0;
1045               mask--;           /* Set all bits to one.  */
1046               mask <<= fixP->fx_size * 8 - (fixP->fx_signed ? 1 : 0);
1047               if ((add_number & mask) != 0 && (add_number & mask) != mask)
1048                 {
1049                   char buf[50], buf2[50];
1050                   sprint_value (buf, fragP->fr_address + fixP->fx_where);
1051                   if (add_number > 1000)
1052                     sprint_value (buf2, add_number);
1053                   else
1054                     sprintf (buf2, "%ld", (long) add_number);
1055                   as_bad_where (fixP->fx_file, fixP->fx_line,
1056                                 _("value of %s too large for field of %d bytes at %s"),
1057                                 buf2, fixP->fx_size, buf);
1058                 } /* Generic error checking.  */
1059             }
1060 #ifdef WARN_SIGNED_OVERFLOW_WORD
1061           /* Warn if a .word value is too large when treated as a signed
1062              number.  We already know it is not too negative.  This is to
1063              catch over-large switches generated by gcc on the 68k.  */
1064           if (!flag_signed_overflow_ok
1065               && fixP->fx_size == 2
1066               && add_number > 0x7fff)
1067             as_bad_where (fixP->fx_file, fixP->fx_line,
1068                           _("signed .word overflow; switch may be too large; %ld at 0x%lx"),
1069                           (long) add_number,
1070                           (long) (fragP->fr_address + fixP->fx_where));
1071 #endif
1072         }                       /* Not a bit fix.  */
1073
1074 #ifdef TC_VALIDATE_FIX
1075     skip:  ATTRIBUTE_UNUSED_LABEL
1076       ;
1077 #endif
1078 #ifdef DEBUG5
1079       fprintf (stderr, "result:\n");
1080       print_fixup (fixP);
1081 #endif
1082     }                           /* For each fixS in this segment.  */
1083
1084   TC_ADJUST_RELOC_COUNT (fixP, seg_reloc_count);
1085   return seg_reloc_count;
1086 }
1087
1088 static void
1089 fix_segment (bfd *abfd ATTRIBUTE_UNUSED,
1090              asection *sec,
1091              void *xxx ATTRIBUTE_UNUSED)
1092 {
1093   segment_info_type *seginfo = seg_info (sec);
1094
1095   fixup_segment (seginfo->fix_root, sec);
1096 }
1097
1098 static void
1099 install_reloc (asection *sec, arelent *reloc, fragS *fragp,
1100                char *file, unsigned int line)
1101 {
1102   char *err;
1103   bfd_reloc_status_type s;
1104   asymbol *sym;
1105
1106   if (reloc->sym_ptr_ptr != NULL
1107       && (sym = *reloc->sym_ptr_ptr) != NULL
1108       && (sym->flags & BSF_KEEP) == 0
1109       && ((sym->flags & BSF_SECTION_SYM) == 0
1110           || (EMIT_SECTION_SYMBOLS
1111               && !bfd_is_abs_section (sym->section))))
1112     as_bad_where (file, line, _("redefined symbol cannot be used on reloc"));
1113
1114   s = bfd_install_relocation (stdoutput, reloc,
1115                               fragp->fr_literal, fragp->fr_address,
1116                               sec, &err);
1117   switch (s)
1118     {
1119     case bfd_reloc_ok:
1120       break;
1121     case bfd_reloc_overflow:
1122       as_bad_where (file, line, _("relocation overflow"));
1123       break;
1124     case bfd_reloc_outofrange:
1125       as_bad_where (file, line, _("relocation out of range"));
1126       break;
1127     default:
1128       as_fatal (_("%s:%u: bad return from bfd_install_relocation: %x"),
1129                 file, line, s);
1130     }
1131 }
1132
1133 static void
1134 write_relocs (bfd *abfd, asection *sec, void *xxx ATTRIBUTE_UNUSED)
1135 {
1136   segment_info_type *seginfo = seg_info (sec);
1137   unsigned int i;
1138   unsigned int n;
1139   struct reloc_list *my_reloc_list, **rp, *r;
1140   arelent **relocs;
1141   fixS *fixp;
1142
1143   /* If seginfo is NULL, we did not create this section; don't do
1144      anything with it.  */
1145   if (seginfo == NULL)
1146     return;
1147
1148   n = 0;
1149   for (fixp = seginfo->fix_root; fixp; fixp = fixp->fx_next)
1150     if (!fixp->fx_done)
1151       n++;
1152
1153 #ifdef RELOC_EXPANSION_POSSIBLE
1154   n *= MAX_RELOC_EXPANSION;
1155 #endif
1156
1157   /* Extract relocs for this section from reloc_list.  */
1158   rp = &reloc_list;
1159   my_reloc_list = NULL;
1160   while ((r = *rp) != NULL)
1161     {
1162       if (r->u.b.sec == sec)
1163         {
1164           *rp = r->next;
1165           r->next = my_reloc_list;
1166           my_reloc_list = r;
1167           n++;
1168         }
1169       else
1170         rp = &r->next;
1171     }
1172
1173   relocs = (arelent **) xcalloc (n, sizeof (arelent *));
1174
1175   i = 0;
1176   for (fixp = seginfo->fix_root; fixp != (fixS *) NULL; fixp = fixp->fx_next)
1177     {
1178       int j;
1179       int fx_size, slack;
1180       offsetT loc;
1181
1182       if (fixp->fx_done)
1183         continue;
1184
1185       fx_size = fixp->fx_size;
1186       slack = TC_FX_SIZE_SLACK (fixp);
1187       if (slack > 0)
1188         fx_size = fx_size > slack ? fx_size - slack : 0;
1189       loc = fixp->fx_where + fx_size;
1190       if (slack >= 0 && loc > fixp->fx_frag->fr_fix)
1191         as_bad_where (fixp->fx_file, fixp->fx_line,
1192                       _("internal error: fixup not contained within frag"));
1193
1194 #ifndef RELOC_EXPANSION_POSSIBLE
1195       {
1196         arelent *reloc = tc_gen_reloc (sec, fixp);
1197
1198         if (!reloc)
1199           continue;
1200         relocs[i++] = reloc;
1201         j = 1;
1202       }
1203 #else
1204       {
1205         arelent **reloc = tc_gen_reloc (sec, fixp);
1206
1207         for (j = 0; reloc[j]; j++)
1208           relocs[i++] = reloc[j];
1209       }
1210 #endif
1211
1212       for ( ; j != 0; --j)
1213         install_reloc (sec, relocs[i - j], fixp->fx_frag,
1214                        fixp->fx_file, fixp->fx_line);
1215     }
1216   n = i;
1217
1218 #ifdef DEBUG4
1219   {
1220     unsigned int i, j, nsyms;
1221     asymbol **sympp;
1222     sympp = bfd_get_outsymbols (stdoutput);
1223     nsyms = bfd_get_symcount (stdoutput);
1224     for (i = 0; i < n; i++)
1225       if (((*relocs[i]->sym_ptr_ptr)->flags & BSF_SECTION_SYM) == 0)
1226         {
1227           for (j = 0; j < nsyms; j++)
1228             if (sympp[j] == *relocs[i]->sym_ptr_ptr)
1229               break;
1230           if (j == nsyms)
1231             abort ();
1232         }
1233   }
1234 #endif
1235
1236   for (r = my_reloc_list; r != NULL; r = r->next)
1237     {
1238       fragS *f;
1239       for (f = seginfo->frchainP->frch_root; f; f = f->fr_next)
1240         if (f->fr_address <= r->u.b.r.address
1241             && r->u.b.r.address < f->fr_address + f->fr_fix)
1242           break;
1243       if (f == NULL)
1244         as_bad_where (r->file, r->line,
1245                       _("reloc not within (fixed part of) section"));
1246       else
1247         {
1248           relocs[n++] = &r->u.b.r;
1249           install_reloc (sec, &r->u.b.r, f, r->file, r->line);
1250         }
1251     }
1252
1253   if (n)
1254     {
1255       flagword flags = bfd_get_section_flags (abfd, sec);
1256       flags |= SEC_RELOC;
1257       bfd_set_section_flags (abfd, sec, flags);
1258       bfd_set_reloc (stdoutput, sec, relocs, n);
1259     }
1260
1261 #ifdef SET_SECTION_RELOCS
1262   SET_SECTION_RELOCS (sec, relocs, n);
1263 #endif
1264
1265 #ifdef DEBUG3
1266   {
1267     unsigned int i;
1268     arelent *r;
1269     asymbol *s;
1270     fprintf (stderr, "relocs for sec %s\n", sec->name);
1271     for (i = 0; i < n; i++)
1272       {
1273         r = relocs[i];
1274         s = *r->sym_ptr_ptr;
1275         fprintf (stderr, "  reloc %2d @%p off %4lx : sym %-10s addend %lx\n",
1276                  i, r, (unsigned long)r->address, s->name, (unsigned long)r->addend);
1277       }
1278   }
1279 #endif
1280 }
1281
1282 static void
1283 write_contents (bfd *abfd ATTRIBUTE_UNUSED,
1284                 asection *sec,
1285                 void *xxx ATTRIBUTE_UNUSED)
1286 {
1287   segment_info_type *seginfo = seg_info (sec);
1288   addressT offset = 0;
1289   fragS *f;
1290
1291   /* Write out the frags.  */
1292   if (seginfo == NULL
1293       || !(bfd_get_section_flags (abfd, sec) & SEC_HAS_CONTENTS))
1294     return;
1295
1296   for (f = seginfo->frchainP->frch_root;
1297        f;
1298        f = f->fr_next)
1299     {
1300       int x;
1301       addressT fill_size;
1302       char *fill_literal;
1303       offsetT count;
1304
1305       gas_assert (f->fr_type == rs_fill);
1306       if (f->fr_fix)
1307         {
1308           x = bfd_set_section_contents (stdoutput, sec,
1309                                         f->fr_literal, (file_ptr) offset,
1310                                         (bfd_size_type) f->fr_fix);
1311           if (!x)
1312             as_fatal (_("can't write %s: %s"), stdoutput->filename,
1313                       bfd_errmsg (bfd_get_error ()));
1314           offset += f->fr_fix;
1315         }
1316       fill_literal = f->fr_literal + f->fr_fix;
1317       fill_size = f->fr_var;
1318       count = f->fr_offset;
1319       gas_assert (count >= 0);
1320       if (fill_size && count)
1321         {
1322           char buf[256];
1323           if (fill_size > sizeof (buf))
1324             {
1325               /* Do it the old way. Can this ever happen?  */
1326               while (count--)
1327                 {
1328                   x = bfd_set_section_contents (stdoutput, sec,
1329                                                 fill_literal,
1330                                                 (file_ptr) offset,
1331                                                 (bfd_size_type) fill_size);
1332                   if (!x)
1333                     as_fatal (_("can't write %s: %s"), stdoutput->filename,
1334                               bfd_errmsg (bfd_get_error ()));
1335                   offset += fill_size;
1336                 }
1337             }
1338           else
1339             {
1340               /* Build a buffer full of fill objects and output it as
1341                  often as necessary. This saves on the overhead of
1342                  potentially lots of bfd_set_section_contents calls.  */
1343               int n_per_buf, i;
1344               if (fill_size == 1)
1345                 {
1346                   n_per_buf = sizeof (buf);
1347                   memset (buf, *fill_literal, n_per_buf);
1348                 }
1349               else
1350                 {
1351                   char *bufp;
1352                   n_per_buf = sizeof (buf) / fill_size;
1353                   for (i = n_per_buf, bufp = buf; i; i--, bufp += fill_size)
1354                     memcpy (bufp, fill_literal, fill_size);
1355                 }
1356               for (; count > 0; count -= n_per_buf)
1357                 {
1358                   n_per_buf = n_per_buf > count ? count : n_per_buf;
1359                   x = bfd_set_section_contents
1360                     (stdoutput, sec, buf, (file_ptr) offset,
1361                      (bfd_size_type) n_per_buf * fill_size);
1362                   if (!x)
1363                     as_fatal (_("cannot write to output file"));
1364                   offset += n_per_buf * fill_size;
1365                 }
1366             }
1367         }
1368     }
1369 }
1370
1371 static void
1372 merge_data_into_text (void)
1373 {
1374   seg_info (text_section)->frchainP->frch_last->fr_next =
1375     seg_info (data_section)->frchainP->frch_root;
1376   seg_info (text_section)->frchainP->frch_last =
1377     seg_info (data_section)->frchainP->frch_last;
1378   seg_info (data_section)->frchainP = 0;
1379 }
1380
1381 static void
1382 set_symtab (void)
1383 {
1384   int nsyms;
1385   asymbol **asympp;
1386   symbolS *symp;
1387   bfd_boolean result;
1388
1389   /* Count symbols.  We can't rely on a count made by the loop in
1390      write_object_file, because *_frob_file may add a new symbol or
1391      two.  */
1392   nsyms = 0;
1393   for (symp = symbol_rootP; symp; symp = symbol_next (symp))
1394     nsyms++;
1395
1396   if (nsyms)
1397     {
1398       int i;
1399       bfd_size_type amt = (bfd_size_type) nsyms * sizeof (asymbol *);
1400
1401       asympp = (asymbol **) bfd_alloc (stdoutput, amt);
1402       symp = symbol_rootP;
1403       for (i = 0; i < nsyms; i++, symp = symbol_next (symp))
1404         {
1405           asympp[i] = symbol_get_bfdsym (symp);
1406           if (asympp[i]->flags != BSF_SECTION_SYM
1407               || !(bfd_is_const_section (asympp[i]->section)
1408                    && asympp[i]->section->symbol == asympp[i]))
1409             asympp[i]->flags |= BSF_KEEP;
1410           symbol_mark_written (symp);
1411         }
1412     }
1413   else
1414     asympp = 0;
1415   result = bfd_set_symtab (stdoutput, asympp, nsyms);
1416   gas_assert (result);
1417   symbol_table_frozen = 1;
1418 }
1419
1420 /* Finish the subsegments.  After every sub-segment, we fake an
1421    ".align ...".  This conforms to BSD4.2 brane-damage.  We then fake
1422    ".fill 0" because that is the kind of frag that requires least
1423    thought.  ".align" frags like to have a following frag since that
1424    makes calculating their intended length trivial.  */
1425
1426 #ifndef SUB_SEGMENT_ALIGN
1427 #ifdef HANDLE_ALIGN
1428 /* The last subsegment gets an alignment corresponding to the alignment
1429    of the section.  This allows proper nop-filling at the end of
1430    code-bearing sections.  */
1431 #define SUB_SEGMENT_ALIGN(SEG, FRCHAIN)                                 \
1432   (!(FRCHAIN)->frch_next ? get_recorded_alignment (SEG) : 0)
1433 #else
1434 #define SUB_SEGMENT_ALIGN(SEG, FRCHAIN) 0
1435 #endif
1436 #endif
1437
1438 void
1439 subsegs_finish (void)
1440 {
1441   struct frchain *frchainP;
1442   asection *s;
1443
1444   for (s = stdoutput->sections; s; s = s->next)
1445     {
1446       segment_info_type *seginfo = seg_info (s);
1447       if (!seginfo)
1448         continue;
1449
1450       for (frchainP = seginfo->frchainP;
1451            frchainP != NULL;
1452            frchainP = frchainP->frch_next)
1453         {
1454           int alignment = 0;
1455
1456           subseg_set (s, frchainP->frch_subseg);
1457
1458           /* This now gets called even if we had errors.  In that case,
1459              any alignment is meaningless, and, moreover, will look weird
1460              if we are generating a listing.  */
1461           if (!had_errors ())
1462             {
1463               alignment = SUB_SEGMENT_ALIGN (now_seg, frchainP);
1464               if ((bfd_get_section_flags (now_seg->owner, now_seg) & SEC_MERGE)
1465                   && now_seg->entsize)
1466                 {
1467                   unsigned int entsize = now_seg->entsize;
1468                   int entalign = 0;
1469
1470                   while ((entsize & 1) == 0)
1471                     {
1472                       ++entalign;
1473                       entsize >>= 1;
1474                     }
1475                   if (entalign > alignment)
1476                     alignment = entalign;
1477                 }
1478             }
1479
1480           if (subseg_text_p (now_seg))
1481             frag_align_code (alignment, 0);
1482           else
1483             frag_align (alignment, 0, 0);
1484
1485           /* frag_align will have left a new frag.
1486              Use this last frag for an empty ".fill".
1487
1488              For this segment ...
1489              Create a last frag. Do not leave a "being filled in frag".  */
1490           frag_wane (frag_now);
1491           frag_now->fr_fix = 0;
1492           know (frag_now->fr_next == NULL);
1493         }
1494     }
1495 }
1496
1497 /* Write the object file.  */
1498
1499 void
1500 write_object_file (void)
1501 {
1502   struct relax_seg_info rsi;
1503 #ifndef WORKING_DOT_WORD
1504   fragS *fragP;                 /* Track along all frags.  */
1505 #endif
1506
1507   /* Do we really want to write it?  */
1508   {
1509     int n_warns, n_errs;
1510     n_warns = had_warnings ();
1511     n_errs = had_errors ();
1512     /* The -Z flag indicates that an object file should be generated,
1513        regardless of warnings and errors.  */
1514     if (flag_always_generate_output)
1515       {
1516         if (n_warns || n_errs)
1517           as_warn (_("%d error%s, %d warning%s, generating bad object file"),
1518                    n_errs, n_errs == 1 ? "" : "s",
1519                    n_warns, n_warns == 1 ? "" : "s");
1520       }
1521     else
1522       {
1523         if (n_errs)
1524           as_fatal (_("%d error%s, %d warning%s, no object file generated"),
1525                     n_errs, n_errs == 1 ? "" : "s",
1526                     n_warns, n_warns == 1 ? "" : "s");
1527       }
1528   }
1529
1530 #ifdef  OBJ_VMS
1531   /* Under VMS we try to be compatible with VAX-11 "C".  Thus, we call
1532      a routine to check for the definition of the procedure "_main",
1533      and if so -- fix it up so that it can be program entry point.  */
1534   vms_check_for_main ();
1535 #endif /* OBJ_VMS  */
1536
1537   /* From now on, we don't care about sub-segments.  Build one frag chain
1538      for each segment. Linked thru fr_next.  */
1539
1540   /* Remove the sections created by gas for its own purposes.  */
1541   {
1542     int i;
1543
1544     bfd_section_list_remove (stdoutput, reg_section);
1545     bfd_section_list_remove (stdoutput, expr_section);
1546     stdoutput->section_count -= 2;
1547     i = 0;
1548     bfd_map_over_sections (stdoutput, renumber_sections, &i);
1549   }
1550
1551   bfd_map_over_sections (stdoutput, chain_frchains_together, (char *) 0);
1552
1553   /* We have two segments. If user gave -R flag, then we must put the
1554      data frags into the text segment. Do this before relaxing so
1555      we know to take advantage of -R and make shorter addresses.  */
1556   if (flag_readonly_data_in_text)
1557     {
1558       merge_data_into_text ();
1559     }
1560
1561   rsi.pass = 0;
1562   while (1)
1563     {
1564 #ifndef WORKING_DOT_WORD
1565       /* We need to reset the markers in the broken word list and
1566          associated frags between calls to relax_segment (via
1567          relax_seg).  Since the broken word list is global, we do it
1568          once per round, rather than locally in relax_segment for each
1569          segment.  */
1570       struct broken_word *brokp;
1571
1572       for (brokp = broken_words;
1573            brokp != (struct broken_word *) NULL;
1574            brokp = brokp->next_broken_word)
1575         {
1576           brokp->added = 0;
1577
1578           if (brokp->dispfrag != (fragS *) NULL
1579               && brokp->dispfrag->fr_type == rs_broken_word)
1580             brokp->dispfrag->fr_subtype = 0;
1581         }
1582 #endif
1583
1584       rsi.changed = 0;
1585       bfd_map_over_sections (stdoutput, relax_seg, &rsi);
1586       rsi.pass++;
1587       if (!rsi.changed)
1588         break;
1589     }
1590
1591   /* Note - Most ports will use the default value of
1592      TC_FINALIZE_SYMS_BEFORE_SIZE_SEG, which 1.  This will force
1593      local symbols to be resolved, removing their frag information.
1594      Some ports however, will not have finished relaxing all of
1595      their frags and will still need the local symbol frag
1596      information.  These ports can set
1597      TC_FINALIZE_SYMS_BEFORE_SIZE_SEG to 0.  */
1598   finalize_syms = TC_FINALIZE_SYMS_BEFORE_SIZE_SEG;
1599
1600   bfd_map_over_sections (stdoutput, size_seg, (char *) 0);
1601
1602   /* Relaxation has completed.  Freeze all syms.  */
1603   finalize_syms = 1;
1604
1605 #ifdef md_post_relax_hook
1606   md_post_relax_hook;
1607 #endif
1608
1609 #ifndef WORKING_DOT_WORD
1610   {
1611     struct broken_word *lie;
1612     struct broken_word **prevP;
1613
1614     prevP = &broken_words;
1615     for (lie = broken_words; lie; lie = lie->next_broken_word)
1616       if (!lie->added)
1617         {
1618           expressionS exp;
1619
1620           subseg_change (lie->seg, lie->subseg);
1621           exp.X_op = O_subtract;
1622           exp.X_add_symbol = lie->add;
1623           exp.X_op_symbol = lie->sub;
1624           exp.X_add_number = lie->addnum;
1625 #ifdef TC_CONS_FIX_NEW
1626           TC_CONS_FIX_NEW (lie->frag,
1627                            lie->word_goes_here - lie->frag->fr_literal,
1628                            2, &exp);
1629 #else
1630           fix_new_exp (lie->frag,
1631                        lie->word_goes_here - lie->frag->fr_literal,
1632                        2, &exp, 0, BFD_RELOC_16);
1633 #endif
1634           *prevP = lie->next_broken_word;
1635         }
1636       else
1637         prevP = &(lie->next_broken_word);
1638
1639     for (lie = broken_words; lie;)
1640       {
1641         struct broken_word *untruth;
1642         char *table_ptr;
1643         addressT table_addr;
1644         addressT from_addr, to_addr;
1645         int n, m;
1646
1647         subseg_change (lie->seg, lie->subseg);
1648         fragP = lie->dispfrag;
1649
1650         /* Find out how many broken_words go here.  */
1651         n = 0;
1652         for (untruth = lie;
1653              untruth && untruth->dispfrag == fragP;
1654              untruth = untruth->next_broken_word)
1655           if (untruth->added == 1)
1656             n++;
1657
1658         table_ptr = lie->dispfrag->fr_opcode;
1659         table_addr = (lie->dispfrag->fr_address
1660                       + (table_ptr - lie->dispfrag->fr_literal));
1661         /* Create the jump around the long jumps.  This is a short
1662            jump from table_ptr+0 to table_ptr+n*long_jump_size.  */
1663         from_addr = table_addr;
1664         to_addr = table_addr + md_short_jump_size + n * md_long_jump_size;
1665         md_create_short_jump (table_ptr, from_addr, to_addr, lie->dispfrag,
1666                               lie->add);
1667         table_ptr += md_short_jump_size;
1668         table_addr += md_short_jump_size;
1669
1670         for (m = 0;
1671              lie && lie->dispfrag == fragP;
1672              m++, lie = lie->next_broken_word)
1673           {
1674             if (lie->added == 2)
1675               continue;
1676             /* Patch the jump table.  */
1677             for (untruth = (struct broken_word *) (fragP->fr_symbol);
1678                  untruth && untruth->dispfrag == fragP;
1679                  untruth = untruth->next_broken_word)
1680               {
1681                 if (untruth->use_jump == lie)
1682                   {
1683                     /* This is the offset from ??? to table_ptr+0.
1684                        The target is the same for all users of this
1685                        md_long_jump, but the "sub" bases (and hence the
1686                        offsets) may be different.  */
1687                     addressT to_word = table_addr - S_GET_VALUE (untruth->sub);
1688 #ifdef TC_CHECK_ADJUSTED_BROKEN_DOT_WORD
1689                     TC_CHECK_ADJUSTED_BROKEN_DOT_WORD (to_word, untruth);
1690 #endif
1691                     md_number_to_chars (untruth->word_goes_here, to_word, 2);
1692                   }
1693               }
1694
1695             /* Install the long jump.  */
1696             /* This is a long jump from table_ptr+0 to the final target.  */
1697             from_addr = table_addr;
1698             to_addr = S_GET_VALUE (lie->add) + lie->addnum;
1699             md_create_long_jump (table_ptr, from_addr, to_addr, lie->dispfrag,
1700                                  lie->add);
1701             table_ptr += md_long_jump_size;
1702             table_addr += md_long_jump_size;
1703           }
1704       }
1705   }
1706 #endif /* not WORKING_DOT_WORD  */
1707
1708   /* Resolve symbol values.  This needs to be done before processing
1709      the relocations.  */
1710   if (symbol_rootP)
1711     {
1712       symbolS *symp;
1713
1714       for (symp = symbol_rootP; symp; symp = symbol_next (symp))
1715         resolve_symbol_value (symp);
1716     }
1717   resolve_local_symbol_values ();
1718   resolve_reloc_expr_symbols ();
1719
1720   PROGRESS (1);
1721
1722 #ifdef tc_frob_file_before_adjust
1723   tc_frob_file_before_adjust ();
1724 #endif
1725 #ifdef obj_frob_file_before_adjust
1726   obj_frob_file_before_adjust ();
1727 #endif
1728
1729   bfd_map_over_sections (stdoutput, adjust_reloc_syms, (char *) 0);
1730
1731 #ifdef tc_frob_file_before_fix
1732   tc_frob_file_before_fix ();
1733 #endif
1734 #ifdef obj_frob_file_before_fix
1735   obj_frob_file_before_fix ();
1736 #endif
1737
1738   bfd_map_over_sections (stdoutput, fix_segment, (char *) 0);
1739
1740   /* Set up symbol table, and write it out.  */
1741   if (symbol_rootP)
1742     {
1743       symbolS *symp;
1744       bfd_boolean skip_next_symbol = FALSE;
1745
1746       for (symp = symbol_rootP; symp; symp = symbol_next (symp))
1747         {
1748           int punt = 0;
1749           const char *name;
1750
1751           if (skip_next_symbol)
1752             {
1753               /* Don't do anything besides moving the value of the
1754                  symbol from the GAS value-field to the BFD value-field.  */
1755               symbol_get_bfdsym (symp)->value = S_GET_VALUE (symp);
1756               skip_next_symbol = FALSE;
1757               continue;
1758             }
1759
1760           if (symbol_mri_common_p (symp))
1761             {
1762               if (S_IS_EXTERNAL (symp))
1763                 as_bad (_("%s: global symbols not supported in common sections"),
1764                         S_GET_NAME (symp));
1765               symbol_remove (symp, &symbol_rootP, &symbol_lastP);
1766               continue;
1767             }
1768
1769           name = S_GET_NAME (symp);
1770           if (name)
1771             {
1772               const char *name2 =
1773                 decode_local_label_name ((char *) S_GET_NAME (symp));
1774               /* They only differ if `name' is a fb or dollar local
1775                  label name.  */
1776               if (name2 != name && ! S_IS_DEFINED (symp))
1777                 as_bad (_("local label `%s' is not defined"), name2);
1778             }
1779
1780           /* Do it again, because adjust_reloc_syms might introduce
1781              more symbols.  They'll probably only be section symbols,
1782              but they'll still need to have the values computed.  */
1783           resolve_symbol_value (symp);
1784
1785           /* Skip symbols which were equated to undefined or common
1786              symbols.  */
1787           if (symbol_equated_reloc_p (symp)
1788               || S_IS_WEAKREFR (symp))
1789             {
1790               const char *name = S_GET_NAME (symp);
1791               if (S_IS_COMMON (symp)
1792                   && !TC_FAKE_LABEL (name)
1793                   && !S_IS_WEAKREFR (symp)
1794                   && (!S_IS_EXTERNAL (symp) || S_IS_LOCAL (symp)))
1795                 {
1796                   expressionS *e = symbol_get_value_expression (symp);
1797                   as_bad (_("Local symbol `%s' can't be equated to common symbol `%s'"),
1798                           name, S_GET_NAME (e->X_add_symbol));
1799                 }
1800               if (S_GET_SEGMENT (symp) == reg_section)
1801                 {
1802                   /* Report error only if we know the symbol name.  */
1803                   if (S_GET_NAME (symp) != reg_section->name)
1804                     as_bad (_("can't make global register symbol `%s'"),
1805                             name);
1806                 }
1807               symbol_remove (symp, &symbol_rootP, &symbol_lastP);
1808               continue;
1809             }
1810
1811 #ifdef obj_frob_symbol
1812           obj_frob_symbol (symp, punt);
1813 #endif
1814 #ifdef tc_frob_symbol
1815           if (! punt || symbol_used_in_reloc_p (symp))
1816             tc_frob_symbol (symp, punt);
1817 #endif
1818
1819           /* If we don't want to keep this symbol, splice it out of
1820              the chain now.  If EMIT_SECTION_SYMBOLS is 0, we never
1821              want section symbols.  Otherwise, we skip local symbols
1822              and symbols that the frob_symbol macros told us to punt,
1823              but we keep such symbols if they are used in relocs.  */
1824           if (symp == abs_section_sym
1825               || (! EMIT_SECTION_SYMBOLS
1826                   && symbol_section_p (symp))
1827               /* Note that S_IS_EXTERNAL and S_IS_LOCAL are not always
1828                  opposites.  Sometimes the former checks flags and the
1829                  latter examines the name...  */
1830               || (!S_IS_EXTERNAL (symp)
1831                   && (punt || S_IS_LOCAL (symp) ||
1832                       (S_IS_WEAKREFD (symp) && ! symbol_used_p (symp)))
1833                   && ! symbol_used_in_reloc_p (symp)))
1834             {
1835               symbol_remove (symp, &symbol_rootP, &symbol_lastP);
1836
1837               /* After symbol_remove, symbol_next(symp) still returns
1838                  the one that came after it in the chain.  So we don't
1839                  need to do any extra cleanup work here.  */
1840               continue;
1841             }
1842
1843           /* Make sure we really got a value for the symbol.  */
1844           if (! symbol_resolved_p (symp))
1845             {
1846               as_bad (_("can't resolve value for symbol `%s'"),
1847                       S_GET_NAME (symp));
1848               symbol_mark_resolved (symp);
1849             }
1850
1851           /* Set the value into the BFD symbol.  Up til now the value
1852              has only been kept in the gas symbolS struct.  */
1853           symbol_get_bfdsym (symp)->value = S_GET_VALUE (symp);
1854
1855           /* A warning construct is a warning symbol followed by the
1856              symbol warned about.  Don't let anything object-format or
1857              target-specific muck with it; it's ready for output.  */
1858           if (symbol_get_bfdsym (symp)->flags & BSF_WARNING)
1859             skip_next_symbol = TRUE;
1860         }
1861     }
1862
1863   PROGRESS (1);
1864
1865   /* Now do any format-specific adjustments to the symbol table, such
1866      as adding file symbols.  */
1867 #ifdef tc_adjust_symtab
1868   tc_adjust_symtab ();
1869 #endif
1870 #ifdef obj_adjust_symtab
1871   obj_adjust_symtab ();
1872 #endif
1873
1874   /* Stop if there is an error.  */
1875   if (had_errors ())
1876     return;
1877
1878   /* Now that all the sizes are known, and contents correct, we can
1879      start writing to the file.  */
1880   set_symtab ();
1881
1882   /* If *_frob_file changes the symbol value at this point, it is
1883      responsible for moving the changed value into symp->bsym->value
1884      as well.  Hopefully all symbol value changing can be done in
1885      *_frob_symbol.  */
1886 #ifdef tc_frob_file
1887   tc_frob_file ();
1888 #endif
1889 #ifdef obj_frob_file
1890   obj_frob_file ();
1891 #endif
1892 #ifdef obj_coff_generate_pdata
1893   obj_coff_generate_pdata ();
1894 #endif
1895   bfd_map_over_sections (stdoutput, write_relocs, (char *) 0);
1896
1897 #ifdef tc_frob_file_after_relocs
1898   tc_frob_file_after_relocs ();
1899 #endif
1900 #ifdef obj_frob_file_after_relocs
1901   obj_frob_file_after_relocs ();
1902 #endif
1903
1904   bfd_map_over_sections (stdoutput, write_contents, (char *) 0);
1905 }
1906
1907 #ifdef TC_GENERIC_RELAX_TABLE
1908 /* Relax a fragment by scanning TC_GENERIC_RELAX_TABLE.  */
1909
1910 long
1911 relax_frag (segT segment, fragS *fragP, long stretch)
1912 {
1913   const relax_typeS *this_type;
1914   const relax_typeS *start_type;
1915   relax_substateT next_state;
1916   relax_substateT this_state;
1917   offsetT growth;
1918   offsetT aim;
1919   addressT target;
1920   addressT address;
1921   symbolS *symbolP;
1922   const relax_typeS *table;
1923
1924   target = fragP->fr_offset;
1925   address = fragP->fr_address;
1926   table = TC_GENERIC_RELAX_TABLE;
1927   this_state = fragP->fr_subtype;
1928   start_type = this_type = table + this_state;
1929   symbolP = fragP->fr_symbol;
1930
1931   if (symbolP)
1932     {
1933       fragS *sym_frag;
1934
1935       sym_frag = symbol_get_frag (symbolP);
1936
1937 #ifndef DIFF_EXPR_OK
1938       know (sym_frag != NULL);
1939 #endif
1940       know (S_GET_SEGMENT (symbolP) != absolute_section
1941             || sym_frag == &zero_address_frag);
1942       target += S_GET_VALUE (symbolP);
1943
1944       /* If frag has yet to be reached on this pass,
1945          assume it will move by STRETCH just as we did.
1946          If this is not so, it will be because some frag
1947          between grows, and that will force another pass.  */
1948
1949       if (stretch != 0
1950           && sym_frag->relax_marker != fragP->relax_marker
1951           && S_GET_SEGMENT (symbolP) == segment)
1952         {
1953           target += stretch;
1954         }
1955     }
1956
1957   aim = target - address - fragP->fr_fix;
1958 #ifdef TC_PCREL_ADJUST
1959   /* Currently only the ns32k family needs this.  */
1960   aim += TC_PCREL_ADJUST (fragP);
1961 #endif
1962
1963 #ifdef md_prepare_relax_scan
1964   /* Formerly called M68K_AIM_KLUDGE.  */
1965   md_prepare_relax_scan (fragP, address, aim, this_state, this_type);
1966 #endif
1967
1968   if (aim < 0)
1969     {
1970       /* Look backwards.  */
1971       for (next_state = this_type->rlx_more; next_state;)
1972         if (aim >= this_type->rlx_backward)
1973           next_state = 0;
1974         else
1975           {
1976             /* Grow to next state.  */
1977             this_state = next_state;
1978             this_type = table + this_state;
1979             next_state = this_type->rlx_more;
1980           }
1981     }
1982   else
1983     {
1984       /* Look forwards.  */
1985       for (next_state = this_type->rlx_more; next_state;)
1986         if (aim <= this_type->rlx_forward)
1987           next_state = 0;
1988         else
1989           {
1990             /* Grow to next state.  */
1991             this_state = next_state;
1992             this_type = table + this_state;
1993             next_state = this_type->rlx_more;
1994           }
1995     }
1996
1997   growth = this_type->rlx_length - start_type->rlx_length;
1998   if (growth != 0)
1999     fragP->fr_subtype = this_state;
2000   return growth;
2001 }
2002
2003 #endif /* defined (TC_GENERIC_RELAX_TABLE)  */
2004
2005 /* Relax_align. Advance location counter to next address that has 'alignment'
2006    lowest order bits all 0s, return size of adjustment made.  */
2007 static relax_addressT
2008 relax_align (register relax_addressT address,   /* Address now.  */
2009              register int alignment     /* Alignment (binary).  */)
2010 {
2011   relax_addressT mask;
2012   relax_addressT new_address;
2013
2014   mask = ~((~0) << alignment);
2015   new_address = (address + mask) & (~mask);
2016 #ifdef LINKER_RELAXING_SHRINKS_ONLY
2017   if (linkrelax)
2018     /* We must provide lots of padding, so the linker can discard it
2019        when needed.  The linker will not add extra space, ever.  */
2020     new_address += (1 << alignment);
2021 #endif
2022   return (new_address - address);
2023 }
2024
2025 /* Now we have a segment, not a crowd of sub-segments, we can make
2026    fr_address values.
2027
2028    Relax the frags.
2029
2030    After this, all frags in this segment have addresses that are correct
2031    within the segment. Since segments live in different file addresses,
2032    these frag addresses may not be the same as final object-file
2033    addresses.  */
2034
2035 int
2036 relax_segment (struct frag *segment_frag_root, segT segment, int pass)
2037 {
2038   unsigned long frag_count;
2039   struct frag *fragP;
2040   relax_addressT address;
2041   int ret;
2042
2043   /* In case md_estimate_size_before_relax() wants to make fixSs.  */
2044   subseg_change (segment, 0);
2045
2046   /* For each frag in segment: count and store  (a 1st guess of)
2047      fr_address.  */
2048   address = 0;
2049   for (frag_count = 0, fragP = segment_frag_root;
2050        fragP;
2051        fragP = fragP->fr_next, frag_count ++)
2052     {
2053       fragP->relax_marker = 0;
2054       fragP->fr_address = address;
2055       address += fragP->fr_fix;
2056
2057       switch (fragP->fr_type)
2058         {
2059         case rs_fill:
2060           address += fragP->fr_offset * fragP->fr_var;
2061           break;
2062
2063         case rs_align:
2064         case rs_align_code:
2065         case rs_align_test:
2066           {
2067             addressT offset = relax_align (address, (int) fragP->fr_offset);
2068
2069             if (fragP->fr_subtype != 0 && offset > fragP->fr_subtype)
2070               offset = 0;
2071
2072             if (offset % fragP->fr_var != 0)
2073               {
2074                 as_bad_where (fragP->fr_file, fragP->fr_line,
2075                               _("alignment padding (%lu bytes) not a multiple of %ld"),
2076                               (unsigned long) offset, (long) fragP->fr_var);
2077                 offset -= (offset % fragP->fr_var);
2078               }
2079
2080             address += offset;
2081           }
2082           break;
2083
2084         case rs_org:
2085         case rs_space:
2086           /* Assume .org is nugatory. It will grow with 1st relax.  */
2087           break;
2088
2089         case rs_machine_dependent:
2090           /* If fr_symbol is an expression, this call to
2091              resolve_symbol_value sets up the correct segment, which will
2092              likely be needed in md_estimate_size_before_relax.  */
2093           if (fragP->fr_symbol)
2094             resolve_symbol_value (fragP->fr_symbol);
2095
2096           address += md_estimate_size_before_relax (fragP, segment);
2097           break;
2098
2099 #ifndef WORKING_DOT_WORD
2100           /* Broken words don't concern us yet.  */
2101         case rs_broken_word:
2102           break;
2103 #endif
2104
2105         case rs_leb128:
2106           /* Initial guess is always 1; doing otherwise can result in
2107              stable solutions that are larger than the minimum.  */
2108           address += fragP->fr_offset = 1;
2109           break;
2110
2111         case rs_cfa:
2112           address += eh_frame_estimate_size_before_relax (fragP);
2113           break;
2114
2115         case rs_dwarf2dbg:
2116           address += dwarf2dbg_estimate_size_before_relax (fragP);
2117           break;
2118
2119         default:
2120           BAD_CASE (fragP->fr_type);
2121           break;
2122         }
2123     }
2124
2125   /* Do relax().  */
2126   {
2127     unsigned long max_iterations;
2128
2129     /* Cumulative address adjustment.  */
2130     offsetT stretch;
2131
2132     /* Have we made any adjustment this pass?  We can't just test
2133        stretch because one piece of code may have grown and another
2134        shrank.  */
2135     int stretched;
2136
2137     /* Most horrible, but gcc may give us some exception data that
2138        is impossible to assemble, of the form
2139
2140        .align 4
2141        .byte 0, 0
2142        .uleb128 end - start
2143        start:
2144        .space 128*128 - 1
2145        .align 4
2146        end:
2147
2148        If the leb128 is two bytes in size, then end-start is 128*128,
2149        which requires a three byte leb128.  If the leb128 is three
2150        bytes in size, then end-start is 128*128-1, which requires a
2151        two byte leb128.  We work around this dilemma by inserting
2152        an extra 4 bytes of alignment just after the .align.  This
2153        works because the data after the align is accessed relative to
2154        the end label.
2155
2156        This counter is used in a tiny state machine to detect
2157        whether a leb128 followed by an align is impossible to
2158        relax.  */
2159     int rs_leb128_fudge = 0;
2160
2161     /* We want to prevent going into an infinite loop where one frag grows
2162        depending upon the location of a symbol which is in turn moved by
2163        the growing frag.  eg:
2164
2165          foo = .
2166          .org foo+16
2167          foo = .
2168
2169        So we dictate that this algorithm can be at most O2.  */
2170     max_iterations = frag_count * frag_count;
2171     /* Check for overflow.  */
2172     if (max_iterations < frag_count)
2173       max_iterations = frag_count;
2174
2175     ret = 0;
2176     do
2177       {
2178         stretch = 0;
2179         stretched = 0;
2180
2181         for (fragP = segment_frag_root; fragP; fragP = fragP->fr_next)
2182           {
2183             offsetT growth = 0;
2184             addressT was_address;
2185             offsetT offset;
2186             symbolS *symbolP;
2187
2188             fragP->relax_marker ^= 1;
2189             was_address = fragP->fr_address;
2190             address = fragP->fr_address += stretch;
2191             symbolP = fragP->fr_symbol;
2192             offset = fragP->fr_offset;
2193
2194             switch (fragP->fr_type)
2195               {
2196               case rs_fill:     /* .fill never relaxes.  */
2197                 growth = 0;
2198                 break;
2199
2200 #ifndef WORKING_DOT_WORD
2201                 /* JF:  This is RMS's idea.  I do *NOT* want to be blamed
2202                    for it I do not want to write it.  I do not want to have
2203                    anything to do with it.  This is not the proper way to
2204                    implement this misfeature.  */
2205               case rs_broken_word:
2206                 {
2207                   struct broken_word *lie;
2208                   struct broken_word *untruth;
2209
2210                   /* Yes this is ugly (storing the broken_word pointer
2211                      in the symbol slot).  Still, this whole chunk of
2212                      code is ugly, and I don't feel like doing anything
2213                      about it.  Think of it as stubbornness in action.  */
2214                   growth = 0;
2215                   for (lie = (struct broken_word *) (fragP->fr_symbol);
2216                        lie && lie->dispfrag == fragP;
2217                        lie = lie->next_broken_word)
2218                     {
2219
2220                       if (lie->added)
2221                         continue;
2222
2223                       offset = (S_GET_VALUE (lie->add)
2224                                 + lie->addnum
2225                                 - S_GET_VALUE (lie->sub));
2226                       if (offset <= -32768 || offset >= 32767)
2227                         {
2228                           if (flag_warn_displacement)
2229                             {
2230                               char buf[50];
2231                               sprint_value (buf, (addressT) lie->addnum);
2232                               as_warn_where (fragP->fr_file, fragP->fr_line,
2233                                              _(".word %s-%s+%s didn't fit"),
2234                                              S_GET_NAME (lie->add),
2235                                              S_GET_NAME (lie->sub),
2236                                              buf);
2237                             }
2238                           if (fragP->fr_subtype == 0)
2239                             {
2240                               fragP->fr_subtype++;
2241                               growth += md_short_jump_size;
2242                             }
2243
2244                           /* Redirect *all* words of this table with the same
2245                              target, lest we have to handle the case where the
2246                              same target but with a offset that fits on this
2247                              round overflows at the next relaxation round.  */
2248                           for (untruth = (struct broken_word *) (fragP->fr_symbol);
2249                                untruth && untruth->dispfrag == lie->dispfrag;
2250                                untruth = untruth->next_broken_word)
2251                             if ((symbol_get_frag (untruth->add)
2252                                  == symbol_get_frag (lie->add))
2253                                 && (S_GET_VALUE (untruth->add)
2254                                     == S_GET_VALUE (lie->add)))
2255                               {
2256                                 untruth->added = 2;
2257                                 untruth->use_jump = lie;
2258                               }
2259
2260                           lie->added = 1;
2261                           growth += md_long_jump_size;
2262                         }
2263                     }
2264
2265                   break;
2266                 }               /* case rs_broken_word  */
2267 #endif
2268               case rs_align:
2269               case rs_align_code:
2270               case rs_align_test:
2271                 {
2272                   addressT oldoff, newoff;
2273
2274                   oldoff = relax_align (was_address + fragP->fr_fix,
2275                                         (int) offset);
2276                   newoff = relax_align (address + fragP->fr_fix,
2277                                         (int) offset);
2278
2279                   if (fragP->fr_subtype != 0)
2280                     {
2281                       if (oldoff > fragP->fr_subtype)
2282                         oldoff = 0;
2283                       if (newoff > fragP->fr_subtype)
2284                         newoff = 0;
2285                     }
2286
2287                   growth = newoff - oldoff;
2288
2289                   /* If this align happens to follow a leb128 and
2290                      we have determined that the leb128 is bouncing
2291                      in size, then break the cycle by inserting an
2292                      extra alignment.  */
2293                   if (growth < 0
2294                       && (rs_leb128_fudge & 16) != 0
2295                       && (rs_leb128_fudge & 15) >= 2)
2296                     {
2297                       segment_info_type *seginfo = seg_info (segment);
2298                       struct obstack *ob = &seginfo->frchainP->frch_obstack;
2299                       struct frag *newf;
2300
2301                       newf = frag_alloc (ob);
2302                       obstack_blank_fast (ob, fragP->fr_var);
2303                       obstack_finish (ob);
2304                       memcpy (newf, fragP, SIZEOF_STRUCT_FRAG);
2305                       memcpy (newf->fr_literal,
2306                               fragP->fr_literal + fragP->fr_fix,
2307                               fragP->fr_var);
2308                       newf->fr_type = rs_fill;
2309                       newf->fr_fix = 0;
2310                       newf->fr_offset = (((offsetT) 1 << fragP->fr_offset)
2311                                          / fragP->fr_var);
2312                       if (newf->fr_offset * newf->fr_var
2313                           != (offsetT) 1 << fragP->fr_offset)
2314                         {
2315                           newf->fr_offset = (offsetT) 1 << fragP->fr_offset;
2316                           newf->fr_var = 1;
2317                         }
2318                       /* Include growth of new frag, because rs_fill
2319                          frags don't normally grow.  */
2320                       growth += newf->fr_offset * newf->fr_var;
2321                       /* The new frag address is newoff.  Adjust this
2322                          for the amount we'll add when we process the
2323                          new frag.  */
2324                       newf->fr_address = newoff - stretch - growth;
2325                       newf->relax_marker ^= 1;
2326                       fragP->fr_next = newf;
2327 #ifdef DEBUG
2328                       as_warn (_("padding added"));
2329 #endif
2330                     }
2331                 }
2332                 break;
2333
2334               case rs_org:
2335                 {
2336                   addressT target = offset;
2337                   addressT after;
2338
2339                   if (symbolP)
2340                     {
2341                       /* Convert from an actual address to an octet offset
2342                          into the section.  Here it is assumed that the
2343                          section's VMA is zero, and can omit subtracting it
2344                          from the symbol's value to get the address offset.  */
2345                       know (S_GET_SEGMENT (symbolP)->vma == 0);
2346                       target += S_GET_VALUE (symbolP) * OCTETS_PER_BYTE;
2347                     }
2348
2349                   know (fragP->fr_next);
2350                   after = fragP->fr_next->fr_address + stretch;
2351                   growth = target - after;
2352                   if (growth < 0)
2353                     {
2354                       growth = 0;
2355
2356                       /* Don't error on first few frag relax passes.
2357                          The symbol might be an expression involving
2358                          symbol values from other sections.  If those
2359                          sections have not yet been processed their
2360                          frags will all have zero addresses, so we
2361                          will calculate incorrect values for them.  The
2362                          number of passes we allow before giving an
2363                          error is somewhat arbitrary.  It should be at
2364                          least one, with larger values requiring
2365                          increasingly contrived dependencies between
2366                          frags to trigger a false error.  */
2367                       if (pass < 2)
2368                         {
2369                           /* Force another pass.  */
2370                           ret = 1;
2371                           break;
2372                         }
2373
2374                       /* Growth may be negative, but variable part of frag
2375                          cannot have fewer than 0 chars.  That is, we can't
2376                          .org backwards.  */
2377                       as_bad_where (fragP->fr_file, fragP->fr_line,
2378                                     _("attempt to move .org backwards"));
2379
2380                       /* We've issued an error message.  Change the
2381                          frag to avoid cascading errors.  */
2382                       fragP->fr_type = rs_align;
2383                       fragP->fr_subtype = 0;
2384                       fragP->fr_offset = 0;
2385                       fragP->fr_fix = after - address;
2386                     }
2387                 }
2388                 break;
2389
2390               case rs_space:
2391                 growth = 0;
2392                 if (symbolP)
2393                   {
2394                     offsetT amount;
2395
2396                     amount = S_GET_VALUE (symbolP);
2397                     if (S_GET_SEGMENT (symbolP) != absolute_section
2398                         || S_IS_COMMON (symbolP)
2399                         || ! S_IS_DEFINED (symbolP))
2400                       {
2401                         as_bad_where (fragP->fr_file, fragP->fr_line,
2402                                       _(".space specifies non-absolute value"));
2403                         /* Prevent repeat of this error message.  */
2404                         fragP->fr_symbol = 0;
2405                       }
2406                     else if (amount < 0)
2407                       {
2408                         /* Don't error on first few frag relax passes.
2409                            See rs_org comment for a longer explanation.  */
2410                         if (pass < 2)
2411                           {
2412                             ret = 1;
2413                             break;
2414                           }
2415
2416                         as_warn_where (fragP->fr_file, fragP->fr_line,
2417                                        _(".space or .fill with negative value, ignored"));
2418                         fragP->fr_symbol = 0;
2419                       }
2420                     else
2421                       growth = (was_address + fragP->fr_fix + amount
2422                                 - fragP->fr_next->fr_address);
2423                   }
2424                 break;
2425
2426               case rs_machine_dependent:
2427 #ifdef md_relax_frag
2428                 growth = md_relax_frag (segment, fragP, stretch);
2429 #else
2430 #ifdef TC_GENERIC_RELAX_TABLE
2431                 /* The default way to relax a frag is to look through
2432                    TC_GENERIC_RELAX_TABLE.  */
2433                 growth = relax_frag (segment, fragP, stretch);
2434 #endif /* TC_GENERIC_RELAX_TABLE  */
2435 #endif
2436                 break;
2437
2438               case rs_leb128:
2439                 {
2440                   valueT value;
2441                   offsetT size;
2442
2443                   value = resolve_symbol_value (fragP->fr_symbol);
2444                   size = sizeof_leb128 (value, fragP->fr_subtype);
2445                   growth = size - fragP->fr_offset;
2446                   fragP->fr_offset = size;
2447                 }
2448                 break;
2449
2450               case rs_cfa:
2451                 growth = eh_frame_relax_frag (fragP);
2452                 break;
2453
2454               case rs_dwarf2dbg:
2455                 growth = dwarf2dbg_relax_frag (fragP);
2456                 break;
2457
2458               default:
2459                 BAD_CASE (fragP->fr_type);
2460                 break;
2461               }
2462             if (growth)
2463               {
2464                 stretch += growth;
2465                 stretched = 1;
2466                 if (fragP->fr_type == rs_leb128)
2467                   rs_leb128_fudge += 16;
2468                 else if (fragP->fr_type == rs_align
2469                          && (rs_leb128_fudge & 16) != 0
2470                          && stretch == 0)
2471                   rs_leb128_fudge += 16;
2472                 else
2473                   rs_leb128_fudge = 0;
2474               }
2475           }
2476
2477         if (stretch == 0
2478             && (rs_leb128_fudge & 16) == 0
2479             && (rs_leb128_fudge & -16) != 0)
2480           rs_leb128_fudge += 1;
2481         else
2482           rs_leb128_fudge = 0;
2483       }
2484     /* Until nothing further to relax.  */
2485     while (stretched && -- max_iterations);
2486
2487     if (stretched)
2488       as_fatal (_("Infinite loop encountered whilst attempting to compute the addresses of symbols in section %s"),
2489                 segment_name (segment));
2490   }
2491
2492   for (fragP = segment_frag_root; fragP; fragP = fragP->fr_next)
2493     if (fragP->last_fr_address != fragP->fr_address)
2494       {
2495         fragP->last_fr_address = fragP->fr_address;
2496         ret = 1;
2497       }
2498   return ret;
2499 }
2500
2501 void
2502 number_to_chars_bigendian (char *buf, valueT val, int n)
2503 {
2504   if (n <= 0)
2505     abort ();
2506   while (n--)
2507     {
2508       buf[n] = val & 0xff;
2509       val >>= 8;
2510     }
2511 }
2512
2513 void
2514 number_to_chars_littleendian (char *buf, valueT val, int n)
2515 {
2516   if (n <= 0)
2517     abort ();
2518   while (n--)
2519     {
2520       *buf++ = val & 0xff;
2521       val >>= 8;
2522     }
2523 }
2524
2525 void
2526 write_print_statistics (FILE *file)
2527 {
2528   fprintf (file, "fixups: %d\n", n_fixups);
2529 }
2530
2531 /* For debugging.  */
2532 extern int indent_level;
2533
2534 void
2535 print_fixup (fixS *fixp)
2536 {
2537   indent_level = 1;
2538   fprintf (stderr, "fix ");
2539   fprintf_vma (stderr, (bfd_vma)((bfd_hostptr_t) fixp));
2540   fprintf (stderr, " %s:%d",fixp->fx_file, fixp->fx_line);
2541   if (fixp->fx_pcrel)
2542     fprintf (stderr, " pcrel");
2543   if (fixp->fx_pcrel_adjust)
2544     fprintf (stderr, " pcrel_adjust=%d", fixp->fx_pcrel_adjust);
2545   if (fixp->fx_im_disp)
2546     {
2547 #ifdef TC_NS32K
2548       fprintf (stderr, " im_disp=%d", fixp->fx_im_disp);
2549 #else
2550       fprintf (stderr, " im_disp");
2551 #endif
2552     }
2553   if (fixp->fx_tcbit)
2554     fprintf (stderr, " tcbit");
2555   if (fixp->fx_done)
2556     fprintf (stderr, " done");
2557   fprintf (stderr, "\n    size=%d frag=", fixp->fx_size);
2558   fprintf_vma (stderr, (bfd_vma) ((bfd_hostptr_t) fixp->fx_frag));
2559   fprintf (stderr, " where=%ld offset=%lx addnumber=%lx",
2560            (long) fixp->fx_where,
2561            (unsigned long) fixp->fx_offset,
2562            (unsigned long) fixp->fx_addnumber);
2563   fprintf (stderr, "\n    %s (%d)", bfd_get_reloc_code_name (fixp->fx_r_type),
2564            fixp->fx_r_type);
2565   if (fixp->fx_addsy)
2566     {
2567       fprintf (stderr, "\n   +<");
2568       print_symbol_value_1 (stderr, fixp->fx_addsy);
2569       fprintf (stderr, ">");
2570     }
2571   if (fixp->fx_subsy)
2572     {
2573       fprintf (stderr, "\n   -<");
2574       print_symbol_value_1 (stderr, fixp->fx_subsy);
2575       fprintf (stderr, ">");
2576     }
2577   fprintf (stderr, "\n");
2578 #ifdef TC_FIX_DATA_PRINT
2579   TC_FIX_DATA_PRINT (stderr, fixp);
2580 #endif
2581 }