OpenCores
URL https://opencores.org/ocsvn/or1k/or1k/trunk

Subversion Repositories or1k

[/] [or1k/] [trunk/] [insight/] [bfd/] [elf32-ppc.c] - Blame information for rev 1776

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 578 markom
/* PowerPC-specific support for 32-bit ELF
2
   Copyright 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001
3
   Free Software Foundation, Inc.
4
   Written by Ian Lance Taylor, Cygnus Support.
5
 
6
This file is part of BFD, the Binary File Descriptor library.
7
 
8
This program is free software; you can redistribute it and/or modify
9
it under the terms of the GNU General Public License as published by
10
the Free Software Foundation; either version 2 of the License, or
11
(at your option) any later version.
12
 
13
This program is distributed in the hope that it will be useful,
14
but WITHOUT ANY WARRANTY; without even the implied warranty of
15
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16
GNU General Public License for more details.
17
 
18
You should have received a copy of the GNU General Public License
19
along with this program; if not, write to the Free Software
20
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
21
 
22
/* This file is based on a preliminary PowerPC ELF ABI.  The
23
   information may not match the final PowerPC ELF ABI.  It includes
24
   suggestions from the in-progress Embedded PowerPC ABI, and that
25
   information may also not match.  */
26
 
27
#include "bfd.h"
28
#include "sysdep.h"
29
#include "bfdlink.h"
30
#include "libbfd.h"
31
#include "elf-bfd.h"
32
#include "elf/ppc.h"
33
 
34
#define USE_RELA                /* we want RELA relocations, not REL */
35
 
36
static reloc_howto_type *ppc_elf_reloc_type_lookup
37
  PARAMS ((bfd *abfd, bfd_reloc_code_real_type code));
38
static void ppc_elf_info_to_howto
39
  PARAMS ((bfd *abfd, arelent *cache_ptr, Elf32_Internal_Rela *dst));
40
static void ppc_elf_howto_init PARAMS ((void));
41
static bfd_reloc_status_type ppc_elf_addr16_ha_reloc
42
  PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
43
static boolean ppc_elf_set_private_flags PARAMS ((bfd *, flagword));
44
static boolean ppc_elf_copy_private_bfd_data PARAMS ((bfd *, bfd *));
45
static boolean ppc_elf_merge_private_bfd_data PARAMS ((bfd *, bfd *));
46
 
47
static int ppc_elf_additional_program_headers PARAMS ((bfd *));
48
static boolean ppc_elf_modify_segment_map PARAMS ((bfd *));
49
 
50
static boolean ppc_elf_create_dynamic_sections
51
  PARAMS ((bfd *, struct bfd_link_info *));
52
 
53
static boolean ppc_elf_section_from_shdr PARAMS ((bfd *,
54
                                                  Elf32_Internal_Shdr *,
55
                                                  char *));
56
static boolean ppc_elf_fake_sections
57
  PARAMS ((bfd *, Elf32_Internal_Shdr *, asection *));
58
 
59
static elf_linker_section_t *ppc_elf_create_linker_section
60
  PARAMS ((bfd *abfd,
61
           struct bfd_link_info *info,
62
           enum elf_linker_section_enum));
63
 
64
static boolean ppc_elf_check_relocs PARAMS ((bfd *,
65
                                             struct bfd_link_info *,
66
                                             asection *,
67
                                             const Elf_Internal_Rela *));
68
 
69
static asection * ppc_elf_gc_mark_hook PARAMS ((bfd *abfd,
70
                                                struct bfd_link_info *info,
71
                                                Elf_Internal_Rela *rel,
72
                                                struct elf_link_hash_entry *h,
73
                                                Elf_Internal_Sym *sym));
74
 
75
static boolean ppc_elf_gc_sweep_hook PARAMS ((bfd *abfd,
76
                                              struct bfd_link_info *info,
77
                                              asection *sec,
78
                                              const Elf_Internal_Rela *relocs));
79
 
80
static boolean ppc_elf_adjust_dynamic_symbol PARAMS ((struct bfd_link_info *,
81
                                                      struct elf_link_hash_entry *));
82
 
83
static boolean ppc_elf_size_dynamic_sections PARAMS ((bfd *, struct bfd_link_info *));
84
 
85
static boolean ppc_elf_relocate_section PARAMS ((bfd *,
86
                                                 struct bfd_link_info *info,
87
                                                 bfd *,
88
                                                 asection *,
89
                                                 bfd_byte *,
90
                                                 Elf_Internal_Rela *relocs,
91
                                                 Elf_Internal_Sym *local_syms,
92
                                                 asection **));
93
 
94
static boolean ppc_elf_add_symbol_hook  PARAMS ((bfd *,
95
                                                 struct bfd_link_info *,
96
                                                 const Elf_Internal_Sym *,
97
                                                 const char **,
98
                                                 flagword *,
99
                                                 asection **,
100
                                                 bfd_vma *));
101
 
102
static boolean ppc_elf_finish_dynamic_symbol PARAMS ((bfd *,
103
                                                      struct bfd_link_info *,
104
                                                      struct elf_link_hash_entry *,
105
                                                      Elf_Internal_Sym *));
106
 
107
static boolean ppc_elf_finish_dynamic_sections PARAMS ((bfd *, struct bfd_link_info *));
108
 
109
#define BRANCH_PREDICT_BIT 0x200000             /* branch prediction bit for branch taken relocs */
110
#define RA_REGISTER_MASK 0x001f0000             /* mask to set RA in memory instructions */
111
#define RA_REGISTER_SHIFT 16                    /* value to shift register by to insert RA */
112
 
113
/* The name of the dynamic interpreter.  This is put in the .interp
114
   section.  */
115
 
116
#define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
117
 
118
/* The size in bytes of an entry in the procedure linkage table.  */
119
#define PLT_ENTRY_SIZE 12
120
/* The initial size of the plt reserved for the dynamic linker.  */
121
#define PLT_INITIAL_ENTRY_SIZE 72
122
/* The size of the gap between entries in the PLT.  */
123
#define PLT_SLOT_SIZE 8
124
/* The number of single-slot PLT entries (the rest use two slots).  */
125
#define PLT_NUM_SINGLE_ENTRIES 8192
126
 
127
/* Will references to this symbol always reference the symbol
128
   in this object?  */
129
#define SYMBOL_REFERENCES_LOCAL(INFO, H)                                \
130
  ((! INFO->shared                                                      \
131
    || INFO->symbolic                                                   \
132
    || H->dynindx == -1                                                 \
133
    || ELF_ST_VISIBILITY (H->other) == STV_INTERNAL                     \
134
    || ELF_ST_VISIBILITY (H->other) == STV_HIDDEN)                      \
135
   && (H->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) != 0)
136
 
137
/* Will _calls_ to this symbol always call the version in this object?  */
138
#define SYMBOL_CALLS_LOCAL(INFO, H)                             \
139
  ((! INFO->shared                                                      \
140
    || INFO->symbolic                                                   \
141
    || H->dynindx == -1                                                 \
142
    || ELF_ST_VISIBILITY (H->other) != STV_DEFAULT)                     \
143
   && (H->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) != 0)
144
 
145
static reloc_howto_type *ppc_elf_howto_table[(int) R_PPC_max];
146
 
