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