OpenCores
URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [binutils-2.20.1/] [ld/] [emultempl/] [beos.em] - Blame information for rev 301

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 205 julius
# 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 <
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 
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
 
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
 
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
  /* Pass the wacky PE command line options into the output bfd.
380
     FIXME: This should be done via a function, rather than by
381
     including an internal BFD header.  */
382
  if (!coff_data(link_info.output_bfd)->pe)
383
    {
384
      einfo ("%F%P: PE operations on non PE file.\n");
385
    }
386
 
387
  pe_data(link_info.output_bfd)->pe_opthdr = pe;
388
  pe_data(link_info.output_bfd)->dll = init[DLLOFF].value;
389
 
390
}
391
 
392
/* Callback functions for qsort in sort_sections. */
393
 
394
static int
395
sort_by_file_name (const void *a, const void *b)
396
{
397
  const lang_statement_union_type *const *ra = a;
398
  const lang_statement_union_type *const *rb = b;
399
  int i, a_sec, b_sec;
400
 
401
  i = strcmp ((*ra)->input_section.section->owner->my_archive->filename,
402
              (*rb)->input_section.section->owner->my_archive->filename);
403
  if (i != 0)
404
    return i;
405
 
406
  i = strcmp ((*ra)->input_section.section->owner->filename,
407
                 (*rb)->input_section.section->owner->filename);
408
  if (i != 0)
409
    return i;
410
  /* the tail idata4/5 are the only ones without relocs to an
411
     idata$6 section unless we are importing by ordinal,
412
     so sort them to last to terminate the IAT
413
     and HNT properly. if no reloc this one is import by ordinal
414
     so we have to sort by section contents */
415
 
416
  if ( ((*ra)->input_section.section->reloc_count + (*rb)->input_section.section->reloc_count) )
417
    {
418
       i =  (((*ra)->input_section.section->reloc_count >
419
                 (*rb)->input_section.section->reloc_count) ? -1 : 0);
420
       if ( i != 0)
421
         return i;
422
 
423
        return  (((*ra)->input_section.section->reloc_count >
424
                 (*rb)->input_section.section->reloc_count) ? 0 : 1);
425
    }
426
  else
427
    {
428
       if ( (strcmp( (*ra)->input_section.section->name, ".idata$6") == 0) )
429
          return 0; /* don't sort .idata$6 or .idata$7 FIXME dlltool eliminate .idata$7 */
430
 
431
       if (! bfd_get_section_contents ((*ra)->input_section.section->owner,
432
         (*ra)->input_section.section, &a_sec, (file_ptr) 0, (bfd_size_type)sizeof(a_sec)))
433
            einfo ("%F%B: Can't read contents of section .idata: %E\n",
434
                 (*ra)->input_section.section->owner);
435
 
436
       if (! bfd_get_section_contents ((*rb)->input_section.section->owner,
437
        (*rb)->input_section.section, &b_sec, (file_ptr) 0, (bfd_size_type)sizeof(b_sec) ))
438
           einfo ("%F%B: Can't read contents of section .idata: %E\n",
439
                (*rb)->input_section.section->owner);
440
 
441
      i =  ((a_sec < b_sec) ? -1 : 0);
442
      if ( i != 0)
443
        return i;
444
      return  ((a_sec < b_sec) ? 0 : 1);
445
   }
446
return 0;
447
}
448
 
449
static int
450
sort_by_section_name (const void *a, const void *b)
451
{
452
  const lang_statement_union_type *const *ra = a;
453
  const lang_statement_union_type *const *rb = b;
454
  int i;
455
  i = strcmp ((*ra)->input_section.section->name,
456
              (*rb)->input_section.section->name);
457
  /* This is a hack to make .stab and .stabstr last, so we don't have
458
     to fix strip/objcopy for .reloc sections.
459
     FIXME stripping images with a .rsrc section still needs to be fixed.  */
460
  if (i != 0)
461
    {
462
      if ((CONST_STRNEQ ((*ra)->input_section.section->name, ".stab"))
463
           && (! CONST_STRNEQ ((*rb)->input_section.section->name, ".stab")))
464
         return 1;
465
    }
466
  return i;
467
}
468
 
