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 several 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 alignment, 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 occurrence 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 attach 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                                             command_line.accept_unknown_input_arch);
3704
3705       /* In general it is not possible to perform a relocatable
3706          link between differing object formats when the input
3707          file has relocations, because the relocations in the
3708          input format may not have equivalent representations in
3709          the output format (and besides BFD does not translate
3710          relocs for other link purposes than a final link).  */
3711       if ((link_info.relocateable || link_info.emitrelocations)
3712           && (compatible == NULL
3713               || bfd_get_flavour (input_bfd) != bfd_get_flavour (output_bfd))
3714           && (bfd_get_file_flags (input_bfd) & HAS_RELOC) != 0)
3715         {
3716           einfo (_("%P%F: Relocatable linking with relocations from format %s (%B) to format %s (%B) is not supported\n"),
3717                  bfd_get_target (input_bfd), input_bfd,
3718                  bfd_get_target (output_bfd), output_bfd);
3719           /* einfo with %F exits.  */
3720         }
3721
3722       if (compatible == NULL)
3723         {
3724           if (command_line.warn_mismatch)
3725             einfo (_("%P: warning: %s architecture of input file `%B' is incompatible with %s output\n"),
3726                    bfd_printable_name (input_bfd), input_bfd,
3727                    bfd_printable_name (output_bfd));
3728         }
3729       else if (bfd_count_sections (input_bfd))
3730         {
3731           /* If the input bfd has no contents, it shouldn't set the
3732              private data of the output bfd.  */
3733
3734           bfd_error_handler_type pfn = NULL;
3735
3736           /* If we aren't supposed to warn about mismatched input
3737              files, temporarily set the BFD error handler to a
3738              function which will do nothing.  We still want to call
3739              bfd_merge_private_bfd_data, since it may set up
3740              information which is needed in the output file.  */
3741           if (! command_line.warn_mismatch)
3742             pfn = bfd_set_error_handler (ignore_bfd_errors);
3743           if (! bfd_merge_private_bfd_data (input_bfd, output_bfd))
3744             {
3745               if (command_line.warn_mismatch)
3746                 einfo (_("%E%X: failed to merge target specific data of file %B\n"),
3747                        input_bfd);
3748             }
3749           if (! command_line.warn_mismatch)
3750             bfd_set_error_handler (pfn);
3751         }
3752     }
3753 }
3754
3755 /* Look through all the global common symbols and attach them to the
3756    correct section.  The -sort-common command line switch may be used
3757    to roughly sort the entries by size.  */
3758
3759 static void
3760 lang_common ()
3761 {
3762   if (command_line.inhibit_common_definition)
3763     return;
3764   if (link_info.relocateable
3765       && ! command_line.force_common_definition)
3766     return;
3767
3768   if (! config.sort_common)
3769     bfd_link_hash_traverse (link_info.hash, lang_one_common, (PTR) NULL);
3770   else
3771     {
3772       int power;
3773
3774       for (power = 4; power >= 0; power--)
3775         bfd_link_hash_traverse (link_info.hash, lang_one_common,
3776                                 (PTR) &power);
3777     }
3778 }
3779
3780 /* Place one common symbol in the correct section.  */
3781
3782 static bfd_boolean
3783 lang_one_common (h, info)
3784      struct bfd_link_hash_entry *h;
3785      PTR info;
3786 {
3787   unsigned int power_of_two;
3788   bfd_vma size;
3789   asection *section;
3790   unsigned opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
3791                                                 ldfile_output_machine);
3792
3793   if (h->type != bfd_link_hash_common)
3794     return TRUE;
3795
3796   size = h->u.c.size;
3797   power_of_two = h->u.c.p->alignment_power;
3798
3799   if (config.sort_common
3800       && power_of_two < (unsigned int) *(int *) info)
3801     return TRUE;
3802
3803   section = h->u.c.p->section;
3804
3805   /* Increase the size of the section.  */
3806   section->_cooked_size = align_n ((section->_cooked_size + opb - 1) / opb,
3807                                    (bfd_vma) 1 << power_of_two) * opb;
3808
3809   /* Adjust the alignment if necessary.  */
3810   if (power_of_two > section->alignment_power)
3811     section->alignment_power = power_of_two;
3812
3813   /* Change the symbol from common to defined.  */
3814   h->type = bfd_link_hash_defined;
3815   h->u.def.section = section;
3816   h->u.def.value = section->_cooked_size;
3817
3818   /* Increase the size of the section.  */
3819   section->_cooked_size += size;
3820
3821   /* Make sure the section is allocated in memory, and make sure that
3822      it is no longer a common section.  */
3823   section->flags |= SEC_ALLOC;
3824   section->flags &= ~SEC_IS_COMMON;
3825
3826   if (config.map_file != NULL)
3827     {
3828       static bfd_boolean header_printed;
3829       int len;
3830       char *name;
3831       char buf[50];
3832
3833       if (! header_printed)
3834         {
3835           minfo (_("\nAllocating common symbols\n"));
3836           minfo (_("Common symbol       size              file\n\n"));
3837           header_printed = TRUE;
3838         }
3839
3840       name = demangle (h->root.string);
3841       minfo ("%s", name);
3842       len = strlen (name);
3843       free (name);
3844
3845       if (len >= 19)
3846         {
3847           print_nl ();
3848           len = 0;
3849         }
3850       while (len < 20)
3851         {
3852           print_space ();
3853           ++len;
3854         }
3855
3856       minfo ("0x");
3857       if (size <= 0xffffffff)
3858         sprintf (buf, "%lx", (unsigned long) size);
3859       else
3860         sprintf_vma (buf, size);
3861       minfo ("%s", buf);
3862       len = strlen (buf);
3863
3864       while (len < 16)
3865         {
3866           print_space ();
3867           ++len;
3868         }
3869
3870       minfo ("%B\n", section->owner);
3871     }
3872
3873   return TRUE;
3874 }
3875
3876 /* Run through the input files and ensure that every input section has
3877    somewhere to go.  If one is found without a destination then create
3878    an input request and place it into the statement tree.  */
3879
3880 static void
3881 lang_place_orphans ()
3882 {
3883   LANG_FOR_EACH_INPUT_STATEMENT (file)
3884     {
3885       asection *s;
3886
3887       for (s = file->the_bfd->sections;
3888            s != (asection *) NULL;
3889            s = s->next)
3890         {
3891           if (s->output_section == (asection *) NULL)
3892             {
3893               /* This section of the file is not attached, root
3894                  around for a sensible place for it to go.  */
3895
3896               if (file->just_syms_flag)
3897                 {
3898                   abort ();
3899                 }
3900               else if (strcmp (s->name, "COMMON") == 0)
3901                 {
3902                   /* This is a lonely common section which must have
3903                      come from an archive.  We attach to the section
3904                      with the wildcard.  */
3905                   if (! link_info.relocateable
3906                       || command_line.force_common_definition)
3907                     {
3908                       if (default_common_section == NULL)
3909                         {
3910 #if 0
3911                           /* This message happens when using the
3912                              svr3.ifile linker script, so I have
3913                              disabled it.  */
3914                           info_msg (_("%P: no [COMMON] command, defaulting to .bss\n"));
3915 #endif
3916                           default_common_section =
3917                             lang_output_section_statement_lookup (".bss");
3918
3919                         }
3920                       lang_add_section (&default_common_section->children, s,
3921                                         default_common_section, file);
3922                     }
3923                 }
3924               else if (ldemul_place_orphan (file, s))
3925                 ;
3926               else
3927                 {
3928                   lang_output_section_statement_type *os;
3929
3930                   os = lang_output_section_statement_lookup (s->name);
3931                   lang_add_section (&os->children, s, os, file);
3932                 }
3933             }
3934         }
3935     }
3936 }
3937
3938 void
3939 lang_set_flags (ptr, flags, invert)
3940      lang_memory_region_type *ptr;
3941      const char *flags;
3942      int invert;
3943 {
3944   flagword *ptr_flags;
3945
3946   ptr_flags = invert ? &ptr->not_flags : &ptr->flags;
3947   while (*flags)
3948     {
3949       switch (*flags)
3950         {
3951         case 'A': case 'a':
3952           *ptr_flags |= SEC_ALLOC;
3953           break;
3954
3955         case 'R': case 'r':
3956           *ptr_flags |= SEC_READONLY;
3957           break;
3958
3959         case 'W': case 'w':
3960           *ptr_flags |= SEC_DATA;
3961           break;
3962
3963         case 'X': case 'x':
3964           *ptr_flags |= SEC_CODE;
3965           break;
3966
3967         case 'L': case 'l':
3968         case 'I': case 'i':
3969           *ptr_flags |= SEC_LOAD;
3970           break;
3971
3972         default:
3973           einfo (_("%P%F: invalid syntax in flags\n"));
3974           break;
3975         }
3976       flags++;
3977     }
3978 }
3979
3980 /* Call a function on each input file.  This function will be called
3981    on an archive, but not on the elements.  */
3982
3983 void
3984 lang_for_each_input_file (func)
3985      void (*func) PARAMS ((lang_input_statement_type *));
3986 {
3987   lang_input_statement_type *f;
3988
3989   for (f = (lang_input_statement_type *) input_file_chain.head;
3990        f != NULL;
3991        f = (lang_input_statement_type *) f->next_real_file)
3992     func (f);
3993 }
3994
3995 /* Call a function on each file.  The function will be called on all
3996    the elements of an archive which are included in the link, but will
3997    not be called on the archive file itself.  */
3998
3999 void
4000 lang_for_each_file (func)
4001      void (*func) PARAMS ((lang_input_statement_type *));
4002 {
4003   LANG_FOR_EACH_INPUT_STATEMENT (f)
4004     {
4005       func (f);
4006     }
4007 }
4008
4009 #if 0
4010
4011 /* Not used.  */
4012
4013 void
4014 lang_for_each_input_section (func)
4015      void (*func) PARAMS ((bfd *ab, asection *as));
4016 {
4017   LANG_FOR_EACH_INPUT_STATEMENT (f)
4018     {
4019       asection *s;
4020
4021       for (s = f->the_bfd->sections;
4022            s != (asection *) NULL;
4023            s = s->next)
4024         {
4025           func (f->the_bfd, s);
4026         }
4027     }
4028 }
4029
4030 #endif
4031
4032 void
4033 ldlang_add_file (entry)
4034      lang_input_statement_type *entry;
4035 {
4036   bfd **pp;
4037
4038   lang_statement_append (&file_chain,
4039                          (lang_statement_union_type *) entry,
4040                          &entry->next);
4041
4042   /* The BFD linker needs to have a list of all input BFDs involved in
4043      a link.  */
4044   ASSERT (entry->the_bfd->link_next == (bfd *) NULL);
4045   ASSERT (entry->the_bfd != output_bfd);
4046   for (pp = &link_info.input_bfds;
4047        *pp != (bfd *) NULL;
4048        pp = &(*pp)->link_next)
4049     ;
4050   *pp = entry->the_bfd;
4051   entry->the_bfd->usrdata = (PTR) entry;
4052   bfd_set_gp_size (entry->the_bfd, g_switch_value);
4053
4054   /* Look through the sections and check for any which should not be
4055      included in the link.  We need to do this now, so that we can
4056      notice when the backend linker tries to report multiple
4057      definition errors for symbols which are in sections we aren't
4058      going to link.  FIXME: It might be better to entirely ignore
4059      symbols which are defined in sections which are going to be
4060      discarded.  This would require modifying the backend linker for
4061      each backend which might set the SEC_LINK_ONCE flag.  If we do
4062      this, we should probably handle SEC_EXCLUDE in the same way.  */
4063
4064   bfd_map_over_sections (entry->the_bfd, section_already_linked, (PTR) entry);
4065 }
4066
4067 void
4068 lang_add_output (name, from_script)
4069      const char *name;
4070      int from_script;
4071 {
4072   /* Make -o on command line override OUTPUT in script.  */
4073   if (!had_output_filename || !from_script)
4074     {
4075       output_filename = name;
4076       had_output_filename = TRUE;
4077     }
4078 }
4079
4080 static lang_output_section_statement_type *current_section;
4081
4082 static int
4083 topower (x)
4084      int x;
4085 {
4086   unsigned int i = 1;
4087   int l;
4088
4089   if (x < 0)
4090     return -1;
4091
4092   for (l = 0; l < 32; l++)
4093     {
4094       if (i >= (unsigned int) x)
4095         return l;
4096       i <<= 1;
4097     }
4098
4099   return 0;
4100 }
4101
4102 lang_output_section_statement_type *
4103 lang_enter_output_section_statement (output_section_statement_name,
4104                                      address_exp, sectype, block_value,
4105                                      align, subalign, ebase)
4106      const char *output_section_statement_name;
4107      etree_type *address_exp;
4108      enum section_type sectype;
4109      bfd_vma block_value;
4110      etree_type *align;
4111      etree_type *subalign;
4112      etree_type *ebase;
4113 {
4114   lang_output_section_statement_type *os;
4115
4116   current_section =
4117    os =
4118     lang_output_section_statement_lookup (output_section_statement_name);
4119
4120   /* Add this statement to tree.  */
4121 #if 0
4122   add_statement (lang_output_section_statement_enum,
4123                  output_section_statement);
4124 #endif
4125   /* Make next things chain into subchain of this.  */
4126
4127   if (os->addr_tree == (etree_type *) NULL)
4128     {
4129       os->addr_tree = address_exp;
4130     }
4131   os->sectype = sectype;
4132   if (sectype != noload_section)
4133     os->flags = SEC_NO_FLAGS;
4134   else
4135     os->flags = SEC_NEVER_LOAD;
4136   os->block_value = block_value ? block_value : 1;
4137   stat_ptr = &os->children;
4138
4139   os->subsection_alignment =
4140     topower (exp_get_value_int (subalign, -1, "subsection alignment", 0));
4141   os->section_alignment =
4142     topower (exp_get_value_int (align, -1, "section alignment", 0));
4143
4144   os->load_base = ebase;
4145   return os;
4146 }
4147
4148 void
4149 lang_final ()
4150 {
4151   lang_output_statement_type *new =
4152     new_stat (lang_output_statement, stat_ptr);
4153
4154   new->name = output_filename;
4155 }
4156
4157 /* Reset the current counters in the regions.  */
4158
4159 void
4160 lang_reset_memory_regions ()
4161 {
4162   lang_memory_region_type *p = lang_memory_region_list;
4163   asection *o;
4164
4165   for (p = lang_memory_region_list;
4166        p != (lang_memory_region_type *) NULL;
4167        p = p->next)
4168     {
4169       p->old_length = (bfd_size_type) (p->current - p->origin);
4170       p->current = p->origin;
4171     }
4172
4173   for (o = output_bfd->sections; o != NULL; o = o->next)
4174     o->_raw_size = 0;
4175 }
4176
4177 /* If the wild pattern was marked KEEP, the member sections
4178    should be as well.  */
4179
4180 static void
4181 gc_section_callback (ptr, sec, section, file, data)
4182      lang_wild_statement_type *ptr;
4183      struct wildcard_list *sec ATTRIBUTE_UNUSED;
4184      asection *section;
4185      lang_input_statement_type *file ATTRIBUTE_UNUSED;
4186      PTR data ATTRIBUTE_UNUSED;
4187 {
4188   if (ptr->keep_sections)
4189     section->flags |= SEC_KEEP;
4190 }
4191
4192 /* Handle a wild statement, marking it against GC.  */
4193
4194 static void
4195 lang_gc_wild (s)
4196      lang_wild_statement_type *s;
4197 {
4198   walk_wild (s, gc_section_callback, NULL);
4199 }
4200
4201 /* Iterate over sections marking them against GC.  */
4202
4203 static void
4204 lang_gc_sections_1 (s)
4205      lang_statement_union_type *s;
4206 {
4207   for (; s != (lang_statement_union_type *) NULL; s = s->header.next)
4208     {
4209       switch (s->header.type)
4210         {
4211         case lang_wild_statement_enum:
4212           lang_gc_wild (&s->wild_statement);
4213           break;
4214         case lang_constructors_statement_enum:
4215           lang_gc_sections_1 (constructor_list.head);
4216           break;
4217         case lang_output_section_statement_enum:
4218           lang_gc_sections_1 (s->output_section_statement.children.head);
4219           break;
4220         case lang_group_statement_enum:
4221           lang_gc_sections_1 (s->group_statement.children.head);
4222           break;
4223         default:
4224           break;
4225         }
4226     }
4227 }
4228
4229 static void
4230 lang_gc_sections ()
4231 {
4232   struct bfd_link_hash_entry *h;
4233   ldlang_undef_chain_list_type *ulist;
4234
4235   /* Keep all sections so marked in the link script.  */
4236
4237   lang_gc_sections_1 (statement_list.head);
4238
4239   /* Keep all sections containing symbols undefined on the command-line,
4240      and the section containing the entry symbol.  */
4241
4242   for (ulist = link_info.gc_sym_list; ulist; ulist = ulist->next)
4243     {
4244       h = bfd_link_hash_lookup (link_info.hash, ulist->name,
4245                                 FALSE, FALSE, FALSE);
4246
4247       if (h != (struct bfd_link_hash_entry *) NULL
4248           && (h->type == bfd_link_hash_defined
4249               || h->type == bfd_link_hash_defweak)
4250           && ! bfd_is_abs_section (h->u.def.section))
4251         {
4252           h->u.def.section->flags |= SEC_KEEP;
4253         }
4254     }
4255
4256   bfd_gc_sections (output_bfd, &link_info);
4257 }
4258
4259 void
4260 lang_process ()
4261 {
4262   lang_reasonable_defaults ();
4263   current_target = default_target;
4264
4265   /* Open the output file.  */
4266   lang_for_each_statement (ldlang_open_output);
4267
4268   ldemul_create_output_section_statements ();
4269
4270   /* Add to the hash table all undefineds on the command line.  */
4271   lang_place_undefineds ();
4272
4273   already_linked_table_init ();
4274
4275   /* Create a bfd for each input file.  */
4276   current_target = default_target;
4277   open_input_bfds (statement_list.head, FALSE);
4278
4279   link_info.gc_sym_list = &entry_symbol;
4280   if (entry_symbol.name == NULL)
4281     link_info.gc_sym_list = ldlang_undef_chain_list_head;
4282
4283   ldemul_after_open ();
4284
4285   already_linked_table_free ();
4286
4287   /* Make sure that we're not mixing architectures.  We call this
4288      after all the input files have been opened, but before we do any
4289      other processing, so that any operations merge_private_bfd_data
4290      does on the output file will be known during the rest of the
4291      link.  */
4292   lang_check ();
4293
4294   /* Handle .exports instead of a version script if we're told to do so.  */
4295   if (command_line.version_exports_section)
4296     lang_do_version_exports_section ();
4297
4298   /* Build all sets based on the information gathered from the input
4299      files.  */
4300   ldctor_build_sets ();
4301
4302   /* Remove unreferenced sections if asked to.  */
4303   if (command_line.gc_sections)
4304     lang_gc_sections ();
4305
4306   /* If there were any SEC_MERGE sections, finish their merging, so that
4307      section sizes can be computed.  This has to be done after GC of sections,
4308      so that GCed sections are not merged, but before assigning output
4309      sections, since removing whole input sections is hard then.  */
4310   bfd_merge_sections (output_bfd, &link_info);
4311
4312   /* Size up the common data.  */
4313   lang_common ();
4314
4315   /* Run through the contours of the script and attach input sections
4316      to the correct output sections.  */
4317   map_input_to_output_sections (statement_list.head, (char *) NULL,
4318                                 (lang_output_section_statement_type *) NULL);
4319
4320   /* Find any sections not attached explicitly and handle them.  */
4321   lang_place_orphans ();
4322
4323   if (! link_info.relocateable)
4324     {
4325       /* Look for a text section and set the readonly attribute in it.  */
4326       asection *found = bfd_get_section_by_name (output_bfd, ".text");
4327
4328       if (found != (asection *) NULL)
4329         {
4330           if (config.text_read_only)
4331             found->flags |= SEC_READONLY;
4332           else
4333             found->flags &= ~SEC_READONLY;
4334         }
4335     }
4336
4337   /* Do anything special before sizing sections.  This is where ELF
4338      and other back-ends size dynamic sections.  */
4339   ldemul_before_allocation ();
4340
4341   if (!link_info.relocateable)
4342     strip_excluded_output_sections ();
4343
4344   /* We must record the program headers before we try to fix the
4345      section positions, since they will affect SIZEOF_HEADERS.  */
4346   lang_record_phdrs ();
4347
4348   /* Size up the sections.  */
4349   lang_size_sections (statement_list.head,
4350                       abs_output_section,
4351                       &statement_list.head, 0, (bfd_vma) 0, NULL);
4352
4353   /* Now run around and relax if we can.  */
4354   if (command_line.relax)
4355     {
4356       /* Keep relaxing until bfd_relax_section gives up.  */
4357       bfd_boolean relax_again;
4358
4359       do
4360         {
4361           lang_reset_memory_regions ();
4362
4363           relax_again = FALSE;
4364
4365           /* Note: pe-dll.c does something like this also.  If you find
4366              you need to change this code, you probably need to change
4367              pe-dll.c also.  DJ  */
4368
4369           /* Do all the assignments with our current guesses as to
4370              section sizes.  */
4371           lang_do_assignments (statement_list.head,
4372                                abs_output_section,
4373                                (fill_type *) 0, (bfd_vma) 0);
4374
4375           /* Perform another relax pass - this time we know where the
4376              globals are, so can make a better guess.  */
4377           lang_size_sections (statement_list.head,
4378                               abs_output_section,
4379                               &statement_list.head, 0, (bfd_vma) 0,
4380                               &relax_again);
4381         }
4382       while (relax_again);
4383     }
4384
4385   /* See if anything special should be done now we know how big
4386      everything is.  */
4387   ldemul_after_allocation ();
4388
4389   /* Fix any .startof. or .sizeof. symbols.  */
4390   lang_set_startof ();
4391
4392   /* Do all the assignments, now that we know the final resting places
4393      of all the symbols.  */
4394
4395   lang_do_assignments (statement_list.head,
4396                        abs_output_section,
4397                        (fill_type *) 0, (bfd_vma) 0);
4398
4399   /* Make sure that the section addresses make sense.  */
4400   if (! link_info.relocateable
4401       && command_line.check_section_addresses)
4402     lang_check_section_addresses ();
4403
4404   /* Final stuffs.  */
4405
4406   ldemul_finish ();
4407   lang_finish ();
4408 }
4409
4410 /* EXPORTED TO YACC */
4411
4412 void
4413 lang_add_wild (filespec, section_list, keep_sections)
4414      struct wildcard_spec *filespec;
4415      struct wildcard_list *section_list;
4416      bfd_boolean keep_sections;
4417 {
4418   struct wildcard_list *curr, *next;
4419   lang_wild_statement_type *new;
4420
4421   /* Reverse the list as the parser puts it back to front.  */
4422   for (curr = section_list, section_list = NULL;
4423        curr != NULL;
4424        section_list = curr, curr = next)
4425     {
4426       if (curr->spec.name != NULL && strcmp (curr->spec.name, "COMMON") == 0)
4427         placed_commons = TRUE;
4428
4429       next = curr->next;
4430       curr->next = section_list;
4431     }
4432
4433   if (filespec != NULL && filespec->name != NULL)
4434     {
4435       if (strcmp (filespec->name, "*") == 0)
4436         filespec->name = NULL;
4437       else if (! wildcardp (filespec->name))
4438         lang_has_input_file = TRUE;
4439     }
4440
4441   new = new_stat (lang_wild_statement, stat_ptr);
4442   new->filename = NULL;
4443   new->filenames_sorted = FALSE;
4444   if (filespec != NULL)
4445     {
4446       new->filename = filespec->name;
4447       new->filenames_sorted = filespec->sorted;
4448     }
4449   new->section_list = section_list;
4450   new->keep_sections = keep_sections;
4451   lang_list_init (&new->children);
4452 }
4453
4454 void
4455 lang_section_start (name, address)
4456      const char *name;
4457      etree_type *address;
4458 {
4459   lang_address_statement_type *ad;
4460
4461   ad = new_stat (lang_address_statement, stat_ptr);
4462   ad->section_name = name;
4463   ad->address = address;
4464 }
4465
4466 /* Set the start symbol to NAME.  CMDLINE is nonzero if this is called
4467    because of a -e argument on the command line, or zero if this is
4468    called by ENTRY in a linker script.  Command line arguments take
4469    precedence.  */
4470
4471 void
4472 lang_add_entry (name, cmdline)
4473      const char *name;
4474      bfd_boolean cmdline;
4475 {
4476   if (entry_symbol.name == NULL
4477       || cmdline
4478       || ! entry_from_cmdline)
4479     {
4480       entry_symbol.name = name;
4481       entry_from_cmdline = cmdline;
4482     }
4483 }
4484
4485 void
4486 lang_add_target (name)
4487      const char *name;
4488 {
4489   lang_target_statement_type *new = new_stat (lang_target_statement,
4490                                               stat_ptr);
4491
4492   new->target = name;
4493
4494 }
4495
4496 void
4497 lang_add_map (name)
4498      const char *name;
4499 {
4500   while (*name)
4501     {
4502       switch (*name)
4503         {
4504         case 'F':
4505           map_option_f = TRUE;
4506           break;
4507         }
4508       name++;
4509     }
4510 }
4511
4512 void
4513 lang_add_fill (fill)
4514      fill_type *fill;
4515 {
4516   lang_fill_statement_type *new = new_stat (lang_fill_statement,
4517                                             stat_ptr);
4518
4519   new->fill = fill;
4520 }
4521
4522 void
4523 lang_add_data (type, exp)
4524      int type;
4525      union etree_union *exp;
4526 {
4527
4528   lang_data_statement_type *new = new_stat (lang_data_statement,
4529                                             stat_ptr);
4530
4531   new->exp = exp;
4532   new->type = type;
4533
4534 }
4535
4536 /* Create a new reloc statement.  RELOC is the BFD relocation type to
4537    generate.  HOWTO is the corresponding howto structure (we could
4538    look this up, but the caller has already done so).  SECTION is the
4539    section to generate a reloc against, or NAME is the name of the
4540    symbol to generate a reloc against.  Exactly one of SECTION and
4541    NAME must be NULL.  ADDEND is an expression for the addend.  */
4542
4543 void
4544 lang_add_reloc (reloc, howto, section, name, addend)
4545      bfd_reloc_code_real_type reloc;
4546      reloc_howto_type *howto;
4547      asection *section;
4548      const char *name;
4549      union etree_union *addend;
4550 {
4551   lang_reloc_statement_type *p = new_stat (lang_reloc_statement, stat_ptr);
4552
4553   p->reloc = reloc;
4554   p->howto = howto;
4555   p->section = section;
4556   p->name = name;
4557   p->addend_exp = addend;
4558
4559   p->addend_value = 0;
4560   p->output_section = NULL;
4561   p->output_vma = 0;
4562 }
4563
4564 lang_assignment_statement_type *
4565 lang_add_assignment (exp)
4566      etree_type *exp;
4567 {
4568   lang_assignment_statement_type *new = new_stat (lang_assignment_statement,
4569                                                   stat_ptr);
4570
4571   new->exp = exp;
4572   return new;
4573 }
4574
4575 void
4576 lang_add_attribute (attribute)
4577      enum statement_enum attribute;
4578 {
4579   new_statement (attribute, sizeof (lang_statement_union_type), stat_ptr);
4580 }
4581
4582 void
4583 lang_startup (name)
4584      const char *name;
4585 {
4586   if (startup_file != (char *) NULL)
4587     {
4588       einfo (_("%P%Fmultiple STARTUP files\n"));
4589     }
4590   first_file->filename = name;
4591   first_file->local_sym_name = name;
4592   first_file->real = TRUE;
4593
4594   startup_file = name;
4595 }
4596
4597 void
4598 lang_float (maybe)
4599      bfd_boolean maybe;
4600 {
4601   lang_float_flag = maybe;
4602 }
4603
4604
4605 /* Work out the load- and run-time regions from a script statement, and
4606    store them in *LMA_REGION and *REGION respectively.
4607
4608    MEMSPEC is the name of the run-time region, or "*default*" if the
4609    statement didn't specify one.  LMA_MEMSPEC is the name of the
4610    load-time region, or null if the statement didn't specify one.
4611    HAVE_LMA_P is TRUE if the statement had an explicit load address.
4612
4613    It is an error to specify both a load region and a load address.  */
4614
4615 static void
4616 lang_get_regions (region, lma_region, memspec, lma_memspec, have_lma_p)
4617      struct memory_region_struct **region, **lma_region;
4618      const char *memspec, *lma_memspec;
4619      int have_lma_p;
4620 {
4621   *lma_region = lang_memory_region_lookup (lma_memspec);
4622
4623   /* If no runtime region has been given, but the load region has
4624      been, use the load region.  */
4625   if (lma_memspec != 0 && strcmp (memspec, "*default*") == 0)
4626     *region = *lma_region;
4627   else
4628     *region = lang_memory_region_lookup (memspec);
4629
4630   if (have_lma_p && lma_memspec != 0)
4631     einfo (_("%X%P:%S: section has both a load address and a load region\n"));
4632 }
4633
4634 void
4635 lang_leave_output_section_statement (fill, memspec, phdrs, lma_memspec)
4636      fill_type *fill;
4637      const char *memspec;
4638      struct lang_output_section_phdr_list *phdrs;
4639      const char *lma_memspec;
4640 {
4641   lang_get_regions (&current_section->region,
4642                     &current_section->lma_region,
4643                     memspec, lma_memspec,
4644                     current_section->load_base != 0);
4645   current_section->fill = fill;
4646   current_section->phdrs = phdrs;
4647   stat_ptr = &statement_list;
4648 }
4649
4650 /* Create an absolute symbol with the given name with the value of the
4651    address of first byte of the section named.
4652
4653    If the symbol already exists, then do nothing.  */
4654
4655 void
4656 lang_abs_symbol_at_beginning_of (secname, name)
4657      const char *secname;
4658      const char *name;
4659 {
4660   struct bfd_link_hash_entry *h;
4661
4662   h = bfd_link_hash_lookup (link_info.hash, name, TRUE, TRUE, TRUE);
4663   if (h == (struct bfd_link_hash_entry *) NULL)
4664     einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
4665
4666   if (h->type == bfd_link_hash_new
4667       || h->type == bfd_link_hash_undefined)
4668     {
4669       asection *sec;
4670
4671       h->type = bfd_link_hash_defined;
4672
4673       sec = bfd_get_section_by_name (output_bfd, secname);
4674       if (sec == (asection *) NULL)
4675         h->u.def.value = 0;
4676       else
4677         h->u.def.value = bfd_get_section_vma (output_bfd, sec);
4678
4679       h->u.def.section = bfd_abs_section_ptr;
4680     }
4681 }
4682
4683 /* Create an absolute symbol with the given name with the value of the
4684    address of the first byte after the end of the section named.
4685
4686    If the symbol already exists, then do nothing.  */
4687
4688 void
4689 lang_abs_symbol_at_end_of (secname, name)
4690      const char *secname;
4691      const char *name;
4692 {
4693   struct bfd_link_hash_entry *h;
4694
4695   h = bfd_link_hash_lookup (link_info.hash, name, TRUE, TRUE, TRUE);
4696   if (h == (struct bfd_link_hash_entry *) NULL)
4697     einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
4698
4699   if (h->type == bfd_link_hash_new
4700       || h->type == bfd_link_hash_undefined)
4701     {
4702       asection *sec;
4703
4704       h->type = bfd_link_hash_defined;
4705
4706       sec = bfd_get_section_by_name (output_bfd, secname);
4707       if (sec == (asection *) NULL)
4708         h->u.def.value = 0;
4709       else
4710         h->u.def.value = (bfd_get_section_vma (output_bfd, sec)
4711                           + bfd_section_size (output_bfd, sec) /
4712                           bfd_octets_per_byte (output_bfd));
4713
4714       h->u.def.section = bfd_abs_section_ptr;
4715     }
4716 }
4717
4718 void
4719 lang_statement_append (list, element, field)
4720      lang_statement_list_type *list;
4721      lang_statement_union_type *element;
4722      lang_statement_union_type **field;
4723 {
4724   *(list->tail) = element;
4725   list->tail = field;
4726 }
4727
4728 /* Set the output format type.  -oformat overrides scripts.  */
4729
4730 void
4731 lang_add_output_format (format, big, little, from_script)
4732      const char *format;
4733      const char *big;
4734      const char *little;
4735      int from_script;
4736 {
4737   if (output_target == NULL || !from_script)
4738     {
4739       if (command_line.endian == ENDIAN_BIG
4740           && big != NULL)
4741         format = big;
4742       else if (command_line.endian == ENDIAN_LITTLE
4743                && little != NULL)
4744         format = little;
4745
4746       output_target = format;
4747     }
4748 }
4749
4750 /* Enter a group.  This creates a new lang_group_statement, and sets
4751    stat_ptr to build new statements within the group.  */
4752
4753 void
4754 lang_enter_group ()
4755 {
4756   lang_group_statement_type *g;
4757
4758   g = new_stat (lang_group_statement, stat_ptr);
4759   lang_list_init (&g->children);
4760   stat_ptr = &g->children;
4761 }
4762
4763 /* Leave a group.  This just resets stat_ptr to start writing to the
4764    regular list of statements again.  Note that this will not work if
4765    groups can occur inside anything else which can adjust stat_ptr,
4766    but currently they can't.  */
4767
4768 void
4769 lang_leave_group ()
4770 {
4771   stat_ptr = &statement_list;
4772 }
4773
4774 /* Add a new program header.  This is called for each entry in a PHDRS
4775    command in a linker script.  */
4776
4777 void
4778 lang_new_phdr (name, type, filehdr, phdrs, at, flags)
4779      const char *name;
4780      etree_type *type;
4781      bfd_boolean filehdr;
4782      bfd_boolean phdrs;
4783      etree_type *at;
4784      etree_type *flags;
4785 {
4786   struct lang_phdr *n, **pp;
4787
4788   n = (struct lang_phdr *) stat_alloc (sizeof (struct lang_phdr));
4789   n->next = NULL;
4790   n->name = name;
4791   n->type = exp_get_value_int (type, 0, "program header type",
4792                                lang_final_phase_enum);
4793   n->filehdr = filehdr;
4794   n->phdrs = phdrs;
4795   n->at = at;
4796   n->flags = flags;
4797
4798   for (pp = &lang_phdr_list; *pp != NULL; pp = &(*pp)->next)
4799     ;
4800   *pp = n;
4801 }
4802
4803 /* Record the program header information in the output BFD.  FIXME: We
4804    should not be calling an ELF specific function here.  */
4805
4806 static void
4807 lang_record_phdrs ()
4808 {
4809   unsigned int alc;
4810   asection **secs;
4811   struct lang_output_section_phdr_list *last;
4812   struct lang_phdr *l;
4813   lang_statement_union_type *u;
4814
4815   alc = 10;
4816   secs = (asection **) xmalloc (alc * sizeof (asection *));
4817   last = NULL;
4818   for (l = lang_phdr_list; l != NULL; l = l->next)
4819     {
4820       unsigned int c;
4821       flagword flags;
4822       bfd_vma at;
4823
4824       c = 0;
4825       for (u = lang_output_section_statement.head;
4826            u != NULL;
4827            u = u->output_section_statement.next)
4828         {
4829           lang_output_section_statement_type *os;
4830           struct lang_output_section_phdr_list *pl;
4831
4832           os = &u->output_section_statement;
4833
4834           pl = os->phdrs;
4835           if (pl != NULL)
4836             last = pl;
4837           else
4838             {
4839               if (os->sectype == noload_section
4840                   || os->bfd_section == NULL
4841                   || (os->bfd_section->flags & SEC_ALLOC) == 0)
4842                 continue;
4843               pl = last;
4844             }
4845
4846           if (os->bfd_section == NULL)
4847             continue;
4848
4849           for (; pl != NULL; pl = pl->next)
4850             {
4851               if (strcmp (pl->name, l->name) == 0)
4852                 {
4853                   if (c >= alc)
4854                     {
4855                       alc *= 2;
4856                       secs = ((asection **)
4857                               xrealloc (secs, alc * sizeof (asection *)));
4858                     }
4859                   secs[c] = os->bfd_section;
4860                   ++c;
4861                   pl->used = TRUE;
4862                 }
4863             }
4864         }
4865
4866       if (l->flags == NULL)
4867         flags = 0;
4868       else
4869         flags = exp_get_vma (l->flags, 0, "phdr flags",
4870                              lang_final_phase_enum);
4871
4872       if (l->at == NULL)
4873         at = 0;
4874       else
4875         at = exp_get_vma (l->at, 0, "phdr load address",
4876                           lang_final_phase_enum);
4877
4878       if (! bfd_record_phdr (output_bfd, l->type,
4879                              l->flags != NULL, flags, l->at != NULL,
4880                              at, l->filehdr, l->phdrs, c, secs))
4881         einfo (_("%F%P: bfd_record_phdr failed: %E\n"));
4882     }
4883
4884   free (secs);
4885
4886   /* Make sure all the phdr assignments succeeded.  */
4887   for (u = lang_output_section_statement.head;
4888        u != NULL;
4889        u = u->output_section_statement.next)
4890     {
4891       struct lang_output_section_phdr_list *pl;
4892
4893       if (u->output_section_statement.bfd_section == NULL)
4894         continue;
4895
4896       for (pl = u->output_section_statement.phdrs;
4897            pl != NULL;
4898            pl = pl->next)
4899         if (! pl->used && strcmp (pl->name, "NONE") != 0)
4900           einfo (_("%X%P: section `%s' assigned to non-existent phdr `%s'\n"),
4901                  u->output_section_statement.name, pl->name);
4902     }
4903 }
4904
4905 /* Record a list of sections which may not be cross referenced.  */
4906
4907 void
4908 lang_add_nocrossref (l)
4909      struct lang_nocrossref *l;
4910 {
4911   struct lang_nocrossrefs *n;
4912
4913   n = (struct lang_nocrossrefs *) xmalloc (sizeof *n);
4914   n->next = nocrossref_list;
4915   n->list = l;
4916   nocrossref_list = n;
4917
4918   /* Set notice_all so that we get informed about all symbols.  */
4919   link_info.notice_all = TRUE;
4920 }
4921 \f
4922 /* Overlay handling.  We handle overlays with some static variables.  */
4923
4924 /* The overlay virtual address.  */
4925 static etree_type *overlay_vma;
4926
4927 /* An expression for the maximum section size seen so far.  */
4928 static etree_type *overlay_max;
4929
4930 /* A list of all the sections in this overlay.  */
4931
4932 struct overlay_list {
4933   struct overlay_list *next;
4934   lang_output_section_statement_type *os;
4935 };
4936
4937 static struct overlay_list *overlay_list;
4938
4939 /* Start handling an overlay.  */
4940
4941 void
4942 lang_enter_overlay (vma_expr)
4943      etree_type *vma_expr;
4944 {
4945   /* The grammar should prevent nested overlays from occurring.  */
4946   ASSERT (overlay_vma == NULL && overlay_max == NULL);
4947
4948   overlay_vma = vma_expr;
4949 }
4950
4951 /* Start a section in an overlay.  We handle this by calling
4952    lang_enter_output_section_statement with the correct VMA.
4953    lang_leave_overlay sets up the LMA and memory regions.  */
4954
4955 void
4956 lang_enter_overlay_section (name)
4957      const char *name;
4958 {
4959   struct overlay_list *n;
4960   etree_type *size;
4961
4962   lang_enter_output_section_statement (name, overlay_vma, normal_section,
4963                                        0, 0, 0, 0);
4964
4965   /* If this is the first section, then base the VMA of future
4966      sections on this one.  This will work correctly even if `.' is
4967      used in the addresses.  */
4968   if (overlay_list == NULL)
4969     overlay_vma = exp_nameop (ADDR, name);
4970
4971   /* Remember the section.  */
4972   n = (struct overlay_list *) xmalloc (sizeof *n);
4973   n->os = current_section;
4974   n->next = overlay_list;
4975   overlay_list = n;
4976
4977   size = exp_nameop (SIZEOF, name);
4978
4979   /* Arrange to work out the maximum section end address.  */
4980   if (overlay_max == NULL)
4981     overlay_max = size;
4982   else
4983     overlay_max = exp_binop (MAX_K, overlay_max, size);
4984 }
4985
4986 /* Finish a section in an overlay.  There isn't any special to do
4987    here.  */
4988
4989 void
4990 lang_leave_overlay_section (fill, phdrs)
4991      fill_type *fill;
4992      struct lang_output_section_phdr_list *phdrs;
4993 {
4994   const char *name;
4995   char *clean, *s2;
4996   const char *s1;
4997   char *buf;
4998
4999   name = current_section->name;
5000
5001   /* For now, assume that "*default*" is the run-time memory region and
5002      that no load-time region has been specified.  It doesn't really
5003      matter what we say here, since lang_leave_overlay will override it.  */
5004   lang_leave_output_section_statement (fill, "*default*", phdrs, 0);
5005
5006   /* Define the magic symbols.  */
5007
5008   clean = xmalloc (strlen (name) + 1);
5009   s2 = clean;
5010   for (s1 = name; *s1 != '\0'; s1++)
5011     if (ISALNUM (*s1) || *s1 == '_')
5012       *s2++ = *s1;
5013   *s2 = '\0';
5014
5015   buf = xmalloc (strlen (clean) + sizeof "__load_start_");
5016   sprintf (buf, "__load_start_%s", clean);
5017   lang_add_assignment (exp_assop ('=', buf,
5018                                   exp_nameop (LOADADDR, name)));
5019
5020   buf = xmalloc (strlen (clean) + sizeof "__load_stop_");
5021   sprintf (buf, "__load_stop_%s", clean);
5022   lang_add_assignment (exp_assop ('=', buf,
5023                                   exp_binop ('+',
5024                                              exp_nameop (LOADADDR, name),
5025                                              exp_nameop (SIZEOF, name))));
5026
5027   free (clean);
5028 }
5029
5030 /* Finish an overlay.  If there are any overlay wide settings, this
5031    looks through all the sections in the overlay and sets them.  */
5032
5033 void
5034 lang_leave_overlay (lma_expr, nocrossrefs, fill, memspec, phdrs, lma_memspec)
5035      etree_type *lma_expr;
5036      int nocrossrefs;
5037      fill_type *fill;
5038      const char *memspec;
5039      struct lang_output_section_phdr_list *phdrs;
5040      const char *lma_memspec;
5041 {
5042   lang_memory_region_type *region;
5043   lang_memory_region_type *lma_region;
5044   struct overlay_list *l;
5045   struct lang_nocrossref *nocrossref;
5046
5047   lang_get_regions (&region, &lma_region,
5048                     memspec, lma_memspec,
5049                     lma_expr != 0);
5050
5051   nocrossref = NULL;
5052
5053   /* After setting the size of the last section, set '.' to end of the
5054      overlay region.  */
5055   if (overlay_list != NULL)
5056     overlay_list->os->update_dot_tree
5057       = exp_assop ('=', ".", exp_binop ('+', overlay_vma, overlay_max));
5058
5059   l = overlay_list;
5060   while (l != NULL)
5061     {
5062       struct overlay_list *next;
5063
5064       if (fill != (fill_type *) 0 && l->os->fill == (fill_type *) 0)
5065         l->os->fill = fill;
5066
5067       l->os->region = region;
5068       l->os->lma_region = lma_region;
5069
5070       /* The first section has the load address specified in the
5071          OVERLAY statement.  The rest are worked out from that.
5072          The base address is not needed (and should be null) if
5073          an LMA region was specified.  */
5074       if (l->next == 0)
5075         l->os->load_base = lma_expr;
5076       else if (lma_region == 0)
5077         l->os->load_base = exp_binop ('+',
5078                                       exp_nameop (LOADADDR, l->next->os->name),
5079                                       exp_nameop (SIZEOF, l->next->os->name));
5080
5081       if (phdrs != NULL && l->os->phdrs == NULL)
5082         l->os->phdrs = phdrs;
5083
5084       if (nocrossrefs)
5085         {
5086           struct lang_nocrossref *nc;
5087
5088           nc = (struct lang_nocrossref *) xmalloc (sizeof *nc);
5089           nc->name = l->os->name;
5090           nc->next = nocrossref;
5091           nocrossref = nc;
5092         }
5093
5094       next = l->next;
5095       free (l);
5096       l = next;
5097     }
5098
5099   if (nocrossref != NULL)
5100     lang_add_nocrossref (nocrossref);
5101
5102   overlay_vma = NULL;
5103   overlay_list = NULL;
5104   overlay_max = NULL;
5105 }
5106 \f
5107 /* Version handling.  This is only useful for ELF.  */
5108
5109 /* This global variable holds the version tree that we build.  */
5110
5111 struct bfd_elf_version_tree *lang_elf_version_info;
5112
5113 static int
5114 lang_vers_match_lang_c (expr, sym)
5115      struct bfd_elf_version_expr *expr;
5116      const char *sym;
5117 {
5118   if (expr->pattern[0] == '*' && expr->pattern[1] == '\0')
5119     return 1;
5120   return fnmatch (expr->pattern, sym, 0) == 0;
5121 }
5122
5123 static int
5124 lang_vers_match_lang_cplusplus (expr, sym)
5125      struct bfd_elf_version_expr *expr;
5126      const char *sym;
5127 {
5128   char *alt_sym;
5129   int result;
5130
5131   if (expr->pattern[0] == '*' && expr->pattern[1] == '\0')
5132     return 1;
5133
5134   alt_sym = cplus_demangle (sym, /* DMGL_NO_TPARAMS */ 0);
5135   if (!alt_sym)
5136     {
5137       /* cplus_demangle (also) returns NULL when it is not a C++ symbol.
5138          Should we early out FALSE in this case?  */
5139       result = fnmatch (expr->pattern, sym, 0) == 0;
5140     }
5141   else
5142     {
5143       result = fnmatch (expr->pattern, alt_sym, 0) == 0;
5144       free (alt_sym);
5145     }
5146
5147   return result;
5148 }
5149
5150 static int
5151 lang_vers_match_lang_java (expr, sym)
5152      struct bfd_elf_version_expr *expr;
5153      const char *sym;
5154 {
5155   char *alt_sym;
5156   int result;
5157
5158   if (expr->pattern[0] == '*' && expr->pattern[1] == '\0')
5159     return 1;
5160
5161   alt_sym = cplus_demangle (sym, DMGL_JAVA);
5162   if (!alt_sym)
5163     {
5164       /* cplus_demangle (also) returns NULL when it is not a Java symbol.
5165          Should we early out FALSE in this case?  */
5166       result = fnmatch (expr->pattern, sym, 0) == 0;
5167     }
5168   else
5169     {
5170       result = fnmatch (expr->pattern, alt_sym, 0) == 0;
5171       free (alt_sym);
5172     }
5173
5174   return result;
5175 }
5176
5177 /* This is called for each variable name or match expression.  */
5178
5179 struct bfd_elf_version_expr *
5180 lang_new_vers_pattern (orig, new, lang)
5181      struct bfd_elf_version_expr *orig;
5182      const char *new;
5183      const char *lang;
5184 {
5185   struct bfd_elf_version_expr *ret;
5186
5187   ret = (struct bfd_elf_version_expr *) xmalloc (sizeof *ret);
5188   ret->next = orig;
5189   ret->pattern = new;
5190   ret->symver = 0;
5191   ret->script = 0;
5192
5193   if (lang == NULL || strcasecmp (lang, "C") == 0)
5194     ret->match = lang_vers_match_lang_c;
5195   else if (strcasecmp (lang, "C++") == 0)
5196     ret->match = lang_vers_match_lang_cplusplus;
5197   else if (strcasecmp (lang, "Java") == 0)
5198     ret->match = lang_vers_match_lang_java;
5199   else
5200     {
5201       einfo (_("%X%P: unknown language `%s' in version information\n"),
5202              lang);
5203       ret->match = lang_vers_match_lang_c;
5204     }
5205
5206   return ldemul_new_vers_pattern (ret);
5207 }
5208
5209 /* This is called for each set of variable names and match
5210    expressions.  */
5211
5212 struct bfd_elf_version_tree *
5213 lang_new_vers_node (globals, locals)
5214      struct bfd_elf_version_expr *globals;
5215      struct bfd_elf_version_expr *locals;
5216 {
5217   struct bfd_elf_version_tree *ret;
5218
5219   ret = (struct bfd_elf_version_tree *) xmalloc (sizeof *ret);
5220   ret->next = NULL;
5221   ret->name = NULL;
5222   ret->vernum = 0;
5223   ret->globals = globals;
5224   ret->locals = locals;
5225   ret->deps = NULL;
5226   ret->name_indx = (unsigned int) -1;
5227   ret->used = 0;
5228   return ret;
5229 }
5230
5231 /* This static variable keeps track of version indices.  */
5232
5233 static int version_index;
5234
5235 /* This is called when we know the name and dependencies of the
5236    version.  */
5237
5238 void
5239 lang_register_vers_node (name, version, deps)
5240      const char *name;
5241      struct bfd_elf_version_tree *version;
5242      struct bfd_elf_version_deps *deps;
5243 {
5244   struct bfd_elf_version_tree *t, **pp;
5245   struct bfd_elf_version_expr *e1;
5246
5247   if (name == NULL)
5248     name = "";
5249
5250   if ((name[0] == '\0' && lang_elf_version_info != NULL)
5251       || (lang_elf_version_info && lang_elf_version_info->name[0] == '\0'))
5252     {
5253       einfo (_("%X%P: anonymous version tag cannot be combined with other version tags\n"));
5254       return;
5255     }
5256
5257   /* Make sure this node has a unique name.  */
5258   for (t = lang_elf_version_info; t != NULL; t = t->next)
5259     if (strcmp (t->name, name) == 0)
5260       einfo (_("%X%P: duplicate version tag `%s'\n"), name);
5261
5262   /* Check the global and local match names, and make sure there
5263      aren't any duplicates.  */
5264
5265   for (e1 = version->globals; e1 != NULL; e1 = e1->next)
5266     {
5267       for (t = lang_elf_version_info; t != NULL; t = t->next)
5268         {
5269           struct bfd_elf_version_expr *e2;
5270
5271           for (e2 = t->locals; e2 != NULL; e2 = e2->next)
5272             if (strcmp (e1->pattern, e2->pattern) == 0)
5273               einfo (_("%X%P: duplicate expression `%s' in version information\n"),
5274                      e1->pattern);
5275         }
5276     }
5277
5278   for (e1 = version->locals; e1 != NULL; e1 = e1->next)
5279     {
5280       for (t = lang_elf_version_info; t != NULL; t = t->next)
5281         {
5282           struct bfd_elf_version_expr *e2;
5283
5284           for (e2 = t->globals; e2 != NULL; e2 = e2->next)
5285             if (strcmp (e1->pattern, e2->pattern) == 0)
5286               einfo (_("%X%P: duplicate expression `%s' in version information\n"),
5287                      e1->pattern);
5288         }
5289     }
5290
5291   version->deps = deps;
5292   version->name = name;
5293   if (name[0] != '\0')
5294     {
5295       ++version_index;
5296       version->vernum = version_index;
5297     }
5298   else
5299     version->vernum = 0;
5300
5301   for (pp = &lang_elf_version_info; *pp != NULL; pp = &(*pp)->next)
5302     ;
5303   *pp = version;
5304 }
5305
5306 /* This is called when we see a version dependency.  */
5307
5308 struct bfd_elf_version_deps *
5309 lang_add_vers_depend (list, name)
5310      struct bfd_elf_version_deps *list;
5311      const char *name;
5312 {
5313   struct bfd_elf_version_deps *ret;
5314   struct bfd_elf_version_tree *t;
5315
5316   ret = (struct bfd_elf_version_deps *) xmalloc (sizeof *ret);
5317   ret->next = list;
5318
5319   for (t = lang_elf_version_info; t != NULL; t = t->next)
5320     {
5321       if (strcmp (t->name, name) == 0)
5322         {
5323           ret->version_needed = t;
5324           return ret;
5325         }
5326     }
5327
5328   einfo (_("%X%P: unable to find version dependency `%s'\n"), name);
5329
5330   return ret;
5331 }
5332
5333 static void
5334 lang_do_version_exports_section ()
5335 {
5336   struct bfd_elf_version_expr *greg = NULL, *lreg;
5337
5338   LANG_FOR_EACH_INPUT_STATEMENT (is)
5339     {
5340       asection *sec = bfd_get_section_by_name (is->the_bfd, ".exports");
5341       char *contents, *p;
5342       bfd_size_type len;
5343
5344       if (sec == NULL)
5345         continue;
5346
5347       len = bfd_section_size (is->the_bfd, sec);
5348       contents = xmalloc (len);
5349       if (!bfd_get_section_contents (is->the_bfd, sec, contents, 0, len))
5350         einfo (_("%X%P: unable to read .exports section contents\n"), sec);
5351
5352       p = contents;
5353       while (p < contents + len)
5354         {
5355           greg = lang_new_vers_pattern (greg, p, NULL);
5356           p = strchr (p, '\0') + 1;
5357         }
5358
5359       /* Do not free the contents, as we used them creating the regex.  */
5360
5361       /* Do not include this section in the link.  */
5362       bfd_set_section_flags (is->the_bfd, sec,
5363         bfd_get_section_flags (is->the_bfd, sec) | SEC_EXCLUDE);
5364     }
5365
5366   lreg = lang_new_vers_pattern (NULL, "*", NULL);
5367   lang_register_vers_node (command_line.version_exports_section,
5368                            lang_new_vers_node (greg, lreg), NULL);
5369 }
5370
5371 void
5372 lang_add_unique (name)
5373      const char *name;
5374 {
5375   struct unique_sections *ent;
5376
5377   for (ent = unique_section_list; ent; ent = ent->next)
5378     if (strcmp (ent->name, name) == 0)
5379       return;
5380
5381   ent = (struct unique_sections *) xmalloc (sizeof *ent);
5382   ent->name = xstrdup (name);
5383   ent->next = unique_section_list;
5384   unique_section_list = ent;
5385 }