147
static reloc_howto_type ppc_elf_howto_raw[] = {
148
  /* This reloc does nothing.  */
149
  HOWTO (R_PPC_NONE,            /* type */
150
         0,                      /* rightshift */
151
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
152
         32,                    /* bitsize */
153
         false,                 /* pc_relative */
154
         0,                      /* bitpos */
155
         complain_overflow_bitfield, /* complain_on_overflow */
156
         bfd_elf_generic_reloc, /* special_function */
157
         "R_PPC_NONE",          /* name */
158
         false,                 /* partial_inplace */
159
         0,                      /* src_mask */
160
         0,                      /* dst_mask */
161
         false),                /* pcrel_offset */
162
 
163
  /* A standard 32 bit relocation.  */
164
  HOWTO (R_PPC_ADDR32,          /* type */
165
         0,                      /* rightshift */
166
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
167
         32,                    /* bitsize */
168
         false,                 /* pc_relative */
169
         0,                      /* bitpos */
170
         complain_overflow_bitfield, /* complain_on_overflow */
171
         bfd_elf_generic_reloc, /* special_function */
172
         "R_PPC_ADDR32",        /* name */
173
         false,                 /* partial_inplace */
174
         0,                      /* src_mask */
175
         0xffffffff,            /* dst_mask */
176
         false),                /* pcrel_offset */
177
 
178
  /* An absolute 26 bit branch; the lower two bits must be zero.
179
     FIXME: we don't check that, we just clear them.  */
180
  HOWTO (R_PPC_ADDR24,          /* type */
181
         0,                      /* rightshift */
182
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
183
         26,                    /* bitsize */
184
         false,                 /* pc_relative */
185
         0,                      /* bitpos */
186
         complain_overflow_bitfield, /* complain_on_overflow */
187
         bfd_elf_generic_reloc, /* special_function */
188
         "R_PPC_ADDR24",        /* name */
189
         false,                 /* partial_inplace */
190
         0,                      /* src_mask */
191
         0x3fffffc,             /* dst_mask */
192
         false),                /* pcrel_offset */
193
 
194
  /* A standard 16 bit relocation.  */
195
  HOWTO (R_PPC_ADDR16,          /* type */
196
         0,                      /* rightshift */
197
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
198
         16,                    /* bitsize */
199
         false,                 /* pc_relative */
200
         0,                      /* bitpos */
201
         complain_overflow_bitfield, /* complain_on_overflow */
202
         bfd_elf_generic_reloc, /* special_function */
203
         "R_PPC_ADDR16",        /* name */
204
         false,                 /* partial_inplace */
205
         0,                      /* src_mask */
206
         0xffff,                /* dst_mask */
207
         false),                /* pcrel_offset */
208
 
209
  /* A 16 bit relocation without overflow.  */
210
  HOWTO (R_PPC_ADDR16_LO,       /* type */
211
         0,                      /* rightshift */
212
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
213
         16,                    /* bitsize */
214
         false,                 /* pc_relative */
215
         0,                      /* bitpos */
216
         complain_overflow_dont,/* complain_on_overflow */
217
         bfd_elf_generic_reloc, /* special_function */
218
         "R_PPC_ADDR16_LO",     /* name */
219
         false,                 /* partial_inplace */
220
         0,                      /* src_mask */
221
         0xffff,                /* dst_mask */
222
         false),                /* pcrel_offset */
223
 
224
  /* The high order 16 bits of an address.  */
225
  HOWTO (R_PPC_ADDR16_HI,       /* type */
226
         16,                    /* rightshift */
227
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
228
         16,                    /* bitsize */
229
         false,                 /* pc_relative */
230
         0,                      /* bitpos */
231
         complain_overflow_dont, /* complain_on_overflow */
232
         bfd_elf_generic_reloc, /* special_function */
233
         "R_PPC_ADDR16_HI",     /* name */
234
         false,                 /* partial_inplace */
235
         0,                      /* src_mask */
236
         0xffff,                /* dst_mask */
237
         false),                /* pcrel_offset */
238
 
239
  /* The high order 16 bits of an address, plus 1 if the contents of
240
     the low 16 bits, treated as a signed number, is negative.  */
241
  HOWTO (R_PPC_ADDR16_HA,       /* type */
242
         16,                    /* rightshift */
243
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
244
         16,                    /* bitsize */
245
         false,                 /* pc_relative */
246
         0,                      /* bitpos */
247
         complain_overflow_dont, /* complain_on_overflow */
248
         ppc_elf_addr16_ha_reloc, /* special_function */
249
         "R_PPC_ADDR16_HA",     /* name */
250
         false,                 /* partial_inplace */
251
         0,                      /* src_mask */
252
         0xffff,                /* dst_mask */
253
         false),                /* pcrel_offset */
254
 
255
  /* An absolute 16 bit branch; the lower two bits must be zero.
256
     FIXME: we don't check that, we just clear them.  */
257
  HOWTO (R_PPC_ADDR14,          /* type */
258
         0,                      /* rightshift */
259
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
260
         16,                    /* bitsize */
261
         false,                 /* pc_relative */
262
         0,                      /* bitpos */
263
         complain_overflow_bitfield, /* complain_on_overflow */
264
         bfd_elf_generic_reloc, /* special_function */
265
         "R_PPC_ADDR14",        /* name */
266
         false,                 /* partial_inplace */
267
         0,                      /* src_mask */
268
         0xfffc,                /* dst_mask */
269
         false),                /* pcrel_offset */
270
 
271
  /* An absolute 16 bit branch, for which bit 10 should be set to
272
     indicate that the branch is expected to be taken.  The lower two
273
     bits must be zero.  */
274
  HOWTO (R_PPC_ADDR14_BRTAKEN,  /* type */
275
         0,                      /* rightshift */
276
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
277
         16,                    /* bitsize */
278
         false,                 /* pc_relative */
279
         0,                      /* bitpos */
280
         complain_overflow_bitfield, /* complain_on_overflow */
281
         bfd_elf_generic_reloc, /* special_function */
282
         "R_PPC_ADDR14_BRTAKEN",/* name */
283
         false,                 /* partial_inplace */
284
         0,                      /* src_mask */
285
         0xfffc,                /* dst_mask */
286
         false),                /* pcrel_offset */
287
 
288
  /* An absolute 16 bit branch, for which bit 10 should be set to
289
     indicate that the branch is not expected to be taken.  The lower
290
     two bits must be zero.  */
291
  HOWTO (R_PPC_ADDR14_BRNTAKEN, /* type */
292
         0,                      /* rightshift */
293
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
294
         16,                    /* bitsize */
295
         false,                 /* pc_relative */
296
         0,                      /* bitpos */
297
         complain_overflow_bitfield, /* complain_on_overflow */
298
         bfd_elf_generic_reloc, /* special_function */
299
         "R_PPC_ADDR14_BRNTAKEN",/* name */
300
         false,                 /* partial_inplace */
301
         0,                      /* src_mask */
302
         0xfffc,                /* dst_mask */
303
         false),                /* pcrel_offset */
304
 
305
  /* A relative 26 bit branch; the lower two bits must be zero.  */
306
  HOWTO (R_PPC_REL24,           /* type */
307
         0,                      /* rightshift */
308
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
309
         26,                    /* bitsize */
310
         true,                  /* pc_relative */
311
         0,                      /* bitpos */
312
         complain_overflow_signed, /* complain_on_overflow */
313
         bfd_elf_generic_reloc, /* special_function */
314
         "R_PPC_REL24",         /* name */
315
         false,                 /* partial_inplace */
316
         0,                      /* src_mask */
317
         0x3fffffc,             /* dst_mask */
318
         true),                 /* pcrel_offset */
319
 
320
  /* A relative 16 bit branch; the lower two bits must be zero.  */
321
  HOWTO (R_PPC_REL14,           /* type */
322
         0,                      /* rightshift */
323
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
324
         16,                    /* bitsize */
325
         true,                  /* pc_relative */
326
         0,                      /* bitpos */
327
         complain_overflow_signed, /* complain_on_overflow */
328
         bfd_elf_generic_reloc, /* special_function */
329
         "R_PPC_REL14",         /* name */
330
         false,                 /* partial_inplace */
331
         0,                      /* src_mask */
332
         0xfffc,                /* dst_mask */
333
         true),                 /* pcrel_offset */
334
 
335
  /* A relative 16 bit branch.  Bit 10 should be set to indicate that
336
     the branch is expected to be taken.  The lower two bits must be
337
     zero.  */
338
  HOWTO (R_PPC_REL14_BRTAKEN,   /* type */
339
         0,                      /* rightshift */
340
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
341
         16,                    /* bitsize */
342
         true,                  /* pc_relative */
343
         0,                      /* bitpos */
344
         complain_overflow_signed, /* complain_on_overflow */
345
         bfd_elf_generic_reloc, /* special_function */
346
         "R_PPC_REL14_BRTAKEN", /* name */
347
         false,                 /* partial_inplace */
348
         0,                      /* src_mask */
349
         0xfffc,                /* dst_mask */
350
         true),                 /* pcrel_offset */
351
 
352
  /* A relative 16 bit branch.  Bit 10 should be set to indicate that
353
     the branch is not expected to be taken.  The lower two bits must
354
     be zero.  */
355
  HOWTO (R_PPC_REL14_BRNTAKEN,  /* type */
356
         0,                      /* rightshift */
357
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
358
         16,                    /* bitsize */
359
         true,                  /* pc_relative */
360
         0,                      /* bitpos */
361
         complain_overflow_signed, /* complain_on_overflow */
362
         bfd_elf_generic_reloc, /* special_function */
363
         "R_PPC_REL14_BRNTAKEN",/* name */
364
         false,                 /* partial_inplace */
365
         0,                      /* src_mask */
366
         0xfffc,                /* dst_mask */
367
         true),                 /* pcrel_offset */
368
 
369
  /* Like R_PPC_ADDR16, but referring to the GOT table entry for the
370
     symbol.  */
371
  HOWTO (R_PPC_GOT16,           /* type */
372
         0,                      /* rightshift */
373
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
374
         16,                    /* bitsize */
375
         false,                 /* pc_relative */
376
         0,                      /* bitpos */
377
         complain_overflow_signed, /* complain_on_overflow */
378
         bfd_elf_generic_reloc, /* special_function */
379
         "R_PPC_GOT16",         /* name */
380
         false,                 /* partial_inplace */
381
         0,                      /* src_mask */
382
         0xffff,                /* dst_mask */
383
         false),                /* pcrel_offset */
384
 
385
  /* Like R_PPC_ADDR16_LO, but referring to the GOT table entry for
386
     the symbol.  */
387
  HOWTO (R_PPC_GOT16_LO,        /* type */
388
         0,                      /* rightshift */
389
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
390
         16,                    /* bitsize */
391
         false,                 /* pc_relative */
392
         0,                      /* bitpos */
393
         complain_overflow_dont, /* complain_on_overflow */
394
         bfd_elf_generic_reloc, /* special_function */
395
         "R_PPC_GOT16_LO",      /* name */
396
         false,                 /* partial_inplace */
397
         0,                      /* src_mask */
398
         0xffff,                /* dst_mask */
399
         false),                /* pcrel_offset */
400
 
401
  /* Like R_PPC_ADDR16_HI, but referring to the GOT table entry for
402
     the symbol.  */
403
  HOWTO (R_PPC_GOT16_HI,        /* type */
404
         16,                    /* rightshift */
405
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
406
         16,                    /* bitsize */
407
         false,                 /* pc_relative */
408
         0,                      /* bitpos */
409
         complain_overflow_bitfield, /* complain_on_overflow */
410
         bfd_elf_generic_reloc, /* special_function */
411
         "R_PPC_GOT16_HI",      /* name */
412
         false,                 /* partial_inplace */
413
         0,                      /* src_mask */
414
         0xffff,                /* dst_mask */
415
         false),                 /* pcrel_offset */
416
 
417
  /* Like R_PPC_ADDR16_HA, but referring to the GOT table entry for
418
     the symbol.  */
419
  HOWTO (R_PPC_GOT16_HA,        /* type */
420
         16,                    /* rightshift */
421
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
422
         16,                    /* bitsize */
423
         false,                 /* pc_relative */
424
         0,                      /* bitpos */
425
         complain_overflow_bitfield, /* complain_on_overflow */
426
         ppc_elf_addr16_ha_reloc, /* special_function */
427
         "R_PPC_GOT16_HA",      /* name */
428
         false,                 /* partial_inplace */
429
         0,                      /* src_mask */
430
         0xffff,                /* dst_mask */
431
         false),                /* pcrel_offset */
432
 
433
  /* Like R_PPC_REL24, but referring to the procedure linkage table
434
     entry for the symbol.  */
435
  HOWTO (R_PPC_PLTREL24,        /* type */
436
         0,                      /* rightshift */
437
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
438
         26,                    /* bitsize */
439
         true,                  /* pc_relative */
440
         0,                      /* bitpos */
441
         complain_overflow_signed,  /* complain_on_overflow */
442
         bfd_elf_generic_reloc, /* special_function */
443
         "R_PPC_PLTREL24",      /* name */
444
         false,                 /* partial_inplace */
445
         0,                      /* src_mask */
446
         0x3fffffc,             /* dst_mask */
447
         true),                 /* pcrel_offset */
448
 
449
  /* This is used only by the dynamic linker.  The symbol should exist
450
     both in the object being run and in some shared library.  The
451
     dynamic linker copies the data addressed by the symbol from the
452
     shared library into the object, because the object being
453
     run has to have the data at some particular address.  */
454
  HOWTO (R_PPC_COPY,            /* type */
455
         0,                      /* rightshift */
456
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
457
         32,                    /* bitsize */
458
         false,                 /* pc_relative */
459
         0,                      /* bitpos */
460
         complain_overflow_bitfield, /* complain_on_overflow */
461
         bfd_elf_generic_reloc,  /* special_function */
462
         "R_PPC_COPY",          /* name */
463
         false,                 /* partial_inplace */
464
         0,                      /* src_mask */
465
         0,                      /* dst_mask */
466
         false),                /* pcrel_offset */
467
 
468
  /* Like R_PPC_ADDR32, but used when setting global offset table
469
     entries.  */
470
  HOWTO (R_PPC_GLOB_DAT,        /* type */
471
         0,                      /* rightshift */
472
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
473
         32,                    /* bitsize */
474
         false,                 /* pc_relative */
475
         0,                      /* bitpos */
476
         complain_overflow_bitfield, /* complain_on_overflow */
477
         bfd_elf_generic_reloc,  /* special_function */
478
         "R_PPC_GLOB_DAT",      /* name */
479
         false,                 /* partial_inplace */
480
         0,                      /* src_mask */
481
         0xffffffff,            /* dst_mask */
482
         false),                /* pcrel_offset */
483
 
484
  /* Marks a procedure linkage table entry for a symbol.  */
485
  HOWTO (R_PPC_JMP_SLOT,        /* type */
486
         0,                      /* rightshift */
487
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
488
         32,                    /* bitsize */
489
         false,                 /* pc_relative */
490
         0,                      /* bitpos */
491
         complain_overflow_bitfield, /* complain_on_overflow */
492
         bfd_elf_generic_reloc,  /* special_function */
493
         "R_PPC_JMP_SLOT",      /* name */
494
         false,                 /* partial_inplace */
495
         0,                      /* src_mask */
496
         0,                      /* dst_mask */
497
         false),                /* pcrel_offset */
498
 
499
  /* Used only by the dynamic linker.  When the object is run, this
500
     longword is set to the load address of the object, plus the
501
     addend.  */
502
  HOWTO (R_PPC_RELATIVE,        /* type */
503
         0,                      /* rightshift */
504
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
505
         32,                    /* bitsize */
506
         false,                 /* pc_relative */
507
         0,                      /* bitpos */
508
         complain_overflow_bitfield, /* complain_on_overflow */
509
         bfd_elf_generic_reloc,  /* special_function */
510
         "R_PPC_RELATIVE",      /* name */
511
         false,                 /* partial_inplace */
512
         0,                      /* src_mask */
513
         0xffffffff,            /* dst_mask */
514
         false),                /* pcrel_offset */
515
 
516
  /* Like R_PPC_REL24, but uses the value of the symbol within the
517
     object rather than the final value.  Normally used for
518
     _GLOBAL_OFFSET_TABLE_.  */
519
  HOWTO (R_PPC_LOCAL24PC,       /* type */
520
         0,                      /* rightshift */
521
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
522
         26,                    /* bitsize */
523
         true,                  /* pc_relative */
524
         0,                      /* bitpos */
525
         complain_overflow_signed, /* complain_on_overflow */
526
         bfd_elf_generic_reloc, /* special_function */
527
         "R_PPC_LOCAL24PC",     /* name */
528
         false,                 /* partial_inplace */
529
         0,                      /* src_mask */
530
         0x3fffffc,             /* dst_mask */
531
         true),                 /* pcrel_offset */
532
 
533
  /* Like R_PPC_ADDR32, but may be unaligned.  */
534
  HOWTO (R_PPC_UADDR32,         /* type */
535
         0,                      /* rightshift */
536
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
537
         32,                    /* bitsize */
538
         false,                 /* pc_relative */
539
         0,                      /* bitpos */
540
         complain_overflow_bitfield, /* complain_on_overflow */
541
         bfd_elf_generic_reloc, /* special_function */
542
         "R_PPC_UADDR32",       /* name */
543
         false,                 /* partial_inplace */
544
         0,                      /* src_mask */
545
         0xffffffff,            /* dst_mask */
546
         false),                /* pcrel_offset */
547
 
548
  /* Like R_PPC_ADDR16, but may be unaligned.  */
549
  HOWTO (R_PPC_UADDR16,         /* type */
550
         0,                      /* rightshift */
551
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
552
         16,                    /* bitsize */
553
         false,                 /* pc_relative */
554
         0,                      /* bitpos */
555
         complain_overflow_bitfield, /* complain_on_overflow */
556
         bfd_elf_generic_reloc, /* special_function */
557
         "R_PPC_UADDR16",       /* name */
558
         false,                 /* partial_inplace */
559
         0,                      /* src_mask */
560
         0xffff,                /* dst_mask */
561
         false),                /* pcrel_offset */
562
 
563
  /* 32-bit PC relative */
564
  HOWTO (R_PPC_REL32,           /* type */
565
         0,                      /* rightshift */
566
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
567
         32,                    /* bitsize */
568
         true,                  /* pc_relative */
569
         0,                      /* bitpos */
570
         complain_overflow_bitfield, /* complain_on_overflow */
571
         bfd_elf_generic_reloc, /* special_function */
572
         "R_PPC_REL32",         /* name */
573
         false,                 /* partial_inplace */
574
         0,                      /* src_mask */
575
         0xffffffff,            /* dst_mask */
576
         true),                 /* pcrel_offset */
577
 
578
  /* 32-bit relocation to the symbol's procedure linkage table.
579
     FIXME: not supported.  */
580
  HOWTO (R_PPC_PLT32,           /* type */
581
         0,                      /* rightshift */
582
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
583
         32,                    /* bitsize */
584
         false,                 /* pc_relative */
585
         0,                      /* bitpos */
586
         complain_overflow_bitfield, /* complain_on_overflow */
587
         bfd_elf_generic_reloc, /* special_function */
588
         "R_PPC_PLT32",         /* name */
589
         false,                 /* partial_inplace */
590
         0,                      /* src_mask */
591
         0,                      /* dst_mask */
592
         false),                /* pcrel_offset */
593
 
594
  /* 32-bit PC relative relocation to the symbol's procedure linkage table.
595
     FIXME: not supported.  */
596
  HOWTO (R_PPC_PLTREL32,        /* type */
597
         0,                      /* rightshift */
598
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
599
         32,                    /* bitsize */
600
         true,                  /* pc_relative */
601
         0,                      /* bitpos */
602
         complain_overflow_bitfield, /* complain_on_overflow */
603
         bfd_elf_generic_reloc, /* special_function */
604
         "R_PPC_PLTREL32",      /* name */
605
         false,                 /* partial_inplace */
606
         0,                      /* src_mask */
607
         0,                      /* dst_mask */
608
         true),                 /* pcrel_offset */
609
 
610
  /* Like R_PPC_ADDR16_LO, but referring to the PLT table entry for
611
     the symbol.  */
612
  HOWTO (R_PPC_PLT16_LO,        /* type */
613
         0,                      /* rightshift */
614
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
615
         16,                    /* bitsize */
616
         false,                 /* pc_relative */
617
         0,                      /* bitpos */
618
         complain_overflow_dont, /* complain_on_overflow */
619
         bfd_elf_generic_reloc, /* special_function */
620
         "R_PPC_PLT16_LO",      /* name */
621
         false,                 /* partial_inplace */
622
         0,                      /* src_mask */
623
         0xffff,                /* dst_mask */
624
         false),                /* pcrel_offset */
625
 
626
  /* Like R_PPC_ADDR16_HI, but referring to the PLT table entry for
627
     the symbol.  */
628
  HOWTO (R_PPC_PLT16_HI,        /* type */
629
         16,                    /* rightshift */
630
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
631
         16,                    /* bitsize */
632
         false,                 /* pc_relative */
633
         0,                      /* bitpos */
634
         complain_overflow_bitfield, /* complain_on_overflow */
635
         bfd_elf_generic_reloc, /* special_function */
636
         "R_PPC_PLT16_HI",      /* name */
637
         false,                 /* partial_inplace */
638
         0,                      /* src_mask */
639
         0xffff,                /* dst_mask */
640
         false),                 /* pcrel_offset */
641
 
642
  /* Like R_PPC_ADDR16_HA, but referring to the PLT table entry for
643
     the symbol.  */
644
  HOWTO (R_PPC_PLT16_HA,        /* type */
645
         16,                    /* rightshift */
646
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
647
         16,                    /* bitsize */
648
         false,                 /* pc_relative */
649
         0,                      /* bitpos */
650
         complain_overflow_bitfield, /* complain_on_overflow */
651
         ppc_elf_addr16_ha_reloc, /* special_function */
652
         "R_PPC_PLT16_HA",      /* name */
653
         false,                 /* partial_inplace */
654
         0,                      /* src_mask */
655
         0xffff,                /* dst_mask */
656
         false),                /* pcrel_offset */
657
 
658
  /* A sign-extended 16 bit value relative to _SDA_BASE_, for use with
659
     small data items.  */
660
  HOWTO (R_PPC_SDAREL16,        /* type */
661
         0,                      /* rightshift */
662
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
663
         16,                    /* bitsize */
664
         false,                 /* pc_relative */
665
         0,                      /* bitpos */
666
         complain_overflow_signed, /* complain_on_overflow */
667
         bfd_elf_generic_reloc, /* special_function */
668
         "R_PPC_SDAREL16",      /* name */
669
         false,                 /* partial_inplace */
670
         0,                      /* src_mask */
671
         0xffff,                /* dst_mask */
672
         false),                /* pcrel_offset */
673
 
674
  /* 32-bit section relative relocation.  */
675
  HOWTO (R_PPC_SECTOFF,         /* type */
676
         0,                      /* rightshift */
677
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
678
         32,                    /* bitsize */
679
         true,                  /* pc_relative */
680
         0,                      /* bitpos */
681
         complain_overflow_bitfield, /* complain_on_overflow */
682
         bfd_elf_generic_reloc, /* special_function */
683
         "R_PPC_SECTOFF",       /* name */
684
         false,                 /* partial_inplace */
685
         0,                      /* src_mask */
686
         0,                      /* dst_mask */
687
         true),                 /* pcrel_offset */
688
 
689
  /* 16-bit lower half section relative relocation.  */
690
  HOWTO (R_PPC_SECTOFF_LO,        /* type */
691
         0,                      /* rightshift */
692
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
693
         16,                    /* bitsize */
694
         false,                 /* pc_relative */
695
         0,                      /* bitpos */
696
         complain_overflow_dont, /* complain_on_overflow */
697
         bfd_elf_generic_reloc, /* special_function */
698
         "R_PPC_SECTOFF_LO",    /* name */
699
         false,                 /* partial_inplace */
700
         0,                      /* src_mask */
701
         0xffff,                /* dst_mask */
702
         false),                /* pcrel_offset */
703
 
704
  /* 16-bit upper half section relative relocation.  */
705
  HOWTO (R_PPC_SECTOFF_HI,      /* type */
706
         16,                    /* rightshift */
707
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
708
         16,                    /* bitsize */
709
         false,                 /* pc_relative */
710
         0,                      /* bitpos */
711
         complain_overflow_bitfield, /* complain_on_overflow */
712
         bfd_elf_generic_reloc, /* special_function */
713
         "R_PPC_SECTOFF_HI",    /* name */
714
         false,                 /* partial_inplace */
715
         0,                      /* src_mask */
716
         0xffff,                /* dst_mask */
717
         false),                 /* pcrel_offset */
718
 
719
  /* 16-bit upper half adjusted section relative relocation.  */
720
  HOWTO (R_PPC_SECTOFF_HA,      /* type */
721
         16,                    /* rightshift */
722
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
723
         16,                    /* bitsize */
724
         false,                 /* pc_relative */
725
         0,                      /* bitpos */
726
         complain_overflow_bitfield, /* complain_on_overflow */
727
         ppc_elf_addr16_ha_reloc, /* special_function */
728
         "R_PPC_SECTOFF_HA",    /* name */
729
         false,                 /* partial_inplace */
730
         0,                      /* src_mask */
731
         0xffff,                /* dst_mask */
732
         false),                /* pcrel_offset */
733
 
734
  /* The remaining relocs are from the Embedded ELF ABI, and are not
735
     in the SVR4 ELF ABI.  */
736
 
737
  /* 32 bit value resulting from the addend minus the symbol */
738
  HOWTO (R_PPC_EMB_NADDR32,     /* type */
739
         0,                      /* rightshift */
740
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
741
         32,                    /* bitsize */
742
         false,                 /* pc_relative */
743
         0,                      /* bitpos */
744
         complain_overflow_bitfield, /* complain_on_overflow */
745
         bfd_elf_generic_reloc, /* special_function */
746
         "R_PPC_EMB_NADDR32",   /* name */
747
         false,                 /* partial_inplace */
748
         0,                      /* src_mask */
749
         0xffffffff,            /* dst_mask */
750
         false),                /* pcrel_offset */
751
 
752
  /* 16 bit value resulting from the addend minus the symbol */
753
  HOWTO (R_PPC_EMB_NADDR16,     /* type */
754
         0,                      /* rightshift */
755
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
756
         16,                    /* bitsize */
757
         false,                 /* pc_relative */
758
         0,                      /* bitpos */
759
         complain_overflow_bitfield, /* complain_on_overflow */
760
         bfd_elf_generic_reloc, /* special_function */
761
         "R_PPC_EMB_NADDR16",   /* name */
762
         false,                 /* partial_inplace */
763
         0,                      /* src_mask */
764
         0xffff,                /* dst_mask */
765
         false),                /* pcrel_offset */
766
 
767
  /* 16 bit value resulting from the addend minus the symbol */
768
  HOWTO (R_PPC_EMB_NADDR16_LO,  /* type */
769
         0,                      /* rightshift */
770
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
771
         16,                    /* bitsize */
772
         false,                 /* pc_relative */
773
         0,                      /* bitpos */
774
         complain_overflow_dont,/* complain_on_overflow */
775
         bfd_elf_generic_reloc, /* special_function */
776
         "R_PPC_EMB_ADDR16_LO", /* name */
777
         false,                 /* partial_inplace */
778
         0,                      /* src_mask */
779
         0xffff,                /* dst_mask */
780
         false),                /* pcrel_offset */
781
 
782
  /* The high order 16 bits of the addend minus the symbol */
783
  HOWTO (R_PPC_EMB_NADDR16_HI,  /* type */
784
         16,                    /* rightshift */
785
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
786
         16,                    /* bitsize */
787
         false,                 /* pc_relative */
788
         0,                      /* bitpos */
789
         complain_overflow_dont, /* complain_on_overflow */
790
         bfd_elf_generic_reloc, /* special_function */
791
         "R_PPC_EMB_NADDR16_HI", /* name */
792
         false,                 /* partial_inplace */
793
         0,                      /* src_mask */
794
         0xffff,                /* dst_mask */
795
         false),                /* pcrel_offset */
796
 
797
  /* The high order 16 bits of the result of the addend minus the address,
798
     plus 1 if the contents of the low 16 bits, treated as a signed number,
799
     is negative.  */
800
  HOWTO (R_PPC_EMB_NADDR16_HA,  /* type */
801
         16,                    /* rightshift */
802
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
803
         16,                    /* bitsize */
804
         false,                 /* pc_relative */
805
         0,                      /* bitpos */
806
         complain_overflow_dont, /* complain_on_overflow */
807
         ppc_elf_addr16_ha_reloc, /* special_function */
808
         "R_PPC_EMB_NADDR16_HA", /* name */
809
         false,                 /* partial_inplace */
810
         0,                      /* src_mask */
811
         0xffff,                /* dst_mask */
812
         false),                /* pcrel_offset */
813
 
814
  /* 16 bit value resulting from allocating a 4 byte word to hold an
815
     address in the .sdata section, and returning the offset from
816
     _SDA_BASE_ for that relocation */
817
  HOWTO (R_PPC_EMB_SDAI16,      /* type */
818
         0,                      /* rightshift */
819
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
820
         16,                    /* bitsize */
821
         false,                 /* pc_relative */
822
         0,                      /* bitpos */
823
         complain_overflow_bitfield, /* complain_on_overflow */
824
         bfd_elf_generic_reloc, /* special_function */
825
         "R_PPC_EMB_SDAI16",    /* name */
826
         false,                 /* partial_inplace */
827
         0,                      /* src_mask */
828
         0xffff,                /* dst_mask */
829
         false),                /* pcrel_offset */
830
 
831
  /* 16 bit value resulting from allocating a 4 byte word to hold an
832
     address in the .sdata2 section, and returning the offset from
833
     _SDA2_BASE_ for that relocation */
834
  HOWTO (R_PPC_EMB_SDA2I16,     /* type */
835
         0,                      /* rightshift */
836
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
837
         16,                    /* bitsize */
838
         false,                 /* pc_relative */
839
         0,                      /* bitpos */
840
         complain_overflow_bitfield, /* complain_on_overflow */
841
         bfd_elf_generic_reloc, /* special_function */
842
         "R_PPC_EMB_SDA2I16",   /* name */
843
         false,                 /* partial_inplace */
844
         0,                      /* src_mask */
845
         0xffff,                /* dst_mask */
846
         false),                /* pcrel_offset */
847
 
848
  /* A sign-extended 16 bit value relative to _SDA2_BASE_, for use with
849
     small data items.   */
850
  HOWTO (R_PPC_EMB_SDA2REL,     /* type */
851
         0,                      /* rightshift */
852
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
853
         16,                    /* bitsize */
854
         false,                 /* pc_relative */
855
         0,                      /* bitpos */
856
         complain_overflow_signed, /* complain_on_overflow */
857
         bfd_elf_generic_reloc, /* special_function */
858
         "R_PPC_EMB_SDA2REL",   /* name */
859
         false,                 /* partial_inplace */
860
         0,                      /* src_mask */
861
         0xffff,                /* dst_mask */
862
         false),                /* pcrel_offset */
863
 
864
  /* Relocate against either _SDA_BASE_ or _SDA2_BASE_, filling in the 16 bit
865
     signed offset from the appropriate base, and filling in the register
866
     field with the appropriate register (0, 2, or 13).  */
867
  HOWTO (R_PPC_EMB_SDA21,       /* type */
868
         0,                      /* rightshift */
869
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
870
         16,                    /* bitsize */
871
         false,                 /* pc_relative */
872
         0,                      /* bitpos */
873
         complain_overflow_signed, /* complain_on_overflow */
874
         bfd_elf_generic_reloc, /* special_function */
875
         "R_PPC_EMB_SDA21",     /* name */
876
         false,                 /* partial_inplace */
877
         0,                      /* src_mask */
878
         0xffff,                /* dst_mask */
879
         false),                /* pcrel_offset */
880
 
881
  /* Relocation not handled: R_PPC_EMB_MRKREF */
882
  /* Relocation not handled: R_PPC_EMB_RELSEC16 */
883
  /* Relocation not handled: R_PPC_EMB_RELST_LO */
884
  /* Relocation not handled: R_PPC_EMB_RELST_HI */
885
  /* Relocation not handled: R_PPC_EMB_RELST_HA */
886
  /* Relocation not handled: R_PPC_EMB_BIT_FLD */
887
 
888
  /* PC relative relocation against either _SDA_BASE_ or _SDA2_BASE_, filling
889
     in the 16 bit signed offset from the appropriate base, and filling in the
890
     register field with the appropriate register (0, 2, or 13).  */
891
  HOWTO (R_PPC_EMB_RELSDA,      /* type */
892
         0,                      /* rightshift */
893
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
894
         16,                    /* bitsize */
895
         true,                  /* pc_relative */
896
         0,                      /* bitpos */
897
         complain_overflow_signed, /* complain_on_overflow */
898
         bfd_elf_generic_reloc, /* special_function */
899
         "R_PPC_EMB_RELSDA",    /* name */
900
         false,                 /* partial_inplace */
901
         0,                      /* src_mask */
902
         0xffff,                /* dst_mask */
903
         false),                /* pcrel_offset */
904
 
905
  /* GNU extension to record C++ vtable hierarchy */
906
  HOWTO (R_PPC_GNU_VTINHERIT,   /* type */
907
         0,                      /* rightshift */
908
         0,                      /* size (0 = byte, 1 = short, 2 = long) */
909
         0,                      /* bitsize */
910
         false,                 /* pc_relative */
911
         0,                      /* bitpos */
912
         complain_overflow_dont, /* complain_on_overflow */
913
         NULL,                  /* special_function */
914
         "R_PPC_GNU_VTINHERIT", /* name */
915
         false,                 /* partial_inplace */
916
         0,                      /* src_mask */
917
         0,                      /* dst_mask */
918
         false),                /* pcrel_offset */
919
 
920
  /* GNU extension to record C++ vtable member usage */
921
  HOWTO (R_PPC_GNU_VTENTRY,     /* type */
922
         0,                      /* rightshift */
923
         0,                      /* size (0 = byte, 1 = short, 2 = long) */
924
         0,                      /* bitsize */
925
         false,                 /* pc_relative */
926
         0,                      /* bitpos */
927
         complain_overflow_dont, /* complain_on_overflow */
928
         NULL,                  /* special_function */
929
         "R_PPC_GNU_VTENTRY",   /* name */
930
         false,                 /* partial_inplace */
931
         0,                      /* src_mask */
932
         0,                      /* dst_mask */
933
         false),                /* pcrel_offset */
934
 
935
  /* Phony reloc to handle AIX style TOC entries */
936
  HOWTO (R_PPC_TOC16,           /* type */
937
         0,                      /* rightshift */
938
         1,                     /* size (0 = byte, 1 = short, 2 = long) */
939
         16,                    /* bitsize */
940
         false,                 /* pc_relative */
941
         0,                      /* bitpos */
942
         complain_overflow_signed, /* complain_on_overflow */
943
         bfd_elf_generic_reloc, /* special_function */
944
         "R_PPC_TOC16",         /* name */
945
         false,                 /* partial_inplace */
946
         0,                      /* src_mask */
947
         0xffff,                /* dst_mask */
948
         false),                /* pcrel_offset */
949
};
950
 