469
/* Subroutine of sort_sections to a contiguous subset of a list of sections.
470
   NEXT_AFTER is the element after the last one to sort.
471
   The result is a pointer to the last element's "next" pointer.  */
472
 
473
static lang_statement_union_type **
474
sort_sections_1 (lang_statement_union_type **startptr,
475
                 lang_statement_union_type *next_after,
476
                 int count,
477
                 int (*sort_func) (const void *, const void *))
478
{
479
  lang_statement_union_type **vec;
480
  lang_statement_union_type *p;
481
  int i;
482
  lang_statement_union_type **ret;
483
 
484
  if (count == 0)
485
    return startptr;
486
 
487
  vec = ((lang_statement_union_type **)
488
         xmalloc (count * sizeof (lang_statement_union_type *)));
489
 
490
  for (p = *startptr, i = 0; i < count; i++, p = p->header.next)
491
    vec[i] = p;
492
 
493
  qsort (vec, count, sizeof (vec[0]), sort_func);
494
 
495
  /* Fill in the next pointers again. */
496
  *startptr = vec[0];
497
  for (i = 0; i < count - 1; i++)
498
    vec[i]->header.next = vec[i + 1];
499
  vec[i]->header.next = next_after;
500
  ret = &vec[i]->header.next;
501
  free (vec);
502
  return ret;
503
}
504
 
505
/* Sort the .idata\$foo input sections of archives into filename order.
506
   The reason is so dlltool can arrange to have the pe dll import information
507
   generated correctly - the head of the list goes into dh.o, the tail into
508
   dt.o, and the guts into ds[nnnn].o.  Note that this is only needed for the
509
   .idata section.
510
   FIXME: This may no longer be necessary with grouped sections.  Instead of
511
   sorting on dh.o, ds[nnnn].o, dt.o, one could, for example, have dh.o use
512
   .idata\$4h, have ds[nnnn].o use .idata\$4s[nnnn], and have dt.o use .idata\$4t.
513
   This would have to be elaborated upon to handle multiple dll's
514
   [assuming such an eloboration is possible of course].
515
 
516
   We also sort sections in '\$' wild statements.  These are created by the
517
   place_orphans routine to implement grouped sections.  */
518
 
519
static void
520
sort_sections (lang_statement_union_type *s)
521
{
522
  for (; s ; s = s->header.next)
523
    switch (s->header.type)
524
      {
525
      case lang_output_section_statement_enum:
526
        sort_sections (s->output_section_statement.children.head);
527
        break;
528
      case lang_wild_statement_enum:
529
        {
530
          lang_statement_union_type **p = &s->wild_statement.children.head;
531
          struct wildcard_list *sec;
532
 
533
          for (sec = s->wild_statement.section_list; sec; sec = sec->next)
534
            {
535
              /* Is this the .idata section?  */
536
              if (sec->spec.name != NULL
537
                  && CONST_STRNEQ (sec->spec.name, ".idata"))
538
                {
539
                  /* Sort the children.  We want to sort any objects in
540
                     the same archive.  In order to handle the case of
541
                     including a single archive multiple times, we sort
542
                     all the children by archive name and then by object
543
                     name.  After sorting them, we re-thread the pointer
544
                     chain.  */
545
 
546
                  while (*p)
547
                    {
548
                      lang_statement_union_type *start = *p;
549
                      if (start->header.type != lang_input_section_enum
550
                          || !start->input_section.section->owner->my_archive)
551
                        p = &(start->header.next);
552
                      else
553
                        {
554
                          lang_statement_union_type *end;
555
                          int count;
556
 
557
                          for (end = start, count = 0;
558
                               end && (end->header.type
559
                                       == lang_input_section_enum);
560
                               end = end->header.next)
561
                            count++;
562
 
563
                          p = sort_sections_1 (p, end, count,
564
                                               sort_by_file_name);
565
                        }
566
                    }
567
                  break;
568
                }
569
 
570
              /* If this is a collection of grouped sections, sort them.
571
                 The linker script must explicitly mention "*(.foo\$)" or
572
                 "*(.foo\$*)".  Don't sort them if \$ is not the last
573
                 character (not sure if this is really useful, but it
574
                 allows explicitly mentioning some \$ sections and letting
575
                 the linker handle the rest).  */
576
              if (sec->spec.name != NULL)
577
                {
578
                  char *q = strchr (sec->spec.name, '\$');
579
 
580
                  if (q != NULL
581
                      && (q[1] == '\0'
582
                          || (q[1] == '*' && q[2] == '\0')))
583
                    {
584
                      lang_statement_union_type *end;
585
                      int count;
586
 
587
                      for (end = *p, count = 0; end; end = end->header.next)
588
                        {
589
                          if (end->header.type != lang_input_section_enum)
590
                            abort ();
591
                          count++;
592
                        }
593
                      (void) sort_sections_1 (p, end, count,
594
                                              sort_by_section_name);
595
                    }
596
                  break;
597
                }
598
            }
599
        }
600
        break;
601
      default:
602
        break;
603
      }
604
}
605
 
