ld/emultempl/elf32.em

   1 # This shell script emits a C file. -*- C -*-
   2 # It does some substitutions.
   3 cat >e${EMULATION_NAME}.c <<EOF
   4 /* This file is is generated by a shell script.  DO NOT EDIT! */
   5
   6 /* 32 bit ELF emulation code for ${EMULATION_NAME}
   7    Copyright (C) 1991, 1993, 1994, 1995 Free Software Foundation, Inc.
   8    Written by Steve Chamberlain <sac@cygnus.com>
   9    ELF support by Ian Lance Taylor <ian@cygnus.com>
  10
  11 This file is part of GLD, the Gnu Linker.
  12
  13 This program is free software; you can redistribute it and/or modify
  14 it under the terms of the GNU General Public License as published by
  15 the Free Software Foundation; either version 2 of the License, or
  16 (at your option) any later version.
  17
  18 This program is distributed in the hope that it will be useful,
  19 but WITHOUT ANY WARRANTY; without even the implied warranty of
  20 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21 GNU General Public License for more details.
  22
  23 You should have received a copy of the GNU General Public License
  24 along with this program; if not, write to the Free Software
  25 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  26
  27 #define TARGET_IS_${EMULATION_NAME}
  28
  29 #include "bfd.h"
  30 #include "sysdep.h"
  31
  32 #include <ctype.h>
  33
  34 #include "bfdlink.h"
  35
  36 #include "ld.h"
  37 #include "ldmain.h"
  38 #include "ldemul.h"
  39 #include "ldfile.h"
  40 #include "ldmisc.h"
  41 #include "ldexp.h"
  42 #include "ldlang.h"
  43 #include "ldgram.h"
  44
  45 static void gld${EMULATION_NAME}_before_parse PARAMS ((void));
  46 static boolean gld${EMULATION_NAME}_open_dynamic_archive
  47   PARAMS ((const char *, search_dirs_type *, lang_input_statement_type *));
  48 static void gld${EMULATION_NAME}_after_open PARAMS ((void));
  49 static void gld${EMULATION_NAME}_check_needed
  50   PARAMS ((lang_input_statement_type *));
  51 static void gld${EMULATION_NAME}_stat_needed
  52   PARAMS ((lang_input_statement_type *));
  53 static boolean gld${EMULATION_NAME}_search_needed
  54   PARAMS ((const char *, const char *));
  55 static boolean gld${EMULATION_NAME}_try_needed PARAMS ((const char *));
  56 static void gld${EMULATION_NAME}_before_allocation PARAMS ((void));
  57 static void gld${EMULATION_NAME}_find_statement_assignment
  58   PARAMS ((lang_statement_union_type *));
  59 static void gld${EMULATION_NAME}_find_exp_assignment PARAMS ((etree_type *));
  60 static boolean gld${EMULATION_NAME}_place_orphan
  61   PARAMS ((lang_input_statement_type *, asection *));
  62 static void gld${EMULATION_NAME}_place_section
  63   PARAMS ((lang_statement_union_type *));
  64 static char *gld${EMULATION_NAME}_get_script PARAMS ((int *isfile));
  65
  66 static void
  67 gld${EMULATION_NAME}_before_parse()
  68 {
  69   ldfile_output_architecture = bfd_arch_${ARCH};
  70   config.dynamic_link = ${DYNAMIC_LINK-true};
  71 }
  72
  73 /* Try to open a dynamic archive.  This is where we know that ELF
  74    dynamic libraries have an extension of .so.  */
  75
  76 static boolean
  77 gld${EMULATION_NAME}_open_dynamic_archive (arch, search, entry)
  78      const char *arch;
  79      search_dirs_type *search;
  80      lang_input_statement_type *entry;
  81 {
  82   const char *filename;
  83   char *string;
  84
  85   if (! entry->is_archive)
  86     return false;
  87
  88   filename = entry->filename;
  89
  90   string = (char *) xmalloc (strlen (search->name)
  91                              + strlen (filename)
  92                              + strlen (arch)
  93                              + sizeof "/lib.so");
  94
  95   sprintf (string, "%s/lib%s%s.so", search->name, filename, arch);
  96
  97   if (! ldfile_try_open_bfd (string, entry))
  98     {
  99       free (string);
 100       return false;
 101     }
 102
 103   entry->filename = string;
 104
 105   /* We have found a dynamic object to include in the link.  The ELF
 106      backend linker will create a DT_NEEDED entry in the .dynamic
 107      section naming this file.  If this file includes a DT_SONAME
 108      entry, it will be used.  Otherwise, the ELF linker will just use
 109      the name of the file.  For an archive found by searching, like
 110      this one, the DT_NEEDED entry should consist of just the name of
 111      the file, without the path information used to find it.  Note
 112      that we only need to do this if we have a dynamic object; an
 113      archive will never be referenced by a DT_NEEDED entry.
 114
 115      FIXME: This approach--using bfd_elf_set_dt_needed_name--is not
 116      very pretty.  I haven't been able to think of anything that is
 117      pretty, though.  */
 118   if (bfd_check_format (entry->the_bfd, bfd_object)
 119       && (entry->the_bfd->flags & DYNAMIC) != 0)
 120     {
 121       char *needed_name;
 122
 123       ASSERT (entry->is_archive && entry->search_dirs_flag);
 124       needed_name = (char *) xmalloc (strlen (filename)
 125                                       + strlen (arch)
 126                                       + sizeof "lib.so");
 127       sprintf (needed_name, "lib%s%s.so", filename, arch);
 128       bfd_elf_set_dt_needed_name (entry->the_bfd, needed_name);
 129     }
 130
 131   return true;
 132 }
 133
 134 /* These variables are required to pass information back and forth
 135    between after_open and check_needed and stat_needed.  */
 136
 137 static struct bfd_elf_link_needed_list *global_needed;
 138 static struct stat global_stat;
 139 static boolean global_found;
 140
 141 /* This is called after all the input files have been opened.  */
 142
 143 static void
 144 gld${EMULATION_NAME}_after_open ()
 145 {
 146   struct bfd_elf_link_needed_list *needed, *l;
 147
 148   /* We only need to worry about this when doing a final link.  */
 149   if (link_info.relocateable || link_info.shared)
 150     return;
 151
 152   /* Get the list of files which appear in DT_NEEDED entries in
 153      dynamic objects included in the link (often there will be none).
 154      For each such file, we want to track down the corresponding
 155      library, and include the symbol table in the link.  This is what
 156      the runtime dynamic linker will do.  Tracking the files down here
 157      permits one dynamic object to include another without requiring
 158      special action by the person doing the link.  Note that the
 159      needed list can actually grow while we are stepping through this
 160      loop.  */
 161   needed = bfd_elf_get_needed_list (output_bfd, &link_info);
 162   for (l = needed; l != NULL; l = l->next)
 163     {
 164       struct bfd_elf_link_needed_list *ll;
 165       const char *lib_path;
 166       size_t len;
 167       search_dirs_type *search;
 168
 169       /* If we've already seen this file, skip it.  */
 170       for (ll = needed; ll != l; ll = ll->next)
 171         if (strcmp (ll->name, l->name) == 0)
 172           break;
 173       if (ll != l)
 174         continue;
 175
 176       /* See if this file was included in the link explicitly.  */
 177       global_needed = l;
 178       global_found = false;
 179       lang_for_each_input_file (gld${EMULATION_NAME}_check_needed);
 180       if (global_found)
 181         continue;
 182
 183       /* We need to find this file and include the symbol table.  We
 184          want to search for the file in the same way that the dynamic
 185          linker will search.  That means that we want to use rpath,
 186          then the environment variable LD_LIBRARY_PATH, then the
 187          linker script LIB_SEARCH_DIRS.  We do not search using the -L
 188          arguments.  */
 189       if (gld${EMULATION_NAME}_search_needed (command_line.rpath, l->name))
 190         continue;
 191       lib_path = (const char *) getenv ("LD_LIBRARY_PATH");
 192       if (gld${EMULATION_NAME}_search_needed (lib_path, l->name))
 193         continue;
 194       len = strlen (l->name);
 195       for (search = search_head; search != NULL; search = search->next)
 196         {
 197           char *filename;
 198
 199           if (search->cmdline)
 200             continue;
 201           filename = (char *) xmalloc (strlen (search->name) + len + 2);
 202           sprintf (filename, "%s/%s", search->name, l->name);
 203           if (gld${EMULATION_NAME}_try_needed (filename))
 204             break;
 205           free (filename);
 206         }
 207       if (search != NULL)
 208         continue;
 209
 210       einfo ("%P: warning: %s, needed by %B, not found\n",
 211              l->name, l->by);
 212     }
 213 }
 214
 215 /* Search for a needed file in a path.  */
 216
 217 static boolean
 218 gld${EMULATION_NAME}_search_needed (path, name)
 219      const char *path;
 220      const char *name;
 221 {
 222   const char *s;
 223   size_t len;
 224
 225   if (path == NULL || *path == '\0')
 226     return false;
 227   len = strlen (name);
 228   while (1)
 229     {
 230       char *filename, *sset;
 231
 232       s = strchr (path, ':');
 233       if (s == NULL)
 234         s = path + strlen (path);
 235
 236       filename = (char *) xmalloc (s - path + len + 2);
 237       if (s == path)
 238         sset = filename;
 239       else
 240         {
 241           memcpy (filename, path, s - path);
 242           filename[s - path] = '/';
 243           sset = filename + (s - path) + 1;
 244         }
 245       strcpy (sset, name);
 246
 247       if (gld${EMULATION_NAME}_try_needed (filename))
 248         return true;
 249
 250       free (filename);
 251
 252       if (*s == '\0')
 253         break;
 254       path = s + 1;
 255     }
 256
 257   return false;
 258 }
 259
 260 /* This function is called for each possible name for a dynamic object
 261    named by a DT_NEEDED entry.  */
 262
 263 static boolean
 264 gld${EMULATION_NAME}_try_needed (name)
 265      const char *name;
 266 {
 267   bfd *abfd;
 268
 269   abfd = bfd_openr (name, bfd_get_target (output_bfd));
 270   if (abfd == NULL)
 271     return false;
 272   if (! bfd_check_format (abfd, bfd_object))
 273     {
 274       (void) bfd_close (abfd);
 275       return false;
 276     }
 277   if ((bfd_get_file_flags (abfd) & DYNAMIC) == 0)
 278     {
 279       (void) bfd_close (abfd);
 280       return false;
 281     }
 282
 283   /* We've found a dynamic object matching the DT_NEEDED entry.  */
 284
 285   /* We have already checked that there is no other input file of the
 286      same name.  We must now check again that we are not including the
 287      same file twice.  We need to do this because on many systems
 288      libc.so is a symlink to, e.g., libc.so.1.  The SONAME entry will
 289      reference libc.so.1.  If we have already included libc.so, we
 290      don't want to include libc.so.1 if they are the same file, and we
 291      can only check that using stat.  */
 292
 293   if (bfd_stat (abfd, &global_stat) != 0)
 294     einfo ("%F%P:%B: bfd_stat failed: %E\n", abfd);
 295   global_found = false;
 296   lang_for_each_input_file (gld${EMULATION_NAME}_stat_needed);
 297   if (global_found)
 298     {
 299       /* Return true to indicate that we found the file, even though
 300          we aren't going to do anything with it.  */
 301       return true;
 302     }
 303
 304   /* Tell the ELF backend that don't want the output file to have a
 305      DT_NEEDED entry for this file.  */
 306   bfd_elf_set_dt_needed_name (abfd, "");
 307
 308   /* Add this file into the symbol table.  */
 309   if (! bfd_link_add_symbols (abfd, &link_info))
 310     einfo ("%F%B: could not read symbols: %E\n", abfd);
 311
 312   return true;
 313 }
 314
 315 /* See if an input file matches a DT_NEEDED entry by name.  */
 316
 317 static void
 318 gld${EMULATION_NAME}_check_needed (s)
 319      lang_input_statement_type *s;
 320 {
 321   if (s->filename != NULL
 322       && strcmp (s->filename, global_needed->name) == 0)
 323     global_found = true;
 324   else if (s->search_dirs_flag
 325            && s->filename != NULL
 326            && strchr (global_needed->name, '/') == NULL)
 327     {
 328       const char *f;
 329
 330       f = strrchr (s->filename, '/');
 331       if (f != NULL
 332           && strcmp (f + 1, global_needed->name) == 0)
 333         global_found = true;
 334     }
 335 }
 336
 337 /* See if an input file matches a DT_NEEDED entry by running stat on
 338    the file.  */
 339
 340 static void
 341 gld${EMULATION_NAME}_stat_needed (s)
 342      lang_input_statement_type *s;
 343 {
 344   if (global_found)
 345     return;
 346   if (s->the_bfd != NULL)
 347     {
 348       struct stat st;
 349
 350       if (bfd_stat (s->the_bfd, &st) != 0)
 351         einfo ("%P:%B: bfd_stat failed: %E\n", s->the_bfd);
 352       else
 353         {
 354           if (st.st_dev == global_stat.st_dev
 355               && st.st_ino == global_stat.st_ino)
 356             global_found = true;
 357         }
 358     }
 359 }
 360
 361 /* This is called after the sections have been attached to output
 362    sections, but before any sizes or addresses have been set.  */
 363
 364 static void
 365 gld${EMULATION_NAME}_before_allocation ()
 366 {
 367   asection *sinterp;
 368
 369   /* If we are going to make any variable assignments, we need to let
 370      the ELF backend know about them in case the variables are
 371      referred to by dynamic objects.  */
 372   lang_for_each_statement (gld${EMULATION_NAME}_find_statement_assignment);
 373
 374   /* Let the ELF backend work out the sizes of any sections required
 375      by dynamic linking.  */
 376   if (! bfd_elf32_size_dynamic_sections (output_bfd,
 377                                          command_line.soname,
 378                                          command_line.rpath,
 379                                          command_line.export_dynamic,
 380                                          &link_info,
 381                                          &sinterp))
 382     einfo ("%P%F: failed to set dynamic section sizes: %E\n");
 383
 384   /* Let the user override the dynamic linker we are using.  */
 385   if (command_line.interpreter != NULL
 386       && sinterp != NULL)
 387     {
 388       sinterp->contents = (bfd_byte *) command_line.interpreter;
 389       sinterp->_raw_size = strlen (command_line.interpreter) + 1;
 390     }
 391
 392   /* Look for any sections named .gnu.warning.  As a GNU extensions,
 393      we treat such sections as containing warning messages.  We print
 394      out the warning message, and then zero out the section size so
 395      that it does not get copied into the output file.  */
 396
 397   {
 398     LANG_FOR_EACH_INPUT_STATEMENT (is)
 399       {
 400         asection *s;
 401         bfd_size_type sz;
 402         char *msg;
 403         boolean ret;
 404
 405         if (is->just_syms_flag)
 406           continue;
 407
 408         s = bfd_get_section_by_name (is->the_bfd, ".gnu.warning");
 409         if (s == NULL)
 410           continue;
 411
 412         sz = bfd_section_size (is->the_bfd, s);
 413         msg = xmalloc ((size_t) sz + 1);
 414         if (! bfd_get_section_contents (is->the_bfd, s, msg, (file_ptr) 0, sz))
 415           einfo ("%F%B: Can't read contents of section .gnu.warning: %E\n",
 416                  is->the_bfd);
 417         msg[sz] = '\0';
 418         ret = link_info.callbacks->warning (&link_info, msg,
 419                                             (const char *) NULL,
 420                                             is->the_bfd, (asection *) NULL,
 421                                             (bfd_vma) 0);
 422         ASSERT (ret);
 423         free (msg);
 424
 425         /* Clobber the section size, so that we don't waste copying the
 426            warning into the output file.  */
 427         s->_raw_size = 0;
 428       }
 429   }
 430
 431 #if defined (TARGET_IS_elf32bmip) || defined (TARGET_IS_elf32lmip)
 432   /* For MIPS ELF the .reginfo section requires special handling.
 433      Each input section is 24 bytes, and the final output section must
 434      also be 24 bytes.  We handle this by clobbering all but the first
 435      input section size to 0.  The .reginfo section is handled
 436      specially by the backend code anyhow.  */
 437   {
 438     boolean found = false;
 439     LANG_FOR_EACH_INPUT_STATEMENT (is)
 440       {
 441         asection *s;
 442
 443         if (is->just_syms_flag)
 444           continue;
 445
 446         s = bfd_get_section_by_name (is->the_bfd, ".reginfo");
 447         if (s == NULL)
 448           continue;
 449
 450         if (! found)
 451           {
 452             found = true;
 453             continue;
 454           }
 455
 456         s->_raw_size = 0;
 457         s->_cooked_size = 0;
 458       }
 459   }
 460 #endif
 461 }
 462
 463 /* This is called by the before_allocation routine via
 464    lang_for_each_statement.  It locates any assignment statements, and
 465    tells the ELF backend about them, in case they are assignments to
 466    symbols which are referred to by dynamic objects.  */
 467
 468 static void
 469 gld${EMULATION_NAME}_find_statement_assignment (s)
 470      lang_statement_union_type *s;
 471 {
 472   if (s->header.type == lang_assignment_statement_enum)
 473     gld${EMULATION_NAME}_find_exp_assignment (s->assignment_statement.exp);
 474 }
 475
 476 /* Look through an expression for an assignment statement.  */
 477
 478 static void
 479 gld${EMULATION_NAME}_find_exp_assignment (exp)
 480      etree_type *exp;
 481 {
 482   struct bfd_link_hash_entry *h;
 483
 484   switch (exp->type.node_class)
 485     {
 486     case etree_provide:
 487       h = bfd_link_hash_lookup (link_info.hash, exp->assign.dst,
 488                                 false, false, false);
 489       if (h == NULL)
 490         break;
 491
 492       /* We call record_link_assignment even if the symbol is defined.
 493          This is because if it is defined by a dynamic object, we
 494          actually want to use the value defined by the linker script,
 495          not the value from the dynamic object (because we are setting
 496          symbols like etext).  If the symbol is defined by a regular
 497          object, then, as it happens, calling record_link_assignment
 498          will do no harm.  */
 499
 500       /* Fall through.  */
 501     case etree_assign:
 502       if (strcmp (exp->assign.dst, ".") != 0)
 503         {
 504           if (! (bfd_elf32_record_link_assignment
 505                  (output_bfd, &link_info, exp->assign.dst,
 506                   exp->type.node_class == etree_provide ? true : false)))
 507             einfo ("%P%F: failed to record assignment to %s: %E\n",
 508                    exp->assign.dst);
 509         }
 510       gld${EMULATION_NAME}_find_exp_assignment (exp->assign.src);
 511       break;
 512
 513     case etree_binary:
 514       gld${EMULATION_NAME}_find_exp_assignment (exp->binary.lhs);
 515       gld${EMULATION_NAME}_find_exp_assignment (exp->binary.rhs);
 516       break;
 517
 518     case etree_trinary:
 519       gld${EMULATION_NAME}_find_exp_assignment (exp->trinary.lhs);
 520       gld${EMULATION_NAME}_find_exp_assignment (exp->trinary.lhs);
 521       gld${EMULATION_NAME}_find_exp_assignment (exp->trinary.rhs);
 522       break;
 523
 524     case etree_unary:
 525       gld${EMULATION_NAME}_find_exp_assignment (exp->unary.child);
 526       break;
 527
 528     default:
 529       break;
 530     }
 531 }
 532
 533 /* Place an orphan section.  We use this to put random SHF_ALLOC
 534    sections in the right segment.  */
 535
 536 static asection *hold_section;
 537 static lang_output_section_statement_type *hold_use;
 538 static lang_output_section_statement_type *hold_text;
 539 static lang_output_section_statement_type *hold_data;
 540 static lang_output_section_statement_type *hold_bss;
 541 static lang_output_section_statement_type *hold_rel;
 542
 543 /*ARGSUSED*/
 544 static boolean
 545 gld${EMULATION_NAME}_place_orphan (file, s)
 546      lang_input_statement_type *file;
 547      asection *s;
 548 {
 549   lang_output_section_statement_type *place;
 550   asection *snew, **pps;
 551   lang_statement_list_type *old;
 552   lang_statement_list_type add;
 553   etree_type *address;
 554   const char *secname, *ps;
 555   lang_output_section_statement_type *os;
 556
 557   if ((s->flags & SEC_ALLOC) == 0)
 558     return false;
 559
 560   /* Look through the script to see where to place this section.  */
 561   hold_section = s;
 562   hold_use = NULL;
 563   lang_for_each_statement (gld${EMULATION_NAME}_place_section);
 564
 565   if (hold_use != NULL)
 566     {
 567       /* We have already placed a section with this name.  */
 568       wild_doit (&hold_use->children, s, hold_use, file);
 569       return true;
 570     }
 571
 572   secname = bfd_get_section_name (s->owner, s);
 573
 574   /* If this is a final link, then always put .gnu.warning.SYMBOL
 575      sections into the .text section to get them out of the way.  */
 576   if (! link_info.shared
 577       && ! link_info.relocateable
 578       && strncmp (secname, ".gnu.warning.", sizeof ".gnu.warning." - 1) == 0
 579       && hold_text != NULL)
 580     {
 581       wild_doit (&hold_text->children, s, hold_text, file);
 582       return true;
 583     }
 584
 585   /* Decide which segment the section should go in based on the
 586      section name and section flags.  */
 587   place = NULL;
 588   if ((s->flags & SEC_HAS_CONTENTS) == 0
 589       && hold_bss != NULL)
 590     place = hold_bss;
 591   else if ((s->flags & SEC_READONLY) == 0
 592            && hold_data != NULL)
 593     place = hold_data;
 594   else if (strncmp (secname, ".rel", 4) == 0
 595            && hold_rel != NULL)
 596     place = hold_rel;
 597   else if ((s->flags & SEC_READONLY) != 0
 598            && hold_text != NULL)
 599     place = hold_text;
 600   if (place == NULL)
 601     return false;
 602
 603   /* Create the section in the output file, and put it in the right
 604      place.  This shuffling is to make the output file look neater.  */
 605   snew = bfd_make_section (output_bfd, secname);
 606   if (snew == NULL)
 607       einfo ("%P%F: output format %s cannot represent section called %s\n",
 608              output_bfd->xvec->name, secname);
 609   if (place->bfd_section != NULL)
 610     {
 611       for (pps = &output_bfd->sections; *pps != snew; pps = &(*pps)->next)
 612         ;
 613       *pps = snew->next;
 614       snew->next = place->bfd_section->next;
 615       place->bfd_section->next = snew;
 616     }
 617
 618   /* Start building a list of statements for this section.  */
 619   old = stat_ptr;
 620   stat_ptr = &add;
 621   lang_list_init (stat_ptr);
 622
 623   /* If the name of the section is representable in C, then create
 624      symbols to mark the start and the end of the section.  */
 625   for (ps = secname; *ps != '\0'; ps++)
 626     if (! isalnum (*ps) && *ps != '_')
 627       break;
 628   if (*ps == '\0' && config.build_constructors)
 629     {
 630       char *symname;
 631
 632       symname = (char *) xmalloc (ps - secname + sizeof "__start_");
 633       sprintf (symname, "__start_%s", secname);
 634       lang_add_assignment (exp_assop ('=', symname,
 635                                       exp_nameop (NAME, ".")));
 636     }
 637
 638   if (! link_info.relocateable)
 639     address = NULL;
 640   else
 641     address = exp_intop ((bfd_vma) 0);
 642
 643   lang_enter_output_section_statement (secname, address, 0,
 644                                        (bfd_vma) 0,
 645                                        (etree_type *) NULL,
 646                                        (etree_type *) NULL,
 647                                        (etree_type *) NULL);
 648
 649   os = lang_output_section_statement_lookup (secname);
 650   wild_doit (&os->children, s, os, file);
 651
 652   lang_leave_output_section_statement ((bfd_vma) 0, "*default*");
 653   stat_ptr = &add;
 654
 655   if (*ps == '\0' && config.build_constructors)
 656     {
 657       char *symname;
 658
 659       symname = (char *) xmalloc (ps - secname + sizeof "__stop_");
 660       sprintf (symname, "__stop_%s", secname);
 661       lang_add_assignment (exp_assop ('=', symname,
 662                                       exp_nameop (NAME, ".")));
 663     }
 664
 665   /* Now stick the new statement list right after PLACE.  */
 666   *add.tail = place->header.next;
 667   place->header.next = add.head;
 668
 669   stat_ptr = old;
 670
 671   return true;
 672 }
 673
 674 static void
 675 gld${EMULATION_NAME}_place_section (s)
 676      lang_statement_union_type *s;
 677 {
 678   lang_output_section_statement_type *os;
 679
 680   if (s->header.type != lang_output_section_statement_enum)
 681     return;
 682
 683   os = &s->output_section_statement;
 684
 685   if (strcmp (os->name, hold_section->name) == 0)
 686     hold_use = os;
 687
 688   if (strcmp (os->name, ".text") == 0)
 689     hold_text = os;
 690   else if (strcmp (os->name, ".data") == 0)
 691     hold_data = os;
 692   else if (strcmp (os->name, ".bss") == 0)
 693     hold_bss = os;
 694   else if (hold_rel == NULL
 695            && strncmp (os->name, ".rel", 4) == 0)
 696     hold_rel = os;
 697 }
 698
 699 static char *
 700 gld${EMULATION_NAME}_get_script(isfile)
 701      int *isfile;
 702 EOF
 703
 704 if test -n "$COMPILE_IN"
 705 then
 706 # Scripts compiled in.
 707
 708 # sed commands to quote an ld script as a C string.
 709 sc='s/["\\]/\\&/g
 710 s/$/\\n\\/
 711 1s/^/"/
 712 $s/$/n"/
 713 '
 714
 715 cat >>e${EMULATION_NAME}.c <<EOF
 716 {
 717   *isfile = 0;
 718
 719   if (link_info.relocateable == true && config.build_constructors == true)
 720     return `sed "$sc" ldscripts/${EMULATION_NAME}.xu`;
 721   else if (link_info.relocateable == true)
 722     return `sed "$sc" ldscripts/${EMULATION_NAME}.xr`;
 723   else if (!config.text_read_only)
 724     return `sed "$sc" ldscripts/${EMULATION_NAME}.xbn`;
 725   else if (!config.magic_demand_paged)
 726     return `sed "$sc" ldscripts/${EMULATION_NAME}.xn`;
 727   else if (link_info.shared)
 728     return `sed "$sc" ldscripts/${EMULATION_NAME}.xs`;
 729   else
 730     return `sed "$sc" ldscripts/${EMULATION_NAME}.x`;
 731 }
 732 EOF
 733
 734 else
 735 # Scripts read from the filesystem.
 736
 737 cat >>e${EMULATION_NAME}.c <<EOF
 738 {
 739   *isfile = 1;
 740
 741   if (link_info.relocateable == true && config.build_constructors == true)
 742     return "ldscripts/${EMULATION_NAME}.xu";
 743   else if (link_info.relocateable == true)
 744     return "ldscripts/${EMULATION_NAME}.xr";
 745   else if (!config.text_read_only)
 746     return "ldscripts/${EMULATION_NAME}.xbn";
 747   else if (!config.magic_demand_paged)
 748     return "ldscripts/${EMULATION_NAME}.xn";
 749   else if (link_info.shared)
 750     return "ldscripts/${EMULATION_NAME}.xs";
 751   else
 752     return "ldscripts/${EMULATION_NAME}.x";
 753 }
 754 EOF
 755
 756 fi
 757
 758 cat >>e${EMULATION_NAME}.c <<EOF
 759
 760 struct ld_emulation_xfer_struct ld_${EMULATION_NAME}_emulation =
 761 {
 762   gld${EMULATION_NAME}_before_parse,
 763   syslib_default,
 764   hll_default,
 765   after_parse_default,
 766   gld${EMULATION_NAME}_after_open,
 767   after_allocation_default,
 768   set_output_arch_default,
 769   ldemul_default_target,
 770   gld${EMULATION_NAME}_before_allocation,
 771   gld${EMULATION_NAME}_get_script,
 772   "${EMULATION_NAME}",
 773   "${OUTPUT_FORMAT}",
 774   NULL,
 775   NULL,
 776   gld${EMULATION_NAME}_open_dynamic_archive,
 777   gld${EMULATION_NAME}_place_orphan
 778 };
 779 EOF