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