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

Subversion Repositories open8_urisc

[/] [open8_urisc/] [trunk/] [gnu/] [binutils/] [ld/] [emultempl/] [armelf.em] - Blame information for rev 268

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

Line No. Rev Author Line
1 145 khays
# This shell script emits a C file. -*- C -*-
2
#   Copyright 1991, 1993, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003,
3 166 khays
#   2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
4 145 khays
#   Free Software Foundation, Inc.
5
#
6
# This file is part of the GNU Binutils.
7
#
8
# This program is free software; you can redistribute it and/or modify
9
# it under the terms of the GNU General Public License as published by
10
# the Free Software Foundation; either version 3 of the License, or
11
# (at your option) any later version.
12
#
13
# This program is distributed in the hope that it will be useful,
14
# but WITHOUT ANY WARRANTY; without even the implied warranty of
15
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16
# GNU General Public License for more details.
17
#
18
# You should have received a copy of the GNU General Public License
19
# along with this program; if not, write to the Free Software
20
# Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
21
# MA 02110-1301, USA.
22
#
23
 
24
# This file is sourced from elf32.em, and defines extra arm-elf
25
# specific routines.
26
#
27
test -z "$TARGET2_TYPE" && TARGET2_TYPE="rel"
28
fragment <
29
 
30
#include "ldctor.h"
31
#include "elf/arm.h"
32
 
33
static char *thumb_entry_symbol = NULL;
34
static int byteswap_code = 0;
35
static int target1_is_rel = 0${TARGET1_IS_REL};
36
static char *target2_type = "${TARGET2_TYPE}";
37
static int fix_v4bx = 0;
38
static int use_blx = 0;
39
static bfd_arm_vfp11_fix vfp11_denorm_fix = BFD_ARM_VFP11_FIX_DEFAULT;
40
static int fix_cortex_a8 = -1;
41
static int no_enum_size_warning = 0;
42
static int no_wchar_size_warning = 0;
43
static int pic_veneer = 0;
44
static int merge_exidx_entries = -1;
45 157 khays
static int fix_arm1176 = 1;
46 145 khays
 
47
static void
48
gld${EMULATION_NAME}_before_parse (void)
49
{
50
#ifndef TARGET_                 /* I.e., if not generic.  */
51
  ldfile_set_output_arch ("`echo ${ARCH}`", bfd_arch_unknown);
52
#endif /* not TARGET_ */
53
  config.dynamic_link = ${DYNAMIC_LINK-TRUE};
54
  config.has_shared = `if test -n "$GENERATE_SHLIB_SCRIPT" ; then echo TRUE ; else echo FALSE ; fi`;
55
}
56
 
57
static void
58
arm_elf_before_allocation (void)
59
{
60
  bfd_elf32_arm_set_byteswap_code (&link_info, byteswap_code);
61
 
62
  /* Choose type of VFP11 erratum fix, or warn if specified fix is unnecessary
63
     due to architecture version.  */
64
  bfd_elf32_arm_set_vfp11_fix (link_info.output_bfd, &link_info);
65
 
66
  /* Auto-select Cortex-A8 erratum fix if it wasn't explicitly specified.  */
67
  bfd_elf32_arm_set_cortex_a8_fix (link_info.output_bfd, &link_info);
68
 
69
  /* We should be able to set the size of the interworking stub section.  We
70
     can't do it until later if we have dynamic sections, though.  */
71
  if (elf_hash_table (&link_info)->dynobj == NULL)
72
    {
73
      /* Here we rummage through the found bfds to collect glue information.  */
74
      LANG_FOR_EACH_INPUT_STATEMENT (is)
75
        {
76
          /* Initialise mapping tables for code/data.  */
77
          bfd_elf32_arm_init_maps (is->the_bfd);
78
 
79
          if (!bfd_elf32_arm_process_before_allocation (is->the_bfd,
80
                                                        &link_info)
81
              || !bfd_elf32_arm_vfp11_erratum_scan (is->the_bfd, &link_info))
82
            /* xgettext:c-format */
83
            einfo (_("Errors encountered processing file %s"), is->filename);
84
        }
85
 
86
      /* We have seen it all.  Allocate it, and carry on.  */
87
      bfd_elf32_arm_allocate_interworking_sections (& link_info);
88
    }
89
 
90
  /* Call the standard elf routine.  */
91
  gld${EMULATION_NAME}_before_allocation ();
92
}
93
 
