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 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         {
 274           fprintf (stderr, "%s: Can't open base file %s\n",
 275                    program_name, optarg);
 276           xexit (1);
 277         }
 278       break;
 279
 280       /* PE options */
 281     case OPTION_HEAP:
 282       set_pe_stack_heap ("__size_of_heap_reserve__", "__size_of_heap_commit__");
 283       break;
 284     case OPTION_STACK:
 285       set_pe_stack_heap ("__size_of_stack_reserve__", "__size_of_stack_commit__");
 286       break;
 287     case OPTION_SUBSYSTEM:
 288       set_pe_subsystem ();
 289       break;
 290     case OPTION_MAJOR_OS_VERSION:
 291       set_pe_value ("__major_os_version__");
 292       break;
 293     case OPTION_MINOR_OS_VERSION:
 294       set_pe_value ("__minor_os_version__");
 295       break;
 296     case OPTION_MAJOR_SUBSYSTEM_VERSION:
 297       set_pe_value ("__major_subsystem_version__");
 298       break;
 299     case OPTION_MINOR_SUBSYSTEM_VERSION:
 300       set_pe_value ("__minor_subsystem_version__");
 301       break;
 302     case OPTION_MAJOR_IMAGE_VERSION:
 303       set_pe_value ("__major_image_version__");
 304       break;
 305     case OPTION_MINOR_IMAGE_VERSION:
 306       set_pe_value ("__minor_image_version__");
 307       break;
 308     case OPTION_FILE_ALIGNMENT:
 309       set_pe_value ("__file_alignment__");
 310       break;
 311     case OPTION_SECTION_ALIGNMENT:
 312       set_pe_value ("__section_alignment__");
 313       break;
 314     case OPTION_DLL:
 315       set_pe_name ("__dll__", 1);
 316       break;
 317     case OPTION_IMAGE_BASE:
 318       set_pe_value ("__image_base__");
 319       break;
 320     }
 321   return TRUE;
 322 }
 323 \f
 324 /* Assign values to the special symbols before the linker script is
 325    read.  */
 326
 327 static void
 328 gld_${EMULATION_NAME}_set_symbols (void)
 329 {
 330   /* Run through and invent symbols for all the
 331      names and insert the defaults. */
 332   int j;
 333
 334   if (!init[IMAGEBASEOFF].inited)
 335     {
 336       if (link_info.relocatable)
 337         init[IMAGEBASEOFF].value = 0;
 338       else if (init[DLLOFF].value)
 339         init[IMAGEBASEOFF].value = BEOS_DLL_IMAGE_BASE;
 340       else
 341         init[IMAGEBASEOFF].value = BEOS_EXE_IMAGE_BASE;
 342     }
 343
 344   /* Don't do any symbol assignments if this is a relocatable link.  */
 345   if (link_info.relocatable)
 346     return;
 347
 348   /* Glue the assignments into the abs section */
 349   push_stat_ptr (&abs_output_section->children);
 350
 351   for (j = 0; init[j].ptr; j++)
 352     {
 353       long val = init[j].value;
 354       lang_add_assignment (exp_assop ('=', init[j].symbol, exp_intop (val)));
 355       if (init[j].size == sizeof(short))
 356         *(short *)init[j].ptr = val;
 357       else if (init[j].size == sizeof(int))
 358         *(int *)init[j].ptr = val;
 359       else if (init[j].size == sizeof(long))
 360         *(long *)init[j].ptr = val;
 361       /* This might be a long long or other special type.  */
 362       else if (init[j].size == sizeof(bfd_vma))
 363         *(bfd_vma *)init[j].ptr = val;
 364       else      abort();
 365     }
 366   /* Restore the pointer. */
 367   pop_stat_ptr ();
 368
 369   if (pe.FileAlignment >
 370       pe.SectionAlignment)
 371     {
 372       einfo ("%P: warning, file alignment > section alignment.\n");
 373     }
 374 }
 375
 376 static void
 377 gld_${EMULATION_NAME}_after_open (void)
 378 {
 379   after_open_default ();
 380
 381   /* Pass the wacky PE command line options into the output bfd.
 382      FIXME: This should be done via a function, rather than by
 383      including an internal BFD header.  */
 384   if (!coff_data(link_info.output_bfd)->pe)
 385     {
 386       einfo ("%F%P: PE operations on non PE file.\n");
 387     }
 388
 389   pe_data(link_info.output_bfd)->pe_opthdr = pe;
 390   pe_data(link_info.output_bfd)->dll = init[DLLOFF].value;
 391
 392 }
 393 \f
 394 /* Callback functions for qsort in sort_sections. */
 395
 396 static int
 397 sort_by_file_name (const void *a, const void *b)
 398 {
 399   const lang_statement_union_type *const *ra = a;
 400   const lang_statement_union_type *const *rb = b;
 401   int i, a_sec, b_sec;
 402
 403   i = strcmp ((*ra)->input_section.section->owner->my_archive->filename,
 404               (*rb)->input_section.section->owner->my_archive->filename);
 405   if (i != 0)
 406     return i;
 407
 408   i = strcmp ((*ra)->input_section.section->owner->filename,
 409                  (*rb)->input_section.section->owner->filename);
 410   if (i != 0)
 411     return i;
 412   /* the tail idata4/5 are the only ones without relocs to an
 413      idata$6 section unless we are importing by ordinal,
 414      so sort them to last to terminate the IAT
 415      and HNT properly. if no reloc this one is import by ordinal
 416      so we have to sort by section contents */
 417
 418   if ( ((*ra)->input_section.section->reloc_count + (*rb)->input_section.section->reloc_count) )
 419     {
 420        i =  (((*ra)->input_section.section->reloc_count >
 421                  (*rb)->input_section.section->reloc_count) ? -1 : 0);
 422        if ( i != 0)
 423          return i;
 424
 425         return  (((*ra)->input_section.section->reloc_count >
 426                  (*rb)->input_section.section->reloc_count) ? 0 : 1);
 427     }
 428   else
 429     {
 430        if ( (strcmp( (*ra)->input_section.section->name, ".idata$6") == 0) )
 431           return 0; /* don't sort .idata$6 or .idata$7 FIXME dlltool eliminate .idata$7 */
 432
 433        if (! bfd_get_section_contents ((*ra)->input_section.section->owner,
 434          (*ra)->input_section.section, &a_sec, (file_ptr) 0, (bfd_size_type)sizeof(a_sec)))
 435             einfo ("%F%B: Can't read contents of section .idata: %E\n",
 436                  (*ra)->input_section.section->owner);
 437
 438        if (! bfd_get_section_contents ((*rb)->input_section.section->owner,
 439         (*rb)->input_section.section, &b_sec, (file_ptr) 0, (bfd_size_type)sizeof(b_sec) ))
 440            einfo ("%F%B: Can't read contents of section .idata: %E\n",
 441                 (*rb)->input_section.section->owner);
 442
 443       i =  ((a_sec < b_sec) ? -1 : 0);
 444       if ( i != 0)
 445         return i;
 446       return  ((a_sec < b_sec) ? 0 : 1);
 447    }
 448 return 0;
 449 }
 450
 451 static int
 452 sort_by_section_name (const void *a, const void *b)
 453 {
 454   const lang_statement_union_type *const *ra = a;
 455   const lang_statement_union_type *const *rb = b;
 456   int i;
 457   i = strcmp ((*ra)->input_section.section->name,
 458               (*rb)->input_section.section->name);
 459   /* This is a hack to make .stab and .stabstr last, so we don't have
 460      to fix strip/objcopy for .reloc sections.
 461      FIXME stripping images with a .rsrc section still needs to be fixed.  */
 462   if (i != 0)
 463     {
 464       if ((CONST_STRNEQ ((*ra)->input_section.section->name, ".stab"))
 465            && (! CONST_STRNEQ ((*rb)->input_section.section->name, ".stab")))
 466          return 1;
 467     }
 468   return i;
 469 }
 470
 471 /* Subroutine of sort_sections to a contiguous subset of a list of sections.
 472    NEXT_AFTER is the element after the last one to sort.
 473    The result is a pointer to the last element's "next" pointer.  */
 474
 475 static lang_statement_union_type **
 476 sort_sections_1 (lang_statement_union_type **startptr,
 477                  lang_statement_union_type *next_after,
 478                  int count,
 479                  int (*sort_func) (const void *, const void *))
 480 {
 481   lang_statement_union_type **vec;
 482   lang_statement_union_type *p;
 483   int i;
 484   lang_statement_union_type **ret;
 485
 486   if (count == 0)
 487     return startptr;
 488
 489   vec = ((lang_statement_union_type **)
 490          xmalloc (count * sizeof (lang_statement_union_type *)));
 491
 492   for (p = *startptr, i = 0; i < count; i++, p = p->header.next)
 493     vec[i] = p;
 494
 495   qsort (vec, count, sizeof (vec[0]), sort_func);
 496
 497   /* Fill in the next pointers again. */
 498   *startptr = vec[0];
 499   for (i = 0; i < count - 1; i++)
 500     vec[i]->header.next = vec[i + 1];
 501   vec[i]->header.next = next_after;
 502   ret = &vec[i]->header.next;
 503   free (vec);
 504   return ret;
 505 }
 506
 507 /* Sort the .idata\$foo input sections of archives into filename order.
 508    The reason is so dlltool can arrange to have the pe dll import information
 509    generated correctly - the head of the list goes into dh.o, the tail into
 510    dt.o, and the guts into ds[nnnn].o.  Note that this is only needed for the
 511    .idata section.
 512    FIXME: This may no longer be necessary with grouped sections.  Instead of
 513    sorting on dh.o, ds[nnnn].o, dt.o, one could, for example, have dh.o use
 514    .idata\$4h, have ds[nnnn].o use .idata\$4s[nnnn], and have dt.o use .idata\$4t.
 515    This would have to be elaborated upon to handle multiple dll's
 516    [assuming such an eloboration is possible of course].
 517
 518    We also sort sections in '\$' wild statements.  These are created by the
 519    place_orphans routine to implement grouped sections.  */
 520
 521 static void
 522 sort_sections (lang_statement_union_type *s)
 523 {
 524   for (; s ; s = s->header.next)
 525     switch (s->header.type)
 526       {
 527       case lang_output_section_statement_enum:
 528         sort_sections (s->output_section_statement.children.head);
 529         break;
 530       case lang_wild_statement_enum:
 531         {
 532           lang_statement_union_type **p = &s->wild_statement.children.head;
 533           struct wildcard_list *sec;
 534
 535           for (sec = s->wild_statement.section_list; sec; sec = sec->next)
 536             {
 537               /* Is this the .idata section?  */
 538               if (sec->spec.name != NULL
 539                   && CONST_STRNEQ (sec->spec.name, ".idata"))
 540                 {
 541                   /* Sort the children.  We want to sort any objects in
 542                      the same archive.  In order to handle the case of
 543                      including a single archive multiple times, we sort
 544                      all the children by archive name and then by object
 545                      name.  After sorting them, we re-thread the pointer
 546                      chain.  */
 547
 548                   while (*p)
 549                     {
 550                       lang_statement_union_type *start = *p;
 551                       if (start->header.type != lang_input_section_enum
 552                           || !start->input_section.section->owner->my_archive)
 553                         p = &(start->header.next);
 554                       else
 555                         {
 556                           lang_statement_union_type *end;
 557                           int count;
 558
 559                           for (end = start, count = 0;
 560                                end && (end->header.type
 561                                        == lang_input_section_enum);
 562                                end = end->header.next)
 563                             count++;
 564
 565                           p = sort_sections_1 (p, end, count,
 566                                                sort_by_file_name);
 567                         }
 568                     }
 569                   break;
 570                 }
 571
 572               /* If this is a collection of grouped sections, sort them.
 573                  The linker script must explicitly mention "*(.foo\$)" or
 574                  "*(.foo\$*)".  Don't sort them if \$ is not the last
 575                  character (not sure if this is really useful, but it
 576                  allows explicitly mentioning some \$ sections and letting
 577                  the linker handle the rest).  */
 578               if (sec->spec.name != NULL)
 579                 {
 580                   char *q = strchr (sec->spec.name, '\$');
 581
 582                   if (q != NULL
 583                       && (q[1] == '\0'
 584                           || (q[1] == '*' && q[2] == '\0')))
 585                     {
 586                       lang_statement_union_type *end;
 587                       int count;
 588
 589                       for (end = *p, count = 0; end; end = end->header.next)
 590                         {
 591                           if (end->header.type != lang_input_section_enum)
 592                             abort ();
 593                           count++;
 594                         }
 595                       (void) sort_sections_1 (p, end, count,
 596                                               sort_by_section_name);
 597                     }
 598                   break;
 599                 }
 600             }
 601         }
 602         break;
 603       default:
 604         break;
 605       }
 606 }
 607
 608 static void
 609 gld_${EMULATION_NAME}_before_allocation (void)
 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 lang_output_section_statement_type *
 665 gld${EMULATION_NAME}_place_orphan (asection *s,
 666                                    const char *secname,
 667                                    int constraint)
 668 {
 669   char *output_secname, *ps;
 670   lang_output_section_statement_type *os;
 671   lang_statement_union_type *l;
 672
 673   if ((s->flags & SEC_ALLOC) == 0)
 674     return NULL;
 675
 676   /* Don't process grouped sections unless doing a final link.
 677      If they're marked as COMDAT sections, we don't want .text\$foo to
 678      end up in .text and then have .text disappear because it's marked
 679      link-once-discard.  */
 680   if (link_info.relocatable)
 681     return NULL;
 682
 683   /* Everything from the '\$' on gets deleted so don't allow '\$' as the
 684      first character.  */
 685   if (*secname == '\$')
 686     einfo ("%P%F: section %s has '\$' as first character\n", secname);
 687   if (strchr (secname + 1, '\$') == NULL)
 688     return NULL;
 689
 690   /* Look up the output section.  The Microsoft specs say sections names in
 691      image files never contain a '\$'.  Fortunately, lang_..._lookup creates
 692      the section if it doesn't exist.  */
 693   output_secname = xstrdup (secname);
 694   ps = strchr (output_secname + 1, '\$');
 695   *ps = 0;
 696   os = lang_output_section_statement_lookup (output_secname, constraint, TRUE);
 697
 698   /* Find the '\$' wild statement for this section.  We currently require the
 699      linker script to explicitly mention "*(.foo\$)".
 700      FIXME: ppcpe.sc has .CRT\$foo in the .rdata section.  According to the
 701      Microsoft docs this isn't correct so it's not (currently) handled.  */
 702
 703   ps[0] = '\$';
 704   ps[1] = 0;
 705   for (l = os->children.head; l; l = l->header.next)
 706     if (l->header.type == lang_wild_statement_enum)
 707       {
 708         struct wildcard_list *sec;
 709
 710         for (sec = l->wild_statement.section_list; sec; sec = sec->next)
 711           if (sec->spec.name && strcmp (sec->spec.name, output_secname) == 0)
 712             break;
 713         if (sec)
 714           break;
 715       }
 716   ps[0] = 0;
 717   if (l == NULL)
 718     einfo ("%P%F: *(%s\$) missing from linker script\n", output_secname);
 719
 720   /* Link the input section in and we're done for now.
 721      The sections still have to be sorted, but that has to wait until
 722      all such sections have been processed by us.  The sorting is done by
 723      sort_sections.  */
 724   lang_add_section (&l->wild_statement.children, s, os);
 725
 726   return os;
 727 }
 728 \f
 729 static char *
 730 gld_${EMULATION_NAME}_get_script (int *isfile)
 731 EOF
 732 # Scripts compiled in.
 733 # sed commands to quote an ld script as a C string.
 734 sc="-f stringify.sed"
 735
 736 fragment <<EOF
 737 {
 738   *isfile = 0;
 739
 740   if (link_info.relocatable && config.build_constructors)
 741     return
 742 EOF
 743 sed $sc ldscripts/${EMULATION_NAME}.xu                 >> e${EMULATION_NAME}.c
 744 echo '  ; else if (link_info.relocatable) return'     >> e${EMULATION_NAME}.c
 745 sed $sc ldscripts/${EMULATION_NAME}.xr                 >> e${EMULATION_NAME}.c
 746 echo '  ; else if (!config.text_read_only) return'     >> e${EMULATION_NAME}.c
 747 sed $sc ldscripts/${EMULATION_NAME}.xbn                >> e${EMULATION_NAME}.c
 748 echo '  ; else if (!config.magic_demand_paged) return' >> e${EMULATION_NAME}.c
 749 sed $sc ldscripts/${EMULATION_NAME}.xn                 >> e${EMULATION_NAME}.c
 750 echo '  ; else return'                                 >> e${EMULATION_NAME}.c
 751 sed $sc ldscripts/${EMULATION_NAME}.x                  >> e${EMULATION_NAME}.c
 752 echo '; }'                                             >> e${EMULATION_NAME}.c
 753
 754 fragment <<EOF
 755
 756
 757 struct ld_emulation_xfer_struct ld_${EMULATION_NAME}_emulation =
 758 {
 759   gld_${EMULATION_NAME}_before_parse,
 760   syslib_default,
 761   hll_default,
 762   after_parse_default,
 763   gld_${EMULATION_NAME}_after_open,
 764   after_allocation_default,
 765   set_output_arch_default,
 766   ldemul_default_target,
 767   gld_${EMULATION_NAME}_before_allocation,
 768   gld_${EMULATION_NAME}_get_script,
 769   "${EMULATION_NAME}",
 770   "${OUTPUT_FORMAT}",
 771   finish_default,
 772   NULL, /* create output section statements */
 773   NULL, /* open dynamic archive */
 774   gld${EMULATION_NAME}_place_orphan,
 775   gld_${EMULATION_NAME}_set_symbols,
 776   NULL, /* parse_args */
 777   gld${EMULATION_NAME}_add_options,
 778   gld${EMULATION_NAME}_handle_option,
 779   NULL, /* unrecognized file */
 780   NULL, /* list options */
 781   NULL, /* recognized file */
 782   NULL, /* find_potential_libraries */
 783   NULL  /* new_vers_pattern */
 784 };
 785 EOF