ld/ldlang.c

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