1 /* BFD back-end for PowerPC Microsoft Portable Executable files.
2 Copyright (C) 1990-2014 Free Software Foundation, Inc.
3
4 Original version pieced together by Kim Knuttila (krk@cygnus.com)
5
6 There is nothing new under the sun. This file draws a lot on other
7 coff files, in particular, those for the rs/6000, alpha, mips, and
8 intel backends, and the PE work for the arm.
9
10 This file is part of BFD, the Binary File Descriptor library.
11
12 This program is free software; you can redistribute it and/or modify
13 it under the terms of the GNU General Public License as published by
14 the Free Software Foundation; either version 3 of the License, or
15 (at your option) any later version.
16
17 This program is distributed in the hope that it will be useful,
18 but WITHOUT ANY WARRANTY; without even the implied warranty of
19 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 GNU General Public License for more details.
21
22 You should have received a copy of the GNU General Public License
23 along with this program; if not, write to the Free Software
24 Foundation, 51 Franklin Street - Fifth Floor,
25 Boston, MA 02110-1301, USA. */
26
27 /* Current State:
28 - objdump works
29 - relocs generated by gas
30 - ld will link files, but they do not run.
31 - dlltool will not produce correct output in some .reloc cases, and will
32 not produce the right glue code for dll function calls. */
33
34 #include "sysdep.h"
35 #include "bfd.h"
36 #include "libbfd.h"
37
38 #include "coff/powerpc.h"
39 #include "coff/internal.h"
40
41 #include "coff/pe.h"
42
43 #ifdef BADMAG
44 #undef BADMAG
45 #endif
46
47 #define BADMAG(x) PPCBADMAG(x)
48
49 #include "libcoff.h"
50
51 /* This file is compiled more than once, but we only compile the
52 final_link routine once. */
53 extern bfd_boolean ppc_bfd_coff_final_link (bfd *, struct bfd_link_info *);
54 extern void dump_toc (void *);
55
56 /* The toc is a set of bfd_vma fields. We use the fact that valid
57 addresses are even (i.e. the bit representing "1" is off) to allow
58 us to encode a little extra information in the field
59 - Unallocated addresses are initialized to 1.
60 - Allocated addresses are even numbers.
61 The first time we actually write a reference to the toc in the bfd,
62 we want to record that fact in a fixup file (if it is asked for), so
63 we keep track of whether or not an address has been written by marking
64 the low order bit with a "1" upon writing. */
65
66 #define SET_UNALLOCATED(x) ((x) = 1)
67 #define IS_UNALLOCATED(x) ((x) == 1)
68
69 #define IS_WRITTEN(x) ((x) & 1)
70 #define MARK_AS_WRITTEN(x) ((x) |= 1)
71 #define MAKE_ADDR_AGAIN(x) ((x) &= ~1)
72
73 /* Turn on this check if you suspect something amiss in the hash tables. */
74 #ifdef DEBUG_HASH
75
76 /* Need a 7 char string for an eye catcher. */
77 #define EYE "krkjunk"
78
79 #define HASH_CHECK_DCL char eye_catcher[8];
80 #define HASH_CHECK_INIT(ret) strcpy(ret->eye_catcher, EYE)
81 #define HASH_CHECK(addr) \
82 if (strcmp(addr->eye_catcher, EYE) != 0) \
83 { \
84 fprintf (stderr,\
85 _("File %s, line %d, Hash check failure, bad eye %8s\n"), \
86 __FILE__, __LINE__, addr->eye_catcher); \
87 abort (); \
88 }
89
90 #else
91
92 #define HASH_CHECK_DCL
93 #define HASH_CHECK_INIT(ret)
94 #define HASH_CHECK(addr)
95
96 #endif
97
98 /* In order not to add an int to every hash table item for every coff
99 linker, we define our own hash table, derived from the coff one. */
100
101 /* PE linker hash table entries. */
102
103 struct ppc_coff_link_hash_entry
104 {
105 struct coff_link_hash_entry root; /* First entry, as required. */
106
107 /* As we wonder around the relocs, we'll keep the assigned toc_offset
108 here. */
109 bfd_vma toc_offset; /* Our addition, as required. */
110 int symbol_is_glue;
111 unsigned long int glue_insn;
112
113 HASH_CHECK_DCL
114 };
115
116 /* PE linker hash table. */
117
118 struct ppc_coff_link_hash_table
119 {
120 struct coff_link_hash_table root; /* First entry, as required. */
121 };
122
123 /* Routine to create an entry in the link hash table. */
124
125 static struct bfd_hash_entry *
ppc_coff_link_hash_newfunc(struct bfd_hash_entry * entry,struct bfd_hash_table * table,const char * string)126 ppc_coff_link_hash_newfunc (struct bfd_hash_entry * entry,
127 struct bfd_hash_table * table,
128 const char * string)
129 {
130 struct ppc_coff_link_hash_entry *ret =
131 (struct ppc_coff_link_hash_entry *) entry;
132
133 /* Allocate the structure if it has not already been allocated by a
134 subclass. */
135 if (ret == (struct ppc_coff_link_hash_entry *) NULL)
136 ret = (struct ppc_coff_link_hash_entry *)
137 bfd_hash_allocate (table,
138 sizeof (struct ppc_coff_link_hash_entry));
139
140 if (ret == (struct ppc_coff_link_hash_entry *) NULL)
141 return NULL;
142
143 /* Call the allocation method of the superclass. */
144 ret = ((struct ppc_coff_link_hash_entry *)
145 _bfd_coff_link_hash_newfunc ((struct bfd_hash_entry *) ret,
146 table, string));
147
148 if (ret)
149 {
150 /* Initialize the local fields. */
151 SET_UNALLOCATED (ret->toc_offset);
152 ret->symbol_is_glue = 0;
153 ret->glue_insn = 0;
154
155 HASH_CHECK_INIT (ret);
156 }
157
158 return (struct bfd_hash_entry *) ret;
159 }
160
161 /* Initialize a PE linker hash table. */
162
163 static bfd_boolean
ppc_coff_link_hash_table_init(struct ppc_coff_link_hash_table * table,bfd * abfd,struct bfd_hash_entry * (* newfunc)(struct bfd_hash_entry *,struct bfd_hash_table *,const char *),unsigned int entsize)164 ppc_coff_link_hash_table_init (struct ppc_coff_link_hash_table *table,
165 bfd *abfd,
166 struct bfd_hash_entry *(*newfunc)
167 (struct bfd_hash_entry *,
168 struct bfd_hash_table *,
169 const char *),
170 unsigned int entsize)
171 {
172 return _bfd_coff_link_hash_table_init (&table->root, abfd, newfunc, entsize);
173 }
174
175 /* Create a PE linker hash table. */
176
177 static struct bfd_link_hash_table *
ppc_coff_link_hash_table_create(bfd * abfd)178 ppc_coff_link_hash_table_create (bfd *abfd)
179 {
180 struct ppc_coff_link_hash_table *ret;
181 bfd_size_type amt = sizeof (struct ppc_coff_link_hash_table);
182
183 ret = (struct ppc_coff_link_hash_table *) bfd_malloc (amt);
184 if (ret == NULL)
185 return NULL;
186 if (!ppc_coff_link_hash_table_init (ret, abfd,
187 ppc_coff_link_hash_newfunc,
188 sizeof (struct ppc_coff_link_hash_entry)))
189 {
190 free (ret);
191 return (struct bfd_link_hash_table *) NULL;
192 }
193 return &ret->root.root;
194 }
195
196 /* Now, tailor coffcode.h to use our hash stuff. */
197
198 #define coff_bfd_link_hash_table_create ppc_coff_link_hash_table_create
199
200 /* The nt loader points the toc register to &toc + 32768, in order to
201 use the complete range of a 16-bit displacement. We have to adjust
202 for this when we fix up loads displaced off the toc reg. */
203 #define TOC_LOAD_ADJUSTMENT (-32768)
204 #define TOC_SECTION_NAME ".private.toc"
205
206 /* The main body of code is in coffcode.h. */
207
208 #define COFF_DEFAULT_SECTION_ALIGNMENT_POWER (3)
209
210 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value
211 from smaller values. Start with zero, widen, *then* decrement. */
212 #define MINUS_ONE (((bfd_vma)0) - 1)
213
214 /* These should definitely go in a header file somewhere... */
215
216 /* NOP */
217 #define IMAGE_REL_PPC_ABSOLUTE 0x0000
218
219 /* 64-bit address */
220 #define IMAGE_REL_PPC_ADDR64 0x0001
221
222 /* 32-bit address */
223 #define IMAGE_REL_PPC_ADDR32 0x0002
224
225 /* 26-bit address, shifted left 2 (branch absolute) */
226 #define IMAGE_REL_PPC_ADDR24 0x0003
227
228 /* 16-bit address */
229 #define IMAGE_REL_PPC_ADDR16 0x0004
230
231 /* 16-bit address, shifted left 2 (load doubleword) */
232 #define IMAGE_REL_PPC_ADDR14 0x0005
233
234 /* 26-bit PC-relative offset, shifted left 2 (branch relative) */
235 #define IMAGE_REL_PPC_REL24 0x0006
236
237 /* 16-bit PC-relative offset, shifted left 2 (br cond relative) */
238 #define IMAGE_REL_PPC_REL14 0x0007
239
240 /* 16-bit offset from TOC base */
241 #define IMAGE_REL_PPC_TOCREL16 0x0008
242
243 /* 16-bit offset from TOC base, shifted left 2 (load doubleword) */
244 #define IMAGE_REL_PPC_TOCREL14 0x0009
245
246 /* 32-bit addr w/o image base */
247 #define IMAGE_REL_PPC_ADDR32NB 0x000A
248
249 /* va of containing section (as in an image sectionhdr) */
250 #define IMAGE_REL_PPC_SECREL 0x000B
251
252 /* sectionheader number */
253 #define IMAGE_REL_PPC_SECTION 0x000C
254
255 /* substitute TOC restore instruction iff symbol is glue code */
256 #define IMAGE_REL_PPC_IFGLUE 0x000D
257
258 /* symbol is glue code; virtual address is TOC restore instruction */
259 #define IMAGE_REL_PPC_IMGLUE 0x000E
260
261 /* va of containing section (limited to 16 bits) */
262 #define IMAGE_REL_PPC_SECREL16 0x000F
263
264 /* Stuff to handle immediate data when the number of bits in the
265 data is greater than the number of bits in the immediate field
266 We need to do (usually) 32 bit arithmetic on 16 bit chunks. */
267 #define IMAGE_REL_PPC_REFHI 0x0010
268 #define IMAGE_REL_PPC_REFLO 0x0011
269 #define IMAGE_REL_PPC_PAIR 0x0012
270
271 /* This is essentially the same as tocrel16, with TOCDEFN assumed. */
272 #define IMAGE_REL_PPC_TOCREL16_DEFN 0x0013
273
274 /* Flag bits in IMAGE_RELOCATION.TYPE. */
275
276 /* Subtract reloc value rather than adding it. */
277 #define IMAGE_REL_PPC_NEG 0x0100
278
279 /* Fix branch prediction bit to predict branch taken. */
280 #define IMAGE_REL_PPC_BRTAKEN 0x0200
281
282 /* Fix branch prediction bit to predict branch not taken. */
283 #define IMAGE_REL_PPC_BRNTAKEN 0x0400
284
285 /* TOC slot defined in file (or, data in toc). */
286 #define IMAGE_REL_PPC_TOCDEFN 0x0800
287
288 /* Masks to isolate above values in IMAGE_RELOCATION.Type. */
289 #define IMAGE_REL_PPC_TYPEMASK 0x00FF
290 #define IMAGE_REL_PPC_FLAGMASK 0x0F00
291
292 #define EXTRACT_TYPE(x) ((x) & IMAGE_REL_PPC_TYPEMASK)
293 #define EXTRACT_FLAGS(x) ((x) & IMAGE_REL_PPC_FLAGMASK)
294 #define EXTRACT_JUNK(x) \
295 ((x) & ~(IMAGE_REL_PPC_TYPEMASK | IMAGE_REL_PPC_FLAGMASK))
296
297 /* Static helper functions to make relocation work. */
298 /* (Work In Progress) */
299
300 static bfd_reloc_status_type ppc_refhi_reloc
301 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
302 static bfd_reloc_status_type ppc_pair_reloc
303 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
304 static bfd_reloc_status_type ppc_toc16_reloc
305 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
306 static bfd_reloc_status_type ppc_section_reloc
307 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
308 static bfd_reloc_status_type ppc_secrel_reloc
309 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
310 static bfd_reloc_status_type ppc_imglue_reloc
311 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
312
313 /* FIXME: It'll take a while to get through all of these. I only need a few to
314 get us started, so those I'll make sure work. Those marked FIXME are either
315 completely unverified or have a specific unknown marked in the comment. */
316
317 /* Relocation entries for Windows/NT on PowerPC.
318
319 From the document "" we find the following listed as used relocs:
320
321 ABSOLUTE : The noop
322 ADDR[64|32|16] : fields that hold addresses in data fields or the
323 16 bit displacement field on a load/store.
324 ADDR[24|14] : fields that hold addresses in branch and cond
325 branches. These represent [26|16] bit addresses.
326 The low order 2 bits are preserved.
327 REL[24|14] : branches relative to the Instruction Address
328 register. These represent [26|16] bit addresses,
329 as before. The instruction field will be zero, and
330 the address of the SYM will be inserted at link time.
331 TOCREL16 : 16 bit displacement field referring to a slot in
332 toc.
333 TOCREL14 : 16 bit displacement field, similar to REL14 or ADDR14.
334 ADDR32NB : 32 bit address relative to the virtual origin.
335 (On the alpha, this is always a linker generated thunk)
336 (i.e. 32bit addr relative to the image base)
337 SECREL : The value is relative to the start of the section
338 containing the symbol.
339 SECTION : access to the header containing the item. Supports the
340 codeview debugger.
341
342 In particular, note that the document does not indicate that the
343 relocations listed in the header file are used. */
344
345
346 static reloc_howto_type ppc_coff_howto_table[] =
347 {
348 /* IMAGE_REL_PPC_ABSOLUTE 0x0000 NOP */
349 /* Unused: */
350 HOWTO (IMAGE_REL_PPC_ABSOLUTE, /* type */
351 0, /* rightshift */
352 0, /* size (0 = byte, 1 = short, 2 = long) */
353 0, /* bitsize */
354 FALSE, /* pc_relative */
355 0, /* bitpos */
356 complain_overflow_dont, /* dont complain_on_overflow */
357 0, /* special_function */
358 "ABSOLUTE", /* name */
359 FALSE, /* partial_inplace */
360 0x00, /* src_mask */
361 0x00, /* dst_mask */
362 FALSE), /* pcrel_offset */
363
364 /* IMAGE_REL_PPC_ADDR64 0x0001 64-bit address */
365 /* Unused: */
366 HOWTO(IMAGE_REL_PPC_ADDR64, /* type */
367 0, /* rightshift */
368 3, /* size (0 = byte, 1 = short, 2 = long) */
369 64, /* bitsize */
370 FALSE, /* pc_relative */
371 0, /* bitpos */
372 complain_overflow_bitfield, /* complain_on_overflow */
373 0, /* special_function */
374 "ADDR64", /* name */
375 TRUE, /* partial_inplace */
376 MINUS_ONE, /* src_mask */
377 MINUS_ONE, /* dst_mask */
378 FALSE), /* pcrel_offset */
379
380 /* IMAGE_REL_PPC_ADDR32 0x0002 32-bit address */
381 /* Used: */
382 HOWTO (IMAGE_REL_PPC_ADDR32, /* type */
383 0, /* rightshift */
384 2, /* size (0 = byte, 1 = short, 2 = long) */
385 32, /* bitsize */
386 FALSE, /* pc_relative */
387 0, /* bitpos */
388 complain_overflow_bitfield, /* complain_on_overflow */
389 0, /* special_function */
390 "ADDR32", /* name */
391 TRUE, /* partial_inplace */
392 0xffffffff, /* src_mask */
393 0xffffffff, /* dst_mask */
394 FALSE), /* pcrel_offset */
395
396 /* IMAGE_REL_PPC_ADDR24 0x0003 26-bit address, shifted left 2 (branch absolute) */
397 /* the LI field is in bit 6 through bit 29 is 24 bits, + 2 for the shift */
398 /* Of course, That's the IBM approved bit numbering, which is not what */
399 /* anyone else uses.... The li field is in bit 2 thru 25 */
400 /* Used: */
401 HOWTO (IMAGE_REL_PPC_ADDR24, /* type */
402 0, /* rightshift */
403 2, /* size (0 = byte, 1 = short, 2 = long) */
404 26, /* bitsize */
405 FALSE, /* pc_relative */
406 0, /* bitpos */
407 complain_overflow_bitfield, /* complain_on_overflow */
408 0, /* special_function */
409 "ADDR24", /* name */
410 TRUE, /* partial_inplace */
411 0x07fffffc, /* src_mask */
412 0x07fffffc, /* dst_mask */
413 FALSE), /* pcrel_offset */
414
415 /* IMAGE_REL_PPC_ADDR16 0x0004 16-bit address */
416 /* Used: */
417 HOWTO (IMAGE_REL_PPC_ADDR16, /* type */
418 0, /* rightshift */
419 1, /* size (0 = byte, 1 = short, 2 = long) */
420 16, /* bitsize */
421 FALSE, /* pc_relative */
422 0, /* bitpos */
423 complain_overflow_signed, /* complain_on_overflow */
424 0, /* special_function */
425 "ADDR16", /* name */
426 TRUE, /* partial_inplace */
427 0xffff, /* src_mask */
428 0xffff, /* dst_mask */
429 FALSE), /* pcrel_offset */
430
431 /* IMAGE_REL_PPC_ADDR14 0x0005 */
432 /* 16-bit address, shifted left 2 (load doubleword) */
433 /* FIXME: the mask is likely wrong, and the bit position may be as well */
434 /* Unused: */
435 HOWTO (IMAGE_REL_PPC_ADDR14, /* type */
436 1, /* rightshift */
437 1, /* size (0 = byte, 1 = short, 2 = long) */
438 16, /* bitsize */
439 FALSE, /* pc_relative */
440 0, /* bitpos */
441 complain_overflow_signed, /* complain_on_overflow */
442 0, /* special_function */
443 "ADDR16", /* name */
444 TRUE, /* partial_inplace */
445 0xffff, /* src_mask */
446 0xffff, /* dst_mask */
447 FALSE), /* pcrel_offset */
448
449 /* IMAGE_REL_PPC_REL24 0x0006 */
450 /* 26-bit PC-relative offset, shifted left 2 (branch relative) */
451 /* Used: */
452 HOWTO (IMAGE_REL_PPC_REL24, /* type */
453 0, /* rightshift */
454 2, /* size (0 = byte, 1 = short, 2 = long) */
455 26, /* bitsize */
456 TRUE, /* pc_relative */
457 0, /* bitpos */
458 complain_overflow_signed, /* complain_on_overflow */
459 0, /* special_function */
460 "REL24", /* name */
461 TRUE, /* partial_inplace */
462 0x3fffffc, /* src_mask */
463 0x3fffffc, /* dst_mask */
464 FALSE), /* pcrel_offset */
465
466 /* IMAGE_REL_PPC_REL14 0x0007 */
467 /* 16-bit PC-relative offset, shifted left 2 (br cond relative) */
468 /* FIXME: the mask is likely wrong, and the bit position may be as well */
469 /* FIXME: how does it know how far to shift? */
470 /* Unused: */
471 HOWTO (IMAGE_REL_PPC_ADDR14, /* type */
472 1, /* rightshift */
473 1, /* size (0 = byte, 1 = short, 2 = long) */
474 16, /* bitsize */
475 FALSE, /* pc_relative */
476 0, /* bitpos */
477 complain_overflow_signed, /* complain_on_overflow */
478 0, /* special_function */
479 "ADDR16", /* name */
480 TRUE, /* partial_inplace */
481 0xffff, /* src_mask */
482 0xffff, /* dst_mask */
483 TRUE), /* pcrel_offset */
484
485 /* IMAGE_REL_PPC_TOCREL16 0x0008 */
486 /* 16-bit offset from TOC base */
487 /* Used: */
488 HOWTO (IMAGE_REL_PPC_TOCREL16,/* type */
489 0, /* rightshift */
490 1, /* size (0 = byte, 1 = short, 2 = long) */
491 16, /* bitsize */
492 FALSE, /* pc_relative */
493 0, /* bitpos */
494 complain_overflow_dont, /* complain_on_overflow */
495 ppc_toc16_reloc, /* special_function */
496 "TOCREL16", /* name */
497 FALSE, /* partial_inplace */
498 0xffff, /* src_mask */
499 0xffff, /* dst_mask */
500 FALSE), /* pcrel_offset */
501
502 /* IMAGE_REL_PPC_TOCREL14 0x0009 */
503 /* 16-bit offset from TOC base, shifted left 2 (load doubleword) */
504 /* Unused: */
505 HOWTO (IMAGE_REL_PPC_TOCREL14,/* type */
506 1, /* rightshift */
507 1, /* size (0 = byte, 1 = short, 2 = long) */
508 16, /* bitsize */
509 FALSE, /* pc_relative */
510 0, /* bitpos */
511 complain_overflow_signed, /* complain_on_overflow */
512 0, /* special_function */
513 "TOCREL14", /* name */
514 FALSE, /* partial_inplace */
515 0xffff, /* src_mask */
516 0xffff, /* dst_mask */
517 FALSE), /* pcrel_offset */
518
519 /* IMAGE_REL_PPC_ADDR32NB 0x000A */
520 /* 32-bit addr w/ image base */
521 /* Unused: */
522 HOWTO (IMAGE_REL_PPC_ADDR32NB,/* type */
523 0, /* rightshift */
524 2, /* size (0 = byte, 1 = short, 2 = long) */
525 32, /* bitsize */
526 FALSE, /* pc_relative */
527 0, /* bitpos */
528 complain_overflow_signed, /* complain_on_overflow */
529 0, /* special_function */
530 "ADDR32NB", /* name */
531 TRUE, /* partial_inplace */
532 0xffffffff, /* src_mask */
533 0xffffffff, /* dst_mask */
534 FALSE), /* pcrel_offset */
535
536 /* IMAGE_REL_PPC_SECREL 0x000B */
537 /* va of containing section (as in an image sectionhdr) */
538 /* Unused: */
539 HOWTO (IMAGE_REL_PPC_SECREL,/* type */
540 0, /* rightshift */
541 2, /* size (0 = byte, 1 = short, 2 = long) */
542 32, /* bitsize */
543 FALSE, /* pc_relative */
544 0, /* bitpos */
545 complain_overflow_signed, /* complain_on_overflow */
546 ppc_secrel_reloc, /* special_function */
547 "SECREL", /* name */
548 TRUE, /* partial_inplace */
549 0xffffffff, /* src_mask */
550 0xffffffff, /* dst_mask */
551 TRUE), /* pcrel_offset */
552
553 /* IMAGE_REL_PPC_SECTION 0x000C */
554 /* sectionheader number */
555 /* Unused: */
556 HOWTO (IMAGE_REL_PPC_SECTION,/* type */
557 0, /* rightshift */
558 2, /* size (0 = byte, 1 = short, 2 = long) */
559 32, /* bitsize */
560 FALSE, /* pc_relative */
561 0, /* bitpos */
562 complain_overflow_signed, /* complain_on_overflow */
563 ppc_section_reloc, /* special_function */
564 "SECTION", /* name */
565 TRUE, /* partial_inplace */
566 0xffffffff, /* src_mask */
567 0xffffffff, /* dst_mask */
568 TRUE), /* pcrel_offset */
569
570 /* IMAGE_REL_PPC_IFGLUE 0x000D */
571 /* substitute TOC restore instruction iff symbol is glue code */
572 /* Used: */
573 HOWTO (IMAGE_REL_PPC_IFGLUE,/* type */
574 0, /* rightshift */
575 2, /* size (0 = byte, 1 = short, 2 = long) */
576 32, /* bitsize */
577 FALSE, /* pc_relative */
578 0, /* bitpos */
579 complain_overflow_signed, /* complain_on_overflow */
580 0, /* special_function */
581 "IFGLUE", /* name */
582 TRUE, /* partial_inplace */
583 0xffffffff, /* src_mask */
584 0xffffffff, /* dst_mask */
585 FALSE), /* pcrel_offset */
586
587 /* IMAGE_REL_PPC_IMGLUE 0x000E */
588 /* symbol is glue code; virtual address is TOC restore instruction */
589 /* Unused: */
590 HOWTO (IMAGE_REL_PPC_IMGLUE,/* type */
591 0, /* rightshift */
592 2, /* size (0 = byte, 1 = short, 2 = long) */
593 32, /* bitsize */
594 FALSE, /* pc_relative */
595 0, /* bitpos */
596 complain_overflow_dont, /* complain_on_overflow */
597 ppc_imglue_reloc, /* special_function */
598 "IMGLUE", /* name */
599 FALSE, /* partial_inplace */
600 0xffffffff, /* src_mask */
601 0xffffffff, /* dst_mask */
602 FALSE), /* pcrel_offset */
603
604 /* IMAGE_REL_PPC_SECREL16 0x000F */
605 /* va of containing section (limited to 16 bits) */
606 /* Unused: */
607 HOWTO (IMAGE_REL_PPC_SECREL16,/* type */
608 0, /* rightshift */
609 1, /* size (0 = byte, 1 = short, 2 = long) */
610 16, /* bitsize */
611 FALSE, /* pc_relative */
612 0, /* bitpos */
613 complain_overflow_signed, /* complain_on_overflow */
614 0, /* special_function */
615 "SECREL16", /* name */
616 TRUE, /* partial_inplace */
617 0xffff, /* src_mask */
618 0xffff, /* dst_mask */
619 TRUE), /* pcrel_offset */
620
621 /* IMAGE_REL_PPC_REFHI 0x0010 */
622 /* Unused: */
623 HOWTO (IMAGE_REL_PPC_REFHI, /* type */
624 0, /* rightshift */
625 1, /* size (0 = byte, 1 = short, 2 = long) */
626 16, /* bitsize */
627 FALSE, /* pc_relative */
628 0, /* bitpos */
629 complain_overflow_signed, /* complain_on_overflow */
630 ppc_refhi_reloc, /* special_function */
631 "REFHI", /* name */
632 TRUE, /* partial_inplace */
633 0xffffffff, /* src_mask */
634 0xffffffff, /* dst_mask */
635 FALSE), /* pcrel_offset */
636
637 /* IMAGE_REL_PPC_REFLO 0x0011 */
638 /* Unused: */
639 HOWTO (IMAGE_REL_PPC_REFLO, /* type */
640 0, /* rightshift */
641 1, /* size (0 = byte, 1 = short, 2 = long) */
642 16, /* bitsize */
643 FALSE, /* pc_relative */
644 0, /* bitpos */
645 complain_overflow_signed, /* complain_on_overflow */
646 ppc_refhi_reloc, /* special_function */
647 "REFLO", /* name */
648 TRUE, /* partial_inplace */
649 0xffffffff, /* src_mask */
650 0xffffffff, /* dst_mask */
651 FALSE), /* pcrel_offset */
652
653 /* IMAGE_REL_PPC_PAIR 0x0012 */
654 /* Unused: */
655 HOWTO (IMAGE_REL_PPC_PAIR, /* type */
656 0, /* rightshift */
657 1, /* size (0 = byte, 1 = short, 2 = long) */
658 16, /* bitsize */
659 FALSE, /* pc_relative */
660 0, /* bitpos */
661 complain_overflow_signed, /* complain_on_overflow */
662 ppc_pair_reloc, /* special_function */
663 "PAIR", /* name */
664 TRUE, /* partial_inplace */
665 0xffffffff, /* src_mask */
666 0xffffffff, /* dst_mask */
667 FALSE), /* pcrel_offset */
668
669 /* IMAGE_REL_PPC_TOCREL16_DEFN 0x0013 */
670 /* 16-bit offset from TOC base, without causing a definition */
671 /* Used: */
672 HOWTO ( (IMAGE_REL_PPC_TOCREL16 | IMAGE_REL_PPC_TOCDEFN), /* type */
673 0, /* rightshift */
674 1, /* size (0 = byte, 1 = short, 2 = long) */
675 16, /* bitsize */
676 FALSE, /* pc_relative */
677 0, /* bitpos */
678 complain_overflow_dont, /* complain_on_overflow */
679 0, /* special_function */
680 "TOCREL16, TOCDEFN", /* name */
681 FALSE, /* partial_inplace */
682 0xffff, /* src_mask */
683 0xffff, /* dst_mask */
684 FALSE), /* pcrel_offset */
685
686 };
687
688 /* Some really cheezy macros that can be turned on to test stderr :-) */
689
690 #ifdef DEBUG_RELOC
691 #define UN_IMPL(x) \
692 { \
693 static int i; \
694 if (i == 0) \
695 { \
696 i = 1; \
697 fprintf (stderr,_("Unimplemented Relocation -- %s\n"),x); \
698 } \
699 }
700
701 #define DUMP_RELOC(n,r) \
702 { \
703 fprintf (stderr,"%s sym %d, addr %d, addend %d\n", \
704 n, (*(r->sym_ptr_ptr))->name, \
705 r->address, r->addend); \
706 }
707
708 /* Given a reloc name, n, and a pointer to an internal_reloc,
709 dump out interesting information on the contents
710
711 #define n_name _n._n_name
712 #define n_zeroes _n._n_n._n_zeroes
713 #define n_offset _n._n_n._n_offset */
714
715 #define DUMP_RELOC2(n,r) \
716 { \
717 fprintf (stderr,"%s sym %d, r_vaddr %d %s\n", \
718 n, r->r_symndx, r->r_vaddr, \
719 (((r->r_type) & IMAGE_REL_PPC_TOCDEFN) == 0) \
720 ?" ":" TOCDEFN" ); \
721 }
722
723 #else
724 #define UN_IMPL(x)
725 #define DUMP_RELOC(n,r)
726 #define DUMP_RELOC2(n,r)
727 #endif
728
729 /* TOC construction and management routines. */
730
731 /* This file is compiled twice, and these variables are defined in one
732 of the compilations. FIXME: This is confusing and weird. Also,
733 BFD should not use global variables. */
734 extern bfd * bfd_of_toc_owner;
735 extern long int global_toc_size;
736 extern long int import_table_size;
737 extern long int first_thunk_address;
738 extern long int thunk_size;
739
740 enum toc_type
741 {
742 default_toc,
743 toc_32,
744 toc_64
745 };
746
747 enum ref_category
748 {
749 priv,
750 pub,
751 tocdata
752 };
753
754 struct list_ele
755 {
756 struct list_ele *next;
757 bfd_vma addr;
758 enum ref_category cat;
759 int offset;
760 const char *name;
761 };
762
763 extern struct list_ele *head;
764 extern struct list_ele *tail;
765
766 static void
record_toc(asection * toc_section,bfd_signed_vma our_toc_offset,enum ref_category cat,const char * name)767 record_toc (asection *toc_section,
768 bfd_signed_vma our_toc_offset,
769 enum ref_category cat,
770 const char *name)
771 {
772 /* Add this entry to our toc addr-offset-name list. */
773 bfd_size_type amt = sizeof (struct list_ele);
774 struct list_ele *t = (struct list_ele *) bfd_malloc (amt);
775
776 if (t == NULL)
777 abort ();
778 t->next = 0;
779 t->offset = our_toc_offset;
780 t->name = name;
781 t->cat = cat;
782 t->addr = toc_section->output_offset + our_toc_offset;
783
784 if (head == 0)
785 {
786 head = t;
787 tail = t;
788 }
789 else
790 {
791 tail->next = t;
792 tail = t;
793 }
794 }
795
796 #ifdef COFF_IMAGE_WITH_PE
797
798 /* Record a toc offset against a symbol. */
799 static bfd_boolean
ppc_record_toc_entry(bfd * abfd,struct bfd_link_info * info ATTRIBUTE_UNUSED,asection * sec ATTRIBUTE_UNUSED,int sym,enum toc_type toc_kind ATTRIBUTE_UNUSED)800 ppc_record_toc_entry (bfd *abfd,
801 struct bfd_link_info *info ATTRIBUTE_UNUSED,
802 asection *sec ATTRIBUTE_UNUSED,
803 int sym,
804 enum toc_type toc_kind ATTRIBUTE_UNUSED)
805 {
806 struct ppc_coff_link_hash_entry *h;
807 int *local_syms;
808
809 h = 0;
810
811 h = (struct ppc_coff_link_hash_entry *) (obj_coff_sym_hashes (abfd)[sym]);
812 if (h != 0)
813 {
814 HASH_CHECK(h);
815 }
816
817 if (h == 0)
818 {
819 local_syms = obj_coff_local_toc_table(abfd);
820
821 if (local_syms == 0)
822 {
823 unsigned int i;
824 bfd_size_type amt;
825
826 /* allocate a table */
827 amt = (bfd_size_type) obj_raw_syment_count (abfd) * sizeof (int);
828 local_syms = (int *) bfd_zalloc (abfd, amt);
829 if (local_syms == 0)
830 return FALSE;
831 obj_coff_local_toc_table (abfd) = local_syms;
832
833 for (i = 0; i < obj_raw_syment_count (abfd); ++i)
834 {
835 SET_UNALLOCATED (local_syms[i]);
836 }
837 }
838
839 if (IS_UNALLOCATED(local_syms[sym]))
840 {
841 local_syms[sym] = global_toc_size;
842 global_toc_size += 4;
843
844 /* The size must fit in a 16-bit displacement. */
845 if (global_toc_size > 65535)
846 {
847 (*_bfd_error_handler) (_("TOC overflow"));
848 bfd_set_error (bfd_error_file_too_big);
849 return FALSE;
850 }
851 }
852 }
853 else
854 {
855 /* Check to see if there's a toc slot allocated. If not, do it
856 here. It will be used in relocate_section. */
857 if (IS_UNALLOCATED(h->toc_offset))
858 {
859 h->toc_offset = global_toc_size;
860 global_toc_size += 4;
861
862 /* The size must fit in a 16-bit displacement. */
863 if (global_toc_size >= 65535)
864 {
865 (*_bfd_error_handler) (_("TOC overflow"));
866 bfd_set_error (bfd_error_file_too_big);
867 return FALSE;
868 }
869 }
870 }
871
872 return TRUE;
873 }
874
875 /* Record a toc offset against a symbol. */
876 static void
ppc_mark_symbol_as_glue(bfd * abfd,int sym,struct internal_reloc * rel)877 ppc_mark_symbol_as_glue (bfd *abfd,
878 int sym,
879 struct internal_reloc *rel)
880 {
881 struct ppc_coff_link_hash_entry *h;
882
883 h = (struct ppc_coff_link_hash_entry *) (obj_coff_sym_hashes (abfd)[sym]);
884
885 HASH_CHECK(h);
886
887 h->symbol_is_glue = 1;
888 h->glue_insn = bfd_get_32 (abfd, (bfd_byte *) &rel->r_vaddr);
889
890 return;
891 }
892
893 #endif /* COFF_IMAGE_WITH_PE */
894
895 /* Return TRUE if this relocation should
896 appear in the output .reloc section. */
897
898 static bfd_boolean
in_reloc_p(bfd * abfd ATTRIBUTE_UNUSED,reloc_howto_type * howto)899 in_reloc_p (bfd * abfd ATTRIBUTE_UNUSED,
900 reloc_howto_type *howto)
901 {
902 return
903 (! howto->pc_relative)
904 && (howto->type != IMAGE_REL_PPC_ADDR32NB)
905 && (howto->type != IMAGE_REL_PPC_TOCREL16)
906 && (howto->type != IMAGE_REL_PPC_IMGLUE)
907 && (howto->type != IMAGE_REL_PPC_IFGLUE)
908 && (howto->type != IMAGE_REL_PPC_SECREL)
909 && (howto->type != IMAGE_REL_PPC_SECTION)
910 && (howto->type != IMAGE_REL_PPC_SECREL16)
911 && (howto->type != IMAGE_REL_PPC_REFHI)
912 && (howto->type != IMAGE_REL_PPC_REFLO)
913 && (howto->type != IMAGE_REL_PPC_PAIR)
914 && (howto->type != IMAGE_REL_PPC_TOCREL16_DEFN) ;
915 }
916
917 static bfd_boolean
write_base_file_entry(bfd * obfd,struct bfd_link_info * info,bfd_vma addr)918 write_base_file_entry (bfd *obfd, struct bfd_link_info *info, bfd_vma addr)
919 {
920 if (coff_data (obfd)->pe)
921 addr -= pe_data (obfd)->pe_opthdr.ImageBase;
922 if (fwrite (&addr, sizeof (addr), 1, (FILE *) info->base_file) == 1)
923 return TRUE;
924
925 bfd_set_error (bfd_error_system_call);
926 return FALSE;
927 }
928
929 /* The reloc processing routine for the optimized COFF linker. */
930
931 static bfd_boolean
coff_ppc_relocate_section(bfd * output_bfd,struct bfd_link_info * info,bfd * input_bfd,asection * input_section,bfd_byte * contents,struct internal_reloc * relocs,struct internal_syment * syms,asection ** sections)932 coff_ppc_relocate_section (bfd *output_bfd,
933 struct bfd_link_info *info,
934 bfd *input_bfd,
935 asection *input_section,
936 bfd_byte *contents,
937 struct internal_reloc *relocs,
938 struct internal_syment *syms,
939 asection **sections)
940 {
941 struct internal_reloc *rel;
942 struct internal_reloc *relend;
943 asection *toc_section = 0;
944 bfd_vma relocation;
945 reloc_howto_type *howto = 0;
946
947 /* If we are performing a relocatable link, we don't need to do a
948 thing. The caller will take care of adjusting the reloc
949 addresses and symbol indices. */
950 if (info->relocatable)
951 return TRUE;
952
953 rel = relocs;
954 relend = rel + input_section->reloc_count;
955 for (; rel < relend; rel++)
956 {
957 long symndx;
958 struct ppc_coff_link_hash_entry *h;
959 struct internal_syment *sym;
960 bfd_vma val;
961
962 asection *sec;
963 bfd_reloc_status_type rstat;
964 bfd_byte *loc;
965
966 unsigned short r_type = EXTRACT_TYPE (rel->r_type);
967 unsigned short r_flags = EXTRACT_FLAGS(rel->r_type);
968
969 symndx = rel->r_symndx;
970 loc = contents + rel->r_vaddr - input_section->vma;
971
972 /* FIXME: check bounds on r_type */
973 howto = ppc_coff_howto_table + r_type;
974
975 if (symndx == -1)
976 {
977 h = NULL;
978 sym = NULL;
979 }
980 else
981 {
982 h = (struct ppc_coff_link_hash_entry *)
983 (obj_coff_sym_hashes (input_bfd)[symndx]);
984 if (h != 0)
985 {
986 HASH_CHECK(h);
987 }
988
989 sym = syms + symndx;
990 }
991
992 if (r_type == IMAGE_REL_PPC_IMGLUE && h == 0)
993 {
994 /* An IMGLUE reloc must have a name. Something is very wrong. */
995 abort ();
996 }
997
998 sec = NULL;
999 val = 0;
1000
1001 /* FIXME: PAIR unsupported in the following code. */
1002 if (h == NULL)
1003 {
1004 if (symndx == -1)
1005 sec = bfd_abs_section_ptr;
1006 else
1007 {
1008 sec = sections[symndx];
1009 val = (sec->output_section->vma
1010 + sec->output_offset
1011 + sym->n_value);
1012 if (! obj_pe (output_bfd))
1013 val -= sec->vma;
1014 }
1015 }
1016 else
1017 {
1018 HASH_CHECK(h);
1019
1020 if (h->root.root.type == bfd_link_hash_defined
1021 || h->root.root.type == bfd_link_hash_defweak)
1022 {
1023 sec = h->root.root.u.def.section;
1024 val = (h->root.root.u.def.value
1025 + sec->output_section->vma
1026 + sec->output_offset);
1027 }
1028 else
1029 {
1030 if (! ((*info->callbacks->undefined_symbol)
1031 (info, h->root.root.root.string, input_bfd, input_section,
1032 rel->r_vaddr - input_section->vma, TRUE)))
1033 return FALSE;
1034 }
1035 }
1036
1037 rstat = bfd_reloc_ok;
1038
1039 /* Each case must do its own relocation, setting rstat appropriately. */
1040 switch (r_type)
1041 {
1042 default:
1043 (*_bfd_error_handler)
1044 (_("%B: unsupported relocation type 0x%02x"), input_bfd, r_type);
1045 bfd_set_error (bfd_error_bad_value);
1046 return FALSE;
1047 case IMAGE_REL_PPC_TOCREL16:
1048 {
1049 bfd_signed_vma our_toc_offset;
1050 int fixit;
1051
1052 DUMP_RELOC2(howto->name, rel);
1053
1054 if (toc_section == 0)
1055 {
1056 toc_section = bfd_get_section_by_name (bfd_of_toc_owner,
1057 TOC_SECTION_NAME);
1058
1059 if ( toc_section == NULL )
1060 {
1061 /* There is no toc section. Something is very wrong. */
1062 abort ();
1063 }
1064 }
1065
1066 /* Amazing bit tricks present. As we may have seen earlier, we
1067 use the 1 bit to tell us whether or not a toc offset has been
1068 allocated. Now that they've all been allocated, we will use
1069 the 1 bit to tell us if we've written this particular toc
1070 entry out. */
1071 fixit = FALSE;
1072 if (h == 0)
1073 {
1074 /* It is a file local symbol. */
1075 int *local_toc_table;
1076 char name[SYMNMLEN + 1];
1077
1078 sym = syms + symndx;
1079 strncpy (name, sym->_n._n_name, SYMNMLEN);
1080 name[SYMNMLEN] = '\0';
1081
1082 local_toc_table = obj_coff_local_toc_table(input_bfd);
1083 our_toc_offset = local_toc_table[symndx];
1084
1085 if (IS_WRITTEN(our_toc_offset))
1086 {
1087 /* If it has been written out, it is marked with the
1088 1 bit. Fix up our offset, but do not write it out
1089 again. */
1090 MAKE_ADDR_AGAIN(our_toc_offset);
1091 }
1092 else
1093 {
1094 /* Write out the toc entry. */
1095 record_toc (toc_section, our_toc_offset, priv,
1096 strdup (name));
1097
1098 bfd_put_32 (output_bfd, val,
1099 toc_section->contents + our_toc_offset);
1100
1101 MARK_AS_WRITTEN(local_toc_table[symndx]);
1102 fixit = TRUE;
1103 }
1104 }
1105 else
1106 {
1107 const char *name = h->root.root.root.string;
1108 our_toc_offset = h->toc_offset;
1109
1110 if ((r_flags & IMAGE_REL_PPC_TOCDEFN)
1111 == IMAGE_REL_PPC_TOCDEFN )
1112 {
1113 /* This is unbelievable cheese. Some knowledgable asm
1114 hacker has decided to use r2 as a base for loading
1115 a value. He/She does this by setting the tocdefn bit,
1116 and not supplying a toc definition. The behaviour is
1117 then to use the difference between the value of the
1118 symbol and the actual location of the toc as the toc
1119 index.
1120
1121 In fact, what is usually happening is, because the
1122 Import Address Table is mapped immediately following
1123 the toc, some trippy library code trying for speed on
1124 dll linkage, takes advantage of that and considers
1125 the IAT to be part of the toc, thus saving a load. */
1126
1127 our_toc_offset = val - (toc_section->output_section->vma
1128 + toc_section->output_offset);
1129
1130 /* The size must still fit in a 16-bit displacement. */
1131 if ((bfd_vma) our_toc_offset >= 65535)
1132 {
1133 (*_bfd_error_handler)
1134 (_("%B: Relocation for %s of %lx exceeds Toc size limit"),
1135 input_bfd, name,
1136 (unsigned long) our_toc_offset);
1137 bfd_set_error (bfd_error_bad_value);
1138 return FALSE;
1139 }
1140
1141 record_toc (toc_section, our_toc_offset, pub,
1142 strdup (name));
1143 }
1144 else if (IS_WRITTEN (our_toc_offset))
1145 {
1146 /* If it has been written out, it is marked with the
1147 1 bit. Fix up our offset, but do not write it out
1148 again. */
1149 MAKE_ADDR_AGAIN(our_toc_offset);
1150 }
1151 else
1152 {
1153 record_toc(toc_section, our_toc_offset, pub,
1154 strdup (name));
1155
1156 /* Write out the toc entry. */
1157 bfd_put_32 (output_bfd, val,
1158 toc_section->contents + our_toc_offset);
1159
1160 MARK_AS_WRITTEN(h->toc_offset);
1161 /* The tricky part is that this is the address that
1162 needs a .reloc entry for it. */
1163 fixit = TRUE;
1164 }
1165 }
1166
1167 if (fixit && info->base_file)
1168 {
1169 /* So if this is non pcrelative, and is referenced
1170 to a section or a common symbol, then it needs a reloc. */
1171
1172 /* Relocation to a symbol in a section which
1173 isn't absolute - we output the address here
1174 to a file. */
1175 bfd_vma addr = (toc_section->output_section->vma
1176 + toc_section->output_offset + our_toc_offset);
1177
1178 if (!write_base_file_entry (output_bfd, info, addr))
1179 return FALSE;
1180 }
1181
1182 /* FIXME: this test is conservative. */
1183 if ((r_flags & IMAGE_REL_PPC_TOCDEFN) != IMAGE_REL_PPC_TOCDEFN
1184 && (bfd_vma) our_toc_offset > toc_section->size)
1185 {
1186 (*_bfd_error_handler)
1187 (_("%B: Relocation exceeds allocated TOC (%lx)"),
1188 input_bfd, (unsigned long) toc_section->size);
1189 bfd_set_error (bfd_error_bad_value);
1190 return FALSE;
1191 }
1192
1193 /* Now we know the relocation for this toc reference. */
1194 relocation = our_toc_offset + TOC_LOAD_ADJUSTMENT;
1195 rstat = _bfd_relocate_contents (howto, input_bfd, relocation, loc);
1196 }
1197 break;
1198 case IMAGE_REL_PPC_IFGLUE:
1199 {
1200 /* To solve this, we need to know whether or not the symbol
1201 appearing on the call instruction is a glue function or not.
1202 A glue function must announce itself via a IMGLUE reloc, and
1203 the reloc contains the required toc restore instruction. */
1204 DUMP_RELOC2 (howto->name, rel);
1205
1206 if (h != 0)
1207 {
1208 if (h->symbol_is_glue == 1)
1209 {
1210 bfd_put_32 (input_bfd, (bfd_vma) h->glue_insn, loc);
1211 }
1212 }
1213 }
1214 break;
1215 case IMAGE_REL_PPC_SECREL:
1216 /* Unimplemented: codeview debugging information. */
1217 /* For fast access to the header of the section
1218 containing the item. */
1219 break;
1220 case IMAGE_REL_PPC_SECTION:
1221 /* Unimplemented: codeview debugging information. */
1222 /* Is used to indicate that the value should be relative
1223 to the beginning of the section that contains the
1224 symbol. */
1225 break;
1226 case IMAGE_REL_PPC_ABSOLUTE:
1227 {
1228 const char *my_name;
1229 char buf[SYMNMLEN + 1];
1230
1231 if (h == 0)
1232 {
1233 strncpy (buf, (syms+symndx)->_n._n_name, SYMNMLEN);
1234 buf[SYMNMLEN] = '\0';
1235 my_name = buf;
1236 }
1237 else
1238 my_name = h->root.root.root.string;
1239
1240 (*_bfd_error_handler)
1241 (_("Warning: unsupported reloc %s <file %B, section %A>\n"
1242 "sym %ld (%s), r_vaddr %ld (%lx)"),
1243 input_bfd, input_section, howto->name,
1244 rel->r_symndx, my_name, (long) rel->r_vaddr,
1245 (unsigned long) rel->r_vaddr);
1246 }
1247 break;
1248 case IMAGE_REL_PPC_IMGLUE:
1249 {
1250 /* There is nothing to do now. This reloc was noted in the first
1251 pass over the relocs, and the glue instruction extracted. */
1252 const char *my_name;
1253
1254 if (h->symbol_is_glue == 1)
1255 break;
1256 my_name = h->root.root.root.string;
1257
1258 (*_bfd_error_handler)
1259 (_("%B: Out of order IMGLUE reloc for %s"), input_bfd, my_name);
1260 bfd_set_error (bfd_error_bad_value);
1261 return FALSE;
1262 }
1263
1264 case IMAGE_REL_PPC_ADDR32NB:
1265 {
1266 const char *name = 0;
1267
1268 DUMP_RELOC2 (howto->name, rel);
1269
1270 if (CONST_STRNEQ (input_section->name, ".idata$2") && first_thunk_address == 0)
1271 {
1272 /* Set magic values. */
1273 int idata5offset;
1274 struct coff_link_hash_entry *myh;
1275
1276 myh = coff_link_hash_lookup (coff_hash_table (info),
1277 "__idata5_magic__",
1278 FALSE, FALSE, TRUE);
1279 first_thunk_address = myh->root.u.def.value +
1280 sec->output_section->vma +
1281 sec->output_offset -
1282 pe_data(output_bfd)->pe_opthdr.ImageBase;
1283
1284 idata5offset = myh->root.u.def.value;
1285 myh = coff_link_hash_lookup (coff_hash_table (info),
1286 "__idata6_magic__",
1287 FALSE, FALSE, TRUE);
1288
1289 thunk_size = myh->root.u.def.value - idata5offset;
1290 myh = coff_link_hash_lookup (coff_hash_table (info),
1291 "__idata4_magic__",
1292 FALSE, FALSE, TRUE);
1293 import_table_size = myh->root.u.def.value;
1294 }
1295
1296 if (h == 0)
1297 /* It is a file local symbol. */
1298 sym = syms + symndx;
1299 else
1300 {
1301 char *target = 0;
1302
1303 name = h->root.root.root.string;
1304 if (strcmp (".idata$2", name) == 0)
1305 target = "__idata2_magic__";
1306 else if (strcmp (".idata$4", name) == 0)
1307 target = "__idata4_magic__";
1308 else if (strcmp (".idata$5", name) == 0)
1309 target = "__idata5_magic__";
1310
1311 if (target != 0)
1312 {
1313 struct coff_link_hash_entry *myh;
1314
1315 myh = coff_link_hash_lookup (coff_hash_table (info),
1316 target,
1317 FALSE, FALSE, TRUE);
1318 if (myh == 0)
1319 {
1320 /* Missing magic cookies. Something is very wrong. */
1321 abort ();
1322 }
1323
1324 val = myh->root.u.def.value +
1325 sec->output_section->vma + sec->output_offset;
1326 if (first_thunk_address == 0)
1327 {
1328 int idata5offset;
1329 myh = coff_link_hash_lookup (coff_hash_table (info),
1330 "__idata5_magic__",
1331 FALSE, FALSE, TRUE);
1332 first_thunk_address = myh->root.u.def.value +
1333 sec->output_section->vma +
1334 sec->output_offset -
1335 pe_data(output_bfd)->pe_opthdr.ImageBase;
1336
1337 idata5offset = myh->root.u.def.value;
1338 myh = coff_link_hash_lookup (coff_hash_table (info),
1339 "__idata6_magic__",
1340 FALSE, FALSE, TRUE);
1341
1342 thunk_size = myh->root.u.def.value - idata5offset;
1343 myh = coff_link_hash_lookup (coff_hash_table (info),
1344 "__idata4_magic__",
1345 FALSE, FALSE, TRUE);
1346 import_table_size = myh->root.u.def.value;
1347 }
1348 }
1349 }
1350
1351 rstat = _bfd_relocate_contents (howto,
1352 input_bfd,
1353 val -
1354 pe_data (output_bfd)->pe_opthdr.ImageBase,
1355 loc);
1356 }
1357 break;
1358
1359 case IMAGE_REL_PPC_REL24:
1360 DUMP_RELOC2(howto->name, rel);
1361 val -= (input_section->output_section->vma
1362 + input_section->output_offset);
1363
1364 rstat = _bfd_relocate_contents (howto,
1365 input_bfd,
1366 val,
1367 loc);
1368 break;
1369 case IMAGE_REL_PPC_ADDR16:
1370 case IMAGE_REL_PPC_ADDR24:
1371 case IMAGE_REL_PPC_ADDR32:
1372 DUMP_RELOC2(howto->name, rel);
1373 rstat = _bfd_relocate_contents (howto,
1374 input_bfd,
1375 val,
1376 loc);
1377 break;
1378 }
1379
1380 if (info->base_file)
1381 {
1382 /* So if this is non pcrelative, and is referenced
1383 to a section or a common symbol, then it needs a reloc. */
1384 if (sym && pe_data(output_bfd)->in_reloc_p (output_bfd, howto))
1385 {
1386 /* Relocation to a symbol in a section which
1387 isn't absolute - we output the address here
1388 to a file. */
1389 bfd_vma addr = (rel->r_vaddr
1390 - input_section->vma
1391 + input_section->output_offset
1392 + input_section->output_section->vma);
1393
1394 if (!write_base_file_entry (output_bfd, info, addr))
1395 return FALSE;
1396 }
1397 }
1398
1399 switch (rstat)
1400 {
1401 default:
1402 abort ();
1403 case bfd_reloc_ok:
1404 break;
1405 case bfd_reloc_overflow:
1406 {
1407 const char *name;
1408 char buf[SYMNMLEN + 1];
1409
1410 if (symndx == -1)
1411 name = "*ABS*";
1412 else if (h != NULL)
1413 name = NULL;
1414 else if (sym == NULL)
1415 name = "*unknown*";
1416 else if (sym->_n._n_n._n_zeroes == 0
1417 && sym->_n._n_n._n_offset != 0)
1418 name = obj_coff_strings (input_bfd) + sym->_n._n_n._n_offset;
1419 else
1420 {
1421 strncpy (buf, sym->_n._n_name, SYMNMLEN);
1422 buf[SYMNMLEN] = '\0';
1423 name = buf;
1424 }
1425
1426 if (! ((*info->callbacks->reloc_overflow)
1427 (info, (h ? &h->root.root : NULL), name, howto->name,
1428 (bfd_vma) 0, input_bfd,
1429 input_section, rel->r_vaddr - input_section->vma)))
1430 return FALSE;
1431 }
1432 }
1433 }
1434
1435 return TRUE;
1436 }
1437
1438 #ifdef COFF_IMAGE_WITH_PE
1439
1440 /* FIXME: BFD should not use global variables. This file is compiled
1441 twice, and these variables are shared. This is confusing and
1442 weird. */
1443
1444 long int global_toc_size = 4;
1445
1446 bfd* bfd_of_toc_owner = 0;
1447
1448 long int import_table_size;
1449 long int first_thunk_address;
1450 long int thunk_size;
1451
1452 struct list_ele *head;
1453 struct list_ele *tail;
1454
1455 static char *
1456 h1 = N_("\n\t\t\tTOC MAPPING\n\n");
1457 static char *
1458 h2 = N_(" TOC disassembly Comments Name\n");
1459 static char *
1460 h3 = N_(" Offset spelling (if present)\n");
1461
1462 void
dump_toc(void * vfile)1463 dump_toc (void * vfile)
1464 {
1465 FILE *file = (FILE *) vfile;
1466 struct list_ele *t;
1467
1468 fputs (_(h1), file);
1469 fputs (_(h2), file);
1470 fputs (_(h3), file);
1471
1472 for (t = head; t != 0; t=t->next)
1473 {
1474 const char *cat = "";
1475
1476 if (t->cat == priv)
1477 cat = _("private ");
1478 else if (t->cat == pub)
1479 cat = _("public ");
1480 else if (t->cat == tocdata)
1481 cat = _("data-in-toc ");
1482
1483 if (t->offset > global_toc_size)
1484 {
1485 if (t->offset <= global_toc_size + thunk_size)
1486 cat = _("IAT reference ");
1487 else
1488 {
1489 fprintf (file,
1490 _("**** global_toc_size %ld(%lx), thunk_size %ld(%lx)\n"),
1491 global_toc_size, (unsigned long) global_toc_size,
1492 thunk_size, (unsigned long) thunk_size);
1493 cat = _("Out of bounds!");
1494 }
1495 }
1496
1497 fprintf (file,
1498 " %04lx (%d)", (unsigned long) t->offset, t->offset - 32768);
1499 fprintf (file,
1500 " %s %s\n",
1501 cat, t->name);
1502
1503 }
1504
1505 fprintf (file, "\n");
1506 }
1507
1508 bfd_boolean
ppc_allocate_toc_section(struct bfd_link_info * info ATTRIBUTE_UNUSED)1509 ppc_allocate_toc_section (struct bfd_link_info *info ATTRIBUTE_UNUSED)
1510 {
1511 asection *s;
1512 bfd_byte *foo;
1513 bfd_size_type amt;
1514 static char test_char = '1';
1515
1516 if ( global_toc_size == 0 ) /* FIXME: does this get me in trouble? */
1517 return TRUE;
1518
1519 if (bfd_of_toc_owner == 0)
1520 /* No toc owner? Something is very wrong. */
1521 abort ();
1522
1523 s = bfd_get_section_by_name ( bfd_of_toc_owner , TOC_SECTION_NAME);
1524 if (s == NULL)
1525 /* No toc section? Something is very wrong. */
1526 abort ();
1527
1528 amt = global_toc_size;
1529 foo = (bfd_byte *) bfd_alloc (bfd_of_toc_owner, amt);
1530 memset(foo, test_char, (size_t) global_toc_size);
1531
1532 s->size = global_toc_size;
1533 s->contents = foo;
1534
1535 return TRUE;
1536 }
1537
1538 bfd_boolean
ppc_process_before_allocation(bfd * abfd,struct bfd_link_info * info)1539 ppc_process_before_allocation (bfd *abfd,
1540 struct bfd_link_info *info)
1541 {
1542 asection *sec;
1543 struct internal_reloc *i, *rel;
1544
1545 /* Here we have a bfd that is to be included on the link. We have a hook
1546 to do reloc rummaging, before section sizes are nailed down. */
1547 _bfd_coff_get_external_symbols (abfd);
1548
1549 /* Rummage around all the relocs and map the toc. */
1550 sec = abfd->sections;
1551
1552 if (sec == 0)
1553 return TRUE;
1554
1555 for (; sec != 0; sec = sec->next)
1556 {
1557 if (sec->reloc_count == 0)
1558 continue;
1559
1560 /* load the relocs */
1561 /* FIXME: there may be a storage leak here */
1562 i=_bfd_coff_read_internal_relocs(abfd,sec,1,0,0,0);
1563
1564 if (i == 0)
1565 abort ();
1566
1567 for (rel = i; rel < i + sec->reloc_count; ++rel)
1568 {
1569 unsigned short r_type = EXTRACT_TYPE (rel->r_type);
1570 unsigned short r_flags = EXTRACT_FLAGS (rel->r_type);
1571 bfd_boolean ok = TRUE;
1572
1573 DUMP_RELOC2 (ppc_coff_howto_table[r_type].name, rel);
1574
1575 switch(r_type)
1576 {
1577 case IMAGE_REL_PPC_TOCREL16:
1578 /* If TOCDEFN is on, ignore as someone else has allocated the
1579 toc entry. */
1580 if ((r_flags & IMAGE_REL_PPC_TOCDEFN) != IMAGE_REL_PPC_TOCDEFN)
1581 ok = ppc_record_toc_entry(abfd, info, sec,
1582 rel->r_symndx, default_toc);
1583 if (!ok)
1584 return FALSE;
1585 break;
1586 case IMAGE_REL_PPC_IMGLUE:
1587 ppc_mark_symbol_as_glue (abfd, rel->r_symndx, rel);
1588 break;
1589 default:
1590 break;
1591 }
1592 }
1593 }
1594
1595 return TRUE;
1596 }
1597
1598 #endif
1599
1600 static bfd_reloc_status_type
ppc_refhi_reloc(bfd * abfd ATTRIBUTE_UNUSED,arelent * reloc_entry ATTRIBUTE_UNUSED,asymbol * symbol ATTRIBUTE_UNUSED,void * data ATTRIBUTE_UNUSED,asection * input_section ATTRIBUTE_UNUSED,bfd * output_bfd,char ** error_message ATTRIBUTE_UNUSED)1601 ppc_refhi_reloc (bfd *abfd ATTRIBUTE_UNUSED,
1602 arelent *reloc_entry ATTRIBUTE_UNUSED,
1603 asymbol *symbol ATTRIBUTE_UNUSED,
1604 void * data ATTRIBUTE_UNUSED,
1605 asection *input_section ATTRIBUTE_UNUSED,
1606 bfd *output_bfd,
1607 char **error_message ATTRIBUTE_UNUSED)
1608 {
1609 UN_IMPL("REFHI");
1610 DUMP_RELOC("REFHI",reloc_entry);
1611
1612 if (output_bfd == (bfd *) NULL)
1613 return bfd_reloc_continue;
1614
1615 return bfd_reloc_undefined;
1616 }
1617
1618 static bfd_reloc_status_type
ppc_pair_reloc(bfd * abfd ATTRIBUTE_UNUSED,arelent * reloc_entry ATTRIBUTE_UNUSED,asymbol * symbol ATTRIBUTE_UNUSED,void * data ATTRIBUTE_UNUSED,asection * input_section ATTRIBUTE_UNUSED,bfd * output_bfd,char ** error_message ATTRIBUTE_UNUSED)1619 ppc_pair_reloc (bfd *abfd ATTRIBUTE_UNUSED,
1620 arelent *reloc_entry ATTRIBUTE_UNUSED,
1621 asymbol *symbol ATTRIBUTE_UNUSED,
1622 void * data ATTRIBUTE_UNUSED,
1623 asection *input_section ATTRIBUTE_UNUSED,
1624 bfd *output_bfd,
1625 char **error_message ATTRIBUTE_UNUSED)
1626 {
1627 UN_IMPL("PAIR");
1628 DUMP_RELOC("PAIR",reloc_entry);
1629
1630 if (output_bfd == (bfd *) NULL)
1631 return bfd_reloc_continue;
1632
1633 return bfd_reloc_undefined;
1634 }
1635
1636 static bfd_reloc_status_type
ppc_toc16_reloc(bfd * abfd ATTRIBUTE_UNUSED,arelent * reloc_entry ATTRIBUTE_UNUSED,asymbol * symbol ATTRIBUTE_UNUSED,void * data ATTRIBUTE_UNUSED,asection * input_section ATTRIBUTE_UNUSED,bfd * output_bfd,char ** error_message ATTRIBUTE_UNUSED)1637 ppc_toc16_reloc (bfd *abfd ATTRIBUTE_UNUSED,
1638 arelent *reloc_entry ATTRIBUTE_UNUSED,
1639 asymbol *symbol ATTRIBUTE_UNUSED,
1640 void * data ATTRIBUTE_UNUSED,
1641 asection *input_section ATTRIBUTE_UNUSED,
1642 bfd *output_bfd,
1643 char **error_message ATTRIBUTE_UNUSED)
1644 {
1645 UN_IMPL ("TOCREL16");
1646 DUMP_RELOC ("TOCREL16",reloc_entry);
1647
1648 if (output_bfd == (bfd *) NULL)
1649 return bfd_reloc_continue;
1650
1651 return bfd_reloc_ok;
1652 }
1653
1654 static bfd_reloc_status_type
ppc_secrel_reloc(bfd * abfd ATTRIBUTE_UNUSED,arelent * reloc_entry ATTRIBUTE_UNUSED,asymbol * symbol ATTRIBUTE_UNUSED,void * data ATTRIBUTE_UNUSED,asection * input_section ATTRIBUTE_UNUSED,bfd * output_bfd,char ** error_message ATTRIBUTE_UNUSED)1655 ppc_secrel_reloc (bfd *abfd ATTRIBUTE_UNUSED,
1656 arelent *reloc_entry ATTRIBUTE_UNUSED,
1657 asymbol *symbol ATTRIBUTE_UNUSED,
1658 void * data ATTRIBUTE_UNUSED,
1659 asection *input_section ATTRIBUTE_UNUSED,
1660 bfd *output_bfd,
1661 char **error_message ATTRIBUTE_UNUSED)
1662 {
1663 UN_IMPL("SECREL");
1664 DUMP_RELOC("SECREL",reloc_entry);
1665
1666 if (output_bfd == (bfd *) NULL)
1667 return bfd_reloc_continue;
1668
1669 return bfd_reloc_ok;
1670 }
1671
1672 static bfd_reloc_status_type
ppc_section_reloc(bfd * abfd ATTRIBUTE_UNUSED,arelent * reloc_entry ATTRIBUTE_UNUSED,asymbol * symbol ATTRIBUTE_UNUSED,void * data ATTRIBUTE_UNUSED,asection * input_section ATTRIBUTE_UNUSED,bfd * output_bfd,char ** error_message ATTRIBUTE_UNUSED)1673 ppc_section_reloc (bfd *abfd ATTRIBUTE_UNUSED,
1674 arelent *reloc_entry ATTRIBUTE_UNUSED,
1675 asymbol *symbol ATTRIBUTE_UNUSED,
1676 void * data ATTRIBUTE_UNUSED,
1677 asection *input_section ATTRIBUTE_UNUSED,
1678 bfd *output_bfd,
1679 char **error_message ATTRIBUTE_UNUSED)
1680 {
1681 UN_IMPL("SECTION");
1682 DUMP_RELOC("SECTION",reloc_entry);
1683
1684 if (output_bfd == (bfd *) NULL)
1685 return bfd_reloc_continue;
1686
1687 return bfd_reloc_ok;
1688 }
1689
1690 static bfd_reloc_status_type
ppc_imglue_reloc(bfd * abfd ATTRIBUTE_UNUSED,arelent * reloc_entry ATTRIBUTE_UNUSED,asymbol * symbol ATTRIBUTE_UNUSED,void * data ATTRIBUTE_UNUSED,asection * input_section ATTRIBUTE_UNUSED,bfd * output_bfd,char ** error_message ATTRIBUTE_UNUSED)1691 ppc_imglue_reloc (bfd *abfd ATTRIBUTE_UNUSED,
1692 arelent *reloc_entry ATTRIBUTE_UNUSED,
1693 asymbol *symbol ATTRIBUTE_UNUSED,
1694 void * data ATTRIBUTE_UNUSED,
1695 asection *input_section ATTRIBUTE_UNUSED,
1696 bfd *output_bfd,
1697 char **error_message ATTRIBUTE_UNUSED)
1698
1699 {
1700 UN_IMPL("IMGLUE");
1701 DUMP_RELOC("IMGLUE",reloc_entry);
1702
1703 if (output_bfd == (bfd *) NULL)
1704 return bfd_reloc_continue;
1705
1706 return bfd_reloc_ok;
1707 }
1708
1709 #define MAX_RELOC_INDEX \
1710 (sizeof (ppc_coff_howto_table) / sizeof (ppc_coff_howto_table[0]) - 1)
1711
1712 /* FIXME: There is a possibility that when we read in a reloc from a file,
1713 that there are some bits encoded in the upper portion of the
1714 type field. Not yet implemented. */
1715
1716 static void
ppc_coff_rtype2howto(arelent * relent,struct internal_reloc * internal)1717 ppc_coff_rtype2howto (arelent *relent, struct internal_reloc *internal)
1718 {
1719 /* We can encode one of three things in the type field, aside from the
1720 type:
1721 1. IMAGE_REL_PPC_NEG - indicates the value field is a subtraction
1722 value, rather than an addition value
1723 2. IMAGE_REL_PPC_BRTAKEN, IMAGE_REL_PPC_BRNTAKEN - indicates that
1724 the branch is expected to be taken or not.
1725 3. IMAGE_REL_PPC_TOCDEFN - toc slot definition in the file
1726 For now, we just strip this stuff to find the type, and ignore it other
1727 than that. */
1728 reloc_howto_type *howto;
1729 unsigned short r_type = EXTRACT_TYPE (internal->r_type);
1730 unsigned short r_flags = EXTRACT_FLAGS(internal->r_type);
1731 unsigned short junk = EXTRACT_JUNK (internal->r_type);
1732
1733 /* The masking process only slices off the bottom byte for r_type. */
1734 if ( r_type > MAX_RELOC_INDEX )
1735 abort ();
1736
1737 /* Check for absolute crap. */
1738 if (junk != 0)
1739 abort ();
1740
1741 switch(r_type)
1742 {
1743 case IMAGE_REL_PPC_ADDR16:
1744 case IMAGE_REL_PPC_REL24:
1745 case IMAGE_REL_PPC_ADDR24:
1746 case IMAGE_REL_PPC_ADDR32:
1747 case IMAGE_REL_PPC_IFGLUE:
1748 case IMAGE_REL_PPC_ADDR32NB:
1749 case IMAGE_REL_PPC_SECTION:
1750 case IMAGE_REL_PPC_SECREL:
1751 DUMP_RELOC2 (ppc_coff_howto_table[r_type].name, internal);
1752 howto = ppc_coff_howto_table + r_type;
1753 break;
1754 case IMAGE_REL_PPC_IMGLUE:
1755 DUMP_RELOC2 (ppc_coff_howto_table[r_type].name, internal);
1756 howto = ppc_coff_howto_table + r_type;
1757 break;
1758 case IMAGE_REL_PPC_TOCREL16:
1759 DUMP_RELOC2 (ppc_coff_howto_table[r_type].name, internal);
1760 if (r_flags & IMAGE_REL_PPC_TOCDEFN)
1761 howto = ppc_coff_howto_table + IMAGE_REL_PPC_TOCREL16_DEFN;
1762 else
1763 howto = ppc_coff_howto_table + IMAGE_REL_PPC_TOCREL16;
1764 break;
1765 default:
1766 (*_bfd_error_handler) (_("warning: unsupported reloc %s [%d] used -- it may not work"),
1767 ppc_coff_howto_table[r_type].name,
1768 r_type);
1769 howto = ppc_coff_howto_table + r_type;
1770 break;
1771 }
1772
1773 relent->howto = howto;
1774 }
1775
1776 static reloc_howto_type *
coff_ppc_rtype_to_howto(bfd * abfd ATTRIBUTE_UNUSED,asection * sec,struct internal_reloc * rel,struct coff_link_hash_entry * h ATTRIBUTE_UNUSED,struct internal_syment * sym ATTRIBUTE_UNUSED,bfd_vma * addendp)1777 coff_ppc_rtype_to_howto (bfd *abfd ATTRIBUTE_UNUSED,
1778 asection *sec,
1779 struct internal_reloc *rel,
1780 struct coff_link_hash_entry *h ATTRIBUTE_UNUSED,
1781 struct internal_syment *sym ATTRIBUTE_UNUSED,
1782 bfd_vma *addendp)
1783 {
1784 reloc_howto_type *howto;
1785
1786 /* We can encode one of three things in the type field, aside from the
1787 type:
1788 1. IMAGE_REL_PPC_NEG - indicates the value field is a subtraction
1789 value, rather than an addition value
1790 2. IMAGE_REL_PPC_BRTAKEN, IMAGE_REL_PPC_BRNTAKEN - indicates that
1791 the branch is expected to be taken or not.
1792 3. IMAGE_REL_PPC_TOCDEFN - toc slot definition in the file
1793 For now, we just strip this stuff to find the type, and ignore it other
1794 than that. */
1795
1796 unsigned short r_type = EXTRACT_TYPE (rel->r_type);
1797 unsigned short r_flags = EXTRACT_FLAGS (rel->r_type);
1798 unsigned short junk = EXTRACT_JUNK (rel->r_type);
1799
1800 /* The masking process only slices off the bottom byte for r_type. */
1801 if (r_type > MAX_RELOC_INDEX)
1802 abort ();
1803
1804 /* Check for absolute crap. */
1805 if (junk != 0)
1806 abort ();
1807
1808 switch(r_type)
1809 {
1810 case IMAGE_REL_PPC_ADDR32NB:
1811 DUMP_RELOC2(ppc_coff_howto_table[r_type].name, rel);
1812 *addendp -= pe_data(sec->output_section->owner)->pe_opthdr.ImageBase;
1813 howto = ppc_coff_howto_table + r_type;
1814 break;
1815 case IMAGE_REL_PPC_TOCREL16:
1816 DUMP_RELOC2(ppc_coff_howto_table[r_type].name, rel);
1817 if (r_flags & IMAGE_REL_PPC_TOCDEFN)
1818 howto = ppc_coff_howto_table + IMAGE_REL_PPC_TOCREL16_DEFN;
1819 else
1820 howto = ppc_coff_howto_table + IMAGE_REL_PPC_TOCREL16;
1821 break;
1822 case IMAGE_REL_PPC_ADDR16:
1823 case IMAGE_REL_PPC_REL24:
1824 case IMAGE_REL_PPC_ADDR24:
1825 case IMAGE_REL_PPC_ADDR32:
1826 case IMAGE_REL_PPC_IFGLUE:
1827 case IMAGE_REL_PPC_SECTION:
1828 case IMAGE_REL_PPC_SECREL:
1829 DUMP_RELOC2(ppc_coff_howto_table[r_type].name, rel);
1830 howto = ppc_coff_howto_table + r_type;
1831 break;
1832 case IMAGE_REL_PPC_IMGLUE:
1833 DUMP_RELOC2(ppc_coff_howto_table[r_type].name, rel);
1834 howto = ppc_coff_howto_table + r_type;
1835 break;
1836 default:
1837 (*_bfd_error_handler) (_("warning: unsupported reloc %s [%d] used -- it may not work"),
1838 ppc_coff_howto_table[r_type].name,
1839 r_type);
1840 howto = ppc_coff_howto_table + r_type;
1841 break;
1842 }
1843
1844 return howto;
1845 }
1846
1847 /* A cheesy little macro to make the code a little more readable. */
1848 #define HOW2MAP(bfd_rtype,ppc_rtype) \
1849 case bfd_rtype: return &ppc_coff_howto_table[ppc_rtype]
1850
1851 static reloc_howto_type *
ppc_coff_reloc_type_lookup(bfd * abfd ATTRIBUTE_UNUSED,bfd_reloc_code_real_type code)1852 ppc_coff_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
1853 bfd_reloc_code_real_type code)
1854 {
1855 switch (code)
1856 {
1857 HOW2MAP(BFD_RELOC_32_GOTOFF, IMAGE_REL_PPC_IMGLUE);
1858 HOW2MAP(BFD_RELOC_16_GOT_PCREL, IMAGE_REL_PPC_IFGLUE);
1859 HOW2MAP(BFD_RELOC_16, IMAGE_REL_PPC_ADDR16);
1860 HOW2MAP(BFD_RELOC_PPC_B26, IMAGE_REL_PPC_REL24);
1861 HOW2MAP(BFD_RELOC_PPC_BA26, IMAGE_REL_PPC_ADDR24);
1862 HOW2MAP(BFD_RELOC_PPC_TOC16, IMAGE_REL_PPC_TOCREL16);
1863 HOW2MAP(BFD_RELOC_16_GOTOFF, IMAGE_REL_PPC_TOCREL16_DEFN);
1864 HOW2MAP(BFD_RELOC_32, IMAGE_REL_PPC_ADDR32);
1865 HOW2MAP(BFD_RELOC_RVA, IMAGE_REL_PPC_ADDR32NB);
1866 default:
1867 return NULL;
1868 }
1869 }
1870 #undef HOW2MAP
1871
1872 static reloc_howto_type *
ppc_coff_reloc_name_lookup(bfd * abfd ATTRIBUTE_UNUSED,const char * r_name)1873 ppc_coff_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
1874 const char *r_name)
1875 {
1876 unsigned int i;
1877
1878 for (i = 0;
1879 i < sizeof (ppc_coff_howto_table) / sizeof (ppc_coff_howto_table[0]);
1880 i++)
1881 if (ppc_coff_howto_table[i].name != NULL
1882 && strcasecmp (ppc_coff_howto_table[i].name, r_name) == 0)
1883 return &ppc_coff_howto_table[i];
1884
1885 return NULL;
1886 }
1887
1888 /* Tailor coffcode.h -- macro heaven. */
1889
1890 #define RTYPE2HOWTO(cache_ptr, dst) ppc_coff_rtype2howto (cache_ptr, dst)
1891
1892 /* We use the special COFF backend linker, with our own special touch. */
1893
1894 #define coff_bfd_reloc_type_lookup ppc_coff_reloc_type_lookup
1895 #define coff_bfd_reloc_name_lookup ppc_coff_reloc_name_lookup
1896 #define coff_rtype_to_howto coff_ppc_rtype_to_howto
1897 #define coff_relocate_section coff_ppc_relocate_section
1898 #define coff_bfd_final_link ppc_bfd_coff_final_link
1899
1900 #ifndef COFF_IMAGE_WITH_PE
1901 #endif
1902
1903 #define SELECT_RELOC(internal, howto) {internal.r_type=howto->type;}
1904
1905 #define COFF_PAGE_SIZE 0x1000
1906
1907 /* FIXME: This controls some code that used to be in peicode.h and is
1908 now in peigen.c. It will not control the code in peigen.c. If
1909 anybody wants to get this working, you will need to fix that. */
1910 #define POWERPC_LE_PE
1911
1912 #define COFF_SECTION_ALIGNMENT_ENTRIES \
1913 { COFF_SECTION_NAME_EXACT_MATCH (".idata$2"), \
1914 COFF_ALIGNMENT_FIELD_EMPTY, COFF_ALIGNMENT_FIELD_EMPTY, 0 }, \
1915 { COFF_SECTION_NAME_EXACT_MATCH (".idata$3"), \
1916 COFF_ALIGNMENT_FIELD_EMPTY, COFF_ALIGNMENT_FIELD_EMPTY, 0 }, \
1917 { COFF_SECTION_NAME_EXACT_MATCH (".idata$4"), \
1918 COFF_ALIGNMENT_FIELD_EMPTY, COFF_ALIGNMENT_FIELD_EMPTY, 2 }, \
1919 { COFF_SECTION_NAME_EXACT_MATCH (".idata$5"), \
1920 COFF_ALIGNMENT_FIELD_EMPTY, COFF_ALIGNMENT_FIELD_EMPTY, 2 }, \
1921 { COFF_SECTION_NAME_EXACT_MATCH (".idata$6"), \
1922 COFF_ALIGNMENT_FIELD_EMPTY, COFF_ALIGNMENT_FIELD_EMPTY, 1 }, \
1923 { COFF_SECTION_NAME_EXACT_MATCH (".reloc"), \
1924 COFF_ALIGNMENT_FIELD_EMPTY, COFF_ALIGNMENT_FIELD_EMPTY, 1 }
1925
1926 #include "coffcode.h"
1927
1928 #ifndef COFF_IMAGE_WITH_PE
1929
1930 static bfd_boolean
ppc_do_last(bfd * abfd)1931 ppc_do_last (bfd *abfd)
1932 {
1933 if (abfd == bfd_of_toc_owner)
1934 return TRUE;
1935 else
1936 return FALSE;
1937 }
1938
1939 static bfd *
ppc_get_last(void)1940 ppc_get_last (void)
1941 {
1942 return bfd_of_toc_owner;
1943 }
1944
1945 /* This piece of machinery exists only to guarantee that the bfd that holds
1946 the toc section is written last.
1947
1948 This does depend on bfd_make_section attaching a new section to the
1949 end of the section list for the bfd.
1950
1951 This is otherwise intended to be functionally the same as
1952 cofflink.c:_bfd_coff_final_link(). It is specifically different only
1953 where the POWERPC_LE_PE macro modifies the code. It is left in as a
1954 precise form of comment. krk@cygnus.com */
1955
1956 /* Do the final link step. */
1957
1958 bfd_boolean
ppc_bfd_coff_final_link(bfd * abfd,struct bfd_link_info * info)1959 ppc_bfd_coff_final_link (bfd *abfd, struct bfd_link_info *info)
1960 {
1961 bfd_size_type symesz;
1962 struct coff_final_link_info flaginfo;
1963 bfd_boolean debug_merge_allocated;
1964 asection *o;
1965 struct bfd_link_order *p;
1966 bfd_size_type max_sym_count;
1967 bfd_size_type max_lineno_count;
1968 bfd_size_type max_reloc_count;
1969 bfd_size_type max_output_reloc_count;
1970 bfd_size_type max_contents_size;
1971 file_ptr rel_filepos;
1972 unsigned int relsz;
1973 file_ptr line_filepos;
1974 unsigned int linesz;
1975 bfd *sub;
1976 bfd_byte *external_relocs = NULL;
1977 char strbuf[STRING_SIZE_SIZE];
1978 bfd_size_type amt;
1979
1980 symesz = bfd_coff_symesz (abfd);
1981
1982 flaginfo.info = info;
1983 flaginfo.output_bfd = abfd;
1984 flaginfo.strtab = NULL;
1985 flaginfo.section_info = NULL;
1986 flaginfo.last_file_index = -1;
1987 flaginfo.last_bf_index = -1;
1988 flaginfo.internal_syms = NULL;
1989 flaginfo.sec_ptrs = NULL;
1990 flaginfo.sym_indices = NULL;
1991 flaginfo.outsyms = NULL;
1992 flaginfo.linenos = NULL;
1993 flaginfo.contents = NULL;
1994 flaginfo.external_relocs = NULL;
1995 flaginfo.internal_relocs = NULL;
1996 debug_merge_allocated = FALSE;
1997
1998 coff_data (abfd)->link_info = info;
1999
2000 flaginfo.strtab = _bfd_stringtab_init ();
2001 if (flaginfo.strtab == NULL)
2002 goto error_return;
2003
2004 if (! coff_debug_merge_hash_table_init (&flaginfo.debug_merge))
2005 goto error_return;
2006 debug_merge_allocated = TRUE;
2007
2008 /* Compute the file positions for all the sections. */
2009 if (! abfd->output_has_begun)
2010 {
2011 if (! bfd_coff_compute_section_file_positions (abfd))
2012 return FALSE;
2013 }
2014
2015 /* Count the line numbers and relocation entries required for the
2016 output file. Set the file positions for the relocs. */
2017 rel_filepos = obj_relocbase (abfd);
2018 relsz = bfd_coff_relsz (abfd);
2019 max_contents_size = 0;
2020 max_lineno_count = 0;
2021 max_reloc_count = 0;
2022
2023 for (o = abfd->sections; o != NULL; o = o->next)
2024 {
2025 o->reloc_count = 0;
2026 o->lineno_count = 0;
2027
2028 for (p = o->map_head.link_order; p != NULL; p = p->next)
2029 {
2030 if (p->type == bfd_indirect_link_order)
2031 {
2032 asection *sec;
2033
2034 sec = p->u.indirect.section;
2035
2036 /* Mark all sections which are to be included in the
2037 link. This will normally be every section. We need
2038 to do this so that we can identify any sections which
2039 the linker has decided to not include. */
2040 sec->linker_mark = TRUE;
2041
2042 if (info->strip == strip_none
2043 || info->strip == strip_some)
2044 o->lineno_count += sec->lineno_count;
2045
2046 if (info->relocatable)
2047 o->reloc_count += sec->reloc_count;
2048
2049 if (sec->rawsize > max_contents_size)
2050 max_contents_size = sec->rawsize;
2051 if (sec->size > max_contents_size)
2052 max_contents_size = sec->size;
2053 if (sec->lineno_count > max_lineno_count)
2054 max_lineno_count = sec->lineno_count;
2055 if (sec->reloc_count > max_reloc_count)
2056 max_reloc_count = sec->reloc_count;
2057 }
2058 else if (info->relocatable
2059 && (p->type == bfd_section_reloc_link_order
2060 || p->type == bfd_symbol_reloc_link_order))
2061 ++o->reloc_count;
2062 }
2063 if (o->reloc_count == 0)
2064 o->rel_filepos = 0;
2065 else
2066 {
2067 o->flags |= SEC_RELOC;
2068 o->rel_filepos = rel_filepos;
2069 rel_filepos += o->reloc_count * relsz;
2070 }
2071 }
2072
2073 /* If doing a relocatable link, allocate space for the pointers we
2074 need to keep. */
2075 if (info->relocatable)
2076 {
2077 unsigned int i;
2078
2079 /* We use section_count + 1, rather than section_count, because
2080 the target_index fields are 1 based. */
2081 amt = abfd->section_count + 1;
2082 amt *= sizeof (struct coff_link_section_info);
2083 flaginfo.section_info = (struct coff_link_section_info *) bfd_malloc (amt);
2084
2085 if (flaginfo.section_info == NULL)
2086 goto error_return;
2087
2088 for (i = 0; i <= abfd->section_count; i++)
2089 {
2090 flaginfo.section_info[i].relocs = NULL;
2091 flaginfo.section_info[i].rel_hashes = NULL;
2092 }
2093 }
2094
2095 /* We now know the size of the relocs, so we can determine the file
2096 positions of the line numbers. */
2097 line_filepos = rel_filepos;
2098 linesz = bfd_coff_linesz (abfd);
2099 max_output_reloc_count = 0;
2100
2101 for (o = abfd->sections; o != NULL; o = o->next)
2102 {
2103 if (o->lineno_count == 0)
2104 o->line_filepos = 0;
2105 else
2106 {
2107 o->line_filepos = line_filepos;
2108 line_filepos += o->lineno_count * linesz;
2109 }
2110
2111 if (o->reloc_count != 0)
2112 {
2113 /* We don't know the indices of global symbols until we have
2114 written out all the local symbols. For each section in
2115 the output file, we keep an array of pointers to hash
2116 table entries. Each entry in the array corresponds to a
2117 reloc. When we find a reloc against a global symbol, we
2118 set the corresponding entry in this array so that we can
2119 fix up the symbol index after we have written out all the
2120 local symbols.
2121
2122 Because of this problem, we also keep the relocs in
2123 memory until the end of the link. This wastes memory,
2124 but only when doing a relocatable link, which is not the
2125 common case. */
2126 BFD_ASSERT (info->relocatable);
2127 amt = o->reloc_count;
2128 amt *= sizeof (struct internal_reloc);
2129 flaginfo.section_info[o->target_index].relocs =
2130 (struct internal_reloc *) bfd_malloc (amt);
2131 amt = o->reloc_count;
2132 amt *= sizeof (struct coff_link_hash_entry *);
2133 flaginfo.section_info[o->target_index].rel_hashes =
2134 (struct coff_link_hash_entry **) bfd_malloc (amt);
2135 if (flaginfo.section_info[o->target_index].relocs == NULL
2136 || flaginfo.section_info[o->target_index].rel_hashes == NULL)
2137 goto error_return;
2138
2139 if (o->reloc_count > max_output_reloc_count)
2140 max_output_reloc_count = o->reloc_count;
2141 }
2142
2143 /* Reset the reloc and lineno counts, so that we can use them to
2144 count the number of entries we have output so far. */
2145 o->reloc_count = 0;
2146 o->lineno_count = 0;
2147 }
2148
2149 obj_sym_filepos (abfd) = line_filepos;
2150
2151 /* Figure out the largest number of symbols in an input BFD. Take
2152 the opportunity to clear the output_has_begun fields of all the
2153 input BFD's. */
2154 max_sym_count = 0;
2155 for (sub = info->input_bfds; sub != NULL; sub = sub->link.next)
2156 {
2157 bfd_size_type sz;
2158
2159 sub->output_has_begun = FALSE;
2160 sz = obj_raw_syment_count (sub);
2161 if (sz > max_sym_count)
2162 max_sym_count = sz;
2163 }
2164
2165 /* Allocate some buffers used while linking. */
2166 amt = max_sym_count * sizeof (struct internal_syment);
2167 flaginfo.internal_syms = (struct internal_syment *) bfd_malloc (amt);
2168 amt = max_sym_count * sizeof (asection *);
2169 flaginfo.sec_ptrs = (asection **) bfd_malloc (amt);
2170 amt = max_sym_count * sizeof (long);
2171 flaginfo.sym_indices = (long *) bfd_malloc (amt);
2172 amt = (max_sym_count + 1) * symesz;
2173 flaginfo.outsyms = (bfd_byte *) bfd_malloc (amt);
2174 amt = max_lineno_count * bfd_coff_linesz (abfd);
2175 flaginfo.linenos = (bfd_byte *) bfd_malloc (amt);
2176 flaginfo.contents = (bfd_byte *) bfd_malloc (max_contents_size);
2177 flaginfo.external_relocs = (bfd_byte *) bfd_malloc (max_reloc_count * relsz);
2178 if (! info->relocatable)
2179 {
2180 amt = max_reloc_count * sizeof (struct internal_reloc);
2181 flaginfo.internal_relocs = (struct internal_reloc *) bfd_malloc (amt);
2182 }
2183 if ((flaginfo.internal_syms == NULL && max_sym_count > 0)
2184 || (flaginfo.sec_ptrs == NULL && max_sym_count > 0)
2185 || (flaginfo.sym_indices == NULL && max_sym_count > 0)
2186 || flaginfo.outsyms == NULL
2187 || (flaginfo.linenos == NULL && max_lineno_count > 0)
2188 || (flaginfo.contents == NULL && max_contents_size > 0)
2189 || (flaginfo.external_relocs == NULL && max_reloc_count > 0)
2190 || (! info->relocatable
2191 && flaginfo.internal_relocs == NULL
2192 && max_reloc_count > 0))
2193 goto error_return;
2194
2195 /* We now know the position of everything in the file, except that
2196 we don't know the size of the symbol table and therefore we don't
2197 know where the string table starts. We just build the string
2198 table in memory as we go along. We process all the relocations
2199 for a single input file at once. */
2200 obj_raw_syment_count (abfd) = 0;
2201
2202 if (coff_backend_info (abfd)->_bfd_coff_start_final_link)
2203 {
2204 if (! bfd_coff_start_final_link (abfd, info))
2205 goto error_return;
2206 }
2207
2208 for (o = abfd->sections; o != NULL; o = o->next)
2209 {
2210 for (p = o->map_head.link_order; p != NULL; p = p->next)
2211 {
2212 if (p->type == bfd_indirect_link_order
2213 && (bfd_get_flavour (p->u.indirect.section->owner)
2214 == bfd_target_coff_flavour))
2215 {
2216 sub = p->u.indirect.section->owner;
2217 #ifdef POWERPC_LE_PE
2218 if (! sub->output_has_begun && !ppc_do_last(sub))
2219 #else
2220 if (! sub->output_has_begun)
2221 #endif
2222 {
2223 if (! _bfd_coff_link_input_bfd (&flaginfo, sub))
2224 goto error_return;
2225 sub->output_has_begun = TRUE;
2226 }
2227 }
2228 else if (p->type == bfd_section_reloc_link_order
2229 || p->type == bfd_symbol_reloc_link_order)
2230 {
2231 if (! _bfd_coff_reloc_link_order (abfd, &flaginfo, o, p))
2232 goto error_return;
2233 }
2234 else
2235 {
2236 if (! _bfd_default_link_order (abfd, info, o, p))
2237 goto error_return;
2238 }
2239 }
2240 }
2241
2242 #ifdef POWERPC_LE_PE
2243 {
2244 bfd* last_one = ppc_get_last();
2245 if (last_one)
2246 {
2247 if (! _bfd_coff_link_input_bfd (&flaginfo, last_one))
2248 goto error_return;
2249 }
2250 last_one->output_has_begun = TRUE;
2251 }
2252 #endif
2253
2254 /* Free up the buffers used by _bfd_coff_link_input_bfd. */
2255 coff_debug_merge_hash_table_free (&flaginfo.debug_merge);
2256 debug_merge_allocated = FALSE;
2257
2258 if (flaginfo.internal_syms != NULL)
2259 {
2260 free (flaginfo.internal_syms);
2261 flaginfo.internal_syms = NULL;
2262 }
2263 if (flaginfo.sec_ptrs != NULL)
2264 {
2265 free (flaginfo.sec_ptrs);
2266 flaginfo.sec_ptrs = NULL;
2267 }
2268 if (flaginfo.sym_indices != NULL)
2269 {
2270 free (flaginfo.sym_indices);
2271 flaginfo.sym_indices = NULL;
2272 }
2273 if (flaginfo.linenos != NULL)
2274 {
2275 free (flaginfo.linenos);
2276 flaginfo.linenos = NULL;
2277 }
2278 if (flaginfo.contents != NULL)
2279 {
2280 free (flaginfo.contents);
2281 flaginfo.contents = NULL;
2282 }
2283 if (flaginfo.external_relocs != NULL)
2284 {
2285 free (flaginfo.external_relocs);
2286 flaginfo.external_relocs = NULL;
2287 }
2288 if (flaginfo.internal_relocs != NULL)
2289 {
2290 free (flaginfo.internal_relocs);
2291 flaginfo.internal_relocs = NULL;
2292 }
2293
2294 /* The value of the last C_FILE symbol is supposed to be the symbol
2295 index of the first external symbol. Write it out again if
2296 necessary. */
2297 if (flaginfo.last_file_index != -1
2298 && (unsigned int) flaginfo.last_file.n_value != obj_raw_syment_count (abfd))
2299 {
2300 file_ptr pos;
2301
2302 flaginfo.last_file.n_value = obj_raw_syment_count (abfd);
2303 bfd_coff_swap_sym_out (abfd, &flaginfo.last_file,
2304 flaginfo.outsyms);
2305 pos = obj_sym_filepos (abfd) + flaginfo.last_file_index * symesz;
2306 if (bfd_seek (abfd, pos, SEEK_SET) != 0
2307 || bfd_bwrite (flaginfo.outsyms, symesz, abfd) != symesz)
2308 return FALSE;
2309 }
2310
2311 /* Write out the global symbols. */
2312 flaginfo.failed = FALSE;
2313 bfd_hash_traverse (&info->hash->table, _bfd_coff_write_global_sym, &flaginfo);
2314 if (flaginfo.failed)
2315 goto error_return;
2316
2317 /* The outsyms buffer is used by _bfd_coff_write_global_sym. */
2318 if (flaginfo.outsyms != NULL)
2319 {
2320 free (flaginfo.outsyms);
2321 flaginfo.outsyms = NULL;
2322 }
2323
2324 if (info->relocatable)
2325 {
2326 /* Now that we have written out all the global symbols, we know
2327 the symbol indices to use for relocs against them, and we can
2328 finally write out the relocs. */
2329 amt = max_output_reloc_count * relsz;
2330 external_relocs = (bfd_byte *) bfd_malloc (amt);
2331 if (external_relocs == NULL)
2332 goto error_return;
2333
2334 for (o = abfd->sections; o != NULL; o = o->next)
2335 {
2336 struct internal_reloc *irel;
2337 struct internal_reloc *irelend;
2338 struct coff_link_hash_entry **rel_hash;
2339 bfd_byte *erel;
2340
2341 if (o->reloc_count == 0)
2342 continue;
2343
2344 irel = flaginfo.section_info[o->target_index].relocs;
2345 irelend = irel + o->reloc_count;
2346 rel_hash = flaginfo.section_info[o->target_index].rel_hashes;
2347 erel = external_relocs;
2348 for (; irel < irelend; irel++, rel_hash++, erel += relsz)
2349 {
2350 if (*rel_hash != NULL)
2351 {
2352 BFD_ASSERT ((*rel_hash)->indx >= 0);
2353 irel->r_symndx = (*rel_hash)->indx;
2354 }
2355 bfd_coff_swap_reloc_out (abfd, irel, erel);
2356 }
2357
2358 amt = relsz * o->reloc_count;
2359 if (bfd_seek (abfd, o->rel_filepos, SEEK_SET) != 0
2360 || bfd_bwrite (external_relocs, amt, abfd) != amt)
2361 goto error_return;
2362 }
2363
2364 free (external_relocs);
2365 external_relocs = NULL;
2366 }
2367
2368 /* Free up the section information. */
2369 if (flaginfo.section_info != NULL)
2370 {
2371 unsigned int i;
2372
2373 for (i = 0; i < abfd->section_count; i++)
2374 {
2375 if (flaginfo.section_info[i].relocs != NULL)
2376 free (flaginfo.section_info[i].relocs);
2377 if (flaginfo.section_info[i].rel_hashes != NULL)
2378 free (flaginfo.section_info[i].rel_hashes);
2379 }
2380 free (flaginfo.section_info);
2381 flaginfo.section_info = NULL;
2382 }
2383
2384 /* If we have optimized stabs strings, output them. */
2385 if (coff_hash_table (info)->stab_info.stabstr != NULL)
2386 {
2387 if (! _bfd_write_stab_strings (abfd, &coff_hash_table (info)->stab_info))
2388 return FALSE;
2389 }
2390
2391 /* Write out the string table. */
2392 if (obj_raw_syment_count (abfd) != 0)
2393 {
2394 file_ptr pos;
2395
2396 pos = obj_sym_filepos (abfd) + obj_raw_syment_count (abfd) * symesz;
2397 if (bfd_seek (abfd, pos, SEEK_SET) != 0)
2398 return FALSE;
2399
2400 #if STRING_SIZE_SIZE == 4
2401 H_PUT_32 (abfd,
2402 _bfd_stringtab_size (flaginfo.strtab) + STRING_SIZE_SIZE,
2403 strbuf);
2404 #else
2405 #error Change H_PUT_32 above
2406 #endif
2407
2408 if (bfd_bwrite (strbuf, (bfd_size_type) STRING_SIZE_SIZE, abfd)
2409 != STRING_SIZE_SIZE)
2410 return FALSE;
2411
2412 if (! _bfd_stringtab_emit (abfd, flaginfo.strtab))
2413 return FALSE;
2414 }
2415
2416 _bfd_stringtab_free (flaginfo.strtab);
2417
2418 /* Setting bfd_get_symcount to 0 will cause write_object_contents to
2419 not try to write out the symbols. */
2420 bfd_get_symcount (abfd) = 0;
2421
2422 return TRUE;
2423
2424 error_return:
2425 if (debug_merge_allocated)
2426 coff_debug_merge_hash_table_free (&flaginfo.debug_merge);
2427 if (flaginfo.strtab != NULL)
2428 _bfd_stringtab_free (flaginfo.strtab);
2429 if (flaginfo.section_info != NULL)
2430 {
2431 unsigned int i;
2432
2433 for (i = 0; i < abfd->section_count; i++)
2434 {
2435 if (flaginfo.section_info[i].relocs != NULL)
2436 free (flaginfo.section_info[i].relocs);
2437 if (flaginfo.section_info[i].rel_hashes != NULL)
2438 free (flaginfo.section_info[i].rel_hashes);
2439 }
2440 free (flaginfo.section_info);
2441 }
2442 if (flaginfo.internal_syms != NULL)
2443 free (flaginfo.internal_syms);
2444 if (flaginfo.sec_ptrs != NULL)
2445 free (flaginfo.sec_ptrs);
2446 if (flaginfo.sym_indices != NULL)
2447 free (flaginfo.sym_indices);
2448 if (flaginfo.outsyms != NULL)
2449 free (flaginfo.outsyms);
2450 if (flaginfo.linenos != NULL)
2451 free (flaginfo.linenos);
2452 if (flaginfo.contents != NULL)
2453 free (flaginfo.contents);
2454 if (flaginfo.external_relocs != NULL)
2455 free (flaginfo.external_relocs);
2456 if (flaginfo.internal_relocs != NULL)
2457 free (flaginfo.internal_relocs);
2458 if (external_relocs != NULL)
2459 free (external_relocs);
2460 return FALSE;
2461 }
2462 #endif
2463
2464 /* Forward declaration for use by alternative_target field. */
2465 #ifdef TARGET_BIG_SYM
2466 extern const bfd_target TARGET_BIG_SYM;
2467 #endif
2468
2469 /* The transfer vectors that lead the outside world to all of the above. */
2470
2471 #ifdef TARGET_LITTLE_SYM
2472 const bfd_target TARGET_LITTLE_SYM =
2473 {
2474 TARGET_LITTLE_NAME, /* name or coff-arm-little */
2475 bfd_target_coff_flavour,
2476 BFD_ENDIAN_LITTLE, /* data byte order is little */
2477 BFD_ENDIAN_LITTLE, /* header byte order is little */
2478
2479 (HAS_RELOC | EXEC_P | /* FIXME: object flags */
2480 HAS_LINENO | HAS_DEBUG |
2481 HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED),
2482
2483 #ifndef COFF_WITH_PE
2484 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY
2485 | SEC_RELOC), /* section flags */
2486 #else
2487 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY
2488 | SEC_RELOC | SEC_LINK_ONCE | SEC_LINK_DUPLICATES),
2489 #endif
2490
2491 0, /* leading char */
2492 '/', /* ar_pad_char */
2493 15, /* ar_max_namelen??? FIXMEmgo */
2494 0, /* match priority. */
2495
2496 bfd_getl64, bfd_getl_signed_64, bfd_putl64,
2497 bfd_getl32, bfd_getl_signed_32, bfd_putl32,
2498 bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* data */
2499
2500 bfd_getl64, bfd_getl_signed_64, bfd_putl64,
2501 bfd_getl32, bfd_getl_signed_32, bfd_putl32,
2502 bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* hdrs */
2503
2504 {_bfd_dummy_target, coff_object_p, /* bfd_check_format */
2505 bfd_generic_archive_p, /* _bfd_dummy_target */ coff_object_p },
2506 {bfd_false, coff_mkobject, _bfd_generic_mkarchive, /* bfd_set_format */
2507 bfd_false},
2508 {bfd_false, coff_write_object_contents, /* bfd_write_contents */
2509 _bfd_write_archive_contents, bfd_false},
2510
2511 BFD_JUMP_TABLE_GENERIC (coff),
2512 BFD_JUMP_TABLE_COPY (coff),
2513 BFD_JUMP_TABLE_CORE (_bfd_nocore),
2514 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff),
2515 BFD_JUMP_TABLE_SYMBOLS (coff),
2516 BFD_JUMP_TABLE_RELOCS (coff),
2517 BFD_JUMP_TABLE_WRITE (coff),
2518 BFD_JUMP_TABLE_LINK (coff),
2519 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
2520
2521 /* Alternative_target. */
2522 #ifdef TARGET_BIG_SYM
2523 & TARGET_BIG_SYM,
2524 #else
2525 NULL,
2526 #endif
2527
2528 COFF_SWAP_TABLE
2529 };
2530 #endif
2531
2532 #ifdef TARGET_BIG_SYM
2533 const bfd_target TARGET_BIG_SYM =
2534 {
2535 TARGET_BIG_NAME,
2536 bfd_target_coff_flavour,
2537 BFD_ENDIAN_BIG, /* data byte order is big */
2538 BFD_ENDIAN_BIG, /* header byte order is big */
2539
2540 (HAS_RELOC | EXEC_P | /* FIXME: object flags */
2541 HAS_LINENO | HAS_DEBUG |
2542 HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED),
2543
2544 #ifndef COFF_WITH_PE
2545 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY
2546 | SEC_RELOC), /* section flags */
2547 #else
2548 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY
2549 | SEC_RELOC | SEC_LINK_ONCE | SEC_LINK_DUPLICATES),
2550 #endif
2551
2552 0, /* leading char */
2553 '/', /* ar_pad_char */
2554 15, /* ar_max_namelen??? FIXMEmgo */
2555 0, /* match priority. */
2556
2557 bfd_getb64, bfd_getb_signed_64, bfd_putb64,
2558 bfd_getb32, bfd_getb_signed_32, bfd_putb32,
2559 bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* data */
2560
2561 bfd_getb64, bfd_getb_signed_64, bfd_putb64,
2562 bfd_getb32, bfd_getb_signed_32, bfd_putb32,
2563 bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* hdrs */
2564
2565 {_bfd_dummy_target, coff_object_p, /* bfd_check_format */
2566 bfd_generic_archive_p, /* _bfd_dummy_target */ coff_object_p },
2567 {bfd_false, coff_mkobject, _bfd_generic_mkarchive, /* bfd_set_format */
2568 bfd_false},
2569 {bfd_false, coff_write_object_contents, /* bfd_write_contents */
2570 _bfd_write_archive_contents, bfd_false},
2571
2572 BFD_JUMP_TABLE_GENERIC (coff),
2573 BFD_JUMP_TABLE_COPY (coff),
2574 BFD_JUMP_TABLE_CORE (_bfd_nocore),
2575 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff),
2576 BFD_JUMP_TABLE_SYMBOLS (coff),
2577 BFD_JUMP_TABLE_RELOCS (coff),
2578 BFD_JUMP_TABLE_WRITE (coff),
2579 BFD_JUMP_TABLE_LINK (coff),
2580 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
2581
2582 /* Alternative_target. */
2583 #ifdef TARGET_LITTLE_SYM
2584 & TARGET_LITTLE_SYM,
2585 #else
2586 NULL,
2587 #endif
2588
2589 COFF_SWAP_TABLE
2590 };
2591
2592 #endif
2593