94
/* Fake input file for stubs.  */
95
static lang_input_statement_type *stub_file;
96
 
97
/* Whether we need to call gldarm_layout_sections_again.  */
98
static int need_laying_out = 0;
99
 
100
/* Maximum size of a group of input sections that can be handled by
101
   one stub section.  A value of +/-1 indicates the bfd back-end
102
   should use a suitable default size.  */
103
static bfd_signed_vma group_size = 1;
104
 
105
struct hook_stub_info
106
{
107
  lang_statement_list_type add;
108
  asection *input_section;
109
};
110
 
111
/* Traverse the linker tree to find the spot where the stub goes.  */
112
 
113
static bfd_boolean
114
hook_in_stub (struct hook_stub_info *info, lang_statement_union_type **lp)
115
{
116
  lang_statement_union_type *l;
117
  bfd_boolean ret;
118
 
119
  for (; (l = *lp) != NULL; lp = &l->header.next)
120
    {
121
      switch (l->header.type)
122
        {
123
        case lang_constructors_statement_enum:
124
          ret = hook_in_stub (info, &constructor_list.head);
125
          if (ret)
126
            return ret;
127
          break;
128
 
129
        case lang_output_section_statement_enum:
130
          ret = hook_in_stub (info,
131
                              &l->output_section_statement.children.head);
132
          if (ret)
133
            return ret;
134
          break;
135
 
136
        case lang_wild_statement_enum:
137
          ret = hook_in_stub (info, &l->wild_statement.children.head);
138
          if (ret)
139
            return ret;
140
          break;
141
 
142
        case lang_group_statement_enum:
143
          ret = hook_in_stub (info, &l->group_statement.children.head);
144
          if (ret)
145
            return ret;
146
          break;
147
 
148
        case lang_input_section_enum:
149
          if (l->input_section.section == info->input_section)
150
            {
151
              /* We've found our section.  Insert the stub immediately
152
                 after its associated input section.  */
153
              *(info->add.tail) = l->header.next;
154
              l->header.next = info->add.head;
155
              return TRUE;
156
            }
157
          break;
158
 
159
        case lang_data_statement_enum:
160
        case lang_reloc_statement_enum:
161
        case lang_object_symbols_statement_enum:
162
        case lang_output_statement_enum:
163
        case lang_target_statement_enum:
164
        case lang_input_statement_enum:
165
        case lang_assignment_statement_enum:
166
        case lang_padding_statement_enum:
167
        case lang_address_statement_enum:
168
        case lang_fill_statement_enum:
169
          break;
170
 
171
        default:
172
          FAIL ();
173
          break;
174
        }
175
    }
176
  return FALSE;
177
}
178
 
179
 
180
/* Call-back for elf32_arm_size_stubs.  */
181
 
182
/* Create a new stub section, and arrange for it to be linked
183
   immediately after INPUT_SECTION.  */
184
 
185
static asection *
186
elf32_arm_add_stub_section (const char *stub_sec_name,
187
                            asection *input_section)
188
{
189
  asection *stub_sec;
190
  flagword flags;
191
  asection *output_section;
192
  const char *secname;
193
  lang_output_section_statement_type *os;
194
  struct hook_stub_info info;
195
 
196
  flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_CODE
197
           | SEC_HAS_CONTENTS | SEC_RELOC | SEC_IN_MEMORY | SEC_KEEP);
198
  stub_sec = bfd_make_section_anyway_with_flags (stub_file->the_bfd,
199
                                                 stub_sec_name, flags);
200
  if (stub_sec == NULL)
201
    goto err_ret;
202
 
203
  bfd_set_section_alignment (stub_file->the_bfd, stub_sec, 3);
204
 
205
  output_section = input_section->output_section;
206
  secname = bfd_get_section_name (output_section->owner, output_section);
207
  os = lang_output_section_find (secname);
208
 
209
  info.input_section = input_section;
210
  lang_list_init (&info.add);
211
  lang_add_section (&info.add, stub_sec, os);
212
 