951
/* Initialize the ppc_elf_howto_table, so that linear accesses can be done.  */
952
 
953
static void
954
ppc_elf_howto_init ()
955
{
956
  unsigned int i, type;
957
 
958
  for (i = 0; i < sizeof (ppc_elf_howto_raw) / sizeof (ppc_elf_howto_raw[0]); i++)
959
    {
960
      type = ppc_elf_howto_raw[i].type;
961
      BFD_ASSERT (type < sizeof (ppc_elf_howto_table) / sizeof (ppc_elf_howto_table[0]));
962
      ppc_elf_howto_table[type] = &ppc_elf_howto_raw[i];
963
    }
964
}
965
 
966
/* This function handles relaxing for the PPC with option --mpc860c0[=<n>].
967
 
968
   The MPC860, revision C0 or earlier contains a bug in the die.
969
   If all of the following conditions are true, the next instruction
970
   to be executed *may* be treated as a no-op.
971
   1/ A forward branch is executed.
972
   2/ The branch is predicted as not taken.
973
   3/ The branch is taken.
974
   4/ The branch is located in the last 5 words of a page.
975
      (The EOP limit is 5 by default but may be specified as any value from 1-10.)
976
 
977
   Our software solution is to detect these problematic branches in a
978
   linker pass and modify them as follows:
979
   1/ Unconditional branches - Since these are always predicted taken,
980
      there is no problem and no action is required.
981
   2/ Conditional backward branches - No problem, no action required.
982
   3/ Conditional forward branches - Ensure that the "inverse prediction
983
      bit" is set (ensure it is predicted taken).
984
   4/ Conditional register branches - Ensure that the "y bit" is set
985
      (ensure it is predicted taken).
986
*/
987
 
988
/* Sort sections by address.  */
989
 
990
static int
991
ppc_elf_sort_rela (arg1, arg2)
992
     const void *arg1;
993
     const void *arg2;
994
{
995
  const Elf_Internal_Rela **rela1 = (const Elf_Internal_Rela**) arg1;
996
  const Elf_Internal_Rela **rela2 = (const Elf_Internal_Rela**) arg2;
997
 
998
  /* Sort by offset.  */
999
  return ((*rela1)->r_offset - (*rela2)->r_offset);
1000
}
1001
 
1002
static boolean
1003
ppc_elf_relax_section (abfd, isec, link_info, again)
1004
     bfd *abfd;
1005
     asection *isec;
1006
     struct bfd_link_info *link_info;
1007
     boolean *again;
1008
{
1009
#define PAGESIZE 0x1000
1010
 
1011
  bfd_byte *contents = NULL;
1012
  bfd_byte *free_contents = NULL;
1013
  Elf_Internal_Rela *internal_relocs = NULL;
1014
  Elf_Internal_Rela *free_relocs = NULL;
1015
  Elf_Internal_Rela **rela_comb = NULL;
1016
  int comb_curr, comb_count;
1017
 
1018
  /* We never have to do this more than once per input section.  */
1019
  *again = false;
1020
 
1021
  /* If needed, initialize this section's cooked size.  */
1022
  if (isec->_cooked_size == 0)
1023
      isec->_cooked_size = isec->_raw_size;
1024
 
1025
  /* We're only interested in text sections which overlap the
1026
     troublesome area at the end of a page.  */
1027
  if (link_info->mpc860c0 && (isec->flags & SEC_CODE) && isec->_cooked_size)
1028
    {
1029
      bfd_vma dot, end_page, end_section;
1030
      boolean section_modified;
1031
 
1032
      /* Get the section contents.  */
1033
      /* Get cached copy if it exists.  */
1034
      if (elf_section_data (isec)->this_hdr.contents != NULL)
1035
          contents = elf_section_data (isec)->this_hdr.contents;
1036
      else
1037
        {
1038
          /* Go get them off disk.  */
1039
          contents = (bfd_byte *) bfd_malloc (isec->_raw_size);
1040
          if (contents == NULL)
1041
            goto error_return;
1042
          free_contents = contents;
1043
 
1044
          if (! bfd_get_section_contents (abfd, isec, contents,
1045
                                          (file_ptr) 0, isec->_raw_size))
1046
            goto error_return;
1047
        }
1048
 
1049
      comb_curr = 0;
1050
      comb_count = 0;
1051
      if (isec->reloc_count)
1052
        {
1053
          unsigned n;
1054
 
1055
          /* Get a copy of the native relocations.  */
1056
          internal_relocs = _bfd_elf32_link_read_relocs (
1057
            abfd, isec, (PTR) NULL, (Elf_Internal_Rela *) NULL,
1058
            link_info->keep_memory);
1059
          if (internal_relocs == NULL)
1060
              goto error_return;
1061
          if (! link_info->keep_memory)
1062
              free_relocs = internal_relocs;
1063
 
1064
          /* Setup a faster access method for the reloc info we need.  */
1065
          rela_comb = (Elf_Internal_Rela**)
1066
            bfd_malloc (isec->reloc_count*sizeof (Elf_Internal_Rela*));
1067
          if (rela_comb == NULL)
1068
              goto error_return;
1069
          for (n = 0; n < isec->reloc_count; ++n)
1070
            {
1071
              long r_type;
1072
 
1073
              r_type = ELF32_R_TYPE (internal_relocs[n].r_info);
1074
              if (r_type < 0 || r_type >= (int) R_PPC_max)
1075
                  goto error_return;
1076
 
1077
              /* Prologue constants are sometimes present in the ".text"
1078
              sections and they can be identified by their associated relocation.
1079
              We don't want to process those words and some others which
1080
              can also be identified by their relocations.  However, not all
1081
              conditional branches will have a relocation so we will
1082
              only ignore words that 1) have a reloc, and 2) the reloc
1083
              is not applicable to a conditional branch.
1084
              The array rela_comb is built here for use in the EOP scan loop.  */
1085
              switch (r_type)
1086
                {
1087
                case R_PPC_ADDR14_BRNTAKEN:     /* absolute, predicted not taken */
1088
                case R_PPC_REL14:               /* relative cond. br.  */
1089
                case R_PPC_REL14_BRNTAKEN:      /* rel. cond. br., predicted not taken */
1090
                  /* We should check the instruction.  */
1091
                  break;
1092
                default:
1093
                  /* The word is not a conditional branch - ignore it.  */
1094
                  rela_comb[comb_count++] = &internal_relocs[n];
1095
                  break;
1096
                }
1097
            }
1098
          if (comb_count > 1)
1099
            qsort (rela_comb, (size_t) comb_count, sizeof (int), ppc_elf_sort_rela);
1100
        }
1101
 
1102
      /* Enumerate each EOP region that overlaps this section.  */
1103
      end_section = isec->vma + isec->_cooked_size;
1104
      dot = end_page = (isec->vma | (PAGESIZE - 1)) + 1;
1105
      dot -= link_info->mpc860c0;
1106
      section_modified = false;
1107
      if (dot < isec->vma)      /* Increment the start position if this section */
1108
          dot = isec->vma;      /* begins in the middle of its first EOP region.  */
1109
      for (;
1110
           dot < end_section;
1111
           dot += PAGESIZE, end_page += PAGESIZE)
1112
        {
1113
 
1114
          /* Check each word in this EOP region.  */
1115
          for (; dot < end_page; dot += 4)
1116
            {
1117
              bfd_vma isec_offset;
1118
              unsigned long insn;
1119
              boolean skip, modified;
1120
 
1121
              /* Don't process this word if there is a relocation for it and
1122
              the relocation indicates the word is not a conditional branch.  */
1123
              skip = false;
1124
              isec_offset = dot - isec->vma;
1125
              for (; comb_curr<comb_count; ++comb_curr)
1126
                {
1127
                  bfd_vma r_offset;
1128
 
1129
                  r_offset = rela_comb[comb_curr]->r_offset;
1130
                  if (r_offset >= isec_offset)
1131
                    {
1132
                      if (r_offset == isec_offset) skip = true;
1133
                      break;
1134
                    }
1135
                }
1136
              if (skip) continue;
1137
 
1138
              /* Check the current word for a problematic conditional branch.  */
1139
#define BO0(insn) ((insn) & 0x02000000)
1140
#define BO2(insn) ((insn) & 0x00800000)
1141
#define BO4(insn) ((insn) & 0x00200000)
1142
              insn = (unsigned long) bfd_get_32 (abfd, contents + isec_offset);
1143
              modified = false;
1144
              if ((insn & 0xFc000000) == 0x40000000)
1145
                {
1146
                  /* Instruction is BCx */
1147
                  if ((!BO0(insn) || !BO2(insn)) && !BO4(insn))
1148
                    {
1149
                      bfd_vma target;
1150
                      /* This branch is predicted as "normal".
1151
                      If this is a forward branch, it is problematic.  */
1152
 
1153
                      target = insn & 0x0000Fffc;               /*extract*/
1154
                      target = (target ^ 0x8000) - 0x8000;      /*sign extend*/
1155
                      if ((insn & 0x00000002) == 0)
1156
                          target += dot;                        /*convert to abs*/
1157
                      if (target > dot)
1158
                        {
1159
                          insn |= 0x00200000;   /* set the prediction bit */
1160
                          modified = true;
1161
                        }
1162
                    }
1163
                }
1164
              else if ((insn & 0xFc00Fffe) == 0x4c000420)
1165
                {
1166
                  /* Instruction is BCCTRx */
1167
                  if ((!BO0(insn) || !BO2(insn)) && !BO4(insn))
1168
                    {
1169
                      /* This branch is predicted as not-taken.
1170
                      If this is a forward branch, it is problematic.
1171
                      Since we can't tell statically if it will branch forward,
1172
                      always set the prediction bit.  */
1173
                      insn |= 0x00200000;   /* set the prediction bit */
1174
                      modified = true;
1175
                    }
1176
                }
1177
              else if ((insn & 0xFc00Fffe) == 0x4c000020)
1178
                {
1179
                  /* Instruction is BCLRx */
1180
                  if ((!BO0(insn) || !BO2(insn)) && !BO4(insn))
1181
                    {
1182
                      /* This branch is predicted as not-taken.
1183
                      If this is a forward branch, it is problematic.
1184
                      Since we can't tell statically if it will branch forward,
1185
                      always set the prediction bit.  */
1186
                      insn |= 0x00200000;   /* set the prediction bit */
1187
                      modified = true;
1188
                    }
1189
                }
1190
#undef BO0
1191
#undef BO2
1192
#undef BO4
1193
              if (modified)
1194
                {
1195
                  bfd_put_32 (abfd, insn, contents + isec_offset);
1196
                  section_modified = true;
1197
                }
1198
            }
1199
        }
1200
      if (section_modified)
1201
        {
1202
          elf_section_data (isec)->this_hdr.contents = contents;
1203
          free_contents = NULL;
1204
        }
1205
    }
1206
 
1207
  if (rela_comb != NULL)
1208
    {
1209
      free (rela_comb);
1210
      rela_comb = NULL;
1211
    }
1212
 
1213
  if (free_relocs != NULL)
1214
    {
1215
      free (free_relocs);
1216
      free_relocs = NULL;
1217
    }
1218
 
1219
  if (free_contents != NULL)
1220
    {
1221
      if (! link_info->keep_memory)
1222
        free (free_contents);
1223
      else
1224
        {
1225
          /* Cache the section contents for elf_link_input_bfd.  */
1226
          elf_section_data (isec)->this_hdr.contents = contents;
1227
        }
1228
      free_contents = NULL;
1229
    }
1230
 
1231
  return true;
1232
 
1233
error_return:
1234
  if (rela_comb != NULL)
1235
    free (rela_comb);
1236
  if (free_relocs != NULL)
1237
    free (free_relocs);
1238
  if (free_contents != NULL)
1239
    free (free_contents);
1240
  return false;
1241
}
1242
 
1243
static reloc_howto_type *
1244
ppc_elf_reloc_type_lookup (abfd, code)
1245
     bfd *abfd ATTRIBUTE_UNUSED;
1246
     bfd_reloc_code_real_type code;
1247
{
1248
  enum elf_ppc_reloc_type ppc_reloc = R_PPC_NONE;
1249
 
1250
  if (!ppc_elf_howto_table[R_PPC_ADDR32])
1251
    /* Initialize howto table if needed.  */
1252
    ppc_elf_howto_init ();
1253
 
1254
  switch ((int) code)
1255
    {
1256
    default:
1257
      return (reloc_howto_type *) NULL;
1258
 
1259
    case BFD_RELOC_NONE:                ppc_reloc = R_PPC_NONE;                 break;
1260
    case BFD_RELOC_32:                  ppc_reloc = R_PPC_ADDR32;               break;
1261
    case BFD_RELOC_PPC_BA26:            ppc_reloc = R_PPC_ADDR24;               break;
1262
    case BFD_RELOC_16:                  ppc_reloc = R_PPC_ADDR16;               break;
1263
    case BFD_RELOC_LO16:                ppc_reloc = R_PPC_ADDR16_LO;            break;
1264
    case BFD_RELOC_HI16:                ppc_reloc = R_PPC_ADDR16_HI;            break;
1265
    case BFD_RELOC_HI16_S:              ppc_reloc = R_PPC_ADDR16_HA;            break;
1266
    case BFD_RELOC_PPC_BA16:            ppc_reloc = R_PPC_ADDR14;               break;
1267
    case BFD_RELOC_PPC_BA16_BRTAKEN:    ppc_reloc = R_PPC_ADDR14_BRTAKEN;       break;
1268
    case BFD_RELOC_PPC_BA16_BRNTAKEN:   ppc_reloc = R_PPC_ADDR14_BRNTAKEN;      break;
1269
    case BFD_RELOC_PPC_B26:             ppc_reloc = R_PPC_REL24;                break;
1270
    case BFD_RELOC_PPC_B16:             ppc_reloc = R_PPC_REL14;                break;
1271
    case BFD_RELOC_PPC_B16_BRTAKEN:     ppc_reloc = R_PPC_REL14_BRTAKEN;        break;
1272
    case BFD_RELOC_PPC_B16_BRNTAKEN:    ppc_reloc = R_PPC_REL14_BRNTAKEN;       break;
1273
    case BFD_RELOC_16_GOTOFF:           ppc_reloc = R_PPC_GOT16;                break;
1274
    case BFD_RELOC_LO16_GOTOFF:         ppc_reloc = R_PPC_GOT16_LO;             break;
1275
    case BFD_RELOC_HI16_GOTOFF:         ppc_reloc = R_PPC_GOT16_HI;             break;
1276
    case BFD_RELOC_HI16_S_GOTOFF:       ppc_reloc = R_PPC_GOT16_HA;             break;
1277
    case BFD_RELOC_24_PLT_PCREL:        ppc_reloc = R_PPC_PLTREL24;             break;
1278
    case BFD_RELOC_PPC_COPY:            ppc_reloc = R_PPC_COPY;                 break;
1279
    case BFD_RELOC_PPC_GLOB_DAT:        ppc_reloc = R_PPC_GLOB_DAT;             break;
1280
    case BFD_RELOC_PPC_LOCAL24PC:       ppc_reloc = R_PPC_LOCAL24PC;            break;
1281
    case BFD_RELOC_32_PCREL:            ppc_reloc = R_PPC_REL32;                break;
1282
    case BFD_RELOC_32_PLTOFF:           ppc_reloc = R_PPC_PLT32;                break;
1283
    case BFD_RELOC_32_PLT_PCREL:        ppc_reloc = R_PPC_PLTREL32;             break;
1284
    case BFD_RELOC_LO16_PLTOFF:         ppc_reloc = R_PPC_PLT16_LO;             break;
1285
    case BFD_RELOC_HI16_PLTOFF:         ppc_reloc = R_PPC_PLT16_HI;             break;
1286
    case BFD_RELOC_HI16_S_PLTOFF:       ppc_reloc = R_PPC_PLT16_HA;             break;
1287
    case BFD_RELOC_GPREL16:             ppc_reloc = R_PPC_SDAREL16;             break;
1288
    case BFD_RELOC_32_BASEREL:          ppc_reloc = R_PPC_SECTOFF;              break;
1289
    case BFD_RELOC_LO16_BASEREL:        ppc_reloc = R_PPC_SECTOFF_LO;           break;
1290
    case BFD_RELOC_HI16_BASEREL:        ppc_reloc = R_PPC_SECTOFF_HI;           break;
1291
    case BFD_RELOC_HI16_S_BASEREL:      ppc_reloc = R_PPC_SECTOFF_HA;           break;
1292
    case BFD_RELOC_CTOR:                ppc_reloc = R_PPC_ADDR32;               break;
1293
    case BFD_RELOC_PPC_TOC16:           ppc_reloc = R_PPC_TOC16;                break;
1294
    case BFD_RELOC_PPC_EMB_NADDR32:     ppc_reloc = R_PPC_EMB_NADDR32;          break;
1295
    case BFD_RELOC_PPC_EMB_NADDR16:     ppc_reloc = R_PPC_EMB_NADDR16;          break;
1296
    case BFD_RELOC_PPC_EMB_NADDR16_LO:  ppc_reloc = R_PPC_EMB_NADDR16_LO;       break;
1297
    case BFD_RELOC_PPC_EMB_NADDR16_HI:  ppc_reloc = R_PPC_EMB_NADDR16_HI;       break;
1298
    case BFD_RELOC_PPC_EMB_NADDR16_HA:  ppc_reloc = R_PPC_EMB_NADDR16_HA;       break;
1299
    case BFD_RELOC_PPC_EMB_SDAI16:      ppc_reloc = R_PPC_EMB_SDAI16;           break;
1300
    case BFD_RELOC_PPC_EMB_SDA2I16:     ppc_reloc = R_PPC_EMB_SDA2I16;          break;
1301
    case BFD_RELOC_PPC_EMB_SDA2REL:     ppc_reloc = R_PPC_EMB_SDA2REL;          break;
1302
    case BFD_RELOC_PPC_EMB_SDA21:       ppc_reloc = R_PPC_EMB_SDA21;            break;
1303
    case BFD_RELOC_PPC_EMB_MRKREF:      ppc_reloc = R_PPC_EMB_MRKREF;           break;
1304
    case BFD_RELOC_PPC_EMB_RELSEC16:    ppc_reloc = R_PPC_EMB_RELSEC16;         break;
1305
    case BFD_RELOC_PPC_EMB_RELST_LO:    ppc_reloc = R_PPC_EMB_RELST_LO;         break;
1306
    case BFD_RELOC_PPC_EMB_RELST_HI:    ppc_reloc = R_PPC_EMB_RELST_HI;         break;
1307
    case BFD_RELOC_PPC_EMB_RELST_HA:    ppc_reloc = R_PPC_EMB_RELST_HA;         break;
1308
    case BFD_RELOC_PPC_EMB_BIT_FLD:     ppc_reloc = R_PPC_EMB_BIT_FLD;          break;
1309
    case BFD_RELOC_PPC_EMB_RELSDA:      ppc_reloc = R_PPC_EMB_RELSDA;           break;
1310
    case BFD_RELOC_VTABLE_INHERIT:      ppc_reloc = R_PPC_GNU_VTINHERIT;        break;
1311
    case BFD_RELOC_VTABLE_ENTRY:        ppc_reloc = R_PPC_GNU_VTENTRY;          break;
1312
    }
1313
 
1314
  return ppc_elf_howto_table[(int) ppc_reloc];
1315
};
1316
 
