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