ld/emultempl/beos.em

   1 # This shell script emits a C file. -*- C -*-
   2 # It does some substitutions.
   3 if [ -z "$MACHINE" ]; then
   4   OUTPUT_ARCH=${ARCH}
   5 else
   6   OUTPUT_ARCH=${ARCH}:${MACHINE}
   7 fi
   8 fragment <<EOF
   9 /* This file is part of GLD, the Gnu Linker.
  10    Copyright (C) 1995-2024 Free Software Foundation, Inc.
  11
  12    This file is part of the GNU Binutils.
  13
  14    This program is free software; you can redistribute it and/or modify
  15    it under the terms of the GNU General Public License as published by
  16    the Free Software Foundation; either version 3 of the License, or
  17    (at your option) any later version.
  18
  19    This program is distributed in the hope that it will be useful,
  20    but WITHOUT ANY WARRANTY; without even the implied warranty of
  21    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  22    GNU General Public License for more details.
  23
  24    You should have received a copy of the GNU General Public License
  25    along with this program; if not, write to the Free Software
  26    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
  27    MA 02110-1301, USA.  */
  28
  29
  30 /* For WINDOWS_NT */
  31 /* The original file generated returned different default scripts depending
  32    on whether certain switches were set, but these switches pertain to the
  33    Linux system and that particular version of coff.  In the NT case, we
  34    only determine if the subsystem is console or windows in order to select
  35    the correct entry point by default. */
  36
  37 #include "sysdep.h"
  38 #include "bfd.h"
  39 #include "bfdlink.h"
  40 #include "ctf-api.h"
  41 #include "getopt.h"
  42 #include "libiberty.h"
  43 #include "filenames.h"
  44 #include "ld.h"
  45 #include "ldmain.h"
  46 #include "ldexp.h"
  47 #include "ldlang.h"
  48 #include "ldfile.h"
  49 #include "ldemul.h"
  50 #include <ldgram.h>
  51 #include "ldlex.h"
  52 #include "ldmisc.h"
  53 #include "ldctor.h"
  54 #include "coff/internal.h"
  55 #include "../bfd/libcoff.h"
  56
  57 #define TARGET_IS_${EMULATION_NAME}
  58
  59 static struct internal_extra_pe_aouthdr pe;
  60 static int dll;
  61
  62 extern const char *output_filename;
  63
  64 static void
  65 gld${EMULATION_NAME}_before_parse (void)
  66 {
  67   ldfile_set_output_arch ("${OUTPUT_ARCH}", bfd_arch_`echo ${ARCH} | sed -e 's/:.*//'`);
  68   output_filename = "a.exe";
  69 }
  70 \f
  71 /* PE format extra command line options.  */
  72
  73 static void
  74 gld${EMULATION_NAME}_add_options
  75   (int ns ATTRIBUTE_UNUSED, char **shortopts ATTRIBUTE_UNUSED, int nl,
  76    struct option **longopts, int nrl ATTRIBUTE_UNUSED,
  77    struct option **really_longopts ATTRIBUTE_UNUSED)
  78 {
  79   static const struct option xtra_long[] = {
  80     /* PE options */
  81     {"base-file", required_argument, NULL, OPTION_BASE_FILE},
  82     {"dll", no_argument, NULL, OPTION_DLL},
  83     {"file-alignment", required_argument, NULL, OPTION_FILE_ALIGNMENT},
  84     {"heap", required_argument, NULL, OPTION_HEAP},
  85     {"major-image-version", required_argument, NULL, OPTION_MAJOR_IMAGE_VERSION},
  86     {"major-os-version", required_argument, NULL, OPTION_MAJOR_OS_VERSION},
  87     {"major-subsystem-version", required_argument, NULL, OPTION_MAJOR_SUBSYSTEM_VERSION},
  88     {"minor-image-version", required_argument, NULL, OPTION_MINOR_IMAGE_VERSION},
  89     {"minor-os-version", required_argument, NULL, OPTION_MINOR_OS_VERSION},
  90     {"minor-subsystem-version", required_argument, NULL, OPTION_MINOR_SUBSYSTEM_VERSION},
  91     {"section-alignment", required_argument, NULL, OPTION_SECTION_ALIGNMENT},
  92     {"stack", required_argument, NULL, OPTION_STACK},
  93     {"subsystem", required_argument, NULL, OPTION_SUBSYSTEM},
  94     {NULL, no_argument, NULL, 0}
  95   };
  96
  97   *longopts = (struct option *)
  98     xrealloc (*longopts, nl * sizeof (struct option) + sizeof (xtra_long));
  99   memcpy (*longopts + nl, &xtra_long, sizeof (xtra_long));
 100 }
 101
 102
 103 /* PE/WIN32; added routines to get the subsystem type, heap and/or stack
 104    parameters which may be input from the command line */
 105
 106 typedef struct {
 107   void *ptr;
 108   int size;
 109   int value;
 110   char *symbol;
 111   int inited;
 112 } definfo;
 113
 114 #define D(field,symbol,def)  {&pe.field,sizeof(pe.field), def, symbol,0}
 115
 116 static definfo init[] =
 117 {
 118   /* imagebase must be first */
 119 #define IMAGEBASEOFF 0
 120   D(ImageBase,"__image_base__", BEOS_EXE_IMAGE_BASE),
 121 #define DLLOFF 1
 122   {&dll, sizeof(dll), 0, "__dll__", 0},
 123   D(SectionAlignment,"__section_alignment__", PE_DEF_SECTION_ALIGNMENT),
 124   D(FileAlignment,"__file_alignment__", PE_DEF_FILE_ALIGNMENT),
 125   D(MajorOperatingSystemVersion,"__major_os_version__", 4),
 126   D(MinorOperatingSystemVersion,"__minor_os_version__", 0),
 127   D(MajorImageVersion,"__major_image_version__", 1),
 128   D(MinorImageVersion,"__minor_image_version__", 0),
 129   D(MajorSubsystemVersion,"__major_subsystem_version__", 4),
 130   D(MinorSubsystemVersion,"__minor_subsystem_version__", 0),
 131   D(Subsystem,"__subsystem__", 3),
 132   D(SizeOfStackReserve,"__size_of_stack_reserve__", 0x2000000),
 133   D(SizeOfStackCommit,"__size_of_stack_commit__", 0x1000),
 134   D(SizeOfHeapReserve,"__size_of_heap_reserve__", 0x100000),
 135   D(SizeOfHeapCommit,"__size_of_heap_commit__", 0x1000),
 136   D(LoaderFlags,"__loader_flags__", 0x0),
 137   { NULL, 0, 0, NULL, 0 }
 138 };
 139
 140
 141 static void
 142 set_pe_name (char *name, long val)
 143 {
 144   int i;
 145   /* Find the name and set it. */
 146   for (i = 0; init[i].ptr; i++)
 147     {
 148       if (strcmp (name, init[i].symbol) == 0)
 149         {
 150           init[i].value = val;
 151           init[i].inited = 1;
 152           return;
 153         }
 154     }
 155   abort();
 156 }
 157
 158
 159 static void
 160 set_pe_subsystem (void)
 161 {
 162   const char *sver;
 163   int len;
 164   int i;
 165   static const struct
 166     {
 167       const char *name;
 168       const int value;
 169       const char *entry;
 170     }
 171   v[] =
 172     {
 173       { "native", 1, "_NtProcessStartup" },
 174       { "windows", 2, "_WinMainCRTStartup" },
 175       { "wwindows", 2, "_wWinMainCRTStartup" },
 176       { "console", 3, "_mainCRTStartup" },
 177       { "wconsole", 3, "_wmainCRTStartup" },
 178       { "posix", 7, "___PosixProcessStartup"},
 179       { 0, 0, 0 }
 180     };
 181
 182   sver = strchr (optarg, ':');
 183   if (sver == NULL)
 184     len = strlen (optarg);
 185   else
 186     {
 187       char *end;
 188
 189       len = sver - optarg;
 190       set_pe_name ("__major_subsystem_version__",
 191                    strtoul (sver + 1, &end, 0));
 192       if (*end == '.')
 193         set_pe_name ("__minor_subsystem_version__",
 194                      strtoul (end + 1, &end, 0));
 195       if (*end != '\0')
 196         einfo (_("%P: warning: bad version number in -subsystem option\n"));
 197     }
 198
 199   for (i = 0; v[i].name; i++)
 200     {
 201       if (strncmp (optarg, v[i].name, len) == 0
 202           && v[i].name[len] == '\0')
 203         {
 204           set_pe_name ("__subsystem__", v[i].value);
 205
 206           /* If the subsystem is windows, we use a different entry
 207              point.  */
 208           lang_default_entry (v[i].entry);
 209
 210           return;
 211         }
 212     }
 213   einfo (_("%F%P: invalid subsystem type %s\n"), optarg);
 214 }
 215
 216
 217 static void
 218 set_pe_value (char *name)
 219 {
 220   char *end;
 221   set_pe_name (name,  strtoul (optarg, &end, 0));
 222   if (end == optarg)
 223     {
 224       einfo (_("%F%P: invalid hex number for PE parameter '%s'\n"), optarg);
 225     }
 226
 227   optarg = end;
 228 }
 229
 230 static void
 231 set_pe_stack_heap (char *resname, char *comname)
 232 {
 233   set_pe_value (resname);
 234   if (*optarg == ',')
 235     {
 236       optarg++;
 237       set_pe_value (comname);
 238     }
 239   else if (*optarg)
 240     {
 241       einfo (_("%F%P: strange hex info for PE parameter '%s'\n"), optarg);
 242     }
 243 }
 244
 245
 246 static bool
 247 gld${EMULATION_NAME}_handle_option (int optc)
 248 {
 249   switch (optc)
 250     {
 251     default:
 252       return false;
 253
 254     case OPTION_BASE_FILE:
 255       link_info.base_file = fopen (optarg, FOPEN_WB);
 256       if (link_info.base_file == NULL)
 257         einfo (_("%F%P: cannot open base file %s\n"), optarg);
 258       break;
 259
 260       /* PE options */
 261     case OPTION_HEAP:
 262       set_pe_stack_heap ("__size_of_heap_reserve__", "__size_of_heap_commit__");
 263       break;
 264     case OPTION_STACK:
 265       set_pe_stack_heap ("__size_of_stack_reserve__", "__size_of_stack_commit__");
 266       break;
 267     case OPTION_SUBSYSTEM:
 268       set_pe_subsystem ();
 269       break;
 270     case OPTION_MAJOR_OS_VERSION:
 271       set_pe_value ("__major_os_version__");
 272       break;
 273     case OPTION_MINOR_OS_VERSION:
 274       set_pe_value ("__minor_os_version__");
 275       break;
 276     case OPTION_MAJOR_SUBSYSTEM_VERSION:
 277       set_pe_value ("__major_subsystem_version__");
 278       break;
 279     case OPTION_MINOR_SUBSYSTEM_VERSION:
 280       set_pe_value ("__minor_subsystem_version__");
 281       break;
 282     case OPTION_MAJOR_IMAGE_VERSION:
 283       set_pe_value ("__major_image_version__");
 284       break;
 285     case OPTION_MINOR_IMAGE_VERSION:
 286       set_pe_value ("__minor_image_version__");
 287       break;
 288     case OPTION_FILE_ALIGNMENT:
 289       set_pe_value ("__file_alignment__");
 290       break;
 291     case OPTION_SECTION_ALIGNMENT:
 292       set_pe_value ("__section_alignment__");
 293       break;
 294     case OPTION_DLL:
 295       set_pe_name ("__dll__", 1);
 296       break;
 297     case OPTION_IMAGE_BASE:
 298       set_pe_value ("__image_base__");
 299       break;
 300     }
 301   return true;
 302 }
 303 \f
 304 /* Assign values to the special symbols before the linker script is
 305    read.  */
 306
 307 static void
 308 gld${EMULATION_NAME}_set_symbols (void)
 309 {
 310   /* Run through and invent symbols for all the
 311      names and insert the defaults. */
 312   int j;
 313
 314   if (!init[IMAGEBASEOFF].inited)
 315     {
 316       if (bfd_link_relocatable (&link_info))
 317         init[IMAGEBASEOFF].value = 0;
 318       else if (init[DLLOFF].value)
 319         init[IMAGEBASEOFF].value = BEOS_DLL_IMAGE_BASE;
 320       else
 321         init[IMAGEBASEOFF].value = BEOS_EXE_IMAGE_BASE;
 322     }
 323
 324   /* Don't do any symbol assignments if this is a relocatable link.  */
 325   if (bfd_link_relocatable (&link_info))
 326     return;
 327
 328   /* Glue the assignments into the abs section */
 329   push_stat_ptr (&abs_output_section->children);
 330
 331   for (j = 0; init[j].ptr; j++)
 332     {
 333       long val = init[j].value;
 334       lang_add_assignment (exp_assign (init[j].symbol, exp_intop (val),
 335                                        false));
 336       if (init[j].size == sizeof(short))
 337         *(short *)init[j].ptr = val;
 338       else if (init[j].size == sizeof(int))
 339         *(int *)init[j].ptr = val;
 340       else if (init[j].size == sizeof(long))
 341         *(long *)init[j].ptr = val;
 342       /* This might be a long long or other special type.  */
 343       else if (init[j].size == sizeof(bfd_vma))
 344         *(bfd_vma *)init[j].ptr = val;
 345       else      abort();
 346     }
 347   /* Restore the pointer. */
 348   pop_stat_ptr ();
 349
 350   if (pe.FileAlignment >
 351       pe.SectionAlignment)
 352     {
 353       einfo (_("%P: warning, file alignment > section alignment\n"));
 354     }
 355 }
 356
 357 static void
 358 gld${EMULATION_NAME}_after_open (void)
 359 {
 360   after_open_default ();
 361
 362   /* Pass the wacky PE command line options into the output bfd.
 363      FIXME: This should be done via a function, rather than by
 364      including an internal BFD header.  */
 365   if (!obj_pe (link_info.output_bfd))
 366     {
 367       einfo (_("%F%P: PE operations on non PE file\n"));
 368     }
 369
 370   pe_data(link_info.output_bfd)->pe_opthdr = pe;
 371   pe_data(link_info.output_bfd)->dll = init[DLLOFF].value;
 372
 373 }
 374 \f
 375 /* Callback functions for qsort in sort_sections. */
 376
 377 static int
 378 sort_by_file_name (const void *a, const void *b)
 379 {
 380   const lang_input_section_type *const *ra = a;
 381   const lang_input_section_type *const *rb = b;
 382   asection *sa = (*ra)->section;
 383   asection *sb = (*rb)->section;
 384   int i, a_sec, b_sec;
 385
 386   i = filename_cmp (bfd_get_filename (sa->owner->my_archive),
 387                     bfd_get_filename (sb->owner->my_archive));
 388   if (i != 0)
 389     return i;
 390
 391   i = filename_cmp (bfd_get_filename (sa->owner),
 392                     bfd_get_filename (sb->owner));
 393   if (i != 0)
 394     return i;
 395   /* the tail idata4/5 are the only ones without relocs to an
 396      idata$6 section unless we are importing by ordinal,
 397      so sort them to last to terminate the IAT
 398      and HNT properly. if no reloc this one is import by ordinal
 399      so we have to sort by section contents */
 400
 401   if (sa->reloc_count + sb->reloc_count != 0)
 402     {
 403       i = sa->reloc_count > sb->reloc_count ? -1 : 0;
 404       if (i != 0)
 405         return i;
 406
 407       return sa->reloc_count > sb->reloc_count ? 0 : 1;
 408     }
 409   else
 410     {
 411       /* don't sort .idata$6 or .idata$7 FIXME dlltool eliminate .idata$7 */
 412       if ((strcmp (sa->name, ".idata$6") == 0))
 413         return 0;
 414
 415       if (!bfd_get_section_contents (sa->owner, sa, &a_sec, (file_ptr) 0,
 416                                      (bfd_size_type) sizeof (a_sec)))
 417         einfo (_("%F%P: %pB: can't read contents of section .idata: %E\n"),
 418                sa->owner);
 419
 420       if (!bfd_get_section_contents (sb->owner, sb, &b_sec, (file_ptr) 0,
 421                                      (bfd_size_type) sizeof (b_sec)))
 422         einfo (_("%F%P: %pB: can't read contents of section .idata: %E\n"),
 423                sb->owner);
 424
 425       i = a_sec < b_sec ? -1 : 0;
 426       if (i != 0)
 427         return i;
 428       return a_sec < b_sec ? 0 : 1;
 429     }
 430   return 0;
 431 }
 432
 433 static int
 434 sort_by_section_name (const void *a, const void *b)
 435 {
 436   const lang_input_section_type *const *ra = a;
 437   const lang_input_section_type *const *rb = b;
 438   const char *sna = (*ra)->section->name;
 439   const char *snb = (*rb)->section->name;
 440   int i;
 441   i = strcmp (sna, snb);
 442   /* This is a hack to make .stab and .stabstr last, so we don't have
 443      to fix strip/objcopy for .reloc sections.
 444      FIXME stripping images with a .rsrc section still needs to be fixed.  */
 445   if (i != 0)
 446     {
 447       if ((startswith (sna, ".stab"))
 448           && (!startswith (snb, ".stab")))
 449         return 1;
 450     }
 451   return i;
 452 }
 453
 454 /* Subroutine of sort_sections to a contiguous subset of a list of sections.
 455    NEXT_AFTER is the element after the last one to sort.
 456    The result is a pointer to the last element's "next" pointer.  */
 457
 458 static lang_statement_union_type **
 459 sort_sections_1 (lang_statement_union_type **startptr,
 460                  lang_statement_union_type *next_after,
 461                  int count,
 462                  int (*sort_func) (const void *, const void *))
 463 {
 464   lang_statement_union_type **vec;
 465   lang_statement_union_type *p;
 466   int i;
 467   lang_statement_union_type **ret;
 468
 469   if (count == 0)
 470     return startptr;
 471
 472   vec = ((lang_statement_union_type **)
 473          xmalloc (count * sizeof (lang_statement_union_type *)));
 474
 475   for (p = *startptr, i = 0; i < count; i++, p = p->header.next)
 476     vec[i] = p;
 477
 478   qsort (vec, count, sizeof (vec[0]), sort_func);
 479
 480   /* Fill in the next pointers again. */
 481   *startptr = vec[0];
 482   for (i = 0; i < count - 1; i++)
 483     vec[i]->header.next = vec[i + 1];
 484   vec[i]->header.next = next_after;
 485   ret = &vec[i]->header.next;
 486   free (vec);
 487   return ret;
 488 }
 489
 490 /* Sort the .idata\$foo input sections of archives into filename order.
 491    The reason is so dlltool can arrange to have the pe dll import information
 492    generated correctly - the head of the list goes into dh.o, the tail into
 493    dt.o, and the guts into ds[nnnn].o.  Note that this is only needed for the
 494    .idata section.
 495    FIXME: This may no longer be necessary with grouped sections.  Instead of
 496    sorting on dh.o, ds[nnnn].o, dt.o, one could, for example, have dh.o use
 497    .idata\$4h, have ds[nnnn].o use .idata\$4s[nnnn], and have dt.o use .idata\$4t.
 498    This would have to be elaborated upon to handle multiple dll's
 499    [assuming such an eloboration is possible of course].
 500
 501    We also sort sections in '\$' wild statements.  These are created by the
 502    place_orphans routine to implement grouped sections.  */
 503
 504 static void
 505 sort_sections (lang_statement_union_type *s)
 506 {
 507   for (; s ; s = s->header.next)
 508     switch (s->header.type)
 509       {
 510       case lang_output_section_statement_enum:
 511         sort_sections (s->output_section_statement.children.head);
 512         break;
 513       case lang_wild_statement_enum:
 514         {
 515           lang_statement_union_type **p = &s->wild_statement.children.head;
 516           struct wildcard_list *sec;
 517
 518           for (sec = s->wild_statement.section_list; sec; sec = sec->next)
 519             {
 520               /* Is this the .idata section?  */
 521               if (sec->spec.name != NULL
 522                   && startswith (sec->spec.name, ".idata"))
 523                 {
 524                   /* Sort the children.  We want to sort any objects in
 525                      the same archive.  In order to handle the case of
 526                      including a single archive multiple times, we sort
 527                      all the children by archive name and then by object
 528                      name.  After sorting them, we re-thread the pointer
 529                      chain.  */
 530
 531                   while (*p)
 532                     {
 533                       lang_statement_union_type *start = *p;
 534                       if (start->header.type != lang_input_section_enum
 535                           || !start->input_section.section->owner->my_archive)
 536                         p = &(start->header.next);
 537                       else
 538                         {
 539                           lang_statement_union_type *end;
 540                           int count;
 541
 542                           for (end = start, count = 0;
 543                                end && (end->header.type
 544                                        == lang_input_section_enum);
 545                                end = end->header.next)
 546                             count++;
 547
 548                           p = sort_sections_1 (p, end, count,
 549                                                sort_by_file_name);
 550                         }
 551                     }
 552                   break;
 553                 }
 554
 555               /* If this is a collection of grouped sections, sort them.
 556                  The linker script must explicitly mention "*(.foo\$)" or
 557                  "*(.foo\$*)".  Don't sort them if \$ is not the last
 558                  character (not sure if this is really useful, but it
 559                  allows explicitly mentioning some \$ sections and letting
 560                  the linker handle the rest).  */
 561               if (sec->spec.name != NULL)
 562                 {
 563                   char *q = strchr (sec->spec.name, '\$');
 564
 565                   if (q != NULL
 566                       && (q[1] == '\0'
 567                           || (q[1] == '*' && q[2] == '\0')))
 568                     {
 569                       lang_statement_union_type *end;
 570                       int count;
 571
 572                       for (end = *p, count = 0; end; end = end->header.next)
 573                         {
 574                           if (end->header.type != lang_input_section_enum)
 575                             abort ();
 576                           count++;
 577                         }
 578                       (void) sort_sections_1 (p, end, count,
 579                                               sort_by_section_name);
 580                     }
 581                   break;
 582                 }
 583             }
 584         }
 585         break;
 586       default:
 587         break;
 588       }
 589 }
 590
 591 static void
 592 gld${EMULATION_NAME}_before_allocation (void)
 593 {
 594 #ifdef TARGET_IS_armpe
 595   /* FIXME: we should be able to set the size of the interworking stub
 596      section.
 597
 598      Here we rummage through the found bfds to collect glue
 599      information.  FIXME: should this be based on a command line
 600      option?  krk@cygnus.com */
 601   {
 602     LANG_FOR_EACH_INPUT_STATEMENT (is)
 603     {
 604       if (!arm_process_before_allocation (is->the_bfd, & link_info))
 605         {
 606           einfo (_("%P: errors encountered processing file %s\n"),
 607                  is->filename);
 608         }
 609     }
 610   }
 611
 612   /* We have seen it all. Allocate it, and carry on */
 613   arm_allocate_interworking_sections (& link_info);
 614 #endif /* TARGET_IS_armpe */
 615
 616   sort_sections (stat_ptr->head);
 617
 618   before_allocation_default ();
 619 }
 620 \f
 621 /* Place an orphan section.  We use this to put sections with a '\$' in them
 622    into the right place.  Any section with a '\$' in them (e.g. .text\$foo)
 623    gets mapped to the output section with everything from the '\$' on stripped
 624    (e.g. .text).
 625    See the Microsoft Portable Executable and Common Object File Format
 626    Specification 4.1, section 4.2, Grouped Sections.
 627
 628    FIXME: This is now handled by the linker script using wildcards,
 629    but I'm leaving this here in case we want to enable it for sections
 630    which are not mentioned in the linker script.  */
 631
 632 static lang_output_section_statement_type *
 633 gld${EMULATION_NAME}_place_orphan (asection *s,
 634                                    const char *secname,
 635                                    int constraint)
 636 {
 637   char *output_secname, *ps;
 638   lang_output_section_statement_type *os;
 639   lang_statement_union_type *l;
 640
 641   if ((s->flags & SEC_ALLOC) == 0)
 642     return NULL;
 643
 644   /* Don't process grouped sections unless doing a final link.
 645      If they're marked as COMDAT sections, we don't want .text\$foo to
 646      end up in .text and then have .text disappear because it's marked
 647      link-once-discard.  */
 648   if (bfd_link_relocatable (&link_info))
 649     return NULL;
 650
 651   /* Everything from the '\$' on gets deleted so don't allow '\$' as the
 652      first character.  */
 653   if (*secname == '\$')
 654     einfo (_("%F%P: section %s has '\$' as first character\n"), secname);
 655   if (strchr (secname + 1, '\$') == NULL)
 656     return NULL;
 657
 658   /* Look up the output section.  The Microsoft specs say sections names in
 659      image files never contain a '\$'.  Fortunately, lang_..._lookup creates
 660      the section if it doesn't exist.  */
 661   output_secname = xstrdup (secname);
 662   ps = strchr (output_secname + 1, '\$');
 663   *ps = 0;
 664   os = lang_output_section_statement_lookup (output_secname, constraint, true);
 665
 666   /* Find the '\$' wild statement for this section.  We currently require the
 667      linker script to explicitly mention "*(.foo\$)".  */
 668
 669   ps[0] = '\$';
 670   ps[1] = 0;
 671   for (l = os->children.head; l; l = l->header.next)
 672     if (l->header.type == lang_wild_statement_enum)
 673       {
 674         struct wildcard_list *sec;
 675
 676         for (sec = l->wild_statement.section_list; sec; sec = sec->next)
 677           if (sec->spec.name && strcmp (sec->spec.name, output_secname) == 0)
 678             break;
 679         if (sec)
 680           break;
 681       }
 682   ps[0] = 0;
 683   if (l == NULL)
 684     einfo (_("%F%P: *(%s\$) missing from linker script\n"), output_secname);
 685
 686   /* Link the input section in and we're done for now.
 687      The sections still have to be sorted, but that has to wait until
 688      all such sections have been processed by us.  The sorting is done by
 689      sort_sections.  */
 690   lang_add_section (&l->wild_statement.children, s, NULL, NULL, os);
 691
 692   return os;
 693 }
 694 \f
 695 static char *
 696 gld${EMULATION_NAME}_get_script (int *isfile)
 697 EOF
 698
 699 if test x"$COMPILE_IN" = xyes
 700 then
 701 # Scripts compiled in.
 702
 703 # sed commands to quote an ld script as a C string.
 704 sc="-f ${srcdir}/emultempl/stringify.sed"
 705
 706 fragment <<EOF
 707 {
 708   *isfile = 0;
 709
 710   if (bfd_link_relocatable (&link_info) && config.build_constructors)
 711     return
 712 EOF
 713 sed $sc ldscripts/${EMULATION_NAME}.xu                 >> e${EMULATION_NAME}.c
 714 echo '  ; else if (bfd_link_relocatable (&link_info)) return' >> e${EMULATION_NAME}.c
 715 sed $sc ldscripts/${EMULATION_NAME}.xr                 >> e${EMULATION_NAME}.c
 716 echo '  ; else if (!config.text_read_only) return'     >> e${EMULATION_NAME}.c
 717 sed $sc ldscripts/${EMULATION_NAME}.xbn                >> e${EMULATION_NAME}.c
 718 echo '  ; else if (!config.magic_demand_paged) return' >> e${EMULATION_NAME}.c
 719 sed $sc ldscripts/${EMULATION_NAME}.xn                 >> e${EMULATION_NAME}.c
 720 echo '  ; else return'                                 >> e${EMULATION_NAME}.c
 721 sed $sc ldscripts/${EMULATION_NAME}.x                  >> e${EMULATION_NAME}.c
 722 echo '; }'                                             >> e${EMULATION_NAME}.c
 723
 724 else
 725 # Scripts read from the filesystem.
 726
 727 fragment <<EOF
 728 {
 729   *isfile = 1;
 730
 731   if (bfd_link_relocatable (&link_info) && config.build_constructors)
 732     return "ldscripts/${EMULATION_NAME}.xu";
 733   else if (bfd_link_relocatable (&link_info))
 734     return "ldscripts/${EMULATION_NAME}.xr";
 735   else if (!config.text_read_only)
 736     return "ldscripts/${EMULATION_NAME}.xbn";
 737   else if (!config.magic_demand_paged)
 738     return "ldscripts/${EMULATION_NAME}.xn";
 739   else
 740     return "ldscripts/${EMULATION_NAME}.x";
 741 }
 742 EOF
 743 fi
 744
 745 LDEMUL_AFTER_OPEN=gld${EMULATION_NAME}_after_open
 746 LDEMUL_BEFORE_ALLOCATION=gld${EMULATION_NAME}_before_allocation
 747 LDEMUL_PLACE_ORPHAN=gld${EMULATION_NAME}_place_orphan
 748 LDEMUL_SET_SYMBOLS=gld${EMULATION_NAME}_set_symbols
 749 LDEMUL_ADD_OPTIONS=gld${EMULATION_NAME}_add_options
 750 LDEMUL_HANDLE_OPTION=gld${EMULATION_NAME}_handle_option
 751
 752 source_em ${srcdir}/emultempl/emulation.em