ld/ldlang.c

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