213
  if (info.add.head == NULL)
214
    goto err_ret;
215
 
216
  if (hook_in_stub (&info, &os->children.head))
217
    return stub_sec;
218
 
219
 err_ret:
220
  einfo ("%X%P: can not make stub section: %E\n");
221
  return NULL;
222
}
223
 
224
/* Another call-back for elf_arm_size_stubs.  */
225
 
226
static void
227
gldarm_layout_sections_again (void)
228
{
229
  /* If we have changed sizes of the stub sections, then we need
230
     to recalculate all the section offsets.  This may mean we need to
231
     add even more stubs.  */
232
  gld${EMULATION_NAME}_map_segments (TRUE);
233
  need_laying_out = -1;
234
}
235
 
236
static void
237
build_section_lists (lang_statement_union_type *statement)
238
{
239
  if (statement->header.type == lang_input_section_enum)
240
    {
241
      asection *i = statement->input_section.section;
242
 
243
      if (!((lang_input_statement_type *) i->owner->usrdata)->just_syms_flag
244
          && (i->flags & SEC_EXCLUDE) == 0
245
          && i->output_section != NULL
246
          && i->output_section->owner == link_info.output_bfd)
247
        elf32_arm_next_input_section (& link_info, i);
248
    }
249
}
250
 
251
static int
252
compare_output_sec_vma (const void *a, const void *b)
253
{
254
  asection *asec = *(asection **) a, *bsec = *(asection **) b;
255
  asection *aout = asec->output_section, *bout = bsec->output_section;
256
  bfd_vma avma, bvma;
257
 
258
  /* If there's no output section for some reason, compare equal.  */
259
  if (!aout || !bout)
260
    return 0;
261
 
262
  avma = aout->vma + asec->output_offset;
263
  bvma = bout->vma + bsec->output_offset;
264
 
265
  if (avma > bvma)
266
    return 1;
267
  else if (avma < bvma)
268
    return -1;
269
 
270
  return 0;
271
}
272
 
273
static void
274
gld${EMULATION_NAME}_after_allocation (void)
275
{
276
  if (!link_info.relocatable)
277
    {
278
      /* Build a sorted list of input text sections, then use that to process
279
         the unwind table index.  */
280
      unsigned int list_size = 10;
281
      asection **sec_list = (asection **)
282
          xmalloc (list_size * sizeof (asection *));
283
      unsigned int sec_count = 0;
284
 
285
      LANG_FOR_EACH_INPUT_STATEMENT (is)
286
        {
287
          bfd *abfd = is->the_bfd;
288
          asection *sec;
289
 
290
          if ((abfd->flags & (EXEC_P | DYNAMIC)) != 0)
291
            continue;
292
 
293
          for (sec = abfd->sections; sec != NULL; sec = sec->next)
294
            {
295
              asection *out_sec = sec->output_section;
296
 
297
              if (out_sec
298
                  && elf_section_data (sec)
299
                  && elf_section_type (sec) == SHT_PROGBITS
300
                  && (elf_section_flags (sec) & SHF_EXECINSTR) != 0
301
                  && (sec->flags & SEC_EXCLUDE) == 0
302
                  && sec->sec_info_type != ELF_INFO_TYPE_JUST_SYMS
303
                  && out_sec != bfd_abs_section_ptr)
304
                {
305
                  if (sec_count == list_size)
306
                    {
307
                      list_size *= 2;
308
                      sec_list = (asection **)
309
                          xrealloc (sec_list, list_size * sizeof (asection *));
310
                    }
311
 
312
                  sec_list[sec_count++] = sec;
313
                }
314
            }
315
        }
316
 
317
      qsort (sec_list, sec_count, sizeof (asection *), &compare_output_sec_vma);
318
 
319
      if (elf32_arm_fix_exidx_coverage (sec_list, sec_count, &link_info,
320
                                           merge_exidx_entries))
321
        need_laying_out = 1;
322
 
323
      free (sec_list);
324
    }
325
 
326
  /* bfd_elf32_discard_info just plays with debugging sections,
327
     ie. doesn't affect any code, so we can delay resizing the
328
     sections.  It's likely we'll resize everything in the process of
329
     adding stubs.  */
330
  if (bfd_elf_discard_info (link_info.output_bfd, & link_info))
331
    need_laying_out = 1;
332
 
333
  /* If generating a relocatable output file, then we don't
334
     have to examine the relocs.  */
335
  if (stub_file != NULL && !link_info.relocatable)
336
    {
337
      int  ret = elf32_arm_setup_section_lists (link_info.output_bfd, & link_info);
338
 
339
      if (ret != 0)
340
        {
341
          if (ret < 0)
342
            {
343
              einfo ("%X%P: could not compute sections lists for stub generation: %E\n");
344
              return;
345
            }
346
 
347
          lang_for_each_statement (build_section_lists);
348
 
349
          /* Call into the BFD backend to do the real work.  */
350
          if (! elf32_arm_size_stubs (link_info.output_bfd,
351
                                      stub_file->the_bfd,
352
                                      & link_info,
353
                                      group_size,
354
                                      & elf32_arm_add_stub_section,
355
                                      & gldarm_layout_sections_again))
356
            {
357
              einfo ("%X%P: cannot size stub section: %E\n");
358
              return;
359
            }
360
        }
361
    }
362
 
363
  if (need_laying_out != -1)
364
    gld${EMULATION_NAME}_map_segments (need_laying_out);
365
}
366
 