1317
/* Set the howto pointer for a PowerPC ELF reloc.  */
1318
 
1319
static void
1320
ppc_elf_info_to_howto (abfd, cache_ptr, dst)
1321
     bfd *abfd ATTRIBUTE_UNUSED;
1322
     arelent *cache_ptr;
1323
     Elf32_Internal_Rela *dst;
1324
{
1325
  if (!ppc_elf_howto_table[R_PPC_ADDR32])
1326
    /* Initialize howto table if needed.  */
1327
    ppc_elf_howto_init ();
1328
 
1329
  BFD_ASSERT (ELF32_R_TYPE (dst->r_info) < (unsigned int) R_PPC_max);
1330
  cache_ptr->howto = ppc_elf_howto_table[ELF32_R_TYPE (dst->r_info)];
1331
}
1332
 
1333
/* Handle the R_PPC_ADDR16_HA reloc.  */
1334
 
1335
static bfd_reloc_status_type
1336
ppc_elf_addr16_ha_reloc (abfd, reloc_entry, symbol, data, input_section,
1337
                         output_bfd, error_message)
1338
     bfd *abfd ATTRIBUTE_UNUSED;
1339
     arelent *reloc_entry;
1340
     asymbol *symbol;
1341
     PTR data ATTRIBUTE_UNUSED;
1342
     asection *input_section;
1343
     bfd *output_bfd;
1344
     char **error_message ATTRIBUTE_UNUSED;
1345
{
1346
  bfd_vma relocation;
1347
 
1348
  if (output_bfd != NULL)
1349
    {
1350
      reloc_entry->address += input_section->output_offset;
1351
      return bfd_reloc_ok;
1352
    }
1353
 
1354
  if (reloc_entry->address > input_section->_cooked_size)
1355
    return bfd_reloc_outofrange;
1356
 
1357
  if (bfd_is_com_section (symbol->section))
1358
    relocation = 0;
1359
  else
1360
    relocation = symbol->value;
1361
 
1362
  relocation += symbol->section->output_section->vma;
1363
  relocation += symbol->section->output_offset;
1364
  relocation += reloc_entry->addend;
1365
 
1366
  reloc_entry->addend += (relocation & 0x8000) << 1;
1367
 
1368
  return bfd_reloc_continue;
1369
}
1370
 
1371
/* Function to set whether a module needs the -mrelocatable bit set.  */
1372
 
1373
static boolean
1374
ppc_elf_set_private_flags (abfd, flags)
1375
     bfd *abfd;
1376
     flagword flags;
1377
{
1378
  BFD_ASSERT (!elf_flags_init (abfd)
1379
              || elf_elfheader (abfd)->e_flags == flags);
1380
 
1381
  elf_elfheader (abfd)->e_flags = flags;
1382
  elf_flags_init (abfd) = true;
1383
  return true;
1384
}
1385
 
1386
/* Copy backend specific data from one object module to another */
1387
static boolean
1388
ppc_elf_copy_private_bfd_data (ibfd, obfd)
1389
     bfd *ibfd;
1390
     bfd *obfd;
1391
{
1392
  if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
1393
      || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
1394
    return true;
1395
 
1396
  BFD_ASSERT (!elf_flags_init (obfd)
1397
              || elf_elfheader (obfd)->e_flags == elf_elfheader (ibfd)->e_flags);
1398
 
1399
  elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags;
1400
  elf_flags_init (obfd) = true;
1401
  return true;
1402
}
1403
 
1404
/* Merge backend specific data from an object file to the output
1405
   object file when linking */
1406
static boolean
1407
ppc_elf_merge_private_bfd_data (ibfd, obfd)
1408
     bfd *ibfd;
1409
     bfd *obfd;
1410
{
1411
  flagword old_flags;
1412
  flagword new_flags;
1413
  boolean error;
1414
 
1415
  /* Check if we have the same endianess */
1416
  if (_bfd_generic_verify_endian_match (ibfd, obfd) == false)
1417
    return false;
1418
 
1419
  if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
1420
      || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
1421
    return true;
1422
 
1423
  new_flags = elf_elfheader (ibfd)->e_flags;
1424
  old_flags = elf_elfheader (obfd)->e_flags;
1425
  if (!elf_flags_init (obfd))   /* First call, no flags set */
1426
    {
1427
      elf_flags_init (obfd) = true;
1428
      elf_elfheader (obfd)->e_flags = new_flags;
1429
    }
1430
 
1431
  else if (new_flags == old_flags)      /* Compatible flags are ok */
1432
    ;
1433
 
1434
  else                                  /* Incompatible flags */
1435
    {
1436
      /* Warn about -mrelocatable mismatch.  Allow -mrelocatable-lib to be linked
1437
         with either.  */
1438
      error = false;
1439
      if ((new_flags & EF_PPC_RELOCATABLE) != 0
1440
          && (old_flags & (EF_PPC_RELOCATABLE | EF_PPC_RELOCATABLE_LIB)) == 0)
1441
        {
1442
          error = true;
1443
          (*_bfd_error_handler)
1444
            (_("%s: compiled with -mrelocatable and linked with modules compiled normally"),
1445
             bfd_get_filename (ibfd));
1446
        }
1447
      else if ((new_flags & (EF_PPC_RELOCATABLE | EF_PPC_RELOCATABLE_LIB)) == 0
1448
               && (old_flags & EF_PPC_RELOCATABLE) != 0)
1449
        {
1450
          error = true;
1451
          (*_bfd_error_handler)
1452
            (_("%s: compiled normally and linked with modules compiled with -mrelocatable"),
1453
             bfd_get_filename (ibfd));
1454
        }
1455
 
1456
      /* The output is -mrelocatable-lib iff both the input files are.  */
1457
      if (! (new_flags & EF_PPC_RELOCATABLE_LIB))
1458
        elf_elfheader (obfd)->e_flags &= ~EF_PPC_RELOCATABLE_LIB;
1459
 
1460
      /* The output is -mrelocatable iff it can't be -mrelocatable-lib,
1461
         but each input file is either -mrelocatable or -mrelocatable-lib.  */
1462
      if (! (elf_elfheader (obfd)->e_flags & EF_PPC_RELOCATABLE_LIB)
1463
          && (new_flags & (EF_PPC_RELOCATABLE_LIB | EF_PPC_RELOCATABLE))
1464
          && (old_flags & (EF_PPC_RELOCATABLE_LIB | EF_PPC_RELOCATABLE)))
1465
        elf_elfheader (obfd)->e_flags |= EF_PPC_RELOCATABLE;
1466
 
1467
      /* Do not warn about eabi vs. V.4 mismatch, just or in the bit if any module uses it */
1468
      elf_elfheader (obfd)->e_flags |= (new_flags & EF_PPC_EMB);
1469
 
1470
      new_flags &= ~ (EF_PPC_RELOCATABLE | EF_PPC_RELOCATABLE_LIB | EF_PPC_EMB);
1471
      old_flags &= ~ (EF_PPC_RELOCATABLE | EF_PPC_RELOCATABLE_LIB | EF_PPC_EMB);
1472
 
1473
      /* Warn about any other mismatches */
1474
      if (new_flags != old_flags)
1475
        {
1476
          error = true;
1477
          (*_bfd_error_handler)
1478
            (_("%s: uses different e_flags (0x%lx) fields than previous modules (0x%lx)"),
1479
             bfd_get_filename (ibfd), (long) new_flags, (long) old_flags);
1480
        }
1481
 
1482
      if (error)
1483
        {
1484
          bfd_set_error (bfd_error_bad_value);
1485
          return false;
1486
        }
1487
    }
1488
 
1489
  return true;
1490
}
1491
 
1492
/* Handle a PowerPC specific section when reading an object file.  This
1493
   is called when elfcode.h finds a section with an unknown type.  */
1494
 
1495
static boolean
1496
ppc_elf_section_from_shdr (abfd, hdr, name)
1497
     bfd *abfd;
1498
     Elf32_Internal_Shdr *hdr;
1499
     char *name;
1500
{
1501
  asection *newsect;
1502
  flagword flags;
1503
 
1504
  if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name))
1505
    return false;
1506
 
1507
  newsect = hdr->bfd_section;
1508
  flags = bfd_get_section_flags (abfd, newsect);
1509
  if (hdr->sh_flags & SHF_EXCLUDE)
1510
    flags |= SEC_EXCLUDE;
1511
 
1512
  if (hdr->sh_type == SHT_ORDERED)
1513
    flags |= SEC_SORT_ENTRIES;
1514
 
1515
  bfd_set_section_flags (abfd, newsect, flags);
1516
  return true;
1517
}
1518
 
1519
/* Set up any other section flags and such that may be necessary.  */
1520
 
1521
static boolean
1522
ppc_elf_fake_sections (abfd, shdr, asect)
1523
     bfd *abfd ATTRIBUTE_UNUSED;
1524
     Elf32_Internal_Shdr *shdr;
1525
     asection *asect;
1526
{
1527
  if ((asect->flags & SEC_EXCLUDE) != 0)
1528
    shdr->sh_flags |= SHF_EXCLUDE;
1529
 
1530
  if ((asect->flags & SEC_SORT_ENTRIES) != 0)
1531
    shdr->sh_type = SHT_ORDERED;
1532
 
1533
  return true;
1534
}
1535
 
1536
/* Create a special linker section */
1537
static elf_linker_section_t *
1538
ppc_elf_create_linker_section (abfd, info, which)
1539
     bfd *abfd;
1540
     struct bfd_link_info *info;
1541
     enum elf_linker_section_enum which;
1542
{
1543
  bfd *dynobj = elf_hash_table (info)->dynobj;
1544
  elf_linker_section_t *lsect;
1545
 
1546
  /* Record the first bfd section that needs the special section */
1547
  if (!dynobj)
1548
    dynobj = elf_hash_table (info)->dynobj = abfd;
1549
 
1550
  /* If this is the first time, create the section */
1551
  lsect = elf_linker_section (dynobj, which);
1552
  if (!lsect)
1553
    {
1554
      elf_linker_section_t defaults;
1555
      static elf_linker_section_t zero_section;
1556
 
1557
      defaults = zero_section;
1558
      defaults.which = which;
1559
      defaults.hole_written_p = false;
1560
      defaults.alignment = 2;
1561
 
1562
      /* Both of these sections are (technically) created by the user
1563
         putting data in them, so they shouldn't be marked
1564
         SEC_LINKER_CREATED.
1565
 
1566
         The linker creates them so it has somewhere to attach their
1567
         respective symbols. In fact, if they were empty it would
1568
         be OK to leave the symbol set to 0 (or any random number), because
1569
         the appropriate register should never be used.  */
1570
      defaults.flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS
1571
                        | SEC_IN_MEMORY);
1572
 
1573
      switch (which)
1574
        {
1575
        default:
1576
          (*_bfd_error_handler) (_("%s: Unknown special linker type %d"),
1577
                                 bfd_get_filename (abfd),
1578
                                 (int) which);
1579
 
1580
          bfd_set_error (bfd_error_bad_value);
1581
          return (elf_linker_section_t *) 0;
1582
 
1583
        case LINKER_SECTION_SDATA:      /* .sdata/.sbss section */
1584
          defaults.name           = ".sdata";
1585
          defaults.rel_name       = ".rela.sdata";
1586
          defaults.bss_name       = ".sbss";
1587
          defaults.sym_name       = "_SDA_BASE_";
1588
          defaults.sym_offset     = 32768;
1589
          break;
1590
 
1591
        case LINKER_SECTION_SDATA2:     /* .sdata2/.sbss2 section */
1592
          defaults.name           = ".sdata2";
1593
          defaults.rel_name       = ".rela.sdata2";
1594
          defaults.bss_name       = ".sbss2";
1595
          defaults.sym_name       = "_SDA2_BASE_";
1596
          defaults.sym_offset     = 32768;
1597
          defaults.flags         |= SEC_READONLY;
1598
          break;
1599
        }
1600
 
1601
      lsect = _bfd_elf_create_linker_section (abfd, info, which, &defaults);
1602
    }
1603
 
1604
  return lsect;
1605
}
1606
 
1607
/* If we have a non-zero sized .sbss2 or .PPC.EMB.sbss0 sections, we
1608
   need to bump up the number of section headers.  */
1609
 
1610
static int
1611
ppc_elf_additional_program_headers (abfd)
1612
     bfd *abfd;
1613
{
1614
  asection *s;
1615
  int ret;
1616
 
1617
  ret = 0;
1618
 
1619
  s = bfd_get_section_by_name (abfd, ".interp");
1620
  if (s != NULL)
1621
    ++ret;
1622
 
1623
  s = bfd_get_section_by_name (abfd, ".sbss2");
1624
  if (s != NULL && (s->flags & SEC_LOAD) != 0 && s->_raw_size > 0)
1625
    ++ret;
1626
 
1627
  s = bfd_get_section_by_name (abfd, ".PPC.EMB.sbss0");
1628
  if (s != NULL && (s->flags & SEC_LOAD) != 0 && s->_raw_size > 0)
1629
    ++ret;
1630
 
1631
  return ret;
1632
}
1633
 
1634
/* Modify the segment map if needed.  */
1635
 
1636
static boolean
1637
ppc_elf_modify_segment_map (abfd)
1638
     bfd *abfd ATTRIBUTE_UNUSED;
1639
{
1640
  return true;
1641
}
1642
 
1643
/* We have to create .dynsbss and .rela.sbss here so that they get mapped
1644
   to output sections (just like _bfd_elf_create_dynamic_sections has
1645
   to create .dynbss and .rela.bss).  */
1646
 
1647
static boolean
1648
ppc_elf_create_dynamic_sections (abfd, info)
1649
     bfd *abfd;
1650
     struct bfd_link_info *info;
1651
{
1652
  register asection *s;
1653
  flagword flags;
1654
 
1655
  if (!_bfd_elf_create_dynamic_sections (abfd, info))
1656
    return false;
1657
 
1658
  flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
1659
           | SEC_LINKER_CREATED);
1660
 
1661
  s = bfd_make_section (abfd, ".dynsbss");
1662
  if (s == NULL
1663
      || ! bfd_set_section_flags (abfd, s, SEC_ALLOC))
1664
    return false;
1665
 
1666
  if (! info->shared)
1667
    {
1668
      s = bfd_make_section (abfd, ".rela.sbss");
1669
      if (s == NULL
1670
          || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
1671
          || ! bfd_set_section_alignment (abfd, s, 2))
1672
        return false;
1673
    }
1674
  return true;
1675
}
1676
 
1677
/* Adjust a symbol defined by a dynamic object and referenced by a
1678
   regular object.  The current definition is in some section of the
1679
   dynamic object, but we're not including those sections.  We have to
1680
   change the definition to something the rest of the link can
1681
   understand.  */
1682
 
1683
static boolean
1684
ppc_elf_adjust_dynamic_symbol (info, h)
1685
     struct bfd_link_info *info;
1686
     struct elf_link_hash_entry *h;
1687
{
1688
  bfd *dynobj = elf_hash_table (info)->dynobj;
1689
  asection *s;
1690
  unsigned int power_of_two;
1691
  bfd_vma plt_offset;
1692
 
1693
#ifdef DEBUG
1694
  fprintf (stderr, "ppc_elf_adjust_dynamic_symbol called for %s\n", h->root.root.string);
1695
#endif
1696
 
1697
  /* Make sure we know what is going on here.  */
1698
  BFD_ASSERT (dynobj != NULL
1699
              && ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT)
1700
                  || h->weakdef != NULL
1701
                  || ((h->elf_link_hash_flags
1702
                       & ELF_LINK_HASH_DEF_DYNAMIC) != 0
1703
                      && (h->elf_link_hash_flags
1704
                          & ELF_LINK_HASH_REF_REGULAR) != 0
1705
                      && (h->elf_link_hash_flags
1706
                          & ELF_LINK_HASH_DEF_REGULAR) == 0)));
1707
 
1708
  /* If this is a function, put it in the procedure linkage table.  We
1709
     will fill in the contents of the procedure linkage table later,
1710
     when we know the address of the .got section.  */