606
static void
607
gld_${EMULATION_NAME}_before_allocation (void)
608
{
609
#ifdef TARGET_IS_ppcpe
610
  /* Here we rummage through the found bfds to collect toc information */
611
  {
612
    LANG_FOR_EACH_INPUT_STATEMENT (is)
613
      {
614
        if (!ppc_process_before_allocation(is->the_bfd, &link_info))
615
          {
616
            einfo("Errors encountered processing file %s\n", is->filename);
617
          }
618
      }
619
  }
620
 
621
  /* We have seen it all. Allocate it, and carry on */
622
  ppc_allocate_toc_section (&link_info);
623
#else
624
#ifdef TARGET_IS_armpe
625
  /* FIXME: we should be able to set the size of the interworking stub
626
     section.
627
 
628
     Here we rummage through the found bfds to collect glue
629
     information.  FIXME: should this be based on a command line
630
     option?  krk@cygnus.com */
631
  {
632
    LANG_FOR_EACH_INPUT_STATEMENT (is)
633
      {
634
        if (!arm_process_before_allocation (is->the_bfd, & link_info))
635
          {
636
            einfo ("Errors encountered processing file %s", is->filename);
637
          }
638
      }
639
  }
640
 
641
  /* We have seen it all. Allocate it, and carry on */
642
  arm_allocate_interworking_sections (& link_info);
643
#endif /* TARGET_IS_armpe */
644
#endif /* TARGET_IS_ppcpe */
645
 
646
  sort_sections (stat_ptr->head);
647
 
648
  before_allocation_default ();
649
}
650
 
651
/* Place an orphan section.  We use this to put sections with a '\$' in them
652
   into the right place.  Any section with a '\$' in them (e.g. .text\$foo)
653
   gets mapped to the output section with everything from the '\$' on stripped
654
   (e.g. .text).
655
   See the Microsoft Portable Executable and Common Object File Format
656
   Specification 4.1, section 4.2, Grouped Sections.
657
 
658
   FIXME: This is now handled by the linker script using wildcards,
659
   but I'm leaving this here in case we want to enable it for sections
660
   which are not mentioned in the linker script.  */
661
 
662
static lang_output_section_statement_type *
663
gld${EMULATION_NAME}_place_orphan (asection *s,
664
                                   const char *secname,
665
                                   int constraint)
