ld/ldlang.c

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