ld/ldlang.c

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