666
{
667
  char *output_secname, *ps;
668
  lang_output_section_statement_type *os;
669
  lang_statement_union_type *l;
670
 
671
  if ((s->flags & SEC_ALLOC) == 0)
672
    return NULL;
673
 
674
  /* Don't process grouped sections unless doing a final link.
675
     If they're marked as COMDAT sections, we don't want .text\$foo to
676
     end up in .text and then have .text disappear because it's marked
677
     link-once-discard.  */
678
  if (link_info.relocatable)
679
    return NULL;
680
 
681
  /* Everything from the '\$' on gets deleted so don't allow '\$' as the
682
     first character.  */
683
  if (*secname == '\$')
684
    einfo ("%P%F: section %s has '\$' as first character\n", secname);
685
  if (strchr (secname + 1, '\$') == NULL)
686
    return NULL;
687
 
688
  /* Look up the output section.  The Microsoft specs say sections names in
689
     image files never contain a '\$'.  Fortunately, lang_..._lookup creates
690
     the section if it doesn't exist.  */
691
  output_secname = xstrdup (secname);
692
  ps = strchr (output_secname + 1, '\$');
693
  *ps = 0;
694
  os = lang_output_section_statement_lookup (output_secname, constraint, TRUE);
695
 
696
  /* Find the '\$' wild statement for this section.  We currently require the
697
     linker script to explicitly mention "*(.foo\$)".
698
     FIXME: ppcpe.sc has .CRT\$foo in the .rdata section.  According to the
699
     Microsoft docs this isn't correct so it's not (currently) handled.  */
700
 
701
  ps[0] = '\$';
702
  ps[1] = 0;
703
  for (l = os->children.head; l; l = l->header.next)
704
    if (l->header.type == lang_wild_statement_enum)
705
      {
706
        struct wildcard_list *sec;
707
 
708
        for (sec = l->wild_statement.section_list; sec; sec = sec->next)
709
          if (sec->spec.name && strcmp (sec->spec.name, output_secname) == 0)
710
            break;
711
        if (sec)
712
          break;
713
      }
714
  ps[0] = 0;
715
  if (l == NULL)
716
    einfo ("%P%F: *(%s\$) missing from linker script\n", output_secname);
717
 
718
  /* Link the input section in and we're done for now.
719
     The sections still have to be sorted, but that has to wait until
720
     all such sections have been processed by us.  The sorting is done by
721
     sort_sections.  */
722
  lang_add_section (&l->wild_statement.children, s, os);
723
 
724
  return os;
725
}
726
 
727
static char *
728
gld_${EMULATION_NAME}_get_script (int *isfile)
729
EOF
730
# Scripts compiled in.
731
# sed commands to quote an ld script as a C string.
732
sc="-f stringify.sed"
733
 
734
fragment <
735
{
736
  *isfile = 0;
737
 
738
  if (link_info.relocatable && config.build_constructors)
739
    return
740
EOF
741
sed $sc ldscripts/${EMULATION_NAME}.xu                 >> e${EMULATION_NAME}.c
742
echo '  ; else if (link_info.relocatable) return'     >> e${EMULATION_NAME}.c
743
sed $sc ldscripts/${EMULATION_NAME}.xr                 >> e${EMULATION_NAME}.c
744
echo '  ; else if (!config.text_read_only) return'     >> e${EMULATION_NAME}.c
745
sed $sc ldscripts/${EMULATION_NAME}.xbn                >> e${EMULATION_NAME}.c
746
echo '  ; else if (!config.magic_demand_paged) return' >> e${EMULATION_NAME}.c
747
sed $sc ldscripts/${EMULATION_NAME}.xn                 >> e${EMULATION_NAME}.c
748
echo '  ; else return'                                 >> e${EMULATION_NAME}.c
749
sed $sc ldscripts/${EMULATION_NAME}.x                  >> e${EMULATION_NAME}.c
750
echo '; }'                                             >> e${EMULATION_NAME}.c
751
 
752
fragment <
753
 
754
 
755
struct ld_emulation_xfer_struct ld_${EMULATION_NAME}_emulation =
756
{
757
  gld_${EMULATION_NAME}_before_parse,
758
  syslib_default,
759
  hll_default,
760
  after_parse_default,
761
  gld_${EMULATION_NAME}_after_open,
762
  after_allocation_default,
763
  set_output_arch_default,
764
  ldemul_default_target,
765
  gld_${EMULATION_NAME}_before_allocation,
766
  gld_${EMULATION_NAME}_get_script,
767
  "${EMULATION_NAME}",
768
  "${OUTPUT_FORMAT}",
769
  finish_default,
770
  NULL, /* create output section statements */
771
  NULL, /* open dynamic archive */
772
  gld${EMULATION_NAME}_place_orphan,
773
  gld_${EMULATION_NAME}_set_symbols,
774
  NULL, /* parse_args */
775
  gld${EMULATION_NAME}_add_options,
776
  gld${EMULATION_NAME}_handle_option,
777
  NULL, /* unrecognized file */
778
  NULL, /* list options */
779
  NULL, /* recognized file */
780
  NULL, /* find_potential_libraries */
781
  NULL  /* new_vers_pattern */
782
};
783
EOF

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.