Subversion Repositories Kolibri OS

Rev

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

  1. /* ldwrite.c -- write out the linked file
  2.    Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 2000, 2002,
  3.    2003, 2004, 2005, 2006, 2007, 2008, 2010, 2012
  4.    Free Software Foundation, Inc.
  5.    Written by Steve Chamberlain sac@cygnus.com
  6.  
  7.    This file is part of the GNU Binutils.
  8.  
  9.    This program is free software; you can redistribute it and/or modify
  10.    it under the terms of the GNU General Public License as published by
  11.    the Free Software Foundation; either version 3 of the License, or
  12.    (at your option) any later version.
  13.  
  14.    This program is distributed in the hope that it will be useful,
  15.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17.    GNU General Public License for more details.
  18.  
  19.    You should have received a copy of the GNU General Public License
  20.    along with this program; if not, write to the Free Software
  21.    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
  22.    MA 02110-1301, USA.  */
  23.  
  24. #include "sysdep.h"
  25. #include "bfd.h"
  26. #include "bfdlink.h"
  27. #include "libiberty.h"
  28. #include "safe-ctype.h"
  29.  
  30. #include "ld.h"
  31. #include "ldexp.h"
  32. #include "ldlang.h"
  33. #include "ldwrite.h"
  34. #include "ldmisc.h"
  35. #include <ldgram.h>
  36. #include "ldmain.h"
  37.  
  38. /* Build link_order structures for the BFD linker.  */
  39.  
  40. static void
  41. build_link_order (lang_statement_union_type *statement)
  42. {
  43.   switch (statement->header.type)
  44.     {
  45.     case lang_data_statement_enum:
  46.       {
  47.         asection *output_section;
  48.         struct bfd_link_order *link_order;
  49.         bfd_vma value;
  50.         bfd_boolean big_endian = FALSE;
  51.  
  52.         output_section = statement->data_statement.output_section;
  53.         ASSERT (output_section->owner == link_info.output_bfd);
  54.  
  55.         if (!((output_section->flags & SEC_HAS_CONTENTS) != 0
  56.               || ((output_section->flags & SEC_LOAD) != 0
  57.                   && (output_section->flags & SEC_THREAD_LOCAL))))
  58.           break;
  59.  
  60.         link_order = bfd_new_link_order (link_info.output_bfd, output_section);
  61.         if (link_order == NULL)
  62.           einfo (_("%P%F: bfd_new_link_order failed\n"));
  63.  
  64.         link_order->type = bfd_data_link_order;
  65.         link_order->offset = statement->data_statement.output_offset;
  66.         link_order->u.data.contents = (bfd_byte *) xmalloc (QUAD_SIZE);
  67.  
  68.         value = statement->data_statement.value;
  69.  
  70.         /* If the endianness of the output BFD is not known, then we
  71.            base the endianness of the data on the first input file.
  72.            By convention, the bfd_put routines for an unknown
  73.            endianness are big endian, so we must swap here if the
  74.            input file is little endian.  */
  75.         if (bfd_big_endian (link_info.output_bfd))
  76.           big_endian = TRUE;
  77.         else if (bfd_little_endian (link_info.output_bfd))
  78.           big_endian = FALSE;
  79.         else
  80.           {
  81.             bfd_boolean swap;
  82.  
  83.             swap = FALSE;
  84.             if (command_line.endian == ENDIAN_BIG)
  85.               big_endian = TRUE;
  86.             else if (command_line.endian == ENDIAN_LITTLE)
  87.               {
  88.                 big_endian = FALSE;
  89.                 swap = TRUE;
  90.               }
  91.             else if (command_line.endian == ENDIAN_UNSET)
  92.               {
  93.                 big_endian = TRUE;
  94.                 {
  95.                   LANG_FOR_EACH_INPUT_STATEMENT (s)
  96.                     {
  97.                       if (s->the_bfd != NULL)
  98.                         {
  99.                           if (bfd_little_endian (s->the_bfd))
  100.                             {
  101.                               big_endian = FALSE;
  102.                               swap = TRUE;
  103.                             }
  104.                           break;
  105.                         }
  106.                     }
  107.                 }
  108.               }
  109.  
  110.             if (swap)
  111.               {
  112.                 bfd_byte buffer[8];
  113.  
  114.                 switch (statement->data_statement.type)
  115.                   {
  116.                   case QUAD:
  117.                   case SQUAD:
  118.                     if (sizeof (bfd_vma) >= QUAD_SIZE)
  119.                       {
  120.                         bfd_putl64 (value, buffer);
  121.                         value = bfd_getb64 (buffer);
  122.                         break;
  123.                       }
  124.                     /* Fall through.  */
  125.                   case LONG:
  126.                     bfd_putl32 (value, buffer);
  127.                     value = bfd_getb32 (buffer);
  128.                     break;
  129.                   case SHORT:
  130.                     bfd_putl16 (value, buffer);
  131.                     value = bfd_getb16 (buffer);
  132.                     break;
  133.                   case BYTE:
  134.                     break;
  135.                   default:
  136.                     abort ();
  137.                   }
  138.               }
  139.           }
  140.  
  141.         ASSERT (output_section->owner == link_info.output_bfd);
  142.         switch (statement->data_statement.type)
  143.           {
  144.           case QUAD:
  145.           case SQUAD:
  146.             if (sizeof (bfd_vma) >= QUAD_SIZE)
  147.               bfd_put_64 (link_info.output_bfd, value,
  148.                           link_order->u.data.contents);
  149.             else
  150.               {
  151.                 bfd_vma high;
  152.  
  153.                 if (statement->data_statement.type == QUAD)
  154.                   high = 0;
  155.                 else if ((value & 0x80000000) == 0)
  156.                   high = 0;
  157.                 else
  158.                   high = (bfd_vma) -1;
  159.                 bfd_put_32 (link_info.output_bfd, high,
  160.                             (link_order->u.data.contents
  161.                              + (big_endian ? 0 : 4)));
  162.                 bfd_put_32 (link_info.output_bfd, value,
  163.                             (link_order->u.data.contents
  164.                              + (big_endian ? 4 : 0)));
  165.               }
  166.             link_order->size = QUAD_SIZE;
  167.             break;
  168.           case LONG:
  169.             bfd_put_32 (link_info.output_bfd, value,
  170.                         link_order->u.data.contents);
  171.             link_order->size = LONG_SIZE;
  172.             break;
  173.           case SHORT:
  174.             bfd_put_16 (link_info.output_bfd, value,
  175.                         link_order->u.data.contents);
  176.             link_order->size = SHORT_SIZE;
  177.             break;
  178.           case BYTE:
  179.             bfd_put_8 (link_info.output_bfd, value,
  180.                        link_order->u.data.contents);
  181.             link_order->size = BYTE_SIZE;
  182.             break;
  183.           default:
  184.             abort ();
  185.           }
  186.         link_order->u.data.size = link_order->size;
  187.       }
  188.       break;
  189.  
  190.     case lang_reloc_statement_enum:
  191.       {
  192.         lang_reloc_statement_type *rs;
  193.         asection *output_section;
  194.         struct bfd_link_order *link_order;
  195.  
  196.         rs = &statement->reloc_statement;
  197.  
  198.         output_section = rs->output_section;
  199.         ASSERT (output_section->owner == link_info.output_bfd);
  200.  
  201.         if (!((output_section->flags & SEC_HAS_CONTENTS) != 0
  202.               || ((output_section->flags & SEC_LOAD) != 0
  203.                   && (output_section->flags & SEC_THREAD_LOCAL))))
  204.           break;
  205.  
  206.         link_order = bfd_new_link_order (link_info.output_bfd, output_section);
  207.         if (link_order == NULL)
  208.           einfo (_("%P%F: bfd_new_link_order failed\n"));
  209.  
  210.         link_order->offset = rs->output_offset;
  211.         link_order->size = bfd_get_reloc_size (rs->howto);
  212.  
  213.         link_order->u.reloc.p = (struct bfd_link_order_reloc *)
  214.             xmalloc (sizeof (struct bfd_link_order_reloc));
  215.  
  216.         link_order->u.reloc.p->reloc = rs->reloc;
  217.         link_order->u.reloc.p->addend = rs->addend_value;
  218.  
  219.         if (rs->name == NULL)
  220.           {
  221.             link_order->type = bfd_section_reloc_link_order;
  222.             if (rs->section->owner == link_info.output_bfd)
  223.               link_order->u.reloc.p->u.section = rs->section;
  224.             else
  225.               {
  226.                 link_order->u.reloc.p->u.section = rs->section->output_section;
  227.                 link_order->u.reloc.p->addend += rs->section->output_offset;
  228.               }
  229.           }
  230.         else
  231.           {
  232.             link_order->type = bfd_symbol_reloc_link_order;
  233.             link_order->u.reloc.p->u.name = rs->name;
  234.           }
  235.       }
  236.       break;
  237.  
  238.     case lang_input_section_enum:
  239.       {
  240.         /* Create a new link_order in the output section with this
  241.            attached */
  242.         asection *i = statement->input_section.section;
  243.  
  244.         if (i->sec_info_type != SEC_INFO_TYPE_JUST_SYMS
  245.             && (i->flags & SEC_EXCLUDE) == 0)
  246.           {
  247.             asection *output_section = i->output_section;
  248.             struct bfd_link_order *link_order;
  249.  
  250.             ASSERT (output_section->owner == link_info.output_bfd);
  251.  
  252.             if (!((output_section->flags & SEC_HAS_CONTENTS) != 0
  253.                   || ((output_section->flags & SEC_LOAD) != 0
  254.                       && (output_section->flags & SEC_THREAD_LOCAL))))
  255.               break;
  256.  
  257.             link_order = bfd_new_link_order (link_info.output_bfd,
  258.                                              output_section);
  259.  
  260.             if ((i->flags & SEC_NEVER_LOAD) != 0
  261.                 && (i->flags & SEC_DEBUGGING) == 0)
  262.               {
  263.                 /* We've got a never load section inside one which is
  264.                    going to be output, we'll change it into a fill.  */
  265.                 link_order->type = bfd_data_link_order;
  266.                 link_order->u.data.contents = (unsigned char *) "";
  267.                 link_order->u.data.size = 1;
  268.               }
  269.             else
  270.               {
  271.                 link_order->type = bfd_indirect_link_order;
  272.                 link_order->u.indirect.section = i;
  273.                 ASSERT (i->output_section == output_section);
  274.               }
  275.             link_order->size = i->size;
  276.             link_order->offset = i->output_offset;
  277.           }
  278.       }
  279.       break;
  280.  
  281.     case lang_padding_statement_enum:
  282.       /* Make a new link_order with the right filler */
  283.       {
  284.         asection *output_section;
  285.         struct bfd_link_order *link_order;
  286.  
  287.         output_section = statement->padding_statement.output_section;
  288.         ASSERT (statement->padding_statement.output_section->owner
  289.                 == link_info.output_bfd);
  290.  
  291.         if (!((output_section->flags & SEC_HAS_CONTENTS) != 0
  292.               || ((output_section->flags & SEC_LOAD) != 0
  293.                   && (output_section->flags & SEC_THREAD_LOCAL))))
  294.           break;
  295.  
  296.         link_order = bfd_new_link_order (link_info.output_bfd,
  297.                                          output_section);
  298.         link_order->type = bfd_data_link_order;
  299.         link_order->size = statement->padding_statement.size;
  300.         link_order->offset = statement->padding_statement.output_offset;
  301.         link_order->u.data.contents = statement->padding_statement.fill->data;
  302.         link_order->u.data.size = statement->padding_statement.fill->size;
  303.       }
  304.       break;
  305.  
  306.     default:
  307.       /* All the other ones fall through */
  308.       break;
  309.     }
  310. }
  311.  
  312. /* Return true if NAME is the name of an unsplittable section. These
  313.    are the stabs strings, dwarf strings.  */
  314.  
  315. static bfd_boolean
  316. unsplittable_name (const char *name)
  317. {
  318.   if (CONST_STRNEQ (name, ".stab"))
  319.     {
  320.       /* There are several stab like string sections. We pattern match on
  321.          ".stab...str"  */
  322.       unsigned len = strlen (name);
  323.       if (strcmp (&name[len-3], "str") == 0)
  324.         return TRUE;
  325.     }
  326.   else if (strcmp (name, "$GDB_STRINGS$") == 0)
  327.     return TRUE;
  328.   return FALSE;
  329. }
  330.  
  331. /* Wander around the input sections, make sure that
  332.    we'll never try and create an output section with more relocs
  333.    than will fit.. Do this by always assuming the worst case, and
  334.    creating new output sections with all the right bits.  */
  335. #define TESTIT 1
  336. static asection *
  337. clone_section (bfd *abfd, asection *s, const char *name, int *count)
  338. {
  339.   char *tname;
  340.   char *sname;
  341.   unsigned int len;
  342.   asection *n;
  343.   struct bfd_link_hash_entry *h;
  344.  
  345.   /* Invent a section name from the section name and a dotted numeric
  346.      suffix.   */
  347.   len = strlen (name);
  348.   tname = (char *) xmalloc (len + 1);
  349.   memcpy (tname, name, len + 1);
  350.   /* Remove a dotted number suffix, from a previous split link. */
  351.   while (len && ISDIGIT (tname[len-1]))
  352.     len--;
  353.   if (len > 1 && tname[len-1] == '.')
  354.     /* It was a dotted number. */
  355.     tname[len-1] = 0;
  356.  
  357.   /* We want to use the whole of the original section name for the
  358.      split name, but coff can be restricted to 8 character names.  */
  359.   if (bfd_family_coff (abfd) && strlen (tname) > 5)
  360.     {
  361.       /* Some section names cannot be truncated, as the name is
  362.          used to locate some other section.  */
  363.       if (CONST_STRNEQ (name, ".stab")
  364.           || strcmp (name, "$GDB_SYMBOLS$") == 0)
  365.         {
  366.           einfo (_ ("%F%P: cannot create split section name for %s\n"), name);
  367.           /* Silence gcc warnings.  einfo exits, so we never reach here.  */
  368.           return NULL;
  369.         }
  370.       tname[5] = 0;
  371.     }
  372.  
  373.   if ((sname = bfd_get_unique_section_name (abfd, tname, count)) == NULL
  374.       || (n = bfd_make_section_anyway (abfd, sname)) == NULL
  375.       || (h = bfd_link_hash_lookup (link_info.hash,
  376.                                     sname, TRUE, TRUE, FALSE)) == NULL)
  377.     {
  378.       einfo (_("%F%P: clone section failed: %E\n"));
  379.       /* Silence gcc warnings.  einfo exits, so we never reach here.  */
  380.       return NULL;
  381.     }
  382.   free (tname);
  383.  
  384.   /* Set up section symbol.  */
  385.   h->type = bfd_link_hash_defined;
  386.   h->u.def.value = 0;
  387.   h->u.def.section = n;
  388.  
  389.   n->flags = s->flags;
  390.   n->vma = s->vma;
  391.   n->user_set_vma = s->user_set_vma;
  392.   n->lma = s->lma;
  393.   n->size = 0;
  394.   n->output_offset = s->output_offset;
  395.   n->output_section = n;
  396.   n->orelocation = 0;
  397.   n->reloc_count = 0;
  398.   n->alignment_power = s->alignment_power;
  399.  
  400.   bfd_copy_private_section_data (abfd, s, abfd, n);
  401.  
  402.   return n;
  403. }
  404.  
  405. #if TESTING
  406. static void
  407. ds (asection *s)
  408. {
  409.   struct bfd_link_order *l = s->map_head.link_order;
  410.   printf ("vma %x size %x\n", s->vma, s->size);
  411.   while (l)
  412.     {
  413.       if (l->type == bfd_indirect_link_order)
  414.         {
  415.           printf ("%8x %s\n", l->offset, l->u.indirect.section->owner->filename);
  416.         }
  417.       else
  418.         {
  419.           printf (_("%8x something else\n"), l->offset);
  420.         }
  421.       l = l->next;
  422.     }
  423.   printf ("\n");
  424. }
  425.  
  426. dump (char *s, asection *a1, asection *a2)
  427. {
  428.   printf ("%s\n", s);
  429.   ds (a1);
  430.   ds (a2);
  431. }
  432.  
  433. static void
  434. sanity_check (bfd *abfd)
  435. {
  436.   asection *s;
  437.   for (s = abfd->sections; s; s = s->next)
  438.     {
  439.       struct bfd_link_order *p;
  440.       bfd_vma prev = 0;
  441.       for (p = s->map_head.link_order; p; p = p->next)
  442.         {
  443.           if (p->offset > 100000)
  444.             abort ();
  445.           if (p->offset < prev)
  446.             abort ();
  447.           prev = p->offset;
  448.         }
  449.     }
  450. }
  451. #else
  452. #define sanity_check(a)
  453. #define dump(a, b, c)
  454. #endif
  455.  
  456. static void
  457. split_sections (bfd *abfd, struct bfd_link_info *info)
  458. {
  459.   asection *original_sec;
  460.   int nsecs = abfd->section_count;
  461.   sanity_check (abfd);
  462.   /* Look through all the original sections.  */
  463.   for (original_sec = abfd->sections;
  464.        original_sec && nsecs;
  465.        original_sec = original_sec->next, nsecs--)
  466.     {
  467.       int count = 0;
  468.       unsigned int lines = 0;
  469.       unsigned int relocs = 0;
  470.       bfd_size_type sec_size = 0;
  471.       struct bfd_link_order *l;
  472.       struct bfd_link_order *p;
  473.       bfd_vma vma = original_sec->vma;
  474.       asection *cursor = original_sec;
  475.  
  476.       /* Count up the relocations and line entries to see if anything
  477.          would be too big to fit.  Accumulate section size too.  */
  478.       for (l = NULL, p = cursor->map_head.link_order; p != NULL; p = l->next)
  479.         {
  480.           unsigned int thislines = 0;
  481.           unsigned int thisrelocs = 0;
  482.           bfd_size_type thissize = 0;
  483.           if (p->type == bfd_indirect_link_order)
  484.             {
  485.               asection *sec;
  486.  
  487.               sec = p->u.indirect.section;
  488.  
  489.               if (info->strip == strip_none
  490.                   || info->strip == strip_some)
  491.                 thislines = sec->lineno_count;
  492.  
  493.               if (info->relocatable)
  494.                 thisrelocs = sec->reloc_count;
  495.  
  496.               thissize = sec->size;
  497.  
  498.             }
  499.           else if (info->relocatable
  500.                    && (p->type == bfd_section_reloc_link_order
  501.                        || p->type == bfd_symbol_reloc_link_order))
  502.             thisrelocs++;
  503.  
  504.           if (l != NULL
  505.               && (thisrelocs + relocs >= config.split_by_reloc
  506.                   || thislines + lines >= config.split_by_reloc
  507.                   || (thissize + sec_size >= config.split_by_file))
  508.               && !unsplittable_name (cursor->name))
  509.             {
  510.               /* Create a new section and put this link order and the
  511.                  following link orders into it.  */
  512.               bfd_vma shift_offset;
  513.               asection *n;
  514.  
  515.               n = clone_section (abfd, cursor, original_sec->name, &count);
  516.  
  517.               /* Attach the link orders to the new section and snip
  518.                  them off from the old section.  */
  519.               n->map_head.link_order = p;
  520.               n->map_tail.link_order = cursor->map_tail.link_order;
  521.               cursor->map_tail.link_order = l;
  522.               l->next = NULL;
  523.               l = p;
  524.  
  525.               /* Change the size of the original section and
  526.                  update the vma of the new one.  */
  527.  
  528.               dump ("before snip", cursor, n);
  529.  
  530.               shift_offset = p->offset;
  531.               n->size = cursor->size - shift_offset;
  532.               cursor->size = shift_offset;
  533.  
  534.               vma += shift_offset;
  535.               n->lma = n->vma = vma;
  536.  
  537.               /* Run down the chain and change the output section to
  538.                  the right one, update the offsets too.  */
  539.               do
  540.                 {
  541.                   p->offset -= shift_offset;
  542.                   if (p->type == bfd_indirect_link_order)
  543.                     {
  544.                       p->u.indirect.section->output_section = n;
  545.                       p->u.indirect.section->output_offset = p->offset;
  546.                     }
  547.                   p = p->next;
  548.                 }
  549.               while (p);
  550.  
  551.               dump ("after snip", cursor, n);
  552.               cursor = n;
  553.               relocs = thisrelocs;
  554.               lines = thislines;
  555.               sec_size = thissize;
  556.             }
  557.           else
  558.             {
  559.               l = p;
  560.               relocs += thisrelocs;
  561.               lines += thislines;
  562.               sec_size += thissize;
  563.             }
  564.         }
  565.     }
  566.   sanity_check (abfd);
  567. }
  568.  
  569. /* Call BFD to write out the linked file.  */
  570.  
  571. void
  572. ldwrite (void)
  573. {
  574.   /* Reset error indicator, which can typically something like invalid
  575.      format from opening up the .o files.  */
  576.   bfd_set_error (bfd_error_no_error);
  577.   lang_for_each_statement (build_link_order);
  578.  
  579.   if (config.split_by_reloc != (unsigned) -1
  580.       || config.split_by_file != (bfd_size_type) -1)
  581.     split_sections (link_info.output_bfd, &link_info);
  582.   if (!bfd_final_link (link_info.output_bfd, &link_info))
  583.     {
  584.       /* If there was an error recorded, print it out.  Otherwise assume
  585.          an appropriate error message like unknown symbol was printed
  586.          out.  */
  587.  
  588.       if (bfd_get_error () != bfd_error_no_error)
  589.         einfo (_("%F%P: final link failed: %E\n"));
  590.       else
  591.         xexit (1);
  592.     }
  593. }
  594.