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