ld/ldlang.c

   1 /* Linker command language support.
   2    Copyright (C) 1991, 92, 93, 94, 1995 Free Software Foundation, Inc.
   3
   4 This file is part of GLD, the Gnu Linker.
   5
   6 GLD is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 1, or (at your option)
   9 any later version.
  10
  11 GLD is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GLD; see the file COPYING.  If not, write to
  18 the Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  19
  20 #include "bfd.h"
  21 #include "sysdep.h"
  22 #include "libiberty.h"
  23 #include "bfdlink.h"
  24
  25 #include "ld.h"
  26 #include "ldmain.h"
  27 #include "ldgram.h"
  28 #include "ldexp.h"
  29 #include "ldlang.h"
  30 #include "ldemul.h"
  31 #include "ldlex.h"
  32 #include "ldmisc.h"
  33 #include "ldctor.h"
  34 #include "ldfile.h"
  35
  36 /* FORWARDS */
  37 static lang_statement_union_type *new_statement PARAMS ((enum statement_enum,
  38                                                          size_t,
  39                                                          lang_statement_list_type*));
  40
  41
  42 /* LOCALS */
  43 static struct obstack stat_obstack;
  44
  45 #define obstack_chunk_alloc xmalloc
  46 #define obstack_chunk_free free
  47 static CONST char *startup_file;
  48 static lang_statement_list_type input_file_chain;
  49 static boolean placed_commons = false;
  50 static lang_output_section_statement_type *default_common_section;
  51 static boolean map_option_f;
  52 static bfd_vma print_dot;
  53 static lang_input_statement_type *first_file;
  54 static lang_statement_list_type lang_output_section_statement;
  55 static CONST char *current_target;
  56 static CONST char *output_target;
  57 static int longest_section_name = 8;
  58 static lang_statement_list_type statement_list;
  59 static struct lang_phdr *lang_phdr_list;
  60
  61 static void print_size PARAMS ((size_t value));
  62 static void print_alignment PARAMS ((unsigned int value));
  63 static void print_fill PARAMS ((fill_type value));
  64 static void print_section PARAMS ((const char *name));
  65 static void lang_for_each_statement_worker
  66   PARAMS ((void (*func) (lang_statement_union_type *),
  67            lang_statement_union_type *s));
  68 static lang_input_statement_type *new_afile
  69   PARAMS ((const char *name, lang_input_file_enum_type file_type,
  70            const char *target, boolean add_to_list));
  71 static void print_flags PARAMS ((int *ignore_flags));
  72 static void init_os PARAMS ((lang_output_section_statement_type *s));
  73 static void wild_section PARAMS ((lang_wild_statement_type *ptr,
  74                                   const char *section,
  75                                   lang_input_statement_type *file,
  76                                   lang_output_section_statement_type *output));
  77 static lang_input_statement_type *lookup_name PARAMS ((const char *name));
  78 static void load_symbols PARAMS ((lang_input_statement_type *entry,
  79                                   lang_statement_list_type *));
  80 static void wild PARAMS ((lang_wild_statement_type *s,
  81                           const char *section, const char *file,
  82                           const char *target,
  83                           lang_output_section_statement_type *output));
  84 static bfd *open_output PARAMS ((const char *name));
  85 static void ldlang_open_output PARAMS ((lang_statement_union_type *statement));
  86 static void open_input_bfds
  87   PARAMS ((lang_statement_union_type *statement, boolean));
  88 static void lang_reasonable_defaults PARAMS ((void));
  89 static void lang_place_undefineds PARAMS ((void));
  90 static void map_input_to_output_sections
  91   PARAMS ((lang_statement_union_type *s,
  92            const char *target,
  93            lang_output_section_statement_type *output_section_statement));
  94 static void print_output_section_statement
  95   PARAMS ((lang_output_section_statement_type *output_section_statement));
  96 static void print_assignment
  97   PARAMS ((lang_assignment_statement_type *assignment,
  98            lang_output_section_statement_type *output_section));
  99 static void print_input_statement PARAMS ((lang_input_statement_type *statm));
 100 static void print_input_section PARAMS ((lang_input_section_type *in));
 101 static void print_fill_statement PARAMS ((lang_fill_statement_type *fill));
 102 static void print_data_statement PARAMS ((lang_data_statement_type *data));
 103 static void print_reloc_statement PARAMS ((lang_reloc_statement_type *reloc));
 104 static void print_padding_statement PARAMS ((lang_padding_statement_type *s));
 105 static void print_wild_statement
 106   PARAMS ((lang_wild_statement_type *w,
 107            lang_output_section_statement_type *os));
 108 static void print_group
 109   PARAMS ((lang_group_statement_type *, lang_output_section_statement_type *));
 110 static void print_statement PARAMS ((lang_statement_union_type *s,
 111                                      lang_output_section_statement_type *os));
 112 static void print_statement_list PARAMS ((lang_statement_union_type *s,
 113                                           lang_output_section_statement_type *os));
 114 static void print_statements PARAMS ((void));
 115 static bfd_vma insert_pad PARAMS ((lang_statement_union_type **this_ptr,
 116                                    fill_type fill, unsigned int power,
 117                                    asection *output_section_statement,
 118                                    bfd_vma dot));
 119 static bfd_vma size_input_section
 120   PARAMS ((lang_statement_union_type **this_ptr,
 121            lang_output_section_statement_type *output_section_statement,
 122            fill_type fill, bfd_vma dot, boolean relax));
 123 static void lang_finish PARAMS ((void));
 124 static void lang_check PARAMS ((void));
 125 static void lang_common PARAMS ((void));
 126 static boolean lang_one_common PARAMS ((struct bfd_link_hash_entry *, PTR));
 127 static void lang_place_orphans PARAMS ((void));
 128 static int topower PARAMS ((int));
 129 static void lang_set_startof PARAMS ((void));
 130 static void reset_memory_regions PARAMS ((void));
 131 static void lang_record_phdrs PARAMS ((void));
 132
 133 /* EXPORTS */
 134 lang_output_section_statement_type *abs_output_section;
 135 lang_statement_list_type *stat_ptr = &statement_list;
 136 lang_statement_list_type file_chain = { 0 };
 137 const char *entry_symbol = NULL;
 138 boolean entry_from_cmdline;
 139 boolean lang_has_input_file = false;
 140 boolean had_output_filename = false;
 141 boolean lang_float_flag = false;
 142 boolean delete_output_file_on_failure = false;
 143
 144 etree_type *base; /* Relocation base - or null */
 145
 146
 147 #if defined(__STDC__) || defined(ALMOST_STDC)
 148 #define cat(a,b) a##b
 149 #else
 150 #define cat(a,b) a/**/b
 151 #endif
 152
 153 #define new_stat(x,y) (cat(x,_type)*) new_statement(cat(x,_enum), sizeof(cat(x,_type)),y)
 154
 155 #define outside_section_address(q) ( (q)->output_offset + (q)->output_section->vma)
 156
 157 #define outside_symbol_address(q) ((q)->value +   outside_section_address(q->section))
 158
 159 PTR
 160 stat_alloc (size)
 161      size_t size;
 162 {
 163   return obstack_alloc (&stat_obstack, size);
 164 }
 165
 166 static void
 167 print_size (value)
 168      size_t value;
 169 {
 170   fprintf (config.map_file, "%5x", (unsigned) value);
 171 }
 172
 173 static void
 174 print_alignment (value)
 175      unsigned int value;
 176 {
 177   fprintf (config.map_file, "2**%1u", value);
 178 }
 179
 180 static void
 181 print_fill (value)
 182      fill_type value;
 183 {
 184   fprintf (config.map_file, "%04x", (unsigned) value);
 185 }
 186
 187 static void
 188 print_section (name)
 189      CONST char *name;
 190 {
 191   fprintf (config.map_file, "%*s", -longest_section_name, name);
 192 }
 193
 194 /*----------------------------------------------------------------------
 195   lang_for_each_statement walks the parse tree and calls the provided
 196   function for each node
 197 */
 198
 199 static void
 200 lang_for_each_statement_worker (func, s)
 201      void (*func) PARAMS ((lang_statement_union_type *));
 202      lang_statement_union_type *s;
 203 {
 204   for (; s != (lang_statement_union_type *) NULL; s = s->next)
 205     {
 206       func (s);
 207
 208       switch (s->header.type)
 209         {
 210         case lang_constructors_statement_enum:
 211           lang_for_each_statement_worker (func, constructor_list.head);
 212           break;
 213         case lang_output_section_statement_enum:
 214           lang_for_each_statement_worker
 215             (func,
 216              s->output_section_statement.children.head);
 217           break;
 218         case lang_wild_statement_enum:
 219           lang_for_each_statement_worker
 220             (func,
 221              s->wild_statement.children.head);
 222           break;
 223         case lang_group_statement_enum:
 224           lang_for_each_statement_worker (func,
 225                                           s->group_statement.children.head);
 226           break;
 227         case lang_data_statement_enum:
 228         case lang_reloc_statement_enum:
 229         case lang_object_symbols_statement_enum:
 230         case lang_output_statement_enum:
 231         case lang_target_statement_enum:
 232         case lang_input_section_enum:
 233         case lang_input_statement_enum:
 234         case lang_assignment_statement_enum:
 235         case lang_padding_statement_enum:
 236         case lang_address_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   p->complained = false;
 316   switch (file_type)
 317     {
 318     case lang_input_file_is_symbols_only_enum:
 319       p->filename = name;
 320       p->is_archive = false;
 321       p->real = true;
 322       p->local_sym_name = name;
 323       p->just_syms_flag = true;
 324       p->search_dirs_flag = false;
 325       break;
 326     case lang_input_file_is_fake_enum:
 327       p->filename = name;
 328       p->is_archive = false;
 329       p->real = false;
 330       p->local_sym_name = name;
 331       p->just_syms_flag = false;
 332       p->search_dirs_flag = false;
 333       break;
 334     case lang_input_file_is_l_enum:
 335       p->is_archive = true;
 336       p->filename = name;
 337       p->real = true;
 338       p->local_sym_name = concat ("-l", name, (const char *) NULL);
 339       p->just_syms_flag = false;
 340       p->search_dirs_flag = true;
 341       break;
 342     case lang_input_file_is_marker_enum:
 343       p->filename = name;
 344       p->is_archive = false;
 345       p->real = false;
 346       p->local_sym_name = name;
 347       p->just_syms_flag = false;
 348       p->search_dirs_flag = true;
 349       break;
 350     case lang_input_file_is_search_file_enum:
 351       p->filename = name;
 352       p->is_archive = false;
 353       p->real = true;
 354       p->local_sym_name = name;
 355       p->just_syms_flag = false;
 356       p->search_dirs_flag = true;
 357       break;
 358     case lang_input_file_is_file_enum:
 359       p->filename = name;
 360       p->is_archive = false;
 361       p->real = true;
 362       p->local_sym_name = name;
 363       p->just_syms_flag = false;
 364       p->search_dirs_flag = false;
 365       break;
 366     default:
 367       FAIL ();
 368     }
 369   p->the_bfd = (bfd *) NULL;
 370   p->asymbols = (asymbol **) NULL;
 371   p->next_real_file = (lang_statement_union_type *) NULL;
 372   p->next = (lang_statement_union_type *) NULL;
 373   p->symbol_count = 0;
 374   p->common_output_section = (asection *) NULL;
 375   p->dynamic = config.dynamic_link;
 376   p->loaded = false;
 377   lang_statement_append (&input_file_chain,
 378                          (lang_statement_union_type *) p,
 379                          &p->next_real_file);
 380   return p;
 381 }
 382
 383 lang_input_statement_type *
 384 lang_add_input_file (name, file_type, target)
 385      CONST char *name;
 386      lang_input_file_enum_type file_type;
 387      CONST char *target;
 388 {
 389   lang_has_input_file = true;
 390   return new_afile (name, file_type, target, true);
 391 }
 392
 393 /* Build enough state so that the parser can build its tree */
 394 void
 395 lang_init ()
 396 {
 397   obstack_begin (&stat_obstack, 1000);
 398
 399   stat_ptr = &statement_list;
 400
 401   lang_list_init (stat_ptr);
 402
 403   lang_list_init (&input_file_chain);
 404   lang_list_init (&lang_output_section_statement);
 405   lang_list_init (&file_chain);
 406   first_file = lang_add_input_file ((char *) NULL,
 407                                     lang_input_file_is_marker_enum,
 408                                     (char *) NULL);
 409   abs_output_section = lang_output_section_statement_lookup (BFD_ABS_SECTION_NAME);
 410
 411   abs_output_section->bfd_section = bfd_abs_section_ptr;
 412
 413 }
 414
 415 /*----------------------------------------------------------------------
 416  A region is an area of memory declared with the
 417  MEMORY {  name:org=exp, len=exp ... }
 418  syntax.
 419
 420  We maintain a list of all the regions here
 421
 422  If no regions are specified in the script, then the default is used
 423  which is created when looked up to be the entire data space
 424 */
 425
 426 static lang_memory_region_type *lang_memory_region_list;
 427 static lang_memory_region_type **lang_memory_region_list_tail = &lang_memory_region_list;
 428
 429 lang_memory_region_type *
 430 lang_memory_region_lookup (name)
 431      CONST char *CONST name;
 432 {
 433
 434   lang_memory_region_type *p = lang_memory_region_list;
 435
 436   for (p = lang_memory_region_list;
 437        p != (lang_memory_region_type *) NULL;
 438        p = p->next)
 439     {
 440       if (strcmp (p->name, name) == 0)
 441         {
 442           return p;
 443         }
 444     }
 445
 446 #if 0
 447   /* This code used to always use the first region in the list as the
 448      default region.  I changed it to instead use a region
 449      encompassing all of memory as the default region.  This permits
 450      NOLOAD sections to work reasonably without requiring a region.
 451      People should specify what region they mean, if they really want
 452      a region.  */
 453   if (strcmp (name, "*default*") == 0)
 454     {
 455       if (lang_memory_region_list != (lang_memory_region_type *) NULL)
 456         {
 457           return lang_memory_region_list;
 458         }
 459     }
 460 #endif
 461
 462   {
 463     lang_memory_region_type *new =
 464     (lang_memory_region_type *) stat_alloc (sizeof (lang_memory_region_type));
 465
 466     new->name = buystring (name);
 467     new->next = (lang_memory_region_type *) NULL;
 468
 469     *lang_memory_region_list_tail = new;
 470     lang_memory_region_list_tail = &new->next;
 471     new->origin = 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_output_section_statement_type *
 482 lang_output_section_find (name)
 483      CONST char *CONST name;
 484 {
 485   lang_statement_union_type *u;
 486   lang_output_section_statement_type *lookup;
 487
 488   for (u = lang_output_section_statement.head;
 489        u != (lang_statement_union_type *) NULL;
 490        u = lookup->next)
 491     {
 492       lookup = &u->output_section_statement;
 493       if (strcmp (name, lookup->name) == 0)
 494         {
 495           return lookup;
 496         }
 497     }
 498   return (lang_output_section_statement_type *) NULL;
 499 }
 500
 501 lang_output_section_statement_type *
 502 lang_output_section_statement_lookup (name)
 503      CONST char *CONST name;
 504 {
 505   lang_output_section_statement_type *lookup;
 506
 507   lookup = lang_output_section_find (name);
 508   if (lookup == (lang_output_section_statement_type *) NULL)
 509     {
 510
 511       lookup = (lang_output_section_statement_type *)
 512         new_stat (lang_output_section_statement, stat_ptr);
 513       lookup->region = (lang_memory_region_type *) NULL;
 514       lookup->fill = 0;
 515       lookup->block_value = 1;
 516       lookup->name = name;
 517
 518       lookup->next = (lang_statement_union_type *) NULL;
 519       lookup->bfd_section = (asection *) NULL;
 520       lookup->processed = false;
 521       lookup->loadable = 1;
 522       lookup->addr_tree = (etree_type *) NULL;
 523       lang_list_init (&lookup->children);
 524
 525       lookup->memspec = (CONST char *) NULL;
 526       lookup->flags = 0;
 527       lookup->subsection_alignment = -1;
 528       lookup->section_alignment = -1;
 529       lookup->load_base = (union etree_union *) NULL;
 530       lookup->phdrs = NULL;
 531
 532       lang_statement_append (&lang_output_section_statement,
 533                              (lang_statement_union_type *) lookup,
 534                              &lookup->next);
 535     }
 536   return lookup;
 537 }
 538
 539 /*ARGSUSED*/
 540 static void
 541 print_flags (ignore_flags)
 542      int *ignore_flags;
 543 {
 544   fprintf (config.map_file, "(");
 545 #if 0
 546   if (flags->flag_read)
 547     fprintf (outfile, "R");
 548   if (flags->flag_write)
 549     fprintf (outfile, "W");
 550   if (flags->flag_executable)
 551     fprintf (outfile, "X");
 552   if (flags->flag_loadable)
 553     fprintf (outfile, "L");
 554 #endif
 555  fprintf (config.map_file, ")");
 556 }
 557
 558 void
 559 lang_map ()
 560 {
 561   lang_memory_region_type *m;
 562
 563   fprintf (config.map_file, "**MEMORY CONFIGURATION**\n\n");
 564 #ifdef BFD64
 565   fprintf (config.map_file, "name\t\torigin\t\tlength\t\tattributes\n");
 566 #else
 567   fprintf (config.map_file,
 568            "name\t\torigin   length   r_size   c_size    is    attributes\n");
 569
 570 #endif
 571   for (m = lang_memory_region_list;
 572        m != (lang_memory_region_type *) NULL;
 573        m = m->next)
 574     {
 575       fprintf (config.map_file, "%-16s", m->name);
 576       print_address (m->origin);
 577       print_space ();
 578       print_address ((bfd_vma)m->length);
 579       print_space ();
 580       print_address ((bfd_vma)m->old_length);
 581       print_space();
 582       print_address (m->current - m->origin);
 583       print_space();
 584       if (m->old_length)
 585        fprintf (config.map_file, " %2d%%  ",
 586                 (int) ((m->current - m->origin) * 100 / m->old_length));
 587       print_flags (&m->flags);
 588       fprintf (config.map_file, "\n");
 589     }
 590   fprintf (config.map_file, "\n\n**LINK EDITOR MEMORY MAP**\n\n");
 591   fprintf (config.map_file, "output   input     virtual\n");
 592   fprintf (config.map_file, "section  section   address    tsize\n\n");
 593
 594   print_statements ();
 595
 596 }
 597
 598 /*
 599  *
 600  */
 601 static void
 602 init_os (s)
 603      lang_output_section_statement_type * s;
 604 {
 605 /*  asection *section = bfd_get_section_by_name(output_bfd, s->name);*/
 606   section_userdata_type *new =
 607   (section_userdata_type *)
 608   stat_alloc (sizeof (section_userdata_type));
 609
 610   s->bfd_section = bfd_get_section_by_name (output_bfd, s->name);
 611   if (s->bfd_section == (asection *) NULL)
 612     s->bfd_section = bfd_make_section (output_bfd, s->name);
 613   if (s->bfd_section == (asection *) NULL)
 614     {
 615       einfo ("%P%F: output format %s cannot represent section called %s\n",
 616              output_bfd->xvec->name, s->name);
 617     }
 618   s->bfd_section->output_section = s->bfd_section;
 619
 620   /* We initialize an output sections output offset to minus its own */
 621   /* vma to allow us to output a section through itself */
 622   s->bfd_section->output_offset = 0;
 623   get_userdata (s->bfd_section) = (PTR) new;
 624
 625 }
 626
 627 /***********************************************************************
 628   The wild routines.
 629
 630   These expand statements like *(.text) and foo.o to a list of
 631   explicit actions, like foo.o(.text), bar.o(.text) and
 632   foo.o(.text,.data) .
 633
 634   The toplevel routine, wild, takes a statement, section, file and
 635   target. If either the section or file is null it is taken to be the
 636   wildcard. Seperate lang_input_section statements are created for
 637   each part of the expanstion, and placed after the statement provided.
 638
 639 */
 640
 641 void
 642 wild_doit (ptr, section, output, file)
 643      lang_statement_list_type * ptr;
 644      asection * section;
 645      lang_output_section_statement_type * output;
 646      lang_input_statement_type * file;
 647 {
 648   if (output->bfd_section == (asection *) NULL)
 649     init_os (output);
 650
 651   if (section != (asection *) NULL
 652       && section->output_section == (asection *) NULL)
 653   {
 654     /* Add a section reference to the list */
 655     lang_input_section_type *new = new_stat (lang_input_section, ptr);
 656
 657     new->section = section;
 658     new->ifile = file;
 659     section->output_section = output->bfd_section;
 660
 661     /* We don't copy the SEC_NEVER_LOAD flag from an input section to
 662        an output section, because we want to be able to include a
 663        SEC_NEVER_LOAD section in the middle of an otherwise loaded
 664        section (I don't know why we want to do this, but we do).
 665        build_link_order in ldwrite.c handles this case by turning the
 666        embedded SEC_NEVER_LOAD section into a fill.  */
 667     section->output_section->flags |=
 668       section->flags & (flagword) (~ SEC_NEVER_LOAD);
 669
 670     if (!output->loadable)
 671     {
 672       /* Turn off load flag */
 673       output->bfd_section->flags &= ~SEC_LOAD;
 674       output->bfd_section->flags |= SEC_NEVER_LOAD;
 675     }
 676     if (section->alignment_power > output->bfd_section->alignment_power)
 677     {
 678       output->bfd_section->alignment_power = section->alignment_power;
 679     }
 680     /* If supplied an aligmnet, then force it */
 681     if (output->section_alignment != -1)
 682     {
 683       output->bfd_section->alignment_power = output->section_alignment;
 684     }
 685   }
 686 }
 687
 688 static void
 689 wild_section (ptr, section, file, output)
 690      lang_wild_statement_type *ptr;
 691      const char *section;
 692      lang_input_statement_type *file;
 693      lang_output_section_statement_type *output;
 694 {
 695   if (file->just_syms_flag == false)
 696     {
 697       register asection *s;
 698
 699       for (s = file->the_bfd->sections; s != NULL; s = s->next)
 700         {
 701           /* Attach all sections named SECTION.  If SECTION is NULL,
 702              then attach all sections.
 703
 704              Previously, if SECTION was NULL, this code did not call
 705              wild_doit if the SEC_IS_COMMON flag was set for the
 706              section.  I did not understand that, and I took it out.
 707              [email protected].  */
 708
 709           if (section == NULL
 710               || strcmp (bfd_get_section_name (file->the_bfd, s),
 711                          section) == 0)
 712             wild_doit (&ptr->children, s, output, file);
 713         }
 714     }
 715 }
 716
 717 /* passed a file name (which must have been seen already and added to
 718    the statement tree. We will see if it has been opened already and
 719    had its symbols read. If not then we'll read it.
 720
 721    Archives are pecuilar here. We may open them once, but if they do
 722    not define anything we need at the time, they won't have all their
 723    symbols read. If we need them later, we'll have to redo it.  */
 724 static lang_input_statement_type *
 725 lookup_name (name)
 726      CONST char *name;
 727 {
 728   lang_input_statement_type *search;
 729
 730   for (search = (lang_input_statement_type *) input_file_chain.head;
 731        search != (lang_input_statement_type *) NULL;
 732        search = (lang_input_statement_type *) search->next_real_file)
 733     {
 734       if (search->filename == (char *) NULL && name == (char *) NULL)
 735         return search;
 736       if (search->filename != (char *) NULL
 737           && name != (char *) NULL
 738           && strcmp (search->filename, name) == 0)
 739         break;
 740     }
 741
 742   if (search == (lang_input_statement_type *) NULL)
 743     search = new_afile (name, lang_input_file_is_file_enum, default_target,
 744                         false);
 745
 746   /* If we have already added this file, or this file is not real
 747      (FIXME: can that ever actually happen?) or the name is NULL
 748      (FIXME: can that ever actually happen?) don't add this file.  */
 749   if (search->loaded
 750       || ! search->real
 751       || search->filename == (const char *) NULL)
 752     return search;
 753
 754   load_symbols (search, (lang_statement_list_type *) NULL);
 755
 756   return search;
 757 }
 758
 759 /* Get the symbols for an input file.  */
 760
 761 static void
 762 load_symbols (entry, place)
 763      lang_input_statement_type *entry;
 764      lang_statement_list_type *place;
 765 {
 766   char **matching;
 767
 768   if (entry->loaded)
 769     return;
 770
 771   ldfile_open_file (entry);
 772
 773   if (! bfd_check_format (entry->the_bfd, bfd_archive)
 774       && ! bfd_check_format_matches (entry->the_bfd, bfd_object, &matching))
 775     {
 776       bfd_error_type err;
 777       lang_statement_list_type *hold;
 778
 779       err = bfd_get_error ();
 780       if (err == bfd_error_file_ambiguously_recognized)
 781         {
 782           char **p;
 783
 784           einfo ("%B: file not recognized: %E\n", entry->the_bfd);
 785           einfo ("%B: matching formats:", entry->the_bfd);
 786           for (p = matching; *p != NULL; p++)
 787             einfo (" %s", *p);
 788           einfo ("%F\n");
 789         }
 790       else if (err != bfd_error_file_not_recognized
 791                || place == NULL)
 792         einfo ("%F%B: file not recognized: %E\n", entry->the_bfd);
 793
 794       /* Try to interpret the file as a linker script.  */
 795
 796       bfd_close (entry->the_bfd);
 797       entry->the_bfd = NULL;
 798
 799       ldfile_open_command_file (entry->filename);
 800
 801       hold = stat_ptr;
 802       stat_ptr = place;
 803
 804       ldfile_assumed_script = true;
 805       parser_input = input_script;
 806       yyparse ();
 807       ldfile_assumed_script = false;
 808
 809       stat_ptr = hold;
 810
 811       return;
 812     }
 813
 814   /* We don't call ldlang_add_file for an archive.  Instead, the
 815      add_symbols entry point will call ldlang_add_file, via the
 816      add_archive_element callback, for each element of the archive
 817      which is used.  */
 818   switch (bfd_get_format (entry->the_bfd))
 819     {
 820     default:
 821       break;
 822
 823     case bfd_object:
 824       ldlang_add_file (entry);
 825       if (trace_files || trace_file_tries)
 826         info_msg ("%I\n", entry);
 827       break;
 828
 829     case bfd_archive:
 830       if (whole_archive)
 831         {
 832           bfd *member = bfd_openr_next_archived_file (entry->the_bfd,
 833                                                       (bfd *) NULL);
 834           while (member != NULL)
 835             {
 836               if (! bfd_check_format (member, bfd_object))
 837                 einfo ("%F%B: object %B in archive is not object\n",
 838                        entry->the_bfd, member);
 839               if (! ((*link_info.callbacks->add_archive_element)
 840                      (&link_info, member, "-whole-archive")))
 841                 abort ();
 842               if (! bfd_link_add_symbols (member, &link_info))
 843                 einfo ("%F%B: could not read symbols: %E\n", member);
 844               member = bfd_openr_next_archived_file (entry->the_bfd,
 845                                                      member);
 846             }
 847
 848           entry->loaded = true;
 849
 850           return;
 851         }
 852     }
 853
 854   if (! bfd_link_add_symbols (entry->the_bfd, &link_info))
 855     einfo ("%F%B: could not read symbols: %E\n", entry->the_bfd);
 856
 857   entry->loaded = true;
 858 }
 859
 860 static void
 861 wild (s, section, file, target, output)
 862      lang_wild_statement_type * s;
 863      CONST char *section;
 864      CONST char *file;
 865      CONST char *target;
 866      lang_output_section_statement_type * output;
 867 {
 868   lang_input_statement_type *f;
 869
 870   if (file == (char *) NULL)
 871     {
 872       /* Perform the iteration over all files in the list */
 873       for (f = (lang_input_statement_type *) file_chain.head;
 874            f != (lang_input_statement_type *) NULL;
 875            f = (lang_input_statement_type *) f->next)
 876         {
 877           wild_section (s, section, f, output);
 878         }
 879     }
 880   else
 881     {
 882       /* Perform the iteration over a single file */
 883       wild_section (s, section, lookup_name (file), output);
 884     }
 885   if (section != (char *) NULL
 886       && strcmp (section, "COMMON") == 0
 887    && default_common_section == (lang_output_section_statement_type *) NULL)
 888     {
 889       /* Remember the section that common is going to incase we later
 890          get something which doesn't know where to put it */
 891       default_common_section = output;
 892     }
 893 }
 894
 895 /*
 896   read in all the files
 897   */
 898
 899 static bfd *
 900 open_output (name)
 901      CONST char *name;
 902 {
 903   bfd *output;
 904
 905   if (output_target == (char *) NULL)
 906     {
 907       if (current_target != (char *) NULL)
 908         output_target = current_target;
 909       else
 910         output_target = default_target;
 911     }
 912   output = bfd_openw (name, output_target);
 913
 914   if (output == (bfd *) NULL)
 915     {
 916       if (bfd_get_error () == bfd_error_invalid_target)
 917         {
 918           einfo ("%P%F: target %s not found\n", output_target);
 919         }
 920       einfo ("%P%F: cannot open output file %s: %E\n", name);
 921     }
 922
 923   delete_output_file_on_failure = 1;
 924
 925   /*  output->flags |= D_PAGED;*/
 926
 927   if (! bfd_set_format (output, bfd_object))
 928     einfo ("%P%F:%s: can not make object file: %E\n", name);
 929   if (! bfd_set_arch_mach (output,
 930                            ldfile_output_architecture,
 931                            ldfile_output_machine))
 932     einfo ("%P%F:%s: can not set architecture: %E\n", name);
 933
 934   link_info.hash = bfd_link_hash_table_create (output);
 935   if (link_info.hash == (struct bfd_link_hash_table *) NULL)
 936     einfo ("%P%F: can not create link hash table: %E\n");
 937
 938   bfd_set_gp_size (output, g_switch_value);
 939   return output;
 940 }
 941
 942
 943
 944
 945 static void
 946 ldlang_open_output (statement)
 947      lang_statement_union_type * statement;
 948 {
 949   switch (statement->header.type)
 950     {
 951     case lang_output_statement_enum:
 952       ASSERT (output_bfd == (bfd *) NULL);
 953       output_bfd = open_output (statement->output_statement.name);
 954       ldemul_set_output_arch ();
 955       if (config.magic_demand_paged && !link_info.relocateable)
 956         output_bfd->flags |= D_PAGED;
 957       else
 958         output_bfd->flags &= ~D_PAGED;
 959       if (config.text_read_only)
 960         output_bfd->flags |= WP_TEXT;
 961       else
 962         output_bfd->flags &= ~WP_TEXT;
 963       if (config.traditional_format)
 964         output_bfd->flags |= BFD_TRADITIONAL_FORMAT;
 965       else
 966         output_bfd->flags &= ~BFD_TRADITIONAL_FORMAT;
 967       break;
 968
 969     case lang_target_statement_enum:
 970       current_target = statement->target_statement.target;
 971       break;
 972     default:
 973       break;
 974     }
 975 }
 976
 977 /* Open all the input files.  */
 978
 979 static void
 980 open_input_bfds (s, force)
 981      lang_statement_union_type *s;
 982      boolean force;
 983 {
 984   for (; s != (lang_statement_union_type *) NULL; s = s->next)
 985     {
 986       switch (s->header.type)
 987         {
 988         case lang_constructors_statement_enum:
 989           open_input_bfds (constructor_list.head, force);
 990           break;
 991         case lang_output_section_statement_enum:
 992           open_input_bfds (s->output_section_statement.children.head, force);
 993           break;
 994         case lang_wild_statement_enum:
 995           /* Maybe we should load the file's symbols */
 996           if (s->wild_statement.filename)
 997             (void) lookup_name (s->wild_statement.filename);
 998           open_input_bfds (s->wild_statement.children.head, force);
 999           break;
1000         case lang_group_statement_enum:
1001           {
1002             struct bfd_link_hash_entry *undefs;
1003
1004             /* We must continually search the entries in the group
1005                until no new symbols are added to the list of undefined
1006                symbols.  */
1007
1008             do
1009               {
1010                 undefs = link_info.hash->undefs_tail;
1011                 open_input_bfds (s->group_statement.children.head, true);
1012               }
1013             while (undefs != link_info.hash->undefs_tail);
1014           }
1015           break;
1016         case lang_target_statement_enum:
1017           current_target = s->target_statement.target;
1018           break;
1019         case lang_input_statement_enum:
1020           if (s->input_statement.real == true)
1021             {
1022               lang_statement_list_type add;
1023
1024               s->input_statement.target = current_target;
1025
1026               /* If we are being called from within a group, and this
1027                  is an archive which has already been searched, then
1028                  force it to be researched.  */
1029               if (force
1030                   && s->input_statement.loaded
1031                   && bfd_check_format (s->input_statement.the_bfd,
1032                                        bfd_archive))
1033                 s->input_statement.loaded = false;
1034
1035               lang_list_init (&add);
1036
1037               load_symbols (&s->input_statement, &add);
1038
1039               if (add.head != NULL)
1040                 {
1041                   *add.tail = s->next;
1042                   s->next = add.head;
1043                 }
1044             }
1045           break;
1046         default:
1047           break;
1048         }
1049     }
1050 }
1051
1052 /* If there are [COMMONS] statements, put a wild one into the bss section */
1053
1054 static void
1055 lang_reasonable_defaults ()
1056 {
1057 #if 0
1058   lang_output_section_statement_lookup (".text");
1059   lang_output_section_statement_lookup (".data");
1060
1061   default_common_section =
1062     lang_output_section_statement_lookup (".bss");
1063
1064
1065   if (placed_commons == false)
1066     {
1067       lang_wild_statement_type *new =
1068       new_stat (lang_wild_statement,
1069                 &default_common_section->children);
1070
1071       new->section_name = "COMMON";
1072       new->filename = (char *) NULL;
1073       lang_list_init (&new->children);
1074     }
1075 #endif
1076
1077 }
1078
1079 /*
1080  Add the supplied name to the symbol table as an undefined reference.
1081  Remove items from the chain as we open input bfds
1082  */
1083 typedef struct ldlang_undef_chain_list
1084 {
1085   struct ldlang_undef_chain_list *next;
1086   char *name;
1087 }                       ldlang_undef_chain_list_type;
1088
1089 static ldlang_undef_chain_list_type *ldlang_undef_chain_list_head;
1090
1091 void
1092 ldlang_add_undef (name)
1093      CONST char *CONST name;
1094 {
1095   ldlang_undef_chain_list_type *new =
1096     ((ldlang_undef_chain_list_type *)
1097      stat_alloc (sizeof (ldlang_undef_chain_list_type)));
1098
1099   new->next = ldlang_undef_chain_list_head;
1100   ldlang_undef_chain_list_head = new;
1101
1102   new->name = buystring (name);
1103 }
1104
1105 /* Run through the list of undefineds created above and place them
1106    into the linker hash table as undefined symbols belonging to the
1107    script file.
1108 */
1109 static void
1110 lang_place_undefineds ()
1111 {
1112   ldlang_undef_chain_list_type *ptr;
1113
1114   for (ptr = ldlang_undef_chain_list_head;
1115        ptr != (ldlang_undef_chain_list_type *) NULL;
1116        ptr = ptr->next)
1117     {
1118       struct bfd_link_hash_entry *h;
1119
1120       h = bfd_link_hash_lookup (link_info.hash, ptr->name, true, false, true);
1121       if (h == (struct bfd_link_hash_entry *) NULL)
1122         einfo ("%P%F: bfd_link_hash_lookup failed: %E");
1123       if (h->type == bfd_link_hash_new)
1124         {
1125           h->type = bfd_link_hash_undefined;
1126           h->u.undef.abfd = NULL;
1127           bfd_link_add_undef (link_info.hash, h);
1128         }
1129     }
1130 }
1131
1132 /* Open input files and attatch to output sections */
1133 static void
1134 map_input_to_output_sections (s, target, output_section_statement)
1135      lang_statement_union_type * s;
1136      CONST char *target;
1137      lang_output_section_statement_type * output_section_statement;
1138 {
1139   for (; s != (lang_statement_union_type *) NULL; s = s->next)
1140     {
1141       switch (s->header.type)
1142         {
1143
1144
1145         case lang_wild_statement_enum:
1146           wild (&s->wild_statement, s->wild_statement.section_name,
1147                 s->wild_statement.filename, target,
1148                 output_section_statement);
1149
1150           break;
1151         case lang_constructors_statement_enum:
1152           map_input_to_output_sections (constructor_list.head,
1153                                         target,
1154                                         output_section_statement);
1155           break;
1156         case lang_output_section_statement_enum:
1157           map_input_to_output_sections (s->output_section_statement.children.head,
1158                                         target,
1159                                         &s->output_section_statement);
1160           break;
1161         case lang_output_statement_enum:
1162           break;
1163         case lang_target_statement_enum:
1164           target = s->target_statement.target;
1165           break;
1166         case lang_group_statement_enum:
1167           map_input_to_output_sections (s->group_statement.children.head,
1168                                         target,
1169                                         output_section_statement);
1170           break;
1171         case lang_fill_statement_enum:
1172         case lang_input_section_enum:
1173         case lang_object_symbols_statement_enum:
1174         case lang_data_statement_enum:
1175         case lang_reloc_statement_enum:
1176         case lang_assignment_statement_enum:
1177         case lang_padding_statement_enum:
1178         case lang_input_statement_enum:
1179           if (output_section_statement != NULL
1180               && output_section_statement->bfd_section == NULL)
1181             init_os (output_section_statement);
1182           break;
1183         case lang_afile_asection_pair_statement_enum:
1184           FAIL ();
1185           break;
1186         case lang_address_statement_enum:
1187           /* Mark the specified section with the supplied address */
1188           {
1189             lang_output_section_statement_type *os =
1190               lang_output_section_statement_lookup
1191                 (s->address_statement.section_name);
1192
1193             if (os->bfd_section == NULL)
1194               init_os (os);
1195             os->addr_tree = s->address_statement.address;
1196           }
1197           break;
1198         }
1199     }
1200 }
1201
1202 static void
1203 print_output_section_statement (output_section_statement)
1204      lang_output_section_statement_type * output_section_statement;
1205 {
1206   asection *section = output_section_statement->bfd_section;
1207
1208   print_nl ();
1209   print_section (output_section_statement->name);
1210
1211
1212   if (section)
1213   {
1214     print_dot = section->vma;
1215     print_space ();
1216     print_section ("");
1217     print_space ();
1218     print_address (section->vma);
1219     print_space ();
1220     print_size (section->_raw_size);
1221     print_space ();
1222     print_size(section->_cooked_size);
1223     print_space ();
1224     print_alignment (section->alignment_power);
1225     print_space ();
1226 #if 0
1227     fprintf (config.map_file, "%s flags", output_section_statement->region->name);
1228     print_flags (stdout, &output_section_statement->flags);
1229 #endif
1230     if (section->flags & SEC_LOAD)
1231      fprintf (config.map_file, "load ");
1232     if (section->flags & SEC_ALLOC)
1233      fprintf (config.map_file, "alloc ");
1234     if (section->flags & SEC_RELOC)
1235      fprintf (config.map_file, "reloc ");
1236     if (section->flags & SEC_HAS_CONTENTS)
1237      fprintf (config.map_file, "contents ");
1238
1239   }
1240   else
1241   {
1242     fprintf (config.map_file, " (no attached output section)");
1243   }
1244   print_nl ();
1245   if (output_section_statement->load_base)
1246     {
1247       bfd_vma b = exp_get_abs_int(output_section_statement->load_base,
1248                                 0, "output base", lang_final_phase_enum);
1249       fprintf (config.map_file, "Output address   ");
1250       fprintf_vma (config.map_file, b);
1251       fprintf (config.map_file, "\n");
1252     }
1253   if (output_section_statement->section_alignment >= 0
1254       || output_section_statement->subsection_alignment >= 0)
1255   {
1256     fprintf (config.map_file, "\t\t\t\t\tforced alignment ");
1257     if (output_section_statement->section_alignment >= 0)
1258     {
1259       fprintf (config.map_file, "section 2**%d ",output_section_statement->section_alignment );
1260     }
1261     if ( output_section_statement->subsection_alignment >= 0)
1262     {
1263       fprintf (config.map_file, "subsection 2**%d ",output_section_statement->subsection_alignment );
1264     }
1265
1266     print_nl ();
1267   }
1268   print_statement_list (output_section_statement->children.head,
1269                         output_section_statement);
1270
1271 }
1272
1273 static void
1274 print_assignment (assignment, output_section)
1275      lang_assignment_statement_type * assignment;
1276      lang_output_section_statement_type * output_section;
1277 {
1278   etree_value_type result;
1279
1280   print_section ("");
1281   print_space ();
1282   print_section ("");
1283   print_space ();
1284   print_address (print_dot);
1285   print_space ();
1286   result = exp_fold_tree (assignment->exp->assign.src,
1287                           output_section,
1288                           lang_final_phase_enum,
1289                           print_dot,
1290                           &print_dot);
1291
1292   if (result.valid)
1293     {
1294       print_address (result.value);
1295     }
1296   else
1297     {
1298       fprintf (config.map_file, "*undefined*");
1299     }
1300   print_space ();
1301   exp_print_tree (assignment->exp);
1302
1303   fprintf (config.map_file, "\n");
1304 }
1305
1306 static void
1307 print_input_statement (statm)
1308      lang_input_statement_type * statm;
1309 {
1310   if (statm->filename != (char *) NULL)
1311     {
1312       fprintf (config.map_file, "LOAD %s\n", statm->filename);
1313     }
1314 }
1315
1316 /* Print all the defined symbols for the abfd provided by in the supplied
1317    section.
1318 */
1319
1320 static boolean
1321 print_one_symbol (hash_entry, ptr)
1322 struct  bfd_link_hash_entry *hash_entry;
1323 PTR ptr;
1324 {
1325   asection * sec = (asection *)ptr;
1326
1327   if (hash_entry->type == bfd_link_hash_defined
1328       || hash_entry->type == bfd_link_hash_defweak)
1329     {
1330       if (sec == hash_entry->u.def.section) {
1331         print_section ("");
1332         fprintf (config.map_file, " ");
1333         print_section ("");
1334         fprintf (config.map_file, " ");
1335         print_address (hash_entry->u.def.value + outside_section_address (sec));
1336         fprintf (config.map_file, "              %s", hash_entry->root.string);
1337         print_nl ();
1338       }
1339     }
1340
1341   return true;
1342 }
1343
1344 static void
1345 print_input_section (in)
1346      lang_input_section_type * in;
1347 {
1348   asection *i = in->section;
1349   bfd_size_type size = i->_cooked_size != 0 ? i->_cooked_size : i->_raw_size;
1350
1351   if (size != 0)
1352     {
1353       print_section ("");
1354       fprintf (config.map_file, " ");
1355       print_section (i->name);
1356       fprintf (config.map_file, " ");
1357       if (i->output_section)
1358         {
1359           print_address (i->output_section->vma + i->output_offset);
1360           fprintf (config.map_file, " ");
1361           print_size (i->_raw_size);
1362           fprintf (config.map_file, " ");
1363           print_size(i->_cooked_size);
1364           fprintf (config.map_file, " ");
1365           print_alignment (i->alignment_power);
1366           fprintf (config.map_file, " ");
1367           if (in->ifile)
1368             {
1369
1370               bfd *abfd = in->ifile->the_bfd;
1371
1372               if (in->ifile->just_syms_flag == true)
1373                 {
1374                   fprintf (config.map_file, "symbols only ");
1375                 }
1376
1377               fprintf (config.map_file, " %s ", abfd->xvec->name);
1378               if (abfd->my_archive != (bfd *) NULL)
1379                 {
1380                   fprintf (config.map_file, "[%s]%s", abfd->my_archive->filename,
1381                            abfd->filename);
1382                 }
1383               else
1384                 {
1385                   fprintf (config.map_file, "%s", abfd->filename);
1386                 }
1387               fprintf (config.map_file, "(overhead %d bytes)", (int) bfd_alloc_size (abfd));
1388               print_nl ();
1389
1390               /* Print all the symbols */
1391               bfd_link_hash_traverse (link_info.hash, print_one_symbol, (PTR) i);
1392             }
1393           else
1394             {
1395               print_nl ();
1396             }
1397
1398
1399           print_dot = outside_section_address (i) + size;
1400         }
1401       else
1402         {
1403           fprintf (config.map_file, "No output section allocated\n");
1404         }
1405     }
1406 }
1407
1408 static void
1409 print_fill_statement (fill)
1410      lang_fill_statement_type * fill;
1411 {
1412   fprintf (config.map_file, "FILL mask ");
1413   print_fill (fill->fill);
1414 }
1415
1416 static void
1417 print_data_statement (data)
1418      lang_data_statement_type * data;
1419 {
1420 /*  bfd_vma value; */
1421   print_section ("");
1422   print_space ();
1423   print_section ("");
1424   print_space ();
1425 /*  ASSERT(print_dot == data->output_vma);*/
1426
1427   /* data->output_section may be NULL if called from gdb.  */
1428   if (data->output_section)
1429     print_address (data->output_vma + data->output_section->vma);
1430   else
1431     print_address (data->output_vma);
1432   print_space ();
1433   print_address (data->value);
1434   print_space ();
1435   switch (data->type)
1436     {
1437     case BYTE:
1438       fprintf (config.map_file, "BYTE ");
1439       print_dot += BYTE_SIZE;
1440       break;
1441     case SHORT:
1442       fprintf (config.map_file, "SHORT ");
1443       print_dot += SHORT_SIZE;
1444       break;
1445     case LONG:
1446       fprintf (config.map_file, "LONG ");
1447       print_dot += LONG_SIZE;
1448       break;
1449     case QUAD:
1450       fprintf (config.map_file, "QUAD ");
1451       print_dot += QUAD_SIZE;
1452       break;
1453     }
1454
1455   exp_print_tree (data->exp);
1456
1457   fprintf (config.map_file, "\n");
1458 }
1459
1460 /* Print a reloc statement.  */
1461
1462 static void
1463 print_reloc_statement (reloc)
1464      lang_reloc_statement_type *reloc;
1465 {
1466   print_section ("");
1467   print_space ();
1468   print_section ("");
1469   print_space ();
1470
1471 /*  ASSERT(print_dot == data->output_vma);*/
1472
1473   /* reloc->output_section may be NULL if called from gdb.  */
1474   if (reloc->output_section)
1475     print_address (reloc->output_vma + reloc->output_section->vma);
1476   else
1477     print_address (reloc->output_vma);
1478   print_space ();
1479   print_address (reloc->addend_value);
1480   print_space ();
1481
1482   fprintf (config.map_file, "RELOC %s ", reloc->howto->name);
1483
1484   print_dot += bfd_get_reloc_size (reloc->howto);
1485
1486   exp_print_tree (reloc->addend_exp);
1487
1488   fprintf (config.map_file, "\n");
1489 }
1490
1491 static void
1492 print_padding_statement (s)
1493      lang_padding_statement_type * s;
1494 {
1495   print_section ("");
1496   print_space ();
1497   print_section ("*fill*");
1498   print_space ();
1499   /* s->output_section may be NULL if called from gdb.  */
1500   if (s->output_section)
1501     print_address (s->output_offset + s->output_section->vma);
1502   else
1503     print_address (s->output_offset);
1504   print_space ();
1505   print_size (s->size);
1506   print_space ();
1507   print_fill (s->fill);
1508   print_nl ();
1509
1510   print_dot = s->output_offset + s->size;
1511   /* s->output_section may be NULL if called from gdb.  */
1512   if (s->output_section)
1513     print_dot += s->output_section->vma;
1514 }
1515
1516 static void
1517 print_wild_statement (w, os)
1518      lang_wild_statement_type * w;
1519      lang_output_section_statement_type * os;
1520 {
1521   fprintf (config.map_file, " from ");
1522   if (w->filename != (char *) NULL)
1523     {
1524       fprintf (config.map_file, "%s", w->filename);
1525     }
1526   else
1527     {
1528       fprintf (config.map_file, "*");
1529     }
1530   if (w->section_name != (char *) NULL)
1531     {
1532       fprintf (config.map_file, "(%s)", w->section_name);
1533     }
1534   else
1535     {
1536       fprintf (config.map_file, "(*)");
1537     }
1538   print_nl ();
1539   print_statement_list (w->children.head, os);
1540
1541 }
1542
1543 /* Print a group statement.  */
1544
1545 static void
1546 print_group (s, os)
1547      lang_group_statement_type *s;
1548      lang_output_section_statement_type *os;
1549 {
1550   fprintf (config.map_file, "START GROUP\n");
1551   print_statement_list (s->children.head, os);
1552   fprintf (config.map_file, "END GROUP\n");
1553 }
1554
1555 /* Print the list of statements in S.
1556    This can be called for any statement type.  */
1557
1558 static void
1559 print_statement_list (s, os)
1560      lang_statement_union_type * s;
1561      lang_output_section_statement_type * os;
1562 {
1563   while (s)
1564     {
1565       print_statement (s, os);
1566       s = s->next;
1567     }
1568 }
1569
1570 /* Print the first statement in statement list S.
1571    This can be called for any statement type.  */
1572
1573 static void
1574 print_statement (s, os)
1575      lang_statement_union_type * s;
1576      lang_output_section_statement_type * os;
1577 {
1578   switch (s->header.type)
1579     {
1580     case lang_constructors_statement_enum:
1581       fprintf (config.map_file, "constructors:\n");
1582       print_statement_list (constructor_list.head, os);
1583       break;
1584     case lang_wild_statement_enum:
1585       print_wild_statement (&s->wild_statement, os);
1586       break;
1587     default:
1588       fprintf (config.map_file, "Fail with %d\n", s->header.type);
1589       FAIL ();
1590       break;
1591     case lang_address_statement_enum:
1592       fprintf (config.map_file, "address\n");
1593       break;
1594     case lang_object_symbols_statement_enum:
1595       fprintf (config.map_file, "object symbols\n");
1596       break;
1597     case lang_fill_statement_enum:
1598       print_fill_statement (&s->fill_statement);
1599       break;
1600     case lang_data_statement_enum:
1601       print_data_statement (&s->data_statement);
1602       break;
1603     case lang_reloc_statement_enum:
1604       print_reloc_statement (&s->reloc_statement);
1605       break;
1606     case lang_input_section_enum:
1607       print_input_section (&s->input_section);
1608       break;
1609     case lang_padding_statement_enum:
1610       print_padding_statement (&s->padding_statement);
1611       break;
1612     case lang_output_section_statement_enum:
1613       print_output_section_statement (&s->output_section_statement);
1614       break;
1615     case lang_assignment_statement_enum:
1616       print_assignment (&s->assignment_statement,
1617                         os);
1618       break;
1619     case lang_target_statement_enum:
1620       fprintf (config.map_file, "TARGET(%s)\n", s->target_statement.target);
1621       break;
1622     case lang_output_statement_enum:
1623       fprintf (config.map_file, "OUTPUT(%s %s)\n",
1624                s->output_statement.name,
1625                output_target ? output_target : "");
1626       break;
1627     case lang_input_statement_enum:
1628       print_input_statement (&s->input_statement);
1629       break;
1630     case lang_group_statement_enum:
1631       print_group (&s->group_statement, os);
1632       break;
1633     case lang_afile_asection_pair_statement_enum:
1634       FAIL ();
1635       break;
1636     }
1637 }
1638
1639
1640 static void
1641 print_statements ()
1642 {
1643   print_statement_list (statement_list.head,
1644                    abs_output_section);
1645
1646 }
1647
1648 /* Print the first N statements in statement list S to STDERR.
1649    If N == 0, nothing is printed.
1650    If N < 0, the entire list is printed.
1651    Intended to be called from GDB.  */
1652
1653 void
1654 dprint_statement (s, n)
1655      lang_statement_union_type * s;
1656      int n;
1657 {
1658   FILE *map_save = config.map_file;
1659
1660   config.map_file = stderr;
1661
1662   if (n < 0)
1663     print_statement_list (s, abs_output_section);
1664   else
1665     {
1666       while (--n >= 0)
1667         {
1668           print_statement (s, abs_output_section);
1669           s = s->next;
1670         }
1671     }
1672
1673   config.map_file = map_save;
1674 }
1675
1676 static bfd_vma
1677 insert_pad (this_ptr, fill, power, output_section_statement, dot)
1678      lang_statement_union_type ** this_ptr;
1679      fill_type fill;
1680      unsigned int power;
1681      asection * output_section_statement;
1682      bfd_vma dot;
1683 {
1684   /* Align this section first to the
1685      input sections requirement, then
1686      to the output section's requirement.
1687      If this alignment is > than any seen before,
1688      then record it too. Perform the alignment by
1689      inserting a magic 'padding' statement.
1690      */
1691
1692   unsigned int alignment_needed = align_power (dot, power) - dot;
1693
1694   if (alignment_needed != 0)
1695     {
1696       lang_statement_union_type *new =
1697         ((lang_statement_union_type *)
1698          stat_alloc (sizeof (lang_padding_statement_type)));
1699
1700       /* Link into existing chain */
1701       new->header.next = *this_ptr;
1702       *this_ptr = new;
1703       new->header.type = lang_padding_statement_enum;
1704       new->padding_statement.output_section = output_section_statement;
1705       new->padding_statement.output_offset =
1706         dot - output_section_statement->vma;
1707       new->padding_statement.fill = fill;
1708       new->padding_statement.size = alignment_needed;
1709     }
1710
1711
1712   /* Remember the most restrictive alignment */
1713   if (power > output_section_statement->alignment_power)
1714     {
1715       output_section_statement->alignment_power = power;
1716     }
1717   output_section_statement->_raw_size += alignment_needed;
1718   return alignment_needed + dot;
1719
1720 }
1721
1722 /* Work out how much this section will move the dot point */
1723 static bfd_vma
1724 size_input_section (this_ptr, output_section_statement, fill, dot, relax)
1725      lang_statement_union_type ** this_ptr;
1726      lang_output_section_statement_type * output_section_statement;
1727      fill_type fill;
1728      bfd_vma dot;
1729      boolean relax;
1730 {
1731   lang_input_section_type *is = &((*this_ptr)->input_section);
1732   asection *i = is->section;
1733
1734   if (is->ifile->just_syms_flag == false)
1735     {
1736       if (output_section_statement->subsection_alignment != -1)
1737        i->alignment_power =
1738         output_section_statement->subsection_alignment;
1739
1740       dot = insert_pad (this_ptr, fill, i->alignment_power,
1741                         output_section_statement->bfd_section, dot);
1742
1743       /* Remember where in the output section this input section goes */
1744
1745       i->output_offset = dot - output_section_statement->bfd_section->vma;
1746
1747       /* Mark how big the output section must be to contain this now
1748          */
1749       if (i->_cooked_size != 0)
1750         dot += i->_cooked_size;
1751       else
1752         dot += i->_raw_size;
1753       output_section_statement->bfd_section->_raw_size = dot - output_section_statement->bfd_section->vma;
1754     }
1755   else
1756     {
1757       i->output_offset = i->vma - output_section_statement->bfd_section->vma;
1758     }
1759
1760   return dot;
1761 }
1762
1763 /* This variable indicates whether bfd_relax_section should be called
1764    again.  */
1765
1766 static boolean relax_again;
1767
1768 /* Set the sizes for all the output sections.  */
1769
1770 bfd_vma
1771 lang_size_sections (s, output_section_statement, prev, fill, dot, relax)
1772      lang_statement_union_type * s;
1773      lang_output_section_statement_type * output_section_statement;
1774      lang_statement_union_type ** prev;
1775      fill_type fill;
1776      bfd_vma dot;
1777      boolean relax;
1778 {
1779   /* Size up the sections from their constituent parts */
1780   for (; s != (lang_statement_union_type *) NULL; s = s->next)
1781   {
1782     switch (s->header.type)
1783     {
1784
1785      case lang_output_section_statement_enum:
1786      {
1787        bfd_vma after;
1788        lang_output_section_statement_type *os = &s->output_section_statement;
1789
1790        if (os->bfd_section == NULL)
1791          {
1792            /* This section was never actually created.  */
1793            break;
1794          }
1795
1796        /* If this is a COFF shared library section, use the size and
1797           address from the input section.  FIXME: This is COFF
1798           specific; it would be cleaner if there were some other way
1799           to do this, but nothing simple comes to mind.  */
1800        if ((os->bfd_section->flags & SEC_COFF_SHARED_LIBRARY) != 0)
1801          {
1802            asection *input;
1803
1804            if (os->children.head == NULL
1805                || os->children.head->next != NULL
1806                || os->children.head->header.type != lang_input_section_enum)
1807              einfo ("%P%X: Internal error on COFF shared library section %s",
1808                     os->name);
1809
1810            input = os->children.head->input_section.section;
1811            bfd_set_section_vma (os->bfd_section->owner,
1812                                 os->bfd_section,
1813                                 bfd_section_vma (input->owner, input));
1814            os->bfd_section->_raw_size = input->_raw_size;
1815            break;
1816          }
1817
1818        if (bfd_is_abs_section (os->bfd_section))
1819        {
1820          /* No matter what happens, an abs section starts at zero */
1821          ASSERT (os->bfd_section->vma == 0);
1822        }
1823        else
1824        {
1825          if (os->addr_tree == (etree_type *) NULL)
1826          {
1827            /* No address specified for this section, get one
1828               from the region specification
1829               */
1830            if (os->region == (lang_memory_region_type *) NULL)
1831            {
1832              os->region = lang_memory_region_lookup ("*default*");
1833            }
1834            dot = os->region->current;
1835            if (os->section_alignment == -1)
1836              dot = align_power (dot, os->bfd_section->alignment_power);
1837          }
1838          else
1839          {
1840            etree_value_type r;
1841
1842            r = exp_fold_tree (os->addr_tree,
1843                               abs_output_section,
1844                               lang_allocating_phase_enum,
1845                               dot, &dot);
1846            if (r.valid == false)
1847            {
1848              einfo ("%F%S: non constant address expression for section %s\n",
1849                     os->name);
1850            }
1851            dot = r.value;
1852          }
1853          /* The section starts here */
1854          /* First, align to what the section needs */
1855
1856          if (os->section_alignment != -1)
1857            dot = align_power (dot, os->section_alignment);
1858
1859          bfd_set_section_vma (0, os->bfd_section, dot);
1860
1861          os->bfd_section->output_offset = 0;
1862        }
1863
1864        (void) lang_size_sections (os->children.head, os, &os->children.head,
1865                                   os->fill, dot, relax);
1866        /* Ignore the size of the input sections, use the vma and size to */
1867        /* align against */
1868
1869        after = ALIGN_N (os->bfd_section->vma +
1870                         os->bfd_section->_raw_size,
1871                         /* The coercion here is important, see ld.h.  */
1872                         (bfd_vma) os->block_value);
1873
1874        if (bfd_is_abs_section (os->bfd_section))
1875          ASSERT (after == os->bfd_section->vma);
1876        else
1877          os->bfd_section->_raw_size = after - os->bfd_section->vma;
1878        dot = os->bfd_section->vma + os->bfd_section->_raw_size;
1879        os->processed = true;
1880
1881        /* Replace into region ? */
1882        if (os->region != (lang_memory_region_type *) NULL)
1883          {
1884            os->region->current = dot;
1885            /* Make sure this isn't silly.  */
1886            if ((os->region->current < os->region->origin)
1887                || (os->region->current
1888                    > os->region->origin + os->region->length))
1889              {
1890                if (os->addr_tree != (etree_type *) NULL)
1891                  {
1892                    einfo ("%X%P: address 0x%v of %B section %s is not within region %s\n",
1893                           os->region->current,
1894                           os->bfd_section->owner,
1895                           os->bfd_section->name,
1896                           os->region->name);
1897                  }
1898                else
1899                  {
1900                    einfo ("%X%P: region %s is full (%B section %s)\n",
1901                           os->region->name,
1902                           os->bfd_section->owner,
1903                           os->bfd_section->name);
1904                  }
1905                /* Reset the region pointer.  */
1906                os->region->current = os->region->origin;
1907              }
1908          }
1909      }
1910      break;
1911
1912      case lang_constructors_statement_enum:
1913       dot = lang_size_sections (constructor_list.head,
1914                                 output_section_statement,
1915                                 &s->wild_statement.children.head,
1916                                 fill,
1917                                 dot, relax);
1918       break;
1919
1920      case lang_data_statement_enum:
1921      {
1922        unsigned int size = 0;
1923
1924        s->data_statement.output_vma = dot - output_section_statement->bfd_section->vma;
1925        s->data_statement.output_section =
1926         output_section_statement->bfd_section;
1927
1928        switch (s->data_statement.type)
1929        {
1930         case QUAD:
1931          size = QUAD_SIZE;
1932          break;
1933         case LONG:
1934          size = LONG_SIZE;
1935          break;
1936         case SHORT:
1937          size = SHORT_SIZE;
1938          break;
1939         case BYTE:
1940          size = BYTE_SIZE;
1941          break;
1942
1943        }
1944        dot += size;
1945        output_section_statement->bfd_section->_raw_size += size;
1946        /* The output section gets contents, and then we inspect for
1947           any flags set in the input script which override any ALLOC */
1948        output_section_statement->bfd_section->flags |= SEC_HAS_CONTENTS;
1949        if (!(output_section_statement->flags & SEC_NEVER_LOAD)) {
1950          output_section_statement->bfd_section->flags |= SEC_ALLOC | SEC_LOAD;
1951        }
1952      }
1953       break;
1954
1955      case lang_reloc_statement_enum:
1956      {
1957        int size;
1958
1959        s->reloc_statement.output_vma =
1960          dot - output_section_statement->bfd_section->vma;
1961        s->reloc_statement.output_section =
1962          output_section_statement->bfd_section;
1963        size = bfd_get_reloc_size (s->reloc_statement.howto);
1964        dot += size;
1965        output_section_statement->bfd_section->_raw_size += size;
1966      }
1967      break;
1968
1969      case lang_wild_statement_enum:
1970
1971       dot = lang_size_sections (s->wild_statement.children.head,
1972                                 output_section_statement,
1973                                 &s->wild_statement.children.head,
1974
1975                                 fill, dot, relax);
1976
1977       break;
1978
1979      case lang_object_symbols_statement_enum:
1980       link_info.create_object_symbols_section =
1981         output_section_statement->bfd_section;
1982       break;
1983      case lang_output_statement_enum:
1984      case lang_target_statement_enum:
1985       break;
1986      case lang_input_section_enum:
1987       {
1988         asection *i;
1989
1990         i = (*prev)->input_section.section;
1991         if (! relax)
1992           i->_cooked_size = i->_raw_size;
1993         else
1994           {
1995             boolean again;
1996
1997             if (! bfd_relax_section (i->owner, i, &link_info, &again))
1998               einfo ("%P%F: can't relax section: %E\n");
1999             if (again)
2000               relax_again = true;
2001           }
2002         dot = size_input_section (prev,
2003                                   output_section_statement,
2004                                   output_section_statement->fill,
2005                                   dot, relax);
2006       }
2007       break;
2008      case lang_input_statement_enum:
2009       break;
2010      case lang_fill_statement_enum:
2011       s->fill_statement.output_section = output_section_statement->bfd_section;
2012
2013       fill = s->fill_statement.fill;
2014       break;
2015      case lang_assignment_statement_enum:
2016      {
2017        bfd_vma newdot = dot;
2018
2019        exp_fold_tree (s->assignment_statement.exp,
2020                       output_section_statement,
2021                       lang_allocating_phase_enum,
2022                       dot,
2023                       &newdot);
2024
2025        if (newdot != dot && !relax)
2026          {
2027            /* The assignment changed dot.  Insert a pad.  */
2028            if (output_section_statement == abs_output_section)
2029              {
2030                /* If we don't have an output section, then just adjust
2031                   the default memory address.  */
2032                lang_memory_region_lookup ("*default*")->current = newdot;
2033              }
2034            else
2035              {
2036                lang_statement_union_type *new =
2037                  ((lang_statement_union_type *)
2038                   stat_alloc (sizeof (lang_padding_statement_type)));
2039
2040                /* Link into existing chain */
2041                new->header.next = *prev;
2042                *prev = new;
2043                new->header.type = lang_padding_statement_enum;
2044                new->padding_statement.output_section =
2045                  output_section_statement->bfd_section;
2046                new->padding_statement.output_offset =
2047                  dot - output_section_statement->bfd_section->vma;
2048                new->padding_statement.fill = fill;
2049                new->padding_statement.size = newdot - dot;
2050                output_section_statement->bfd_section->_raw_size +=
2051                  new->padding_statement.size;
2052              }
2053
2054            dot = newdot;
2055          }
2056      }
2057      break;
2058
2059    case lang_padding_statement_enum:
2060      /* If we are relaxing, and this is not the first pass, some
2061         padding statements may have been inserted during previous
2062         passes.  We may have to move the padding statement to a new
2063         location if dot has a different value at this point in this
2064         pass than it did at this point in the previous pass.  */
2065      s->padding_statement.output_offset =
2066        dot - output_section_statement->bfd_section->vma;
2067      dot += s->padding_statement.size;
2068      output_section_statement->bfd_section->_raw_size +=
2069        s->padding_statement.size;
2070      break;
2071
2072      case lang_group_statement_enum:
2073        dot = lang_size_sections (s->group_statement.children.head,
2074                                  output_section_statement,
2075                                  &s->group_statement.children.head,
2076                                  fill, dot, relax);
2077        break;
2078
2079      default:
2080       FAIL ();
2081       break;
2082
2083       /* This can only get here when relaxing is turned on */
2084
2085      case lang_address_statement_enum:
2086       break;
2087     }
2088     prev = &s->header.next;
2089   }
2090   return dot;
2091 }
2092
2093 bfd_vma
2094 lang_do_assignments (s, output_section_statement, fill, dot)
2095      lang_statement_union_type * s;
2096      lang_output_section_statement_type * output_section_statement;
2097      fill_type fill;
2098      bfd_vma dot;
2099 {
2100   for (; s != (lang_statement_union_type *) NULL; s = s->next)
2101     {
2102       switch (s->header.type)
2103         {
2104         case lang_constructors_statement_enum:
2105           dot = lang_do_assignments (constructor_list.head,
2106                                      output_section_statement,
2107                                      fill,
2108                                      dot);
2109           break;
2110
2111         case lang_output_section_statement_enum:
2112           {
2113             lang_output_section_statement_type *os =
2114               &(s->output_section_statement);
2115
2116             if (os->bfd_section != NULL)
2117               {
2118                 dot = os->bfd_section->vma;
2119                 (void) lang_do_assignments (os->children.head, os,
2120                                             os->fill, dot);
2121                 dot = os->bfd_section->vma + os->bfd_section->_raw_size;
2122               }
2123             if (os->load_base)
2124               {
2125                 /* If nothing has been placed into the output section then
2126                    it won't have a bfd_section. */
2127                 if (os->bfd_section)
2128                   {
2129                     os->bfd_section->lma
2130                       = exp_get_abs_int(os->load_base, 0,"load base", lang_final_phase_enum);
2131                   }
2132               }
2133           }
2134           break;
2135         case lang_wild_statement_enum:
2136
2137           dot = lang_do_assignments (s->wild_statement.children.head,
2138                                      output_section_statement,
2139                                      fill, dot);
2140
2141           break;
2142
2143         case lang_object_symbols_statement_enum:
2144         case lang_output_statement_enum:
2145         case lang_target_statement_enum:
2146 #if 0
2147         case lang_common_statement_enum:
2148 #endif
2149           break;
2150         case lang_data_statement_enum:
2151           {
2152             etree_value_type value;
2153
2154             value = exp_fold_tree (s->data_statement.exp,
2155                                    abs_output_section,
2156                                    lang_final_phase_enum, dot, &dot);
2157             s->data_statement.value = value.value;
2158             if (value.valid == false)
2159               einfo ("%F%P: invalid data statement\n");
2160           }
2161           switch (s->data_statement.type)
2162             {
2163             case QUAD:
2164               dot += QUAD_SIZE;
2165               break;
2166             case LONG:
2167               dot += LONG_SIZE;
2168               break;
2169             case SHORT:
2170               dot += SHORT_SIZE;
2171               break;
2172             case BYTE:
2173               dot += BYTE_SIZE;
2174               break;
2175             }
2176           break;
2177
2178         case lang_reloc_statement_enum:
2179           {
2180             etree_value_type value;
2181
2182             value = exp_fold_tree (s->reloc_statement.addend_exp,
2183                                    abs_output_section,
2184                                    lang_final_phase_enum, dot, &dot);
2185             s->reloc_statement.addend_value = value.value;
2186             if (value.valid == false)
2187               einfo ("%F%P: invalid reloc statement\n");
2188           }
2189           dot += bfd_get_reloc_size (s->reloc_statement.howto);
2190           break;
2191
2192         case lang_input_section_enum:
2193           {
2194             asection *in = s->input_section.section;
2195
2196             if (in->_cooked_size != 0)
2197               dot += in->_cooked_size;
2198             else
2199               dot += in->_raw_size;
2200           }
2201           break;
2202
2203         case lang_input_statement_enum:
2204           break;
2205         case lang_fill_statement_enum:
2206           fill = s->fill_statement.fill;
2207           break;
2208         case lang_assignment_statement_enum:
2209           {
2210             exp_fold_tree (s->assignment_statement.exp,
2211                            output_section_statement,
2212                            lang_final_phase_enum,
2213                            dot,
2214                            &dot);
2215           }
2216
2217           break;
2218         case lang_padding_statement_enum:
2219           dot += s->padding_statement.size;
2220           break;
2221
2222         case lang_group_statement_enum:
2223           dot = lang_do_assignments (s->group_statement.children.head,
2224                                      output_section_statement,
2225                                      fill, dot);
2226
2227           break;
2228
2229         default:
2230           FAIL ();
2231           break;
2232         case lang_address_statement_enum:
2233           break;
2234         }
2235
2236     }
2237   return dot;
2238 }
2239
2240 /* Fix any .startof. or .sizeof. symbols.  When the assemblers see the
2241    operator .startof. (section_name), it produces an undefined symbol
2242    .startof.section_name.  Similarly, when it sees
2243    .sizeof. (section_name), it produces an undefined symbol
2244    .sizeof.section_name.  For all the output sections, we look for
2245    such symbols, and set them to the correct value.  */
2246
2247 static void
2248 lang_set_startof ()
2249 {
2250   asection *s;
2251
2252   for (s = output_bfd->sections; s != NULL; s = s->next)
2253     {
2254       const char *secname;
2255       char *buf;
2256       struct bfd_link_hash_entry *h;
2257
2258       secname = bfd_get_section_name (output_bfd, s);
2259       buf = xmalloc (10 + strlen (secname));
2260
2261       sprintf (buf, ".startof.%s", secname);
2262       h = bfd_link_hash_lookup (link_info.hash, buf, false, false, true);
2263       if (h != NULL && h->type == bfd_link_hash_undefined)
2264         {
2265           h->type = bfd_link_hash_defined;
2266           h->u.def.value = bfd_get_section_vma (output_bfd, s);
2267           h->u.def.section = bfd_abs_section_ptr;
2268         }
2269
2270       sprintf (buf, ".sizeof.%s", secname);
2271       h = bfd_link_hash_lookup (link_info.hash, buf, false, false, true);
2272       if (h != NULL && h->type == bfd_link_hash_undefined)
2273         {
2274           h->type = bfd_link_hash_defined;
2275           if (s->_cooked_size != 0)
2276             h->u.def.value = s->_cooked_size;
2277           else
2278             h->u.def.value = s->_raw_size;
2279           h->u.def.section = bfd_abs_section_ptr;
2280         }
2281
2282       free (buf);
2283     }
2284 }
2285
2286 static void
2287 lang_finish ()
2288 {
2289   struct bfd_link_hash_entry *h;
2290   boolean warn;
2291
2292   if (link_info.relocateable || link_info.shared)
2293     warn = false;
2294   else
2295     warn = true;
2296
2297   if (entry_symbol == (char *) NULL)
2298     {
2299       /* No entry has been specified.  Look for start, but don't warn
2300          if we don't find it.  */
2301       entry_symbol = "start";
2302       warn = false;
2303     }
2304
2305   h = bfd_link_hash_lookup (link_info.hash, entry_symbol, false, false, true);
2306   if (h != (struct bfd_link_hash_entry *) NULL
2307       && (h->type == bfd_link_hash_defined
2308           || h->type == bfd_link_hash_defweak)
2309       && h->u.def.section->output_section != NULL)
2310     {
2311       bfd_vma val;
2312
2313       val = (h->u.def.value
2314              + bfd_get_section_vma (output_bfd,
2315                                     h->u.def.section->output_section)
2316              + h->u.def.section->output_offset);
2317       if (! bfd_set_start_address (output_bfd, val))
2318         einfo ("%P%F:%s: can't set start address\n", entry_symbol);
2319     }
2320   else
2321     {
2322       asection *ts;
2323
2324       /* Can't find the entry symbol.  Use the first address in the
2325          text section.  */
2326       ts = bfd_get_section_by_name (output_bfd, ".text");
2327       if (ts != (asection *) NULL)
2328         {
2329           if (warn)
2330             einfo ("%P: warning: cannot find entry symbol %s; defaulting to %V\n",
2331                    entry_symbol, bfd_get_section_vma (output_bfd, ts));
2332           if (! bfd_set_start_address (output_bfd,
2333                                        bfd_get_section_vma (output_bfd, ts)))
2334             einfo ("%P%F: can't set start address\n");
2335         }
2336       else
2337         {
2338           if (warn)
2339             einfo ("%P: warning: cannot find entry symbol %s; not setting start address\n",
2340                    entry_symbol);
2341         }
2342     }
2343 }
2344
2345 /* Check that the architecture of all the input files is compatible
2346    with the output file.  Also call the backend to let it do any
2347    other checking that is needed.  */
2348
2349 static void
2350 lang_check ()
2351 {
2352   lang_statement_union_type *file;
2353   bfd *input_bfd;
2354   CONST bfd_arch_info_type *compatible;
2355
2356   for (file = file_chain.head;
2357        file != (lang_statement_union_type *) NULL;
2358        file = file->input_statement.next)
2359     {
2360       input_bfd = file->input_statement.the_bfd;
2361       compatible = bfd_arch_get_compatible (input_bfd,
2362                                             output_bfd);
2363       if (compatible == NULL)
2364         einfo ("%P: warning: %s architecture of input file `%B' is incompatible with %s output\n",
2365                bfd_printable_name (input_bfd), input_bfd,
2366                bfd_printable_name (output_bfd));
2367
2368       else
2369         bfd_merge_private_bfd_data (input_bfd, output_bfd);
2370     }
2371 }
2372
2373 /* Look through all the global common symbols and attach them to the
2374    correct section.  The -sort-common command line switch may be used
2375    to roughly sort the entries by size.  */
2376
2377 static void
2378 lang_common ()
2379 {
2380   if (link_info.relocateable
2381       && ! command_line.force_common_definition)
2382     return;
2383
2384   if (! config.sort_common)
2385     bfd_link_hash_traverse (link_info.hash, lang_one_common, (PTR) NULL);
2386   else
2387     {
2388       int power;
2389
2390       for (power = 4; power >= 0; power--)
2391         bfd_link_hash_traverse (link_info.hash, lang_one_common,
2392                                 (PTR) &power);
2393     }
2394 }
2395
2396 /* Place one common symbol in the correct section.  */
2397
2398 static boolean
2399 lang_one_common (h, info)
2400      struct bfd_link_hash_entry *h;
2401      PTR info;
2402 {
2403   unsigned int power_of_two;
2404   bfd_vma size;
2405   asection *section;
2406
2407   if (h->type != bfd_link_hash_common)
2408     return true;
2409
2410   size = h->u.c.size;
2411   power_of_two = h->u.c.p->alignment_power;
2412
2413   if (config.sort_common
2414       && power_of_two < (unsigned int) *(int *) info)
2415     return true;
2416
2417   section = h->u.c.p->section;
2418
2419   /* Increase the size of the section.  */
2420   section->_raw_size = ALIGN_N (section->_raw_size,
2421                                 (bfd_size_type) (1 << power_of_two));
2422
2423   /* Adjust the alignment if necessary.  */
2424   if (power_of_two > section->alignment_power)
2425     section->alignment_power = power_of_two;
2426
2427   /* Change the symbol from common to defined.  */
2428   h->type = bfd_link_hash_defined;
2429   h->u.def.section = section;
2430   h->u.def.value = section->_raw_size;
2431
2432   /* Increase the size of the section.  */
2433   section->_raw_size += size;
2434
2435   /* Make sure the section is allocated in memory.  */
2436   section->flags |= SEC_ALLOC;
2437
2438   if (config.map_file != NULL)
2439     fprintf (config.map_file, "Allocating common %s: %lx at %lx %s\n",
2440              h->root.string, (unsigned long) size,
2441              (unsigned long) h->u.def.value, section->owner->filename);
2442
2443   return true;
2444 }
2445
2446 /*
2447 run through the input files and ensure that every input
2448 section has somewhere to go. If one is found without
2449 a destination then create an input request and place it
2450 into the statement tree.
2451 */
2452
2453 static void
2454 lang_place_orphans ()
2455 {
2456   lang_input_statement_type *file;
2457
2458   for (file = (lang_input_statement_type *) file_chain.head;
2459        file != (lang_input_statement_type *) NULL;
2460        file = (lang_input_statement_type *) file->next)
2461     {
2462       asection *s;
2463
2464       for (s = file->the_bfd->sections;
2465            s != (asection *) NULL;
2466            s = s->next)
2467         {
2468           if (s->output_section == (asection *) NULL)
2469             {
2470               /* This section of the file is not attatched, root
2471                  around for a sensible place for it to go */
2472
2473               if (file->just_syms_flag)
2474                 {
2475                   /* We are only retrieving symbol values from this
2476                      file.  We want the symbols to act as though the
2477                      values in the file are absolute.  */
2478                   s->output_section = bfd_abs_section_ptr;
2479                   s->output_offset = s->vma;
2480                 }
2481               else if (file->common_section == s)
2482                 {
2483                   /* This is a lonely common section which must
2484                      have come from an archive. We attatch to the
2485                      section with the wildcard  */
2486                   if (! link_info.relocateable
2487                       && ! command_line.force_common_definition)
2488                     {
2489                       if (default_common_section ==
2490                           (lang_output_section_statement_type *) NULL)
2491                         {
2492                           info_msg ("%P: no [COMMON] command, defaulting to .bss\n");
2493
2494                           default_common_section =
2495                             lang_output_section_statement_lookup (".bss");
2496
2497                         }
2498                       wild_doit (&default_common_section->children, s,
2499                                  default_common_section, file);
2500                     }
2501                 }
2502               else if (ldemul_place_orphan (file, s))
2503                 ;
2504               else
2505                 {
2506                   lang_output_section_statement_type *os =
2507                   lang_output_section_statement_lookup (s->name);
2508
2509                   wild_doit (&os->children, s, os, file);
2510                 }
2511             }
2512         }
2513     }
2514 }
2515
2516
2517 void
2518 lang_set_flags (ptr, flags)
2519      int *ptr;
2520      CONST char *flags;
2521 {
2522   boolean state = false;
2523
2524   *ptr = 0;
2525   while (*flags)
2526     {
2527       if (*flags == '!')
2528         {
2529           state = false;
2530           flags++;
2531         }
2532       else
2533         state = true;
2534       switch (*flags)
2535         {
2536         case 'R':
2537           /*      ptr->flag_read = state; */
2538           break;
2539         case 'W':
2540           /*      ptr->flag_write = state; */
2541           break;
2542         case 'X':
2543           /*      ptr->flag_executable= state;*/
2544           break;
2545         case 'L':
2546         case 'I':
2547           /*      ptr->flag_loadable= state;*/
2548           break;
2549         default:
2550           einfo ("%P%F: invalid syntax in flags\n");
2551           break;
2552         }
2553       flags++;
2554     }
2555 }
2556
2557 /* Call a function on each input file.  This function will be called
2558    on an archive, but not on the elements.  */
2559
2560 void
2561 lang_for_each_input_file (func)
2562      void (*func) PARAMS ((lang_input_statement_type *));
2563 {
2564   lang_input_statement_type *f;
2565
2566   for (f = (lang_input_statement_type *) input_file_chain.head;
2567        f != NULL;
2568        f = (lang_input_statement_type *) f->next_real_file)
2569     func (f);
2570 }
2571
2572 /* Call a function on each file.  The function will be called on all
2573    the elements of an archive which are included in the link, but will
2574    not be called on the archive file itself.  */
2575
2576 void
2577 lang_for_each_file (func)
2578      void (*func) PARAMS ((lang_input_statement_type *));
2579 {
2580   lang_input_statement_type *f;
2581
2582   for (f = (lang_input_statement_type *) file_chain.head;
2583        f != (lang_input_statement_type *) NULL;
2584        f = (lang_input_statement_type *) f->next)
2585     {
2586       func (f);
2587     }
2588 }
2589
2590 #if 0
2591
2592 /* Not used.  */
2593
2594 void
2595 lang_for_each_input_section (func)
2596      void (*func) PARAMS ((bfd * ab, asection * as));
2597 {
2598   lang_input_statement_type *f;
2599
2600   for (f = (lang_input_statement_type *) file_chain.head;
2601        f != (lang_input_statement_type *) NULL;
2602        f = (lang_input_statement_type *) f->next)
2603     {
2604       asection *s;
2605
2606       for (s = f->the_bfd->sections;
2607            s != (asection *) NULL;
2608            s = s->next)
2609         {
2610           func (f->the_bfd, s);
2611         }
2612     }
2613 }
2614
2615 #endif
2616
2617 void
2618 ldlang_add_file (entry)
2619      lang_input_statement_type * entry;
2620 {
2621   bfd **pp;
2622
2623   lang_statement_append (&file_chain,
2624                          (lang_statement_union_type *) entry,
2625                          &entry->next);
2626
2627   /* The BFD linker needs to have a list of all input BFDs involved in
2628      a link.  */
2629   ASSERT (entry->the_bfd->link_next == (bfd *) NULL);
2630   ASSERT (entry->the_bfd != output_bfd);
2631   for (pp = &link_info.input_bfds;
2632        *pp != (bfd *) NULL;
2633        pp = &(*pp)->link_next)
2634     ;
2635   *pp = entry->the_bfd;
2636   entry->the_bfd->usrdata = (PTR) entry;
2637   bfd_set_gp_size (entry->the_bfd, g_switch_value);
2638 }
2639
2640 void
2641 lang_add_output (name, from_script)
2642      CONST char *name;
2643      int from_script;
2644 {
2645   /* Make -o on command line override OUTPUT in script.  */
2646   if (had_output_filename == false || !from_script)
2647     {
2648       output_filename = name;
2649       had_output_filename = true;
2650     }
2651 }
2652
2653
2654 static lang_output_section_statement_type *current_section;
2655
2656 static int
2657 topower (x)
2658      int x;
2659 {
2660   unsigned int i = 1;
2661   int l;
2662
2663   if (x < 0)
2664     return -1;
2665
2666   for (l = 0; l < 32; l++)
2667     {
2668       if (i >= (unsigned int) x)
2669         return l;
2670       i <<= 1;
2671     }
2672
2673   return 0;
2674 }
2675 void
2676 lang_enter_output_section_statement (output_section_statement_name,
2677                                      address_exp, flags, block_value,
2678                                      align, subalign, ebase)
2679      const char *output_section_statement_name;
2680      etree_type * address_exp;
2681      int flags;
2682      bfd_vma block_value;
2683      etree_type *align;
2684      etree_type *subalign;
2685      etree_type *ebase;
2686 {
2687   lang_output_section_statement_type *os;
2688
2689   current_section =
2690    os =
2691     lang_output_section_statement_lookup (output_section_statement_name);
2692
2693
2694
2695   /* Add this statement to tree */
2696   /*  add_statement(lang_output_section_statement_enum,
2697       output_section_statement);*/
2698   /* Make next things chain into subchain of this */
2699
2700   if (os->addr_tree ==
2701       (etree_type *) NULL)
2702   {
2703     os->addr_tree =
2704      address_exp;
2705   }
2706   os->flags = flags;
2707   if (flags & SEC_NEVER_LOAD)
2708    os->loadable = 0;
2709   else
2710    os->loadable = 1;
2711   os->block_value = block_value ? block_value : 1;
2712   stat_ptr = &os->children;
2713
2714   os->subsection_alignment = topower(
2715    exp_get_value_int(subalign, -1,
2716                      "subsection alignment",
2717                      0));
2718   os->section_alignment = topower(
2719    exp_get_value_int(align, -1,
2720                      "section alignment", 0));
2721
2722   os->load_base = ebase;
2723 }
2724
2725
2726 void
2727 lang_final ()
2728 {
2729   lang_output_statement_type *new =
2730     new_stat (lang_output_statement, stat_ptr);
2731
2732   new->name = output_filename;
2733 }
2734
2735 /* Reset the current counters in the regions */
2736 static void
2737 reset_memory_regions ()
2738 {
2739   lang_memory_region_type *p = lang_memory_region_list;
2740
2741   for (p = lang_memory_region_list;
2742        p != (lang_memory_region_type *) NULL;
2743        p = p->next)
2744     {
2745       p->old_length = (bfd_size_type) (p->current - p->origin);
2746       p->current = p->origin;
2747     }
2748 }
2749
2750 void
2751 lang_process ()
2752 {
2753   lang_reasonable_defaults ();
2754   current_target = default_target;
2755
2756   lang_for_each_statement (ldlang_open_output); /* Open the output file */
2757
2758   ldemul_create_output_section_statements ();
2759
2760   /* Add to the hash table all undefineds on the command line */
2761   lang_place_undefineds ();
2762
2763   /* Create a bfd for each input file */
2764   current_target = default_target;
2765   open_input_bfds (statement_list.head, false);
2766
2767   ldemul_after_open ();
2768
2769   /* Build all sets based on the information gathered from the input
2770      files.  */
2771   ldctor_build_sets ();
2772
2773   /* Size up the common data */
2774   lang_common ();
2775
2776   /* Run through the contours of the script and attatch input sections
2777      to the correct output sections
2778      */
2779   map_input_to_output_sections (statement_list.head, (char *) NULL,
2780                                 (lang_output_section_statement_type *) NULL);
2781
2782
2783   /* Find any sections not attatched explicitly and handle them */
2784   lang_place_orphans ();
2785
2786   ldemul_before_allocation ();
2787
2788   /* We must record the program headers before we try to fix the
2789      section positions, since they will affect SIZEOF_HEADERS.  */
2790   lang_record_phdrs ();
2791
2792   /* Now run around and relax if we can */
2793   if (command_line.relax)
2794     {
2795       /* First time round is a trial run to get the 'worst case'
2796          addresses of the objects if there was no relaxing.  */
2797       lang_size_sections (statement_list.head,
2798                           abs_output_section,
2799                           &(statement_list.head), 0, (bfd_vma) 0, false);
2800
2801       /* Keep relaxing until bfd_relax_section gives up.  */
2802       do
2803         {
2804           reset_memory_regions ();
2805
2806           relax_again = false;
2807
2808           /* Do all the assignments with our current guesses as to
2809              section sizes.  */
2810           lang_do_assignments (statement_list.head,
2811                                abs_output_section,
2812                                (fill_type) 0, (bfd_vma) 0);
2813
2814           /* Perform another relax pass - this time we know where the
2815              globals are, so can make better guess.  */
2816           lang_size_sections (statement_list.head,
2817                               abs_output_section,
2818                               &(statement_list.head), 0, (bfd_vma) 0, true);
2819         }
2820       while (relax_again);
2821     }
2822   else
2823     {
2824       /* Size up the sections.  */
2825       lang_size_sections (statement_list.head,
2826                           abs_output_section,
2827                           &(statement_list.head), 0, (bfd_vma) 0, false);
2828     }
2829
2830   /* See if anything special should be done now we know how big
2831      everything is.  */
2832   ldemul_after_allocation ();
2833
2834   /* Fix any .startof. or .sizeof. symbols.  */
2835   lang_set_startof ();
2836
2837   /* Do all the assignments, now that we know the final restingplaces
2838      of all the symbols */
2839
2840   lang_do_assignments (statement_list.head,
2841                        abs_output_section,
2842                        (fill_type) 0, (bfd_vma) 0);
2843
2844   /* Make sure that we're not mixing architectures */
2845
2846   lang_check ();
2847
2848   /* Final stuffs */
2849
2850   ldemul_finish ();
2851   lang_finish ();
2852 }
2853
2854 /* EXPORTED TO YACC */
2855
2856 void
2857 lang_add_wild (section_name, filename)
2858      CONST char *CONST section_name;
2859      CONST char *CONST filename;
2860 {
2861   lang_wild_statement_type *new = new_stat (lang_wild_statement,
2862                                             stat_ptr);
2863
2864   if (section_name != (char *) NULL && strcmp (section_name, "COMMON") == 0)
2865     {
2866       placed_commons = true;
2867     }
2868   if (filename != (char *) NULL)
2869     {
2870       lang_has_input_file = true;
2871     }
2872   new->section_name = section_name;
2873   new->filename = filename;
2874   lang_list_init (&new->children);
2875 }
2876
2877 void
2878 lang_section_start (name, address)
2879      CONST char *name;
2880      etree_type * address;
2881 {
2882   lang_address_statement_type *ad = new_stat (lang_address_statement, stat_ptr);
2883
2884   ad->section_name = name;
2885   ad->address = address;
2886 }
2887
2888 /* Set the start symbol to NAME.  CMDLINE is nonzero if this is called
2889    because of a -e argument on the command line, or zero if this is
2890    called by ENTRY in a linker script.  Command line arguments take
2891    precedence.  */
2892
2893 /* WINDOWS_NT.  When an entry point has been specified, we will also force
2894    this symbol to be defined by calling ldlang_add_undef (equivalent to
2895    having switch -u entry_name on the command line).  The reason we do
2896    this is so that the user doesn't have to because they would have to use
2897    the -u switch if they were specifying an entry point other than
2898    _mainCRTStartup.  Specifically, if creating a windows application, entry
2899    point _WinMainCRTStartup must be specified.
2900      What I have found for non console applications (entry not _mainCRTStartup)
2901    is that the .obj that contains mainCRTStartup is brought in since it is
2902    the first encountered in libc.lib and it has other symbols in it which will
2903    be pulled in by the link process.  To avoid this, adding -u with the entry
2904    point name specified forces the correct .obj to be used.  We can avoid
2905    making the user do this by always adding the entry point name as an
2906    undefined symbol.  */
2907
2908 void
2909 lang_add_entry (name, cmdline)
2910      CONST char *name;
2911      boolean cmdline;
2912 {
2913   if (entry_symbol == NULL
2914       || cmdline
2915       || ! entry_from_cmdline)
2916     {
2917       entry_symbol = name;
2918       entry_from_cmdline = cmdline;
2919     }
2920 #if 0
2921   /* don't do this yet.  It seems to work (the executables run), but the
2922      image created is very different from what I was getting before indicating
2923      that something else is being pulled in.  When everything else is working,
2924      then try to put this back in to see if it will do the right thing for
2925      other more complicated applications */
2926   ldlang_add_undef (name);
2927 #endif
2928 }
2929
2930 void
2931 lang_add_target (name)
2932      CONST char *name;
2933 {
2934   lang_target_statement_type *new = new_stat (lang_target_statement,
2935                                               stat_ptr);
2936
2937   new->target = name;
2938
2939 }
2940
2941 void
2942 lang_add_map (name)
2943      CONST char *name;
2944 {
2945   while (*name)
2946     {
2947       switch (*name)
2948         {
2949           case 'F':
2950           map_option_f = true;
2951           break;
2952         }
2953       name++;
2954     }
2955 }
2956
2957 void
2958 lang_add_fill (exp)
2959      int exp;
2960 {
2961   lang_fill_statement_type *new = new_stat (lang_fill_statement,
2962                                             stat_ptr);
2963
2964   new->fill = exp;
2965 }
2966
2967 void
2968 lang_add_data (type, exp)
2969      int type;
2970      union etree_union *exp;
2971 {
2972
2973   lang_data_statement_type *new = new_stat (lang_data_statement,
2974                                             stat_ptr);
2975
2976   new->exp = exp;
2977   new->type = type;
2978
2979 }
2980
2981 /* Create a new reloc statement.  RELOC is the BFD relocation type to
2982    generate.  HOWTO is the corresponding howto structure (we could
2983    look this up, but the caller has already done so).  SECTION is the
2984    section to generate a reloc against, or NAME is the name of the
2985    symbol to generate a reloc against.  Exactly one of SECTION and
2986    NAME must be NULL.  ADDEND is an expression for the addend.  */
2987
2988 void
2989 lang_add_reloc (reloc, howto, section, name, addend)
2990      bfd_reloc_code_real_type reloc;
2991      reloc_howto_type *howto;
2992      asection *section;
2993      const char *name;
2994      union etree_union *addend;
2995 {
2996   lang_reloc_statement_type *p = new_stat (lang_reloc_statement, stat_ptr);
2997
2998   p->reloc = reloc;
2999   p->howto = howto;
3000   p->section = section;
3001   p->name = name;
3002   p->addend_exp = addend;
3003
3004   p->addend_value = 0;
3005   p->output_section = NULL;
3006   p->output_vma = 0;
3007 }
3008
3009 void
3010 lang_add_assignment (exp)
3011      etree_type * exp;
3012 {
3013   lang_assignment_statement_type *new = new_stat (lang_assignment_statement,
3014                                                   stat_ptr);
3015
3016   new->exp = exp;
3017 }
3018
3019 void
3020 lang_add_attribute (attribute)
3021      enum statement_enum attribute;
3022 {
3023   new_statement (attribute, sizeof (lang_statement_union_type), stat_ptr);
3024 }
3025
3026 void
3027 lang_startup (name)
3028      CONST char *name;
3029 {
3030   if (startup_file != (char *) NULL)
3031     {
3032       einfo ("%P%Fmultiple STARTUP files\n");
3033     }
3034   first_file->filename = name;
3035   first_file->local_sym_name = name;
3036   first_file->real = true;
3037
3038   startup_file = name;
3039 }
3040
3041 void
3042 lang_float (maybe)
3043      boolean maybe;
3044 {
3045   lang_float_flag = maybe;
3046 }
3047
3048 void
3049 lang_leave_output_section_statement (fill, memspec)
3050      bfd_vma fill;
3051      CONST char *memspec;
3052 {
3053   current_section->fill = fill;
3054   current_section->region = lang_memory_region_lookup (memspec);
3055   stat_ptr = &statement_list;
3056 }
3057
3058 /*
3059  Create an absolute symbol with the given name with the value of the
3060  address of first byte of the section named.
3061
3062  If the symbol already exists, then do nothing.
3063 */
3064 void
3065 lang_abs_symbol_at_beginning_of (secname, name)
3066      const char *secname;
3067      const char *name;
3068 {
3069   struct bfd_link_hash_entry *h;
3070
3071   h = bfd_link_hash_lookup (link_info.hash, name, true, true, true);
3072   if (h == (struct bfd_link_hash_entry *) NULL)
3073     einfo ("%P%F: bfd_link_hash_lookup failed: %E\n");
3074
3075   if (h->type == bfd_link_hash_new
3076       || h->type == bfd_link_hash_undefined)
3077     {
3078       asection *sec;
3079
3080       h->type = bfd_link_hash_defined;
3081
3082       sec = bfd_get_section_by_name (output_bfd, secname);
3083       if (sec == (asection *) NULL)
3084         h->u.def.value = 0;
3085       else
3086         h->u.def.value = bfd_get_section_vma (output_bfd, sec);
3087
3088       h->u.def.section = bfd_abs_section_ptr;
3089     }
3090 }
3091
3092 /*
3093  Create an absolute symbol with the given name with the value of the
3094  address of the first byte after the end of the section named.
3095
3096  If the symbol already exists, then do nothing.
3097 */
3098 void
3099 lang_abs_symbol_at_end_of (secname, name)
3100      const char *secname;
3101      const char *name;
3102 {
3103   struct bfd_link_hash_entry *h;
3104
3105   h = bfd_link_hash_lookup (link_info.hash, name, true, true, true);
3106   if (h == (struct bfd_link_hash_entry *) NULL)
3107     einfo ("%P%F: bfd_link_hash_lookup failed: %E\n");
3108
3109   if (h->type == bfd_link_hash_new
3110       || h->type == bfd_link_hash_undefined)
3111     {
3112       asection *sec;
3113
3114       h->type = bfd_link_hash_defined;
3115
3116       sec = bfd_get_section_by_name (output_bfd, secname);
3117       if (sec == (asection *) NULL)
3118         h->u.def.value = 0;
3119       else
3120         h->u.def.value = (bfd_get_section_vma (output_bfd, sec)
3121                           + bfd_section_size (output_bfd, sec));
3122
3123       h->u.def.section = bfd_abs_section_ptr;
3124     }
3125 }
3126
3127 void
3128 lang_statement_append (list, element, field)
3129      lang_statement_list_type * list;
3130      lang_statement_union_type * element;
3131      lang_statement_union_type ** field;
3132 {
3133   *(list->tail) = element;
3134   list->tail = field;
3135 }
3136
3137 /* Set the output format type.  -oformat overrides scripts.  */
3138
3139 void
3140 lang_add_output_format (format, big, little, from_script)
3141      const char *format;
3142      const char *big;
3143      const char *little;
3144      int from_script;
3145 {
3146   if (output_target == NULL || !from_script)
3147     {
3148       if (command_line.endian == ENDIAN_BIG
3149           && big != NULL)
3150         format = big;
3151       else if (command_line.endian == ENDIAN_LITTLE
3152                && little != NULL)
3153         format = little;
3154
3155       output_target = format;
3156     }
3157 }
3158
3159 /* Enter a group.  This creates a new lang_group_statement, and sets
3160    stat_ptr to build new statements within the group.  */
3161
3162 void
3163 lang_enter_group ()
3164 {
3165   lang_group_statement_type *g;
3166
3167   g = new_stat (lang_group_statement, stat_ptr);
3168   lang_list_init (&g->children);
3169   stat_ptr = &g->children;
3170 }
3171
3172 /* Leave a group.  This just resets stat_ptr to start writing to the
3173    regular list of statements again.  Note that this will not work if
3174    groups can occur inside anything else which can adjust stat_ptr,
3175    but currently they can't.  */
3176
3177 void
3178 lang_leave_group ()
3179 {
3180   stat_ptr = &statement_list;
3181 }
3182
3183 /* Add a new program header.  This is called for each entry in a PHDRS
3184    command in a linker script.  */
3185
3186 void
3187 lang_new_phdr (name, type, filehdr, phdrs, at, flags)
3188      const char *name;
3189      etree_type *type;
3190      boolean filehdr;
3191      boolean phdrs;
3192      etree_type *at;
3193      etree_type *flags;
3194 {
3195   struct lang_phdr *n, **pp;
3196
3197   n = (struct lang_phdr *) stat_alloc (sizeof (struct lang_phdr));
3198   n->next = NULL;
3199   n->name = name;
3200   n->type = exp_get_value_int (type, 0, "program header type",
3201                                lang_final_phase_enum);
3202   n->filehdr = filehdr;
3203   n->phdrs = phdrs;
3204   n->at = at;
3205   n->flags = flags;
3206
3207   for (pp = &lang_phdr_list; *pp != NULL; pp = &(*pp)->next)
3208     ;
3209   *pp = n;
3210 }
3211
3212 /* Record that a section should be placed in a phdr.  */
3213
3214 void
3215 lang_section_in_phdr (name)
3216      const char *name;
3217 {
3218   struct lang_output_section_phdr_list *n;
3219
3220   n = ((struct lang_output_section_phdr_list *)
3221        stat_alloc (sizeof (struct lang_output_section_phdr_list)));
3222   n->name = name;
3223   n->used = false;
3224   n->next = current_section->phdrs;
3225   current_section->phdrs = n;
3226 }
3227
3228 /* Record the program header information in the output BFD.  FIXME: We
3229    should not be calling an ELF specific function here.  */
3230
3231 static void
3232 lang_record_phdrs ()
3233 {
3234   unsigned int alc;
3235   asection **secs;
3236   struct lang_output_section_phdr_list *last;
3237   struct lang_phdr *l;
3238   lang_statement_union_type *u;
3239
3240   alc = 10;
3241   secs = xmalloc (alc * sizeof (asection *));
3242   last = NULL;
3243   for (l = lang_phdr_list; l != NULL; l = l->next)
3244     {
3245       unsigned int c;
3246       flagword flags;
3247       bfd_vma at;
3248
3249       c = 0;
3250       for (u = lang_output_section_statement.head;
3251            u != NULL;
3252            u = u->output_section_statement.next)
3253         {
3254           lang_output_section_statement_type *os;
3255           struct lang_output_section_phdr_list *pl;
3256
3257           os = &u->output_section_statement;
3258
3259           pl = os->phdrs;
3260           if (pl != NULL)
3261             last = pl;
3262           else
3263             {
3264               if (! os->loadable
3265                   || os->bfd_section == NULL
3266                   || (os->bfd_section->flags & SEC_ALLOC) == 0)
3267                 continue;
3268               pl = last;
3269             }
3270
3271           if (os->bfd_section == NULL)
3272             continue;
3273
3274           for (; pl != NULL; pl = pl->next)
3275             {
3276               if (strcmp (pl->name, l->name) == 0)
3277                 {
3278                   if (c >= alc)
3279                     {
3280                       alc *= 2;
3281                       secs = xrealloc (secs, alc * sizeof (asection *));
3282                     }
3283                   secs[c] = os->bfd_section;
3284                   ++c;
3285                   pl->used = true;
3286                 }
3287             }
3288         }
3289
3290       if (l->flags == NULL)
3291         flags = 0;
3292       else
3293         flags = exp_get_vma (l->flags, 0, "phdr flags",
3294                              lang_final_phase_enum);
3295
3296       if (l->at == NULL)
3297         at = 0;
3298       else
3299         at = exp_get_vma (l->at, 0, "phdr load address",
3300                           lang_final_phase_enum);
3301
3302       if (! bfd_record_phdr (output_bfd, l->type,
3303                              l->flags == NULL ? false : true,
3304                              flags,
3305                              l->at == NULL ? false : true,
3306                              at, l->filehdr, l->phdrs, c, secs))
3307         einfo ("%F%P: bfd_record_phdr failed: %E\n");
3308     }
3309
3310   free (secs);
3311
3312   /* Make sure all the phdr assignments succeeded.  */
3313   for (u = lang_output_section_statement.head;
3314        u != NULL;
3315        u = u->output_section_statement.next)
3316     {
3317       struct lang_output_section_phdr_list *pl;
3318
3319       if (u->output_section_statement.bfd_section == NULL)
3320         continue;
3321
3322       for (pl = u->output_section_statement.phdrs;
3323            pl != NULL;
3324            pl = pl->next)
3325         if (! pl->used && strcmp (pl->name, "NONE") != 0)
3326           einfo ("%X%P: section `%s' assigned to non-existent phdr `%s'\n",
3327                  u->output_section_statement.name, pl->name);
3328     }
3329 }