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