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 = 0;
 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_assert:
 779       exp_init_os (exp->assert_s.child);
 780       break;
 781
 782     case etree_unary:
 783       exp_init_os (exp->unary.child);
 784       break;
 785
 786     case etree_name:
 787       switch (exp->type.node_code)
 788         {
 789         case ADDR:
 790         case LOADADDR:
 791         case SIZEOF:
 792           {
 793             lang_output_section_statement_type *os;
 794
 795             os = lang_output_section_find (exp->name.name);
 796             if (os != NULL && os->bfd_section == NULL)
 797               init_os (os);
 798           }
 799         }
 800       break;
 801
 802     default:
 803       break;
 804     }
 805 }
 806 \f
 807 /* Sections marked with the SEC_LINK_ONCE flag should only be linked
 808    once into the output.  This routine checks each section, and
 809    arrange to discard it if a section of the same name has already
 810    been linked.  If the section has COMDAT information, then it uses
 811    that to decide whether the section should be included.  This code
 812    assumes that all relevant sections have the SEC_LINK_ONCE flag set;
 813    that is, it does not depend solely upon the section name.
 814    section_already_linked is called via bfd_map_over_sections.  */
 815
 816 /* This is the shape of the elements inside the already_linked hash
 817    table. It maps a name onto a list of already_linked elements with
 818    the same name.  It's possible to get more than one element in a
 819    list if the COMDAT sections have different names.  */
 820
 821 struct already_linked_hash_entry
 822 {
 823   struct bfd_hash_entry root;
 824   struct already_linked *entry;
 825 };
 826
 827 struct already_linked
 828 {
 829   struct already_linked *next;
 830   asection *sec;
 831 };
 832
 833 /* The hash table.  */
 834
 835 static struct bfd_hash_table already_linked_table;
 836
 837 static void
 838 section_already_linked (bfd *abfd, asection *sec, void *data)
 839 {
 840   lang_input_statement_type *entry = data;
 841   flagword flags;
 842   const char *name;
 843   struct already_linked *l;
 844   struct already_linked_hash_entry *already_linked_list;
 845
 846   /* If we are only reading symbols from this object, then we want to
 847      discard all sections.  */
 848   if (entry->just_syms_flag)
 849     {
 850       bfd_link_just_syms (sec, &link_info);
 851       return;
 852     }
 853
 854   flags = bfd_get_section_flags (abfd, sec);
 855
 856   if ((flags & SEC_LINK_ONCE) == 0)
 857     return;
 858
 859   /* FIXME: When doing a relocatable link, we may have trouble
 860      copying relocations in other sections that refer to local symbols
 861      in the section being discarded.  Those relocations will have to
 862      be converted somehow; as of this writing I'm not sure that any of
 863      the backends handle that correctly.
 864
 865      It is tempting to instead not discard link once sections when
 866      doing a relocatable link (technically, they should be discarded
 867      whenever we are building constructors).  However, that fails,
 868      because the linker winds up combining all the link once sections
 869      into a single large link once section, which defeats the purpose
 870      of having link once sections in the first place.
 871
 872      Also, not merging link once sections in a relocatable link
 873      causes trouble for MIPS ELF, which relies on link once semantics
 874      to handle the .reginfo section correctly.  */
 875
 876   name = bfd_get_section_name (abfd, sec);
 877
 878   already_linked_list =
 879     ((struct already_linked_hash_entry *)
 880      bfd_hash_lookup (&already_linked_table, name, TRUE, FALSE));
 881
 882   for (l = already_linked_list->entry; l != NULL; l = l->next)
 883     {
 884       if (sec->comdat == NULL
 885           || l->sec->comdat == NULL
 886           || strcmp (sec->comdat->name, l->sec->comdat->name) == 0)
 887         {
 888           /* The section has already been linked.  See if we should
 889              issue a warning.  */
 890           switch (flags & SEC_LINK_DUPLICATES)
 891             {
 892             default:
 893               abort ();
 894
 895             case SEC_LINK_DUPLICATES_DISCARD:
 896               break;
 897
 898             case SEC_LINK_DUPLICATES_ONE_ONLY:
 899               if (sec->comdat == NULL)
 900                 einfo (_("%P: %B: warning: ignoring duplicate section `%s'\n"),
 901                        abfd, name);
 902               else
 903                 einfo (_("%P: %B: warning: ignoring duplicate `%s' section symbol `%s'\n"),
 904                        abfd, name, sec->comdat->name);
 905               break;
 906
 907             case SEC_LINK_DUPLICATES_SAME_CONTENTS:
 908               /* FIXME: We should really dig out the contents of both
 909                  sections and memcmp them.  The COFF/PE spec says that
 910                  the Microsoft linker does not implement this
 911                  correctly, so I'm not going to bother doing it
 912                  either.  */
 913               /* Fall through.  */
 914             case SEC_LINK_DUPLICATES_SAME_SIZE:
 915               if (bfd_section_size (abfd, sec)
 916                   != bfd_section_size (l->sec->owner, l->sec))
 917                 einfo (_("%P: %B: warning: duplicate section `%s' has different size\n"),
 918                        abfd, name);
 919               break;
 920             }
 921
 922           /* Set the output_section field so that lang_add_section
 923              does not create a lang_input_section structure for this
 924              section.  Since there might be a symbol in the section
 925              being discarded, we must retain a pointer to the section
 926              which we are really going to use.  */
 927           sec->output_section = bfd_abs_section_ptr;
 928           sec->kept_section = l->sec;
 929
 930           if (flags & SEC_GROUP)
 931             bfd_discard_group (abfd, sec);
 932
 933           return;
 934         }
 935     }
 936
 937   /* This is the first section with this name.  Record it.  Allocate
 938      the memory from the same obstack as the hash table is kept in.  */
 939
 940   l = bfd_hash_allocate (&already_linked_table, sizeof *l);
 941
 942   l->sec = sec;
 943   l->next = already_linked_list->entry;
 944   already_linked_list->entry = l;
 945 }
 946
 947 /* Support routines for the hash table used by section_already_linked,
 948    initialize the table, fill in an entry and remove the table.  */
 949
 950 static struct bfd_hash_entry *
 951 already_linked_newfunc (struct bfd_hash_entry *entry ATTRIBUTE_UNUSED,
 952                         struct bfd_hash_table *table,
 953                         const char *string ATTRIBUTE_UNUSED)
 954 {
 955   struct already_linked_hash_entry *ret =
 956     bfd_hash_allocate (table, sizeof (struct already_linked_hash_entry));
 957
 958   ret->entry = NULL;
 959
 960   return &ret->root;
 961 }
 962
 963 static void
 964 already_linked_table_init (void)
 965 {
 966   if (! bfd_hash_table_init_n (&already_linked_table,
 967                                already_linked_newfunc,
 968                                42))
 969     einfo (_("%P%F: Failed to create hash table\n"));
 970 }
 971
 972 static void
 973 already_linked_table_free (void)
 974 {
 975   bfd_hash_table_free (&already_linked_table);
 976 }
 977 \f
 978 /* The wild routines.
 979
 980    These expand statements like *(.text) and foo.o to a list of
 981    explicit actions, like foo.o(.text), bar.o(.text) and
 982    foo.o(.text, .data).  */
 983
 984 /* Return TRUE if the PATTERN argument is a wildcard pattern.
 985    Although backslashes are treated specially if a pattern contains
 986    wildcards, we do not consider the mere presence of a backslash to
 987    be enough to cause the pattern to be treated as a wildcard.
 988    That lets us handle DOS filenames more naturally.  */
 989
 990 static bfd_boolean
 991 wildcardp (const char *pattern)
 992 {
 993   const char *s;
 994
 995   for (s = pattern; *s != '\0'; ++s)
 996     if (*s == '?'
 997         || *s == '*'
 998         || *s == '[')
 999       return TRUE;
1000   return FALSE;
1001 }
1002
1003 /* Add SECTION to the output section OUTPUT.  Do this by creating a
1004    lang_input_section statement which is placed at PTR.  FILE is the
1005    input file which holds SECTION.  */
1006
1007 void
1008 lang_add_section (lang_statement_list_type *ptr,
1009                   asection *section,
1010                   lang_output_section_statement_type *output,
1011                   lang_input_statement_type *file)
1012 {
1013   flagword flags;
1014   bfd_boolean discard;
1015
1016   flags = bfd_get_section_flags (section->owner, section);
1017
1018   discard = FALSE;
1019
1020   /* Discard sections marked with SEC_EXCLUDE if we are doing a final
1021      link.  Discard debugging sections marked with SEC_EXCLUDE on a
1022      relocatable link too.  */
1023   if ((flags & SEC_EXCLUDE) != 0
1024       && ((flags & SEC_DEBUGGING) != 0 || !link_info.relocatable))
1025     discard = TRUE;
1026
1027   /* Discard input sections which are assigned to a section named
1028      DISCARD_SECTION_NAME.  */
1029   if (strcmp (output->name, DISCARD_SECTION_NAME) == 0)
1030     discard = TRUE;
1031
1032   /* Discard debugging sections if we are stripping debugging
1033      information.  */
1034   if ((link_info.strip == strip_debugger || link_info.strip == strip_all)
1035       && (flags & SEC_DEBUGGING) != 0)
1036     discard = TRUE;
1037
1038   if (discard)
1039     {
1040       if (section->output_section == NULL)
1041         {
1042           /* This prevents future calls from assigning this section.  */
1043           section->output_section = bfd_abs_section_ptr;
1044         }
1045       return;
1046     }
1047
1048   if (section->output_section == NULL)
1049     {
1050       bfd_boolean first;
1051       lang_input_section_type *new;
1052       flagword flags;
1053
1054       if (output->bfd_section == NULL)
1055         init_os (output);
1056
1057       first = ! output->bfd_section->linker_has_input;
1058       output->bfd_section->linker_has_input = 1;
1059
1060       /* Add a section reference to the list.  */
1061       new = new_stat (lang_input_section, ptr);
1062
1063       new->section = section;
1064       new->ifile = file;
1065       section->output_section = output->bfd_section;
1066
1067       flags = section->flags;
1068
1069       /* We don't copy the SEC_NEVER_LOAD flag from an input section
1070          to an output section, because we want to be able to include a
1071          SEC_NEVER_LOAD section in the middle of an otherwise loaded
1072          section (I don't know why we want to do this, but we do).
1073          build_link_order in ldwrite.c handles this case by turning
1074          the embedded SEC_NEVER_LOAD section into a fill.  */
1075
1076       flags &= ~ SEC_NEVER_LOAD;
1077
1078       /* If final link, don't copy the SEC_LINK_ONCE flags, they've
1079          already been processed.  One reason to do this is that on pe
1080          format targets, .text$foo sections go into .text and it's odd
1081          to see .text with SEC_LINK_ONCE set.  */
1082
1083       if (! link_info.relocatable)
1084         flags &= ~ (SEC_LINK_ONCE | SEC_LINK_DUPLICATES);
1085
1086       /* If this is not the first input section, and the SEC_READONLY
1087          flag is not currently set, then don't set it just because the
1088          input section has it set.  */
1089
1090       if (! first && (section->output_section->flags & SEC_READONLY) == 0)
1091         flags &= ~ SEC_READONLY;
1092
1093       /* Keep SEC_MERGE and SEC_STRINGS only if they are the same.  */
1094       if (! first
1095           && ((section->output_section->flags & (SEC_MERGE | SEC_STRINGS))
1096               != (flags & (SEC_MERGE | SEC_STRINGS))
1097               || ((flags & SEC_MERGE)
1098                   && section->output_section->entsize != section->entsize)))
1099         {
1100           section->output_section->flags &= ~ (SEC_MERGE | SEC_STRINGS);
1101           flags &= ~ (SEC_MERGE | SEC_STRINGS);
1102         }
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_data_statement_enum:
2098           /* Make sure that any sections mentioned in the expression
2099              are initialized.  */
2100           exp_init_os (s->data_statement.exp);
2101           /* FALLTHROUGH */
2102         case lang_fill_statement_enum:
2103         case lang_input_section_enum:
2104         case lang_object_symbols_statement_enum:
2105         case lang_reloc_statement_enum:
2106         case lang_padding_statement_enum:
2107         case lang_input_statement_enum:
2108           if (output_section_statement != NULL
2109               && output_section_statement->bfd_section == NULL)
2110             init_os (output_section_statement);
2111           break;
2112         case lang_assignment_statement_enum:
2113           if (output_section_statement != NULL
2114               && output_section_statement->bfd_section == NULL)
2115             init_os (output_section_statement);
2116
2117           /* Make sure that any sections mentioned in the assignment
2118              are initialized.  */
2119           exp_init_os (s->assignment_statement.exp);
2120           break;
2121         case lang_afile_asection_pair_statement_enum:
2122           FAIL ();
2123           break;
2124         case lang_address_statement_enum:
2125           /* Mark the specified section with the supplied address.  */
2126           {
2127             lang_output_section_statement_type *os =
2128               lang_output_section_statement_lookup
2129                 (s->address_statement.section_name);
2130
2131             if (os->bfd_section == NULL)
2132               init_os (os);
2133             os->addr_tree = s->address_statement.address;
2134           }
2135           break;
2136         }
2137     }
2138 }
2139
2140 /* An output section might have been removed after its statement was
2141    added.  For example, ldemul_before_allocation can remove dynamic
2142    sections if they turn out to be not needed.  Clean them up here.  */
2143
2144 static void
2145 strip_excluded_output_sections (void)
2146 {
2147   lang_statement_union_type *u;
2148
2149   for (u = lang_output_section_statement.head;
2150        u != NULL;
2151        u = u->output_section_statement.next)
2152     {
2153       lang_output_section_statement_type *os;
2154       asection *s;
2155
2156       os = &u->output_section_statement;
2157       s = os->bfd_section;
2158       if (s != NULL && (s->flags & SEC_EXCLUDE) != 0)
2159         {
2160           asection **p;
2161
2162           os->bfd_section = NULL;
2163
2164           for (p = &output_bfd->sections; *p; p = &(*p)->next)
2165             if (*p == s)
2166               {
2167                 bfd_section_list_remove (output_bfd, p);
2168                 output_bfd->section_count--;
2169                 break;
2170               }
2171         }
2172     }
2173 }
2174
2175 static void
2176 print_output_section_statement
2177   (lang_output_section_statement_type *output_section_statement)
2178 {
2179   asection *section = output_section_statement->bfd_section;
2180   int len;
2181
2182   if (output_section_statement != abs_output_section)
2183     {
2184       minfo ("\n%s", output_section_statement->name);
2185
2186       if (section != NULL)
2187         {
2188           print_dot = section->vma;
2189
2190           len = strlen (output_section_statement->name);
2191           if (len >= SECTION_NAME_MAP_LENGTH - 1)
2192             {
2193               print_nl ();
2194               len = 0;
2195             }
2196           while (len < SECTION_NAME_MAP_LENGTH)
2197             {
2198               print_space ();
2199               ++len;
2200             }
2201
2202           minfo ("0x%V %W", section->vma, section->_raw_size);
2203
2204           if (output_section_statement->load_base != NULL)
2205             {
2206               bfd_vma addr;
2207
2208               addr = exp_get_abs_int (output_section_statement->load_base, 0,
2209                                       "load base", lang_final_phase_enum);
2210               minfo (_(" load address 0x%V"), addr);
2211             }
2212         }
2213
2214       print_nl ();
2215     }
2216
2217   print_statement_list (output_section_statement->children.head,
2218                         output_section_statement);
2219 }
2220
2221 static void
2222 print_assignment (lang_assignment_statement_type *assignment,
2223                   lang_output_section_statement_type *output_section)
2224 {
2225   int i;
2226   etree_value_type result;
2227
2228   for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
2229     print_space ();
2230
2231   result = exp_fold_tree (assignment->exp->assign.src, output_section,
2232                           lang_final_phase_enum, print_dot, &print_dot);
2233   if (result.valid_p)
2234     {
2235       const char *dst;
2236       bfd_vma value;
2237
2238       value = result.value + result.section->bfd_section->vma;
2239       dst = assignment->exp->assign.dst;
2240
2241       minfo ("0x%V", value);
2242       if (dst[0] == '.' && dst[1] == 0)
2243         print_dot = value;
2244     }
2245   else
2246     {
2247       minfo ("*undef*   ");
2248 #ifdef BFD64
2249       minfo ("        ");
2250 #endif
2251     }
2252
2253   minfo ("                ");
2254
2255   exp_print_tree (assignment->exp);
2256
2257   print_nl ();
2258 }
2259
2260 static void
2261 print_input_statement (lang_input_statement_type *statm)
2262 {
2263   if (statm->filename != NULL)
2264     {
2265       fprintf (config.map_file, "LOAD %s\n", statm->filename);
2266     }
2267 }
2268
2269 /* Print all symbols defined in a particular section.  This is called
2270    via bfd_link_hash_traverse.  */
2271
2272 static bfd_boolean
2273 print_one_symbol (struct bfd_link_hash_entry *hash_entry, void *ptr)
2274 {
2275   asection *sec = ptr;
2276
2277   if ((hash_entry->type == bfd_link_hash_defined
2278        || hash_entry->type == bfd_link_hash_defweak)
2279       && sec == hash_entry->u.def.section)
2280     {
2281       int i;
2282
2283       for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
2284         print_space ();
2285       minfo ("0x%V   ",
2286              (hash_entry->u.def.value
2287               + hash_entry->u.def.section->output_offset
2288               + hash_entry->u.def.section->output_section->vma));
2289
2290       minfo ("             %T\n", hash_entry->root.string);
2291     }
2292
2293   return TRUE;
2294 }
2295
2296 /* Print information about an input section to the map file.  */
2297
2298 static void
2299 print_input_section (lang_input_section_type *in)
2300 {
2301   asection *i = in->section;
2302   bfd_size_type size = i->_cooked_size != 0 ? i->_cooked_size : i->_raw_size;
2303
2304   init_opb ();
2305   if (size != 0)
2306     {
2307       print_space ();
2308
2309       minfo ("%s", i->name);
2310
2311       if (i->output_section != NULL)
2312         {
2313           int len;
2314
2315           len = 1 + strlen (i->name);
2316           if (len >= SECTION_NAME_MAP_LENGTH - 1)
2317             {
2318               print_nl ();
2319               len = 0;
2320             }
2321           while (len < SECTION_NAME_MAP_LENGTH)
2322             {
2323               print_space ();
2324               ++len;
2325             }
2326
2327           minfo ("0x%V %W %B\n",
2328                  i->output_section->vma + i->output_offset, TO_ADDR (size),
2329                  i->owner);
2330
2331           if (i->_cooked_size != 0 && i->_cooked_size != i->_raw_size)
2332             {
2333               len = SECTION_NAME_MAP_LENGTH + 3;
2334 #ifdef BFD64
2335               len += 16;
2336 #else
2337               len += 8;
2338 #endif
2339               while (len > 0)
2340                 {
2341                   print_space ();
2342                   --len;
2343                 }
2344
2345               minfo (_("%W (size before relaxing)\n"), i->_raw_size);
2346             }
2347
2348           bfd_link_hash_traverse (link_info.hash, print_one_symbol, i);
2349
2350           print_dot = (i->output_section->vma + i->output_offset
2351                        + TO_ADDR (size));
2352         }
2353     }
2354 }
2355
2356 static void
2357 print_fill_statement (lang_fill_statement_type *fill)
2358 {
2359   size_t size;
2360   unsigned char *p;
2361   fputs (" FILL mask 0x", config.map_file);
2362   for (p = fill->fill->data, size = fill->fill->size; size != 0; p++, size--)
2363     fprintf (config.map_file, "%02x", *p);
2364   fputs ("\n", config.map_file);
2365 }
2366
2367 static void
2368 print_data_statement (lang_data_statement_type *data)
2369 {
2370   int i;
2371   bfd_vma addr;
2372   bfd_size_type size;
2373   const char *name;
2374
2375   init_opb ();
2376   for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
2377     print_space ();
2378
2379   addr = data->output_vma;
2380   if (data->output_section != NULL)
2381     addr += data->output_section->vma;
2382
2383   switch (data->type)
2384     {
2385     default:
2386       abort ();
2387     case BYTE:
2388       size = BYTE_SIZE;
2389       name = "BYTE";
2390       break;
2391     case SHORT:
2392       size = SHORT_SIZE;
2393       name = "SHORT";
2394       break;
2395     case LONG:
2396       size = LONG_SIZE;
2397       name = "LONG";
2398       break;
2399     case QUAD:
2400       size = QUAD_SIZE;
2401       name = "QUAD";
2402       break;
2403     case SQUAD:
2404       size = QUAD_SIZE;
2405       name = "SQUAD";
2406       break;
2407     }
2408
2409   minfo ("0x%V %W %s 0x%v", addr, size, name, data->value);
2410
2411   if (data->exp->type.node_class != etree_value)
2412     {
2413       print_space ();
2414       exp_print_tree (data->exp);
2415     }
2416
2417   print_nl ();
2418
2419   print_dot = addr + TO_ADDR (size);
2420 }
2421
2422 /* Print an address statement.  These are generated by options like
2423    -Ttext.  */
2424
2425 static void
2426 print_address_statement (lang_address_statement_type *address)
2427 {
2428   minfo (_("Address of section %s set to "), address->section_name);
2429   exp_print_tree (address->address);
2430   print_nl ();
2431 }
2432
2433 /* Print a reloc statement.  */
2434
2435 static void
2436 print_reloc_statement (lang_reloc_statement_type *reloc)
2437 {
2438   int i;
2439   bfd_vma addr;
2440   bfd_size_type size;
2441
2442   init_opb ();
2443   for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
2444     print_space ();
2445
2446   addr = reloc->output_vma;
2447   if (reloc->output_section != NULL)
2448     addr += reloc->output_section->vma;
2449
2450   size = bfd_get_reloc_size (reloc->howto);
2451
2452   minfo ("0x%V %W RELOC %s ", addr, size, reloc->howto->name);
2453
2454   if (reloc->name != NULL)
2455     minfo ("%s+", reloc->name);
2456   else
2457     minfo ("%s+", reloc->section->name);
2458
2459   exp_print_tree (reloc->addend_exp);
2460
2461   print_nl ();
2462
2463   print_dot = addr + TO_ADDR (size);
2464 }
2465
2466 static void
2467 print_padding_statement (lang_padding_statement_type *s)
2468 {
2469   int len;
2470   bfd_vma addr;
2471
2472   init_opb ();
2473   minfo (" *fill*");
2474
2475   len = sizeof " *fill*" - 1;
2476   while (len < SECTION_NAME_MAP_LENGTH)
2477     {
2478       print_space ();
2479       ++len;
2480     }
2481
2482   addr = s->output_offset;
2483   if (s->output_section != NULL)
2484     addr += s->output_section->vma;
2485   minfo ("0x%V %W ", addr, s->size);
2486
2487   if (s->fill->size != 0)
2488     {
2489       size_t size;
2490       unsigned char *p;
2491       for (p = s->fill->data, size = s->fill->size; size != 0; p++, size--)
2492         fprintf (config.map_file, "%02x", *p);
2493     }
2494
2495   print_nl ();
2496
2497   print_dot = addr + TO_ADDR (s->size);
2498 }
2499
2500 static void
2501 print_wild_statement (lang_wild_statement_type *w,
2502                       lang_output_section_statement_type *os)
2503 {
2504   struct wildcard_list *sec;
2505
2506   print_space ();
2507
2508   if (w->filenames_sorted)
2509     minfo ("SORT(");
2510   if (w->filename != NULL)
2511     minfo ("%s", w->filename);
2512   else
2513     minfo ("*");
2514   if (w->filenames_sorted)
2515     minfo (")");
2516
2517   minfo ("(");
2518   for (sec = w->section_list; sec; sec = sec->next)
2519     {
2520       if (sec->spec.sorted)
2521         minfo ("SORT(");
2522       if (sec->spec.exclude_name_list != NULL)
2523         {
2524           name_list *tmp;
2525           minfo ("EXCLUDE_FILE(%s", sec->spec.exclude_name_list->name);
2526           for (tmp = sec->spec.exclude_name_list->next; tmp; tmp = tmp->next)
2527             minfo (" %s", tmp->name);
2528           minfo (") ");
2529         }
2530       if (sec->spec.name != NULL)
2531         minfo ("%s", sec->spec.name);
2532       else
2533         minfo ("*");
2534       if (sec->spec.sorted)
2535         minfo (")");
2536       if (sec->next)
2537         minfo (" ");
2538     }
2539   minfo (")");
2540
2541   print_nl ();
2542
2543   print_statement_list (w->children.head, os);
2544 }
2545
2546 /* Print a group statement.  */
2547
2548 static void
2549 print_group (lang_group_statement_type *s,
2550              lang_output_section_statement_type *os)
2551 {
2552   fprintf (config.map_file, "START GROUP\n");
2553   print_statement_list (s->children.head, os);
2554   fprintf (config.map_file, "END GROUP\n");
2555 }
2556
2557 /* Print the list of statements in S.
2558    This can be called for any statement type.  */
2559
2560 static void
2561 print_statement_list (lang_statement_union_type *s,
2562                       lang_output_section_statement_type *os)
2563 {
2564   while (s != NULL)
2565     {
2566       print_statement (s, os);
2567       s = s->header.next;
2568     }
2569 }
2570
2571 /* Print the first statement in statement list S.
2572    This can be called for any statement type.  */
2573
2574 static void
2575 print_statement (lang_statement_union_type *s,
2576                  lang_output_section_statement_type *os)
2577 {
2578   switch (s->header.type)
2579     {
2580     default:
2581       fprintf (config.map_file, _("Fail with %d\n"), s->header.type);
2582       FAIL ();
2583       break;
2584     case lang_constructors_statement_enum:
2585       if (constructor_list.head != NULL)
2586         {
2587           if (constructors_sorted)
2588             minfo (" SORT (CONSTRUCTORS)\n");
2589           else
2590             minfo (" CONSTRUCTORS\n");
2591           print_statement_list (constructor_list.head, os);
2592         }
2593       break;
2594     case lang_wild_statement_enum:
2595       print_wild_statement (&s->wild_statement, os);
2596       break;
2597     case lang_address_statement_enum:
2598       print_address_statement (&s->address_statement);
2599       break;
2600     case lang_object_symbols_statement_enum:
2601       minfo (" CREATE_OBJECT_SYMBOLS\n");
2602       break;
2603     case lang_fill_statement_enum:
2604       print_fill_statement (&s->fill_statement);
2605       break;
2606     case lang_data_statement_enum:
2607       print_data_statement (&s->data_statement);
2608       break;
2609     case lang_reloc_statement_enum:
2610       print_reloc_statement (&s->reloc_statement);
2611       break;
2612     case lang_input_section_enum:
2613       print_input_section (&s->input_section);
2614       break;
2615     case lang_padding_statement_enum:
2616       print_padding_statement (&s->padding_statement);
2617       break;
2618     case lang_output_section_statement_enum:
2619       print_output_section_statement (&s->output_section_statement);
2620       break;
2621     case lang_assignment_statement_enum:
2622       print_assignment (&s->assignment_statement, os);
2623       break;
2624     case lang_target_statement_enum:
2625       fprintf (config.map_file, "TARGET(%s)\n", s->target_statement.target);
2626       break;
2627     case lang_output_statement_enum:
2628       minfo ("OUTPUT(%s", s->output_statement.name);
2629       if (output_target != NULL)
2630         minfo (" %s", output_target);
2631       minfo (")\n");
2632       break;
2633     case lang_input_statement_enum:
2634       print_input_statement (&s->input_statement);
2635       break;
2636     case lang_group_statement_enum:
2637       print_group (&s->group_statement, os);
2638       break;
2639     case lang_afile_asection_pair_statement_enum:
2640       FAIL ();
2641       break;
2642     }
2643 }
2644
2645 static void
2646 print_statements (void)
2647 {
2648   print_statement_list (statement_list.head, abs_output_section);
2649 }
2650
2651 /* Print the first N statements in statement list S to STDERR.
2652    If N == 0, nothing is printed.
2653    If N < 0, the entire list is printed.
2654    Intended to be called from GDB.  */
2655
2656 void
2657 dprint_statement (lang_statement_union_type *s, int n)
2658 {
2659   FILE *map_save = config.map_file;
2660
2661   config.map_file = stderr;
2662
2663   if (n < 0)
2664     print_statement_list (s, abs_output_section);
2665   else
2666     {
2667       while (s && --n >= 0)
2668         {
2669           print_statement (s, abs_output_section);
2670           s = s->header.next;
2671         }
2672     }
2673
2674   config.map_file = map_save;
2675 }
2676
2677 static void
2678 insert_pad (lang_statement_union_type **ptr,
2679             fill_type *fill,
2680             unsigned int alignment_needed,
2681             asection *output_section,
2682             bfd_vma dot)
2683 {
2684   static fill_type zero_fill = { 1, { 0 } };
2685   lang_statement_union_type *pad;
2686
2687   pad = ((lang_statement_union_type *)
2688          ((char *) ptr - offsetof (lang_statement_union_type, header.next)));
2689   if (ptr != &statement_list.head
2690       && pad->header.type == lang_padding_statement_enum
2691       && pad->padding_statement.output_section == output_section)
2692     {
2693       /* Use the existing pad statement.  The above test on output
2694          section is probably redundant, but it doesn't hurt to check.  */
2695     }
2696   else
2697     {
2698       /* Make a new padding statement, linked into existing chain.  */
2699       pad = stat_alloc (sizeof (lang_padding_statement_type));
2700       pad->header.next = *ptr;
2701       *ptr = pad;
2702       pad->header.type = lang_padding_statement_enum;
2703       pad->padding_statement.output_section = output_section;
2704       if (fill == NULL)
2705         fill = &zero_fill;
2706       pad->padding_statement.fill = fill;
2707     }
2708   pad->padding_statement.output_offset = dot - output_section->vma;
2709   pad->padding_statement.size = alignment_needed;
2710   output_section->_raw_size += alignment_needed;
2711 }
2712
2713 /* Work out how much this section will move the dot point.  */
2714
2715 static bfd_vma
2716 size_input_section (lang_statement_union_type **this_ptr,
2717                     lang_output_section_statement_type *output_section_statement,
2718                     fill_type *fill,
2719                     bfd_vma dot)
2720 {
2721   lang_input_section_type *is = &((*this_ptr)->input_section);
2722   asection *i = is->section;
2723
2724   if (!is->ifile->just_syms_flag)
2725     {
2726       unsigned int alignment_needed;
2727       asection *o;
2728
2729       /* Align this section first to the input sections requirement,
2730          then to the output section's requirement.  If this alignment
2731          is greater than any seen before, then record it too.  Perform
2732          the alignment by inserting a magic 'padding' statement.  */
2733
2734       if (output_section_statement->subsection_alignment != -1)
2735         i->alignment_power = output_section_statement->subsection_alignment;
2736
2737       o = output_section_statement->bfd_section;
2738       if (o->alignment_power < i->alignment_power)
2739         o->alignment_power = i->alignment_power;
2740
2741       alignment_needed = align_power (dot, i->alignment_power) - dot;
2742
2743       if (alignment_needed != 0)
2744         {
2745           insert_pad (this_ptr, fill, TO_SIZE (alignment_needed), o, dot);
2746           dot += alignment_needed;
2747         }
2748
2749       /* Remember where in the output section this input section goes.  */
2750
2751       i->output_offset = dot - o->vma;
2752
2753       /* Mark how big the output section must be to contain this now.  */
2754       if (i->_cooked_size != 0)
2755         dot += TO_ADDR (i->_cooked_size);
2756       else
2757         dot += TO_ADDR (i->_raw_size);
2758       o->_raw_size = TO_SIZE (dot - o->vma);
2759     }
2760   else
2761     {
2762       i->output_offset = i->vma - output_section_statement->bfd_section->vma;
2763     }
2764
2765   return dot;
2766 }
2767
2768 #define IGNORE_SECTION(bfd, s) \
2769   (((bfd_get_section_flags (bfd, s) & SEC_THREAD_LOCAL)                 \
2770     ? ((bfd_get_section_flags (bfd, s) & (SEC_LOAD | SEC_NEVER_LOAD))   \
2771        != SEC_LOAD)                                                     \
2772     :  ((bfd_get_section_flags (bfd, s) & (SEC_ALLOC | SEC_NEVER_LOAD)) \
2773         != SEC_ALLOC))                                                  \
2774    || bfd_section_size (bfd, s) == 0)
2775
2776 /* Check to see if any allocated sections overlap with other allocated
2777    sections.  This can happen when the linker script specifically specifies
2778    the output section addresses of the two sections.  */
2779
2780 static void
2781 lang_check_section_addresses (void)
2782 {
2783   asection *s;
2784
2785   /* Scan all sections in the output list.  */
2786   for (s = output_bfd->sections; s != NULL; s = s->next)
2787     {
2788       asection *os;
2789
2790       /* Ignore sections which are not loaded or which have no contents.  */
2791       if (IGNORE_SECTION (output_bfd, s))
2792         continue;
2793
2794       /* Once we reach section 's' stop our seach.  This prevents two
2795          warning messages from being produced, one for 'section A overlaps
2796          section B' and one for 'section B overlaps section A'.  */
2797       for (os = output_bfd->sections; os != s; os = os->next)
2798         {
2799           bfd_vma s_start;
2800           bfd_vma s_end;
2801           bfd_vma os_start;
2802           bfd_vma os_end;
2803
2804           /* Only consider loadable sections with real contents.  */
2805           if (IGNORE_SECTION (output_bfd, os))
2806             continue;
2807
2808           /* We must check the sections' LMA addresses not their
2809              VMA addresses because overlay sections can have
2810              overlapping VMAs but they must have distinct LMAs.  */
2811           s_start = bfd_section_lma (output_bfd, s);
2812           os_start = bfd_section_lma (output_bfd, os);
2813           s_end = s_start + TO_ADDR (bfd_section_size (output_bfd, s)) - 1;
2814           os_end = os_start + TO_ADDR (bfd_section_size (output_bfd, os)) - 1;
2815
2816           /* Look for an overlap.  */
2817           if ((s_end < os_start) || (s_start > os_end))
2818             continue;
2819
2820           einfo (
2821 _("%X%P: section %s [%V -> %V] overlaps section %s [%V -> %V]\n"),
2822                  s->name, s_start, s_end, os->name, os_start, os_end);
2823
2824           /* Once we have found one overlap for this section,
2825              stop looking for others.  */
2826           break;
2827         }
2828     }
2829 }
2830
2831 /* Make sure the new address is within the region.  We explicitly permit the
2832    current address to be at the exact end of the region when the address is
2833    non-zero, in case the region is at the end of addressable memory and the
2834    calculation wraps around.  */
2835
2836 static void
2837 os_region_check (lang_output_section_statement_type *os,
2838                  lang_memory_region_type *region,
2839                  etree_type *tree,
2840                  bfd_vma base)
2841 {
2842   if ((region->current < region->origin
2843        || (region->current - region->origin > region->length))
2844       && ((region->current != region->origin + region->length)
2845           || base == 0))
2846     {
2847       if (tree != NULL)
2848         {
2849           einfo (_("%X%P: address 0x%v of %B section %s is not within region %s\n"),
2850                  region->current,
2851                  os->bfd_section->owner,
2852                  os->bfd_section->name,
2853                  region->name);
2854         }
2855       else
2856         {
2857           einfo (_("%X%P: region %s is full (%B section %s)\n"),
2858                  region->name,
2859                  os->bfd_section->owner,
2860                  os->bfd_section->name);
2861         }
2862       /* Reset the region pointer.  */
2863       region->current = region->origin;
2864     }
2865 }
2866
2867 /* Set the sizes for all the output sections.  */
2868
2869 static bfd_vma
2870 lang_size_sections_1
2871   (lang_statement_union_type *s,
2872    lang_output_section_statement_type *output_section_statement,
2873    lang_statement_union_type **prev,
2874    fill_type *fill,
2875    bfd_vma dot,
2876    bfd_boolean *relax,
2877    bfd_boolean check_regions)
2878 {
2879   /* Size up the sections from their constituent parts.  */
2880   for (; s != NULL; s = s->header.next)
2881     {
2882       switch (s->header.type)
2883         {
2884         case lang_output_section_statement_enum:
2885           {
2886             bfd_vma after;
2887             lang_output_section_statement_type *os;
2888
2889             os = &s->output_section_statement;
2890             if (os->bfd_section == NULL)
2891               /* This section was never actually created.  */
2892               break;
2893
2894             /* If this is a COFF shared library section, use the size and
2895                address from the input section.  FIXME: This is COFF
2896                specific; it would be cleaner if there were some other way
2897                to do this, but nothing simple comes to mind.  */
2898             if ((os->bfd_section->flags & SEC_COFF_SHARED_LIBRARY) != 0)
2899               {
2900                 asection *input;
2901
2902                 if (os->children.head == NULL
2903                     || os->children.head->header.next != NULL
2904                     || os->children.head->header.type != lang_input_section_enum)
2905                   einfo (_("%P%X: Internal error on COFF shared library section %s\n"),
2906                          os->name);
2907
2908                 input = os->children.head->input_section.section;
2909                 bfd_set_section_vma (os->bfd_section->owner,
2910                                      os->bfd_section,
2911                                      bfd_section_vma (input->owner, input));
2912                 os->bfd_section->_raw_size = input->_raw_size;
2913                 break;
2914               }
2915
2916             if (bfd_is_abs_section (os->bfd_section))
2917               {
2918                 /* No matter what happens, an abs section starts at zero.  */
2919                 ASSERT (os->bfd_section->vma == 0);
2920               }
2921             else
2922               {
2923                 if (os->addr_tree == NULL)
2924                   {
2925                     /* No address specified for this section, get one
2926                        from the region specification.  */
2927                     if (os->region == NULL
2928                         || (((bfd_get_section_flags (output_bfd, os->bfd_section)
2929                               & (SEC_ALLOC | SEC_LOAD)) != 0)
2930                             && os->region->name[0] == '*'
2931                             && strcmp (os->region->name, DEFAULT_MEMORY_REGION) == 0))
2932                       {
2933                         os->region = lang_memory_default (os->bfd_section);
2934                       }
2935
2936                     /* If a loadable section is using the default memory
2937                        region, and some non default memory regions were
2938                        defined, issue an error message.  */
2939                     if (!IGNORE_SECTION (output_bfd, os->bfd_section)
2940                         && ! link_info.relocatable
2941                         && check_regions
2942                         && strcmp (os->region->name, DEFAULT_MEMORY_REGION) == 0
2943                         && lang_memory_region_list != NULL
2944                         && (strcmp (lang_memory_region_list->name,
2945                                     DEFAULT_MEMORY_REGION) != 0
2946                             || lang_memory_region_list->next != NULL))
2947                       {
2948                         /* By default this is an error rather than just a
2949                            warning because if we allocate the section to the
2950                            default memory region we can end up creating an
2951                            excessively large binary, or even seg faulting when
2952                            attempting to perform a negative seek.  See
2953                              http://sources.redhat.com/ml/binutils/2003-04/msg00423.html
2954                            for an example of this.  This behaviour can be
2955                            overridden by the using the --no-check-sections
2956                            switch.  */
2957                         if (command_line.check_section_addresses)
2958                           einfo (_("%P%F: error: no memory region specified for loadable section `%s'\n"),
2959                                  bfd_get_section_name (output_bfd,
2960                                                        os->bfd_section));
2961                         else
2962                           einfo (_("%P: warning: no memory region specified for loadable section `%s'\n"),
2963                                  bfd_get_section_name (output_bfd,
2964                                                        os->bfd_section));
2965                       }
2966
2967                     dot = os->region->current;
2968
2969                     if (os->section_alignment == -1)
2970                       {
2971                         bfd_vma olddot;
2972
2973                         olddot = dot;
2974                         dot = align_power (dot,
2975                                            os->bfd_section->alignment_power);
2976
2977                         if (dot != olddot && config.warn_section_align)
2978                           einfo (_("%P: warning: changing start of section %s by %u bytes\n"),
2979                                  os->name, (unsigned int) (dot - olddot));
2980                       }
2981                   }
2982                 else
2983                   {
2984                     etree_value_type r;
2985
2986                     os->processed = -1;
2987                     r = exp_fold_tree (os->addr_tree,
2988                                        abs_output_section,
2989                                        lang_allocating_phase_enum,
2990                                        dot, &dot);
2991                     os->processed = 0;
2992
2993                     if (!r.valid_p)
2994                       einfo (_("%F%S: non constant or forward reference address expression for section %s\n"),
2995                              os->name);
2996
2997                     dot = r.value + r.section->bfd_section->vma;
2998                   }
2999
3000                 /* The section starts here.
3001                    First, align to what the section needs.  */
3002
3003                 if (os->section_alignment != -1)
3004                   dot = align_power (dot, os->section_alignment);
3005
3006                 bfd_set_section_vma (0, os->bfd_section, dot);
3007
3008                 os->bfd_section->output_offset = 0;
3009               }
3010
3011             lang_size_sections_1 (os->children.head, os, &os->children.head,
3012                                   os->fill, dot, relax, check_regions);
3013
3014             /* Put the section within the requested block size, or
3015                align at the block boundary.  */
3016             after = ((os->bfd_section->vma
3017                       + TO_ADDR (os->bfd_section->_raw_size)
3018                       + os->block_value - 1)
3019                      & - (bfd_vma) os->block_value);
3020
3021             if (bfd_is_abs_section (os->bfd_section))
3022               ASSERT (after == os->bfd_section->vma);
3023             else
3024               os->bfd_section->_raw_size
3025                 = TO_SIZE (after - os->bfd_section->vma);
3026
3027             dot = os->bfd_section->vma;
3028             /* .tbss sections effectively have zero size.  */
3029             if ((os->bfd_section->flags & SEC_HAS_CONTENTS) != 0
3030                 || (os->bfd_section->flags & SEC_THREAD_LOCAL) == 0
3031                 || link_info.relocatable)
3032               dot += TO_ADDR (os->bfd_section->_raw_size);
3033
3034             os->processed = 1;
3035
3036             if (os->update_dot_tree != 0)
3037               exp_fold_tree (os->update_dot_tree, abs_output_section,
3038                              lang_allocating_phase_enum, dot, &dot);
3039
3040             /* Update dot in the region ?
3041                We only do this if the section is going to be allocated,
3042                since unallocated sections do not contribute to the region's
3043                overall size in memory.
3044
3045                If the SEC_NEVER_LOAD bit is not set, it will affect the
3046                addresses of sections after it. We have to update
3047                dot.  */
3048             if (os->region != NULL
3049                 && ((bfd_get_section_flags (output_bfd, os->bfd_section)
3050                      & SEC_NEVER_LOAD) == 0
3051                     || (bfd_get_section_flags (output_bfd, os->bfd_section)
3052                         & (SEC_ALLOC | SEC_LOAD))))
3053               {
3054                 os->region->current = dot;
3055
3056                 if (check_regions)
3057                   /* Make sure the new address is within the region.  */
3058                   os_region_check (os, os->region, os->addr_tree,
3059                                    os->bfd_section->vma);
3060
3061                 /* If there's no load address specified, use the run
3062                    region as the load region.  */
3063                 if (os->lma_region == NULL && os->load_base == NULL)
3064                   os->lma_region = os->region;
3065
3066                 if (os->lma_region != NULL && os->lma_region != os->region)
3067                   {
3068                     /* Set load_base, which will be handled later.  */
3069                     os->load_base = exp_intop (os->lma_region->current);
3070                     os->lma_region->current +=
3071                       TO_ADDR (os->bfd_section->_raw_size);
3072                     if (check_regions)
3073                       os_region_check (os, os->lma_region, NULL,
3074                                        os->bfd_section->lma);
3075                   }
3076               }
3077           }
3078           break;
3079
3080         case lang_constructors_statement_enum:
3081           dot = lang_size_sections_1 (constructor_list.head,
3082                                       output_section_statement,
3083                                       &s->wild_statement.children.head,
3084                                       fill, dot, relax, check_regions);
3085           break;
3086
3087         case lang_data_statement_enum:
3088           {
3089             unsigned int size = 0;
3090
3091             s->data_statement.output_vma =
3092               dot - output_section_statement->bfd_section->vma;
3093             s->data_statement.output_section =
3094               output_section_statement->bfd_section;
3095
3096             /* We might refer to provided symbols in the expression, and
3097                need to mark them as needed.  */
3098             exp_fold_tree (s->data_statement.exp, abs_output_section,
3099                            lang_allocating_phase_enum, dot, &dot);
3100
3101             switch (s->data_statement.type)
3102               {
3103               default:
3104                 abort ();
3105               case QUAD:
3106               case SQUAD:
3107                 size = QUAD_SIZE;
3108                 break;
3109               case LONG:
3110                 size = LONG_SIZE;
3111                 break;
3112               case SHORT:
3113                 size = SHORT_SIZE;
3114                 break;
3115               case BYTE:
3116                 size = BYTE_SIZE;
3117                 break;
3118               }
3119             if (size < TO_SIZE ((unsigned) 1))
3120               size = TO_SIZE ((unsigned) 1);
3121             dot += TO_ADDR (size);
3122             output_section_statement->bfd_section->_raw_size += size;
3123             /* The output section gets contents, and then we inspect for
3124                any flags set in the input script which override any ALLOC.  */
3125             output_section_statement->bfd_section->flags |= SEC_HAS_CONTENTS;
3126             if (!(output_section_statement->flags & SEC_NEVER_LOAD))
3127               {
3128                 output_section_statement->bfd_section->flags |=
3129                   SEC_ALLOC | SEC_LOAD;
3130               }
3131           }
3132           break;
3133
3134         case lang_reloc_statement_enum:
3135           {
3136             int size;
3137
3138             s->reloc_statement.output_vma =
3139               dot - output_section_statement->bfd_section->vma;
3140             s->reloc_statement.output_section =
3141               output_section_statement->bfd_section;
3142             size = bfd_get_reloc_size (s->reloc_statement.howto);
3143             dot += TO_ADDR (size);
3144             output_section_statement->bfd_section->_raw_size += size;
3145           }
3146           break;
3147
3148         case lang_wild_statement_enum:
3149
3150           dot = lang_size_sections_1 (s->wild_statement.children.head,
3151                                       output_section_statement,
3152                                       &s->wild_statement.children.head,
3153                                       fill, dot, relax, check_regions);
3154
3155           break;
3156
3157         case lang_object_symbols_statement_enum:
3158           link_info.create_object_symbols_section =
3159             output_section_statement->bfd_section;
3160           break;
3161         case lang_output_statement_enum:
3162         case lang_target_statement_enum:
3163           break;
3164         case lang_input_section_enum:
3165           {
3166             asection *i;
3167
3168             i = (*prev)->input_section.section;
3169             if (! relax)
3170               {
3171                 if (i->_cooked_size == 0)
3172                   i->_cooked_size = i->_raw_size;
3173               }
3174             else
3175               {
3176                 bfd_boolean again;
3177
3178                 if (! bfd_relax_section (i->owner, i, &link_info, &again))
3179                   einfo (_("%P%F: can't relax section: %E\n"));
3180                 if (again)
3181                   *relax = TRUE;
3182               }
3183             dot = size_input_section (prev, output_section_statement,
3184                                       output_section_statement->fill, dot);
3185           }
3186           break;
3187         case lang_input_statement_enum:
3188           break;
3189         case lang_fill_statement_enum:
3190           s->fill_statement.output_section =
3191             output_section_statement->bfd_section;
3192
3193           fill = s->fill_statement.fill;
3194           break;
3195         case lang_assignment_statement_enum:
3196           {
3197             bfd_vma newdot = dot;
3198
3199             exp_fold_tree (s->assignment_statement.exp,
3200                            output_section_statement,
3201                            lang_allocating_phase_enum,
3202                            dot,
3203                            &newdot);
3204
3205             if (newdot != dot)
3206               {
3207                 if (output_section_statement == abs_output_section)
3208                   {
3209                     /* If we don't have an output section, then just adjust
3210                        the default memory address.  */
3211                     lang_memory_region_lookup (DEFAULT_MEMORY_REGION, FALSE)->current = newdot;
3212                   }
3213                 else
3214                   {
3215                     /* Insert a pad after this statement.  We can't
3216                        put the pad before when relaxing, in case the
3217                        assignment references dot.  */
3218                     insert_pad (&s->header.next, fill, TO_SIZE (newdot - dot),
3219                                 output_section_statement->bfd_section, dot);
3220
3221                     /* Don't neuter the pad below when relaxing.  */
3222                     s = s->header.next;
3223                   }
3224
3225                 /* If dot is advanced, this implies that the section should
3226                    have space allocated to it, unless the user has explicitly
3227                    stated that the section should never be loaded.  */
3228                 if (!(output_section_statement->flags & (SEC_NEVER_LOAD | SEC_ALLOC)))
3229                   output_section_statement->bfd_section->flags |= SEC_ALLOC;
3230
3231                 dot = newdot;
3232               }
3233           }
3234           break;
3235
3236         case lang_padding_statement_enum:
3237           /* If this is the first time lang_size_sections is called,
3238              we won't have any padding statements.  If this is the
3239              second or later passes when relaxing, we should allow
3240              padding to shrink.  If padding is needed on this pass, it
3241              will be added back in.  */
3242           s->padding_statement.size = 0;
3243
3244           /* Make sure output_offset is valid.  If relaxation shrinks
3245              the section and this pad isn't needed, it's possible to
3246              have output_offset larger than the final size of the
3247              section.  bfd_set_section_contents will complain even for
3248              a pad size of zero.  */
3249           s->padding_statement.output_offset
3250             = dot - output_section_statement->bfd_section->vma;
3251           break;
3252
3253         case lang_group_statement_enum:
3254           dot = lang_size_sections_1 (s->group_statement.children.head,
3255                                       output_section_statement,
3256                                       &s->group_statement.children.head,
3257                                       fill, dot, relax, check_regions);
3258           break;
3259
3260         default:
3261           FAIL ();
3262           break;
3263
3264           /* We can only get here when relaxing is turned on.  */
3265         case lang_address_statement_enum:
3266           break;
3267         }
3268       prev = &s->header.next;
3269     }
3270   return dot;
3271 }
3272
3273 bfd_vma
3274 lang_size_sections
3275   (lang_statement_union_type *s,
3276    lang_output_section_statement_type *output_section_statement,
3277    lang_statement_union_type **prev,
3278    fill_type *fill,
3279    bfd_vma dot,
3280    bfd_boolean *relax,
3281    bfd_boolean check_regions)
3282 {
3283   bfd_vma result;
3284   asection *o;
3285
3286   /* Callers of exp_fold_tree need to increment this.  */
3287   lang_statement_iteration++;
3288
3289   exp_data_seg.phase = exp_dataseg_none;
3290   result = lang_size_sections_1 (s, output_section_statement, prev, fill,
3291                                  dot, relax, check_regions);
3292   if (exp_data_seg.phase == exp_dataseg_end_seen)
3293     {
3294       /* If DATA_SEGMENT_ALIGN DATA_SEGMENT_END pair was seen, check whether
3295          a page could be saved in the data segment.  */
3296       bfd_vma first, last;
3297
3298       first = -exp_data_seg.base & (exp_data_seg.pagesize - 1);
3299       last = exp_data_seg.end & (exp_data_seg.pagesize - 1);
3300       if (first && last
3301           && ((exp_data_seg.base & ~(exp_data_seg.pagesize - 1))
3302               != (exp_data_seg.end & ~(exp_data_seg.pagesize - 1)))
3303           && first + last <= exp_data_seg.pagesize)
3304         {
3305           exp_data_seg.phase = exp_dataseg_adjust;
3306           lang_statement_iteration++;
3307           result = lang_size_sections_1 (s, output_section_statement, prev,
3308                                          fill, dot, relax, check_regions);
3309         }
3310     }
3311
3312   /* Some backend relaxers want to refer to the output section size.  Give
3313      them a section size that does not change on the next call while they
3314      relax.  We can't set this at top because lang_reset_memory_regions
3315      which is called before we get here, sets _raw_size to 0 on relaxing
3316      rounds.  */
3317   for (o = output_bfd->sections; o != NULL; o = o->next)
3318     o->_cooked_size = o->_raw_size;
3319
3320   return result;
3321 }
3322
3323 /* Worker function for lang_do_assignments.  Recursiveness goes here.  */
3324
3325 static bfd_vma
3326 lang_do_assignments_1
3327   (lang_statement_union_type *s,
3328    lang_output_section_statement_type *output_section_statement,
3329    fill_type *fill,
3330    bfd_vma dot)
3331 {
3332   for (; s != NULL; s = s->header.next)
3333     {
3334       switch (s->header.type)
3335         {
3336         case lang_constructors_statement_enum:
3337           dot = lang_do_assignments_1 (constructor_list.head,
3338                                        output_section_statement,
3339                                        fill,
3340                                        dot);
3341           break;
3342
3343         case lang_output_section_statement_enum:
3344           {
3345             lang_output_section_statement_type *os;
3346
3347             os = &(s->output_section_statement);
3348             if (os->bfd_section != NULL)
3349               {
3350                 dot = os->bfd_section->vma;
3351                 (void) lang_do_assignments_1 (os->children.head, os,
3352                                               os->fill, dot);
3353                 dot = (os->bfd_section->vma
3354                        + TO_ADDR (os->bfd_section->_raw_size));
3355
3356               }
3357             if (os->load_base)
3358               {
3359                 /* If nothing has been placed into the output section then
3360                    it won't have a bfd_section.  */
3361                 if (os->bfd_section)
3362                   {
3363                     os->bfd_section->lma
3364                       = exp_get_abs_int (os->load_base, 0, "load base",
3365                                          lang_final_phase_enum);
3366                   }
3367               }
3368           }
3369           break;
3370         case lang_wild_statement_enum:
3371
3372           dot = lang_do_assignments_1 (s->wild_statement.children.head,
3373                                        output_section_statement,
3374                                        fill, dot);
3375
3376           break;
3377
3378         case lang_object_symbols_statement_enum:
3379         case lang_output_statement_enum:
3380         case lang_target_statement_enum:
3381 #if 0
3382         case lang_common_statement_enum:
3383 #endif
3384           break;
3385         case lang_data_statement_enum:
3386           {
3387             etree_value_type value;
3388
3389             value = exp_fold_tree (s->data_statement.exp,
3390                                    abs_output_section,
3391                                    lang_final_phase_enum, dot, &dot);
3392             if (!value.valid_p)
3393               einfo (_("%F%P: invalid data statement\n"));
3394             s->data_statement.value
3395               = value.value + value.section->bfd_section->vma;
3396           }
3397           {
3398             unsigned int size;
3399             switch (s->data_statement.type)
3400               {
3401               default:
3402                 abort ();
3403               case QUAD:
3404               case SQUAD:
3405                 size = QUAD_SIZE;
3406                 break;
3407               case LONG:
3408                 size = LONG_SIZE;
3409                 break;
3410               case SHORT:
3411                 size = SHORT_SIZE;
3412                 break;
3413               case BYTE:
3414                 size = BYTE_SIZE;
3415                 break;
3416               }
3417             if (size < TO_SIZE ((unsigned) 1))
3418               size = TO_SIZE ((unsigned) 1);
3419             dot += TO_ADDR (size);
3420           }
3421           break;
3422
3423         case lang_reloc_statement_enum:
3424           {
3425             etree_value_type value;
3426
3427             value = exp_fold_tree (s->reloc_statement.addend_exp,
3428                                    abs_output_section,
3429                                    lang_final_phase_enum, dot, &dot);
3430             s->reloc_statement.addend_value = value.value;
3431             if (!value.valid_p)
3432               einfo (_("%F%P: invalid reloc statement\n"));
3433           }
3434           dot += TO_ADDR (bfd_get_reloc_size (s->reloc_statement.howto));
3435           break;
3436
3437         case lang_input_section_enum:
3438           {
3439             asection *in = s->input_section.section;
3440
3441             if (in->_cooked_size != 0)
3442               dot += TO_ADDR (in->_cooked_size);
3443             else
3444               dot += TO_ADDR (in->_raw_size);
3445           }
3446           break;
3447
3448         case lang_input_statement_enum:
3449           break;
3450         case lang_fill_statement_enum:
3451           fill = s->fill_statement.fill;
3452           break;
3453         case lang_assignment_statement_enum:
3454           {
3455             exp_fold_tree (s->assignment_statement.exp,
3456                            output_section_statement,
3457                            lang_final_phase_enum,
3458                            dot,
3459                            &dot);
3460           }
3461
3462           break;
3463         case lang_padding_statement_enum:
3464           dot += TO_ADDR (s->padding_statement.size);
3465           break;
3466
3467         case lang_group_statement_enum:
3468           dot = lang_do_assignments_1 (s->group_statement.children.head,
3469                                        output_section_statement,
3470                                        fill, dot);
3471
3472           break;
3473
3474         default:
3475           FAIL ();
3476           break;
3477         case lang_address_statement_enum:
3478           break;
3479         }
3480
3481     }
3482   return dot;
3483 }
3484
3485 void
3486 lang_do_assignments (lang_statement_union_type *s,
3487                      lang_output_section_statement_type *output_section_statement,
3488                      fill_type *fill,
3489                      bfd_vma dot)
3490 {
3491   /* Callers of exp_fold_tree need to increment this.  */
3492   lang_statement_iteration++;
3493   lang_do_assignments_1 (s, output_section_statement, fill, dot);
3494 }
3495
3496 /* Fix any .startof. or .sizeof. symbols.  When the assemblers see the
3497    operator .startof. (section_name), it produces an undefined symbol
3498    .startof.section_name.  Similarly, when it sees
3499    .sizeof. (section_name), it produces an undefined symbol
3500    .sizeof.section_name.  For all the output sections, we look for
3501    such symbols, and set them to the correct value.  */
3502
3503 static void
3504 lang_set_startof (void)
3505 {
3506   asection *s;
3507
3508   if (link_info.relocatable)
3509     return;
3510
3511   for (s = output_bfd->sections; s != NULL; s = s->next)
3512     {
3513       const char *secname;
3514       char *buf;
3515       struct bfd_link_hash_entry *h;
3516
3517       secname = bfd_get_section_name (output_bfd, s);
3518       buf = xmalloc (10 + strlen (secname));
3519
3520       sprintf (buf, ".startof.%s", secname);
3521       h = bfd_link_hash_lookup (link_info.hash, buf, FALSE, FALSE, TRUE);
3522       if (h != NULL && h->type == bfd_link_hash_undefined)
3523         {
3524           h->type = bfd_link_hash_defined;
3525           h->u.def.value = bfd_get_section_vma (output_bfd, s);
3526           h->u.def.section = bfd_abs_section_ptr;
3527         }
3528
3529       sprintf (buf, ".sizeof.%s", secname);
3530       h = bfd_link_hash_lookup (link_info.hash, buf, FALSE, FALSE, TRUE);
3531       if (h != NULL && h->type == bfd_link_hash_undefined)
3532         {
3533           h->type = bfd_link_hash_defined;
3534           if (s->_cooked_size != 0)
3535             h->u.def.value = TO_ADDR (s->_cooked_size);
3536           else
3537             h->u.def.value = TO_ADDR (s->_raw_size);
3538           h->u.def.section = bfd_abs_section_ptr;
3539         }
3540
3541       free (buf);
3542     }
3543 }
3544
3545 static void
3546 lang_finish (void)
3547 {
3548   struct bfd_link_hash_entry *h;
3549   bfd_boolean warn;
3550
3551   if (link_info.relocatable || link_info.shared)
3552     warn = FALSE;
3553   else
3554     warn = TRUE;
3555
3556   if (entry_symbol.name == NULL)
3557     {
3558       /* No entry has been specified.  Look for start, but don't warn
3559          if we don't find it.  */
3560       entry_symbol.name = "start";
3561       warn = FALSE;
3562     }
3563
3564   h = bfd_link_hash_lookup (link_info.hash, entry_symbol.name,
3565                             FALSE, FALSE, TRUE);
3566   if (h != NULL
3567       && (h->type == bfd_link_hash_defined
3568           || h->type == bfd_link_hash_defweak)
3569       && h->u.def.section->output_section != NULL)
3570     {
3571       bfd_vma val;
3572
3573       val = (h->u.def.value
3574              + bfd_get_section_vma (output_bfd,
3575                                     h->u.def.section->output_section)
3576              + h->u.def.section->output_offset);
3577       if (! bfd_set_start_address (output_bfd, val))
3578         einfo (_("%P%F:%s: can't set start address\n"), entry_symbol.name);
3579     }
3580   else
3581     {
3582       bfd_vma val;
3583       const char *send;
3584
3585       /* We couldn't find the entry symbol.  Try parsing it as a
3586          number.  */
3587       val = bfd_scan_vma (entry_symbol.name, &send, 0);
3588       if (*send == '\0')
3589         {
3590           if (! bfd_set_start_address (output_bfd, val))
3591             einfo (_("%P%F: can't set start address\n"));
3592         }
3593       else
3594         {
3595           asection *ts;
3596
3597           /* Can't find the entry symbol, and it's not a number.  Use
3598              the first address in the text section.  */
3599           ts = bfd_get_section_by_name (output_bfd, entry_section);
3600           if (ts != NULL)
3601             {
3602               if (warn)
3603                 einfo (_("%P: warning: cannot find entry symbol %s; defaulting to %V\n"),
3604                        entry_symbol.name,
3605                        bfd_get_section_vma (output_bfd, ts));
3606               if (! bfd_set_start_address (output_bfd,
3607                                            bfd_get_section_vma (output_bfd,
3608                                                                 ts)))
3609                 einfo (_("%P%F: can't set start address\n"));
3610             }
3611           else
3612             {
3613               if (warn)
3614                 einfo (_("%P: warning: cannot find entry symbol %s; not setting start address\n"),
3615                        entry_symbol.name);
3616             }
3617         }
3618     }
3619
3620   bfd_hash_table_free (&lang_definedness_table);
3621 }
3622
3623 /* This is a small function used when we want to ignore errors from
3624    BFD.  */
3625
3626 static void
3627 ignore_bfd_errors (const char *s ATTRIBUTE_UNUSED, ...)
3628 {
3629   /* Don't do anything.  */
3630 }
3631
3632 /* Check that the architecture of all the input files is compatible
3633    with the output file.  Also call the backend to let it do any
3634    other checking that is needed.  */
3635
3636 static void
3637 lang_check (void)
3638 {
3639   lang_statement_union_type *file;
3640   bfd *input_bfd;
3641   const bfd_arch_info_type *compatible;
3642
3643   for (file = file_chain.head; file != NULL; file = file->input_statement.next)
3644     {
3645       input_bfd = file->input_statement.the_bfd;
3646       compatible = bfd_arch_get_compatible (input_bfd, output_bfd,
3647                                             command_line.accept_unknown_input_arch);
3648
3649       /* In general it is not possible to perform a relocatable
3650          link between differing object formats when the input
3651          file has relocations, because the relocations in the
3652          input format may not have equivalent representations in
3653          the output format (and besides BFD does not translate
3654          relocs for other link purposes than a final link).  */
3655       if ((link_info.relocatable || link_info.emitrelocations)
3656           && (compatible == NULL
3657               || bfd_get_flavour (input_bfd) != bfd_get_flavour (output_bfd))
3658           && (bfd_get_file_flags (input_bfd) & HAS_RELOC) != 0)
3659         {
3660           einfo (_("%P%F: Relocatable linking with relocations from format %s (%B) to format %s (%B) is not supported\n"),
3661                  bfd_get_target (input_bfd), input_bfd,
3662                  bfd_get_target (output_bfd), output_bfd);
3663           /* einfo with %F exits.  */
3664         }
3665
3666       if (compatible == NULL)
3667         {
3668           if (command_line.warn_mismatch)
3669             einfo (_("%P: warning: %s architecture of input file `%B' is incompatible with %s output\n"),
3670                    bfd_printable_name (input_bfd), input_bfd,
3671                    bfd_printable_name (output_bfd));
3672         }
3673       else if (bfd_count_sections (input_bfd))
3674         {
3675           /* If the input bfd has no contents, it shouldn't set the
3676              private data of the output bfd.  */
3677
3678           bfd_error_handler_type pfn = NULL;
3679
3680           /* If we aren't supposed to warn about mismatched input
3681              files, temporarily set the BFD error handler to a
3682              function which will do nothing.  We still want to call
3683              bfd_merge_private_bfd_data, since it may set up
3684              information which is needed in the output file.  */
3685           if (! command_line.warn_mismatch)
3686             pfn = bfd_set_error_handler (ignore_bfd_errors);
3687           if (! bfd_merge_private_bfd_data (input_bfd, output_bfd))
3688             {
3689               if (command_line.warn_mismatch)
3690                 einfo (_("%P%X: failed to merge target specific data of file %B\n"),
3691                        input_bfd);
3692             }
3693           if (! command_line.warn_mismatch)
3694             bfd_set_error_handler (pfn);
3695         }
3696     }
3697 }
3698
3699 /* Look through all the global common symbols and attach them to the
3700    correct section.  The -sort-common command line switch may be used
3701    to roughly sort the entries by size.  */
3702
3703 static void
3704 lang_common (void)
3705 {
3706   if (command_line.inhibit_common_definition)
3707     return;
3708   if (link_info.relocatable
3709       && ! command_line.force_common_definition)
3710     return;
3711
3712   if (! config.sort_common)
3713     bfd_link_hash_traverse (link_info.hash, lang_one_common, NULL);
3714   else
3715     {
3716       int power;
3717
3718       for (power = 4; power >= 0; power--)
3719         bfd_link_hash_traverse (link_info.hash, lang_one_common, &power);
3720     }
3721 }
3722
3723 /* Place one common symbol in the correct section.  */
3724
3725 static bfd_boolean
3726 lang_one_common (struct bfd_link_hash_entry *h, void *info)
3727 {
3728   unsigned int power_of_two;
3729   bfd_vma size;
3730   asection *section;
3731
3732   if (h->type != bfd_link_hash_common)
3733     return TRUE;
3734
3735   size = h->u.c.size;
3736   power_of_two = h->u.c.p->alignment_power;
3737
3738   if (config.sort_common
3739       && power_of_two < (unsigned int) *(int *) info)
3740     return TRUE;
3741
3742   section = h->u.c.p->section;
3743
3744   /* Increase the size of the section to align the common sym.  */
3745   section->_cooked_size += ((bfd_vma) 1 << (power_of_two + opb_shift)) - 1;
3746   section->_cooked_size &= (- (bfd_vma) 1 << (power_of_two + opb_shift));
3747
3748   /* Adjust the alignment if necessary.  */
3749   if (power_of_two > section->alignment_power)
3750     section->alignment_power = power_of_two;
3751
3752   /* Change the symbol from common to defined.  */
3753   h->type = bfd_link_hash_defined;
3754   h->u.def.section = section;
3755   h->u.def.value = section->_cooked_size;
3756
3757   /* Increase the size of the section.  */
3758   section->_cooked_size += size;
3759
3760   /* Make sure the section is allocated in memory, and make sure that
3761      it is no longer a common section.  */
3762   section->flags |= SEC_ALLOC;
3763   section->flags &= ~SEC_IS_COMMON;
3764
3765   if (config.map_file != NULL)
3766     {
3767       static bfd_boolean header_printed;
3768       int len;
3769       char *name;
3770       char buf[50];
3771
3772       if (! header_printed)
3773         {
3774           minfo (_("\nAllocating common symbols\n"));
3775           minfo (_("Common symbol       size              file\n\n"));
3776           header_printed = TRUE;
3777         }
3778
3779       name = demangle (h->root.string);
3780       minfo ("%s", name);
3781       len = strlen (name);
3782       free (name);
3783
3784       if (len >= 19)
3785         {
3786           print_nl ();
3787           len = 0;
3788         }
3789       while (len < 20)
3790         {
3791           print_space ();
3792           ++len;
3793         }
3794
3795       minfo ("0x");
3796       if (size <= 0xffffffff)
3797         sprintf (buf, "%lx", (unsigned long) size);
3798       else
3799         sprintf_vma (buf, size);
3800       minfo ("%s", buf);
3801       len = strlen (buf);
3802
3803       while (len < 16)
3804         {
3805           print_space ();
3806           ++len;
3807         }
3808
3809       minfo ("%B\n", section->owner);
3810     }
3811
3812   return TRUE;
3813 }
3814
3815 /* Run through the input files and ensure that every input section has
3816    somewhere to go.  If one is found without a destination then create
3817    an input request and place it into the statement tree.  */
3818
3819 static void
3820 lang_place_orphans (void)
3821 {
3822   LANG_FOR_EACH_INPUT_STATEMENT (file)
3823     {
3824       asection *s;
3825
3826       for (s = file->the_bfd->sections; s != NULL; s = s->next)
3827         {
3828           if (s->output_section == NULL)
3829             {
3830               /* This section of the file is not attached, root
3831                  around for a sensible place for it to go.  */
3832
3833               if (file->just_syms_flag)
3834                 {
3835                   abort ();
3836                 }
3837               else if (strcmp (s->name, "COMMON") == 0)
3838                 {
3839                   /* This is a lonely common section which must have
3840                      come from an archive.  We attach to the section
3841                      with the wildcard.  */
3842                   if (! link_info.relocatable
3843                       || command_line.force_common_definition)
3844                     {
3845                       if (default_common_section == NULL)
3846                         {
3847 #if 0
3848                           /* This message happens when using the
3849                              svr3.ifile linker script, so I have
3850                              disabled it.  */
3851                           info_msg (_("%P: no [COMMON] command, defaulting to .bss\n"));
3852 #endif
3853                           default_common_section =
3854                             lang_output_section_statement_lookup (".bss");
3855
3856                         }
3857                       lang_add_section (&default_common_section->children, s,
3858                                         default_common_section, file);
3859                     }
3860                 }
3861               else if (ldemul_place_orphan (file, s))
3862                 ;
3863               else
3864                 {
3865                   lang_output_section_statement_type *os;
3866
3867                   os = lang_output_section_statement_lookup (s->name);
3868                   lang_add_section (&os->children, s, os, file);
3869                 }
3870             }
3871         }
3872     }
3873 }
3874
3875 void
3876 lang_set_flags (lang_memory_region_type *ptr, const char *flags, int invert)
3877 {
3878   flagword *ptr_flags;
3879
3880   ptr_flags = invert ? &ptr->not_flags : &ptr->flags;
3881   while (*flags)
3882     {
3883       switch (*flags)
3884         {
3885         case 'A': case 'a':
3886           *ptr_flags |= SEC_ALLOC;
3887           break;
3888
3889         case 'R': case 'r':
3890           *ptr_flags |= SEC_READONLY;
3891           break;
3892
3893         case 'W': case 'w':
3894           *ptr_flags |= SEC_DATA;
3895           break;
3896
3897         case 'X': case 'x':
3898           *ptr_flags |= SEC_CODE;
3899           break;
3900
3901         case 'L': case 'l':
3902         case 'I': case 'i':
3903           *ptr_flags |= SEC_LOAD;
3904           break;
3905
3906         default:
3907           einfo (_("%P%F: invalid syntax in flags\n"));
3908           break;
3909         }
3910       flags++;
3911     }
3912 }
3913
3914 /* Call a function on each input file.  This function will be called
3915    on an archive, but not on the elements.  */
3916
3917 void
3918 lang_for_each_input_file (void (*func) (lang_input_statement_type *))
3919 {
3920   lang_input_statement_type *f;
3921
3922   for (f = (lang_input_statement_type *) input_file_chain.head;
3923        f != NULL;
3924        f = (lang_input_statement_type *) f->next_real_file)
3925     func (f);
3926 }
3927
3928 /* Call a function on each file.  The function will be called on all
3929    the elements of an archive which are included in the link, but will
3930    not be called on the archive file itself.  */
3931
3932 void
3933 lang_for_each_file (void (*func) (lang_input_statement_type *))
3934 {
3935   LANG_FOR_EACH_INPUT_STATEMENT (f)
3936     {
3937       func (f);
3938     }
3939 }
3940
3941 #if 0
3942
3943 /* Not used.  */
3944
3945 void
3946 lang_for_each_input_section (void (*func) (bfd *ab, asection *as))
3947 {
3948   LANG_FOR_EACH_INPUT_STATEMENT (f)
3949     {
3950       asection *s;
3951
3952       for (s = f->the_bfd->sections; s != NULL; s = s->next)
3953         func (f->the_bfd, s);
3954     }
3955 }
3956
3957 #endif
3958
3959 void
3960 ldlang_add_file (lang_input_statement_type *entry)
3961 {
3962   bfd **pp;
3963
3964   lang_statement_append (&file_chain,
3965                          (lang_statement_union_type *) entry,
3966                          &entry->next);
3967
3968   /* The BFD linker needs to have a list of all input BFDs involved in
3969      a link.  */
3970   ASSERT (entry->the_bfd->link_next == NULL);
3971   ASSERT (entry->the_bfd != output_bfd);
3972   for (pp = &link_info.input_bfds; *pp != NULL; pp = &(*pp)->link_next)
3973     ;
3974   *pp = entry->the_bfd;
3975   entry->the_bfd->usrdata = entry;
3976   bfd_set_gp_size (entry->the_bfd, g_switch_value);
3977
3978   /* Look through the sections and check for any which should not be
3979      included in the link.  We need to do this now, so that we can
3980      notice when the backend linker tries to report multiple
3981      definition errors for symbols which are in sections we aren't
3982      going to link.  FIXME: It might be better to entirely ignore
3983      symbols which are defined in sections which are going to be
3984      discarded.  This would require modifying the backend linker for
3985      each backend which might set the SEC_LINK_ONCE flag.  If we do
3986      this, we should probably handle SEC_EXCLUDE in the same way.  */
3987
3988   bfd_map_over_sections (entry->the_bfd, section_already_linked, entry);
3989 }
3990
3991 void
3992 lang_add_output (const char *name, int from_script)
3993 {
3994   /* Make -o on command line override OUTPUT in script.  */
3995   if (!had_output_filename || !from_script)
3996     {
3997       output_filename = name;
3998       had_output_filename = TRUE;
3999     }
4000 }
4001
4002 static lang_output_section_statement_type *current_section;
4003
4004 static int
4005 topower (int x)
4006 {
4007   unsigned int i = 1;
4008   int l;
4009
4010   if (x < 0)
4011     return -1;
4012
4013   for (l = 0; l < 32; l++)
4014     {
4015       if (i >= (unsigned int) x)
4016         return l;
4017       i <<= 1;
4018     }
4019
4020   return 0;
4021 }
4022
4023 lang_output_section_statement_type *
4024 lang_enter_output_section_statement (const char *output_section_statement_name,
4025                                      etree_type *address_exp,
4026                                      enum section_type sectype,
4027                                      etree_type *align,
4028                                      etree_type *subalign,
4029                                      etree_type *ebase)
4030 {
4031   lang_output_section_statement_type *os;
4032
4033   current_section =
4034    os =
4035     lang_output_section_statement_lookup (output_section_statement_name);
4036
4037   /* Add this statement to tree.  */
4038 #if 0
4039   add_statement (lang_output_section_statement_enum,
4040                  output_section_statement);
4041 #endif
4042   /* Make next things chain into subchain of this.  */
4043
4044   if (os->addr_tree == NULL)
4045     {
4046       os->addr_tree = address_exp;
4047     }
4048   os->sectype = sectype;
4049   if (sectype != noload_section)
4050     os->flags = SEC_NO_FLAGS;
4051   else
4052     os->flags = SEC_NEVER_LOAD;
4053   os->block_value = 1;
4054   stat_ptr = &os->children;
4055
4056   os->subsection_alignment =
4057     topower (exp_get_value_int (subalign, -1, "subsection alignment", 0));
4058   os->section_alignment =
4059     topower (exp_get_value_int (align, -1, "section alignment", 0));
4060
4061   os->load_base = ebase;
4062   return os;
4063 }
4064
4065 void
4066 lang_final (void)
4067 {
4068   lang_output_statement_type *new =
4069     new_stat (lang_output_statement, stat_ptr);
4070
4071   new->name = output_filename;
4072 }
4073
4074 /* Reset the current counters in the regions.  */
4075
4076 void
4077 lang_reset_memory_regions (void)
4078 {
4079   lang_memory_region_type *p = lang_memory_region_list;
4080   asection *o;
4081
4082   for (p = lang_memory_region_list; p != NULL; p = p->next)
4083     {
4084       p->old_length = (bfd_size_type) (p->current - p->origin);
4085       p->current = p->origin;
4086     }
4087
4088   for (o = output_bfd->sections; o != NULL; o = o->next)
4089     o->_raw_size = 0;
4090 }
4091
4092 /* If the wild pattern was marked KEEP, the member sections
4093    should be as well.  */
4094
4095 static void
4096 gc_section_callback (lang_wild_statement_type *ptr,
4097                      struct wildcard_list *sec ATTRIBUTE_UNUSED,
4098                      asection *section,
4099                      lang_input_statement_type *file ATTRIBUTE_UNUSED,
4100                      void *data ATTRIBUTE_UNUSED)
4101 {
4102   if (ptr->keep_sections)
4103     section->flags |= SEC_KEEP;
4104 }
4105
4106 /* Handle a wild statement, marking it against GC.  */
4107
4108 static void
4109 lang_gc_wild (lang_wild_statement_type *s)
4110 {
4111   walk_wild (s, gc_section_callback, NULL);
4112 }
4113
4114 /* Iterate over sections marking them against GC.  */
4115
4116 static void
4117 lang_gc_sections_1 (lang_statement_union_type *s)
4118 {
4119   for (; s != NULL; s = s->header.next)
4120     {
4121       switch (s->header.type)
4122         {
4123         case lang_wild_statement_enum:
4124           lang_gc_wild (&s->wild_statement);
4125           break;
4126         case lang_constructors_statement_enum:
4127           lang_gc_sections_1 (constructor_list.head);
4128           break;
4129         case lang_output_section_statement_enum:
4130           lang_gc_sections_1 (s->output_section_statement.children.head);
4131           break;
4132         case lang_group_statement_enum:
4133           lang_gc_sections_1 (s->group_statement.children.head);
4134           break;
4135         default:
4136           break;
4137         }
4138     }
4139 }
4140
4141 static void
4142 lang_gc_sections (void)
4143 {
4144   struct bfd_link_hash_entry *h;
4145   ldlang_undef_chain_list_type *ulist;
4146
4147   /* Keep all sections so marked in the link script.  */
4148
4149   lang_gc_sections_1 (statement_list.head);
4150
4151   /* Keep all sections containing symbols undefined on the command-line,
4152      and the section containing the entry symbol.  */
4153
4154   for (ulist = link_info.gc_sym_list; ulist; ulist = ulist->next)
4155     {
4156       h = bfd_link_hash_lookup (link_info.hash, ulist->name,
4157                                 FALSE, FALSE, FALSE);
4158
4159       if (h != NULL
4160           && (h->type == bfd_link_hash_defined
4161               || h->type == bfd_link_hash_defweak)
4162           && ! bfd_is_abs_section (h->u.def.section))
4163         {
4164           h->u.def.section->flags |= SEC_KEEP;
4165         }
4166     }
4167
4168   bfd_gc_sections (output_bfd, &link_info);
4169 }
4170
4171 void
4172 lang_process (void)
4173 {
4174   lang_reasonable_defaults ();
4175   current_target = default_target;
4176
4177   /* Open the output file.  */
4178   lang_for_each_statement (ldlang_open_output);
4179   init_opb ();
4180
4181   ldemul_create_output_section_statements ();
4182
4183   /* Add to the hash table all undefineds on the command line.  */
4184   lang_place_undefineds ();
4185
4186   already_linked_table_init ();
4187
4188   /* Create a bfd for each input file.  */
4189   current_target = default_target;
4190   open_input_bfds (statement_list.head, FALSE);
4191
4192   link_info.gc_sym_list = &entry_symbol;
4193   if (entry_symbol.name == NULL)
4194     link_info.gc_sym_list = ldlang_undef_chain_list_head;
4195
4196   ldemul_after_open ();
4197
4198   already_linked_table_free ();
4199
4200   /* Make sure that we're not mixing architectures.  We call this
4201      after all the input files have been opened, but before we do any
4202      other processing, so that any operations merge_private_bfd_data
4203      does on the output file will be known during the rest of the
4204      link.  */
4205   lang_check ();
4206
4207   /* Handle .exports instead of a version script if we're told to do so.  */
4208   if (command_line.version_exports_section)
4209     lang_do_version_exports_section ();
4210
4211   /* Build all sets based on the information gathered from the input
4212      files.  */
4213   ldctor_build_sets ();
4214
4215   /* Remove unreferenced sections if asked to.  */
4216   if (command_line.gc_sections)
4217     lang_gc_sections ();
4218
4219   /* If there were any SEC_MERGE sections, finish their merging, so that
4220      section sizes can be computed.  This has to be done after GC of sections,
4221      so that GCed sections are not merged, but before assigning output
4222      sections, since removing whole input sections is hard then.  */
4223   bfd_merge_sections (output_bfd, &link_info);
4224
4225   /* Size up the common data.  */
4226   lang_common ();
4227
4228   /* Run through the contours of the script and attach input sections
4229      to the correct output sections.  */
4230   map_input_to_output_sections (statement_list.head, NULL, NULL);
4231
4232   /* Find any sections not attached explicitly and handle them.  */
4233   lang_place_orphans ();
4234
4235   if (! link_info.relocatable)
4236     {
4237       /* Look for a text section and set the readonly attribute in it.  */
4238       asection *found = bfd_get_section_by_name (output_bfd, ".text");
4239
4240       if (found != NULL)
4241         {
4242           if (config.text_read_only)
4243             found->flags |= SEC_READONLY;
4244           else
4245             found->flags &= ~SEC_READONLY;
4246         }
4247     }
4248
4249   /* Do anything special before sizing sections.  This is where ELF
4250      and other back-ends size dynamic sections.  */
4251   ldemul_before_allocation ();
4252
4253   if (!link_info.relocatable)
4254     strip_excluded_output_sections ();
4255
4256   /* We must record the program headers before we try to fix the
4257      section positions, since they will affect SIZEOF_HEADERS.  */
4258   lang_record_phdrs ();
4259
4260   /* Size up the sections.  */
4261   lang_size_sections (statement_list.head, abs_output_section,
4262                       &statement_list.head, 0, 0, NULL,
4263                       command_line.relax ? FALSE : TRUE);
4264
4265   /* Now run around and relax if we can.  */
4266   if (command_line.relax)
4267     {
4268       /* Keep relaxing until bfd_relax_section gives up.  */
4269       bfd_boolean relax_again;
4270
4271       do
4272         {
4273           relax_again = FALSE;
4274
4275           /* Note: pe-dll.c does something like this also.  If you find
4276              you need to change this code, you probably need to change
4277              pe-dll.c also.  DJ  */
4278
4279           /* Do all the assignments with our current guesses as to
4280              section sizes.  */
4281           lang_do_assignments (statement_list.head, abs_output_section,
4282                                NULL, 0);
4283
4284           /* We must do this after lang_do_assignments, because it uses
4285              _raw_size.  */
4286           lang_reset_memory_regions ();
4287
4288           /* Perform another relax pass - this time we know where the
4289              globals are, so can make a better guess.  */
4290           lang_size_sections (statement_list.head, abs_output_section,
4291                               &statement_list.head, 0, 0, &relax_again, FALSE);
4292
4293           /* If the normal relax is done and the relax finalize pass
4294              is not performed yet, we perform another relax pass.  */
4295           if (!relax_again && link_info.need_relax_finalize)
4296             {
4297               link_info.need_relax_finalize = FALSE;
4298               relax_again = TRUE;
4299             }
4300         }
4301       while (relax_again);
4302
4303       /* Final extra sizing to report errors.  */
4304       lang_do_assignments (statement_list.head, abs_output_section, NULL, 0);
4305       lang_reset_memory_regions ();
4306       lang_size_sections (statement_list.head, abs_output_section,
4307                           &statement_list.head, 0, 0, NULL, TRUE);
4308     }
4309
4310   /* See if anything special should be done now we know how big
4311      everything is.  */
4312   ldemul_after_allocation ();
4313
4314   /* Fix any .startof. or .sizeof. symbols.  */
4315   lang_set_startof ();
4316
4317   /* Do all the assignments, now that we know the final resting places
4318      of all the symbols.  */
4319
4320   lang_do_assignments (statement_list.head, abs_output_section, NULL, 0);
4321
4322   /* Make sure that the section addresses make sense.  */
4323   if (! link_info.relocatable
4324       && command_line.check_section_addresses)
4325     lang_check_section_addresses ();
4326
4327   /* Final stuffs.  */
4328
4329   ldemul_finish ();
4330   lang_finish ();
4331 }
4332
4333 /* EXPORTED TO YACC */
4334
4335 void
4336 lang_add_wild (struct wildcard_spec *filespec,
4337                struct wildcard_list *section_list,
4338                bfd_boolean keep_sections)
4339 {
4340   struct wildcard_list *curr, *next;
4341   lang_wild_statement_type *new;
4342
4343   /* Reverse the list as the parser puts it back to front.  */
4344   for (curr = section_list, section_list = NULL;
4345        curr != NULL;
4346        section_list = curr, curr = next)
4347     {
4348       if (curr->spec.name != NULL && strcmp (curr->spec.name, "COMMON") == 0)
4349         placed_commons = TRUE;
4350
4351       next = curr->next;
4352       curr->next = section_list;
4353     }
4354
4355   if (filespec != NULL && filespec->name != NULL)
4356     {
4357       if (strcmp (filespec->name, "*") == 0)
4358         filespec->name = NULL;
4359       else if (! wildcardp (filespec->name))
4360         lang_has_input_file = TRUE;
4361     }
4362
4363   new = new_stat (lang_wild_statement, stat_ptr);
4364   new->filename = NULL;
4365   new->filenames_sorted = FALSE;
4366   if (filespec != NULL)
4367     {
4368       new->filename = filespec->name;
4369       new->filenames_sorted = filespec->sorted;
4370     }
4371   new->section_list = section_list;
4372   new->keep_sections = keep_sections;
4373   lang_list_init (&new->children);
4374 }
4375
4376 void
4377 lang_section_start (const char *name, etree_type *address)
4378 {
4379   lang_address_statement_type *ad;
4380
4381   ad = new_stat (lang_address_statement, stat_ptr);
4382   ad->section_name = name;
4383   ad->address = address;
4384 }
4385
4386 /* Set the start symbol to NAME.  CMDLINE is nonzero if this is called
4387    because of a -e argument on the command line, or zero if this is
4388    called by ENTRY in a linker script.  Command line arguments take
4389    precedence.  */
4390
4391 void
4392 lang_add_entry (const char *name, bfd_boolean cmdline)
4393 {
4394   if (entry_symbol.name == NULL
4395       || cmdline
4396       || ! entry_from_cmdline)
4397     {
4398       entry_symbol.name = name;
4399       entry_from_cmdline = cmdline;
4400     }
4401 }
4402
4403 void
4404 lang_add_target (const char *name)
4405 {
4406   lang_target_statement_type *new = new_stat (lang_target_statement,
4407                                               stat_ptr);
4408
4409   new->target = name;
4410
4411 }
4412
4413 void
4414 lang_add_map (const char *name)
4415 {
4416   while (*name)
4417     {
4418       switch (*name)
4419         {
4420         case 'F':
4421           map_option_f = TRUE;
4422           break;
4423         }
4424       name++;
4425     }
4426 }
4427
4428 void
4429 lang_add_fill (fill_type *fill)
4430 {
4431   lang_fill_statement_type *new = new_stat (lang_fill_statement,
4432                                             stat_ptr);
4433
4434   new->fill = fill;
4435 }
4436
4437 void
4438 lang_add_data (int type, union etree_union *exp)
4439 {
4440
4441   lang_data_statement_type *new = new_stat (lang_data_statement,
4442                                             stat_ptr);
4443
4444   new->exp = exp;
4445   new->type = type;
4446
4447 }
4448
4449 /* Create a new reloc statement.  RELOC is the BFD relocation type to
4450    generate.  HOWTO is the corresponding howto structure (we could
4451    look this up, but the caller has already done so).  SECTION is the
4452    section to generate a reloc against, or NAME is the name of the
4453    symbol to generate a reloc against.  Exactly one of SECTION and
4454    NAME must be NULL.  ADDEND is an expression for the addend.  */
4455
4456 void
4457 lang_add_reloc (bfd_reloc_code_real_type reloc,
4458                 reloc_howto_type *howto,
4459                 asection *section,
4460                 const char *name,
4461                 union etree_union *addend)
4462 {
4463   lang_reloc_statement_type *p = new_stat (lang_reloc_statement, stat_ptr);
4464
4465   p->reloc = reloc;
4466   p->howto = howto;
4467   p->section = section;
4468   p->name = name;
4469   p->addend_exp = addend;
4470
4471   p->addend_value = 0;
4472   p->output_section = NULL;
4473   p->output_vma = 0;
4474 }
4475
4476 lang_assignment_statement_type *
4477 lang_add_assignment (etree_type *exp)
4478 {
4479   lang_assignment_statement_type *new = new_stat (lang_assignment_statement,
4480                                                   stat_ptr);
4481
4482   new->exp = exp;
4483   return new;
4484 }
4485
4486 void
4487 lang_add_attribute (enum statement_enum attribute)
4488 {
4489   new_statement (attribute, sizeof (lang_statement_union_type), stat_ptr);
4490 }
4491
4492 void
4493 lang_startup (const char *name)
4494 {
4495   if (startup_file != NULL)
4496     {
4497       einfo (_("%P%Fmultiple STARTUP files\n"));
4498     }
4499   first_file->filename = name;
4500   first_file->local_sym_name = name;
4501   first_file->real = TRUE;
4502
4503   startup_file = name;
4504 }
4505
4506 void
4507 lang_float (bfd_boolean maybe)
4508 {
4509   lang_float_flag = maybe;
4510 }
4511
4512
4513 /* Work out the load- and run-time regions from a script statement, and
4514    store them in *LMA_REGION and *REGION respectively.
4515
4516    MEMSPEC is the name of the run-time region, or the value of
4517    DEFAULT_MEMORY_REGION if the statement didn't specify one.
4518    LMA_MEMSPEC is the name of the load-time region, or null if the
4519    statement didn't specify one.HAVE_LMA_P is TRUE if the statement
4520    had an explicit load address.
4521
4522    It is an error to specify both a load region and a load address.  */
4523
4524 static void
4525 lang_get_regions (lang_memory_region_type **region,
4526                   lang_memory_region_type **lma_region,
4527                   const char *memspec,
4528                   const char *lma_memspec,
4529                   bfd_boolean have_lma,
4530                   bfd_boolean have_vma)
4531 {
4532   *lma_region = lang_memory_region_lookup (lma_memspec, FALSE);
4533
4534   /* If no runtime region or VMA has been specified, but the load region has
4535      been specified, then use the load region for the runtime region as well.  */
4536   if (lma_memspec != NULL
4537       && ! have_vma
4538       && strcmp (memspec, DEFAULT_MEMORY_REGION) == 0)
4539     *region = *lma_region;
4540   else
4541     *region = lang_memory_region_lookup (memspec, FALSE);
4542
4543   if (have_lma && lma_memspec != 0)
4544     einfo (_("%X%P:%S: section has both a load address and a load region\n"));
4545 }
4546
4547 void
4548 lang_leave_output_section_statement (fill_type *fill, const char *memspec,
4549                                      lang_output_section_phdr_list *phdrs,
4550                                      const char *lma_memspec)
4551 {
4552   lang_get_regions (&current_section->region,
4553                     &current_section->lma_region,
4554                     memspec, lma_memspec,
4555                     current_section->load_base != NULL,
4556                     current_section->addr_tree != NULL);
4557   current_section->fill = fill;
4558   current_section->phdrs = phdrs;
4559   stat_ptr = &statement_list;
4560 }
4561
4562 /* Create an absolute symbol with the given name with the value of the
4563    address of first byte of the section named.
4564
4565    If the symbol already exists, then do nothing.  */
4566
4567 void
4568 lang_abs_symbol_at_beginning_of (const char *secname, const char *name)
4569 {
4570   struct bfd_link_hash_entry *h;
4571
4572   h = bfd_link_hash_lookup (link_info.hash, name, TRUE, TRUE, TRUE);
4573   if (h == NULL)
4574     einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
4575
4576   if (h->type == bfd_link_hash_new
4577       || h->type == bfd_link_hash_undefined)
4578     {
4579       asection *sec;
4580
4581       h->type = bfd_link_hash_defined;
4582
4583       sec = bfd_get_section_by_name (output_bfd, secname);
4584       if (sec == NULL)
4585         h->u.def.value = 0;
4586       else
4587         h->u.def.value = bfd_get_section_vma (output_bfd, sec);
4588
4589       h->u.def.section = bfd_abs_section_ptr;
4590     }
4591 }
4592
4593 /* Create an absolute symbol with the given name with the value of the
4594    address of the first byte after the end of the section named.
4595
4596    If the symbol already exists, then do nothing.  */
4597
4598 void
4599 lang_abs_symbol_at_end_of (const char *secname, const char *name)
4600 {
4601   struct bfd_link_hash_entry *h;
4602
4603   h = bfd_link_hash_lookup (link_info.hash, name, TRUE, TRUE, TRUE);
4604   if (h == NULL)
4605     einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
4606
4607   if (h->type == bfd_link_hash_new
4608       || h->type == bfd_link_hash_undefined)
4609     {
4610       asection *sec;
4611
4612       h->type = bfd_link_hash_defined;
4613
4614       sec = bfd_get_section_by_name (output_bfd, secname);
4615       if (sec == NULL)
4616         h->u.def.value = 0;
4617       else
4618         h->u.def.value = (bfd_get_section_vma (output_bfd, sec)
4619                           + TO_ADDR (bfd_section_size (output_bfd, sec)));
4620
4621       h->u.def.section = bfd_abs_section_ptr;
4622     }
4623 }
4624
4625 void
4626 lang_statement_append (lang_statement_list_type *list,
4627                        lang_statement_union_type *element,
4628                        lang_statement_union_type **field)
4629 {
4630   *(list->tail) = element;
4631   list->tail = field;
4632 }
4633
4634 /* Set the output format type.  -oformat overrides scripts.  */
4635
4636 void
4637 lang_add_output_format (const char *format,
4638                         const char *big,
4639                         const char *little,
4640                         int from_script)
4641 {
4642   if (output_target == NULL || !from_script)
4643     {
4644       if (command_line.endian == ENDIAN_BIG
4645           && big != NULL)
4646         format = big;
4647       else if (command_line.endian == ENDIAN_LITTLE
4648                && little != NULL)
4649         format = little;
4650
4651       output_target = format;
4652     }
4653 }
4654
4655 /* Enter a group.  This creates a new lang_group_statement, and sets
4656    stat_ptr to build new statements within the group.  */
4657
4658 void
4659 lang_enter_group (void)
4660 {
4661   lang_group_statement_type *g;
4662
4663   g = new_stat (lang_group_statement, stat_ptr);
4664   lang_list_init (&g->children);
4665   stat_ptr = &g->children;
4666 }
4667
4668 /* Leave a group.  This just resets stat_ptr to start writing to the
4669    regular list of statements again.  Note that this will not work if
4670    groups can occur inside anything else which can adjust stat_ptr,
4671    but currently they can't.  */
4672
4673 void
4674 lang_leave_group (void)
4675 {
4676   stat_ptr = &statement_list;
4677 }
4678
4679 /* Add a new program header.  This is called for each entry in a PHDRS
4680    command in a linker script.  */
4681
4682 void
4683 lang_new_phdr (const char *name,
4684                etree_type *type,
4685                bfd_boolean filehdr,
4686                bfd_boolean phdrs,
4687                etree_type *at,
4688                etree_type *flags)
4689 {
4690   struct lang_phdr *n, **pp;
4691
4692   n = stat_alloc (sizeof (struct lang_phdr));
4693   n->next = NULL;
4694   n->name = name;
4695   n->type = exp_get_value_int (type, 0, "program header type",
4696                                lang_final_phase_enum);
4697   n->filehdr = filehdr;
4698   n->phdrs = phdrs;
4699   n->at = at;
4700   n->flags = flags;
4701
4702   for (pp = &lang_phdr_list; *pp != NULL; pp = &(*pp)->next)
4703     ;
4704   *pp = n;
4705 }
4706
4707 /* Record the program header information in the output BFD.  FIXME: We
4708    should not be calling an ELF specific function here.  */
4709
4710 static void
4711 lang_record_phdrs (void)
4712 {
4713   unsigned int alc;
4714   asection **secs;
4715   lang_output_section_phdr_list *last;
4716   struct lang_phdr *l;
4717   lang_statement_union_type *u;
4718
4719   alc = 10;
4720   secs = xmalloc (alc * sizeof (asection *));
4721   last = NULL;
4722   for (l = lang_phdr_list; l != NULL; l = l->next)
4723     {
4724       unsigned int c;
4725       flagword flags;
4726       bfd_vma at;
4727
4728       c = 0;
4729       for (u = lang_output_section_statement.head;
4730            u != NULL;
4731            u = u->output_section_statement.next)
4732         {
4733           lang_output_section_statement_type *os;
4734           lang_output_section_phdr_list *pl;
4735
4736           os = &u->output_section_statement;
4737
4738           pl = os->phdrs;
4739           if (pl != NULL)
4740             last = pl;
4741           else
4742             {
4743               if (os->sectype == noload_section
4744                   || os->bfd_section == NULL
4745                   || (os->bfd_section->flags & SEC_ALLOC) == 0)
4746                 continue;
4747               pl = last;
4748             }
4749
4750           if (os->bfd_section == NULL)
4751             continue;
4752
4753           for (; pl != NULL; pl = pl->next)
4754             {
4755               if (strcmp (pl->name, l->name) == 0)
4756                 {
4757                   if (c >= alc)
4758                     {
4759                       alc *= 2;
4760                       secs = xrealloc (secs, alc * sizeof (asection *));
4761                     }
4762                   secs[c] = os->bfd_section;
4763                   ++c;
4764                   pl->used = TRUE;
4765                 }
4766             }
4767         }
4768
4769       if (l->flags == NULL)
4770         flags = 0;
4771       else
4772         flags = exp_get_vma (l->flags, 0, "phdr flags",
4773                              lang_final_phase_enum);
4774
4775       if (l->at == NULL)
4776         at = 0;
4777       else
4778         at = exp_get_vma (l->at, 0, "phdr load address",
4779                           lang_final_phase_enum);
4780
4781       if (! bfd_record_phdr (output_bfd, l->type,
4782                              l->flags != NULL, flags, l->at != NULL,
4783                              at, l->filehdr, l->phdrs, c, secs))
4784         einfo (_("%F%P: bfd_record_phdr failed: %E\n"));
4785     }
4786
4787   free (secs);
4788
4789   /* Make sure all the phdr assignments succeeded.  */
4790   for (u = lang_output_section_statement.head;
4791        u != NULL;
4792        u = u->output_section_statement.next)
4793     {
4794       lang_output_section_phdr_list *pl;
4795
4796       if (u->output_section_statement.bfd_section == NULL)
4797         continue;
4798
4799       for (pl = u->output_section_statement.phdrs;
4800            pl != NULL;
4801            pl = pl->next)
4802         if (! pl->used && strcmp (pl->name, "NONE") != 0)
4803           einfo (_("%X%P: section `%s' assigned to non-existent phdr `%s'\n"),
4804                  u->output_section_statement.name, pl->name);
4805     }
4806 }
4807
4808 /* Record a list of sections which may not be cross referenced.  */
4809
4810 void
4811 lang_add_nocrossref (lang_nocrossref_type *l)
4812 {
4813   struct lang_nocrossrefs *n;
4814
4815   n = xmalloc (sizeof *n);
4816   n->next = nocrossref_list;
4817   n->list = l;
4818   nocrossref_list = n;
4819
4820   /* Set notice_all so that we get informed about all symbols.  */
4821   link_info.notice_all = TRUE;
4822 }
4823 \f
4824 /* Overlay handling.  We handle overlays with some static variables.  */
4825
4826 /* The overlay virtual address.  */
4827 static etree_type *overlay_vma;
4828 /* And subsection alignment.  */
4829 static etree_type *overlay_subalign;
4830
4831 /* An expression for the maximum section size seen so far.  */
4832 static etree_type *overlay_max;
4833
4834 /* A list of all the sections in this overlay.  */
4835
4836 struct overlay_list {
4837   struct overlay_list *next;
4838   lang_output_section_statement_type *os;
4839 };
4840
4841 static struct overlay_list *overlay_list;
4842
4843 /* Start handling an overlay.  */
4844
4845 void
4846 lang_enter_overlay (etree_type *vma_expr, etree_type *subalign)
4847 {
4848   /* The grammar should prevent nested overlays from occurring.  */
4849   ASSERT (overlay_vma == NULL
4850           && overlay_subalign == NULL
4851           && overlay_max == NULL);
4852
4853   overlay_vma = vma_expr;
4854   overlay_subalign = subalign;
4855 }
4856
4857 /* Start a section in an overlay.  We handle this by calling
4858    lang_enter_output_section_statement with the correct VMA.
4859    lang_leave_overlay sets up the LMA and memory regions.  */
4860
4861 void
4862 lang_enter_overlay_section (const char *name)
4863 {
4864   struct overlay_list *n;
4865   etree_type *size;
4866
4867   lang_enter_output_section_statement (name, overlay_vma, normal_section,
4868                                        0, overlay_subalign, 0);
4869
4870   /* If this is the first section, then base the VMA of future
4871      sections on this one.  This will work correctly even if `.' is
4872      used in the addresses.  */
4873   if (overlay_list == NULL)
4874     overlay_vma = exp_nameop (ADDR, name);
4875
4876   /* Remember the section.  */
4877   n = xmalloc (sizeof *n);
4878   n->os = current_section;
4879   n->next = overlay_list;
4880   overlay_list = n;
4881
4882   size = exp_nameop (SIZEOF, name);
4883
4884   /* Arrange to work out the maximum section end address.  */
4885   if (overlay_max == NULL)
4886     overlay_max = size;
4887   else
4888     overlay_max = exp_binop (MAX_K, overlay_max, size);
4889 }
4890
4891 /* Finish a section in an overlay.  There isn't any special to do
4892    here.  */
4893
4894 void
4895 lang_leave_overlay_section (fill_type *fill,
4896                             lang_output_section_phdr_list *phdrs)
4897 {
4898   const char *name;
4899   char *clean, *s2;
4900   const char *s1;
4901   char *buf;
4902
4903   name = current_section->name;
4904
4905   /* For now, assume that DEFAULT_MEMORY_REGION is the run-time memory
4906      region and that no load-time region has been specified.  It doesn't
4907      really matter what we say here, since lang_leave_overlay will
4908      override it.  */
4909   lang_leave_output_section_statement (fill, DEFAULT_MEMORY_REGION, phdrs, 0);
4910
4911   /* Define the magic symbols.  */
4912
4913   clean = xmalloc (strlen (name) + 1);
4914   s2 = clean;
4915   for (s1 = name; *s1 != '\0'; s1++)
4916     if (ISALNUM (*s1) || *s1 == '_')
4917       *s2++ = *s1;
4918   *s2 = '\0';
4919
4920   buf = xmalloc (strlen (clean) + sizeof "__load_start_");
4921   sprintf (buf, "__load_start_%s", clean);
4922   lang_add_assignment (exp_assop ('=', buf,
4923                                   exp_nameop (LOADADDR, name)));
4924
4925   buf = xmalloc (strlen (clean) + sizeof "__load_stop_");
4926   sprintf (buf, "__load_stop_%s", clean);
4927   lang_add_assignment (exp_assop ('=', buf,
4928                                   exp_binop ('+',
4929                                              exp_nameop (LOADADDR, name),
4930                                              exp_nameop (SIZEOF, name))));
4931
4932   free (clean);
4933 }
4934
4935 /* Finish an overlay.  If there are any overlay wide settings, this
4936    looks through all the sections in the overlay and sets them.  */
4937
4938 void
4939 lang_leave_overlay (etree_type *lma_expr,
4940                     int nocrossrefs,
4941                     fill_type *fill,
4942                     const char *memspec,
4943                     lang_output_section_phdr_list *phdrs,
4944                     const char *lma_memspec)
4945 {
4946   lang_memory_region_type *region;
4947   lang_memory_region_type *lma_region;
4948   struct overlay_list *l;
4949   lang_nocrossref_type *nocrossref;
4950
4951   lang_get_regions (&region, &lma_region,
4952                     memspec, lma_memspec,
4953                     lma_expr != NULL, FALSE);
4954
4955   nocrossref = NULL;
4956
4957   /* After setting the size of the last section, set '.' to end of the
4958      overlay region.  */
4959   if (overlay_list != NULL)
4960     overlay_list->os->update_dot_tree
4961       = exp_assop ('=', ".", exp_binop ('+', overlay_vma, overlay_max));
4962
4963   l = overlay_list;
4964   while (l != NULL)
4965     {
4966       struct overlay_list *next;
4967
4968       if (fill != NULL && l->os->fill == NULL)
4969         l->os->fill = fill;
4970
4971       l->os->region = region;
4972       l->os->lma_region = lma_region;
4973
4974       /* The first section has the load address specified in the
4975          OVERLAY statement.  The rest are worked out from that.
4976          The base address is not needed (and should be null) if
4977          an LMA region was specified.  */
4978       if (l->next == 0)
4979         l->os->load_base = lma_expr;
4980       else if (lma_region == 0)
4981         l->os->load_base = exp_binop ('+',
4982                                       exp_nameop (LOADADDR, l->next->os->name),
4983                                       exp_nameop (SIZEOF, l->next->os->name));
4984
4985       if (phdrs != NULL && l->os->phdrs == NULL)
4986         l->os->phdrs = phdrs;
4987
4988       if (nocrossrefs)
4989         {
4990           lang_nocrossref_type *nc;
4991
4992           nc = xmalloc (sizeof *nc);
4993           nc->name = l->os->name;
4994           nc->next = nocrossref;
4995           nocrossref = nc;
4996         }
4997
4998       next = l->next;
4999       free (l);
5000       l = next;
5001     }
5002
5003   if (nocrossref != NULL)
5004     lang_add_nocrossref (nocrossref);
5005
5006   overlay_vma = NULL;
5007   overlay_list = NULL;
5008   overlay_max = NULL;
5009 }
5010 \f
5011 /* Version handling.  This is only useful for ELF.  */
5012
5013 /* This global variable holds the version tree that we build.  */
5014
5015 struct bfd_elf_version_tree *lang_elf_version_info;
5016
5017 /* If PREV is NULL, return first version pattern matching particular symbol.
5018    If PREV is non-NULL, return first version pattern matching particular
5019    symbol after PREV (previously returned by lang_vers_match).  */
5020
5021 static struct bfd_elf_version_expr *
5022 lang_vers_match (struct bfd_elf_version_expr_head *head,
5023                  struct bfd_elf_version_expr *prev,
5024                  const char *sym)
5025 {
5026   const char *cxx_sym = sym;
5027   const char *java_sym = sym;
5028   struct bfd_elf_version_expr *expr = NULL;
5029
5030   if (head->mask & BFD_ELF_VERSION_CXX_TYPE)
5031     {
5032       cxx_sym = cplus_demangle (sym, DMGL_PARAMS | DMGL_ANSI);
5033       if (!cxx_sym)
5034         cxx_sym = sym;
5035     }
5036   if (head->mask & BFD_ELF_VERSION_JAVA_TYPE)
5037     {
5038       java_sym = cplus_demangle (sym, DMGL_JAVA);
5039       if (!java_sym)
5040         java_sym = sym;
5041     }
5042
5043   if (head->htab && (prev == NULL || prev->symbol))
5044     {
5045       struct bfd_elf_version_expr e;
5046
5047       switch (prev ? prev->mask : 0)
5048         {
5049           case 0:
5050             if (head->mask & BFD_ELF_VERSION_C_TYPE)
5051               {
5052                 e.symbol = sym;
5053                 expr = htab_find (head->htab, &e);
5054                 while (expr && strcmp (expr->symbol, sym) == 0)
5055                   if (expr->mask == BFD_ELF_VERSION_C_TYPE)
5056                     goto out_ret;
5057                 else
5058                   expr = expr->next;
5059               }
5060             /* Fallthrough */
5061           case BFD_ELF_VERSION_C_TYPE:
5062             if (head->mask & BFD_ELF_VERSION_CXX_TYPE)
5063               {
5064                 e.symbol = cxx_sym;
5065                 expr = htab_find (head->htab, &e);
5066                 while (expr && strcmp (expr->symbol, cxx_sym) == 0)
5067                   if (expr->mask == BFD_ELF_VERSION_CXX_TYPE)
5068                     goto out_ret;
5069                 else
5070                   expr = expr->next;
5071               }
5072             /* Fallthrough */
5073           case BFD_ELF_VERSION_CXX_TYPE:
5074             if (head->mask & BFD_ELF_VERSION_JAVA_TYPE)
5075               {
5076                 e.symbol = java_sym;
5077                 expr = htab_find (head->htab, &e);
5078                 while (expr && strcmp (expr->symbol, java_sym) == 0)
5079                   if (expr->mask == BFD_ELF_VERSION_JAVA_TYPE)
5080                     goto out_ret;
5081                 else
5082                   expr = expr->next;
5083               }
5084             /* Fallthrough */
5085           default:
5086             break;
5087         }
5088     }
5089
5090   /* Finally, try the wildcards.  */
5091   if (prev == NULL || prev->symbol)
5092     expr = head->remaining;
5093   else
5094     expr = prev->next;
5095   while (expr)
5096     {
5097       const char *s;
5098
5099       if (expr->pattern[0] == '*' && expr->pattern[1] == '\0')
5100         break;
5101
5102       if (expr->mask == BFD_ELF_VERSION_JAVA_TYPE)
5103         s = java_sym;
5104       else if (expr->mask == BFD_ELF_VERSION_CXX_TYPE)
5105         s = cxx_sym;
5106       else
5107         s = sym;
5108       if (fnmatch (expr->pattern, s, 0) == 0)
5109         break;
5110       expr = expr->next;
5111     }
5112
5113 out_ret:
5114   if (cxx_sym != sym)
5115     free ((char *) cxx_sym);
5116   if (java_sym != sym)
5117     free ((char *) java_sym);
5118   return expr;
5119 }
5120
5121 /* Return NULL if the PATTERN argument is a glob pattern, otherwise,
5122    return a string pointing to the symbol name.  */
5123
5124 static const char *
5125 realsymbol (const char *pattern)
5126 {
5127   const char *p;
5128   bfd_boolean changed = FALSE, backslash = FALSE;
5129   char *s, *symbol = xmalloc (strlen (pattern) + 1);
5130
5131   for (p = pattern, s = symbol; *p != '\0'; ++p)
5132     {
5133       /* It is a glob pattern only if there is no preceding
5134          backslash.  */
5135       if (! backslash && (*p == '?' || *p == '*' || *p == '['))
5136         {
5137           free (symbol);
5138           return NULL;
5139         }
5140
5141       if (backslash)
5142         {
5143           /* Remove the preceding backslash.  */
5144           *(s - 1) = *p;
5145           changed = TRUE;
5146         }
5147       else
5148         *s++ = *p;
5149
5150       backslash = *p == '\\';
5151     }
5152
5153   if (changed)
5154     {
5155       *s = '\0';
5156       return symbol;
5157     }
5158   else
5159     {
5160       free (symbol);
5161       return pattern;
5162     }
5163 }
5164
5165 /* This is called for each variable name or match expression.  */
5166
5167 struct bfd_elf_version_expr *
5168 lang_new_vers_pattern (struct bfd_elf_version_expr *orig,
5169                        const char *new,
5170                        const char *lang)
5171 {
5172   struct bfd_elf_version_expr *ret;
5173
5174   ret = xmalloc (sizeof *ret);
5175   ret->next = orig;
5176   ret->pattern = new;
5177   ret->symver = 0;
5178   ret->script = 0;
5179   ret->symbol = realsymbol (new);
5180
5181   if (lang == NULL || strcasecmp (lang, "C") == 0)
5182     ret->mask = BFD_ELF_VERSION_C_TYPE;
5183   else if (strcasecmp (lang, "C++") == 0)
5184     ret->mask = BFD_ELF_VERSION_CXX_TYPE;
5185   else if (strcasecmp (lang, "Java") == 0)
5186     ret->mask = BFD_ELF_VERSION_JAVA_TYPE;
5187   else
5188     {
5189       einfo (_("%X%P: unknown language `%s' in version information\n"),
5190              lang);
5191       ret->mask = BFD_ELF_VERSION_C_TYPE;
5192     }
5193
5194   return ldemul_new_vers_pattern (ret);
5195 }
5196
5197 /* This is called for each set of variable names and match
5198    expressions.  */
5199
5200 struct bfd_elf_version_tree *
5201 lang_new_vers_node (struct bfd_elf_version_expr *globals,
5202                     struct bfd_elf_version_expr *locals)
5203 {
5204   struct bfd_elf_version_tree *ret;
5205
5206   ret = xcalloc (1, sizeof *ret);
5207   ret->globals.list = globals;
5208   ret->locals.list = locals;
5209   ret->match = lang_vers_match;
5210   ret->name_indx = (unsigned int) -1;
5211   return ret;
5212 }
5213
5214 /* This static variable keeps track of version indices.  */
5215
5216 static int version_index;
5217
5218 static hashval_t
5219 version_expr_head_hash (const void *p)
5220 {
5221   const struct bfd_elf_version_expr *e = p;
5222
5223   return htab_hash_string (e->symbol);
5224 }
5225
5226 static int
5227 version_expr_head_eq (const void *p1, const void *p2)
5228 {
5229   const struct bfd_elf_version_expr *e1 = p1;
5230   const struct bfd_elf_version_expr *e2 = p2;
5231
5232   return strcmp (e1->symbol, e2->symbol) == 0;
5233 }
5234
5235 static void
5236 lang_finalize_version_expr_head (struct bfd_elf_version_expr_head *head)
5237 {
5238   size_t count = 0;
5239   struct bfd_elf_version_expr *e, *next;
5240   struct bfd_elf_version_expr **list_loc, **remaining_loc;
5241
5242   for (e = head->list; e; e = e->next)
5243     {
5244       if (e->symbol)
5245         count++;
5246       head->mask |= e->mask;
5247     }
5248
5249   if (count)
5250     {
5251       head->htab = htab_create (count * 2, version_expr_head_hash,
5252                                 version_expr_head_eq, NULL);
5253       list_loc = &head->list;
5254       remaining_loc = &head->remaining;
5255       for (e = head->list; e; e = next)
5256         {
5257           next = e->next;
5258           if (!e->symbol)
5259             {
5260               *remaining_loc = e;
5261               remaining_loc = &e->next;
5262             }
5263           else
5264             {
5265               void **loc = htab_find_slot (head->htab, e, INSERT);
5266
5267               if (*loc)
5268                 {
5269                   struct bfd_elf_version_expr *e1, *last;
5270
5271                   e1 = *loc;
5272                   last = NULL;
5273                   do
5274                     {
5275                       if (e1->mask == e->mask)
5276                         {
5277                           last = NULL;
5278                           break;
5279                         }
5280                       last = e1;
5281                       e1 = e1->next;
5282                     }
5283                   while (e1 && strcmp (e1->symbol, e->symbol) == 0);
5284
5285                   if (last == NULL)
5286                     {
5287                       /* This is a duplicate.  */
5288                       /* FIXME: Memory leak.  Sometimes pattern is not
5289                          xmalloced alone, but in larger chunk of memory.  */
5290                       /* free (e->symbol); */
5291                       free (e);
5292                     }
5293                   else
5294                     {
5295                       e->next = last->next;
5296                       last->next = e;
5297                     }
5298                 }
5299               else
5300                 {
5301                   *loc = e;
5302                   *list_loc = e;
5303                   list_loc = &e->next;
5304                 }
5305             }
5306         }
5307       *remaining_loc = NULL;
5308       *list_loc = head->remaining;
5309     }
5310   else
5311     head->remaining = head->list;
5312 }
5313
5314 /* This is called when we know the name and dependencies of the
5315    version.  */
5316
5317 void
5318 lang_register_vers_node (const char *name,
5319                          struct bfd_elf_version_tree *version,
5320                          struct bfd_elf_version_deps *deps)
5321 {
5322   struct bfd_elf_version_tree *t, **pp;
5323   struct bfd_elf_version_expr *e1;
5324
5325   if (name == NULL)
5326     name = "";
5327
5328   if ((name[0] == '\0' && lang_elf_version_info != NULL)
5329       || (lang_elf_version_info && lang_elf_version_info->name[0] == '\0'))
5330     {
5331       einfo (_("%X%P: anonymous version tag cannot be combined with other version tags\n"));
5332       free (version);
5333       return;
5334     }
5335
5336   /* Make sure this node has a unique name.  */
5337   for (t = lang_elf_version_info; t != NULL; t = t->next)
5338     if (strcmp (t->name, name) == 0)
5339       einfo (_("%X%P: duplicate version tag `%s'\n"), name);
5340
5341   lang_finalize_version_expr_head (&version->globals);
5342   lang_finalize_version_expr_head (&version->locals);
5343
5344   /* Check the global and local match names, and make sure there
5345      aren't any duplicates.  */
5346
5347   for (e1 = version->globals.list; e1 != NULL; e1 = e1->next)
5348     {
5349       for (t = lang_elf_version_info; t != NULL; t = t->next)
5350         {
5351           struct bfd_elf_version_expr *e2;
5352
5353           if (t->locals.htab && e1->symbol)
5354             {
5355               e2 = htab_find (t->locals.htab, e1);
5356               while (e2 && strcmp (e1->symbol, e2->symbol) == 0)
5357                 {
5358                   if (e1->mask == e2->mask)
5359                     einfo (_("%X%P: duplicate expression `%s' in version information\n"),
5360                            e1->symbol);
5361                   e2 = e2->next;
5362                 }
5363             }
5364           else if (!e1->symbol)
5365             for (e2 = t->locals.remaining; e2 != NULL; e2 = e2->next)
5366               if (strcmp (e1->pattern, e2->pattern) == 0 && e1->mask == e2->mask)
5367                 einfo (_("%X%P: duplicate expression `%s' in version information\n"),
5368                        e1->pattern);
5369         }
5370     }
5371
5372   for (e1 = version->locals.list; e1 != NULL; e1 = e1->next)
5373     {
5374       for (t = lang_elf_version_info; t != NULL; t = t->next)
5375         {
5376           struct bfd_elf_version_expr *e2;
5377
5378           if (t->globals.htab && e1->symbol)
5379             {
5380               e2 = htab_find (t->globals.htab, e1);
5381               while (e2 && strcmp (e1->symbol, e2->symbol) == 0)
5382                 {
5383                   if (e1->mask == e2->mask)
5384                     einfo (_("%X%P: duplicate expression `%s' in version information\n"),
5385                            e1->symbol);
5386                   e2 = e2->next;
5387                 }
5388             }
5389           else if (!e1->symbol)
5390             for (e2 = t->globals.remaining; e2 != NULL; e2 = e2->next)
5391               if (strcmp (e1->pattern, e2->pattern) == 0 && e1->mask == e2->mask)
5392                 einfo (_("%X%P: duplicate expression `%s' in version information\n"),
5393                        e1->pattern);
5394         }
5395     }
5396
5397   version->deps = deps;
5398   version->name = name;
5399   if (name[0] != '\0')
5400     {
5401       ++version_index;
5402       version->vernum = version_index;
5403     }
5404   else
5405     version->vernum = 0;
5406
5407   for (pp = &lang_elf_version_info; *pp != NULL; pp = &(*pp)->next)
5408     ;
5409   *pp = version;
5410 }
5411
5412 /* This is called when we see a version dependency.  */
5413
5414 struct bfd_elf_version_deps *
5415 lang_add_vers_depend (struct bfd_elf_version_deps *list, const char *name)
5416 {
5417   struct bfd_elf_version_deps *ret;
5418   struct bfd_elf_version_tree *t;
5419
5420   ret = xmalloc (sizeof *ret);
5421   ret->next = list;
5422
5423   for (t = lang_elf_version_info; t != NULL; t = t->next)
5424     {
5425       if (strcmp (t->name, name) == 0)
5426         {
5427           ret->version_needed = t;
5428           return ret;
5429         }
5430     }
5431
5432   einfo (_("%X%P: unable to find version dependency `%s'\n"), name);
5433
5434   return ret;
5435 }
5436
5437 static void
5438 lang_do_version_exports_section (void)
5439 {
5440   struct bfd_elf_version_expr *greg = NULL, *lreg;
5441
5442   LANG_FOR_EACH_INPUT_STATEMENT (is)
5443     {
5444       asection *sec = bfd_get_section_by_name (is->the_bfd, ".exports");
5445       char *contents, *p;
5446       bfd_size_type len;
5447
5448       if (sec == NULL)
5449         continue;
5450
5451       len = bfd_section_size (is->the_bfd, sec);
5452       contents = xmalloc (len);
5453       if (!bfd_get_section_contents (is->the_bfd, sec, contents, 0, len))
5454         einfo (_("%X%P: unable to read .exports section contents\n"), sec);
5455
5456       p = contents;
5457       while (p < contents + len)
5458         {
5459           greg = lang_new_vers_pattern (greg, p, NULL);
5460           p = strchr (p, '\0') + 1;
5461         }
5462
5463       /* Do not free the contents, as we used them creating the regex.  */
5464
5465       /* Do not include this section in the link.  */
5466       bfd_set_section_flags (is->the_bfd, sec,
5467         bfd_get_section_flags (is->the_bfd, sec) | SEC_EXCLUDE);
5468     }
5469
5470   lreg = lang_new_vers_pattern (NULL, "*", NULL);
5471   lang_register_vers_node (command_line.version_exports_section,
5472                            lang_new_vers_node (greg, lreg), NULL);
5473 }
5474
5475 void
5476 lang_add_unique (const char *name)
5477 {
5478   struct unique_sections *ent;
5479
5480   for (ent = unique_section_list; ent; ent = ent->next)
5481     if (strcmp (ent->name, name) == 0)
5482       return;
5483
5484   ent = xmalloc (sizeof *ent);
5485   ent->name = xstrdup (name);
5486   ent->next = unique_section_list;
5487   unique_section_list = ent;
5488 }