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

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [binutils-2.18.50/] [bfd/] [coff-arm.c] - Blame information for rev 156

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 38 julius
/* BFD back-end for ARM COFF files.
2
   Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
3
   2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007
4
   Free Software Foundation, Inc.
5
   Written by Cygnus Support.
6
 
7
   This file is part of BFD, the Binary File Descriptor library.
8
 
9
   This program is free software; you can redistribute it and/or modify
10
   it under the terms of the GNU General Public License as published by
11
   the Free Software Foundation; either version 3 of the License, or
12
   (at your option) any later version.
13
 
14
   This program is distributed in the hope that it will be useful,
15
   but WITHOUT ANY WARRANTY; without even the implied warranty of
16
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17
   GNU General Public License for more details.
18
 
19
   You should have received a copy of the GNU General Public License
20
   along with this program; if not, write to the Free Software
21
   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
22
   MA 02110-1301, USA.  */
23
 
24
#include "sysdep.h"
25
#include "bfd.h"
26
#include "libbfd.h"
27
#include "coff/arm.h"
28
#include "coff/internal.h"
29
 
30
#ifdef COFF_WITH_PE
31
#include "coff/pe.h"
32
#endif
33
 
34
#include "libcoff.h"
35
 
36
/* Macros for manipulation the bits in the flags field of the coff data
37
   structure.  */
38
#define APCS_26_FLAG(abfd) \
39
  (coff_data (abfd)->flags & F_APCS_26)
40
 
41
#define APCS_FLOAT_FLAG(abfd) \
42
  (coff_data (abfd)->flags & F_APCS_FLOAT)
43
 
44
#define PIC_FLAG(abfd) \
45
  (coff_data (abfd)->flags & F_PIC)
46
 
47
#define APCS_SET(abfd) \
48
  (coff_data (abfd)->flags & F_APCS_SET)
49
 
50
#define SET_APCS_FLAGS(abfd, flgs) \
51
  do                                                                    \
52
    {                                                                   \
53
      coff_data (abfd)->flags &= ~(F_APCS_26 | F_APCS_FLOAT | F_PIC);   \
54
      coff_data (abfd)->flags |= (flgs) | F_APCS_SET;                   \
55
    }                                                                   \
56
  while (0)
57
 
58
#define INTERWORK_FLAG(abfd) \
59
  (coff_data (abfd)->flags & F_INTERWORK)
60
 
61
#define INTERWORK_SET(abfd) \
62
  (coff_data (abfd)->flags & F_INTERWORK_SET)
63
 
64
#define SET_INTERWORK_FLAG(abfd, flg) \
65
  do                                                                    \
66
    {                                                                   \
67
      coff_data (abfd)->flags &= ~F_INTERWORK;                          \
68
      coff_data (abfd)->flags |= (flg) | F_INTERWORK_SET;               \
69
    }                                                                   \
70
  while (0)
71
 
72
#ifndef NUM_ELEM
73
#define NUM_ELEM(a) ((sizeof (a)) / sizeof ((a)[0]))
74
#endif
75
 
76
typedef enum {bunknown, b9, b12, b23} thumb_pcrel_branchtype;
77
/* Some typedefs for holding instructions.  */
78
typedef unsigned long int insn32;
79
typedef unsigned short int insn16;
80
 
81
/* The linker script knows the section names for placement.
82
   The entry_names are used to do simple name mangling on the stubs.
83
   Given a function name, and its type, the stub can be found. The
84
   name can be changed. The only requirement is the %s be present.  */
85
 
86
#define THUMB2ARM_GLUE_SECTION_NAME ".glue_7t"
87
#define THUMB2ARM_GLUE_ENTRY_NAME   "__%s_from_thumb"
88
 
89
#define ARM2THUMB_GLUE_SECTION_NAME ".glue_7"
90
#define ARM2THUMB_GLUE_ENTRY_NAME   "__%s_from_arm"
91
 
92
/* Used by the assembler.  */
93
 
94
static bfd_reloc_status_type
95
coff_arm_reloc (bfd *abfd,
96
                arelent *reloc_entry,
97
                asymbol *symbol ATTRIBUTE_UNUSED,
98
                void * data,
99
                asection *input_section ATTRIBUTE_UNUSED,
100
                bfd *output_bfd,
101
                char **error_message ATTRIBUTE_UNUSED)
102
{
103
  symvalue diff;
104
 
105
  if (output_bfd == NULL)
106
    return bfd_reloc_continue;
107
 
108
  diff = reloc_entry->addend;
109
 
110
#define DOIT(x)                                                 \
111
  x = ((x & ~howto->dst_mask)                                   \
112
       | (((x & howto->src_mask) + diff) & howto->dst_mask))
113
 
114
    if (diff != 0)
115
      {
116
        reloc_howto_type *howto = reloc_entry->howto;
117
        unsigned char *addr = (unsigned char *) data + reloc_entry->address;
118
 
119
        switch (howto->size)
120
          {
121
          case 0:
122
            {
123
              char x = bfd_get_8 (abfd, addr);
124
              DOIT (x);
125
              bfd_put_8 (abfd, x, addr);
126
            }
127
            break;
128
 
129
          case 1:
130
            {
131
              short x = bfd_get_16 (abfd, addr);
132
              DOIT (x);
133
              bfd_put_16 (abfd, (bfd_vma) x, addr);
134
            }
135
            break;
136
 
137
          case 2:
138
            {
139
              long x = bfd_get_32 (abfd, addr);
140
              DOIT (x);
141
              bfd_put_32 (abfd, (bfd_vma) x, addr);
142
            }
143
            break;
144
 
145
          default:
146
            abort ();
147
          }
148
      }
149
 
150
  /* Now let bfd_perform_relocation finish everything up.  */
151
  return bfd_reloc_continue;
152
}
153
 
154
/* If USER_LABEL_PREFIX is defined as "_" (see coff_arm_is_local_label_name()
155
   in this file), then TARGET_UNDERSCORE should be defined, otherwise it
156
   should not.  */
157
#ifndef TARGET_UNDERSCORE
158
#define TARGET_UNDERSCORE '_'
159
#endif
160
 
161
#ifndef PCRELOFFSET
162
#define PCRELOFFSET TRUE
163
#endif
164
 
165
/* These most certainly belong somewhere else. Just had to get rid of
166
   the manifest constants in the code.  */
167
 
168
#ifdef ARM_WINCE
169
 
170
#define ARM_26D      0
171
#define ARM_32       1
172
#define ARM_RVA32    2
173
#define ARM_26       3
174
#define ARM_THUMB12  4
175
#define ARM_SECTION  14
176
#define ARM_SECREL   15
177
 
178
#else
179
 
180
#define ARM_8        0
181
#define ARM_16       1
182
#define ARM_32       2
183
#define ARM_26       3
184
#define ARM_DISP8    4
185
#define ARM_DISP16   5
186
#define ARM_DISP32   6
187
#define ARM_26D      7
188
/* 8 is unused.  */
189
#define ARM_NEG16    9
190
#define ARM_NEG32   10
191
#define ARM_RVA32   11
192
#define ARM_THUMB9  12
193
#define ARM_THUMB12 13
194
#define ARM_THUMB23 14
195
 
196
#endif
197
 
