?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
* ar.c (move_members): Plug memory leak.
[binutils.git] / bfd / coff-ppc.c
blob69e10d8c6671a5b3c230d11e7ee345777b742075
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, 2009, 2010, 2011
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 int *local_syms;
871
872 h = 0;
873
874 h = (struct ppc_coff_link_hash_entry *) (obj_coff_sym_hashes (abfd)[sym]);
875 if (h != 0)
876 {
877 HASH_CHECK(h);
878 }
879
880 if (h == 0)
881 {
882 local_syms = obj_coff_local_toc_table(abfd);
883
884 if (local_syms == 0)
885 {
886 unsigned int i;
887 bfd_size_type amt;
888
889 /* allocate a table */
890 amt = (bfd_size_type) obj_raw_syment_count (abfd) * sizeof (int);
891 local_syms = (int *) bfd_zalloc (abfd, amt);
892 if (local_syms == 0)
893 return FALSE;
894 obj_coff_local_toc_table (abfd) = local_syms;
895
896 for (i = 0; i < obj_raw_syment_count (abfd); ++i)
897 {
898 SET_UNALLOCATED (local_syms[i]);
899 }
900 }
901
902 if (IS_UNALLOCATED(local_syms[sym]))
903 {
904 local_syms[sym] = global_toc_size;
905 global_toc_size += 4;
906
907 /* The size must fit in a 16-bit displacement. */
908 if (global_toc_size > 65535)
909 {
910 (*_bfd_error_handler) (_("TOC overflow"));
911 bfd_set_error (bfd_error_file_too_big);
912 return FALSE;
913 }
914 }
915 }
916 else
917 {
918 /* Check to see if there's a toc slot allocated. If not, do it
919 here. It will be used in relocate_section. */
920 if (IS_UNALLOCATED(h->toc_offset))
921 {
922 h->toc_offset = global_toc_size;
923 global_toc_size += 4;
924
925 /* The size must fit in a 16-bit displacement. */
926 if (global_toc_size >= 65535)
927 {
928 (*_bfd_error_handler) (_("TOC overflow"));
929 bfd_set_error (bfd_error_file_too_big);
930 return FALSE;
931 }
932 }
933 }
934
935 return TRUE;
936 }
937
938 /* Record a toc offset against a symbol. */
939 static void
940 ppc_mark_symbol_as_glue(abfd, sym, rel)
941 bfd *abfd;
942 int sym;
943 struct internal_reloc *rel;
944 {
945 struct ppc_coff_link_hash_entry *h;
946
947 h = (struct ppc_coff_link_hash_entry *) (obj_coff_sym_hashes (abfd)[sym]);
948
949 HASH_CHECK(h);
950
951 h->symbol_is_glue = 1;
952 h->glue_insn = bfd_get_32 (abfd, (bfd_byte *) &rel->r_vaddr);
953
954 return;
955 }
956
957 #endif /* COFF_IMAGE_WITH_PE */
958 \f
959 /* Return TRUE if this relocation should
960 appear in the output .reloc section. */
961
962 static bfd_boolean in_reloc_p(abfd, howto)
963 bfd * abfd ATTRIBUTE_UNUSED;
964 reloc_howto_type *howto;
965 {
966 return
967 (! howto->pc_relative)
968 && (howto->type != IMAGE_REL_PPC_ADDR32NB)
969 && (howto->type != IMAGE_REL_PPC_TOCREL16)
970 && (howto->type != IMAGE_REL_PPC_IMGLUE)
971 && (howto->type != IMAGE_REL_PPC_IFGLUE)
972 && (howto->type != IMAGE_REL_PPC_SECREL)
973 && (howto->type != IMAGE_REL_PPC_SECTION)
974 && (howto->type != IMAGE_REL_PPC_SECREL16)
975 && (howto->type != IMAGE_REL_PPC_REFHI)
976 && (howto->type != IMAGE_REL_PPC_REFLO)
977 && (howto->type != IMAGE_REL_PPC_PAIR)
978 && (howto->type != IMAGE_REL_PPC_TOCREL16_DEFN) ;
979 }
980
981 static bfd_boolean
982 write_base_file_entry (bfd *obfd, struct bfd_link_info *info, bfd_vma addr)
983 {
984 if (coff_data (obfd)->pe)
985 addr -= pe_data (obfd)->pe_opthdr.ImageBase;
986 if (fwrite (&addr, sizeof (addr), 1, (FILE *) info->base_file) == 1)
987 return TRUE;
988
989 bfd_set_error (bfd_error_system_call);
990 return FALSE;
991 }
992
993 /* The reloc processing routine for the optimized COFF linker. */
994
995 static bfd_boolean
996 coff_ppc_relocate_section (output_bfd, info, input_bfd, input_section,
997 contents, relocs, syms, sections)
998 bfd *output_bfd;
999 struct bfd_link_info *info;
1000 bfd *input_bfd;
1001 asection *input_section;
1002 bfd_byte *contents;
1003 struct internal_reloc *relocs;
1004 struct internal_syment *syms;
1005 asection **sections;
1006 {
1007 struct internal_reloc *rel;
1008 struct internal_reloc *relend;
1009 asection *toc_section = 0;
1010 bfd_vma relocation;
1011 reloc_howto_type *howto = 0;
1012
1013 /* If we are performing a relocatable link, we don't need to do a
1014 thing. The caller will take care of adjusting the reloc
1015 addresses and symbol indices. */
1016 if (info->relocatable)
1017 return TRUE;
1018
1019 rel = relocs;
1020 relend = rel + input_section->reloc_count;
1021 for (; rel < relend; rel++)
1022 {
1023 long symndx;
1024 struct ppc_coff_link_hash_entry *h;
1025 struct internal_syment *sym;
1026 bfd_vma val;
1027
1028 asection *sec;
1029 bfd_reloc_status_type rstat;
1030 bfd_byte *loc;
1031
1032 unsigned short r_type = EXTRACT_TYPE (rel->r_type);
1033 unsigned short r_flags = EXTRACT_FLAGS(rel->r_type);
1034
1035 symndx = rel->r_symndx;
1036 loc = contents + rel->r_vaddr - input_section->vma;
1037
1038 /* FIXME: check bounds on r_type */
1039 howto = ppc_coff_howto_table + r_type;
1040
1041 if (symndx == -1)
1042 {
1043 h = NULL;
1044 sym = NULL;
1045 }
1046 else
1047 {
1048 h = (struct ppc_coff_link_hash_entry *)
1049 (obj_coff_sym_hashes (input_bfd)[symndx]);
1050 if (h != 0)
1051 {
1052 HASH_CHECK(h);
1053 }
1054
1055 sym = syms + symndx;
1056 }
1057
1058 if (r_type == IMAGE_REL_PPC_IMGLUE && h == 0)
1059 {
1060 /* An IMGLUE reloc must have a name. Something is very wrong. */
1061 abort ();
1062 }
1063
1064 sec = NULL;
1065 val = 0;
1066
1067 /* FIXME: PAIR unsupported in the following code. */
1068 if (h == NULL)
1069 {
1070 if (symndx == -1)
1071 sec = bfd_abs_section_ptr;
1072 else
1073 {
1074 sec = sections[symndx];
1075 val = (sec->output_section->vma
1076 + sec->output_offset
1077 + sym->n_value);
1078 if (! obj_pe (output_bfd))
1079 val -= sec->vma;
1080 }
1081 }
1082 else
1083 {
1084 HASH_CHECK(h);
1085
1086 if (h->root.root.type == bfd_link_hash_defined
1087 || h->root.root.type == bfd_link_hash_defweak)
1088 {
1089 sec = h->root.root.u.def.section;
1090 val = (h->root.root.u.def.value
1091 + sec->output_section->vma
1092 + sec->output_offset);
1093 }
1094 else
1095 {
1096 if (! ((*info->callbacks->undefined_symbol)
1097 (info, h->root.root.root.string, input_bfd, input_section,
1098 rel->r_vaddr - input_section->vma, TRUE)))
1099 return FALSE;
1100 }
1101 }
1102
1103 rstat = bfd_reloc_ok;
1104
1105 /* Each case must do its own relocation, setting rstat appropriately. */
1106 switch (r_type)
1107 {
1108 default:
1109 (*_bfd_error_handler)
1110 (_("%B: unsupported relocation type 0x%02x"), input_bfd, r_type);
1111 bfd_set_error (bfd_error_bad_value);
1112 return FALSE;
1113 case IMAGE_REL_PPC_TOCREL16:
1114 {
1115 bfd_signed_vma our_toc_offset;
1116 int fixit;
1117
1118 DUMP_RELOC2(howto->name, rel);
1119
1120 if (toc_section == 0)
1121 {
1122 toc_section = bfd_get_section_by_name (bfd_of_toc_owner,
1123 TOC_SECTION_NAME);
1124
1125 if ( toc_section == NULL )
1126 {
1127 /* There is no toc section. Something is very wrong. */
1128 abort ();
1129 }
1130 }
1131
1132 /* Amazing bit tricks present. As we may have seen earlier, we
1133 use the 1 bit to tell us whether or not a toc offset has been
1134 allocated. Now that they've all been allocated, we will use
1135 the 1 bit to tell us if we've written this particular toc
1136 entry out. */
1137 fixit = FALSE;
1138 if (h == 0)
1139 {
1140 /* It is a file local symbol. */
1141 int *local_toc_table;
1142 const char *name;
1143
1144 sym = syms + symndx;
1145 name = sym->_n._n_name;
1146
1147 local_toc_table = obj_coff_local_toc_table(input_bfd);
1148 our_toc_offset = local_toc_table[symndx];
1149
1150 if (IS_WRITTEN(our_toc_offset))
1151 {
1152 /* If it has been written out, it is marked with the
1153 1 bit. Fix up our offset, but do not write it out
1154 again. */
1155 MAKE_ADDR_AGAIN(our_toc_offset);
1156 }
1157 else
1158 {
1159 /* Write out the toc entry. */
1160 record_toc (toc_section, our_toc_offset, priv,
1161 strdup (name));
1162
1163 bfd_put_32 (output_bfd, val,
1164 toc_section->contents + our_toc_offset);
1165
1166 MARK_AS_WRITTEN(local_toc_table[symndx]);
1167 fixit = TRUE;
1168 }
1169 }
1170 else
1171 {
1172 const char *name = h->root.root.root.string;
1173 our_toc_offset = h->toc_offset;
1174
1175 if ((r_flags & IMAGE_REL_PPC_TOCDEFN)
1176 == IMAGE_REL_PPC_TOCDEFN )
1177 {
1178 /* This is unbelievable cheese. Some knowledgable asm
1179 hacker has decided to use r2 as a base for loading
1180 a value. He/She does this by setting the tocdefn bit,
1181 and not supplying a toc definition. The behaviour is
1182 then to use the difference between the value of the
1183 symbol and the actual location of the toc as the toc
1184 index.
1185
1186 In fact, what is usually happening is, because the
1187 Import Address Table is mapped immediately following
1188 the toc, some trippy library code trying for speed on
1189 dll linkage, takes advantage of that and considers
1190 the IAT to be part of the toc, thus saving a load. */
1191
1192 our_toc_offset = val - (toc_section->output_section->vma
1193 + toc_section->output_offset);
1194
1195 /* The size must still fit in a 16-bit displacement. */
1196 if ((bfd_vma) our_toc_offset >= 65535)
1197 {
1198 (*_bfd_error_handler)
1199 (_("%B: Relocation for %s of %lx exceeds Toc size limit"),
1200 input_bfd, name,
1201 (unsigned long) our_toc_offset);
1202 bfd_set_error (bfd_error_bad_value);
1203 return FALSE;
1204 }
1205
1206 record_toc (toc_section, our_toc_offset, pub,
1207 strdup (name));
1208 }
1209 else if (IS_WRITTEN (our_toc_offset))
1210 {
1211 /* If it has been written out, it is marked with the
1212 1 bit. Fix up our offset, but do not write it out
1213 again. */
1214 MAKE_ADDR_AGAIN(our_toc_offset);
1215 }
1216 else
1217 {
1218 record_toc(toc_section, our_toc_offset, pub,
1219 strdup (name));
1220
1221 /* Write out the toc entry. */
1222 bfd_put_32 (output_bfd, val,
1223 toc_section->contents + our_toc_offset);
1224
1225 MARK_AS_WRITTEN(h->toc_offset);
1226 /* The tricky part is that this is the address that
1227 needs a .reloc entry for it. */
1228 fixit = TRUE;
1229 }
1230 }
1231
1232 if (fixit && info->base_file)
1233 {
1234 /* So if this is non pcrelative, and is referenced
1235 to a section or a common symbol, then it needs a reloc. */
1236
1237 /* Relocation to a symbol in a section which
1238 isn't absolute - we output the address here
1239 to a file. */
1240 bfd_vma addr = (toc_section->output_section->vma
1241 + toc_section->output_offset + our_toc_offset);
1242
1243 if (!write_base_file_entry (output_bfd, info, addr))
1244 return FALSE;
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 DUMP_RELOC2 (howto->name, rel);
1270
1271 if (h != 0)
1272 {
1273 if (h->symbol_is_glue == 1)
1274 {
1275 bfd_put_32 (input_bfd, (bfd_vma) h->glue_insn, loc);
1276 }
1277 }
1278 }
1279 break;
1280 case IMAGE_REL_PPC_SECREL:
1281 /* Unimplemented: codeview debugging information. */
1282 /* For fast access to the header of the section
1283 containing the item. */
1284 break;
1285 case IMAGE_REL_PPC_SECTION:
1286 /* Unimplemented: codeview debugging information. */
1287 /* Is used to indicate that the value should be relative
1288 to the beginning of the section that contains the
1289 symbol. */
1290 break;
1291 case IMAGE_REL_PPC_ABSOLUTE:
1292 {
1293 const char *my_name;
1294
1295 if (h == 0)
1296 my_name = (syms+symndx)->_n._n_name;
1297 else
1298 my_name = h->root.root.root.string;
1299
1300 (*_bfd_error_handler)
1301 (_("Warning: unsupported reloc %s <file %B, section %A>\n"
1302 "sym %ld (%s), r_vaddr %ld (%lx)"),
1303 input_bfd, input_section, howto->name,
1304 rel->r_symndx, my_name, (long) rel->r_vaddr,
1305 (unsigned long) rel->r_vaddr);
1306 }
1307 break;
1308 case IMAGE_REL_PPC_IMGLUE:
1309 {
1310 /* There is nothing to do now. This reloc was noted in the first
1311 pass over the relocs, and the glue instruction extracted. */
1312 const char *my_name;
1313
1314 if (h->symbol_is_glue == 1)
1315 break;
1316 my_name = h->root.root.root.string;
1317
1318 (*_bfd_error_handler)
1319 (_("%B: Out of order IMGLUE reloc for %s"), input_bfd, my_name);
1320 bfd_set_error (bfd_error_bad_value);
1321 return FALSE;
1322 }
1323
1324 case IMAGE_REL_PPC_ADDR32NB:
1325 {
1326 const char *name = 0;
1327
1328 DUMP_RELOC2 (howto->name, rel);
1329
1330 if (CONST_STRNEQ (input_section->name, ".idata$2") && first_thunk_address == 0)
1331 {
1332 /* Set magic values. */
1333 int idata5offset;
1334 struct coff_link_hash_entry *myh;
1335
1336 myh = coff_link_hash_lookup (coff_hash_table (info),
1337 "__idata5_magic__",
1338 FALSE, FALSE, TRUE);
1339 first_thunk_address = myh->root.u.def.value +
1340 sec->output_section->vma +
1341 sec->output_offset -
1342 pe_data(output_bfd)->pe_opthdr.ImageBase;
1343
1344 idata5offset = myh->root.u.def.value;
1345 myh = coff_link_hash_lookup (coff_hash_table (info),
1346 "__idata6_magic__",
1347 FALSE, FALSE, TRUE);
1348
1349 thunk_size = myh->root.u.def.value - idata5offset;
1350 myh = coff_link_hash_lookup (coff_hash_table (info),
1351 "__idata4_magic__",
1352 FALSE, FALSE, TRUE);
1353 import_table_size = myh->root.u.def.value;
1354 }
1355
1356 if (h == 0)
1357 {
1358 /* It is a file local symbol. */
1359 sym = syms + symndx;
1360 name = sym->_n._n_name;
1361 }
1362 else
1363 {
1364 char *target = 0;
1365
1366 name = h->root.root.root.string;
1367 if (strcmp (".idata$2", name) == 0)
1368 target = "__idata2_magic__";
1369 else if (strcmp (".idata$4", name) == 0)
1370 target = "__idata4_magic__";
1371 else if (strcmp (".idata$5", name) == 0)
1372 target = "__idata5_magic__";
1373
1374 if (target != 0)
1375 {
1376 struct coff_link_hash_entry *myh;
1377
1378 myh = coff_link_hash_lookup (coff_hash_table (info),
1379 target,
1380 FALSE, FALSE, TRUE);
1381 if (myh == 0)
1382 {
1383 /* Missing magic cookies. Something is very wrong. */
1384 abort ();
1385 }
1386
1387 val = myh->root.u.def.value +
1388 sec->output_section->vma + sec->output_offset;
1389 if (first_thunk_address == 0)
1390 {
1391 int idata5offset;
1392 myh = coff_link_hash_lookup (coff_hash_table (info),
1393 "__idata5_magic__",
1394 FALSE, FALSE, TRUE);
1395 first_thunk_address = myh->root.u.def.value +
1396 sec->output_section->vma +
1397 sec->output_offset -
1398 pe_data(output_bfd)->pe_opthdr.ImageBase;
1399
1400 idata5offset = myh->root.u.def.value;
1401 myh = coff_link_hash_lookup (coff_hash_table (info),
1402 "__idata6_magic__",
1403 FALSE, FALSE, TRUE);
1404
1405 thunk_size = myh->root.u.def.value - idata5offset;
1406 myh = coff_link_hash_lookup (coff_hash_table (info),
1407 "__idata4_magic__",
1408 FALSE, FALSE, TRUE);
1409 import_table_size = myh->root.u.def.value;
1410 }
1411 }
1412 }
1413
1414 rstat = _bfd_relocate_contents (howto,
1415 input_bfd,
1416 val -
1417 pe_data (output_bfd)->pe_opthdr.ImageBase,
1418 loc);
1419 }
1420 break;
1421
1422 case IMAGE_REL_PPC_REL24:
1423 DUMP_RELOC2(howto->name, rel);
1424 val -= (input_section->output_section->vma
1425 + input_section->output_offset);
1426
1427 rstat = _bfd_relocate_contents (howto,
1428 input_bfd,
1429 val,
1430 loc);
1431 break;
1432 case IMAGE_REL_PPC_ADDR16:
1433 case IMAGE_REL_PPC_ADDR24:
1434 case IMAGE_REL_PPC_ADDR32:
1435 DUMP_RELOC2(howto->name, rel);
1436 rstat = _bfd_relocate_contents (howto,
1437 input_bfd,
1438 val,
1439 loc);
1440 break;
1441 }
1442
1443 if (info->base_file)
1444 {
1445 /* So if this is non pcrelative, and is referenced
1446 to a section or a common symbol, then it needs a reloc. */
1447 if (sym && pe_data(output_bfd)->in_reloc_p (output_bfd, howto))
1448 {
1449 /* Relocation to a symbol in a section which
1450 isn't absolute - we output the address here
1451 to a file. */
1452 bfd_vma addr = (rel->r_vaddr
1453 - input_section->vma
1454 + input_section->output_offset
1455 + input_section->output_section->vma);
1456
1457 if (!write_base_file_entry (output_bfd, info, addr))
1458 return FALSE;
1459 }
1460 }
1461
1462 switch (rstat)
1463 {
1464 default:
1465 abort ();
1466 case bfd_reloc_ok:
1467 break;
1468 case bfd_reloc_overflow:
1469 {
1470 const char *name;
1471 char buf[SYMNMLEN + 1];
1472
1473 if (symndx == -1)
1474 name = "*ABS*";
1475 else if (h != NULL)
1476 name = NULL;
1477 else if (sym == NULL)
1478 name = "*unknown*";
1479 else if (sym->_n._n_n._n_zeroes == 0
1480 && sym->_n._n_n._n_offset != 0)
1481 name = obj_coff_strings (input_bfd) + sym->_n._n_n._n_offset;
1482 else
1483 {
1484 strncpy (buf, sym->_n._n_name, SYMNMLEN);
1485 buf[SYMNMLEN] = '\0';
1486 name = buf;
1487 }
1488
1489 if (! ((*info->callbacks->reloc_overflow)
1490 (info, (h ? &h->root.root : NULL), name, howto->name,
1491 (bfd_vma) 0, input_bfd,
1492 input_section, rel->r_vaddr - input_section->vma)))
1493 return FALSE;
1494 }
1495 }
1496 }
1497
1498 return TRUE;
1499 }
1500
1501 #ifdef COFF_IMAGE_WITH_PE
1502
1503 /* FIXME: BFD should not use global variables. This file is compiled
1504 twice, and these variables are shared. This is confusing and
1505 weird. */
1506
1507 long int global_toc_size = 4;
1508
1509 bfd* bfd_of_toc_owner = 0;
1510
1511 long int import_table_size;
1512 long int first_thunk_address;
1513 long int thunk_size;
1514
1515 struct list_ele *head;
1516 struct list_ele *tail;
1517
1518 static char *
1519 h1 = N_("\n\t\t\tTOC MAPPING\n\n");
1520 static char *
1521 h2 = N_(" TOC disassembly Comments Name\n");
1522 static char *
1523 h3 = N_(" Offset spelling (if present)\n");
1524
1525 void
1526 dump_toc (vfile)
1527 PTR vfile;
1528 {
1529 FILE *file = (FILE *) vfile;
1530 struct list_ele *t;
1531
1532 fputs (_(h1), file);
1533 fputs (_(h2), file);
1534 fputs (_(h3), file);
1535
1536 for (t = head; t != 0; t=t->next)
1537 {
1538 const char *cat = "";
1539
1540 if (t->cat == priv)
1541 cat = _("private ");
1542 else if (t->cat == pub)
1543 cat = _("public ");
1544 else if (t->cat == tocdata)
1545 cat = _("data-in-toc ");
1546
1547 if (t->offset > global_toc_size)
1548 {
1549 if (t->offset <= global_toc_size + thunk_size)
1550 cat = _("IAT reference ");
1551 else
1552 {
1553 fprintf (file,
1554 _("**** global_toc_size %ld(%lx), thunk_size %ld(%lx)\n"),
1555 global_toc_size, (unsigned long) global_toc_size,
1556 thunk_size, (unsigned long) thunk_size);
1557 cat = _("Out of bounds!");
1558 }
1559 }
1560
1561 fprintf (file,
1562 " %04lx (%d)", (unsigned long) t->offset, t->offset - 32768);
1563 fprintf (file,
1564 " %s %s\n",
1565 cat, t->name);
1566
1567 }
1568
1569 fprintf (file, "\n");
1570 }
1571
1572 bfd_boolean
1573 ppc_allocate_toc_section (info)
1574 struct bfd_link_info *info ATTRIBUTE_UNUSED;
1575 {
1576 asection *s;
1577 bfd_byte *foo;
1578 bfd_size_type amt;
1579 static char test_char = '1';
1580
1581 if ( global_toc_size == 0 ) /* FIXME: does this get me in trouble? */
1582 return TRUE;
1583
1584 if (bfd_of_toc_owner == 0)
1585 /* No toc owner? Something is very wrong. */
1586 abort ();
1587
1588 s = bfd_get_section_by_name ( bfd_of_toc_owner , TOC_SECTION_NAME);
1589 if (s == NULL)
1590 /* No toc section? Something is very wrong. */
1591 abort ();
1592
1593 amt = global_toc_size;
1594 foo = (bfd_byte *) bfd_alloc (bfd_of_toc_owner, amt);
1595 memset(foo, test_char, (size_t) global_toc_size);
1596
1597 s->size = global_toc_size;
1598 s->contents = foo;
1599
1600 return TRUE;
1601 }
1602
1603 bfd_boolean
1604 ppc_process_before_allocation (abfd, info)
1605 bfd *abfd;
1606 struct bfd_link_info *info;
1607 {
1608 asection *sec;
1609 struct internal_reloc *i, *rel;
1610
1611 /* Here we have a bfd that is to be included on the link. We have a hook
1612 to do reloc rummaging, before section sizes are nailed down. */
1613 _bfd_coff_get_external_symbols (abfd);
1614
1615 /* Rummage around all the relocs and map the toc. */
1616 sec = abfd->sections;
1617
1618 if (sec == 0)
1619 return TRUE;
1620
1621 for (; sec != 0; sec = sec->next)
1622 {
1623 if (sec->reloc_count == 0)
1624 continue;
1625
1626 /* load the relocs */
1627 /* FIXME: there may be a storage leak here */
1628 i=_bfd_coff_read_internal_relocs(abfd,sec,1,0,0,0);
1629
1630 if (i == 0)
1631 abort ();
1632
1633 for (rel = i; rel < i + sec->reloc_count; ++rel)
1634 {
1635 unsigned short r_type = EXTRACT_TYPE (rel->r_type);
1636 unsigned short r_flags = EXTRACT_FLAGS (rel->r_type);
1637 bfd_boolean ok = TRUE;
1638
1639 DUMP_RELOC2 (ppc_coff_howto_table[r_type].name, rel);
1640
1641 switch(r_type)
1642 {
1643 case IMAGE_REL_PPC_TOCREL16:
1644 /* If TOCDEFN is on, ignore as someone else has allocated the
1645 toc entry. */
1646 if ((r_flags & IMAGE_REL_PPC_TOCDEFN) != IMAGE_REL_PPC_TOCDEFN)
1647 ok = ppc_record_toc_entry(abfd, info, sec,
1648 rel->r_symndx, default_toc);
1649 if (!ok)
1650 return FALSE;
1651 break;
1652 case IMAGE_REL_PPC_IMGLUE:
1653 ppc_mark_symbol_as_glue (abfd, rel->r_symndx, rel);
1654 break;
1655 default:
1656 break;
1657 }
1658 }
1659 }
1660
1661 return TRUE;
1662 }
1663
1664 #endif
1665
1666 static bfd_reloc_status_type
1667 ppc_refhi_reloc (abfd, reloc_entry, symbol, data,
1668 input_section, output_bfd, error_message)
1669 bfd *abfd ATTRIBUTE_UNUSED;
1670 arelent *reloc_entry ATTRIBUTE_UNUSED;
1671 asymbol *symbol ATTRIBUTE_UNUSED;
1672 PTR data ATTRIBUTE_UNUSED;
1673 asection *input_section ATTRIBUTE_UNUSED;
1674 bfd *output_bfd;
1675 char **error_message ATTRIBUTE_UNUSED;
1676 {
1677 UN_IMPL("REFHI");
1678 DUMP_RELOC("REFHI",reloc_entry);
1679
1680 if (output_bfd == (bfd *) NULL)
1681 return bfd_reloc_continue;
1682
1683 return bfd_reloc_undefined;
1684 }
1685
1686 static bfd_reloc_status_type
1687 ppc_pair_reloc (abfd, reloc_entry, symbol, data,
1688 input_section, output_bfd, error_message)
1689 bfd *abfd ATTRIBUTE_UNUSED;
1690 arelent *reloc_entry ATTRIBUTE_UNUSED;
1691 asymbol *symbol ATTRIBUTE_UNUSED;
1692 PTR data ATTRIBUTE_UNUSED;
1693 asection *input_section ATTRIBUTE_UNUSED;
1694 bfd *output_bfd;
1695 char **error_message ATTRIBUTE_UNUSED;
1696 {
1697 UN_IMPL("PAIR");
1698 DUMP_RELOC("PAIR",reloc_entry);
1699
1700 if (output_bfd == (bfd *) NULL)
1701 return bfd_reloc_continue;
1702
1703 return bfd_reloc_undefined;
1704 }
1705 \f
1706 static bfd_reloc_status_type
1707 ppc_toc16_reloc (abfd, reloc_entry, symbol, data,
1708 input_section, output_bfd, error_message)
1709 bfd *abfd ATTRIBUTE_UNUSED;
1710 arelent *reloc_entry ATTRIBUTE_UNUSED;
1711 asymbol *symbol ATTRIBUTE_UNUSED;
1712 PTR data ATTRIBUTE_UNUSED;
1713 asection *input_section ATTRIBUTE_UNUSED;
1714 bfd *output_bfd;
1715 char **error_message ATTRIBUTE_UNUSED;
1716 {
1717 UN_IMPL ("TOCREL16");
1718 DUMP_RELOC ("TOCREL16",reloc_entry);
1719
1720 if (output_bfd == (bfd *) NULL)
1721 return bfd_reloc_continue;
1722
1723 return bfd_reloc_ok;
1724 }
1725
1726 static bfd_reloc_status_type
1727 ppc_secrel_reloc (abfd, reloc_entry, symbol, data,
1728 input_section, output_bfd, error_message)
1729 bfd *abfd ATTRIBUTE_UNUSED;
1730 arelent *reloc_entry ATTRIBUTE_UNUSED;
1731 asymbol *symbol ATTRIBUTE_UNUSED;
1732 PTR data ATTRIBUTE_UNUSED;
1733 asection *input_section ATTRIBUTE_UNUSED;
1734 bfd *output_bfd;
1735 char **error_message ATTRIBUTE_UNUSED;
1736 {
1737 UN_IMPL("SECREL");
1738 DUMP_RELOC("SECREL",reloc_entry);
1739
1740 if (output_bfd == (bfd *) NULL)
1741 return bfd_reloc_continue;
1742
1743 return bfd_reloc_ok;
1744 }
1745
1746 static bfd_reloc_status_type
1747 ppc_section_reloc (abfd, reloc_entry, symbol, data,
1748 input_section, output_bfd, error_message)
1749 bfd *abfd ATTRIBUTE_UNUSED;
1750 arelent *reloc_entry ATTRIBUTE_UNUSED;
1751 asymbol *symbol ATTRIBUTE_UNUSED;
1752 PTR data ATTRIBUTE_UNUSED;
1753 asection *input_section ATTRIBUTE_UNUSED;
1754 bfd *output_bfd;
1755 char **error_message ATTRIBUTE_UNUSED;
1756 {
1757 UN_IMPL("SECTION");
1758 DUMP_RELOC("SECTION",reloc_entry);
1759
1760 if (output_bfd == (bfd *) NULL)
1761 return bfd_reloc_continue;
1762
1763 return bfd_reloc_ok;
1764 }
1765
1766 static bfd_reloc_status_type
1767 ppc_imglue_reloc (abfd, reloc_entry, symbol, data,
1768 input_section, output_bfd, error_message)
1769 bfd *abfd ATTRIBUTE_UNUSED;
1770 arelent *reloc_entry ATTRIBUTE_UNUSED;
1771 asymbol *symbol ATTRIBUTE_UNUSED;
1772 PTR data ATTRIBUTE_UNUSED;
1773 asection *input_section ATTRIBUTE_UNUSED;
1774 bfd *output_bfd;
1775 char **error_message ATTRIBUTE_UNUSED;
1776 {
1777 UN_IMPL("IMGLUE");
1778 DUMP_RELOC("IMGLUE",reloc_entry);
1779
1780 if (output_bfd == (bfd *) NULL)
1781 return bfd_reloc_continue;
1782
1783 return bfd_reloc_ok;
1784 }
1785 \f
1786 #define MAX_RELOC_INDEX \
1787 (sizeof (ppc_coff_howto_table) / sizeof (ppc_coff_howto_table[0]) - 1)
1788
1789 /* FIXME: There is a possibility that when we read in a reloc from a file,
1790 that there are some bits encoded in the upper portion of the
1791 type field. Not yet implemented. */
1792 static void ppc_coff_rtype2howto PARAMS ((arelent *, struct internal_reloc *));
1793
1794 static void
1795 ppc_coff_rtype2howto (relent, internal)
1796 arelent *relent;
1797 struct internal_reloc *internal;
1798 {
1799 /* We can encode one of three things in the type field, aside from the
1800 type:
1801 1. IMAGE_REL_PPC_NEG - indicates the value field is a subtraction
1802 value, rather than an addition value
1803 2. IMAGE_REL_PPC_BRTAKEN, IMAGE_REL_PPC_BRNTAKEN - indicates that
1804 the branch is expected to be taken or not.
1805 3. IMAGE_REL_PPC_TOCDEFN - toc slot definition in the file
1806 For now, we just strip this stuff to find the type, and ignore it other
1807 than that. */
1808 reloc_howto_type *howto;
1809 unsigned short r_type = EXTRACT_TYPE (internal->r_type);
1810 unsigned short r_flags = EXTRACT_FLAGS(internal->r_type);
1811 unsigned short junk = EXTRACT_JUNK (internal->r_type);
1812
1813 /* The masking process only slices off the bottom byte for r_type. */
1814 if ( r_type > MAX_RELOC_INDEX )
1815 abort ();
1816
1817 /* Check for absolute crap. */
1818 if (junk != 0)
1819 abort ();
1820
1821 switch(r_type)
1822 {
1823 case IMAGE_REL_PPC_ADDR16:
1824 case IMAGE_REL_PPC_REL24:
1825 case IMAGE_REL_PPC_ADDR24:
1826 case IMAGE_REL_PPC_ADDR32:
1827 case IMAGE_REL_PPC_IFGLUE:
1828 case IMAGE_REL_PPC_ADDR32NB:
1829 case IMAGE_REL_PPC_SECTION:
1830 case IMAGE_REL_PPC_SECREL:
1831 DUMP_RELOC2 (ppc_coff_howto_table[r_type].name, internal);
1832 howto = ppc_coff_howto_table + r_type;
1833 break;
1834 case IMAGE_REL_PPC_IMGLUE:
1835 DUMP_RELOC2 (ppc_coff_howto_table[r_type].name, internal);
1836 howto = ppc_coff_howto_table + r_type;
1837 break;
1838 case IMAGE_REL_PPC_TOCREL16:
1839 DUMP_RELOC2 (ppc_coff_howto_table[r_type].name, internal);
1840 if (r_flags & IMAGE_REL_PPC_TOCDEFN)
1841 howto = ppc_coff_howto_table + IMAGE_REL_PPC_TOCREL16_DEFN;
1842 else
1843 howto = ppc_coff_howto_table + IMAGE_REL_PPC_TOCREL16;
1844 break;
1845 default:
1846 (*_bfd_error_handler) (_("warning: unsupported reloc %s [%d] used -- it may not work"),
1847 ppc_coff_howto_table[r_type].name,
1848 r_type);
1849 howto = ppc_coff_howto_table + r_type;
1850 break;
1851 }
1852
1853 relent->howto = howto;
1854 }
1855
1856 static reloc_howto_type *
1857 coff_ppc_rtype_to_howto (abfd, sec, rel, h, sym, addendp)
1858 bfd *abfd ATTRIBUTE_UNUSED;
1859 asection *sec;
1860 struct internal_reloc *rel;
1861 struct coff_link_hash_entry *h ATTRIBUTE_UNUSED;
1862 struct internal_syment *sym ATTRIBUTE_UNUSED;
1863 bfd_vma *addendp;
1864 {
1865 reloc_howto_type *howto;
1866
1867 /* We can encode one of three things in the type field, aside from the
1868 type:
1869 1. IMAGE_REL_PPC_NEG - indicates the value field is a subtraction
1870 value, rather than an addition value
1871 2. IMAGE_REL_PPC_BRTAKEN, IMAGE_REL_PPC_BRNTAKEN - indicates that
1872 the branch is expected to be taken or not.
1873 3. IMAGE_REL_PPC_TOCDEFN - toc slot definition in the file
1874 For now, we just strip this stuff to find the type, and ignore it other
1875 than that. */
1876
1877 unsigned short r_type = EXTRACT_TYPE (rel->r_type);
1878 unsigned short r_flags = EXTRACT_FLAGS (rel->r_type);
1879 unsigned short junk = EXTRACT_JUNK (rel->r_type);
1880
1881 /* The masking process only slices off the bottom byte for r_type. */
1882 if (r_type > MAX_RELOC_INDEX)
1883 abort ();
1884
1885 /* Check for absolute crap. */
1886 if (junk != 0)
1887 abort ();
1888
1889 switch(r_type)
1890 {
1891 case IMAGE_REL_PPC_ADDR32NB:
1892 DUMP_RELOC2(ppc_coff_howto_table[r_type].name, rel);
1893 *addendp -= pe_data(sec->output_section->owner)->pe_opthdr.ImageBase;
1894 howto = ppc_coff_howto_table + r_type;
1895 break;
1896 case IMAGE_REL_PPC_TOCREL16:
1897 DUMP_RELOC2(ppc_coff_howto_table[r_type].name, rel);
1898 if (r_flags & IMAGE_REL_PPC_TOCDEFN)
1899 howto = ppc_coff_howto_table + IMAGE_REL_PPC_TOCREL16_DEFN;
1900 else
1901 howto = ppc_coff_howto_table + IMAGE_REL_PPC_TOCREL16;
1902 break;
1903 case IMAGE_REL_PPC_ADDR16:
1904 case IMAGE_REL_PPC_REL24:
1905 case IMAGE_REL_PPC_ADDR24:
1906 case IMAGE_REL_PPC_ADDR32:
1907 case IMAGE_REL_PPC_IFGLUE:
1908 case IMAGE_REL_PPC_SECTION:
1909 case IMAGE_REL_PPC_SECREL:
1910 DUMP_RELOC2(ppc_coff_howto_table[r_type].name, rel);
1911 howto = ppc_coff_howto_table + r_type;
1912 break;
1913 case IMAGE_REL_PPC_IMGLUE:
1914 DUMP_RELOC2(ppc_coff_howto_table[r_type].name, rel);
1915 howto = ppc_coff_howto_table + r_type;
1916 break;
1917 default:
1918 (*_bfd_error_handler) (_("warning: unsupported reloc %s [%d] used -- it may not work"),
1919 ppc_coff_howto_table[r_type].name,
1920 r_type);
1921 howto = ppc_coff_howto_table + r_type;
1922 break;
1923 }
1924
1925 return howto;
1926 }
1927
1928 /* A cheesy little macro to make the code a little more readable. */
1929 #define HOW2MAP(bfd_rtype,ppc_rtype) \
1930 case bfd_rtype: return &ppc_coff_howto_table[ppc_rtype]
1931
1932 static reloc_howto_type *ppc_coff_reloc_type_lookup
1933 PARAMS ((bfd *, bfd_reloc_code_real_type));
1934
1935 static reloc_howto_type *
1936 ppc_coff_reloc_type_lookup (abfd, code)
1937 bfd *abfd ATTRIBUTE_UNUSED;
1938 bfd_reloc_code_real_type code;
1939 {
1940 switch (code)
1941 {
1942 HOW2MAP(BFD_RELOC_32_GOTOFF, IMAGE_REL_PPC_IMGLUE);
1943 HOW2MAP(BFD_RELOC_16_GOT_PCREL, IMAGE_REL_PPC_IFGLUE);
1944 HOW2MAP(BFD_RELOC_16, IMAGE_REL_PPC_ADDR16);
1945 HOW2MAP(BFD_RELOC_PPC_B26, IMAGE_REL_PPC_REL24);
1946 HOW2MAP(BFD_RELOC_PPC_BA26, IMAGE_REL_PPC_ADDR24);
1947 HOW2MAP(BFD_RELOC_PPC_TOC16, IMAGE_REL_PPC_TOCREL16);
1948 HOW2MAP(BFD_RELOC_16_GOTOFF, IMAGE_REL_PPC_TOCREL16_DEFN);
1949 HOW2MAP(BFD_RELOC_32, IMAGE_REL_PPC_ADDR32);
1950 HOW2MAP(BFD_RELOC_RVA, IMAGE_REL_PPC_ADDR32NB);
1951 default:
1952 return NULL;
1953 }
1954 }
1955 #undef HOW2MAP
1956
1957 static reloc_howto_type *
1958 ppc_coff_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
1959 const char *r_name)
1960 {
1961 unsigned int i;
1962
1963 for (i = 0;
1964 i < sizeof (ppc_coff_howto_table) / sizeof (ppc_coff_howto_table[0]);
1965 i++)
1966 if (ppc_coff_howto_table[i].name != NULL
1967 && strcasecmp (ppc_coff_howto_table[i].name, r_name) == 0)
1968 return &ppc_coff_howto_table[i];
1969
1970 return NULL;
1971 }
1972 \f
1973 /* Tailor coffcode.h -- macro heaven. */
1974
1975 #define RTYPE2HOWTO(cache_ptr, dst) ppc_coff_rtype2howto (cache_ptr, dst)
1976
1977 /* We use the special COFF backend linker, with our own special touch. */
1978
1979 #define coff_bfd_reloc_type_lookup ppc_coff_reloc_type_lookup
1980 #define coff_bfd_reloc_name_lookup ppc_coff_reloc_name_lookup
1981 #define coff_rtype_to_howto coff_ppc_rtype_to_howto
1982 #define coff_relocate_section coff_ppc_relocate_section
1983 #define coff_bfd_final_link ppc_bfd_coff_final_link
1984
1985 #ifndef COFF_IMAGE_WITH_PE
1986 #endif
1987
1988 #define SELECT_RELOC(internal, howto) {internal.r_type=howto->type;}
1989
1990 #define COFF_PAGE_SIZE 0x1000
1991
1992 /* FIXME: This controls some code that used to be in peicode.h and is
1993 now in peigen.c. It will not control the code in peigen.c. If
1994 anybody wants to get this working, you will need to fix that. */
1995 #define POWERPC_LE_PE
1996
1997 #define COFF_SECTION_ALIGNMENT_ENTRIES \
1998 { COFF_SECTION_NAME_EXACT_MATCH (".idata$2"), \
1999 COFF_ALIGNMENT_FIELD_EMPTY, COFF_ALIGNMENT_FIELD_EMPTY, 0 }, \
2000 { COFF_SECTION_NAME_EXACT_MATCH (".idata$3"), \
2001 COFF_ALIGNMENT_FIELD_EMPTY, COFF_ALIGNMENT_FIELD_EMPTY, 0 }, \
2002 { COFF_SECTION_NAME_EXACT_MATCH (".idata$4"), \
2003 COFF_ALIGNMENT_FIELD_EMPTY, COFF_ALIGNMENT_FIELD_EMPTY, 2 }, \
2004 { COFF_SECTION_NAME_EXACT_MATCH (".idata$5"), \
2005 COFF_ALIGNMENT_FIELD_EMPTY, COFF_ALIGNMENT_FIELD_EMPTY, 2 }, \
2006 { COFF_SECTION_NAME_EXACT_MATCH (".idata$6"), \
2007 COFF_ALIGNMENT_FIELD_EMPTY, COFF_ALIGNMENT_FIELD_EMPTY, 1 }, \
2008 { COFF_SECTION_NAME_EXACT_MATCH (".reloc"), \
2009 COFF_ALIGNMENT_FIELD_EMPTY, COFF_ALIGNMENT_FIELD_EMPTY, 1 }
2010
2011 #include "coffcode.h"
2012 \f
2013 #ifndef COFF_IMAGE_WITH_PE
2014
2015 static bfd_boolean ppc_do_last PARAMS ((bfd *));
2016 static bfd *ppc_get_last PARAMS ((void));
2017
2018 static bfd_boolean
2019 ppc_do_last (abfd)
2020 bfd *abfd;
2021 {
2022 if (abfd == bfd_of_toc_owner)
2023 return TRUE;
2024 else
2025 return FALSE;
2026 }
2027
2028 static bfd *
2029 ppc_get_last()
2030 {
2031 return bfd_of_toc_owner;
2032 }
2033
2034 /* This piece of machinery exists only to guarantee that the bfd that holds
2035 the toc section is written last.
2036
2037 This does depend on bfd_make_section attaching a new section to the
2038 end of the section list for the bfd.
2039
2040 This is otherwise intended to be functionally the same as
2041 cofflink.c:_bfd_coff_final_link(). It is specifically different only
2042 where the POWERPC_LE_PE macro modifies the code. It is left in as a
2043 precise form of comment. krk@cygnus.com */
2044
2045 /* Do the final link step. */
2046
2047 bfd_boolean
2048 ppc_bfd_coff_final_link (abfd, info)
2049 bfd *abfd;
2050 struct bfd_link_info *info;
2051 {
2052 bfd_size_type symesz;
2053 struct coff_final_link_info finfo;
2054 bfd_boolean debug_merge_allocated;
2055 asection *o;
2056 struct bfd_link_order *p;
2057 bfd_size_type max_sym_count;
2058 bfd_size_type max_lineno_count;
2059 bfd_size_type max_reloc_count;
2060 bfd_size_type max_output_reloc_count;
2061 bfd_size_type max_contents_size;
2062 file_ptr rel_filepos;
2063 unsigned int relsz;
2064 file_ptr line_filepos;
2065 unsigned int linesz;
2066 bfd *sub;
2067 bfd_byte *external_relocs = NULL;
2068 char strbuf[STRING_SIZE_SIZE];
2069 bfd_size_type amt;
2070
2071 symesz = bfd_coff_symesz (abfd);
2072
2073 finfo.info = info;
2074 finfo.output_bfd = abfd;
2075 finfo.strtab = NULL;
2076 finfo.section_info = NULL;
2077 finfo.last_file_index = -1;
2078 finfo.last_bf_index = -1;
2079 finfo.internal_syms = NULL;
2080 finfo.sec_ptrs = NULL;
2081 finfo.sym_indices = NULL;
2082 finfo.outsyms = NULL;
2083 finfo.linenos = NULL;
2084 finfo.contents = NULL;
2085 finfo.external_relocs = NULL;
2086 finfo.internal_relocs = NULL;
2087 debug_merge_allocated = FALSE;
2088
2089 coff_data (abfd)->link_info = info;
2090
2091 finfo.strtab = _bfd_stringtab_init ();
2092 if (finfo.strtab == NULL)
2093 goto error_return;
2094
2095 if (! coff_debug_merge_hash_table_init (&finfo.debug_merge))
2096 goto error_return;
2097 debug_merge_allocated = TRUE;
2098
2099 /* Compute the file positions for all the sections. */
2100 if (! abfd->output_has_begun)
2101 {
2102 if (! bfd_coff_compute_section_file_positions (abfd))
2103 return FALSE;
2104 }
2105
2106 /* Count the line numbers and relocation entries required for the
2107 output file. Set the file positions for the relocs. */
2108 rel_filepos = obj_relocbase (abfd);
2109 relsz = bfd_coff_relsz (abfd);
2110 max_contents_size = 0;
2111 max_lineno_count = 0;
2112 max_reloc_count = 0;
2113
2114 for (o = abfd->sections; o != NULL; o = o->next)
2115 {
2116 o->reloc_count = 0;
2117 o->lineno_count = 0;
2118
2119 for (p = o->map_head.link_order; p != NULL; p = p->next)
2120 {
2121 if (p->type == bfd_indirect_link_order)
2122 {
2123 asection *sec;
2124
2125 sec = p->u.indirect.section;
2126
2127 /* Mark all sections which are to be included in the
2128 link. This will normally be every section. We need
2129 to do this so that we can identify any sections which
2130 the linker has decided to not include. */
2131 sec->linker_mark = TRUE;
2132
2133 if (info->strip == strip_none
2134 || info->strip == strip_some)
2135 o->lineno_count += sec->lineno_count;
2136
2137 if (info->relocatable)
2138 o->reloc_count += sec->reloc_count;
2139
2140 if (sec->rawsize > max_contents_size)
2141 max_contents_size = sec->rawsize;
2142 if (sec->size > max_contents_size)
2143 max_contents_size = sec->size;
2144 if (sec->lineno_count > max_lineno_count)
2145 max_lineno_count = sec->lineno_count;
2146 if (sec->reloc_count > max_reloc_count)
2147 max_reloc_count = sec->reloc_count;
2148 }
2149 else if (info->relocatable
2150 && (p->type == bfd_section_reloc_link_order
2151 || p->type == bfd_symbol_reloc_link_order))
2152 ++o->reloc_count;
2153 }
2154 if (o->reloc_count == 0)
2155 o->rel_filepos = 0;
2156 else
2157 {
2158 o->flags |= SEC_RELOC;
2159 o->rel_filepos = rel_filepos;
2160 rel_filepos += o->reloc_count * relsz;
2161 }
2162 }
2163
2164 /* If doing a relocatable link, allocate space for the pointers we
2165 need to keep. */
2166 if (info->relocatable)
2167 {
2168 unsigned int i;
2169
2170 /* We use section_count + 1, rather than section_count, because
2171 the target_index fields are 1 based. */
2172 amt = abfd->section_count + 1;
2173 amt *= sizeof (struct coff_link_section_info);
2174 finfo.section_info = (struct coff_link_section_info *) bfd_malloc (amt);
2175
2176 if (finfo.section_info == NULL)
2177 goto error_return;
2178
2179 for (i = 0; i <= abfd->section_count; i++)
2180 {
2181 finfo.section_info[i].relocs = NULL;
2182 finfo.section_info[i].rel_hashes = NULL;
2183 }
2184 }
2185
2186 /* We now know the size of the relocs, so we can determine the file
2187 positions of the line numbers. */
2188 line_filepos = rel_filepos;
2189 linesz = bfd_coff_linesz (abfd);
2190 max_output_reloc_count = 0;
2191
2192 for (o = abfd->sections; o != NULL; o = o->next)
2193 {
2194 if (o->lineno_count == 0)
2195 o->line_filepos = 0;
2196 else
2197 {
2198 o->line_filepos = line_filepos;
2199 line_filepos += o->lineno_count * linesz;
2200 }
2201
2202 if (o->reloc_count != 0)
2203 {
2204 /* We don't know the indices of global symbols until we have
2205 written out all the local symbols. For each section in
2206 the output file, we keep an array of pointers to hash
2207 table entries. Each entry in the array corresponds to a
2208 reloc. When we find a reloc against a global symbol, we
2209 set the corresponding entry in this array so that we can
2210 fix up the symbol index after we have written out all the
2211 local symbols.
2212
2213 Because of this problem, we also keep the relocs in
2214 memory until the end of the link. This wastes memory,
2215 but only when doing a relocatable link, which is not the
2216 common case. */
2217 BFD_ASSERT (info->relocatable);
2218 amt = o->reloc_count;
2219 amt *= sizeof (struct internal_reloc);
2220 finfo.section_info[o->target_index].relocs =
2221 (struct internal_reloc *) bfd_malloc (amt);
2222 amt = o->reloc_count;
2223 amt *= sizeof (struct coff_link_hash_entry *);
2224 finfo.section_info[o->target_index].rel_hashes =
2225 (struct coff_link_hash_entry **) bfd_malloc (amt);
2226 if (finfo.section_info[o->target_index].relocs == NULL
2227 || finfo.section_info[o->target_index].rel_hashes == NULL)
2228 goto error_return;
2229
2230 if (o->reloc_count > max_output_reloc_count)
2231 max_output_reloc_count = o->reloc_count;
2232 }
2233
2234 /* Reset the reloc and lineno counts, so that we can use them to
2235 count the number of entries we have output so far. */
2236 o->reloc_count = 0;
2237 o->lineno_count = 0;
2238 }
2239
2240 obj_sym_filepos (abfd) = line_filepos;
2241
2242 /* Figure out the largest number of symbols in an input BFD. Take
2243 the opportunity to clear the output_has_begun fields of all the
2244 input BFD's. */
2245 max_sym_count = 0;
2246 for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
2247 {
2248 bfd_size_type sz;
2249
2250 sub->output_has_begun = FALSE;
2251 sz = obj_raw_syment_count (sub);
2252 if (sz > max_sym_count)
2253 max_sym_count = sz;
2254 }
2255
2256 /* Allocate some buffers used while linking. */
2257 amt = max_sym_count * sizeof (struct internal_syment);
2258 finfo.internal_syms = (struct internal_syment *) bfd_malloc (amt);
2259 amt = max_sym_count * sizeof (asection *);
2260 finfo.sec_ptrs = (asection **) bfd_malloc (amt);
2261 amt = max_sym_count * sizeof (long);
2262 finfo.sym_indices = (long *) bfd_malloc (amt);
2263 amt = (max_sym_count + 1) * symesz;
2264 finfo.outsyms = (bfd_byte *) bfd_malloc (amt);
2265 amt = max_lineno_count * bfd_coff_linesz (abfd);
2266 finfo.linenos = (bfd_byte *) bfd_malloc (amt);
2267 finfo.contents = (bfd_byte *) bfd_malloc (max_contents_size);
2268 finfo.external_relocs = (bfd_byte *) bfd_malloc (max_reloc_count * relsz);
2269 if (! info->relocatable)
2270 {
2271 amt = max_reloc_count * sizeof (struct internal_reloc);
2272 finfo.internal_relocs = (struct internal_reloc *) bfd_malloc (amt);
2273 }
2274 if ((finfo.internal_syms == NULL && max_sym_count > 0)
2275 || (finfo.sec_ptrs == NULL && max_sym_count > 0)
2276 || (finfo.sym_indices == NULL && max_sym_count > 0)
2277 || finfo.outsyms == NULL
2278 || (finfo.linenos == NULL && max_lineno_count > 0)
2279 || (finfo.contents == NULL && max_contents_size > 0)
2280 || (finfo.external_relocs == NULL && max_reloc_count > 0)
2281 || (! info->relocatable
2282 && finfo.internal_relocs == NULL
2283 && max_reloc_count > 0))
2284 goto error_return;
2285
2286 /* We now know the position of everything in the file, except that
2287 we don't know the size of the symbol table and therefore we don't
2288 know where the string table starts. We just build the string
2289 table in memory as we go along. We process all the relocations
2290 for a single input file at once. */
2291 obj_raw_syment_count (abfd) = 0;
2292
2293 if (coff_backend_info (abfd)->_bfd_coff_start_final_link)
2294 {
2295 if (! bfd_coff_start_final_link (abfd, info))
2296 goto error_return;
2297 }
2298
2299 for (o = abfd->sections; o != NULL; o = o->next)
2300 {
2301 for (p = o->map_head.link_order; p != NULL; p = p->next)
2302 {
2303 if (p->type == bfd_indirect_link_order
2304 && (bfd_get_flavour (p->u.indirect.section->owner)
2305 == bfd_target_coff_flavour))
2306 {
2307 sub = p->u.indirect.section->owner;
2308 #ifdef POWERPC_LE_PE
2309 if (! sub->output_has_begun && !ppc_do_last(sub))
2310 #else
2311 if (! sub->output_has_begun)
2312 #endif
2313 {
2314 if (! _bfd_coff_link_input_bfd (&finfo, sub))
2315 goto error_return;
2316 sub->output_has_begun = TRUE;
2317 }
2318 }
2319 else if (p->type == bfd_section_reloc_link_order
2320 || p->type == bfd_symbol_reloc_link_order)
2321 {
2322 if (! _bfd_coff_reloc_link_order (abfd, &finfo, o, p))
2323 goto error_return;
2324 }
2325 else
2326 {
2327 if (! _bfd_default_link_order (abfd, info, o, p))
2328 goto error_return;
2329 }
2330 }
2331 }
2332
2333 #ifdef POWERPC_LE_PE
2334 {
2335 bfd* last_one = ppc_get_last();
2336 if (last_one)
2337 {
2338 if (! _bfd_coff_link_input_bfd (&finfo, last_one))
2339 goto error_return;
2340 }
2341 last_one->output_has_begun = TRUE;
2342 }
2343 #endif
2344
2345 /* Free up the buffers used by _bfd_coff_link_input_bfd. */
2346 coff_debug_merge_hash_table_free (&finfo.debug_merge);
2347 debug_merge_allocated = FALSE;
2348
2349 if (finfo.internal_syms != NULL)
2350 {
2351 free (finfo.internal_syms);
2352 finfo.internal_syms = NULL;
2353 }
2354 if (finfo.sec_ptrs != NULL)
2355 {
2356 free (finfo.sec_ptrs);
2357 finfo.sec_ptrs = NULL;
2358 }
2359 if (finfo.sym_indices != NULL)
2360 {
2361 free (finfo.sym_indices);
2362 finfo.sym_indices = NULL;
2363 }
2364 if (finfo.linenos != NULL)
2365 {
2366 free (finfo.linenos);
2367 finfo.linenos = NULL;
2368 }
2369 if (finfo.contents != NULL)
2370 {
2371 free (finfo.contents);
2372 finfo.contents = NULL;
2373 }
2374 if (finfo.external_relocs != NULL)
2375 {
2376 free (finfo.external_relocs);
2377 finfo.external_relocs = NULL;
2378 }
2379 if (finfo.internal_relocs != NULL)
2380 {
2381 free (finfo.internal_relocs);
2382 finfo.internal_relocs = NULL;
2383 }
2384
2385 /* The value of the last C_FILE symbol is supposed to be the symbol
2386 index of the first external symbol. Write it out again if
2387 necessary. */
2388 if (finfo.last_file_index != -1
2389 && (unsigned int) finfo.last_file.n_value != obj_raw_syment_count (abfd))
2390 {
2391 file_ptr pos;
2392
2393 finfo.last_file.n_value = obj_raw_syment_count (abfd);
2394 bfd_coff_swap_sym_out (abfd, (PTR) &finfo.last_file,
2395 (PTR) finfo.outsyms);
2396 pos = obj_sym_filepos (abfd) + finfo.last_file_index * symesz;
2397 if (bfd_seek (abfd, pos, SEEK_SET) != 0
2398 || bfd_bwrite (finfo.outsyms, symesz, abfd) != symesz)
2399 return FALSE;
2400 }
2401
2402 /* Write out the global symbols. */
2403 finfo.failed = FALSE;
2404 coff_link_hash_traverse (coff_hash_table (info), _bfd_coff_write_global_sym,
2405 (PTR) &finfo);
2406 if (finfo.failed)
2407 goto error_return;
2408
2409 /* The outsyms buffer is used by _bfd_coff_write_global_sym. */
2410 if (finfo.outsyms != NULL)
2411 {
2412 free (finfo.outsyms);
2413 finfo.outsyms = NULL;
2414 }
2415
2416 if (info->relocatable)
2417 {
2418 /* Now that we have written out all the global symbols, we know
2419 the symbol indices to use for relocs against them, and we can
2420 finally write out the relocs. */
2421 amt = max_output_reloc_count * relsz;
2422 external_relocs = (bfd_byte *) bfd_malloc (amt);
2423 if (external_relocs == NULL)
2424 goto error_return;
2425
2426 for (o = abfd->sections; o != NULL; o = o->next)
2427 {
2428 struct internal_reloc *irel;
2429 struct internal_reloc *irelend;
2430 struct coff_link_hash_entry **rel_hash;
2431 bfd_byte *erel;
2432
2433 if (o->reloc_count == 0)
2434 continue;
2435
2436 irel = finfo.section_info[o->target_index].relocs;
2437 irelend = irel + o->reloc_count;
2438 rel_hash = finfo.section_info[o->target_index].rel_hashes;
2439 erel = external_relocs;
2440 for (; irel < irelend; irel++, rel_hash++, erel += relsz)
2441 {
2442 if (*rel_hash != NULL)
2443 {
2444 BFD_ASSERT ((*rel_hash)->indx >= 0);
2445 irel->r_symndx = (*rel_hash)->indx;
2446 }
2447 bfd_coff_swap_reloc_out (abfd, (PTR) irel, (PTR) erel);
2448 }
2449
2450 amt = relsz * o->reloc_count;
2451 if (bfd_seek (abfd, o->rel_filepos, SEEK_SET) != 0
2452 || bfd_bwrite ((PTR) external_relocs, amt, abfd) != amt)
2453 goto error_return;
2454 }
2455
2456 free (external_relocs);
2457 external_relocs = NULL;
2458 }
2459
2460 /* Free up the section information. */
2461 if (finfo.section_info != NULL)
2462 {
2463 unsigned int i;
2464
2465 for (i = 0; i < abfd->section_count; i++)
2466 {
2467 if (finfo.section_info[i].relocs != NULL)
2468 free (finfo.section_info[i].relocs);
2469 if (finfo.section_info[i].rel_hashes != NULL)
2470 free (finfo.section_info[i].rel_hashes);
2471 }
2472 free (finfo.section_info);
2473 finfo.section_info = NULL;
2474 }
2475
2476 /* If we have optimized stabs strings, output them. */
2477 if (coff_hash_table (info)->stab_info.stabstr != NULL)
2478 {
2479 if (! _bfd_write_stab_strings (abfd, &coff_hash_table (info)->stab_info))
2480 return FALSE;
2481 }
2482
2483 /* Write out the string table. */
2484 if (obj_raw_syment_count (abfd) != 0)
2485 {
2486 file_ptr pos;
2487
2488 pos = obj_sym_filepos (abfd) + obj_raw_syment_count (abfd) * symesz;
2489 if (bfd_seek (abfd, pos, SEEK_SET) != 0)
2490 return FALSE;
2491
2492 #if STRING_SIZE_SIZE == 4
2493 H_PUT_32 (abfd,
2494 _bfd_stringtab_size (finfo.strtab) + STRING_SIZE_SIZE,
2495 strbuf);
2496 #else
2497 #error Change H_PUT_32 above
2498 #endif
2499
2500 if (bfd_bwrite (strbuf, (bfd_size_type) STRING_SIZE_SIZE, abfd)
2501 != STRING_SIZE_SIZE)
2502 return FALSE;
2503
2504 if (! _bfd_stringtab_emit (abfd, finfo.strtab))
2505 return FALSE;
2506 }
2507
2508 _bfd_stringtab_free (finfo.strtab);
2509
2510 /* Setting bfd_get_symcount to 0 will cause write_object_contents to
2511 not try to write out the symbols. */
2512 bfd_get_symcount (abfd) = 0;
2513
2514 return TRUE;
2515
2516 error_return:
2517 if (debug_merge_allocated)
2518 coff_debug_merge_hash_table_free (&finfo.debug_merge);
2519 if (finfo.strtab != NULL)
2520 _bfd_stringtab_free (finfo.strtab);
2521 if (finfo.section_info != NULL)
2522 {
2523 unsigned int i;
2524
2525 for (i = 0; i < abfd->section_count; i++)
2526 {
2527 if (finfo.section_info[i].relocs != NULL)
2528 free (finfo.section_info[i].relocs);
2529 if (finfo.section_info[i].rel_hashes != NULL)
2530 free (finfo.section_info[i].rel_hashes);
2531 }
2532 free (finfo.section_info);
2533 }
2534 if (finfo.internal_syms != NULL)
2535 free (finfo.internal_syms);
2536 if (finfo.sec_ptrs != NULL)
2537 free (finfo.sec_ptrs);
2538 if (finfo.sym_indices != NULL)
2539 free (finfo.sym_indices);
2540 if (finfo.outsyms != NULL)
2541 free (finfo.outsyms);
2542 if (finfo.linenos != NULL)
2543 free (finfo.linenos);
2544 if (finfo.contents != NULL)
2545 free (finfo.contents);
2546 if (finfo.external_relocs != NULL)
2547 free (finfo.external_relocs);
2548 if (finfo.internal_relocs != NULL)
2549 free (finfo.internal_relocs);
2550 if (external_relocs != NULL)
2551 free (external_relocs);
2552 return FALSE;
2553 }
2554 #endif
2555 \f
2556 /* Forward declaration for use by alternative_target field. */
2557 #ifdef TARGET_BIG_SYM
2558 extern const bfd_target TARGET_BIG_SYM;
2559 #endif
2560
2561 /* The transfer vectors that lead the outside world to all of the above. */
2562
2563 #ifdef TARGET_LITTLE_SYM
2564 const bfd_target TARGET_LITTLE_SYM =
2565 {
2566 TARGET_LITTLE_NAME, /* name or coff-arm-little */
2567 bfd_target_coff_flavour,
2568 BFD_ENDIAN_LITTLE, /* data byte order is little */
2569 BFD_ENDIAN_LITTLE, /* header byte order is little */
2570
2571 (HAS_RELOC | EXEC_P | /* FIXME: object flags */
2572 HAS_LINENO | HAS_DEBUG |
2573 HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED),
2574
2575 #ifndef COFF_WITH_PE
2576 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* section flags */
2577 #else
2578 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC /* section flags */
2579 | SEC_LINK_ONCE | SEC_LINK_DUPLICATES),
2580 #endif
2581
2582 0, /* leading char */
2583 '/', /* ar_pad_char */
2584 15, /* ar_max_namelen??? FIXMEmgo */
2585
2586 bfd_getl64, bfd_getl_signed_64, bfd_putl64,
2587 bfd_getl32, bfd_getl_signed_32, bfd_putl32,
2588 bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* data */
2589
2590 bfd_getl64, bfd_getl_signed_64, bfd_putl64,
2591 bfd_getl32, bfd_getl_signed_32, bfd_putl32,
2592 bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* hdrs */
2593
2594 {_bfd_dummy_target, coff_object_p, /* bfd_check_format */
2595 bfd_generic_archive_p, /* _bfd_dummy_target */ coff_object_p },
2596 {bfd_false, coff_mkobject, _bfd_generic_mkarchive, /* bfd_set_format */
2597 bfd_false},
2598 {bfd_false, coff_write_object_contents, /* bfd_write_contents */
2599 _bfd_write_archive_contents, bfd_false},
2600
2601 BFD_JUMP_TABLE_GENERIC (coff),
2602 BFD_JUMP_TABLE_COPY (coff),
2603 BFD_JUMP_TABLE_CORE (_bfd_nocore),
2604 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff),
2605 BFD_JUMP_TABLE_SYMBOLS (coff),
2606 BFD_JUMP_TABLE_RELOCS (coff),
2607 BFD_JUMP_TABLE_WRITE (coff),
2608 BFD_JUMP_TABLE_LINK (coff),
2609 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
2610
2611 /* Alternative_target. */
2612 #ifdef TARGET_BIG_SYM
2613 & TARGET_BIG_SYM,
2614 #else
2615 NULL,
2616 #endif
2617
2618 COFF_SWAP_TABLE
2619 };
2620 #endif
2621
2622 #ifdef TARGET_BIG_SYM
2623 const bfd_target TARGET_BIG_SYM =
2624 {
2625 TARGET_BIG_NAME,
2626 bfd_target_coff_flavour,
2627 BFD_ENDIAN_BIG, /* data byte order is big */
2628 BFD_ENDIAN_BIG, /* header byte order is big */
2629
2630 (HAS_RELOC | EXEC_P | /* FIXME: object flags */
2631 HAS_LINENO | HAS_DEBUG |
2632 HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED),
2633
2634 #ifndef COFF_WITH_PE
2635 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* section flags */
2636 #else
2637 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC /* section flags */
2638 | SEC_LINK_ONCE | SEC_LINK_DUPLICATES),
2639 #endif
2640
2641 0, /* leading char */
2642 '/', /* ar_pad_char */
2643 15, /* ar_max_namelen??? FIXMEmgo */
2644
2645 bfd_getb64, bfd_getb_signed_64, bfd_putb64,
2646 bfd_getb32, bfd_getb_signed_32, bfd_putb32,
2647 bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* data */
2648
2649 bfd_getb64, bfd_getb_signed_64, bfd_putb64,
2650 bfd_getb32, bfd_getb_signed_32, bfd_putb32,
2651 bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* hdrs */
2652
2653 {_bfd_dummy_target, coff_object_p, /* bfd_check_format */
2654 bfd_generic_archive_p, /* _bfd_dummy_target */ coff_object_p },
2655 {bfd_false, coff_mkobject, _bfd_generic_mkarchive, /* bfd_set_format */
2656 bfd_false},
2657 {bfd_false, coff_write_object_contents, /* bfd_write_contents */
2658 _bfd_write_archive_contents, bfd_false},
2659
2660 BFD_JUMP_TABLE_GENERIC (coff),
2661 BFD_JUMP_TABLE_COPY (coff),
2662 BFD_JUMP_TABLE_CORE (_bfd_nocore),
2663 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff),
2664 BFD_JUMP_TABLE_SYMBOLS (coff),
2665 BFD_JUMP_TABLE_RELOCS (coff),
2666 BFD_JUMP_TABLE_WRITE (coff),
2667 BFD_JUMP_TABLE_LINK (coff),
2668 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
2669
2670 /* Alternative_target. */
2671 #ifdef TARGET_LITTLE_SYM
2672 & TARGET_LITTLE_SYM,
2673 #else
2674 NULL,
2675 #endif
2676
2677 COFF_SWAP_TABLE
2678 };
2679
2680 #endif
git-cvsimport of binutils cvsroot