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