198
static bfd_reloc_status_type aoutarm_fix_pcrel_26_done
199
  (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
200
static bfd_reloc_status_type aoutarm_fix_pcrel_26
201
  (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
202
static bfd_reloc_status_type coff_thumb_pcrel_12
203
  (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
204
#ifndef ARM_WINCE
205
static bfd_reloc_status_type coff_thumb_pcrel_9
206
  (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
207
static bfd_reloc_status_type coff_thumb_pcrel_23
208
  (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
209
#endif
210
 
211
static reloc_howto_type aoutarm_std_reloc_howto[] =
212
  {
213
#ifdef ARM_WINCE
214
    HOWTO (ARM_26D,
215
           2,
216
           2,
217
           24,
218
           TRUE,
219
           0,
220
           complain_overflow_dont,
221
           aoutarm_fix_pcrel_26_done,
222
           "ARM_26D",
223
           TRUE,        /* partial_inplace.  */
224
           0x00ffffff,
225
           0x0,
226
           PCRELOFFSET),
227
    HOWTO (ARM_32,
228
           0,
229
           2,
230
           32,
231
           FALSE,
232
           0,
233
           complain_overflow_bitfield,
234
           coff_arm_reloc,
235
           "ARM_32",
236
           TRUE,        /* partial_inplace.  */
237
           0xffffffff,
238
           0xffffffff,
239
           PCRELOFFSET),
240
    HOWTO (ARM_RVA32,
241
           0,
242
           2,
243
           32,
244
           FALSE,
245
           0,
246
           complain_overflow_bitfield,
247
           coff_arm_reloc,
248
           "ARM_RVA32",
249
           TRUE,        /* partial_inplace.  */
250
           0xffffffff,
251
           0xffffffff,
252
           PCRELOFFSET),
253
    HOWTO (ARM_26,
254
           2,
255
           2,
256
           24,
257
           TRUE,
258
           0,
259
           complain_overflow_signed,
260
           aoutarm_fix_pcrel_26 ,
261
           "ARM_26",
262
           FALSE,
263
           0x00ffffff,
264
           0x00ffffff,
265
           PCRELOFFSET),
266
    HOWTO (ARM_THUMB12,
267
           1,
268
           1,
269
           11,
270
           TRUE,
271
           0,
272
           complain_overflow_signed,
273
           coff_thumb_pcrel_12 ,
274
           "ARM_THUMB12",
275
           FALSE,
276
           0x000007ff,
277
           0x000007ff,
278
           PCRELOFFSET),
279
    EMPTY_HOWTO (-1),
280
    EMPTY_HOWTO (-1),
281
    EMPTY_HOWTO (-1),
282
    EMPTY_HOWTO (-1),
283
    EMPTY_HOWTO (-1),
284
    EMPTY_HOWTO (-1),
285
    EMPTY_HOWTO (-1),
286
    EMPTY_HOWTO (-1),
287
    EMPTY_HOWTO (-1),
288
    HOWTO (ARM_SECTION,
289
           0,
290
           1,
291
           16,
292
           FALSE,
293
           0,
294
           complain_overflow_bitfield,
295
           coff_arm_reloc,
296
           "ARM_SECTION",
297
           TRUE,        /* partial_inplace.  */
298
           0x0000ffff,
299
           0x0000ffff,
300
           PCRELOFFSET),
301
    HOWTO (ARM_SECREL,
302
           0,
303
           2,
304
           32,
305
           FALSE,
306
           0,
307
           complain_overflow_bitfield,
308
           coff_arm_reloc,
309
           "ARM_SECREL",
310
           TRUE,        /* partial_inplace.  */
311
           0xffffffff,
312
           0xffffffff,
313
           PCRELOFFSET),
314
#else /* not ARM_WINCE */
315
    HOWTO (ARM_8,
316
           0,
317
           0,
318
           8,
319
           FALSE,
320
           0,
321
           complain_overflow_bitfield,
322
           coff_arm_reloc,
323
           "ARM_8",
324
           TRUE,
325
           0x000000ff,
326
           0x000000ff,
327
           PCRELOFFSET),
328
    HOWTO (ARM_16,
329
           0,
330
           1,
331
           16,
332
           FALSE,
333
           0,
334
           complain_overflow_bitfield,
335
           coff_arm_reloc,
336
           "ARM_16",
337
           TRUE,
338
           0x0000ffff,
339
           0x0000ffff,
340
           PCRELOFFSET),
341
    HOWTO (ARM_32,
342
           0,
343
           2,
344
           32,
345
           FALSE,
346
           0,
347
           complain_overflow_bitfield,
348
           coff_arm_reloc,
349
           "ARM_32",
350
           TRUE,
351
           0xffffffff,
352
           0xffffffff,
353
           PCRELOFFSET),
354
    HOWTO (ARM_26,
355
           2,
356
           2,
357
           24,
358
           TRUE,
359
           0,
360
           complain_overflow_signed,
361
           aoutarm_fix_pcrel_26 ,
362
           "ARM_26",
363
           FALSE,
364
           0x00ffffff,
365
           0x00ffffff,
366
           PCRELOFFSET),
367
    HOWTO (ARM_DISP8,
368
           0,
369
           0,
370
           8,
371
           TRUE,
372
           0,
373
           complain_overflow_signed,
374
           coff_arm_reloc,
375
           "ARM_DISP8",
376
           TRUE,
377
           0x000000ff,
378
           0x000000ff,
379
           TRUE),
380
    HOWTO (ARM_DISP16,
381
           0,
382
           1,
383
           16,
384
           TRUE,
385
           0,
386
           complain_overflow_signed,
387
           coff_arm_reloc,
388
           "ARM_DISP16",
389
           TRUE,
390
           0x0000ffff,
391
           0x0000ffff,
392
           TRUE),
393
    HOWTO (ARM_DISP32,
394
           0,
395
           2,
396
           32,
397
           TRUE,
398
           0,
399
           complain_overflow_signed,
400
           coff_arm_reloc,
401
           "ARM_DISP32",
402
           TRUE,
403
           0xffffffff,
404
           0xffffffff,
405
           TRUE),
406
    HOWTO (ARM_26D,
407
           2,
408
           2,
409
           24,
410
           FALSE,
411
           0,
412
           complain_overflow_dont,
413
           aoutarm_fix_pcrel_26_done,
414
           "ARM_26D",
415
           TRUE,
416
           0x00ffffff,
417
           0x0,
418
           FALSE),
419
    /* 8 is unused */
420
    EMPTY_HOWTO (-1),
421
    HOWTO (ARM_NEG16,
422
           0,
423
           -1,
424
           16,
425
           FALSE,
426
           0,
427
           complain_overflow_bitfield,
428
           coff_arm_reloc,
429
           "ARM_NEG16",
430
           TRUE,
431
           0x0000ffff,
432
           0x0000ffff,
433
           FALSE),
434
    HOWTO (ARM_NEG32,
435
           0,
436
           -2,
437
           32,
438
           FALSE,
439
           0,
440
           complain_overflow_bitfield,
441
           coff_arm_reloc,
442
           "ARM_NEG32",
443
           TRUE,
444
           0xffffffff,
445
           0xffffffff,
446
           FALSE),
447
    HOWTO (ARM_RVA32,
448
           0,
449
           2,
450
           32,
451
           FALSE,
452
           0,
453
           complain_overflow_bitfield,
454
           coff_arm_reloc,
455
           "ARM_RVA32",
456
           TRUE,
457
           0xffffffff,
458
           0xffffffff,
459
           PCRELOFFSET),
460
    HOWTO (ARM_THUMB9,
461
           1,
462
           1,
463
           8,
464
           TRUE,
465
           0,
466
           complain_overflow_signed,
467
           coff_thumb_pcrel_9 ,
468
           "ARM_THUMB9",
469
           FALSE,
470
           0x000000ff,
471
           0x000000ff,
472
           PCRELOFFSET),
473
    HOWTO (ARM_THUMB12,
474
           1,
475
           1,
476
           11,
477
           TRUE,
478
           0,
479
           complain_overflow_signed,
480
           coff_thumb_pcrel_12 ,
481
           "ARM_THUMB12",
482
           FALSE,
483
           0x000007ff,
484
           0x000007ff,
485
           PCRELOFFSET),
486
    HOWTO (ARM_THUMB23,
487
           1,
488
           2,
489
           22,
490
           TRUE,
491
           0,
492
           complain_overflow_signed,
493
           coff_thumb_pcrel_23 ,
494
           "ARM_THUMB23",
495
           FALSE,
496
           0x07ff07ff,
497
           0x07ff07ff,
498
           PCRELOFFSET)
499
#endif /* not ARM_WINCE */
500
  };
501
 
502
#define NUM_RELOCS NUM_ELEM (aoutarm_std_reloc_howto)
503
 
504
#ifdef COFF_WITH_PE
505
/* Return TRUE if this relocation should
506
   appear in the output .reloc section.  */
507
 
508
static bfd_boolean
509
in_reloc_p (bfd * abfd ATTRIBUTE_UNUSED,
510
            reloc_howto_type * howto)
511
{
512
  return !howto->pc_relative && howto->type != ARM_RVA32;
513
}
514
#endif
515
 
516
#define RTYPE2HOWTO(cache_ptr, dst)             \
517
  (cache_ptr)->howto =                          \
518
    (dst)->r_type < NUM_RELOCS                  \
519
    ? aoutarm_std_reloc_howto + (dst)->r_type   \
520
    : NULL
521
 
522
#define coff_rtype_to_howto coff_arm_rtype_to_howto
523
 
524
static reloc_howto_type *
525
coff_arm_rtype_to_howto (bfd *abfd ATTRIBUTE_UNUSED,
526
                         asection *sec,
527
                         struct internal_reloc *rel,
528
                         struct coff_link_hash_entry *h ATTRIBUTE_UNUSED,
529
                         struct internal_syment *sym ATTRIBUTE_UNUSED,
530
                         bfd_vma *addendp)
531
{
532
  reloc_howto_type * howto;
533
 
534
  if (rel->r_type >= NUM_RELOCS)
535
    return NULL;
536
 
537
  howto = aoutarm_std_reloc_howto + rel->r_type;
538
 
539
  if (rel->r_type == ARM_RVA32)
540
    *addendp -= pe_data (sec->output_section->owner)->pe_opthdr.ImageBase;
541
 
542
#if defined COFF_WITH_PE && defined ARM_WINCE
543
  if (rel->r_type == ARM_SECREL)
544
    {
545
      bfd_vma osect_vma;
546
 
547
      if (h && (h->type == bfd_link_hash_defined
548
                || h->type == bfd_link_hash_defweak))
549
        osect_vma = h->root.u.def.section->output_section->vma;
550
      else
551
        {
552
          asection *sec;
553
          int i;
554
 
555
          /* Sigh, the only way to get the section to offset against
556
             is to find it the hard way.  */
557
 
558
          for (sec = abfd->sections, i = 1; i < sym->n_scnum; i++)
559
            sec = sec->next;
560
 
561
          osect_vma = sec->output_section->vma;
562
        }
563
 
564
      *addendp -= osect_vma;
565
    }
566
#endif
567
 
568
  return howto;
569
}
570
 
571
/* Used by the assembler.  */
572
 
573
static bfd_reloc_status_type
574
aoutarm_fix_pcrel_26_done (bfd *abfd ATTRIBUTE_UNUSED,
575
                           arelent *reloc_entry ATTRIBUTE_UNUSED,
576
                           asymbol *symbol ATTRIBUTE_UNUSED,
577
                           void * data ATTRIBUTE_UNUSED,
578
                           asection *input_section ATTRIBUTE_UNUSED,
579
                           bfd *output_bfd ATTRIBUTE_UNUSED,
580
                           char **error_message ATTRIBUTE_UNUSED)
581
{
582
  /* This is dead simple at present.  */
583
  return bfd_reloc_ok;
584
}
585
 
586
/* Used by the assembler.  */
587
 
588
static bfd_reloc_status_type
589
aoutarm_fix_pcrel_26 (bfd *abfd,
590
                      arelent *reloc_entry,
591
                      asymbol *symbol,
592
                      void * data,
593
                      asection *input_section,
594
                      bfd *output_bfd,
595
                      char **error_message ATTRIBUTE_UNUSED)
596
{
597
  bfd_vma relocation;
598
  bfd_size_type addr = reloc_entry->address;
599
  long target = bfd_get_32 (abfd, (bfd_byte *) data + addr);
600
  bfd_reloc_status_type flag = bfd_reloc_ok;
601
 
602
  /* If this is an undefined symbol, return error.  */
603
  if (symbol->section == &bfd_und_section
604
      && (symbol->flags & BSF_WEAK) == 0)
605
    return output_bfd ? bfd_reloc_continue : bfd_reloc_undefined;
606
 
607
  /* If the sections are different, and we are doing a partial relocation,
608
     just ignore it for now.  */
609
  if (symbol->section->name != input_section->name
610
      && output_bfd != (bfd *)NULL)
611
    return bfd_reloc_continue;
612
 
613
  relocation = (target & 0x00ffffff) << 2;
614
  relocation = (relocation ^ 0x02000000) - 0x02000000; /* Sign extend.  */
615
  relocation += symbol->value;
616
  relocation += symbol->section->output_section->vma;
617
  relocation += symbol->section->output_offset;
618
  relocation += reloc_entry->addend;
619
  relocation -= input_section->output_section->vma;
620
  relocation -= input_section->output_offset;
621
  relocation -= addr;
622
 
623
  if (relocation & 3)
624
    return bfd_reloc_overflow;
625
 
626
  /* Check for overflow.  */
627
  if (relocation & 0x02000000)
628
    {
629
      if ((relocation & ~ (bfd_vma) 0x03ffffff) != ~ (bfd_vma) 0x03ffffff)
630
        flag = bfd_reloc_overflow;
631
    }
632
  else if (relocation & ~(bfd_vma) 0x03ffffff)
633
    flag = bfd_reloc_overflow;
634
 
635
  target &= ~0x00ffffff;
636
  target |= (relocation >> 2) & 0x00ffffff;
637
  bfd_put_32 (abfd, (bfd_vma) target, (bfd_byte *) data + addr);
638
 
639
  /* Now the ARM magic... Change the reloc type so that it is marked as done.
640
     Strictly this is only necessary if we are doing a partial relocation.  */
641
  reloc_entry->howto = &aoutarm_std_reloc_howto[ARM_26D];
642
 
643
  return flag;
644
}
645
 
646
static bfd_reloc_status_type
647
coff_thumb_pcrel_common (bfd *abfd,
648
                         arelent *reloc_entry,
649
                         asymbol *symbol,
650
                         void * data,
651
                         asection *input_section,
652
                         bfd *output_bfd,
653
                         char **error_message ATTRIBUTE_UNUSED,
654
                         thumb_pcrel_branchtype btype)
655
{
656
  bfd_vma relocation = 0;
657
  bfd_size_type addr = reloc_entry->address;
658
  long target = bfd_get_32 (abfd, (bfd_byte *) data + addr);
659
  bfd_reloc_status_type flag = bfd_reloc_ok;
660
  bfd_vma dstmsk;
661
  bfd_vma offmsk;
662
  bfd_vma signbit;
663
 
664
  /* NOTE: This routine is currently used by GAS, but not by the link
665
     phase.  */
666
  switch (btype)
667
    {
668
    case b9:
669
      dstmsk  = 0x000000ff;
670
      offmsk  = 0x000001fe;
671
      signbit = 0x00000100;
672
      break;
673
 
674
    case b12:
675
      dstmsk  = 0x000007ff;
676
      offmsk  = 0x00000ffe;
677
      signbit = 0x00000800;
678
      break;
679
 
680
    case b23:
681
      dstmsk  = 0x07ff07ff;
682
      offmsk  = 0x007fffff;
683
      signbit = 0x00400000;
684
      break;
685
 
686
    default:
687
      abort ();
688
    }
689
 
690
  /* If this is an undefined symbol, return error.  */
691
  if (symbol->section == &bfd_und_section
692
      && (symbol->flags & BSF_WEAK) == 0)
693
    return output_bfd ? bfd_reloc_continue : bfd_reloc_undefined;
694
 
695
  /* If the sections are different, and we are doing a partial relocation,
696
     just ignore it for now.  */
697
  if (symbol->section->name != input_section->name
698
      && output_bfd != (bfd *)NULL)
699
    return bfd_reloc_continue;
700
 
701
  switch (btype)
702
    {
703
    case b9:
704
    case b12:
705
      relocation = ((target & dstmsk) << 1);
706
      break;
707
 
708
    case b23:
709
      if (bfd_big_endian (abfd))
710
        relocation = ((target & 0x7ff) << 1)  | ((target & 0x07ff0000) >> 4);
711
      else
712
        relocation = ((target & 0x7ff) << 12) | ((target & 0x07ff0000) >> 15);
713
      break;
714
 
715
    default:
716
      abort ();
717
    }
718
 
719
  relocation = (relocation ^ signbit) - signbit; /* Sign extend.  */
720
  relocation += symbol->value;
721
  relocation += symbol->section->output_section->vma;
722
  relocation += symbol->section->output_offset;
723
  relocation += reloc_entry->addend;
724
  relocation -= input_section->output_section->vma;
725
  relocation -= input_section->output_offset;
726
  relocation -= addr;
727
 
728
  if (relocation & 1)
729
    return bfd_reloc_overflow;
730
 
731
  /* Check for overflow.  */
732
  if (relocation & signbit)
733
    {
734
      if ((relocation & ~offmsk) != ~offmsk)
735
        flag = bfd_reloc_overflow;
736
    }
737
  else if (relocation & ~offmsk)
738
    flag = bfd_reloc_overflow;
739
 
740
  target &= ~dstmsk;
741
  switch (btype)
742
   {
743
   case b9:
744
   case b12:
745
     target |= (relocation >> 1);
746
     break;
747
 
748
   case b23:
749
     if (bfd_big_endian (abfd))
750
       target |= (((relocation & 0xfff) >> 1)
751
                  | ((relocation << 4)  & 0x07ff0000));
752
     else
753
       target |= (((relocation & 0xffe) << 15)
754
                  | ((relocation >> 12) & 0x7ff));
755
     break;
756
 
757
   default:
758
     abort ();
759
   }
760
 
761
  bfd_put_32 (abfd, (bfd_vma) target, (bfd_byte *) data + addr);
762
 
763
  /* Now the ARM magic... Change the reloc type so that it is marked as done.
764
     Strictly this is only necessary if we are doing a partial relocation.  */
765
  reloc_entry->howto = & aoutarm_std_reloc_howto [ARM_26D];
766
 
767
  /* TODO: We should possibly have DONE entries for the THUMB PCREL relocations.  */
768
  return flag;
769
}
770
 
771
#ifndef ARM_WINCE
772
static bfd_reloc_status_type
773
coff_thumb_pcrel_23 (bfd *abfd,
774
                     arelent *reloc_entry,
775
                     asymbol *symbol,
776
                     void * data,
777
                     asection *input_section,
778
                     bfd *output_bfd,
779
                     char **error_message)
780
{
781
  return coff_thumb_pcrel_common (abfd, reloc_entry, symbol, data,
782
                                  input_section, output_bfd, error_message,
783
                                  b23);
784
}
785
 
786
static bfd_reloc_status_type
787
coff_thumb_pcrel_9 (bfd *abfd,
788
                    arelent *reloc_entry,
789
                    asymbol *symbol,
790
                    void * data,
791
                    asection *input_section,
792
                    bfd *output_bfd,
793
                    char **error_message)
794
{
795
  return coff_thumb_pcrel_common (abfd, reloc_entry, symbol, data,
796
                                  input_section, output_bfd, error_message,
797
                                  b9);
798
}
799
#endif /* not ARM_WINCE */
800
 
801
static bfd_reloc_status_type
802
coff_thumb_pcrel_12 (bfd *abfd,
803
                     arelent *reloc_entry,
804
                     asymbol *symbol,
805
                     void * data,
806
                     asection *input_section,
807
                     bfd *output_bfd,
808
                     char **error_message)
809
{
810
  return coff_thumb_pcrel_common (abfd, reloc_entry, symbol, data,
811
                                  input_section, output_bfd, error_message,
812
                                  b12);
813
}
814
 
815
static const struct reloc_howto_struct *
816
coff_arm_reloc_type_lookup (bfd * abfd, bfd_reloc_code_real_type code)
817
{
818
#define ASTD(i,j)       case i: return aoutarm_std_reloc_howto + j
819
 
820
  if (code == BFD_RELOC_CTOR)
821
    switch (bfd_get_arch_info (abfd)->bits_per_address)
822
      {
823
      case 32:
824
        code = BFD_RELOC_32;
825
        break;
826
      default:
827
        return NULL;
828
      }
829
 
830
  switch (code)
831
    {
832
#ifdef ARM_WINCE
833
      ASTD (BFD_RELOC_32,                   ARM_32);
834
      ASTD (BFD_RELOC_RVA,                  ARM_RVA32);
835
      ASTD (BFD_RELOC_ARM_PCREL_BRANCH,     ARM_26);
836
      ASTD (BFD_RELOC_THUMB_PCREL_BRANCH12, ARM_THUMB12);
837
      ASTD (BFD_RELOC_32_SECREL,            ARM_SECREL);
838
#else
839
      ASTD (BFD_RELOC_8,                    ARM_8);
840
      ASTD (BFD_RELOC_16,                   ARM_16);
841
      ASTD (BFD_RELOC_32,                   ARM_32);
842
      ASTD (BFD_RELOC_ARM_PCREL_BRANCH,     ARM_26);
843
      ASTD (BFD_RELOC_ARM_PCREL_BLX,        ARM_26);
844
      ASTD (BFD_RELOC_8_PCREL,              ARM_DISP8);
845
      ASTD (BFD_RELOC_16_PCREL,             ARM_DISP16);
846
      ASTD (BFD_RELOC_32_PCREL,             ARM_DISP32);
847
      ASTD (BFD_RELOC_RVA,                  ARM_RVA32);
848
      ASTD (BFD_RELOC_THUMB_PCREL_BRANCH9,  ARM_THUMB9);
849
      ASTD (BFD_RELOC_THUMB_PCREL_BRANCH12, ARM_THUMB12);
850
      ASTD (BFD_RELOC_THUMB_PCREL_BRANCH23, ARM_THUMB23);
851
      ASTD (BFD_RELOC_THUMB_PCREL_BLX,      ARM_THUMB23);
852
#endif
853
    default: return NULL;
854
    }
855
}
856
 
857
static reloc_howto_type *
858
coff_arm_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
859
                            const char *r_name)
860
{
861
  unsigned int i;
862
 
863
  for (i = 0;
864
       i < (sizeof (aoutarm_std_reloc_howto)
865
            / sizeof (aoutarm_std_reloc_howto[0]));
866
       i++)
867
    if (aoutarm_std_reloc_howto[i].name != NULL
868
        && strcasecmp (aoutarm_std_reloc_howto[i].name, r_name) == 0)
869
      return &aoutarm_std_reloc_howto[i];
870
 
871
  return NULL;
872
}
873
 
874
#define COFF_DEFAULT_SECTION_ALIGNMENT_POWER  2
875
#define COFF_PAGE_SIZE                        0x1000
876
 
877
/* Turn a howto into a reloc  nunmber.  */
878
#define SELECT_RELOC(x,howto) { x.r_type = howto->type; }
879
#define BADMAG(x)             ARMBADMAG(x)
880
#define ARM                   1                 /* Customize coffcode.h.  */
881
 
882
#ifndef ARM_WINCE
883
/* Make sure that the 'r_offset' field is copied properly
884
   so that identical binaries will compare the same.  */
885
#define SWAP_IN_RELOC_OFFSET    H_GET_32
886
#define SWAP_OUT_RELOC_OFFSET   H_PUT_32
887
#endif
888
 
889
/* Extend the coff_link_hash_table structure with a few ARM specific fields.
890
   This allows us to store global data here without actually creating any
891
   global variables, which is a no-no in the BFD world.  */
892
struct coff_arm_link_hash_table
893
  {
894
    /* The original coff_link_hash_table structure.  MUST be first field.  */
895
    struct coff_link_hash_table root;
896
 
897
    /* The size in bytes of the section containing the Thumb-to-ARM glue.  */
898
    bfd_size_type               thumb_glue_size;
899
 
900
    /* The size in bytes of the section containing the ARM-to-Thumb glue.  */
901
    bfd_size_type               arm_glue_size;
902
 
903
    /* An arbitrary input BFD chosen to hold the glue sections.  */
904
    bfd *                       bfd_of_glue_owner;
905
 
906
    /* Support interworking with old, non-interworking aware ARM code.  */
907
    int                         support_old_code;
908
};
909
 
910
/* Get the ARM coff linker hash table from a link_info structure.  */
911
#define coff_arm_hash_table(info) \
912
  ((struct coff_arm_link_hash_table *) ((info)->hash))
913
 
914
/* Create an ARM coff linker hash table.  */
915
 
916
static struct bfd_link_hash_table *
917
coff_arm_link_hash_table_create (bfd * abfd)
918
{
919
  struct coff_arm_link_hash_table * ret;
920
  bfd_size_type amt = sizeof (struct coff_arm_link_hash_table);
921
 
922
  ret = bfd_malloc (amt);
923
  if (ret == NULL)
924
    return NULL;
925
 
926
  if (!_bfd_coff_link_hash_table_init (&ret->root,
927
                                       abfd,
928
                                       _bfd_coff_link_hash_newfunc,
929
                                       sizeof (struct coff_link_hash_entry)))
930
    {
931
      free (ret);
932
      return NULL;
933
    }
934
 
935
  ret->thumb_glue_size   = 0;
936
  ret->arm_glue_size     = 0;
937
  ret->bfd_of_glue_owner = NULL;
938
 
939
  return & ret->root.root;
940
}
941
 
942
static bfd_boolean
943
arm_emit_base_file_entry (struct bfd_link_info *info,
944
                          bfd *output_bfd,
945
                          asection *input_section,
946
                          bfd_vma reloc_offset)
947
{
948
  bfd_vma addr = (reloc_offset
949
                  - input_section->vma
950
                  + input_section->output_offset
951
                  + input_section->output_section->vma);
952
 
953
  if (coff_data (output_bfd)->pe)
954
     addr -= pe_data (output_bfd)->pe_opthdr.ImageBase;
955
  if (fwrite (&addr, sizeof (addr), 1, (FILE *) info->base_file) == 1)
956
    return TRUE;
957
 
958
  bfd_set_error (bfd_error_system_call);
959
  return FALSE;
960
}
961
 
962
#ifndef ARM_WINCE
963
/* The thumb form of a long branch is a bit finicky, because the offset
964
   encoding is split over two fields, each in it's own instruction. They
965
   can occur in any order. So given a thumb form of long branch, and an
966
   offset, insert the offset into the thumb branch and return finished
967
   instruction.
968
 
969
   It takes two thumb instructions to encode the target address. Each has
970
   11 bits to invest. The upper 11 bits are stored in one (identified by
971
   H-0.. see below), the lower 11 bits are stored in the other (identified
972
   by H-1).
973
 
974
   Combine together and shifted left by 1 (it's a half word address) and
975
   there you have it.
976
 
977
     Op: 1111 = F,
978
     H-0, upper address-0 = 000
979
     Op: 1111 = F,
980
     H-1, lower address-0 = 800
981
 
982
   They can be ordered either way, but the arm tools I've seen always put
983
   the lower one first. It probably doesn't matter. krk@cygnus.com
984
 
985
   XXX:  Actually the order does matter.  The second instruction (H-1)
986
   moves the computed address into the PC, so it must be the second one
987
   in the sequence.  The problem, however is that whilst little endian code
988
   stores the instructions in HI then LOW order, big endian code does the
989
   reverse.  nickc@cygnus.com.  */
990
 
991
#define LOW_HI_ORDER 0xF800F000
992
#define HI_LOW_ORDER 0xF000F800
993
 
994
static insn32
995
insert_thumb_branch (insn32 br_insn, int rel_off)
996
{
997
  unsigned int low_bits;
998
  unsigned int high_bits;
999
 
1000
  BFD_ASSERT ((rel_off & 1) != 1);
1001
 
1002
  rel_off >>= 1;                              /* Half word aligned address.  */
1003
  low_bits = rel_off & 0x000007FF;            /* The bottom 11 bits.  */
1004
  high_bits = (rel_off >> 11) & 0x000007FF;   /* The top 11 bits.  */
1005
 
1006
  if ((br_insn & LOW_HI_ORDER) == LOW_HI_ORDER)
1007
    br_insn = LOW_HI_ORDER | (low_bits << 16) | high_bits;
1008
  else if ((br_insn & HI_LOW_ORDER) == HI_LOW_ORDER)
1009
    br_insn = HI_LOW_ORDER | (high_bits << 16) | low_bits;
1010
  else
1011
    /* FIXME: the BFD library should never abort except for internal errors
1012
       - it should return an error status.  */
1013
    abort (); /* Error - not a valid branch instruction form.  */
1014
 
1015
  return br_insn;
1016
}
1017
 
1018
 
1019
static struct coff_link_hash_entry *
1020
find_thumb_glue (struct bfd_link_info *info,
1021
                 const char *name,
1022
                 bfd *input_bfd)
1023
{
1024
  char *tmp_name;
1025
  struct coff_link_hash_entry *myh;
1026
  bfd_size_type amt = strlen (name) + strlen (THUMB2ARM_GLUE_ENTRY_NAME) + 1;
1027
 
1028
  tmp_name = bfd_malloc (amt);
1029
 
1030
  BFD_ASSERT (tmp_name);
1031
 
1032
  sprintf (tmp_name, THUMB2ARM_GLUE_ENTRY_NAME, name);
1033
 
1034
  myh = coff_link_hash_lookup
1035
    (coff_hash_table (info), tmp_name, FALSE, FALSE, TRUE);
1036
 
1037
  if (myh == NULL)
1038
    /* xgettext:c-format */
1039
    _bfd_error_handler (_("%B: unable to find THUMB glue '%s' for `%s'"),
1040
                        input_bfd, tmp_name, name);
1041
 
1042
  free (tmp_name);
1043
 
1044
  return myh;
1045
}
1046
#endif /* not ARM_WINCE */
1047
 
1048
static struct coff_link_hash_entry *
1049
find_arm_glue (struct bfd_link_info *info,
1050
               const char *name,
1051
               bfd *input_bfd)
1052
{
1053
  char *tmp_name;
1054
  struct coff_link_hash_entry * myh;
1055
  bfd_size_type amt = strlen (name) + strlen (ARM2THUMB_GLUE_ENTRY_NAME) + 1;
1056
 
1057
  tmp_name = bfd_malloc (amt);
1058
 
1059
  BFD_ASSERT (tmp_name);
1060
 
1061
  sprintf (tmp_name, ARM2THUMB_GLUE_ENTRY_NAME, name);
1062
 
1063
  myh = coff_link_hash_lookup
1064
    (coff_hash_table (info), tmp_name, FALSE, FALSE, TRUE);
1065
 
1066
  if (myh == NULL)
1067
    /* xgettext:c-format */
1068
    _bfd_error_handler (_("%B: unable to find ARM glue '%s' for `%s'"),
1069
                        input_bfd, tmp_name, name);
1070
 
1071
  free (tmp_name);
1072
 
1073
  return myh;
1074
}
1075
 
1076
/*
1077
  ARM->Thumb glue:
1078
 
1079
       .arm
1080
       __func_from_arm:
1081
             ldr r12, __func_addr
1082
             bx  r12
1083
       __func_addr:
1084
            .word func    @ behave as if you saw a ARM_32 reloc
1085
*/
1086
 
1087
#define ARM2THUMB_GLUE_SIZE 12
1088
static const insn32 a2t1_ldr_insn       = 0xe59fc000;
1089
static const insn32 a2t2_bx_r12_insn    = 0xe12fff1c;
1090
static const insn32 a2t3_func_addr_insn = 0x00000001;
1091
 
1092
/*
1093
   Thumb->ARM:                          Thumb->(non-interworking aware) ARM
1094
 
1095
   .thumb                               .thumb
1096
   .align 2                             .align 2
1097
      __func_from_thumb:                   __func_from_thumb:
1098
           bx pc                                push {r6, lr}
1099
           nop                                  ldr  r6, __func_addr
1100
   .arm                                         mov  lr, pc
1101
      __func_change_to_arm:                     bx   r6
1102
           b func                       .arm
1103
                                           __func_back_to_thumb:
1104
                                                ldmia r13! {r6, lr}
1105
                                                bx    lr
1106
                                           __func_addr:
1107
                                                .word   func
1108
*/
1109
 
1110
#define THUMB2ARM_GLUE_SIZE (globals->support_old_code ? 20 : 8)
1111
#ifndef ARM_WINCE
1112
static const insn16 t2a1_bx_pc_insn = 0x4778;
1113
static const insn16 t2a2_noop_insn  = 0x46c0;
1114
static const insn32 t2a3_b_insn     = 0xea000000;
1115
 
1116
static const insn16 t2a1_push_insn  = 0xb540;
1117
static const insn16 t2a2_ldr_insn   = 0x4e03;
1118
static const insn16 t2a3_mov_insn   = 0x46fe;
1119
static const insn16 t2a4_bx_insn    = 0x4730;
1120
static const insn32 t2a5_pop_insn   = 0xe8bd4040;
1121
static const insn32 t2a6_bx_insn    = 0xe12fff1e;
1122
#endif
1123
 
1124
/* TODO:
1125
     We should really create new local (static) symbols in destination
1126
     object for each stub we create.  We should also create local
1127
     (static) symbols within the stubs when switching between ARM and
1128
     Thumb code.  This will ensure that the debugger and disassembler
1129
     can present a better view of stubs.
1130
 
1131
     We can treat stubs like literal sections, and for the THUMB9 ones
1132
     (short addressing range) we should be able to insert the stubs
1133
     between sections. i.e. the simplest approach (since relocations
1134
     are done on a section basis) is to dump the stubs at the end of
1135
     processing a section. That way we can always try and minimise the
1136
     offset to and from a stub. However, this does not map well onto
1137
     the way that the linker/BFD does its work: mapping all input
1138
     sections to output sections via the linker script before doing
1139
     all the processing.
1140
 
1141
     Unfortunately it may be easier to just to disallow short range
1142
     Thumb->ARM stubs (i.e. no conditional inter-working branches,
1143
     only branch-and-link (BL) calls.  This will simplify the processing
1144
     since we can then put all of the stubs into their own section.
1145
 
1146
  TODO:
1147
     On a different subject, rather than complaining when a
1148
     branch cannot fit in the number of bits available for the
1149
     instruction we should generate a trampoline stub (needed to
1150
     address the complete 32bit address space).  */
1151
 
1152
/* The standard COFF backend linker does not cope with the special
1153
   Thumb BRANCH23 relocation.  The alternative would be to split the
1154
   BRANCH23 into seperate HI23 and LO23 relocations. However, it is a
1155
   bit simpler simply providing our own relocation driver.  */
1156
 
1157
/* The reloc processing routine for the ARM/Thumb COFF linker.  NOTE:
1158
   This code is a very slightly modified copy of
1159
   _bfd_coff_generic_relocate_section.  It would be a much more
1160
   maintainable solution to have a MACRO that could be expanded within
1161
   _bfd_coff_generic_relocate_section that would only be provided for
1162
   ARM/Thumb builds.  It is only the code marked THUMBEXTENSION that
1163
   is different from the original.  */
1164
 
1165
static bfd_boolean
1166
coff_arm_relocate_section (bfd *output_bfd,
1167
                           struct bfd_link_info *info,
1168
                           bfd *input_bfd,
1169
                           asection *input_section,
1170
                           bfd_byte *contents,
1171
                           struct internal_reloc *relocs,
1172
                           struct internal_syment *syms,
1173
                           asection **sections)
1174
{
1175
  struct internal_reloc * rel;
1176
  struct internal_reloc * relend;
1177
#ifndef ARM_WINCE
1178
  bfd_vma high_address = bfd_get_section_limit (input_bfd, input_section);
1179
#endif
1180
 
1181
  rel = relocs;
1182
  relend = rel + input_section->reloc_count;
1183
 
1184
  for (; rel < relend; rel++)
1185
    {
1186
      int                            done = 0;
1187
      long                           symndx;
1188
      struct coff_link_hash_entry *  h;
1189
      struct internal_syment *       sym;
1190
      bfd_vma                        addend;
1191
      bfd_vma                        val;
1192
      reloc_howto_type *             howto;
1193
      bfd_reloc_status_type          rstat;
1194
      bfd_vma                        h_val;
1195
 
1196
      symndx = rel->r_symndx;
1197
 
1198
      if (symndx == -1)
1199
        {
1200
          h = NULL;
1201
          sym = NULL;
1202
        }
1203
      else
1204
        {
1205
          h = obj_coff_sym_hashes (input_bfd)[symndx];
1206
          sym = syms + symndx;
1207
        }
1208
 
1209
      /* COFF treats common symbols in one of two ways.  Either the
1210
         size of the symbol is included in the section contents, or it
1211
         is not.  We assume that the size is not included, and force
1212
         the rtype_to_howto function to adjust the addend as needed.  */
1213
 
1214
      if (sym != NULL && sym->n_scnum != 0)
1215
        addend = - sym->n_value;
1216
      else
1217
        addend = 0;
1218
 
1219
      howto = coff_rtype_to_howto (input_bfd, input_section, rel, h,
1220
                                       sym, &addend);
1221
      if (howto == NULL)
1222
        return FALSE;
1223
 
1224
      /* The relocation_section function will skip pcrel_offset relocs
1225
         when doing a relocatable link.  However, we want to convert
1226
         ARM_26 to ARM_26D relocs if possible.  We return a fake howto in
1227
         this case without pcrel_offset set, and adjust the addend to
1228
         compensate.  'partial_inplace' is also set, since we want 'done'
1229
         relocations to be reflected in section's data.  */
1230
      if (rel->r_type == ARM_26
1231
          && h != NULL
1232
          && info->relocatable
1233
          && (h->root.type == bfd_link_hash_defined
1234
              || h->root.type == bfd_link_hash_defweak)
1235
          && (h->root.u.def.section->output_section
1236
              == input_section->output_section))
1237
        {
1238
          static reloc_howto_type fake_arm26_reloc =
1239
            HOWTO (ARM_26,
1240
               2,
1241
               2,
1242
               24,
1243
               TRUE,
1244
               0,
1245
               complain_overflow_signed,
1246
               aoutarm_fix_pcrel_26 ,
1247
               "ARM_26",
1248
               TRUE,
1249
               0x00ffffff,
1250
               0x00ffffff,
1251
               FALSE);
1252
 
1253
          addend -= rel->r_vaddr - input_section->vma;
1254
#ifdef ARM_WINCE
1255
          /* FIXME: I don't know why, but the hack is necessary for correct
1256
                    generation of bl's instruction offset.  */
1257
          addend -= 8;
1258
#endif
1259
          howto = & fake_arm26_reloc;
1260
        }
1261
 
1262
#ifdef ARM_WINCE
1263
      /* MS ARM-CE makes the reloc relative to the opcode's pc, not
1264
         the next opcode's pc, so is off by one.  */
1265
      if (howto->pc_relative && !info->relocatable)
1266
        addend -= 8;
1267
#endif
1268
 
1269
      /* If we are doing a relocatable link, then we can just ignore
1270
         a PC relative reloc that is pcrel_offset.  It will already
1271
         have the correct value.  If this is not a relocatable link,
1272
         then we should ignore the symbol value.  */
1273
      if (howto->pc_relative && howto->pcrel_offset)
1274
        {
1275
          if (info->relocatable)
1276
            continue;
1277
          /* FIXME - it is not clear which targets need this next test
1278
             and which do not.  It is known that it is needed for the
1279
             VxWorks and EPOC-PE targets, but it is also known that it
1280
             was suppressed for other ARM targets.  This ought to be
1281
             sorted out one day.  */
1282
#ifdef ARM_COFF_BUGFIX
1283
          /* We must not ignore the symbol value.  If the symbol is
1284
             within the same section, the relocation should have already
1285
             been fixed, but if it is not, we'll be handed a reloc into
1286
             the beginning of the symbol's section, so we must not cancel
1287
             out the symbol's value, otherwise we'll be adding it in
1288
             twice.  */
1289
          if (sym != NULL && sym->n_scnum != 0)
1290
            addend += sym->n_value;
1291
#endif
1292
        }
1293
 
1294
      val = 0;
1295
 
1296
      if (h == NULL)
1297
        {
1298
          asection *sec;
1299
 
1300
          if (symndx == -1)
1301
            {
1302
              sec = bfd_abs_section_ptr;
1303
              val = 0;
1304
            }
1305
          else
1306
            {
1307
              sec = sections[symndx];
1308
              val = (sec->output_section->vma
1309
                     + sec->output_offset
1310
                     + sym->n_value
1311
                     - sec->vma);
1312
            }
1313
        }
1314
      else
1315
        {
1316
          /* We don't output the stubs if we are generating a
1317
             relocatable output file, since we may as well leave the
1318
             stub generation to the final linker pass. If we fail to
1319
             verify that the name is defined, we'll try to build stubs
1320
             for an undefined name...  */
1321
          if (! info->relocatable
1322
              && (   h->root.type == bfd_link_hash_defined
1323
                  || h->root.type == bfd_link_hash_defweak))
1324
            {
1325
              asection *   h_sec = h->root.u.def.section;
1326
              const char * name  = h->root.root.string;
1327
 
1328
              /* h locates the symbol referenced in the reloc.  */
1329
              h_val = (h->root.u.def.value
1330
                       + h_sec->output_section->vma
1331
                       + h_sec->output_offset);
1332
 
1333
              if (howto->type == ARM_26)
1334
                {
1335
                  if (   h->class == C_THUMBSTATFUNC
1336
                      || h->class == C_THUMBEXTFUNC)
1337
                    {
1338
                      /* Arm code calling a Thumb function.  */
1339
                      unsigned long int                 tmp;
1340
                      bfd_vma                           my_offset;
1341
                      asection *                        s;
1342
                      long int                          ret_offset;
1343
                      struct coff_link_hash_entry *     myh;
1344
                      struct coff_arm_link_hash_table * globals;
1345
 
1346
                      myh = find_arm_glue (info, name, input_bfd);
1347
                      if (myh == NULL)
1348
                        return FALSE;
1349
 
1350
                      globals = coff_arm_hash_table (info);
1351
 
1352
                      BFD_ASSERT (globals != NULL);
1353
                      BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
1354
 
1355
                      my_offset = myh->root.u.def.value;
1356
 
1357
                      s = bfd_get_section_by_name (globals->bfd_of_glue_owner,
1358
                                                  ARM2THUMB_GLUE_SECTION_NAME);
1359
                      BFD_ASSERT (s != NULL);
1360
                      BFD_ASSERT (s->contents != NULL);
1361
                      BFD_ASSERT (s->output_section != NULL);
1362
 
1363
                      if ((my_offset & 0x01) == 0x01)
1364
                        {
1365
                          if (h_sec->owner != NULL
1366
                              && INTERWORK_SET (h_sec->owner)
1367
                              && ! INTERWORK_FLAG (h_sec->owner))
1368
                            _bfd_error_handler
1369
                              /* xgettext:c-format */
1370
                              (_("%B(%s): warning: interworking not enabled.\n"
1371
                                 "  first occurrence: %B: arm call to thumb"),
1372
                               h_sec->owner, input_bfd, name);
1373
 
1374
                          --my_offset;
1375
                          myh->root.u.def.value = my_offset;
1376
 
1377
                          bfd_put_32 (output_bfd, (bfd_vma) a2t1_ldr_insn,
1378
                                      s->contents + my_offset);
1379
 
1380
                          bfd_put_32 (output_bfd, (bfd_vma) a2t2_bx_r12_insn,
1381
                                      s->contents + my_offset + 4);
1382
 
1383
                          /* It's a thumb address.  Add the low order bit.  */
1384
                          bfd_put_32 (output_bfd, h_val | a2t3_func_addr_insn,
1385
                                      s->contents + my_offset + 8);
1386
 
1387
                          if (info->base_file
1388
                              && !arm_emit_base_file_entry (info, output_bfd,
1389
                                                            s, my_offset + 8))
1390
                            return FALSE;
1391
                        }
1392
 
1393
                      BFD_ASSERT (my_offset <= globals->arm_glue_size);
1394
 
1395
                      tmp = bfd_get_32 (input_bfd, contents + rel->r_vaddr
1396
                                        - input_section->vma);
1397
 
1398
                      tmp = tmp & 0xFF000000;
1399
 
1400
                      /* Somehow these are both 4 too far, so subtract 8.  */
1401
                      ret_offset =
1402
                        s->output_offset
1403
                        + my_offset
1404
                        + s->output_section->vma
1405
                        - (input_section->output_offset
1406
                           + input_section->output_section->vma
1407
                           + rel->r_vaddr)
1408
                        - 8;
1409
 
1410
                      tmp = tmp | ((ret_offset >> 2) & 0x00FFFFFF);
1411
 
1412
                      bfd_put_32 (output_bfd, (bfd_vma) tmp,
1413
                                  contents + rel->r_vaddr - input_section->vma);
1414
                      done = 1;
1415
                    }
1416
                }
1417
 
1418
#ifndef ARM_WINCE
1419
              /* Note: We used to check for ARM_THUMB9 and ARM_THUMB12.  */
1420
              else if (howto->type == ARM_THUMB23)
1421
                {
1422
                  if (   h->class == C_EXT
1423
                      || h->class == C_STAT
1424
                      || h->class == C_LABEL)
1425
                    {
1426
                      /* Thumb code calling an ARM function.  */
1427
                      asection *                         s = 0;
1428
                      bfd_vma                            my_offset;
1429
                      unsigned long int                  tmp;
1430
                      long int                           ret_offset;
1431
                      struct coff_link_hash_entry *      myh;
1432
                      struct coff_arm_link_hash_table *  globals;
1433
 
1434
                      myh = find_thumb_glue (info, name, input_bfd);
1435
                      if (myh == NULL)
1436
                        return FALSE;
1437
 
1438
                      globals = coff_arm_hash_table (info);
1439
 
1440
                      BFD_ASSERT (globals != NULL);
1441
                      BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
1442
 
1443
                      my_offset = myh->root.u.def.value;
1444
 
1445
                      s = bfd_get_section_by_name (globals->bfd_of_glue_owner,
1446
                                                   THUMB2ARM_GLUE_SECTION_NAME);
1447
 
1448
                      BFD_ASSERT (s != NULL);
1449
                      BFD_ASSERT (s->contents != NULL);
1450
                      BFD_ASSERT (s->output_section != NULL);
1451
 
1452
                      if ((my_offset & 0x01) == 0x01)
1453
                        {
1454
                          if (h_sec->owner != NULL
1455
                              && INTERWORK_SET (h_sec->owner)
1456
                              && ! INTERWORK_FLAG (h_sec->owner)
1457
                              && ! globals->support_old_code)
1458
                            _bfd_error_handler
1459
                              /* xgettext:c-format */
1460
                              (_("%B(%s): warning: interworking not enabled.\n"
1461
                                 "  first occurrence: %B: thumb call to arm\n"
1462
                                 "  consider relinking with --support-old-code enabled"),
1463
                               h_sec->owner, input_bfd, name);
1464
 
1465
                          -- my_offset;
1466
                          myh->root.u.def.value = my_offset;
1467
 
1468
                          if (globals->support_old_code)
1469
                            {
1470
                              bfd_put_16 (output_bfd, (bfd_vma) t2a1_push_insn,
1471
                                          s->contents + my_offset);
1472
 
1473
                              bfd_put_16 (output_bfd, (bfd_vma) t2a2_ldr_insn,
1474
                                          s->contents + my_offset + 2);
1475
 
1476
                              bfd_put_16 (output_bfd, (bfd_vma) t2a3_mov_insn,
1477
                                          s->contents + my_offset + 4);
1478
 
1479
                              bfd_put_16 (output_bfd, (bfd_vma) t2a4_bx_insn,
1480
                                          s->contents + my_offset + 6);
1481
 
1482
                              bfd_put_32 (output_bfd, (bfd_vma) t2a5_pop_insn,
1483
                                          s->contents + my_offset + 8);
1484
 
1485
                              bfd_put_32 (output_bfd, (bfd_vma) t2a6_bx_insn,
1486
                                          s->contents + my_offset + 12);
1487
 
1488
                              /* Store the address of the function in the last word of the stub.  */
1489
                              bfd_put_32 (output_bfd, h_val,
1490
                                          s->contents + my_offset + 16);
1491
 
1492
                              if (info->base_file
1493
                                  && !arm_emit_base_file_entry (info,
1494
                                                                output_bfd, s,
1495
                                                                my_offset + 16))
1496
                                return FALSE;
1497
                            }
1498
                          else
1499
                            {
1500
                              bfd_put_16 (output_bfd, (bfd_vma) t2a1_bx_pc_insn,
1501
                                          s->contents + my_offset);
1502
 
1503
                              bfd_put_16 (output_bfd, (bfd_vma) t2a2_noop_insn,
1504
                                          s->contents + my_offset + 2);
1505
 
1506
                              ret_offset =
1507
                /* Address of destination of the stub.  */
1508
                                ((bfd_signed_vma) h_val)
1509
                                - ((bfd_signed_vma)
1510
                /* Offset from the start of the current section to the start of the stubs.  */
1511
                                   (s->output_offset
1512
                /* Offset of the start of this stub from the start of the stubs.  */
1513
                                    + my_offset
1514
                /* Address of the start of the current section.  */
1515
                                    + s->output_section->vma)
1516
                /* The branch instruction is 4 bytes into the stub.  */
1517
                                   + 4
1518
                /* ARM branches work from the pc of the instruction + 8.  */
1519
                                   + 8);
1520
 
1521
                              bfd_put_32 (output_bfd,
1522
                                          (bfd_vma) t2a3_b_insn | ((ret_offset >> 2) & 0x00FFFFFF),
1523
                                          s->contents + my_offset + 4);
1524
 
1525
                            }
1526
                        }
1527
 
1528
                      BFD_ASSERT (my_offset <= globals->thumb_glue_size);
1529
 
1530
                      /* Now go back and fix up the original BL insn to point
1531
                         to here.  */
1532
                      ret_offset =
1533
                        s->output_offset
1534
                        + my_offset
1535
                        - (input_section->output_offset
1536
                           + rel->r_vaddr)
1537
                        -4;
1538
 
1539
                      tmp = bfd_get_32 (input_bfd, contents + rel->r_vaddr
1540
                                        - input_section->vma);
1541
 
1542
                      bfd_put_32 (output_bfd,
1543
                                  (bfd_vma) insert_thumb_branch (tmp,
1544
                                                                 ret_offset),
1545
                                  contents + rel->r_vaddr - input_section->vma);
1546
 
1547
                      done = 1;
1548
                    }
1549
                }
1550
#endif
1551
            }
1552
 
1553
          /* If the relocation type and destination symbol does not
1554
             fall into one of the above categories, then we can just
1555
             perform a direct link.  */
1556
 
1557
          if (done)
1558
            rstat = bfd_reloc_ok;
1559
          else
1560
            if (   h->root.type == bfd_link_hash_defined
1561
                || h->root.type == bfd_link_hash_defweak)
1562
            {
1563
              asection *sec;
1564
 
1565
              sec = h->root.u.def.section;
1566
              val = (h->root.u.def.value
1567
                     + sec->output_section->vma
1568
                     + sec->output_offset);
1569
              }
1570
 
1571
          else if (! info->relocatable)
1572
            {
1573
              if (! ((*info->callbacks->undefined_symbol)
1574
                     (info, h->root.root.string, input_bfd, input_section,
1575
                      rel->r_vaddr - input_section->vma, TRUE)))
1576
                return FALSE;
1577
            }
1578
        }
1579
 
1580
      /* Emit a reloc if the backend thinks it needs it.  */
1581
      if (info->base_file
1582
          && sym
1583
          && pe_data(output_bfd)->in_reloc_p(output_bfd, howto)
1584
          && !arm_emit_base_file_entry (info, output_bfd, input_section,
1585
                                        rel->r_vaddr))
1586
        return FALSE;
1587
 
1588
      if (done)
1589
        rstat = bfd_reloc_ok;
1590
#ifndef ARM_WINCE
1591
      /* Only perform this fix during the final link, not a relocatable link.  */
1592
      else if (! info->relocatable
1593
               && howto->type == ARM_THUMB23)
1594
        {
1595
          /* This is pretty much a copy of what the default
1596
             _bfd_final_link_relocate and _bfd_relocate_contents
1597
             routines do to perform a relocation, with special
1598
             processing for the split addressing of the Thumb BL
1599
             instruction.  Again, it would probably be simpler adding a
1600
             ThumbBRANCH23 specific macro expansion into the default
1601
             code.  */
1602
 
1603
          bfd_vma address = rel->r_vaddr - input_section->vma;
1604
 
1605
          if (address > high_address)
1606
            rstat = bfd_reloc_outofrange;
1607
          else
1608
            {
1609
              bfd_vma relocation = val + addend;
1610
              int size = bfd_get_reloc_size (howto);
1611
              bfd_boolean overflow = FALSE;
1612
              bfd_byte *location = contents + address;
1613
              bfd_vma x = bfd_get_32 (input_bfd, location);
1614
              bfd_vma src_mask = 0x007FFFFE;
1615
              bfd_signed_vma reloc_signed_max = (1 << (howto->bitsize - 1)) - 1;
1616
              bfd_signed_vma reloc_signed_min = ~reloc_signed_max;
1617
              bfd_vma check;
1618
              bfd_signed_vma signed_check;
1619
              bfd_vma add;
1620
              bfd_signed_vma signed_add;
1621
 
1622
              BFD_ASSERT (size == 4);
1623
 
1624
              /* howto->pc_relative should be TRUE for type 14 BRANCH23.  */
1625
              relocation -= (input_section->output_section->vma
1626
                             + input_section->output_offset);
1627
 
1628
              /* howto->pcrel_offset should be TRUE for type 14 BRANCH23.  */
1629
              relocation -= address;
1630
 
1631
              /* No need to negate the relocation with BRANCH23.  */
1632
              /* howto->complain_on_overflow == complain_overflow_signed for BRANCH23.  */
1633
              /* howto->rightshift == 1 */
1634
 
1635
              /* Drop unwanted bits from the value we are relocating to.  */
1636
              check = relocation >> howto->rightshift;
1637
 
1638
              /* If this is a signed value, the rightshift just dropped
1639
                 leading 1 bits (assuming twos complement).  */
1640
              if ((bfd_signed_vma) relocation >= 0)
1641
                signed_check = check;
1642
              else
1643
                signed_check = (check
1644
                                | ((bfd_vma) - 1
1645
                                   & ~((bfd_vma) - 1 >> howto->rightshift)));
1646
 
1647
              /* Get the value from the object file.  */
1648
              if (bfd_big_endian (input_bfd))
1649
                add = (((x) & 0x07ff0000) >> 4) | (((x) & 0x7ff) << 1);
1650
              else
1651
                add = ((((x) & 0x7ff) << 12) | (((x) & 0x07ff0000) >> 15));
1652
 
1653
              /* Get the value from the object file with an appropriate sign.
1654
                 The expression involving howto->src_mask isolates the upper
1655
                 bit of src_mask.  If that bit is set in the value we are
1656
                 adding, it is negative, and we subtract out that number times
1657
                 two.  If src_mask includes the highest possible bit, then we
1658
                 can not get the upper bit, but that does not matter since
1659
                 signed_add needs no adjustment to become negative in that
1660
                 case.  */
1661
              signed_add = add;
1662
 
1663
              if ((add & (((~ src_mask) >> 1) & src_mask)) != 0)
1664
                signed_add -= (((~ src_mask) >> 1) & src_mask) << 1;
1665
 
1666
              /* howto->bitpos == 0 */
1667
              /* Add the value from the object file, shifted so that it is a
1668
                 straight number.  */
1669
              signed_check += signed_add;
1670
              relocation   += signed_add;
1671
 
1672
              BFD_ASSERT (howto->complain_on_overflow == complain_overflow_signed);
1673
 
1674
              /* Assumes two's complement.  */
1675
              if (   signed_check > reloc_signed_max
1676
                  || signed_check < reloc_signed_min)
1677
                overflow = TRUE;
1678
 
1679
              /* Put the relocation into the correct bits.
1680
                 For a BLX instruction, make sure that the relocation is rounded up
1681
                 to a word boundary.  This follows the semantics of the instruction
1682
                 which specifies that bit 1 of the target address will come from bit
1683
                 1 of the base address.  */
1684
              if (bfd_big_endian (input_bfd))
1685
                {
1686
                  if ((x & 0x1800) == 0x0800 && (relocation & 0x02))
1687
                    relocation += 2;
1688
                  relocation = (((relocation & 0xffe) >> 1)  | ((relocation << 4) & 0x07ff0000));
1689
                }
1690
              else
1691
                {
1692
                  if ((x & 0x18000000) == 0x08000000 && (relocation & 0x02))
1693
                    relocation += 2;
1694
                  relocation = (((relocation & 0xffe) << 15) | ((relocation >> 12) & 0x7ff));
1695
                }
1696
 
1697
              /* Add the relocation to the correct bits of X.  */
1698
              x = ((x & ~howto->dst_mask) | relocation);
1699
 
1700
              /* Put the relocated value back in the object file.  */
1701
              bfd_put_32 (input_bfd, x, location);
1702
 
1703
              rstat = overflow ? bfd_reloc_overflow : bfd_reloc_ok;
1704
            }
1705
        }
1706
#endif
1707
      else
1708
        if (info->relocatable && ! howto->partial_inplace)
1709
            rstat = bfd_reloc_ok;
1710
        else
1711
          rstat = _bfd_final_link_relocate (howto, input_bfd, input_section,
1712
                                            contents,
1713
                                            rel->r_vaddr - input_section->vma,
1714
                                            val, addend);
1715
      /* Only perform this fix during the final link, not a relocatable link.  */
1716
      if (! info->relocatable
1717
          && (rel->r_type == ARM_32 || rel->r_type == ARM_RVA32))
1718
        {
1719
          /* Determine if we need to set the bottom bit of a relocated address
1720
             because the address is the address of a Thumb code symbol.  */
1721
          int patchit = FALSE;
1722
 
1723
          if (h != NULL
1724
              && (   h->class == C_THUMBSTATFUNC
1725
                  || h->class == C_THUMBEXTFUNC))
1726
            {
1727
              patchit = TRUE;
1728
            }
1729
          else if (sym != NULL
1730
                   && sym->n_scnum > N_UNDEF)
1731
            {
1732
              /* No hash entry - use the symbol instead.  */
1733
              if (   sym->n_sclass == C_THUMBSTATFUNC
1734
                  || sym->n_sclass == C_THUMBEXTFUNC)
1735
                patchit = TRUE;
1736
            }
1737
 
1738
          if (patchit)
1739
            {
1740
              bfd_byte * location = contents + rel->r_vaddr - input_section->vma;
1741
              bfd_vma    x        = bfd_get_32 (input_bfd, location);
1742
 
1743
              bfd_put_32 (input_bfd, x | 1, location);
1744
            }
1745
        }
1746
 
1747
      switch (rstat)
1748
        {
1749
        default:
1750
          abort ();
1751
        case bfd_reloc_ok:
1752
          break;
1753
        case bfd_reloc_outofrange:
1754
          (*_bfd_error_handler)
1755
            (_("%B: bad reloc address 0x%lx in section `%A'"),
1756
             input_bfd, input_section, (unsigned long) rel->r_vaddr);
1757
          return FALSE;
1758
        case bfd_reloc_overflow:
1759
          {
1760
            const char *name;
1761
            char buf[SYMNMLEN + 1];
1762
 
1763
            if (symndx == -1)
1764
              name = "*ABS*";
1765
            else if (h != NULL)
1766
              name = NULL;
1767
            else
1768
              {
1769
                name = _bfd_coff_internal_syment_name (input_bfd, sym, buf);
1770
                if (name == NULL)
1771
                  return FALSE;
1772
              }
1773
 
1774
            if (! ((*info->callbacks->reloc_overflow)
1775
                   (info, (h ? &h->root : NULL), name, howto->name,
1776
                    (bfd_vma) 0, input_bfd, input_section,
1777
                    rel->r_vaddr - input_section->vma)))
1778
              return FALSE;
1779
          }
1780
        }
1781
    }
1782
 
1783
  return TRUE;
1784
}
1785
 
1786
#ifndef COFF_IMAGE_WITH_PE
1787
 
1788
bfd_boolean
1789
bfd_arm_allocate_interworking_sections (struct bfd_link_info * info)
1790
{
1791
  asection *                        s;
1792
  bfd_byte *                        foo;
1793
  struct coff_arm_link_hash_table * globals;
1794
 
1795
  globals = coff_arm_hash_table (info);
1796
 
1797
  BFD_ASSERT (globals != NULL);
1798
 
1799
  if (globals->arm_glue_size != 0)
1800
    {
1801
      BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
1802
 
1803
      s = bfd_get_section_by_name
1804
        (globals->bfd_of_glue_owner, ARM2THUMB_GLUE_SECTION_NAME);
1805
 
1806
      BFD_ASSERT (s != NULL);
1807
 
1808
      foo = bfd_alloc (globals->bfd_of_glue_owner, globals->arm_glue_size);
1809
 
1810
      s->size = globals->arm_glue_size;
1811
      s->contents = foo;
1812
    }
1813
 
1814
  if (globals->thumb_glue_size != 0)
1815
    {
1816
      BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
1817
 
1818
      s = bfd_get_section_by_name
1819
        (globals->bfd_of_glue_owner, THUMB2ARM_GLUE_SECTION_NAME);
1820
 
1821
      BFD_ASSERT (s != NULL);
1822
 
1823
      foo = bfd_alloc (globals->bfd_of_glue_owner, globals->thumb_glue_size);
1824
 
1825
      s->size = globals->thumb_glue_size;
1826
      s->contents = foo;
1827
    }
1828
 
1829
  return TRUE;
1830
}
1831
 
1832
static void
1833
record_arm_to_thumb_glue (struct bfd_link_info *        info,
1834
                          struct coff_link_hash_entry * h)
1835
{
1836
  const char *                      name = h->root.root.string;
1837
  register asection *               s;
1838
  char *                            tmp_name;
1839
  struct coff_link_hash_entry *     myh;
1840
  struct bfd_link_hash_entry *      bh;
1841
  struct coff_arm_link_hash_table * globals;
1842
  bfd_vma val;
1843
  bfd_size_type amt;
1844
 
1845
  globals = coff_arm_hash_table (info);
1846
 
1847
  BFD_ASSERT (globals != NULL);
1848
  BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
1849
 
1850
  s = bfd_get_section_by_name
1851
    (globals->bfd_of_glue_owner, ARM2THUMB_GLUE_SECTION_NAME);
1852
 
1853
  BFD_ASSERT (s != NULL);
1854
 
1855
  amt = strlen (name) + strlen (ARM2THUMB_GLUE_ENTRY_NAME) + 1;
1856
  tmp_name = bfd_malloc (amt);
1857
 
1858
  BFD_ASSERT (tmp_name);
1859
 
1860
  sprintf (tmp_name, ARM2THUMB_GLUE_ENTRY_NAME, name);
1861
 
1862
  myh = coff_link_hash_lookup
1863
    (coff_hash_table (info), tmp_name, FALSE, FALSE, TRUE);
1864
 
1865
  if (myh != NULL)
1866
    {
1867
      free (tmp_name);
1868
      /* We've already seen this guy.  */
1869
      return;
1870
    }
1871
 
1872
  /* The only trick here is using globals->arm_glue_size as the value. Even
1873
     though the section isn't allocated yet, this is where we will be putting
1874
     it.  */
1875
  bh = NULL;
1876
  val = globals->arm_glue_size + 1;
1877
  bfd_coff_link_add_one_symbol (info, globals->bfd_of_glue_owner, tmp_name,
1878
                                BSF_GLOBAL, s, val, NULL, TRUE, FALSE, &bh);
1879
 
1880
  free (tmp_name);
1881
 
1882
  globals->arm_glue_size += ARM2THUMB_GLUE_SIZE;
1883
 
1884
  return;
1885
}
1886
 
1887
#ifndef ARM_WINCE
1888
static void
1889
record_thumb_to_arm_glue (struct bfd_link_info *        info,
1890
                          struct coff_link_hash_entry * h)
1891
{
1892
  const char *                       name = h->root.root.string;
1893
  asection *                         s;
1894
  char *                             tmp_name;
1895
  struct coff_link_hash_entry *      myh;
1896
  struct bfd_link_hash_entry *       bh;
1897
  struct coff_arm_link_hash_table *  globals;
1898
  bfd_vma val;
1899
  bfd_size_type amt;
1900
 
1901
  globals = coff_arm_hash_table (info);
1902
 
1903
  BFD_ASSERT (globals != NULL);
1904
  BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
1905
 
1906
  s = bfd_get_section_by_name
1907
    (globals->bfd_of_glue_owner, THUMB2ARM_GLUE_SECTION_NAME);
1908
 
1909
  BFD_ASSERT (s != NULL);
1910
 
1911
  amt = strlen (name) + strlen (THUMB2ARM_GLUE_ENTRY_NAME) + 1;
1912
  tmp_name = bfd_malloc (amt);
1913
 
1914
  BFD_ASSERT (tmp_name);
1915
 
1916
  sprintf (tmp_name, THUMB2ARM_GLUE_ENTRY_NAME, name);
1917
 
1918
  myh = coff_link_hash_lookup
1919
    (coff_hash_table (info), tmp_name, FALSE, FALSE, TRUE);
1920
 
1921
  if (myh != NULL)
1922
    {
1923
      free (tmp_name);
1924
      /* We've already seen this guy.  */
1925
      return;
1926
    }
1927
 
1928
  bh = NULL;
1929
  val = globals->thumb_glue_size + 1;
1930
  bfd_coff_link_add_one_symbol (info, globals->bfd_of_glue_owner, tmp_name,
1931
                                BSF_GLOBAL, s, val, NULL, TRUE, FALSE, &bh);
1932
 
1933
  /* If we mark it 'thumb', the disassembler will do a better job.  */
1934
  myh = (struct coff_link_hash_entry *) bh;
1935
  myh->class = C_THUMBEXTFUNC;
1936
 
1937
  free (tmp_name);
1938
 
1939
  /* Allocate another symbol to mark where we switch to arm mode.  */
1940
 
1941
#define CHANGE_TO_ARM "__%s_change_to_arm"
1942
#define BACK_FROM_ARM "__%s_back_from_arm"
1943
 
1944
  amt = strlen (name) + strlen (CHANGE_TO_ARM) + 1;
1945
  tmp_name = bfd_malloc (amt);
1946
 
1947
  BFD_ASSERT (tmp_name);
1948
 
1949
  sprintf (tmp_name, globals->support_old_code ? BACK_FROM_ARM : CHANGE_TO_ARM, name);
1950
 
1951
  bh = NULL;
1952
  val = globals->thumb_glue_size + (globals->support_old_code ? 8 : 4);
1953
  bfd_coff_link_add_one_symbol (info, globals->bfd_of_glue_owner, tmp_name,
1954
                                BSF_LOCAL, s, val, NULL, TRUE, FALSE, &bh);
1955
 
1956
  free (tmp_name);
1957
 
1958
  globals->thumb_glue_size += THUMB2ARM_GLUE_SIZE;
1959
 
1960
  return;
1961
}
1962
#endif /* not ARM_WINCE */
1963
 
1964
/* Select a BFD to be used to hold the sections used by the glue code.
1965
   This function is called from the linker scripts in ld/emultempl/
1966
   {armcoff/pe}.em  */
1967
 
1968
bfd_boolean
1969
bfd_arm_get_bfd_for_interworking (bfd *                  abfd,
1970
                                  struct bfd_link_info * info)
1971
{
1972
  struct coff_arm_link_hash_table * globals;
1973
  flagword                          flags;
1974
  asection *                        sec;
1975
 
1976
  /* If we are only performing a partial link do not bother
1977
     getting a bfd to hold the glue.  */
1978
  if (info->relocatable)
1979
    return TRUE;
1980
 
1981
  globals = coff_arm_hash_table (info);
1982
 
1983
  BFD_ASSERT (globals != NULL);
1984
 
1985
  if (globals->bfd_of_glue_owner != NULL)
1986
    return TRUE;
1987
 
1988
  sec = bfd_get_section_by_name (abfd, ARM2THUMB_GLUE_SECTION_NAME);
1989
 
1990
  if (sec == NULL)
1991
    {
1992
      flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
1993
               | SEC_CODE | SEC_READONLY);
1994
      sec = bfd_make_section_with_flags (abfd, ARM2THUMB_GLUE_SECTION_NAME,
1995
                                         flags);
1996
      if (sec == NULL
1997
          || ! bfd_set_section_alignment (abfd, sec, 2))
1998
        return FALSE;
1999
    }
2000
 
2001
  sec = bfd_get_section_by_name (abfd, THUMB2ARM_GLUE_SECTION_NAME);
2002
 
2003
  if (sec == NULL)
2004
    {
2005
      flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
2006
               | SEC_CODE | SEC_READONLY);
2007
      sec = bfd_make_section_with_flags (abfd, THUMB2ARM_GLUE_SECTION_NAME,
2008
                                         flags);
2009
 
2010
      if (sec == NULL
2011
          || ! bfd_set_section_alignment (abfd, sec, 2))
2012
        return FALSE;
2013
    }
2014
 
2015
  /* Save the bfd for later use.  */
2016
  globals->bfd_of_glue_owner = abfd;
2017
 
2018
  return TRUE;
2019
}
2020
 
2021
bfd_boolean
2022
bfd_arm_process_before_allocation (bfd *                   abfd,
2023
                                   struct bfd_link_info *  info,
2024
                                   int                     support_old_code)
2025
{
2026
  asection * sec;
2027
  struct coff_arm_link_hash_table * globals;
2028
 
2029
  /* If we are only performing a partial link do not bother
2030
     to construct any glue.  */
2031
  if (info->relocatable)
2032
    return TRUE;
2033
 
2034
  /* Here we have a bfd that is to be included on the link.  We have a hook
2035
     to do reloc rummaging, before section sizes are nailed down.  */
2036
  _bfd_coff_get_external_symbols (abfd);
2037
 
2038
  globals = coff_arm_hash_table (info);
2039
 
2040
  BFD_ASSERT (globals != NULL);
2041
  BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
2042
 
2043
  globals->support_old_code = support_old_code;
2044
 
2045
  /* Rummage around all the relocs and map the glue vectors.  */
2046
  sec = abfd->sections;
2047
 
2048
  if (sec == NULL)
2049
    return TRUE;
2050
 
2051
  for (; sec != NULL; sec = sec->next)
2052
    {
2053
      struct internal_reloc * i;
2054
      struct internal_reloc * rel;
2055
 
2056
      if (sec->reloc_count == 0)
2057
        continue;
2058
 
2059
      /* Load the relocs.  */
2060
      /* FIXME: there may be a storage leak here.  */
2061
      i = _bfd_coff_read_internal_relocs (abfd, sec, 1, 0, 0, 0);
2062
 
2063
      BFD_ASSERT (i != 0);
2064
 
2065
      for (rel = i; rel < i + sec->reloc_count; ++rel)
2066
        {
2067
          unsigned short                 r_type  = rel->r_type;
2068
          long                           symndx;
2069
          struct coff_link_hash_entry *  h;
2070
 
2071
          symndx = rel->r_symndx;
2072
 
2073
          /* If the relocation is not against a symbol it cannot concern us.  */
2074
          if (symndx == -1)
2075
            continue;
2076
 
2077
          /* If the index is outside of the range of our table, something has gone wrong.  */
2078
          if (symndx >= obj_conv_table_size (abfd))
2079
            {
2080
              _bfd_error_handler (_("%B: illegal symbol index in reloc: %d"),
2081
                                  abfd, symndx);
2082
              continue;
2083
            }
2084
 
2085
          h = obj_coff_sym_hashes (abfd)[symndx];
2086
 
2087
          /* If the relocation is against a static symbol it must be within
2088
             the current section and so cannot be a cross ARM/Thumb relocation.  */
2089
          if (h == NULL)
2090
            continue;
2091
 
2092
          switch (r_type)
2093
            {
2094
            case ARM_26:
2095
              /* This one is a call from arm code.  We need to look up
2096
                 the target of the call. If it is a thumb target, we
2097
                 insert glue.  */
2098
 
2099
              if (h->class == C_THUMBEXTFUNC)
2100
                record_arm_to_thumb_glue (info, h);
2101
              break;
2102
 
2103
#ifndef ARM_WINCE
2104
            case ARM_THUMB23:
2105
              /* This one is a call from thumb code.  We used to look
2106
                 for ARM_THUMB9 and ARM_THUMB12 as well.  We need to look
2107
                 up the target of the call. If it is an arm target, we
2108
                 insert glue.  If the symbol does not exist it will be
2109
                 given a class of C_EXT and so we will generate a stub
2110
                 for it.  This is not really a problem, since the link
2111
                 is doomed anyway.  */
2112
 
2113
              switch (h->class)
2114
                {
2115
                case C_EXT:
2116
                case C_STAT:
2117
                case C_LABEL:
2118
                  record_thumb_to_arm_glue (info, h);
2119
                  break;
2120
                default:
2121
                  ;
2122
                }
2123
              break;
2124
#endif
2125
 
2126
            default:
2127
              break;
2128
            }
2129
        }
2130
    }
2131
 
2132
  return TRUE;
2133
}
2134
 
2135
#endif /* ! defined (COFF_IMAGE_WITH_PE) */
2136
 
2137
#define coff_bfd_reloc_type_lookup              coff_arm_reloc_type_lookup
2138
#define coff_bfd_reloc_name_lookup      coff_arm_reloc_name_lookup
2139
#define coff_relocate_section                   coff_arm_relocate_section
2140
#define coff_bfd_is_local_label_name            coff_arm_is_local_label_name
2141
#define coff_adjust_symndx                      coff_arm_adjust_symndx
2142
#define coff_link_output_has_begun              coff_arm_link_output_has_begun
2143
#define coff_final_link_postscript              coff_arm_final_link_postscript
2144
#define coff_bfd_merge_private_bfd_data         coff_arm_merge_private_bfd_data
2145
#define coff_bfd_print_private_bfd_data         coff_arm_print_private_bfd_data
2146
#define coff_bfd_set_private_flags              _bfd_coff_arm_set_private_flags
2147
#define coff_bfd_copy_private_bfd_data          coff_arm_copy_private_bfd_data
2148
#define coff_bfd_link_hash_table_create         coff_arm_link_hash_table_create
2149
 
2150
/* When doing a relocatable link, we want to convert ARM_26 relocs
2151
   into ARM_26D relocs.  */
2152
 
2153
static bfd_boolean
2154
coff_arm_adjust_symndx (bfd *obfd ATTRIBUTE_UNUSED,
2155
                        struct bfd_link_info *info ATTRIBUTE_UNUSED,
2156
                        bfd *ibfd,
2157
                        asection *sec,
2158
                        struct internal_reloc *irel,
2159
                        bfd_boolean *adjustedp)
2160
{
2161
  if (irel->r_type == ARM_26)
2162
    {
2163
      struct coff_link_hash_entry *h;
2164
 
2165
      h = obj_coff_sym_hashes (ibfd)[irel->r_symndx];
2166
      if (h != NULL
2167
          && (h->root.type == bfd_link_hash_defined
2168
              || h->root.type == bfd_link_hash_defweak)
2169
          && h->root.u.def.section->output_section == sec->output_section)
2170
        irel->r_type = ARM_26D;
2171
    }
2172
  *adjustedp = FALSE;
2173
  return TRUE;
2174
}
2175
 
2176
/* Called when merging the private data areas of two BFDs.
2177
   This is important as it allows us to detect if we are
2178
   attempting to merge binaries compiled for different ARM
2179
   targets, eg different CPUs or different APCS's.     */
2180
 
2181
static bfd_boolean
2182
coff_arm_merge_private_bfd_data (bfd * ibfd, bfd * obfd)
2183
{
2184
  BFD_ASSERT (ibfd != NULL && obfd != NULL);
2185
 
2186
  if (ibfd == obfd)
2187
    return TRUE;
2188
 
2189
  /* If the two formats are different we cannot merge anything.
2190
     This is not an error, since it is permissable to change the
2191
     input and output formats.  */
2192
  if (   ibfd->xvec->flavour != bfd_target_coff_flavour
2193
      || obfd->xvec->flavour != bfd_target_coff_flavour)
2194
    return TRUE;
2195
 
2196
  /* Determine what should happen if the input ARM architecture
2197
     does not match the output ARM architecture.  */
2198
  if (! bfd_arm_merge_machines (ibfd, obfd))
2199
    return FALSE;
2200
 
2201
  /* Verify that the APCS is the same for the two BFDs.  */
2202
  if (APCS_SET (ibfd))
2203
    {
2204
      if (APCS_SET (obfd))
2205
        {
2206
          /* If the src and dest have different APCS flag bits set, fail.  */
2207
          if (APCS_26_FLAG (obfd) != APCS_26_FLAG (ibfd))
2208
            {
2209
              _bfd_error_handler
2210
                /* xgettext: c-format */
2211
                (_("ERROR: %B is compiled for APCS-%d, whereas %B is compiled for APCS-%d"),
2212
                 ibfd, obfd,
2213
                 APCS_26_FLAG (ibfd) ? 26 : 32,
2214
                 APCS_26_FLAG (obfd) ? 26 : 32
2215
                 );
2216
 
2217
              bfd_set_error (bfd_error_wrong_format);
2218
              return FALSE;
2219
            }
2220
 
2221
          if (APCS_FLOAT_FLAG (obfd) != APCS_FLOAT_FLAG (ibfd))
2222
            {
2223
              const char *msg;
2224
 
2225
              if (APCS_FLOAT_FLAG (ibfd))
2226
                /* xgettext: c-format */
2227
                msg = _("ERROR: %B passes floats in float registers, whereas %B passes them in integer registers");
2228
              else
2229
                /* xgettext: c-format */
2230
                msg = _("ERROR: %B passes floats in integer registers, whereas %B passes them in float registers");
2231
 
2232
              _bfd_error_handler (msg, ibfd, obfd);
2233
 
2234
              bfd_set_error (bfd_error_wrong_format);
2235
              return FALSE;
2236
            }
2237
 
2238
          if (PIC_FLAG (obfd) != PIC_FLAG (ibfd))
2239
            {
2240
              const char * msg;
2241
 
2242
              if (PIC_FLAG (ibfd))
2243
                /* xgettext: c-format */
2244
                msg = _("ERROR: %B is compiled as position independent code, whereas target %B is absolute position");
2245
              else
2246
                /* xgettext: c-format */
2247
                msg = _("ERROR: %B is compiled as absolute position code, whereas target %B is position independent");
2248
              _bfd_error_handler (msg, ibfd, obfd);
2249
 
2250
              bfd_set_error (bfd_error_wrong_format);
2251
              return FALSE;
2252
            }
2253
        }
2254
      else
2255
        {
2256
          SET_APCS_FLAGS (obfd, APCS_26_FLAG (ibfd) | APCS_FLOAT_FLAG (ibfd) | PIC_FLAG (ibfd));
2257
 
2258
          /* Set up the arch and fields as well as these are probably wrong.  */
2259
          bfd_set_arch_mach (obfd, bfd_get_arch (ibfd), bfd_get_mach (ibfd));
2260
        }
2261
    }
2262
 
2263
  /* Check the interworking support.  */
2264
  if (INTERWORK_SET (ibfd))
2265
    {
2266
      if (INTERWORK_SET (obfd))
2267
        {
2268
          /* If the src and dest differ in their interworking issue a warning.  */
2269
          if (INTERWORK_FLAG (obfd) != INTERWORK_FLAG (ibfd))
2270
            {
2271
              const char * msg;
2272
 
2273
              if (INTERWORK_FLAG (ibfd))
2274
                /* xgettext: c-format */
2275
                msg = _("Warning: %B supports interworking, whereas %B does not");
2276
              else
2277
                /* xgettext: c-format */
2278
                msg = _("Warning: %B does not support interworking, whereas %B does");
2279
 
2280
              _bfd_error_handler (msg, ibfd, obfd);
2281
            }
2282
        }
2283
      else
2284
        {
2285
          SET_INTERWORK_FLAG (obfd, INTERWORK_FLAG (ibfd));
2286
        }
2287
    }
2288
 
2289
  return TRUE;
2290
}
2291
 
2292
/* Display the flags field.  */
2293
 
2294
static bfd_boolean
2295
coff_arm_print_private_bfd_data (bfd * abfd, void * ptr)
2296
{
2297
  FILE * file = (FILE *) ptr;
2298
 
2299
  BFD_ASSERT (abfd != NULL && ptr != NULL);
2300
 
2301
  /* xgettext:c-format */
2302
  fprintf (file, _("private flags = %x:"), coff_data (abfd)->flags);
2303
 
2304
  if (APCS_SET (abfd))
2305
    {
2306
      /* xgettext: APCS is ARM Procedure Call Standard, it should not be translated.  */
2307
      fprintf (file, " [APCS-%d]", APCS_26_FLAG (abfd) ? 26 : 32);
2308
 
2309
      if (APCS_FLOAT_FLAG (abfd))
2310
        fprintf (file, _(" [floats passed in float registers]"));
2311
      else
2312
        fprintf (file, _(" [floats passed in integer registers]"));
2313
 
2314
      if (PIC_FLAG (abfd))
2315
        fprintf (file, _(" [position independent]"));
2316
      else
2317
        fprintf (file, _(" [absolute position]"));
2318
    }
2319
 
2320
  if (! INTERWORK_SET (abfd))
2321
    fprintf (file, _(" [interworking flag not initialised]"));
2322
  else if (INTERWORK_FLAG (abfd))
2323
    fprintf (file, _(" [interworking supported]"));
2324
  else
2325
    fprintf (file, _(" [interworking not supported]"));
2326
 
2327
  fputc ('\n', file);
2328
 
2329
  return TRUE;
2330
}
2331
 
2332
/* Copies the given flags into the coff_tdata.flags field.
2333
   Typically these flags come from the f_flags[] field of
2334
   the COFF filehdr structure, which contains important,
2335
   target specific information.
2336
   Note: Although this function is static, it is explicitly
2337
   called from both coffcode.h and peicode.h.  */
2338
 
2339
static bfd_boolean
2340
_bfd_coff_arm_set_private_flags (bfd * abfd, flagword flags)
2341
{
2342
  flagword flag;
2343
 
2344
  BFD_ASSERT (abfd != NULL);
2345
 
2346
  flag = (flags & F_APCS26) ? F_APCS_26 : 0;
2347
 
2348
  /* Make sure that the APCS field has not been initialised to the opposite
2349
     value.  */
2350
  if (APCS_SET (abfd)
2351
      && (   (APCS_26_FLAG    (abfd) != flag)
2352
          || (APCS_FLOAT_FLAG (abfd) != (flags & F_APCS_FLOAT))
2353
          || (PIC_FLAG        (abfd) != (flags & F_PIC))
2354
          ))
2355
    return FALSE;
2356
 
2357
  flag |= (flags & (F_APCS_FLOAT | F_PIC));
2358
 
2359
  SET_APCS_FLAGS (abfd, flag);
2360
 
2361
  flag = (flags & F_INTERWORK);
2362
 
2363
  /* If the BFD has already had its interworking flag set, but it
2364
     is different from the value that we have been asked to set,
2365
     then assume that that merged code will not support interworking
2366
     and set the flag accordingly.  */
2367
  if (INTERWORK_SET (abfd) && (INTERWORK_FLAG (abfd) != flag))
2368
    {
2369
      if (flag)
2370
        /* xgettext: c-format */
2371
        _bfd_error_handler (_("Warning: Not setting interworking flag of %B since it has already been specified as non-interworking"),
2372
                            abfd);
2373
      else
2374
        /* xgettext: c-format */
2375
        _bfd_error_handler (_("Warning: Clearing the interworking flag of %B due to outside request"),
2376
                            abfd);
2377
      flag = 0;
2378
    }
2379
 
2380
  SET_INTERWORK_FLAG (abfd, flag);
2381
 
2382
  return TRUE;
2383
}
2384
 
2385
/* Copy the important parts of the target specific data
2386
   from one instance of a BFD to another.  */
2387
 
2388
static bfd_boolean
2389
coff_arm_copy_private_bfd_data (bfd * src, bfd * dest)
2390
{
2391
  BFD_ASSERT (src != NULL && dest != NULL);
2392
 
2393
  if (src == dest)
2394
    return TRUE;
2395
 
2396
  /* If the destination is not in the same format as the source, do not do
2397
     the copy.  */
2398
  if (src->xvec != dest->xvec)
2399
    return TRUE;
2400
 
2401
  /* Copy the flags field.  */
2402
  if (APCS_SET (src))
2403
    {
2404
      if (APCS_SET (dest))
2405
        {
2406
          /* If the src and dest have different APCS flag bits set, fail.  */
2407
          if (APCS_26_FLAG (dest) != APCS_26_FLAG (src))
2408
            return FALSE;
2409
 
2410
          if (APCS_FLOAT_FLAG (dest) != APCS_FLOAT_FLAG (src))
2411
            return FALSE;
2412
 
2413
          if (PIC_FLAG (dest) != PIC_FLAG (src))
2414
            return FALSE;
2415
        }
2416
      else
2417
        SET_APCS_FLAGS (dest, APCS_26_FLAG (src) | APCS_FLOAT_FLAG (src)
2418
                        | PIC_FLAG (src));
2419
    }
2420
 
2421
  if (INTERWORK_SET (src))
2422
    {
2423
      if (INTERWORK_SET (dest))
2424
        {
2425
          /* If the src and dest have different interworking flags then turn
2426
             off the interworking bit.  */
2427
          if (INTERWORK_FLAG (dest) != INTERWORK_FLAG (src))
2428
            {
2429
              if (INTERWORK_FLAG (dest))
2430
                {
2431
                  /* xgettext:c-format */
2432
                  _bfd_error_handler (("\
2433
Warning: Clearing the interworking flag of %B because non-interworking code in %B has been linked with it"),
2434
                                      dest, src);
2435
                }
2436
 
2437
              SET_INTERWORK_FLAG (dest, 0);
2438
            }
2439
        }
2440
      else
2441
        {
2442
          SET_INTERWORK_FLAG (dest, INTERWORK_FLAG (src));
2443
        }
2444
    }
2445
 
2446
  return TRUE;
2447
}
2448
 
2449
/* Note:  the definitions here of LOCAL_LABEL_PREFIX and USER_LABEL_PREIFX
2450
   *must* match the definitions in gcc/config/arm/{coff|semi|aout}.h.  */
2451
#ifndef LOCAL_LABEL_PREFIX
2452
#define LOCAL_LABEL_PREFIX ""
2453
#endif
2454
#ifndef USER_LABEL_PREFIX
2455
#define USER_LABEL_PREFIX "_"
2456
#endif
2457
 
2458
/* Like _bfd_coff_is_local_label_name, but
2459
   a) test against USER_LABEL_PREFIX, to avoid stripping labels known to be
2460
      non-local.
2461
   b) Allow other prefixes than ".", e.g. an empty prefix would cause all
2462
      labels of the form Lxxx to be stripped.  */
2463
 
2464
static bfd_boolean
2465
coff_arm_is_local_label_name (bfd *        abfd ATTRIBUTE_UNUSED,
2466
                              const char * name)
2467
{
2468
#ifdef USER_LABEL_PREFIX
2469
  if (USER_LABEL_PREFIX[0] != 0)
2470
    {
2471
      size_t len = strlen (USER_LABEL_PREFIX);
2472
 
2473
      if (strncmp (name, USER_LABEL_PREFIX, len) == 0)
2474
        return FALSE;
2475
    }
2476
#endif
2477
 
2478
#ifdef LOCAL_LABEL_PREFIX
2479
  /* If there is a prefix for local labels then look for this.
2480
     If the prefix exists, but it is empty, then ignore the test.  */
2481
 
2482
  if (LOCAL_LABEL_PREFIX[0] != 0)
2483
    {
2484
      size_t len = strlen (LOCAL_LABEL_PREFIX);
2485
 
2486
      if (strncmp (name, LOCAL_LABEL_PREFIX, len) != 0)
2487
        return FALSE;
2488
 
2489
      /* Perform the checks below for the rest of the name.  */
2490
      name += len;
2491
    }
2492
#endif
2493
 
2494
  return name[0] == 'L';
2495
}
2496
 
2497
/* This piece of machinery exists only to guarantee that the bfd that holds
2498
   the glue section is written last.
2499
 
2500
   This does depend on bfd_make_section attaching a new section to the
2501
   end of the section list for the bfd.  */
2502
 
2503
static bfd_boolean
2504
coff_arm_link_output_has_begun (bfd * sub, struct coff_final_link_info * info)
2505
{
2506
  return (sub->output_has_begun
2507
          || sub == coff_arm_hash_table (info->info)->bfd_of_glue_owner);
2508
}
2509
 
2510
static bfd_boolean
2511
coff_arm_final_link_postscript (bfd * abfd ATTRIBUTE_UNUSED,
2512
                                struct coff_final_link_info * pfinfo)
2513
{
2514
  struct coff_arm_link_hash_table * globals;
2515
 
2516
  globals = coff_arm_hash_table (pfinfo->info);
2517
 
2518
  BFD_ASSERT (globals != NULL);
2519
 
2520
  if (globals->bfd_of_glue_owner != NULL)
2521
    {
2522
      if (! _bfd_coff_link_input_bfd (pfinfo, globals->bfd_of_glue_owner))
2523
        return FALSE;
2524
 
2525
      globals->bfd_of_glue_owner->output_has_begun = TRUE;
2526
    }
2527
 
2528
  return bfd_arm_update_notes (abfd, ARM_NOTE_SECTION);
2529
}
2530
 
2531
#include "coffcode.h"
2532
 
2533
#ifndef TARGET_LITTLE_SYM
2534
#define TARGET_LITTLE_SYM armcoff_little_vec
2535
#endif
2536
#ifndef TARGET_LITTLE_NAME
2537
#define TARGET_LITTLE_NAME "coff-arm-little"
2538
#endif
2539
#ifndef TARGET_BIG_SYM
2540
#define TARGET_BIG_SYM armcoff_big_vec
2541
#endif
2542
#ifndef TARGET_BIG_NAME
2543
#define TARGET_BIG_NAME "coff-arm-big"
2544
#endif
2545
 
2546
#ifndef TARGET_UNDERSCORE
2547
#define TARGET_UNDERSCORE 0
2548
#endif
2549
 
2550
#ifndef EXTRA_S_FLAGS
2551
#ifdef COFF_WITH_PE
2552
#define EXTRA_S_FLAGS (SEC_CODE | SEC_LINK_ONCE | SEC_LINK_DUPLICATES)
2553
#else
2554
#define EXTRA_S_FLAGS SEC_CODE
2555
#endif
2556
#endif
2557
 
2558
/* Forward declaration for use initialising alternative_target field.  */
2559
extern const bfd_target TARGET_BIG_SYM ;
2560
 
2561
/* Target vectors.  */
2562
CREATE_LITTLE_COFF_TARGET_VEC (TARGET_LITTLE_SYM, TARGET_LITTLE_NAME, D_PAGED, EXTRA_S_FLAGS, TARGET_UNDERSCORE, & TARGET_BIG_SYM, COFF_SWAP_TABLE)
2563
CREATE_BIG_COFF_TARGET_VEC (TARGET_BIG_SYM, TARGET_BIG_NAME, D_PAGED, EXTRA_S_FLAGS, TARGET_UNDERSCORE, & TARGET_LITTLE_SYM, COFF_SWAP_TABLE)

powered by: WebSVN 2.1.0

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