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