1711
  if (h->type == STT_FUNC
1712
      || (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0)
1713
    {
1714
      if (! elf_hash_table (info)->dynamic_sections_created
1715
          || SYMBOL_CALLS_LOCAL (info, h)
1716
          || (info->shared && h->plt.refcount <= 0))
1717
        {
1718
          /* A PLT entry is not required/allowed when:
1719
 
1720
             1. We are not using ld.so; because then the PLT entry
1721
             can't be set up, so we can't use one.
1722
 
1723
             2. We know for certain that a call to this symbol
1724
             will go to this object.
1725
 
1726
             3. GC has rendered the entry unused.
1727
             Note, however, that in an executable all references to the
1728
             symbol go to the PLT, so we can't turn it off in that case.
1729
             ??? The correct thing to do here is to reference count
1730
             all uses of the symbol, not just those to the GOT or PLT.  */
1731
          h->plt.offset = (bfd_vma) -1;
1732
          h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
1733
          return true;
1734
        }
1735
 
1736
      /* Make sure this symbol is output as a dynamic symbol.  */
1737
      if (h->dynindx == -1)
1738
        {
1739
          if (! bfd_elf32_link_record_dynamic_symbol (info, h))
1740
            return false;
1741
        }
1742
      BFD_ASSERT (h->dynindx != -1);
1743
 
1744
      s = bfd_get_section_by_name (dynobj, ".plt");
1745
      BFD_ASSERT (s != NULL);
1746
 
1747
      /* If this is the first .plt entry, make room for the special
1748
         first entry.  */
1749
      if (s->_raw_size == 0)
1750
        s->_raw_size += PLT_INITIAL_ENTRY_SIZE;
1751
 
1752
      /* The PowerPC PLT is actually composed of two parts, the first part
1753
         is 2 words (for a load and a jump), and then there is a remaining
1754
         word available at the end.  */
1755
      plt_offset = (PLT_INITIAL_ENTRY_SIZE
1756
                    + (PLT_SLOT_SIZE
1757
                       * ((s->_raw_size - PLT_INITIAL_ENTRY_SIZE)
1758
                          / PLT_ENTRY_SIZE)));
1759
 
1760
      /* If this symbol is not defined in a regular file, and we are
1761
         not generating a shared library, then set the symbol to this
1762
         location in the .plt.  This is required to make function
1763
         pointers compare as equal between the normal executable and
1764
         the shared library.  */
1765
      if (! info->shared
1766
          && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
1767
        {
1768
          h->root.u.def.section = s;
1769
          h->root.u.def.value = plt_offset;
1770
        }
1771
 
1772
      h->plt.offset = plt_offset;
1773
 
1774
      /* Make room for this entry.  After the 8192nd entry, room
1775
         for two entries is allocated.  */
1776
      if ((s->_raw_size - PLT_INITIAL_ENTRY_SIZE) / PLT_ENTRY_SIZE
1777
          >= PLT_NUM_SINGLE_ENTRIES)
1778
        s->_raw_size += 2 * PLT_ENTRY_SIZE;
1779
      else
1780
        s->_raw_size += PLT_ENTRY_SIZE;
1781
 
1782
      /* We also need to make an entry in the .rela.plt section.  */
1783
      s = bfd_get_section_by_name (dynobj, ".rela.plt");
1784
      BFD_ASSERT (s != NULL);
1785
      s->_raw_size += sizeof (Elf32_External_Rela);
1786
 
1787
      return true;
1788
    }
1789
 
1790
  /* If this is a weak symbol, and there is a real definition, the
1791
     processor independent code will have arranged for us to see the
1792
     real definition first, and we can just use the same value.  */
1793
  if (h->weakdef != NULL)
1794
    {
1795
      BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
1796
                  || h->weakdef->root.type == bfd_link_hash_defweak);
1797
      h->root.u.def.section = h->weakdef->root.u.def.section;
1798
      h->root.u.def.value = h->weakdef->root.u.def.value;
1799
      return true;
1800
    }
1801
 
1802
  /* This is a reference to a symbol defined by a dynamic object which
1803
     is not a function.  */
1804
 
1805
  /* If we are creating a shared library, we must presume that the
1806
     only references to the symbol are via the global offset table.
1807
     For such cases we need not do anything here; the relocations will
1808
     be handled correctly by relocate_section.  */
1809
  if (info->shared)
1810
    return true;
1811
 
1812
  /* We must allocate the symbol in our .dynbss section, which will
1813
     become part of the .bss section of the executable.  There will be
1814
     an entry for this symbol in the .dynsym section.  The dynamic
1815
     object will contain position independent code, so all references
1816
     from the dynamic object to this symbol will go through the global
1817
     offset table.  The dynamic linker will use the .dynsym entry to
1818
     determine the address it must put in the global offset table, so
1819
     both the dynamic object and the regular object will refer to the
1820
     same memory location for the variable.
1821
 
1822
     Of course, if the symbol is sufficiently small, we must instead
1823
     allocate it in .sbss.  FIXME: It would be better to do this if and
1824
     only if there were actually SDAREL relocs for that symbol.  */
1825
 
1826
  if (h->size <= elf_gp_size (dynobj))
1827
    s = bfd_get_section_by_name (dynobj, ".dynsbss");
1828
  else
1829
    s = bfd_get_section_by_name (dynobj, ".dynbss");
1830
  BFD_ASSERT (s != NULL);
1831
 
1832
  /* We must generate a R_PPC_COPY reloc to tell the dynamic linker to
1833
     copy the initial value out of the dynamic object and into the
1834
     runtime process image.  We need to remember the offset into the
1835
     .rela.bss section we are going to use.  */
1836
  if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
1837
    {
1838
      asection *srel;
1839
 
1840
      if (h->size <= elf_gp_size (dynobj))
1841
        srel = bfd_get_section_by_name (dynobj, ".rela.sbss");
1842
      else
1843
        srel = bfd_get_section_by_name (dynobj, ".rela.bss");
1844
      BFD_ASSERT (srel != NULL);
1845
      srel->_raw_size += sizeof (Elf32_External_Rela);
1846
      h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_COPY;
1847
    }
1848
 
1849
  /* We need to figure out the alignment required for this symbol.  I
1850
     have no idea how ELF linkers handle this.  */
1851
  power_of_two = bfd_log2 (h->size);
1852
  if (power_of_two > 4)
1853
    power_of_two = 4;
1854
 
1855
  /* Apply the required alignment.  */
1856
  s->_raw_size = BFD_ALIGN (s->_raw_size,
1857
                            (bfd_size_type) (1 << power_of_two));
1858
  if (power_of_two > bfd_get_section_alignment (dynobj, s))
1859
    {
1860
      if (! bfd_set_section_alignment (dynobj, s, power_of_two))
1861
        return false;
1862
    }
1863
 
1864
  /* Define the symbol as being at this point in the section.  */
1865
  h->root.u.def.section = s;
1866
  h->root.u.def.value = s->_raw_size;
1867
 
1868
  /* Increment the section size to make room for the symbol.  */
1869
  s->_raw_size += h->size;
1870
 
1871
  return true;
1872
}
1873
 
1874
/* Set the sizes of the dynamic sections.  */
1875
 
1876
static boolean
1877
ppc_elf_size_dynamic_sections (output_bfd, info)
1878
     bfd *output_bfd;
1879
     struct bfd_link_info *info;
1880
{
1881
  bfd *dynobj;
1882
  asection *s;
1883
  boolean plt;
1884
  boolean relocs;
1885
  boolean reltext;
1886
 
1887
#ifdef DEBUG
1888
  fprintf (stderr, "ppc_elf_size_dynamic_sections called\n");
1889
#endif
1890
 
1891
  dynobj = elf_hash_table (info)->dynobj;
1892
  BFD_ASSERT (dynobj != NULL);
1893
 
1894
  if (elf_hash_table (info)->dynamic_sections_created)
1895
    {
1896
      /* Set the contents of the .interp section to the interpreter.  */
1897
      if (! info->shared)
1898
        {
1899
          s = bfd_get_section_by_name (dynobj, ".interp");
1900
          BFD_ASSERT (s != NULL);
1901
          s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER;
1902
          s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
1903
        }
1904
    }
1905
  else
1906
    {
1907
      /* We may have created entries in the .rela.got, .rela.sdata, and
1908
         .rela.sdata2 sections.  However, if we are not creating the
1909
         dynamic sections, we will not actually use these entries.  Reset
1910
         the size of .rela.got, et al, which will cause it to get
1911
         stripped from the output file below.  */
1912
      static char *rela_sections[] = { ".rela.got", ".rela.sdata",
1913
                                       ".rela.sdata2", ".rela.sbss",
1914
                                       (char *) 0 };
1915
      char **p;
1916
 
1917
      for (p = rela_sections; *p != (char *) 0; p++)
1918
        {
1919
          s = bfd_get_section_by_name (dynobj, *p);
1920
          if (s != NULL)
1921
            s->_raw_size = 0;
1922
        }
1923
    }
1924
 
1925
  /* The check_relocs and adjust_dynamic_symbol entry points have
1926
     determined the sizes of the various dynamic sections.  Allocate
1927
     memory for them.  */
1928
  plt = false;
1929
  relocs = false;
1930
  reltext = false;
1931
  for (s = dynobj->sections; s != NULL; s = s->next)
1932
    {
1933
      const char *name;
1934
      boolean strip;
1935
 
1936
      if ((s->flags & SEC_LINKER_CREATED) == 0)
1937
        continue;
1938
 
1939
      /* It's OK to base decisions on the section name, because none
1940
         of the dynobj section names depend upon the input files.  */
1941
      name = bfd_get_section_name (dynobj, s);
1942
 
1943
      strip = false;
1944
 
1945
      if (strcmp (name, ".plt") == 0)
1946
        {
1947
          if (s->_raw_size == 0)
1948
            {
1949
              /* Strip this section if we don't need it; see the
1950
                 comment below.  */
1951
              strip = true;
1952
            }
1953
          else
1954
            {
1955
              /* Remember whether there is a PLT.  */
1956
              plt = true;
1957
            }
1958
        }
1959
      else if (strncmp (name, ".rela", 5) == 0)
1960
        {
1961
          if (s->_raw_size == 0)
1962
            {
1963
              /* If we don't need this section, strip it from the
1964
                 output file.  This is mostly to handle .rela.bss and
1965
                 .rela.plt.  We must create both sections in
1966
                 create_dynamic_sections, because they must be created
1967
                 before the linker maps input sections to output
1968
                 sections.  The linker does that before
1969
                 adjust_dynamic_symbol is called, and it is that
1970
                 function which decides whether anything needs to go
1971
                 into these sections.  */
1972
              strip = true;
1973
            }
1974
          else
1975
            {
1976
              asection *target;
1977
              const char *outname;
1978
 
1979
              /* Remember whether there are any relocation sections.  */
1980
              relocs = true;
1981
 
1982
              /* If this relocation section applies to a read only
1983
                 section, then we probably need a DT_TEXTREL entry.  */
1984
              outname = bfd_get_section_name (output_bfd,
1985
                                              s->output_section);
1986
              target = bfd_get_section_by_name (output_bfd, outname + 5);
1987
              if (target != NULL
1988
                  && (target->flags & SEC_READONLY) != 0
1989
                  && (target->flags & SEC_ALLOC) != 0)
1990
                reltext = true;
1991
 
1992
              /* We use the reloc_count field as a counter if we need
1993
                 to copy relocs into the output file.  */
1994
              s->reloc_count = 0;
1995
            }
1996
        }
1997
      else if (strcmp (name, ".got") != 0
1998
               && strcmp (name, ".sdata") != 0
1999
               && strcmp (name, ".sdata2") != 0)
2000
        {
2001
          /* It's not one of our sections, so don't allocate space.  */
2002
          continue;
2003
        }
2004
 
2005
      if (strip)
2006
        {
2007
          _bfd_strip_section_from_output (info, s);
2008
          continue;
2009
        }
2010
 
2011
      /* Allocate memory for the section contents.  */
2012
      s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->_raw_size);
2013
      if (s->contents == NULL && s->_raw_size != 0)
2014
        return false;
2015
    }
2016
 
2017
  if (elf_hash_table (info)->dynamic_sections_created)
2018
    {
2019
      /* Add some entries to the .dynamic section.  We fill in the
2020
         values later, in ppc_elf_finish_dynamic_sections, but we
2021
         must add the entries now so that we get the correct size for
2022
         the .dynamic section.  The DT_DEBUG entry is filled in by the
2023
         dynamic linker and used by the debugger.  */
2024
      if (! info->shared)
2025
        {
2026
          if (! bfd_elf32_add_dynamic_entry (info, DT_DEBUG, 0))
2027
            return false;
2028
        }
2029
 
2030
      if (plt)
2031
        {
2032
          if (! bfd_elf32_add_dynamic_entry (info, DT_PLTGOT, 0)
2033
              || ! bfd_elf32_add_dynamic_entry (info, DT_PLTRELSZ, 0)
2034
              || ! bfd_elf32_add_dynamic_entry (info, DT_PLTREL, DT_RELA)
2035
              || ! bfd_elf32_add_dynamic_entry (info, DT_JMPREL, 0))
2036
            return false;
2037
        }
2038
 
2039
      if (relocs)
2040
        {
2041
          if (! bfd_elf32_add_dynamic_entry (info, DT_RELA, 0)
2042
              || ! bfd_elf32_add_dynamic_entry (info, DT_RELASZ, 0)
2043
              || ! bfd_elf32_add_dynamic_entry (info, DT_RELAENT,
2044
                                                sizeof (Elf32_External_Rela)))
2045
            return false;
2046
        }
2047
 
2048
      if (reltext)
2049
        {
2050
          if (! bfd_elf32_add_dynamic_entry (info, DT_TEXTREL, 0))
2051
            return false;
2052
          info->flags |= DF_TEXTREL;
2053
        }
2054
    }
2055
 
2056
  return true;
2057
}
2058
 
2059
/* Look through the relocs for a section during the first phase, and
2060
   allocate space in the global offset table or procedure linkage
2061
   table.  */
2062
 
2063
static boolean
2064
ppc_elf_check_relocs (abfd, info, sec, relocs)
2065
     bfd *abfd;
2066
     struct bfd_link_info *info;
2067
     asection *sec;
2068
     const Elf_Internal_Rela *relocs;
