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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, 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.  We also register the entry point as an undefined
 220              symbol. from lang_add_entry() The reason we do
 221              this is so that the user
 222              doesn't have to because they would have to use the -u
 223              switch if they were specifying an entry point other than
 224              _mainCRTStartup.  Specifically, if creating a windows
 225              application, entry point _WinMainCRTStartup must be
 226              specified.  What I have found for non console
 227              applications (entry not _mainCRTStartup) is that the .obj
 228              that contains mainCRTStartup is brought in since it is
 229              the first encountered in libc.lib and it has other
 230              symbols in it which will be pulled in by the link
 231              process.  To avoid this, adding -u with the entry point
 232              name specified forces the correct .obj to be used.  We
 233              can avoid making the user do this by always adding the
 234              entry point name as an undefined symbol.  */
 235           lang_add_entry (v[i].entry, 1);
 236
 237           return;
 238         }
 239     }
 240   einfo ("%P%F: invalid subsystem type %s\n", optarg);
 241 }
 242
 243
 244 static void
 245 set_pe_value (char *name)
 246 {
 247   char *end;
 248   set_pe_name (name,  strtoul (optarg, &end, 0));
 249   if (end == optarg)
 250     {
 251       einfo ("%P%F: invalid hex number for PE parameter '%s'\n", optarg);
 252     }
 253
 254   optarg = end;
 255 }
 256
 257 static void
 258 set_pe_stack_heap (char *resname, char *comname)
 259 {
 260   set_pe_value (resname);
 261   if (*optarg == ',')
 262     {
 263       optarg++;
 264       set_pe_value (comname);
 265     }
 266   else if (*optarg)
 267     {
 268       einfo ("%P%F: strange hex info for PE parameter '%s'\n", optarg);
 269     }
 270 }
 271
 272
 273 static bfd_boolean
 274 gld${EMULATION_NAME}_handle_option (int optc)
 275 {
 276   switch (optc)
 277     {
 278     default:
 279       return FALSE;
 280
 281     case OPTION_BASE_FILE:
 282       link_info.base_file = fopen (optarg, FOPEN_WB);
 283       if (link_info.base_file == NULL)
 284         {
 285           fprintf (stderr, "%s: Can't open base file %s\n",
 286                    program_name, optarg);
 287           xexit (1);
 288         }
 289       break;
 290
 291       /* PE options */
 292     case OPTION_HEAP:
 293       set_pe_stack_heap ("__size_of_heap_reserve__", "__size_of_heap_commit__");
 294       break;
 295     case OPTION_STACK:
 296       set_pe_stack_heap ("__size_of_stack_reserve__", "__size_of_stack_commit__");
 297       break;
 298     case OPTION_SUBSYSTEM:
 299       set_pe_subsystem ();
 300       break;
 301     case OPTION_MAJOR_OS_VERSION:
 302       set_pe_value ("__major_os_version__");
 303       break;
 304     case OPTION_MINOR_OS_VERSION:
 305       set_pe_value ("__minor_os_version__");
 306       break;
 307     case OPTION_MAJOR_SUBSYSTEM_VERSION:
 308       set_pe_value ("__major_subsystem_version__");
 309       break;
 310     case OPTION_MINOR_SUBSYSTEM_VERSION:
 311       set_pe_value ("__minor_subsystem_version__");
 312       break;
 313     case OPTION_MAJOR_IMAGE_VERSION:
 314       set_pe_value ("__major_image_version__");
 315       break;
 316     case OPTION_MINOR_IMAGE_VERSION:
 317       set_pe_value ("__minor_image_version__");
 318       break;
 319     case OPTION_FILE_ALIGNMENT:
 320       set_pe_value ("__file_alignment__");
 321       break;
 322     case OPTION_SECTION_ALIGNMENT:
 323       set_pe_value ("__section_alignment__");
 324       break;
 325     case OPTION_DLL:
 326       set_pe_name ("__dll__", 1);
 327       break;
 328     case OPTION_IMAGE_BASE:
 329       set_pe_value ("__image_base__");
 330       break;
 331     }
 332   return TRUE;
 333 }
 334 \f
 335 /* Assign values to the special symbols before the linker script is
 336    read.  */
 337
 338 static void
 339 gld_${EMULATION_NAME}_set_symbols (void)
 340 {
 341   /* Run through and invent symbols for all the
 342      names and insert the defaults. */
 343   int j;
 344   lang_statement_list_type *save;
 345
 346   if (!init[IMAGEBASEOFF].inited)
 347     {
 348       if (link_info.relocatable)
 349         init[IMAGEBASEOFF].value = 0;
 350       else if (init[DLLOFF].value)
 351         init[IMAGEBASEOFF].value = BEOS_DLL_IMAGE_BASE;
 352       else
 353         init[IMAGEBASEOFF].value = BEOS_EXE_IMAGE_BASE;
 354     }
 355
 356   /* Don't do any symbol assignments if this is a relocatable link.  */
 357   if (link_info.relocatable)
 358     return;
 359
 360   /* Glue the assignments into the abs section */
 361   save = stat_ptr;
 362
 363   stat_ptr = &(abs_output_section->children);
 364
 365   for (j = 0; init[j].ptr; j++)
 366     {
 367       long val = init[j].value;
 368       lang_add_assignment (exp_assop ('=', init[j].symbol, exp_intop (val)));
 369       if (init[j].size == sizeof(short))
 370         *(short *)init[j].ptr = val;
 371       else if (init[j].size == sizeof(int))
 372         *(int *)init[j].ptr = val;
 373       else if (init[j].size == sizeof(long))
 374         *(long *)init[j].ptr = val;
 375       /* This might be a long long or other special type.  */
 376       else if (init[j].size == sizeof(bfd_vma))
 377         *(bfd_vma *)init[j].ptr = val;
 378       else      abort();
 379     }
 380   /* Restore the pointer. */
 381   stat_ptr = save;
 382
 383   if (pe.FileAlignment >
 384       pe.SectionAlignment)
 385     {
 386       einfo ("%P: warning, file alignment > section alignment.\n");
 387     }
 388 }
 389
 390 static void
 391 gld_${EMULATION_NAME}_after_open (void)
 392 {
 393   /* Pass the wacky PE command line options into the output bfd.
 394      FIXME: This should be done via a function, rather than by
 395      including an internal BFD header.  */
 396   if (!coff_data(output_bfd)->pe)
 397     {
 398       einfo ("%F%P: PE operations on non PE file.\n");
 399     }
 400
 401   pe_data(output_bfd)->pe_opthdr = pe;
 402   pe_data(output_bfd)->dll = init[DLLOFF].value;
 403
 404 }
 405 \f
 406 /* Callback functions for qsort in sort_sections. */
 407
 408 static int
 409 sort_by_file_name (const void *a, const void *b)
 410 {
 411   const lang_statement_union_type *const *ra = a;
 412   const lang_statement_union_type *const *rb = b;
 413   int i, a_sec, b_sec;
 414
 415   i = strcmp ((*ra)->input_section.ifile->the_bfd->my_archive->filename,
 416               (*rb)->input_section.ifile->the_bfd->my_archive->filename);
 417   if (i != 0)
 418     return i;
 419
 420   i = strcmp ((*ra)->input_section.ifile->filename,
 421                  (*rb)->input_section.ifile->filename);
 422   if (i != 0)
 423     return i;
 424   /* the tail idata4/5 are the only ones without relocs to an
 425      idata$6 section unless we are importing by ordinal,
 426      so sort them to last to terminate the IAT
 427      and HNT properly. if no reloc this one is import by ordinal
 428      so we have to sort by section contents */
 429
 430   if ( ((*ra)->input_section.section->reloc_count + (*rb)->input_section.section->reloc_count) )
 431     {
 432        i =  (((*ra)->input_section.section->reloc_count >
 433                  (*rb)->input_section.section->reloc_count) ? -1 : 0);
 434        if ( i != 0)
 435          return i;
 436
 437         return  (((*ra)->input_section.section->reloc_count >
 438                  (*rb)->input_section.section->reloc_count) ? 0 : 1);
 439     }
 440   else
 441     {
 442        if ( (strcmp( (*ra)->input_section.section->name, ".idata$6") == 0) )
 443           return 0; /* don't sort .idata$6 or .idata$7 FIXME dlltool eliminate .idata$7 */
 444
 445        if (! bfd_get_section_contents ((*ra)->input_section.ifile->the_bfd,
 446          (*ra)->input_section.section, &a_sec, (file_ptr) 0, (bfd_size_type)sizeof(a_sec)))
 447             einfo ("%F%B: Can't read contents of section .idata: %E\n",
 448                  (*ra)->input_section.ifile->the_bfd);
 449
 450        if (! bfd_get_section_contents ((*rb)->input_section.ifile->the_bfd,
 451         (*rb)->input_section.section, &b_sec, (file_ptr) 0, (bfd_size_type)sizeof(b_sec) ))
 452            einfo ("%F%B: Can't read contents of section .idata: %E\n",
 453                 (*rb)->input_section.ifile->the_bfd);
 454
 455       i =  ((a_sec < b_sec) ? -1 : 0);
 456       if ( i != 0)
 457         return i;
 458       return  ((a_sec < b_sec) ? 0 : 1);
 459    }
 460 return 0;
 461 }
 462
 463 static int
 464 sort_by_section_name (const void *a, const void *b)
 465 {
 466   const lang_statement_union_type *const *ra = a;
 467   const lang_statement_union_type *const *rb = b;
 468   int i;
 469   i = strcmp ((*ra)->input_section.section->name,
 470                  (*rb)->input_section.section->name);
 471 /* this is a hack to make .stab and .stabstr last, so we don't have
 472    to fix strip/objcopy for .reloc sections.
 473    FIXME stripping images with a .rsrc section still needs to be fixed */
 474   if ( i != 0)
 475     {
 476       if ((strncmp ((*ra)->input_section.section->name, ".stab", 5) == 0)
 477            && (strncmp ((*rb)->input_section.section->name, ".stab", 5) != 0))
 478          return 1;
 479       return i;
 480     }
 481   return i;
 482 }
 483
 484 /* Subroutine of sort_sections to a contiguous subset of a list of sections.
 485    NEXT_AFTER is the element after the last one to sort.
 486    The result is a pointer to the last element's "next" pointer.  */
 487
 488 static lang_statement_union_type **
 489 sort_sections_1 (lang_statement_union_type **startptr,
 490                  lang_statement_union_type *next_after,
 491                  int count,
 492                  int (*sort_func) (const void *, const void *))
 493 {
 494   lang_statement_union_type **vec;
 495   lang_statement_union_type *p;
 496   int i;
 497   lang_statement_union_type **ret;
 498
 499   if (count == 0)
 500     return startptr;
 501
 502   vec = ((lang_statement_union_type **)
 503          xmalloc (count * sizeof (lang_statement_union_type *)));
 504
 505   for (p = *startptr, i = 0; i < count; i++, p = p->header.next)
 506     vec[i] = p;
 507
 508   qsort (vec, count, sizeof (vec[0]), sort_func);
 509
 510   /* Fill in the next pointers again. */
 511   *startptr = vec[0];
 512   for (i = 0; i < count - 1; i++)
 513     vec[i]->header.next = vec[i + 1];
 514   vec[i]->header.next = next_after;
 515   ret = &vec[i]->header.next;
 516   free (vec);
 517   return ret;
 518 }
 519
 520 /* Sort the .idata\$foo input sections of archives into filename order.
 521    The reason is so dlltool can arrange to have the pe dll import information
 522    generated correctly - the head of the list goes into dh.o, the tail into
 523    dt.o, and the guts into ds[nnnn].o.  Note that this is only needed for the
 524    .idata section.
 525    FIXME: This may no longer be necessary with grouped sections.  Instead of
 526    sorting on dh.o, ds[nnnn].o, dt.o, one could, for example, have dh.o use
 527    .idata\$4h, have ds[nnnn].o use .idata\$4s[nnnn], and have dt.o use .idata\$4t.
 528    This would have to be elaborated upon to handle multiple dll's
 529    [assuming such an eloboration is possible of course].
 530
 531    We also sort sections in '\$' wild statements.  These are created by the
 532    place_orphans routine to implement grouped sections.  */
 533
 534 static void
 535 sort_sections (lang_statement_union_type *s)
 536 {
 537   for (; s ; s = s->header.next)
 538     switch (s->header.type)
 539       {
 540       case lang_output_section_statement_enum:
 541         sort_sections (s->output_section_statement.children.head);
 542         break;
 543       case lang_wild_statement_enum:
 544         {
 545           lang_statement_union_type **p = &s->wild_statement.children.head;
 546           struct wildcard_list *sec;
 547
 548           for (sec = s->wild_statement.section_list; sec; sec = sec->next)
 549             {
 550               /* Is this the .idata section?  */
 551               if (sec->spec.name != NULL
 552                   && strncmp (sec->spec.name, ".idata", 6) == 0)
 553                 {
 554                   /* Sort the children.  We want to sort any objects in
 555                      the same archive.  In order to handle the case of
 556                      including a single archive multiple times, we sort
 557                      all the children by archive name and then by object
 558                      name.  After sorting them, we re-thread the pointer
 559                      chain.  */
 560
 561                   while (*p)
 562                     {
 563                       lang_statement_union_type *start = *p;
 564                       if (start->header.type != lang_input_section_enum
 565                           || !start->input_section.ifile->the_bfd->my_archive)
 566                         p = &(start->header.next);
 567                       else
 568                         {
 569                           lang_statement_union_type *end;
 570                           int count;
 571
 572                           for (end = start, count = 0;
 573                                end && (end->header.type
 574                                        == lang_input_section_enum);
 575                                end = end->header.next)
 576                             count++;
 577
 578                           p = sort_sections_1 (p, end, count,
 579                                                sort_by_file_name);
 580                         }
 581                     }
 582                   break;
 583                 }
 584
 585               /* If this is a collection of grouped sections, sort them.
 586                  The linker script must explicitly mention "*(.foo\$)" or
 587                  "*(.foo\$*)".  Don't sort them if \$ is not the last
 588                  character (not sure if this is really useful, but it
 589                  allows explicitly mentioning some \$ sections and letting
 590                  the linker handle the rest).  */
 591               if (sec->spec.name != NULL)
 592                 {
 593                   char *q = strchr (sec->spec.name, '\$');
 594
 595                   if (q != NULL
 596                       && (q[1] == '\0'
 597                           || (q[1] == '*' && q[2] == '\0')))
 598                     {
 599                       lang_statement_union_type *end;
 600                       int count;
 601
 602                       for (end = *p, count = 0; end; end = end->header.next)
 603                         {
 604                           if (end->header.type != lang_input_section_enum)
 605                             abort ();
 606                           count++;
 607                         }
 608                       (void) sort_sections_1 (p, end, count,
 609                                               sort_by_section_name);
 610                     }
 611                   break;
 612                 }
 613             }
 614         }
 615         break;
 616       default:
 617         break;
 618       }
 619 }
 620
 621 static void
 622 gld_${EMULATION_NAME}_before_allocation (void)
 623 {
 624   extern lang_statement_list_type *stat_ptr;
 625
 626 #ifdef TARGET_IS_ppcpe
 627   /* Here we rummage through the found bfds to collect toc information */
 628   {
 629     LANG_FOR_EACH_INPUT_STATEMENT (is)
 630       {
 631         if (!ppc_process_before_allocation(is->the_bfd, &link_info))
 632           {
 633             einfo("Errors encountered processing file %s\n", is->filename);
 634           }
 635       }
 636   }
 637
 638   /* We have seen it all. Allocate it, and carry on */
 639   ppc_allocate_toc_section (&link_info);
 640 #else
 641 #ifdef TARGET_IS_armpe
 642   /* FIXME: we should be able to set the size of the interworking stub
 643      section.
 644
 645      Here we rummage through the found bfds to collect glue
 646      information.  FIXME: should this be based on a command line
 647      option?  krk@cygnus.com */
 648   {
 649     LANG_FOR_EACH_INPUT_STATEMENT (is)
 650       {
 651         if (!arm_process_before_allocation (is->the_bfd, & link_info))
 652           {
 653             einfo ("Errors encountered processing file %s", is->filename);
 654           }
 655       }
 656   }
 657
 658   /* We have seen it all. Allocate it, and carry on */
 659   arm_allocate_interworking_sections (& link_info);
 660 #endif /* TARGET_IS_armpe */
 661 #endif /* TARGET_IS_ppcpe */
 662
 663   sort_sections (stat_ptr->head);
 664 }
 665 \f
 666 /* Place an orphan section.  We use this to put sections with a '\$' in them
 667    into the right place.  Any section with a '\$' in them (e.g. .text\$foo)
 668    gets mapped to the output section with everything from the '\$' on stripped
 669    (e.g. .text).
 670    See the Microsoft Portable Executable and Common Object File Format
 671    Specification 4.1, section 4.2, Grouped Sections.
 672
 673    FIXME: This is now handled by the linker script using wildcards,
 674    but I'm leaving this here in case we want to enable it for sections
 675    which are not mentioned in the linker script.  */
 676
 677 static bfd_boolean
 678 gld${EMULATION_NAME}_place_orphan (lang_input_statement_type *file, asection *s)
 679 {
 680   const char *secname;
 681   char *output_secname, *ps;
 682   lang_output_section_statement_type *os;
 683   lang_statement_union_type *l;
 684
 685   if ((s->flags & SEC_ALLOC) == 0)
 686     return FALSE;
 687
 688   /* Don't process grouped sections unless doing a final link.
 689      If they're marked as COMDAT sections, we don't want .text\$foo to
 690      end up in .text and then have .text disappear because it's marked
 691      link-once-discard.  */
 692   if (link_info.relocatable)
 693     return FALSE;
 694
 695   secname = bfd_get_section_name (s->owner, s);
 696
 697   /* Everything from the '\$' on gets deleted so don't allow '\$' as the
 698      first character.  */
 699   if (*secname == '\$')
 700     einfo ("%P%F: section %s has '\$' as first character\n", secname);
 701   if (strchr (secname + 1, '\$') == NULL)
 702     return FALSE;
 703
 704   /* Look up the output section.  The Microsoft specs say sections names in
 705      image files never contain a '\$'.  Fortunately, lang_..._lookup creates
 706      the section if it doesn't exist.  */
 707   output_secname = xstrdup (secname);
 708   ps = strchr (output_secname + 1, '\$');
 709   *ps = 0;
 710   os = lang_output_section_statement_lookup (output_secname);
 711
 712   /* Find the '\$' wild statement for this section.  We currently require the
 713      linker script to explicitly mention "*(.foo\$)".
 714      FIXME: ppcpe.sc has .CRT\$foo in the .rdata section.  According to the
 715      Microsoft docs this isn't correct so it's not (currently) handled.  */
 716
 717   ps[0] = '\$';
 718   ps[1] = 0;
 719   for (l = os->children.head; l; l = l->header.next)
 720     if (l->header.type == lang_wild_statement_enum)
 721       {
 722         struct wildcard_list *sec;
 723
 724         for (sec = l->wild_statement.section_list; sec; sec = sec->next)
 725           if (sec->spec.name && strcmp (sec->spec.name, output_secname) == 0)
 726             break;
 727         if (sec)
 728           break;
 729       }
 730   ps[0] = 0;
 731   if (l == NULL)
 732     einfo ("%P%F: *(%s\$) missing from linker script\n", output_secname);
 733
 734   /* Link the input section in and we're done for now.
 735      The sections still have to be sorted, but that has to wait until
 736      all such sections have been processed by us.  The sorting is done by
 737      sort_sections.  */
 738   lang_add_section (&l->wild_statement.children, s, os, file);
 739
 740   return TRUE;
 741 }
 742 \f
 743 static char *
 744 gld_${EMULATION_NAME}_get_script (int *isfile)
 745 EOF
 746 # Scripts compiled in.
 747 # sed commands to quote an ld script as a C string.
 748 sc="-f stringify.sed"
 749
 750 cat >>e${EMULATION_NAME}.c <<EOF
 751 {
 752   *isfile = 0;
 753
 754   if (link_info.relocatable && config.build_constructors)
 755     return
 756 EOF
 757 sed $sc ldscripts/${EMULATION_NAME}.xu                 >> e${EMULATION_NAME}.c
 758 echo '  ; else if (link_info.relocatable) return'     >> e${EMULATION_NAME}.c
 759 sed $sc ldscripts/${EMULATION_NAME}.xr                 >> e${EMULATION_NAME}.c
 760 echo '  ; else if (!config.text_read_only) return'     >> e${EMULATION_NAME}.c
 761 sed $sc ldscripts/${EMULATION_NAME}.xbn                >> e${EMULATION_NAME}.c
 762 echo '  ; else if (!config.magic_demand_paged) return' >> e${EMULATION_NAME}.c
 763 sed $sc ldscripts/${EMULATION_NAME}.xn                 >> e${EMULATION_NAME}.c
 764 echo '  ; else return'                                 >> e${EMULATION_NAME}.c
 765 sed $sc ldscripts/${EMULATION_NAME}.x                  >> e${EMULATION_NAME}.c
 766 echo '; }'                                             >> e${EMULATION_NAME}.c
 767
 768 cat >>e${EMULATION_NAME}.c <<EOF
 769
 770
 771 struct ld_emulation_xfer_struct ld_${EMULATION_NAME}_emulation =
 772 {
 773   gld_${EMULATION_NAME}_before_parse,
 774   syslib_default,
 775   hll_default,
 776   after_parse_default,
 777   gld_${EMULATION_NAME}_after_open,
 778   after_allocation_default,
 779   set_output_arch_default,
 780   ldemul_default_target,
 781   gld_${EMULATION_NAME}_before_allocation,
 782   gld_${EMULATION_NAME}_get_script,
 783   "${EMULATION_NAME}",
 784   "${OUTPUT_FORMAT}",
 785   NULL, /* finish */
 786   NULL, /* create output section statements */
 787   NULL, /* open dynamic archive */
 788   gld${EMULATION_NAME}_place_orphan,
 789   gld_${EMULATION_NAME}_set_symbols,
 790   NULL, /* parse_args */
 791   gld${EMULATION_NAME}_add_options,
 792   gld${EMULATION_NAME}_handle_option,
 793   NULL, /* unrecognized file */
 794   NULL, /* list options */
 795   NULL, /* recognized file */
 796   NULL, /* find_potential_libraries */
 797   NULL  /* new_vers_pattern */
 798 };
 799 EOF