367
static void
368
gld${EMULATION_NAME}_finish (void)
369
{
370
  struct bfd_link_hash_entry * h;
371
 
372
  {
373
    LANG_FOR_EACH_INPUT_STATEMENT (is)
374
      {
375
        /* Figure out where VFP11 erratum veneers (and the labels returning
376
           from same) have been placed.  */
377
        bfd_elf32_arm_vfp11_fix_veneer_locations (is->the_bfd, &link_info);
378
      }
379
  }
380
 
381
  if (! link_info.relocatable)
382
    {
383
      /* Now build the linker stubs.  */
384
      if (stub_file->the_bfd->sections != NULL)
385
        {
386
          if (! elf32_arm_build_stubs (& link_info))
387
            einfo ("%X%P: can not build stubs: %E\n");
388
        }
389
    }
390
 
391
  finish_default ();
392
 
393
  if (thumb_entry_symbol)
394
    {
395
      h = bfd_link_hash_lookup (link_info.hash, thumb_entry_symbol,
396
                                FALSE, FALSE, TRUE);
397
    }
398
  else
399
    {
400
      struct elf_link_hash_entry * eh;
401
 
402
      if (!entry_symbol.name)
403
        return;
404
 
405
      h = bfd_link_hash_lookup (link_info.hash, entry_symbol.name,
406
                                FALSE, FALSE, TRUE);
407
      eh = (struct elf_link_hash_entry *)h;
408
      if (!h || eh->target_internal != ST_BRANCH_TO_THUMB)
409
        return;
410
    }
411
 
412
 
413
  if (h != (struct bfd_link_hash_entry *) NULL
414
      && (h->type == bfd_link_hash_defined
415
          || h->type == bfd_link_hash_defweak)
416
      && h->u.def.section->output_section != NULL)
417
    {
418
      static char buffer[32];
419
      bfd_vma val;
420
 
421
      /* Special procesing is required for a Thumb entry symbol.  The
422
         bottom bit of its address must be set.  */
423
      val = (h->u.def.value
424
             + bfd_get_section_vma (link_info.output_bfd,
425
                                    h->u.def.section->output_section)
426
             + h->u.def.section->output_offset);
427
 
428
      val |= 1;
429
 
430
      /* Now convert this value into a string and store it in entry_symbol
431
         where the lang_finish() function will pick it up.  */
432
      buffer[0] = '0';
433
      buffer[1] = 'x';
434
 
435
      sprintf_vma (buffer + 2, val);
436
 
437
      if (thumb_entry_symbol != NULL && entry_symbol.name != NULL
438
          && entry_from_cmdline)
439
        einfo (_("%P: warning: '--thumb-entry %s' is overriding '-e %s'\n"),
440
               thumb_entry_symbol, entry_symbol.name);
441
      entry_symbol.name = buffer;
442
    }
443
  else
444
    einfo (_("%P: warning: cannot find thumb start symbol %s\n"),
445
           thumb_entry_symbol);
446
}
447
 