2069
{
2070
  bfd *dynobj;
2071
  Elf_Internal_Shdr *symtab_hdr;
2072
  struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
2073
  const Elf_Internal_Rela *rel;
2074
  const Elf_Internal_Rela *rel_end;
2075
  bfd_signed_vma *local_got_refcounts;
2076
  elf_linker_section_t *sdata;
2077
  elf_linker_section_t *sdata2;
2078
  asection *sreloc;
2079
  asection *sgot = NULL;
2080
  asection *srelgot = NULL;
2081
 
2082
  if (info->relocateable)
2083
    return true;
2084
 
2085
#ifdef DEBUG
2086
  fprintf (stderr, "ppc_elf_check_relocs called for section %s in %s\n",
2087
           bfd_get_section_name (abfd, sec),
2088
           bfd_get_filename (abfd));
2089
#endif
2090
 
2091
  /* Create the linker generated sections all the time so that the
2092
     special symbols are created.  */
2093
 
2094
  if ((sdata = elf_linker_section (abfd, LINKER_SECTION_SDATA)) == NULL)
2095
    {
2096
      sdata = ppc_elf_create_linker_section (abfd, info, LINKER_SECTION_SDATA);
2097
      if (!sdata)
2098
        return false;
2099
    }
2100
 
2101
  if ((sdata2 = elf_linker_section (abfd, LINKER_SECTION_SDATA2)) == NULL)
2102
    {
2103
      sdata2 = ppc_elf_create_linker_section (abfd, info, LINKER_SECTION_SDATA2);
2104
      if (!sdata2)
2105
        return false;
2106
    }
2107
 
2108
  dynobj = elf_hash_table (info)->dynobj;
2109
  symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2110
  local_got_refcounts = elf_local_got_refcounts (abfd);
2111
 
2112
  sym_hashes = elf_sym_hashes (abfd);
2113
  sym_hashes_end = sym_hashes + symtab_hdr->sh_size/sizeof (Elf32_External_Sym);
2114
  if (!elf_bad_symtab (abfd))
2115
    sym_hashes_end -= symtab_hdr->sh_info;
2116
 
2117
  sreloc = NULL;
2118
 
2119
  rel_end = relocs + sec->reloc_count;
2120
  for (rel = relocs; rel < rel_end; rel++)
2121
    {
2122
      unsigned long r_symndx;
2123
      struct elf_link_hash_entry *h;
2124
 
2125
      r_symndx = ELF32_R_SYM (rel->r_info);
2126
      if (r_symndx < symtab_hdr->sh_info)
2127
        h = NULL;
2128
      else
2129
        h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2130
 
2131
      /* If a relocation refers to _GLOBAL_OFFSET_TABLE_, create the .got.
2132
         This shows up in particular in an R_PPC_ADDR32 in the eabi
2133
         startup code.  */
2134
      if (h && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
2135
        {
2136
          if (sgot == NULL)
2137
            {
2138
              if (dynobj == NULL)
2139
                elf_hash_table (info)->dynobj = dynobj = abfd;
2140
              if (! _bfd_elf_create_got_section (dynobj, info))
2141
                return false;
2142
              sgot = bfd_get_section_by_name (dynobj, ".got");
2143
              BFD_ASSERT (sgot != NULL);
2144
            }
2145
        }
2146
 
2147
      switch (ELF32_R_TYPE (rel->r_info))
2148
        {
2149
        /* GOT16 relocations */
2150
        case R_PPC_GOT16:
2151
        case R_PPC_GOT16_LO:
2152
        case R_PPC_GOT16_HI:
2153
        case R_PPC_GOT16_HA:
2154
          /* This symbol requires a global offset table entry.  */
2155
 
2156
          if (sgot == NULL)
2157
            {
2158
              if (dynobj == NULL)
2159
                elf_hash_table (info)->dynobj = dynobj = abfd;
2160
              if (! _bfd_elf_create_got_section (dynobj, info))
2161
                return false;
2162
              sgot = bfd_get_section_by_name (dynobj, ".got");
2163
              BFD_ASSERT (sgot != NULL);
2164
            }
2165
 
2166
          if (srelgot == NULL
2167
              && (h != NULL || info->shared))
2168
            {
2169
              srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
2170
              if (srelgot == NULL)
2171
                {
2172
                  srelgot = bfd_make_section (dynobj, ".rela.got");
2173
                  if (srelgot == NULL
2174
                      || ! bfd_set_section_flags (dynobj, srelgot,
2175
                                                  (SEC_ALLOC
2176
                                                   | SEC_LOAD
2177
                                                   | SEC_HAS_CONTENTS
2178
                                                   | SEC_IN_MEMORY
2179
                                                   | SEC_LINKER_CREATED
2180
                                                   | SEC_READONLY))
2181
                      || ! bfd_set_section_alignment (dynobj, srelgot, 2))
2182
                    return false;
2183
                }
2184
            }
2185
 
2186
          if (h != NULL)
2187
            {
2188
              if (h->got.refcount == -1)
2189
                {
2190
                  /* Make sure this symbol is output as a dynamic symbol.  */
2191
                  if (h->dynindx == -1)
2192
                    if (!bfd_elf32_link_record_dynamic_symbol (info, h))
2193
                      return false;
2194
 
2195
                  /* Allocate space in the .got.  */
2196
                  sgot->_raw_size += 4;
2197
                  /* Allocate relocation space.  */
2198
                  srelgot->_raw_size += sizeof (Elf32_External_Rela);
2199
 
2200
                  h->got.refcount = 1;
2201
                }
2202
              else
2203
                h->got.refcount++;
2204
            }
2205
          else
2206
            {
2207
              /* This is a global offset table entry for a local symbol.  */
2208
              if (local_got_refcounts == NULL)
2209
                {
2210
                  size_t size;
2211
 
2212
                  size = symtab_hdr->sh_info * sizeof (bfd_signed_vma);
2213
                  local_got_refcounts = (bfd_signed_vma *)
2214
                    bfd_alloc (abfd, size);
2215
                  if (local_got_refcounts == NULL)
2216
                    return false;
2217
                  elf_local_got_refcounts (abfd) = local_got_refcounts;
2218
                  memset (local_got_refcounts, -1, size);
2219
                }
2220
              if (local_got_refcounts[r_symndx] == -1)
2221
                {
2222
                  sgot->_raw_size += 4;
2223
 
2224
                  /* If we are generating a shared object, we need to
2225
                     output a R_PPC_RELATIVE reloc so that the
2226
                     dynamic linker can adjust this GOT entry.  */
2227
                  if (info->shared)
2228
                    srelgot->_raw_size += sizeof (Elf32_External_Rela);
2229
 
2230
                  local_got_refcounts[r_symndx] = 1;
2231
                }
2232
              else
2233
                local_got_refcounts[r_symndx]++;
2234
            }
2235
          break;
2236
 
2237
        /* Indirect .sdata relocation */
2238
        case R_PPC_EMB_SDAI16:
2239
          if (info->shared)
2240
            {
2241
              ((*_bfd_error_handler)
2242
               (_("%s: relocation %s cannot be used when making a shared object"),
2243
                bfd_get_filename (abfd), "R_PPC_EMB_SDAI16"));
2244
              return false;
2245
            }
2246
 
2247
          if (srelgot == NULL && (h != NULL || info->shared))
2248
            {
2249
              srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
2250
              if (srelgot == NULL)
2251
                {
2252
                  srelgot = bfd_make_section (dynobj, ".rela.got");
2253
                  if (srelgot == NULL
2254
                      || ! bfd_set_section_flags (dynobj, srelgot,
2255
                                                  (SEC_ALLOC
2256
                                                   | SEC_LOAD
2257
                                                   | SEC_HAS_CONTENTS
2258
                                                   | SEC_IN_MEMORY
2259
                                                   | SEC_LINKER_CREATED
2260
                                                   | SEC_READONLY))
2261
                      || ! bfd_set_section_alignment (dynobj, srelgot, 2))
2262
                    return false;
2263
                }
2264
            }
2265
 
2266
          if (!bfd_elf32_create_pointer_linker_section (abfd, info, sdata, h, rel))
2267
            return false;
2268
 
2269
          break;
2270
 
2271
        /* Indirect .sdata2 relocation */
2272
        case R_PPC_EMB_SDA2I16:
2273
          if (info->shared)
2274
            {
2275
              ((*_bfd_error_handler)
2276
               (_("%s: relocation %s cannot be used when making a shared object"),
2277
                bfd_get_filename (abfd), "R_PPC_EMB_SDA2I16"));
2278
              return false;
2279
            }
2280
 
2281
          if (srelgot == NULL && (h != NULL || info->shared))
2282
            {
2283
              srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
2284
              if (srelgot == NULL)
2285
                {
2286
                  srelgot = bfd_make_section (dynobj, ".rela.got");
2287
                  if (srelgot == NULL
2288
                      || ! bfd_set_section_flags (dynobj, srelgot,
2289
                                                  (SEC_ALLOC
2290
                                                   | SEC_LOAD
2291
                                                   | SEC_HAS_CONTENTS
2292
                                                   | SEC_IN_MEMORY
2293
                                                   | SEC_LINKER_CREATED
2294
                                                   | SEC_READONLY))
2295
                      || ! bfd_set_section_alignment (dynobj, srelgot, 2))
2296
                    return false;
2297
                }
2298
            }
2299
 
2300
          if (!bfd_elf32_create_pointer_linker_section (abfd, info, sdata2, h, rel))
2301
            return false;
2302
 
2303
          break;
2304
 
2305
        case R_PPC_SDAREL16:
2306
        case R_PPC_EMB_SDA2REL:
2307
        case R_PPC_EMB_SDA21:
2308
          if (info->shared)
2309
            {
2310
              ((*_bfd_error_handler)
2311
               (_("%s: relocation %s cannot be used when making a shared object"),
2312
                bfd_get_filename (abfd),
2313
                ppc_elf_howto_table[(int) ELF32_R_TYPE (rel->r_info)]->name));
2314
              return false;
2315
            }
2316
          break;
2317
 
2318
        case R_PPC_PLT32:
2319
        case R_PPC_PLTREL24:
2320
        case R_PPC_PLT16_LO:
2321
        case R_PPC_PLT16_HI:
2322
        case R_PPC_PLT16_HA:
2323
#ifdef DEBUG
2324
          fprintf (stderr, "Reloc requires a PLT entry\n");
2325
#endif
2326
          /* This symbol requires a procedure linkage table entry.  We
2327
             actually build the entry in adjust_dynamic_symbol,
2328
             because this might be a case of linking PIC code without
2329
             linking in any dynamic objects, in which case we don't
2330
             need to generate a procedure linkage table after all.  */
2331
 
2332
          if (h == NULL)
2333
            {
2334
              /* It does not make sense to have a procedure linkage
2335
                 table entry for a local symbol.  */
2336
              bfd_set_error (bfd_error_bad_value);
2337
              return false;
2338
            }
2339
 
2340
          /* Make sure this symbol is output as a dynamic symbol.  */
2341
          if (h->dynindx == -1)
2342
            {
2343
              if (! bfd_elf32_link_record_dynamic_symbol (info, h))
2344
                return false;
2345
            }
2346
          if (h->plt.refcount == -1)
2347
            {
2348
              h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
2349
              h->plt.refcount = 1;
2350
            }
2351
          else
2352
            h->plt.refcount++;
2353
          break;
2354
 
2355
          /* The following relocations don't need to propagate the
2356
             relocation if linking a shared object since they are
2357
             section relative.  */
2358
        case R_PPC_SECTOFF:
2359
        case R_PPC_SECTOFF_LO:
2360
        case R_PPC_SECTOFF_HI:
2361
        case R_PPC_SECTOFF_HA:
2362
          break;
2363
 
2364
          /* This refers only to functions defined in the shared library */
2365
        case R_PPC_LOCAL24PC:
2366
          break;
2367
 
2368
          /* This relocation describes the C++ object vtable hierarchy.
2369
             Reconstruct it for later use during GC.  */
2370
        case R_PPC_GNU_VTINHERIT:
2371
          if (!_bfd_elf32_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
2372
            return false;
2373
          break;
2374
 
2375
          /* This relocation describes which C++ vtable entries are actually
2376
             used.  Record for later use during GC.  */
2377
        case R_PPC_GNU_VTENTRY:
2378
          if (!_bfd_elf32_gc_record_vtentry (abfd, sec, h, rel->r_addend))
2379
            return false;
2380
          break;
2381
 
2382
          /* When creating a shared object, we must copy these
2383
             relocs into the output file.  We create a reloc
2384
             section in dynobj and make room for the reloc.  */
2385
        case R_PPC_REL24:
2386
        case R_PPC_REL14:
2387
        case R_PPC_REL14_BRTAKEN:
2388
        case R_PPC_REL14_BRNTAKEN:
2389
        case R_PPC_REL32:
2390
          if (h == NULL
2391
              || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0
2392
              || SYMBOL_REFERENCES_LOCAL (info, h))
2393
            break;
2394
          /* fall through */
2395
 
2396
        default:
2397
          if (info->shared)
2398
            {
2399
#ifdef DEBUG
2400
              fprintf (stderr, "ppc_elf_check_relocs need to create relocation for %s\n",
2401
                       (h && h->root.root.string) ? h->root.root.string : "<unknown>");
2402
#endif
2403
              if (sreloc == NULL)
2404
                {
2405
                  const char *name;
2406
 
2407
                  name = (bfd_elf_string_from_elf_section
2408
                          (abfd,
2409
                           elf_elfheader (abfd)->e_shstrndx,
2410
                           elf_section_data (sec)->rel_hdr.sh_name));
2411
                  if (name == NULL)
2412
                    return false;
2413
 
2414
                  BFD_ASSERT (strncmp (name, ".rela", 5) == 0
2415
                              && strcmp (bfd_get_section_name (abfd, sec),
2416
                                         name + 5) == 0);
2417
 
2418
                  sreloc = bfd_get_section_by_name (dynobj, name);
2419
                  if (sreloc == NULL)
2420
                    {
2421
                      flagword flags;
2422
 
2423
                      sreloc = bfd_make_section (dynobj, name);
2424
                      flags = (SEC_HAS_CONTENTS | SEC_READONLY
2425
                               | SEC_IN_MEMORY | SEC_LINKER_CREATED);
2426
                      if ((sec->flags & SEC_ALLOC) != 0)
2427
                        flags |= SEC_ALLOC | SEC_LOAD;
2428
                      if (sreloc == NULL
2429
                          || ! bfd_set_section_flags (dynobj, sreloc, flags)
2430
                          || ! bfd_set_section_alignment (dynobj, sreloc, 2))
2431
                        return false;
2432
                    }
2433
                }
2434
 
2435
              sreloc->_raw_size += sizeof (Elf32_External_Rela);
2436
 
2437
              /* FIXME: We should here do what the m68k and i386
2438
                 backends do: if the reloc is pc-relative, record it
2439
                 in case it turns out that the reloc is unnecessary
2440
                 because the symbol is forced local by versioning or
2441
                 we are linking with -Bdynamic.  Fortunately this
2442
                 case is not frequent.  */
2443
            }
2444
 
2445
          break;
2446
        }
2447
    }
2448
 
2449
  return true;
2450
}
2451
 
2452
/* Return the section that should be marked against GC for a given
2453
   relocation.  */
2454
 
2455
static asection *
2456
ppc_elf_gc_mark_hook (abfd, info, rel, h, sym)
2457
     bfd *abfd;
2458
     struct bfd_link_info *info ATTRIBUTE_UNUSED;
2459
     Elf_Internal_Rela *rel;
2460
     struct elf_link_hash_entry *h;
2461
     Elf_Internal_Sym *sym;
2462
{
2463
  if (h != NULL)
2464
    {
2465
      switch (ELF32_R_TYPE (rel->r_info))
2466
        {
2467
        case R_PPC_GNU_VTINHERIT:
2468
        case R_PPC_GNU_VTENTRY:
2469
          break;
2470
 
2471
        default:
2472
          switch (h->root.type)
2473
            {
2474
            case bfd_link_hash_defined:
2475
            case bfd_link_hash_defweak:
2476
              return h->root.u.def.section;
2477
 
2478
            case bfd_link_hash_common:
2479
              return h->root.u.c.p->section;
2480
 
2481
            default:
2482
              break;
2483
            }
2484
        }
2485
    }
2486
  else
2487
    {
2488
      if (!(elf_bad_symtab (abfd)
2489
            && ELF_ST_BIND (sym->st_info) != STB_LOCAL)
2490
          && ! ((sym->st_shndx <= 0 || sym->st_shndx >= SHN_LORESERVE)
2491
                && sym->st_shndx != SHN_COMMON))
2492
        {
2493
          return bfd_section_from_elf_index (abfd, sym->st_shndx);
2494
        }
2495
    }
2496
 
2497
  return NULL;
2498
}
2499
 
2500
/* Update the got entry reference counts for the section being removed.  */
2501
 
2502
static boolean
2503
ppc_elf_gc_sweep_hook (abfd, info, sec, relocs)
2504
     bfd *abfd;
2505
     struct bfd_link_info *info ATTRIBUTE_UNUSED;
2506
     asection *sec;
2507
     const Elf_Internal_Rela *relocs;
2508
{
2509
  Elf_Internal_Shdr *symtab_hdr;
2510
  struct elf_link_hash_entry **sym_hashes;
2511
  bfd_signed_vma *local_got_refcounts;
2512
  const Elf_Internal_Rela *rel, *relend;
2513
  unsigned long r_symndx;
2514
  struct elf_link_hash_entry *h;
2515
 
2516
  symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2517
  sym_hashes = elf_sym_hashes (abfd);
2518
  local_got_refcounts = elf_local_got_refcounts (abfd);
2519
 
2520
  relend = relocs + sec->reloc_count;
2521
  for (rel = relocs; rel < relend; rel++)
2522
    switch (ELF32_R_TYPE (rel->r_info))
2523
      {
2524
      case R_PPC_GOT16:
2525
      case R_PPC_GOT16_LO:
2526
      case R_PPC_GOT16_HI:
2527
      case R_PPC_GOT16_HA:
2528
        r_symndx = ELF32_R_SYM (rel->r_info);
2529
        if (r_symndx >= symtab_hdr->sh_info)
2530
          {
2531
            h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2532
            if (h->got.refcount > 0)
2533
              h->got.refcount--;
2534
          }
2535
        else if (local_got_refcounts != NULL)
2536
          {
2537
            if (local_got_refcounts[r_symndx] > 0)
2538
              local_got_refcounts[r_symndx]--;
2539
          }
2540
        break;
2541
 
2542
      case R_PPC_PLT32:
2543
      case R_PPC_PLTREL24:
2544
      case R_PPC_PLT16_LO:
2545
      case R_PPC_PLT16_HI:
2546
      case R_PPC_PLT16_HA:
2547
        r_symndx = ELF32_R_SYM (rel->r_info);
2548
        if (r_symndx >= symtab_hdr->sh_info)
2549
          {
2550
            h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2551
            if (h->plt.refcount > 0)
2552
              h->plt.refcount--;
2553
          }
2554
        break;
2555
 
2556
      default:
2557
        break;
2558
      }
2559
 
2560
  return true;
2561
}
2562
 
2563
/* Hook called by the linker routine which adds symbols from an object
2564
   file.  We use it to put .comm items in .sbss, and not .bss.  */
2565
 
2566
static boolean
2567
ppc_elf_add_symbol_hook (abfd, info, sym, namep, flagsp, secp, valp)
2568
     bfd *abfd;
2569
     struct bfd_link_info *info;
2570
     const Elf_Internal_Sym *sym;
2571
     const char **namep ATTRIBUTE_UNUSED;
2572
     flagword *flagsp ATTRIBUTE_UNUSED;
2573
     asection **secp;
2574
     bfd_vma *valp;
2575
{
2576
  if (sym->st_shndx == SHN_COMMON
2577
      && !info->relocateable
2578
      && sym->st_size <= (bfd_vma) bfd_get_gp_size (abfd))
2579
    {
2580
      /* Common symbols less than or equal to -G nn bytes are automatically
2581
         put into .sdata.  */
2582
      elf_linker_section_t *sdata
2583
        = ppc_elf_create_linker_section (abfd, info, LINKER_SECTION_SDATA);
2584
 
2585
      if (!sdata->bss_section)
2586
        {
2587
          /* We don't go through bfd_make_section, because we don't
2588
             want to attach this common section to DYNOBJ.  The linker
2589
             will move the symbols to the appropriate output section
2590
             when it defines common symbols.  */
2591
          sdata->bss_section = ((asection *)
2592
                                bfd_zalloc (abfd, sizeof (asection)));
2593
          if (sdata->bss_section == NULL)
2594
            return false;
2595
          sdata->bss_section->name = sdata->bss_name;
2596
          sdata->bss_section->flags = SEC_IS_COMMON;
2597
          sdata->bss_section->output_section = sdata->bss_section;
2598
          sdata->bss_section->symbol =
2599
            (asymbol *) bfd_zalloc (abfd, sizeof (asymbol));
2600
          sdata->bss_section->symbol_ptr_ptr =
2601
            (asymbol **) bfd_zalloc (abfd, sizeof (asymbol *));
2602
          if (sdata->bss_section->symbol == NULL
2603
              || sdata->bss_section->symbol_ptr_ptr == NULL)
2604
            return false;
2605
          sdata->bss_section->symbol->name = sdata->bss_name;
2606
          sdata->bss_section->symbol->flags = BSF_SECTION_SYM;
2607
          sdata->bss_section->symbol->section = sdata->bss_section;
2608
          *sdata->bss_section->symbol_ptr_ptr = sdata->bss_section->symbol;
2609
        }
2610
 
2611
      *secp = sdata->bss_section;
2612
      *valp = sym->st_size;
2613
    }
2614
 
2615
  return true;
2616
}
2617
 
2618
/* Finish up dynamic symbol handling.  We set the contents of various
2619
   dynamic sections here.  */
2620
 
2621
static boolean
2622
ppc_elf_finish_dynamic_symbol (output_bfd, info, h, sym)
2623
     bfd *output_bfd;
2624
     struct bfd_link_info *info;
2625
     struct elf_link_hash_entry *h;
2626
     Elf_Internal_Sym *sym;
2627
{
2628
  bfd *dynobj;
2629
 
2630
#ifdef DEBUG
2631
  fprintf (stderr, "ppc_elf_finish_dynamic_symbol called for %s",
2632
           h->root.root.string);
2633
#endif
2634
 
2635
  dynobj = elf_hash_table (info)->dynobj;
2636
  BFD_ASSERT (dynobj != NULL);
2637
 
2638
  if (h->plt.offset != (bfd_vma) -1)
2639
    {
2640
      asection *splt;
2641
      asection *srela;
2642
      Elf_Internal_Rela rela;
2643
      bfd_vma reloc_index;
2644
 
2645
#ifdef DEBUG
2646
      fprintf (stderr, ", plt_offset = %d", h->plt.offset);
2647
#endif
2648
 
2649
      /* This symbol has an entry in the procedure linkage table.  Set
2650
         it up.  */
2651
 
2652
      BFD_ASSERT (h->dynindx != -1);
2653
 
2654
      splt = bfd_get_section_by_name (dynobj, ".plt");
2655
      srela = bfd_get_section_by_name (dynobj, ".rela.plt");
2656
      BFD_ASSERT (splt != NULL && srela != NULL);
2657
 
2658
      /* We don't need to fill in the .plt.  The ppc dynamic linker
2659
         will fill it in.  */
2660
 
2661
      /* Fill in the entry in the .rela.plt section.  */
2662
      rela.r_offset = (splt->output_section->vma
2663
                       + splt->output_offset
2664
                       + h->plt.offset);
2665
      rela.r_info = ELF32_R_INFO (h->dynindx, R_PPC_JMP_SLOT);
2666
      rela.r_addend = 0;
2667
 
2668
      reloc_index = (h->plt.offset - PLT_INITIAL_ENTRY_SIZE) / PLT_SLOT_SIZE;
2669
      if (reloc_index > PLT_NUM_SINGLE_ENTRIES)
2670
        reloc_index -= (reloc_index - PLT_NUM_SINGLE_ENTRIES) / 2;
2671
      bfd_elf32_swap_reloca_out (output_bfd, &rela,
2672
                                 ((Elf32_External_Rela *) srela->contents
2673
                                  + reloc_index));
2674
 
2675
      if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
2676
        {
2677
          /* Mark the symbol as undefined, rather than as defined in
2678
             the .plt section.  Leave the value alone.  */
2679
          sym->st_shndx = SHN_UNDEF;
2680
          /* If the symbol is weak, we do need to clear the value.
2681
             Otherwise, the PLT entry would provide a definition for
2682
             the symbol even if the symbol wasn't defined anywhere,
2683
             and so the symbol would never be NULL.  */
2684
          if ((h->elf_link_hash_flags & ELF_LINK_HASH_REF_REGULAR_NONWEAK)
2685
              == 0)
2686
            sym->st_value = 0;
2687
        }
2688
    }
2689
 
2690
  if (h->got.offset != (bfd_vma) -1)
2691
    {
2692
      asection *sgot;
2693
      asection *srela;
2694
      Elf_Internal_Rela rela;
2695
 
2696
      /* This symbol has an entry in the global offset table.  Set it
2697
         up.  */
2698
 
2699
      sgot = bfd_get_section_by_name (dynobj, ".got");
2700
      srela = bfd_get_section_by_name (dynobj, ".rela.got");
2701
      BFD_ASSERT (sgot != NULL && srela != NULL);
2702
 
2703
      rela.r_offset = (sgot->output_section->vma
2704
                       + sgot->output_offset
2705
                       + (h->got.offset &~ 1));
2706
 
2707
      /* If this is a -Bsymbolic link, and the symbol is defined
2708
         locally, we just want to emit a RELATIVE reloc.  The entry in
2709
         the global offset table will already have been initialized in
2710
         the relocate_section function.  */
2711
      if (info->shared
2712
          && SYMBOL_REFERENCES_LOCAL (info, h))
2713
        {
2714
          rela.r_info = ELF32_R_INFO (0, R_PPC_RELATIVE);
2715
          rela.r_addend = (h->root.u.def.value
2716
                           + h->root.u.def.section->output_section->vma
2717
                           + h->root.u.def.section->output_offset);
2718
        }
2719
      else
2720
        {
2721
          BFD_ASSERT ((h->got.offset & 1) == 0);
2722
          bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset);
2723
          rela.r_info = ELF32_R_INFO (h->dynindx, R_PPC_GLOB_DAT);
2724
          rela.r_addend = 0;
2725
        }
2726
 
2727
      bfd_elf32_swap_reloca_out (output_bfd, &rela,
2728
                                 ((Elf32_External_Rela *) srela->contents
2729
                                  + srela->reloc_count));
2730
      ++srela->reloc_count;
2731
    }
2732
 
2733
  if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0)
2734
    {
2735
      asection *s;
2736
      Elf_Internal_Rela rela;
2737
 
2738
      /* This symbols needs a copy reloc.  Set it up.  */
2739
 
2740
#ifdef DEBUG
2741
      fprintf (stderr, ", copy");
2742
#endif
2743
 
2744
      BFD_ASSERT (h->dynindx != -1);
2745
 
2746
      if (h->size <= elf_gp_size (dynobj))
2747
        s = bfd_get_section_by_name (h->root.u.def.section->owner,
2748
                                     ".rela.sbss");
2749
      else
2750
        s = bfd_get_section_by_name (h->root.u.def.section->owner,
2751
                                     ".rela.bss");
2752
      BFD_ASSERT (s != NULL);
2753
 
2754
      rela.r_offset = (h->root.u.def.value
2755
                       + h->root.u.def.section->output_section->vma
2756
                       + h->root.u.def.section->output_offset);
2757
      rela.r_info = ELF32_R_INFO (h->dynindx, R_PPC_COPY);
2758
      rela.r_addend = 0;
2759
      bfd_elf32_swap_reloca_out (output_bfd, &rela,
2760
                                 ((Elf32_External_Rela *) s->contents
2761
                                  + s->reloc_count));
2762
      ++s->reloc_count;
2763
    }
2764
 
2765
#ifdef DEBUG
2766
  fprintf (stderr, "\n");
2767
#endif
2768
 
2769
  /* Mark some specially defined symbols as absolute.  */
2770
  if (strcmp (h->root.root.string, "_DYNAMIC") == 0
2771
      || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0
2772
      || strcmp (h->root.root.string, "_PROCEDURE_LINKAGE_TABLE_") == 0)
2773
    sym->st_shndx = SHN_ABS;
2774
 
2775
  return true;
2776
}
2777
 
2778
/* Finish up the dynamic sections.  */
2779
 
2780
static boolean
2781
ppc_elf_finish_dynamic_sections (output_bfd, info)
2782
     bfd *output_bfd;
2783
     struct bfd_link_info *info;
