1
/* BFD back-end for PowerPC Microsoft Portable Executable files.
2
Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
4
Free Software Foundation, Inc.
6
Original version pieced together by Kim Knuttila (krk@cygnus.com)
8
There is nothing new under the sun. This file draws a lot on other
9
coff files, in particular, those for the rs/6000, alpha, mips, and
10
intel backends, and the PE work for the arm.
12
This file is part of BFD, the Binary File Descriptor library.
14
This program is free software; you can redistribute it and/or modify
15
it under the terms of the GNU General Public License as published by
16
the Free Software Foundation; either version 2 of the License, or
17
(at your option) any later version.
19
This program is distributed in the hope that it will be useful,
20
but WITHOUT ANY WARRANTY; without even the implied warranty of
21
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
22
GNU General Public License for more details.
24
You should have received a copy of the GNU General Public License
25
along with this program; if not, write to the Free Software
26
Foundation, 59 Temple Place - Suite 330,
27
Boston, MA 02111-1307, USA. */
31
- relocs generated by gas
32
- ld will link files, but they do not run.
33
- dlltool will not produce correct output in some .reloc cases, and will
34
not produce the right glue code for dll function calls.
42
#include "coff/powerpc.h"
43
#include "coff/internal.h"
51
#define BADMAG(x) PPCBADMAG(x)
55
/* This file is compiled more than once, but we only compile the
56
final_link routine once. */
57
extern boolean ppc_bfd_coff_final_link
58
PARAMS ((bfd *, struct bfd_link_info *));
59
extern void dump_toc PARAMS ((PTR));
61
/* The toc is a set of bfd_vma fields. We use the fact that valid */
62
/* addresses are even (i.e. the bit representing "1" is off) to allow */
63
/* us to encode a little extra information in the field */
64
/* - Unallocated addresses are intialized to 1. */
65
/* - Allocated addresses are even numbers. */
66
/* The first time we actually write a reference to the toc in the bfd, */
67
/* we want to record that fact in a fixup file (if it is asked for), so */
68
/* we keep track of whether or not an address has been written by marking */
69
/* the low order bit with a "1" upon writing */
71
#define SET_UNALLOCATED(x) ((x) = 1)
72
#define IS_UNALLOCATED(x) ((x) == 1)
74
#define IS_WRITTEN(x) ((x) & 1)
75
#define MARK_AS_WRITTEN(x) ((x) |= 1)
76
#define MAKE_ADDR_AGAIN(x) ((x) &= ~1)
78
/* Turn on this check if you suspect something amiss in the hash tables */
81
/* Need a 7 char string for an eye catcher */
84
#define HASH_CHECK_DCL char eye_catcher[8];
85
#define HASH_CHECK_INIT(ret) strcpy(ret->eye_catcher, EYE)
86
#define HASH_CHECK(addr) \
87
if (strcmp(addr->eye_catcher, EYE) != 0) \
90
_("File %s, line %d, Hash check failure, bad eye %8s\n"), \
91
__FILE__, __LINE__, addr->eye_catcher); \
97
#define HASH_CHECK_DCL
98
#define HASH_CHECK_INIT(ret)
99
#define HASH_CHECK(addr)
103
/* In order not to add an int to every hash table item for every coff
104
linker, we define our own hash table, derived from the coff one */
106
/* PE linker hash table entries. */
108
struct ppc_coff_link_hash_entry
110
struct coff_link_hash_entry root; /* First entry, as required */
112
/* As we wonder around the relocs, we'll keep the assigned toc_offset
114
bfd_vma toc_offset; /* Our addition, as required */
116
unsigned long int glue_insn;
121
/* PE linker hash table. */
123
struct ppc_coff_link_hash_table
125
struct coff_link_hash_table root; /* First entry, as required */
128
static struct bfd_hash_entry *ppc_coff_link_hash_newfunc
129
PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *,
131
static boolean ppc_coff_link_hash_table_init
132
PARAMS ((struct ppc_coff_link_hash_table *, bfd *,
133
struct bfd_hash_entry *(*) (struct bfd_hash_entry *,
134
struct bfd_hash_table *,
136
static struct bfd_link_hash_table *ppc_coff_link_hash_table_create
138
static boolean coff_ppc_relocate_section
139
PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
140
struct internal_reloc *, struct internal_syment *, asection **));
141
static reloc_howto_type *coff_ppc_rtype_to_howto
142
PARAMS ((bfd *, asection *, struct internal_reloc *,
143
struct coff_link_hash_entry *, struct internal_syment *,
146
/* Routine to create an entry in the link hash table. */
148
static struct bfd_hash_entry *
149
ppc_coff_link_hash_newfunc (entry, table, string)
150
struct bfd_hash_entry *entry;
151
struct bfd_hash_table *table;
154
struct ppc_coff_link_hash_entry *ret =
155
(struct ppc_coff_link_hash_entry *) entry;
157
/* Allocate the structure if it has not already been allocated by a
159
if (ret == (struct ppc_coff_link_hash_entry *) NULL)
160
ret = (struct ppc_coff_link_hash_entry *)
161
bfd_hash_allocate (table,
162
sizeof (struct ppc_coff_link_hash_entry));
164
if (ret == (struct ppc_coff_link_hash_entry *) NULL)
167
/* Call the allocation method of the superclass. */
168
ret = ((struct ppc_coff_link_hash_entry *)
169
_bfd_coff_link_hash_newfunc ((struct bfd_hash_entry *) ret,
174
/* Initialize the local fields. */
175
SET_UNALLOCATED(ret->toc_offset);
176
ret->symbol_is_glue = 0;
179
HASH_CHECK_INIT(ret);
182
return (struct bfd_hash_entry *) ret;
185
/* Initialize a PE linker hash table. */
188
ppc_coff_link_hash_table_init (table, abfd, newfunc)
189
struct ppc_coff_link_hash_table *table;
191
struct bfd_hash_entry *(*newfunc) PARAMS ((struct bfd_hash_entry *,
192
struct bfd_hash_table *,
195
return _bfd_coff_link_hash_table_init (&table->root, abfd, newfunc);
198
/* Create a PE linker hash table. */
200
static struct bfd_link_hash_table *
201
ppc_coff_link_hash_table_create (abfd)
204
struct ppc_coff_link_hash_table *ret;
205
bfd_size_type amt = sizeof (struct ppc_coff_link_hash_table);
207
ret = (struct ppc_coff_link_hash_table *) bfd_malloc (amt);
210
if (! ppc_coff_link_hash_table_init (ret, abfd,
211
ppc_coff_link_hash_newfunc))
214
return (struct bfd_link_hash_table *) NULL;
216
return &ret->root.root;
219
/* Now, tailor coffcode.h to use our hash stuff */
221
#define coff_bfd_link_hash_table_create ppc_coff_link_hash_table_create
223
/* The nt loader points the toc register to &toc + 32768, in order to */
224
/* use the complete range of a 16-bit displacement. We have to adjust */
225
/* for this when we fix up loads displaced off the toc reg. */
226
#define TOC_LOAD_ADJUSTMENT (-32768)
227
#define TOC_SECTION_NAME ".private.toc"
229
/* The main body of code is in coffcode.h. */
231
#define COFF_DEFAULT_SECTION_ALIGNMENT_POWER (3)
233
/* In case we're on a 32-bit machine, construct a 64-bit "-1" value
234
from smaller values. Start with zero, widen, *then* decrement. */
235
#define MINUS_ONE (((bfd_vma)0) - 1)
237
/* these should definitely go in a header file somewhere... */
240
#define IMAGE_REL_PPC_ABSOLUTE 0x0000
243
#define IMAGE_REL_PPC_ADDR64 0x0001
246
#define IMAGE_REL_PPC_ADDR32 0x0002
248
/* 26-bit address, shifted left 2 (branch absolute) */
249
#define IMAGE_REL_PPC_ADDR24 0x0003
252
#define IMAGE_REL_PPC_ADDR16 0x0004
254
/* 16-bit address, shifted left 2 (load doubleword) */
255
#define IMAGE_REL_PPC_ADDR14 0x0005
257
/* 26-bit PC-relative offset, shifted left 2 (branch relative) */
258
#define IMAGE_REL_PPC_REL24 0x0006
260
/* 16-bit PC-relative offset, shifted left 2 (br cond relative) */
261
#define IMAGE_REL_PPC_REL14 0x0007
263
/* 16-bit offset from TOC base */
264
#define IMAGE_REL_PPC_TOCREL16 0x0008
266
/* 16-bit offset from TOC base, shifted left 2 (load doubleword) */
267
#define IMAGE_REL_PPC_TOCREL14 0x0009
269
/* 32-bit addr w/o image base */
270
#define IMAGE_REL_PPC_ADDR32NB 0x000A
272
/* va of containing section (as in an image sectionhdr) */
273
#define IMAGE_REL_PPC_SECREL 0x000B
275
/* sectionheader number */
276
#define IMAGE_REL_PPC_SECTION 0x000C
278
/* substitute TOC restore instruction iff symbol is glue code */
279
#define IMAGE_REL_PPC_IFGLUE 0x000D
281
/* symbol is glue code; virtual address is TOC restore instruction */
282
#define IMAGE_REL_PPC_IMGLUE 0x000E
284
/* va of containing section (limited to 16 bits) */
285
#define IMAGE_REL_PPC_SECREL16 0x000F
287
/* stuff to handle immediate data when the number of bits in the */
288
/* data is greater than the number of bits in the immediate field */
289
/* We need to do (usually) 32 bit arithmetic on 16 bit chunks */
290
#define IMAGE_REL_PPC_REFHI 0x0010
291
#define IMAGE_REL_PPC_REFLO 0x0011
292
#define IMAGE_REL_PPC_PAIR 0x0012
294
/* This is essentially the same as tocrel16, with TOCDEFN assumed */
295
#define IMAGE_REL_PPC_TOCREL16_DEFN 0x0013
297
/* Flag bits in IMAGE_RELOCATION.TYPE */
299
/* subtract reloc value rather than adding it */
300
#define IMAGE_REL_PPC_NEG 0x0100
302
/* fix branch prediction bit to predict branch taken */
303
#define IMAGE_REL_PPC_BRTAKEN 0x0200
305
/* fix branch prediction bit to predict branch not taken */
306
#define IMAGE_REL_PPC_BRNTAKEN 0x0400
308
/* toc slot defined in file (or, data in toc) */
309
#define IMAGE_REL_PPC_TOCDEFN 0x0800
311
/* masks to isolate above values in IMAGE_RELOCATION.Type */
312
#define IMAGE_REL_PPC_TYPEMASK 0x00FF
313
#define IMAGE_REL_PPC_FLAGMASK 0x0F00
315
#define EXTRACT_TYPE(x) ((x) & IMAGE_REL_PPC_TYPEMASK)
316
#define EXTRACT_FLAGS(x) ((x) & IMAGE_REL_PPC_FLAGMASK)
317
#define EXTRACT_JUNK(x) \
318
((x) & ~(IMAGE_REL_PPC_TYPEMASK | IMAGE_REL_PPC_FLAGMASK))
320
/* static helper functions to make relocation work */
321
/* (Work In Progress) */
323
static bfd_reloc_status_type ppc_refhi_reloc PARAMS ((bfd *abfd,
331
static bfd_reloc_status_type ppc_reflo_reloc PARAMS ((bfd *abfd,
339
static bfd_reloc_status_type ppc_pair_reloc PARAMS ((bfd *abfd,
347
static bfd_reloc_status_type ppc_toc16_reloc PARAMS ((bfd *abfd,
356
static bfd_reloc_status_type ppc_addr32nb_reloc PARAMS ((bfd *abfd,
364
static bfd_reloc_status_type ppc_section_reloc PARAMS ((bfd *abfd,
372
static bfd_reloc_status_type ppc_secrel_reloc PARAMS ((bfd *abfd,
380
static bfd_reloc_status_type ppc_imglue_reloc PARAMS ((bfd *abfd,
388
static boolean in_reloc_p PARAMS((bfd *abfd, reloc_howto_type *howto));
390
/* FIXME: It'll take a while to get through all of these. I only need a few to
391
get us started, so those I'll make sure work. Those marked FIXME are either
392
completely unverified or have a specific unknown marked in the comment */
394
/*---------------------------------------------------------------------------*/
396
/* Relocation entries for Windows/NT on PowerPC. */
398
/* From the document "" we find the following listed as used relocs: */
400
/* ABSOLUTE : The noop */
401
/* ADDR[64|32|16] : fields that hold addresses in data fields or the */
402
/* 16 bit displacement field on a load/store. */
403
/* ADDR[24|14] : fields that hold addresses in branch and cond */
404
/* branches. These represent [26|16] bit addresses. */
405
/* The low order 2 bits are preserved. */
406
/* REL[24|14] : branches relative to the Instruction Address */
407
/* register. These represent [26|16] bit addresses, */
408
/* as before. The instruction field will be zero, and */
409
/* the address of the SYM will be inserted at link time. */
410
/* TOCREL16 : 16 bit displacement field referring to a slot in */
412
/* TOCREL14 : 16 bit displacement field, similar to REL14 or ADDR14. */
413
/* ADDR32NB : 32 bit address relative to the virtual origin. */
414
/* (On the alpha, this is always a linker generated thunk)*/
415
/* (i.e. 32bit addr relative to the image base) */
416
/* SECREL : The value is relative to the start of the section */
417
/* containing the symbol. */
418
/* SECTION : access to the header containing the item. Supports the */
419
/* codeview debugger. */
421
/* In particular, note that the document does not indicate that the */
422
/* relocations listed in the header file are used. */
426
/*---------------------------------------------------------------------------*/
428
static reloc_howto_type ppc_coff_howto_table[] =
430
/* IMAGE_REL_PPC_ABSOLUTE 0x0000 NOP */
432
HOWTO (IMAGE_REL_PPC_ABSOLUTE, /* type */
434
0, /* size (0 = byte, 1 = short, 2 = long) */
436
false, /* pc_relative */
438
complain_overflow_dont, /* dont complain_on_overflow */
439
0, /* special_function */
440
"ABSOLUTE", /* name */
441
false, /* partial_inplace */
444
false), /* pcrel_offset */
446
/* IMAGE_REL_PPC_ADDR64 0x0001 64-bit address */
448
HOWTO(IMAGE_REL_PPC_ADDR64, /* type */
450
3, /* size (0 = byte, 1 = short, 2 = long) */
452
false, /* pc_relative */
454
complain_overflow_bitfield, /* complain_on_overflow */
455
0, /* special_function */
457
true, /* partial_inplace */
458
MINUS_ONE, /* src_mask */
459
MINUS_ONE, /* dst_mask */
460
false), /* pcrel_offset */
462
/* IMAGE_REL_PPC_ADDR32 0x0002 32-bit address */
464
HOWTO (IMAGE_REL_PPC_ADDR32, /* type */
466
2, /* size (0 = byte, 1 = short, 2 = long) */
468
false, /* pc_relative */
470
complain_overflow_bitfield, /* complain_on_overflow */
471
0, /* special_function */
473
true, /* partial_inplace */
474
0xffffffff, /* src_mask */
475
0xffffffff, /* dst_mask */
476
false), /* pcrel_offset */
478
/* IMAGE_REL_PPC_ADDR24 0x0003 26-bit address, shifted left 2 (branch absolute) */
479
/* the LI field is in bit 6 through bit 29 is 24 bits, + 2 for the shift */
480
/* Of course, That's the IBM approved bit numbering, which is not what */
481
/* anyone else uses.... The li field is in bit 2 thru 25 */
483
HOWTO (IMAGE_REL_PPC_ADDR24, /* type */
485
2, /* size (0 = byte, 1 = short, 2 = long) */
487
false, /* pc_relative */
489
complain_overflow_bitfield, /* complain_on_overflow */
490
0, /* special_function */
492
true, /* partial_inplace */
493
0x07fffffc, /* src_mask */
494
0x07fffffc, /* dst_mask */
495
false), /* pcrel_offset */
497
/* IMAGE_REL_PPC_ADDR16 0x0004 16-bit address */
499
HOWTO (IMAGE_REL_PPC_ADDR16, /* type */
501
1, /* size (0 = byte, 1 = short, 2 = long) */
503
false, /* pc_relative */
505
complain_overflow_signed, /* complain_on_overflow */
506
0, /* special_function */
508
true, /* partial_inplace */
509
0xffff, /* src_mask */
510
0xffff, /* dst_mask */
511
false), /* pcrel_offset */
513
/* IMAGE_REL_PPC_ADDR14 0x0005 */
514
/* 16-bit address, shifted left 2 (load doubleword) */
515
/* FIXME: the mask is likely wrong, and the bit position may be as well */
517
HOWTO (IMAGE_REL_PPC_ADDR14, /* type */
519
1, /* size (0 = byte, 1 = short, 2 = long) */
521
false, /* pc_relative */
523
complain_overflow_signed, /* complain_on_overflow */
524
0, /* special_function */
526
true, /* partial_inplace */
527
0xffff, /* src_mask */
528
0xffff, /* dst_mask */
529
false), /* pcrel_offset */
531
/* IMAGE_REL_PPC_REL24 0x0006 */
532
/* 26-bit PC-relative offset, shifted left 2 (branch relative) */
534
HOWTO (IMAGE_REL_PPC_REL24, /* type */
536
2, /* size (0 = byte, 1 = short, 2 = long) */
538
true, /* pc_relative */
540
complain_overflow_signed, /* complain_on_overflow */
541
0, /* special_function */
543
true, /* partial_inplace */
544
0x3fffffc, /* src_mask */
545
0x3fffffc, /* dst_mask */
546
false), /* pcrel_offset */
548
/* IMAGE_REL_PPC_REL14 0x0007 */
549
/* 16-bit PC-relative offset, shifted left 2 (br cond relative) */
550
/* FIXME: the mask is likely wrong, and the bit position may be as well */
551
/* FIXME: how does it know how far to shift? */
553
HOWTO (IMAGE_REL_PPC_ADDR14, /* type */
555
1, /* size (0 = byte, 1 = short, 2 = long) */
557
false, /* pc_relative */
559
complain_overflow_signed, /* complain_on_overflow */
560
0, /* special_function */
562
true, /* partial_inplace */
563
0xffff, /* src_mask */
564
0xffff, /* dst_mask */
565
true), /* pcrel_offset */
567
/* IMAGE_REL_PPC_TOCREL16 0x0008 */
568
/* 16-bit offset from TOC base */
570
HOWTO (IMAGE_REL_PPC_TOCREL16,/* type */
572
1, /* size (0 = byte, 1 = short, 2 = long) */
574
false, /* pc_relative */
576
complain_overflow_dont, /* complain_on_overflow */
577
ppc_toc16_reloc, /* special_function */
578
"TOCREL16", /* name */
579
false, /* partial_inplace */
580
0xffff, /* src_mask */
581
0xffff, /* dst_mask */
582
false), /* pcrel_offset */
584
/* IMAGE_REL_PPC_TOCREL14 0x0009 */
585
/* 16-bit offset from TOC base, shifted left 2 (load doubleword) */
587
HOWTO (IMAGE_REL_PPC_TOCREL14,/* type */
589
1, /* size (0 = byte, 1 = short, 2 = long) */
591
false, /* pc_relative */
593
complain_overflow_signed, /* complain_on_overflow */
594
0, /* special_function */
595
"TOCREL14", /* name */
596
false, /* partial_inplace */
597
0xffff, /* src_mask */
598
0xffff, /* dst_mask */
599
false), /* pcrel_offset */
601
/* IMAGE_REL_PPC_ADDR32NB 0x000A */
602
/* 32-bit addr w/ image base */
604
HOWTO (IMAGE_REL_PPC_ADDR32NB,/* type */
606
2, /* size (0 = byte, 1 = short, 2 = long) */
608
false, /* pc_relative */
610
complain_overflow_signed, /* complain_on_overflow */
611
0, /* special_function */
612
"ADDR32NB", /* name */
613
true, /* partial_inplace */
614
0xffffffff, /* src_mask */
615
0xffffffff, /* dst_mask */
616
false), /* pcrel_offset */
618
/* IMAGE_REL_PPC_SECREL 0x000B */
619
/* va of containing section (as in an image sectionhdr) */
621
HOWTO (IMAGE_REL_PPC_SECREL,/* type */
623
2, /* size (0 = byte, 1 = short, 2 = long) */
625
false, /* pc_relative */
627
complain_overflow_signed, /* complain_on_overflow */
628
ppc_secrel_reloc, /* special_function */
630
true, /* partial_inplace */
631
0xffffffff, /* src_mask */
632
0xffffffff, /* dst_mask */
633
true), /* pcrel_offset */
635
/* IMAGE_REL_PPC_SECTION 0x000C */
636
/* sectionheader number */
638
HOWTO (IMAGE_REL_PPC_SECTION,/* type */
640
2, /* size (0 = byte, 1 = short, 2 = long) */
642
false, /* pc_relative */
644
complain_overflow_signed, /* complain_on_overflow */
645
ppc_section_reloc, /* special_function */
646
"SECTION", /* name */
647
true, /* partial_inplace */
648
0xffffffff, /* src_mask */
649
0xffffffff, /* dst_mask */
650
true), /* pcrel_offset */
652
/* IMAGE_REL_PPC_IFGLUE 0x000D */
653
/* substitute TOC restore instruction iff symbol is glue code */
655
HOWTO (IMAGE_REL_PPC_IFGLUE,/* type */
657
2, /* size (0 = byte, 1 = short, 2 = long) */
659
false, /* pc_relative */
661
complain_overflow_signed, /* complain_on_overflow */
662
0, /* special_function */
664
true, /* partial_inplace */
665
0xffffffff, /* src_mask */
666
0xffffffff, /* dst_mask */
667
false), /* pcrel_offset */
669
/* IMAGE_REL_PPC_IMGLUE 0x000E */
670
/* symbol is glue code; virtual address is TOC restore instruction */
672
HOWTO (IMAGE_REL_PPC_IMGLUE,/* type */
674
2, /* size (0 = byte, 1 = short, 2 = long) */
676
false, /* pc_relative */
678
complain_overflow_dont, /* complain_on_overflow */
679
ppc_imglue_reloc, /* special_function */
681
false, /* partial_inplace */
682
0xffffffff, /* src_mask */
683
0xffffffff, /* dst_mask */
684
false), /* pcrel_offset */
686
/* IMAGE_REL_PPC_SECREL16 0x000F */
687
/* va of containing section (limited to 16 bits) */
689
HOWTO (IMAGE_REL_PPC_SECREL16,/* type */
691
1, /* size (0 = byte, 1 = short, 2 = long) */
693
false, /* pc_relative */
695
complain_overflow_signed, /* complain_on_overflow */
696
0, /* special_function */
697
"SECREL16", /* name */
698
true, /* partial_inplace */
699
0xffff, /* src_mask */
700
0xffff, /* dst_mask */
701
true), /* pcrel_offset */
703
/* IMAGE_REL_PPC_REFHI 0x0010 */
705
HOWTO (IMAGE_REL_PPC_REFHI, /* type */
707
1, /* size (0 = byte, 1 = short, 2 = long) */
709
false, /* pc_relative */
711
complain_overflow_signed, /* complain_on_overflow */
712
ppc_refhi_reloc, /* special_function */
714
true, /* partial_inplace */
715
0xffffffff, /* src_mask */
716
0xffffffff, /* dst_mask */
717
false), /* pcrel_offset */
719
/* IMAGE_REL_PPC_REFLO 0x0011 */
721
HOWTO (IMAGE_REL_PPC_REFLO, /* type */
723
1, /* size (0 = byte, 1 = short, 2 = long) */
725
false, /* pc_relative */
727
complain_overflow_signed, /* complain_on_overflow */
728
ppc_refhi_reloc, /* special_function */
730
true, /* partial_inplace */
731
0xffffffff, /* src_mask */
732
0xffffffff, /* dst_mask */
733
false), /* pcrel_offset */
735
/* IMAGE_REL_PPC_PAIR 0x0012 */
737
HOWTO (IMAGE_REL_PPC_PAIR, /* type */
739
1, /* size (0 = byte, 1 = short, 2 = long) */
741
false, /* pc_relative */
743
complain_overflow_signed, /* complain_on_overflow */
744
ppc_pair_reloc, /* special_function */
746
true, /* partial_inplace */
747
0xffffffff, /* src_mask */
748
0xffffffff, /* dst_mask */
749
false), /* pcrel_offset */
751
/* IMAGE_REL_PPC_TOCREL16_DEFN 0x0013 */
752
/* 16-bit offset from TOC base, without causing a definition */
754
HOWTO ( (IMAGE_REL_PPC_TOCREL16 | IMAGE_REL_PPC_TOCDEFN), /* type */
756
1, /* size (0 = byte, 1 = short, 2 = long) */
758
false, /* pc_relative */
760
complain_overflow_dont, /* complain_on_overflow */
761
0, /* special_function */
762
"TOCREL16, TOCDEFN", /* name */
763
false, /* partial_inplace */
764
0xffff, /* src_mask */
765
0xffff, /* dst_mask */
766
false), /* pcrel_offset */
770
/* Some really cheezy macros that can be turned on to test stderr :-) */
779
fprintf (stderr,_("Unimplemented Relocation -- %s\n"),x); \
783
#define DUMP_RELOC(n,r) \
785
fprintf (stderr,"%s sym %d, addr %d, addend %d\n", \
786
n, (*(r->sym_ptr_ptr))->name, \
787
r->address, r->addend); \
790
/* Given a reloc name, n, and a pointer to an internal_reloc,
791
dump out interesting information on the contents
793
#define n_name _n._n_name
794
#define n_zeroes _n._n_n._n_zeroes
795
#define n_offset _n._n_n._n_offset
799
#define DUMP_RELOC2(n,r) \
801
fprintf (stderr,"%s sym %d, r_vaddr %d %s\n", \
802
n, r->r_symndx, r->r_vaddr,\
803
(((r->r_type) & IMAGE_REL_PPC_TOCDEFN) == 0) \
809
#define DUMP_RELOC(n,r)
810
#define DUMP_RELOC2(n,r)
813
/* toc construction and management routines */
815
/* This file is compiled twice, and these variables are defined in one
816
of the compilations. FIXME: This is confusing and weird. Also,
817
BFD should not use global variables. */
818
extern bfd* bfd_of_toc_owner;
819
extern long int global_toc_size;
821
extern long int import_table_size;
822
extern long int first_thunk_address;
823
extern long int thunk_size;
841
struct list_ele *next;
843
enum ref_category cat;
848
extern struct list_ele *head;
849
extern struct list_ele *tail;
851
static void record_toc
852
PARAMS ((asection *, bfd_signed_vma, enum ref_category, const char *));
855
record_toc (toc_section, our_toc_offset, cat, name)
856
asection *toc_section;
857
bfd_signed_vma our_toc_offset;
858
enum ref_category cat;
861
/* add this entry to our toc addr-offset-name list */
862
bfd_size_type amt = sizeof (struct list_ele);
863
struct list_ele *t = (struct list_ele *) bfd_malloc (amt);
868
t->offset = our_toc_offset;
871
t->addr = toc_section->output_offset + our_toc_offset;
885
#ifdef COFF_IMAGE_WITH_PE
887
static boolean ppc_record_toc_entry
888
PARAMS ((bfd *, struct bfd_link_info *, asection *, int, enum toc_type));
889
static void ppc_mark_symbol_as_glue
890
PARAMS ((bfd *, int, struct internal_reloc *));
892
/* record a toc offset against a symbol */
894
ppc_record_toc_entry(abfd, info, sec, sym, toc_kind)
896
struct bfd_link_info *info ATTRIBUTE_UNUSED;
897
asection *sec ATTRIBUTE_UNUSED;
899
enum toc_type toc_kind ATTRIBUTE_UNUSED;
901
struct ppc_coff_link_hash_entry *h;
908
h = (struct ppc_coff_link_hash_entry *) (obj_coff_sym_hashes (abfd)[sym]);
916
local_syms = obj_coff_local_toc_table(abfd);
921
/* allocate a table */
922
amt = (bfd_size_type) obj_raw_syment_count (abfd) * sizeof (int);
923
local_syms = (int *) bfd_zalloc (abfd, amt);
926
obj_coff_local_toc_table (abfd) = local_syms;
927
for (i = 0; i < obj_raw_syment_count (abfd); ++i)
929
SET_UNALLOCATED (local_syms[i]);
933
if (IS_UNALLOCATED(local_syms[sym]))
935
local_syms[sym] = global_toc_size;
936
global_toc_size += 4;
938
/* The size must fit in a 16bit displacment */
939
if (global_toc_size > 65535)
941
(*_bfd_error_handler) (_("TOC overflow"));
942
bfd_set_error (bfd_error_file_too_big);
949
name = h->root.root.root.string;
951
/* check to see if there's a toc slot allocated. If not, do it
952
here. It will be used in relocate_section */
953
if (IS_UNALLOCATED(h->toc_offset))
955
h->toc_offset = global_toc_size;
956
global_toc_size += 4;
958
/* The size must fit in a 16bit displacment */
959
if (global_toc_size >= 65535)
961
(*_bfd_error_handler) (_("TOC overflow"));
962
bfd_set_error (bfd_error_file_too_big);
971
/* record a toc offset against a symbol */
973
ppc_mark_symbol_as_glue(abfd, sym, rel)
976
struct internal_reloc *rel;
978
struct ppc_coff_link_hash_entry *h;
980
h = (struct ppc_coff_link_hash_entry *) (obj_coff_sym_hashes (abfd)[sym]);
984
h->symbol_is_glue = 1;
985
h->glue_insn = bfd_get_32 (abfd, (bfd_byte *) &rel->r_vaddr);
990
#endif /* COFF_IMAGE_WITH_PE */
992
/* Return true if this relocation should
993
appear in the output .reloc section. */
995
static boolean in_reloc_p(abfd, howto)
996
bfd * abfd ATTRIBUTE_UNUSED;
997
reloc_howto_type *howto;
1000
(! howto->pc_relative)
1001
&& (howto->type != IMAGE_REL_PPC_ADDR32NB)
1002
&& (howto->type != IMAGE_REL_PPC_TOCREL16)
1003
&& (howto->type != IMAGE_REL_PPC_IMGLUE)
1004
&& (howto->type != IMAGE_REL_PPC_IFGLUE)
1005
&& (howto->type != IMAGE_REL_PPC_SECREL)
1006
&& (howto->type != IMAGE_REL_PPC_SECTION)
1007
&& (howto->type != IMAGE_REL_PPC_SECREL16)
1008
&& (howto->type != IMAGE_REL_PPC_REFHI)
1009
&& (howto->type != IMAGE_REL_PPC_REFLO)
1010
&& (howto->type != IMAGE_REL_PPC_PAIR)
1011
&& (howto->type != IMAGE_REL_PPC_TOCREL16_DEFN) ;
1016
/* this function is in charge of performing all the ppc PE relocations */
1017
/* Don't yet know if we want to do this this particular way ... (krk) */
1018
/* FIXME: (it is not yet enabled) */
1020
static bfd_reloc_status_type
1021
pe_ppc_reloc (abfd, reloc_entry, symbol_in, data, input_section, output_bfd,
1024
arelent *reloc_entry;
1027
asection *input_section;
1029
char **error_message;
1031
/* the consth relocation comes in two parts, we have to remember
1032
the state between calls, in these variables */
1033
static boolean part1_consth_active = false;
1034
static unsigned long part1_consth_value;
1036
unsigned long sym_value;
1037
unsigned short r_type;
1038
unsigned long addr = reloc_entry->address ; /*+ input_section->vma*/
1040
r_type = reloc_entry->howto->type;
1044
/* Partial linking - do nothing */
1045
reloc_entry->address += input_section->output_offset;
1046
return bfd_reloc_ok;
1049
if (symbol_in != NULL
1050
&& bfd_is_und_section (symbol_in->section))
1052
/* Keep the state machine happy in case we're called again */
1053
if (r_type == IMAGE_REL_PPC_REFHI)
1055
part1_consth_active = true;
1056
part1_consth_value = 0;
1058
return(bfd_reloc_undefined);
1061
if ((part1_consth_active) && (r_type != IMAGE_REL_PPC_PAIR))
1063
part1_consth_active = false;
1064
*error_message = (char *) _("Missing PAIR");
1065
return(bfd_reloc_dangerous);
1068
sym_value = get_symbol_value(symbol_in);
1070
return(bfd_reloc_ok);
1075
/* The reloc processing routine for the optimized COFF linker. */
1078
coff_ppc_relocate_section (output_bfd, info, input_bfd, input_section,
1079
contents, relocs, syms, sections)
1081
struct bfd_link_info *info;
1083
asection *input_section;
1085
struct internal_reloc *relocs;
1086
struct internal_syment *syms;
1087
asection **sections;
1089
struct internal_reloc *rel;
1090
struct internal_reloc *relend;
1093
asection *toc_section = 0;
1095
reloc_howto_type *howto = 0;
1097
/* If we are performing a relocateable link, we don't need to do a
1098
thing. The caller will take care of adjusting the reloc
1099
addresses and symbol indices. */
1100
if (info->relocateable)
1107
relend = rel + input_section->reloc_count;
1108
for (; rel < relend; rel++)
1111
struct ppc_coff_link_hash_entry *h;
1112
struct internal_syment *sym;
1116
bfd_reloc_status_type rstat;
1119
unsigned short r_type = EXTRACT_TYPE (rel->r_type);
1120
unsigned short r_flags = EXTRACT_FLAGS(rel->r_type);
1122
symndx = rel->r_symndx;
1123
loc = contents + rel->r_vaddr - input_section->vma;
1125
/* FIXME: check bounds on r_type */
1126
howto = ppc_coff_howto_table + r_type;
1135
h = (struct ppc_coff_link_hash_entry *)
1136
(obj_coff_sym_hashes (input_bfd)[symndx]);
1142
sym = syms + symndx;
1145
if (r_type == IMAGE_REL_PPC_IMGLUE && h == 0)
1147
/* An IMGLUE reloc must have a name. Something is very wrong. */
1154
/* FIXME: PAIR unsupported in the following code */
1158
sec = bfd_abs_section_ptr;
1161
sec = sections[symndx];
1162
val = (sec->output_section->vma
1163
+ sec->output_offset
1165
if (! obj_pe (output_bfd))
1173
if (h->root.root.type == bfd_link_hash_defined
1174
|| h->root.root.type == bfd_link_hash_defweak)
1176
sec = h->root.root.u.def.section;
1177
val = (h->root.root.u.def.value
1178
+ sec->output_section->vma
1179
+ sec->output_offset);
1183
if (! ((*info->callbacks->undefined_symbol)
1184
(info, h->root.root.root.string, input_bfd, input_section,
1185
rel->r_vaddr - input_section->vma, true)))
1190
rstat = bfd_reloc_ok;
1192
/* Each case must do its own relocation, setting rstat appropriately */
1196
(*_bfd_error_handler)
1197
(_("%s: unsupported relocation type 0x%02x"),
1198
bfd_archive_filename (input_bfd), r_type);
1199
bfd_set_error (bfd_error_bad_value);
1201
case IMAGE_REL_PPC_TOCREL16:
1203
bfd_signed_vma our_toc_offset;
1206
DUMP_RELOC2(howto->name, rel);
1208
if (toc_section == 0)
1210
toc_section = bfd_get_section_by_name (bfd_of_toc_owner,
1213
if ( toc_section == NULL )
1215
/* There is no toc section. Something is very wrong. */
1221
* Amazing bit tricks present. As we may have seen earlier, we
1222
* use the 1 bit to tell us whether or not a toc offset has been
1223
* allocated. Now that they've all been allocated, we will use
1224
* the 1 bit to tell us if we've written this particular toc
1229
{ /* it is a file local symbol */
1230
int *local_toc_table;
1233
sym = syms + symndx;
1234
name = sym->_n._n_name;
1236
local_toc_table = obj_coff_local_toc_table(input_bfd);
1237
our_toc_offset = local_toc_table[symndx];
1239
if (IS_WRITTEN(our_toc_offset))
1241
/* if it has been written out, it is marked with the
1242
1 bit. Fix up our offset, but do not write it out
1245
MAKE_ADDR_AGAIN(our_toc_offset);
1249
/* write out the toc entry */
1250
record_toc (toc_section, our_toc_offset, priv,
1253
bfd_put_32 (output_bfd, val,
1254
toc_section->contents + our_toc_offset);
1256
MARK_AS_WRITTEN(local_toc_table[symndx]);
1262
const char *name = h->root.root.root.string;
1263
our_toc_offset = h->toc_offset;
1265
if ((r_flags & IMAGE_REL_PPC_TOCDEFN)
1266
== IMAGE_REL_PPC_TOCDEFN )
1268
/* This is unbelievable cheese. Some knowledgable asm
1269
hacker has decided to use r2 as a base for loading
1270
a value. He/She does this by setting the tocdefn bit,
1271
and not supplying a toc definition. The behaviour is
1272
then to use the difference between the value of the
1273
symbol and the actual location of the toc as the toc
1276
In fact, what is usually happening is, because the
1277
Import Address Table is mapped immediately following
1278
the toc, some trippy library code trying for speed on
1279
dll linkage, takes advantage of that and considers
1280
the IAT to be part of the toc, thus saving a load.
1283
our_toc_offset = val - (toc_section->output_section->vma
1284
+ toc_section->output_offset);
1286
/* The size must still fit in a 16bit displacment */
1287
if ((bfd_vma) our_toc_offset >= 65535)
1289
(*_bfd_error_handler)
1290
(_("%s: Relocation for %s of %lx exceeds Toc size limit"),
1291
bfd_archive_filename (input_bfd), name,
1292
(unsigned long) our_toc_offset);
1293
bfd_set_error (bfd_error_bad_value);
1297
record_toc (toc_section, our_toc_offset, pub,
1300
else if (IS_WRITTEN(our_toc_offset))
1302
/* if it has been written out, it is marked with the
1303
1 bit. Fix up our offset, but do not write it out
1306
MAKE_ADDR_AGAIN(our_toc_offset);
1310
record_toc(toc_section, our_toc_offset, pub,
1313
/* write out the toc entry */
1314
bfd_put_32 (output_bfd, val,
1315
toc_section->contents + our_toc_offset);
1317
MARK_AS_WRITTEN(h->toc_offset);
1318
/* The tricky part is that this is the address that */
1319
/* needs a .reloc entry for it */
1324
if (fixit && info->base_file)
1326
/* So if this is non pcrelative, and is referenced
1327
to a section or a common symbol, then it needs a reloc */
1329
/* relocation to a symbol in a section which
1330
isn't absolute - we output the address here
1333
bfd_vma addr = (toc_section->output_section->vma
1334
+ toc_section->output_offset + our_toc_offset);
1336
if (coff_data(output_bfd)->pe)
1337
addr -= pe_data(output_bfd)->pe_opthdr.ImageBase;
1339
fwrite (&addr, 1,4, (FILE *) info->base_file);
1342
/* FIXME: this test is conservative */
1343
if ((r_flags & IMAGE_REL_PPC_TOCDEFN) != IMAGE_REL_PPC_TOCDEFN
1344
&& (bfd_vma) our_toc_offset > toc_section->_raw_size)
1346
(*_bfd_error_handler)
1347
(_("%s: Relocation exceeds allocated TOC (%lx)"),
1348
bfd_archive_filename (input_bfd),
1349
(unsigned long) toc_section->_raw_size);
1350
bfd_set_error (bfd_error_bad_value);
1354
/* Now we know the relocation for this toc reference */
1355
relocation = our_toc_offset + TOC_LOAD_ADJUSTMENT;
1356
rstat = _bfd_relocate_contents (howto, input_bfd, relocation, loc);
1359
case IMAGE_REL_PPC_IFGLUE:
1361
/* To solve this, we need to know whether or not the symbol */
1362
/* appearing on the call instruction is a glue function or not. */
1363
/* A glue function must announce itself via a IMGLUE reloc, and */
1364
/* the reloc contains the required toc restore instruction */
1367
const char *my_name;
1368
DUMP_RELOC2(howto->name, rel);
1372
my_name = h->root.root.root.string;
1373
if (h->symbol_is_glue == 1)
1375
x = bfd_get_32 (input_bfd, loc);
1376
bfd_put_32 (input_bfd, (bfd_vma) h->glue_insn, loc);
1381
case IMAGE_REL_PPC_SECREL:
1382
/* Unimplemented: codeview debugging information */
1383
/* For fast access to the header of the section
1384
containing the item. */
1386
case IMAGE_REL_PPC_SECTION:
1387
/* Unimplemented: codeview debugging information */
1388
/* Is used to indicate that the value should be relative
1389
to the beginning of the section that contains the
1392
case IMAGE_REL_PPC_ABSOLUTE:
1394
const char *my_name;
1396
my_name = (syms+symndx)->_n._n_name;
1399
my_name = h->root.root.root.string;
1403
_("Warning: unsupported reloc %s <file %s, section %s>\n"),
1405
bfd_archive_filename(input_bfd),
1406
input_section->name);
1408
fprintf (stderr,"sym %ld (%s), r_vaddr %ld (%lx)\n",
1409
rel->r_symndx, my_name, (long) rel->r_vaddr,
1410
(unsigned long) rel->r_vaddr);
1413
case IMAGE_REL_PPC_IMGLUE:
1415
/* There is nothing to do now. This reloc was noted in the first
1416
pass over the relocs, and the glue instruction extracted */
1417
const char *my_name;
1418
if (h->symbol_is_glue == 1)
1420
my_name = h->root.root.root.string;
1422
(*_bfd_error_handler)
1423
(_("%s: Out of order IMGLUE reloc for %s"),
1424
bfd_archive_filename (input_bfd), my_name);
1425
bfd_set_error (bfd_error_bad_value);
1429
case IMAGE_REL_PPC_ADDR32NB:
1431
const char *name = 0;
1432
DUMP_RELOC2(howto->name, rel);
1434
if (strncmp(".idata$2",input_section->name,8) == 0 && first_thunk_address == 0)
1436
/* set magic values */
1438
struct coff_link_hash_entry *myh;
1439
myh = coff_link_hash_lookup (coff_hash_table (info),
1441
false, false, true);
1442
first_thunk_address = myh->root.u.def.value +
1443
sec->output_section->vma +
1444
sec->output_offset -
1445
pe_data(output_bfd)->pe_opthdr.ImageBase;
1447
idata5offset = myh->root.u.def.value;
1448
myh = coff_link_hash_lookup (coff_hash_table (info),
1450
false, false, true);
1452
thunk_size = myh->root.u.def.value - idata5offset;
1453
myh = coff_link_hash_lookup (coff_hash_table (info),
1455
false, false, true);
1456
import_table_size = myh->root.u.def.value;
1460
{ /* it is a file local symbol */
1461
sym = syms + symndx;
1462
name = sym->_n._n_name;
1468
name = h->root.root.root.string;
1469
if (strcmp(".idata$2", name) == 0)
1470
target = "__idata2_magic__";
1471
else if (strcmp(".idata$4", name) == 0)
1472
target = "__idata4_magic__";
1473
else if (strcmp(".idata$5", name) == 0)
1474
target = "__idata5_magic__";
1478
struct coff_link_hash_entry *myh;
1480
myh = coff_link_hash_lookup (coff_hash_table (info),
1482
false, false, true);
1485
/* Missing magic cookies. Something is very wrong. */
1489
val = myh->root.u.def.value +
1490
sec->output_section->vma + sec->output_offset;
1491
if (first_thunk_address == 0)
1494
myh = coff_link_hash_lookup (coff_hash_table (info),
1496
false, false, true);
1497
first_thunk_address = myh->root.u.def.value +
1498
sec->output_section->vma +
1499
sec->output_offset -
1500
pe_data(output_bfd)->pe_opthdr.ImageBase;
1502
idata5offset = myh->root.u.def.value;
1503
myh = coff_link_hash_lookup (coff_hash_table (info),
1505
false, false, true);
1507
thunk_size = myh->root.u.def.value - idata5offset;
1508
myh = coff_link_hash_lookup (coff_hash_table (info),
1510
false, false, true);
1511
import_table_size = myh->root.u.def.value;
1516
rstat = _bfd_relocate_contents (howto,
1519
pe_data(output_bfd)->pe_opthdr.ImageBase,
1524
case IMAGE_REL_PPC_REL24:
1525
DUMP_RELOC2(howto->name, rel);
1526
val -= (input_section->output_section->vma
1527
+ input_section->output_offset);
1529
rstat = _bfd_relocate_contents (howto,
1534
case IMAGE_REL_PPC_ADDR16:
1535
case IMAGE_REL_PPC_ADDR24:
1536
case IMAGE_REL_PPC_ADDR32:
1537
DUMP_RELOC2(howto->name, rel);
1538
rstat = _bfd_relocate_contents (howto,
1545
if ( info->base_file )
1547
/* So if this is non pcrelative, and is referenced
1548
to a section or a common symbol, then it needs a reloc */
1549
if (sym && pe_data(output_bfd)->in_reloc_p(output_bfd, howto))
1551
/* relocation to a symbol in a section which
1552
isn't absolute - we output the address here
1554
bfd_vma addr = rel->r_vaddr
1555
- input_section->vma
1556
+ input_section->output_offset
1557
+ input_section->output_section->vma;
1559
if (coff_data(output_bfd)->pe)
1561
addr -= pe_data(output_bfd)->pe_opthdr.ImageBase;
1563
fwrite (&addr, 1,4, (FILE *) info->base_file);
1573
case bfd_reloc_overflow:
1576
char buf[SYMNMLEN + 1];
1581
name = h->root.root.root.string;
1582
else if (sym == NULL)
1584
else if (sym->_n._n_n._n_zeroes == 0
1585
&& sym->_n._n_n._n_offset != 0)
1586
name = obj_coff_strings (input_bfd) + sym->_n._n_n._n_offset;
1589
strncpy (buf, sym->_n._n_name, SYMNMLEN);
1590
buf[SYMNMLEN] = '\0';
1594
if (! ((*info->callbacks->reloc_overflow)
1595
(info, name, howto->name,
1596
(bfd_vma) 0, input_bfd,
1597
input_section, rel->r_vaddr - input_section->vma)))
1609
#ifdef COFF_IMAGE_WITH_PE
1611
/* FIXME: BFD should not use global variables. This file is compiled
1612
twice, and these variables are shared. This is confusing and
1615
long int global_toc_size = 4;
1617
bfd* bfd_of_toc_owner = 0;
1619
long int import_table_size;
1620
long int first_thunk_address;
1621
long int thunk_size;
1623
struct list_ele *head;
1624
struct list_ele *tail;
1627
h1 = N_("\n\t\t\tTOC MAPPING\n\n");
1629
h2 = N_(" TOC disassembly Comments Name\n");
1631
h3 = N_(" Offset spelling (if present)\n");
1637
FILE *file = (FILE *) vfile;
1640
fprintf (file, _(h1));
1641
fprintf (file, _(h2));
1642
fprintf (file, _(h3));
1644
for (t = head; t != 0; t=t->next)
1646
const char *cat = "";
1649
cat = _("private ");
1650
else if (t->cat == pub)
1652
else if (t->cat == tocdata)
1653
cat = _("data-in-toc ");
1655
if (t->offset > global_toc_size)
1657
if (t->offset <= global_toc_size + thunk_size)
1658
cat = _("IAT reference ");
1662
_("**** global_toc_size %ld(%lx), thunk_size %ld(%lx)\n"),
1663
global_toc_size, global_toc_size,
1664
thunk_size, thunk_size);
1665
cat = _("Out of bounds!");
1670
" %04lx (%d)", (unsigned long) t->offset, t->offset - 32768);
1677
fprintf (file, "\n");
1681
ppc_allocate_toc_section (info)
1682
struct bfd_link_info *info ATTRIBUTE_UNUSED;
1687
static char test_char = '1';
1689
if ( global_toc_size == 0 ) /* FIXME: does this get me in trouble? */
1692
if (bfd_of_toc_owner == 0)
1694
/* No toc owner? Something is very wrong. */
1698
s = bfd_get_section_by_name ( bfd_of_toc_owner , TOC_SECTION_NAME);
1701
/* No toc section? Something is very wrong. */
1705
amt = global_toc_size;
1706
foo = (bfd_byte *) bfd_alloc (bfd_of_toc_owner, amt);
1707
memset(foo, test_char, (size_t) global_toc_size);
1709
s->_raw_size = s->_cooked_size = global_toc_size;
1716
ppc_process_before_allocation (abfd, info)
1718
struct bfd_link_info *info;
1721
struct internal_reloc *i, *rel;
1723
/* here we have a bfd that is to be included on the link. We have a hook
1724
to do reloc rummaging, before section sizes are nailed down. */
1726
_bfd_coff_get_external_symbols(abfd);
1728
/* rummage around all the relocs and map the toc */
1729
sec = abfd->sections;
1736
for (; sec != 0; sec = sec->next)
1738
if (sec->reloc_count == 0)
1741
/* load the relocs */
1742
/* FIXME: there may be a storage leak here */
1743
i=_bfd_coff_read_internal_relocs(abfd,sec,1,0,0,0);
1748
for (rel=i;rel<i+sec->reloc_count;++rel)
1750
unsigned short r_type = EXTRACT_TYPE (rel->r_type);
1751
unsigned short r_flags = EXTRACT_FLAGS(rel->r_type);
1754
DUMP_RELOC2(ppc_coff_howto_table[r_type].name, rel);
1758
case IMAGE_REL_PPC_TOCREL16:
1759
/* if TOCDEFN is on, ignore as someone else has allocated the
1761
if ( (r_flags & IMAGE_REL_PPC_TOCDEFN) != IMAGE_REL_PPC_TOCDEFN )
1762
ok = ppc_record_toc_entry(abfd, info, sec,
1763
rel->r_symndx, default_toc);
1767
case IMAGE_REL_PPC_IMGLUE:
1768
ppc_mark_symbol_as_glue(abfd, rel->r_symndx, rel);
1781
static bfd_reloc_status_type
1782
ppc_refhi_reloc (abfd,
1789
bfd *abfd ATTRIBUTE_UNUSED;
1790
arelent *reloc_entry ATTRIBUTE_UNUSED;
1791
asymbol *symbol ATTRIBUTE_UNUSED;
1792
PTR data ATTRIBUTE_UNUSED;
1793
asection *input_section ATTRIBUTE_UNUSED;
1795
char **error_message ATTRIBUTE_UNUSED;
1798
DUMP_RELOC("REFHI",reloc_entry);
1800
if (output_bfd == (bfd *) NULL)
1801
return bfd_reloc_continue;
1803
return bfd_reloc_undefined;
1808
static bfd_reloc_status_type
1809
ppc_reflo_reloc (abfd,
1817
arelent *reloc_entry;
1820
asection *input_section;
1822
char **error_message;
1825
DUMP_RELOC("REFLO",reloc_entry);
1827
if (output_bfd == (bfd *) NULL)
1828
return bfd_reloc_continue;
1830
return bfd_reloc_undefined;
1835
static bfd_reloc_status_type
1836
ppc_pair_reloc (abfd,
1843
bfd *abfd ATTRIBUTE_UNUSED;
1844
arelent *reloc_entry ATTRIBUTE_UNUSED;
1845
asymbol *symbol ATTRIBUTE_UNUSED;
1846
PTR data ATTRIBUTE_UNUSED;
1847
asection *input_section ATTRIBUTE_UNUSED;
1849
char **error_message ATTRIBUTE_UNUSED;
1852
DUMP_RELOC("PAIR",reloc_entry);
1854
if (output_bfd == (bfd *) NULL)
1855
return bfd_reloc_continue;
1857
return bfd_reloc_undefined;
1860
static bfd_reloc_status_type
1861
ppc_toc16_reloc (abfd,
1868
bfd *abfd ATTRIBUTE_UNUSED;
1869
arelent *reloc_entry ATTRIBUTE_UNUSED;
1870
asymbol *symbol ATTRIBUTE_UNUSED;
1871
PTR data ATTRIBUTE_UNUSED;
1872
asection *input_section ATTRIBUTE_UNUSED;
1874
char **error_message ATTRIBUTE_UNUSED;
1876
UN_IMPL("TOCREL16");
1877
DUMP_RELOC("TOCREL16",reloc_entry);
1879
if (output_bfd == (bfd *) NULL)
1881
return bfd_reloc_continue;
1884
return bfd_reloc_ok;
1889
/* ADDR32NB : 32 bit address relative to the virtual origin. */
1890
/* (On the alpha, this is always a linker generated thunk)*/
1891
/* (i.e. 32bit addr relative to the image base) */
1895
static bfd_reloc_status_type
1896
ppc_addr32nb_reloc (abfd,
1904
arelent *reloc_entry;
1907
asection *input_section;
1909
char **error_message;
1911
UN_IMPL("ADDR32NB");
1912
DUMP_RELOC("ADDR32NB",reloc_entry);
1914
return bfd_reloc_ok;
1919
static bfd_reloc_status_type
1920
ppc_secrel_reloc (abfd,
1927
bfd *abfd ATTRIBUTE_UNUSED;
1928
arelent *reloc_entry ATTRIBUTE_UNUSED;
1929
asymbol *symbol ATTRIBUTE_UNUSED;
1930
PTR data ATTRIBUTE_UNUSED;
1931
asection *input_section ATTRIBUTE_UNUSED;
1933
char **error_message ATTRIBUTE_UNUSED;
1936
DUMP_RELOC("SECREL",reloc_entry);
1938
if (output_bfd == (bfd *) NULL)
1939
return bfd_reloc_continue;
1941
return bfd_reloc_ok;
1944
static bfd_reloc_status_type
1945
ppc_section_reloc (abfd,
1952
bfd *abfd ATTRIBUTE_UNUSED;
1953
arelent *reloc_entry ATTRIBUTE_UNUSED;
1954
asymbol *symbol ATTRIBUTE_UNUSED;
1955
PTR data ATTRIBUTE_UNUSED;
1956
asection *input_section ATTRIBUTE_UNUSED;
1958
char **error_message ATTRIBUTE_UNUSED;
1961
DUMP_RELOC("SECTION",reloc_entry);
1963
if (output_bfd == (bfd *) NULL)
1964
return bfd_reloc_continue;
1966
return bfd_reloc_ok;
1969
static bfd_reloc_status_type
1970
ppc_imglue_reloc (abfd,
1977
bfd *abfd ATTRIBUTE_UNUSED;
1978
arelent *reloc_entry ATTRIBUTE_UNUSED;
1979
asymbol *symbol ATTRIBUTE_UNUSED;
1980
PTR data ATTRIBUTE_UNUSED;
1981
asection *input_section ATTRIBUTE_UNUSED;
1983
char **error_message ATTRIBUTE_UNUSED;
1986
DUMP_RELOC("IMGLUE",reloc_entry);
1988
if (output_bfd == (bfd *) NULL)
1989
return bfd_reloc_continue;
1991
return bfd_reloc_ok;
1994
#define MAX_RELOC_INDEX \
1995
(sizeof (ppc_coff_howto_table) / sizeof (ppc_coff_howto_table[0]) - 1)
1997
/* FIXME: There is a possiblity that when we read in a reloc from a file,
1998
that there are some bits encoded in the upper portion of the
1999
type field. Not yet implemented.
2001
static void ppc_coff_rtype2howto PARAMS ((arelent *relent,
2002
struct internal_reloc *internal));
2005
ppc_coff_rtype2howto (relent, internal)
2007
struct internal_reloc *internal;
2010
/* We can encode one of three things in the type field, aside from the
2012
1. IMAGE_REL_PPC_NEG - indicates the value field is a subtraction
2013
value, rather than an addition value
2014
2. IMAGE_REL_PPC_BRTAKEN, IMAGE_REL_PPC_BRNTAKEN - indicates that
2015
the branch is expected to be taken or not.
2016
3. IMAGE_REL_PPC_TOCDEFN - toc slot definition in the file
2017
For now, we just strip this stuff to find the type, and ignore it other
2020
reloc_howto_type *howto;
2021
unsigned short r_type = EXTRACT_TYPE (internal->r_type);
2022
unsigned short r_flags = EXTRACT_FLAGS(internal->r_type);
2023
unsigned short junk = EXTRACT_JUNK (internal->r_type);
2025
/* the masking process only slices off the bottom byte for r_type. */
2026
if ( r_type > MAX_RELOC_INDEX )
2029
/* check for absolute crap */
2035
case IMAGE_REL_PPC_ADDR16:
2036
case IMAGE_REL_PPC_REL24:
2037
case IMAGE_REL_PPC_ADDR24:
2038
case IMAGE_REL_PPC_ADDR32:
2039
case IMAGE_REL_PPC_IFGLUE:
2040
case IMAGE_REL_PPC_ADDR32NB:
2041
case IMAGE_REL_PPC_SECTION:
2042
case IMAGE_REL_PPC_SECREL:
2043
DUMP_RELOC2(ppc_coff_howto_table[r_type].name, internal);
2044
howto = ppc_coff_howto_table + r_type;
2046
case IMAGE_REL_PPC_IMGLUE:
2047
DUMP_RELOC2(ppc_coff_howto_table[r_type].name, internal);
2048
howto = ppc_coff_howto_table + r_type;
2050
case IMAGE_REL_PPC_TOCREL16:
2051
DUMP_RELOC2(ppc_coff_howto_table[r_type].name, internal);
2052
if (r_flags & IMAGE_REL_PPC_TOCDEFN)
2053
howto = ppc_coff_howto_table + IMAGE_REL_PPC_TOCREL16_DEFN;
2055
howto = ppc_coff_howto_table + IMAGE_REL_PPC_TOCREL16;
2059
_("Warning: Unsupported reloc %s [%d] used -- it may not work.\n"),
2060
ppc_coff_howto_table[r_type].name,
2062
howto = ppc_coff_howto_table + r_type;
2066
relent->howto = howto;
2070
static reloc_howto_type *
2071
coff_ppc_rtype_to_howto (abfd, sec, rel, h, sym, addendp)
2072
bfd *abfd ATTRIBUTE_UNUSED;
2074
struct internal_reloc *rel;
2075
struct coff_link_hash_entry *h ATTRIBUTE_UNUSED;
2076
struct internal_syment *sym ATTRIBUTE_UNUSED;
2079
reloc_howto_type *howto;
2081
/* We can encode one of three things in the type field, aside from the
2083
1. IMAGE_REL_PPC_NEG - indicates the value field is a subtraction
2084
value, rather than an addition value
2085
2. IMAGE_REL_PPC_BRTAKEN, IMAGE_REL_PPC_BRNTAKEN - indicates that
2086
the branch is expected to be taken or not.
2087
3. IMAGE_REL_PPC_TOCDEFN - toc slot definition in the file
2088
For now, we just strip this stuff to find the type, and ignore it other
2092
unsigned short r_type = EXTRACT_TYPE (rel->r_type);
2093
unsigned short r_flags = EXTRACT_FLAGS(rel->r_type);
2094
unsigned short junk = EXTRACT_JUNK (rel->r_type);
2096
/* the masking process only slices off the bottom byte for r_type. */
2097
if ( r_type > MAX_RELOC_INDEX )
2100
/* check for absolute crap */
2106
case IMAGE_REL_PPC_ADDR32NB:
2107
DUMP_RELOC2(ppc_coff_howto_table[r_type].name, rel);
2108
*addendp -= pe_data(sec->output_section->owner)->pe_opthdr.ImageBase;
2109
howto = ppc_coff_howto_table + r_type;
2111
case IMAGE_REL_PPC_TOCREL16:
2112
DUMP_RELOC2(ppc_coff_howto_table[r_type].name, rel);
2113
if (r_flags & IMAGE_REL_PPC_TOCDEFN)
2114
howto = ppc_coff_howto_table + IMAGE_REL_PPC_TOCREL16_DEFN;
2116
howto = ppc_coff_howto_table + IMAGE_REL_PPC_TOCREL16;
2118
case IMAGE_REL_PPC_ADDR16:
2119
case IMAGE_REL_PPC_REL24:
2120
case IMAGE_REL_PPC_ADDR24:
2121
case IMAGE_REL_PPC_ADDR32:
2122
case IMAGE_REL_PPC_IFGLUE:
2123
case IMAGE_REL_PPC_SECTION:
2124
case IMAGE_REL_PPC_SECREL:
2125
DUMP_RELOC2(ppc_coff_howto_table[r_type].name, rel);
2126
howto = ppc_coff_howto_table + r_type;
2128
case IMAGE_REL_PPC_IMGLUE:
2129
DUMP_RELOC2(ppc_coff_howto_table[r_type].name, rel);
2130
howto = ppc_coff_howto_table + r_type;
2134
_("Warning: Unsupported reloc %s [%d] used -- it may not work.\n"),
2135
ppc_coff_howto_table[r_type].name,
2137
howto = ppc_coff_howto_table + r_type;
2144
/* a cheesy little macro to make the code a little more readable */
2145
#define HOW2MAP(bfd_rtype,ppc_rtype) \
2146
case bfd_rtype: return &ppc_coff_howto_table[ppc_rtype]
2148
static reloc_howto_type *ppc_coff_reloc_type_lookup
2149
PARAMS ((bfd *, bfd_reloc_code_real_type));
2151
static reloc_howto_type *
2152
ppc_coff_reloc_type_lookup (abfd, code)
2153
bfd *abfd ATTRIBUTE_UNUSED;
2154
bfd_reloc_code_real_type code;
2158
HOW2MAP(BFD_RELOC_32_GOTOFF, IMAGE_REL_PPC_IMGLUE);
2159
HOW2MAP(BFD_RELOC_16_GOT_PCREL, IMAGE_REL_PPC_IFGLUE);
2160
HOW2MAP(BFD_RELOC_16, IMAGE_REL_PPC_ADDR16);
2161
HOW2MAP(BFD_RELOC_PPC_B26, IMAGE_REL_PPC_REL24);
2162
HOW2MAP(BFD_RELOC_PPC_BA26, IMAGE_REL_PPC_ADDR24);
2163
HOW2MAP(BFD_RELOC_PPC_TOC16, IMAGE_REL_PPC_TOCREL16);
2164
HOW2MAP(BFD_RELOC_16_GOTOFF, IMAGE_REL_PPC_TOCREL16_DEFN);
2165
HOW2MAP(BFD_RELOC_32, IMAGE_REL_PPC_ADDR32);
2166
HOW2MAP(BFD_RELOC_RVA, IMAGE_REL_PPC_ADDR32NB);
2175
/* Tailor coffcode.h -- macro heaven. */
2177
#define RTYPE2HOWTO(cache_ptr, dst) ppc_coff_rtype2howto (cache_ptr, dst)
2179
/* We use the special COFF backend linker, with our own special touch. */
2181
#define coff_bfd_reloc_type_lookup ppc_coff_reloc_type_lookup
2182
#define coff_rtype_to_howto coff_ppc_rtype_to_howto
2183
#define coff_relocate_section coff_ppc_relocate_section
2184
#define coff_bfd_final_link ppc_bfd_coff_final_link
2186
#ifndef COFF_IMAGE_WITH_PE
2187
/* FIXME: This no longer works. */
2189
#define coff_swap_sym_in_hook ppc_coff_swap_sym_in_hook
2193
#define SELECT_RELOC(internal, howto) {internal.r_type=howto->type;}
2195
#define COFF_PAGE_SIZE 0x1000
2197
/* FIXME: This controls some code that used to be in peicode.h and is
2198
now in peigen.c. It will not control the code in peigen.c. If
2199
anybody wants to get this working, you will need to fix that. */
2200
#define POWERPC_LE_PE
2202
#define COFF_SECTION_ALIGNMENT_ENTRIES \
2203
{ COFF_SECTION_NAME_EXACT_MATCH (".idata$2"), \
2204
COFF_ALIGNMENT_FIELD_EMPTY, COFF_ALIGNMENT_FIELD_EMPTY, 0 }, \
2205
{ COFF_SECTION_NAME_EXACT_MATCH (".idata$3"), \
2206
COFF_ALIGNMENT_FIELD_EMPTY, COFF_ALIGNMENT_FIELD_EMPTY, 0 }, \
2207
{ COFF_SECTION_NAME_EXACT_MATCH (".idata$4"), \
2208
COFF_ALIGNMENT_FIELD_EMPTY, COFF_ALIGNMENT_FIELD_EMPTY, 2 }, \
2209
{ COFF_SECTION_NAME_EXACT_MATCH (".idata$5"), \
2210
COFF_ALIGNMENT_FIELD_EMPTY, COFF_ALIGNMENT_FIELD_EMPTY, 2 }, \
2211
{ COFF_SECTION_NAME_EXACT_MATCH (".idata$6"), \
2212
COFF_ALIGNMENT_FIELD_EMPTY, COFF_ALIGNMENT_FIELD_EMPTY, 1 }, \
2213
{ COFF_SECTION_NAME_EXACT_MATCH (".reloc"), \
2214
COFF_ALIGNMENT_FIELD_EMPTY, COFF_ALIGNMENT_FIELD_EMPTY, 1 }
2216
#include "coffcode.h"
2218
#ifndef COFF_IMAGE_WITH_PE
2219
/* FIXME: This no longer works. */
2222
What we're trying to do here is allocate a toc section (early), and attach
2223
it to the last bfd to be processed. This avoids the problem of having a toc
2224
written out before all files have been processed. This code allocates
2225
a toc section for every file, and records the last one seen. There are
2226
at least two problems with this approach:
2227
1. We allocate whole bunches of toc sections that are ignored, but at
2228
at least we will not allocate a toc if no .toc is present.
2229
2. It's not clear to me that being the last bfd read necessarily means
2230
that you are the last bfd closed.
2231
3. Doing it on a "swap in" hook depends on when the "swap in" is called,
2232
and how often, etc. It's not clear to me that there isn't a hole here.
2234
static void ppc_coff_swap_sym_in_hook PARAMS ((bfd *, PTR, PTR));
2237
ppc_coff_swap_sym_in_hook (abfd, ext1, in1)
2239
PTR ext1 ATTRIBUTE_UNUSED;
2242
struct internal_syment *in = (struct internal_syment *)in1;
2244
if (bfd_of_toc_owner != 0) /* we already have a toc, so go home */
2247
if (strcmp(in->_n._n_name, ".toc") == 0)
2250
register asection *s;
2252
s = bfd_get_section_by_name ( abfd , TOC_SECTION_NAME);
2258
flags = SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY ;
2260
s = bfd_make_section (abfd, TOC_SECTION_NAME);
2263
|| !bfd_set_section_flags (abfd, s, flags)
2264
|| !bfd_set_section_alignment (abfd, s, 2))
2266
/* FIXME: set appropriate bfd error */
2270
/* save the bfd for later allocation */
2271
bfd_of_toc_owner = abfd;
2279
#ifndef COFF_IMAGE_WITH_PE
2281
static boolean ppc_do_last PARAMS ((bfd *));
2282
static bfd *ppc_get_last PARAMS ((void));
2288
if (abfd == bfd_of_toc_owner)
2297
return bfd_of_toc_owner;
2300
/* this piece of machinery exists only to guarantee that the bfd that holds
2301
the toc section is written last.
2303
This does depend on bfd_make_section attaching a new section to the
2304
end of the section list for the bfd.
2306
This is otherwise intended to be functionally the same as
2307
cofflink.c:_bfd_coff_final_link(). It is specifically different only
2308
where the POWERPC_LE_PE macro modifies the code. It is left in as a
2309
precise form of comment. krk@cygnus.com
2312
/* Do the final link step. */
2315
ppc_bfd_coff_final_link (abfd, info)
2317
struct bfd_link_info *info;
2319
bfd_size_type symesz;
2320
struct coff_final_link_info finfo;
2321
boolean debug_merge_allocated;
2323
struct bfd_link_order *p;
2324
bfd_size_type max_sym_count;
2325
bfd_size_type max_lineno_count;
2326
bfd_size_type max_reloc_count;
2327
bfd_size_type max_output_reloc_count;
2328
bfd_size_type max_contents_size;
2329
file_ptr rel_filepos;
2331
file_ptr line_filepos;
2332
unsigned int linesz;
2334
bfd_byte *external_relocs = NULL;
2335
char strbuf[STRING_SIZE_SIZE];
2338
symesz = bfd_coff_symesz (abfd);
2341
finfo.output_bfd = abfd;
2342
finfo.strtab = NULL;
2343
finfo.section_info = NULL;
2344
finfo.last_file_index = -1;
2345
finfo.last_bf_index = -1;
2346
finfo.internal_syms = NULL;
2347
finfo.sec_ptrs = NULL;
2348
finfo.sym_indices = NULL;
2349
finfo.outsyms = NULL;
2350
finfo.linenos = NULL;
2351
finfo.contents = NULL;
2352
finfo.external_relocs = NULL;
2353
finfo.internal_relocs = NULL;
2354
debug_merge_allocated = false;
2356
coff_data (abfd)->link_info = info;
2358
finfo.strtab = _bfd_stringtab_init ();
2359
if (finfo.strtab == NULL)
2362
if (! coff_debug_merge_hash_table_init (&finfo.debug_merge))
2364
debug_merge_allocated = true;
2366
/* Compute the file positions for all the sections. */
2367
if (! abfd->output_has_begun)
2369
if (! bfd_coff_compute_section_file_positions (abfd))
2373
/* Count the line numbers and relocation entries required for the
2374
output file. Set the file positions for the relocs. */
2375
rel_filepos = obj_relocbase (abfd);
2376
relsz = bfd_coff_relsz (abfd);
2377
max_contents_size = 0;
2378
max_lineno_count = 0;
2379
max_reloc_count = 0;
2381
for (o = abfd->sections; o != NULL; o = o->next)
2384
o->lineno_count = 0;
2385
for (p = o->link_order_head; p != NULL; p = p->next)
2388
if (p->type == bfd_indirect_link_order)
2392
sec = p->u.indirect.section;
2394
/* Mark all sections which are to be included in the
2395
link. This will normally be every section. We need
2396
to do this so that we can identify any sections which
2397
the linker has decided to not include. */
2398
sec->linker_mark = true;
2400
if (info->strip == strip_none
2401
|| info->strip == strip_some)
2402
o->lineno_count += sec->lineno_count;
2404
if (info->relocateable)
2405
o->reloc_count += sec->reloc_count;
2407
if (sec->_raw_size > max_contents_size)
2408
max_contents_size = sec->_raw_size;
2409
if (sec->lineno_count > max_lineno_count)
2410
max_lineno_count = sec->lineno_count;
2411
if (sec->reloc_count > max_reloc_count)
2412
max_reloc_count = sec->reloc_count;
2414
else if (info->relocateable
2415
&& (p->type == bfd_section_reloc_link_order
2416
|| p->type == bfd_symbol_reloc_link_order))
2419
if (o->reloc_count == 0)
2423
o->flags |= SEC_RELOC;
2424
o->rel_filepos = rel_filepos;
2425
rel_filepos += o->reloc_count * relsz;
2429
/* If doing a relocateable link, allocate space for the pointers we
2431
if (info->relocateable)
2435
/* We use section_count + 1, rather than section_count, because
2436
the target_index fields are 1 based. */
2437
amt = abfd->section_count + 1;
2438
amt *= sizeof (struct coff_link_section_info);
2439
finfo.section_info = (struct coff_link_section_info *) bfd_malloc (amt);
2440
if (finfo.section_info == NULL)
2442
for (i = 0; i <= abfd->section_count; i++)
2444
finfo.section_info[i].relocs = NULL;
2445
finfo.section_info[i].rel_hashes = NULL;
2449
/* We now know the size of the relocs, so we can determine the file
2450
positions of the line numbers. */
2451
line_filepos = rel_filepos;
2452
linesz = bfd_coff_linesz (abfd);
2453
max_output_reloc_count = 0;
2454
for (o = abfd->sections; o != NULL; o = o->next)
2456
if (o->lineno_count == 0)
2457
o->line_filepos = 0;
2460
o->line_filepos = line_filepos;
2461
line_filepos += o->lineno_count * linesz;
2464
if (o->reloc_count != 0)
2466
/* We don't know the indices of global symbols until we have
2467
written out all the local symbols. For each section in
2468
the output file, we keep an array of pointers to hash
2469
table entries. Each entry in the array corresponds to a
2470
reloc. When we find a reloc against a global symbol, we
2471
set the corresponding entry in this array so that we can
2472
fix up the symbol index after we have written out all the
2475
Because of this problem, we also keep the relocs in
2476
memory until the end of the link. This wastes memory,
2477
but only when doing a relocateable link, which is not the
2479
BFD_ASSERT (info->relocateable);
2480
amt = o->reloc_count;
2481
amt *= sizeof (struct internal_reloc);
2482
finfo.section_info[o->target_index].relocs =
2483
(struct internal_reloc *) bfd_malloc (amt);
2484
amt = o->reloc_count;
2485
amt *= sizeof (struct coff_link_hash_entry *);
2486
finfo.section_info[o->target_index].rel_hashes =
2487
(struct coff_link_hash_entry **) bfd_malloc (amt);
2488
if (finfo.section_info[o->target_index].relocs == NULL
2489
|| finfo.section_info[o->target_index].rel_hashes == NULL)
2492
if (o->reloc_count > max_output_reloc_count)
2493
max_output_reloc_count = o->reloc_count;
2496
/* Reset the reloc and lineno counts, so that we can use them to
2497
count the number of entries we have output so far. */
2499
o->lineno_count = 0;
2502
obj_sym_filepos (abfd) = line_filepos;
2504
/* Figure out the largest number of symbols in an input BFD. Take
2505
the opportunity to clear the output_has_begun fields of all the
2508
for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
2512
sub->output_has_begun = false;
2513
sz = obj_raw_syment_count (sub);
2514
if (sz > max_sym_count)
2518
/* Allocate some buffers used while linking. */
2519
amt = max_sym_count * sizeof (struct internal_syment);
2520
finfo.internal_syms = (struct internal_syment *) bfd_malloc (amt);
2521
amt = max_sym_count * sizeof (asection *);
2522
finfo.sec_ptrs = (asection **) bfd_malloc (amt);
2523
amt = max_sym_count * sizeof (long);
2524
finfo.sym_indices = (long *) bfd_malloc (amt);
2525
amt = (max_sym_count + 1) * symesz;
2526
finfo.outsyms = (bfd_byte *) bfd_malloc (amt);
2527
amt = max_lineno_count * bfd_coff_linesz (abfd);
2528
finfo.linenos = (bfd_byte *) bfd_malloc (amt);
2529
finfo.contents = (bfd_byte *) bfd_malloc (max_contents_size);
2530
finfo.external_relocs = (bfd_byte *) bfd_malloc (max_reloc_count * relsz);
2531
if (! info->relocateable)
2533
amt = max_reloc_count * sizeof (struct internal_reloc);
2534
finfo.internal_relocs = (struct internal_reloc *) bfd_malloc (amt);
2536
if ((finfo.internal_syms == NULL && max_sym_count > 0)
2537
|| (finfo.sec_ptrs == NULL && max_sym_count > 0)
2538
|| (finfo.sym_indices == NULL && max_sym_count > 0)
2539
|| finfo.outsyms == NULL
2540
|| (finfo.linenos == NULL && max_lineno_count > 0)
2541
|| (finfo.contents == NULL && max_contents_size > 0)
2542
|| (finfo.external_relocs == NULL && max_reloc_count > 0)
2543
|| (! info->relocateable
2544
&& finfo.internal_relocs == NULL
2545
&& max_reloc_count > 0))
2548
/* We now know the position of everything in the file, except that
2549
we don't know the size of the symbol table and therefore we don't
2550
know where the string table starts. We just build the string
2551
table in memory as we go along. We process all the relocations
2552
for a single input file at once. */
2553
obj_raw_syment_count (abfd) = 0;
2555
if (coff_backend_info (abfd)->_bfd_coff_start_final_link)
2557
if (! bfd_coff_start_final_link (abfd, info))
2561
for (o = abfd->sections; o != NULL; o = o->next)
2563
for (p = o->link_order_head; p != NULL; p = p->next)
2565
if (p->type == bfd_indirect_link_order
2566
&& (bfd_get_flavour (p->u.indirect.section->owner)
2567
== bfd_target_coff_flavour))
2569
sub = p->u.indirect.section->owner;
2570
#ifdef POWERPC_LE_PE
2571
if (! sub->output_has_begun && !ppc_do_last(sub))
2573
if (! sub->output_has_begun)
2576
if (! _bfd_coff_link_input_bfd (&finfo, sub))
2578
sub->output_has_begun = true;
2581
else if (p->type == bfd_section_reloc_link_order
2582
|| p->type == bfd_symbol_reloc_link_order)
2584
if (! _bfd_coff_reloc_link_order (abfd, &finfo, o, p))
2589
if (! _bfd_default_link_order (abfd, info, o, p))
2595
#ifdef POWERPC_LE_PE
2597
bfd* last_one = ppc_get_last();
2600
if (! _bfd_coff_link_input_bfd (&finfo, last_one))
2603
last_one->output_has_begun = true;
2607
/* Free up the buffers used by _bfd_coff_link_input_bfd. */
2609
coff_debug_merge_hash_table_free (&finfo.debug_merge);
2610
debug_merge_allocated = false;
2612
if (finfo.internal_syms != NULL)
2614
free (finfo.internal_syms);
2615
finfo.internal_syms = NULL;
2617
if (finfo.sec_ptrs != NULL)
2619
free (finfo.sec_ptrs);
2620
finfo.sec_ptrs = NULL;
2622
if (finfo.sym_indices != NULL)
2624
free (finfo.sym_indices);
2625
finfo.sym_indices = NULL;
2627
if (finfo.linenos != NULL)
2629
free (finfo.linenos);
2630
finfo.linenos = NULL;
2632
if (finfo.contents != NULL)
2634
free (finfo.contents);
2635
finfo.contents = NULL;
2637
if (finfo.external_relocs != NULL)
2639
free (finfo.external_relocs);
2640
finfo.external_relocs = NULL;
2642
if (finfo.internal_relocs != NULL)
2644
free (finfo.internal_relocs);
2645
finfo.internal_relocs = NULL;
2648
/* The value of the last C_FILE symbol is supposed to be the symbol
2649
index of the first external symbol. Write it out again if
2651
if (finfo.last_file_index != -1
2652
&& (unsigned int) finfo.last_file.n_value != obj_raw_syment_count (abfd))
2656
finfo.last_file.n_value = obj_raw_syment_count (abfd);
2657
bfd_coff_swap_sym_out (abfd, (PTR) &finfo.last_file,
2658
(PTR) finfo.outsyms);
2659
pos = obj_sym_filepos (abfd) + finfo.last_file_index * symesz;
2660
if (bfd_seek (abfd, pos, SEEK_SET) != 0
2661
|| bfd_bwrite (finfo.outsyms, symesz, abfd) != symesz)
2665
/* Write out the global symbols. */
2666
finfo.failed = false;
2667
coff_link_hash_traverse (coff_hash_table (info), _bfd_coff_write_global_sym,
2672
/* The outsyms buffer is used by _bfd_coff_write_global_sym. */
2673
if (finfo.outsyms != NULL)
2675
free (finfo.outsyms);
2676
finfo.outsyms = NULL;
2679
if (info->relocateable)
2681
/* Now that we have written out all the global symbols, we know
2682
the symbol indices to use for relocs against them, and we can
2683
finally write out the relocs. */
2684
amt = max_output_reloc_count * relsz;
2685
external_relocs = (bfd_byte *) bfd_malloc (amt);
2686
if (external_relocs == NULL)
2689
for (o = abfd->sections; o != NULL; o = o->next)
2691
struct internal_reloc *irel;
2692
struct internal_reloc *irelend;
2693
struct coff_link_hash_entry **rel_hash;
2696
if (o->reloc_count == 0)
2699
irel = finfo.section_info[o->target_index].relocs;
2700
irelend = irel + o->reloc_count;
2701
rel_hash = finfo.section_info[o->target_index].rel_hashes;
2702
erel = external_relocs;
2703
for (; irel < irelend; irel++, rel_hash++, erel += relsz)
2705
if (*rel_hash != NULL)
2707
BFD_ASSERT ((*rel_hash)->indx >= 0);
2708
irel->r_symndx = (*rel_hash)->indx;
2710
bfd_coff_swap_reloc_out (abfd, (PTR) irel, (PTR) erel);
2713
amt = relsz * o->reloc_count;
2714
if (bfd_seek (abfd, o->rel_filepos, SEEK_SET) != 0
2715
|| bfd_bwrite ((PTR) external_relocs, amt, abfd) != amt)
2719
free (external_relocs);
2720
external_relocs = NULL;
2723
/* Free up the section information. */
2724
if (finfo.section_info != NULL)
2728
for (i = 0; i < abfd->section_count; i++)
2730
if (finfo.section_info[i].relocs != NULL)
2731
free (finfo.section_info[i].relocs);
2732
if (finfo.section_info[i].rel_hashes != NULL)
2733
free (finfo.section_info[i].rel_hashes);
2735
free (finfo.section_info);
2736
finfo.section_info = NULL;
2739
/* If we have optimized stabs strings, output them. */
2740
if (coff_hash_table (info)->stab_info != NULL)
2742
if (! _bfd_write_stab_strings (abfd, &coff_hash_table (info)->stab_info))
2746
/* Write out the string table. */
2747
if (obj_raw_syment_count (abfd) != 0)
2751
pos = obj_sym_filepos (abfd) + obj_raw_syment_count (abfd) * symesz;
2752
if (bfd_seek (abfd, pos, SEEK_SET) != 0)
2755
#if STRING_SIZE_SIZE == 4
2757
_bfd_stringtab_size (finfo.strtab) + STRING_SIZE_SIZE,
2760
#error Change H_PUT_32 above
2763
if (bfd_bwrite (strbuf, (bfd_size_type) STRING_SIZE_SIZE, abfd)
2764
!= STRING_SIZE_SIZE)
2767
if (! _bfd_stringtab_emit (abfd, finfo.strtab))
2771
_bfd_stringtab_free (finfo.strtab);
2773
/* Setting bfd_get_symcount to 0 will cause write_object_contents to
2774
not try to write out the symbols. */
2775
bfd_get_symcount (abfd) = 0;
2780
if (debug_merge_allocated)
2781
coff_debug_merge_hash_table_free (&finfo.debug_merge);
2782
if (finfo.strtab != NULL)
2783
_bfd_stringtab_free (finfo.strtab);
2784
if (finfo.section_info != NULL)
2788
for (i = 0; i < abfd->section_count; i++)
2790
if (finfo.section_info[i].relocs != NULL)
2791
free (finfo.section_info[i].relocs);
2792
if (finfo.section_info[i].rel_hashes != NULL)
2793
free (finfo.section_info[i].rel_hashes);
2795
free (finfo.section_info);
2797
if (finfo.internal_syms != NULL)
2798
free (finfo.internal_syms);
2799
if (finfo.sec_ptrs != NULL)
2800
free (finfo.sec_ptrs);
2801
if (finfo.sym_indices != NULL)
2802
free (finfo.sym_indices);
2803
if (finfo.outsyms != NULL)
2804
free (finfo.outsyms);
2805
if (finfo.linenos != NULL)
2806
free (finfo.linenos);
2807
if (finfo.contents != NULL)
2808
free (finfo.contents);
2809
if (finfo.external_relocs != NULL)
2810
free (finfo.external_relocs);
2811
if (finfo.internal_relocs != NULL)
2812
free (finfo.internal_relocs);
2813
if (external_relocs != NULL)
2814
free (external_relocs);
2819
/* Forward declaration for use by alternative_target field. */
2820
#ifdef TARGET_BIG_SYM
2821
extern const bfd_target TARGET_BIG_SYM;
2824
/* The transfer vectors that lead the outside world to all of the above. */
2826
#ifdef TARGET_LITTLE_SYM
2827
const bfd_target TARGET_LITTLE_SYM =
2829
TARGET_LITTLE_NAME, /* name or coff-arm-little */
2830
bfd_target_coff_flavour,
2831
BFD_ENDIAN_LITTLE, /* data byte order is little */
2832
BFD_ENDIAN_LITTLE, /* header byte order is little */
2834
(HAS_RELOC | EXEC_P | /* FIXME: object flags */
2835
HAS_LINENO | HAS_DEBUG |
2836
HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED),
2838
#ifndef COFF_WITH_PE
2839
(SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* section flags */
2841
(SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC /* section flags */
2842
| SEC_LINK_ONCE | SEC_LINK_DUPLICATES),
2845
0, /* leading char */
2846
'/', /* ar_pad_char */
2847
15, /* ar_max_namelen??? FIXMEmgo */
2849
bfd_getl64, bfd_getl_signed_64, bfd_putl64,
2850
bfd_getl32, bfd_getl_signed_32, bfd_putl32,
2851
bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* data */
2853
bfd_getl64, bfd_getl_signed_64, bfd_putl64,
2854
bfd_getl32, bfd_getl_signed_32, bfd_putl32,
2855
bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* hdrs */
2857
{_bfd_dummy_target, coff_object_p, /* bfd_check_format */
2858
bfd_generic_archive_p, /* _bfd_dummy_target */ coff_object_p },
2859
{bfd_false, coff_mkobject, _bfd_generic_mkarchive, /* bfd_set_format */
2861
{bfd_false, coff_write_object_contents, /* bfd_write_contents */
2862
_bfd_write_archive_contents, bfd_false},
2864
BFD_JUMP_TABLE_GENERIC (coff),
2865
BFD_JUMP_TABLE_COPY (coff),
2866
BFD_JUMP_TABLE_CORE (_bfd_nocore),
2867
BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff),
2868
BFD_JUMP_TABLE_SYMBOLS (coff),
2869
BFD_JUMP_TABLE_RELOCS (coff),
2870
BFD_JUMP_TABLE_WRITE (coff),
2871
BFD_JUMP_TABLE_LINK (coff),
2872
BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
2874
/* Alternative_target. */
2875
#ifdef TARGET_BIG_SYM
2885
#ifdef TARGET_BIG_SYM
2886
const bfd_target TARGET_BIG_SYM =
2889
bfd_target_coff_flavour,
2890
BFD_ENDIAN_BIG, /* data byte order is big */
2891
BFD_ENDIAN_BIG, /* header byte order is big */
2893
(HAS_RELOC | EXEC_P | /* FIXME: object flags */
2894
HAS_LINENO | HAS_DEBUG |
2895
HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED),
2897
#ifndef COFF_WITH_PE
2898
(SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* section flags */
2900
(SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC /* section flags */
2901
| SEC_LINK_ONCE | SEC_LINK_DUPLICATES),
2904
0, /* leading char */
2905
'/', /* ar_pad_char */
2906
15, /* ar_max_namelen??? FIXMEmgo */
2908
bfd_getb64, bfd_getb_signed_64, bfd_putb64,
2909
bfd_getb32, bfd_getb_signed_32, bfd_putb32,
2910
bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* data */
2912
bfd_getb64, bfd_getb_signed_64, bfd_putb64,
2913
bfd_getb32, bfd_getb_signed_32, bfd_putb32,
2914
bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* hdrs */
2916
{_bfd_dummy_target, coff_object_p, /* bfd_check_format */
2917
bfd_generic_archive_p, /* _bfd_dummy_target */ coff_object_p },
2918
{bfd_false, coff_mkobject, _bfd_generic_mkarchive, /* bfd_set_format */
2920
{bfd_false, coff_write_object_contents, /* bfd_write_contents */
2921
_bfd_write_archive_contents, bfd_false},
2923
BFD_JUMP_TABLE_GENERIC (coff),
2924
BFD_JUMP_TABLE_COPY (coff),
2925
BFD_JUMP_TABLE_CORE (_bfd_nocore),
2926
BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff),
2927
BFD_JUMP_TABLE_SYMBOLS (coff),
2928
BFD_JUMP_TABLE_RELOCS (coff),
2929
BFD_JUMP_TABLE_WRITE (coff),
2930
BFD_JUMP_TABLE_LINK (coff),
2931
BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
2933
/* Alternative_target. */
2934
#ifdef TARGET_LITTLE_SYM
2935
& TARGET_LITTLE_SYM,
added
removed
binutils/bfd/coff-ppc.c
