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