2784
{
2785
  asection *sdyn;
2786
  bfd *dynobj = elf_hash_table (info)->dynobj;
2787
  asection *sgot = bfd_get_section_by_name (dynobj, ".got");
2788
 
2789
#ifdef DEBUG
2790
  fprintf (stderr, "ppc_elf_finish_dynamic_sections called\n");
2791
#endif
2792
 
2793
  sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
2794
 
2795
  if (elf_hash_table (info)->dynamic_sections_created)
2796
    {
2797
      asection *splt;
2798
      Elf32_External_Dyn *dyncon, *dynconend;
2799
 
2800
      splt = bfd_get_section_by_name (dynobj, ".plt");
2801
      BFD_ASSERT (splt != NULL && sdyn != NULL);
2802
 
2803
      dyncon = (Elf32_External_Dyn *) sdyn->contents;
2804
      dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
2805
      for (; dyncon < dynconend; dyncon++)
2806
        {
2807
          Elf_Internal_Dyn dyn;
2808
          const char *name;
2809
          boolean size;
2810
 
2811
          bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
2812
 
2813
          switch (dyn.d_tag)
2814
            {
2815
            case DT_PLTGOT:   name = ".plt";      size = false; break;
2816
            case DT_PLTRELSZ: name = ".rela.plt"; size = true;  break;
2817
            case DT_JMPREL:   name = ".rela.plt"; size = false; break;
2818
            default:          name = NULL;        size = false; break;
2819
            }
2820
 
2821
          if (name != NULL)
2822
            {
2823
              asection *s;
2824
 
2825
              s = bfd_get_section_by_name (output_bfd, name);
2826
              if (s == NULL)
2827
                dyn.d_un.d_val = 0;
2828
              else
2829
                {
2830
                  if (! size)
2831
                    dyn.d_un.d_ptr = s->vma;
2832
                  else
2833
                    {
2834
                      if (s->_cooked_size != 0)
2835
                        dyn.d_un.d_val = s->_cooked_size;
2836
                      else
2837
                        dyn.d_un.d_val = s->_raw_size;
2838
                    }
2839
                }
2840
              bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
2841
            }
2842
        }
2843
    }
2844
 
2845
  /* Add a blrl instruction at _GLOBAL_OFFSET_TABLE_-4 so that a function can
2846
     easily find the address of the _GLOBAL_OFFSET_TABLE_.  */
2847
  if (sgot)
2848
    {
2849
      unsigned char *contents = sgot->contents;
2850
      bfd_put_32 (output_bfd, 0x4e800021 /* blrl */, contents);
2851
 
2852
      if (sdyn == NULL)
2853
        bfd_put_32 (output_bfd, (bfd_vma) 0, contents+4);
2854
      else
2855
        bfd_put_32 (output_bfd,
2856
                    sdyn->output_section->vma + sdyn->output_offset,
2857
                    contents+4);
2858
 
2859
      elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
2860
    }
2861
 
2862
  return true;
2863
}
2864
 
2865
/* The RELOCATE_SECTION function is called by the ELF backend linker
2866
   to handle the relocations for a section.
2867
 
2868
   The relocs are always passed as Rela structures; if the section
2869
   actually uses Rel structures, the r_addend field will always be
2870
   zero.
2871
 
2872
   This function is responsible for adjust the section contents as
2873
   necessary, and (if using Rela relocs and generating a
2874
   relocateable output file) adjusting the reloc addend as
2875
   necessary.
2876
 
2877
   This function does not have to worry about setting the reloc
2878
   address or the reloc symbol index.
2879
 
2880
   LOCAL_SYMS is a pointer to the swapped in local symbols.
2881
 
2882
   LOCAL_SECTIONS is an array giving the section in the input file
2883
   corresponding to the st_shndx field of each local symbol.
2884
 
2885
   The global hash table entry for the global symbols can be found
2886
   via elf_sym_hashes (input_bfd).
2887
 
2888
   When generating relocateable output, this function must handle
2889
   STB_LOCAL/STT_SECTION symbols specially.  The output symbol is
2890
   going to be the section symbol corresponding to the output
2891
   section, which means that the addend must be adjusted
2892
   accordingly.  */
2893
 
2894
static boolean
2895
ppc_elf_relocate_section (output_bfd, info, input_bfd, input_section,
2896
                          contents, relocs, local_syms, local_sections)
2897
     bfd *output_bfd;
2898
     struct bfd_link_info *info;
2899
     bfd *input_bfd;
2900
     asection *input_section;
2901
     bfd_byte *contents;
2902
     Elf_Internal_Rela *relocs;
2903
     Elf_Internal_Sym *local_syms;
2904
     asection **local_sections;
