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              --ian@cygnus.com.  */
 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->section_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       unsigned int power;
2263
2264       for (power = 1; power < 4; 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 < *(unsigned int *) info
2289       && *(unsigned int *) info < 4)
2290     return true;
2291
2292   section = h->u.c.p->section;
2293
2294   /* Increase the size of the section.  */
2295   section->_raw_size = ALIGN_N (section->_raw_size,
2296                                 (bfd_size_type) (1 << power_of_two));
2297
2298   /* Adjust the alignment if necessary.  */
2299   if (power_of_two > section->alignment_power)
2300     section->alignment_power = power_of_two;
2301
2302   /* Change the symbol from common to defined.  */
2303   h->type = bfd_link_hash_defined;
2304   h->u.def.section = section;
2305   h->u.def.value = section->_raw_size;
2306
2307   /* Increase the size of the section.  */
2308   section->_raw_size += size;
2309
2310   /* Make sure the section is allocated in memory.  */
2311   section->flags |= SEC_ALLOC;
2312
2313   if (config.map_file != NULL)
2314     fprintf (config.map_file, "Allocating common %s: %lx at %lx %s\n",
2315              h->root.string, (unsigned long) size,
2316              (unsigned long) h->u.def.value, section->owner->filename);
2317
2318   return true;
2319 }
2320
2321 /*
2322 run through the input files and ensure that every input
2323 section has somewhere to go. If one is found without
2324 a destination then create an input request and place it
2325 into the statement tree.
2326 */
2327
2328 static void
2329 lang_place_orphans ()
2330 {
2331   lang_input_statement_type *file;
2332
2333   for (file = (lang_input_statement_type *) file_chain.head;
2334        file != (lang_input_statement_type *) NULL;
2335        file = (lang_input_statement_type *) file->next)
2336     {
2337       asection *s;
2338
2339       for (s = file->the_bfd->sections;
2340            s != (asection *) NULL;
2341            s = s->next)
2342         {
2343           if (s->output_section == (asection *) NULL)
2344             {
2345               /* This section of the file is not attatched, root
2346                  around for a sensible place for it to go */
2347
2348               if (file->just_syms_flag)
2349                 {
2350                   /* We are only retrieving symbol values from this
2351                      file.  We want the symbols to act as though the
2352                      values in the file are absolute.  */
2353                   s->output_section = bfd_abs_section_ptr;
2354                   s->output_offset = s->vma;
2355                 }
2356               else if (file->common_section == s)
2357                 {
2358                   /* This is a lonely common section which must
2359                      have come from an archive. We attatch to the
2360                      section with the wildcard  */
2361                   if (! link_info.relocateable
2362                       && ! command_line.force_common_definition)
2363                     {
2364                       if (default_common_section ==
2365                           (lang_output_section_statement_type *) NULL)
2366                         {
2367                           info_msg ("%P: no [COMMON] command, defaulting to .bss\n");
2368
2369                           default_common_section =
2370                             lang_output_section_statement_lookup (".bss");
2371
2372                         }
2373                       wild_doit (&default_common_section->children, s,
2374                                  default_common_section, file);
2375                     }
2376                 }
2377               else if (ldemul_place_orphan (file, s))
2378                 ;
2379               else
2380                 {
2381                   lang_output_section_statement_type *os =
2382                   lang_output_section_statement_lookup (s->name);
2383
2384                   wild_doit (&os->children, s, os, file);
2385                 }
2386             }
2387         }
2388     }
2389 }
2390
2391
2392 void
2393 lang_set_flags (ptr, flags)
2394      int *ptr;
2395      CONST char *flags;
2396 {
2397   boolean state = false;
2398
2399   *ptr = 0;
2400   while (*flags)
2401     {
2402       if (*flags == '!')
2403         {
2404           state = false;
2405           flags++;
2406         }
2407       else
2408         state = true;
2409       switch (*flags)
2410         {
2411         case 'R':
2412           /*      ptr->flag_read = state; */
2413           break;
2414         case 'W':
2415           /*      ptr->flag_write = state; */
2416           break;
2417         case 'X':
2418           /*      ptr->flag_executable= state;*/
2419           break;
2420         case 'L':
2421         case 'I':
2422           /*      ptr->flag_loadable= state;*/
2423           break;
2424         default:
2425           einfo ("%P%F: invalid syntax in flags\n");
2426           break;
2427         }
2428       flags++;
2429     }
2430 }
2431
2432 /* Call a function on each input file.  This function will be called
2433    on an archive, but not on the elements.  */
2434
2435 void
2436 lang_for_each_input_file (func)
2437      void (*func) PARAMS ((lang_input_statement_type *));
2438 {
2439   lang_input_statement_type *f;
2440
2441   for (f = (lang_input_statement_type *) input_file_chain.head;
2442        f != NULL;
2443        f = (lang_input_statement_type *) f->next_real_file)
2444     func (f);
2445 }
2446
2447 /* Call a function on each file.  The function will be called on all
2448    the elements of an archive which are included in the link, but will
2449    not be called on the archive file itself.  */
2450
2451 void
2452 lang_for_each_file (func)
2453      void (*func) PARAMS ((lang_input_statement_type *));
2454 {
2455   lang_input_statement_type *f;
2456
2457   for (f = (lang_input_statement_type *) file_chain.head;
2458        f != (lang_input_statement_type *) NULL;
2459        f = (lang_input_statement_type *) f->next)
2460     {
2461       func (f);
2462     }
2463 }
2464
2465 #if 0
2466
2467 /* Not used.  */
2468
2469 void
2470 lang_for_each_input_section (func)
2471      void (*func) PARAMS ((bfd * ab, asection * as));
2472 {
2473   lang_input_statement_type *f;
2474
2475   for (f = (lang_input_statement_type *) file_chain.head;
2476        f != (lang_input_statement_type *) NULL;
2477        f = (lang_input_statement_type *) f->next)
2478     {
2479       asection *s;
2480
2481       for (s = f->the_bfd->sections;
2482            s != (asection *) NULL;
2483            s = s->next)
2484         {
2485           func (f->the_bfd, s);
2486         }
2487     }
2488 }
2489
2490 #endif
2491
2492 void
2493 ldlang_add_file (entry)
2494      lang_input_statement_type * entry;
2495 {
2496   bfd **pp;
2497
2498   lang_statement_append (&file_chain,
2499                          (lang_statement_union_type *) entry,
2500                          &entry->next);
2501
2502   /* The BFD linker needs to have a list of all input BFDs involved in
2503      a link.  */
2504   ASSERT (entry->the_bfd->link_next == (bfd *) NULL);
2505   ASSERT (entry->the_bfd != output_bfd);
2506   for (pp = &link_info.input_bfds;
2507        *pp != (bfd *) NULL;
2508        pp = &(*pp)->link_next)
2509     ;
2510   *pp = entry->the_bfd;
2511   entry->the_bfd->usrdata = (PTR) entry;
2512   bfd_set_gp_size (entry->the_bfd, g_switch_value);
2513 }
2514
2515 void
2516 lang_add_output (name, from_script)
2517      CONST char *name;
2518      int from_script;
2519 {
2520   /* Make -o on command line override OUTPUT in script.  */
2521   if (had_output_filename == false || !from_script)
2522     {
2523       output_filename = name;
2524       had_output_filename = true;
2525     }
2526 }
2527
2528
2529 static lang_output_section_statement_type *current_section;
2530
2531 static int topower(x)
2532      int x;
2533 {
2534   unsigned  int i = 1;
2535   int l;
2536   if (x < 0) return -1;
2537   for (l = 0; l < 32; l++)
2538   {
2539     if (i >= x) return l;
2540     i<<=1;
2541   }
2542   return 0;
2543 }
2544 void
2545 lang_enter_output_section_statement (output_section_statement_name,
2546                                      address_exp, flags, block_value,
2547                                      align, subalign, ebase)
2548      const char *output_section_statement_name;
2549      etree_type * address_exp;
2550      int flags;
2551      bfd_vma block_value;
2552      etree_type *align;
2553      etree_type *subalign;
2554      etree_type *ebase;
2555 {
2556   lang_output_section_statement_type *os;
2557
2558   current_section =
2559    os =
2560     lang_output_section_statement_lookup (output_section_statement_name);
2561
2562
2563
2564   /* Add this statement to tree */
2565   /*  add_statement(lang_output_section_statement_enum,
2566       output_section_statement);*/
2567   /* Make next things chain into subchain of this */
2568
2569   if (os->addr_tree ==
2570       (etree_type *) NULL)
2571   {
2572     os->addr_tree =
2573      address_exp;
2574   }
2575   os->flags = flags;
2576   if (flags & SEC_NEVER_LOAD)
2577    os->loadable = 0;
2578   else
2579    os->loadable = 1;
2580   os->block_value = block_value ? block_value : 1;
2581   stat_ptr = &os->children;
2582
2583   os->subsection_alignment = topower(
2584    exp_get_value_int(subalign, -1,
2585                      "subsection alignment",
2586                      0));
2587   os->section_alignment = topower(
2588    exp_get_value_int(align, -1,
2589                      "section alignment", 0));
2590
2591   os->load_base = ebase;
2592 }
2593
2594
2595 void
2596 lang_final ()
2597 {
2598   lang_output_statement_type *new =
2599     new_stat (lang_output_statement, stat_ptr);
2600
2601   new->name = output_filename;
2602 }
2603
2604 /* Reset the current counters in the regions */
2605 static void
2606 reset_memory_regions ()
2607 {
2608   lang_memory_region_type *p = lang_memory_region_list;
2609
2610   for (p = lang_memory_region_list;
2611        p != (lang_memory_region_type *) NULL;
2612        p = p->next)
2613     {
2614       p->old_length = (bfd_size_type) (p->current - p->origin);
2615       p->current = p->origin;
2616     }
2617 }
2618
2619 void
2620 lang_process ()
2621 {
2622   lang_reasonable_defaults ();
2623   current_target = default_target;
2624
2625   lang_for_each_statement (ldlang_open_output); /* Open the output file */
2626
2627   ldemul_create_output_section_statements ();
2628
2629   /* Add to the hash table all undefineds on the command line */
2630   lang_place_undefineds ();
2631
2632   /* Create a bfd for each input file */
2633   current_target = default_target;
2634   open_input_bfds (statement_list.head, false);
2635
2636   ldemul_after_open ();
2637
2638   /* Build all sets based on the information gathered from the input
2639      files.  */
2640   ldctor_build_sets ();
2641
2642   /* Size up the common data */
2643   lang_common ();
2644
2645   /* Run through the contours of the script and attatch input sections
2646      to the correct output sections
2647      */
2648   map_input_to_output_sections (statement_list.head, (char *) NULL,
2649                                 (lang_output_section_statement_type *) NULL);
2650
2651
2652   /* Find any sections not attatched explicitly and handle them */
2653   lang_place_orphans ();
2654
2655   ldemul_before_allocation ();
2656
2657   /* Now run around and relax if we can */
2658   if (command_line.relax)
2659     {
2660       /* First time round is a trial run to get the 'worst case'
2661          addresses of the objects if there was no relaxing.  */
2662       lang_size_sections (statement_list.head,
2663                           abs_output_section,
2664                           &(statement_list.head), 0, (bfd_vma) 0, false);
2665
2666
2667       reset_memory_regions ();
2668
2669       /* Keep relaxing until bfd_relax_section gives up.  */
2670       do
2671         {
2672           relax_again = false;
2673
2674           /* Do all the assignments with our current guesses as to
2675              section sizes.  */
2676           lang_do_assignments (statement_list.head,
2677                                abs_output_section,
2678                                (fill_type) 0, (bfd_vma) 0);
2679
2680           /* Perform another relax pass - this time we know where the
2681              globals are, so can make better guess.  */
2682           lang_size_sections (statement_list.head,
2683                               abs_output_section,
2684                               &(statement_list.head), 0, (bfd_vma) 0, true);
2685         }
2686       while (relax_again);
2687     }
2688   else
2689     {
2690       /* Size up the sections.  */
2691       lang_size_sections (statement_list.head,
2692                           abs_output_section,
2693                           &(statement_list.head), 0, (bfd_vma) 0, false);
2694     }
2695
2696   /* See if anything special should be done now we know how big
2697      everything is.  */
2698   ldemul_after_allocation ();
2699
2700   /* Do all the assignments, now that we know the final restingplaces
2701      of all the symbols */
2702
2703   lang_do_assignments (statement_list.head,
2704                        abs_output_section,
2705                        (fill_type) 0, (bfd_vma) 0);
2706
2707   /* Make sure that we're not mixing architectures */
2708
2709   lang_check ();
2710
2711   /* Final stuffs */
2712
2713   ldemul_finish ();
2714   lang_finish ();
2715 }
2716
2717 /* EXPORTED TO YACC */
2718
2719 void
2720 lang_add_wild (section_name, filename)
2721      CONST char *CONST section_name;
2722      CONST char *CONST filename;
2723 {
2724   lang_wild_statement_type *new = new_stat (lang_wild_statement,
2725                                             stat_ptr);
2726
2727   if (section_name != (char *) NULL && strcmp (section_name, "COMMON") == 0)
2728     {
2729       placed_commons = true;
2730     }
2731   if (filename != (char *) NULL)
2732     {
2733       lang_has_input_file = true;
2734     }
2735   new->section_name = section_name;
2736   new->filename = filename;
2737   lang_list_init (&new->children);
2738 }
2739
2740 void
2741 lang_section_start (name, address)
2742      CONST char *name;
2743      etree_type * address;
2744 {
2745   lang_address_statement_type *ad = new_stat (lang_address_statement, stat_ptr);
2746
2747   ad->section_name = name;
2748   ad->address = address;
2749 }
2750
2751 /* Set the start symbol to NAME.  CMDLINE is nonzero if this is called
2752    because of a -e argument on the command line, or zero if this is
2753    called by ENTRY in a linker script.  Command line arguments take
2754    precedence.  */
2755
2756 void
2757 lang_add_entry (name, cmdline)
2758      CONST char *name;
2759      int cmdline;
2760 {
2761   static int from_cmdline;
2762
2763   if (entry_symbol == NULL
2764       || cmdline
2765       || ! from_cmdline)
2766     {
2767       entry_symbol = name;
2768       from_cmdline = cmdline;
2769     }
2770 }
2771
2772 void
2773 lang_add_target (name)
2774      CONST char *name;
2775 {
2776   lang_target_statement_type *new = new_stat (lang_target_statement,
2777                                               stat_ptr);
2778
2779   new->target = name;
2780
2781 }
2782
2783 void
2784 lang_add_map (name)
2785      CONST char *name;
2786 {
2787   while (*name)
2788     {
2789       switch (*name)
2790         {
2791           case 'F':
2792           map_option_f = true;
2793           break;
2794         }
2795       name++;
2796     }
2797 }
2798
2799 void
2800 lang_add_fill (exp)
2801      int exp;
2802 {
2803   lang_fill_statement_type *new = new_stat (lang_fill_statement,
2804                                             stat_ptr);
2805
2806   new->fill = exp;
2807 }
2808
2809 void
2810 lang_add_data (type, exp)
2811      int type;
2812      union etree_union *exp;
2813 {
2814
2815   lang_data_statement_type *new = new_stat (lang_data_statement,
2816                                             stat_ptr);
2817
2818   new->exp = exp;
2819   new->type = type;
2820
2821 }
2822
2823 /* Create a new reloc statement.  RELOC is the BFD relocation type to
2824    generate.  HOWTO is the corresponding howto structure (we could
2825    look this up, but the caller has already done so).  SECTION is the
2826    section to generate a reloc against, or NAME is the name of the
2827    symbol to generate a reloc against.  Exactly one of SECTION and
2828    NAME must be NULL.  ADDEND is an expression for the addend.  */
2829
2830 void
2831 lang_add_reloc (reloc, howto, section, name, addend)
2832      bfd_reloc_code_real_type reloc;
2833      reloc_howto_type *howto;
2834      asection *section;
2835      const char *name;
2836      union etree_union *addend;
2837 {
2838   lang_reloc_statement_type *p = new_stat (lang_reloc_statement, stat_ptr);
2839
2840   p->reloc = reloc;
2841   p->howto = howto;
2842   p->section = section;
2843   p->name = name;
2844   p->addend_exp = addend;
2845
2846   p->addend_value = 0;
2847   p->output_section = NULL;
2848   p->output_vma = 0;
2849 }
2850
2851 void
2852 lang_add_assignment (exp)
2853      etree_type * exp;
2854 {
2855   lang_assignment_statement_type *new = new_stat (lang_assignment_statement,
2856                                                   stat_ptr);
2857
2858   new->exp = exp;
2859 }
2860
2861 void
2862 lang_add_attribute (attribute)
2863      enum statement_enum attribute;
2864 {
2865   new_statement (attribute, sizeof (lang_statement_union_type), stat_ptr);
2866 }
2867
2868 void
2869 lang_startup (name)
2870      CONST char *name;
2871 {
2872   if (startup_file != (char *) NULL)
2873     {
2874       einfo ("%P%Fmultiple STARTUP files\n");
2875     }
2876   first_file->filename = name;
2877   first_file->local_sym_name = name;
2878   first_file->real = true;
2879
2880   startup_file = name;
2881 }
2882
2883 void
2884 lang_float (maybe)
2885      boolean maybe;
2886 {
2887   lang_float_flag = maybe;
2888 }
2889
2890 void
2891 lang_leave_output_section_statement (fill, memspec)
2892      bfd_vma fill;
2893      CONST char *memspec;
2894 {
2895   current_section->fill = fill;
2896   current_section->region = lang_memory_region_lookup (memspec);
2897   stat_ptr = &statement_list;
2898 }
2899
2900 /*
2901  Create an absolute symbol with the given name with the value of the
2902  address of first byte of the section named.
2903
2904  If the symbol already exists, then do nothing.
2905 */
2906 void
2907 lang_abs_symbol_at_beginning_of (secname, name)
2908      const char *secname;
2909      const char *name;
2910 {
2911   struct bfd_link_hash_entry *h;
2912
2913   h = bfd_link_hash_lookup (link_info.hash, name, true, true, true);
2914   if (h == (struct bfd_link_hash_entry *) NULL)
2915     einfo ("%P%F: bfd_link_hash_lookup failed: %E\n");
2916
2917   if (h->type == bfd_link_hash_new
2918       || h->type == bfd_link_hash_undefined)
2919     {
2920       asection *sec;
2921
2922       h->type = bfd_link_hash_defined;
2923
2924       sec = bfd_get_section_by_name (output_bfd, secname);
2925       if (sec == (asection *) NULL)
2926         h->u.def.value = 0;
2927       else
2928         h->u.def.value = bfd_get_section_vma (output_bfd, sec);
2929
2930       h->u.def.section = bfd_abs_section_ptr;
2931     }
2932 }
2933
2934 /*
2935  Create an absolute symbol with the given name with the value of the
2936  address of the first byte after the end of the section named.
2937
2938  If the symbol already exists, then do nothing.
2939 */
2940 void
2941 lang_abs_symbol_at_end_of (secname, name)
2942      const char *secname;
2943      const char *name;
2944 {
2945   struct bfd_link_hash_entry *h;
2946
2947   h = bfd_link_hash_lookup (link_info.hash, name, true, true, true);
2948   if (h == (struct bfd_link_hash_entry *) NULL)
2949     einfo ("%P%F: bfd_link_hash_lookup failed: %E\n");
2950
2951   if (h->type == bfd_link_hash_new
2952       || h->type == bfd_link_hash_undefined)
2953     {
2954       asection *sec;
2955
2956       h->type = bfd_link_hash_defined;
2957
2958       sec = bfd_get_section_by_name (output_bfd, secname);
2959       if (sec == (asection *) NULL)
2960         h->u.def.value = 0;
2961       else
2962         h->u.def.value = (bfd_get_section_vma (output_bfd, sec)
2963                           + bfd_section_size (output_bfd, sec));
2964
2965       h->u.def.section = bfd_abs_section_ptr;
2966     }
2967 }
2968
2969 void
2970 lang_statement_append (list, element, field)
2971      lang_statement_list_type * list;
2972      lang_statement_union_type * element;
2973      lang_statement_union_type ** field;
2974 {
2975   *(list->tail) = element;
2976   list->tail = field;
2977 }
2978
2979 /* Set the output format type.  -oformat overrides scripts.  */
2980
2981 void
2982 lang_add_output_format (format, big, little, from_script)
2983      const char *format;
2984      const char *big;
2985      const char *little;
2986      int from_script;
2987 {
2988   if (output_target == NULL || !from_script)
2989     {
2990       if (command_line.endian == ENDIAN_BIG
2991           && big != NULL)
2992         format = big;
2993       else if (command_line.endian == ENDIAN_LITTLE
2994                && little != NULL)
2995         format = little;
2996
2997       output_target = format;
2998     }
2999 }
3000
3001 /* Enter a group.  This creates a new lang_group_statement, and sets
3002    stat_ptr to build new statements within the group.  */
3003
3004 void
3005 lang_enter_group ()
3006 {
3007   lang_group_statement_type *g;
3008
3009   g = new_stat (lang_group_statement, stat_ptr);
3010   lang_list_init (&g->children);
3011   stat_ptr = &g->children;
3012 }
3013
3014 /* Leave a group.  This just resets stat_ptr to start writing to the
3015    regular list of statements again.  Note that this will not work if
3016    groups can occur inside anything else which can adjust stat_ptr,
3017    but currently they can't.  */
3018
3019 void
3020 lang_leave_group ()
3021 {
3022   stat_ptr = &statement_list;
3023 }