448
/* This is a convenient point to tell BFD about target specific flags.
449
   After the output has been created, but before inputs are read.  */
450
static void
451
arm_elf_create_output_section_statements (void)
452
{
453
  if (strstr (bfd_get_target (link_info.output_bfd), "arm") == NULL)
454
    {
455
      /* The arm backend needs special fields in the output hash structure.
456
         These will only be created if the output format is an arm format,
457
         hence we do not support linking and changing output formats at the
458
         same time.  Use a link followed by objcopy to change output formats.  */
459
      einfo ("%F%X%P: error: Cannot change output format whilst linking ARM binaries.\n");
460
      return;
461
    }
462
 
463
  bfd_elf32_arm_set_target_relocs (link_info.output_bfd, &link_info,
464
                                   target1_is_rel,
465
                                   target2_type, fix_v4bx, use_blx,
466
                                   vfp11_denorm_fix, no_enum_size_warning,
467
                                   no_wchar_size_warning,
468 157 khays
                                   pic_veneer, fix_cortex_a8,
469
                                   fix_arm1176);
470 145 khays
 
471
  stub_file = lang_add_input_file ("linker stubs",
472
                                   lang_input_file_is_fake_enum,
473
                                   NULL);
474
  stub_file->the_bfd = bfd_create ("linker stubs", link_info.output_bfd);
475
  if (stub_file->the_bfd == NULL
476
      || ! bfd_set_arch_mach (stub_file->the_bfd,
477
                              bfd_get_arch (link_info.output_bfd),
478
                              bfd_get_mach (link_info.output_bfd)))
479
    {
480
      einfo ("%X%P: can not create BFD %E\n");
481
      return;
482
    }
483
 
484
  stub_file->the_bfd->flags |= BFD_LINKER_CREATED;
485
  ldlang_add_file (stub_file);
486
 
487
  /* Also use the stub file for stubs placed in a single output section.  */
488
  bfd_elf32_arm_add_glue_sections_to_bfd (stub_file->the_bfd, &link_info);
489
  bfd_elf32_arm_get_bfd_for_interworking (stub_file->the_bfd, &link_info);
490
}
491
 
492
/* Avoid processing the fake stub_file in vercheck, stat_needed and
493
   check_needed routines.  */
494
 
495
static void (*real_func) (lang_input_statement_type *);
496
 
497
static void arm_for_each_input_file_wrapper (lang_input_statement_type *l)
498
{
499
  if (l != stub_file)
500
    (*real_func) (l);
501
}
502
 
503
static void
504
arm_lang_for_each_input_file (void (*func) (lang_input_statement_type *))
505
{
506
  real_func = func;
507
  lang_for_each_input_file (&arm_for_each_input_file_wrapper);
508
}
509
 
510
#define lang_for_each_input_file arm_lang_for_each_input_file
511
 
512
EOF
513
 
514
# Define some shell vars to insert bits of code into the standard elf
515
# parse_args and list_options functions.
516
#
517
PARSE_AND_LIST_PROLOGUE='
518
#define OPTION_THUMB_ENTRY              301
519
#define OPTION_BE8                      302
520
#define OPTION_TARGET1_REL              303
521
#define OPTION_TARGET1_ABS              304
522
#define OPTION_TARGET2                  305
523
#define OPTION_FIX_V4BX                 306
524
#define OPTION_USE_BLX                  307
525
#define OPTION_VFP11_DENORM_FIX         308
526
#define OPTION_NO_ENUM_SIZE_WARNING     309
527
#define OPTION_PIC_VENEER               310
528
#define OPTION_FIX_V4BX_INTERWORKING    311
529
#define OPTION_STUBGROUP_SIZE           312
530
#define OPTION_NO_WCHAR_SIZE_WARNING    313
531
#define OPTION_FIX_CORTEX_A8            314
532
#define OPTION_NO_FIX_CORTEX_A8         315
533
#define OPTION_NO_MERGE_EXIDX_ENTRIES   316
534 157 khays
#define OPTION_FIX_ARM1176              317
535
#define OPTION_NO_FIX_ARM1176           318
536 145 khays
'
537
 
538
PARSE_AND_LIST_SHORTOPTS=p
539
 
