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