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     }
2576   minfo (")");
2577
2578   print_nl ();
2579
2580   print_statement_list (w->children.head, os);
2581 }
2582
2583 /* Print a group statement.  */
2584
2585 static void
2586 print_group (s, os)
2587      lang_group_statement_type *s;
2588      lang_output_section_statement_type *os;
2589 {
2590   fprintf (config.map_file, "START GROUP\n");
2591   print_statement_list (s->children.head, os);
2592   fprintf (config.map_file, "END GROUP\n");
2593 }
2594
2595 /* Print the list of statements in S.
2596    This can be called for any statement type.  */
2597
2598 static void
2599 print_statement_list (s, os)
2600      lang_statement_union_type *s;
2601      lang_output_section_statement_type *os;
2602 {
2603   while (s != NULL)
2604     {
2605       print_statement (s, os);
2606       s = s->header.next;
2607     }
2608 }
2609
2610 /* Print the first statement in statement list S.
2611    This can be called for any statement type.  */
2612
2613 static void
2614 print_statement (s, os)
2615      lang_statement_union_type *s;
2616      lang_output_section_statement_type *os;
2617 {
2618   switch (s->header.type)
2619     {
2620     default:
2621       fprintf (config.map_file, _("Fail with %d\n"), s->header.type);
2622       FAIL ();
2623       break;
2624     case lang_constructors_statement_enum:
2625       if (constructor_list.head != NULL)
2626         {
2627           if (constructors_sorted)
2628             minfo (" SORT (CONSTRUCTORS)\n");
2629           else
2630             minfo (" CONSTRUCTORS\n");
2631           print_statement_list (constructor_list.head, os);
2632         }
2633       break;
2634     case lang_wild_statement_enum:
2635       print_wild_statement (&s->wild_statement, os);
2636       break;
2637     case lang_address_statement_enum:
2638       print_address_statement (&s->address_statement);
2639       break;
2640     case lang_object_symbols_statement_enum:
2641       minfo (" CREATE_OBJECT_SYMBOLS\n");
2642       break;
2643     case lang_fill_statement_enum:
2644       print_fill_statement (&s->fill_statement);
2645       break;
2646     case lang_data_statement_enum:
2647       print_data_statement (&s->data_statement);
2648       break;
2649     case lang_reloc_statement_enum:
2650       print_reloc_statement (&s->reloc_statement);
2651       break;
2652     case lang_input_section_enum:
2653       print_input_section (&s->input_section);
2654       break;
2655     case lang_padding_statement_enum:
2656       print_padding_statement (&s->padding_statement);
2657       break;
2658     case lang_output_section_statement_enum:
2659       print_output_section_statement (&s->output_section_statement);
2660       break;
2661     case lang_assignment_statement_enum:
2662       print_assignment (&s->assignment_statement, os);
2663       break;
2664     case lang_target_statement_enum:
2665       fprintf (config.map_file, "TARGET(%s)\n", s->target_statement.target);
2666       break;
2667     case lang_output_statement_enum:
2668       minfo ("OUTPUT(%s", s->output_statement.name);
2669       if (output_target != NULL)
2670         minfo (" %s", output_target);
2671       minfo (")\n");
2672       break;
2673     case lang_input_statement_enum:
2674       print_input_statement (&s->input_statement);
2675       break;
2676     case lang_group_statement_enum:
2677       print_group (&s->group_statement, os);
2678       break;
2679     case lang_afile_asection_pair_statement_enum:
2680       FAIL ();
2681       break;
2682     }
2683 }
2684
2685 static void
2686 print_statements ()
2687 {
2688   print_statement_list (statement_list.head, abs_output_section);
2689 }
2690
2691 /* Print the first N statements in statement list S to STDERR.
2692    If N == 0, nothing is printed.
2693    If N < 0, the entire list is printed.
2694    Intended to be called from GDB.  */
2695
2696 void
2697 dprint_statement (s, n)
2698      lang_statement_union_type *s;
2699      int n;
2700 {
2701   FILE *map_save = config.map_file;
2702
2703   config.map_file = stderr;
2704
2705   if (n < 0)
2706     print_statement_list (s, abs_output_section);
2707   else
2708     {
2709       while (s && --n >= 0)
2710         {
2711           print_statement (s, abs_output_section);
2712           s = s->header.next;
2713         }
2714     }
2715
2716   config.map_file = map_save;
2717 }
2718
2719 static void
2720 insert_pad (ptr, fill, alignment_needed, output_section, dot)
2721      lang_statement_union_type **ptr;
2722      fill_type *fill;
2723      unsigned int alignment_needed;
2724      asection *output_section;
2725      bfd_vma dot;
2726 {
2727   static fill_type zero_fill = { 1, { 0 } };
2728   lang_statement_union_type *pad;
2729
2730   pad = ((lang_statement_union_type *)
2731          ((char *) ptr - offsetof (lang_statement_union_type, header.next)));
2732   if (ptr != &statement_list.head
2733       && pad->header.type == lang_padding_statement_enum
2734       && pad->padding_statement.output_section == output_section)
2735     {
2736       /* Use the existing pad statement.  The above test on output
2737          section is probably redundant, but it doesn't hurt to check.  */
2738     }
2739   else
2740     {
2741       /* Make a new padding statement, linked into existing chain.  */
2742       pad = ((lang_statement_union_type *)
2743              stat_alloc (sizeof (lang_padding_statement_type)));
2744       pad->header.next = *ptr;
2745       *ptr = pad;
2746       pad->header.type = lang_padding_statement_enum;
2747       pad->padding_statement.output_section = output_section;
2748       if (fill == (fill_type *) 0)
2749         fill = &zero_fill;
2750       pad->padding_statement.fill = fill;
2751     }
2752   pad->padding_statement.output_offset = dot - output_section->vma;
2753   pad->padding_statement.size = alignment_needed;
2754   output_section->_raw_size += alignment_needed;
2755 }
2756
2757 /* Work out how much this section will move the dot point.  */
2758
2759 static bfd_vma
2760 size_input_section (this_ptr, output_section_statement, fill, dot)
2761      lang_statement_union_type **this_ptr;
2762      lang_output_section_statement_type *output_section_statement;
2763      fill_type *fill;
2764      bfd_vma dot;
2765 {
2766   lang_input_section_type *is = &((*this_ptr)->input_section);
2767   asection *i = is->section;
2768
2769   if (is->ifile->just_syms_flag == false)
2770     {
2771       unsigned opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
2772                                                     ldfile_output_machine);
2773       unsigned int alignment_needed;
2774       asection *o;
2775
2776       /* Align this section first to the input sections requirement,
2777          then to the output section's requirement.  If this alignment
2778          is greater than any seen before, then record it too.  Perform
2779          the alignment by inserting a magic 'padding' statement.  */
2780
2781       if (output_section_statement->subsection_alignment != -1)
2782         i->alignment_power = output_section_statement->subsection_alignment;
2783
2784       o = output_section_statement->bfd_section;
2785       if (o->alignment_power < i->alignment_power)
2786         o->alignment_power = i->alignment_power;
2787
2788       alignment_needed = align_power (dot, i->alignment_power) - dot;
2789
2790       if (alignment_needed != 0)
2791         {
2792           insert_pad (this_ptr, fill, alignment_needed * opb, o, dot);
2793           dot += alignment_needed;
2794         }
2795
2796       /* Remember where in the output section this input section goes.  */
2797
2798       i->output_offset = dot - o->vma;
2799
2800       /* Mark how big the output section must be to contain this now.  */
2801       if (i->_cooked_size != 0)
2802         dot += i->_cooked_size / opb;
2803       else
2804         dot += i->_raw_size / opb;
2805       o->_raw_size = (dot - o->vma) * opb;
2806     }
2807   else
2808     {
2809       i->output_offset = i->vma - output_section_statement->bfd_section->vma;
2810     }
2811
2812   return dot;
2813 }
2814
2815 #define IGNORE_SECTION(bfd, s) \
2816   (((bfd_get_section_flags (bfd, s) & (SEC_ALLOC | SEC_LOAD))   \
2817     != (SEC_ALLOC | SEC_LOAD))                                  \
2818    || bfd_section_size (bfd, s) == 0)
2819
2820 /* Check to see if any allocated sections overlap with other allocated
2821    sections.  This can happen when the linker script specifically specifies
2822    the output section addresses of the two sections.  */
2823
2824 static void
2825 lang_check_section_addresses ()
2826 {
2827   asection *s;
2828   unsigned opb = bfd_octets_per_byte (output_bfd);
2829
2830   /* Scan all sections in the output list.  */
2831   for (s = output_bfd->sections; s != NULL; s = s->next)
2832     {
2833       asection *os;
2834
2835       /* Ignore sections which are not loaded or which have no contents.  */
2836       if (IGNORE_SECTION (output_bfd, s))
2837         continue;
2838
2839       /* Once we reach section 's' stop our seach.  This prevents two
2840          warning messages from being produced, one for 'section A overlaps
2841          section B' and one for 'section B overlaps section A'.  */
2842       for (os = output_bfd->sections; os != s; os = os->next)
2843         {
2844           bfd_vma s_start;
2845           bfd_vma s_end;
2846           bfd_vma os_start;
2847           bfd_vma os_end;
2848
2849           /* Only consider loadable sections with real contents.  */
2850           if (IGNORE_SECTION (output_bfd, os))
2851             continue;
2852
2853           /* We must check the sections' LMA addresses not their
2854              VMA addresses because overlay sections can have
2855              overlapping VMAs but they must have distinct LMAs.  */
2856           s_start  = bfd_section_lma (output_bfd, s);
2857           os_start = bfd_section_lma (output_bfd, os);
2858           s_end    = s_start  + bfd_section_size (output_bfd, s) / opb - 1;
2859           os_end   = os_start + bfd_section_size (output_bfd, os) / opb - 1;
2860
2861           /* Look for an overlap.  */
2862           if ((s_end < os_start) || (s_start > os_end))
2863             continue;
2864
2865           einfo (
2866 _("%X%P: section %s [%V -> %V] overlaps section %s [%V -> %V]\n"),
2867                  s->name, s_start, s_end, os->name, os_start, os_end);
2868
2869           /* Once we have found one overlap for this section,
2870              stop looking for others.  */
2871           break;
2872         }
2873     }
2874 }
2875
2876 /* Make sure the new address is within the region.  We explicitly permit the
2877    current address to be at the exact end of the region when the address is
2878    non-zero, in case the region is at the end of addressable memory and the
2879    calculation wraps around.  */
2880
2881 static void
2882 os_region_check (os, region, tree, base)
2883      lang_output_section_statement_type *os;
2884      struct memory_region_struct *region;
2885      etree_type *tree;
2886      bfd_vma base;
2887 {
2888   if ((region->current < region->origin
2889        || (region->current - region->origin > region->length))
2890       && ((region->current != region->origin + region->length)
2891           || base == 0))
2892     {
2893       if (tree != (etree_type *) NULL)
2894         {
2895           einfo (_("%X%P: address 0x%v of %B section %s is not within region %s\n"),
2896                  region->current,
2897                  os->bfd_section->owner,
2898                  os->bfd_section->name,
2899                  region->name);
2900         }
2901       else
2902         {
2903           einfo (_("%X%P: region %s is full (%B section %s)\n"),
2904                  region->name,
2905                  os->bfd_section->owner,
2906                  os->bfd_section->name);
2907         }
2908       /* Reset the region pointer.  */
2909       region->current = region->origin;
2910     }
2911 }
2912
2913 /* Set the sizes for all the output sections.  */
2914
2915 static bfd_vma
2916 lang_size_sections_1 (s, output_section_statement, prev, fill, dot, relax)
2917      lang_statement_union_type *s;
2918      lang_output_section_statement_type *output_section_statement;
2919      lang_statement_union_type **prev;
2920      fill_type *fill;
2921      bfd_vma dot;
2922      boolean *relax;
2923 {
2924   unsigned opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
2925                                                 ldfile_output_machine);
2926
2927   /* Size up the sections from their constituent parts.  */
2928   for (; s != (lang_statement_union_type *) NULL; s = s->header.next)
2929     {
2930       switch (s->header.type)
2931         {
2932         case lang_output_section_statement_enum:
2933           {
2934             bfd_vma after;
2935             lang_output_section_statement_type *os;
2936
2937             os = &s->output_section_statement;
2938             if (os->bfd_section == NULL)
2939               /* This section was never actually created.  */
2940               break;
2941
2942             /* If this is a COFF shared library section, use the size and
2943                address from the input section.  FIXME: This is COFF
2944                specific; it would be cleaner if there were some other way
2945                to do this, but nothing simple comes to mind.  */
2946             if ((os->bfd_section->flags & SEC_COFF_SHARED_LIBRARY) != 0)
2947               {
2948                 asection *input;
2949
2950                 if (os->children.head == NULL
2951                     || os->children.head->header.next != NULL
2952                     || os->children.head->header.type != lang_input_section_enum)
2953                   einfo (_("%P%X: Internal error on COFF shared library section %s\n"),
2954                          os->name);
2955
2956                 input = os->children.head->input_section.section;
2957                 bfd_set_section_vma (os->bfd_section->owner,
2958                                      os->bfd_section,
2959                                      bfd_section_vma (input->owner, input));
2960                 os->bfd_section->_raw_size = input->_raw_size;
2961                 break;
2962               }
2963
2964             if (bfd_is_abs_section (os->bfd_section))
2965               {
2966                 /* No matter what happens, an abs section starts at zero.  */
2967                 ASSERT (os->bfd_section->vma == 0);
2968               }
2969             else
2970               {
2971                 if (os->addr_tree == (etree_type *) NULL)
2972                   {
2973                     /* No address specified for this section, get one
2974                        from the region specification.  */
2975                     if (os->region == (lang_memory_region_type *) NULL
2976                         || (((bfd_get_section_flags (output_bfd, os->bfd_section)
2977                               & (SEC_ALLOC | SEC_LOAD)) != 0)
2978                             && os->region->name[0] == '*'
2979                             && strcmp (os->region->name, "*default*") == 0))
2980                       {
2981                         os->region = lang_memory_default (os->bfd_section);
2982                       }
2983
2984                     /* If a loadable section is using the default memory
2985                        region, and some non default memory regions were
2986                        defined, issue a warning.  */
2987                     if ((bfd_get_section_flags (output_bfd, os->bfd_section)
2988                          & (SEC_ALLOC | SEC_LOAD)) != 0
2989                         && (bfd_get_section_flags (output_bfd, os->bfd_section)
2990                             & SEC_NEVER_LOAD) == 0
2991                         && ! link_info.relocateable
2992                         && strcmp (os->region->name, "*default*") == 0
2993                         && lang_memory_region_list != NULL
2994                         && (strcmp (lang_memory_region_list->name,
2995                                     "*default*") != 0
2996                             || lang_memory_region_list->next != NULL))
2997                       einfo (_("%P: warning: no memory region specified for section `%s'\n"),
2998                              bfd_get_section_name (output_bfd,
2999                                                    os->bfd_section));
3000
3001                     dot = os->region->current;
3002
3003                     if (os->section_alignment == -1)
3004                       {
3005                         bfd_vma olddot;
3006
3007                         olddot = dot;
3008                         dot = align_power (dot,
3009                                            os->bfd_section->alignment_power);
3010
3011                         if (dot != olddot && config.warn_section_align)
3012                           einfo (_("%P: warning: changing start of section %s by %u bytes\n"),
3013                                  os->name, (unsigned int) (dot - olddot));
3014                       }
3015                   }
3016                 else
3017                   {
3018                     etree_value_type r;
3019
3020                     r = exp_fold_tree (os->addr_tree,
3021                                        abs_output_section,
3022                                        lang_allocating_phase_enum,
3023                                        dot, &dot);
3024                     if (r.valid_p == false)
3025                       {
3026                         einfo (_("%F%S: non constant address expression for section %s\n"),
3027                                os->name);
3028                       }
3029                     dot = r.value + r.section->bfd_section->vma;
3030                   }
3031
3032                 /* The section starts here.
3033                    First, align to what the section needs.  */
3034
3035                 if (os->section_alignment != -1)
3036                   dot = align_power (dot, os->section_alignment);
3037
3038                 bfd_set_section_vma (0, os->bfd_section, dot);
3039
3040                 os->bfd_section->output_offset = 0;
3041               }
3042
3043             lang_size_sections_1 (os->children.head, os, &os->children.head,
3044                                   os->fill, dot, relax);
3045
3046             /* Put the section within the requested block size, or
3047                align at the block boundary.  */
3048             after = ALIGN_N (os->bfd_section->vma
3049                              + os->bfd_section->_raw_size / opb,
3050                              /* The coercion here is important, see ld.h.  */
3051                              (bfd_vma) os->block_value);
3052
3053             if (bfd_is_abs_section (os->bfd_section))
3054               ASSERT (after == os->bfd_section->vma);
3055             else if ((os->bfd_section->flags & SEC_HAS_CONTENTS) == 0
3056                      && (os->bfd_section->flags & SEC_THREAD_LOCAL))
3057               os->bfd_section->_raw_size = 0;
3058             else
3059               os->bfd_section->_raw_size =
3060                 (after - os->bfd_section->vma) * opb;
3061
3062             dot = os->bfd_section->vma + os->bfd_section->_raw_size / opb;
3063             os->processed = true;
3064
3065             if (os->update_dot_tree != 0)
3066               exp_fold_tree (os->update_dot_tree, abs_output_section,
3067                              lang_allocating_phase_enum, dot, &dot);
3068
3069             /* Update dot in the region ?
3070                We only do this if the section is going to be allocated,
3071                since unallocated sections do not contribute to the region's
3072                overall size in memory.
3073
3074                If the SEC_NEVER_LOAD bit is not set, it will affect the
3075                addresses of sections after it. We have to update
3076                dot.  */
3077             if (os->region != (lang_memory_region_type *) NULL
3078                 && ((bfd_get_section_flags (output_bfd, os->bfd_section)
3079                      & SEC_NEVER_LOAD) == 0
3080                     || (bfd_get_section_flags (output_bfd, os->bfd_section)
3081                         & (SEC_ALLOC | SEC_LOAD))))
3082               {
3083                 os->region->current = dot;
3084
3085                 /* Make sure the new address is within the region.  */
3086                 os_region_check (os, os->region, os->addr_tree,
3087                                  os->bfd_section->vma);
3088
3089                 /* If there's no load address specified, use the run
3090                    region as the load region.  */
3091                 if (os->lma_region == NULL && os->load_base == NULL)
3092                   os->lma_region = os->region;
3093
3094                 if (os->lma_region != NULL && os->lma_region != os->region)
3095                   {
3096                     /* Set load_base, which will be handled later.  */
3097                     os->load_base = exp_intop (os->lma_region->current);
3098                     os->lma_region->current +=
3099                       os->bfd_section->_raw_size / opb;
3100                     os_region_check (os, os->lma_region, NULL,
3101                                      os->bfd_section->lma);
3102                   }
3103               }
3104           }
3105           break;
3106
3107         case lang_constructors_statement_enum:
3108           dot = lang_size_sections_1 (constructor_list.head,
3109                                       output_section_statement,
3110                                       &s->wild_statement.children.head,
3111                                       fill, dot, relax);
3112           break;
3113
3114         case lang_data_statement_enum:
3115           {
3116             unsigned int size = 0;
3117
3118             s->data_statement.output_vma =
3119               dot - output_section_statement->bfd_section->vma;
3120             s->data_statement.output_section =
3121               output_section_statement->bfd_section;
3122
3123             switch (s->data_statement.type)
3124               {
3125               default:
3126                 abort ();
3127               case QUAD:
3128               case SQUAD:
3129                 size = QUAD_SIZE;
3130                 break;
3131               case LONG:
3132                 size = LONG_SIZE;
3133                 break;
3134               case SHORT:
3135                 size = SHORT_SIZE;
3136                 break;
3137               case BYTE:
3138                 size = BYTE_SIZE;
3139                 break;
3140               }
3141             if (size < opb)
3142               size = opb;
3143             dot += size / opb;
3144             output_section_statement->bfd_section->_raw_size += size;
3145             /* The output section gets contents, and then we inspect for
3146                any flags set in the input script which override any ALLOC.  */
3147             output_section_statement->bfd_section->flags |= SEC_HAS_CONTENTS;
3148             if (!(output_section_statement->flags & SEC_NEVER_LOAD))
3149               {
3150                 output_section_statement->bfd_section->flags |=
3151                   SEC_ALLOC | SEC_LOAD;
3152               }
3153           }
3154           break;
3155
3156         case lang_reloc_statement_enum:
3157           {
3158             int size;
3159
3160             s->reloc_statement.output_vma =
3161               dot - output_section_statement->bfd_section->vma;
3162             s->reloc_statement.output_section =
3163               output_section_statement->bfd_section;
3164             size = bfd_get_reloc_size (s->reloc_statement.howto);
3165             dot += size / opb;
3166             output_section_statement->bfd_section->_raw_size += size;
3167           }
3168           break;
3169
3170         case lang_wild_statement_enum:
3171
3172           dot = lang_size_sections_1 (s->wild_statement.children.head,
3173                                       output_section_statement,
3174                                       &s->wild_statement.children.head,
3175                                       fill, dot, relax);
3176
3177           break;
3178
3179         case lang_object_symbols_statement_enum:
3180           link_info.create_object_symbols_section =
3181             output_section_statement->bfd_section;
3182           break;
3183         case lang_output_statement_enum:
3184         case lang_target_statement_enum:
3185           break;
3186         case lang_input_section_enum:
3187           {
3188             asection *i;
3189
3190             i = (*prev)->input_section.section;
3191             if (! relax)
3192               {
3193                 if (i->_cooked_size == 0)
3194                   i->_cooked_size = i->_raw_size;
3195               }
3196             else
3197               {
3198                 boolean again;
3199
3200                 if (! bfd_relax_section (i->owner, i, &link_info, &again))
3201                   einfo (_("%P%F: can't relax section: %E\n"));
3202                 if (again)
3203                   *relax = true;
3204               }
3205             dot = size_input_section (prev, output_section_statement,
3206                                       output_section_statement->fill, dot);
3207           }
3208           break;
3209         case lang_input_statement_enum:
3210           break;
3211         case lang_fill_statement_enum:
3212           s->fill_statement.output_section =
3213             output_section_statement->bfd_section;
3214
3215           fill = s->fill_statement.fill;
3216           break;
3217         case lang_assignment_statement_enum:
3218           {
3219             bfd_vma newdot = dot;
3220
3221             exp_fold_tree (s->assignment_statement.exp,
3222                            output_section_statement,
3223                            lang_allocating_phase_enum,
3224                            dot,
3225                            &newdot);
3226
3227             if (newdot != dot)
3228               {
3229                 if (output_section_statement == abs_output_section)
3230                   {
3231                     /* If we don't have an output section, then just adjust
3232                        the default memory address.  */
3233                     lang_memory_region_lookup ("*default*")->current = newdot;
3234                   }
3235                 else
3236                   {
3237                     /* Insert a pad after this statement.  We can't
3238                        put the pad before when relaxing, in case the
3239                        assignment references dot.  */
3240                     insert_pad (&s->header.next, fill, (newdot - dot) * opb,
3241                                 output_section_statement->bfd_section, dot);
3242
3243                     /* Don't neuter the pad below when relaxing.  */
3244                     s = s->header.next;
3245                   }
3246
3247                 dot = newdot;
3248               }
3249           }
3250           break;
3251
3252         case lang_padding_statement_enum:
3253           /* If this is the first time lang_size_sections is called,
3254              we won't have any padding statements.  If this is the
3255              second or later passes when relaxing, we should allow
3256              padding to shrink.  If padding is needed on this pass, it
3257              will be added back in.  */
3258           s->padding_statement.size = 0;
3259
3260           /* Make sure output_offset is valid.  If relaxation shrinks
3261              the section and this pad isn't needed, it's possible to
3262              have output_offset larger than the final size of the
3263              section.  bfd_set_section_contents will complain even for
3264              a pad size of zero.  */
3265           s->padding_statement.output_offset
3266             = dot - output_section_statement->bfd_section->vma;
3267           break;
3268
3269         case lang_group_statement_enum:
3270           dot = lang_size_sections_1 (s->group_statement.children.head,
3271                                       output_section_statement,
3272                                       &s->group_statement.children.head,
3273                                       fill, dot, relax);
3274           break;
3275
3276         default:
3277           FAIL ();
3278           break;
3279
3280           /* We can only get here when relaxing is turned on.  */
3281         case lang_address_statement_enum:
3282           break;
3283         }
3284       prev = &s->header.next;
3285     }
3286   return dot;
3287 }
3288
3289 bfd_vma
3290 lang_size_sections (s, output_section_statement, prev, fill, dot, relax)
3291      lang_statement_union_type *s;
3292      lang_output_section_statement_type *output_section_statement;
3293      lang_statement_union_type **prev;
3294      fill_type *fill;
3295      bfd_vma dot;
3296      boolean *relax;
3297 {
3298   bfd_vma result;
3299
3300   exp_data_seg.phase = exp_dataseg_none;
3301   result = lang_size_sections_1 (s, output_section_statement, prev, fill,
3302                                  dot, relax);
3303   if (exp_data_seg.phase == exp_dataseg_end_seen)
3304     {
3305       /* If DATA_SEGMENT_ALIGN DATA_SEGMENT_END pair was seen, check whether
3306          a page could be saved in the data segment.  */
3307       bfd_vma first, last;
3308
3309       first = -exp_data_seg.base & (exp_data_seg.pagesize - 1);
3310       last = exp_data_seg.end & (exp_data_seg.pagesize - 1);
3311       if (first && last
3312           && ((exp_data_seg.base & ~(exp_data_seg.pagesize - 1))
3313               != (exp_data_seg.end & ~(exp_data_seg.pagesize - 1)))
3314           && first + last <= exp_data_seg.pagesize)
3315         {
3316           exp_data_seg.phase = exp_dataseg_adjust;
3317           result = lang_size_sections_1 (s, output_section_statement, prev,
3318                                          fill, dot, relax);
3319         }
3320     }
3321
3322   return result;
3323 }
3324
3325 bfd_vma
3326 lang_do_assignments (s, output_section_statement, fill, dot)
3327      lang_statement_union_type *s;
3328      lang_output_section_statement_type *output_section_statement;
3329      fill_type *fill;
3330      bfd_vma dot;
3331 {
3332   unsigned opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
3333                                                 ldfile_output_machine);
3334
3335   for (; s != (lang_statement_union_type *) NULL; s = s->header.next)
3336     {
3337       switch (s->header.type)
3338         {
3339         case lang_constructors_statement_enum:
3340           dot = lang_do_assignments (constructor_list.head,
3341                                      output_section_statement,
3342                                      fill,
3343                                      dot);
3344           break;
3345
3346         case lang_output_section_statement_enum:
3347           {
3348             lang_output_section_statement_type *os;
3349
3350             os = &(s->output_section_statement);
3351             if (os->bfd_section != NULL)
3352               {
3353                 dot = os->bfd_section->vma;
3354                 (void) lang_do_assignments (os->children.head, os,
3355                                             os->fill, dot);
3356                 dot = os->bfd_section->vma + os->bfd_section->_raw_size / opb;
3357
3358               }
3359             if (os->load_base)
3360               {
3361                 /* If nothing has been placed into the output section then
3362                    it won't have a bfd_section.  */
3363                 if (os->bfd_section)
3364                   {
3365                     os->bfd_section->lma
3366                       = exp_get_abs_int (os->load_base, 0, "load base",
3367                                          lang_final_phase_enum);
3368                   }
3369               }
3370           }
3371           break;
3372         case lang_wild_statement_enum:
3373
3374           dot = lang_do_assignments (s->wild_statement.children.head,
3375                                      output_section_statement,
3376                                      fill, dot);
3377
3378           break;
3379
3380         case lang_object_symbols_statement_enum:
3381         case lang_output_statement_enum:
3382         case lang_target_statement_enum:
3383 #if 0
3384         case lang_common_statement_enum:
3385 #endif
3386           break;
3387         case lang_data_statement_enum:
3388           {
3389             etree_value_type value;
3390
3391             value = exp_fold_tree (s->data_statement.exp,
3392                                    abs_output_section,
3393                                    lang_final_phase_enum, dot, &dot);
3394             s->data_statement.value = value.value;
3395             if (value.valid_p == false)
3396               einfo (_("%F%P: invalid data statement\n"));
3397           }
3398           {
3399             unsigned int size;
3400             switch (s->data_statement.type)
3401               {
3402               default:
3403                 abort ();
3404               case QUAD:
3405               case SQUAD:
3406                 size = QUAD_SIZE;
3407                 break;
3408               case LONG:
3409                 size = LONG_SIZE;
3410                 break;
3411               case SHORT:
3412                 size = SHORT_SIZE;
3413                 break;
3414               case BYTE:
3415                 size = BYTE_SIZE;
3416                 break;
3417               }
3418             if (size < opb)
3419               size = opb;
3420             dot += size / opb;
3421           }
3422           break;
3423
3424         case lang_reloc_statement_enum:
3425           {
3426             etree_value_type value;
3427
3428             value = exp_fold_tree (s->reloc_statement.addend_exp,
3429                                    abs_output_section,
3430                                    lang_final_phase_enum, dot, &dot);
3431             s->reloc_statement.addend_value = value.value;
3432             if (value.valid_p == false)
3433               einfo (_("%F%P: invalid reloc statement\n"));
3434           }
3435           dot += bfd_get_reloc_size (s->reloc_statement.howto) / opb;
3436           break;
3437
3438         case lang_input_section_enum:
3439           {
3440             asection *in = s->input_section.section;
3441
3442             if (in->_cooked_size != 0)
3443               dot += in->_cooked_size / opb;
3444             else
3445               dot += in->_raw_size / opb;
3446           }
3447           break;
3448
3449         case lang_input_statement_enum:
3450           break;
3451         case lang_fill_statement_enum:
3452           fill = s->fill_statement.fill;
3453           break;
3454         case lang_assignment_statement_enum:
3455           {
3456             exp_fold_tree (s->assignment_statement.exp,
3457                            output_section_statement,
3458                            lang_final_phase_enum,
3459                            dot,
3460                            &dot);
3461           }
3462
3463           break;
3464         case lang_padding_statement_enum:
3465           dot += s->padding_statement.size / opb;
3466           break;
3467
3468         case lang_group_statement_enum:
3469           dot = lang_do_assignments (s->group_statement.children.head,
3470                                      output_section_statement,
3471                                      fill, dot);
3472
3473           break;
3474
3475         default:
3476           FAIL ();
3477           break;
3478         case lang_address_statement_enum:
3479           break;
3480         }
3481
3482     }
3483   return dot;
3484 }
3485
3486 /* Fix any .startof. or .sizeof. symbols.  When the assemblers see the
3487    operator .startof. (section_name), it produces an undefined symbol
3488    .startof.section_name.  Similarly, when it sees
3489    .sizeof. (section_name), it produces an undefined symbol
3490    .sizeof.section_name.  For all the output sections, we look for
3491    such symbols, and set them to the correct value.  */
3492
3493 static void
3494 lang_set_startof ()
3495 {
3496   asection *s;
3497
3498   if (link_info.relocateable)
3499     return;
3500
3501   for (s = output_bfd->sections; s != NULL; s = s->next)
3502     {
3503       const char *secname;
3504       char *buf;
3505       struct bfd_link_hash_entry *h;
3506
3507       secname = bfd_get_section_name (output_bfd, s);
3508       buf = xmalloc (10 + strlen (secname));
3509
3510       sprintf (buf, ".startof.%s", secname);
3511       h = bfd_link_hash_lookup (link_info.hash, buf, false, false, true);
3512       if (h != NULL && h->type == bfd_link_hash_undefined)
3513         {
3514           h->type = bfd_link_hash_defined;
3515           h->u.def.value = bfd_get_section_vma (output_bfd, s);
3516           h->u.def.section = bfd_abs_section_ptr;
3517         }
3518
3519       sprintf (buf, ".sizeof.%s", secname);
3520       h = bfd_link_hash_lookup (link_info.hash, buf, false, false, true);
3521       if (h != NULL && h->type == bfd_link_hash_undefined)
3522         {
3523           unsigned opb;
3524
3525           opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
3526                                                ldfile_output_machine);
3527           h->type = bfd_link_hash_defined;
3528           if (s->_cooked_size != 0)
3529             h->u.def.value = s->_cooked_size / opb;
3530           else
3531             h->u.def.value = s->_raw_size / opb;
3532           h->u.def.section = bfd_abs_section_ptr;
3533         }
3534
3535       free (buf);
3536     }
3537 }
3538
3539 static void
3540 lang_finish ()
3541 {
3542   struct bfd_link_hash_entry *h;
3543   boolean warn;
3544
3545   if (link_info.relocateable || link_info.shared)
3546     warn = false;
3547   else
3548     warn = true;
3549
3550   if (entry_symbol.name == (const char *) NULL)
3551     {
3552       /* No entry has been specified.  Look for start, but don't warn
3553          if we don't find it.  */
3554       entry_symbol.name = "start";
3555       warn = false;
3556     }
3557
3558   h = bfd_link_hash_lookup (link_info.hash, entry_symbol.name,
3559                             false, false, true);
3560   if (h != (struct bfd_link_hash_entry *) NULL
3561       && (h->type == bfd_link_hash_defined
3562           || h->type == bfd_link_hash_defweak)
3563       && h->u.def.section->output_section != NULL)
3564     {
3565       bfd_vma val;
3566
3567       val = (h->u.def.value
3568              + bfd_get_section_vma (output_bfd,
3569                                     h->u.def.section->output_section)
3570              + h->u.def.section->output_offset);
3571       if (! bfd_set_start_address (output_bfd, val))
3572         einfo (_("%P%F:%s: can't set start address\n"), entry_symbol.name);
3573     }
3574   else
3575     {
3576       bfd_vma val;
3577       const char *send;
3578
3579       /* We couldn't find the entry symbol.  Try parsing it as a
3580          number.  */
3581       val = bfd_scan_vma (entry_symbol.name, &send, 0);
3582       if (*send == '\0')
3583         {
3584           if (! bfd_set_start_address (output_bfd, val))
3585             einfo (_("%P%F: can't set start address\n"));
3586         }
3587       else
3588         {
3589           asection *ts;
3590
3591           /* Can't find the entry symbol, and it's not a number.  Use
3592              the first address in the text section.  */
3593           ts = bfd_get_section_by_name (output_bfd, entry_section);
3594           if (ts != (asection *) NULL)
3595             {
3596               if (warn)
3597                 einfo (_("%P: warning: cannot find entry symbol %s; defaulting to %V\n"),
3598                        entry_symbol.name,
3599                        bfd_get_section_vma (output_bfd, ts));
3600               if (! bfd_set_start_address (output_bfd,
3601                                            bfd_get_section_vma (output_bfd,
3602                                                                 ts)))
3603                 einfo (_("%P%F: can't set start address\n"));
3604             }
3605           else
3606             {
3607               if (warn)
3608                 einfo (_("%P: warning: cannot find entry symbol %s; not setting start address\n"),
3609                        entry_symbol.name);
3610             }
3611         }
3612     }
3613 }
3614
3615 /* This is a small function used when we want to ignore errors from
3616    BFD.  */
3617
3618 static void
3619 #ifdef ANSI_PROTOTYPES
3620 ignore_bfd_errors (const char *s ATTRIBUTE_UNUSED, ...)
3621 #else
3622 ignore_bfd_errors (s)
3623      const char *s ATTRIBUTE_UNUSED;
3624 #endif
3625 {
3626   /* Don't do anything.  */
3627 }
3628
3629 /* Check that the architecture of all the input files is compatible
3630    with the output file.  Also call the backend to let it do any
3631    other checking that is needed.  */
3632
3633 static void
3634 lang_check ()
3635 {
3636   lang_statement_union_type *file;
3637   bfd *input_bfd;
3638   const bfd_arch_info_type *compatible;
3639
3640   for (file = file_chain.head;
3641        file != (lang_statement_union_type *) NULL;
3642        file = file->input_statement.next)
3643     {
3644       input_bfd = file->input_statement.the_bfd;
3645       compatible = bfd_arch_get_compatible (input_bfd, output_bfd);
3646
3647       /* In general it is not possible to perform a relocatable
3648          link between differing object formats when the input
3649          file has relocations, because the relocations in the
3650          input format may not have equivalent representations in
3651          the output format (and besides BFD does not translate
3652          relocs for other link purposes than a final link).  */
3653       if ((link_info.relocateable || link_info.emitrelocations)
3654           && (compatible == NULL
3655               || bfd_get_flavour (input_bfd) != bfd_get_flavour (output_bfd))
3656           && (bfd_get_file_flags (input_bfd) & HAS_RELOC) != 0)
3657         {
3658           einfo (_("%P%F: Relocatable linking with relocations from format %s (%B) to format %s (%B) is not supported\n"),
3659                  bfd_get_target (input_bfd), input_bfd,
3660                  bfd_get_target (output_bfd), output_bfd);
3661           /* einfo with %F exits.  */
3662         }
3663
3664       if (compatible == NULL)
3665         {
3666           if (command_line.warn_mismatch)
3667             einfo (_("%P: warning: %s architecture of input file `%B' is incompatible with %s output\n"),
3668                    bfd_printable_name (input_bfd), input_bfd,
3669                    bfd_printable_name (output_bfd));
3670         }
3671       else if (bfd_count_sections (input_bfd))
3672         {
3673           /* If the input bfd has no contents, it shouldn't set the
3674              private data of the output bfd.  */
3675
3676           bfd_error_handler_type pfn = NULL;
3677
3678           /* If we aren't supposed to warn about mismatched input
3679              files, temporarily set the BFD error handler to a
3680              function which will do nothing.  We still want to call
3681              bfd_merge_private_bfd_data, since it may set up
3682              information which is needed in the output file.  */
3683           if (! command_line.warn_mismatch)
3684             pfn = bfd_set_error_handler (ignore_bfd_errors);
3685           if (! bfd_merge_private_bfd_data (input_bfd, output_bfd))
3686             {
3687               if (command_line.warn_mismatch)
3688                 einfo (_("%E%X: failed to merge target specific data of file %B\n"),
3689                        input_bfd);
3690             }
3691           if (! command_line.warn_mismatch)
3692             bfd_set_error_handler (pfn);
3693         }
3694     }
3695 }
3696
3697 /* Look through all the global common symbols and attach them to the
3698    correct section.  The -sort-common command line switch may be used
3699    to roughly sort the entries by size.  */
3700
3701 static void
3702 lang_common ()
3703 {
3704   if (command_line.inhibit_common_definition)
3705     return;
3706   if (link_info.relocateable
3707       && ! command_line.force_common_definition)
3708     return;
3709
3710   if (! config.sort_common)
3711     bfd_link_hash_traverse (link_info.hash, lang_one_common, (PTR) NULL);
3712   else
3713     {
3714       int power;
3715
3716       for (power = 4; power >= 0; power--)
3717         bfd_link_hash_traverse (link_info.hash, lang_one_common,
3718                                 (PTR) &power);
3719     }
3720 }
3721
3722 /* Place one common symbol in the correct section.  */
3723
3724 static boolean
3725 lang_one_common (h, info)
3726      struct bfd_link_hash_entry *h;
3727      PTR info;
3728 {
3729   unsigned int power_of_two;
3730   bfd_vma size;
3731   asection *section;
3732   unsigned opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
3733                                                 ldfile_output_machine);
3734
3735   if (h->type != bfd_link_hash_common)
3736     return true;
3737
3738   size = h->u.c.size;
3739   power_of_two = h->u.c.p->alignment_power;
3740
3741   if (config.sort_common
3742       && power_of_two < (unsigned int) *(int *) info)
3743     return true;
3744
3745   section = h->u.c.p->section;
3746
3747   /* Increase the size of the section.  */
3748   section->_cooked_size = ALIGN_N ((section->_cooked_size + opb - 1) / opb,
3749                                    (bfd_size_type) (1 << power_of_two)) * opb;
3750
3751   /* Adjust the alignment if necessary.  */
3752   if (power_of_two > section->alignment_power)
3753     section->alignment_power = power_of_two;
3754
3755   /* Change the symbol from common to defined.  */
3756   h->type = bfd_link_hash_defined;
3757   h->u.def.section = section;
3758   h->u.def.value = section->_cooked_size;
3759
3760   /* Increase the size of the section.  */
3761   section->_cooked_size += size;
3762
3763   /* Make sure the section is allocated in memory, and make sure that
3764      it is no longer a common section.  */
3765   section->flags |= SEC_ALLOC;
3766   section->flags &= ~SEC_IS_COMMON;
3767
3768   if (config.map_file != NULL)
3769     {
3770       static boolean header_printed;
3771       int len;
3772       char *name;
3773       char buf[50];
3774
3775       if (! header_printed)
3776         {
3777           minfo (_("\nAllocating common symbols\n"));
3778           minfo (_("Common symbol       size              file\n\n"));
3779           header_printed = true;
3780         }
3781
3782       name = demangle (h->root.string);
3783       minfo ("%s", name);
3784       len = strlen (name);
3785       free (name);
3786
3787       if (len >= 19)
3788         {
3789           print_nl ();
3790           len = 0;
3791         }
3792       while (len < 20)
3793         {
3794           print_space ();
3795           ++len;
3796         }
3797
3798       minfo ("0x");
3799       if (size <= 0xffffffff)
3800         sprintf (buf, "%lx", (unsigned long) size);
3801       else
3802         sprintf_vma (buf, size);
3803       minfo ("%s", buf);
3804       len = strlen (buf);
3805
3806       while (len < 16)
3807         {
3808           print_space ();
3809           ++len;
3810         }
3811
3812       minfo ("%B\n", section->owner);
3813     }
3814
3815   return true;
3816 }
3817
3818 /* Run through the input files and ensure that every input section has
3819    somewhere to go.  If one is found without a destination then create
3820    an input request and place it into the statement tree.  */
3821
3822 static void
3823 lang_place_orphans ()
3824 {
3825   LANG_FOR_EACH_INPUT_STATEMENT (file)
3826     {
3827       asection *s;
3828
3829       for (s = file->the_bfd->sections;
3830            s != (asection *) NULL;
3831            s = s->next)
3832         {
3833           if (s->output_section == (asection *) NULL)
3834             {
3835               /* This section of the file is not attatched, root
3836                  around for a sensible place for it to go.  */
3837
3838               if (file->just_syms_flag)
3839                 {
3840                   abort ();
3841                 }
3842               else if (strcmp (s->name, "COMMON") == 0)
3843                 {
3844                   /* This is a lonely common section which must have
3845                      come from an archive.  We attach to the section
3846                      with the wildcard.  */
3847                   if (! link_info.relocateable
3848                       || command_line.force_common_definition)
3849                     {
3850                       if (default_common_section == NULL)
3851                         {
3852 #if 0
3853                           /* This message happens when using the
3854                              svr3.ifile linker script, so I have
3855                              disabled it.  */
3856                           info_msg (_("%P: no [COMMON] command, defaulting to .bss\n"));
3857 #endif
3858                           default_common_section =
3859                             lang_output_section_statement_lookup (".bss");
3860
3861                         }
3862                       lang_add_section (&default_common_section->children, s,
3863                                         default_common_section, file);
3864                     }
3865                 }
3866               else if (ldemul_place_orphan (file, s))
3867                 ;
3868               else
3869                 {
3870                   lang_output_section_statement_type *os;
3871
3872                   os = lang_output_section_statement_lookup (s->name);
3873                   lang_add_section (&os->children, s, os, file);
3874                 }
3875             }
3876         }
3877     }
3878 }
3879
3880 void
3881 lang_set_flags (ptr, flags, invert)
3882      lang_memory_region_type *ptr;
3883      const char *flags;
3884      int invert;
3885 {
3886   flagword *ptr_flags;
3887
3888   ptr_flags = invert ? &ptr->not_flags : &ptr->flags;
3889   while (*flags)
3890     {
3891       switch (*flags)
3892         {
3893         case 'A': case 'a':
3894           *ptr_flags |= SEC_ALLOC;
3895           break;
3896
3897         case 'R': case 'r':
3898           *ptr_flags |= SEC_READONLY;
3899           break;
3900
3901         case 'W': case 'w':
3902           *ptr_flags |= SEC_DATA;
3903           break;
3904
3905         case 'X': case 'x':
3906           *ptr_flags |= SEC_CODE;
3907           break;
3908
3909         case 'L': case 'l':
3910         case 'I': case 'i':
3911           *ptr_flags |= SEC_LOAD;
3912           break;
3913
3914         default:
3915           einfo (_("%P%F: invalid syntax in flags\n"));
3916           break;
3917         }
3918       flags++;
3919     }
3920 }
3921
3922 /* Call a function on each input file.  This function will be called
3923    on an archive, but not on the elements.  */
3924
3925 void
3926 lang_for_each_input_file (func)
3927      void (*func) PARAMS ((lang_input_statement_type *));
3928 {
3929   lang_input_statement_type *f;
3930
3931   for (f = (lang_input_statement_type *) input_file_chain.head;
3932        f != NULL;
3933        f = (lang_input_statement_type *) f->next_real_file)
3934     func (f);
3935 }
3936
3937 /* Call a function on each file.  The function will be called on all
3938    the elements of an archive which are included in the link, but will
3939    not be called on the archive file itself.  */
3940
3941 void
3942 lang_for_each_file (func)
3943      void (*func) PARAMS ((lang_input_statement_type *));
3944 {
3945   LANG_FOR_EACH_INPUT_STATEMENT (f)
3946     {
3947       func (f);
3948     }
3949 }
3950
3951 #if 0
3952
3953 /* Not used.  */
3954
3955 void
3956 lang_for_each_input_section (func)
3957      void (*func) PARAMS ((bfd *ab, asection *as));
3958 {
3959   LANG_FOR_EACH_INPUT_STATEMENT (f)
3960     {
3961       asection *s;
3962
3963       for (s = f->the_bfd->sections;
3964            s != (asection *) NULL;
3965            s = s->next)
3966         {
3967           func (f->the_bfd, s);
3968         }
3969     }
3970 }
3971
3972 #endif
3973
3974 void
3975 ldlang_add_file (entry)
3976      lang_input_statement_type *entry;
3977 {
3978   bfd **pp;
3979
3980   lang_statement_append (&file_chain,
3981                          (lang_statement_union_type *) entry,
3982                          &entry->next);
3983
3984   /* The BFD linker needs to have a list of all input BFDs involved in
3985      a link.  */
3986   ASSERT (entry->the_bfd->link_next == (bfd *) NULL);
3987   ASSERT (entry->the_bfd != output_bfd);
3988   for (pp = &link_info.input_bfds;
3989        *pp != (bfd *) NULL;
3990        pp = &(*pp)->link_next)
3991     ;
3992   *pp = entry->the_bfd;
3993   entry->the_bfd->usrdata = (PTR) entry;
3994   bfd_set_gp_size (entry->the_bfd, g_switch_value);
3995
3996   /* Look through the sections and check for any which should not be
3997      included in the link.  We need to do this now, so that we can
3998      notice when the backend linker tries to report multiple
3999      definition errors for symbols which are in sections we aren't
4000      going to link.  FIXME: It might be better to entirely ignore
4001      symbols which are defined in sections which are going to be
4002      discarded.  This would require modifying the backend linker for
4003      each backend which might set the SEC_LINK_ONCE flag.  If we do
4004      this, we should probably handle SEC_EXCLUDE in the same way.  */
4005
4006   bfd_map_over_sections (entry->the_bfd, section_already_linked, (PTR) entry);
4007 }
4008
4009 void
4010 lang_add_output (name, from_script)
4011      const char *name;
4012      int from_script;
4013 {
4014   /* Make -o on command line override OUTPUT in script.  */
4015   if (had_output_filename == false || !from_script)
4016     {
4017       output_filename = name;
4018       had_output_filename = true;
4019     }
4020 }
4021
4022 static lang_output_section_statement_type *current_section;
4023
4024 static int
4025 topower (x)
4026      int x;
4027 {
4028   unsigned int i = 1;
4029   int l;
4030
4031   if (x < 0)
4032     return -1;
4033
4034   for (l = 0; l < 32; l++)
4035     {
4036       if (i >= (unsigned int) x)
4037         return l;
4038       i <<= 1;
4039     }
4040
4041   return 0;
4042 }
4043
4044 lang_output_section_statement_type *
4045 lang_enter_output_section_statement (output_section_statement_name,
4046                                      address_exp, sectype, block_value,
4047                                      align, subalign, ebase)
4048      const char *output_section_statement_name;
4049      etree_type *address_exp;
4050      enum section_type sectype;
4051      bfd_vma block_value;
4052      etree_type *align;
4053      etree_type *subalign;
4054      etree_type *ebase;
4055 {
4056   lang_output_section_statement_type *os;
4057
4058   current_section =
4059    os =
4060     lang_output_section_statement_lookup (output_section_statement_name);
4061
4062   /* Add this statement to tree.  */
4063 #if 0
4064   add_statement (lang_output_section_statement_enum,
4065                  output_section_statement);
4066 #endif
4067   /* Make next things chain into subchain of this.  */
4068
4069   if (os->addr_tree == (etree_type *) NULL)
4070     {
4071       os->addr_tree = address_exp;
4072     }
4073   os->sectype = sectype;
4074   if (sectype != noload_section)
4075     os->flags = SEC_NO_FLAGS;
4076   else
4077     os->flags = SEC_NEVER_LOAD;
4078   os->block_value = block_value ? block_value : 1;
4079   stat_ptr = &os->children;
4080
4081   os->subsection_alignment =
4082     topower (exp_get_value_int (subalign, -1, "subsection alignment", 0));
4083   os->section_alignment =
4084     topower (exp_get_value_int (align, -1, "section alignment", 0));
4085
4086   os->load_base = ebase;
4087   return os;
4088 }
4089
4090 void
4091 lang_final ()
4092 {
4093   lang_output_statement_type *new =
4094     new_stat (lang_output_statement, stat_ptr);
4095
4096   new->name = output_filename;
4097 }
4098
4099 /* Reset the current counters in the regions.  */
4100
4101 void
4102 lang_reset_memory_regions ()
4103 {
4104   lang_memory_region_type *p = lang_memory_region_list;
4105   asection *o;
4106
4107   for (p = lang_memory_region_list;
4108        p != (lang_memory_region_type *) NULL;
4109        p = p->next)
4110     {
4111       p->old_length = (bfd_size_type) (p->current - p->origin);
4112       p->current = p->origin;
4113     }
4114
4115   for (o = output_bfd->sections; o != NULL; o = o->next)
4116     o->_raw_size = 0;
4117 }
4118
4119 /* If the wild pattern was marked KEEP, the member sections
4120    should be as well.  */
4121
4122 static void
4123 gc_section_callback (ptr, sec, section, file, data)
4124      lang_wild_statement_type *ptr;
4125      struct wildcard_list *sec ATTRIBUTE_UNUSED;
4126      asection *section;
4127      lang_input_statement_type *file ATTRIBUTE_UNUSED;
4128      PTR data ATTRIBUTE_UNUSED;
4129 {
4130   if (ptr->keep_sections)
4131     section->flags |= SEC_KEEP;
4132 }
4133
4134 /* Handle a wild statement, marking it against GC.  */
4135
4136 static void
4137 lang_gc_wild (s)
4138      lang_wild_statement_type *s;
4139 {
4140   walk_wild (s, gc_section_callback, NULL);
4141 }
4142
4143 /* Iterate over sections marking them against GC.  */
4144
4145 static void
4146 lang_gc_sections_1 (s)
4147      lang_statement_union_type *s;
4148 {
4149   for (; s != (lang_statement_union_type *) NULL; s = s->header.next)
4150     {
4151       switch (s->header.type)
4152         {
4153         case lang_wild_statement_enum:
4154           lang_gc_wild (&s->wild_statement);
4155           break;
4156         case lang_constructors_statement_enum:
4157           lang_gc_sections_1 (constructor_list.head);
4158           break;
4159         case lang_output_section_statement_enum:
4160           lang_gc_sections_1 (s->output_section_statement.children.head);
4161           break;
4162         case lang_group_statement_enum:
4163           lang_gc_sections_1 (s->group_statement.children.head);
4164           break;
4165         default:
4166           break;
4167         }
4168     }
4169 }
4170
4171 static void
4172 lang_gc_sections ()
4173 {
4174   struct bfd_link_hash_entry *h;
4175   ldlang_undef_chain_list_type *ulist;
4176
4177   /* Keep all sections so marked in the link script.  */
4178
4179   lang_gc_sections_1 (statement_list.head);
4180
4181   /* Keep all sections containing symbols undefined on the command-line,
4182      and the section containing the entry symbol.  */
4183
4184   for (ulist = link_info.gc_sym_list; ulist; ulist = ulist->next)
4185     {
4186       h = bfd_link_hash_lookup (link_info.hash, ulist->name,
4187                                 false, false, false);
4188
4189       if (h != (struct bfd_link_hash_entry *) NULL
4190           && (h->type == bfd_link_hash_defined
4191               || h->type == bfd_link_hash_defweak)
4192           && ! bfd_is_abs_section (h->u.def.section))
4193         {
4194           h->u.def.section->flags |= SEC_KEEP;
4195         }
4196     }
4197
4198   bfd_gc_sections (output_bfd, &link_info);
4199 }
4200
4201 void
4202 lang_process ()
4203 {
4204   lang_reasonable_defaults ();
4205   current_target = default_target;
4206
4207   /* Open the output file.  */
4208   lang_for_each_statement (ldlang_open_output);
4209
4210   ldemul_create_output_section_statements ();
4211
4212   /* Add to the hash table all undefineds on the command line.  */
4213   lang_place_undefineds ();
4214
4215   already_linked_table_init ();
4216
4217   /* Create a bfd for each input file.  */
4218   current_target = default_target;
4219   open_input_bfds (statement_list.head, false);
4220
4221   link_info.gc_sym_list = &entry_symbol;
4222   if (entry_symbol.name == NULL)
4223     link_info.gc_sym_list = ldlang_undef_chain_list_head;
4224
4225   ldemul_after_open ();
4226
4227   already_linked_table_free ();
4228
4229   /* Make sure that we're not mixing architectures.  We call this
4230      after all the input files have been opened, but before we do any
4231      other processing, so that any operations merge_private_bfd_data
4232      does on the output file will be known during the rest of the
4233      link.  */
4234   lang_check ();
4235
4236   /* Handle .exports instead of a version script if we're told to do so.  */
4237   if (command_line.version_exports_section)
4238     lang_do_version_exports_section ();
4239
4240   /* Build all sets based on the information gathered from the input
4241      files.  */
4242   ldctor_build_sets ();
4243
4244   /* Remove unreferenced sections if asked to.  */
4245   if (command_line.gc_sections)
4246     lang_gc_sections ();
4247
4248   /* If there were any SEC_MERGE sections, finish their merging, so that
4249      section sizes can be computed.  This has to be done after GC of sections,
4250      so that GCed sections are not merged, but before assigning output
4251      sections, since removing whole input sections is hard then.  */
4252   bfd_merge_sections (output_bfd, &link_info);
4253
4254   /* Size up the common data.  */
4255   lang_common ();
4256
4257   /* Run through the contours of the script and attach input sections
4258      to the correct output sections.  */
4259   map_input_to_output_sections (statement_list.head, (char *) NULL,
4260                                 (lang_output_section_statement_type *) NULL);
4261
4262   /* Find any sections not attached explicitly and handle them.  */
4263   lang_place_orphans ();
4264
4265   if (! link_info.relocateable)
4266     {
4267       /* Look for a text section and set the readonly attribute in it.  */
4268       asection *found = bfd_get_section_by_name (output_bfd, ".text");
4269
4270       if (found != (asection *) NULL)
4271         {
4272           if (config.text_read_only)
4273             found->flags |= SEC_READONLY;
4274           else
4275             found->flags &= ~SEC_READONLY;
4276         }
4277     }
4278
4279   /* Do anything special before sizing sections.  This is where ELF
4280      and other back-ends size dynamic sections.  */
4281   ldemul_before_allocation ();
4282
4283   if (!link_info.relocateable)
4284     strip_excluded_output_sections ();
4285
4286   /* We must record the program headers before we try to fix the
4287      section positions, since they will affect SIZEOF_HEADERS.  */
4288   lang_record_phdrs ();
4289
4290   /* Size up the sections.  */
4291   lang_size_sections (statement_list.head,
4292                       abs_output_section,
4293                       &statement_list.head, 0, (bfd_vma) 0, NULL);
4294
4295   /* Now run around and relax if we can.  */
4296   if (command_line.relax)
4297     {
4298       /* Keep relaxing until bfd_relax_section gives up.  */
4299       boolean relax_again;
4300
4301       do
4302         {
4303           lang_reset_memory_regions ();
4304
4305           relax_again = false;
4306
4307           /* Note: pe-dll.c does something like this also.  If you find
4308              you need to change this code, you probably need to change
4309              pe-dll.c also.  DJ  */
4310
4311           /* Do all the assignments with our current guesses as to
4312              section sizes.  */
4313           lang_do_assignments (statement_list.head,
4314                                abs_output_section,
4315                                (fill_type *) 0, (bfd_vma) 0);
4316
4317           /* Perform another relax pass - this time we know where the
4318              globals are, so can make a better guess.  */
4319           lang_size_sections (statement_list.head,
4320                               abs_output_section,
4321                               &statement_list.head, 0, (bfd_vma) 0,
4322                               &relax_again);
4323         }
4324       while (relax_again);
4325     }
4326
4327   /* See if anything special should be done now we know how big
4328      everything is.  */
4329   ldemul_after_allocation ();
4330
4331   /* Fix any .startof. or .sizeof. symbols.  */
4332   lang_set_startof ();
4333
4334   /* Do all the assignments, now that we know the final resting places
4335      of all the symbols.  */
4336
4337   lang_do_assignments (statement_list.head,
4338                        abs_output_section,
4339                        (fill_type *) 0, (bfd_vma) 0);
4340
4341   /* Make sure that the section addresses make sense.  */
4342   if (! link_info.relocateable
4343       && command_line.check_section_addresses)
4344     lang_check_section_addresses ();
4345
4346   /* Final stuffs.  */
4347
4348   ldemul_finish ();
4349   lang_finish ();
4350 }
4351
4352 /* EXPORTED TO YACC */
4353
4354 void
4355 lang_add_wild (filespec, section_list, keep_sections)
4356      struct wildcard_spec *filespec;
4357      struct wildcard_list *section_list;
4358      boolean keep_sections;
4359 {
4360   struct wildcard_list *curr, *next;
4361   lang_wild_statement_type *new;
4362
4363   /* Reverse the list as the parser puts it back to front.  */
4364   for (curr = section_list, section_list = NULL;
4365        curr != NULL;
4366        section_list = curr, curr = next)
4367     {
4368       if (curr->spec.name != NULL && strcmp (curr->spec.name, "COMMON") == 0)
4369         placed_commons = true;
4370
4371       next = curr->next;
4372       curr->next = section_list;
4373     }
4374
4375   if (filespec != NULL && filespec->name != NULL)
4376     {
4377       if (strcmp (filespec->name, "*") == 0)
4378         filespec->name = NULL;
4379       else if (! wildcardp (filespec->name))
4380         lang_has_input_file = true;
4381     }
4382
4383   new = new_stat (lang_wild_statement, stat_ptr);
4384   new->filename = NULL;
4385   new->filenames_sorted = false;
4386   if (filespec != NULL)
4387     {
4388       new->filename = filespec->name;
4389       new->filenames_sorted = filespec->sorted;
4390     }
4391   new->section_list = section_list;
4392   new->keep_sections = keep_sections;
4393   lang_list_init (&new->children);
4394 }
4395
4396 void
4397 lang_section_start (name, address)
4398      const char *name;
4399      etree_type *address;
4400 {
4401   lang_address_statement_type *ad;
4402
4403   ad = new_stat (lang_address_statement, stat_ptr);
4404   ad->section_name = name;
4405   ad->address = address;
4406 }
4407
4408 /* Set the start symbol to NAME.  CMDLINE is nonzero if this is called
4409    because of a -e argument on the command line, or zero if this is
4410    called by ENTRY in a linker script.  Command line arguments take
4411    precedence.  */
4412
4413 void
4414 lang_add_entry (name, cmdline)
4415      const char *name;
4416      boolean cmdline;
4417 {
4418   if (entry_symbol.name == NULL
4419       || cmdline
4420       || ! entry_from_cmdline)
4421     {
4422       entry_symbol.name = name;
4423       entry_from_cmdline = cmdline;
4424     }
4425 }
4426
4427 void
4428 lang_add_target (name)
4429      const char *name;
4430 {
4431   lang_target_statement_type *new = new_stat (lang_target_statement,
4432                                               stat_ptr);
4433
4434   new->target = name;
4435
4436 }
4437
4438 void
4439 lang_add_map (name)
4440      const char *name;
4441 {
4442   while (*name)
4443     {
4444       switch (*name)
4445         {
4446         case 'F':
4447           map_option_f = true;
4448           break;
4449         }
4450       name++;
4451     }
4452 }
4453
4454 void
4455 lang_add_fill (fill)
4456      fill_type *fill;
4457 {
4458   lang_fill_statement_type *new = new_stat (lang_fill_statement,
4459                                             stat_ptr);
4460
4461   new->fill = fill;
4462 }
4463
4464 void
4465 lang_add_data (type, exp)
4466      int type;
4467      union etree_union *exp;
4468 {
4469
4470   lang_data_statement_type *new = new_stat (lang_data_statement,
4471                                             stat_ptr);
4472
4473   new->exp = exp;
4474   new->type = type;
4475
4476 }
4477
4478 /* Create a new reloc statement.  RELOC is the BFD relocation type to
4479    generate.  HOWTO is the corresponding howto structure (we could
4480    look this up, but the caller has already done so).  SECTION is the
4481    section to generate a reloc against, or NAME is the name of the
4482    symbol to generate a reloc against.  Exactly one of SECTION and
4483    NAME must be NULL.  ADDEND is an expression for the addend.  */
4484
4485 void
4486 lang_add_reloc (reloc, howto, section, name, addend)
4487      bfd_reloc_code_real_type reloc;
4488      reloc_howto_type *howto;
4489      asection *section;
4490      const char *name;
4491      union etree_union *addend;
4492 {
4493   lang_reloc_statement_type *p = new_stat (lang_reloc_statement, stat_ptr);
4494
4495   p->reloc = reloc;
4496   p->howto = howto;
4497   p->section = section;
4498   p->name = name;
4499   p->addend_exp = addend;
4500
4501   p->addend_value = 0;
4502   p->output_section = NULL;
4503   p->output_vma = 0;
4504 }
4505
4506 lang_assignment_statement_type *
4507 lang_add_assignment (exp)
4508      etree_type *exp;
4509 {
4510   lang_assignment_statement_type *new = new_stat (lang_assignment_statement,
4511                                                   stat_ptr);
4512
4513   new->exp = exp;
4514   return new;
4515 }
4516
4517 void
4518 lang_add_attribute (attribute)
4519      enum statement_enum attribute;
4520 {
4521   new_statement (attribute, sizeof (lang_statement_union_type), stat_ptr);
4522 }
4523
4524 void
4525 lang_startup (name)
4526      const char *name;
4527 {
4528   if (startup_file != (char *) NULL)
4529     {
4530       einfo (_("%P%Fmultiple STARTUP files\n"));
4531     }
4532   first_file->filename = name;
4533   first_file->local_sym_name = name;
4534   first_file->real = true;
4535
4536   startup_file = name;
4537 }
4538
4539 void
4540 lang_float (maybe)
4541      boolean maybe;
4542 {
4543   lang_float_flag = maybe;
4544 }
4545
4546
4547 /* Work out the load- and run-time regions from a script statement, and
4548    store them in *LMA_REGION and *REGION respectively.
4549
4550    MEMSPEC is the name of the run-time region, or "*default*" if the
4551    statement didn't specify one.  LMA_MEMSPEC is the name of the
4552    load-time region, or null if the statement didn't specify one.
4553    HAVE_LMA_P is true if the statement had an explicit load address.
4554
4555    It is an error to specify both a load region and a load address.  */
4556
4557 static void
4558 lang_get_regions (region, lma_region, memspec, lma_memspec, have_lma_p)
4559      struct memory_region_struct **region, **lma_region;
4560      const char *memspec, *lma_memspec;
4561      int have_lma_p;
4562 {
4563   *lma_region = lang_memory_region_lookup (lma_memspec);
4564
4565   /* If no runtime region has been given, but the load region has
4566      been, use the load region.  */
4567   if (lma_memspec != 0 && strcmp (memspec, "*default*") == 0)
4568     *region = *lma_region;
4569   else
4570     *region = lang_memory_region_lookup (memspec);
4571
4572   if (have_lma_p && lma_memspec != 0)
4573     einfo (_("%X%P:%S: section has both a load address and a load region\n"));
4574 }
4575
4576 void
4577 lang_leave_output_section_statement (fill, memspec, phdrs, lma_memspec)
4578      fill_type *fill;
4579      const char *memspec;
4580      struct lang_output_section_phdr_list *phdrs;
4581      const char *lma_memspec;
4582 {
4583   lang_get_regions (&current_section->region,
4584                     &current_section->lma_region,
4585                     memspec, lma_memspec,
4586                     current_section->load_base != 0);
4587   current_section->fill = fill;
4588   current_section->phdrs = phdrs;
4589   stat_ptr = &statement_list;
4590 }
4591
4592 /* Create an absolute symbol with the given name with the value of the
4593    address of first byte of the section named.
4594
4595    If the symbol already exists, then do nothing.  */
4596
4597 void
4598 lang_abs_symbol_at_beginning_of (secname, name)
4599      const char *secname;
4600      const char *name;
4601 {
4602   struct bfd_link_hash_entry *h;
4603
4604   h = bfd_link_hash_lookup (link_info.hash, name, true, true, true);
4605   if (h == (struct bfd_link_hash_entry *) NULL)
4606     einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
4607
4608   if (h->type == bfd_link_hash_new
4609       || h->type == bfd_link_hash_undefined)
4610     {
4611       asection *sec;
4612
4613       h->type = bfd_link_hash_defined;
4614
4615       sec = bfd_get_section_by_name (output_bfd, secname);
4616       if (sec == (asection *) NULL)
4617         h->u.def.value = 0;
4618       else
4619         h->u.def.value = bfd_get_section_vma (output_bfd, sec);
4620
4621       h->u.def.section = bfd_abs_section_ptr;
4622     }
4623 }
4624
4625 /* Create an absolute symbol with the given name with the value of the
4626    address of the first byte after the end of the section named.
4627
4628    If the symbol already exists, then do nothing.  */
4629
4630 void
4631 lang_abs_symbol_at_end_of (secname, name)
4632      const char *secname;
4633      const char *name;
4634 {
4635   struct bfd_link_hash_entry *h;
4636
4637   h = bfd_link_hash_lookup (link_info.hash, name, true, true, true);
4638   if (h == (struct bfd_link_hash_entry *) NULL)
4639     einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
4640
4641   if (h->type == bfd_link_hash_new
4642       || h->type == bfd_link_hash_undefined)
4643     {
4644       asection *sec;
4645
4646       h->type = bfd_link_hash_defined;
4647
4648       sec = bfd_get_section_by_name (output_bfd, secname);
4649       if (sec == (asection *) NULL)
4650         h->u.def.value = 0;
4651       else
4652         h->u.def.value = (bfd_get_section_vma (output_bfd, sec)
4653                           + bfd_section_size (output_bfd, sec) /
4654                           bfd_octets_per_byte (output_bfd));
4655
4656       h->u.def.section = bfd_abs_section_ptr;
4657     }
4658 }
4659
4660 void
4661 lang_statement_append (list, element, field)
4662      lang_statement_list_type *list;
4663      lang_statement_union_type *element;
4664      lang_statement_union_type **field;
4665 {
4666   *(list->tail) = element;
4667   list->tail = field;
4668 }
4669
4670 /* Set the output format type.  -oformat overrides scripts.  */
4671
4672 void
4673 lang_add_output_format (format, big, little, from_script)
4674      const char *format;
4675      const char *big;
4676      const char *little;
4677      int from_script;
4678 {
4679   if (output_target == NULL || !from_script)
4680     {
4681       if (command_line.endian == ENDIAN_BIG
4682           && big != NULL)
4683         format = big;
4684       else if (command_line.endian == ENDIAN_LITTLE
4685                && little != NULL)
4686         format = little;
4687
4688       output_target = format;
4689     }
4690 }
4691
4692 /* Enter a group.  This creates a new lang_group_statement, and sets
4693    stat_ptr to build new statements within the group.  */
4694
4695 void
4696 lang_enter_group ()
4697 {
4698   lang_group_statement_type *g;
4699
4700   g = new_stat (lang_group_statement, stat_ptr);
4701   lang_list_init (&g->children);
4702   stat_ptr = &g->children;
4703 }
4704
4705 /* Leave a group.  This just resets stat_ptr to start writing to the
4706    regular list of statements again.  Note that this will not work if
4707    groups can occur inside anything else which can adjust stat_ptr,
4708    but currently they can't.  */
4709
4710 void
4711 lang_leave_group ()
4712 {
4713   stat_ptr = &statement_list;
4714 }
4715
4716 /* Add a new program header.  This is called for each entry in a PHDRS
4717    command in a linker script.  */
4718
4719 void
4720 lang_new_phdr (name, type, filehdr, phdrs, at, flags)
4721      const char *name;
4722      etree_type *type;
4723      boolean filehdr;
4724      boolean phdrs;
4725      etree_type *at;
4726      etree_type *flags;
4727 {
4728   struct lang_phdr *n, **pp;
4729
4730   n = (struct lang_phdr *) stat_alloc (sizeof (struct lang_phdr));
4731   n->next = NULL;
4732   n->name = name;
4733   n->type = exp_get_value_int (type, 0, "program header type",
4734                                lang_final_phase_enum);
4735   n->filehdr = filehdr;
4736   n->phdrs = phdrs;
4737   n->at = at;
4738   n->flags = flags;
4739
4740   for (pp = &lang_phdr_list; *pp != NULL; pp = &(*pp)->next)
4741     ;
4742   *pp = n;
4743 }
4744
4745 /* Record the program header information in the output BFD.  FIXME: We
4746    should not be calling an ELF specific function here.  */
4747
4748 static void
4749 lang_record_phdrs ()
4750 {
4751   unsigned int alc;
4752   asection **secs;
4753   struct lang_output_section_phdr_list *last;
4754   struct lang_phdr *l;
4755   lang_statement_union_type *u;
4756
4757   alc = 10;
4758   secs = (asection **) xmalloc (alc * sizeof (asection *));
4759   last = NULL;
4760   for (l = lang_phdr_list; l != NULL; l = l->next)
4761     {
4762       unsigned int c;
4763       flagword flags;
4764       bfd_vma at;
4765
4766       c = 0;
4767       for (u = lang_output_section_statement.head;
4768            u != NULL;
4769            u = u->output_section_statement.next)
4770         {
4771           lang_output_section_statement_type *os;
4772           struct lang_output_section_phdr_list *pl;
4773
4774           os = &u->output_section_statement;
4775
4776           pl = os->phdrs;
4777           if (pl != NULL)
4778             last = pl;
4779           else
4780             {
4781               if (os->sectype == noload_section
4782                   || os->bfd_section == NULL
4783                   || (os->bfd_section->flags & SEC_ALLOC) == 0)
4784                 continue;
4785               pl = last;
4786             }
4787
4788           if (os->bfd_section == NULL)
4789             continue;
4790
4791           for (; pl != NULL; pl = pl->next)
4792             {
4793               if (strcmp (pl->name, l->name) == 0)
4794                 {
4795                   if (c >= alc)
4796                     {
4797                       alc *= 2;
4798                       secs = ((asection **)
4799                               xrealloc (secs, alc * sizeof (asection *)));
4800                     }
4801                   secs[c] = os->bfd_section;
4802                   ++c;
4803                   pl->used = true;
4804                 }
4805             }
4806         }
4807
4808       if (l->flags == NULL)
4809         flags = 0;
4810       else
4811         flags = exp_get_vma (l->flags, 0, "phdr flags",
4812                              lang_final_phase_enum);
4813
4814       if (l->at == NULL)
4815         at = 0;
4816       else
4817         at = exp_get_vma (l->at, 0, "phdr load address",
4818                           lang_final_phase_enum);
4819
4820       if (! bfd_record_phdr (output_bfd, l->type,
4821                              l->flags != NULL, flags, l->at != NULL,
4822                              at, l->filehdr, l->phdrs, c, secs))
4823         einfo (_("%F%P: bfd_record_phdr failed: %E\n"));
4824     }
4825
4826   free (secs);
4827
4828   /* Make sure all the phdr assignments succeeded.  */
4829   for (u = lang_output_section_statement.head;
4830        u != NULL;
4831        u = u->output_section_statement.next)
4832     {
4833       struct lang_output_section_phdr_list *pl;
4834
4835       if (u->output_section_statement.bfd_section == NULL)
4836         continue;
4837
4838       for (pl = u->output_section_statement.phdrs;
4839            pl != NULL;
4840            pl = pl->next)
4841         if (! pl->used && strcmp (pl->name, "NONE") != 0)
4842           einfo (_("%X%P: section `%s' assigned to non-existent phdr `%s'\n"),
4843                  u->output_section_statement.name, pl->name);
4844     }
4845 }
4846
4847 /* Record a list of sections which may not be cross referenced.  */
4848
4849 void
4850 lang_add_nocrossref (l)
4851      struct lang_nocrossref *l;
4852 {
4853   struct lang_nocrossrefs *n;
4854
4855   n = (struct lang_nocrossrefs *) xmalloc (sizeof *n);
4856   n->next = nocrossref_list;
4857   n->list = l;
4858   nocrossref_list = n;
4859
4860   /* Set notice_all so that we get informed about all symbols.  */
4861   link_info.notice_all = true;
4862 }
4863 \f
4864 /* Overlay handling.  We handle overlays with some static variables.  */
4865
4866 /* The overlay virtual address.  */
4867 static etree_type *overlay_vma;
4868
4869 /* An expression for the maximum section size seen so far.  */
4870 static etree_type *overlay_max;
4871
4872 /* A list of all the sections in this overlay.  */
4873
4874 struct overlay_list {
4875   struct overlay_list *next;
4876   lang_output_section_statement_type *os;
4877 };
4878
4879 static struct overlay_list *overlay_list;
4880
4881 /* Start handling an overlay.  */
4882
4883 void
4884 lang_enter_overlay (vma_expr)
4885      etree_type *vma_expr;
4886 {
4887   /* The grammar should prevent nested overlays from occurring.  */
4888   ASSERT (overlay_vma == NULL && overlay_max == NULL);
4889
4890   overlay_vma = vma_expr;
4891 }
4892
4893 /* Start a section in an overlay.  We handle this by calling
4894    lang_enter_output_section_statement with the correct VMA.
4895    lang_leave_overlay sets up the LMA and memory regions.  */
4896
4897 void
4898 lang_enter_overlay_section (name)
4899      const char *name;
4900 {
4901   struct overlay_list *n;
4902   etree_type *size;
4903
4904   lang_enter_output_section_statement (name, overlay_vma, normal_section,
4905                                        0, 0, 0, 0);
4906
4907   /* If this is the first section, then base the VMA of future
4908      sections on this one.  This will work correctly even if `.' is
4909      used in the addresses.  */
4910   if (overlay_list == NULL)
4911     overlay_vma = exp_nameop (ADDR, name);
4912
4913   /* Remember the section.  */
4914   n = (struct overlay_list *) xmalloc (sizeof *n);
4915   n->os = current_section;
4916   n->next = overlay_list;
4917   overlay_list = n;
4918
4919   size = exp_nameop (SIZEOF, name);
4920
4921   /* Arrange to work out the maximum section end address.  */
4922   if (overlay_max == NULL)
4923     overlay_max = size;
4924   else
4925     overlay_max = exp_binop (MAX_K, overlay_max, size);
4926 }
4927
4928 /* Finish a section in an overlay.  There isn't any special to do
4929    here.  */
4930
4931 void
4932 lang_leave_overlay_section (fill, phdrs)
4933      fill_type *fill;
4934      struct lang_output_section_phdr_list *phdrs;
4935 {
4936   const char *name;
4937   char *clean, *s2;
4938   const char *s1;
4939   char *buf;
4940
4941   name = current_section->name;
4942
4943   /* For now, assume that "*default*" is the run-time memory region and
4944      that no load-time region has been specified.  It doesn't really
4945      matter what we say here, since lang_leave_overlay will override it.  */
4946   lang_leave_output_section_statement (fill, "*default*", phdrs, 0);
4947
4948   /* Define the magic symbols.  */
4949
4950   clean = xmalloc (strlen (name) + 1);
4951   s2 = clean;
4952   for (s1 = name; *s1 != '\0'; s1++)
4953     if (ISALNUM (*s1) || *s1 == '_')
4954       *s2++ = *s1;
4955   *s2 = '\0';
4956
4957   buf = xmalloc (strlen (clean) + sizeof "__load_start_");
4958   sprintf (buf, "__load_start_%s", clean);
4959   lang_add_assignment (exp_assop ('=', buf,
4960                                   exp_nameop (LOADADDR, name)));
4961
4962   buf = xmalloc (strlen (clean) + sizeof "__load_stop_");
4963   sprintf (buf, "__load_stop_%s", clean);
4964   lang_add_assignment (exp_assop ('=', buf,
4965                                   exp_binop ('+',
4966                                              exp_nameop (LOADADDR, name),
4967                                              exp_nameop (SIZEOF, name))));
4968
4969   free (clean);
4970 }
4971
4972 /* Finish an overlay.  If there are any overlay wide settings, this
4973    looks through all the sections in the overlay and sets them.  */
4974
4975 void
4976 lang_leave_overlay (lma_expr, nocrossrefs, fill, memspec, phdrs, lma_memspec)
4977      etree_type *lma_expr;
4978      int nocrossrefs;
4979      fill_type *fill;
4980      const char *memspec;
4981      struct lang_output_section_phdr_list *phdrs;
4982      const char *lma_memspec;
4983 {
4984   lang_memory_region_type *region;
4985   lang_memory_region_type *lma_region;
4986   struct overlay_list *l;
4987   struct lang_nocrossref *nocrossref;
4988
4989   lang_get_regions (&region, &lma_region,
4990                     memspec, lma_memspec,
4991                     lma_expr != 0);
4992
4993   nocrossref = NULL;
4994
4995   /* After setting the size of the last section, set '.' to end of the
4996      overlay region.  */
4997   if (overlay_list != NULL)
4998     overlay_list->os->update_dot_tree
4999       = exp_assop ('=', ".", exp_binop ('+', overlay_vma, overlay_max));
5000
5001   l = overlay_list;
5002   while (l != NULL)
5003     {
5004       struct overlay_list *next;
5005
5006       if (fill != (fill_type *) 0 && l->os->fill == (fill_type *) 0)
5007         l->os->fill = fill;
5008
5009       l->os->region = region;
5010       l->os->lma_region = lma_region;
5011
5012       /* The first section has the load address specified in the
5013          OVERLAY statement.  The rest are worked out from that.
5014          The base address is not needed (and should be null) if
5015          an LMA region was specified.  */
5016       if (l->next == 0)
5017         l->os->load_base = lma_expr;
5018       else if (lma_region == 0)
5019         l->os->load_base = exp_binop ('+',
5020                                       exp_nameop (LOADADDR, l->next->os->name),
5021                                       exp_nameop (SIZEOF, l->next->os->name));
5022
5023       if (phdrs != NULL && l->os->phdrs == NULL)
5024         l->os->phdrs = phdrs;
5025
5026       if (nocrossrefs)
5027         {
5028           struct lang_nocrossref *nc;
5029
5030           nc = (struct lang_nocrossref *) xmalloc (sizeof *nc);
5031           nc->name = l->os->name;
5032           nc->next = nocrossref;
5033           nocrossref = nc;
5034         }
5035
5036       next = l->next;
5037       free (l);
5038       l = next;
5039     }
5040
5041   if (nocrossref != NULL)
5042     lang_add_nocrossref (nocrossref);
5043
5044   overlay_vma = NULL;
5045   overlay_list = NULL;
5046   overlay_max = NULL;
5047 }
5048 \f
5049 /* Version handling.  This is only useful for ELF.  */
5050
5051 /* This global variable holds the version tree that we build.  */
5052
5053 struct bfd_elf_version_tree *lang_elf_version_info;
5054
5055 static int
5056 lang_vers_match_lang_c (expr, sym)
5057      struct bfd_elf_version_expr *expr;
5058      const char *sym;
5059 {
5060   if (expr->pattern[0] == '*' && expr->pattern[1] == '\0')
5061     return 1;
5062   return fnmatch (expr->pattern, sym, 0) == 0;
5063 }
5064
5065 static int
5066 lang_vers_match_lang_cplusplus (expr, sym)
5067      struct bfd_elf_version_expr *expr;
5068      const char *sym;
5069 {
5070   char *alt_sym;
5071   int result;
5072
5073   if (expr->pattern[0] == '*' && expr->pattern[1] == '\0')
5074     return 1;
5075
5076   alt_sym = cplus_demangle (sym, /* DMGL_NO_TPARAMS */ 0);
5077   if (!alt_sym)
5078     {
5079       /* cplus_demangle (also) returns NULL when it is not a C++ symbol.
5080          Should we early out false in this case?  */
5081       result = fnmatch (expr->pattern, sym, 0) == 0;
5082     }
5083   else
5084     {
5085       result = fnmatch (expr->pattern, alt_sym, 0) == 0;
5086       free (alt_sym);
5087     }
5088
5089   return result;
5090 }
5091
5092 static int
5093 lang_vers_match_lang_java (expr, sym)
5094      struct bfd_elf_version_expr *expr;
5095      const char *sym;
5096 {
5097   char *alt_sym;
5098   int result;
5099
5100   if (expr->pattern[0] == '*' && expr->pattern[1] == '\0')
5101     return 1;
5102
5103   alt_sym = cplus_demangle (sym, DMGL_JAVA);
5104   if (!alt_sym)
5105     {
5106       /* cplus_demangle (also) returns NULL when it is not a Java symbol.
5107          Should we early out false in this case?  */
5108       result = fnmatch (expr->pattern, sym, 0) == 0;
5109     }
5110   else
5111     {
5112       result = fnmatch (expr->pattern, alt_sym, 0) == 0;
5113       free (alt_sym);
5114     }
5115
5116   return result;
5117 }
5118
5119 /* This is called for each variable name or match expression.  */
5120
5121 struct bfd_elf_version_expr *
5122 lang_new_vers_pattern (orig, new, lang)
5123      struct bfd_elf_version_expr *orig;
5124      const char *new;
5125      const char *lang;
5126 {
5127   struct bfd_elf_version_expr *ret;
5128
5129   ret = (struct bfd_elf_version_expr *) xmalloc (sizeof *ret);
5130   ret->next = orig;
5131   ret->pattern = new;
5132
5133   if (lang == NULL || strcasecmp (lang, "C") == 0)
5134     ret->match = lang_vers_match_lang_c;
5135   else if (strcasecmp (lang, "C++") == 0)
5136     ret->match = lang_vers_match_lang_cplusplus;
5137   else if (strcasecmp (lang, "Java") == 0)
5138     ret->match = lang_vers_match_lang_java;
5139   else
5140     {
5141       einfo (_("%X%P: unknown language `%s' in version information\n"),
5142              lang);
5143       ret->match = lang_vers_match_lang_c;
5144     }
5145
5146   return ldemul_new_vers_pattern (ret);
5147 }
5148
5149 /* This is called for each set of variable names and match
5150    expressions.  */
5151
5152 struct bfd_elf_version_tree *
5153 lang_new_vers_node (globals, locals)
5154      struct bfd_elf_version_expr *globals;
5155      struct bfd_elf_version_expr *locals;
5156 {
5157   struct bfd_elf_version_tree *ret;
5158
5159   ret = (struct bfd_elf_version_tree *) xmalloc (sizeof *ret);
5160   ret->next = NULL;
5161   ret->name = NULL;
5162   ret->vernum = 0;
5163   ret->globals = globals;
5164   ret->locals = locals;
5165   ret->deps = NULL;
5166   ret->name_indx = (unsigned int) -1;
5167   ret->used = 0;
5168   return ret;
5169 }
5170
5171 /* This static variable keeps track of version indices.  */
5172
5173 static int version_index;
5174
5175 /* This is called when we know the name and dependencies of the
5176    version.  */
5177
5178 void
5179 lang_register_vers_node (name, version, deps)
5180      const char *name;
5181      struct bfd_elf_version_tree *version;
5182      struct bfd_elf_version_deps *deps;
5183 {
5184   struct bfd_elf_version_tree *t, **pp;
5185   struct bfd_elf_version_expr *e1;
5186
5187   if (name == NULL)
5188     name = "";
5189
5190   if ((name[0] == '\0' && lang_elf_version_info != NULL)
5191       || (lang_elf_version_info && lang_elf_version_info->name[0] == '\0'))
5192     {
5193       einfo (_("%X%P: anonymous version tag cannot be combined with other version tags\n"));
5194       return;
5195     }
5196
5197   /* Make sure this node has a unique name.  */
5198   for (t = lang_elf_version_info; t != NULL; t = t->next)
5199     if (strcmp (t->name, name) == 0)
5200       einfo (_("%X%P: duplicate version tag `%s'\n"), name);
5201
5202   /* Check the global and local match names, and make sure there
5203      aren't any duplicates.  */
5204
5205   for (e1 = version->globals; e1 != NULL; e1 = e1->next)
5206     {
5207       for (t = lang_elf_version_info; t != NULL; t = t->next)
5208         {
5209           struct bfd_elf_version_expr *e2;
5210
5211           for (e2 = t->locals; e2 != NULL; e2 = e2->next)
5212             if (strcmp (e1->pattern, e2->pattern) == 0)
5213               einfo (_("%X%P: duplicate expression `%s' in version information\n"),
5214                      e1->pattern);
5215         }
5216     }
5217
5218   for (e1 = version->locals; e1 != NULL; e1 = e1->next)
5219     {
5220       for (t = lang_elf_version_info; t != NULL; t = t->next)
5221         {
5222           struct bfd_elf_version_expr *e2;
5223
5224           for (e2 = t->globals; e2 != NULL; e2 = e2->next)
5225             if (strcmp (e1->pattern, e2->pattern) == 0)
5226               einfo (_("%X%P: duplicate expression `%s' in version information\n"),
5227                      e1->pattern);
5228         }
5229     }
5230
5231   version->deps = deps;
5232   version->name = name;
5233   if (name[0] != '\0')
5234     {
5235       ++version_index;
5236       version->vernum = version_index;
5237     }
5238   else
5239     version->vernum = 0;
5240
5241   for (pp = &lang_elf_version_info; *pp != NULL; pp = &(*pp)->next)
5242     ;
5243   *pp = version;
5244 }
5245
5246 /* This is called when we see a version dependency.  */
5247
5248 struct bfd_elf_version_deps *
5249 lang_add_vers_depend (list, name)
5250      struct bfd_elf_version_deps *list;
5251      const char *name;
5252 {
5253   struct bfd_elf_version_deps *ret;
5254   struct bfd_elf_version_tree *t;
5255
5256   ret = (struct bfd_elf_version_deps *) xmalloc (sizeof *ret);
5257   ret->next = list;
5258
5259   for (t = lang_elf_version_info; t != NULL; t = t->next)
5260     {
5261       if (strcmp (t->name, name) == 0)
5262         {
5263           ret->version_needed = t;
5264           return ret;
5265         }
5266     }
5267
5268   einfo (_("%X%P: unable to find version dependency `%s'\n"), name);
5269
5270   return ret;
5271 }
5272
5273 static void
5274 lang_do_version_exports_section ()
5275 {
5276   struct bfd_elf_version_expr *greg = NULL, *lreg;
5277
5278   LANG_FOR_EACH_INPUT_STATEMENT (is)
5279     {
5280       asection *sec = bfd_get_section_by_name (is->the_bfd, ".exports");
5281       char *contents, *p;
5282       bfd_size_type len;
5283
5284       if (sec == NULL)
5285         continue;
5286
5287       len = bfd_section_size (is->the_bfd, sec);
5288       contents = xmalloc (len);
5289       if (!bfd_get_section_contents (is->the_bfd, sec, contents, 0, len))
5290         einfo (_("%X%P: unable to read .exports section contents\n"), sec);
5291
5292       p = contents;
5293       while (p < contents + len)
5294         {
5295           greg = lang_new_vers_pattern (greg, p, NULL);
5296           p = strchr (p, '\0') + 1;
5297         }
5298
5299       /* Do not free the contents, as we used them creating the regex.  */
5300
5301       /* Do not include this section in the link.  */
5302       bfd_set_section_flags (is->the_bfd, sec,
5303         bfd_get_section_flags (is->the_bfd, sec) | SEC_EXCLUDE);
5304     }
5305
5306   lreg = lang_new_vers_pattern (NULL, "*", NULL);
5307   lang_register_vers_node (command_line.version_exports_section,
5308                            lang_new_vers_node (greg, lreg), NULL);
5309 }
5310
5311 void
5312 lang_add_unique (name)
5313      const char *name;
5314 {
5315   struct unique_sections *ent;
5316
5317   for (ent = unique_section_list; ent; ent = ent->next)
5318     if (strcmp (ent->name, name) == 0)
5319       return;
5320
5321   ent = (struct unique_sections *) xmalloc (sizeof *ent);
5322   ent->name = xstrdup (name);
5323   ent->next = unique_section_list;
5324   unique_section_list = ent;
5325 }