540
PARSE_AND_LIST_LONGOPTS='
541
  { "no-pipeline-knowledge", no_argument, NULL, '\'p\''},
542
  { "thumb-entry", required_argument, NULL, OPTION_THUMB_ENTRY},
543
  { "be8", no_argument, NULL, OPTION_BE8},
544
  { "target1-rel", no_argument, NULL, OPTION_TARGET1_REL},
545
  { "target1-abs", no_argument, NULL, OPTION_TARGET1_ABS},
546
  { "target2", required_argument, NULL, OPTION_TARGET2},
547
  { "fix-v4bx", no_argument, NULL, OPTION_FIX_V4BX},
548
  { "fix-v4bx-interworking", no_argument, NULL, OPTION_FIX_V4BX_INTERWORKING},
549
  { "use-blx", no_argument, NULL, OPTION_USE_BLX},
550
  { "vfp11-denorm-fix", required_argument, NULL, OPTION_VFP11_DENORM_FIX},
551
  { "no-enum-size-warning", no_argument, NULL, OPTION_NO_ENUM_SIZE_WARNING},
552
  { "pic-veneer", no_argument, NULL, OPTION_PIC_VENEER},
553
  { "stub-group-size", required_argument, NULL, OPTION_STUBGROUP_SIZE },
554
  { "no-wchar-size-warning", no_argument, NULL, OPTION_NO_WCHAR_SIZE_WARNING},
555
  { "fix-cortex-a8", no_argument, NULL, OPTION_FIX_CORTEX_A8 },
556
  { "no-fix-cortex-a8", no_argument, NULL, OPTION_NO_FIX_CORTEX_A8 },
557
  { "no-merge-exidx-entries", no_argument, NULL, OPTION_NO_MERGE_EXIDX_ENTRIES },
558 157 khays
  { "fix-arm1176", no_argument, NULL, OPTION_FIX_ARM1176 },
559
  { "no-fix-arm1176", no_argument, NULL, OPTION_NO_FIX_ARM1176 },
560 145 khays
'
561
 
562
PARSE_AND_LIST_OPTIONS='
563
  fprintf (file, _("  --thumb-entry=         Set the entry point to be Thumb symbol \n"));
564
  fprintf (file, _("  --be8                       Output BE8 format image\n"));
565
  fprintf (file, _("  --target1-rel               Interpret R_ARM_TARGET1 as R_ARM_REL32\n"));
566
  fprintf (file, _("  --target1-abs               Interpret R_ARM_TARGET1 as R_ARM_ABS32\n"));
567
  fprintf (file, _("  --target2=            Specify definition of R_ARM_TARGET2\n"));
568
  fprintf (file, _("  --fix-v4bx                  Rewrite BX rn as MOV pc, rn for ARMv4\n"));
569
  fprintf (file, _("  --fix-v4bx-interworking     Rewrite BX rn branch to ARMv4 interworking veneer\n"));
570
  fprintf (file, _("  --use-blx                   Enable use of BLX instructions\n"));
571
  fprintf (file, _("  --vfp11-denorm-fix          Specify how to fix VFP11 denorm erratum\n"));
572
  fprintf (file, _("  --no-enum-size-warning      Don'\''t warn about objects with incompatible\n"
573
                   "                                enum sizes\n"));
574 166 khays
  fprintf (file, _("  --no-wchar-size-warning     Don'\''t warn about objects with incompatible\n"
575 145 khays
                   "                                wchar_t sizes\n"));
576
  fprintf (file, _("  --pic-veneer                Always generate PIC interworking veneers\n"));
