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) && ! link_info.relocateable)
1222         flags |= SEC_LOAD;
1223
1224       section->output_section->flags |= flags;
1225
1226       if (flags & SEC_MERGE)
1227         section->output_section->entsize = section->entsize;
1228
1229       /* If SEC_READONLY is not set in the input section, then clear
1230          it from the output section.  */
1231       if ((section->flags & SEC_READONLY) == 0)
1232         section->output_section->flags &= ~SEC_READONLY;
1233
1234       switch (output->sectype)
1235         {
1236         case normal_section:
1237           break;
1238         case dsect_section:
1239         case copy_section:
1240         case info_section:
1241         case overlay_section:
1242           output->bfd_section->flags &= ~SEC_ALLOC;
1243           break;
1244         case noload_section:
1245           output->bfd_section->flags &= ~SEC_LOAD;
1246           output->bfd_section->flags |= SEC_NEVER_LOAD;
1247           break;
1248         }
1249
1250       /* Copy over SEC_SMALL_DATA.  */
1251       if (section->flags & SEC_SMALL_DATA)
1252         section->output_section->flags |= SEC_SMALL_DATA;
1253
1254       if (section->alignment_power > output->bfd_section->alignment_power)
1255         output->bfd_section->alignment_power = section->alignment_power;
1256
1257       /* If supplied an aligment, then force it.  */
1258       if (output->section_alignment != -1)
1259         output->bfd_section->alignment_power = output->section_alignment;
1260
1261       if (section->flags & SEC_BLOCK)
1262         {
1263           section->output_section->flags |= SEC_BLOCK;
1264           /* FIXME: This value should really be obtained from the bfd...  */
1265           output->block_value = 128;
1266         }
1267     }
1268 }
1269
1270 /* Handle wildcard sorting.  This returns the lang_input_section which
1271    should follow the one we are going to create for SECTION and FILE,
1272    based on the sorting requirements of WILD.  It returns NULL if the
1273    new section should just go at the end of the current list.  */
1274
1275 static lang_statement_union_type *
1276 wild_sort (wild, sec, file, section)
1277      lang_wild_statement_type *wild;
1278      struct wildcard_list *sec;
1279      lang_input_statement_type *file;
1280      asection *section;
1281 {
1282   const char *section_name;
1283   lang_statement_union_type *l;
1284
1285   if (!wild->filenames_sorted && (sec == NULL || !sec->spec.sorted))
1286     return NULL;
1287
1288   section_name = bfd_get_section_name (file->the_bfd, section);
1289   for (l = wild->children.head; l != NULL; l = l->header.next)
1290     {
1291       lang_input_section_type *ls;
1292
1293       if (l->header.type != lang_input_section_enum)
1294         continue;
1295       ls = &l->input_section;
1296
1297       /* Sorting by filename takes precedence over sorting by section
1298          name.  */
1299
1300       if (wild->filenames_sorted)
1301         {
1302           const char *fn, *ln;
1303           boolean fa, la;
1304           int i;
1305
1306           /* The PE support for the .idata section as generated by
1307              dlltool assumes that files will be sorted by the name of
1308              the archive and then the name of the file within the
1309              archive.  */
1310
1311           if (file->the_bfd != NULL
1312               && bfd_my_archive (file->the_bfd) != NULL)
1313             {
1314               fn = bfd_get_filename (bfd_my_archive (file->the_bfd));
1315               fa = true;
1316             }
1317           else
1318             {
1319               fn = file->filename;
1320               fa = false;
1321             }
1322
1323           if (ls->ifile->the_bfd != NULL
1324               && bfd_my_archive (ls->ifile->the_bfd) != NULL)
1325             {
1326               ln = bfd_get_filename (bfd_my_archive (ls->ifile->the_bfd));
1327               la = true;
1328             }
1329           else
1330             {
1331               ln = ls->ifile->filename;
1332               la = false;
1333             }
1334
1335           i = strcmp (fn, ln);
1336           if (i > 0)
1337             continue;
1338           else if (i < 0)
1339             break;
1340
1341           if (fa || la)
1342             {
1343               if (fa)
1344                 fn = file->filename;
1345               if (la)
1346                 ln = ls->ifile->filename;
1347
1348               i = strcmp (fn, ln);
1349               if (i > 0)
1350                 continue;
1351               else if (i < 0)
1352                 break;
1353             }
1354         }
1355
1356       /* Here either the files are not sorted by name, or we are
1357          looking at the sections for this file.  */
1358
1359       if (sec != NULL && sec->spec.sorted)
1360         {
1361           if (strcmp (section_name,
1362                       bfd_get_section_name (ls->ifile->the_bfd,
1363                                             ls->section))
1364               < 0)
1365             break;
1366         }
1367     }
1368
1369   return l;
1370 }
1371
1372 /* Expand a wild statement for a particular FILE.  SECTION may be
1373    NULL, in which case it is a wild card.  */
1374
1375 static void
1376 output_section_callback (ptr, sec, section, file, output)
1377      lang_wild_statement_type *ptr;
1378      struct wildcard_list *sec;
1379      asection *section;
1380      lang_input_statement_type *file;
1381      PTR output;
1382 {
1383   lang_statement_union_type *before;
1384
1385   /* Exclude sections that match UNIQUE_SECTION_LIST.  */
1386   if (unique_section_p (bfd_get_section_name (file->the_bfd, section)))
1387     return;
1388
1389   /* If the wild pattern was marked KEEP, the member sections
1390      should be as well.  */
1391   if (ptr->keep_sections)
1392     section->flags |= SEC_KEEP;
1393
1394   before = wild_sort (ptr, sec, file, section);
1395
1396   /* Here BEFORE points to the lang_input_section which
1397      should follow the one we are about to add.  If BEFORE
1398      is NULL, then the section should just go at the end
1399      of the current list.  */
1400
1401   if (before == NULL)
1402     lang_add_section (&ptr->children, section,
1403                       (lang_output_section_statement_type *) output,
1404                       file);
1405   else
1406     {
1407       lang_statement_list_type list;
1408       lang_statement_union_type **pp;
1409
1410       lang_list_init (&list);
1411       lang_add_section (&list, section,
1412                         (lang_output_section_statement_type *) output,
1413                         file);
1414
1415       /* If we are discarding the section, LIST.HEAD will
1416          be NULL.  */
1417       if (list.head != NULL)
1418         {
1419           ASSERT (list.head->header.next == NULL);
1420
1421           for (pp = &ptr->children.head;
1422                *pp != before;
1423                pp = &(*pp)->header.next)
1424             ASSERT (*pp != NULL);
1425
1426           list.head->header.next = *pp;
1427           *pp = list.head;
1428         }
1429     }
1430 }
1431
1432 /* This is passed a file name which must have been seen already and
1433    added to the statement tree.  We will see if it has been opened
1434    already and had its symbols read.  If not then we'll read it.  */
1435
1436 static lang_input_statement_type *
1437 lookup_name (name)
1438      const char *name;
1439 {
1440   lang_input_statement_type *search;
1441
1442   for (search = (lang_input_statement_type *) input_file_chain.head;
1443        search != (lang_input_statement_type *) NULL;
1444        search = (lang_input_statement_type *) search->next_real_file)
1445     {
1446       if (search->filename == (char *) NULL && name == (char *) NULL)
1447         return search;
1448       if (search->filename != (char *) NULL
1449           && name != (char *) NULL
1450           && strcmp (search->filename, name) == 0)
1451         break;
1452     }
1453
1454   if (search == (lang_input_statement_type *) NULL)
1455     search = new_afile (name, lang_input_file_is_file_enum, default_target,
1456                         false);
1457
1458   /* If we have already added this file, or this file is not real
1459      (FIXME: can that ever actually happen?) or the name is NULL
1460      (FIXME: can that ever actually happen?) don't add this file.  */
1461   if (search->loaded
1462       || ! search->real
1463       || search->filename == (const char *) NULL)
1464     return search;
1465
1466   if (! load_symbols (search, (lang_statement_list_type *) NULL))
1467     return NULL;
1468
1469   return search;
1470 }
1471
1472 /* Get the symbols for an input file.  */
1473
1474 static boolean
1475 load_symbols (entry, place)
1476      lang_input_statement_type *entry;
1477      lang_statement_list_type *place;
1478 {
1479   char **matching;
1480
1481   if (entry->loaded)
1482     return true;
1483
1484   ldfile_open_file (entry);
1485
1486   if (! bfd_check_format (entry->the_bfd, bfd_archive)
1487       && ! bfd_check_format_matches (entry->the_bfd, bfd_object, &matching))
1488     {
1489       bfd_error_type err;
1490       lang_statement_list_type *hold;
1491       boolean bad_load = true;
1492
1493       err = bfd_get_error ();
1494
1495       /* See if the emulation has some special knowledge.  */
1496       if (ldemul_unrecognized_file (entry))
1497         return true;
1498
1499       if (err == bfd_error_file_ambiguously_recognized)
1500         {
1501           char **p;
1502
1503           einfo (_("%B: file not recognized: %E\n"), entry->the_bfd);
1504           einfo (_("%B: matching formats:"), entry->the_bfd);
1505           for (p = matching; *p != NULL; p++)
1506             einfo (" %s", *p);
1507           einfo ("%F\n");
1508         }
1509       else if (err != bfd_error_file_not_recognized
1510                || place == NULL)
1511           einfo (_("%F%B: file not recognized: %E\n"), entry->the_bfd);
1512       else
1513         bad_load = false;
1514
1515       bfd_close (entry->the_bfd);
1516       entry->the_bfd = NULL;
1517
1518       /* Try to interpret the file as a linker script.  */
1519       ldfile_open_command_file (entry->filename);
1520
1521       hold = stat_ptr;
1522       stat_ptr = place;
1523
1524       ldfile_assumed_script = true;
1525       parser_input = input_script;
1526       yyparse ();
1527       ldfile_assumed_script = false;
1528
1529       stat_ptr = hold;
1530
1531       return ! bad_load;
1532     }
1533
1534   if (ldemul_recognized_file (entry))
1535     return true;
1536
1537   /* We don't call ldlang_add_file for an archive.  Instead, the
1538      add_symbols entry point will call ldlang_add_file, via the
1539      add_archive_element callback, for each element of the archive
1540      which is used.  */
1541   switch (bfd_get_format (entry->the_bfd))
1542     {
1543     default:
1544       break;
1545
1546     case bfd_object:
1547       ldlang_add_file (entry);
1548       if (trace_files || trace_file_tries)
1549         info_msg ("%I\n", entry);
1550       break;
1551
1552     case bfd_archive:
1553       if (entry->whole_archive)
1554         {
1555           bfd *member = NULL;
1556           boolean loaded = true;
1557
1558           for (;;)
1559             {
1560               member = bfd_openr_next_archived_file (entry->the_bfd, member);
1561
1562               if (member == NULL)
1563                 break;
1564
1565               if (! bfd_check_format (member, bfd_object))
1566                 {
1567                   einfo (_("%F%B: member %B in archive is not an object\n"),
1568                          entry->the_bfd, member);
1569                   loaded = false;
1570                 }
1571
1572               if (! ((*link_info.callbacks->add_archive_element)
1573                      (&link_info, member, "--whole-archive")))
1574                 abort ();
1575
1576               if (! bfd_link_add_symbols (member, &link_info))
1577                 {
1578                   einfo (_("%F%B: could not read symbols: %E\n"), member);
1579                   loaded = false;
1580                 }
1581             }
1582
1583           entry->loaded = loaded;
1584           return loaded;
1585         }
1586       break;
1587     }
1588
1589   if (bfd_link_add_symbols (entry->the_bfd, &link_info))
1590     entry->loaded = true;
1591   else
1592     einfo (_("%F%B: could not read symbols: %E\n"), entry->the_bfd);
1593
1594   return entry->loaded;
1595 }
1596
1597 /* Handle a wild statement.  S->FILENAME or S->SECTION_LIST or both
1598    may be NULL, indicating that it is a wildcard.  Separate
1599    lang_input_section statements are created for each part of the
1600    expansion; they are added after the wild statement S.  OUTPUT is
1601    the output section.  */
1602
1603 static void
1604 wild (s, target, output)
1605      lang_wild_statement_type *s;
1606      const char *target ATTRIBUTE_UNUSED;
1607      lang_output_section_statement_type *output;
1608 {
1609   struct wildcard_list *sec;
1610
1611   walk_wild (s, output_section_callback, (PTR) output);
1612
1613   for (sec = s->section_list; sec != NULL; sec = sec->next)
1614     {
1615       if (default_common_section != NULL)
1616         break;
1617       if (sec->spec.name != NULL && strcmp (sec->spec.name, "COMMON") == 0)
1618         {
1619           /* Remember the section that common is going to in case we
1620              later get something which doesn't know where to put it.  */
1621           default_common_section = output;
1622         }
1623     }
1624 }
1625
1626 /* Return true iff target is the sought target.  */
1627
1628 static int
1629 get_target (target, data)
1630      const bfd_target *target;
1631      PTR data;
1632 {
1633   const char *sought = (const char *) data;
1634
1635   return strcmp (target->name, sought) == 0;
1636 }
1637
1638 /* Like strcpy() but convert to lower case as well.  */
1639
1640 static void
1641 stricpy (dest, src)
1642      char *dest;
1643      char *src;
1644 {
1645   char c;
1646
1647   while ((c = *src++) != 0)
1648     *dest++ = TOLOWER (c);
1649
1650   *dest = 0;
1651 }
1652
1653 /* Remove the first occurance of needle (if any) in haystack
1654    from haystack.  */
1655
1656 static void
1657 strcut (haystack, needle)
1658      char *haystack;
1659      char *needle;
1660 {
1661   haystack = strstr (haystack, needle);
1662
1663   if (haystack)
1664     {
1665       char *src;
1666
1667       for (src = haystack + strlen (needle); *src;)
1668         *haystack++ = *src++;
1669
1670       *haystack = 0;
1671     }
1672 }
1673
1674 /* Compare two target format name strings.
1675    Return a value indicating how "similar" they are.  */
1676
1677 static int
1678 name_compare (first, second)
1679      char *first;
1680      char *second;
1681 {
1682   char *copy1;
1683   char *copy2;
1684   int result;
1685
1686   copy1 = xmalloc (strlen (first) + 1);
1687   copy2 = xmalloc (strlen (second) + 1);
1688
1689   /* Convert the names to lower case.  */
1690   stricpy (copy1, first);
1691   stricpy (copy2, second);
1692
1693   /* Remove and endian strings from the name.  */
1694   strcut (copy1, "big");
1695   strcut (copy1, "little");
1696   strcut (copy2, "big");
1697   strcut (copy2, "little");
1698
1699   /* Return a value based on how many characters match,
1700      starting from the beginning.   If both strings are
1701      the same then return 10 * their length.  */
1702   for (result = 0; copy1[result] == copy2[result]; result++)
1703     if (copy1[result] == 0)
1704       {
1705         result *= 10;
1706         break;
1707       }
1708
1709   free (copy1);
1710   free (copy2);
1711
1712   return result;
1713 }
1714
1715 /* Set by closest_target_match() below.  */
1716 static const bfd_target *winner;
1717
1718 /* Scan all the valid bfd targets looking for one that has the endianness
1719    requirement that was specified on the command line, and is the nearest
1720    match to the original output target.  */
1721
1722 static int
1723 closest_target_match (target, data)
1724      const bfd_target *target;
1725      PTR data;
1726 {
1727   const bfd_target *original = (const bfd_target *) data;
1728
1729   if (command_line.endian == ENDIAN_BIG
1730       && target->byteorder != BFD_ENDIAN_BIG)
1731     return 0;
1732
1733   if (command_line.endian == ENDIAN_LITTLE
1734       && target->byteorder != BFD_ENDIAN_LITTLE)
1735     return 0;
1736
1737   /* Must be the same flavour.  */
1738   if (target->flavour != original->flavour)
1739     return 0;
1740
1741   /* If we have not found a potential winner yet, then record this one.  */
1742   if (winner == NULL)
1743     {
1744       winner = target;
1745       return 0;
1746     }
1747
1748   /* Oh dear, we now have two potential candidates for a successful match.
1749      Compare their names and choose the better one.  */
1750   if (name_compare (target->name, original->name)
1751       > name_compare (winner->name, original->name))
1752     winner = target;
1753
1754   /* Keep on searching until wqe have checked them all.  */
1755   return 0;
1756 }
1757
1758 /* Return the BFD target format of the first input file.  */
1759
1760 static char *
1761 get_first_input_target ()
1762 {
1763   char *target = NULL;
1764
1765   LANG_FOR_EACH_INPUT_STATEMENT (s)
1766     {
1767       if (s->header.type == lang_input_statement_enum
1768           && s->real)
1769         {
1770           ldfile_open_file (s);
1771
1772           if (s->the_bfd != NULL
1773               && bfd_check_format (s->the_bfd, bfd_object))
1774             {
1775               target = bfd_get_target (s->the_bfd);
1776
1777               if (target != NULL)
1778                 break;
1779             }
1780         }
1781     }
1782
1783   return target;
1784 }
1785
1786 /* Open the output file.  */
1787
1788 static bfd *
1789 open_output (name)
1790      const char *name;
1791 {
1792   bfd *output;
1793
1794   /* Has the user told us which output format to use?  */
1795   if (output_target == (char *) NULL)
1796     {
1797       /* No - has the current target been set to something other than
1798          the default?  */
1799       if (current_target != default_target)
1800         output_target = current_target;
1801
1802       /* No - can we determine the format of the first input file?  */
1803       else
1804         {
1805           output_target = get_first_input_target ();
1806
1807           /* Failed - use the default output target.  */
1808           if (output_target == NULL)
1809             output_target = default_target;
1810         }
1811     }
1812
1813   /* Has the user requested a particular endianness on the command
1814      line?  */
1815   if (command_line.endian != ENDIAN_UNSET)
1816     {
1817       const bfd_target *target;
1818       enum bfd_endian desired_endian;
1819
1820       /* Get the chosen target.  */
1821       target = bfd_search_for_target (get_target, (PTR) output_target);
1822
1823       /* If the target is not supported, we cannot do anything.  */
1824       if (target != NULL)
1825         {
1826           if (command_line.endian == ENDIAN_BIG)
1827             desired_endian = BFD_ENDIAN_BIG;
1828           else
1829             desired_endian = BFD_ENDIAN_LITTLE;
1830
1831           /* See if the target has the wrong endianness.  This should
1832              not happen if the linker script has provided big and
1833              little endian alternatives, but some scrips don't do
1834              this.  */
1835           if (target->byteorder != desired_endian)
1836             {
1837               /* If it does, then see if the target provides
1838                  an alternative with the correct endianness.  */
1839               if (target->alternative_target != NULL
1840                   && (target->alternative_target->byteorder == desired_endian))
1841                 output_target = target->alternative_target->name;
1842               else
1843                 {
1844                   /* Try to find a target as similar as possible to
1845                      the default target, but which has the desired
1846                      endian characteristic.  */
1847                   (void) bfd_search_for_target (closest_target_match,
1848                                                 (PTR) target);
1849
1850                   /* Oh dear - we could not find any targets that
1851                      satisfy our requirements.  */
1852                   if (winner == NULL)
1853                     einfo (_("%P: warning: could not find any targets that match endianness requirement\n"));
1854                   else
1855                     output_target = winner->name;
1856                 }
1857             }
1858         }
1859     }
1860
1861   output = bfd_openw (name, output_target);
1862
1863   if (output == (bfd *) NULL)
1864     {
1865       if (bfd_get_error () == bfd_error_invalid_target)
1866         einfo (_("%P%F: target %s not found\n"), output_target);
1867
1868       einfo (_("%P%F: cannot open output file %s: %E\n"), name);
1869     }
1870
1871   delete_output_file_on_failure = true;
1872
1873 #if 0
1874   output->flags |= D_PAGED;
1875 #endif
1876
1877   if (! bfd_set_format (output, bfd_object))
1878     einfo (_("%P%F:%s: can not make object file: %E\n"), name);
1879   if (! bfd_set_arch_mach (output,
1880                            ldfile_output_architecture,
1881                            ldfile_output_machine))
1882     einfo (_("%P%F:%s: can not set architecture: %E\n"), name);
1883
1884   link_info.hash = bfd_link_hash_table_create (output);
1885   if (link_info.hash == (struct bfd_link_hash_table *) NULL)
1886     einfo (_("%P%F: can not create link hash table: %E\n"));
1887
1888   bfd_set_gp_size (output, g_switch_value);
1889   return output;
1890 }
1891
1892 static void
1893 ldlang_open_output (statement)
1894      lang_statement_union_type *statement;
1895 {
1896   switch (statement->header.type)
1897     {
1898     case lang_output_statement_enum:
1899       ASSERT (output_bfd == (bfd *) NULL);
1900       output_bfd = open_output (statement->output_statement.name);
1901       ldemul_set_output_arch ();
1902       if (config.magic_demand_paged && !link_info.relocateable)
1903         output_bfd->flags |= D_PAGED;
1904       else
1905         output_bfd->flags &= ~D_PAGED;
1906       if (config.text_read_only)
1907         output_bfd->flags |= WP_TEXT;
1908       else
1909         output_bfd->flags &= ~WP_TEXT;
1910       if (link_info.traditional_format)
1911         output_bfd->flags |= BFD_TRADITIONAL_FORMAT;
1912       else
1913         output_bfd->flags &= ~BFD_TRADITIONAL_FORMAT;
1914       break;
1915
1916     case lang_target_statement_enum:
1917       current_target = statement->target_statement.target;
1918       break;
1919     default:
1920       break;
1921     }
1922 }
1923
1924 /* Open all the input files.  */
1925
1926 static void
1927 open_input_bfds (s, force)
1928      lang_statement_union_type *s;
1929      boolean force;
1930 {
1931   for (; s != (lang_statement_union_type *) NULL; s = s->header.next)
1932     {
1933       switch (s->header.type)
1934         {
1935         case lang_constructors_statement_enum:
1936           open_input_bfds (constructor_list.head, force);
1937           break;
1938         case lang_output_section_statement_enum:
1939           open_input_bfds (s->output_section_statement.children.head, force);
1940           break;
1941         case lang_wild_statement_enum:
1942           /* Maybe we should load the file's symbols.  */
1943           if (s->wild_statement.filename
1944               && ! wildcardp (s->wild_statement.filename))
1945             (void) lookup_name (s->wild_statement.filename);
1946           open_input_bfds (s->wild_statement.children.head, force);
1947           break;
1948         case lang_group_statement_enum:
1949           {
1950             struct bfd_link_hash_entry *undefs;
1951
1952             /* We must continually search the entries in the group
1953                until no new symbols are added to the list of undefined
1954                symbols.  */
1955
1956             do
1957               {
1958                 undefs = link_info.hash->undefs_tail;
1959                 open_input_bfds (s->group_statement.children.head, true);
1960               }
1961             while (undefs != link_info.hash->undefs_tail);
1962           }
1963           break;
1964         case lang_target_statement_enum:
1965           current_target = s->target_statement.target;
1966           break;
1967         case lang_input_statement_enum:
1968           if (s->input_statement.real)
1969             {
1970               lang_statement_list_type add;
1971
1972               s->input_statement.target = current_target;
1973
1974               /* If we are being called from within a group, and this
1975                  is an archive which has already been searched, then
1976                  force it to be researched unless the whole archive
1977                  has been loaded already.  */
1978               if (force
1979                   && !s->input_statement.whole_archive
1980                   && s->input_statement.loaded
1981                   && bfd_check_format (s->input_statement.the_bfd,
1982                                        bfd_archive))
1983                 s->input_statement.loaded = false;
1984
1985               lang_list_init (&add);
1986
1987               if (! load_symbols (&s->input_statement, &add))
1988                 config.make_executable = false;
1989
1990               if (add.head != NULL)
1991                 {
1992                   *add.tail = s->header.next;
1993                   s->header.next = add.head;
1994                 }
1995             }
1996           break;
1997         default:
1998           break;
1999         }
2000     }
2001 }
2002
2003 /* If there are [COMMONS] statements, put a wild one into the bss
2004    section.  */
2005
2006 static void
2007 lang_reasonable_defaults ()
2008 {
2009 #if 0
2010   lang_output_section_statement_lookup (".text");
2011   lang_output_section_statement_lookup (".data");
2012
2013   default_common_section = lang_output_section_statement_lookup (".bss");
2014
2015   if (placed_commons == false)
2016     {
2017       lang_wild_statement_type *new =
2018       new_stat (lang_wild_statement,
2019                 &default_common_section->children);
2020
2021       new->section_name = "COMMON";
2022       new->filename = (char *) NULL;
2023       lang_list_init (&new->children);
2024     }
2025 #endif
2026 }
2027
2028 /* Add the supplied name to the symbol table as an undefined reference.
2029    This is a two step process as the symbol table doesn't even exist at
2030    the time the ld command line is processed.  First we put the name
2031    on a list, then, once the output file has been opened, transfer the
2032    name to the symbol table.  */
2033
2034 typedef struct bfd_sym_chain ldlang_undef_chain_list_type;
2035
2036 #define ldlang_undef_chain_list_head entry_symbol.next
2037
2038 void
2039 ldlang_add_undef (name)
2040      const char *const name;
2041 {
2042   ldlang_undef_chain_list_type *new =
2043     ((ldlang_undef_chain_list_type *)
2044      stat_alloc (sizeof (ldlang_undef_chain_list_type)));
2045
2046   new->next = ldlang_undef_chain_list_head;
2047   ldlang_undef_chain_list_head = new;
2048
2049   new->name = xstrdup (name);
2050
2051   if (output_bfd != NULL)
2052     insert_undefined (new->name);
2053 }
2054
2055 /* Insert NAME as undefined in the symbol table.  */
2056
2057 static void
2058 insert_undefined (name)
2059      const char *name;
2060 {
2061   struct bfd_link_hash_entry *h;
2062
2063   h = bfd_link_hash_lookup (link_info.hash, name, true, false, true);
2064   if (h == (struct bfd_link_hash_entry *) NULL)
2065     einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
2066   if (h->type == bfd_link_hash_new)
2067     {
2068       h->type = bfd_link_hash_undefined;
2069       h->u.undef.abfd = NULL;
2070       bfd_link_add_undef (link_info.hash, h);
2071     }
2072 }
2073
2074 /* Run through the list of undefineds created above and place them
2075    into the linker hash table as undefined symbols belonging to the
2076    script file.  */
2077
2078 static void
2079 lang_place_undefineds ()
2080 {
2081   ldlang_undef_chain_list_type *ptr;
2082
2083   for (ptr = ldlang_undef_chain_list_head;
2084        ptr != (ldlang_undef_chain_list_type *) NULL;
2085        ptr = ptr->next)
2086     {
2087       insert_undefined (ptr->name);
2088     }
2089 }
2090
2091 /* Open input files and attatch to output sections.  */
2092
2093 static void
2094 map_input_to_output_sections (s, target, output_section_statement)
2095      lang_statement_union_type *s;
2096      const char *target;
2097      lang_output_section_statement_type *output_section_statement;
2098 {
2099   for (; s != (lang_statement_union_type *) NULL; s = s->header.next)
2100     {
2101       switch (s->header.type)
2102         {
2103         case lang_wild_statement_enum:
2104           wild (&s->wild_statement, target, output_section_statement);
2105           break;
2106         case lang_constructors_statement_enum:
2107           map_input_to_output_sections (constructor_list.head,
2108                                         target,
2109                                         output_section_statement);
2110           break;
2111         case lang_output_section_statement_enum:
2112           map_input_to_output_sections (s->output_section_statement.children.head,
2113                                         target,
2114                                         &s->output_section_statement);
2115           break;
2116         case lang_output_statement_enum:
2117           break;
2118         case lang_target_statement_enum:
2119           target = s->target_statement.target;
2120           break;
2121         case lang_group_statement_enum:
2122           map_input_to_output_sections (s->group_statement.children.head,
2123                                         target,
2124                                         output_section_statement);
2125           break;
2126         case lang_fill_statement_enum:
2127         case lang_input_section_enum:
2128         case lang_object_symbols_statement_enum:
2129         case lang_data_statement_enum:
2130         case lang_reloc_statement_enum:
2131         case lang_padding_statement_enum:
2132         case lang_input_statement_enum:
2133           if (output_section_statement != NULL
2134               && output_section_statement->bfd_section == NULL)
2135             init_os (output_section_statement);
2136           break;
2137         case lang_assignment_statement_enum:
2138           if (output_section_statement != NULL
2139               && output_section_statement->bfd_section == NULL)
2140             init_os (output_section_statement);
2141
2142           /* Make sure that any sections mentioned in the assignment
2143              are initialized.  */
2144           exp_init_os (s->assignment_statement.exp);
2145           break;
2146         case lang_afile_asection_pair_statement_enum:
2147           FAIL ();
2148           break;
2149         case lang_address_statement_enum:
2150           /* Mark the specified section with the supplied address.  */
2151           {
2152             lang_output_section_statement_type *os =
2153               lang_output_section_statement_lookup
2154                 (s->address_statement.section_name);
2155
2156             if (os->bfd_section == NULL)
2157               init_os (os);
2158             os->addr_tree = s->address_statement.address;
2159           }
2160           break;
2161         }
2162     }
2163 }
2164
2165 /* An output section might have been removed after its statement was
2166    added.  For example, ldemul_before_allocation can remove dynamic
2167    sections if they turn out to be not needed.  Clean them up here.  */
2168
2169 static void
2170 strip_excluded_output_sections ()
2171 {
2172   lang_statement_union_type *u;
2173
2174   for (u = lang_output_section_statement.head;
2175        u != NULL;
2176        u = u->output_section_statement.next)
2177     {
2178       lang_output_section_statement_type *os;
2179       asection *s;
2180
2181       os = &u->output_section_statement;
2182       s = os->bfd_section;
2183       if (s != NULL && (s->flags & SEC_EXCLUDE) != 0)
2184         {
2185           asection **p;
2186
2187           os->bfd_section = NULL;
2188
2189           for (p = &output_bfd->sections; *p; p = &(*p)->next)
2190             if (*p == s)
2191               {
2192                 bfd_section_list_remove (output_bfd, p);
2193                 output_bfd->section_count--;
2194                 break;
2195               }
2196         }
2197     }
2198 }
2199
2200 static void
2201 print_output_section_statement (output_section_statement)
2202      lang_output_section_statement_type *output_section_statement;
2203 {
2204   asection *section = output_section_statement->bfd_section;
2205   int len;
2206
2207   if (output_section_statement != abs_output_section)
2208     {
2209       minfo ("\n%s", output_section_statement->name);
2210
2211       if (section != NULL)
2212         {
2213           print_dot = section->vma;
2214
2215           len = strlen (output_section_statement->name);
2216           if (len >= SECTION_NAME_MAP_LENGTH - 1)
2217             {
2218               print_nl ();
2219               len = 0;
2220             }
2221           while (len < SECTION_NAME_MAP_LENGTH)
2222             {
2223               print_space ();
2224               ++len;
2225             }
2226
2227           minfo ("0x%V %W", section->vma, section->_raw_size);
2228
2229           if (output_section_statement->load_base != NULL)
2230             {
2231               bfd_vma addr;
2232
2233               addr = exp_get_abs_int (output_section_statement->load_base, 0,
2234                                       "load base", lang_final_phase_enum);
2235               minfo (_(" load address 0x%V"), addr);
2236             }
2237         }
2238
2239       print_nl ();
2240     }
2241
2242   print_statement_list (output_section_statement->children.head,
2243                         output_section_statement);
2244 }
2245
2246 static void
2247 print_assignment (assignment, output_section)
2248      lang_assignment_statement_type *assignment;
2249      lang_output_section_statement_type *output_section;
2250 {
2251   int i;
2252   etree_value_type result;
2253
2254   for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
2255     print_space ();
2256
2257   result = exp_fold_tree (assignment->exp->assign.src, output_section,
2258                           lang_final_phase_enum, print_dot, &print_dot);
2259   if (result.valid_p)
2260     {
2261       const char *dst;
2262       bfd_vma value;
2263
2264       value = result.value + result.section->bfd_section->vma;
2265       dst = assignment->exp->assign.dst;
2266
2267       minfo ("0x%V", value);
2268       if (dst[0] == '.' && dst[1] == 0)
2269         print_dot = value;
2270     }
2271   else
2272     {
2273       minfo ("*undef*   ");
2274 #ifdef BFD64
2275       minfo ("        ");
2276 #endif
2277     }
2278
2279   minfo ("                ");
2280
2281   exp_print_tree (assignment->exp);
2282
2283   print_nl ();
2284 }
2285
2286 static void
2287 print_input_statement (statm)
2288      lang_input_statement_type *statm;
2289 {
2290   if (statm->filename != (char *) NULL)
2291     {
2292       fprintf (config.map_file, "LOAD %s\n", statm->filename);
2293     }
2294 }
2295
2296 /* Print all symbols defined in a particular section.  This is called
2297    via bfd_link_hash_traverse.  */
2298
2299 static boolean
2300 print_one_symbol (hash_entry, ptr)
2301      struct bfd_link_hash_entry *hash_entry;
2302      PTR ptr;
2303 {
2304   asection *sec = (asection *) ptr;
2305
2306   if ((hash_entry->type == bfd_link_hash_defined
2307        || hash_entry->type == bfd_link_hash_defweak)
2308       && sec == hash_entry->u.def.section)
2309     {
2310       int i;
2311
2312       for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
2313         print_space ();
2314       minfo ("0x%V   ",
2315              (hash_entry->u.def.value
2316               + hash_entry->u.def.section->output_offset
2317               + hash_entry->u.def.section->output_section->vma));
2318
2319       minfo ("             %T\n", hash_entry->root.string);
2320     }
2321
2322   return true;
2323 }
2324
2325 /* Print information about an input section to the map file.  */
2326
2327 static void
2328 print_input_section (in)
2329      lang_input_section_type *in;
2330 {
2331   asection *i = in->section;
2332   bfd_size_type size = i->_cooked_size != 0 ? i->_cooked_size : i->_raw_size;
2333   unsigned opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
2334                                                 ldfile_output_machine);
2335   if (size != 0)
2336     {
2337       print_space ();
2338
2339       minfo ("%s", i->name);
2340
2341       if (i->output_section != NULL)
2342         {
2343           int len;
2344
2345           len = 1 + strlen (i->name);
2346           if (len >= SECTION_NAME_MAP_LENGTH - 1)
2347             {
2348               print_nl ();
2349               len = 0;
2350             }
2351           while (len < SECTION_NAME_MAP_LENGTH)
2352             {
2353               print_space ();
2354               ++len;
2355             }
2356
2357           minfo ("0x%V %W %B\n",
2358                  i->output_section->vma + i->output_offset, size / opb,
2359                  i->owner);
2360
2361           if (i->_cooked_size != 0 && i->_cooked_size != i->_raw_size)
2362             {
2363               len = SECTION_NAME_MAP_LENGTH + 3;
2364 #ifdef BFD64
2365               len += 16;
2366 #else
2367               len += 8;
2368 #endif
2369               while (len > 0)
2370                 {
2371                   print_space ();
2372                   --len;
2373                 }
2374
2375               minfo (_("%W (size before relaxing)\n"), i->_raw_size);
2376             }
2377
2378           bfd_link_hash_traverse (link_info.hash, print_one_symbol, (PTR) i);
2379
2380           print_dot = i->output_section->vma + i->output_offset + size / opb;
2381         }
2382     }
2383 }
2384
2385 static void
2386 print_fill_statement (fill)
2387      lang_fill_statement_type *fill;
2388 {
2389   size_t size;
2390   unsigned char *p;
2391   fputs (" FILL mask 0x", config.map_file);
2392   for (p = fill->fill->data, size = fill->fill->size; size != 0; p++, size--)
2393     fprintf (config.map_file, "%02x", *p);
2394   fputs ("\n", config.map_file);
2395 }
2396
2397 static void
2398 print_data_statement (data)
2399      lang_data_statement_type *data;
2400 {
2401   int i;
2402   bfd_vma addr;
2403   bfd_size_type size;
2404   const char *name;
2405   unsigned opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
2406                                                 ldfile_output_machine);
2407
2408   for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
2409     print_space ();
2410
2411   addr = data->output_vma;
2412   if (data->output_section != NULL)
2413     addr += data->output_section->vma;
2414
2415   switch (data->type)
2416     {
2417     default:
2418       abort ();
2419     case BYTE:
2420       size = BYTE_SIZE;
2421       name = "BYTE";
2422       break;
2423     case SHORT:
2424       size = SHORT_SIZE;
2425       name = "SHORT";
2426       break;
2427     case LONG:
2428       size = LONG_SIZE;
2429       name = "LONG";
2430       break;
2431     case QUAD:
2432       size = QUAD_SIZE;
2433       name = "QUAD";
2434       break;
2435     case SQUAD:
2436       size = QUAD_SIZE;
2437       name = "SQUAD";
2438       break;
2439     }
2440
2441   minfo ("0x%V %W %s 0x%v", addr, size, name, data->value);
2442
2443   if (data->exp->type.node_class != etree_value)
2444     {
2445       print_space ();
2446       exp_print_tree (data->exp);
2447     }
2448
2449   print_nl ();
2450
2451   print_dot = addr + size / opb;
2452
2453 }
2454
2455 /* Print an address statement.  These are generated by options like
2456    -Ttext.  */
2457
2458 static void
2459 print_address_statement (address)
2460      lang_address_statement_type *address;
2461 {
2462   minfo (_("Address of section %s set to "), address->section_name);
2463   exp_print_tree (address->address);
2464   print_nl ();
2465 }
2466
2467 /* Print a reloc statement.  */
2468
2469 static void
2470 print_reloc_statement (reloc)
2471      lang_reloc_statement_type *reloc;
2472 {
2473   int i;
2474   bfd_vma addr;
2475   bfd_size_type size;
2476   unsigned opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
2477                                                 ldfile_output_machine);
2478
2479   for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
2480     print_space ();
2481
2482   addr = reloc->output_vma;
2483   if (reloc->output_section != NULL)
2484     addr += reloc->output_section->vma;
2485
2486   size = bfd_get_reloc_size (reloc->howto);
2487
2488   minfo ("0x%V %W RELOC %s ", addr, size, reloc->howto->name);
2489
2490   if (reloc->name != NULL)
2491     minfo ("%s+", reloc->name);
2492   else
2493     minfo ("%s+", reloc->section->name);
2494
2495   exp_print_tree (reloc->addend_exp);
2496
2497   print_nl ();
2498
2499   print_dot = addr + size / opb;
2500 }
2501
2502 static void
2503 print_padding_statement (s)
2504      lang_padding_statement_type *s;
2505 {
2506   int len;
2507   bfd_vma addr;
2508   unsigned opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
2509                                                 ldfile_output_machine);
2510
2511   minfo (" *fill*");
2512
2513   len = sizeof " *fill*" - 1;
2514   while (len < SECTION_NAME_MAP_LENGTH)
2515     {
2516       print_space ();
2517       ++len;
2518     }
2519
2520   addr = s->output_offset;
2521   if (s->output_section != NULL)
2522     addr += s->output_section->vma;
2523   minfo ("0x%V %W ", addr, s->size);
2524
2525   if (s->fill->size != 0)
2526     {
2527       size_t size;
2528       unsigned char *p;
2529       for (p = s->fill->data, size = s->fill->size; size != 0; p++, size--)
2530         fprintf (config.map_file, "%02x", *p);
2531     }
2532
2533   print_nl ();
2534
2535   print_dot = addr + s->size / opb;
2536 }
2537
2538 static void
2539 print_wild_statement (w, os)
2540      lang_wild_statement_type *w;
2541      lang_output_section_statement_type *os;
2542 {
2543   struct wildcard_list *sec;
2544
2545   print_space ();
2546
2547   if (w->filenames_sorted)
2548     minfo ("SORT(");
2549   if (w->filename != NULL)
2550     minfo ("%s", w->filename);
2551   else
2552     minfo ("*");
2553   if (w->filenames_sorted)
2554     minfo (")");
2555
2556   minfo ("(");
2557   for (sec = w->section_list; sec; sec = sec->next)
2558     {
2559       if (sec->spec.sorted)
2560         minfo ("SORT(");
2561       if (sec->spec.exclude_name_list != NULL)
2562         {
2563           name_list *tmp;
2564           minfo ("EXCLUDE_FILE(%s", sec->spec.exclude_name_list->name);
2565           for (tmp = sec->spec.exclude_name_list->next; tmp; tmp = tmp->next)
2566             minfo (" %s", tmp->name);
2567           minfo (") ");
2568         }
2569       if (sec->spec.name != NULL)
2570         minfo ("%s", sec->spec.name);
2571       else
2572         minfo ("*");
2573       if (sec->spec.sorted)
2574         minfo (")");
2575       if (sec->next)
2576         minfo (" ");
2577     }
2578   minfo (")");
2579
2580   print_nl ();
2581
2582   print_statement_list (w->children.head, os);
2583 }
2584
2585 /* Print a group statement.  */
2586
2587 static void
2588 print_group (s, os)
2589      lang_group_statement_type *s;
2590      lang_output_section_statement_type *os;
2591 {
2592   fprintf (config.map_file, "START GROUP\n");
2593   print_statement_list (s->children.head, os);
2594   fprintf (config.map_file, "END GROUP\n");
2595 }
2596
2597 /* Print the list of statements in S.
2598    This can be called for any statement type.  */
2599
2600 static void
2601 print_statement_list (s, os)
2602      lang_statement_union_type *s;
2603      lang_output_section_statement_type *os;
2604 {
2605   while (s != NULL)
2606     {
2607       print_statement (s, os);
2608       s = s->header.next;
2609     }
2610 }
2611
2612 /* Print the first statement in statement list S.
2613    This can be called for any statement type.  */
2614
2615 static void
2616 print_statement (s, os)
2617      lang_statement_union_type *s;
2618      lang_output_section_statement_type *os;
2619 {
2620   switch (s->header.type)
2621     {
2622     default:
2623       fprintf (config.map_file, _("Fail with %d\n"), s->header.type);
2624       FAIL ();
2625       break;
2626     case lang_constructors_statement_enum:
2627       if (constructor_list.head != NULL)
2628         {
2629           if (constructors_sorted)
2630             minfo (" SORT (CONSTRUCTORS)\n");
2631           else
2632             minfo (" CONSTRUCTORS\n");
2633           print_statement_list (constructor_list.head, os);
2634         }
2635       break;
2636     case lang_wild_statement_enum:
2637       print_wild_statement (&s->wild_statement, os);
2638       break;
2639     case lang_address_statement_enum:
2640       print_address_statement (&s->address_statement);
2641       break;
2642     case lang_object_symbols_statement_enum:
2643       minfo (" CREATE_OBJECT_SYMBOLS\n");
2644       break;
2645     case lang_fill_statement_enum:
2646       print_fill_statement (&s->fill_statement);
2647       break;
2648     case lang_data_statement_enum:
2649       print_data_statement (&s->data_statement);
2650       break;
2651     case lang_reloc_statement_enum:
2652       print_reloc_statement (&s->reloc_statement);
2653       break;
2654     case lang_input_section_enum:
2655       print_input_section (&s->input_section);
2656       break;
2657     case lang_padding_statement_enum:
2658       print_padding_statement (&s->padding_statement);
2659       break;
2660     case lang_output_section_statement_enum:
2661       print_output_section_statement (&s->output_section_statement);
2662       break;
2663     case lang_assignment_statement_enum:
2664       print_assignment (&s->assignment_statement, os);
2665       break;
2666     case lang_target_statement_enum:
2667       fprintf (config.map_file, "TARGET(%s)\n", s->target_statement.target);
2668       break;
2669     case lang_output_statement_enum:
2670       minfo ("OUTPUT(%s", s->output_statement.name);
2671       if (output_target != NULL)
2672         minfo (" %s", output_target);
2673       minfo (")\n");
2674       break;
2675     case lang_input_statement_enum:
2676       print_input_statement (&s->input_statement);
2677       break;
2678     case lang_group_statement_enum:
2679       print_group (&s->group_statement, os);
2680       break;
2681     case lang_afile_asection_pair_statement_enum:
2682       FAIL ();
2683       break;
2684     }
2685 }
2686
2687 static void
2688 print_statements ()
2689 {
2690   print_statement_list (statement_list.head, abs_output_section);
2691 }
2692
2693 /* Print the first N statements in statement list S to STDERR.
2694    If N == 0, nothing is printed.
2695    If N < 0, the entire list is printed.
2696    Intended to be called from GDB.  */
2697
2698 void
2699 dprint_statement (s, n)
2700      lang_statement_union_type *s;
2701      int n;
2702 {
2703   FILE *map_save = config.map_file;
2704
2705   config.map_file = stderr;
2706
2707   if (n < 0)
2708     print_statement_list (s, abs_output_section);
2709   else
2710     {
2711       while (s && --n >= 0)
2712         {
2713           print_statement (s, abs_output_section);
2714           s = s->header.next;
2715         }
2716     }
2717
2718   config.map_file = map_save;
2719 }
2720
2721 static void
2722 insert_pad (ptr, fill, alignment_needed, output_section, dot)
2723      lang_statement_union_type **ptr;
2724      fill_type *fill;
2725      unsigned int alignment_needed;
2726      asection *output_section;
2727      bfd_vma dot;
2728 {
2729   static fill_type zero_fill = { 1, { 0 } };
2730   lang_statement_union_type *pad;
2731
2732   pad = ((lang_statement_union_type *)
2733          ((char *) ptr - offsetof (lang_statement_union_type, header.next)));
2734   if (ptr != &statement_list.head
2735       && pad->header.type == lang_padding_statement_enum
2736       && pad->padding_statement.output_section == output_section)
2737     {
2738       /* Use the existing pad statement.  The above test on output
2739          section is probably redundant, but it doesn't hurt to check.  */
2740     }
2741   else
2742     {
2743       /* Make a new padding statement, linked into existing chain.  */
2744       pad = ((lang_statement_union_type *)
2745              stat_alloc (sizeof (lang_padding_statement_type)));
2746       pad->header.next = *ptr;
2747       *ptr = pad;
2748       pad->header.type = lang_padding_statement_enum;
2749       pad->padding_statement.output_section = output_section;
2750       if (fill == (fill_type *) 0)
2751         fill = &zero_fill;
2752       pad->padding_statement.fill = fill;
2753     }
2754   pad->padding_statement.output_offset = dot - output_section->vma;
2755   pad->padding_statement.size = alignment_needed;
2756   output_section->_raw_size += alignment_needed;
2757 }
2758
2759 /* Work out how much this section will move the dot point.  */
2760
2761 static bfd_vma
2762 size_input_section (this_ptr, output_section_statement, fill, dot)
2763      lang_statement_union_type **this_ptr;
2764      lang_output_section_statement_type *output_section_statement;
2765      fill_type *fill;
2766      bfd_vma dot;
2767 {
2768   lang_input_section_type *is = &((*this_ptr)->input_section);
2769   asection *i = is->section;
2770
2771   if (is->ifile->just_syms_flag == false)
2772     {
2773       unsigned opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
2774                                                     ldfile_output_machine);
2775       unsigned int alignment_needed;
2776       asection *o;
2777
2778       /* Align this section first to the input sections requirement,
2779          then to the output section's requirement.  If this alignment
2780          is greater than any seen before, then record it too.  Perform
2781          the alignment by inserting a magic 'padding' statement.  */
2782
2783       if (output_section_statement->subsection_alignment != -1)
2784         i->alignment_power = output_section_statement->subsection_alignment;
2785
2786       o = output_section_statement->bfd_section;
2787       if (o->alignment_power < i->alignment_power)
2788         o->alignment_power = i->alignment_power;
2789
2790       alignment_needed = align_power (dot, i->alignment_power) - dot;
2791
2792       if (alignment_needed != 0)
2793         {
2794           insert_pad (this_ptr, fill, alignment_needed * opb, o, dot);
2795           dot += alignment_needed;
2796         }
2797
2798       /* Remember where in the output section this input section goes.  */
2799
2800       i->output_offset = dot - o->vma;
2801
2802       /* Mark how big the output section must be to contain this now.  */
2803       if (i->_cooked_size != 0)
2804         dot += i->_cooked_size / opb;
2805       else
2806         dot += i->_raw_size / opb;
2807       o->_raw_size = (dot - o->vma) * opb;
2808     }
2809   else
2810     {
2811       i->output_offset = i->vma - output_section_statement->bfd_section->vma;
2812     }
2813
2814   return dot;
2815 }
2816
2817 #define IGNORE_SECTION(bfd, s) \
2818   (((bfd_get_section_flags (bfd, s) & (SEC_ALLOC | SEC_LOAD))   \
2819     != (SEC_ALLOC | SEC_LOAD))                                  \
2820    || bfd_section_size (bfd, s) == 0)
2821
2822 /* Check to see if any allocated sections overlap with other allocated
2823    sections.  This can happen when the linker script specifically specifies
2824    the output section addresses of the two sections.  */
2825
2826 static void
2827 lang_check_section_addresses ()
2828 {
2829   asection *s;
2830   unsigned opb = bfd_octets_per_byte (output_bfd);
2831
2832   /* Scan all sections in the output list.  */
2833   for (s = output_bfd->sections; s != NULL; s = s->next)
2834     {
2835       asection *os;
2836
2837       /* Ignore sections which are not loaded or which have no contents.  */
2838       if (IGNORE_SECTION (output_bfd, s))
2839         continue;
2840
2841       /* Once we reach section 's' stop our seach.  This prevents two
2842          warning messages from being produced, one for 'section A overlaps
2843          section B' and one for 'section B overlaps section A'.  */
2844       for (os = output_bfd->sections; os != s; os = os->next)
2845         {
2846           bfd_vma s_start;
2847           bfd_vma s_end;
2848           bfd_vma os_start;
2849           bfd_vma os_end;
2850
2851           /* Only consider loadable sections with real contents.  */
2852           if (IGNORE_SECTION (output_bfd, os))
2853             continue;
2854
2855           /* We must check the sections' LMA addresses not their
2856              VMA addresses because overlay sections can have
2857              overlapping VMAs but they must have distinct LMAs.  */
2858           s_start  = bfd_section_lma (output_bfd, s);
2859           os_start = bfd_section_lma (output_bfd, os);
2860           s_end    = s_start  + bfd_section_size (output_bfd, s) / opb - 1;
2861           os_end   = os_start + bfd_section_size (output_bfd, os) / opb - 1;
2862
2863           /* Look for an overlap.  */
2864           if ((s_end < os_start) || (s_start > os_end))
2865             continue;
2866
2867           einfo (
2868 _("%X%P: section %s [%V -> %V] overlaps section %s [%V -> %V]\n"),
2869                  s->name, s_start, s_end, os->name, os_start, os_end);
2870
2871           /* Once we have found one overlap for this section,
2872              stop looking for others.  */
2873           break;
2874         }
2875     }
2876 }
2877
2878 /* Make sure the new address is within the region.  We explicitly permit the
2879    current address to be at the exact end of the region when the address is
2880    non-zero, in case the region is at the end of addressable memory and the
2881    calculation wraps around.  */
2882
2883 static void
2884 os_region_check (os, region, tree, base)
2885      lang_output_section_statement_type *os;
2886      struct memory_region_struct *region;
2887      etree_type *tree;
2888      bfd_vma base;
2889 {
2890   if ((region->current < region->origin
2891        || (region->current - region->origin > region->length))
2892       && ((region->current != region->origin + region->length)
2893           || base == 0))
2894     {
2895       if (tree != (etree_type *) NULL)
2896         {
2897           einfo (_("%X%P: address 0x%v of %B section %s is not within region %s\n"),
2898                  region->current,
2899                  os->bfd_section->owner,
2900                  os->bfd_section->name,
2901                  region->name);
2902         }
2903       else
2904         {
2905           einfo (_("%X%P: region %s is full (%B section %s)\n"),
2906                  region->name,
2907                  os->bfd_section->owner,
2908                  os->bfd_section->name);
2909         }
2910       /* Reset the region pointer.  */
2911       region->current = region->origin;
2912     }
2913 }
2914
2915 /* Set the sizes for all the output sections.  */
2916
2917 static bfd_vma
2918 lang_size_sections_1 (s, output_section_statement, prev, fill, dot, relax)
2919      lang_statement_union_type *s;
2920      lang_output_section_statement_type *output_section_statement;
2921      lang_statement_union_type **prev;
2922      fill_type *fill;
2923      bfd_vma dot;
2924      boolean *relax;
2925 {
2926   unsigned opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
2927                                                 ldfile_output_machine);
2928
2929   /* Size up the sections from their constituent parts.  */
2930   for (; s != (lang_statement_union_type *) NULL; s = s->header.next)
2931     {
2932       switch (s->header.type)
2933         {
2934         case lang_output_section_statement_enum:
2935           {
2936             bfd_vma after;
2937             lang_output_section_statement_type *os;
2938
2939             os = &s->output_section_statement;
2940             if (os->bfd_section == NULL)
2941               /* This section was never actually created.  */
2942               break;
2943
2944             /* If this is a COFF shared library section, use the size and
2945                address from the input section.  FIXME: This is COFF
2946                specific; it would be cleaner if there were some other way
2947                to do this, but nothing simple comes to mind.  */
2948             if ((os->bfd_section->flags & SEC_COFF_SHARED_LIBRARY) != 0)
2949               {
2950                 asection *input;
2951
2952                 if (os->children.head == NULL
2953                     || os->children.head->header.next != NULL
2954                     || os->children.head->header.type != lang_input_section_enum)
2955                   einfo (_("%P%X: Internal error on COFF shared library section %s\n"),
2956                          os->name);
2957
2958                 input = os->children.head->input_section.section;
2959                 bfd_set_section_vma (os->bfd_section->owner,
2960                                      os->bfd_section,
2961                                      bfd_section_vma (input->owner, input));
2962                 os->bfd_section->_raw_size = input->_raw_size;
2963                 break;
2964               }
2965
2966             if (bfd_is_abs_section (os->bfd_section))
2967               {
2968                 /* No matter what happens, an abs section starts at zero.  */
2969                 ASSERT (os->bfd_section->vma == 0);
2970               }
2971             else
2972               {
2973                 if (os->addr_tree == (etree_type *) NULL)
2974                   {
2975                     /* No address specified for this section, get one
2976                        from the region specification.  */
2977                     if (os->region == (lang_memory_region_type *) NULL
2978                         || (((bfd_get_section_flags (output_bfd, os->bfd_section)
2979                               & (SEC_ALLOC | SEC_LOAD)) != 0)
2980                             && os->region->name[0] == '*'
2981                             && strcmp (os->region->name, "*default*") == 0))
2982                       {
2983                         os->region = lang_memory_default (os->bfd_section);
2984                       }
2985
2986                     /* If a loadable section is using the default memory
2987                        region, and some non default memory regions were
2988                        defined, issue a warning.  */
2989                     if ((bfd_get_section_flags (output_bfd, os->bfd_section)
2990                          & (SEC_ALLOC | SEC_LOAD)) != 0
2991                         && (bfd_get_section_flags (output_bfd, os->bfd_section)
2992                             & SEC_NEVER_LOAD) == 0
2993                         && ! link_info.relocateable
2994                         && strcmp (os->region->name, "*default*") == 0
2995                         && lang_memory_region_list != NULL
2996                         && (strcmp (lang_memory_region_list->name,
2997                                     "*default*") != 0
2998                             || lang_memory_region_list->next != NULL))
2999                       einfo (_("%P: warning: no memory region specified for section `%s'\n"),
3000                              bfd_get_section_name (output_bfd,
3001                                                    os->bfd_section));
3002
3003                     dot = os->region->current;
3004
3005                     if (os->section_alignment == -1)
3006                       {
3007                         bfd_vma olddot;
3008
3009                         olddot = dot;
3010                         dot = align_power (dot,
3011                                            os->bfd_section->alignment_power);
3012
3013                         if (dot != olddot && config.warn_section_align)
3014                           einfo (_("%P: warning: changing start of section %s by %u bytes\n"),
3015                                  os->name, (unsigned int) (dot - olddot));
3016                       }
3017                   }
3018                 else
3019                   {
3020                     etree_value_type r;
3021
3022                     r = exp_fold_tree (os->addr_tree,
3023                                        abs_output_section,
3024                                        lang_allocating_phase_enum,
3025                                        dot, &dot);
3026                     if (r.valid_p == false)
3027                       {
3028                         einfo (_("%F%S: non constant address expression for section %s\n"),
3029                                os->name);
3030                       }
3031                     dot = r.value + r.section->bfd_section->vma;
3032                   }
3033
3034                 /* The section starts here.
3035                    First, align to what the section needs.  */
3036
3037                 if (os->section_alignment != -1)
3038                   dot = align_power (dot, os->section_alignment);
3039
3040                 bfd_set_section_vma (0, os->bfd_section, dot);
3041
3042                 os->bfd_section->output_offset = 0;
3043               }
3044
3045             lang_size_sections_1 (os->children.head, os, &os->children.head,
3046                                   os->fill, dot, relax);
3047
3048             /* Put the section within the requested block size, or
3049                align at the block boundary.  */
3050             after = ALIGN_N (os->bfd_section->vma
3051                              + os->bfd_section->_raw_size / opb,
3052                              /* The coercion here is important, see ld.h.  */
3053                              (bfd_vma) os->block_value);
3054
3055             if (bfd_is_abs_section (os->bfd_section))
3056               ASSERT (after == os->bfd_section->vma);
3057             else if ((os->bfd_section->flags & SEC_HAS_CONTENTS) == 0
3058                      && (os->bfd_section->flags & SEC_THREAD_LOCAL)
3059                      && ! link_info.relocateable)
3060               os->bfd_section->_raw_size = 0;
3061             else
3062               os->bfd_section->_raw_size =
3063                 (after - os->bfd_section->vma) * opb;
3064
3065             dot = os->bfd_section->vma + os->bfd_section->_raw_size / opb;
3066             os->processed = true;
3067
3068             if (os->update_dot_tree != 0)
3069               exp_fold_tree (os->update_dot_tree, abs_output_section,
3070                              lang_allocating_phase_enum, dot, &dot);
3071
3072             /* Update dot in the region ?
3073                We only do this if the section is going to be allocated,
3074                since unallocated sections do not contribute to the region's
3075                overall size in memory.
3076
3077                If the SEC_NEVER_LOAD bit is not set, it will affect the
3078                addresses of sections after it. We have to update
3079                dot.  */
3080             if (os->region != (lang_memory_region_type *) NULL
3081                 && ((bfd_get_section_flags (output_bfd, os->bfd_section)
3082                      & SEC_NEVER_LOAD) == 0
3083                     || (bfd_get_section_flags (output_bfd, os->bfd_section)
3084                         & (SEC_ALLOC | SEC_LOAD))))
3085               {
3086                 os->region->current = dot;
3087
3088                 /* Make sure the new address is within the region.  */
3089                 os_region_check (os, os->region, os->addr_tree,
3090                                  os->bfd_section->vma);
3091
3092                 /* If there's no load address specified, use the run
3093                    region as the load region.  */
3094                 if (os->lma_region == NULL && os->load_base == NULL)
3095                   os->lma_region = os->region;
3096
3097                 if (os->lma_region != NULL && os->lma_region != os->region)
3098                   {
3099                     /* Set load_base, which will be handled later.  */
3100                     os->load_base = exp_intop (os->lma_region->current);
3101                     os->lma_region->current +=
3102                       os->bfd_section->_raw_size / opb;
3103                     os_region_check (os, os->lma_region, NULL,
3104                                      os->bfd_section->lma);
3105                   }
3106               }
3107           }
3108           break;
3109
3110         case lang_constructors_statement_enum:
3111           dot = lang_size_sections_1 (constructor_list.head,
3112                                       output_section_statement,
3113                                       &s->wild_statement.children.head,
3114                                       fill, dot, relax);
3115           break;
3116
3117         case lang_data_statement_enum:
3118           {
3119             unsigned int size = 0;
3120
3121             s->data_statement.output_vma =
3122               dot - output_section_statement->bfd_section->vma;
3123             s->data_statement.output_section =
3124               output_section_statement->bfd_section;
3125
3126             switch (s->data_statement.type)
3127               {
3128               default:
3129                 abort ();
3130               case QUAD:
3131               case SQUAD:
3132                 size = QUAD_SIZE;
3133                 break;
3134               case LONG:
3135                 size = LONG_SIZE;
3136                 break;
3137               case SHORT:
3138                 size = SHORT_SIZE;
3139                 break;
3140               case BYTE:
3141                 size = BYTE_SIZE;
3142                 break;
3143               }
3144             if (size < opb)
3145               size = opb;
3146             dot += size / opb;
3147             output_section_statement->bfd_section->_raw_size += size;
3148             /* The output section gets contents, and then we inspect for
3149                any flags set in the input script which override any ALLOC.  */
3150             output_section_statement->bfd_section->flags |= SEC_HAS_CONTENTS;
3151             if (!(output_section_statement->flags & SEC_NEVER_LOAD))
3152               {
3153                 output_section_statement->bfd_section->flags |=
3154                   SEC_ALLOC | SEC_LOAD;
3155               }
3156           }
3157           break;
3158
3159         case lang_reloc_statement_enum:
3160           {
3161             int size;
3162
3163             s->reloc_statement.output_vma =
3164               dot - output_section_statement->bfd_section->vma;
3165             s->reloc_statement.output_section =
3166               output_section_statement->bfd_section;
3167             size = bfd_get_reloc_size (s->reloc_statement.howto);
3168             dot += size / opb;
3169             output_section_statement->bfd_section->_raw_size += size;
3170           }
3171           break;
3172
3173         case lang_wild_statement_enum:
3174
3175           dot = lang_size_sections_1 (s->wild_statement.children.head,
3176                                       output_section_statement,
3177                                       &s->wild_statement.children.head,
3178                                       fill, dot, relax);
3179
3180           break;
3181
3182         case lang_object_symbols_statement_enum:
3183           link_info.create_object_symbols_section =
3184             output_section_statement->bfd_section;
3185           break;
3186         case lang_output_statement_enum:
3187         case lang_target_statement_enum:
3188           break;
3189         case lang_input_section_enum:
3190           {
3191             asection *i;
3192
3193             i = (*prev)->input_section.section;
3194             if (! relax)
3195               {
3196                 if (i->_cooked_size == 0)
3197                   i->_cooked_size = i->_raw_size;
3198               }
3199             else
3200               {
3201                 boolean again;
3202
3203                 if (! bfd_relax_section (i->owner, i, &link_info, &again))
3204                   einfo (_("%P%F: can't relax section: %E\n"));
3205                 if (again)
3206                   *relax = true;
3207               }
3208             dot = size_input_section (prev, output_section_statement,
3209                                       output_section_statement->fill, dot);
3210           }
3211           break;
3212         case lang_input_statement_enum:
3213           break;
3214         case lang_fill_statement_enum:
3215           s->fill_statement.output_section =
3216             output_section_statement->bfd_section;
3217
3218           fill = s->fill_statement.fill;
3219           break;
3220         case lang_assignment_statement_enum:
3221           {
3222             bfd_vma newdot = dot;
3223
3224             exp_fold_tree (s->assignment_statement.exp,
3225                            output_section_statement,
3226                            lang_allocating_phase_enum,
3227                            dot,
3228                            &newdot);
3229
3230             if (newdot != dot)
3231               {
3232                 if (output_section_statement == abs_output_section)
3233                   {
3234                     /* If we don't have an output section, then just adjust
3235                        the default memory address.  */
3236                     lang_memory_region_lookup ("*default*")->current = newdot;
3237                   }
3238                 else
3239                   {
3240                     /* Insert a pad after this statement.  We can't
3241                        put the pad before when relaxing, in case the
3242                        assignment references dot.  */
3243                     insert_pad (&s->header.next, fill, (newdot - dot) * opb,
3244                                 output_section_statement->bfd_section, dot);
3245
3246                     /* Don't neuter the pad below when relaxing.  */
3247                     s = s->header.next;
3248                   }
3249
3250                 dot = newdot;
3251               }
3252           }
3253           break;
3254
3255         case lang_padding_statement_enum:
3256           /* If this is the first time lang_size_sections is called,
3257              we won't have any padding statements.  If this is the
3258              second or later passes when relaxing, we should allow
3259              padding to shrink.  If padding is needed on this pass, it
3260              will be added back in.  */
3261           s->padding_statement.size = 0;
3262
3263           /* Make sure output_offset is valid.  If relaxation shrinks
3264              the section and this pad isn't needed, it's possible to
3265              have output_offset larger than the final size of the
3266              section.  bfd_set_section_contents will complain even for
3267              a pad size of zero.  */
3268           s->padding_statement.output_offset
3269             = dot - output_section_statement->bfd_section->vma;
3270           break;
3271
3272         case lang_group_statement_enum:
3273           dot = lang_size_sections_1 (s->group_statement.children.head,
3274                                       output_section_statement,
3275                                       &s->group_statement.children.head,
3276                                       fill, dot, relax);
3277           break;
3278
3279         default:
3280           FAIL ();
3281           break;
3282
3283           /* We can only get here when relaxing is turned on.  */
3284         case lang_address_statement_enum:
3285           break;
3286         }
3287       prev = &s->header.next;
3288     }
3289   return dot;
3290 }
3291
3292 bfd_vma
3293 lang_size_sections (s, output_section_statement, prev, fill, dot, relax)
3294      lang_statement_union_type *s;
3295      lang_output_section_statement_type *output_section_statement;
3296      lang_statement_union_type **prev;
3297      fill_type *fill;
3298      bfd_vma dot;
3299      boolean *relax;
3300 {
3301   bfd_vma result;
3302
3303   exp_data_seg.phase = exp_dataseg_none;
3304   result = lang_size_sections_1 (s, output_section_statement, prev, fill,
3305                                  dot, relax);
3306   if (exp_data_seg.phase == exp_dataseg_end_seen)
3307     {
3308       /* If DATA_SEGMENT_ALIGN DATA_SEGMENT_END pair was seen, check whether
3309          a page could be saved in the data segment.  */
3310       bfd_vma first, last;
3311
3312       first = -exp_data_seg.base & (exp_data_seg.pagesize - 1);
3313       last = exp_data_seg.end & (exp_data_seg.pagesize - 1);
3314       if (first && last
3315           && ((exp_data_seg.base & ~(exp_data_seg.pagesize - 1))
3316               != (exp_data_seg.end & ~(exp_data_seg.pagesize - 1)))
3317           && first + last <= exp_data_seg.pagesize)
3318         {
3319           exp_data_seg.phase = exp_dataseg_adjust;
3320           result = lang_size_sections_1 (s, output_section_statement, prev,
3321                                          fill, dot, relax);
3322         }
3323     }
3324
3325   return result;
3326 }
3327
3328 bfd_vma
3329 lang_do_assignments (s, output_section_statement, fill, dot)
3330      lang_statement_union_type *s;
3331      lang_output_section_statement_type *output_section_statement;
3332      fill_type *fill;
3333      bfd_vma dot;
3334 {
3335   unsigned opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
3336                                                 ldfile_output_machine);
3337
3338   for (; s != (lang_statement_union_type *) NULL; s = s->header.next)
3339     {
3340       switch (s->header.type)
3341         {
3342         case lang_constructors_statement_enum:
3343           dot = lang_do_assignments (constructor_list.head,
3344                                      output_section_statement,
3345                                      fill,
3346                                      dot);
3347           break;
3348
3349         case lang_output_section_statement_enum:
3350           {
3351             lang_output_section_statement_type *os;
3352
3353             os = &(s->output_section_statement);
3354             if (os->bfd_section != NULL)
3355               {
3356                 dot = os->bfd_section->vma;
3357                 (void) lang_do_assignments (os->children.head, os,
3358                                             os->fill, dot);
3359                 dot = os->bfd_section->vma + os->bfd_section->_raw_size / opb;
3360
3361               }
3362             if (os->load_base)
3363               {
3364                 /* If nothing has been placed into the output section then
3365                    it won't have a bfd_section.  */
3366                 if (os->bfd_section)
3367                   {
3368                     os->bfd_section->lma
3369                       = exp_get_abs_int (os->load_base, 0, "load base",
3370                                          lang_final_phase_enum);
3371                   }
3372               }
3373           }
3374           break;
3375         case lang_wild_statement_enum:
3376
3377           dot = lang_do_assignments (s->wild_statement.children.head,
3378                                      output_section_statement,
3379                                      fill, dot);
3380
3381           break;
3382
3383         case lang_object_symbols_statement_enum:
3384         case lang_output_statement_enum:
3385         case lang_target_statement_enum:
3386 #if 0
3387         case lang_common_statement_enum:
3388 #endif
3389           break;
3390         case lang_data_statement_enum:
3391           {
3392             etree_value_type value;
3393
3394             value = exp_fold_tree (s->data_statement.exp,
3395                                    abs_output_section,
3396                                    lang_final_phase_enum, dot, &dot);
3397             s->data_statement.value = value.value;
3398             if (value.valid_p == false)
3399               einfo (_("%F%P: invalid data statement\n"));
3400           }
3401           {
3402             unsigned int size;
3403             switch (s->data_statement.type)
3404               {
3405               default:
3406                 abort ();
3407               case QUAD:
3408               case SQUAD:
3409                 size = QUAD_SIZE;
3410                 break;
3411               case LONG:
3412                 size = LONG_SIZE;
3413                 break;
3414               case SHORT:
3415                 size = SHORT_SIZE;
3416                 break;
3417               case BYTE:
3418                 size = BYTE_SIZE;
3419                 break;
3420               }
3421             if (size < opb)
3422               size = opb;
3423             dot += size / opb;
3424           }
3425           break;
3426
3427         case lang_reloc_statement_enum:
3428           {
3429             etree_value_type value;
3430
3431             value = exp_fold_tree (s->reloc_statement.addend_exp,
3432                                    abs_output_section,
3433                                    lang_final_phase_enum, dot, &dot);
3434             s->reloc_statement.addend_value = value.value;
3435             if (value.valid_p == false)
3436               einfo (_("%F%P: invalid reloc statement\n"));
3437           }
3438           dot += bfd_get_reloc_size (s->reloc_statement.howto) / opb;
3439           break;
3440
3441         case lang_input_section_enum:
3442           {
3443             asection *in = s->input_section.section;
3444
3445             if (in->_cooked_size != 0)
3446               dot += in->_cooked_size / opb;
3447             else
3448               dot += in->_raw_size / opb;
3449           }
3450           break;
3451
3452         case lang_input_statement_enum:
3453           break;
3454         case lang_fill_statement_enum:
3455           fill = s->fill_statement.fill;
3456           break;
3457         case lang_assignment_statement_enum:
3458           {
3459             exp_fold_tree (s->assignment_statement.exp,
3460                            output_section_statement,
3461                            lang_final_phase_enum,
3462                            dot,
3463                            &dot);
3464           }
3465
3466           break;
3467         case lang_padding_statement_enum:
3468           dot += s->padding_statement.size / opb;
3469           break;
3470
3471         case lang_group_statement_enum:
3472           dot = lang_do_assignments (s->group_statement.children.head,
3473                                      output_section_statement,
3474                                      fill, dot);
3475
3476           break;
3477
3478         default:
3479           FAIL ();
3480           break;
3481         case lang_address_statement_enum:
3482           break;
3483         }
3484
3485     }
3486   return dot;
3487 }
3488
3489 /* Fix any .startof. or .sizeof. symbols.  When the assemblers see the
3490    operator .startof. (section_name), it produces an undefined symbol
3491    .startof.section_name.  Similarly, when it sees
3492    .sizeof. (section_name), it produces an undefined symbol
3493    .sizeof.section_name.  For all the output sections, we look for
3494    such symbols, and set them to the correct value.  */
3495
3496 static void
3497 lang_set_startof ()
3498 {
3499   asection *s;
3500
3501   if (link_info.relocateable)
3502     return;
3503
3504   for (s = output_bfd->sections; s != NULL; s = s->next)
3505     {
3506       const char *secname;
3507       char *buf;
3508       struct bfd_link_hash_entry *h;
3509
3510       secname = bfd_get_section_name (output_bfd, s);
3511       buf = xmalloc (10 + strlen (secname));
3512
3513       sprintf (buf, ".startof.%s", secname);
3514       h = bfd_link_hash_lookup (link_info.hash, buf, false, false, true);
3515       if (h != NULL && h->type == bfd_link_hash_undefined)
3516         {
3517           h->type = bfd_link_hash_defined;
3518           h->u.def.value = bfd_get_section_vma (output_bfd, s);
3519           h->u.def.section = bfd_abs_section_ptr;
3520         }
3521
3522       sprintf (buf, ".sizeof.%s", secname);
3523       h = bfd_link_hash_lookup (link_info.hash, buf, false, false, true);
3524       if (h != NULL && h->type == bfd_link_hash_undefined)
3525         {
3526           unsigned opb;
3527
3528           opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
3529                                                ldfile_output_machine);
3530           h->type = bfd_link_hash_defined;
3531           if (s->_cooked_size != 0)
3532             h->u.def.value = s->_cooked_size / opb;
3533           else
3534             h->u.def.value = s->_raw_size / opb;
3535           h->u.def.section = bfd_abs_section_ptr;
3536         }
3537
3538       free (buf);
3539     }
3540 }
3541
3542 static void
3543 lang_finish ()
3544 {
3545   struct bfd_link_hash_entry *h;
3546   boolean warn;
3547
3548   if (link_info.relocateable || link_info.shared)
3549     warn = false;
3550   else
3551     warn = true;
3552
3553   if (entry_symbol.name == (const char *) NULL)
3554     {
3555       /* No entry has been specified.  Look for start, but don't warn
3556          if we don't find it.  */
3557       entry_symbol.name = "start";
3558       warn = false;
3559     }
3560
3561   h = bfd_link_hash_lookup (link_info.hash, entry_symbol.name,
3562                             false, false, true);
3563   if (h != (struct bfd_link_hash_entry *) NULL
3564       && (h->type == bfd_link_hash_defined
3565           || h->type == bfd_link_hash_defweak)
3566       && h->u.def.section->output_section != NULL)
3567     {
3568       bfd_vma val;
3569
3570       val = (h->u.def.value
3571              + bfd_get_section_vma (output_bfd,
3572                                     h->u.def.section->output_section)
3573              + h->u.def.section->output_offset);
3574       if (! bfd_set_start_address (output_bfd, val))
3575         einfo (_("%P%F:%s: can't set start address\n"), entry_symbol.name);
3576     }
3577   else
3578     {
3579       bfd_vma val;
3580       const char *send;
3581
3582       /* We couldn't find the entry symbol.  Try parsing it as a
3583          number.  */
3584       val = bfd_scan_vma (entry_symbol.name, &send, 0);
3585       if (*send == '\0')
3586         {
3587           if (! bfd_set_start_address (output_bfd, val))
3588             einfo (_("%P%F: can't set start address\n"));
3589         }
3590       else
3591         {
3592           asection *ts;
3593
3594           /* Can't find the entry symbol, and it's not a number.  Use
3595              the first address in the text section.  */
3596           ts = bfd_get_section_by_name (output_bfd, entry_section);
3597           if (ts != (asection *) NULL)
3598             {
3599               if (warn)
3600                 einfo (_("%P: warning: cannot find entry symbol %s; defaulting to %V\n"),
3601                        entry_symbol.name,
3602                        bfd_get_section_vma (output_bfd, ts));
3603               if (! bfd_set_start_address (output_bfd,
3604                                            bfd_get_section_vma (output_bfd,
3605                                                                 ts)))
3606                 einfo (_("%P%F: can't set start address\n"));
3607             }
3608           else
3609             {
3610               if (warn)
3611                 einfo (_("%P: warning: cannot find entry symbol %s; not setting start address\n"),
3612                        entry_symbol.name);
3613             }
3614         }
3615     }
3616 }
3617
3618 /* This is a small function used when we want to ignore errors from
3619    BFD.  */
3620
3621 static void
3622 #ifdef ANSI_PROTOTYPES
3623 ignore_bfd_errors (const char *s ATTRIBUTE_UNUSED, ...)
3624 #else
3625 ignore_bfd_errors (s)
3626      const char *s ATTRIBUTE_UNUSED;
3627 #endif
3628 {
3629   /* Don't do anything.  */
3630 }
3631
3632 /* Check that the architecture of all the input files is compatible
3633    with the output file.  Also call the backend to let it do any
3634    other checking that is needed.  */
3635
3636 static void
3637 lang_check ()
3638 {
3639   lang_statement_union_type *file;
3640   bfd *input_bfd;
3641   const bfd_arch_info_type *compatible;
3642
3643   for (file = file_chain.head;
3644        file != (lang_statement_union_type *) NULL;
3645        file = file->input_statement.next)
3646     {
3647       input_bfd = file->input_statement.the_bfd;
3648       compatible = bfd_arch_get_compatible (input_bfd, output_bfd);
3649
3650       /* In general it is not possible to perform a relocatable
3651          link between differing object formats when the input
3652          file has relocations, because the relocations in the
3653          input format may not have equivalent representations in
3654          the output format (and besides BFD does not translate
3655          relocs for other link purposes than a final link).  */
3656       if ((link_info.relocateable || link_info.emitrelocations)
3657           && (compatible == NULL
3658               || bfd_get_flavour (input_bfd) != bfd_get_flavour (output_bfd))
3659           && (bfd_get_file_flags (input_bfd) & HAS_RELOC) != 0)
3660         {
3661           einfo (_("%P%F: Relocatable linking with relocations from format %s (%B) to format %s (%B) is not supported\n"),
3662                  bfd_get_target (input_bfd), input_bfd,
3663                  bfd_get_target (output_bfd), output_bfd);
3664           /* einfo with %F exits.  */
3665         }
3666
3667       if (compatible == NULL)
3668         {
3669           if (command_line.warn_mismatch)
3670             einfo (_("%P: warning: %s architecture of input file `%B' is incompatible with %s output\n"),
3671                    bfd_printable_name (input_bfd), input_bfd,
3672                    bfd_printable_name (output_bfd));
3673         }
3674       else if (bfd_count_sections (input_bfd))
3675         {
3676           /* If the input bfd has no contents, it shouldn't set the
3677              private data of the output bfd.  */
3678
3679           bfd_error_handler_type pfn = NULL;
3680
3681           /* If we aren't supposed to warn about mismatched input
3682              files, temporarily set the BFD error handler to a
3683              function which will do nothing.  We still want to call
3684              bfd_merge_private_bfd_data, since it may set up
3685              information which is needed in the output file.  */
3686           if (! command_line.warn_mismatch)
3687             pfn = bfd_set_error_handler (ignore_bfd_errors);
3688           if (! bfd_merge_private_bfd_data (input_bfd, output_bfd))
3689             {
3690               if (command_line.warn_mismatch)
3691                 einfo (_("%E%X: failed to merge target specific data of file %B\n"),
3692                        input_bfd);
3693             }
3694           if (! command_line.warn_mismatch)
3695             bfd_set_error_handler (pfn);
3696         }
3697     }
3698 }
3699
3700 /* Look through all the global common symbols and attach them to the
3701    correct section.  The -sort-common command line switch may be used
3702    to roughly sort the entries by size.  */
3703
3704 static void
3705 lang_common ()
3706 {
3707   if (command_line.inhibit_common_definition)
3708     return;
3709   if (link_info.relocateable
3710       && ! command_line.force_common_definition)
3711     return;
3712
3713   if (! config.sort_common)
3714     bfd_link_hash_traverse (link_info.hash, lang_one_common, (PTR) NULL);
3715   else
3716     {
3717       int power;
3718
3719       for (power = 4; power >= 0; power--)
3720         bfd_link_hash_traverse (link_info.hash, lang_one_common,
3721                                 (PTR) &power);
3722     }
3723 }
3724
3725 /* Place one common symbol in the correct section.  */
3726
3727 static boolean
3728 lang_one_common (h, info)
3729      struct bfd_link_hash_entry *h;
3730      PTR info;
3731 {
3732   unsigned int power_of_two;
3733   bfd_vma size;
3734   asection *section;
3735   unsigned opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
3736                                                 ldfile_output_machine);
3737
3738   if (h->type != bfd_link_hash_common)
3739     return true;
3740
3741   size = h->u.c.size;
3742   power_of_two = h->u.c.p->alignment_power;
3743
3744   if (config.sort_common
3745       && power_of_two < (unsigned int) *(int *) info)
3746     return true;
3747
3748   section = h->u.c.p->section;
3749
3750   /* Increase the size of the section.  */
3751   section->_cooked_size = ALIGN_N ((section->_cooked_size + opb - 1) / opb,
3752                                    (bfd_size_type) (1 << power_of_two)) * opb;
3753
3754   /* Adjust the alignment if necessary.  */
3755   if (power_of_two > section->alignment_power)
3756     section->alignment_power = power_of_two;
3757
3758   /* Change the symbol from common to defined.  */
3759   h->type = bfd_link_hash_defined;
3760   h->u.def.section = section;
3761   h->u.def.value = section->_cooked_size;
3762
3763   /* Increase the size of the section.  */
3764   section->_cooked_size += size;
3765
3766   /* Make sure the section is allocated in memory, and make sure that
3767      it is no longer a common section.  */
3768   section->flags |= SEC_ALLOC;
3769   section->flags &= ~SEC_IS_COMMON;
3770
3771   if (config.map_file != NULL)
3772     {
3773       static boolean header_printed;
3774       int len;
3775       char *name;
3776       char buf[50];
3777
3778       if (! header_printed)
3779         {
3780           minfo (_("\nAllocating common symbols\n"));
3781           minfo (_("Common symbol       size              file\n\n"));
3782           header_printed = true;
3783         }
3784
3785       name = demangle (h->root.string);
3786       minfo ("%s", name);
3787       len = strlen (name);
3788       free (name);
3789
3790       if (len >= 19)
3791         {
3792           print_nl ();
3793           len = 0;
3794         }
3795       while (len < 20)
3796         {
3797           print_space ();
3798           ++len;
3799         }
3800
3801       minfo ("0x");
3802       if (size <= 0xffffffff)
3803         sprintf (buf, "%lx", (unsigned long) size);
3804       else
3805         sprintf_vma (buf, size);
3806       minfo ("%s", buf);
3807       len = strlen (buf);
3808
3809       while (len < 16)
3810         {
3811           print_space ();
3812           ++len;
3813         }
3814
3815       minfo ("%B\n", section->owner);
3816     }
3817
3818   return true;
3819 }
3820
3821 /* Run through the input files and ensure that every input section has
3822    somewhere to go.  If one is found without a destination then create
3823    an input request and place it into the statement tree.  */
3824
3825 static void
3826 lang_place_orphans ()
3827 {
3828   LANG_FOR_EACH_INPUT_STATEMENT (file)
3829     {
3830       asection *s;
3831
3832       for (s = file->the_bfd->sections;
3833            s != (asection *) NULL;
3834            s = s->next)
3835         {
3836           if (s->output_section == (asection *) NULL)
3837             {
3838               /* This section of the file is not attatched, root
3839                  around for a sensible place for it to go.  */
3840
3841               if (file->just_syms_flag)
3842                 {
3843                   abort ();
3844                 }
3845               else if (strcmp (s->name, "COMMON") == 0)
3846                 {
3847                   /* This is a lonely common section which must have
3848                      come from an archive.  We attach to the section
3849                      with the wildcard.  */
3850                   if (! link_info.relocateable
3851                       || command_line.force_common_definition)
3852                     {
3853                       if (default_common_section == NULL)
3854                         {
3855 #if 0
3856                           /* This message happens when using the
3857                              svr3.ifile linker script, so I have
3858                              disabled it.  */
3859                           info_msg (_("%P: no [COMMON] command, defaulting to .bss\n"));
3860 #endif
3861                           default_common_section =
3862                             lang_output_section_statement_lookup (".bss");
3863
3864                         }
3865                       lang_add_section (&default_common_section->children, s,
3866                                         default_common_section, file);
3867                     }
3868                 }
3869               else if (ldemul_place_orphan (file, s))
3870                 ;
3871               else
3872                 {
3873                   lang_output_section_statement_type *os;
3874
3875                   os = lang_output_section_statement_lookup (s->name);
3876                   lang_add_section (&os->children, s, os, file);
3877                 }
3878             }
3879         }
3880     }
3881 }
3882
3883 void
3884 lang_set_flags (ptr, flags, invert)
3885      lang_memory_region_type *ptr;
3886      const char *flags;
3887      int invert;
3888 {
3889   flagword *ptr_flags;
3890
3891   ptr_flags = invert ? &ptr->not_flags : &ptr->flags;
3892   while (*flags)
3893     {
3894       switch (*flags)
3895         {
3896         case 'A': case 'a':
3897           *ptr_flags |= SEC_ALLOC;
3898           break;
3899
3900         case 'R': case 'r':
3901           *ptr_flags |= SEC_READONLY;
3902           break;
3903
3904         case 'W': case 'w':
3905           *ptr_flags |= SEC_DATA;
3906           break;
3907
3908         case 'X': case 'x':
3909           *ptr_flags |= SEC_CODE;
3910           break;
3911
3912         case 'L': case 'l':
3913         case 'I': case 'i':
3914           *ptr_flags |= SEC_LOAD;
3915           break;
3916
3917         default:
3918           einfo (_("%P%F: invalid syntax in flags\n"));
3919           break;
3920         }
3921       flags++;
3922     }
3923 }
3924
3925 /* Call a function on each input file.  This function will be called
3926    on an archive, but not on the elements.  */
3927
3928 void
3929 lang_for_each_input_file (func)
3930      void (*func) PARAMS ((lang_input_statement_type *));
3931 {
3932   lang_input_statement_type *f;
3933
3934   for (f = (lang_input_statement_type *) input_file_chain.head;
3935        f != NULL;
3936        f = (lang_input_statement_type *) f->next_real_file)
3937     func (f);
3938 }
3939
3940 /* Call a function on each file.  The function will be called on all
3941    the elements of an archive which are included in the link, but will
3942    not be called on the archive file itself.  */
3943
3944 void
3945 lang_for_each_file (func)
3946      void (*func) PARAMS ((lang_input_statement_type *));
3947 {
3948   LANG_FOR_EACH_INPUT_STATEMENT (f)
3949     {
3950       func (f);
3951     }
3952 }
3953
3954 #if 0
3955
3956 /* Not used.  */
3957
3958 void
3959 lang_for_each_input_section (func)
3960      void (*func) PARAMS ((bfd *ab, asection *as));
3961 {
3962   LANG_FOR_EACH_INPUT_STATEMENT (f)
3963     {
3964       asection *s;
3965
3966       for (s = f->the_bfd->sections;
3967            s != (asection *) NULL;
3968            s = s->next)
3969         {
3970           func (f->the_bfd, s);
3971         }
3972     }
3973 }
3974
3975 #endif
3976
3977 void
3978 ldlang_add_file (entry)
3979      lang_input_statement_type *entry;
3980 {
3981   bfd **pp;
3982
3983   lang_statement_append (&file_chain,
3984                          (lang_statement_union_type *) entry,
3985                          &entry->next);
3986
3987   /* The BFD linker needs to have a list of all input BFDs involved in
3988      a link.  */
3989   ASSERT (entry->the_bfd->link_next == (bfd *) NULL);
3990   ASSERT (entry->the_bfd != output_bfd);
3991   for (pp = &link_info.input_bfds;
3992        *pp != (bfd *) NULL;
3993        pp = &(*pp)->link_next)
3994     ;
3995   *pp = entry->the_bfd;
3996   entry->the_bfd->usrdata = (PTR) entry;
3997   bfd_set_gp_size (entry->the_bfd, g_switch_value);
3998
3999   /* Look through the sections and check for any which should not be
4000      included in the link.  We need to do this now, so that we can
4001      notice when the backend linker tries to report multiple
4002      definition errors for symbols which are in sections we aren't
4003      going to link.  FIXME: It might be better to entirely ignore
4004      symbols which are defined in sections which are going to be
4005      discarded.  This would require modifying the backend linker for
4006      each backend which might set the SEC_LINK_ONCE flag.  If we do
4007      this, we should probably handle SEC_EXCLUDE in the same way.  */
4008
4009   bfd_map_over_sections (entry->the_bfd, section_already_linked, (PTR) entry);
4010 }
4011
4012 void
4013 lang_add_output (name, from_script)
4014      const char *name;
4015      int from_script;
4016 {
4017   /* Make -o on command line override OUTPUT in script.  */
4018   if (had_output_filename == false || !from_script)
4019     {
4020       output_filename = name;
4021       had_output_filename = true;
4022     }
4023 }
4024
4025 static lang_output_section_statement_type *current_section;
4026
4027 static int
4028 topower (x)
4029      int x;
4030 {
4031   unsigned int i = 1;
4032   int l;
4033
4034   if (x < 0)
4035     return -1;
4036
4037   for (l = 0; l < 32; l++)
4038     {
4039       if (i >= (unsigned int) x)
4040         return l;
4041       i <<= 1;
4042     }
4043
4044   return 0;
4045 }
4046
4047 lang_output_section_statement_type *
4048 lang_enter_output_section_statement (output_section_statement_name,
4049                                      address_exp, sectype, block_value,
4050                                      align, subalign, ebase)
4051      const char *output_section_statement_name;
4052      etree_type *address_exp;
4053      enum section_type sectype;
4054      bfd_vma block_value;
4055      etree_type *align;
4056      etree_type *subalign;
4057      etree_type *ebase;
4058 {
4059   lang_output_section_statement_type *os;
4060
4061   current_section =
4062    os =
4063     lang_output_section_statement_lookup (output_section_statement_name);
4064
4065   /* Add this statement to tree.  */
4066 #if 0
4067   add_statement (lang_output_section_statement_enum,
4068                  output_section_statement);
4069 #endif
4070   /* Make next things chain into subchain of this.  */
4071
4072   if (os->addr_tree == (etree_type *) NULL)
4073     {
4074       os->addr_tree = address_exp;
4075     }
4076   os->sectype = sectype;
4077   if (sectype != noload_section)
4078     os->flags = SEC_NO_FLAGS;
4079   else
4080     os->flags = SEC_NEVER_LOAD;
4081   os->block_value = block_value ? block_value : 1;
4082   stat_ptr = &os->children;
4083
4084   os->subsection_alignment =
4085     topower (exp_get_value_int (subalign, -1, "subsection alignment", 0));
4086   os->section_alignment =
4087     topower (exp_get_value_int (align, -1, "section alignment", 0));
4088
4089   os->load_base = ebase;
4090   return os;
4091 }
4092
4093 void
4094 lang_final ()
4095 {
4096   lang_output_statement_type *new =
4097     new_stat (lang_output_statement, stat_ptr);
4098
4099   new->name = output_filename;
4100 }
4101
4102 /* Reset the current counters in the regions.  */
4103
4104 void
4105 lang_reset_memory_regions ()
4106 {
4107   lang_memory_region_type *p = lang_memory_region_list;
4108   asection *o;
4109
4110   for (p = lang_memory_region_list;
4111        p != (lang_memory_region_type *) NULL;
4112        p = p->next)
4113     {
4114       p->old_length = (bfd_size_type) (p->current - p->origin);
4115       p->current = p->origin;
4116     }
4117
4118   for (o = output_bfd->sections; o != NULL; o = o->next)
4119     o->_raw_size = 0;
4120 }
4121
4122 /* If the wild pattern was marked KEEP, the member sections
4123    should be as well.  */
4124
4125 static void
4126 gc_section_callback (ptr, sec, section, file, data)
4127      lang_wild_statement_type *ptr;
4128      struct wildcard_list *sec ATTRIBUTE_UNUSED;
4129      asection *section;
4130      lang_input_statement_type *file ATTRIBUTE_UNUSED;
4131      PTR data ATTRIBUTE_UNUSED;
4132 {
4133   if (ptr->keep_sections)
4134     section->flags |= SEC_KEEP;
4135 }
4136
4137 /* Handle a wild statement, marking it against GC.  */
4138
4139 static void
4140 lang_gc_wild (s)
4141      lang_wild_statement_type *s;
4142 {
4143   walk_wild (s, gc_section_callback, NULL);
4144 }
4145
4146 /* Iterate over sections marking them against GC.  */
4147
4148 static void
4149 lang_gc_sections_1 (s)
4150      lang_statement_union_type *s;
4151 {
4152   for (; s != (lang_statement_union_type *) NULL; s = s->header.next)
4153     {
4154       switch (s->header.type)
4155         {
4156         case lang_wild_statement_enum:
4157           lang_gc_wild (&s->wild_statement);
4158           break;
4159         case lang_constructors_statement_enum:
4160           lang_gc_sections_1 (constructor_list.head);
4161           break;
4162         case lang_output_section_statement_enum:
4163           lang_gc_sections_1 (s->output_section_statement.children.head);
4164           break;
4165         case lang_group_statement_enum:
4166           lang_gc_sections_1 (s->group_statement.children.head);
4167           break;
4168         default:
4169           break;
4170         }
4171     }
4172 }
4173
4174 static void
4175 lang_gc_sections ()
4176 {
4177   struct bfd_link_hash_entry *h;
4178   ldlang_undef_chain_list_type *ulist;
4179
4180   /* Keep all sections so marked in the link script.  */
4181
4182   lang_gc_sections_1 (statement_list.head);
4183
4184   /* Keep all sections containing symbols undefined on the command-line,
4185      and the section containing the entry symbol.  */
4186
4187   for (ulist = link_info.gc_sym_list; ulist; ulist = ulist->next)
4188     {
4189       h = bfd_link_hash_lookup (link_info.hash, ulist->name,
4190                                 false, false, false);
4191
4192       if (h != (struct bfd_link_hash_entry *) NULL
4193           && (h->type == bfd_link_hash_defined
4194               || h->type == bfd_link_hash_defweak)
4195           && ! bfd_is_abs_section (h->u.def.section))
4196         {
4197           h->u.def.section->flags |= SEC_KEEP;
4198         }
4199     }
4200
4201   bfd_gc_sections (output_bfd, &link_info);
4202 }
4203
4204 void
4205 lang_process ()
4206 {
4207   lang_reasonable_defaults ();
4208   current_target = default_target;
4209
4210   /* Open the output file.  */
4211   lang_for_each_statement (ldlang_open_output);
4212
4213   ldemul_create_output_section_statements ();
4214
4215   /* Add to the hash table all undefineds on the command line.  */
4216   lang_place_undefineds ();
4217
4218   already_linked_table_init ();
4219
4220   /* Create a bfd for each input file.  */
4221   current_target = default_target;
4222   open_input_bfds (statement_list.head, false);
4223
4224   link_info.gc_sym_list = &entry_symbol;
4225   if (entry_symbol.name == NULL)
4226     link_info.gc_sym_list = ldlang_undef_chain_list_head;
4227
4228   ldemul_after_open ();
4229
4230   already_linked_table_free ();
4231
4232   /* Make sure that we're not mixing architectures.  We call this
4233      after all the input files have been opened, but before we do any
4234      other processing, so that any operations merge_private_bfd_data
4235      does on the output file will be known during the rest of the
4236      link.  */
4237   lang_check ();
4238
4239   /* Handle .exports instead of a version script if we're told to do so.  */
4240   if (command_line.version_exports_section)
4241     lang_do_version_exports_section ();
4242
4243   /* Build all sets based on the information gathered from the input
4244      files.  */
4245   ldctor_build_sets ();
4246
4247   /* Remove unreferenced sections if asked to.  */
4248   if (command_line.gc_sections)
4249     lang_gc_sections ();
4250
4251   /* If there were any SEC_MERGE sections, finish their merging, so that
4252      section sizes can be computed.  This has to be done after GC of sections,
4253      so that GCed sections are not merged, but before assigning output
4254      sections, since removing whole input sections is hard then.  */
4255   bfd_merge_sections (output_bfd, &link_info);
4256
4257   /* Size up the common data.  */
4258   lang_common ();
4259
4260   /* Run through the contours of the script and attach input sections
4261      to the correct output sections.  */
4262   map_input_to_output_sections (statement_list.head, (char *) NULL,
4263                                 (lang_output_section_statement_type *) NULL);
4264
4265   /* Find any sections not attached explicitly and handle them.  */
4266   lang_place_orphans ();
4267
4268   if (! link_info.relocateable)
4269     {
4270       /* Look for a text section and set the readonly attribute in it.  */
4271       asection *found = bfd_get_section_by_name (output_bfd, ".text");
4272
4273       if (found != (asection *) NULL)
4274         {
4275           if (config.text_read_only)
4276             found->flags |= SEC_READONLY;
4277           else
4278             found->flags &= ~SEC_READONLY;
4279         }
4280     }
4281
4282   /* Do anything special before sizing sections.  This is where ELF
4283      and other back-ends size dynamic sections.  */
4284   ldemul_before_allocation ();
4285
4286   if (!link_info.relocateable)
4287     strip_excluded_output_sections ();
4288
4289   /* We must record the program headers before we try to fix the
4290      section positions, since they will affect SIZEOF_HEADERS.  */
4291   lang_record_phdrs ();
4292
4293   /* Size up the sections.  */
4294   lang_size_sections (statement_list.head,
4295                       abs_output_section,
4296                       &statement_list.head, 0, (bfd_vma) 0, NULL);
4297
4298   /* Now run around and relax if we can.  */
4299   if (command_line.relax)
4300     {
4301       /* Keep relaxing until bfd_relax_section gives up.  */
4302       boolean relax_again;
4303
4304       do
4305         {
4306           lang_reset_memory_regions ();
4307
4308           relax_again = false;
4309
4310           /* Note: pe-dll.c does something like this also.  If you find
4311              you need to change this code, you probably need to change
4312              pe-dll.c also.  DJ  */
4313
4314           /* Do all the assignments with our current guesses as to
4315              section sizes.  */
4316           lang_do_assignments (statement_list.head,
4317                                abs_output_section,
4318                                (fill_type *) 0, (bfd_vma) 0);
4319
4320           /* Perform another relax pass - this time we know where the
4321              globals are, so can make a better guess.  */
4322           lang_size_sections (statement_list.head,
4323                               abs_output_section,
4324                               &statement_list.head, 0, (bfd_vma) 0,
4325                               &relax_again);
4326         }
4327       while (relax_again);
4328     }
4329
4330   /* See if anything special should be done now we know how big
4331      everything is.  */
4332   ldemul_after_allocation ();
4333
4334   /* Fix any .startof. or .sizeof. symbols.  */
4335   lang_set_startof ();
4336
4337   /* Do all the assignments, now that we know the final resting places
4338      of all the symbols.  */
4339
4340   lang_do_assignments (statement_list.head,
4341                        abs_output_section,
4342                        (fill_type *) 0, (bfd_vma) 0);
4343
4344   /* Make sure that the section addresses make sense.  */
4345   if (! link_info.relocateable
4346       && command_line.check_section_addresses)
4347     lang_check_section_addresses ();
4348
4349   /* Final stuffs.  */
4350
4351   ldemul_finish ();
4352   lang_finish ();
4353 }
4354
4355 /* EXPORTED TO YACC */
4356
4357 void
4358 lang_add_wild (filespec, section_list, keep_sections)
4359      struct wildcard_spec *filespec;
4360      struct wildcard_list *section_list;
4361      boolean keep_sections;
4362 {
4363   struct wildcard_list *curr, *next;
4364   lang_wild_statement_type *new;
4365
4366   /* Reverse the list as the parser puts it back to front.  */
4367   for (curr = section_list, section_list = NULL;
4368        curr != NULL;
4369        section_list = curr, curr = next)
4370     {
4371       if (curr->spec.name != NULL && strcmp (curr->spec.name, "COMMON") == 0)
4372         placed_commons = true;
4373
4374       next = curr->next;
4375       curr->next = section_list;
4376     }
4377
4378   if (filespec != NULL && filespec->name != NULL)
4379     {
4380       if (strcmp (filespec->name, "*") == 0)
4381         filespec->name = NULL;
4382       else if (! wildcardp (filespec->name))
4383         lang_has_input_file = true;
4384     }
4385
4386   new = new_stat (lang_wild_statement, stat_ptr);
4387   new->filename = NULL;
4388   new->filenames_sorted = false;
4389   if (filespec != NULL)
4390     {
4391       new->filename = filespec->name;
4392       new->filenames_sorted = filespec->sorted;
4393     }
4394   new->section_list = section_list;
4395   new->keep_sections = keep_sections;
4396   lang_list_init (&new->children);
4397 }
4398
4399 void
4400 lang_section_start (name, address)
4401      const char *name;
4402      etree_type *address;
4403 {
4404   lang_address_statement_type *ad;
4405
4406   ad = new_stat (lang_address_statement, stat_ptr);
4407   ad->section_name = name;
4408   ad->address = address;
4409 }
4410
4411 /* Set the start symbol to NAME.  CMDLINE is nonzero if this is called
4412    because of a -e argument on the command line, or zero if this is
4413    called by ENTRY in a linker script.  Command line arguments take
4414    precedence.  */
4415
4416 void
4417 lang_add_entry (name, cmdline)
4418      const char *name;
4419      boolean cmdline;
4420 {
4421   if (entry_symbol.name == NULL
4422       || cmdline
4423       || ! entry_from_cmdline)
4424     {
4425       entry_symbol.name = name;
4426       entry_from_cmdline = cmdline;
4427     }
4428 }
4429
4430 void
4431 lang_add_target (name)
4432      const char *name;
4433 {
4434   lang_target_statement_type *new = new_stat (lang_target_statement,
4435                                               stat_ptr);
4436
4437   new->target = name;
4438
4439 }
4440
4441 void
4442 lang_add_map (name)
4443      const char *name;
4444 {
4445   while (*name)
4446     {
4447       switch (*name)
4448         {
4449         case 'F':
4450           map_option_f = true;
4451           break;
4452         }
4453       name++;
4454     }
4455 }
4456
4457 void
4458 lang_add_fill (fill)
4459      fill_type *fill;
4460 {
4461   lang_fill_statement_type *new = new_stat (lang_fill_statement,
4462                                             stat_ptr);
4463
4464   new->fill = fill;
4465 }
4466
4467 void
4468 lang_add_data (type, exp)
4469      int type;
4470      union etree_union *exp;
4471 {
4472
4473   lang_data_statement_type *new = new_stat (lang_data_statement,
4474                                             stat_ptr);
4475
4476   new->exp = exp;
4477   new->type = type;
4478
4479 }
4480
4481 /* Create a new reloc statement.  RELOC is the BFD relocation type to
4482    generate.  HOWTO is the corresponding howto structure (we could
4483    look this up, but the caller has already done so).  SECTION is the
4484    section to generate a reloc against, or NAME is the name of the
4485    symbol to generate a reloc against.  Exactly one of SECTION and
4486    NAME must be NULL.  ADDEND is an expression for the addend.  */
4487
4488 void
4489 lang_add_reloc (reloc, howto, section, name, addend)
4490      bfd_reloc_code_real_type reloc;
4491      reloc_howto_type *howto;
4492      asection *section;
4493      const char *name;
4494      union etree_union *addend;
4495 {
4496   lang_reloc_statement_type *p = new_stat (lang_reloc_statement, stat_ptr);
4497
4498   p->reloc = reloc;
4499   p->howto = howto;
4500   p->section = section;
4501   p->name = name;
4502   p->addend_exp = addend;
4503
4504   p->addend_value = 0;
4505   p->output_section = NULL;
4506   p->output_vma = 0;
4507 }
4508
4509 lang_assignment_statement_type *
4510 lang_add_assignment (exp)
4511      etree_type *exp;
4512 {
4513   lang_assignment_statement_type *new = new_stat (lang_assignment_statement,
4514                                                   stat_ptr);
4515
4516   new->exp = exp;
4517   return new;
4518 }
4519
4520 void
4521 lang_add_attribute (attribute)
4522      enum statement_enum attribute;
4523 {
4524   new_statement (attribute, sizeof (lang_statement_union_type), stat_ptr);
4525 }
4526
4527 void
4528 lang_startup (name)
4529      const char *name;
4530 {
4531   if (startup_file != (char *) NULL)
4532     {
4533       einfo (_("%P%Fmultiple STARTUP files\n"));
4534     }
4535   first_file->filename = name;
4536   first_file->local_sym_name = name;
4537   first_file->real = true;
4538
4539   startup_file = name;
4540 }
4541
4542 void
4543 lang_float (maybe)
4544      boolean maybe;
4545 {
4546   lang_float_flag = maybe;
4547 }
4548
4549
4550 /* Work out the load- and run-time regions from a script statement, and
4551    store them in *LMA_REGION and *REGION respectively.
4552
4553    MEMSPEC is the name of the run-time region, or "*default*" if the
4554    statement didn't specify one.  LMA_MEMSPEC is the name of the
4555    load-time region, or null if the statement didn't specify one.
4556    HAVE_LMA_P is true if the statement had an explicit load address.
4557
4558    It is an error to specify both a load region and a load address.  */
4559
4560 static void
4561 lang_get_regions (region, lma_region, memspec, lma_memspec, have_lma_p)
4562      struct memory_region_struct **region, **lma_region;
4563      const char *memspec, *lma_memspec;
4564      int have_lma_p;
4565 {
4566   *lma_region = lang_memory_region_lookup (lma_memspec);
4567
4568   /* If no runtime region has been given, but the load region has
4569      been, use the load region.  */
4570   if (lma_memspec != 0 && strcmp (memspec, "*default*") == 0)
4571     *region = *lma_region;
4572   else
4573     *region = lang_memory_region_lookup (memspec);
4574
4575   if (have_lma_p && lma_memspec != 0)
4576     einfo (_("%X%P:%S: section has both a load address and a load region\n"));
4577 }
4578
4579 void
4580 lang_leave_output_section_statement (fill, memspec, phdrs, lma_memspec)
4581      fill_type *fill;
4582      const char *memspec;
4583      struct lang_output_section_phdr_list *phdrs;
4584      const char *lma_memspec;
4585 {
4586   lang_get_regions (&current_section->region,
4587                     &current_section->lma_region,
4588                     memspec, lma_memspec,
4589                     current_section->load_base != 0);
4590   current_section->fill = fill;
4591   current_section->phdrs = phdrs;
4592   stat_ptr = &statement_list;
4593 }
4594
4595 /* Create an absolute symbol with the given name with the value of the
4596    address of first byte of the section named.
4597
4598    If the symbol already exists, then do nothing.  */
4599
4600 void
4601 lang_abs_symbol_at_beginning_of (secname, name)
4602      const char *secname;
4603      const char *name;
4604 {
4605   struct bfd_link_hash_entry *h;
4606
4607   h = bfd_link_hash_lookup (link_info.hash, name, true, true, true);
4608   if (h == (struct bfd_link_hash_entry *) NULL)
4609     einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
4610
4611   if (h->type == bfd_link_hash_new
4612       || h->type == bfd_link_hash_undefined)
4613     {
4614       asection *sec;
4615
4616       h->type = bfd_link_hash_defined;
4617
4618       sec = bfd_get_section_by_name (output_bfd, secname);
4619       if (sec == (asection *) NULL)
4620         h->u.def.value = 0;
4621       else
4622         h->u.def.value = bfd_get_section_vma (output_bfd, sec);
4623
4624       h->u.def.section = bfd_abs_section_ptr;
4625     }
4626 }
4627
4628 /* Create an absolute symbol with the given name with the value of the
4629    address of the first byte after the end of the section named.
4630
4631    If the symbol already exists, then do nothing.  */
4632
4633 void
4634 lang_abs_symbol_at_end_of (secname, name)
4635      const char *secname;
4636      const char *name;
4637 {
4638   struct bfd_link_hash_entry *h;
4639
4640   h = bfd_link_hash_lookup (link_info.hash, name, true, true, true);
4641   if (h == (struct bfd_link_hash_entry *) NULL)
4642     einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
4643
4644   if (h->type == bfd_link_hash_new
4645       || h->type == bfd_link_hash_undefined)
4646     {
4647       asection *sec;
4648
4649       h->type = bfd_link_hash_defined;
4650
4651       sec = bfd_get_section_by_name (output_bfd, secname);
4652       if (sec == (asection *) NULL)
4653         h->u.def.value = 0;
4654       else
4655         h->u.def.value = (bfd_get_section_vma (output_bfd, sec)
4656                           + bfd_section_size (output_bfd, sec) /
4657                           bfd_octets_per_byte (output_bfd));
4658
4659       h->u.def.section = bfd_abs_section_ptr;
4660     }
4661 }
4662
4663 void
4664 lang_statement_append (list, element, field)
4665      lang_statement_list_type *list;
4666      lang_statement_union_type *element;
4667      lang_statement_union_type **field;
4668 {
4669   *(list->tail) = element;
4670   list->tail = field;
4671 }
4672
4673 /* Set the output format type.  -oformat overrides scripts.  */
4674
4675 void
4676 lang_add_output_format (format, big, little, from_script)
4677      const char *format;
4678      const char *big;
4679      const char *little;
4680      int from_script;
4681 {
4682   if (output_target == NULL || !from_script)
4683     {
4684       if (command_line.endian == ENDIAN_BIG
4685           && big != NULL)
4686         format = big;
4687       else if (command_line.endian == ENDIAN_LITTLE
4688                && little != NULL)
4689         format = little;
4690
4691       output_target = format;
4692     }
4693 }
4694
4695 /* Enter a group.  This creates a new lang_group_statement, and sets
4696    stat_ptr to build new statements within the group.  */
4697
4698 void
4699 lang_enter_group ()
4700 {
4701   lang_group_statement_type *g;
4702
4703   g = new_stat (lang_group_statement, stat_ptr);
4704   lang_list_init (&g->children);
4705   stat_ptr = &g->children;
4706 }
4707
4708 /* Leave a group.  This just resets stat_ptr to start writing to the
4709    regular list of statements again.  Note that this will not work if
4710    groups can occur inside anything else which can adjust stat_ptr,
4711    but currently they can't.  */
4712
4713 void
4714 lang_leave_group ()
4715 {
4716   stat_ptr = &statement_list;
4717 }
4718
4719 /* Add a new program header.  This is called for each entry in a PHDRS
4720    command in a linker script.  */
4721
4722 void
4723 lang_new_phdr (name, type, filehdr, phdrs, at, flags)
4724      const char *name;
4725      etree_type *type;
4726      boolean filehdr;
4727      boolean phdrs;
4728      etree_type *at;
4729      etree_type *flags;
4730 {
4731   struct lang_phdr *n, **pp;
4732
4733   n = (struct lang_phdr *) stat_alloc (sizeof (struct lang_phdr));
4734   n->next = NULL;
4735   n->name = name;
4736   n->type = exp_get_value_int (type, 0, "program header type",
4737                                lang_final_phase_enum);
4738   n->filehdr = filehdr;
4739   n->phdrs = phdrs;
4740   n->at = at;
4741   n->flags = flags;
4742
4743   for (pp = &lang_phdr_list; *pp != NULL; pp = &(*pp)->next)
4744     ;
4745   *pp = n;
4746 }
4747
4748 /* Record the program header information in the output BFD.  FIXME: We
4749    should not be calling an ELF specific function here.  */
4750
4751 static void
4752 lang_record_phdrs ()
4753 {
4754   unsigned int alc;
4755   asection **secs;
4756   struct lang_output_section_phdr_list *last;
4757   struct lang_phdr *l;
4758   lang_statement_union_type *u;
4759
4760   alc = 10;
4761   secs = (asection **) xmalloc (alc * sizeof (asection *));
4762   last = NULL;
4763   for (l = lang_phdr_list; l != NULL; l = l->next)
4764     {
4765       unsigned int c;
4766       flagword flags;
4767       bfd_vma at;
4768
4769       c = 0;
4770       for (u = lang_output_section_statement.head;
4771            u != NULL;
4772            u = u->output_section_statement.next)
4773         {
4774           lang_output_section_statement_type *os;
4775           struct lang_output_section_phdr_list *pl;
4776
4777           os = &u->output_section_statement;
4778
4779           pl = os->phdrs;
4780           if (pl != NULL)
4781             last = pl;
4782           else
4783             {
4784               if (os->sectype == noload_section
4785                   || os->bfd_section == NULL
4786                   || (os->bfd_section->flags & SEC_ALLOC) == 0)
4787                 continue;
4788               pl = last;
4789             }
4790
4791           if (os->bfd_section == NULL)
4792             continue;
4793
4794           for (; pl != NULL; pl = pl->next)
4795             {
4796               if (strcmp (pl->name, l->name) == 0)
4797                 {
4798                   if (c >= alc)
4799                     {
4800                       alc *= 2;
4801                       secs = ((asection **)
4802                               xrealloc (secs, alc * sizeof (asection *)));
4803                     }
4804                   secs[c] = os->bfd_section;
4805                   ++c;
4806                   pl->used = true;
4807                 }
4808             }
4809         }
4810
4811       if (l->flags == NULL)
4812         flags = 0;
4813       else
4814         flags = exp_get_vma (l->flags, 0, "phdr flags",
4815                              lang_final_phase_enum);
4816
4817       if (l->at == NULL)
4818         at = 0;
4819       else
4820         at = exp_get_vma (l->at, 0, "phdr load address",
4821                           lang_final_phase_enum);
4822
4823       if (! bfd_record_phdr (output_bfd, l->type,
4824                              l->flags != NULL, flags, l->at != NULL,
4825                              at, l->filehdr, l->phdrs, c, secs))
4826         einfo (_("%F%P: bfd_record_phdr failed: %E\n"));
4827     }
4828
4829   free (secs);
4830
4831   /* Make sure all the phdr assignments succeeded.  */
4832   for (u = lang_output_section_statement.head;
4833        u != NULL;
4834        u = u->output_section_statement.next)
4835     {
4836       struct lang_output_section_phdr_list *pl;
4837
4838       if (u->output_section_statement.bfd_section == NULL)
4839         continue;
4840
4841       for (pl = u->output_section_statement.phdrs;
4842            pl != NULL;
4843            pl = pl->next)
4844         if (! pl->used && strcmp (pl->name, "NONE") != 0)
4845           einfo (_("%X%P: section `%s' assigned to non-existent phdr `%s'\n"),
4846                  u->output_section_statement.name, pl->name);
4847     }
4848 }
4849
4850 /* Record a list of sections which may not be cross referenced.  */
4851
4852 void
4853 lang_add_nocrossref (l)
4854      struct lang_nocrossref *l;
4855 {
4856   struct lang_nocrossrefs *n;
4857
4858   n = (struct lang_nocrossrefs *) xmalloc (sizeof *n);
4859   n->next = nocrossref_list;
4860   n->list = l;
4861   nocrossref_list = n;
4862
4863   /* Set notice_all so that we get informed about all symbols.  */
4864   link_info.notice_all = true;
4865 }
4866 \f
4867 /* Overlay handling.  We handle overlays with some static variables.  */
4868
4869 /* The overlay virtual address.  */
4870 static etree_type *overlay_vma;
4871
4872 /* An expression for the maximum section size seen so far.  */
4873 static etree_type *overlay_max;
4874
4875 /* A list of all the sections in this overlay.  */
4876
4877 struct overlay_list {
4878   struct overlay_list *next;
4879   lang_output_section_statement_type *os;
4880 };
4881
4882 static struct overlay_list *overlay_list;
4883
4884 /* Start handling an overlay.  */
4885
4886 void
4887 lang_enter_overlay (vma_expr)
4888      etree_type *vma_expr;
4889 {
4890   /* The grammar should prevent nested overlays from occurring.  */
4891   ASSERT (overlay_vma == NULL && overlay_max == NULL);
4892
4893   overlay_vma = vma_expr;
4894 }
4895
4896 /* Start a section in an overlay.  We handle this by calling
4897    lang_enter_output_section_statement with the correct VMA.
4898    lang_leave_overlay sets up the LMA and memory regions.  */
4899
4900 void
4901 lang_enter_overlay_section (name)
4902      const char *name;
4903 {
4904   struct overlay_list *n;
4905   etree_type *size;
4906
4907   lang_enter_output_section_statement (name, overlay_vma, normal_section,
4908                                        0, 0, 0, 0);
4909
4910   /* If this is the first section, then base the VMA of future
4911      sections on this one.  This will work correctly even if `.' is
4912      used in the addresses.  */
4913   if (overlay_list == NULL)
4914     overlay_vma = exp_nameop (ADDR, name);
4915
4916   /* Remember the section.  */
4917   n = (struct overlay_list *) xmalloc (sizeof *n);
4918   n->os = current_section;
4919   n->next = overlay_list;
4920   overlay_list = n;
4921
4922   size = exp_nameop (SIZEOF, name);
4923
4924   /* Arrange to work out the maximum section end address.  */
4925   if (overlay_max == NULL)
4926     overlay_max = size;
4927   else
4928     overlay_max = exp_binop (MAX_K, overlay_max, size);
4929 }
4930
4931 /* Finish a section in an overlay.  There isn't any special to do
4932    here.  */
4933
4934 void
4935 lang_leave_overlay_section (fill, phdrs)
4936      fill_type *fill;
4937      struct lang_output_section_phdr_list *phdrs;
4938 {
4939   const char *name;
4940   char *clean, *s2;
4941   const char *s1;
4942   char *buf;
4943
4944   name = current_section->name;
4945
4946   /* For now, assume that "*default*" is the run-time memory region and
4947      that no load-time region has been specified.  It doesn't really
4948      matter what we say here, since lang_leave_overlay will override it.  */
4949   lang_leave_output_section_statement (fill, "*default*", phdrs, 0);
4950
4951   /* Define the magic symbols.  */
4952
4953   clean = xmalloc (strlen (name) + 1);
4954   s2 = clean;
4955   for (s1 = name; *s1 != '\0'; s1++)
4956     if (ISALNUM (*s1) || *s1 == '_')
4957       *s2++ = *s1;
4958   *s2 = '\0';
4959
4960   buf = xmalloc (strlen (clean) + sizeof "__load_start_");
4961   sprintf (buf, "__load_start_%s", clean);
4962   lang_add_assignment (exp_assop ('=', buf,
4963                                   exp_nameop (LOADADDR, name)));
4964
4965   buf = xmalloc (strlen (clean) + sizeof "__load_stop_");
4966   sprintf (buf, "__load_stop_%s", clean);
4967   lang_add_assignment (exp_assop ('=', buf,
4968                                   exp_binop ('+',
4969                                              exp_nameop (LOADADDR, name),
4970                                              exp_nameop (SIZEOF, name))));
4971
4972   free (clean);
4973 }
4974
4975 /* Finish an overlay.  If there are any overlay wide settings, this
4976    looks through all the sections in the overlay and sets them.  */
4977
4978 void
4979 lang_leave_overlay (lma_expr, nocrossrefs, fill, memspec, phdrs, lma_memspec)
4980      etree_type *lma_expr;
4981      int nocrossrefs;
4982      fill_type *fill;
4983      const char *memspec;
4984      struct lang_output_section_phdr_list *phdrs;
4985      const char *lma_memspec;
4986 {
4987   lang_memory_region_type *region;
4988   lang_memory_region_type *lma_region;
4989   struct overlay_list *l;
4990   struct lang_nocrossref *nocrossref;
4991
4992   lang_get_regions (&region, &lma_region,
4993                     memspec, lma_memspec,
4994                     lma_expr != 0);
4995
4996   nocrossref = NULL;
4997
4998   /* After setting the size of the last section, set '.' to end of the
4999      overlay region.  */
5000   if (overlay_list != NULL)
5001     overlay_list->os->update_dot_tree
5002       = exp_assop ('=', ".", exp_binop ('+', overlay_vma, overlay_max));
5003
5004   l = overlay_list;
5005   while (l != NULL)
5006     {
5007       struct overlay_list *next;
5008
5009       if (fill != (fill_type *) 0 && l->os->fill == (fill_type *) 0)
5010         l->os->fill = fill;
5011
5012       l->os->region = region;
5013       l->os->lma_region = lma_region;
5014
5015       /* The first section has the load address specified in the
5016          OVERLAY statement.  The rest are worked out from that.
5017          The base address is not needed (and should be null) if
5018          an LMA region was specified.  */
5019       if (l->next == 0)
5020         l->os->load_base = lma_expr;
5021       else if (lma_region == 0)
5022         l->os->load_base = exp_binop ('+',
5023                                       exp_nameop (LOADADDR, l->next->os->name),
5024                                       exp_nameop (SIZEOF, l->next->os->name));
5025
5026       if (phdrs != NULL && l->os->phdrs == NULL)
5027         l->os->phdrs = phdrs;
5028
5029       if (nocrossrefs)
5030         {
5031           struct lang_nocrossref *nc;
5032
5033           nc = (struct lang_nocrossref *) xmalloc (sizeof *nc);
5034           nc->name = l->os->name;
5035           nc->next = nocrossref;
5036           nocrossref = nc;
5037         }
5038
5039       next = l->next;
5040       free (l);
5041       l = next;
5042     }
5043
5044   if (nocrossref != NULL)
5045     lang_add_nocrossref (nocrossref);
5046
5047   overlay_vma = NULL;
5048   overlay_list = NULL;
5049   overlay_max = NULL;
5050 }
5051 \f
5052 /* Version handling.  This is only useful for ELF.  */
5053
5054 /* This global variable holds the version tree that we build.  */
5055
5056 struct bfd_elf_version_tree *lang_elf_version_info;
5057
5058 static int
5059 lang_vers_match_lang_c (expr, sym)
5060      struct bfd_elf_version_expr *expr;
5061      const char *sym;
5062 {
5063   if (expr->pattern[0] == '*' && expr->pattern[1] == '\0')
5064     return 1;
5065   return fnmatch (expr->pattern, sym, 0) == 0;
5066 }
5067
5068 static int
5069 lang_vers_match_lang_cplusplus (expr, sym)
5070      struct bfd_elf_version_expr *expr;
5071      const char *sym;
5072 {
5073   char *alt_sym;
5074   int result;
5075
5076   if (expr->pattern[0] == '*' && expr->pattern[1] == '\0')
5077     return 1;
5078
5079   alt_sym = cplus_demangle (sym, /* DMGL_NO_TPARAMS */ 0);
5080   if (!alt_sym)
5081     {
5082       /* cplus_demangle (also) returns NULL when it is not a C++ symbol.
5083          Should we early out false in this case?  */
5084       result = fnmatch (expr->pattern, sym, 0) == 0;
5085     }
5086   else
5087     {
5088       result = fnmatch (expr->pattern, alt_sym, 0) == 0;
5089       free (alt_sym);
5090     }
5091
5092   return result;
5093 }
5094
5095 static int
5096 lang_vers_match_lang_java (expr, sym)
5097      struct bfd_elf_version_expr *expr;
5098      const char *sym;
5099 {
5100   char *alt_sym;
5101   int result;
5102
5103   if (expr->pattern[0] == '*' && expr->pattern[1] == '\0')
5104     return 1;
5105
5106   alt_sym = cplus_demangle (sym, DMGL_JAVA);
5107   if (!alt_sym)
5108     {
5109       /* cplus_demangle (also) returns NULL when it is not a Java symbol.
5110          Should we early out false in this case?  */
5111       result = fnmatch (expr->pattern, sym, 0) == 0;
5112     }
5113   else
5114     {
5115       result = fnmatch (expr->pattern, alt_sym, 0) == 0;
5116       free (alt_sym);
5117     }
5118
5119   return result;
5120 }
5121
5122 /* This is called for each variable name or match expression.  */
5123
5124 struct bfd_elf_version_expr *
5125 lang_new_vers_pattern (orig, new, lang)
5126      struct bfd_elf_version_expr *orig;
5127      const char *new;
5128      const char *lang;
5129 {
5130   struct bfd_elf_version_expr *ret;
5131
5132   ret = (struct bfd_elf_version_expr *) xmalloc (sizeof *ret);
5133   ret->next = orig;
5134   ret->pattern = new;
5135   ret->symver = 0;
5136   ret->script = 0;
5137
5138   if (lang == NULL || strcasecmp (lang, "C") == 0)
5139     ret->match = lang_vers_match_lang_c;
5140   else if (strcasecmp (lang, "C++") == 0)
5141     ret->match = lang_vers_match_lang_cplusplus;
5142   else if (strcasecmp (lang, "Java") == 0)
5143     ret->match = lang_vers_match_lang_java;
5144   else
5145     {
5146       einfo (_("%X%P: unknown language `%s' in version information\n"),
5147              lang);
5148       ret->match = lang_vers_match_lang_c;
5149     }
5150
5151   return ldemul_new_vers_pattern (ret);
5152 }
5153
5154 /* This is called for each set of variable names and match
5155    expressions.  */
5156
5157 struct bfd_elf_version_tree *
5158 lang_new_vers_node (globals, locals)
5159      struct bfd_elf_version_expr *globals;
5160      struct bfd_elf_version_expr *locals;
5161 {
5162   struct bfd_elf_version_tree *ret;
5163
5164   ret = (struct bfd_elf_version_tree *) xmalloc (sizeof *ret);
5165   ret->next = NULL;
5166   ret->name = NULL;
5167   ret->vernum = 0;
5168   ret->globals = globals;
5169   ret->locals = locals;
5170   ret->deps = NULL;
5171   ret->name_indx = (unsigned int) -1;
5172   ret->used = 0;
5173   return ret;
5174 }
5175
5176 /* This static variable keeps track of version indices.  */
5177
5178 static int version_index;
5179
5180 /* This is called when we know the name and dependencies of the
5181    version.  */
5182
5183 void
5184 lang_register_vers_node (name, version, deps)
5185      const char *name;
5186      struct bfd_elf_version_tree *version;
5187      struct bfd_elf_version_deps *deps;
5188 {
5189   struct bfd_elf_version_tree *t, **pp;
5190   struct bfd_elf_version_expr *e1;
5191
5192   if (name == NULL)
5193     name = "";
5194
5195   if ((name[0] == '\0' && lang_elf_version_info != NULL)
5196       || (lang_elf_version_info && lang_elf_version_info->name[0] == '\0'))
5197     {
5198       einfo (_("%X%P: anonymous version tag cannot be combined with other version tags\n"));
5199       return;
5200     }
5201
5202   /* Make sure this node has a unique name.  */
5203   for (t = lang_elf_version_info; t != NULL; t = t->next)
5204     if (strcmp (t->name, name) == 0)
5205       einfo (_("%X%P: duplicate version tag `%s'\n"), name);
5206
5207   /* Check the global and local match names, and make sure there
5208      aren't any duplicates.  */
5209
5210   for (e1 = version->globals; e1 != NULL; e1 = e1->next)
5211     {
5212       for (t = lang_elf_version_info; t != NULL; t = t->next)
5213         {
5214           struct bfd_elf_version_expr *e2;
5215
5216           for (e2 = t->locals; e2 != NULL; e2 = e2->next)
5217             if (strcmp (e1->pattern, e2->pattern) == 0)
5218               einfo (_("%X%P: duplicate expression `%s' in version information\n"),
5219                      e1->pattern);
5220         }
5221     }
5222
5223   for (e1 = version->locals; e1 != NULL; e1 = e1->next)
5224     {
5225       for (t = lang_elf_version_info; t != NULL; t = t->next)
5226         {
5227           struct bfd_elf_version_expr *e2;
5228
5229           for (e2 = t->globals; e2 != NULL; e2 = e2->next)
5230             if (strcmp (e1->pattern, e2->pattern) == 0)
5231               einfo (_("%X%P: duplicate expression `%s' in version information\n"),
5232                      e1->pattern);
5233         }
5234     }
5235
5236   version->deps = deps;
5237   version->name = name;
5238   if (name[0] != '\0')
5239     {
5240       ++version_index;
5241       version->vernum = version_index;
5242     }
5243   else
5244     version->vernum = 0;
5245
5246   for (pp = &lang_elf_version_info; *pp != NULL; pp = &(*pp)->next)
5247     ;
5248   *pp = version;
5249 }
5250
5251 /* This is called when we see a version dependency.  */
5252
5253 struct bfd_elf_version_deps *
5254 lang_add_vers_depend (list, name)
5255      struct bfd_elf_version_deps *list;
5256      const char *name;
5257 {
5258   struct bfd_elf_version_deps *ret;
5259   struct bfd_elf_version_tree *t;
5260
5261   ret = (struct bfd_elf_version_deps *) xmalloc (sizeof *ret);
5262   ret->next = list;
5263
5264   for (t = lang_elf_version_info; t != NULL; t = t->next)
5265     {
5266       if (strcmp (t->name, name) == 0)
5267         {
5268           ret->version_needed = t;
5269           return ret;
5270         }
5271     }
5272
5273   einfo (_("%X%P: unable to find version dependency `%s'\n"), name);
5274
5275   return ret;
5276 }
5277
5278 static void
5279 lang_do_version_exports_section ()
5280 {
5281   struct bfd_elf_version_expr *greg = NULL, *lreg;
5282
5283   LANG_FOR_EACH_INPUT_STATEMENT (is)
5284     {
5285       asection *sec = bfd_get_section_by_name (is->the_bfd, ".exports");
5286       char *contents, *p;
5287       bfd_size_type len;
5288
5289       if (sec == NULL)
5290         continue;
5291
5292       len = bfd_section_size (is->the_bfd, sec);
5293       contents = xmalloc (len);
5294       if (!bfd_get_section_contents (is->the_bfd, sec, contents, 0, len))
5295         einfo (_("%X%P: unable to read .exports section contents\n"), sec);
5296
5297       p = contents;
5298       while (p < contents + len)
5299         {
5300           greg = lang_new_vers_pattern (greg, p, NULL);
5301           p = strchr (p, '\0') + 1;
5302         }
5303
5304       /* Do not free the contents, as we used them creating the regex.  */
5305
5306       /* Do not include this section in the link.  */
5307       bfd_set_section_flags (is->the_bfd, sec,
5308         bfd_get_section_flags (is->the_bfd, sec) | SEC_EXCLUDE);
5309     }
5310
5311   lreg = lang_new_vers_pattern (NULL, "*", NULL);
5312   lang_register_vers_node (command_line.version_exports_section,
5313                            lang_new_vers_node (greg, lreg), NULL);
5314 }
5315
5316 void
5317 lang_add_unique (name)
5318      const char *name;
5319 {
5320   struct unique_sections *ent;
5321
5322   for (ent = unique_section_list; ent; ent = ent->next)
5323     if (strcmp (ent->name, name) == 0)
5324       return;
5325
5326   ent = (struct unique_sections *) xmalloc (sizeof *ent);
5327   ent->name = xstrdup (name);
5328   ent->next = unique_section_list;
5329   unique_section_list = ent;
5330 }