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