1# This shell script emits a C file. -*- C -*-
2# It does some substitutions.
3if [ -z "$MACHINE" ]; then
4  OUTPUT_ARCH=${ARCH}
5else
6  OUTPUT_ARCH=${ARCH}:${MACHINE}
7fi
8fragment <<EOF
9/* This file is part of GLD, the Gnu Linker.
10   Copyright (C) 1995-2016 Free Software Foundation, Inc.
11
12   This file is part of the GNU Binutils.
13
14   This program is free software; you can redistribute it and/or modify
15   it under the terms of the GNU General Public License as published by
16   the Free Software Foundation; either version 3 of the License, or
17   (at your option) any later version.
18
19   This program is distributed in the hope that it will be useful,
20   but WITHOUT ANY WARRANTY; without even the implied warranty of
21   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
22   GNU General Public License for more details.
23
24   You should have received a copy of the GNU General Public License
25   along with this program; if not, write to the Free Software
26   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
27   MA 02110-1301, USA.  */
28
29
30/* For WINDOWS_NT */
31/* The original file generated returned different default scripts depending
32   on whether certain switches were set, but these switches pertain to the
33   Linux system and that particular version of coff.  In the NT case, we
34   only determine if the subsystem is console or windows in order to select
35   the correct entry point by default. */
36
37#include "sysdep.h"
38#include "bfd.h"
39#include "bfdlink.h"
40#include "getopt.h"
41#include "libiberty.h"
42#include "filenames.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
58static struct internal_extra_pe_aouthdr pe;
59static int dll;
60
61extern const char *output_filename;
62
63static void
64gld_${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
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
88static void
89gld${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
122typedef 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
132static 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
157static void
158set_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
175static void
176set_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
233static void
234set_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
246static void
247set_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
262static bfd_boolean
263gld${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
320/* Assign values to the special symbols before the linker script is
321   read.  */
322
323static void
324gld_${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 (bfd_link_relocatable (&link_info))
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 (bfd_link_relocatable (&link_info))
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				       FALSE));
352      if (init[j].size == sizeof(short))
353	*(short *)init[j].ptr = val;
354      else if (init[j].size == sizeof(int))
355	*(int *)init[j].ptr = val;
356      else if (init[j].size == sizeof(long))
357	*(long *)init[j].ptr = val;
358      /* This might be a long long or other special type.  */
359      else if (init[j].size == sizeof(bfd_vma))
360	*(bfd_vma *)init[j].ptr = val;
361      else	abort();
362    }
363  /* Restore the pointer. */
364  pop_stat_ptr ();
365
366  if (pe.FileAlignment >
367      pe.SectionAlignment)
368    {
369      einfo ("%P: warning, file alignment > section alignment.\n");
370    }
371}
372
373static void
374gld_${EMULATION_NAME}_after_open (void)
375{
376  after_open_default ();
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(link_info.output_bfd)->pe)
382    {
383      einfo ("%F%P: PE operations on non PE file.\n");
384    }
385
386  pe_data(link_info.output_bfd)->pe_opthdr = pe;
387  pe_data(link_info.output_bfd)->dll = init[DLLOFF].value;
388
389}
390
391/* Callback functions for qsort in sort_sections. */
392
393static int
394sort_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 = filename_cmp ((*ra)->input_section.section->owner->my_archive->filename,
401		    (*rb)->input_section.section->owner->my_archive->filename);
402  if (i != 0)
403    return i;
404
405  i = filename_cmp ((*ra)->input_section.section->owner->filename,
406		    (*rb)->input_section.section->owner->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.section->owner,
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.section->owner);
434
435       if (! bfd_get_section_contents ((*rb)->input_section.section->owner,
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.section->owner);
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   }
445return 0;
446}
447
448static int
449sort_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 ((CONST_STRNEQ ((*ra)->input_section.section->name, ".stab"))
462           && (! CONST_STRNEQ ((*rb)->input_section.section->name, ".stab")))
463         return 1;
464    }
465  return i;
466}
467
468/* Subroutine of sort_sections to a contiguous subset of a list of sections.
469   NEXT_AFTER is the element after the last one to sort.
470   The result is a pointer to the last element's "next" pointer.  */
471
472static lang_statement_union_type **
473sort_sections_1 (lang_statement_union_type **startptr,
474		 lang_statement_union_type *next_after,
475		 int count,
476		 int (*sort_func) (const void *, const void *))
477{
478  lang_statement_union_type **vec;
479  lang_statement_union_type *p;
480  int i;
481  lang_statement_union_type **ret;
482
483  if (count == 0)
484    return startptr;
485
486  vec = ((lang_statement_union_type **)
487	 xmalloc (count * sizeof (lang_statement_union_type *)));
488
489  for (p = *startptr, i = 0; i < count; i++, p = p->header.next)
490    vec[i] = p;
491
492  qsort (vec, count, sizeof (vec[0]), sort_func);
493
494  /* Fill in the next pointers again. */
495  *startptr = vec[0];
496  for (i = 0; i < count - 1; i++)
497    vec[i]->header.next = vec[i + 1];
498  vec[i]->header.next = next_after;
499  ret = &vec[i]->header.next;
500  free (vec);
501  return ret;
502}
503
504/* Sort the .idata\$foo input sections of archives into filename order.
505   The reason is so dlltool can arrange to have the pe dll import information
506   generated correctly - the head of the list goes into dh.o, the tail into
507   dt.o, and the guts into ds[nnnn].o.  Note that this is only needed for the
508   .idata section.
509   FIXME: This may no longer be necessary with grouped sections.  Instead of
510   sorting on dh.o, ds[nnnn].o, dt.o, one could, for example, have dh.o use
511   .idata\$4h, have ds[nnnn].o use .idata\$4s[nnnn], and have dt.o use .idata\$4t.
512   This would have to be elaborated upon to handle multiple dll's
513   [assuming such an eloboration is possible of course].
514
515   We also sort sections in '\$' wild statements.  These are created by the
516   place_orphans routine to implement grouped sections.  */
517
518static void
519sort_sections (lang_statement_union_type *s)
520{
521  for (; s ; s = s->header.next)
522    switch (s->header.type)
523      {
524      case lang_output_section_statement_enum:
525	sort_sections (s->output_section_statement.children.head);
526	break;
527      case lang_wild_statement_enum:
528	{
529	  lang_statement_union_type **p = &s->wild_statement.children.head;
530	  struct wildcard_list *sec;
531
532	  for (sec = s->wild_statement.section_list; sec; sec = sec->next)
533	    {
534	      /* Is this the .idata section?  */
535	      if (sec->spec.name != NULL
536		  && CONST_STRNEQ (sec->spec.name, ".idata"))
537		{
538		  /* Sort the children.  We want to sort any objects in
539		     the same archive.  In order to handle the case of
540		     including a single archive multiple times, we sort
541		     all the children by archive name and then by object
542		     name.  After sorting them, we re-thread the pointer
543		     chain.  */
544
545		  while (*p)
546		    {
547		      lang_statement_union_type *start = *p;
548		      if (start->header.type != lang_input_section_enum
549			  || !start->input_section.section->owner->my_archive)
550			p = &(start->header.next);
551		      else
552			{
553			  lang_statement_union_type *end;
554			  int count;
555
556			  for (end = start, count = 0;
557			       end && (end->header.type
558				       == lang_input_section_enum);
559			       end = end->header.next)
560			    count++;
561
562			  p = sort_sections_1 (p, end, count,
563					       sort_by_file_name);
564			}
565		    }
566		  break;
567		}
568
569	      /* If this is a collection of grouped sections, sort them.
570		 The linker script must explicitly mention "*(.foo\$)" or
571		 "*(.foo\$*)".  Don't sort them if \$ is not the last
572		 character (not sure if this is really useful, but it
573		 allows explicitly mentioning some \$ sections and letting
574		 the linker handle the rest).  */
575	      if (sec->spec.name != NULL)
576		{
577		  char *q = strchr (sec->spec.name, '\$');
578
579		  if (q != NULL
580		      && (q[1] == '\0'
581			  || (q[1] == '*' && q[2] == '\0')))
582		    {
583		      lang_statement_union_type *end;
584		      int count;
585
586		      for (end = *p, count = 0; end; end = end->header.next)
587			{
588			  if (end->header.type != lang_input_section_enum)
589			    abort ();
590			  count++;
591			}
592		      (void) sort_sections_1 (p, end, count,
593					      sort_by_section_name);
594		    }
595		  break;
596		}
597	    }
598	}
599	break;
600      default:
601	break;
602      }
603}
604
605static void
606gld_${EMULATION_NAME}_before_allocation (void)
607{
608#ifdef TARGET_IS_ppcpe
609  /* Here we rummage through the found bfds to collect toc information */
610  {
611    LANG_FOR_EACH_INPUT_STATEMENT (is)
612      {
613	if (!ppc_process_before_allocation(is->the_bfd, &link_info))
614	  {
615	    einfo("Errors encountered processing file %s\n", is->filename);
616	  }
617      }
618  }
619
620  /* We have seen it all. Allocate it, and carry on */
621  ppc_allocate_toc_section (&link_info);
622#else
623#ifdef TARGET_IS_armpe
624  /* FIXME: we should be able to set the size of the interworking stub
625     section.
626
627     Here we rummage through the found bfds to collect glue
628     information.  FIXME: should this be based on a command line
629     option?  krk@cygnus.com */
630  {
631    LANG_FOR_EACH_INPUT_STATEMENT (is)
632      {
633	if (!arm_process_before_allocation (is->the_bfd, & link_info))
634	  {
635	    einfo ("Errors encountered processing file %s", is->filename);
636	  }
637      }
638  }
639
640  /* We have seen it all. Allocate it, and carry on */
641  arm_allocate_interworking_sections (& link_info);
642#endif /* TARGET_IS_armpe */
643#endif /* TARGET_IS_ppcpe */
644
645  sort_sections (stat_ptr->head);
646
647  before_allocation_default ();
648}
649
650/* Place an orphan section.  We use this to put sections with a '\$' in them
651   into the right place.  Any section with a '\$' in them (e.g. .text\$foo)
652   gets mapped to the output section with everything from the '\$' on stripped
653   (e.g. .text).
654   See the Microsoft Portable Executable and Common Object File Format
655   Specification 4.1, section 4.2, Grouped Sections.
656
657   FIXME: This is now handled by the linker script using wildcards,
658   but I'm leaving this here in case we want to enable it for sections
659   which are not mentioned in the linker script.  */
660
661static lang_output_section_statement_type *
662gld${EMULATION_NAME}_place_orphan (asection *s,
663				   const char *secname,
664				   int constraint)
665{
666  char *output_secname, *ps;
667  lang_output_section_statement_type *os;
668  lang_statement_union_type *l;
669
670  if ((s->flags & SEC_ALLOC) == 0)
671    return NULL;
672
673  /* Don't process grouped sections unless doing a final link.
674     If they're marked as COMDAT sections, we don't want .text\$foo to
675     end up in .text and then have .text disappear because it's marked
676     link-once-discard.  */
677  if (bfd_link_relocatable (&link_info))
678    return NULL;
679
680  /* Everything from the '\$' on gets deleted so don't allow '\$' as the
681     first character.  */
682  if (*secname == '\$')
683    einfo ("%P%F: section %s has '\$' as first character\n", secname);
684  if (strchr (secname + 1, '\$') == NULL)
685    return NULL;
686
687  /* Look up the output section.  The Microsoft specs say sections names in
688     image files never contain a '\$'.  Fortunately, lang_..._lookup creates
689     the section if it doesn't exist.  */
690  output_secname = xstrdup (secname);
691  ps = strchr (output_secname + 1, '\$');
692  *ps = 0;
693  os = lang_output_section_statement_lookup (output_secname, constraint, TRUE);
694
695  /* Find the '\$' wild statement for this section.  We currently require the
696     linker script to explicitly mention "*(.foo\$)".
697     FIXME: ppcpe.sc has .CRT\$foo in the .rdata section.  According to the
698     Microsoft docs this isn't correct so it's not (currently) handled.  */
699
700  ps[0] = '\$';
701  ps[1] = 0;
702  for (l = os->children.head; l; l = l->header.next)
703    if (l->header.type == lang_wild_statement_enum)
704      {
705	struct wildcard_list *sec;
706
707	for (sec = l->wild_statement.section_list; sec; sec = sec->next)
708	  if (sec->spec.name && strcmp (sec->spec.name, output_secname) == 0)
709	    break;
710	if (sec)
711	  break;
712      }
713  ps[0] = 0;
714  if (l == NULL)
715    einfo ("%P%F: *(%s\$) missing from linker script\n", output_secname);
716
717  /* Link the input section in and we're done for now.
718     The sections still have to be sorted, but that has to wait until
719     all such sections have been processed by us.  The sorting is done by
720     sort_sections.  */
721  lang_add_section (&l->wild_statement.children, s, NULL, os);
722
723  return os;
724}
725
726static char *
727gld_${EMULATION_NAME}_get_script (int *isfile)
728EOF
729# Scripts compiled in.
730# sed commands to quote an ld script as a C string.
731sc="-f stringify.sed"
732
733fragment <<EOF
734{
735  *isfile = 0;
736
737  if (bfd_link_relocatable (&link_info) && config.build_constructors)
738    return
739EOF
740sed $sc ldscripts/${EMULATION_NAME}.xu                 >> e${EMULATION_NAME}.c
741echo '  ; else if (bfd_link_relocatable (&link_info)) return' >> e${EMULATION_NAME}.c
742sed $sc ldscripts/${EMULATION_NAME}.xr                 >> e${EMULATION_NAME}.c
743echo '  ; else if (!config.text_read_only) return'     >> e${EMULATION_NAME}.c
744sed $sc ldscripts/${EMULATION_NAME}.xbn                >> e${EMULATION_NAME}.c
745echo '  ; else if (!config.magic_demand_paged) return' >> e${EMULATION_NAME}.c
746sed $sc ldscripts/${EMULATION_NAME}.xn                 >> e${EMULATION_NAME}.c
747echo '  ; else return'                                 >> e${EMULATION_NAME}.c
748sed $sc ldscripts/${EMULATION_NAME}.x                  >> e${EMULATION_NAME}.c
749echo '; }'                                             >> e${EMULATION_NAME}.c
750
751fragment <<EOF
752
753
754struct ld_emulation_xfer_struct ld_${EMULATION_NAME}_emulation =
755{
756  gld_${EMULATION_NAME}_before_parse,
757  syslib_default,
758  hll_default,
759  after_parse_default,
760  gld_${EMULATION_NAME}_after_open,
761  after_allocation_default,
762  set_output_arch_default,
763  ldemul_default_target,
764  gld_${EMULATION_NAME}_before_allocation,
765  gld_${EMULATION_NAME}_get_script,
766  "${EMULATION_NAME}",
767  "${OUTPUT_FORMAT}",
768  finish_default,
769  NULL, /* create output section statements */
770  NULL, /* open dynamic archive */
771  gld${EMULATION_NAME}_place_orphan,
772  gld_${EMULATION_NAME}_set_symbols,
773  NULL, /* parse_args */
774  gld${EMULATION_NAME}_add_options,
775  gld${EMULATION_NAME}_handle_option,
776  NULL,	/* unrecognized file */
777  NULL,	/* list options */
778  NULL,	/* recognized file */
779  NULL,	/* find_potential_libraries */
780  NULL,	/* new_vers_pattern */
781  NULL	/* extra_map_file_text */
782};
783EOF
784