Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | RSS feed

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