ld/ldlang.c

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