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