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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-stable/] [binutils-2.20.1/] [ld/] [emultempl/] [armelf.em] - Blame information for rev 862

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