ld/ldlang.c

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