ld/mpw-elfmips.c

   1 /* This file is is generated by a shell script.  DO NOT EDIT! */
   2
   3 /* 32 bit ELF emulation code for elf32ebmip
   4    Copyright 1991, 1993, 1994, 1995, 1996, 1997, 1999, 2000, 2001
   5    Free Software Foundation, Inc.
   6    Written by Steve Chamberlain <sac@cygnus.com>
   7    ELF support by Ian Lance Taylor <ian@cygnus.com>
   8
   9 This file is part of GLD, the Gnu Linker.
  10
  11 This program is free software; you can redistribute it and/or modify
  12 it under the terms of the GNU General Public License as published by
  13 the Free Software Foundation; either version 2 of the License, or
  14 (at your option) any later version.
  15
  16 This program is distributed in the hope that it will be useful,
  17 but WITHOUT ANY WARRANTY; without even the implied warranty of
  18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19 GNU General Public License for more details.
  20
  21 You should have received a copy of the GNU General Public License
  22 along with this program; if not, write to the Free Software
  23 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  24
  25 #define TARGET_IS_elf32ebmip
  26
  27 #include "bfd.h"
  28 #include "sysdep.h"
  29 #include "safe-ctype.h"
  30
  31 #include "bfdlink.h"
  32
  33 #include "ld.h"
  34 #include "ldmain.h"
  35 #include "ldmisc.h"
  36 #include "ldexp.h"
  37 #include "ldlang.h"
  38 #include "ldgram.h"
  39 #include "ldfile.h"
  40 #include "ldemul.h"
  41
  42 static void gldelf32ebmip_before_parse PARAMS ((void));
  43 static boolean gldelf32ebmip_open_dynamic_archive
  44   PARAMS ((const char *, search_dirs_type *, lang_input_statement_type *));
  45 static void gldelf32ebmip_after_open PARAMS ((void));
  46 static void gldelf32ebmip_check_needed
  47   PARAMS ((lang_input_statement_type *));
  48 static void gldelf32ebmip_stat_needed
  49   PARAMS ((lang_input_statement_type *));
  50 static boolean gldelf32ebmip_search_needed
  51   PARAMS ((const char *, const char *));
  52 static boolean gldelf32ebmip_try_needed PARAMS ((const char *));
  53 static void gldelf32ebmip_before_allocation PARAMS ((void));
  54 static void gldelf32ebmip_find_statement_assignment
  55   PARAMS ((lang_statement_union_type *));
  56 static void gldelf32ebmip_find_exp_assignment PARAMS ((etree_type *));
  57 static boolean gldelf32ebmip_place_orphan
  58   PARAMS ((lang_input_statement_type *, asection *));
  59 static void gldelf32ebmip_place_section
  60   PARAMS ((lang_statement_union_type *));
  61 static char *gldelf32ebmip_get_script PARAMS ((int *isfile));
  62
  63 static void
  64 gldelf32ebmip_before_parse()
  65 {
  66   ldfile_output_architecture = bfd_arch_mips;
  67   config.dynamic_link = true;
  68 }
  69
  70 /* Try to open a dynamic archive.  This is where we know that ELF
  71    dynamic libraries have an extension of .so.  */
  72
  73 static boolean
  74 gldelf32ebmip_open_dynamic_archive (arch, search, entry)
  75      const char *arch;
  76      search_dirs_type *search;
  77      lang_input_statement_type *entry;
  78 {
  79   const char *filename;
  80   char *string;
  81
  82   if (! entry->is_archive)
  83     return false;
  84
  85   filename = entry->filename;
  86
  87   string = (char *) xmalloc (strlen (search->name)
  88                              + strlen (filename)
  89                              + strlen (arch)
  90                              + sizeof "/lib.so");
  91
  92   sprintf (string, "%s/lib%s%s.so", search->name, filename, arch);
  93
  94   if (! ldfile_try_open_bfd (string, entry))
  95     {
  96       free (string);
  97       return false;
  98     }
  99
 100   entry->filename = string;
 101
 102   /* We have found a dynamic object to include in the link.  The ELF
 103      backend linker will create a DT_NEEDED entry in the .dynamic
 104      section naming this file.  If this file includes a DT_SONAME
 105      entry, it will be used.  Otherwise, the ELF linker will just use
 106      the name of the file.  For an archive found by searching, like
 107      this one, the DT_NEEDED entry should consist of just the name of
 108      the file, without the path information used to find it.  Note
 109      that we only need to do this if we have a dynamic object; an
 110      archive will never be referenced by a DT_NEEDED entry.
 111
 112      FIXME: This approach--using bfd_elf_set_dt_needed_name--is not
 113      very pretty.  I haven't been able to think of anything that is
 114      pretty, though.  */
 115   if (bfd_check_format (entry->the_bfd, bfd_object)
 116       && (entry->the_bfd->flags & DYNAMIC) != 0)
 117     {
 118       char *needed_name;
 119
 120       ASSERT (entry->is_archive && entry->search_dirs_flag);
 121       needed_name = (char *) xmalloc (strlen (filename)
 122                                       + strlen (arch)
 123                                       + sizeof "lib.so");
 124       sprintf (needed_name, "lib%s%s.so", filename, arch);
 125       bfd_elf_set_dt_needed_name (entry->the_bfd, needed_name);
 126     }
 127
 128   return true;
 129 }
 130
 131
 132 /* These variables are required to pass information back and forth
 133    between after_open and check_needed and stat_needed.  */
 134
 135 static struct bfd_link_needed_list *global_needed;
 136 static struct stat global_stat;
 137 static boolean global_found;
 138
 139 /* This is called after all the input files have been opened.  */
 140
 141 static void
 142 gldelf32ebmip_after_open ()
 143 {
 144   struct bfd_link_needed_list *needed, *l;
 145
 146   /* We only need to worry about this when doing a final link.  */
 147   if (link_info.relocateable || link_info.shared)
 148     return;
 149
 150   /* Get the list of files which appear in DT_NEEDED entries in
 151      dynamic objects included in the link (often there will be none).
 152      For each such file, we want to track down the corresponding
 153      library, and include the symbol table in the link.  This is what
 154      the runtime dynamic linker will do.  Tracking the files down here
 155      permits one dynamic object to include another without requiring
 156      special action by the person doing the link.  Note that the
 157      needed list can actually grow while we are stepping through this
 158      loop.  */
 159   needed = bfd_elf_get_needed_list (output_bfd, &link_info);
 160   for (l = needed; l != NULL; l = l->next)
 161     {
 162       struct bfd_link_needed_list *ll;
 163       const char *lib_path;
 164       size_t len;
 165       search_dirs_type *search;
 166
 167       /* If we've already seen this file, skip it.  */
 168       for (ll = needed; ll != l; ll = ll->next)
 169         if (strcmp (ll->name, l->name) == 0)
 170           break;
 171       if (ll != l)
 172         continue;
 173
 174       /* See if this file was included in the link explicitly.  */
 175       global_needed = l;
 176       global_found = false;
 177       lang_for_each_input_file (gldelf32ebmip_check_needed);
 178       if (global_found)
 179         continue;
 180
 181       /* We need to find this file and include the symbol table.  We
 182          want to search for the file in the same way that the dynamic
 183          linker will search.  That means that we want to use
 184          rpath_link, rpath, then the environment variable
 185          LD_LIBRARY_PATH (native only), then the linker script
 186          LIB_SEARCH_DIRS.  We do not search using the -L arguments.  */
 187       if (gldelf32ebmip_search_needed (command_line.rpath_link,
 188                                               l->name))
 189         continue;
 190       if (gldelf32ebmip_search_needed (command_line.rpath, l->name))
 191         continue;
 192       if (command_line.rpath_link == NULL
 193           && command_line.rpath == NULL)
 194         {
 195           lib_path = (const char *) getenv ("LD_RUN_PATH");
 196           if (gldelf32ebmip_search_needed (lib_path, l->name))
 197             continue;
 198         }
 199       len = strlen (l->name);
 200       for (search = search_head; search != NULL; search = search->next)
 201         {
 202           char *filename;
 203
 204           if (search->cmdline)
 205             continue;
 206           filename = (char *) xmalloc (strlen (search->name) + len + 2);
 207           sprintf (filename, "%s/%s", search->name, l->name);
 208           if (gldelf32ebmip_try_needed (filename))
 209             break;
 210           free (filename);
 211         }
 212       if (search != NULL)
 213         continue;
 214
 215       einfo (_("%P: warning: %s, needed by %B, not found\n"),
 216              l->name, l->by);
 217     }
 218 }
 219
 220 /* Search for a needed file in a path.  */
 221
 222 static boolean
 223 gldelf32ebmip_search_needed (path, name)
 224      const char *path;
 225      const char *name;
 226 {
 227   const char *s;
 228   size_t len;
 229
 230   if (path == NULL || *path == '\0')
 231     return false;
 232   len = strlen (name);
 233   while (1)
 234     {
 235       char *filename, *sset;
 236
 237       s = strchr (path, ':');
 238       if (s == NULL)
 239         s = path + strlen (path);
 240
 241       filename = (char *) xmalloc (s - path + len + 2);
 242       if (s == path)
 243         sset = filename;
 244       else
 245         {
 246           memcpy (filename, path, s - path);
 247           filename[s - path] = '/';
 248           sset = filename + (s - path) + 1;
 249         }
 250       strcpy (sset, name);
 251
 252       if (gldelf32ebmip_try_needed (filename))
 253         return true;
 254
 255       free (filename);
 256
 257       if (*s == '\0')
 258         break;
 259       path = s + 1;
 260     }
 261
 262   return false;
 263 }
 264
 265 /* This function is called for each possible name for a dynamic object
 266    named by a DT_NEEDED entry.  */
 267
 268 static boolean
 269 gldelf32ebmip_try_needed (name)
 270      const char *name;
 271 {
 272   bfd *abfd;
 273
 274   abfd = bfd_openr (name, bfd_get_target (output_bfd));
 275   if (abfd == NULL)
 276     return false;
 277   if (! bfd_check_format (abfd, bfd_object))
 278     {
 279       (void) bfd_close (abfd);
 280       return false;
 281     }
 282   if ((bfd_get_file_flags (abfd) & DYNAMIC) == 0)
 283     {
 284       (void) bfd_close (abfd);
 285       return false;
 286     }
 287
 288   /* We've found a dynamic object matching the DT_NEEDED entry.  */
 289
 290   /* We have already checked that there is no other input file of the
 291      same name.  We must now check again that we are not including the
 292      same file twice.  We need to do this because on many systems
 293      libc.so is a symlink to, e.g., libc.so.1.  The SONAME entry will
 294      reference libc.so.1.  If we have already included libc.so, we
 295      don't want to include libc.so.1 if they are the same file, and we
 296      can only check that using stat.  */
 297
 298   if (bfd_stat (abfd, &global_stat) != 0)
 299     einfo (_("%F%P:%B: bfd_stat failed: %E\n"), abfd);
 300   global_found = false;
 301   lang_for_each_input_file (gldelf32ebmip_stat_needed);
 302   if (global_found)
 303     {
 304       /* Return true to indicate that we found the file, even though
 305          we aren't going to do anything with it.  */
 306       return true;
 307     }
 308
 309   /* Tell the ELF backend that don't want the output file to have a
 310      DT_NEEDED entry for this file.  */
 311   bfd_elf_set_dt_needed_name (abfd, "");
 312
 313   /* Add this file into the symbol table.  */
 314   if (! bfd_link_add_symbols (abfd, &link_info))
 315     einfo (_("%F%B: could not read symbols: %E\n"), abfd);
 316
 317   return true;
 318 }
 319
 320 /* See if an input file matches a DT_NEEDED entry by name.  */
 321
 322 static void
 323 gldelf32ebmip_check_needed (s)
 324      lang_input_statement_type *s;
 325 {
 326   if (global_found)
 327     return;
 328
 329   if (s->filename != NULL
 330       && strcmp (s->filename, global_needed->name) == 0)
 331     {
 332       global_found = true;
 333       return;
 334     }
 335
 336   if (s->the_bfd != NULL)
 337     {
 338       const char *soname;
 339
 340       soname = bfd_elf_get_dt_soname (s->the_bfd);
 341       if (soname != NULL
 342           && strcmp (soname, global_needed->name) == 0)
 343         {
 344           global_found = true;
 345           return;
 346         }
 347     }
 348
 349   if (s->search_dirs_flag
 350       && s->filename != NULL
 351       && strchr (global_needed->name, '/') == NULL)
 352     {
 353       const char *f;
 354
 355       f = strrchr (s->filename, '/');
 356       if (f != NULL
 357           && strcmp (f + 1, global_needed->name) == 0)
 358         {
 359           global_found = true;
 360           return;
 361         }
 362     }
 363 }
 364
 365 /* See if an input file matches a DT_NEEDED entry by running stat on
 366    the file.  */
 367
 368 static void
 369 gldelf32ebmip_stat_needed (s)
 370      lang_input_statement_type *s;
 371 {
 372   struct stat st;
 373   const char *suffix;
 374   const char *soname;
 375   const char *f;
 376
 377   if (global_found)
 378     return;
 379   if (s->the_bfd == NULL)
 380     return;
 381
 382   if (bfd_stat (s->the_bfd, &st) != 0)
 383     {
 384       einfo (_("%P:%B: bfd_stat failed: %E\n"), s->the_bfd);
 385       return;
 386     }
 387
 388   if (st.st_dev == global_stat.st_dev
 389       && st.st_ino == global_stat.st_ino)
 390     {
 391       global_found = true;
 392       return;
 393     }
 394
 395   /* We issue a warning if it looks like we are including two
 396      different versions of the same shared library.  For example,
 397      there may be a problem if -lc picks up libc.so.6 but some other
 398      shared library has a DT_NEEDED entry of libc.so.5.  This is a
 399      hueristic test, and it will only work if the name looks like
 400      NAME.so.VERSION.  FIXME: Depending on file names is error-prone.
 401      If we really want to issue warnings about mixing version numbers
 402      of shared libraries, we need to find a better way.  */
 403
 404   if (strchr (global_needed->name, '/') != NULL)
 405     return;
 406   suffix = strstr (global_needed->name, ".so.");
 407   if (suffix == NULL)
 408     return;
 409   suffix += sizeof ".so." - 1;
 410
 411   soname = bfd_elf_get_dt_soname (s->the_bfd);
 412   if (soname == NULL)
 413     soname = s->filename;
 414
 415   f = strrchr (soname, '/');
 416   if (f != NULL)
 417     ++f;
 418   else
 419     f = soname;
 420
 421   if (strncmp (f, global_needed->name, suffix - global_needed->name) == 0)
 422     einfo (_("%P: warning: %s, needed by %B, may conflict with %s\n"),
 423            global_needed->name, global_needed->by, f);
 424 }
 425
 426 /* This is called after the sections have been attached to output
 427    sections, but before any sizes or addresses have been set.  */
 428
 429 static void
 430 gldelf32ebmip_before_allocation ()
 431 {
 432   const char *rpath;
 433   asection *sinterp;
 434
 435   /* If we are going to make any variable assignments, we need to let
 436      the ELF backend know about them in case the variables are
 437      referred to by dynamic objects.  */
 438   lang_for_each_statement (gldelf32ebmip_find_statement_assignment);
 439
 440   /* Let the ELF backend work out the sizes of any sections required
 441      by dynamic linking.  */
 442   rpath = command_line.rpath;
 443   if (rpath == NULL)
 444     rpath = (const char *) getenv ("LD_RUN_PATH");
 445   if (! (bfd_elf32_size_dynamic_sections
 446          (output_bfd, command_line.soname, rpath,
 447           command_line.filter_shlib,
 448           (const char * const *) command_line.auxiliary_filters,
 449           &link_info, &sinterp, lang_elf_version_info)))
 450     einfo (_("%P%F: failed to set dynamic section sizes: %E\n"));
 451
 452   /* Let the user override the dynamic linker we are using.  */
 453   if (command_line.interpreter != NULL
 454       && sinterp != NULL)
 455     {
 456       sinterp->contents = (bfd_byte *) command_line.interpreter;
 457       sinterp->_raw_size = strlen (command_line.interpreter) + 1;
 458     }
 459
 460   /* Look for any sections named .gnu.warning.  As a GNU extensions,
 461      we treat such sections as containing warning messages.  We print
 462      out the warning message, and then zero out the section size so
 463      that it does not get copied into the output file.  */
 464
 465   {
 466     LANG_FOR_EACH_INPUT_STATEMENT (is)
 467       {
 468         asection *s;
 469         bfd_size_type sz;
 470         char *msg;
 471         boolean ret;
 472
 473         if (is->just_syms_flag)
 474           continue;
 475
 476         s = bfd_get_section_by_name (is->the_bfd, ".gnu.warning");
 477         if (s == NULL)
 478           continue;
 479
 480         sz = bfd_section_size (is->the_bfd, s);
 481         msg = xmalloc ((size_t) sz + 1);
 482         if (! bfd_get_section_contents (is->the_bfd, s, msg, (file_ptr) 0, sz))
 483           einfo (_("%F%B: Can't read contents of section .gnu.warning: %E\n"),
 484                  is->the_bfd);
 485         msg[sz] = '\0';
 486         ret = link_info.callbacks->warning (&link_info, msg,
 487                                             (const char *) NULL,
 488                                             is->the_bfd, (asection *) NULL,
 489                                             (bfd_vma) 0);
 490         ASSERT (ret);
 491         free (msg);
 492
 493         /* Clobber the section size, so that we don't waste copying the
 494            warning into the output file.  */
 495         s->_raw_size = 0;
 496       }
 497   }
 498 }
 499
 500 /* This is called by the before_allocation routine via
 501    lang_for_each_statement.  It locates any assignment statements, and
 502    tells the ELF backend about them, in case they are assignments to
 503    symbols which are referred to by dynamic objects.  */
 504
 505 static void
 506 gldelf32ebmip_find_statement_assignment (s)
 507      lang_statement_union_type *s;
 508 {
 509   if (s->header.type == lang_assignment_statement_enum)
 510     gldelf32ebmip_find_exp_assignment (s->assignment_statement.exp);
 511 }
 512
 513 /* Look through an expression for an assignment statement.  */
 514
 515 static void
 516 gldelf32ebmip_find_exp_assignment (exp)
 517      etree_type *exp;
 518 {
 519   struct bfd_link_hash_entry *h;
 520
 521   switch (exp->type.node_class)
 522     {
 523     case etree_provide:
 524     case etree_provided:
 525       h = bfd_link_hash_lookup (link_info.hash, exp->assign.dst,
 526                                 false, false, false);
 527       if (h == NULL)
 528         break;
 529
 530       /* We call record_link_assignment even if the symbol is defined.
 531          This is because if it is defined by a dynamic object, we
 532          actually want to use the value defined by the linker script,
 533          not the value from the dynamic object (because we are setting
 534          symbols like etext).  If the symbol is defined by a regular
 535          object, then, as it happens, calling record_link_assignment
 536          will do no harm.  */
 537
 538       /* Fall through.  */
 539     case etree_assign:
 540       if (strcmp (exp->assign.dst, ".") != 0)
 541         {
 542           if (! (bfd_elf32_record_link_assignment
 543                  (output_bfd, &link_info, exp->assign.dst,
 544                   exp->type.node_class != etree_assign ? true : false)))
 545             einfo (_("%P%F: failed to record assignment to %s: %E\n"),
 546                    exp->assign.dst);
 547         }
 548       gldelf32ebmip_find_exp_assignment (exp->assign.src);
 549       break;
 550
 551     case etree_binary:
 552       gldelf32ebmip_find_exp_assignment (exp->binary.lhs);
 553       gldelf32ebmip_find_exp_assignment (exp->binary.rhs);
 554       break;
 555
 556     case etree_trinary:
 557       gldelf32ebmip_find_exp_assignment (exp->trinary.cond);
 558       gldelf32ebmip_find_exp_assignment (exp->trinary.lhs);
 559       gldelf32ebmip_find_exp_assignment (exp->trinary.rhs);
 560       break;
 561
 562     case etree_unary:
 563       gldelf32ebmip_find_exp_assignment (exp->unary.child);
 564       break;
 565
 566     default:
 567       break;
 568     }
 569 }
 570
 571 /* Place an orphan section.  We use this to put random SHF_ALLOC
 572    sections in the right segment.  */
 573
 574 static asection *hold_section;
 575 static lang_output_section_statement_type *hold_use;
 576 static lang_output_section_statement_type *hold_text;
 577 static lang_output_section_statement_type *hold_rodata;
 578 static lang_output_section_statement_type *hold_data;
 579 static lang_output_section_statement_type *hold_bss;
 580 static lang_output_section_statement_type *hold_rel;
 581
 582 /*ARGSUSED*/
 583 static boolean
 584 gldelf32ebmip_place_orphan (file, s)
 585      lang_input_statement_type *file;
 586      asection *s;
 587 {
 588   lang_output_section_statement_type *place;
 589   asection *snew, **pps;
 590   lang_statement_list_type *old;
 591   lang_statement_list_type add;
 592   etree_type *address;
 593   const char *secname, *ps;
 594   lang_output_section_statement_type *os;
 595
 596   if ((s->flags & SEC_ALLOC) == 0)
 597     return false;
 598
 599   /* Look through the script to see where to place this section.  */
 600   hold_section = s;
 601   hold_use = NULL;
 602   lang_for_each_statement (gldelf32ebmip_place_section);
 603
 604   if (hold_use != NULL)
 605     {
 606       /* We have already placed a section with this name.  */
 607       lang_add_section (&hold_use->children, s, hold_use, file);
 608       return true;
 609     }
 610
 611   secname = bfd_get_section_name (s->owner, s);
 612
 613   /* If this is a final link, then always put .gnu.warning.SYMBOL
 614      sections into the .text section to get them out of the way.  */
 615   if (! link_info.shared
 616       && ! link_info.relocateable
 617       && strncmp (secname, ".gnu.warning.", sizeof ".gnu.warning." - 1) == 0
 618       && hold_text != NULL)
 619     {
 620       lang_add_section (&hold_text->children, s, hold_text, file);
 621       return true;
 622     }
 623
 624   /* Decide which segment the section should go in based on the
 625      section name and section flags.  */
 626   place = NULL;
 627   if ((s->flags & SEC_HAS_CONTENTS) == 0
 628       && hold_bss != NULL)
 629     place = hold_bss;
 630   else if ((s->flags & SEC_READONLY) == 0
 631            && hold_data != NULL)
 632     place = hold_data;
 633   else if (strncmp (secname, ".rel", 4) == 0
 634            && hold_rel != NULL)
 635     place = hold_rel;
 636   else if ((s->flags & SEC_CODE) == 0
 637            && (s->flags & SEC_READONLY) != 0
 638            && hold_rodata != NULL)
 639     place = hold_rodata;
 640   else if ((s->flags & SEC_READONLY) != 0
 641            && hold_text != NULL)
 642     place = hold_text;
 643   if (place == NULL)
 644     return false;
 645
 646   /* Create the section in the output file, and put it in the right
 647      place.  This shuffling is to make the output file look neater.  */
 648   snew = bfd_make_section (output_bfd, secname);
 649   if (snew == NULL)
 650       einfo (_("%P%F: output format %s cannot represent section called %s\n"),
 651              output_bfd->xvec->name, secname);
 652   if (place->bfd_section != NULL)
 653     {
 654       for (pps = &output_bfd->sections; *pps != snew; pps = &(*pps)->next)
 655         ;
 656       *pps = snew->next;
 657       snew->next = place->bfd_section->next;
 658       place->bfd_section->next = snew;
 659     }
 660
 661   /* Start building a list of statements for this section.  */
 662   old = stat_ptr;
 663   stat_ptr = &add;
 664   lang_list_init (stat_ptr);
 665
 666   /* If the name of the section is representable in C, then create
 667      symbols to mark the start and the end of the section.  */
 668   for (ps = secname; *ps != '\0'; ps++)
 669     if (! ISALNUM (*ps) && *ps != '_')
 670       break;
 671   if (*ps == '\0' && config.build_constructors)
 672     {
 673       char *symname;
 674
 675       symname = (char *) xmalloc (ps - secname + sizeof "__start_");
 676       sprintf (symname, "__start_%s", secname);
 677       lang_add_assignment (exp_assop ('=', symname,
 678                                       exp_unop (ALIGN_K,
 679                                                 exp_intop ((bfd_vma) 1
 680                                                            << s->alignment_power))));
 681     }
 682
 683   if (! link_info.relocateable)
 684     address = NULL;
 685   else
 686     address = exp_intop ((bfd_vma) 0);
 687
 688   lang_enter_output_section_statement (secname, address, 0,
 689                                        (bfd_vma) 0,
 690                                        (etree_type *) NULL,
 691                                        (etree_type *) NULL,
 692                                        (etree_type *) NULL);
 693
 694   os = lang_output_section_statement_lookup (secname);
 695   lang_add_section (&os->children, s, os, file);
 696
 697   lang_leave_output_section_statement
 698     ((bfd_vma) 0, "*default*",
 699      (struct lang_output_section_phdr_list *) NULL, "*default*");
 700   stat_ptr = &add;
 701
 702   if (*ps == '\0' && config.build_constructors)
 703     {
 704       char *symname;
 705
 706       symname = (char *) xmalloc (ps - secname + sizeof "__stop_");
 707       sprintf (symname, "__stop_%s", secname);
 708       lang_add_assignment (exp_assop ('=', symname,
 709                                       exp_nameop (NAME, ".")));
 710     }
 711
 712   /* Now stick the new statement list right after PLACE.  */
 713   *add.tail = place->header.next;
 714   place->header.next = add.head;
 715
 716   stat_ptr = old;
 717
 718   return true;
 719 }
 720
 721 static void
 722 gldelf32ebmip_place_section (s)
 723      lang_statement_union_type *s;
 724 {
 725   lang_output_section_statement_type *os;
 726
 727   if (s->header.type != lang_output_section_statement_enum)
 728     return;
 729
 730   os = &s->output_section_statement;
 731
 732   if (strcmp (os->name, hold_section->name) == 0)
 733     hold_use = os;
 734
 735   if (strcmp (os->name, ".text") == 0)
 736     hold_text = os;
 737   else if (strcmp (os->name, ".rodata") == 0)
 738     hold_rodata = os;
 739   else if (strcmp (os->name, ".data") == 0)
 740     hold_data = os;
 741   else if (strcmp (os->name, ".bss") == 0)
 742     hold_bss = os;
 743   else if (hold_rel == NULL
 744            && os->bfd_section != NULL
 745            && strncmp (os->name, ".rel", 4) == 0)
 746     hold_rel = os;
 747 }
 748
 749 static char *
 750 gldelf32ebmip_get_script(isfile)
 751      int *isfile;
 752 {
 753   *isfile = 0;
 754
 755   if (link_info.relocateable == true && config.build_constructors == true)
 756     return "OUTPUT_FORMAT(\"elf32-bigmips\", \"elf32-bigmips\",\n\
 757               \"elf32-littlemips\")\n\
 758 OUTPUT_ARCH(mips)\n\
 759 ENTRY(_start)\n\
 760  /* For some reason, the Solaris linker makes bad executables\n\
 761   if gld -r is used and the intermediate file has sections starting\n\
 762   at non-zero addresses.  Could be a Solaris ld bug, could be a GNU ld\n\
 763   bug.  But for now assigning the zero vmas works.  */\n\
 764 SECTIONS\n\
 765 {\n\
 766   /* Read-only sections, merged into text segment: */\n\
 767   .interp   0 : { *(.interp)    }\n\
 768   .reginfo     0 : { *(.reginfo) }\n\
 769   .dynamic     0 : { *(.dynamic) }\n\
 770   .dynstr      0 : { *(.dynstr)         }\n\
 771   .dynsym      0 : { *(.dynsym)         }\n\
 772   .hash        0 : { *(.hash)           }\n\
 773   .rel.text    0 : { *(.rel.text)               }\n\
 774   .rela.text   0 : { *(.rela.text)      }\n\
 775   .rel.data    0 : { *(.rel.data)               }\n\
 776   .rela.data   0 : { *(.rela.data)      }\n\
 777   .rel.rodata  0 : { *(.rel.rodata)     }\n\
 778   .rela.rodata 0 : { *(.rela.rodata)    }\n\
 779   .rel.got     0 : { *(.rel.got)                }\n\
 780   .rela.got    0 : { *(.rela.got)               }\n\
 781   .rel.ctors   0 : { *(.rel.ctors)      }\n\
 782   .rela.ctors  0 : { *(.rela.ctors)     }\n\
 783   .rel.dtors   0 : { *(.rel.dtors)      }\n\
 784   .rela.dtors  0 : { *(.rela.dtors)     }\n\
 785   .rel.init    0 : { *(.rel.init)       }\n\
 786   .rela.init   0 : { *(.rela.init)      }\n\
 787   .rel.fini    0 : { *(.rel.fini)       }\n\
 788   .rela.fini   0 : { *(.rela.fini)      }\n\
 789   .rel.bss     0 : { *(.rel.bss)                }\n\
 790   .rela.bss    0 : { *(.rela.bss)               }\n\
 791   .rel.plt     0 : { *(.rel.plt)                }\n\
 792   .rela.plt    0 : { *(.rela.plt)               }\n\
 793   .rodata  0 : { *(.rodata)  }\n\
 794   .rodata1 0 : { *(.rodata1) }\n\
 795   .init        0 : { *(.init)   } =0\n\
 796   .text    0 :\n\
 797   {\n\
 798     *(.text)\n\
 799     *(.stub)\n\
 800     /* .gnu.warning sections are handled specially by elf32.em.  */\n\
 801     *(.gnu.warning)\n\
 802   } =0\n\
 803   .fini    0 : { *(.fini)    } =0\n\
 804   /* Adjust the address for the data segment.  We want to adjust up to\n\
 805      the same address within the page on the next page up.  It would\n\
 806      be more correct to do this:\n\
 807      The current expression does not correctly handle the case of a\n\
 808      text segment ending precisely at the end of a page; it causes the\n\
 809      data segment to skip a page.  The above expression does not have\n\
 810      this problem, but it will currently (2/95) cause BFD to allocate\n\
 811      a single segment, combining both text and data, for this case.\n\
 812      This will prevent the text segment from being shared among\n\
 813      multiple executions of the program; I think that is more\n\
 814      important than losing a page of the virtual address space (note\n\
 815      that no actual memory is lost; the page which is skipped can not\n\
 816      be referenced).  */\n\
 817   .data  0 :\n\
 818   {\n\
 819     *(.data)\n\
 820     CONSTRUCTORS\n\
 821   }\n\
 822   .data1 0 : { *(.data1) }\n\
 823   .ctors       0 : { *(.ctors)   }\n\
 824   .dtors       0 : { *(.dtors)   }\n\
 825   .got         0 :\n\
 826   {\n\
 827     *(.got.plt) *(.got)\n\
 828    }\n\
 829   /* We want the small data sections together, so single-instruction offsets\n\
 830      can access them all, and initialized data all before uninitialized, so\n\
 831      we can shorten the on-disk segment size.  */\n\
 832   .sdata   0 : { *(.sdata) }\n\
 833   .sbss    0 : { *(.sbss) *(.scommon) }\n\
 834   .bss     0 :\n\
 835   {\n\
 836    *(.dynbss)\n\
 837    *(.bss)\n\
 838    *(COMMON)\n\
 839   }\n\
 840   /* These are needed for ELF backends which have not yet been\n\
 841      converted to the new style linker.  */\n\
 842   .stab 0 : { *(.stab) }\n\
 843   .stabstr 0 : { *(.stabstr) }\n\
 844   /* DWARF debug sections.\n\
 845      Symbols in the .debug DWARF section are relative to the beginning of the\n\
 846      section so we begin .debug at 0.  It's not clear yet what needs to happen\n\
 847      for the others.   */\n\
 848   .debug          0 : { *(.debug) }\n\
 849   .debug_srcinfo  0 : { *(.debug_srcinfo) }\n\
 850   .debug_aranges  0 : { *(.debug_aranges) }\n\
 851   .debug_pubnames 0 : { *(.debug_pubnames) }\n\
 852   .debug_sfnames  0 : { *(.debug_sfnames) }\n\
 853   .line           0 : { *(.line) }\n\
 854   /* These must appear regardless of .  */\n\
 855   .gptab.sdata : { *(.gptab.data) *(.gptab.sdata) }\n\
 856   .gptab.sbss : { *(.gptab.bss) *(.gptab.sbss) }\n\
 857 }\n\n";
 858   else if (link_info.relocateable == true)
 859     return "OUTPUT_FORMAT(\"elf32-bigmips\", \"elf32-bigmips\",\n\
 860               \"elf32-littlemips\")\n\
 861 OUTPUT_ARCH(mips)\n\
 862 ENTRY(_start)\n\
 863  /* For some reason, the Solaris linker makes bad executables\n\
 864   if gld -r is used and the intermediate file has sections starting\n\
 865   at non-zero addresses.  Could be a Solaris ld bug, could be a GNU ld\n\
 866   bug.  But for now assigning the zero vmas works.  */\n\
 867 SECTIONS\n\
 868 {\n\
 869   /* Read-only sections, merged into text segment: */\n\
 870   .interp   0 : { *(.interp)    }\n\
 871   .reginfo     0 : { *(.reginfo) }\n\
 872   .dynamic     0 : { *(.dynamic) }\n\
 873   .dynstr      0 : { *(.dynstr)         }\n\
 874   .dynsym      0 : { *(.dynsym)         }\n\
 875   .hash        0 : { *(.hash)           }\n\
 876   .rel.text    0 : { *(.rel.text)               }\n\
 877   .rela.text   0 : { *(.rela.text)      }\n\
 878   .rel.data    0 : { *(.rel.data)               }\n\
 879   .rela.data   0 : { *(.rela.data)      }\n\
 880   .rel.rodata  0 : { *(.rel.rodata)     }\n\
 881   .rela.rodata 0 : { *(.rela.rodata)    }\n\
 882   .rel.got     0 : { *(.rel.got)                }\n\
 883   .rela.got    0 : { *(.rela.got)               }\n\
 884   .rel.ctors   0 : { *(.rel.ctors)      }\n\
 885   .rela.ctors  0 : { *(.rela.ctors)     }\n\
 886   .rel.dtors   0 : { *(.rel.dtors)      }\n\
 887   .rela.dtors  0 : { *(.rela.dtors)     }\n\
 888   .rel.init    0 : { *(.rel.init)       }\n\
 889   .rela.init   0 : { *(.rela.init)      }\n\
 890   .rel.fini    0 : { *(.rel.fini)       }\n\
 891   .rela.fini   0 : { *(.rela.fini)      }\n\
 892   .rel.bss     0 : { *(.rel.bss)                }\n\
 893   .rela.bss    0 : { *(.rela.bss)               }\n\
 894   .rel.plt     0 : { *(.rel.plt)                }\n\
 895   .rela.plt    0 : { *(.rela.plt)               }\n\
 896   .rodata  0 : { *(.rodata)  }\n\
 897   .rodata1 0 : { *(.rodata1) }\n\
 898   .init        0 : { *(.init)   } =0\n\
 899   .text    0 :\n\
 900   {\n\
 901     *(.text)\n\
 902     *(.stub)\n\
 903     /* .gnu.warning sections are handled specially by elf32.em.  */\n\
 904     *(.gnu.warning)\n\
 905   } =0\n\
 906   .fini    0 : { *(.fini)    } =0\n\
 907   /* Adjust the address for the data segment.  We want to adjust up to\n\
 908      the same address within the page on the next page up.  It would\n\
 909      be more correct to do this:\n\
 910      The current expression does not correctly handle the case of a\n\
 911      text segment ending precisely at the end of a page; it causes the\n\
 912      data segment to skip a page.  The above expression does not have\n\
 913      this problem, but it will currently (2/95) cause BFD to allocate\n\
 914      a single segment, combining both text and data, for this case.\n\
 915      This will prevent the text segment from being shared among\n\
 916      multiple executions of the program; I think that is more\n\
 917      important than losing a page of the virtual address space (note\n\
 918      that no actual memory is lost; the page which is skipped can not\n\
 919      be referenced).  */\n\
 920   .data  0 :\n\
 921   {\n\
 922     *(.data)\n\
 923   }\n\
 924   .data1 0 : { *(.data1) }\n\
 925   .ctors       0 : { *(.ctors)   }\n\
 926   .dtors       0 : { *(.dtors)   }\n\
 927   .got         0 :\n\
 928   {\n\
 929     *(.got.plt) *(.got)\n\
 930    }\n\
 931   /* We want the small data sections together, so single-instruction offsets\n\
 932      can access them all, and initialized data all before uninitialized, so\n\
 933      we can shorten the on-disk segment size.  */\n\
 934   .sdata   0 : { *(.sdata) }\n\
 935   .sbss    0 : { *(.sbss) *(.scommon) }\n\
 936   .bss     0 :\n\
 937   {\n\
 938    *(.dynbss)\n\
 939    *(.bss)\n\
 940    *(COMMON)\n\
 941   }\n\
 942   /* These are needed for ELF backends which have not yet been\n\
 943      converted to the new style linker.  */\n\
 944   .stab 0 : { *(.stab) }\n\
 945   .stabstr 0 : { *(.stabstr) }\n\
 946   /* DWARF debug sections.\n\
 947      Symbols in the .debug DWARF section are relative to the beginning of the\n\
 948      section so we begin .debug at 0.  It's not clear yet what needs to happen\n\
 949      for the others.   */\n\
 950   .debug          0 : { *(.debug) }\n\
 951   .debug_srcinfo  0 : { *(.debug_srcinfo) }\n\
 952   .debug_aranges  0 : { *(.debug_aranges) }\n\
 953   .debug_pubnames 0 : { *(.debug_pubnames) }\n\
 954   .debug_sfnames  0 : { *(.debug_sfnames) }\n\
 955   .line           0 : { *(.line) }\n\
 956   /* These must appear regardless of .  */\n\
 957   .gptab.sdata : { *(.gptab.data) *(.gptab.sdata) }\n\
 958   .gptab.sbss : { *(.gptab.bss) *(.gptab.sbss) }\n\
 959 }\n\n";
 960   else if (!config.text_read_only)
 961     return "OUTPUT_FORMAT(\"elf32-bigmips\", \"elf32-bigmips\",\n\
 962               \"elf32-littlemips\")\n\
 963 OUTPUT_ARCH(mips)\n\
 964 ENTRY(_start)\n\
 965  SEARCH_DIR(/usr/local/mips-elf/lib);\n\
 966 /* Do we need any of these for elf?\n\
 967    __DYNAMIC = 0;    */\n\
 968 SECTIONS\n\
 969 {\n\
 970   /* Read-only sections, merged into text segment: */\n\
 971   . = 0x0400000;\n\
 972   .interp     : { *(.interp)    }\n\
 973   .reginfo       : { *(.reginfo) }\n\
 974   .dynamic       : { *(.dynamic) }\n\
 975   .dynstr        : { *(.dynstr)         }\n\
 976   .dynsym        : { *(.dynsym)         }\n\
 977   .hash          : { *(.hash)           }\n\
 978   .rel.text      : { *(.rel.text)               }\n\
 979   .rela.text     : { *(.rela.text)      }\n\
 980   .rel.data      : { *(.rel.data)               }\n\
 981   .rela.data     : { *(.rela.data)      }\n\
 982   .rel.rodata    : { *(.rel.rodata)     }\n\
 983   .rela.rodata   : { *(.rela.rodata)    }\n\
 984   .rel.got       : { *(.rel.got)                }\n\
 985   .rela.got      : { *(.rela.got)               }\n\
 986   .rel.ctors     : { *(.rel.ctors)      }\n\
 987   .rela.ctors    : { *(.rela.ctors)     }\n\
 988   .rel.dtors     : { *(.rel.dtors)      }\n\
 989   .rela.dtors    : { *(.rela.dtors)     }\n\
 990   .rel.init      : { *(.rel.init)       }\n\
 991   .rela.init     : { *(.rela.init)      }\n\
 992   .rel.fini      : { *(.rel.fini)       }\n\
 993   .rela.fini     : { *(.rela.fini)      }\n\
 994   .rel.bss       : { *(.rel.bss)                }\n\
 995   .rela.bss      : { *(.rela.bss)               }\n\
 996   .rel.plt       : { *(.rel.plt)                }\n\
 997   .rela.plt      : { *(.rela.plt)               }\n\
 998   .rodata    : { *(.rodata)  }\n\
 999   .rodata1   : { *(.rodata1) }\n\
1000   .init          : { *(.init)   } =0\n\
1001   .text      :\n\
1002   {\n\
1003     _ftext = . ;\n\
1004     *(.text)\n\
1005     *(.stub)\n\
1006     /* .gnu.warning sections are handled specially by elf32.em.  */\n\
1007     *(.gnu.warning)\n\
1008   } =0\n\
1009   _etext = .;\n\
1010   PROVIDE (etext = .);\n\
1011   .fini      : { *(.fini)    } =0\n\
1012   /* Adjust the address for the data segment.  We want to adjust up to\n\
1013      the same address within the page on the next page up.  It would\n\
1014      be more correct to do this:\n\
1015        . = .;\n\
1016      The current expression does not correctly handle the case of a\n\
1017      text segment ending precisely at the end of a page; it causes the\n\
1018      data segment to skip a page.  The above expression does not have\n\
1019      this problem, but it will currently (2/95) cause BFD to allocate\n\
1020      a single segment, combining both text and data, for this case.\n\
1021      This will prevent the text segment from being shared among\n\
1022      multiple executions of the program; I think that is more\n\
1023      important than losing a page of the virtual address space (note\n\
1024      that no actual memory is lost; the page which is skipped can not\n\
1025      be referenced).  */\n\
1026   . += . - 0x0400000;\n\
1027   .data    :\n\
1028   {\n\
1029     _fdata = . ;\n\
1030     *(.data)\n\
1031     CONSTRUCTORS\n\
1032   }\n\
1033   .data1   : { *(.data1) }\n\
1034   .ctors         : { *(.ctors)   }\n\
1035   .dtors         : { *(.dtors)   }\n\
1036   _gp = ALIGN(16) + 0x7ff0;\n\
1037   .got           :\n\
1038   {\n\
1039     *(.got.plt) *(.got)\n\
1040    }\n\
1041   /* We want the small data sections together, so single-instruction offsets\n\
1042      can access them all, and initialized data all before uninitialized, so\n\
1043      we can shorten the on-disk segment size.  */\n\
1044   .sdata     : { *(.sdata) }\n\
1045   .lit8 : { *(.lit8) }\n\
1046   .lit4 : { *(.lit4) }\n\
1047   _edata  =  .;\n\
1048   PROVIDE (edata = .);\n\
1049   __bss_start = .;\n\
1050   _fbss = .;\n\
1051   .sbss      : { *(.sbss) *(.scommon) }\n\
1052   .bss       :\n\
1053   {\n\
1054    *(.dynbss)\n\
1055    *(.bss)\n\
1056    *(COMMON)\n\
1057   }\n\
1058   _end = . ;\n\
1059   PROVIDE (end = .);\n\
1060   /* These are needed for ELF backends which have not yet been\n\
1061      converted to the new style linker.  */\n\
1062   .stab 0 : { *(.stab) }\n\
1063   .stabstr 0 : { *(.stabstr) }\n\
1064   /* DWARF debug sections.\n\
1065      Symbols in the .debug DWARF section are relative to the beginning of the\n\
1066      section so we begin .debug at 0.  It's not clear yet what needs to happen\n\
1067      for the others.   */\n\
1068   .debug          0 : { *(.debug) }\n\
1069   .debug_srcinfo  0 : { *(.debug_srcinfo) }\n\
1070   .debug_aranges  0 : { *(.debug_aranges) }\n\
1071   .debug_pubnames 0 : { *(.debug_pubnames) }\n\
1072   .debug_sfnames  0 : { *(.debug_sfnames) }\n\
1073   .line           0 : { *(.line) }\n\
1074   /* These must appear regardless of  .  */\n\
1075   .gptab.sdata : { *(.gptab.data) *(.gptab.sdata) }\n\
1076   .gptab.sbss : { *(.gptab.bss) *(.gptab.sbss) }\n\
1077 }\n\n";
1078   else if (!config.magic_demand_paged)
1079     return "OUTPUT_FORMAT(\"elf32-bigmips\", \"elf32-bigmips\",\n\
1080               \"elf32-littlemips\")\n\
1081 OUTPUT_ARCH(mips)\n\
1082 ENTRY(_start)\n\
1083  SEARCH_DIR(/usr/local/mips-elf/lib);\n\
1084 /* Do we need any of these for elf?\n\
1085    __DYNAMIC = 0;    */\n\
1086 SECTIONS\n\
1087 {\n\
1088   /* Read-only sections, merged into text segment: */\n\
1089   . = 0x0400000;\n\
1090   .interp     : { *(.interp)    }\n\
1091   .reginfo       : { *(.reginfo) }\n\
1092   .dynamic       : { *(.dynamic) }\n\
1093   .dynstr        : { *(.dynstr)         }\n\
1094   .dynsym        : { *(.dynsym)         }\n\
1095   .hash          : { *(.hash)           }\n\
1096   .rel.text      : { *(.rel.text)               }\n\
1097   .rela.text     : { *(.rela.text)      }\n\
1098   .rel.data      : { *(.rel.data)               }\n\
1099   .rela.data     : { *(.rela.data)      }\n\
1100   .rel.rodata    : { *(.rel.rodata)     }\n\
1101   .rela.rodata   : { *(.rela.rodata)    }\n\
1102   .rel.got       : { *(.rel.got)                }\n\
1103   .rela.got      : { *(.rela.got)               }\n\
1104   .rel.ctors     : { *(.rel.ctors)      }\n\
1105   .rela.ctors    : { *(.rela.ctors)     }\n\
1106   .rel.dtors     : { *(.rel.dtors)      }\n\
1107   .rela.dtors    : { *(.rela.dtors)     }\n\
1108   .rel.init      : { *(.rel.init)       }\n\
1109   .rela.init     : { *(.rela.init)      }\n\
1110   .rel.fini      : { *(.rel.fini)       }\n\
1111   .rela.fini     : { *(.rela.fini)      }\n\
1112   .rel.bss       : { *(.rel.bss)                }\n\
1113   .rela.bss      : { *(.rela.bss)               }\n\
1114   .rel.plt       : { *(.rel.plt)                }\n\
1115   .rela.plt      : { *(.rela.plt)               }\n\
1116   .rodata    : { *(.rodata)  }\n\
1117   .rodata1   : { *(.rodata1) }\n\
1118   .init          : { *(.init)   } =0\n\
1119   .text      :\n\
1120   {\n\
1121     _ftext = . ;\n\
1122     *(.text)\n\
1123     *(.stub)\n\
1124     /* .gnu.warning sections are handled specially by elf32.em.  */\n\
1125     *(.gnu.warning)\n\
1126   } =0\n\
1127   _etext = .;\n\
1128   PROVIDE (etext = .);\n\
1129   .fini      : { *(.fini)    } =0\n\
1130   /* Adjust the address for the data segment.  We want to adjust up to\n\
1131      the same address within the page on the next page up.  It would\n\
1132      be more correct to do this:\n\
1133        . = 0x10000000;\n\
1134      The current expression does not correctly handle the case of a\n\
1135      text segment ending precisely at the end of a page; it causes the\n\
1136      data segment to skip a page.  The above expression does not have\n\
1137      this problem, but it will currently (2/95) cause BFD to allocate\n\
1138      a single segment, combining both text and data, for this case.\n\
1139      This will prevent the text segment from being shared among\n\
1140      multiple executions of the program; I think that is more\n\
1141      important than losing a page of the virtual address space (note\n\
1142      that no actual memory is lost; the page which is skipped can not\n\
1143      be referenced).  */\n\
1144   . += 0x10000000 - 0x0400000;\n\
1145   .data    :\n\
1146   {\n\
1147     _fdata = . ;\n\
1148     *(.data)\n\
1149     CONSTRUCTORS\n\
1150   }\n\
1151   .data1   : { *(.data1) }\n\
1152   .ctors         : { *(.ctors)   }\n\
1153   .dtors         : { *(.dtors)   }\n\
1154   _gp = ALIGN(16) + 0x7ff0;\n\
1155   .got           :\n\
1156   {\n\
1157     *(.got.plt) *(.got)\n\
1158    }\n\
1159   /* We want the small data sections together, so single-instruction offsets\n\
1160      can access them all, and initialized data all before uninitialized, so\n\
1161      we can shorten the on-disk segment size.  */\n\
1162   .sdata     : { *(.sdata) }\n\
1163   .lit8 : { *(.lit8) }\n\
1164   .lit4 : { *(.lit4) }\n\
1165   _edata  =  .;\n\
1166   PROVIDE (edata = .);\n\
1167   __bss_start = .;\n\
1168   _fbss = .;\n\
1169   .sbss      : { *(.sbss) *(.scommon) }\n\
1170   .bss       :\n\
1171   {\n\
1172    *(.dynbss)\n\
1173    *(.bss)\n\
1174    *(COMMON)\n\
1175   }\n\
1176   _end = . ;\n\
1177   PROVIDE (end = .);\n\
1178   /* These are needed for ELF backends which have not yet been\n\
1179      converted to the new style linker.  */\n\
1180   .stab 0 : { *(.stab) }\n\
1181   .stabstr 0 : { *(.stabstr) }\n\
1182   /* DWARF debug sections.\n\
1183      Symbols in the .debug DWARF section are relative to the beginning of the\n\
1184      section so we begin .debug at 0.  It's not clear yet what needs to happen\n\
1185      for the others.   */\n\
1186   .debug          0 : { *(.debug) }\n\
1187   .debug_srcinfo  0 : { *(.debug_srcinfo) }\n\
1188   .debug_aranges  0 : { *(.debug_aranges) }\n\
1189   .debug_pubnames 0 : { *(.debug_pubnames) }\n\
1190   .debug_sfnames  0 : { *(.debug_sfnames) }\n\
1191   .line           0 : { *(.line) }\n\
1192   /* These must appear regardless of  .  */\n\
1193   .gptab.sdata : { *(.gptab.data) *(.gptab.sdata) }\n\
1194   .gptab.sbss : { *(.gptab.bss) *(.gptab.sbss) }\n\
1195 }\n\n";
1196   else if (link_info.shared)
1197     return "OUTPUT_FORMAT(\"elf32-bigmips\", \"elf32-bigmips\",\n\
1198               \"elf32-littlemips\")\n\
1199 OUTPUT_ARCH(mips)\n\
1200 ENTRY(_start)\n\
1201  SEARCH_DIR(/usr/local/mips-elf/lib);\n\
1202 /* Do we need any of these for elf?\n\
1203    __DYNAMIC = 0;    */\n\
1204 SECTIONS\n\
1205 {\n\
1206   /* Read-only sections, merged into text segment: */\n\
1207   . = 0x5ffe0000 + SIZEOF_HEADERS;\n\
1208   .reginfo       : { *(.reginfo) }\n\
1209   .dynamic       : { *(.dynamic) }\n\
1210   .dynstr        : { *(.dynstr)         }\n\
1211   .dynsym        : { *(.dynsym)         }\n\
1212   .hash          : { *(.hash)           }\n\
1213   .rel.text      : { *(.rel.text)               }\n\
1214   .rela.text     : { *(.rela.text)      }\n\
1215   .rel.data      : { *(.rel.data)               }\n\
1216   .rela.data     : { *(.rela.data)      }\n\
1217   .rel.rodata    : { *(.rel.rodata)     }\n\
1218   .rela.rodata   : { *(.rela.rodata)    }\n\
1219   .rel.got       : { *(.rel.got)                }\n\
1220   .rela.got      : { *(.rela.got)               }\n\
1221   .rel.ctors     : { *(.rel.ctors)      }\n\
1222   .rela.ctors    : { *(.rela.ctors)     }\n\
1223   .rel.dtors     : { *(.rel.dtors)      }\n\
1224   .rela.dtors    : { *(.rela.dtors)     }\n\
1225   .rel.init      : { *(.rel.init)       }\n\
1226   .rela.init     : { *(.rela.init)      }\n\
1227   .rel.fini      : { *(.rel.fini)       }\n\
1228   .rela.fini     : { *(.rela.fini)      }\n\
1229   .rel.bss       : { *(.rel.bss)                }\n\
1230   .rela.bss      : { *(.rela.bss)               }\n\
1231   .rel.plt       : { *(.rel.plt)                }\n\
1232   .rela.plt      : { *(.rela.plt)               }\n\
1233   .rodata    : { *(.rodata)  }\n\
1234   .rodata1   : { *(.rodata1) }\n\
1235   .init          : { *(.init)   } =0\n\
1236   .text      :\n\
1237   {\n\
1238     *(.text)\n\
1239     *(.stub)\n\
1240     /* .gnu.warning sections are handled specially by elf32.em.  */\n\
1241     *(.gnu.warning)\n\
1242   } =0\n\
1243   .fini      : { *(.fini)    } =0\n\
1244   /* Adjust the address for the data segment.  We want to adjust up to\n\
1245      the same address within the page on the next page up.  It would\n\
1246      be more correct to do this:\n\
1247        . = 0x10000000;\n\
1248      The current expression does not correctly handle the case of a\n\
1249      text segment ending precisely at the end of a page; it causes the\n\
1250      data segment to skip a page.  The above expression does not have\n\
1251      this problem, but it will currently (2/95) cause BFD to allocate\n\
1252      a single segment, combining both text and data, for this case.\n\
1253      This will prevent the text segment from being shared among\n\
1254      multiple executions of the program; I think that is more\n\
1255      important than losing a page of the virtual address space (note\n\
1256      that no actual memory is lost; the page which is skipped can not\n\
1257      be referenced).  */\n\
1258   . += 0x10000;\n\
1259   .data    :\n\
1260   {\n\
1261     *(.data)\n\
1262     CONSTRUCTORS\n\
1263   }\n\
1264   .data1   : { *(.data1) }\n\
1265   .ctors         : { *(.ctors)   }\n\
1266   .dtors         : { *(.dtors)   }\n\
1267   _gp = ALIGN(16) + 0x7ff0;\n\
1268   .got           :\n\
1269   {\n\
1270     *(.got.plt) *(.got)\n\
1271    }\n\
1272   /* We want the small data sections together, so single-instruction offsets\n\
1273      can access them all, and initialized data all before uninitialized, so\n\
1274      we can shorten the on-disk segment size.  */\n\
1275   .sdata     : { *(.sdata) }\n\
1276   .lit8 : { *(.lit8) }\n\
1277   .lit4 : { *(.lit4) }\n\
1278   .sbss      : { *(.sbss) *(.scommon) }\n\
1279   .bss       :\n\
1280   {\n\
1281    *(.dynbss)\n\
1282    *(.bss)\n\
1283    *(COMMON)\n\
1284   }\n\
1285   /* These are needed for ELF backends which have not yet been\n\
1286      converted to the new style linker.  */\n\
1287   .stab 0 : { *(.stab) }\n\
1288   .stabstr 0 : { *(.stabstr) }\n\
1289   /* DWARF debug sections.\n\
1290      Symbols in the .debug DWARF section are relative to the beginning of the\n\
1291      section so we begin .debug at 0.  It's not clear yet what needs to happen\n\
1292      for the others.   */\n\
1293   .debug          0 : { *(.debug) }\n\
1294   .debug_srcinfo  0 : { *(.debug_srcinfo) }\n\
1295   .debug_aranges  0 : { *(.debug_aranges) }\n\
1296   .debug_pubnames 0 : { *(.debug_pubnames) }\n\
1297   .debug_sfnames  0 : { *(.debug_sfnames) }\n\
1298   .line           0 : { *(.line) }\n\
1299   /* These must appear regardless of  .  */\n\
1300   .gptab.sdata : { *(.gptab.data) *(.gptab.sdata) }\n\
1301   .gptab.sbss : { *(.gptab.bss) *(.gptab.sbss) }\n\
1302 }\n\n";
1303   else
1304     return "OUTPUT_FORMAT(\"elf32-bigmips\", \"elf32-bigmips\",\n\
1305               \"elf32-littlemips\")\n\
1306 OUTPUT_ARCH(mips)\n\
1307 ENTRY(_start)\n\
1308  SEARCH_DIR(/usr/local/mips-elf/lib);\n\
1309 /* Do we need any of these for elf?\n\
1310    __DYNAMIC = 0;    */\n\
1311 SECTIONS\n\
1312 {\n\
1313   /* Read-only sections, merged into text segment: */\n\
1314   . = 0x0400000;\n\
1315   .interp     : { *(.interp)    }\n\
1316   .reginfo       : { *(.reginfo) }\n\
1317   .dynamic       : { *(.dynamic) }\n\
1318   .dynstr        : { *(.dynstr)         }\n\
1319   .dynsym        : { *(.dynsym)         }\n\
1320   .hash          : { *(.hash)           }\n\
1321   .rel.text      : { *(.rel.text)               }\n\
1322   .rela.text     : { *(.rela.text)      }\n\
1323   .rel.data      : { *(.rel.data)               }\n\
1324   .rela.data     : { *(.rela.data)      }\n\
1325   .rel.rodata    : { *(.rel.rodata)     }\n\
1326   .rela.rodata   : { *(.rela.rodata)    }\n\
1327   .rel.got       : { *(.rel.got)                }\n\
1328   .rela.got      : { *(.rela.got)               }\n\
1329   .rel.ctors     : { *(.rel.ctors)      }\n\
1330   .rela.ctors    : { *(.rela.ctors)     }\n\
1331   .rel.dtors     : { *(.rel.dtors)      }\n\
1332   .rela.dtors    : { *(.rela.dtors)     }\n\
1333   .rel.init      : { *(.rel.init)       }\n\
1334   .rela.init     : { *(.rela.init)      }\n\
1335   .rel.fini      : { *(.rel.fini)       }\n\
1336   .rela.fini     : { *(.rela.fini)      }\n\
1337   .rel.bss       : { *(.rel.bss)                }\n\
1338   .rela.bss      : { *(.rela.bss)               }\n\
1339   .rel.plt       : { *(.rel.plt)                }\n\
1340   .rela.plt      : { *(.rela.plt)               }\n\
1341   .rodata    : { *(.rodata)  }\n\
1342   .rodata1   : { *(.rodata1) }\n\
1343   .init          : { *(.init)   } =0\n\
1344   .text      :\n\
1345   {\n\
1346     _ftext = . ;\n\
1347     *(.text)\n\
1348     *(.stub)\n\
1349     /* .gnu.warning sections are handled specially by elf32.em.  */\n\
1350     *(.gnu.warning)\n\
1351   } =0\n\
1352   _etext = .;\n\
1353   PROVIDE (etext = .);\n\
1354   .fini      : { *(.fini)    } =0\n\
1355   /* Adjust the address for the data segment.  We want to adjust up to\n\
1356      the same address within the page on the next page up.  It would\n\
1357      be more correct to do this:\n\
1358        . = 0x10000000;\n\
1359      The current expression does not correctly handle the case of a\n\
1360      text segment ending precisely at the end of a page; it causes the\n\
1361      data segment to skip a page.  The above expression does not have\n\
1362      this problem, but it will currently (2/95) cause BFD to allocate\n\
1363      a single segment, combining both text and data, for this case.\n\
1364      This will prevent the text segment from being shared among\n\
1365      multiple executions of the program; I think that is more\n\
1366      important than losing a page of the virtual address space (note\n\
1367      that no actual memory is lost; the page which is skipped can not\n\
1368      be referenced).  */\n\
1369   . += 0x10000000 - 0x0400000;\n\
1370   .data    :\n\
1371   {\n\
1372     _fdata = . ;\n\
1373     *(.data)\n\
1374     CONSTRUCTORS\n\
1375   }\n\
1376   .data1   : { *(.data1) }\n\
1377   .ctors         : { *(.ctors)   }\n\
1378   .dtors         : { *(.dtors)   }\n\
1379   _gp = ALIGN(16) + 0x7ff0;\n\
1380   .got           :\n\
1381   {\n\
1382     *(.got.plt) *(.got)\n\
1383    }\n\
1384   /* We want the small data sections together, so single-instruction offsets\n\
1385      can access them all, and initialized data all before uninitialized, so\n\
1386      we can shorten the on-disk segment size.  */\n\
1387   .sdata     : { *(.sdata) }\n\
1388   .lit8 : { *(.lit8) }\n\
1389   .lit4 : { *(.lit4) }\n\
1390   _edata  =  .;\n\
1391   PROVIDE (edata = .);\n\
1392   __bss_start = .;\n\
1393   _fbss = .;\n\
1394   .sbss      : { *(.sbss) *(.scommon) }\n\
1395   .bss       :\n\
1396   {\n\
1397    *(.dynbss)\n\
1398    *(.bss)\n\
1399    *(COMMON)\n\
1400   }\n\
1401   _end = . ;\n\
1402   PROVIDE (end = .);\n\
1403   /* These are needed for ELF backends which have not yet been\n\
1404      converted to the new style linker.  */\n\
1405   .stab 0 : { *(.stab) }\n\
1406   .stabstr 0 : { *(.stabstr) }\n\
1407   /* DWARF debug sections.\n\
1408      Symbols in the .debug DWARF section are relative to the beginning of the\n\
1409      section so we begin .debug at 0.  It's not clear yet what needs to happen\n\
1410      for the others.   */\n\
1411   .debug          0 : { *(.debug) }\n\
1412   .debug_srcinfo  0 : { *(.debug_srcinfo) }\n\
1413   .debug_aranges  0 : { *(.debug_aranges) }\n\
1414   .debug_pubnames 0 : { *(.debug_pubnames) }\n\
1415   .debug_sfnames  0 : { *(.debug_sfnames) }\n\
1416   .line           0 : { *(.line) }\n\
1417   /* These must appear regardless of  .  */\n\
1418   .gptab.sdata : { *(.gptab.data) *(.gptab.sdata) }\n\
1419   .gptab.sbss : { *(.gptab.bss) *(.gptab.sbss) }\n\
1420 }\n\n";
1421 }
1422
1423 struct ld_emulation_xfer_struct ld_elf32ebmip_emulation =
1424 {
1425   gldelf32ebmip_before_parse,
1426   syslib_default,
1427   hll_default,
1428   after_parse_default,
1429   gldelf32ebmip_after_open,
1430   after_allocation_default,
1431   set_output_arch_default,
1432   ldemul_default_target,
1433   gldelf32ebmip_before_allocation,
1434   gldelf32ebmip_get_script,
1435   "elf32ebmip",
1436   "elf32-bigmips",
1437   NULL,
1438   NULL,
1439   gldelf32ebmip_open_dynamic_archive,
1440   gldelf32ebmip_place_orphan
1441 };