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