ld/ldlang.c

   1 /* Linker command language support.
   2    Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
   3    2001, 2002, 2003
   4    Free Software Foundation, Inc.
   5
   6    This file is part of GLD, the Gnu Linker.
   7
   8    GLD 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 2, or (at your option)
  11    any later version.
  12
  13    GLD 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 GLD; see the file COPYING.  If not, write to the Free
  20    Software Foundation, 59 Temple Place - Suite 330, Boston, MA
  21    02111-1307, USA.  */
  22
  23 #include "bfd.h"
  24 #include "sysdep.h"
  25 #include "libiberty.h"
  26 #include "safe-ctype.h"
  27 #include "obstack.h"
  28 #include "bfdlink.h"
  29
  30 #include "ld.h"
  31 #include "ldmain.h"
  32 #include "ldexp.h"
  33 #include "ldlang.h"
  34 #include <ldgram.h>
  35 #include "ldlex.h"
  36 #include "ldmisc.h"
  37 #include "ldctor.h"
  38 #include "ldfile.h"
  39 #include "ldemul.h"
  40 #include "fnmatch.h"
  41 #include "demangle.h"
  42
  43 #ifndef offsetof
  44 #define offsetof(TYPE, MEMBER) ((size_t) & (((TYPE*) 0)->MEMBER))
  45 #endif
  46
  47 /* Locals variables.  */
  48 static struct obstack stat_obstack;
  49
  50 #define obstack_chunk_alloc xmalloc
  51 #define obstack_chunk_free free
  52 static const char *startup_file;
  53 static lang_statement_list_type input_file_chain;
  54 static bfd_boolean placed_commons = FALSE;
  55 static lang_output_section_statement_type *default_common_section;
  56 static bfd_boolean map_option_f;
  57 static bfd_vma print_dot;
  58 static lang_input_statement_type *first_file;
  59 static const char *current_target;
  60 static const char *output_target;
  61 static lang_statement_list_type statement_list;
  62 static struct lang_phdr *lang_phdr_list;
  63 static struct bfd_hash_table lang_definedness_table;
  64
  65 /* Forward declarations.  */
  66 static void exp_init_os (etree_type *);
  67 static bfd_boolean wildcardp (const char *);
  68 static lang_input_statement_type *lookup_name (const char *);
  69 static bfd_boolean load_symbols (lang_input_statement_type *,
  70                                  lang_statement_list_type *);
  71 static struct bfd_hash_entry *lang_definedness_newfunc
  72  (struct bfd_hash_entry *, struct bfd_hash_table *, const char *);
  73 static void insert_undefined (const char *);
  74 static void print_statement (lang_statement_union_type *,
  75                              lang_output_section_statement_type *);
  76 static void print_statement_list (lang_statement_union_type *,
  77                                   lang_output_section_statement_type *);
  78 static void print_statements (void);
  79 static bfd_boolean lang_one_common (struct bfd_link_hash_entry *, void *);
  80 static void lang_record_phdrs (void);
  81 static void lang_do_version_exports_section (void);
  82
  83 typedef void (*callback_t) (lang_wild_statement_type *, struct wildcard_list *,
  84                             asection *, lang_input_statement_type *, void *);
  85
  86 /* Exported variables.  */
  87 lang_output_section_statement_type *abs_output_section;
  88 lang_statement_list_type lang_output_section_statement;
  89 lang_statement_list_type *stat_ptr = &statement_list;
  90 lang_statement_list_type file_chain = { NULL, NULL };
  91 struct bfd_sym_chain entry_symbol = { NULL, NULL };
  92 const char *entry_section = ".text";
  93 bfd_boolean entry_from_cmdline;
  94 bfd_boolean lang_has_input_file = FALSE;
  95 bfd_boolean had_output_filename = FALSE;
  96 bfd_boolean lang_float_flag = FALSE;
  97 bfd_boolean delete_output_file_on_failure = FALSE;
  98 struct lang_nocrossrefs *nocrossref_list;
  99 struct unique_sections *unique_section_list;
 100 static bfd_boolean ldlang_sysrooted_script = FALSE;
 101 int lang_statement_iteration = 0;
 102
 103 etree_type *base; /* Relocation base - or null */
 104
 105 #define new_stat(x, y) \
 106   (x##_type *) new_statement (x##_enum, sizeof (x##_type), y)
 107
 108 #define outside_section_address(q) \
 109   ((q)->output_offset + (q)->output_section->vma)
 110
 111 #define outside_symbol_address(q) \
 112   ((q)->value + outside_section_address (q->section))
 113
 114 #define SECTION_NAME_MAP_LENGTH (16)
 115
 116 void *
 117 stat_alloc (size_t size)
 118 {
 119   return obstack_alloc (&stat_obstack, size);
 120 }
 121
 122 bfd_boolean
 123 unique_section_p (const char *secnam)
 124 {
 125   struct unique_sections *unam;
 126
 127   for (unam = unique_section_list; unam; unam = unam->next)
 128     if (wildcardp (unam->name)
 129         ? fnmatch (unam->name, secnam, 0) == 0
 130         : strcmp (unam->name, secnam) == 0)
 131       {
 132         return TRUE;
 133       }
 134
 135   return FALSE;
 136 }
 137
 138 /* Generic traversal routines for finding matching sections.  */
 139
 140 static void
 141 walk_wild_section (lang_wild_statement_type *ptr,
 142                    lang_input_statement_type *file,
 143                    callback_t callback,
 144                    void *data)
 145 {
 146   asection *s;
 147
 148   if (file->just_syms_flag)
 149     return;
 150
 151   for (s = file->the_bfd->sections; s != NULL; s = s->next)
 152     {
 153       struct wildcard_list *sec;
 154
 155       sec = ptr->section_list;
 156       if (sec == NULL)
 157         (*callback) (ptr, sec, s, file, data);
 158
 159       while (sec != NULL)
 160         {
 161           bfd_boolean skip = FALSE;
 162           struct name_list *list_tmp;
 163
 164           /* Don't process sections from files which were
 165              excluded.  */
 166           for (list_tmp = sec->spec.exclude_name_list;
 167                list_tmp;
 168                list_tmp = list_tmp->next)
 169             {
 170               if (wildcardp (list_tmp->name))
 171                 skip = fnmatch (list_tmp->name, file->filename, 0) == 0;
 172               else
 173                 skip = strcmp (list_tmp->name, file->filename) == 0;
 174
 175               /* If this file is part of an archive, and the archive is
 176                  excluded, exclude this file.  */
 177               if (! skip && file->the_bfd != NULL
 178                   && file->the_bfd->my_archive != NULL
 179                   && file->the_bfd->my_archive->filename != NULL)
 180                 {
 181                   if (wildcardp (list_tmp->name))
 182                     skip = fnmatch (list_tmp->name,
 183                                     file->the_bfd->my_archive->filename,
 184                                     0) == 0;
 185                   else
 186                     skip = strcmp (list_tmp->name,
 187                                    file->the_bfd->my_archive->filename) == 0;
 188                 }
 189
 190               if (skip)
 191                 break;
 192             }
 193
 194           if (!skip && sec->spec.name != NULL)
 195             {
 196               const char *sname = bfd_get_section_name (file->the_bfd, s);
 197
 198               if (wildcardp (sec->spec.name))
 199                 skip = fnmatch (sec->spec.name, sname, 0) != 0;
 200               else
 201                 skip = strcmp (sec->spec.name, sname) != 0;
 202             }
 203
 204           if (!skip)
 205             (*callback) (ptr, sec, s, file, data);
 206
 207           sec = sec->next;
 208         }
 209     }
 210 }
 211
 212 /* Handle a wild statement for a single file F.  */
 213
 214 static void
 215 walk_wild_file (lang_wild_statement_type *s,
 216                 lang_input_statement_type *f,
 217                 callback_t callback,
 218                 void *data)
 219 {
 220   if (f->the_bfd == NULL
 221       || ! bfd_check_format (f->the_bfd, bfd_archive))
 222     walk_wild_section (s, f, callback, data);
 223   else
 224     {
 225       bfd *member;
 226
 227       /* This is an archive file.  We must map each member of the
 228          archive separately.  */
 229       member = bfd_openr_next_archived_file (f->the_bfd, NULL);
 230       while (member != NULL)
 231         {
 232           /* When lookup_name is called, it will call the add_symbols
 233              entry point for the archive.  For each element of the
 234              archive which is included, BFD will call ldlang_add_file,
 235              which will set the usrdata field of the member to the
 236              lang_input_statement.  */
 237           if (member->usrdata != NULL)
 238             {
 239               walk_wild_section (s, member->usrdata, callback, data);
 240             }
 241
 242           member = bfd_openr_next_archived_file (f->the_bfd, member);
 243         }
 244     }
 245 }
 246
 247 static void
 248 walk_wild (lang_wild_statement_type *s, callback_t callback, void *data)
 249 {
 250   const char *file_spec = s->filename;
 251
 252   if (file_spec == NULL)
 253     {
 254       /* Perform the iteration over all files in the list.  */
 255       LANG_FOR_EACH_INPUT_STATEMENT (f)
 256         {
 257           walk_wild_file (s, f, callback, data);
 258         }
 259     }
 260   else if (wildcardp (file_spec))
 261     {
 262       LANG_FOR_EACH_INPUT_STATEMENT (f)
 263         {
 264           if (fnmatch (file_spec, f->filename, FNM_FILE_NAME) == 0)
 265             walk_wild_file (s, f, callback, data);
 266         }
 267     }
 268   else
 269     {
 270       lang_input_statement_type *f;
 271
 272       /* Perform the iteration over a single file.  */
 273       f = lookup_name (file_spec);
 274       if (f)
 275         walk_wild_file (s, f, callback, data);
 276     }
 277 }
 278
 279 /* lang_for_each_statement walks the parse tree and calls the provided
 280    function for each node.  */
 281
 282 static void
 283 lang_for_each_statement_worker (void (*func) (lang_statement_union_type *),
 284                                 lang_statement_union_type *s)
 285 {
 286   for (; s != NULL; s = s->header.next)
 287     {
 288       func (s);
 289
 290       switch (s->header.type)
 291         {
 292         case lang_constructors_statement_enum:
 293           lang_for_each_statement_worker (func, constructor_list.head);
 294           break;
 295         case lang_output_section_statement_enum:
 296           lang_for_each_statement_worker
 297             (func,
 298              s->output_section_statement.children.head);
 299           break;
 300         case lang_wild_statement_enum:
 301           lang_for_each_statement_worker
 302             (func,
 303              s->wild_statement.children.head);
 304           break;
 305         case lang_group_statement_enum:
 306           lang_for_each_statement_worker (func,
 307                                           s->group_statement.children.head);
 308           break;
 309         case lang_data_statement_enum:
 310         case lang_reloc_statement_enum:
 311         case lang_object_symbols_statement_enum:
 312         case lang_output_statement_enum:
 313         case lang_target_statement_enum:
 314         case lang_input_section_enum:
 315         case lang_input_statement_enum:
 316         case lang_assignment_statement_enum:
 317         case lang_padding_statement_enum:
 318         case lang_address_statement_enum:
 319         case lang_fill_statement_enum:
 320           break;
 321         default:
 322           FAIL ();
 323           break;
 324         }
 325     }
 326 }
 327
 328 void
 329 lang_for_each_statement (void (*func) (lang_statement_union_type *))
 330 {
 331   lang_for_each_statement_worker (func, statement_list.head);
 332 }
 333
 334 /*----------------------------------------------------------------------*/
 335
 336 void
 337 lang_list_init (lang_statement_list_type *list)
 338 {
 339   list->head = NULL;
 340   list->tail = &list->head;
 341 }
 342
 343 /* Build a new statement node for the parse tree.  */
 344
 345 static lang_statement_union_type *
 346 new_statement (enum statement_enum type,
 347                size_t size,
 348                lang_statement_list_type *list)
 349 {
 350   lang_statement_union_type *new;
 351
 352   new = stat_alloc (size);
 353   new->header.type = type;
 354   new->header.next = NULL;
 355   lang_statement_append (list, new, &new->header.next);
 356   return new;
 357 }
 358
 359 /* Build a new input file node for the language.  There are several
 360    ways in which we treat an input file, eg, we only look at symbols,
 361    or prefix it with a -l etc.
 362
 363    We can be supplied with requests for input files more than once;
 364    they may, for example be split over several lines like foo.o(.text)
 365    foo.o(.data) etc, so when asked for a file we check that we haven't
 366    got it already so we don't duplicate the bfd.  */
 367
 368 static lang_input_statement_type *
 369 new_afile (const char *name,
 370            lang_input_file_enum_type file_type,
 371            const char *target,
 372            bfd_boolean add_to_list)
 373 {
 374   lang_input_statement_type *p;
 375
 376   if (add_to_list)
 377     p = new_stat (lang_input_statement, stat_ptr);
 378   else
 379     {
 380       p = stat_alloc (sizeof (lang_input_statement_type));
 381       p->header.next = NULL;
 382     }
 383
 384   lang_has_input_file = TRUE;
 385   p->target = target;
 386   p->sysrooted = FALSE;
 387   switch (file_type)
 388     {
 389     case lang_input_file_is_symbols_only_enum:
 390       p->filename = name;
 391       p->is_archive = FALSE;
 392       p->real = TRUE;
 393       p->local_sym_name = name;
 394       p->just_syms_flag = TRUE;
 395       p->search_dirs_flag = FALSE;
 396       break;
 397     case lang_input_file_is_fake_enum:
 398       p->filename = name;
 399       p->is_archive = FALSE;
 400       p->real = FALSE;
 401       p->local_sym_name = name;
 402       p->just_syms_flag = FALSE;
 403       p->search_dirs_flag = FALSE;
 404       break;
 405     case lang_input_file_is_l_enum:
 406       p->is_archive = TRUE;
 407       p->filename = name;
 408       p->real = TRUE;
 409       p->local_sym_name = concat ("-l", name, NULL);
 410       p->just_syms_flag = FALSE;
 411       p->search_dirs_flag = TRUE;
 412       break;
 413     case lang_input_file_is_marker_enum:
 414       p->filename = name;
 415       p->is_archive = FALSE;
 416       p->real = FALSE;
 417       p->local_sym_name = name;
 418       p->just_syms_flag = FALSE;
 419       p->search_dirs_flag = TRUE;
 420       break;
 421     case lang_input_file_is_search_file_enum:
 422       p->sysrooted = ldlang_sysrooted_script;
 423       p->filename = name;
 424       p->is_archive = FALSE;
 425       p->real = TRUE;
 426       p->local_sym_name = name;
 427       p->just_syms_flag = FALSE;
 428       p->search_dirs_flag = TRUE;
 429       break;
 430     case lang_input_file_is_file_enum:
 431       p->filename = name;
 432       p->is_archive = FALSE;
 433       p->real = TRUE;
 434       p->local_sym_name = name;
 435       p->just_syms_flag = FALSE;
 436       p->search_dirs_flag = FALSE;
 437       break;
 438     default:
 439       FAIL ();
 440     }
 441   p->the_bfd = NULL;
 442   p->asymbols = NULL;
 443   p->next_real_file = NULL;
 444   p->next = NULL;
 445   p->symbol_count = 0;
 446   p->dynamic = config.dynamic_link;
 447   p->whole_archive = whole_archive;
 448   p->loaded = FALSE;
 449   lang_statement_append (&input_file_chain,
 450                          (lang_statement_union_type *) p,
 451                          &p->next_real_file);
 452   return p;
 453 }
 454
 455 lang_input_statement_type *
 456 lang_add_input_file (const char *name,
 457                      lang_input_file_enum_type file_type,
 458                      const char *target)
 459 {
 460   lang_has_input_file = TRUE;
 461   return new_afile (name, file_type, target, TRUE);
 462 }
 463
 464 /* Build enough state so that the parser can build its tree.  */
 465
 466 void
 467 lang_init (void)
 468 {
 469   obstack_begin (&stat_obstack, 1000);
 470
 471   stat_ptr = &statement_list;
 472
 473   lang_list_init (stat_ptr);
 474
 475   lang_list_init (&input_file_chain);
 476   lang_list_init (&lang_output_section_statement);
 477   lang_list_init (&file_chain);
 478   first_file = lang_add_input_file (NULL, lang_input_file_is_marker_enum,
 479                                     NULL);
 480   abs_output_section =
 481     lang_output_section_statement_lookup (BFD_ABS_SECTION_NAME);
 482
 483   abs_output_section->bfd_section = bfd_abs_section_ptr;
 484
 485   /* The value "3" is ad-hoc, somewhat related to the expected number of
 486      DEFINED expressions in a linker script.  For most default linker
 487      scripts, there are none.  Why a hash table then?  Well, it's somewhat
 488      simpler to re-use working machinery than using a linked list in terms
 489      of code-complexity here in ld, besides the initialization which just
 490      looks like other code here.  */
 491   if (bfd_hash_table_init_n (&lang_definedness_table,
 492                              lang_definedness_newfunc, 3) != TRUE)
 493     einfo (_("%P%F: out of memory during initialization"));
 494
 495   /* Callers of exp_fold_tree need to increment this.  */
 496   lang_statement_iteration = 0;
 497 }
 498
 499 /*----------------------------------------------------------------------
 500   A region is an area of memory declared with the
 501   MEMORY {  name:org=exp, len=exp ... }
 502   syntax.
 503
 504   We maintain a list of all the regions here.
 505
 506   If no regions are specified in the script, then the default is used
 507   which is created when looked up to be the entire data space.  */
 508
 509 static lang_memory_region_type *lang_memory_region_list;
 510 static lang_memory_region_type **lang_memory_region_list_tail = &lang_memory_region_list;
 511
 512 lang_memory_region_type *
 513 lang_memory_region_lookup (const char *const name)
 514 {
 515   lang_memory_region_type *p;
 516   lang_memory_region_type *new;
 517
 518   /* NAME is NULL for LMA memspecs if no region was specified.  */
 519   if (name == NULL)
 520     return NULL;
 521
 522   for (p = lang_memory_region_list; p != NULL; p = p->next)
 523     {
 524       if (strcmp (p->name, name) == 0)
 525         return p;
 526     }
 527
 528 #if 0
 529   /* This code used to always use the first region in the list as the
 530      default region.  I changed it to instead use a region
 531      encompassing all of memory as the default region.  This permits
 532      NOLOAD sections to work reasonably without requiring a region.
 533      People should specify what region they mean, if they really want
 534      a region.  */
 535   if (strcmp (name, "*default*") == 0)
 536     {
 537       if (lang_memory_region_list != NULL)
 538         return lang_memory_region_list;
 539     }
 540 #endif
 541
 542   new = stat_alloc (sizeof (lang_memory_region_type));
 543
 544   new->name = xstrdup (name);
 545   new->next = NULL;
 546
 547   *lang_memory_region_list_tail = new;
 548   lang_memory_region_list_tail = &new->next;
 549   new->origin = 0;
 550   new->flags = 0;
 551   new->not_flags = 0;
 552   new->length = ~(bfd_size_type) 0;
 553   new->current = 0;
 554   new->had_full_message = FALSE;
 555
 556   return new;
 557 }
 558
 559 static lang_memory_region_type *
 560 lang_memory_default (asection *section)
 561 {
 562   lang_memory_region_type *p;
 563
 564   flagword sec_flags = section->flags;
 565
 566   /* Override SEC_DATA to mean a writable section.  */
 567   if ((sec_flags & (SEC_ALLOC | SEC_READONLY | SEC_CODE)) == SEC_ALLOC)
 568     sec_flags |= SEC_DATA;
 569
 570   for (p = lang_memory_region_list; p != NULL; p = p->next)
 571     {
 572       if ((p->flags & sec_flags) != 0
 573           && (p->not_flags & sec_flags) == 0)
 574         {
 575           return p;
 576         }
 577     }
 578   return lang_memory_region_lookup ("*default*");
 579 }
 580
 581 lang_output_section_statement_type *
 582 lang_output_section_find (const char *const name)
 583 {
 584   lang_statement_union_type *u;
 585   lang_output_section_statement_type *lookup;
 586
 587   for (u = lang_output_section_statement.head; u != NULL; u = lookup->next)
 588     {
 589       lookup = &u->output_section_statement;
 590       if (strcmp (name, lookup->name) == 0)
 591         return lookup;
 592     }
 593   return NULL;
 594 }
 595
 596 lang_output_section_statement_type *
 597 lang_output_section_statement_lookup (const char *const name)
 598 {
 599   lang_output_section_statement_type *lookup;
 600
 601   lookup = lang_output_section_find (name);
 602   if (lookup == NULL)
 603     {
 604       lookup = new_stat (lang_output_section_statement, stat_ptr);
 605       lookup->region = NULL;
 606       lookup->lma_region = NULL;
 607       lookup->fill = 0;
 608       lookup->block_value = 1;
 609       lookup->name = name;
 610
 611       lookup->next = NULL;
 612       lookup->bfd_section = NULL;
 613       lookup->processed = FALSE;
 614       lookup->sectype = normal_section;
 615       lookup->addr_tree = NULL;
 616       lang_list_init (&lookup->children);
 617
 618       lookup->memspec = NULL;
 619       lookup->flags = 0;
 620       lookup->subsection_alignment = -1;
 621       lookup->section_alignment = -1;
 622       lookup->load_base = NULL;
 623       lookup->update_dot_tree = NULL;
 624       lookup->phdrs = NULL;
 625
 626       lang_statement_append (&lang_output_section_statement,
 627                              (lang_statement_union_type *) lookup,
 628                              &lookup->next);
 629     }
 630   return lookup;
 631 }
 632
 633 static void
 634 lang_map_flags (flagword flag)
 635 {
 636   if (flag & SEC_ALLOC)
 637     minfo ("a");
 638
 639   if (flag & SEC_CODE)
 640     minfo ("x");
 641
 642   if (flag & SEC_READONLY)
 643     minfo ("r");
 644
 645   if (flag & SEC_DATA)
 646     minfo ("w");
 647
 648   if (flag & SEC_LOAD)
 649     minfo ("l");
 650 }
 651
 652 void
 653 lang_map (void)
 654 {
 655   lang_memory_region_type *m;
 656
 657   minfo (_("\nMemory Configuration\n\n"));
 658   fprintf (config.map_file, "%-16s %-18s %-18s %s\n",
 659            _("Name"), _("Origin"), _("Length"), _("Attributes"));
 660
 661   for (m = lang_memory_region_list; m != NULL; m = m->next)
 662     {
 663       char buf[100];
 664       int len;
 665
 666       fprintf (config.map_file, "%-16s ", m->name);
 667
 668       sprintf_vma (buf, m->origin);
 669       minfo ("0x%s ", buf);
 670       len = strlen (buf);
 671       while (len < 16)
 672         {
 673           print_space ();
 674           ++len;
 675         }
 676
 677       minfo ("0x%V", m->length);
 678       if (m->flags || m->not_flags)
 679         {
 680 #ifndef BFD64
 681           minfo ("        ");
 682 #endif
 683           if (m->flags)
 684             {
 685               print_space ();
 686               lang_map_flags (m->flags);
 687             }
 688
 689           if (m->not_flags)
 690             {
 691               minfo (" !");
 692               lang_map_flags (m->not_flags);
 693             }
 694         }
 695
 696       print_nl ();
 697     }
 698
 699   fprintf (config.map_file, _("\nLinker script and memory map\n\n"));
 700
 701   print_statements ();
 702 }
 703
 704 /* Initialize an output section.  */
 705
 706 static void
 707 init_os (lang_output_section_statement_type *s)
 708 {
 709   section_userdata_type *new;
 710
 711   if (s->bfd_section != NULL)
 712     return;
 713
 714   if (strcmp (s->name, DISCARD_SECTION_NAME) == 0)
 715     einfo (_("%P%F: Illegal use of `%s' section\n"), DISCARD_SECTION_NAME);
 716
 717   new = stat_alloc (sizeof (section_userdata_type));
 718
 719   s->bfd_section = bfd_get_section_by_name (output_bfd, s->name);
 720   if (s->bfd_section == NULL)
 721     s->bfd_section = bfd_make_section (output_bfd, s->name);
 722   if (s->bfd_section == NULL)
 723     {
 724       einfo (_("%P%F: output format %s cannot represent section called %s\n"),
 725              output_bfd->xvec->name, s->name);
 726     }
 727   s->bfd_section->output_section = s->bfd_section;
 728
 729   /* We initialize an output sections output offset to minus its own
 730      vma to allow us to output a section through itself.  */
 731   s->bfd_section->output_offset = 0;
 732   get_userdata (s->bfd_section) = new;
 733
 734   /* If there is a base address, make sure that any sections it might
 735      mention are initialized.  */
 736   if (s->addr_tree != NULL)
 737     exp_init_os (s->addr_tree);
 738
 739   if (s->load_base != NULL)
 740     exp_init_os (s->load_base);
 741 }
 742
 743 /* Make sure that all output sections mentioned in an expression are
 744    initialized.  */
 745
 746 static void
 747 exp_init_os (etree_type *exp)
 748 {
 749   switch (exp->type.node_class)
 750     {
 751     case etree_assign:
 752       exp_init_os (exp->assign.src);
 753       break;
 754
 755     case etree_binary:
 756       exp_init_os (exp->binary.lhs);
 757       exp_init_os (exp->binary.rhs);
 758       break;
 759
 760     case etree_trinary:
 761       exp_init_os (exp->trinary.cond);
 762       exp_init_os (exp->trinary.lhs);
 763       exp_init_os (exp->trinary.rhs);
 764       break;
 765
 766     case etree_unary:
 767       exp_init_os (exp->unary.child);
 768       break;
 769
 770     case etree_name:
 771       switch (exp->type.node_code)
 772         {
 773         case ADDR:
 774         case LOADADDR:
 775         case SIZEOF:
 776           {
 777             lang_output_section_statement_type *os;
 778
 779             os = lang_output_section_find (exp->name.name);
 780             if (os != NULL && os->bfd_section == NULL)
 781               init_os (os);
 782           }
 783         }
 784       break;
 785
 786     default:
 787       break;
 788     }
 789 }
 790 \f
 791 /* Sections marked with the SEC_LINK_ONCE flag should only be linked
 792    once into the output.  This routine checks each section, and
 793    arrange to discard it if a section of the same name has already
 794    been linked.  If the section has COMDAT information, then it uses
 795    that to decide whether the section should be included.  This code
 796    assumes that all relevant sections have the SEC_LINK_ONCE flag set;
 797    that is, it does not depend solely upon the section name.
 798    section_already_linked is called via bfd_map_over_sections.  */
 799
 800 /* This is the shape of the elements inside the already_linked hash
 801    table. It maps a name onto a list of already_linked elements with
 802    the same name.  It's possible to get more than one element in a
 803    list if the COMDAT sections have different names.  */
 804
 805 struct already_linked_hash_entry
 806 {
 807   struct bfd_hash_entry root;
 808   struct already_linked *entry;
 809 };
 810
 811 struct already_linked
 812 {
 813   struct already_linked *next;
 814   asection *sec;
 815 };
 816
 817 /* The hash table.  */
 818
 819 static struct bfd_hash_table already_linked_table;
 820
 821 static void
 822 section_already_linked (bfd *abfd, asection *sec, void *data)
 823 {
 824   lang_input_statement_type *entry = data;
 825   flagword flags;
 826   const char *name;
 827   struct already_linked *l;
 828   struct already_linked_hash_entry *already_linked_list;
 829
 830   /* If we are only reading symbols from this object, then we want to
 831      discard all sections.  */
 832   if (entry->just_syms_flag)
 833     {
 834       bfd_link_just_syms (sec, &link_info);
 835       return;
 836     }
 837
 838   flags = bfd_get_section_flags (abfd, sec);
 839
 840   if ((flags & SEC_LINK_ONCE) == 0)
 841     return;
 842
 843   /* FIXME: When doing a relocatable link, we may have trouble
 844      copying relocations in other sections that refer to local symbols
 845      in the section being discarded.  Those relocations will have to
 846      be converted somehow; as of this writing I'm not sure that any of
 847      the backends handle that correctly.
 848
 849      It is tempting to instead not discard link once sections when
 850      doing a relocatable link (technically, they should be discarded
 851      whenever we are building constructors).  However, that fails,
 852      because the linker winds up combining all the link once sections
 853      into a single large link once section, which defeats the purpose
 854      of having link once sections in the first place.
 855
 856      Also, not merging link once sections in a relocatable link
 857      causes trouble for MIPS ELF, which relies on link once semantics
 858      to handle the .reginfo section correctly.  */
 859
 860   name = bfd_get_section_name (abfd, sec);
 861
 862   already_linked_list =
 863     ((struct already_linked_hash_entry *)
 864      bfd_hash_lookup (&already_linked_table, name, TRUE, FALSE));
 865
 866   for (l = already_linked_list->entry; l != NULL; l = l->next)
 867     {
 868       if (sec->comdat == NULL
 869           || l->sec->comdat == NULL
 870           || strcmp (sec->comdat->name, l->sec->comdat->name) == 0)
 871         {
 872           /* The section has already been linked.  See if we should
 873              issue a warning.  */
 874           switch (flags & SEC_LINK_DUPLICATES)
 875             {
 876             default:
 877               abort ();
 878
 879             case SEC_LINK_DUPLICATES_DISCARD:
 880               break;
 881
 882             case SEC_LINK_DUPLICATES_ONE_ONLY:
 883               if (sec->comdat == NULL)
 884                 einfo (_("%P: %B: warning: ignoring duplicate section `%s'\n"),
 885                        abfd, name);
 886               else
 887                 einfo (_("%P: %B: warning: ignoring duplicate `%s' section symbol `%s'\n"),
 888                        abfd, name, sec->comdat->name);
 889               break;
 890
 891             case SEC_LINK_DUPLICATES_SAME_CONTENTS:
 892               /* FIXME: We should really dig out the contents of both
 893                  sections and memcmp them.  The COFF/PE spec says that
 894                  the Microsoft linker does not implement this
 895                  correctly, so I'm not going to bother doing it
 896                  either.  */
 897               /* Fall through.  */
 898             case SEC_LINK_DUPLICATES_SAME_SIZE:
 899               if (bfd_section_size (abfd, sec)
 900                   != bfd_section_size (l->sec->owner, l->sec))
 901                 einfo (_("%P: %B: warning: duplicate section `%s' has different size\n"),
 902                        abfd, name);
 903               break;
 904             }
 905
 906           /* Set the output_section field so that lang_add_section
 907              does not create a lang_input_section structure for this
 908              section.  Since there might be a symbol in the section
 909              being discarded, we must retain a pointer to the section
 910              which we are really going to use.  */
 911           sec->output_section = bfd_abs_section_ptr;
 912           sec->kept_section = l->sec;
 913
 914           if (flags & SEC_GROUP)
 915             bfd_discard_group (abfd, sec);
 916
 917           return;
 918         }
 919     }
 920
 921   /* This is the first section with this name.  Record it.  Allocate
 922      the memory from the same obstack as the hash table is kept in.  */
 923
 924   l = bfd_hash_allocate (&already_linked_table, sizeof *l);
 925
 926   l->sec = sec;
 927   l->next = already_linked_list->entry;
 928   already_linked_list->entry = l;
 929 }
 930
 931 /* Support routines for the hash table used by section_already_linked,
 932    initialize the table, fill in an entry and remove the table.  */
 933
 934 static struct bfd_hash_entry *
 935 already_linked_newfunc (struct bfd_hash_entry *entry ATTRIBUTE_UNUSED,
 936                         struct bfd_hash_table *table,
 937                         const char *string ATTRIBUTE_UNUSED)
 938 {
 939   struct already_linked_hash_entry *ret =
 940     bfd_hash_allocate (table, sizeof (struct already_linked_hash_entry));
 941
 942   ret->entry = NULL;
 943
 944   return &ret->root;
 945 }
 946
 947 static void
 948 already_linked_table_init (void)
 949 {
 950   if (! bfd_hash_table_init_n (&already_linked_table,
 951                                already_linked_newfunc,
 952                                42))
 953     einfo (_("%P%F: Failed to create hash table\n"));
 954 }
 955
 956 static void
 957 already_linked_table_free (void)
 958 {
 959   bfd_hash_table_free (&already_linked_table);
 960 }
 961 \f
 962 /* The wild routines.
 963
 964    These expand statements like *(.text) and foo.o to a list of
 965    explicit actions, like foo.o(.text), bar.o(.text) and
 966    foo.o(.text, .data).  */
 967
 968 /* Return TRUE if the PATTERN argument is a wildcard pattern.
 969    Although backslashes are treated specially if a pattern contains
 970    wildcards, we do not consider the mere presence of a backslash to
 971    be enough to cause the pattern to be treated as a wildcard.
 972    That lets us handle DOS filenames more naturally.  */
 973
 974 static bfd_boolean
 975 wildcardp (const char *pattern)
 976 {
 977   const char *s;
 978
 979   for (s = pattern; *s != '\0'; ++s)
 980     if (*s == '?'
 981         || *s == '*'
 982         || *s == '[')
 983       return TRUE;
 984   return FALSE;
 985 }
 986
 987 /* Add SECTION to the output section OUTPUT.  Do this by creating a
 988    lang_input_section statement which is placed at PTR.  FILE is the
 989    input file which holds SECTION.  */
 990
 991 void
 992 lang_add_section (lang_statement_list_type *ptr,
 993                   asection *section,
 994                   lang_output_section_statement_type *output,
 995                   lang_input_statement_type *file)
 996 {
 997   flagword flags;
 998   bfd_boolean discard;
 999
1000   flags = bfd_get_section_flags (section->owner, section);
1001
1002   discard = FALSE;
1003
1004   /* Discard sections marked with SEC_EXCLUDE if we are doing a final
1005      link.  Discard debugging sections marked with SEC_EXCLUDE on a
1006      relocatable link too.  */
1007   if ((flags & SEC_EXCLUDE) != 0
1008       && ((flags & SEC_DEBUGGING) != 0 || !link_info.relocatable))
1009     discard = TRUE;
1010
1011   /* Discard input sections which are assigned to a section named
1012      DISCARD_SECTION_NAME.  */
1013   if (strcmp (output->name, DISCARD_SECTION_NAME) == 0)
1014     discard = TRUE;
1015
1016   /* Discard debugging sections if we are stripping debugging
1017      information.  */
1018   if ((link_info.strip == strip_debugger || link_info.strip == strip_all)
1019       && (flags & SEC_DEBUGGING) != 0)
1020     discard = TRUE;
1021
1022   if (discard)
1023     {
1024       if (section->output_section == NULL)
1025         {
1026           /* This prevents future calls from assigning this section.  */
1027           section->output_section = bfd_abs_section_ptr;
1028         }
1029       return;
1030     }
1031
1032   if (section->output_section == NULL)
1033     {
1034       bfd_boolean first;
1035       lang_input_section_type *new;
1036       flagword flags;
1037
1038       if (output->bfd_section == NULL)
1039         init_os (output);
1040
1041       first = ! output->bfd_section->linker_has_input;
1042       output->bfd_section->linker_has_input = 1;
1043
1044       /* Add a section reference to the list.  */
1045       new = new_stat (lang_input_section, ptr);
1046
1047       new->section = section;
1048       new->ifile = file;
1049       section->output_section = output->bfd_section;
1050
1051       flags = section->flags;
1052
1053       /* We don't copy the SEC_NEVER_LOAD flag from an input section
1054          to an output section, because we want to be able to include a
1055          SEC_NEVER_LOAD section in the middle of an otherwise loaded
1056          section (I don't know why we want to do this, but we do).
1057          build_link_order in ldwrite.c handles this case by turning
1058          the embedded SEC_NEVER_LOAD section into a fill.  */
1059
1060       flags &= ~ SEC_NEVER_LOAD;
1061
1062       /* If final link, don't copy the SEC_LINK_ONCE flags, they've
1063          already been processed.  One reason to do this is that on pe
1064          format targets, .text$foo sections go into .text and it's odd
1065          to see .text with SEC_LINK_ONCE set.  */
1066
1067       if (! link_info.relocatable)
1068         flags &= ~ (SEC_LINK_ONCE | SEC_LINK_DUPLICATES);
1069
1070       /* If this is not the first input section, and the SEC_READONLY
1071          flag is not currently set, then don't set it just because the
1072          input section has it set.  */
1073
1074       if (! first && (section->output_section->flags & SEC_READONLY) == 0)
1075         flags &= ~ SEC_READONLY;
1076
1077       /* Keep SEC_MERGE and SEC_STRINGS only if they are the same.  */
1078       if (! first
1079           && ((section->output_section->flags & (SEC_MERGE | SEC_STRINGS))
1080               != (flags & (SEC_MERGE | SEC_STRINGS))
1081               || ((flags & SEC_MERGE)
1082                   && section->output_section->entsize != section->entsize)))
1083         {
1084           section->output_section->flags &= ~ (SEC_MERGE | SEC_STRINGS);
1085           flags &= ~ (SEC_MERGE | SEC_STRINGS);
1086         }
1087
1088       /* For now make .tbss normal section.  */
1089       if ((flags & SEC_THREAD_LOCAL) && ! link_info.relocatable)
1090         flags |= SEC_LOAD;
1091
1092       section->output_section->flags |= flags;
1093
1094       if (flags & SEC_MERGE)
1095         section->output_section->entsize = section->entsize;
1096
1097       /* If SEC_READONLY is not set in the input section, then clear
1098          it from the output section.  */
1099       if ((section->flags & SEC_READONLY) == 0)
1100         section->output_section->flags &= ~SEC_READONLY;
1101
1102       switch (output->sectype)
1103         {
1104         case normal_section:
1105           break;
1106         case dsect_section:
1107         case copy_section:
1108         case info_section:
1109         case overlay_section:
1110           output->bfd_section->flags &= ~SEC_ALLOC;
1111           break;
1112         case noload_section:
1113           output->bfd_section->flags &= ~SEC_LOAD;
1114           output->bfd_section->flags |= SEC_NEVER_LOAD;
1115           break;
1116         }
1117
1118       /* Copy over SEC_SMALL_DATA.  */
1119       if (section->flags & SEC_SMALL_DATA)
1120         section->output_section->flags |= SEC_SMALL_DATA;
1121
1122       if (section->alignment_power > output->bfd_section->alignment_power)
1123         output->bfd_section->alignment_power = section->alignment_power;
1124
1125       /* If supplied an alignment, then force it.  */
1126       if (output->section_alignment != -1)
1127         output->bfd_section->alignment_power = output->section_alignment;
1128
1129       if (section->flags & SEC_BLOCK)
1130         {
1131           section->output_section->flags |= SEC_BLOCK;
1132           /* FIXME: This value should really be obtained from the bfd...  */
1133           output->block_value = 128;
1134         }
1135     }
1136 }
1137
1138 /* Handle wildcard sorting.  This returns the lang_input_section which
1139    should follow the one we are going to create for SECTION and FILE,
1140    based on the sorting requirements of WILD.  It returns NULL if the
1141    new section should just go at the end of the current list.  */
1142
1143 static lang_statement_union_type *
1144 wild_sort (lang_wild_statement_type *wild,
1145            struct wildcard_list *sec,
1146            lang_input_statement_type *file,
1147            asection *section)
1148 {
1149   const char *section_name;
1150   lang_statement_union_type *l;
1151
1152   if (!wild->filenames_sorted && (sec == NULL || !sec->spec.sorted))
1153     return NULL;
1154
1155   section_name = bfd_get_section_name (file->the_bfd, section);
1156   for (l = wild->children.head; l != NULL; l = l->header.next)
1157     {
1158       lang_input_section_type *ls;
1159
1160       if (l->header.type != lang_input_section_enum)
1161         continue;
1162       ls = &l->input_section;
1163
1164       /* Sorting by filename takes precedence over sorting by section
1165          name.  */
1166
1167       if (wild->filenames_sorted)
1168         {
1169           const char *fn, *ln;
1170           bfd_boolean fa, la;
1171           int i;
1172
1173           /* The PE support for the .idata section as generated by
1174              dlltool assumes that files will be sorted by the name of
1175              the archive and then the name of the file within the
1176              archive.  */
1177
1178           if (file->the_bfd != NULL
1179               && bfd_my_archive (file->the_bfd) != NULL)
1180             {
1181               fn = bfd_get_filename (bfd_my_archive (file->the_bfd));
1182               fa = TRUE;
1183             }
1184           else
1185             {
1186               fn = file->filename;
1187               fa = FALSE;
1188             }
1189
1190           if (ls->ifile->the_bfd != NULL
1191               && bfd_my_archive (ls->ifile->the_bfd) != NULL)
1192             {
1193               ln = bfd_get_filename (bfd_my_archive (ls->ifile->the_bfd));
1194               la = TRUE;
1195             }
1196           else
1197             {
1198               ln = ls->ifile->filename;
1199               la = FALSE;
1200             }
1201
1202           i = strcmp (fn, ln);
1203           if (i > 0)
1204             continue;
1205           else if (i < 0)
1206             break;
1207
1208           if (fa || la)
1209             {
1210               if (fa)
1211                 fn = file->filename;
1212               if (la)
1213                 ln = ls->ifile->filename;
1214
1215               i = strcmp (fn, ln);
1216               if (i > 0)
1217                 continue;
1218               else if (i < 0)
1219                 break;
1220             }
1221         }
1222
1223       /* Here either the files are not sorted by name, or we are
1224          looking at the sections for this file.  */
1225
1226       if (sec != NULL && sec->spec.sorted)
1227         {
1228           if (strcmp (section_name,
1229                       bfd_get_section_name (ls->ifile->the_bfd,
1230                                             ls->section))
1231               < 0)
1232             break;
1233         }
1234     }
1235
1236   return l;
1237 }
1238
1239 /* Expand a wild statement for a particular FILE.  SECTION may be
1240    NULL, in which case it is a wild card.  */
1241
1242 static void
1243 output_section_callback (lang_wild_statement_type *ptr,
1244                          struct wildcard_list *sec,
1245                          asection *section,
1246                          lang_input_statement_type *file,
1247                          void *output)
1248 {
1249   lang_statement_union_type *before;
1250
1251   /* Exclude sections that match UNIQUE_SECTION_LIST.  */
1252   if (unique_section_p (bfd_get_section_name (file->the_bfd, section)))
1253     return;
1254
1255   /* If the wild pattern was marked KEEP, the member sections
1256      should be as well.  */
1257   if (ptr->keep_sections)
1258     section->flags |= SEC_KEEP;
1259
1260   before = wild_sort (ptr, sec, file, section);
1261
1262   /* Here BEFORE points to the lang_input_section which
1263      should follow the one we are about to add.  If BEFORE
1264      is NULL, then the section should just go at the end
1265      of the current list.  */
1266
1267   if (before == NULL)
1268     lang_add_section (&ptr->children, section,
1269                       (lang_output_section_statement_type *) output,
1270                       file);
1271   else
1272     {
1273       lang_statement_list_type list;
1274       lang_statement_union_type **pp;
1275
1276       lang_list_init (&list);
1277       lang_add_section (&list, section,
1278                         (lang_output_section_statement_type *) output,
1279                         file);
1280
1281       /* If we are discarding the section, LIST.HEAD will
1282          be NULL.  */
1283       if (list.head != NULL)
1284         {
1285           ASSERT (list.head->header.next == NULL);
1286
1287           for (pp = &ptr->children.head;
1288                *pp != before;
1289                pp = &(*pp)->header.next)
1290             ASSERT (*pp != NULL);
1291
1292           list.head->header.next = *pp;
1293           *pp = list.head;
1294         }
1295     }
1296 }
1297
1298 /* This is passed a file name which must have been seen already and
1299    added to the statement tree.  We will see if it has been opened
1300    already and had its symbols read.  If not then we'll read it.  */
1301
1302 static lang_input_statement_type *
1303 lookup_name (const char *name)
1304 {
1305   lang_input_statement_type *search;
1306
1307   for (search = (lang_input_statement_type *) input_file_chain.head;
1308        search != NULL;
1309        search = (lang_input_statement_type *) search->next_real_file)
1310     {
1311       if (search->filename == NULL && name == NULL)
1312         return search;
1313       if (search->filename != NULL
1314           && name != NULL
1315           && strcmp (search->filename, name) == 0)
1316         break;
1317     }
1318
1319   if (search == NULL)
1320     search = new_afile (name, lang_input_file_is_file_enum, default_target,
1321                         FALSE);
1322
1323   /* If we have already added this file, or this file is not real
1324      (FIXME: can that ever actually happen?) or the name is NULL
1325      (FIXME: can that ever actually happen?) don't add this file.  */
1326   if (search->loaded
1327       || ! search->real
1328       || search->filename == NULL)
1329     return search;
1330
1331   if (! load_symbols (search, NULL))
1332     return NULL;
1333
1334   return search;
1335 }
1336
1337 /* Get the symbols for an input file.  */
1338
1339 static bfd_boolean
1340 load_symbols (lang_input_statement_type *entry,
1341               lang_statement_list_type *place)
1342 {
1343   char **matching;
1344
1345   if (entry->loaded)
1346     return TRUE;
1347
1348   ldfile_open_file (entry);
1349
1350   if (! bfd_check_format (entry->the_bfd, bfd_archive)
1351       && ! bfd_check_format_matches (entry->the_bfd, bfd_object, &matching))
1352     {
1353       bfd_error_type err;
1354       lang_statement_list_type *hold;
1355       bfd_boolean bad_load = TRUE;
1356       bfd_boolean save_ldlang_sysrooted_script;
1357
1358       err = bfd_get_error ();
1359
1360       /* See if the emulation has some special knowledge.  */
1361       if (ldemul_unrecognized_file (entry))
1362         return TRUE;
1363
1364       if (err == bfd_error_file_ambiguously_recognized)
1365         {
1366           char **p;
1367
1368           einfo (_("%B: file not recognized: %E\n"), entry->the_bfd);
1369           einfo (_("%B: matching formats:"), entry->the_bfd);
1370           for (p = matching; *p != NULL; p++)
1371             einfo (" %s", *p);
1372           einfo ("%F\n");
1373         }
1374       else if (err != bfd_error_file_not_recognized
1375                || place == NULL)
1376           einfo (_("%F%B: file not recognized: %E\n"), entry->the_bfd);
1377       else
1378         bad_load = FALSE;
1379
1380       bfd_close (entry->the_bfd);
1381       entry->the_bfd = NULL;
1382
1383       /* Try to interpret the file as a linker script.  */
1384       ldfile_open_command_file (entry->filename);
1385
1386       hold = stat_ptr;
1387       stat_ptr = place;
1388       save_ldlang_sysrooted_script = ldlang_sysrooted_script;
1389       ldlang_sysrooted_script = entry->sysrooted;
1390
1391       ldfile_assumed_script = TRUE;
1392       parser_input = input_script;
1393       yyparse ();
1394       ldfile_assumed_script = FALSE;
1395
1396       ldlang_sysrooted_script = save_ldlang_sysrooted_script;
1397       stat_ptr = hold;
1398
1399       return ! bad_load;
1400     }
1401
1402   if (ldemul_recognized_file (entry))
1403     return TRUE;
1404
1405   /* We don't call ldlang_add_file for an archive.  Instead, the
1406      add_symbols entry point will call ldlang_add_file, via the
1407      add_archive_element callback, for each element of the archive
1408      which is used.  */
1409   switch (bfd_get_format (entry->the_bfd))
1410     {
1411     default:
1412       break;
1413
1414     case bfd_object:
1415       ldlang_add_file (entry);
1416       if (trace_files || trace_file_tries)
1417         info_msg ("%I\n", entry);
1418       break;
1419
1420     case bfd_archive:
1421       if (entry->whole_archive)
1422         {
1423           bfd *member = NULL;
1424           bfd_boolean loaded = TRUE;
1425
1426           for (;;)
1427             {
1428               member = bfd_openr_next_archived_file (entry->the_bfd, member);
1429
1430               if (member == NULL)
1431                 break;
1432
1433               if (! bfd_check_format (member, bfd_object))
1434                 {
1435                   einfo (_("%F%B: member %B in archive is not an object\n"),
1436                          entry->the_bfd, member);
1437                   loaded = FALSE;
1438                 }
1439
1440               if (! ((*link_info.callbacks->add_archive_element)
1441                      (&link_info, member, "--whole-archive")))
1442                 abort ();
1443
1444               if (! bfd_link_add_symbols (member, &link_info))
1445                 {
1446                   einfo (_("%F%B: could not read symbols: %E\n"), member);
1447                   loaded = FALSE;
1448                 }
1449             }
1450
1451           entry->loaded = loaded;
1452           return loaded;
1453         }
1454       break;
1455     }
1456
1457   if (bfd_link_add_symbols (entry->the_bfd, &link_info))
1458     entry->loaded = TRUE;
1459   else
1460     einfo (_("%F%B: could not read symbols: %E\n"), entry->the_bfd);
1461
1462   return entry->loaded;
1463 }
1464
1465 /* Handle a wild statement.  S->FILENAME or S->SECTION_LIST or both
1466    may be NULL, indicating that it is a wildcard.  Separate
1467    lang_input_section statements are created for each part of the
1468    expansion; they are added after the wild statement S.  OUTPUT is
1469    the output section.  */
1470
1471 static void
1472 wild (lang_wild_statement_type *s,
1473       const char *target ATTRIBUTE_UNUSED,
1474       lang_output_section_statement_type *output)
1475 {
1476   struct wildcard_list *sec;
1477
1478   walk_wild (s, output_section_callback, output);
1479
1480   for (sec = s->section_list; sec != NULL; sec = sec->next)
1481     {
1482       if (default_common_section != NULL)
1483         break;
1484       if (sec->spec.name != NULL && strcmp (sec->spec.name, "COMMON") == 0)
1485         {
1486           /* Remember the section that common is going to in case we
1487              later get something which doesn't know where to put it.  */
1488           default_common_section = output;
1489         }
1490     }
1491 }
1492
1493 /* Return TRUE iff target is the sought target.  */
1494
1495 static int
1496 get_target (const bfd_target *target, void *data)
1497 {
1498   const char *sought = data;
1499
1500   return strcmp (target->name, sought) == 0;
1501 }
1502
1503 /* Like strcpy() but convert to lower case as well.  */
1504
1505 static void
1506 stricpy (char *dest, char *src)
1507 {
1508   char c;
1509
1510   while ((c = *src++) != 0)
1511     *dest++ = TOLOWER (c);
1512
1513   *dest = 0;
1514 }
1515
1516 /* Remove the first occurrence of needle (if any) in haystack
1517    from haystack.  */
1518
1519 static void
1520 strcut (char *haystack, char *needle)
1521 {
1522   haystack = strstr (haystack, needle);
1523
1524   if (haystack)
1525     {
1526       char *src;
1527
1528       for (src = haystack + strlen (needle); *src;)
1529         *haystack++ = *src++;
1530
1531       *haystack = 0;
1532     }
1533 }
1534
1535 /* Compare two target format name strings.
1536    Return a value indicating how "similar" they are.  */
1537
1538 static int
1539 name_compare (char *first, char *second)
1540 {
1541   char *copy1;
1542   char *copy2;
1543   int result;
1544
1545   copy1 = xmalloc (strlen (first) + 1);
1546   copy2 = xmalloc (strlen (second) + 1);
1547
1548   /* Convert the names to lower case.  */
1549   stricpy (copy1, first);
1550   stricpy (copy2, second);
1551
1552   /* Remove size and endian strings from the name.  */
1553   strcut (copy1, "big");
1554   strcut (copy1, "little");
1555   strcut (copy2, "big");
1556   strcut (copy2, "little");
1557
1558   /* Return a value based on how many characters match,
1559      starting from the beginning.   If both strings are
1560      the same then return 10 * their length.  */
1561   for (result = 0; copy1[result] == copy2[result]; result++)
1562     if (copy1[result] == 0)
1563       {
1564         result *= 10;
1565         break;
1566       }
1567
1568   free (copy1);
1569   free (copy2);
1570
1571   return result;
1572 }
1573
1574 /* Set by closest_target_match() below.  */
1575 static const bfd_target *winner;
1576
1577 /* Scan all the valid bfd targets looking for one that has the endianness
1578    requirement that was specified on the command line, and is the nearest
1579    match to the original output target.  */
1580
1581 static int
1582 closest_target_match (const bfd_target *target, void *data)
1583 {
1584   const bfd_target *original = data;
1585
1586   if (command_line.endian == ENDIAN_BIG
1587       && target->byteorder != BFD_ENDIAN_BIG)
1588     return 0;
1589
1590   if (command_line.endian == ENDIAN_LITTLE
1591       && target->byteorder != BFD_ENDIAN_LITTLE)
1592     return 0;
1593
1594   /* Must be the same flavour.  */
1595   if (target->flavour != original->flavour)
1596     return 0;
1597
1598   /* If we have not found a potential winner yet, then record this one.  */
1599   if (winner == NULL)
1600     {
1601       winner = target;
1602       return 0;
1603     }
1604
1605   /* Oh dear, we now have two potential candidates for a successful match.
1606      Compare their names and choose the better one.  */
1607   if (name_compare (target->name, original->name)
1608       > name_compare (winner->name, original->name))
1609     winner = target;
1610
1611   /* Keep on searching until wqe have checked them all.  */
1612   return 0;
1613 }
1614
1615 /* Return the BFD target format of the first input file.  */
1616
1617 static char *
1618 get_first_input_target (void)
1619 {
1620   char *target = NULL;
1621
1622   LANG_FOR_EACH_INPUT_STATEMENT (s)
1623     {
1624       if (s->header.type == lang_input_statement_enum
1625           && s->real)
1626         {
1627           ldfile_open_file (s);
1628
1629           if (s->the_bfd != NULL
1630               && bfd_check_format (s->the_bfd, bfd_object))
1631             {
1632               target = bfd_get_target (s->the_bfd);
1633
1634               if (target != NULL)
1635                 break;
1636             }
1637         }
1638     }
1639
1640   return target;
1641 }
1642
1643 const char *
1644 lang_get_output_target (void)
1645 {
1646   const char *target;
1647
1648   /* Has the user told us which output format to use?  */
1649   if (output_target != NULL)
1650     return output_target;
1651
1652   /* No - has the current target been set to something other than
1653      the default?  */
1654   if (current_target != default_target)
1655     return current_target;
1656
1657   /* No - can we determine the format of the first input file?  */
1658   target = get_first_input_target ();
1659   if (target != NULL)
1660     return target;
1661
1662   /* Failed - use the default output target.  */
1663   return default_target;
1664 }
1665
1666 /* Open the output file.  */
1667
1668 static bfd *
1669 open_output (const char *name)
1670 {
1671   bfd *output;
1672
1673   output_target = lang_get_output_target ();
1674
1675   /* Has the user requested a particular endianness on the command
1676      line?  */
1677   if (command_line.endian != ENDIAN_UNSET)
1678     {
1679       const bfd_target *target;
1680       enum bfd_endian desired_endian;
1681
1682       /* Get the chosen target.  */
1683       target = bfd_search_for_target (get_target, (void *) output_target);
1684
1685       /* If the target is not supported, we cannot do anything.  */
1686       if (target != NULL)
1687         {
1688           if (command_line.endian == ENDIAN_BIG)
1689             desired_endian = BFD_ENDIAN_BIG;
1690           else
1691             desired_endian = BFD_ENDIAN_LITTLE;
1692
1693           /* See if the target has the wrong endianness.  This should
1694              not happen if the linker script has provided big and
1695              little endian alternatives, but some scrips don't do
1696              this.  */
1697           if (target->byteorder != desired_endian)
1698             {
1699               /* If it does, then see if the target provides
1700                  an alternative with the correct endianness.  */
1701               if (target->alternative_target != NULL
1702                   && (target->alternative_target->byteorder == desired_endian))
1703                 output_target = target->alternative_target->name;
1704               else
1705                 {
1706                   /* Try to find a target as similar as possible to
1707                      the default target, but which has the desired
1708                      endian characteristic.  */
1709                   bfd_search_for_target (closest_target_match,
1710                                          (void *) target);
1711
1712                   /* Oh dear - we could not find any targets that
1713                      satisfy our requirements.  */
1714                   if (winner == NULL)
1715                     einfo (_("%P: warning: could not find any targets that match endianness requirement\n"));
1716                   else
1717                     output_target = winner->name;
1718                 }
1719             }
1720         }
1721     }
1722
1723   output = bfd_openw (name, output_target);
1724
1725   if (output == NULL)
1726     {
1727       if (bfd_get_error () == bfd_error_invalid_target)
1728         einfo (_("%P%F: target %s not found\n"), output_target);
1729
1730       einfo (_("%P%F: cannot open output file %s: %E\n"), name);
1731     }
1732
1733   delete_output_file_on_failure = TRUE;
1734
1735 #if 0
1736   output->flags |= D_PAGED;
1737 #endif
1738
1739   if (! bfd_set_format (output, bfd_object))
1740     einfo (_("%P%F:%s: can not make object file: %E\n"), name);
1741   if (! bfd_set_arch_mach (output,
1742                            ldfile_output_architecture,
1743                            ldfile_output_machine))
1744     einfo (_("%P%F:%s: can not set architecture: %E\n"), name);
1745
1746   link_info.hash = bfd_link_hash_table_create (output);
1747   if (link_info.hash == NULL)
1748     einfo (_("%P%F: can not create link hash table: %E\n"));
1749
1750   bfd_set_gp_size (output, g_switch_value);
1751   return output;
1752 }
1753
1754 static void
1755 ldlang_open_output (lang_statement_union_type *statement)
1756 {
1757   switch (statement->header.type)
1758     {
1759     case lang_output_statement_enum:
1760       ASSERT (output_bfd == NULL);
1761       output_bfd = open_output (statement->output_statement.name);
1762       ldemul_set_output_arch ();
1763       if (config.magic_demand_paged && !link_info.relocatable)
1764         output_bfd->flags |= D_PAGED;
1765       else
1766         output_bfd->flags &= ~D_PAGED;
1767       if (config.text_read_only)
1768         output_bfd->flags |= WP_TEXT;
1769       else
1770         output_bfd->flags &= ~WP_TEXT;
1771       if (link_info.traditional_format)
1772         output_bfd->flags |= BFD_TRADITIONAL_FORMAT;
1773       else
1774         output_bfd->flags &= ~BFD_TRADITIONAL_FORMAT;
1775       break;
1776
1777     case lang_target_statement_enum:
1778       current_target = statement->target_statement.target;
1779       break;
1780     default:
1781       break;
1782     }
1783 }
1784
1785 /* Open all the input files.  */
1786
1787 static void
1788 open_input_bfds (lang_statement_union_type *s, bfd_boolean force)
1789 {
1790   for (; s != NULL; s = s->header.next)
1791     {
1792       switch (s->header.type)
1793         {
1794         case lang_constructors_statement_enum:
1795           open_input_bfds (constructor_list.head, force);
1796           break;
1797         case lang_output_section_statement_enum:
1798           open_input_bfds (s->output_section_statement.children.head, force);
1799           break;
1800         case lang_wild_statement_enum:
1801           /* Maybe we should load the file's symbols.  */
1802           if (s->wild_statement.filename
1803               && ! wildcardp (s->wild_statement.filename))
1804             (void) lookup_name (s->wild_statement.filename);
1805           open_input_bfds (s->wild_statement.children.head, force);
1806           break;
1807         case lang_group_statement_enum:
1808           {
1809             struct bfd_link_hash_entry *undefs;
1810
1811             /* We must continually search the entries in the group
1812                until no new symbols are added to the list of undefined
1813                symbols.  */
1814
1815             do
1816               {
1817                 undefs = link_info.hash->undefs_tail;
1818                 open_input_bfds (s->group_statement.children.head, TRUE);
1819               }
1820             while (undefs != link_info.hash->undefs_tail);
1821           }
1822           break;
1823         case lang_target_statement_enum:
1824           current_target = s->target_statement.target;
1825           break;
1826         case lang_input_statement_enum:
1827           if (s->input_statement.real)
1828             {
1829               lang_statement_list_type add;
1830
1831               s->input_statement.target = current_target;
1832
1833               /* If we are being called from within a group, and this
1834                  is an archive which has already been searched, then
1835                  force it to be researched unless the whole archive
1836                  has been loaded already.  */
1837               if (force
1838                   && !s->input_statement.whole_archive
1839                   && s->input_statement.loaded
1840                   && bfd_check_format (s->input_statement.the_bfd,
1841                                        bfd_archive))
1842                 s->input_statement.loaded = FALSE;
1843
1844               lang_list_init (&add);
1845
1846               if (! load_symbols (&s->input_statement, &add))
1847                 config.make_executable = FALSE;
1848
1849               if (add.head != NULL)
1850                 {
1851                   *add.tail = s->header.next;
1852                   s->header.next = add.head;
1853                 }
1854             }
1855           break;
1856         default:
1857           break;
1858         }
1859     }
1860 }
1861
1862 /* If there are [COMMONS] statements, put a wild one into the bss
1863    section.  */
1864
1865 static void
1866 lang_reasonable_defaults (void)
1867 {
1868 #if 0
1869   lang_output_section_statement_lookup (".text");
1870   lang_output_section_statement_lookup (".data");
1871
1872   default_common_section = lang_output_section_statement_lookup (".bss");
1873
1874   if (!placed_commons)
1875     {
1876       lang_wild_statement_type *new =
1877       new_stat (lang_wild_statement,
1878                 &default_common_section->children);
1879
1880       new->section_name = "COMMON";
1881       new->filename = NULL;
1882       lang_list_init (&new->children);
1883     }
1884 #endif
1885 }
1886
1887 /* Add a symbol to a hash of symbols used in DEFINED (NAME) expressions.  */
1888
1889 void
1890 lang_track_definedness (const char *name)
1891 {
1892   if (bfd_hash_lookup (&lang_definedness_table, name, TRUE, FALSE) == NULL)
1893     einfo (_("%P%F: bfd_hash_lookup failed creating symbol %s\n"), name);
1894 }
1895
1896 /* New-function for the definedness hash table.  */
1897
1898 static struct bfd_hash_entry *
1899 lang_definedness_newfunc (struct bfd_hash_entry *entry,
1900                           struct bfd_hash_table *table ATTRIBUTE_UNUSED,
1901                           const char *name ATTRIBUTE_UNUSED)
1902 {
1903   struct lang_definedness_hash_entry *ret
1904     = (struct lang_definedness_hash_entry *) entry;
1905
1906   if (ret == NULL)
1907     ret = (struct lang_definedness_hash_entry *)
1908       bfd_hash_allocate (table, sizeof (struct lang_definedness_hash_entry));
1909
1910   if (ret == NULL)
1911     einfo (_("%P%F: bfd_hash_allocate failed creating symbol %s\n"), name);
1912
1913   ret->iteration = -1;
1914   return &ret->root;
1915 }
1916
1917 /* Return the iteration when the definition of NAME was last updated.  A
1918    value of -1 means that the symbol is not defined in the linker script
1919    or the command line, but may be defined in the linker symbol table.  */
1920
1921 int
1922 lang_symbol_definition_iteration (const char *name)
1923 {
1924   struct lang_definedness_hash_entry *defentry
1925     = (struct lang_definedness_hash_entry *)
1926     bfd_hash_lookup (&lang_definedness_table, name, FALSE, FALSE);
1927
1928   /* We've already created this one on the presence of DEFINED in the
1929      script, so it can't be NULL unless something is borked elsewhere in
1930      the code.  */
1931   if (defentry == NULL)
1932     FAIL ();
1933
1934   return defentry->iteration;
1935 }
1936
1937 /* Update the definedness state of NAME.  */
1938
1939 void
1940 lang_update_definedness (const char *name, struct bfd_link_hash_entry *h)
1941 {
1942   struct lang_definedness_hash_entry *defentry
1943     = (struct lang_definedness_hash_entry *)
1944     bfd_hash_lookup (&lang_definedness_table, name, FALSE, FALSE);
1945
1946   /* We don't keep track of symbols not tested with DEFINED.  */
1947   if (defentry == NULL)
1948     return;
1949
1950   /* If the symbol was already defined, and not from an earlier statement
1951      iteration, don't update the definedness iteration, because that'd
1952      make the symbol seem defined in the linker script at this point, and
1953      it wasn't; it was defined in some object.  If we do anyway, DEFINED
1954      would start to yield false before this point and the construct "sym =
1955      DEFINED (sym) ? sym : X;" would change sym to X despite being defined
1956      in an object.  */
1957   if (h->type != bfd_link_hash_undefined
1958       && h->type != bfd_link_hash_common
1959       && h->type != bfd_link_hash_new
1960       && defentry->iteration == -1)
1961     return;
1962
1963   defentry->iteration = lang_statement_iteration;
1964 }
1965
1966 /* Add the supplied name to the symbol table as an undefined reference.
1967    This is a two step process as the symbol table doesn't even exist at
1968    the time the ld command line is processed.  First we put the name
1969    on a list, then, once the output file has been opened, transfer the
1970    name to the symbol table.  */
1971
1972 typedef struct bfd_sym_chain ldlang_undef_chain_list_type;
1973
1974 #define ldlang_undef_chain_list_head entry_symbol.next
1975
1976 void
1977 ldlang_add_undef (const char *const name)
1978 {
1979   ldlang_undef_chain_list_type *new =
1980     stat_alloc (sizeof (ldlang_undef_chain_list_type));
1981
1982   new->next = ldlang_undef_chain_list_head;
1983   ldlang_undef_chain_list_head = new;
1984
1985   new->name = xstrdup (name);
1986
1987   if (output_bfd != NULL)
1988     insert_undefined (new->name);
1989 }
1990
1991 /* Insert NAME as undefined in the symbol table.  */
1992
1993 static void
1994 insert_undefined (const char *name)
1995 {
1996   struct bfd_link_hash_entry *h;
1997
1998   h = bfd_link_hash_lookup (link_info.hash, name, TRUE, FALSE, TRUE);
1999   if (h == NULL)
2000     einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
2001   if (h->type == bfd_link_hash_new)
2002     {
2003       h->type = bfd_link_hash_undefined;
2004       h->u.undef.abfd = NULL;
2005       bfd_link_add_undef (link_info.hash, h);
2006     }
2007 }
2008
2009 /* Run through the list of undefineds created above and place them
2010    into the linker hash table as undefined symbols belonging to the
2011    script file.  */
2012
2013 static void
2014 lang_place_undefineds (void)
2015 {
2016   ldlang_undef_chain_list_type *ptr;
2017
2018   for (ptr = ldlang_undef_chain_list_head; ptr != NULL; ptr = ptr->next)
2019     insert_undefined (ptr->name);
2020 }
2021
2022 /* Open input files and attach to output sections.  */
2023
2024 static void
2025 map_input_to_output_sections
2026   (lang_statement_union_type *s, const char *target,
2027    lang_output_section_statement_type *output_section_statement)
2028 {
2029   for (; s != NULL; s = s->header.next)
2030     {
2031       switch (s->header.type)
2032         {
2033         case lang_wild_statement_enum:
2034           wild (&s->wild_statement, target, output_section_statement);
2035           break;
2036         case lang_constructors_statement_enum:
2037           map_input_to_output_sections (constructor_list.head,
2038                                         target,
2039                                         output_section_statement);
2040           break;
2041         case lang_output_section_statement_enum:
2042           map_input_to_output_sections (s->output_section_statement.children.head,
2043                                         target,
2044                                         &s->output_section_statement);
2045           break;
2046         case lang_output_statement_enum:
2047           break;
2048         case lang_target_statement_enum:
2049           target = s->target_statement.target;
2050           break;
2051         case lang_group_statement_enum:
2052           map_input_to_output_sections (s->group_statement.children.head,
2053                                         target,
2054                                         output_section_statement);
2055           break;
2056         case lang_fill_statement_enum:
2057         case lang_input_section_enum:
2058         case lang_object_symbols_statement_enum:
2059         case lang_data_statement_enum:
2060         case lang_reloc_statement_enum:
2061         case lang_padding_statement_enum:
2062         case lang_input_statement_enum:
2063           if (output_section_statement != NULL
2064               && output_section_statement->bfd_section == NULL)
2065             init_os (output_section_statement);
2066           break;
2067         case lang_assignment_statement_enum:
2068           if (output_section_statement != NULL
2069               && output_section_statement->bfd_section == NULL)
2070             init_os (output_section_statement);
2071
2072           /* Make sure that any sections mentioned in the assignment
2073              are initialized.  */
2074           exp_init_os (s->assignment_statement.exp);
2075           break;
2076         case lang_afile_asection_pair_statement_enum:
2077           FAIL ();
2078           break;
2079         case lang_address_statement_enum:
2080           /* Mark the specified section with the supplied address.  */
2081           {
2082             lang_output_section_statement_type *os =
2083               lang_output_section_statement_lookup
2084                 (s->address_statement.section_name);
2085
2086             if (os->bfd_section == NULL)
2087               init_os (os);
2088             os->addr_tree = s->address_statement.address;
2089           }
2090           break;
2091         }
2092     }
2093 }
2094
2095 /* An output section might have been removed after its statement was
2096    added.  For example, ldemul_before_allocation can remove dynamic
2097    sections if they turn out to be not needed.  Clean them up here.  */
2098
2099 static void
2100 strip_excluded_output_sections (void)
2101 {
2102   lang_statement_union_type *u;
2103
2104   for (u = lang_output_section_statement.head;
2105        u != NULL;
2106        u = u->output_section_statement.next)
2107     {
2108       lang_output_section_statement_type *os;
2109       asection *s;
2110
2111       os = &u->output_section_statement;
2112       s = os->bfd_section;
2113       if (s != NULL && (s->flags & SEC_EXCLUDE) != 0)
2114         {
2115           asection **p;
2116
2117           os->bfd_section = NULL;
2118
2119           for (p = &output_bfd->sections; *p; p = &(*p)->next)
2120             if (*p == s)
2121               {
2122                 bfd_section_list_remove (output_bfd, p);
2123                 output_bfd->section_count--;
2124                 break;
2125               }
2126         }
2127     }
2128 }
2129
2130 static void
2131 print_output_section_statement
2132   (lang_output_section_statement_type *output_section_statement)
2133 {
2134   asection *section = output_section_statement->bfd_section;
2135   int len;
2136
2137   if (output_section_statement != abs_output_section)
2138     {
2139       minfo ("\n%s", output_section_statement->name);
2140
2141       if (section != NULL)
2142         {
2143           print_dot = section->vma;
2144
2145           len = strlen (output_section_statement->name);
2146           if (len >= SECTION_NAME_MAP_LENGTH - 1)
2147             {
2148               print_nl ();
2149               len = 0;
2150             }
2151           while (len < SECTION_NAME_MAP_LENGTH)
2152             {
2153               print_space ();
2154               ++len;
2155             }
2156
2157           minfo ("0x%V %W", section->vma, section->_raw_size);
2158
2159           if (output_section_statement->load_base != NULL)
2160             {
2161               bfd_vma addr;
2162
2163               addr = exp_get_abs_int (output_section_statement->load_base, 0,
2164                                       "load base", lang_final_phase_enum);
2165               minfo (_(" load address 0x%V"), addr);
2166             }
2167         }
2168
2169       print_nl ();
2170     }
2171
2172   print_statement_list (output_section_statement->children.head,
2173                         output_section_statement);
2174 }
2175
2176 static void
2177 print_assignment (lang_assignment_statement_type *assignment,
2178                   lang_output_section_statement_type *output_section)
2179 {
2180   int i;
2181   etree_value_type result;
2182
2183   for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
2184     print_space ();
2185
2186   result = exp_fold_tree (assignment->exp->assign.src, output_section,
2187                           lang_final_phase_enum, print_dot, &print_dot);
2188   if (result.valid_p)
2189     {
2190       const char *dst;
2191       bfd_vma value;
2192
2193       value = result.value + result.section->bfd_section->vma;
2194       dst = assignment->exp->assign.dst;
2195
2196       minfo ("0x%V", value);
2197       if (dst[0] == '.' && dst[1] == 0)
2198         print_dot = value;
2199     }
2200   else
2201     {
2202       minfo ("*undef*   ");
2203 #ifdef BFD64
2204       minfo ("        ");
2205 #endif
2206     }
2207
2208   minfo ("                ");
2209
2210   exp_print_tree (assignment->exp);
2211
2212   print_nl ();
2213 }
2214
2215 static void
2216 print_input_statement (lang_input_statement_type *statm)
2217 {
2218   if (statm->filename != NULL)
2219     {
2220       fprintf (config.map_file, "LOAD %s\n", statm->filename);
2221     }
2222 }
2223
2224 /* Print all symbols defined in a particular section.  This is called
2225    via bfd_link_hash_traverse.  */
2226
2227 static bfd_boolean
2228 print_one_symbol (struct bfd_link_hash_entry *hash_entry, void *ptr)
2229 {
2230   asection *sec = ptr;
2231
2232   if ((hash_entry->type == bfd_link_hash_defined
2233        || hash_entry->type == bfd_link_hash_defweak)
2234       && sec == hash_entry->u.def.section)
2235     {
2236       int i;
2237
2238       for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
2239         print_space ();
2240       minfo ("0x%V   ",
2241              (hash_entry->u.def.value
2242               + hash_entry->u.def.section->output_offset
2243               + hash_entry->u.def.section->output_section->vma));
2244
2245       minfo ("             %T\n", hash_entry->root.string);
2246     }
2247
2248   return TRUE;
2249 }
2250
2251 /* Print information about an input section to the map file.  */
2252
2253 static void
2254 print_input_section (lang_input_section_type *in)
2255 {
2256   asection *i = in->section;
2257   bfd_size_type size = i->_cooked_size != 0 ? i->_cooked_size : i->_raw_size;
2258   unsigned opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
2259                                                 ldfile_output_machine);
2260   if (size != 0)
2261     {
2262       print_space ();
2263
2264       minfo ("%s", i->name);
2265
2266       if (i->output_section != NULL)
2267         {
2268           int len;
2269
2270           len = 1 + strlen (i->name);
2271           if (len >= SECTION_NAME_MAP_LENGTH - 1)
2272             {
2273               print_nl ();
2274               len = 0;
2275             }
2276           while (len < SECTION_NAME_MAP_LENGTH)
2277             {
2278               print_space ();
2279               ++len;
2280             }
2281
2282           minfo ("0x%V %W %B\n",
2283                  i->output_section->vma + i->output_offset, size / opb,
2284                  i->owner);
2285
2286           if (i->_cooked_size != 0 && i->_cooked_size != i->_raw_size)
2287             {
2288               len = SECTION_NAME_MAP_LENGTH + 3;
2289 #ifdef BFD64
2290               len += 16;
2291 #else
2292               len += 8;
2293 #endif
2294               while (len > 0)
2295                 {
2296                   print_space ();
2297                   --len;
2298                 }
2299
2300               minfo (_("%W (size before relaxing)\n"), i->_raw_size);
2301             }
2302
2303           bfd_link_hash_traverse (link_info.hash, print_one_symbol, i);
2304
2305           print_dot = i->output_section->vma + i->output_offset + size / opb;
2306         }
2307     }
2308 }
2309
2310 static void
2311 print_fill_statement (lang_fill_statement_type *fill)
2312 {
2313   size_t size;
2314   unsigned char *p;
2315   fputs (" FILL mask 0x", config.map_file);
2316   for (p = fill->fill->data, size = fill->fill->size; size != 0; p++, size--)
2317     fprintf (config.map_file, "%02x", *p);
2318   fputs ("\n", config.map_file);
2319 }
2320
2321 static void
2322 print_data_statement (lang_data_statement_type *data)
2323 {
2324   int i;
2325   bfd_vma addr;
2326   bfd_size_type size;
2327   const char *name;
2328   unsigned opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
2329                                                 ldfile_output_machine);
2330
2331   for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
2332     print_space ();
2333
2334   addr = data->output_vma;
2335   if (data->output_section != NULL)
2336     addr += data->output_section->vma;
2337
2338   switch (data->type)
2339     {
2340     default:
2341       abort ();
2342     case BYTE:
2343       size = BYTE_SIZE;
2344       name = "BYTE";
2345       break;
2346     case SHORT:
2347       size = SHORT_SIZE;
2348       name = "SHORT";
2349       break;
2350     case LONG:
2351       size = LONG_SIZE;
2352       name = "LONG";
2353       break;
2354     case QUAD:
2355       size = QUAD_SIZE;
2356       name = "QUAD";
2357       break;
2358     case SQUAD:
2359       size = QUAD_SIZE;
2360       name = "SQUAD";
2361       break;
2362     }
2363
2364   minfo ("0x%V %W %s 0x%v", addr, size, name, data->value);
2365
2366   if (data->exp->type.node_class != etree_value)
2367     {
2368       print_space ();
2369       exp_print_tree (data->exp);
2370     }
2371
2372   print_nl ();
2373
2374   print_dot = addr + size / opb;
2375
2376 }
2377
2378 /* Print an address statement.  These are generated by options like
2379    -Ttext.  */
2380
2381 static void
2382 print_address_statement (lang_address_statement_type *address)
2383 {
2384   minfo (_("Address of section %s set to "), address->section_name);
2385   exp_print_tree (address->address);
2386   print_nl ();
2387 }
2388
2389 /* Print a reloc statement.  */
2390
2391 static void
2392 print_reloc_statement (lang_reloc_statement_type *reloc)
2393 {
2394   int i;
2395   bfd_vma addr;
2396   bfd_size_type size;
2397   unsigned opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
2398                                                 ldfile_output_machine);
2399
2400   for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
2401     print_space ();
2402
2403   addr = reloc->output_vma;
2404   if (reloc->output_section != NULL)
2405     addr += reloc->output_section->vma;
2406
2407   size = bfd_get_reloc_size (reloc->howto);
2408
2409   minfo ("0x%V %W RELOC %s ", addr, size, reloc->howto->name);
2410
2411   if (reloc->name != NULL)
2412     minfo ("%s+", reloc->name);
2413   else
2414     minfo ("%s+", reloc->section->name);
2415
2416   exp_print_tree (reloc->addend_exp);
2417
2418   print_nl ();
2419
2420   print_dot = addr + size / opb;
2421 }
2422
2423 static void
2424 print_padding_statement (lang_padding_statement_type *s)
2425 {
2426   int len;
2427   bfd_vma addr;
2428   unsigned opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
2429                                                 ldfile_output_machine);
2430
2431   minfo (" *fill*");
2432
2433   len = sizeof " *fill*" - 1;
2434   while (len < SECTION_NAME_MAP_LENGTH)
2435     {
2436       print_space ();
2437       ++len;
2438     }
2439
2440   addr = s->output_offset;
2441   if (s->output_section != NULL)
2442     addr += s->output_section->vma;
2443   minfo ("0x%V %W ", addr, s->size);
2444
2445   if (s->fill->size != 0)
2446     {
2447       size_t size;
2448       unsigned char *p;
2449       for (p = s->fill->data, size = s->fill->size; size != 0; p++, size--)
2450         fprintf (config.map_file, "%02x", *p);
2451     }
2452
2453   print_nl ();
2454
2455   print_dot = addr + s->size / opb;
2456 }
2457
2458 static void
2459 print_wild_statement (lang_wild_statement_type *w,
2460                       lang_output_section_statement_type *os)
2461 {
2462   struct wildcard_list *sec;
2463
2464   print_space ();
2465
2466   if (w->filenames_sorted)
2467     minfo ("SORT(");
2468   if (w->filename != NULL)
2469     minfo ("%s", w->filename);
2470   else
2471     minfo ("*");
2472   if (w->filenames_sorted)
2473     minfo (")");
2474
2475   minfo ("(");
2476   for (sec = w->section_list; sec; sec = sec->next)
2477     {
2478       if (sec->spec.sorted)
2479         minfo ("SORT(");
2480       if (sec->spec.exclude_name_list != NULL)
2481         {
2482           name_list *tmp;
2483           minfo ("EXCLUDE_FILE(%s", sec->spec.exclude_name_list->name);
2484           for (tmp = sec->spec.exclude_name_list->next; tmp; tmp = tmp->next)
2485             minfo (" %s", tmp->name);
2486           minfo (") ");
2487         }
2488       if (sec->spec.name != NULL)
2489         minfo ("%s", sec->spec.name);
2490       else
2491         minfo ("*");
2492       if (sec->spec.sorted)
2493         minfo (")");
2494       if (sec->next)
2495         minfo (" ");
2496     }
2497   minfo (")");
2498
2499   print_nl ();
2500
2501   print_statement_list (w->children.head, os);
2502 }
2503
2504 /* Print a group statement.  */
2505
2506 static void
2507 print_group (lang_group_statement_type *s,
2508              lang_output_section_statement_type *os)
2509 {
2510   fprintf (config.map_file, "START GROUP\n");
2511   print_statement_list (s->children.head, os);
2512   fprintf (config.map_file, "END GROUP\n");
2513 }
2514
2515 /* Print the list of statements in S.
2516    This can be called for any statement type.  */
2517
2518 static void
2519 print_statement_list (lang_statement_union_type *s,
2520                       lang_output_section_statement_type *os)
2521 {
2522   while (s != NULL)
2523     {
2524       print_statement (s, os);
2525       s = s->header.next;
2526     }
2527 }
2528
2529 /* Print the first statement in statement list S.
2530    This can be called for any statement type.  */
2531
2532 static void
2533 print_statement (lang_statement_union_type *s,
2534                  lang_output_section_statement_type *os)
2535 {
2536   switch (s->header.type)
2537     {
2538     default:
2539       fprintf (config.map_file, _("Fail with %d\n"), s->header.type);
2540       FAIL ();
2541       break;
2542     case lang_constructors_statement_enum:
2543       if (constructor_list.head != NULL)
2544         {
2545           if (constructors_sorted)
2546             minfo (" SORT (CONSTRUCTORS)\n");
2547           else
2548             minfo (" CONSTRUCTORS\n");
2549           print_statement_list (constructor_list.head, os);
2550         }
2551       break;
2552     case lang_wild_statement_enum:
2553       print_wild_statement (&s->wild_statement, os);
2554       break;
2555     case lang_address_statement_enum:
2556       print_address_statement (&s->address_statement);
2557       break;
2558     case lang_object_symbols_statement_enum:
2559       minfo (" CREATE_OBJECT_SYMBOLS\n");
2560       break;
2561     case lang_fill_statement_enum:
2562       print_fill_statement (&s->fill_statement);
2563       break;
2564     case lang_data_statement_enum:
2565       print_data_statement (&s->data_statement);
2566       break;
2567     case lang_reloc_statement_enum:
2568       print_reloc_statement (&s->reloc_statement);
2569       break;
2570     case lang_input_section_enum:
2571       print_input_section (&s->input_section);
2572       break;
2573     case lang_padding_statement_enum:
2574       print_padding_statement (&s->padding_statement);
2575       break;
2576     case lang_output_section_statement_enum:
2577       print_output_section_statement (&s->output_section_statement);
2578       break;
2579     case lang_assignment_statement_enum:
2580       print_assignment (&s->assignment_statement, os);
2581       break;
2582     case lang_target_statement_enum:
2583       fprintf (config.map_file, "TARGET(%s)\n", s->target_statement.target);
2584       break;
2585     case lang_output_statement_enum:
2586       minfo ("OUTPUT(%s", s->output_statement.name);
2587       if (output_target != NULL)
2588         minfo (" %s", output_target);
2589       minfo (")\n");
2590       break;
2591     case lang_input_statement_enum:
2592       print_input_statement (&s->input_statement);
2593       break;
2594     case lang_group_statement_enum:
2595       print_group (&s->group_statement, os);
2596       break;
2597     case lang_afile_asection_pair_statement_enum:
2598       FAIL ();
2599       break;
2600     }
2601 }
2602
2603 static void
2604 print_statements (void)
2605 {
2606   print_statement_list (statement_list.head, abs_output_section);
2607 }
2608
2609 /* Print the first N statements in statement list S to STDERR.
2610    If N == 0, nothing is printed.
2611    If N < 0, the entire list is printed.
2612    Intended to be called from GDB.  */
2613
2614 void
2615 dprint_statement (lang_statement_union_type *s, int n)
2616 {
2617   FILE *map_save = config.map_file;
2618
2619   config.map_file = stderr;
2620
2621   if (n < 0)
2622     print_statement_list (s, abs_output_section);
2623   else
2624     {
2625       while (s && --n >= 0)
2626         {
2627           print_statement (s, abs_output_section);
2628           s = s->header.next;
2629         }
2630     }
2631
2632   config.map_file = map_save;
2633 }
2634
2635 static void
2636 insert_pad (lang_statement_union_type **ptr,
2637             fill_type *fill,
2638             unsigned int alignment_needed,
2639             asection *output_section,
2640             bfd_vma dot)
2641 {
2642   static fill_type zero_fill = { 1, { 0 } };
2643   lang_statement_union_type *pad;
2644
2645   pad = ((lang_statement_union_type *)
2646          ((char *) ptr - offsetof (lang_statement_union_type, header.next)));
2647   if (ptr != &statement_list.head
2648       && pad->header.type == lang_padding_statement_enum
2649       && pad->padding_statement.output_section == output_section)
2650     {
2651       /* Use the existing pad statement.  The above test on output
2652          section is probably redundant, but it doesn't hurt to check.  */
2653     }
2654   else
2655     {
2656       /* Make a new padding statement, linked into existing chain.  */
2657       pad = stat_alloc (sizeof (lang_padding_statement_type));
2658       pad->header.next = *ptr;
2659       *ptr = pad;
2660       pad->header.type = lang_padding_statement_enum;
2661       pad->padding_statement.output_section = output_section;
2662       if (fill == NULL)
2663         fill = &zero_fill;
2664       pad->padding_statement.fill = fill;
2665     }
2666   pad->padding_statement.output_offset = dot - output_section->vma;
2667   pad->padding_statement.size = alignment_needed;
2668   output_section->_raw_size += alignment_needed;
2669 }
2670
2671 /* Work out how much this section will move the dot point.  */
2672
2673 static bfd_vma
2674 size_input_section (lang_statement_union_type **this_ptr,
2675                     lang_output_section_statement_type *output_section_statement,
2676                     fill_type *fill,
2677                     bfd_vma dot)
2678 {
2679   lang_input_section_type *is = &((*this_ptr)->input_section);
2680   asection *i = is->section;
2681
2682   if (!is->ifile->just_syms_flag)
2683     {
2684       unsigned opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
2685                                                     ldfile_output_machine);
2686       unsigned int alignment_needed;
2687       asection *o;
2688
2689       /* Align this section first to the input sections requirement,
2690          then to the output section's requirement.  If this alignment
2691          is greater than any seen before, then record it too.  Perform
2692          the alignment by inserting a magic 'padding' statement.  */
2693
2694       if (output_section_statement->subsection_alignment != -1)
2695         i->alignment_power = output_section_statement->subsection_alignment;
2696
2697       o = output_section_statement->bfd_section;
2698       if (o->alignment_power < i->alignment_power)
2699         o->alignment_power = i->alignment_power;
2700
2701       alignment_needed = align_power (dot, i->alignment_power) - dot;
2702
2703       if (alignment_needed != 0)
2704         {
2705           insert_pad (this_ptr, fill, alignment_needed * opb, o, dot);
2706           dot += alignment_needed;
2707         }
2708
2709       /* Remember where in the output section this input section goes.  */
2710
2711       i->output_offset = dot - o->vma;
2712
2713       /* Mark how big the output section must be to contain this now.  */
2714       if (i->_cooked_size != 0)
2715         dot += i->_cooked_size / opb;
2716       else
2717         dot += i->_raw_size / opb;
2718       o->_raw_size = (dot - o->vma) * opb;
2719     }
2720   else
2721     {
2722       i->output_offset = i->vma - output_section_statement->bfd_section->vma;
2723     }
2724
2725   return dot;
2726 }
2727
2728 #define IGNORE_SECTION(bfd, s) \
2729   (((bfd_get_section_flags (bfd, s) & (SEC_ALLOC | SEC_LOAD))   \
2730     != (SEC_ALLOC | SEC_LOAD))                                  \
2731    || bfd_section_size (bfd, s) == 0)
2732
2733 /* Check to see if any allocated sections overlap with other allocated
2734    sections.  This can happen when the linker script specifically specifies
2735    the output section addresses of the two sections.  */
2736
2737 static void
2738 lang_check_section_addresses (void)
2739 {
2740   asection *s;
2741   unsigned opb = bfd_octets_per_byte (output_bfd);
2742
2743   /* Scan all sections in the output list.  */
2744   for (s = output_bfd->sections; s != NULL; s = s->next)
2745     {
2746       asection *os;
2747
2748       /* Ignore sections which are not loaded or which have no contents.  */
2749       if (IGNORE_SECTION (output_bfd, s))
2750         continue;
2751
2752       /* Once we reach section 's' stop our seach.  This prevents two
2753          warning messages from being produced, one for 'section A overlaps
2754          section B' and one for 'section B overlaps section A'.  */
2755       for (os = output_bfd->sections; os != s; os = os->next)
2756         {
2757           bfd_vma s_start;
2758           bfd_vma s_end;
2759           bfd_vma os_start;
2760           bfd_vma os_end;
2761
2762           /* Only consider loadable sections with real contents.  */
2763           if (IGNORE_SECTION (output_bfd, os))
2764             continue;
2765
2766           /* We must check the sections' LMA addresses not their
2767              VMA addresses because overlay sections can have
2768              overlapping VMAs but they must have distinct LMAs.  */
2769           s_start  = bfd_section_lma (output_bfd, s);
2770           os_start = bfd_section_lma (output_bfd, os);
2771           s_end    = s_start  + bfd_section_size (output_bfd, s) / opb - 1;
2772           os_end   = os_start + bfd_section_size (output_bfd, os) / opb - 1;
2773
2774           /* Look for an overlap.  */
2775           if ((s_end < os_start) || (s_start > os_end))
2776             continue;
2777
2778           einfo (
2779 _("%X%P: section %s [%V -> %V] overlaps section %s [%V -> %V]\n"),
2780                  s->name, s_start, s_end, os->name, os_start, os_end);
2781
2782           /* Once we have found one overlap for this section,
2783              stop looking for others.  */
2784           break;
2785         }
2786     }
2787 }
2788
2789 /* Make sure the new address is within the region.  We explicitly permit the
2790    current address to be at the exact end of the region when the address is
2791    non-zero, in case the region is at the end of addressable memory and the
2792    calculation wraps around.  */
2793
2794 static void
2795 os_region_check (lang_output_section_statement_type *os,
2796                  struct memory_region_struct *region,
2797                  etree_type *tree,
2798                  bfd_vma base)
2799 {
2800   if ((region->current < region->origin
2801        || (region->current - region->origin > region->length))
2802       && ((region->current != region->origin + region->length)
2803           || base == 0))
2804     {
2805       if (tree != NULL)
2806         {
2807           einfo (_("%X%P: address 0x%v of %B section %s is not within region %s\n"),
2808                  region->current,
2809                  os->bfd_section->owner,
2810                  os->bfd_section->name,
2811                  region->name);
2812         }
2813       else
2814         {
2815           einfo (_("%X%P: region %s is full (%B section %s)\n"),
2816                  region->name,
2817                  os->bfd_section->owner,
2818                  os->bfd_section->name);
2819         }
2820       /* Reset the region pointer.  */
2821       region->current = region->origin;
2822     }
2823 }
2824
2825 /* Set the sizes for all the output sections.  */
2826
2827 static bfd_vma
2828 lang_size_sections_1
2829   (lang_statement_union_type *s,
2830    lang_output_section_statement_type *output_section_statement,
2831    lang_statement_union_type **prev,
2832    fill_type *fill,
2833    bfd_vma dot,
2834    bfd_boolean *relax,
2835    bfd_boolean check_regions)
2836 {
2837   unsigned opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
2838                                                 ldfile_output_machine);
2839
2840   /* Size up the sections from their constituent parts.  */
2841   for (; s != NULL; s = s->header.next)
2842     {
2843       switch (s->header.type)
2844         {
2845         case lang_output_section_statement_enum:
2846           {
2847             bfd_vma after;
2848             lang_output_section_statement_type *os;
2849
2850             os = &s->output_section_statement;
2851             if (os->bfd_section == NULL)
2852               /* This section was never actually created.  */
2853               break;
2854
2855             /* If this is a COFF shared library section, use the size and
2856                address from the input section.  FIXME: This is COFF
2857                specific; it would be cleaner if there were some other way
2858                to do this, but nothing simple comes to mind.  */
2859             if ((os->bfd_section->flags & SEC_COFF_SHARED_LIBRARY) != 0)
2860               {
2861                 asection *input;
2862
2863                 if (os->children.head == NULL
2864                     || os->children.head->header.next != NULL
2865                     || os->children.head->header.type != lang_input_section_enum)
2866                   einfo (_("%P%X: Internal error on COFF shared library section %s\n"),
2867                          os->name);
2868
2869                 input = os->children.head->input_section.section;
2870                 bfd_set_section_vma (os->bfd_section->owner,
2871                                      os->bfd_section,
2872                                      bfd_section_vma (input->owner, input));
2873                 os->bfd_section->_raw_size = input->_raw_size;
2874                 break;
2875               }
2876
2877             if (bfd_is_abs_section (os->bfd_section))
2878               {
2879                 /* No matter what happens, an abs section starts at zero.  */
2880                 ASSERT (os->bfd_section->vma == 0);
2881               }
2882             else
2883               {
2884                 if (os->addr_tree == NULL)
2885                   {
2886                     /* No address specified for this section, get one
2887                        from the region specification.  */
2888                     if (os->region == NULL
2889                         || (((bfd_get_section_flags (output_bfd, os->bfd_section)
2890                               & (SEC_ALLOC | SEC_LOAD)) != 0)
2891                             && os->region->name[0] == '*'
2892                             && strcmp (os->region->name, "*default*") == 0))
2893                       {
2894                         os->region = lang_memory_default (os->bfd_section);
2895                       }
2896
2897                     /* If a loadable section is using the default memory
2898                        region, and some non default memory regions were
2899                        defined, issue an error message.  */
2900                     if (!IGNORE_SECTION (output_bfd, os->bfd_section)
2901                         && (bfd_get_section_flags (output_bfd, os->bfd_section)
2902                             & SEC_NEVER_LOAD) == 0
2903                         && ! link_info.relocatable
2904                         && check_regions
2905                         && strcmp (os->region->name, "*default*") == 0
2906                         && lang_memory_region_list != NULL
2907                         && (strcmp (lang_memory_region_list->name,
2908                                     "*default*") != 0
2909                             || lang_memory_region_list->next != NULL))
2910                       {
2911                         /* By default this is an error rather than just a
2912                            warning because if we allocate the section to the
2913                            default memory region we can end up creating an
2914                            excessivly large binary, or even seg faulting when
2915                            attmepting to perform a negative seek.  See
2916                              http://sources.redhat.com/ml/binutils/2003-04/msg00423.html
2917                            for an example of this.  This behaviour can be
2918                            overridden by the using the --no-check-sections
2919                            switch.  */
2920                         if (command_line.check_section_addresses)
2921                           einfo (_("%P%F: error: no memory region specified for loadable section `%s'\n"),
2922                                  bfd_get_section_name (output_bfd,
2923                                                        os->bfd_section));
2924                         else
2925                           einfo (_("%P: warning: no memory region specified for loadable section `%s'\n"),
2926                                  bfd_get_section_name (output_bfd,
2927                                                        os->bfd_section));
2928                       }
2929
2930                     dot = os->region->current;
2931
2932                     if (os->section_alignment == -1)
2933                       {
2934                         bfd_vma olddot;
2935
2936                         olddot = dot;
2937                         dot = align_power (dot,
2938                                            os->bfd_section->alignment_power);
2939
2940                         if (dot != olddot && config.warn_section_align)
2941                           einfo (_("%P: warning: changing start of section %s by %u bytes\n"),
2942                                  os->name, (unsigned int) (dot - olddot));
2943                       }
2944                   }
2945                 else
2946                   {
2947                     etree_value_type r;
2948
2949                     r = exp_fold_tree (os->addr_tree,
2950                                        abs_output_section,
2951                                        lang_allocating_phase_enum,
2952                                        dot, &dot);
2953                     if (!r.valid_p)
2954                       einfo (_("%F%S: non constant address expression for section %s\n"),
2955                              os->name);
2956
2957                     dot = r.value + r.section->bfd_section->vma;
2958                   }
2959
2960                 /* The section starts here.
2961                    First, align to what the section needs.  */
2962
2963                 if (os->section_alignment != -1)
2964                   dot = align_power (dot, os->section_alignment);
2965
2966                 bfd_set_section_vma (0, os->bfd_section, dot);
2967
2968                 os->bfd_section->output_offset = 0;
2969               }
2970
2971             lang_size_sections_1 (os->children.head, os, &os->children.head,
2972                                   os->fill, dot, relax, check_regions);
2973
2974             /* Put the section within the requested block size, or
2975                align at the block boundary.  */
2976             after = align_n (os->bfd_section->vma
2977                              + os->bfd_section->_raw_size / opb,
2978                              (bfd_vma) os->block_value);
2979
2980             if (bfd_is_abs_section (os->bfd_section))
2981               ASSERT (after == os->bfd_section->vma);
2982             else if ((os->bfd_section->flags & SEC_HAS_CONTENTS) == 0
2983                      && (os->bfd_section->flags & SEC_THREAD_LOCAL)
2984                      && ! link_info.relocatable)
2985               os->bfd_section->_raw_size = 0;
2986             else
2987               os->bfd_section->_raw_size =
2988                 (after - os->bfd_section->vma) * opb;
2989
2990             dot = os->bfd_section->vma + os->bfd_section->_raw_size / opb;
2991             os->processed = TRUE;
2992
2993             if (os->update_dot_tree != 0)
2994               exp_fold_tree (os->update_dot_tree, abs_output_section,
2995                              lang_allocating_phase_enum, dot, &dot);
2996
2997             /* Update dot in the region ?
2998                We only do this if the section is going to be allocated,
2999                since unallocated sections do not contribute to the region's
3000                overall size in memory.
3001
3002                If the SEC_NEVER_LOAD bit is not set, it will affect the
3003                addresses of sections after it. We have to update
3004                dot.  */
3005             if (os->region != NULL
3006                 && ((bfd_get_section_flags (output_bfd, os->bfd_section)
3007                      & SEC_NEVER_LOAD) == 0
3008                     || (bfd_get_section_flags (output_bfd, os->bfd_section)
3009                         & (SEC_ALLOC | SEC_LOAD))))
3010               {
3011                 os->region->current = dot;
3012
3013                 if (check_regions)
3014                   /* Make sure the new address is within the region.  */
3015                   os_region_check (os, os->region, os->addr_tree,
3016                                    os->bfd_section->vma);
3017
3018                 /* If there's no load address specified, use the run
3019                    region as the load region.  */
3020                 if (os->lma_region == NULL && os->load_base == NULL)
3021                   os->lma_region = os->region;
3022
3023                 if (os->lma_region != NULL && os->lma_region != os->region)
3024                   {
3025                     /* Set load_base, which will be handled later.  */
3026                     os->load_base = exp_intop (os->lma_region->current);
3027                     os->lma_region->current +=
3028                       os->bfd_section->_raw_size / opb;
3029                     if (check_regions)
3030                       os_region_check (os, os->lma_region, NULL,
3031                                        os->bfd_section->lma);
3032                   }
3033               }
3034           }
3035           break;
3036
3037         case lang_constructors_statement_enum:
3038           dot = lang_size_sections_1 (constructor_list.head,
3039                                       output_section_statement,
3040                                       &s->wild_statement.children.head,
3041                                       fill, dot, relax, check_regions);
3042           break;
3043
3044         case lang_data_statement_enum:
3045           {
3046             unsigned int size = 0;
3047
3048             s->data_statement.output_vma =
3049               dot - output_section_statement->bfd_section->vma;
3050             s->data_statement.output_section =
3051               output_section_statement->bfd_section;
3052
3053             switch (s->data_statement.type)
3054               {
3055               default:
3056                 abort ();
3057               case QUAD:
3058               case SQUAD:
3059                 size = QUAD_SIZE;
3060                 break;
3061               case LONG:
3062                 size = LONG_SIZE;
3063                 break;
3064               case SHORT:
3065                 size = SHORT_SIZE;
3066                 break;
3067               case BYTE:
3068                 size = BYTE_SIZE;
3069                 break;
3070               }
3071             if (size < opb)
3072               size = opb;
3073             dot += size / opb;
3074             output_section_statement->bfd_section->_raw_size += size;
3075             /* The output section gets contents, and then we inspect for
3076                any flags set in the input script which override any ALLOC.  */
3077             output_section_statement->bfd_section->flags |= SEC_HAS_CONTENTS;
3078             if (!(output_section_statement->flags & SEC_NEVER_LOAD))
3079               {
3080                 output_section_statement->bfd_section->flags |=
3081                   SEC_ALLOC | SEC_LOAD;
3082               }
3083           }
3084           break;
3085
3086         case lang_reloc_statement_enum:
3087           {
3088             int size;
3089
3090             s->reloc_statement.output_vma =
3091               dot - output_section_statement->bfd_section->vma;
3092             s->reloc_statement.output_section =
3093               output_section_statement->bfd_section;
3094             size = bfd_get_reloc_size (s->reloc_statement.howto);
3095             dot += size / opb;
3096             output_section_statement->bfd_section->_raw_size += size;
3097           }
3098           break;
3099
3100         case lang_wild_statement_enum:
3101
3102           dot = lang_size_sections_1 (s->wild_statement.children.head,
3103                                       output_section_statement,
3104                                       &s->wild_statement.children.head,
3105                                       fill, dot, relax, check_regions);
3106
3107           break;
3108
3109         case lang_object_symbols_statement_enum:
3110           link_info.create_object_symbols_section =
3111             output_section_statement->bfd_section;
3112           break;
3113         case lang_output_statement_enum:
3114         case lang_target_statement_enum:
3115           break;
3116         case lang_input_section_enum:
3117           {
3118             asection *i;
3119
3120             i = (*prev)->input_section.section;
3121             if (! relax)
3122               {
3123                 if (i->_cooked_size == 0)
3124                   i->_cooked_size = i->_raw_size;
3125               }
3126             else
3127               {
3128                 bfd_boolean again;
3129
3130                 if (! bfd_relax_section (i->owner, i, &link_info, &again))
3131                   einfo (_("%P%F: can't relax section: %E\n"));
3132                 if (again)
3133                   *relax = TRUE;
3134               }
3135             dot = size_input_section (prev, output_section_statement,
3136                                       output_section_statement->fill, dot);
3137           }
3138           break;
3139         case lang_input_statement_enum:
3140           break;
3141         case lang_fill_statement_enum:
3142           s->fill_statement.output_section =
3143             output_section_statement->bfd_section;
3144
3145           fill = s->fill_statement.fill;
3146           break;
3147         case lang_assignment_statement_enum:
3148           {
3149             bfd_vma newdot = dot;
3150
3151             exp_fold_tree (s->assignment_statement.exp,
3152                            output_section_statement,
3153                            lang_allocating_phase_enum,
3154                            dot,
3155                            &newdot);
3156
3157             if (newdot != dot)
3158               {
3159                 if (output_section_statement == abs_output_section)
3160                   {
3161                     /* If we don't have an output section, then just adjust
3162                        the default memory address.  */
3163                     lang_memory_region_lookup ("*default*")->current = newdot;
3164                   }
3165                 else
3166                   {
3167                     /* Insert a pad after this statement.  We can't
3168                        put the pad before when relaxing, in case the
3169                        assignment references dot.  */
3170                     insert_pad (&s->header.next, fill, (newdot - dot) * opb,
3171                                 output_section_statement->bfd_section, dot);
3172
3173                     /* Don't neuter the pad below when relaxing.  */
3174                     s = s->header.next;
3175                   }
3176
3177                 dot = newdot;
3178               }
3179           }
3180           break;
3181
3182         case lang_padding_statement_enum:
3183           /* If this is the first time lang_size_sections is called,
3184              we won't have any padding statements.  If this is the
3185              second or later passes when relaxing, we should allow
3186              padding to shrink.  If padding is needed on this pass, it
3187              will be added back in.  */
3188           s->padding_statement.size = 0;
3189
3190           /* Make sure output_offset is valid.  If relaxation shrinks
3191              the section and this pad isn't needed, it's possible to
3192              have output_offset larger than the final size of the
3193              section.  bfd_set_section_contents will complain even for
3194              a pad size of zero.  */
3195           s->padding_statement.output_offset
3196             = dot - output_section_statement->bfd_section->vma;
3197           break;
3198
3199         case lang_group_statement_enum:
3200           dot = lang_size_sections_1 (s->group_statement.children.head,
3201                                       output_section_statement,
3202                                       &s->group_statement.children.head,
3203                                       fill, dot, relax, check_regions);
3204           break;
3205
3206         default:
3207           FAIL ();
3208           break;
3209
3210           /* We can only get here when relaxing is turned on.  */
3211         case lang_address_statement_enum:
3212           break;
3213         }
3214       prev = &s->header.next;
3215     }
3216   return dot;
3217 }
3218
3219 bfd_vma
3220 lang_size_sections
3221   (lang_statement_union_type *s,
3222    lang_output_section_statement_type *output_section_statement,
3223    lang_statement_union_type **prev,
3224    fill_type *fill,
3225    bfd_vma dot,
3226    bfd_boolean *relax,
3227    bfd_boolean check_regions)
3228 {
3229   bfd_vma result;
3230
3231   /* Callers of exp_fold_tree need to increment this.  */
3232   lang_statement_iteration++;
3233
3234   exp_data_seg.phase = exp_dataseg_none;
3235   result = lang_size_sections_1 (s, output_section_statement, prev, fill,
3236                                  dot, relax, check_regions);
3237   if (exp_data_seg.phase == exp_dataseg_end_seen)
3238     {
3239       /* If DATA_SEGMENT_ALIGN DATA_SEGMENT_END pair was seen, check whether
3240          a page could be saved in the data segment.  */
3241       bfd_vma first, last;
3242
3243       first = -exp_data_seg.base & (exp_data_seg.pagesize - 1);
3244       last = exp_data_seg.end & (exp_data_seg.pagesize - 1);
3245       if (first && last
3246           && ((exp_data_seg.base & ~(exp_data_seg.pagesize - 1))
3247               != (exp_data_seg.end & ~(exp_data_seg.pagesize - 1)))
3248           && first + last <= exp_data_seg.pagesize)
3249         {
3250           exp_data_seg.phase = exp_dataseg_adjust;
3251           result = lang_size_sections_1 (s, output_section_statement, prev,
3252                                          fill, dot, relax, check_regions);
3253         }
3254     }
3255
3256   return result;
3257 }
3258
3259 /* Worker function for lang_do_assignments.  Recursiveness goes here.  */
3260
3261 static bfd_vma
3262 lang_do_assignments_1
3263   (lang_statement_union_type *s,
3264    lang_output_section_statement_type *output_section_statement,
3265    fill_type *fill,
3266    bfd_vma dot)
3267 {
3268   unsigned opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
3269                                                 ldfile_output_machine);
3270
3271   for (; s != NULL; s = s->header.next)
3272     {
3273       switch (s->header.type)
3274         {
3275         case lang_constructors_statement_enum:
3276           dot = lang_do_assignments_1 (constructor_list.head,
3277                                        output_section_statement,
3278                                        fill,
3279                                        dot);
3280           break;
3281
3282         case lang_output_section_statement_enum:
3283           {
3284             lang_output_section_statement_type *os;
3285
3286             os = &(s->output_section_statement);
3287             if (os->bfd_section != NULL)
3288               {
3289                 dot = os->bfd_section->vma;
3290                 (void) lang_do_assignments_1 (os->children.head, os,
3291                                               os->fill, dot);
3292                 dot = os->bfd_section->vma + os->bfd_section->_raw_size / opb;
3293
3294               }
3295             if (os->load_base)
3296               {
3297                 /* If nothing has been placed into the output section then
3298                    it won't have a bfd_section.  */
3299                 if (os->bfd_section)
3300                   {
3301                     os->bfd_section->lma
3302                       = exp_get_abs_int (os->load_base, 0, "load base",
3303                                          lang_final_phase_enum);
3304                   }
3305               }
3306           }
3307           break;
3308         case lang_wild_statement_enum:
3309
3310           dot = lang_do_assignments_1 (s->wild_statement.children.head,
3311                                        output_section_statement,
3312                                        fill, dot);
3313
3314           break;
3315
3316         case lang_object_symbols_statement_enum:
3317         case lang_output_statement_enum:
3318         case lang_target_statement_enum:
3319 #if 0
3320         case lang_common_statement_enum:
3321 #endif
3322           break;
3323         case lang_data_statement_enum:
3324           {
3325             etree_value_type value;
3326
3327             value = exp_fold_tree (s->data_statement.exp,
3328                                    abs_output_section,
3329                                    lang_final_phase_enum, dot, &dot);
3330             s->data_statement.value = value.value;
3331             if (!value.valid_p)
3332               einfo (_("%F%P: invalid data statement\n"));
3333           }
3334           {
3335             unsigned int size;
3336             switch (s->data_statement.type)
3337               {
3338               default:
3339                 abort ();
3340               case QUAD:
3341               case SQUAD:
3342                 size = QUAD_SIZE;
3343                 break;
3344               case LONG:
3345                 size = LONG_SIZE;
3346                 break;
3347               case SHORT:
3348                 size = SHORT_SIZE;
3349                 break;
3350               case BYTE:
3351                 size = BYTE_SIZE;
3352                 break;
3353               }
3354             if (size < opb)
3355               size = opb;
3356             dot += size / opb;
3357           }
3358           break;
3359
3360         case lang_reloc_statement_enum:
3361           {
3362             etree_value_type value;
3363
3364             value = exp_fold_tree (s->reloc_statement.addend_exp,
3365                                    abs_output_section,
3366                                    lang_final_phase_enum, dot, &dot);
3367             s->reloc_statement.addend_value = value.value;
3368             if (!value.valid_p)
3369               einfo (_("%F%P: invalid reloc statement\n"));
3370           }
3371           dot += bfd_get_reloc_size (s->reloc_statement.howto) / opb;
3372           break;
3373
3374         case lang_input_section_enum:
3375           {
3376             asection *in = s->input_section.section;
3377
3378             if (in->_cooked_size != 0)
3379               dot += in->_cooked_size / opb;
3380             else
3381               dot += in->_raw_size / opb;
3382           }
3383           break;
3384
3385         case lang_input_statement_enum:
3386           break;
3387         case lang_fill_statement_enum:
3388           fill = s->fill_statement.fill;
3389           break;
3390         case lang_assignment_statement_enum:
3391           {
3392             exp_fold_tree (s->assignment_statement.exp,
3393                            output_section_statement,
3394                            lang_final_phase_enum,
3395                            dot,
3396                            &dot);
3397           }
3398
3399           break;
3400         case lang_padding_statement_enum:
3401           dot += s->padding_statement.size / opb;
3402           break;
3403
3404         case lang_group_statement_enum:
3405           dot = lang_do_assignments_1 (s->group_statement.children.head,
3406                                        output_section_statement,
3407                                        fill, dot);
3408
3409           break;
3410
3411         default:
3412           FAIL ();
3413           break;
3414         case lang_address_statement_enum:
3415           break;
3416         }
3417
3418     }
3419   return dot;
3420 }
3421
3422 bfd_vma
3423 lang_do_assignments (lang_statement_union_type *s,
3424                      lang_output_section_statement_type
3425                      *output_section_statement,
3426                      fill_type *fill,
3427                      bfd_vma dot)
3428 {
3429   /* Callers of exp_fold_tree need to increment this.  */
3430   lang_statement_iteration++;
3431   lang_do_assignments_1 (s, output_section_statement, fill, dot);
3432 }
3433
3434 /* Fix any .startof. or .sizeof. symbols.  When the assemblers see the
3435    operator .startof. (section_name), it produces an undefined symbol
3436    .startof.section_name.  Similarly, when it sees
3437    .sizeof. (section_name), it produces an undefined symbol
3438    .sizeof.section_name.  For all the output sections, we look for
3439    such symbols, and set them to the correct value.  */
3440
3441 static void
3442 lang_set_startof (void)
3443 {
3444   asection *s;
3445
3446   if (link_info.relocatable)
3447     return;
3448
3449   for (s = output_bfd->sections; s != NULL; s = s->next)
3450     {
3451       const char *secname;
3452       char *buf;
3453       struct bfd_link_hash_entry *h;
3454
3455       secname = bfd_get_section_name (output_bfd, s);
3456       buf = xmalloc (10 + strlen (secname));
3457
3458       sprintf (buf, ".startof.%s", secname);
3459       h = bfd_link_hash_lookup (link_info.hash, buf, FALSE, FALSE, TRUE);
3460       if (h != NULL && h->type == bfd_link_hash_undefined)
3461         {
3462           h->type = bfd_link_hash_defined;
3463           h->u.def.value = bfd_get_section_vma (output_bfd, s);
3464           h->u.def.section = bfd_abs_section_ptr;
3465         }
3466
3467       sprintf (buf, ".sizeof.%s", secname);
3468       h = bfd_link_hash_lookup (link_info.hash, buf, FALSE, FALSE, TRUE);
3469       if (h != NULL && h->type == bfd_link_hash_undefined)
3470         {
3471           unsigned opb;
3472
3473           opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
3474                                                ldfile_output_machine);
3475           h->type = bfd_link_hash_defined;
3476           if (s->_cooked_size != 0)
3477             h->u.def.value = s->_cooked_size / opb;
3478           else
3479             h->u.def.value = s->_raw_size / opb;
3480           h->u.def.section = bfd_abs_section_ptr;
3481         }
3482
3483       free (buf);
3484     }
3485 }
3486
3487 static void
3488 lang_finish (void)
3489 {
3490   struct bfd_link_hash_entry *h;
3491   bfd_boolean warn;
3492
3493   if (link_info.relocatable || link_info.shared)
3494     warn = FALSE;
3495   else
3496     warn = TRUE;
3497
3498   if (entry_symbol.name == NULL)
3499     {
3500       /* No entry has been specified.  Look for start, but don't warn
3501          if we don't find it.  */
3502       entry_symbol.name = "start";
3503       warn = FALSE;
3504     }
3505
3506   h = bfd_link_hash_lookup (link_info.hash, entry_symbol.name,
3507                             FALSE, FALSE, TRUE);
3508   if (h != NULL
3509       && (h->type == bfd_link_hash_defined
3510           || h->type == bfd_link_hash_defweak)
3511       && h->u.def.section->output_section != NULL)
3512     {
3513       bfd_vma val;
3514
3515       val = (h->u.def.value
3516              + bfd_get_section_vma (output_bfd,
3517                                     h->u.def.section->output_section)
3518              + h->u.def.section->output_offset);
3519       if (! bfd_set_start_address (output_bfd, val))
3520         einfo (_("%P%F:%s: can't set start address\n"), entry_symbol.name);
3521     }
3522   else
3523     {
3524       bfd_vma val;
3525       const char *send;
3526
3527       /* We couldn't find the entry symbol.  Try parsing it as a
3528          number.  */
3529       val = bfd_scan_vma (entry_symbol.name, &send, 0);
3530       if (*send == '\0')
3531         {
3532           if (! bfd_set_start_address (output_bfd, val))
3533             einfo (_("%P%F: can't set start address\n"));
3534         }
3535       else
3536         {
3537           asection *ts;
3538
3539           /* Can't find the entry symbol, and it's not a number.  Use
3540              the first address in the text section.  */
3541           ts = bfd_get_section_by_name (output_bfd, entry_section);
3542           if (ts != NULL)
3543             {
3544               if (warn)
3545                 einfo (_("%P: warning: cannot find entry symbol %s; defaulting to %V\n"),
3546                        entry_symbol.name,
3547                        bfd_get_section_vma (output_bfd, ts));
3548               if (! bfd_set_start_address (output_bfd,
3549                                            bfd_get_section_vma (output_bfd,
3550                                                                 ts)))
3551                 einfo (_("%P%F: can't set start address\n"));
3552             }
3553           else
3554             {
3555               if (warn)
3556                 einfo (_("%P: warning: cannot find entry symbol %s; not setting start address\n"),
3557                        entry_symbol.name);
3558             }
3559         }
3560     }
3561
3562   bfd_hash_table_free (&lang_definedness_table);
3563 }
3564
3565 /* This is a small function used when we want to ignore errors from
3566    BFD.  */
3567
3568 static void
3569 ignore_bfd_errors (const char *s ATTRIBUTE_UNUSED, ...)
3570 {
3571   /* Don't do anything.  */
3572 }
3573
3574 /* Check that the architecture of all the input files is compatible
3575    with the output file.  Also call the backend to let it do any
3576    other checking that is needed.  */
3577
3578 static void
3579 lang_check (void)
3580 {
3581   lang_statement_union_type *file;
3582   bfd *input_bfd;
3583   const bfd_arch_info_type *compatible;
3584
3585   for (file = file_chain.head; file != NULL; file = file->input_statement.next)
3586     {
3587       input_bfd = file->input_statement.the_bfd;
3588       compatible = bfd_arch_get_compatible (input_bfd, output_bfd,
3589                                             command_line.accept_unknown_input_arch);
3590
3591       /* In general it is not possible to perform a relocatable
3592          link between differing object formats when the input
3593          file has relocations, because the relocations in the
3594          input format may not have equivalent representations in
3595          the output format (and besides BFD does not translate
3596          relocs for other link purposes than a final link).  */
3597       if ((link_info.relocatable || link_info.emitrelocations)
3598           && (compatible == NULL
3599               || bfd_get_flavour (input_bfd) != bfd_get_flavour (output_bfd))
3600           && (bfd_get_file_flags (input_bfd) & HAS_RELOC) != 0)
3601         {
3602           einfo (_("%P%F: Relocatable linking with relocations from format %s (%B) to format %s (%B) is not supported\n"),
3603                  bfd_get_target (input_bfd), input_bfd,
3604                  bfd_get_target (output_bfd), output_bfd);
3605           /* einfo with %F exits.  */
3606         }
3607
3608       if (compatible == NULL)
3609         {
3610           if (command_line.warn_mismatch)
3611             einfo (_("%P: warning: %s architecture of input file `%B' is incompatible with %s output\n"),
3612                    bfd_printable_name (input_bfd), input_bfd,
3613                    bfd_printable_name (output_bfd));
3614         }
3615       else if (bfd_count_sections (input_bfd))
3616         {
3617           /* If the input bfd has no contents, it shouldn't set the
3618              private data of the output bfd.  */
3619
3620           bfd_error_handler_type pfn = NULL;
3621
3622           /* If we aren't supposed to warn about mismatched input
3623              files, temporarily set the BFD error handler to a
3624              function which will do nothing.  We still want to call
3625              bfd_merge_private_bfd_data, since it may set up
3626              information which is needed in the output file.  */
3627           if (! command_line.warn_mismatch)
3628             pfn = bfd_set_error_handler (ignore_bfd_errors);
3629           if (! bfd_merge_private_bfd_data (input_bfd, output_bfd))
3630             {
3631               if (command_line.warn_mismatch)
3632                 einfo (_("%E%X: failed to merge target specific data of file %B\n"),
3633                        input_bfd);
3634             }
3635           if (! command_line.warn_mismatch)
3636             bfd_set_error_handler (pfn);
3637         }
3638     }
3639 }
3640
3641 /* Look through all the global common symbols and attach them to the
3642    correct section.  The -sort-common command line switch may be used
3643    to roughly sort the entries by size.  */
3644
3645 static void
3646 lang_common (void)
3647 {
3648   if (command_line.inhibit_common_definition)
3649     return;
3650   if (link_info.relocatable
3651       && ! command_line.force_common_definition)
3652     return;
3653
3654   if (! config.sort_common)
3655     bfd_link_hash_traverse (link_info.hash, lang_one_common, NULL);
3656   else
3657     {
3658       int power;
3659
3660       for (power = 4; power >= 0; power--)
3661         bfd_link_hash_traverse (link_info.hash, lang_one_common, &power);
3662     }
3663 }
3664
3665 /* Place one common symbol in the correct section.  */
3666
3667 static bfd_boolean
3668 lang_one_common (struct bfd_link_hash_entry *h, void *info)
3669 {
3670   unsigned int power_of_two;
3671   bfd_vma size;
3672   asection *section;
3673   unsigned opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
3674                                                 ldfile_output_machine);
3675
3676   if (h->type != bfd_link_hash_common)
3677     return TRUE;
3678
3679   size = h->u.c.size;
3680   power_of_two = h->u.c.p->alignment_power;
3681
3682   if (config.sort_common
3683       && power_of_two < (unsigned int) *(int *) info)
3684     return TRUE;
3685
3686   section = h->u.c.p->section;
3687
3688   /* Increase the size of the section.  */
3689   section->_cooked_size = align_n ((section->_cooked_size + opb - 1) / opb,
3690                                    (bfd_vma) 1 << power_of_two) * opb;
3691
3692   /* Adjust the alignment if necessary.  */
3693   if (power_of_two > section->alignment_power)
3694     section->alignment_power = power_of_two;
3695
3696   /* Change the symbol from common to defined.  */
3697   h->type = bfd_link_hash_defined;
3698   h->u.def.section = section;
3699   h->u.def.value = section->_cooked_size;
3700
3701   /* Increase the size of the section.  */
3702   section->_cooked_size += size;
3703
3704   /* Make sure the section is allocated in memory, and make sure that
3705      it is no longer a common section.  */
3706   section->flags |= SEC_ALLOC;
3707   section->flags &= ~SEC_IS_COMMON;
3708
3709   if (config.map_file != NULL)
3710     {
3711       static bfd_boolean header_printed;
3712       int len;
3713       char *name;
3714       char buf[50];
3715
3716       if (! header_printed)
3717         {
3718           minfo (_("\nAllocating common symbols\n"));
3719           minfo (_("Common symbol       size              file\n\n"));
3720           header_printed = TRUE;
3721         }
3722
3723       name = demangle (h->root.string);
3724       minfo ("%s", name);
3725       len = strlen (name);
3726       free (name);
3727
3728       if (len >= 19)
3729         {
3730           print_nl ();
3731           len = 0;
3732         }
3733       while (len < 20)
3734         {
3735           print_space ();
3736           ++len;
3737         }
3738
3739       minfo ("0x");
3740       if (size <= 0xffffffff)
3741         sprintf (buf, "%lx", (unsigned long) size);
3742       else
3743         sprintf_vma (buf, size);
3744       minfo ("%s", buf);
3745       len = strlen (buf);
3746
3747       while (len < 16)
3748         {
3749           print_space ();
3750           ++len;
3751         }
3752
3753       minfo ("%B\n", section->owner);
3754     }
3755
3756   return TRUE;
3757 }
3758
3759 /* Run through the input files and ensure that every input section has
3760    somewhere to go.  If one is found without a destination then create
3761    an input request and place it into the statement tree.  */
3762
3763 static void
3764 lang_place_orphans (void)
3765 {
3766   LANG_FOR_EACH_INPUT_STATEMENT (file)
3767     {
3768       asection *s;
3769
3770       for (s = file->the_bfd->sections; s != NULL; s = s->next)
3771         {
3772           if (s->output_section == NULL)
3773             {
3774               /* This section of the file is not attached, root
3775                  around for a sensible place for it to go.  */
3776
3777               if (file->just_syms_flag)
3778                 {
3779                   abort ();
3780                 }
3781               else if (strcmp (s->name, "COMMON") == 0)
3782                 {
3783                   /* This is a lonely common section which must have
3784                      come from an archive.  We attach to the section
3785                      with the wildcard.  */
3786                   if (! link_info.relocatable
3787                       || command_line.force_common_definition)
3788                     {
3789                       if (default_common_section == NULL)
3790                         {
3791 #if 0
3792                           /* This message happens when using the
3793                              svr3.ifile linker script, so I have
3794                              disabled it.  */
3795                           info_msg (_("%P: no [COMMON] command, defaulting to .bss\n"));
3796 #endif
3797                           default_common_section =
3798                             lang_output_section_statement_lookup (".bss");
3799
3800                         }
3801                       lang_add_section (&default_common_section->children, s,
3802                                         default_common_section, file);
3803                     }
3804                 }
3805               else if (ldemul_place_orphan (file, s))
3806                 ;
3807               else
3808                 {
3809                   lang_output_section_statement_type *os;
3810
3811                   os = lang_output_section_statement_lookup (s->name);
3812                   lang_add_section (&os->children, s, os, file);
3813                 }
3814             }
3815         }
3816     }
3817 }
3818
3819 void
3820 lang_set_flags (lang_memory_region_type *ptr, const char *flags, int invert)
3821 {
3822   flagword *ptr_flags;
3823
3824   ptr_flags = invert ? &ptr->not_flags : &ptr->flags;
3825   while (*flags)
3826     {
3827       switch (*flags)
3828         {
3829         case 'A': case 'a':
3830           *ptr_flags |= SEC_ALLOC;
3831           break;
3832
3833         case 'R': case 'r':
3834           *ptr_flags |= SEC_READONLY;
3835           break;
3836
3837         case 'W': case 'w':
3838           *ptr_flags |= SEC_DATA;
3839           break;
3840
3841         case 'X': case 'x':
3842           *ptr_flags |= SEC_CODE;
3843           break;
3844
3845         case 'L': case 'l':
3846         case 'I': case 'i':
3847           *ptr_flags |= SEC_LOAD;
3848           break;
3849
3850         default:
3851           einfo (_("%P%F: invalid syntax in flags\n"));
3852           break;
3853         }
3854       flags++;
3855     }
3856 }
3857
3858 /* Call a function on each input file.  This function will be called
3859    on an archive, but not on the elements.  */
3860
3861 void
3862 lang_for_each_input_file (void (*func) (lang_input_statement_type *))
3863 {
3864   lang_input_statement_type *f;
3865
3866   for (f = (lang_input_statement_type *) input_file_chain.head;
3867        f != NULL;
3868        f = (lang_input_statement_type *) f->next_real_file)
3869     func (f);
3870 }
3871
3872 /* Call a function on each file.  The function will be called on all
3873    the elements of an archive which are included in the link, but will
3874    not be called on the archive file itself.  */
3875
3876 void
3877 lang_for_each_file (void (*func) (lang_input_statement_type *))
3878 {
3879   LANG_FOR_EACH_INPUT_STATEMENT (f)
3880     {
3881       func (f);
3882     }
3883 }
3884
3885 #if 0
3886
3887 /* Not used.  */
3888
3889 void
3890 lang_for_each_input_section (void (*func) (bfd *ab, asection *as))
3891 {
3892   LANG_FOR_EACH_INPUT_STATEMENT (f)
3893     {
3894       asection *s;
3895
3896       for (s = f->the_bfd->sections; s != NULL; s = s->next)
3897         func (f->the_bfd, s);
3898     }
3899 }
3900
3901 #endif
3902
3903 void
3904 ldlang_add_file (lang_input_statement_type *entry)
3905 {
3906   bfd **pp;
3907
3908   lang_statement_append (&file_chain,
3909                          (lang_statement_union_type *) entry,
3910                          &entry->next);
3911
3912   /* The BFD linker needs to have a list of all input BFDs involved in
3913      a link.  */
3914   ASSERT (entry->the_bfd->link_next == NULL);
3915   ASSERT (entry->the_bfd != output_bfd);
3916   for (pp = &link_info.input_bfds; *pp != NULL; pp = &(*pp)->link_next)
3917     ;
3918   *pp = entry->the_bfd;
3919   entry->the_bfd->usrdata = entry;
3920   bfd_set_gp_size (entry->the_bfd, g_switch_value);
3921
3922   /* Look through the sections and check for any which should not be
3923      included in the link.  We need to do this now, so that we can
3924      notice when the backend linker tries to report multiple
3925      definition errors for symbols which are in sections we aren't
3926      going to link.  FIXME: It might be better to entirely ignore
3927      symbols which are defined in sections which are going to be
3928      discarded.  This would require modifying the backend linker for
3929      each backend which might set the SEC_LINK_ONCE flag.  If we do
3930      this, we should probably handle SEC_EXCLUDE in the same way.  */
3931
3932   bfd_map_over_sections (entry->the_bfd, section_already_linked, entry);
3933 }
3934
3935 void
3936 lang_add_output (const char *name, int from_script)
3937 {
3938   /* Make -o on command line override OUTPUT in script.  */
3939   if (!had_output_filename || !from_script)
3940     {
3941       output_filename = name;
3942       had_output_filename = TRUE;
3943     }
3944 }
3945
3946 static lang_output_section_statement_type *current_section;
3947
3948 static int
3949 topower (int x)
3950 {
3951   unsigned int i = 1;
3952   int l;
3953
3954   if (x < 0)
3955     return -1;
3956
3957   for (l = 0; l < 32; l++)
3958     {
3959       if (i >= (unsigned int) x)
3960         return l;
3961       i <<= 1;
3962     }
3963
3964   return 0;
3965 }
3966
3967 lang_output_section_statement_type *
3968 lang_enter_output_section_statement (const char *output_section_statement_name,
3969                                      etree_type *address_exp,
3970                                      enum section_type sectype,
3971                                      bfd_vma block_value,
3972                                      etree_type *align,
3973                                      etree_type *subalign,
3974                                      etree_type *ebase)
3975 {
3976   lang_output_section_statement_type *os;
3977
3978   current_section =
3979    os =
3980     lang_output_section_statement_lookup (output_section_statement_name);
3981
3982   /* Add this statement to tree.  */
3983 #if 0
3984   add_statement (lang_output_section_statement_enum,
3985                  output_section_statement);
3986 #endif
3987   /* Make next things chain into subchain of this.  */
3988
3989   if (os->addr_tree == NULL)
3990     {
3991       os->addr_tree = address_exp;
3992     }
3993   os->sectype = sectype;
3994   if (sectype != noload_section)
3995     os->flags = SEC_NO_FLAGS;
3996   else
3997     os->flags = SEC_NEVER_LOAD;
3998   os->block_value = block_value ? block_value : 1;
3999   stat_ptr = &os->children;
4000
4001   os->subsection_alignment =
4002     topower (exp_get_value_int (subalign, -1, "subsection alignment", 0));
4003   os->section_alignment =
4004     topower (exp_get_value_int (align, -1, "section alignment", 0));
4005
4006   os->load_base = ebase;
4007   return os;
4008 }
4009
4010 void
4011 lang_final (void)
4012 {
4013   lang_output_statement_type *new =
4014     new_stat (lang_output_statement, stat_ptr);
4015
4016   new->name = output_filename;
4017 }
4018
4019 /* Reset the current counters in the regions.  */
4020
4021 void
4022 lang_reset_memory_regions (void)
4023 {
4024   lang_memory_region_type *p = lang_memory_region_list;
4025   asection *o;
4026
4027   for (p = lang_memory_region_list; p != NULL; p = p->next)
4028     {
4029       p->old_length = (bfd_size_type) (p->current - p->origin);
4030       p->current = p->origin;
4031     }
4032
4033   for (o = output_bfd->sections; o != NULL; o = o->next)
4034     o->_raw_size = 0;
4035 }
4036
4037 /* If the wild pattern was marked KEEP, the member sections
4038    should be as well.  */
4039
4040 static void
4041 gc_section_callback (lang_wild_statement_type *ptr,
4042                      struct wildcard_list *sec ATTRIBUTE_UNUSED,
4043                      asection *section,
4044                      lang_input_statement_type *file ATTRIBUTE_UNUSED,
4045                      void *data ATTRIBUTE_UNUSED)
4046 {
4047   if (ptr->keep_sections)
4048     section->flags |= SEC_KEEP;
4049 }
4050
4051 /* Handle a wild statement, marking it against GC.  */
4052
4053 static void
4054 lang_gc_wild (lang_wild_statement_type *s)
4055 {
4056   walk_wild (s, gc_section_callback, NULL);
4057 }
4058
4059 /* Iterate over sections marking them against GC.  */
4060
4061 static void
4062 lang_gc_sections_1 (lang_statement_union_type *s)
4063 {
4064   for (; s != NULL; s = s->header.next)
4065     {
4066       switch (s->header.type)
4067         {
4068         case lang_wild_statement_enum:
4069           lang_gc_wild (&s->wild_statement);
4070           break;
4071         case lang_constructors_statement_enum:
4072           lang_gc_sections_1 (constructor_list.head);
4073           break;
4074         case lang_output_section_statement_enum:
4075           lang_gc_sections_1 (s->output_section_statement.children.head);
4076           break;
4077         case lang_group_statement_enum:
4078           lang_gc_sections_1 (s->group_statement.children.head);
4079           break;
4080         default:
4081           break;
4082         }
4083     }
4084 }
4085
4086 static void
4087 lang_gc_sections (void)
4088 {
4089   struct bfd_link_hash_entry *h;
4090   ldlang_undef_chain_list_type *ulist;
4091
4092   /* Keep all sections so marked in the link script.  */
4093
4094   lang_gc_sections_1 (statement_list.head);
4095
4096   /* Keep all sections containing symbols undefined on the command-line,
4097      and the section containing the entry symbol.  */
4098
4099   for (ulist = link_info.gc_sym_list; ulist; ulist = ulist->next)
4100     {
4101       h = bfd_link_hash_lookup (link_info.hash, ulist->name,
4102                                 FALSE, FALSE, FALSE);
4103
4104       if (h != NULL
4105           && (h->type == bfd_link_hash_defined
4106               || h->type == bfd_link_hash_defweak)
4107           && ! bfd_is_abs_section (h->u.def.section))
4108         {
4109           h->u.def.section->flags |= SEC_KEEP;
4110         }
4111     }
4112
4113   bfd_gc_sections (output_bfd, &link_info);
4114 }
4115
4116 void
4117 lang_process (void)
4118 {
4119   lang_reasonable_defaults ();
4120   current_target = default_target;
4121
4122   /* Open the output file.  */
4123   lang_for_each_statement (ldlang_open_output);
4124
4125   ldemul_create_output_section_statements ();
4126
4127   /* Add to the hash table all undefineds on the command line.  */
4128   lang_place_undefineds ();
4129
4130   already_linked_table_init ();
4131
4132   /* Create a bfd for each input file.  */
4133   current_target = default_target;
4134   open_input_bfds (statement_list.head, FALSE);
4135
4136   link_info.gc_sym_list = &entry_symbol;
4137   if (entry_symbol.name == NULL)
4138     link_info.gc_sym_list = ldlang_undef_chain_list_head;
4139
4140   ldemul_after_open ();
4141
4142   already_linked_table_free ();
4143
4144   /* Make sure that we're not mixing architectures.  We call this
4145      after all the input files have been opened, but before we do any
4146      other processing, so that any operations merge_private_bfd_data
4147      does on the output file will be known during the rest of the
4148      link.  */
4149   lang_check ();
4150
4151   /* Handle .exports instead of a version script if we're told to do so.  */
4152   if (command_line.version_exports_section)
4153     lang_do_version_exports_section ();
4154
4155   /* Build all sets based on the information gathered from the input
4156      files.  */
4157   ldctor_build_sets ();
4158
4159   /* Remove unreferenced sections if asked to.  */
4160   if (command_line.gc_sections)
4161     lang_gc_sections ();
4162
4163   /* If there were any SEC_MERGE sections, finish their merging, so that
4164      section sizes can be computed.  This has to be done after GC of sections,
4165      so that GCed sections are not merged, but before assigning output
4166      sections, since removing whole input sections is hard then.  */
4167   bfd_merge_sections (output_bfd, &link_info);
4168
4169   /* Size up the common data.  */
4170   lang_common ();
4171
4172   /* Run through the contours of the script and attach input sections
4173      to the correct output sections.  */
4174   map_input_to_output_sections (statement_list.head, NULL, NULL);
4175
4176   /* Find any sections not attached explicitly and handle them.  */
4177   lang_place_orphans ();
4178
4179   if (! link_info.relocatable)
4180     {
4181       /* Look for a text section and set the readonly attribute in it.  */
4182       asection *found = bfd_get_section_by_name (output_bfd, ".text");
4183
4184       if (found != NULL)
4185         {
4186           if (config.text_read_only)
4187             found->flags |= SEC_READONLY;
4188           else
4189             found->flags &= ~SEC_READONLY;
4190         }
4191     }
4192
4193   /* Do anything special before sizing sections.  This is where ELF
4194      and other back-ends size dynamic sections.  */
4195   ldemul_before_allocation ();
4196
4197   if (!link_info.relocatable)
4198     strip_excluded_output_sections ();
4199
4200   /* We must record the program headers before we try to fix the
4201      section positions, since they will affect SIZEOF_HEADERS.  */
4202   lang_record_phdrs ();
4203
4204   /* Size up the sections.  */
4205   lang_size_sections (statement_list.head, abs_output_section,
4206                       &statement_list.head, 0, 0, NULL,
4207                       command_line.relax ? FALSE : TRUE);
4208
4209   /* Now run around and relax if we can.  */
4210   if (command_line.relax)
4211     {
4212       /* Keep relaxing until bfd_relax_section gives up.  */
4213       bfd_boolean relax_again;
4214
4215       do
4216         {
4217           lang_reset_memory_regions ();
4218
4219           relax_again = FALSE;
4220
4221           /* Note: pe-dll.c does something like this also.  If you find
4222              you need to change this code, you probably need to change
4223              pe-dll.c also.  DJ  */
4224
4225           /* Do all the assignments with our current guesses as to
4226              section sizes.  */
4227           lang_do_assignments (statement_list.head, abs_output_section,
4228                                NULL, 0);
4229
4230           /* Perform another relax pass - this time we know where the
4231              globals are, so can make a better guess.  */
4232           lang_size_sections (statement_list.head, abs_output_section,
4233                               &statement_list.head, 0, 0, &relax_again, FALSE);
4234
4235           /* If the normal relax is done and the relax finalize pass
4236              is not performed yet, we perform another relax pass.  */
4237           if (!relax_again && !link_info.relax_finalizing)
4238             {
4239               link_info.relax_finalizing = TRUE;
4240               relax_again = TRUE;
4241             }
4242         }
4243       while (relax_again);
4244
4245       /* Final extra sizing to report errors.  */
4246       lang_reset_memory_regions ();
4247       lang_do_assignments (statement_list.head, abs_output_section, NULL, 0);
4248       lang_size_sections (statement_list.head, abs_output_section,
4249                           &statement_list.head, 0, 0, NULL, TRUE);
4250     }
4251
4252   /* See if anything special should be done now we know how big
4253      everything is.  */
4254   ldemul_after_allocation ();
4255
4256   /* Fix any .startof. or .sizeof. symbols.  */
4257   lang_set_startof ();
4258
4259   /* Do all the assignments, now that we know the final resting places
4260      of all the symbols.  */
4261
4262   lang_do_assignments (statement_list.head, abs_output_section, NULL, 0);
4263
4264   /* Make sure that the section addresses make sense.  */
4265   if (! link_info.relocatable
4266       && command_line.check_section_addresses)
4267     lang_check_section_addresses ();
4268
4269   /* Final stuffs.  */
4270
4271   ldemul_finish ();
4272   lang_finish ();
4273 }
4274
4275 /* EXPORTED TO YACC */
4276
4277 void
4278 lang_add_wild (struct wildcard_spec *filespec,
4279                struct wildcard_list *section_list,
4280                bfd_boolean keep_sections)
4281 {
4282   struct wildcard_list *curr, *next;
4283   lang_wild_statement_type *new;
4284
4285   /* Reverse the list as the parser puts it back to front.  */
4286   for (curr = section_list, section_list = NULL;
4287        curr != NULL;
4288        section_list = curr, curr = next)
4289     {
4290       if (curr->spec.name != NULL && strcmp (curr->spec.name, "COMMON") == 0)
4291         placed_commons = TRUE;
4292
4293       next = curr->next;
4294       curr->next = section_list;
4295     }
4296
4297   if (filespec != NULL && filespec->name != NULL)
4298     {
4299       if (strcmp (filespec->name, "*") == 0)
4300         filespec->name = NULL;
4301       else if (! wildcardp (filespec->name))
4302         lang_has_input_file = TRUE;
4303     }
4304
4305   new = new_stat (lang_wild_statement, stat_ptr);
4306   new->filename = NULL;
4307   new->filenames_sorted = FALSE;
4308   if (filespec != NULL)
4309     {
4310       new->filename = filespec->name;
4311       new->filenames_sorted = filespec->sorted;
4312     }
4313   new->section_list = section_list;
4314   new->keep_sections = keep_sections;
4315   lang_list_init (&new->children);
4316 }
4317
4318 void
4319 lang_section_start (const char *name, etree_type *address)
4320 {
4321   lang_address_statement_type *ad;
4322
4323   ad = new_stat (lang_address_statement, stat_ptr);
4324   ad->section_name = name;
4325   ad->address = address;
4326 }
4327
4328 /* Set the start symbol to NAME.  CMDLINE is nonzero if this is called
4329    because of a -e argument on the command line, or zero if this is
4330    called by ENTRY in a linker script.  Command line arguments take
4331    precedence.  */
4332
4333 void
4334 lang_add_entry (const char *name, bfd_boolean cmdline)
4335 {
4336   if (entry_symbol.name == NULL
4337       || cmdline
4338       || ! entry_from_cmdline)
4339     {
4340       entry_symbol.name = name;
4341       entry_from_cmdline = cmdline;
4342     }
4343 }
4344
4345 void
4346 lang_add_target (const char *name)
4347 {
4348   lang_target_statement_type *new = new_stat (lang_target_statement,
4349                                               stat_ptr);
4350
4351   new->target = name;
4352
4353 }
4354
4355 void
4356 lang_add_map (const char *name)
4357 {
4358   while (*name)
4359     {
4360       switch (*name)
4361         {
4362         case 'F':
4363           map_option_f = TRUE;
4364           break;
4365         }
4366       name++;
4367     }
4368 }
4369
4370 void
4371 lang_add_fill (fill_type *fill)
4372 {
4373   lang_fill_statement_type *new = new_stat (lang_fill_statement,
4374                                             stat_ptr);
4375
4376   new->fill = fill;
4377 }
4378
4379 void
4380 lang_add_data (int type, union etree_union *exp)
4381 {
4382
4383   lang_data_statement_type *new = new_stat (lang_data_statement,
4384                                             stat_ptr);
4385
4386   new->exp = exp;
4387   new->type = type;
4388
4389 }
4390
4391 /* Create a new reloc statement.  RELOC is the BFD relocation type to
4392    generate.  HOWTO is the corresponding howto structure (we could
4393    look this up, but the caller has already done so).  SECTION is the
4394    section to generate a reloc against, or NAME is the name of the
4395    symbol to generate a reloc against.  Exactly one of SECTION and
4396    NAME must be NULL.  ADDEND is an expression for the addend.  */
4397
4398 void
4399 lang_add_reloc (bfd_reloc_code_real_type reloc,
4400                 reloc_howto_type *howto,
4401                 asection *section,
4402                 const char *name,
4403                 union etree_union *addend)
4404 {
4405   lang_reloc_statement_type *p = new_stat (lang_reloc_statement, stat_ptr);
4406
4407   p->reloc = reloc;
4408   p->howto = howto;
4409   p->section = section;
4410   p->name = name;
4411   p->addend_exp = addend;
4412
4413   p->addend_value = 0;
4414   p->output_section = NULL;
4415   p->output_vma = 0;
4416 }
4417
4418 lang_assignment_statement_type *
4419 lang_add_assignment (etree_type *exp)
4420 {
4421   lang_assignment_statement_type *new = new_stat (lang_assignment_statement,
4422                                                   stat_ptr);
4423
4424   new->exp = exp;
4425   return new;
4426 }
4427
4428 void
4429 lang_add_attribute (enum statement_enum attribute)
4430 {
4431   new_statement (attribute, sizeof (lang_statement_union_type), stat_ptr);
4432 }
4433
4434 void
4435 lang_startup (const char *name)
4436 {
4437   if (startup_file != NULL)
4438     {
4439       einfo (_("%P%Fmultiple STARTUP files\n"));
4440     }
4441   first_file->filename = name;
4442   first_file->local_sym_name = name;
4443   first_file->real = TRUE;
4444
4445   startup_file = name;
4446 }
4447
4448 void
4449 lang_float (bfd_boolean maybe)
4450 {
4451   lang_float_flag = maybe;
4452 }
4453
4454
4455 /* Work out the load- and run-time regions from a script statement, and
4456    store them in *LMA_REGION and *REGION respectively.
4457
4458    MEMSPEC is the name of the run-time region, or "*default*" if the
4459    statement didn't specify one.  LMA_MEMSPEC is the name of the
4460    load-time region, or null if the statement didn't specify one.
4461    HAVE_LMA_P is TRUE if the statement had an explicit load address.
4462
4463    It is an error to specify both a load region and a load address.  */
4464
4465 static void
4466 lang_get_regions (struct memory_region_struct **region,
4467                   struct memory_region_struct **lma_region,
4468                   const char *memspec,
4469                   const char *lma_memspec,
4470                   int have_lma_p)
4471 {
4472   *lma_region = lang_memory_region_lookup (lma_memspec);
4473
4474   /* If no runtime region has been given, but the load region has
4475      been, use the load region.  */
4476   if (lma_memspec != 0 && strcmp (memspec, "*default*") == 0)
4477     *region = *lma_region;
4478   else
4479     *region = lang_memory_region_lookup (memspec);
4480
4481   if (have_lma_p && lma_memspec != 0)
4482     einfo (_("%X%P:%S: section has both a load address and a load region\n"));
4483 }
4484
4485 void
4486 lang_leave_output_section_statement
4487   (fill_type *fill, const char *memspec,
4488    struct lang_output_section_phdr_list *phdrs, const char *lma_memspec)
4489 {
4490   lang_get_regions (&current_section->region,
4491                     &current_section->lma_region,
4492                     memspec, lma_memspec,
4493                     current_section->load_base != 0);
4494   current_section->fill = fill;
4495   current_section->phdrs = phdrs;
4496   stat_ptr = &statement_list;
4497 }
4498
4499 /* Create an absolute symbol with the given name with the value of the
4500    address of first byte of the section named.
4501
4502    If the symbol already exists, then do nothing.  */
4503
4504 void
4505 lang_abs_symbol_at_beginning_of (const char *secname, const char *name)
4506 {
4507   struct bfd_link_hash_entry *h;
4508
4509   h = bfd_link_hash_lookup (link_info.hash, name, TRUE, TRUE, TRUE);
4510   if (h == NULL)
4511     einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
4512
4513   if (h->type == bfd_link_hash_new
4514       || h->type == bfd_link_hash_undefined)
4515     {
4516       asection *sec;
4517
4518       h->type = bfd_link_hash_defined;
4519
4520       sec = bfd_get_section_by_name (output_bfd, secname);
4521       if (sec == NULL)
4522         h->u.def.value = 0;
4523       else
4524         h->u.def.value = bfd_get_section_vma (output_bfd, sec);
4525
4526       h->u.def.section = bfd_abs_section_ptr;
4527     }
4528 }
4529
4530 /* Create an absolute symbol with the given name with the value of the
4531    address of the first byte after the end of the section named.
4532
4533    If the symbol already exists, then do nothing.  */
4534
4535 void
4536 lang_abs_symbol_at_end_of (const char *secname, const char *name)
4537 {
4538   struct bfd_link_hash_entry *h;
4539
4540   h = bfd_link_hash_lookup (link_info.hash, name, TRUE, TRUE, TRUE);
4541   if (h == NULL)
4542     einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
4543
4544   if (h->type == bfd_link_hash_new
4545       || h->type == bfd_link_hash_undefined)
4546     {
4547       asection *sec;
4548
4549       h->type = bfd_link_hash_defined;
4550
4551       sec = bfd_get_section_by_name (output_bfd, secname);
4552       if (sec == NULL)
4553         h->u.def.value = 0;
4554       else
4555         h->u.def.value = (bfd_get_section_vma (output_bfd, sec)
4556                           + bfd_section_size (output_bfd, sec) /
4557                           bfd_octets_per_byte (output_bfd));
4558
4559       h->u.def.section = bfd_abs_section_ptr;
4560     }
4561 }
4562
4563 void
4564 lang_statement_append (lang_statement_list_type *list,
4565                        lang_statement_union_type *element,
4566                        lang_statement_union_type **field)
4567 {
4568   *(list->tail) = element;
4569   list->tail = field;
4570 }
4571
4572 /* Set the output format type.  -oformat overrides scripts.  */
4573
4574 void
4575 lang_add_output_format (const char *format,
4576                         const char *big,
4577                         const char *little,
4578                         int from_script)
4579 {
4580   if (output_target == NULL || !from_script)
4581     {
4582       if (command_line.endian == ENDIAN_BIG
4583           && big != NULL)
4584         format = big;
4585       else if (command_line.endian == ENDIAN_LITTLE
4586                && little != NULL)
4587         format = little;
4588
4589       output_target = format;
4590     }
4591 }
4592
4593 /* Enter a group.  This creates a new lang_group_statement, and sets
4594    stat_ptr to build new statements within the group.  */
4595
4596 void
4597 lang_enter_group (void)
4598 {
4599   lang_group_statement_type *g;
4600
4601   g = new_stat (lang_group_statement, stat_ptr);
4602   lang_list_init (&g->children);
4603   stat_ptr = &g->children;
4604 }
4605
4606 /* Leave a group.  This just resets stat_ptr to start writing to the
4607    regular list of statements again.  Note that this will not work if
4608    groups can occur inside anything else which can adjust stat_ptr,
4609    but currently they can't.  */
4610
4611 void
4612 lang_leave_group (void)
4613 {
4614   stat_ptr = &statement_list;
4615 }
4616
4617 /* Add a new program header.  This is called for each entry in a PHDRS
4618    command in a linker script.  */
4619
4620 void
4621 lang_new_phdr (const char *name,
4622                etree_type *type,
4623                bfd_boolean filehdr,
4624                bfd_boolean phdrs,
4625                etree_type *at,
4626                etree_type *flags)
4627 {
4628   struct lang_phdr *n, **pp;
4629
4630   n = stat_alloc (sizeof (struct lang_phdr));
4631   n->next = NULL;
4632   n->name = name;
4633   n->type = exp_get_value_int (type, 0, "program header type",
4634                                lang_final_phase_enum);
4635   n->filehdr = filehdr;
4636   n->phdrs = phdrs;
4637   n->at = at;
4638   n->flags = flags;
4639
4640   for (pp = &lang_phdr_list; *pp != NULL; pp = &(*pp)->next)
4641     ;
4642   *pp = n;
4643 }
4644
4645 /* Record the program header information in the output BFD.  FIXME: We
4646    should not be calling an ELF specific function here.  */
4647
4648 static void
4649 lang_record_phdrs (void)
4650 {
4651   unsigned int alc;
4652   asection **secs;
4653   struct lang_output_section_phdr_list *last;
4654   struct lang_phdr *l;
4655   lang_statement_union_type *u;
4656
4657   alc = 10;
4658   secs = xmalloc (alc * sizeof (asection *));
4659   last = NULL;
4660   for (l = lang_phdr_list; l != NULL; l = l->next)
4661     {
4662       unsigned int c;
4663       flagword flags;
4664       bfd_vma at;
4665
4666       c = 0;
4667       for (u = lang_output_section_statement.head;
4668            u != NULL;
4669            u = u->output_section_statement.next)
4670         {
4671           lang_output_section_statement_type *os;
4672           struct lang_output_section_phdr_list *pl;
4673
4674           os = &u->output_section_statement;
4675
4676           pl = os->phdrs;
4677           if (pl != NULL)
4678             last = pl;
4679           else
4680             {
4681               if (os->sectype == noload_section
4682                   || os->bfd_section == NULL
4683                   || (os->bfd_section->flags & SEC_ALLOC) == 0)
4684                 continue;
4685               pl = last;
4686             }
4687
4688           if (os->bfd_section == NULL)
4689             continue;
4690
4691           for (; pl != NULL; pl = pl->next)
4692             {
4693               if (strcmp (pl->name, l->name) == 0)
4694                 {
4695                   if (c >= alc)
4696                     {
4697                       alc *= 2;
4698                       secs = xrealloc (secs, alc * sizeof (asection *));
4699                     }
4700                   secs[c] = os->bfd_section;
4701                   ++c;
4702                   pl->used = TRUE;
4703                 }
4704             }
4705         }
4706
4707       if (l->flags == NULL)
4708         flags = 0;
4709       else
4710         flags = exp_get_vma (l->flags, 0, "phdr flags",
4711                              lang_final_phase_enum);
4712
4713       if (l->at == NULL)
4714         at = 0;
4715       else
4716         at = exp_get_vma (l->at, 0, "phdr load address",
4717                           lang_final_phase_enum);
4718
4719       if (! bfd_record_phdr (output_bfd, l->type,
4720                              l->flags != NULL, flags, l->at != NULL,
4721                              at, l->filehdr, l->phdrs, c, secs))
4722         einfo (_("%F%P: bfd_record_phdr failed: %E\n"));
4723     }
4724
4725   free (secs);
4726
4727   /* Make sure all the phdr assignments succeeded.  */
4728   for (u = lang_output_section_statement.head;
4729        u != NULL;
4730        u = u->output_section_statement.next)
4731     {
4732       struct lang_output_section_phdr_list *pl;
4733
4734       if (u->output_section_statement.bfd_section == NULL)
4735         continue;
4736
4737       for (pl = u->output_section_statement.phdrs;
4738            pl != NULL;
4739            pl = pl->next)
4740         if (! pl->used && strcmp (pl->name, "NONE") != 0)
4741           einfo (_("%X%P: section `%s' assigned to non-existent phdr `%s'\n"),
4742                  u->output_section_statement.name, pl->name);
4743     }
4744 }
4745
4746 /* Record a list of sections which may not be cross referenced.  */
4747
4748 void
4749 lang_add_nocrossref (struct lang_nocrossref *l)
4750 {
4751   struct lang_nocrossrefs *n;
4752
4753   n = xmalloc (sizeof *n);
4754   n->next = nocrossref_list;
4755   n->list = l;
4756   nocrossref_list = n;
4757
4758   /* Set notice_all so that we get informed about all symbols.  */
4759   link_info.notice_all = TRUE;
4760 }
4761 \f
4762 /* Overlay handling.  We handle overlays with some static variables.  */
4763
4764 /* The overlay virtual address.  */
4765 static etree_type *overlay_vma;
4766 /* And subsection alignment.  */
4767 static etree_type *overlay_subalign;
4768
4769 /* An expression for the maximum section size seen so far.  */
4770 static etree_type *overlay_max;
4771
4772 /* A list of all the sections in this overlay.  */
4773
4774 struct overlay_list {
4775   struct overlay_list *next;
4776   lang_output_section_statement_type *os;
4777 };
4778
4779 static struct overlay_list *overlay_list;
4780
4781 /* Start handling an overlay.  */
4782
4783 void
4784 lang_enter_overlay (etree_type *vma_expr, etree_type *subalign)
4785 {
4786   /* The grammar should prevent nested overlays from occurring.  */
4787   ASSERT (overlay_vma == NULL
4788           && overlay_subalign == NULL
4789           && overlay_max == NULL);
4790
4791   overlay_vma = vma_expr;
4792   overlay_subalign = subalign;
4793 }
4794
4795 /* Start a section in an overlay.  We handle this by calling
4796    lang_enter_output_section_statement with the correct VMA.
4797    lang_leave_overlay sets up the LMA and memory regions.  */
4798
4799 void
4800 lang_enter_overlay_section (const char *name)
4801 {
4802   struct overlay_list *n;
4803   etree_type *size;
4804
4805   lang_enter_output_section_statement (name, overlay_vma, normal_section,
4806                                        0, 0, overlay_subalign, 0);
4807
4808   /* If this is the first section, then base the VMA of future
4809      sections on this one.  This will work correctly even if `.' is
4810      used in the addresses.  */
4811   if (overlay_list == NULL)
4812     overlay_vma = exp_nameop (ADDR, name);
4813
4814   /* Remember the section.  */
4815   n = xmalloc (sizeof *n);
4816   n->os = current_section;
4817   n->next = overlay_list;
4818   overlay_list = n;
4819
4820   size = exp_nameop (SIZEOF, name);
4821
4822   /* Arrange to work out the maximum section end address.  */
4823   if (overlay_max == NULL)
4824     overlay_max = size;
4825   else
4826     overlay_max = exp_binop (MAX_K, overlay_max, size);
4827 }
4828
4829 /* Finish a section in an overlay.  There isn't any special to do
4830    here.  */
4831
4832 void
4833 lang_leave_overlay_section (fill_type *fill,
4834                             struct lang_output_section_phdr_list *phdrs)
4835 {
4836   const char *name;
4837   char *clean, *s2;
4838   const char *s1;
4839   char *buf;
4840
4841   name = current_section->name;
4842
4843   /* For now, assume that "*default*" is the run-time memory region and
4844      that no load-time region has been specified.  It doesn't really
4845      matter what we say here, since lang_leave_overlay will override it.  */
4846   lang_leave_output_section_statement (fill, "*default*", phdrs, 0);
4847
4848   /* Define the magic symbols.  */
4849
4850   clean = xmalloc (strlen (name) + 1);
4851   s2 = clean;
4852   for (s1 = name; *s1 != '\0'; s1++)
4853     if (ISALNUM (*s1) || *s1 == '_')
4854       *s2++ = *s1;
4855   *s2 = '\0';
4856
4857   buf = xmalloc (strlen (clean) + sizeof "__load_start_");
4858   sprintf (buf, "__load_start_%s", clean);
4859   lang_add_assignment (exp_assop ('=', buf,
4860                                   exp_nameop (LOADADDR, name)));
4861
4862   buf = xmalloc (strlen (clean) + sizeof "__load_stop_");
4863   sprintf (buf, "__load_stop_%s", clean);
4864   lang_add_assignment (exp_assop ('=', buf,
4865                                   exp_binop ('+',
4866                                              exp_nameop (LOADADDR, name),
4867                                              exp_nameop (SIZEOF, name))));
4868
4869   free (clean);
4870 }
4871
4872 /* Finish an overlay.  If there are any overlay wide settings, this
4873    looks through all the sections in the overlay and sets them.  */
4874
4875 void
4876 lang_leave_overlay (etree_type *lma_expr,
4877                     int nocrossrefs,
4878                     fill_type *fill,
4879                     const char *memspec,
4880                     struct lang_output_section_phdr_list *phdrs,
4881                     const char *lma_memspec)
4882 {
4883   lang_memory_region_type *region;
4884   lang_memory_region_type *lma_region;
4885   struct overlay_list *l;
4886   struct lang_nocrossref *nocrossref;
4887
4888   lang_get_regions (&region, &lma_region,
4889                     memspec, lma_memspec,
4890                     lma_expr != 0);
4891
4892   nocrossref = NULL;
4893
4894   /* After setting the size of the last section, set '.' to end of the
4895      overlay region.  */
4896   if (overlay_list != NULL)
4897     overlay_list->os->update_dot_tree
4898       = exp_assop ('=', ".", exp_binop ('+', overlay_vma, overlay_max));
4899
4900   l = overlay_list;
4901   while (l != NULL)
4902     {
4903       struct overlay_list *next;
4904
4905       if (fill != NULL && l->os->fill == NULL)
4906         l->os->fill = fill;
4907
4908       l->os->region = region;
4909       l->os->lma_region = lma_region;
4910
4911       /* The first section has the load address specified in the
4912          OVERLAY statement.  The rest are worked out from that.
4913          The base address is not needed (and should be null) if
4914          an LMA region was specified.  */
4915       if (l->next == 0)
4916         l->os->load_base = lma_expr;
4917       else if (lma_region == 0)
4918         l->os->load_base = exp_binop ('+',
4919                                       exp_nameop (LOADADDR, l->next->os->name),
4920                                       exp_nameop (SIZEOF, l->next->os->name));
4921
4922       if (phdrs != NULL && l->os->phdrs == NULL)
4923         l->os->phdrs = phdrs;
4924
4925       if (nocrossrefs)
4926         {
4927           struct lang_nocrossref *nc;
4928
4929           nc = xmalloc (sizeof *nc);
4930           nc->name = l->os->name;
4931           nc->next = nocrossref;
4932           nocrossref = nc;
4933         }
4934
4935       next = l->next;
4936       free (l);
4937       l = next;
4938     }
4939
4940   if (nocrossref != NULL)
4941     lang_add_nocrossref (nocrossref);
4942
4943   overlay_vma = NULL;
4944   overlay_list = NULL;
4945   overlay_max = NULL;
4946 }
4947 \f
4948 /* Version handling.  This is only useful for ELF.  */
4949
4950 /* This global variable holds the version tree that we build.  */
4951
4952 struct bfd_elf_version_tree *lang_elf_version_info;
4953
4954 static int
4955 lang_vers_match_lang_c (struct bfd_elf_version_expr *expr,
4956                         const char *sym)
4957 {
4958   if (expr->pattern[0] == '*' && expr->pattern[1] == '\0')
4959     return 1;
4960   return fnmatch (expr->pattern, sym, 0) == 0;
4961 }
4962
4963 static int
4964 lang_vers_match_lang_cplusplus (struct bfd_elf_version_expr *expr,
4965                                 const char *sym)
4966 {
4967   char *alt_sym;
4968   int result;
4969
4970   if (expr->pattern[0] == '*' && expr->pattern[1] == '\0')
4971     return 1;
4972
4973   alt_sym = cplus_demangle (sym, /* DMGL_NO_TPARAMS */ 0);
4974   if (!alt_sym)
4975     {
4976       /* cplus_demangle (also) returns NULL when it is not a C++ symbol.
4977          Should we early out FALSE in this case?  */
4978       result = fnmatch (expr->pattern, sym, 0) == 0;
4979     }
4980   else
4981     {
4982       result = fnmatch (expr->pattern, alt_sym, 0) == 0;
4983       free (alt_sym);
4984     }
4985
4986   return result;
4987 }
4988
4989 static int
4990 lang_vers_match_lang_java (struct bfd_elf_version_expr *expr,
4991                            const char *sym)
4992 {
4993   char *alt_sym;
4994   int result;
4995
4996   if (expr->pattern[0] == '*' && expr->pattern[1] == '\0')
4997     return 1;
4998
4999   alt_sym = cplus_demangle (sym, DMGL_JAVA);
5000   if (!alt_sym)
5001     {
5002       /* cplus_demangle (also) returns NULL when it is not a Java symbol.
5003          Should we early out FALSE in this case?  */
5004       result = fnmatch (expr->pattern, sym, 0) == 0;
5005     }
5006   else
5007     {
5008       result = fnmatch (expr->pattern, alt_sym, 0) == 0;
5009       free (alt_sym);
5010     }
5011
5012   return result;
5013 }
5014
5015 /* This is called for each variable name or match expression.  */
5016
5017 struct bfd_elf_version_expr *
5018 lang_new_vers_pattern (struct bfd_elf_version_expr *orig,
5019                        const char *new,
5020                        const char *lang)
5021 {
5022   struct bfd_elf_version_expr *ret;
5023
5024   ret = xmalloc (sizeof *ret);
5025   ret->next = orig;
5026   ret->pattern = new;
5027   ret->symver = 0;
5028   ret->script = 0;
5029
5030   if (lang == NULL || strcasecmp (lang, "C") == 0)
5031     ret->match = lang_vers_match_lang_c;
5032   else if (strcasecmp (lang, "C++") == 0)
5033     ret->match = lang_vers_match_lang_cplusplus;
5034   else if (strcasecmp (lang, "Java") == 0)
5035     ret->match = lang_vers_match_lang_java;
5036   else
5037     {
5038       einfo (_("%X%P: unknown language `%s' in version information\n"),
5039              lang);
5040       ret->match = lang_vers_match_lang_c;
5041     }
5042
5043   return ldemul_new_vers_pattern (ret);
5044 }
5045
5046 /* This is called for each set of variable names and match
5047    expressions.  */
5048
5049 struct bfd_elf_version_tree *
5050 lang_new_vers_node (struct bfd_elf_version_expr *globals,
5051                     struct bfd_elf_version_expr *locals)
5052 {
5053   struct bfd_elf_version_tree *ret;
5054
5055   ret = xmalloc (sizeof *ret);
5056   ret->next = NULL;
5057   ret->name = NULL;
5058   ret->vernum = 0;
5059   ret->globals = globals;
5060   ret->locals = locals;
5061   ret->deps = NULL;
5062   ret->name_indx = (unsigned int) -1;
5063   ret->used = 0;
5064   return ret;
5065 }
5066
5067 /* This static variable keeps track of version indices.  */
5068
5069 static int version_index;
5070
5071 /* This is called when we know the name and dependencies of the
5072    version.  */
5073
5074 void
5075 lang_register_vers_node (const char *name,
5076                          struct bfd_elf_version_tree *version,
5077                          struct bfd_elf_version_deps *deps)
5078 {
5079   struct bfd_elf_version_tree *t, **pp;
5080   struct bfd_elf_version_expr *e1;
5081
5082   if (name == NULL)
5083     name = "";
5084
5085   if ((name[0] == '\0' && lang_elf_version_info != NULL)
5086       || (lang_elf_version_info && lang_elf_version_info->name[0] == '\0'))
5087     {
5088       einfo (_("%X%P: anonymous version tag cannot be combined with other version tags\n"));
5089       free (version);
5090       return;
5091     }
5092
5093   /* Make sure this node has a unique name.  */
5094   for (t = lang_elf_version_info; t != NULL; t = t->next)
5095     if (strcmp (t->name, name) == 0)
5096       einfo (_("%X%P: duplicate version tag `%s'\n"), name);
5097
5098   /* Check the global and local match names, and make sure there
5099      aren't any duplicates.  */
5100
5101   for (e1 = version->globals; e1 != NULL; e1 = e1->next)
5102     {
5103       for (t = lang_elf_version_info; t != NULL; t = t->next)
5104         {
5105           struct bfd_elf_version_expr *e2;
5106
5107           for (e2 = t->locals; e2 != NULL; e2 = e2->next)
5108             if (strcmp (e1->pattern, e2->pattern) == 0)
5109               einfo (_("%X%P: duplicate expression `%s' in version information\n"),
5110                      e1->pattern);
5111         }
5112     }
5113
5114   for (e1 = version->locals; e1 != NULL; e1 = e1->next)
5115     {
5116       for (t = lang_elf_version_info; t != NULL; t = t->next)
5117         {
5118           struct bfd_elf_version_expr *e2;
5119
5120           for (e2 = t->globals; e2 != NULL; e2 = e2->next)
5121             if (strcmp (e1->pattern, e2->pattern) == 0)
5122               einfo (_("%X%P: duplicate expression `%s' in version information\n"),
5123                      e1->pattern);
5124         }
5125     }
5126
5127   version->deps = deps;
5128   version->name = name;
5129   if (name[0] != '\0')
5130     {
5131       ++version_index;
5132       version->vernum = version_index;
5133     }
5134   else
5135     version->vernum = 0;
5136
5137   for (pp = &lang_elf_version_info; *pp != NULL; pp = &(*pp)->next)
5138     ;
5139   *pp = version;
5140 }
5141
5142 /* This is called when we see a version dependency.  */
5143
5144 struct bfd_elf_version_deps *
5145 lang_add_vers_depend (struct bfd_elf_version_deps *list, const char *name)
5146 {
5147   struct bfd_elf_version_deps *ret;
5148   struct bfd_elf_version_tree *t;
5149
5150   ret = xmalloc (sizeof *ret);
5151   ret->next = list;
5152
5153   for (t = lang_elf_version_info; t != NULL; t = t->next)
5154     {
5155       if (strcmp (t->name, name) == 0)
5156         {
5157           ret->version_needed = t;
5158           return ret;
5159         }
5160     }
5161
5162   einfo (_("%X%P: unable to find version dependency `%s'\n"), name);
5163
5164   return ret;
5165 }
5166
5167 static void
5168 lang_do_version_exports_section (void)
5169 {
5170   struct bfd_elf_version_expr *greg = NULL, *lreg;
5171
5172   LANG_FOR_EACH_INPUT_STATEMENT (is)
5173     {
5174       asection *sec = bfd_get_section_by_name (is->the_bfd, ".exports");
5175       char *contents, *p;
5176       bfd_size_type len;
5177
5178       if (sec == NULL)
5179         continue;
5180
5181       len = bfd_section_size (is->the_bfd, sec);
5182       contents = xmalloc (len);
5183       if (!bfd_get_section_contents (is->the_bfd, sec, contents, 0, len))
5184         einfo (_("%X%P: unable to read .exports section contents\n"), sec);
5185
5186       p = contents;
5187       while (p < contents + len)
5188         {
5189           greg = lang_new_vers_pattern (greg, p, NULL);
5190           p = strchr (p, '\0') + 1;
5191         }
5192
5193       /* Do not free the contents, as we used them creating the regex.  */
5194
5195       /* Do not include this section in the link.  */
5196       bfd_set_section_flags (is->the_bfd, sec,
5197         bfd_get_section_flags (is->the_bfd, sec) | SEC_EXCLUDE);
5198     }
5199
5200   lreg = lang_new_vers_pattern (NULL, "*", NULL);
5201   lang_register_vers_node (command_line.version_exports_section,
5202                            lang_new_vers_node (greg, lreg), NULL);
5203 }
5204
5205 void
5206 lang_add_unique (const char *name)
5207 {
5208   struct unique_sections *ent;
5209
5210   for (ent = unique_section_list; ent; ent = ent->next)
5211     if (strcmp (ent->name, name) == 0)
5212       return;
5213
5214   ent = xmalloc (sizeof *ent);
5215   ent->name = xstrdup (name);
5216   ent->next = unique_section_list;
5217   unique_section_list = ent;
5218 }