577
  fprintf (file, _("\
578 166 khays
  --stub-group-size=N         Maximum size of a group of input sections that\n\
579
                               can be handled by one stub section.  A negative\n\
580
                               value locates all stubs after their branches\n\
581
                               (with a group size of -N), while a positive\n\
582
                               value allows two groups of input sections, one\n\
583
                               before, and one after each stub section.\n\
584
                               Values of +/-1 indicate the linker should\n\
585
                               choose suitable defaults.\n"));
586 145 khays
  fprintf (file, _("  --[no-]fix-cortex-a8        Disable/enable Cortex-A8 Thumb-2 branch erratum fix\n"));
587
  fprintf (file, _("  --no-merge-exidx-entries    Disable merging exidx entries\n"));
588 157 khays
  fprintf (file, _("  --[no-]fix-arm1176          Disable/enable ARM1176 BLX immediate erratum fix\n"));
589 145 khays
'
590
 
591
PARSE_AND_LIST_ARGS_CASES='
592
    case '\'p\'':
593
      /* Only here for backwards compatibility.  */
594
      break;
595
 
596
    case OPTION_THUMB_ENTRY:
597
      thumb_entry_symbol = optarg;
598
      break;
599
 
600
    case OPTION_BE8:
601
      byteswap_code = 1;
602
      break;
603
 
604
    case OPTION_TARGET1_REL:
605
      target1_is_rel = 1;
606
      break;
607
 
608
    case OPTION_TARGET1_ABS:
609
      target1_is_rel = 0;
610
      break;
611
 
612
    case OPTION_TARGET2:
613
      target2_type = optarg;
614
      break;
615
 
616
    case OPTION_FIX_V4BX:
617
      fix_v4bx = 1;
618
      break;
619
 
620
    case OPTION_FIX_V4BX_INTERWORKING:
621
      fix_v4bx = 2;
622
      break;
623
 
624
    case OPTION_USE_BLX:
625
      use_blx = 1;
626
      break;
627
 
628
    case OPTION_VFP11_DENORM_FIX:
629
      if (strcmp (optarg, "none") == 0)
630
        vfp11_denorm_fix = BFD_ARM_VFP11_FIX_NONE;
631
      else if (strcmp (optarg, "scalar") == 0)
632
        vfp11_denorm_fix = BFD_ARM_VFP11_FIX_SCALAR;
633
      else if (strcmp (optarg, "vector") == 0)
634
        vfp11_denorm_fix = BFD_ARM_VFP11_FIX_VECTOR;
635
      else
636
        einfo (_("Unrecognized VFP11 fix type '\''%s'\''.\n"), optarg);
637
      break;
638
 
639
    case OPTION_NO_ENUM_SIZE_WARNING:
640
      no_enum_size_warning = 1;
641
      break;
642
 
643
    case OPTION_NO_WCHAR_SIZE_WARNING:
644
      no_wchar_size_warning = 1;
645
      break;
646
 
647
    case OPTION_PIC_VENEER:
648
      pic_veneer = 1;
649
      break;
650
 
651
    case OPTION_STUBGROUP_SIZE:
652
      {
653
        const char *end;
654
 
655
        group_size = bfd_scan_vma (optarg, &end, 0);
656
        if (*end)
657
          einfo (_("%P%F: invalid number `%s'\''\n"), optarg);
658
      }
659
      break;
660
 
661
    case OPTION_FIX_CORTEX_A8:
662
      fix_cortex_a8 = 1;
663
      break;
664
 
665
    case OPTION_NO_FIX_CORTEX_A8:
666
      fix_cortex_a8 = 0;
667
      break;
668
 
669
   case OPTION_NO_MERGE_EXIDX_ENTRIES:
670
      merge_exidx_entries = 0;
671 157 khays
      break;
672 145 khays
 
673 157 khays
   case OPTION_FIX_ARM1176:
674
      fix_arm1176 = 1;
675
      break;
676
 
677
   case OPTION_NO_FIX_ARM1176:
678
      fix_arm1176 = 0;
679
      break;
680 145 khays
'
681
 
682
# We have our own before_allocation etc. functions, but they call
683
# the standard routines, so give them a different name.
684
LDEMUL_BEFORE_ALLOCATION=arm_elf_before_allocation
685
LDEMUL_AFTER_ALLOCATION=gld${EMULATION_NAME}_after_allocation
686
LDEMUL_CREATE_OUTPUT_SECTION_STATEMENTS=arm_elf_create_output_section_statements
687
 
688
# Replace the elf before_parse function with our own.
689
LDEMUL_BEFORE_PARSE=gld"${EMULATION_NAME}"_before_parse
690
 
691
# Call the extra arm-elf function
692
LDEMUL_FINISH=gld${EMULATION_NAME}_finish

powered by: WebSVN 2.1.0

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