2905
{
2906
  Elf_Internal_Shdr *symtab_hdr           = &elf_tdata (input_bfd)->symtab_hdr;
2907
  struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (input_bfd);
2908
  bfd *dynobj                             = elf_hash_table (info)->dynobj;
2909
  elf_linker_section_t *sdata             = (dynobj) ? elf_linker_section (dynobj, LINKER_SECTION_SDATA)  : NULL;
2910
  elf_linker_section_t *sdata2            = (dynobj) ? elf_linker_section (dynobj, LINKER_SECTION_SDATA2) : NULL;
2911
  Elf_Internal_Rela *rel                  = relocs;
2912
  Elf_Internal_Rela *relend               = relocs + input_section->reloc_count;
2913
  asection *sreloc                        = NULL;
2914
  asection *splt;
2915
  asection *sgot;
2916
  bfd_vma *local_got_offsets;
2917
  boolean ret                             = true;
2918
  long insn;
2919
 
2920
#ifdef DEBUG
2921
  fprintf (stderr, "ppc_elf_relocate_section called for %s section %s, %ld relocations%s\n",
2922
           bfd_get_filename (input_bfd),
2923
           bfd_section_name(input_bfd, input_section),
2924
           (long) input_section->reloc_count,
2925
           (info->relocateable) ? " (relocatable)" : "");
2926
#endif
2927
 
2928
  if (!ppc_elf_howto_table[R_PPC_ADDR32])
2929
    /* Initialize howto table if needed.  */
2930
    ppc_elf_howto_init ();
2931
 
2932
  local_got_offsets = elf_local_got_offsets (input_bfd);
2933
 
2934
  splt = sgot = NULL;
2935
  if (dynobj != NULL)
2936
    {
2937
      splt = bfd_get_section_by_name (dynobj, ".plt");
2938
      sgot = bfd_get_section_by_name (dynobj, ".got");
2939
    }
2940
 
2941
  for (; rel < relend; rel++)
2942
    {
2943
      enum elf_ppc_reloc_type r_type    = (enum elf_ppc_reloc_type)ELF32_R_TYPE (rel->r_info);
2944
      bfd_vma offset                    = rel->r_offset;
2945
      bfd_vma addend                    = rel->r_addend;
2946
      bfd_reloc_status_type r           = bfd_reloc_other;
2947
      Elf_Internal_Sym *sym             = (Elf_Internal_Sym *) 0;
2948
      asection *sec                     = (asection *) 0;
2949
      struct elf_link_hash_entry *h     = (struct elf_link_hash_entry *) 0;
2950
      const char *sym_name              = (const char *) 0;
2951
      reloc_howto_type *howto;
2952
      unsigned long r_symndx;
2953
      bfd_vma relocation;
2954
      int will_become_local;
2955
 
2956
      /* Unknown relocation handling */
2957
      if ((unsigned) r_type >= (unsigned) R_PPC_max
2958
          || !ppc_elf_howto_table[(int) r_type])
2959
        {
2960
          (*_bfd_error_handler) (_("%s: unknown relocation type %d"),
2961
                                 bfd_get_filename (input_bfd),
2962
                                 (int) r_type);
2963
 
2964
          bfd_set_error (bfd_error_bad_value);
2965
          ret = false;
2966
          continue;
2967
        }
2968
 
2969
      howto = ppc_elf_howto_table[(int) r_type];
2970
      r_symndx = ELF32_R_SYM (rel->r_info);
2971
 
2972
      if (info->relocateable)
2973
        {
2974
          /* This is a relocateable link.  We don't have to change
2975
             anything, unless the reloc is against a section symbol,
2976
             in which case we have to adjust according to where the
2977
             section symbol winds up in the output section.  */
2978
          if (r_symndx < symtab_hdr->sh_info)
2979
            {
2980
              sym = local_syms + r_symndx;
2981
              if ((unsigned) ELF_ST_TYPE (sym->st_info) == STT_SECTION)
2982
                {
2983
                  sec = local_sections[r_symndx];
2984
                  addend = rel->r_addend += sec->output_offset + sym->st_value;
2985
                }
2986
            }
2987
 
2988
#ifdef DEBUG
2989
          fprintf (stderr, "\ttype = %s (%d), symbol index = %ld, offset = %ld, addend = %ld\n",
2990
                   howto->name,
2991
                   (int) r_type,
2992
                   r_symndx,
2993
                   (long) offset,
2994
                   (long) addend);
2995
#endif
2996
          continue;
2997
        }
2998
 
2999
      /* This is a final link.  */
3000
      if (r_symndx < symtab_hdr->sh_info)
3001
        {
3002
          sym = local_syms + r_symndx;
3003
          sec = local_sections[r_symndx];
3004
          sym_name = "<local symbol>";
3005
 
3006
          relocation = (sec->output_section->vma
3007
                        + sec->output_offset
3008
                        + sym->st_value);
3009
          /* Relocs to local symbols are always resolved.  */
3010
          will_become_local = 1;
3011
        }
3012
      else
3013
        {
3014
          h = sym_hashes[r_symndx - symtab_hdr->sh_info];
3015
          while (h->root.type == bfd_link_hash_indirect
3016
                 || h->root.type == bfd_link_hash_warning)
3017
            h = (struct elf_link_hash_entry *) h->root.u.i.link;
3018
          sym_name = h->root.root.string;
3019
 
3020
          /* Can this relocation be resolved immediately?  */
3021
          will_become_local = SYMBOL_REFERENCES_LOCAL (info, h);
3022
 
3023
          if (h->root.type == bfd_link_hash_defined
3024
              || h->root.type == bfd_link_hash_defweak)
3025
            {
3026
              sec = h->root.u.def.section;
3027
              if (((r_type == R_PPC_PLT32
3028
                    || r_type == R_PPC_PLTREL24)
3029
                   && splt != NULL
3030
                   && h->plt.offset != (bfd_vma) -1)
3031
                  || (r_type == R_PPC_LOCAL24PC
3032
                      && sec->output_section == NULL)
3033
                  || ((r_type == R_PPC_GOT16
3034
                       || r_type == R_PPC_GOT16_LO
3035
                       || r_type == R_PPC_GOT16_HI
3036
                       || r_type == R_PPC_GOT16_HA)
3037
                      && elf_hash_table (info)->dynamic_sections_created
3038
                      && (! info->shared || ! will_become_local))
3039
                  || (info->shared
3040
                      && ! will_become_local
3041
                      && ((input_section->flags & SEC_ALLOC) != 0
3042
                          /* Testing SEC_DEBUGGING here may be wrong.
3043
                             It's here to avoid a crash when
3044
                             generating a shared library with DWARF
3045
                             debugging information.  */
3046
                          || ((input_section->flags & SEC_DEBUGGING) != 0
3047
                              && (h->elf_link_hash_flags
3048
                                  & ELF_LINK_HASH_DEF_DYNAMIC) != 0))
3049
                      && (r_type == R_PPC_ADDR32
3050
                          || r_type == R_PPC_ADDR24
3051
                          || r_type == R_PPC_ADDR16
3052
                          || r_type == R_PPC_ADDR16_LO
3053
                          || r_type == R_PPC_ADDR16_HI
3054
                          || r_type == R_PPC_ADDR16_HA
3055
                          || r_type == R_PPC_ADDR14
3056
                          || r_type == R_PPC_ADDR14_BRTAKEN
3057
                          || r_type == R_PPC_ADDR14_BRNTAKEN
3058
                          || r_type == R_PPC_COPY
3059
                          || r_type == R_PPC_GLOB_DAT
3060
                          || r_type == R_PPC_JMP_SLOT
3061
                          || r_type == R_PPC_UADDR32
3062
                          || r_type == R_PPC_UADDR16
3063
                          || r_type == R_PPC_SDAREL16
3064
                          || r_type == R_PPC_EMB_NADDR32
3065
                          || r_type == R_PPC_EMB_NADDR16
3066
                          || r_type == R_PPC_EMB_NADDR16_LO
3067
                          || r_type == R_PPC_EMB_NADDR16_HI
3068
                          || r_type == R_PPC_EMB_NADDR16_HA
3069
                          || r_type == R_PPC_EMB_SDAI16
3070
                          || r_type == R_PPC_EMB_SDA2I16
3071
                          || r_type == R_PPC_EMB_SDA2REL
3072
                          || r_type == R_PPC_EMB_SDA21
3073
                          || r_type == R_PPC_EMB_MRKREF
3074
                          || r_type == R_PPC_EMB_BIT_FLD
3075
                          || r_type == R_PPC_EMB_RELSDA
3076
                          || ((r_type == R_PPC_REL24
3077
                               || r_type == R_PPC_REL32
3078
                               || r_type == R_PPC_REL14
3079
                               || r_type == R_PPC_REL14_BRTAKEN
3080
                               || r_type == R_PPC_REL14_BRNTAKEN
3081
                               || r_type == R_PPC_RELATIVE)
3082
                              && strcmp (h->root.root.string,
3083
                                         "_GLOBAL_OFFSET_TABLE_") != 0))))
3084
                {
3085
                  /* In these cases, we don't need the relocation
3086
                     value.  We check specially because in some
3087
                     obscure cases sec->output_section will be NULL.  */
3088
                  relocation = 0;
3089
                }
3090
              else if (sec->output_section == NULL)
3091
                {
3092
                  (*_bfd_error_handler)
3093
                    (_("%s: warning: unresolvable relocation against symbol `%s' from %s section"),
3094
                     bfd_get_filename (input_bfd), h->root.root.string,
3095
                     bfd_get_section_name (input_bfd, input_section));
3096
                  relocation = 0;
3097
                }
3098
              else
3099
                relocation = (h->root.u.def.value
3100
                              + sec->output_section->vma
3101
                              + sec->output_offset);
3102
            }
3103
          else if (h->root.type == bfd_link_hash_undefweak)
3104
            relocation = 0;
3105
          else if (info->shared && !info->symbolic && !info->no_undefined
3106
                   && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
3107
            relocation = 0;
3108
          else
3109
            {
3110
              if (! (*info->callbacks->undefined_symbol) (info,
3111
                                                         h->root.root.string,
3112
                                                         input_bfd,
3113
                                                         input_section,
3114
                                                         rel->r_offset,
3115
                                                         (!info->shared
3116
                                                          || info->no_undefined
3117
                                                          || ELF_ST_VISIBILITY (h->other))))
3118
                return false;
3119
              relocation = 0;
3120
            }
3121
        }
3122
 
3123
      switch ((int) r_type)
3124
        {
3125
        default:
3126
          (*_bfd_error_handler) (_("%s: unknown relocation type %d for symbol %s"),
3127
                                 bfd_get_filename (input_bfd),
3128
                                 (int) r_type, sym_name);
3129
 
3130
          bfd_set_error (bfd_error_bad_value);
3131
          ret = false;
3132
          continue;
3133
 
3134
        /* Relocations that need no special processing.  */
3135
        case (int) R_PPC_LOCAL24PC:
3136
          /* It makes no sense to point a local relocation
3137
             at a symbol not in this object.  */
3138
          if (h != NULL
3139
              && (h->root.type == bfd_link_hash_defined
3140
                  || h->root.type == bfd_link_hash_defweak)
3141
              && sec->output_section == NULL)
3142
            {
3143
              if (! (*info->callbacks->undefined_symbol) (info,
3144
                                                          h->root.root.string,
3145
                                                          input_bfd,
3146
                                                          input_section,
3147
                                                          rel->r_offset,
3148
                                                          true))
3149
                return false;
3150
              continue;
3151
            }
3152
          break;
3153
 
3154
        /* Relocations that may need to be propagated if this is a shared
3155
           object.  */
3156
        case (int) R_PPC_REL24:
3157
        case (int) R_PPC_REL32:
3158
        case (int) R_PPC_REL14:
3159
          /* If these relocations are not to a named symbol, they can be
3160
             handled right here, no need to bother the dynamic linker.  */
3161
          if (h == NULL
3162
              || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0
3163
              || SYMBOL_REFERENCES_LOCAL (info, h))
3164
            break;
3165
        /* fall through */
3166
 
3167
        /* Relocations that always need to be propagated if this is a shared
3168
           object.  */
3169
        case (int) R_PPC_NONE:
3170
        case (int) R_PPC_ADDR32:
3171
        case (int) R_PPC_ADDR24:
3172
        case (int) R_PPC_ADDR16:
3173
        case (int) R_PPC_ADDR16_LO:
3174
        case (int) R_PPC_ADDR16_HI:
3175
        case (int) R_PPC_ADDR16_HA:
3176
        case (int) R_PPC_ADDR14:
3177
        case (int) R_PPC_UADDR32:
3178
        case (int) R_PPC_UADDR16:
3179
          if (info->shared)
3180
            {
3181
              Elf_Internal_Rela outrel;
3182
              boolean skip;
3183
 
3184
#ifdef DEBUG
3185
              fprintf (stderr, "ppc_elf_relocate_section need to create relocation for %s\n",
3186
                       (h && h->root.root.string) ? h->root.root.string : "<unknown>");
3187
#endif
3188
 
3189
              /* When generating a shared object, these relocations
3190
                 are copied into the output file to be resolved at run
3191
                 time.  */
3192
 
3193
              if (sreloc == NULL)
3194
                {
3195
                  const char *name;
3196
 
3197
                  name = (bfd_elf_string_from_elf_section
3198
                          (input_bfd,
3199
                           elf_elfheader (input_bfd)->e_shstrndx,
3200
                           elf_section_data (input_section)->rel_hdr.sh_name));
3201
                  if (name == NULL)
3202
                    return false;
3203
 
3204
                  BFD_ASSERT (strncmp (name, ".rela", 5) == 0
3205
                              && strcmp (bfd_get_section_name (input_bfd,
3206
                                                               input_section),
3207
                                         name + 5) == 0);
3208
 
3209
                  sreloc = bfd_get_section_by_name (dynobj, name);
3210
                  BFD_ASSERT (sreloc != NULL);
3211
                }
3212
 
3213
              skip = false;
3214
 
3215
              if (elf_section_data (input_section)->stab_info == NULL)
3216
                outrel.r_offset = rel->r_offset;
3217
              else
3218
                {
3219
                  bfd_vma off;
3220
 
3221
                  off = (_bfd_stab_section_offset
3222
                         (output_bfd, &elf_hash_table (info)->stab_info,
3223
                          input_section,
3224
                          &elf_section_data (input_section)->stab_info,
3225
                          rel->r_offset));
3226
                  if (off == (bfd_vma) -1)
3227
                    skip = true;
3228
                  outrel.r_offset = off;
3229
                }
3230
 
3231
              outrel.r_offset += (input_section->output_section->vma
3232
                                  + input_section->output_offset);
3233
 
3234
              if (skip)
3235
                memset (&outrel, 0, sizeof outrel);
3236
              /* h->dynindx may be -1 if this symbol was marked to
3237
                 become local.  */
3238
              else if (! will_become_local)
3239
                {
3240
                  outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
3241
                  outrel.r_addend = rel->r_addend;
3242
                }
3243
              else
3244
                {
3245
                  if (r_type == R_PPC_ADDR32)
3246
                    {
3247
                      outrel.r_info = ELF32_R_INFO (0, R_PPC_RELATIVE);
3248
                      outrel.r_addend = relocation + rel->r_addend;
3249
                    }
3250
                  else
3251
                    {
3252
                      long indx;
3253
 
3254
                      if (h == NULL)
3255
                        sec = local_sections[r_symndx];
3256
                      else
3257
                        {
3258
                          BFD_ASSERT (h->root.type == bfd_link_hash_defined
3259
                                      || (h->root.type
3260
                                          == bfd_link_hash_defweak));
3261
                          sec = h->root.u.def.section;
3262
                        }
3263
                      if (sec != NULL && bfd_is_abs_section (sec))
3264
                        indx = 0;
3265
                      else if (sec == NULL || sec->owner == NULL)
3266
                        {
3267
                          bfd_set_error (bfd_error_bad_value);
3268
                          return false;
3269
                        }
3270
                      else
3271
                        {
3272
                          asection *osec;
3273
 
3274
                          osec = sec->output_section;
3275
                          indx = elf_section_data (osec)->dynindx;
3276
                          BFD_ASSERT (indx > 0);
3277
#ifdef DEBUG
3278
                          if (indx <= 0)
3279
                            {
3280
                              printf ("indx=%d section=%s flags=%08x name=%s\n",
3281
                                     indx, osec->name, osec->flags,
3282
                                     h->root.root.string);
3283
                            }
3284
#endif
3285
                        }
3286
 
3287
                      outrel.r_info = ELF32_R_INFO (indx, r_type);
3288
                      outrel.r_addend = relocation + rel->r_addend;
3289
                    }
3290
                }
3291
 
3292
              bfd_elf32_swap_reloca_out (output_bfd, &outrel,
3293
                                         (((Elf32_External_Rela *)
3294
                                           sreloc->contents)
3295
                                          + sreloc->reloc_count));
3296
              ++sreloc->reloc_count;
3297
 
3298
              /* This reloc will be computed at runtime, so there's no
3299
                 need to do anything now, unless this is a RELATIVE
3300
                 reloc in an unallocated section.  */
3301
              if (skip
3302
                  || (input_section->flags & SEC_ALLOC) != 0
3303
                  || ELF32_R_TYPE (outrel.r_info) != R_PPC_RELATIVE)
3304
                continue;
3305
            }
3306
 
3307
          /* Arithmetic adjust relocations that aren't going into a
3308
             shared object.  */
3309
          if (r_type == R_PPC_ADDR16_HA
3310
              /* It's just possible that this symbol is a weak symbol
3311
                 that's not actually defined anywhere. In that case,
3312
                 'sec' would be NULL, and we should leave the symbol
3313
                 alone (it will be set to zero elsewhere in the link).  */
3314
              && sec != NULL)
3315
            {
3316
              addend += ((relocation + addend) & 0x8000) << 1;
3317
            }
3318
          break;
3319
 
3320
        /* branch taken prediction relocations */
3321
        case (int) R_PPC_ADDR14_BRTAKEN:
3322
        case (int) R_PPC_REL14_BRTAKEN:
3323
          insn = bfd_get_32 (output_bfd, contents + offset);
3324
          if ((relocation - offset) & 0x8000)
3325
            insn &= ~BRANCH_PREDICT_BIT;
3326
          else
3327
            insn |= BRANCH_PREDICT_BIT;
3328
          bfd_put_32 (output_bfd, insn, contents + offset);
3329
          break;
3330
 
3331
        /* branch not taken predicition relocations */
3332
        case (int) R_PPC_ADDR14_BRNTAKEN:
3333
        case (int) R_PPC_REL14_BRNTAKEN:
3334
          insn = bfd_get_32 (output_bfd, contents + offset);
3335
          if ((relocation - offset) & 0x8000)
3336
            insn |= BRANCH_PREDICT_BIT;
3337
          else
3338
            insn &= ~BRANCH_PREDICT_BIT;
3339
          bfd_put_32 (output_bfd, insn, contents + offset);
3340
          break;
3341
 
3342
        /* GOT16 relocations */
3343
        case (int) R_PPC_GOT16:
3344
        case (int) R_PPC_GOT16_LO:
3345
        case (int) R_PPC_GOT16_HI:
3346
        case (int) R_PPC_GOT16_HA:
3347
          /* Relocation is to the entry for this symbol in the global
3348
             offset table.  */
3349
          BFD_ASSERT (sgot != NULL);
3350
 
3351
          if (h != NULL)
3352
            {
3353
              bfd_vma off;
3354
 
3355
              off = h->got.offset;
3356
              BFD_ASSERT (off != (bfd_vma) -1);
3357
 
3358
              if (! elf_hash_table (info)->dynamic_sections_created
3359
                  || (info->shared
3360
                      && SYMBOL_REFERENCES_LOCAL (info, h)))
3361
                {
3362
                  /* This is actually a static link, or it is a
3363
                     -Bsymbolic link and the symbol is defined
3364
                     locally.  We must initialize this entry in the
3365
                     global offset table.  Since the offset must
3366
                     always be a multiple of 4, we use the least
3367
                     significant bit to record whether we have
3368
                     initialized it already.
3369
 
3370
                     When doing a dynamic link, we create a .rela.got
3371
                     relocation entry to initialize the value.  This
3372
                     is done in the finish_dynamic_symbol routine.  */
3373
                  if ((off & 1) != 0)
3374
                    off &= ~1;
3375
                  else
3376
                    {
3377
                      bfd_put_32 (output_bfd, relocation,
3378
                                  sgot->contents + off);
3379
                      h->got.offset |= 1;
3380
                    }
3381
                }
3382
 
3383
              relocation = sgot->output_offset + off - 4;
3384
            }
3385
          else
3386
            {
3387
              bfd_vma off;
3388
 
3389
              BFD_ASSERT (local_got_offsets != NULL
3390
                          && local_got_offsets[r_symndx] != (bfd_vma) -1);
3391
 
3392
              off = local_got_offsets[r_symndx];
3393
 
3394
              /* The offset must always be a multiple of 4.  We use
3395
                 the least significant bit to record whether we have
3396
                 already processed this entry.  */
3397
              if ((off & 1) != 0)
3398
                off &= ~1;
3399
              else
3400
                {
3401
                  bfd_put_32 (output_bfd, relocation, sgot->contents + off);
3402
 
3403
                  if (info->shared)
3404
                    {
3405
                      asection *srelgot;
3406
                      Elf_Internal_Rela outrel;
3407
 
3408
                      /* We need to generate a R_PPC_RELATIVE reloc
3409
                         for the dynamic linker.  */
3410
                      srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
3411
                      BFD_ASSERT (srelgot != NULL);
3412
 
3413
                      outrel.r_offset = (sgot->output_section->vma
3414
                                         + sgot->output_offset
3415
                                         + off);
3416
                      outrel.r_info = ELF32_R_INFO (0, R_PPC_RELATIVE);
3417
                      outrel.r_addend = relocation;
3418
                      bfd_elf32_swap_reloca_out (output_bfd, &outrel,
3419
                                                 (((Elf32_External_Rela *)
3420
                                                   srelgot->contents)
3421
                                                  + srelgot->reloc_count));
3422
                      ++srelgot->reloc_count;
3423
                    }
3424
 
3425
                  local_got_offsets[r_symndx] |= 1;
3426
                }
3427
 
3428
              relocation = sgot->output_offset + off - 4;
3429
            }
3430
          break;
3431
 
3432
        /* Indirect .sdata relocation */
3433
        case (int) R_PPC_EMB_SDAI16:
3434
          BFD_ASSERT (sdata != NULL);
3435
          relocation = bfd_elf32_finish_pointer_linker_section (output_bfd, input_bfd, info,
3436
                                                                sdata, h, relocation, rel,
3437
                                                                R_PPC_RELATIVE);
3438
          break;
3439
 
3440
        /* Indirect .sdata2 relocation */
3441
        case (int) R_PPC_EMB_SDA2I16:
3442
          BFD_ASSERT (sdata2 != NULL);
3443
          relocation = bfd_elf32_finish_pointer_linker_section (output_bfd, input_bfd, info,
3444
                                                                sdata2, h, relocation, rel,
3445
                                                                R_PPC_RELATIVE);
3446
          break;
3447
 
3448
        /* Handle the TOC16 reloc.  We want to use the offset within the .got
3449
           section, not the actual VMA.  This is appropriate when generating
3450
           an embedded ELF object, for which the .got section acts like the
3451
           AIX .toc section.  */
3452
        case (int) R_PPC_TOC16:                 /* phony GOT16 relocations */
3453
          BFD_ASSERT (sec != (asection *) 0);
3454
          BFD_ASSERT (bfd_is_und_section (sec)
3455
                      || strcmp (bfd_get_section_name (abfd, sec), ".got") == 0
3456
                      || strcmp (bfd_get_section_name (abfd, sec), ".cgot") == 0)
3457
 
3458
          addend -= sec->output_section->vma + sec->output_offset + 0x8000;
3459
          break;
3460
 
3461
        case (int) R_PPC_PLTREL24:
3462
          /* Relocation is to the entry for this symbol in the
3463
             procedure linkage table.  */
3464
          BFD_ASSERT (h != NULL);
3465
 
3466
          if (h->plt.offset == (bfd_vma) -1
3467
              || splt == NULL)
3468
            {
3469
              /* We didn't make a PLT entry for this symbol.  This
3470
                 happens when statically linking PIC code, or when
3471
                 using -Bsymbolic.  */
3472
              break;
3473
            }
3474
 
3475
          relocation = (splt->output_section->vma
3476
                        + splt->output_offset
3477
                        + h->plt.offset);
3478
          break;
3479
 
3480
        /* relocate against _SDA_BASE_ */
3481
        case (int) R_PPC_SDAREL16:
3482
          {
3483
            const char *name;
3484
 
3485
            BFD_ASSERT (sec != (asection *) 0);
3486
            name = bfd_get_section_name (abfd, sec->output_section);
3487
            if (strcmp (name, ".sdata") != 0
3488
                && strcmp (name, ".sbss") != 0)
3489
              {
3490
                (*_bfd_error_handler) (_("%s: The target (%s) of a %s relocation is in the wrong output section (%s)"),
3491
                                       bfd_get_filename (input_bfd),
3492
                                       sym_name,
3493
                                       ppc_elf_howto_table[(int) r_type]->name,
3494
                                       name);
3495
              }
3496
            addend -= (sdata->sym_hash->root.u.def.value
3497
                       + sdata->sym_hash->root.u.def.section->output_section->vma
3498
                       + sdata->sym_hash->root.u.def.section->output_offset);
3499
          }
3500
          break;
3501
 
3502
        /* relocate against _SDA2_BASE_ */
3503
        case (int) R_PPC_EMB_SDA2REL:
3504
          {
3505
            const char *name;
3506
 
3507
            BFD_ASSERT (sec != (asection *) 0);
3508
            name = bfd_get_section_name (abfd, sec->output_section);
3509
            if (strcmp (name, ".sdata2") != 0 && strcmp (name, ".sbss2") != 0)
3510
              {
3511
                (*_bfd_error_handler) (_("%s: The target (%s) of a %s relocation is in the wrong output section (%s)"),
3512
                                       bfd_get_filename (input_bfd),
3513
                                       sym_name,
3514
                                       ppc_elf_howto_table[(int) r_type]->name,
3515
                                       name);
3516
 
3517
                bfd_set_error (bfd_error_bad_value);
3518
                ret = false;
3519
                continue;
3520
              }
3521
            addend -= (sdata2->sym_hash->root.u.def.value
3522
                       + sdata2->sym_hash->root.u.def.section->output_section->vma
3523
                       + sdata2->sym_hash->root.u.def.section->output_offset);
3524
          }
3525
          break;
3526
 
3527
        /* relocate against either _SDA_BASE_, _SDA2_BASE_, or 0 */
3528
        case (int) R_PPC_EMB_SDA21:
3529
        case (int) R_PPC_EMB_RELSDA:
3530
          {
3531
            const char *name;
3532
            int reg;
3533
 
3534
            BFD_ASSERT (sec != (asection *) 0);
3535
            name = bfd_get_section_name (abfd, sec->output_section);
3536
            if (strcmp (name, ".sdata") == 0 || strcmp (name, ".sbss") == 0)
3537
              {
3538
                reg = 13;
3539
                addend -= (sdata->sym_hash->root.u.def.value
3540
                           + sdata->sym_hash->root.u.def.section->output_section->vma
3541
                           + sdata->sym_hash->root.u.def.section->output_offset);
3542
              }
3543
 
3544
            else if (strcmp (name, ".sdata2") == 0
3545
                     || strcmp (name, ".sbss2") == 0)
3546
              {
3547
                reg = 2;
3548
                addend -= (sdata2->sym_hash->root.u.def.value
3549
                           + sdata2->sym_hash->root.u.def.section->output_section->vma
3550
                           + sdata2->sym_hash->root.u.def.section->output_offset);
3551
              }
3552
 
3553
            else if (strcmp (name, ".PPC.EMB.sdata0") == 0
3554
                     || strcmp (name, ".PPC.EMB.sbss0") == 0)
3555
              {
3556
                reg = 0;
3557
              }
3558
 
3559
            else
3560
              {
3561
                (*_bfd_error_handler) (_("%s: The target (%s) of a %s relocation is in the wrong output section (%s)"),
3562
                                       bfd_get_filename (input_bfd),
3563
                                       sym_name,
3564
                                       ppc_elf_howto_table[(int) r_type]->name,
3565
                                       name);
3566
 
3567
                bfd_set_error (bfd_error_bad_value);
3568
                ret = false;
3569
                continue;
3570
              }
3571
 
3572
            if (r_type == R_PPC_EMB_SDA21)
3573
              {                 /* fill in register field */
3574
                insn = bfd_get_32 (output_bfd, contents + offset);
3575
                insn = (insn & ~RA_REGISTER_MASK) | (reg << RA_REGISTER_SHIFT);
3576
                bfd_put_32 (output_bfd, insn, contents + offset);
3577
              }
3578
          }
3579
          break;
3580
 
3581
        /* Relocate against the beginning of the section */
3582
        case (int) R_PPC_SECTOFF:
3583
        case (int) R_PPC_SECTOFF_LO:
3584
        case (int) R_PPC_SECTOFF_HI:
3585
          BFD_ASSERT (sec != (asection *) 0);
3586
          addend -= sec->output_section->vma;
3587
          break;
3588
 
3589
        case (int) R_PPC_SECTOFF_HA:
3590
          BFD_ASSERT (sec != (asection *) 0);
3591
          addend -= sec->output_section->vma;
3592
          addend += ((relocation + addend) & 0x8000) << 1;
3593
          break;
3594
 
3595
        /* Negative relocations */
3596
        case (int) R_PPC_EMB_NADDR32:
3597
        case (int) R_PPC_EMB_NADDR16:
3598
        case (int) R_PPC_EMB_NADDR16_LO:
3599
        case (int) R_PPC_EMB_NADDR16_HI:
3600
          addend -= 2 * relocation;
3601
          break;
3602
 
3603
        case (int) R_PPC_EMB_NADDR16_HA:
3604
          addend -= 2 * relocation;
3605
          addend += ((relocation + addend) & 0x8000) << 1;
3606
          break;
3607
 
3608
        /* NOP relocation that prevents garbage collecting linkers from omitting a
3609
           reference.  */
3610
        case (int) R_PPC_EMB_MRKREF:
3611
          continue;
3612
 
3613
        case (int) R_PPC_COPY:
3614
        case (int) R_PPC_GLOB_DAT:
3615
        case (int) R_PPC_JMP_SLOT:
3616
        case (int) R_PPC_RELATIVE:
3617
        case (int) R_PPC_PLT32:
3618
        case (int) R_PPC_PLTREL32:
3619
        case (int) R_PPC_PLT16_LO:
3620
        case (int) R_PPC_PLT16_HI:
3621
        case (int) R_PPC_PLT16_HA:
3622
        case (int) R_PPC_EMB_RELSEC16:
3623
        case (int) R_PPC_EMB_RELST_LO:
3624
        case (int) R_PPC_EMB_RELST_HI:
3625
        case (int) R_PPC_EMB_RELST_HA:
3626
        case (int) R_PPC_EMB_BIT_FLD:
3627
          (*_bfd_error_handler) (_("%s: Relocation %s is not yet supported for symbol %s."),
3628
                                 bfd_get_filename (input_bfd),
3629
                                 ppc_elf_howto_table[(int) r_type]->name,
3630
                                 sym_name);
3631
 
3632
          bfd_set_error (bfd_error_invalid_operation);
3633
          ret = false;
3634
          continue;
3635
 
3636
        case (int) R_PPC_GNU_VTINHERIT:
3637
        case (int) R_PPC_GNU_VTENTRY:
3638
          /* These are no-ops in the end.  */
3639
          continue;
3640
        }
3641
 
3642
#ifdef DEBUG
3643
      fprintf (stderr, "\ttype = %s (%d), name = %s, symbol index = %ld, offset = %ld, addend = %ld\n",
3644
               howto->name,
3645
               (int) r_type,
3646
               sym_name,
3647
               r_symndx,
3648
               (long) offset,
3649
               (long) addend);
3650
#endif
3651
 
3652
      r = _bfd_final_link_relocate (howto,
3653
                                    input_bfd,
3654
                                    input_section,
3655
                                    contents,
3656
                                    offset,
3657
                                    relocation,
3658
                                    addend);
3659
 
3660
      if (r == bfd_reloc_ok)
3661
        ;
3662
      else if (r == bfd_reloc_overflow)
3663
        {
3664
          const char *name;
3665
 
3666
          if (h != NULL)
3667
            {
3668
              if (h->root.type == bfd_link_hash_undefweak
3669
                  && howto->pc_relative)
3670
                {
3671
                  /* Assume this is a call protected by other code that
3672
                     detect the symbol is undefined.  If this is the case,
3673
                     we can safely ignore the overflow.  If not, the
3674
                     program is hosed anyway, and a little warning isn't
3675
                     going to help.  */
3676
 
3677
                  continue;
3678
                }
3679
 
3680
              name = h->root.root.string;
3681
            }
3682
          else
3683
            {
3684
              name = bfd_elf_string_from_elf_section (input_bfd,
3685
                                                      symtab_hdr->sh_link,
3686
                                                      sym->st_name);
3687
              if (name == NULL)
3688
                continue;
3689
              if (*name == '\0')
3690
                name = bfd_section_name (input_bfd, sec);
3691
            }
3692
 
3693
          if (! (*info->callbacks->reloc_overflow) (info,
3694
                                                   name,
3695
                                                   howto->name,
3696
                                                   (bfd_vma) 0,
3697
                                                   input_bfd,
3698
                                                   input_section,
3699
                                                   offset))
3700
            return false;
3701
        }
3702
      else
3703
        ret = false;
3704
    }
3705
 
3706
#ifdef DEBUG
3707
  fprintf (stderr, "\n");
3708
#endif
3709
 
3710
  return ret;
3711
}
3712
 
3713
#define TARGET_LITTLE_SYM       bfd_elf32_powerpcle_vec
3714
#define TARGET_LITTLE_NAME      "elf32-powerpcle"
3715
#define TARGET_BIG_SYM          bfd_elf32_powerpc_vec
3716
#define TARGET_BIG_NAME         "elf32-powerpc"
3717
#define ELF_ARCH                bfd_arch_powerpc
3718
#define ELF_MACHINE_CODE        EM_PPC
3719
#define ELF_MAXPAGESIZE         0x10000
3720
#define elf_info_to_howto       ppc_elf_info_to_howto
3721
 
3722
#ifdef  EM_CYGNUS_POWERPC
3723
#define ELF_MACHINE_ALT1        EM_CYGNUS_POWERPC
3724
#endif
3725
 
3726
#ifdef EM_PPC_OLD
3727
#define ELF_MACHINE_ALT2        EM_PPC_OLD
3728
#endif
3729
 
3730
#define elf_backend_plt_not_loaded      1
3731
#define elf_backend_got_symbol_offset   4
3732
#define elf_backend_can_gc_sections     1
3733
#define elf_backend_got_header_size     12
3734
#define elf_backend_plt_header_size     PLT_INITIAL_ENTRY_SIZE
3735
 
3736
#define bfd_elf32_bfd_copy_private_bfd_data     ppc_elf_copy_private_bfd_data
3737
#define bfd_elf32_bfd_merge_private_bfd_data    ppc_elf_merge_private_bfd_data
3738
#define bfd_elf32_bfd_relax_section             ppc_elf_relax_section
3739
#define bfd_elf32_bfd_reloc_type_lookup         ppc_elf_reloc_type_lookup
3740
#define bfd_elf32_bfd_set_private_flags         ppc_elf_set_private_flags
3741
#define bfd_elf32_bfd_final_link                _bfd_elf32_gc_common_final_link
3742
 
3743
#define elf_backend_gc_mark_hook                ppc_elf_gc_mark_hook
3744
#define elf_backend_gc_sweep_hook               ppc_elf_gc_sweep_hook
3745
#define elf_backend_section_from_shdr           ppc_elf_section_from_shdr
3746
#define elf_backend_relocate_section            ppc_elf_relocate_section
3747
#define elf_backend_create_dynamic_sections     ppc_elf_create_dynamic_sections
3748
#define elf_backend_check_relocs                ppc_elf_check_relocs
3749
#define elf_backend_adjust_dynamic_symbol       ppc_elf_adjust_dynamic_symbol
3750
#define elf_backend_add_symbol_hook             ppc_elf_add_symbol_hook
3751
#define elf_backend_size_dynamic_sections       ppc_elf_size_dynamic_sections
3752
#define elf_backend_finish_dynamic_symbol       ppc_elf_finish_dynamic_symbol
3753
#define elf_backend_finish_dynamic_sections     ppc_elf_finish_dynamic_sections
3754
#define elf_backend_fake_sections               ppc_elf_fake_sections
3755
#define elf_backend_additional_program_headers  ppc_elf_additional_program_headers
3756
#define elf_backend_modify_segment_map          ppc_elf_modify_segment_map
3757
 
3758
#include "elf32-target.h"

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.