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