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

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-6.8/] [bfd/] [elfxx-mips.c] - Blame information for rev 225

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 24 jeremybenn
/* MIPS-specific support for ELF
2
   Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
3 225 jeremybenn
   2003, 2004, 2005, 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
4 24 jeremybenn
 
5
   Most of the information added by Ian Lance Taylor, Cygnus Support,
6
   <ian@cygnus.com>.
7
   N32/64 ABI support added by Mark Mitchell, CodeSourcery, LLC.
8
   <mark@codesourcery.com>
9
   Traditional MIPS targets support added by Koundinya.K, Dansk Data
10
   Elektronik & Operations Research Group. <kk@ddeorg.soft.net>
11
 
12
   This file is part of BFD, the Binary File Descriptor library.
13
 
14
   This program is free software; you can redistribute it and/or modify
15
   it under the terms of the GNU General Public License as published by
16
   the Free Software Foundation; either version 3 of the License, or
17
   (at your option) any later version.
18
 
19
   This program is distributed in the hope that it will be useful,
20
   but WITHOUT ANY WARRANTY; without even the implied warranty of
21
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
22
   GNU General Public License for more details.
23
 
24
   You should have received a copy of the GNU General Public License
25
   along with this program; if not, write to the Free Software
26
   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
27
   MA 02110-1301, USA.  */
28
 
29
 
30
/* This file handles functionality common to the different MIPS ABI's.  */
31
 
32
#include "sysdep.h"
33
#include "bfd.h"
34
#include "libbfd.h"
35
#include "libiberty.h"
36
#include "elf-bfd.h"
37
#include "elfxx-mips.h"
38
#include "elf/mips.h"
39
#include "elf-vxworks.h"
40
 
41
/* Get the ECOFF swapping routines.  */
42
#include "coff/sym.h"
43
#include "coff/symconst.h"
44
#include "coff/ecoff.h"
45
#include "coff/mips.h"
46
 
47
#include "hashtab.h"
48
 
49
/* This structure is used to hold information about one GOT entry.
50
   There are three types of entry:
51
 
52
      (1) absolute addresses
53
            (abfd == NULL)
54
      (2) SYMBOL + OFFSET addresses, where SYMBOL is local to an input bfd
55
            (abfd != NULL, symndx >= 0)
56
      (3) global and forced-local symbols
57
            (abfd != NULL, symndx == -1)
58
 
59
   Type (3) entries are treated differently for different types of GOT.
60
   In the "master" GOT -- i.e.  the one that describes every GOT
61
   reference needed in the link -- the mips_got_entry is keyed on both
62
   the symbol and the input bfd that references it.  If it turns out
63
   that we need multiple GOTs, we can then use this information to
64
   create separate GOTs for each input bfd.
65
 
66
   However, we want each of these separate GOTs to have at most one
67
   entry for a given symbol, so their type (3) entries are keyed only
68
   on the symbol.  The input bfd given by the "abfd" field is somewhat
69
   arbitrary in this case.
70
 
71
   This means that when there are multiple GOTs, each GOT has a unique
72
   mips_got_entry for every symbol within it.  We can therefore use the
73
   mips_got_entry fields (tls_type and gotidx) to track the symbol's
74
   GOT index.
75
 
76
   However, if it turns out that we need only a single GOT, we continue
77
   to use the master GOT to describe it.  There may therefore be several
78
   mips_got_entries for the same symbol, each with a different input bfd.
79
   We want to make sure that each symbol gets a unique GOT entry, so when
80
   there's a single GOT, we use the symbol's hash entry, not the
81
   mips_got_entry fields, to track a symbol's GOT index.  */
82
struct mips_got_entry
83
{
84
  /* The input bfd in which the symbol is defined.  */
85
  bfd *abfd;
86
  /* The index of the symbol, as stored in the relocation r_info, if
87
     we have a local symbol; -1 otherwise.  */
88
  long symndx;
89
  union
90
  {
91
    /* If abfd == NULL, an address that must be stored in the got.  */
92
    bfd_vma address;
93
    /* If abfd != NULL && symndx != -1, the addend of the relocation
94
       that should be added to the symbol value.  */
95
    bfd_vma addend;
96
    /* If abfd != NULL && symndx == -1, the hash table entry
97
       corresponding to a global symbol in the got (or, local, if
98
       h->forced_local).  */
99
    struct mips_elf_link_hash_entry *h;
100
  } d;
101
 
102
  /* The TLS types included in this GOT entry (specifically, GD and
103
     IE).  The GD and IE flags can be added as we encounter new
104
     relocations.  LDM can also be set; it will always be alone, not
105
     combined with any GD or IE flags.  An LDM GOT entry will be
106
     a local symbol entry with r_symndx == 0.  */
107
  unsigned char tls_type;
108
 
109
  /* The offset from the beginning of the .got section to the entry
110
     corresponding to this symbol+addend.  If it's a global symbol
111
     whose offset is yet to be decided, it's going to be -1.  */
112
  long gotidx;
113
};
114
 
115
/* This structure describes a range of addends: [MIN_ADDEND, MAX_ADDEND].
116
   The structures form a non-overlapping list that is sorted by increasing
117
   MIN_ADDEND.  */
118
struct mips_got_page_range
119
{
120
  struct mips_got_page_range *next;
121
  bfd_signed_vma min_addend;
122
  bfd_signed_vma max_addend;
123
};
124
 
125
/* This structure describes the range of addends that are applied to page
126
   relocations against a given symbol.  */
127
struct mips_got_page_entry
128
{
129
  /* The input bfd in which the symbol is defined.  */
130
  bfd *abfd;
131
  /* The index of the symbol, as stored in the relocation r_info.  */
132
  long symndx;
133
  /* The ranges for this page entry.  */
134
  struct mips_got_page_range *ranges;
135
  /* The maximum number of page entries needed for RANGES.  */
136
  bfd_vma num_pages;
137
};
138
 
139
/* This structure is used to hold .got information when linking.  */
140
 
141
struct mips_got_info
142
{
143
  /* The global symbol in the GOT with the lowest index in the dynamic
144
     symbol table.  */
145
  struct elf_link_hash_entry *global_gotsym;
146
  /* The number of global .got entries.  */
147
  unsigned int global_gotno;
148 225 jeremybenn
  /* The number of global .got entries that are in the GGA_RELOC_ONLY area.  */
149
  unsigned int reloc_only_gotno;
150 24 jeremybenn
  /* The number of .got slots used for TLS.  */
151
  unsigned int tls_gotno;
152
  /* The first unused TLS .got entry.  Used only during
153
     mips_elf_initialize_tls_index.  */
154
  unsigned int tls_assigned_gotno;
155
  /* The number of local .got entries, eventually including page entries.  */
156
  unsigned int local_gotno;
157
  /* The maximum number of page entries needed.  */
158
  unsigned int page_gotno;
159
  /* The number of local .got entries we have used.  */
160
  unsigned int assigned_gotno;
161
  /* A hash table holding members of the got.  */
162
  struct htab *got_entries;
163
  /* A hash table of mips_got_page_entry structures.  */
164
  struct htab *got_page_entries;
165
  /* A hash table mapping input bfds to other mips_got_info.  NULL
166
     unless multi-got was necessary.  */
167
  struct htab *bfd2got;
168
  /* In multi-got links, a pointer to the next got (err, rather, most
169
     of the time, it points to the previous got).  */
170
  struct mips_got_info *next;
171
  /* This is the GOT index of the TLS LDM entry for the GOT, MINUS_ONE
172
     for none, or MINUS_TWO for not yet assigned.  This is needed
173
     because a single-GOT link may have multiple hash table entries
174
     for the LDM.  It does not get initialized in multi-GOT mode.  */
175
  bfd_vma tls_ldm_offset;
176
};
177
 
178
/* Map an input bfd to a got in a multi-got link.  */
179
 
180
struct mips_elf_bfd2got_hash {
181
  bfd *bfd;
182
  struct mips_got_info *g;
183
};
184
 
185
/* Structure passed when traversing the bfd2got hash table, used to
186
   create and merge bfd's gots.  */
187
 
188
struct mips_elf_got_per_bfd_arg
189
{
190
  /* A hashtable that maps bfds to gots.  */
191
  htab_t bfd2got;
192
  /* The output bfd.  */
193
  bfd *obfd;
194
  /* The link information.  */
195
  struct bfd_link_info *info;
196
  /* A pointer to the primary got, i.e., the one that's going to get
197
     the implicit relocations from DT_MIPS_LOCAL_GOTNO and
198
     DT_MIPS_GOTSYM.  */
199
  struct mips_got_info *primary;
200
  /* A non-primary got we're trying to merge with other input bfd's
201
     gots.  */
202
  struct mips_got_info *current;
203
  /* The maximum number of got entries that can be addressed with a
204
     16-bit offset.  */
205
  unsigned int max_count;
206
  /* The maximum number of page entries needed by each got.  */
207
  unsigned int max_pages;
208
  /* The total number of global entries which will live in the
209
     primary got and be automatically relocated.  This includes
210
     those not referenced by the primary GOT but included in
211
     the "master" GOT.  */
212
  unsigned int global_count;
213
};
214
 
215
/* Another structure used to pass arguments for got entries traversal.  */
216
 
217
struct mips_elf_set_global_got_offset_arg
218
{
219
  struct mips_got_info *g;
220
  int value;
221
  unsigned int needed_relocs;
222
  struct bfd_link_info *info;
223
};
224
 
225
/* A structure used to count TLS relocations or GOT entries, for GOT
226
   entry or ELF symbol table traversal.  */
227
 
228
struct mips_elf_count_tls_arg
229
{
230
  struct bfd_link_info *info;
231
  unsigned int needed;
232
};
233
 
234
struct _mips_elf_section_data
235
{
236
  struct bfd_elf_section_data elf;
237
  union
238
  {
239
    bfd_byte *tdata;
240
  } u;
241
};
242
 
243
#define mips_elf_section_data(sec) \
244
  ((struct _mips_elf_section_data *) elf_section_data (sec))
245
 
246 225 jeremybenn
#define is_mips_elf(bfd)                                \
247
  (bfd_get_flavour (bfd) == bfd_target_elf_flavour      \
248
   && elf_tdata (bfd) != NULL                           \
249
   && elf_object_id (bfd) == MIPS_ELF_TDATA)
250
 
251
/* The ABI says that every symbol used by dynamic relocations must have
252
   a global GOT entry.  Among other things, this provides the dynamic
253
   linker with a free, directly-indexed cache.  The GOT can therefore
254
   contain symbols that are not referenced by GOT relocations themselves
255
   (in other words, it may have symbols that are not referenced by things
256
   like R_MIPS_GOT16 and R_MIPS_GOT_PAGE).
257
 
258
   GOT relocations are less likely to overflow if we put the associated
259
   GOT entries towards the beginning.  We therefore divide the global
260
   GOT entries into two areas: "normal" and "reloc-only".  Entries in
261
   the first area can be used for both dynamic relocations and GP-relative
262
   accesses, while those in the "reloc-only" area are for dynamic
263
   relocations only.
264
 
265
   These GGA_* ("Global GOT Area") values are organised so that lower
266
   values are more general than higher values.  Also, non-GGA_NONE
267
   values are ordered by the position of the area in the GOT.  */
268
#define GGA_NORMAL 0
269
#define GGA_RELOC_ONLY 1
270
#define GGA_NONE 2
271
 
272
/* Information about a non-PIC interface to a PIC function.  There are
273
   two ways of creating these interfaces.  The first is to add:
274
 
275
        lui     $25,%hi(func)
276
        addiu   $25,$25,%lo(func)
277
 
278
   immediately before a PIC function "func".  The second is to add:
279
 
280
        lui     $25,%hi(func)
281
        j       func
282
        addiu   $25,$25,%lo(func)
283
 
284
   to a separate trampoline section.
285
 
286
   Stubs of the first kind go in a new section immediately before the
287
   target function.  Stubs of the second kind go in a single section
288
   pointed to by the hash table's "strampoline" field.  */
289
struct mips_elf_la25_stub {
290
  /* The generated section that contains this stub.  */
291
  asection *stub_section;
292
 
293
  /* The offset of the stub from the start of STUB_SECTION.  */
294
  bfd_vma offset;
295
 
296
  /* One symbol for the original function.  Its location is available
297
     in H->root.root.u.def.  */
298
  struct mips_elf_link_hash_entry *h;
299
};
300
 
301
/* Macros for populating a mips_elf_la25_stub.  */
302
 
303
#define LA25_LUI(VAL) (0x3c190000 | (VAL))      /* lui t9,VAL */
304
#define LA25_J(VAL) (0x08000000 | (((VAL) >> 2) & 0x3ffffff)) /* j VAL */
305
#define LA25_ADDIU(VAL) (0x27390000 | (VAL))    /* addiu t9,t9,VAL */
306
 
307 24 jeremybenn
/* This structure is passed to mips_elf_sort_hash_table_f when sorting
308
   the dynamic symbols.  */
309
 
310
struct mips_elf_hash_sort_data
311
{
312
  /* The symbol in the global GOT with the lowest dynamic symbol table
313
     index.  */
314
  struct elf_link_hash_entry *low;
315
  /* The least dynamic symbol table index corresponding to a non-TLS
316
     symbol with a GOT entry.  */
317
  long min_got_dynindx;
318
  /* The greatest dynamic symbol table index corresponding to a symbol
319
     with a GOT entry that is not referenced (e.g., a dynamic symbol
320
     with dynamic relocations pointing to it from non-primary GOTs).  */
321
  long max_unref_got_dynindx;
322
  /* The greatest dynamic symbol table index not corresponding to a
323
     symbol without a GOT entry.  */
324
  long max_non_got_dynindx;
325
};
326
 
327
/* The MIPS ELF linker needs additional information for each symbol in
328
   the global hash table.  */
329
 
330
struct mips_elf_link_hash_entry
331
{
332
  struct elf_link_hash_entry root;
333
 
334
  /* External symbol information.  */
335
  EXTR esym;
336
 
337 225 jeremybenn
  /* The la25 stub we have created for ths symbol, if any.  */
338
  struct mips_elf_la25_stub *la25_stub;
339
 
340 24 jeremybenn
  /* Number of R_MIPS_32, R_MIPS_REL32, or R_MIPS_64 relocs against
341
     this symbol.  */
342
  unsigned int possibly_dynamic_relocs;
343
 
344
  /* If there is a stub that 32 bit functions should use to call this
345
     16 bit function, this points to the section containing the stub.  */
346
  asection *fn_stub;
347
 
348
  /* If there is a stub that 16 bit functions should use to call this
349
     32 bit function, this points to the section containing the stub.  */
350
  asection *call_stub;
351
 
352
  /* This is like the call_stub field, but it is used if the function
353
     being called returns a floating point value.  */
354
  asection *call_fp_stub;
355
 
356
#define GOT_NORMAL      0
357
#define GOT_TLS_GD      1
358
#define GOT_TLS_LDM     2
359
#define GOT_TLS_IE      4
360
#define GOT_TLS_OFFSET_DONE    0x40
361
#define GOT_TLS_DONE    0x80
362
  unsigned char tls_type;
363 225 jeremybenn
 
364 24 jeremybenn
  /* This is only used in single-GOT mode; in multi-GOT mode there
365
     is one mips_got_entry per GOT entry, so the offset is stored
366
     there.  In single-GOT mode there may be many mips_got_entry
367
     structures all referring to the same GOT slot.  It might be
368
     possible to use root.got.offset instead, but that field is
369
     overloaded already.  */
370
  bfd_vma tls_got_offset;
371 225 jeremybenn
 
372
  /* The highest GGA_* value that satisfies all references to this symbol.  */
373
  unsigned int global_got_area : 2;
374
 
375
  /* True if one of the relocations described by possibly_dynamic_relocs
376
     is against a readonly section.  */
377
  unsigned int readonly_reloc : 1;
378
 
379
  /* True if there is a relocation against this symbol that must be
380
     resolved by the static linker (in other words, if the relocation
381
     cannot possibly be made dynamic).  */
382
  unsigned int has_static_relocs : 1;
383
 
384
  /* True if we must not create a .MIPS.stubs entry for this symbol.
385
     This is set, for example, if there are relocations related to
386
     taking the function's address, i.e. any but R_MIPS_CALL*16 ones.
387
     See "MIPS ABI Supplement, 3rd Edition", p. 4-20.  */
388
  unsigned int no_fn_stub : 1;
389
 
390
  /* Whether we need the fn_stub; this is true if this symbol appears
391
     in any relocs other than a 16 bit call.  */
392
  unsigned int need_fn_stub : 1;
393
 
394
  /* True if this symbol is referenced by branch relocations from
395
     any non-PIC input file.  This is used to determine whether an
396
     la25 stub is required.  */
397
  unsigned int has_nonpic_branches : 1;
398
 
399
  /* Does this symbol need a traditional MIPS lazy-binding stub
400
     (as opposed to a PLT entry)?  */
401
  unsigned int needs_lazy_stub : 1;
402 24 jeremybenn
};
403
 
404
/* MIPS ELF linker hash table.  */
405
 
406
struct mips_elf_link_hash_table
407
{
408
  struct elf_link_hash_table root;
409
#if 0
410
  /* We no longer use this.  */
411
  /* String section indices for the dynamic section symbols.  */
412
  bfd_size_type dynsym_sec_strindex[SIZEOF_MIPS_DYNSYM_SECNAMES];
413
#endif
414 225 jeremybenn
 
415 24 jeremybenn
  /* The number of .rtproc entries.  */
416
  bfd_size_type procedure_count;
417 225 jeremybenn
 
418 24 jeremybenn
  /* The size of the .compact_rel section (if SGI_COMPAT).  */
419
  bfd_size_type compact_rel_size;
420 225 jeremybenn
 
421 24 jeremybenn
  /* This flag indicates that the value of DT_MIPS_RLD_MAP dynamic
422
     entry is set to the address of __rld_obj_head as in IRIX5.  */
423
  bfd_boolean use_rld_obj_head;
424 225 jeremybenn
 
425 24 jeremybenn
  /* This is the value of the __rld_map or __rld_obj_head symbol.  */
426
  bfd_vma rld_value;
427 225 jeremybenn
 
428 24 jeremybenn
  /* This is set if we see any mips16 stub sections.  */
429
  bfd_boolean mips16_stubs_seen;
430 225 jeremybenn
 
431
  /* True if we can generate copy relocs and PLTs.  */
432
  bfd_boolean use_plts_and_copy_relocs;
433
 
434 24 jeremybenn
  /* True if we're generating code for VxWorks.  */
435
  bfd_boolean is_vxworks;
436 225 jeremybenn
 
437 24 jeremybenn
  /* True if we already reported the small-data section overflow.  */
438
  bfd_boolean small_data_overflow_reported;
439 225 jeremybenn
 
440 24 jeremybenn
  /* Shortcuts to some dynamic sections, or NULL if they are not
441
     being used.  */
442
  asection *srelbss;
443
  asection *sdynbss;
444
  asection *srelplt;
445
  asection *srelplt2;
446
  asection *sgotplt;
447
  asection *splt;
448 225 jeremybenn
  asection *sstubs;
449
  asection *sgot;
450
 
451
  /* The master GOT information.  */
452
  struct mips_got_info *got_info;
453
 
454
  /* The size of the PLT header in bytes.  */
455 24 jeremybenn
  bfd_vma plt_header_size;
456 225 jeremybenn
 
457
  /* The size of a PLT entry in bytes.  */
458 24 jeremybenn
  bfd_vma plt_entry_size;
459 225 jeremybenn
 
460
  /* The number of functions that need a lazy-binding stub.  */
461
  bfd_vma lazy_stub_count;
462
 
463 24 jeremybenn
  /* The size of a function stub entry in bytes.  */
464
  bfd_vma function_stub_size;
465 225 jeremybenn
 
466
  /* The number of reserved entries at the beginning of the GOT.  */
467
  unsigned int reserved_gotno;
468
 
469
  /* The section used for mips_elf_la25_stub trampolines.
470
     See the comment above that structure for details.  */
471
  asection *strampoline;
472
 
473
  /* A table of mips_elf_la25_stubs, indexed by (input_section, offset)
474
     pairs.  */
475
  htab_t la25_stubs;
476
 
477
  /* A function FN (NAME, IS, OS) that creates a new input section
478
     called NAME and links it to output section OS.  If IS is nonnull,
479
     the new section should go immediately before it, otherwise it
480
     should go at the (current) beginning of OS.
481
 
482
     The function returns the new section on success, otherwise it
483
     returns null.  */
484
  asection *(*add_stub_section) (const char *, asection *, asection *);
485 24 jeremybenn
};
486
 
487 225 jeremybenn
/* A structure used to communicate with htab_traverse callbacks.  */
488
struct mips_htab_traverse_info {
489
  /* The usual link-wide information.  */
490
  struct bfd_link_info *info;
491
  bfd *output_bfd;
492
 
493
  /* Starts off FALSE and is set to TRUE if the link should be aborted.  */
494
  bfd_boolean error;
495
};
496
 
497 24 jeremybenn
#define TLS_RELOC_P(r_type) \
498
  (r_type == R_MIPS_TLS_DTPMOD32                \
499
   || r_type == R_MIPS_TLS_DTPMOD64             \
500
   || r_type == R_MIPS_TLS_DTPREL32             \
501
   || r_type == R_MIPS_TLS_DTPREL64             \
502
   || r_type == R_MIPS_TLS_GD                   \
503
   || r_type == R_MIPS_TLS_LDM                  \
504
   || r_type == R_MIPS_TLS_DTPREL_HI16          \
505
   || r_type == R_MIPS_TLS_DTPREL_LO16          \
506
   || r_type == R_MIPS_TLS_GOTTPREL             \
507
   || r_type == R_MIPS_TLS_TPREL32              \
508
   || r_type == R_MIPS_TLS_TPREL64              \
509
   || r_type == R_MIPS_TLS_TPREL_HI16           \
510
   || r_type == R_MIPS_TLS_TPREL_LO16)
511
 
512
/* Structure used to pass information to mips_elf_output_extsym.  */
513
 
514
struct extsym_info
515
{
516
  bfd *abfd;
517
  struct bfd_link_info *info;
518
  struct ecoff_debug_info *debug;
519
  const struct ecoff_debug_swap *swap;
520
  bfd_boolean failed;
521
};
522
 
523
/* The names of the runtime procedure table symbols used on IRIX5.  */
524
 
525
static const char * const mips_elf_dynsym_rtproc_names[] =
526
{
527
  "_procedure_table",
528
  "_procedure_string_table",
529
  "_procedure_table_size",
530
  NULL
531
};
532
 
533
/* These structures are used to generate the .compact_rel section on
534
   IRIX5.  */
535
 
536
typedef struct
537
{
538
  unsigned long id1;            /* Always one?  */
539
  unsigned long num;            /* Number of compact relocation entries.  */
540
  unsigned long id2;            /* Always two?  */
541
  unsigned long offset;         /* The file offset of the first relocation.  */
542
  unsigned long reserved0;      /* Zero?  */
543
  unsigned long reserved1;      /* Zero?  */
544
} Elf32_compact_rel;
545
 
546
typedef struct
547
{
548
  bfd_byte id1[4];
549
  bfd_byte num[4];
550
  bfd_byte id2[4];
551
  bfd_byte offset[4];
552
  bfd_byte reserved0[4];
553
  bfd_byte reserved1[4];
554
} Elf32_External_compact_rel;
555
 
556
typedef struct
557
{
558
  unsigned int ctype : 1;       /* 1: long 0: short format. See below.  */
559
  unsigned int rtype : 4;       /* Relocation types. See below.  */
560
  unsigned int dist2to : 8;
561
  unsigned int relvaddr : 19;   /* (VADDR - vaddr of the previous entry)/ 4 */
562
  unsigned long konst;          /* KONST field. See below.  */
563
  unsigned long vaddr;          /* VADDR to be relocated.  */
564
} Elf32_crinfo;
565
 
566
typedef struct
567
{
568
  unsigned int ctype : 1;       /* 1: long 0: short format. See below.  */
569
  unsigned int rtype : 4;       /* Relocation types. See below.  */
570
  unsigned int dist2to : 8;
571
  unsigned int relvaddr : 19;   /* (VADDR - vaddr of the previous entry)/ 4 */
572
  unsigned long konst;          /* KONST field. See below.  */
573
} Elf32_crinfo2;
574
 
575
typedef struct
576
{
577
  bfd_byte info[4];
578
  bfd_byte konst[4];
579
  bfd_byte vaddr[4];
580
} Elf32_External_crinfo;
581
 
582
typedef struct
583
{
584
  bfd_byte info[4];
585
  bfd_byte konst[4];
586
} Elf32_External_crinfo2;
587
 
588
/* These are the constants used to swap the bitfields in a crinfo.  */
589
 
590
#define CRINFO_CTYPE (0x1)
591
#define CRINFO_CTYPE_SH (31)
592
#define CRINFO_RTYPE (0xf)
593
#define CRINFO_RTYPE_SH (27)
594
#define CRINFO_DIST2TO (0xff)
595
#define CRINFO_DIST2TO_SH (19)
596
#define CRINFO_RELVADDR (0x7ffff)
597
#define CRINFO_RELVADDR_SH (0)
598
 
599
/* A compact relocation info has long (3 words) or short (2 words)
600
   formats.  A short format doesn't have VADDR field and relvaddr
601
   fields contains ((VADDR - vaddr of the previous entry) >> 2).  */
602
#define CRF_MIPS_LONG                   1
603
#define CRF_MIPS_SHORT                  0
604
 
605
/* There are 4 types of compact relocation at least. The value KONST
606
   has different meaning for each type:
607
 
608
   (type)               (konst)
609
   CT_MIPS_REL32        Address in data
610
   CT_MIPS_WORD         Address in word (XXX)
611
   CT_MIPS_GPHI_LO      GP - vaddr
612
   CT_MIPS_JMPAD        Address to jump
613
   */
614
 
615
#define CRT_MIPS_REL32                  0xa
616
#define CRT_MIPS_WORD                   0xb
617
#define CRT_MIPS_GPHI_LO                0xc
618
#define CRT_MIPS_JMPAD                  0xd
619
 
620
#define mips_elf_set_cr_format(x,format)        ((x).ctype = (format))
621
#define mips_elf_set_cr_type(x,type)            ((x).rtype = (type))
622
#define mips_elf_set_cr_dist2to(x,v)            ((x).dist2to = (v))
623
#define mips_elf_set_cr_relvaddr(x,d)           ((x).relvaddr = (d)<<2)
624
 
625
/* The structure of the runtime procedure descriptor created by the
626
   loader for use by the static exception system.  */
627
 
628
typedef struct runtime_pdr {
629
        bfd_vma adr;            /* Memory address of start of procedure.  */
630
        long    regmask;        /* Save register mask.  */
631
        long    regoffset;      /* Save register offset.  */
632
        long    fregmask;       /* Save floating point register mask.  */
633
        long    fregoffset;     /* Save floating point register offset.  */
634
        long    frameoffset;    /* Frame size.  */
635
        short   framereg;       /* Frame pointer register.  */
636
        short   pcreg;          /* Offset or reg of return pc.  */
637
        long    irpss;          /* Index into the runtime string table.  */
638
        long    reserved;
639
        struct exception_info *exception_info;/* Pointer to exception array.  */
640
} RPDR, *pRPDR;
641
#define cbRPDR sizeof (RPDR)
642
#define rpdNil ((pRPDR) 0)
643
 
644
static struct mips_got_entry *mips_elf_create_local_got_entry
645 225 jeremybenn
  (bfd *, struct bfd_link_info *, bfd *, bfd_vma, unsigned long,
646
   struct mips_elf_link_hash_entry *, int);
647 24 jeremybenn
static bfd_boolean mips_elf_sort_hash_table_f
648
  (struct mips_elf_link_hash_entry *, void *);
649
static bfd_vma mips_elf_high
650
  (bfd_vma);
651
static bfd_boolean mips_elf_create_dynamic_relocation
652
  (bfd *, struct bfd_link_info *, const Elf_Internal_Rela *,
653
   struct mips_elf_link_hash_entry *, asection *, bfd_vma,
654
   bfd_vma *, asection *);
655
static hashval_t mips_elf_got_entry_hash
656
  (const void *);
657
static bfd_vma mips_elf_adjust_gp
658
  (bfd *, struct mips_got_info *, bfd *);
659
static struct mips_got_info *mips_elf_got_for_ibfd
660
  (struct mips_got_info *, bfd *);
661
 
662
/* This will be used when we sort the dynamic relocation records.  */
663
static bfd *reldyn_sorting_bfd;
664
 
665 225 jeremybenn
/* True if ABFD is for CPUs with load interlocking that include
666
   non-MIPS1 CPUs and R3900.  */
667
#define LOAD_INTERLOCKS_P(abfd) \
668
  (   ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) != E_MIPS_ARCH_1) \
669
   || ((elf_elfheader (abfd)->e_flags & EF_MIPS_MACH) == E_MIPS_MACH_3900))
670
 
671
/* True if ABFD is for CPUs that are faster if JAL is converted to BAL.
672
   This should be safe for all architectures.  We enable this predicate
673
   for RM9000 for now.  */
674
#define JAL_TO_BAL_P(abfd) \
675
  ((elf_elfheader (abfd)->e_flags & EF_MIPS_MACH) == E_MIPS_MACH_9000)
676
 
677
/* True if ABFD is for CPUs that are faster if JALR is converted to BAL.
678
   This should be safe for all architectures.  We enable this predicate for
679
   all CPUs.  */
680
#define JALR_TO_BAL_P(abfd) 1
681
 
682
/* True if ABFD is a PIC object.  */
683
#define PIC_OBJECT_P(abfd) \
684
  ((elf_elfheader (abfd)->e_flags & EF_MIPS_PIC) != 0)
685
 
686 24 jeremybenn
/* Nonzero if ABFD is using the N32 ABI.  */
687
#define ABI_N32_P(abfd) \
688
  ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI2) != 0)
689
 
690
/* Nonzero if ABFD is using the N64 ABI.  */
691
#define ABI_64_P(abfd) \
692
  (get_elf_backend_data (abfd)->s->elfclass == ELFCLASS64)
693
 
694
/* Nonzero if ABFD is using NewABI conventions.  */
695
#define NEWABI_P(abfd) (ABI_N32_P (abfd) || ABI_64_P (abfd))
696
 
697
/* The IRIX compatibility level we are striving for.  */
698
#define IRIX_COMPAT(abfd) \
699
  (get_elf_backend_data (abfd)->elf_backend_mips_irix_compat (abfd))
700
 
701
/* Whether we are trying to be compatible with IRIX at all.  */
702
#define SGI_COMPAT(abfd) \
703
  (IRIX_COMPAT (abfd) != ict_none)
704
 
705
/* The name of the options section.  */
706
#define MIPS_ELF_OPTIONS_SECTION_NAME(abfd) \
707
  (NEWABI_P (abfd) ? ".MIPS.options" : ".options")
708
 
709
/* True if NAME is the recognized name of any SHT_MIPS_OPTIONS section.
710
   Some IRIX system files do not use MIPS_ELF_OPTIONS_SECTION_NAME.  */
711
#define MIPS_ELF_OPTIONS_SECTION_NAME_P(NAME) \
712
  (strcmp (NAME, ".MIPS.options") == 0 || strcmp (NAME, ".options") == 0)
713
 
714
/* Whether the section is readonly.  */
715
#define MIPS_ELF_READONLY_SECTION(sec) \
716
  ((sec->flags & (SEC_ALLOC | SEC_LOAD | SEC_READONLY))         \
717
   == (SEC_ALLOC | SEC_LOAD | SEC_READONLY))
718
 
719
/* The name of the stub section.  */
720
#define MIPS_ELF_STUB_SECTION_NAME(abfd) ".MIPS.stubs"
721
 
722
/* The size of an external REL relocation.  */
723
#define MIPS_ELF_REL_SIZE(abfd) \
724
  (get_elf_backend_data (abfd)->s->sizeof_rel)
725
 
726
/* The size of an external RELA relocation.  */
727
#define MIPS_ELF_RELA_SIZE(abfd) \
728
  (get_elf_backend_data (abfd)->s->sizeof_rela)
729
 
730
/* The size of an external dynamic table entry.  */
731
#define MIPS_ELF_DYN_SIZE(abfd) \
732
  (get_elf_backend_data (abfd)->s->sizeof_dyn)
733
 
734
/* The size of a GOT entry.  */
735
#define MIPS_ELF_GOT_SIZE(abfd) \
736
  (get_elf_backend_data (abfd)->s->arch_size / 8)
737
 
738
/* The size of a symbol-table entry.  */
739
#define MIPS_ELF_SYM_SIZE(abfd) \
740
  (get_elf_backend_data (abfd)->s->sizeof_sym)
741
 
742
/* The default alignment for sections, as a power of two.  */
743
#define MIPS_ELF_LOG_FILE_ALIGN(abfd)                           \
744
  (get_elf_backend_data (abfd)->s->log_file_align)
745
 
746
/* Get word-sized data.  */
747
#define MIPS_ELF_GET_WORD(abfd, ptr) \
748
  (ABI_64_P (abfd) ? bfd_get_64 (abfd, ptr) : bfd_get_32 (abfd, ptr))
749
 
750
/* Put out word-sized data.  */
751
#define MIPS_ELF_PUT_WORD(abfd, val, ptr)       \
752
  (ABI_64_P (abfd)                              \
753
   ? bfd_put_64 (abfd, val, ptr)                \
754
   : bfd_put_32 (abfd, val, ptr))
755
 
756 225 jeremybenn
/* The opcode for word-sized loads (LW or LD).  */
757
#define MIPS_ELF_LOAD_WORD(abfd) \
758
  (ABI_64_P (abfd) ? 0xdc000000 : 0x8c000000)
759
 
760 24 jeremybenn
/* Add a dynamic symbol table-entry.  */
761
#define MIPS_ELF_ADD_DYNAMIC_ENTRY(info, tag, val)      \
762
  _bfd_elf_add_dynamic_entry (info, tag, val)
763
 
764
#define MIPS_ELF_RTYPE_TO_HOWTO(abfd, rtype, rela)                      \
765
  (get_elf_backend_data (abfd)->elf_backend_mips_rtype_to_howto (rtype, rela))
766
 
767
/* Determine whether the internal relocation of index REL_IDX is REL
768
   (zero) or RELA (non-zero).  The assumption is that, if there are
769
   two relocation sections for this section, one of them is REL and
770
   the other is RELA.  If the index of the relocation we're testing is
771
   in range for the first relocation section, check that the external
772
   relocation size is that for RELA.  It is also assumed that, if
773
   rel_idx is not in range for the first section, and this first
774
   section contains REL relocs, then the relocation is in the second
775
   section, that is RELA.  */
776
#define MIPS_RELOC_RELA_P(abfd, sec, rel_idx)                           \
777
  ((NUM_SHDR_ENTRIES (&elf_section_data (sec)->rel_hdr)                 \
778
    * get_elf_backend_data (abfd)->s->int_rels_per_ext_rel              \
779
    > (bfd_vma)(rel_idx))                                               \
780
   == (elf_section_data (sec)->rel_hdr.sh_entsize                       \
781
       == (ABI_64_P (abfd) ? sizeof (Elf64_External_Rela)               \
782
           : sizeof (Elf32_External_Rela))))
783
 
784
/* The name of the dynamic relocation section.  */
785
#define MIPS_ELF_REL_DYN_NAME(INFO) \
786
  (mips_elf_hash_table (INFO)->is_vxworks ? ".rela.dyn" : ".rel.dyn")
787
 
788
/* In case we're on a 32-bit machine, construct a 64-bit "-1" value
789
   from smaller values.  Start with zero, widen, *then* decrement.  */
790
#define MINUS_ONE       (((bfd_vma)0) - 1)
791
#define MINUS_TWO       (((bfd_vma)0) - 2)
792
 
793 225 jeremybenn
/* The value to write into got[1] for SVR4 targets, to identify it is
794
   a GNU object.  The dynamic linker can then use got[1] to store the
795
   module pointer.  */
796
#define MIPS_ELF_GNU_GOT1_MASK(abfd) \
797
  ((bfd_vma) 1 << (ABI_64_P (abfd) ? 63 : 31))
798 24 jeremybenn
 
799
/* The offset of $gp from the beginning of the .got section.  */
800
#define ELF_MIPS_GP_OFFSET(INFO) \
801
  (mips_elf_hash_table (INFO)->is_vxworks ? 0x0 : 0x7ff0)
802
 
803
/* The maximum size of the GOT for it to be addressable using 16-bit
804
   offsets from $gp.  */
805
#define MIPS_ELF_GOT_MAX_SIZE(INFO) (ELF_MIPS_GP_OFFSET (INFO) + 0x7fff)
806
 
807
/* Instructions which appear in a stub.  */
808
#define STUB_LW(abfd)                                                   \
809
  ((ABI_64_P (abfd)                                                     \
810
    ? 0xdf998010                                /* ld t9,0x8010(gp) */  \
811
    : 0x8f998010))                              /* lw t9,0x8010(gp) */
812
#define STUB_MOVE(abfd)                                                 \
813
   ((ABI_64_P (abfd)                                                    \
814
     ? 0x03e0782d                               /* daddu t7,ra */       \
815
     : 0x03e07821))                             /* addu t7,ra */
816
#define STUB_LUI(VAL) (0x3c180000 + (VAL))      /* lui t8,VAL */
817
#define STUB_JALR 0x0320f809                    /* jalr t9,ra */
818
#define STUB_ORI(VAL) (0x37180000 + (VAL))      /* ori t8,t8,VAL */
819
#define STUB_LI16U(VAL) (0x34180000 + (VAL))    /* ori t8,zero,VAL unsigned */
820
#define STUB_LI16S(abfd, VAL)                                           \
821
   ((ABI_64_P (abfd)                                                    \
822
    ? (0x64180000 + (VAL))      /* daddiu t8,zero,VAL sign extended */  \
823
    : (0x24180000 + (VAL))))    /* addiu t8,zero,VAL sign extended */
824
 
825
#define MIPS_FUNCTION_STUB_NORMAL_SIZE 16
826
#define MIPS_FUNCTION_STUB_BIG_SIZE 20
827
 
828
/* The name of the dynamic interpreter.  This is put in the .interp
829
   section.  */
830
 
831
#define ELF_DYNAMIC_INTERPRETER(abfd)           \
832
   (ABI_N32_P (abfd) ? "/usr/lib32/libc.so.1"   \
833
    : ABI_64_P (abfd) ? "/usr/lib64/libc.so.1"  \
834
    : "/usr/lib/libc.so.1")
835
 
836
#ifdef BFD64
837
#define MNAME(bfd,pre,pos) \
838
  (ABI_64_P (bfd) ? CONCAT4 (pre,64,_,pos) : CONCAT4 (pre,32,_,pos))
839
#define ELF_R_SYM(bfd, i)                                       \
840
  (ABI_64_P (bfd) ? ELF64_R_SYM (i) : ELF32_R_SYM (i))
841
#define ELF_R_TYPE(bfd, i)                                      \
842
  (ABI_64_P (bfd) ? ELF64_MIPS_R_TYPE (i) : ELF32_R_TYPE (i))
843
#define ELF_R_INFO(bfd, s, t)                                   \
844
  (ABI_64_P (bfd) ? ELF64_R_INFO (s, t) : ELF32_R_INFO (s, t))
845
#else
846
#define MNAME(bfd,pre,pos) CONCAT4 (pre,32,_,pos)
847
#define ELF_R_SYM(bfd, i)                                       \
848
  (ELF32_R_SYM (i))
849
#define ELF_R_TYPE(bfd, i)                                      \
850
  (ELF32_R_TYPE (i))
851
#define ELF_R_INFO(bfd, s, t)                                   \
852
  (ELF32_R_INFO (s, t))
853
#endif
854
 
855
  /* The mips16 compiler uses a couple of special sections to handle
856
     floating point arguments.
857
 
858
     Section names that look like .mips16.fn.FNNAME contain stubs that
859
     copy floating point arguments from the fp regs to the gp regs and
860
     then jump to FNNAME.  If any 32 bit function calls FNNAME, the
861
     call should be redirected to the stub instead.  If no 32 bit
862
     function calls FNNAME, the stub should be discarded.  We need to
863
     consider any reference to the function, not just a call, because
864
     if the address of the function is taken we will need the stub,
865
     since the address might be passed to a 32 bit function.
866
 
867
     Section names that look like .mips16.call.FNNAME contain stubs
868
     that copy floating point arguments from the gp regs to the fp
869
     regs and then jump to FNNAME.  If FNNAME is a 32 bit function,
870
     then any 16 bit function that calls FNNAME should be redirected
871
     to the stub instead.  If FNNAME is not a 32 bit function, the
872
     stub should be discarded.
873
 
874
     .mips16.call.fp.FNNAME sections are similar, but contain stubs
875
     which call FNNAME and then copy the return value from the fp regs
876
     to the gp regs.  These stubs store the return value in $18 while
877
     calling FNNAME; any function which might call one of these stubs
878
     must arrange to save $18 around the call.  (This case is not
879
     needed for 32 bit functions that call 16 bit functions, because
880
     16 bit functions always return floating point values in both
881
     $f0/$f1 and $2/$3.)
882
 
883
     Note that in all cases FNNAME might be defined statically.
884
     Therefore, FNNAME is not used literally.  Instead, the relocation
885
     information will indicate which symbol the section is for.
886
 
887
     We record any stubs that we find in the symbol table.  */
888
 
889
#define FN_STUB ".mips16.fn."
890
#define CALL_STUB ".mips16.call."
891
#define CALL_FP_STUB ".mips16.call.fp."
892
 
893
#define FN_STUB_P(name) CONST_STRNEQ (name, FN_STUB)
894
#define CALL_STUB_P(name) CONST_STRNEQ (name, CALL_STUB)
895
#define CALL_FP_STUB_P(name) CONST_STRNEQ (name, CALL_FP_STUB)
896
 
897 225 jeremybenn
/* The format of the first PLT entry in an O32 executable.  */
898
static const bfd_vma mips_o32_exec_plt0_entry[] =
899
{
900
  0x3c1c0000,   /* lui $28, %hi(&GOTPLT[0])                             */
901
  0x8f990000,   /* lw $25, %lo(&GOTPLT[0])($28)                         */
902
  0x279c0000,   /* addiu $28, $28, %lo(&GOTPLT[0])                      */
903
  0x031cc023,   /* subu $24, $24, $28                                   */
904
  0x03e07821,   /* move $15, $31                                        */
905
  0x0018c082,   /* srl $24, $24, 2                                      */
906
  0x0320f809,   /* jalr $25                                             */
907
  0x2718fffe    /* subu $24, $24, 2                                     */
908
};
909
 
910
/* The format of the first PLT entry in an N32 executable.  Different
911
   because gp ($28) is not available; we use t2 ($14) instead.  */
912
static const bfd_vma mips_n32_exec_plt0_entry[] =
913
{
914
  0x3c0e0000,   /* lui $14, %hi(&GOTPLT[0])                             */
915
  0x8dd90000,   /* lw $25, %lo(&GOTPLT[0])($14)                         */
916
  0x25ce0000,   /* addiu $14, $14, %lo(&GOTPLT[0])                      */
917
  0x030ec023,   /* subu $24, $24, $14                                   */
918
  0x03e07821,   /* move $15, $31                                        */
919
  0x0018c082,   /* srl $24, $24, 2                                      */
920
  0x0320f809,   /* jalr $25                                             */
921
  0x2718fffe    /* subu $24, $24, 2                                     */
922
};
923
 
924
/* The format of the first PLT entry in an N64 executable.  Different
925
   from N32 because of the increased size of GOT entries.  */
926
static const bfd_vma mips_n64_exec_plt0_entry[] =
927
{
928
  0x3c0e0000,   /* lui $14, %hi(&GOTPLT[0])                             */
929
  0xddd90000,   /* ld $25, %lo(&GOTPLT[0])($14)                         */
930
  0x25ce0000,   /* addiu $14, $14, %lo(&GOTPLT[0])                      */
931
  0x030ec023,   /* subu $24, $24, $14                                   */
932
  0x03e07821,   /* move $15, $31                                        */
933
  0x0018c0c2,   /* srl $24, $24, 3                                      */
934
  0x0320f809,   /* jalr $25                                             */
935
  0x2718fffe    /* subu $24, $24, 2                                     */
936
};
937
 
938
/* The format of subsequent PLT entries.  */
939
static const bfd_vma mips_exec_plt_entry[] =
940
{
941
  0x3c0f0000,   /* lui $15, %hi(.got.plt entry)                 */
942
  0x01f90000,   /* l[wd] $25, %lo(.got.plt entry)($15)          */
943
  0x25f80000,   /* addiu $24, $15, %lo(.got.plt entry)          */
944
  0x03200008    /* jr $25                                       */
945
};
946
 
947 24 jeremybenn
/* The format of the first PLT entry in a VxWorks executable.  */
948 225 jeremybenn
static const bfd_vma mips_vxworks_exec_plt0_entry[] =
949
{
950 24 jeremybenn
  0x3c190000,   /* lui t9, %hi(_GLOBAL_OFFSET_TABLE_)           */
951
  0x27390000,   /* addiu t9, t9, %lo(_GLOBAL_OFFSET_TABLE_)     */
952
  0x8f390008,   /* lw t9, 8(t9)                                 */
953
  0x00000000,   /* nop                                          */
954
  0x03200008,   /* jr t9                                        */
955
  0x00000000    /* nop                                          */
956
};
957
 
958
/* The format of subsequent PLT entries.  */
959 225 jeremybenn
static const bfd_vma mips_vxworks_exec_plt_entry[] =
960
{
961 24 jeremybenn
  0x10000000,   /* b .PLT_resolver                      */
962
  0x24180000,   /* li t8, <pltindex>                    */
963
  0x3c190000,   /* lui t9, %hi(<.got.plt slot>)         */
964
  0x27390000,   /* addiu t9, t9, %lo(<.got.plt slot>)   */
965
  0x8f390000,   /* lw t9, 0(t9)                         */
966
  0x00000000,   /* nop                                  */
967
  0x03200008,   /* jr t9                                */
968
  0x00000000    /* nop                                  */
969
};
970
 
971
/* The format of the first PLT entry in a VxWorks shared object.  */
972 225 jeremybenn
static const bfd_vma mips_vxworks_shared_plt0_entry[] =
973
{
974 24 jeremybenn
  0x8f990008,   /* lw t9, 8(gp)         */
975
  0x00000000,   /* nop                  */
976
  0x03200008,   /* jr t9                */
977
  0x00000000,   /* nop                  */
978
  0x00000000,   /* nop                  */
979
  0x00000000    /* nop                  */
980
};
981
 
982
/* The format of subsequent PLT entries.  */
983 225 jeremybenn
static const bfd_vma mips_vxworks_shared_plt_entry[] =
984
{
985 24 jeremybenn
  0x10000000,   /* b .PLT_resolver      */
986
  0x24180000    /* li t8, <pltindex>    */
987
};
988
 
989
/* Look up an entry in a MIPS ELF linker hash table.  */
990
 
991
#define mips_elf_link_hash_lookup(table, string, create, copy, follow)  \
992
  ((struct mips_elf_link_hash_entry *)                                  \
993
   elf_link_hash_lookup (&(table)->root, (string), (create),            \
994
                         (copy), (follow)))
995
 
996
/* Traverse a MIPS ELF linker hash table.  */
997
 
998
#define mips_elf_link_hash_traverse(table, func, info)                  \
999
  (elf_link_hash_traverse                                               \
1000
   (&(table)->root,                                                     \
1001
    (bfd_boolean (*) (struct elf_link_hash_entry *, void *)) (func),    \
1002
    (info)))
1003
 
1004
/* Get the MIPS ELF linker hash table from a link_info structure.  */
1005
 
1006
#define mips_elf_hash_table(p) \
1007
  ((struct mips_elf_link_hash_table *) ((p)->hash))
1008
 
1009
/* Find the base offsets for thread-local storage in this object,
1010
   for GD/LD and IE/LE respectively.  */
1011
 
1012
#define TP_OFFSET 0x7000
1013
#define DTP_OFFSET 0x8000
1014
 
1015
static bfd_vma
1016
dtprel_base (struct bfd_link_info *info)
1017
{
1018
  /* If tls_sec is NULL, we should have signalled an error already.  */
1019
  if (elf_hash_table (info)->tls_sec == NULL)
1020
    return 0;
1021
  return elf_hash_table (info)->tls_sec->vma + DTP_OFFSET;
1022
}
1023
 
1024
static bfd_vma
1025
tprel_base (struct bfd_link_info *info)
1026
{
1027
  /* If tls_sec is NULL, we should have signalled an error already.  */
1028
  if (elf_hash_table (info)->tls_sec == NULL)
1029
    return 0;
1030
  return elf_hash_table (info)->tls_sec->vma + TP_OFFSET;
1031
}
1032
 
1033
/* Create an entry in a MIPS ELF linker hash table.  */
1034
 
1035
static struct bfd_hash_entry *
1036
mips_elf_link_hash_newfunc (struct bfd_hash_entry *entry,
1037
                            struct bfd_hash_table *table, const char *string)
1038
{
1039
  struct mips_elf_link_hash_entry *ret =
1040
    (struct mips_elf_link_hash_entry *) entry;
1041
 
1042
  /* Allocate the structure if it has not already been allocated by a
1043
     subclass.  */
1044
  if (ret == NULL)
1045
    ret = bfd_hash_allocate (table, sizeof (struct mips_elf_link_hash_entry));
1046
  if (ret == NULL)
1047
    return (struct bfd_hash_entry *) ret;
1048
 
1049
  /* Call the allocation method of the superclass.  */
1050
  ret = ((struct mips_elf_link_hash_entry *)
1051
         _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
1052
                                     table, string));
1053
  if (ret != NULL)
1054
    {
1055
      /* Set local fields.  */
1056
      memset (&ret->esym, 0, sizeof (EXTR));
1057
      /* We use -2 as a marker to indicate that the information has
1058
         not been set.  -1 means there is no associated ifd.  */
1059
      ret->esym.ifd = -2;
1060 225 jeremybenn
      ret->la25_stub = 0;
1061 24 jeremybenn
      ret->possibly_dynamic_relocs = 0;
1062
      ret->fn_stub = NULL;
1063
      ret->call_stub = NULL;
1064
      ret->call_fp_stub = NULL;
1065
      ret->tls_type = GOT_NORMAL;
1066 225 jeremybenn
      ret->global_got_area = GGA_NONE;
1067
      ret->readonly_reloc = FALSE;
1068
      ret->has_static_relocs = FALSE;
1069
      ret->no_fn_stub = FALSE;
1070
      ret->need_fn_stub = FALSE;
1071
      ret->has_nonpic_branches = FALSE;
1072
      ret->needs_lazy_stub = FALSE;
1073 24 jeremybenn
    }
1074
 
1075
  return (struct bfd_hash_entry *) ret;
1076
}
1077
 
1078
bfd_boolean
1079
_bfd_mips_elf_new_section_hook (bfd *abfd, asection *sec)
1080
{
1081
  if (!sec->used_by_bfd)
1082
    {
1083
      struct _mips_elf_section_data *sdata;
1084
      bfd_size_type amt = sizeof (*sdata);
1085
 
1086
      sdata = bfd_zalloc (abfd, amt);
1087
      if (sdata == NULL)
1088
        return FALSE;
1089
      sec->used_by_bfd = sdata;
1090
    }
1091
 
1092
  return _bfd_elf_new_section_hook (abfd, sec);
1093
}
1094
 
1095
/* Read ECOFF debugging information from a .mdebug section into a
1096
   ecoff_debug_info structure.  */
1097
 
1098
bfd_boolean
1099
_bfd_mips_elf_read_ecoff_info (bfd *abfd, asection *section,
1100
                               struct ecoff_debug_info *debug)
1101
{
1102
  HDRR *symhdr;
1103
  const struct ecoff_debug_swap *swap;
1104
  char *ext_hdr;
1105
 
1106
  swap = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
1107
  memset (debug, 0, sizeof (*debug));
1108
 
1109
  ext_hdr = bfd_malloc (swap->external_hdr_size);
1110
  if (ext_hdr == NULL && swap->external_hdr_size != 0)
1111
    goto error_return;
1112
 
1113
  if (! bfd_get_section_contents (abfd, section, ext_hdr, 0,
1114
                                  swap->external_hdr_size))
1115
    goto error_return;
1116
 
1117
  symhdr = &debug->symbolic_header;
1118
  (*swap->swap_hdr_in) (abfd, ext_hdr, symhdr);
1119
 
1120
  /* The symbolic header contains absolute file offsets and sizes to
1121
     read.  */
1122
#define READ(ptr, offset, count, size, type)                            \
1123
  if (symhdr->count == 0)                                                \
1124
    debug->ptr = NULL;                                                  \
1125
  else                                                                  \
1126
    {                                                                   \
1127
      bfd_size_type amt = (bfd_size_type) size * symhdr->count;         \
1128
      debug->ptr = bfd_malloc (amt);                                    \
1129
      if (debug->ptr == NULL)                                           \
1130
        goto error_return;                                              \
1131
      if (bfd_seek (abfd, symhdr->offset, SEEK_SET) != 0         \
1132
          || bfd_bread (debug->ptr, amt, abfd) != amt)                  \
1133
        goto error_return;                                              \
1134
    }
1135
 
1136
  READ (line, cbLineOffset, cbLine, sizeof (unsigned char), unsigned char *);
1137
  READ (external_dnr, cbDnOffset, idnMax, swap->external_dnr_size, void *);
1138
  READ (external_pdr, cbPdOffset, ipdMax, swap->external_pdr_size, void *);
1139
  READ (external_sym, cbSymOffset, isymMax, swap->external_sym_size, void *);
1140
  READ (external_opt, cbOptOffset, ioptMax, swap->external_opt_size, void *);
1141
  READ (external_aux, cbAuxOffset, iauxMax, sizeof (union aux_ext),
1142
        union aux_ext *);
1143
  READ (ss, cbSsOffset, issMax, sizeof (char), char *);
1144
  READ (ssext, cbSsExtOffset, issExtMax, sizeof (char), char *);
1145
  READ (external_fdr, cbFdOffset, ifdMax, swap->external_fdr_size, void *);
1146
  READ (external_rfd, cbRfdOffset, crfd, swap->external_rfd_size, void *);
1147
  READ (external_ext, cbExtOffset, iextMax, swap->external_ext_size, void *);
1148
#undef READ
1149
 
1150
  debug->fdr = NULL;
1151
 
1152
  return TRUE;
1153
 
1154
 error_return:
1155
  if (ext_hdr != NULL)
1156
    free (ext_hdr);
1157
  if (debug->line != NULL)
1158
    free (debug->line);
1159
  if (debug->external_dnr != NULL)
1160
    free (debug->external_dnr);
1161
  if (debug->external_pdr != NULL)
1162
    free (debug->external_pdr);
1163
  if (debug->external_sym != NULL)
1164
    free (debug->external_sym);
1165
  if (debug->external_opt != NULL)
1166
    free (debug->external_opt);
1167
  if (debug->external_aux != NULL)
1168
    free (debug->external_aux);
1169
  if (debug->ss != NULL)
1170
    free (debug->ss);
1171
  if (debug->ssext != NULL)
1172
    free (debug->ssext);
1173
  if (debug->external_fdr != NULL)
1174
    free (debug->external_fdr);
1175
  if (debug->external_rfd != NULL)
1176
    free (debug->external_rfd);
1177
  if (debug->external_ext != NULL)
1178
    free (debug->external_ext);
1179
  return FALSE;
1180
}
1181
 
1182
/* Swap RPDR (runtime procedure table entry) for output.  */
1183
 
1184
static void
1185
ecoff_swap_rpdr_out (bfd *abfd, const RPDR *in, struct rpdr_ext *ex)
1186
{
1187
  H_PUT_S32 (abfd, in->adr, ex->p_adr);
1188
  H_PUT_32 (abfd, in->regmask, ex->p_regmask);
1189
  H_PUT_32 (abfd, in->regoffset, ex->p_regoffset);
1190
  H_PUT_32 (abfd, in->fregmask, ex->p_fregmask);
1191
  H_PUT_32 (abfd, in->fregoffset, ex->p_fregoffset);
1192
  H_PUT_32 (abfd, in->frameoffset, ex->p_frameoffset);
1193
 
1194
  H_PUT_16 (abfd, in->framereg, ex->p_framereg);
1195
  H_PUT_16 (abfd, in->pcreg, ex->p_pcreg);
1196
 
1197
  H_PUT_32 (abfd, in->irpss, ex->p_irpss);
1198
}
1199
 
1200
/* Create a runtime procedure table from the .mdebug section.  */
1201
 
1202
static bfd_boolean
1203
mips_elf_create_procedure_table (void *handle, bfd *abfd,
1204
                                 struct bfd_link_info *info, asection *s,
1205
                                 struct ecoff_debug_info *debug)
1206
{
1207
  const struct ecoff_debug_swap *swap;
1208
  HDRR *hdr = &debug->symbolic_header;
1209
  RPDR *rpdr, *rp;
1210
  struct rpdr_ext *erp;
1211
  void *rtproc;
1212
  struct pdr_ext *epdr;
1213
  struct sym_ext *esym;
1214
  char *ss, **sv;
1215
  char *str;
1216
  bfd_size_type size;
1217
  bfd_size_type count;
1218
  unsigned long sindex;
1219
  unsigned long i;
1220
  PDR pdr;
1221
  SYMR sym;
1222
  const char *no_name_func = _("static procedure (no name)");
1223
 
1224
  epdr = NULL;
1225
  rpdr = NULL;
1226
  esym = NULL;
1227
  ss = NULL;
1228
  sv = NULL;
1229
 
1230
  swap = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
1231
 
1232
  sindex = strlen (no_name_func) + 1;
1233
  count = hdr->ipdMax;
1234
  if (count > 0)
1235
    {
1236
      size = swap->external_pdr_size;
1237
 
1238
      epdr = bfd_malloc (size * count);
1239
      if (epdr == NULL)
1240
        goto error_return;
1241
 
1242
      if (! _bfd_ecoff_get_accumulated_pdr (handle, (bfd_byte *) epdr))
1243
        goto error_return;
1244
 
1245
      size = sizeof (RPDR);
1246
      rp = rpdr = bfd_malloc (size * count);
1247
      if (rpdr == NULL)
1248
        goto error_return;
1249
 
1250
      size = sizeof (char *);
1251
      sv = bfd_malloc (size * count);
1252
      if (sv == NULL)
1253
        goto error_return;
1254
 
1255
      count = hdr->isymMax;
1256
      size = swap->external_sym_size;
1257
      esym = bfd_malloc (size * count);
1258
      if (esym == NULL)
1259
        goto error_return;
1260
 
1261
      if (! _bfd_ecoff_get_accumulated_sym (handle, (bfd_byte *) esym))
1262
        goto error_return;
1263
 
1264
      count = hdr->issMax;
1265
      ss = bfd_malloc (count);
1266
      if (ss == NULL)
1267
        goto error_return;
1268
      if (! _bfd_ecoff_get_accumulated_ss (handle, (bfd_byte *) ss))
1269
        goto error_return;
1270
 
1271
      count = hdr->ipdMax;
1272
      for (i = 0; i < (unsigned long) count; i++, rp++)
1273
        {
1274
          (*swap->swap_pdr_in) (abfd, epdr + i, &pdr);
1275
          (*swap->swap_sym_in) (abfd, &esym[pdr.isym], &sym);
1276
          rp->adr = sym.value;
1277
          rp->regmask = pdr.regmask;
1278
          rp->regoffset = pdr.regoffset;
1279
          rp->fregmask = pdr.fregmask;
1280
          rp->fregoffset = pdr.fregoffset;
1281
          rp->frameoffset = pdr.frameoffset;
1282
          rp->framereg = pdr.framereg;
1283
          rp->pcreg = pdr.pcreg;
1284
          rp->irpss = sindex;
1285
          sv[i] = ss + sym.iss;
1286
          sindex += strlen (sv[i]) + 1;
1287
        }
1288
    }
1289
 
1290
  size = sizeof (struct rpdr_ext) * (count + 2) + sindex;
1291
  size = BFD_ALIGN (size, 16);
1292
  rtproc = bfd_alloc (abfd, size);
1293
  if (rtproc == NULL)
1294
    {
1295
      mips_elf_hash_table (info)->procedure_count = 0;
1296
      goto error_return;
1297
    }
1298
 
1299
  mips_elf_hash_table (info)->procedure_count = count + 2;
1300
 
1301
  erp = rtproc;
1302
  memset (erp, 0, sizeof (struct rpdr_ext));
1303
  erp++;
1304
  str = (char *) rtproc + sizeof (struct rpdr_ext) * (count + 2);
1305
  strcpy (str, no_name_func);
1306
  str += strlen (no_name_func) + 1;
1307
  for (i = 0; i < count; i++)
1308
    {
1309
      ecoff_swap_rpdr_out (abfd, rpdr + i, erp + i);
1310
      strcpy (str, sv[i]);
1311
      str += strlen (sv[i]) + 1;
1312
    }
1313
  H_PUT_S32 (abfd, -1, (erp + count)->p_adr);
1314
 
1315
  /* Set the size and contents of .rtproc section.  */
1316
  s->size = size;
1317
  s->contents = rtproc;
1318
 
1319
  /* Skip this section later on (I don't think this currently
1320
     matters, but someday it might).  */
1321
  s->map_head.link_order = NULL;
1322
 
1323
  if (epdr != NULL)
1324
    free (epdr);
1325
  if (rpdr != NULL)
1326
    free (rpdr);
1327
  if (esym != NULL)
1328
    free (esym);
1329
  if (ss != NULL)
1330
    free (ss);
1331
  if (sv != NULL)
1332
    free (sv);
1333
 
1334
  return TRUE;
1335
 
1336
 error_return:
1337
  if (epdr != NULL)
1338
    free (epdr);
1339
  if (rpdr != NULL)
1340
    free (rpdr);
1341
  if (esym != NULL)
1342
    free (esym);
1343
  if (ss != NULL)
1344
    free (ss);
1345
  if (sv != NULL)
1346
    free (sv);
1347
  return FALSE;
1348
}
1349 225 jeremybenn
 
1350
/* We're going to create a stub for H.  Create a symbol for the stub's
1351
   value and size, to help make the disassembly easier to read.  */
1352 24 jeremybenn
 
1353 225 jeremybenn
static bfd_boolean
1354
mips_elf_create_stub_symbol (struct bfd_link_info *info,
1355
                             struct mips_elf_link_hash_entry *h,
1356
                             const char *prefix, asection *s, bfd_vma value,
1357
                             bfd_vma size)
1358
{
1359
  struct bfd_link_hash_entry *bh;
1360
  struct elf_link_hash_entry *elfh;
1361
  const char *name;
1362
 
1363
  /* Create a new symbol.  */
1364
  name = ACONCAT ((prefix, h->root.root.root.string, NULL));
1365
  bh = NULL;
1366
  if (!_bfd_generic_link_add_one_symbol (info, s->owner, name,
1367
                                         BSF_LOCAL, s, value, NULL,
1368
                                         TRUE, FALSE, &bh))
1369
    return FALSE;
1370
 
1371
  /* Make it a local function.  */
1372
  elfh = (struct elf_link_hash_entry *) bh;
1373
  elfh->type = ELF_ST_INFO (STB_LOCAL, STT_FUNC);
1374
  elfh->size = size;
1375
  elfh->forced_local = 1;
1376
  return TRUE;
1377
}
1378
 
1379
/* We're about to redefine H.  Create a symbol to represent H's
1380
   current value and size, to help make the disassembly easier
1381
   to read.  */
1382
 
1383
static bfd_boolean
1384
mips_elf_create_shadow_symbol (struct bfd_link_info *info,
1385
                               struct mips_elf_link_hash_entry *h,
1386
                               const char *prefix)
1387
{
1388
  struct bfd_link_hash_entry *bh;
1389
  struct elf_link_hash_entry *elfh;
1390
  const char *name;
1391
  asection *s;
1392
  bfd_vma value;
1393
 
1394
  /* Read the symbol's value.  */
1395
  BFD_ASSERT (h->root.root.type == bfd_link_hash_defined
1396
              || h->root.root.type == bfd_link_hash_defweak);
1397
  s = h->root.root.u.def.section;
1398
  value = h->root.root.u.def.value;
1399
 
1400
  /* Create a new symbol.  */
1401
  name = ACONCAT ((prefix, h->root.root.root.string, NULL));
1402
  bh = NULL;
1403
  if (!_bfd_generic_link_add_one_symbol (info, s->owner, name,
1404
                                         BSF_LOCAL, s, value, NULL,
1405
                                         TRUE, FALSE, &bh))
1406
    return FALSE;
1407
 
1408
  /* Make it local and copy the other attributes from H.  */
1409
  elfh = (struct elf_link_hash_entry *) bh;
1410
  elfh->type = ELF_ST_INFO (STB_LOCAL, ELF_ST_TYPE (h->root.type));
1411
  elfh->other = h->root.other;
1412
  elfh->size = h->root.size;
1413
  elfh->forced_local = 1;
1414
  return TRUE;
1415
}
1416
 
1417
/* Return TRUE if relocations in SECTION can refer directly to a MIPS16
1418
   function rather than to a hard-float stub.  */
1419
 
1420
static bfd_boolean
1421
section_allows_mips16_refs_p (asection *section)
1422
{
1423
  const char *name;
1424
 
1425
  name = bfd_get_section_name (section->owner, section);
1426
  return (FN_STUB_P (name)
1427
          || CALL_STUB_P (name)
1428
          || CALL_FP_STUB_P (name)
1429
          || strcmp (name, ".pdr") == 0);
1430
}
1431
 
1432
/* [RELOCS, RELEND) are the relocations against SEC, which is a MIPS16
1433
   stub section of some kind.  Return the R_SYMNDX of the target
1434
   function, or 0 if we can't decide which function that is.  */
1435
 
1436
static unsigned long
1437
mips16_stub_symndx (asection *sec ATTRIBUTE_UNUSED,
1438
                    const Elf_Internal_Rela *relocs,
1439
                    const Elf_Internal_Rela *relend)
1440
{
1441
  const Elf_Internal_Rela *rel;
1442
 
1443
  /* Trust the first R_MIPS_NONE relocation, if any.  */
1444
  for (rel = relocs; rel < relend; rel++)
1445
    if (ELF_R_TYPE (sec->owner, rel->r_info) == R_MIPS_NONE)
1446
      return ELF_R_SYM (sec->owner, rel->r_info);
1447
 
1448
  /* Otherwise trust the first relocation, whatever its kind.  This is
1449
     the traditional behavior.  */
1450
  if (relocs < relend)
1451
    return ELF_R_SYM (sec->owner, relocs->r_info);
1452
 
1453
  return 0;
1454
}
1455
 
1456 24 jeremybenn
/* Check the mips16 stubs for a particular symbol, and see if we can
1457
   discard them.  */
1458
 
1459 225 jeremybenn
static void
1460
mips_elf_check_mips16_stubs (struct bfd_link_info *info,
1461
                             struct mips_elf_link_hash_entry *h)
1462 24 jeremybenn
{
1463 225 jeremybenn
  /* Dynamic symbols must use the standard call interface, in case other
1464
     objects try to call them.  */
1465
  if (h->fn_stub != NULL
1466
      && h->root.dynindx != -1)
1467
    {
1468
      mips_elf_create_shadow_symbol (info, h, ".mips16.");
1469
      h->need_fn_stub = TRUE;
1470
    }
1471 24 jeremybenn
 
1472
  if (h->fn_stub != NULL
1473
      && ! h->need_fn_stub)
1474
    {
1475
      /* We don't need the fn_stub; the only references to this symbol
1476
         are 16 bit calls.  Clobber the size to 0 to prevent it from
1477
         being included in the link.  */
1478
      h->fn_stub->size = 0;
1479
      h->fn_stub->flags &= ~SEC_RELOC;
1480
      h->fn_stub->reloc_count = 0;
1481
      h->fn_stub->flags |= SEC_EXCLUDE;
1482
    }
1483
 
1484
  if (h->call_stub != NULL
1485 225 jeremybenn
      && ELF_ST_IS_MIPS16 (h->root.other))
1486 24 jeremybenn
    {
1487
      /* We don't need the call_stub; this is a 16 bit function, so
1488
         calls from other 16 bit functions are OK.  Clobber the size
1489
         to 0 to prevent it from being included in the link.  */
1490
      h->call_stub->size = 0;
1491
      h->call_stub->flags &= ~SEC_RELOC;
1492
      h->call_stub->reloc_count = 0;
1493
      h->call_stub->flags |= SEC_EXCLUDE;
1494
    }
1495
 
1496
  if (h->call_fp_stub != NULL
1497 225 jeremybenn
      && ELF_ST_IS_MIPS16 (h->root.other))
1498 24 jeremybenn
    {
1499
      /* We don't need the call_stub; this is a 16 bit function, so
1500
         calls from other 16 bit functions are OK.  Clobber the size
1501
         to 0 to prevent it from being included in the link.  */
1502
      h->call_fp_stub->size = 0;
1503
      h->call_fp_stub->flags &= ~SEC_RELOC;
1504
      h->call_fp_stub->reloc_count = 0;
1505
      h->call_fp_stub->flags |= SEC_EXCLUDE;
1506
    }
1507 225 jeremybenn
}
1508 24 jeremybenn
 
1509 225 jeremybenn
/* Hashtable callbacks for mips_elf_la25_stubs.  */
1510
 
1511
static hashval_t
1512
mips_elf_la25_stub_hash (const void *entry_)
1513
{
1514
  const struct mips_elf_la25_stub *entry;
1515
 
1516
  entry = (struct mips_elf_la25_stub *) entry_;
1517
  return entry->h->root.root.u.def.section->id
1518
    + entry->h->root.root.u.def.value;
1519
}
1520
 
1521
static int
1522
mips_elf_la25_stub_eq (const void *entry1_, const void *entry2_)
1523
{
1524
  const struct mips_elf_la25_stub *entry1, *entry2;
1525
 
1526
  entry1 = (struct mips_elf_la25_stub *) entry1_;
1527
  entry2 = (struct mips_elf_la25_stub *) entry2_;
1528
  return ((entry1->h->root.root.u.def.section
1529
           == entry2->h->root.root.u.def.section)
1530
          && (entry1->h->root.root.u.def.value
1531
              == entry2->h->root.root.u.def.value));
1532
}
1533
 
1534
/* Called by the linker to set up the la25 stub-creation code.  FN is
1535
   the linker's implementation of add_stub_function.  Return true on
1536
   success.  */
1537
 
1538
bfd_boolean
1539
_bfd_mips_elf_init_stubs (struct bfd_link_info *info,
1540
                          asection *(*fn) (const char *, asection *,
1541
                                           asection *))
1542
{
1543
  struct mips_elf_link_hash_table *htab;
1544
 
1545
  htab = mips_elf_hash_table (info);
1546
  htab->add_stub_section = fn;
1547
  htab->la25_stubs = htab_try_create (1, mips_elf_la25_stub_hash,
1548
                                      mips_elf_la25_stub_eq, NULL);
1549
  if (htab->la25_stubs == NULL)
1550
    return FALSE;
1551
 
1552 24 jeremybenn
  return TRUE;
1553
}
1554 225 jeremybenn
 
1555
/* Return true if H is a locally-defined PIC function, in the sense
1556
   that it might need $25 to be valid on entry.  Note that MIPS16
1557
   functions never need $25 to be valid on entry; they set up $gp
1558
   using PC-relative instructions instead.  */
1559
 
1560
static bfd_boolean
1561
mips_elf_local_pic_function_p (struct mips_elf_link_hash_entry *h)
1562
{
1563
  return ((h->root.root.type == bfd_link_hash_defined
1564
           || h->root.root.type == bfd_link_hash_defweak)
1565
          && h->root.def_regular
1566
          && !bfd_is_abs_section (h->root.root.u.def.section)
1567
          && !ELF_ST_IS_MIPS16 (h->root.other)
1568
          && (PIC_OBJECT_P (h->root.root.u.def.section->owner)
1569
              || ELF_ST_IS_MIPS_PIC (h->root.other)));
1570
}
1571
 
1572
/* STUB describes an la25 stub that we have decided to implement
1573
   by inserting an LUI/ADDIU pair before the target function.
1574
   Create the section and redirect the function symbol to it.  */
1575
 
1576
static bfd_boolean
1577
mips_elf_add_la25_intro (struct mips_elf_la25_stub *stub,
1578
                         struct bfd_link_info *info)
1579
{
1580
  struct mips_elf_link_hash_table *htab;
1581
  char *name;
1582
  asection *s, *input_section;
1583
  unsigned int align;
1584
 
1585
  htab = mips_elf_hash_table (info);
1586
 
1587
  /* Create a unique name for the new section.  */
1588
  name = bfd_malloc (11 + sizeof (".text.stub."));
1589
  if (name == NULL)
1590
    return FALSE;
1591
  sprintf (name, ".text.stub.%d", (int) htab_elements (htab->la25_stubs));
1592
 
1593
  /* Create the section.  */
1594
  input_section = stub->h->root.root.u.def.section;
1595
  s = htab->add_stub_section (name, input_section,
1596
                              input_section->output_section);
1597
  if (s == NULL)
1598
    return FALSE;
1599
 
1600
  /* Make sure that any padding goes before the stub.  */
1601
  align = input_section->alignment_power;
1602
  if (!bfd_set_section_alignment (s->owner, s, align))
1603
    return FALSE;
1604
  if (align > 3)
1605
    s->size = (1 << align) - 8;
1606
 
1607
  /* Create a symbol for the stub.  */
1608
  mips_elf_create_stub_symbol (info, stub->h, ".pic.", s, s->size, 8);
1609
  stub->stub_section = s;
1610
  stub->offset = s->size;
1611
 
1612
  /* Allocate room for it.  */
1613
  s->size += 8;
1614
  return TRUE;
1615
}
1616
 
1617
/* STUB describes an la25 stub that we have decided to implement
1618
   with a separate trampoline.  Allocate room for it and redirect
1619
   the function symbol to it.  */
1620
 
1621
static bfd_boolean
1622
mips_elf_add_la25_trampoline (struct mips_elf_la25_stub *stub,
1623
                              struct bfd_link_info *info)
1624
{
1625
  struct mips_elf_link_hash_table *htab;
1626
  asection *s;
1627
 
1628
  htab = mips_elf_hash_table (info);
1629
 
1630
  /* Create a trampoline section, if we haven't already.  */
1631
  s = htab->strampoline;
1632
  if (s == NULL)
1633
    {
1634
      asection *input_section = stub->h->root.root.u.def.section;
1635
      s = htab->add_stub_section (".text", NULL,
1636
                                  input_section->output_section);
1637
      if (s == NULL || !bfd_set_section_alignment (s->owner, s, 4))
1638
        return FALSE;
1639
      htab->strampoline = s;
1640
    }
1641
 
1642
  /* Create a symbol for the stub.  */
1643
  mips_elf_create_stub_symbol (info, stub->h, ".pic.", s, s->size, 16);
1644
  stub->stub_section = s;
1645
  stub->offset = s->size;
1646
 
1647
  /* Allocate room for it.  */
1648
  s->size += 16;
1649
  return TRUE;
1650
}
1651
 
1652
/* H describes a symbol that needs an la25 stub.  Make sure that an
1653
   appropriate stub exists and point H at it.  */
1654
 
1655
static bfd_boolean
1656
mips_elf_add_la25_stub (struct bfd_link_info *info,
1657
                        struct mips_elf_link_hash_entry *h)
1658
{
1659
  struct mips_elf_link_hash_table *htab;
1660
  struct mips_elf_la25_stub search, *stub;
1661
  bfd_boolean use_trampoline_p;
1662
  asection *s;
1663
  bfd_vma value;
1664
  void **slot;
1665
 
1666
  /* Prefer to use LUI/ADDIU stubs if the function is at the beginning
1667
     of the section and if we would need no more than 2 nops.  */
1668
  s = h->root.root.u.def.section;
1669
  value = h->root.root.u.def.value;
1670
  use_trampoline_p = (value != 0 || s->alignment_power > 4);
1671
 
1672
  /* Describe the stub we want.  */
1673
  search.stub_section = NULL;
1674
  search.offset = 0;
1675
  search.h = h;
1676
 
1677
  /* See if we've already created an equivalent stub.  */
1678
  htab = mips_elf_hash_table (info);
1679
  slot = htab_find_slot (htab->la25_stubs, &search, INSERT);
1680
  if (slot == NULL)
1681
    return FALSE;
1682
 
1683
  stub = (struct mips_elf_la25_stub *) *slot;
1684
  if (stub != NULL)
1685
    {
1686
      /* We can reuse the existing stub.  */
1687
      h->la25_stub = stub;
1688
      return TRUE;
1689
    }
1690
 
1691
  /* Create a permanent copy of ENTRY and add it to the hash table.  */
1692
  stub = bfd_malloc (sizeof (search));
1693
  if (stub == NULL)
1694
    return FALSE;
1695
  *stub = search;
1696
  *slot = stub;
1697
 
1698
  h->la25_stub = stub;
1699
  return (use_trampoline_p
1700
          ? mips_elf_add_la25_trampoline (stub, info)
1701
          : mips_elf_add_la25_intro (stub, info));
1702
}
1703
 
1704
/* A mips_elf_link_hash_traverse callback that is called before sizing
1705
   sections.  DATA points to a mips_htab_traverse_info structure.  */
1706
 
1707
static bfd_boolean
1708
mips_elf_check_symbols (struct mips_elf_link_hash_entry *h, void *data)
1709
{
1710
  struct mips_htab_traverse_info *hti;
1711
 
1712
  hti = (struct mips_htab_traverse_info *) data;
1713
  if (h->root.root.type == bfd_link_hash_warning)
1714
    h = (struct mips_elf_link_hash_entry *) h->root.root.u.i.link;
1715
 
1716
  if (!hti->info->relocatable)
1717
    mips_elf_check_mips16_stubs (hti->info, h);
1718
 
1719
  if (mips_elf_local_pic_function_p (h))
1720
    {
1721
      /* H is a function that might need $25 to be valid on entry.
1722
         If we're creating a non-PIC relocatable object, mark H as
1723
         being PIC.  If we're creating a non-relocatable object with
1724
         non-PIC branches and jumps to H, make sure that H has an la25
1725
         stub.  */
1726
      if (hti->info->relocatable)
1727
        {
1728
          if (!PIC_OBJECT_P (hti->output_bfd))
1729
            h->root.other = ELF_ST_SET_MIPS_PIC (h->root.other);
1730
        }
1731
      else if (h->has_nonpic_branches && !mips_elf_add_la25_stub (hti->info, h))
1732
        {
1733
          hti->error = TRUE;
1734
          return FALSE;
1735
        }
1736
    }
1737
  return TRUE;
1738
}
1739 24 jeremybenn
 
1740
/* R_MIPS16_26 is used for the mips16 jal and jalx instructions.
1741
   Most mips16 instructions are 16 bits, but these instructions
1742
   are 32 bits.
1743
 
1744
   The format of these instructions is:
1745
 
1746
   +--------------+--------------------------------+
1747
   |     JALX     | X|   Imm 20:16  |   Imm 25:21  |
1748
   +--------------+--------------------------------+
1749
   |                Immediate  15:0                |
1750
   +-----------------------------------------------+
1751
 
1752
   JALX is the 5-bit value 00011.  X is 0 for jal, 1 for jalx.
1753
   Note that the immediate value in the first word is swapped.
1754
 
1755
   When producing a relocatable object file, R_MIPS16_26 is
1756
   handled mostly like R_MIPS_26.  In particular, the addend is
1757
   stored as a straight 26-bit value in a 32-bit instruction.
1758
   (gas makes life simpler for itself by never adjusting a
1759
   R_MIPS16_26 reloc to be against a section, so the addend is
1760
   always zero).  However, the 32 bit instruction is stored as 2
1761
   16-bit values, rather than a single 32-bit value.  In a
1762
   big-endian file, the result is the same; in a little-endian
1763
   file, the two 16-bit halves of the 32 bit value are swapped.
1764
   This is so that a disassembler can recognize the jal
1765
   instruction.
1766
 
1767
   When doing a final link, R_MIPS16_26 is treated as a 32 bit
1768
   instruction stored as two 16-bit values.  The addend A is the
1769
   contents of the targ26 field.  The calculation is the same as
1770
   R_MIPS_26.  When storing the calculated value, reorder the
1771
   immediate value as shown above, and don't forget to store the
1772
   value as two 16-bit values.
1773
 
1774
   To put it in MIPS ABI terms, the relocation field is T-targ26-16,
1775
   defined as
1776
 
1777
   big-endian:
1778
   +--------+----------------------+
1779
   |        |                      |
1780
   |        |    targ26-16         |
1781
   |31    26|25                   0|
1782
   +--------+----------------------+
1783
 
1784
   little-endian:
1785
   +----------+------+-------------+
1786
   |          |      |             |
1787
   |  sub1    |      |     sub2    |
1788
   |0        9|10  15|16         31|
1789
   +----------+--------------------+
1790
   where targ26-16 is sub1 followed by sub2 (i.e., the addend field A is
1791
   ((sub1 << 16) | sub2)).
1792
 
1793
   When producing a relocatable object file, the calculation is
1794
   (((A < 2) | ((P + 4) & 0xf0000000) + S) >> 2)
1795
   When producing a fully linked file, the calculation is
1796
   let R = (((A < 2) | ((P + 4) & 0xf0000000) + S) >> 2)
1797
   ((R & 0x1f0000) << 5) | ((R & 0x3e00000) >> 5) | (R & 0xffff)
1798
 
1799 225 jeremybenn
   The table below lists the other MIPS16 instruction relocations.
1800
   Each one is calculated in the same way as the non-MIPS16 relocation
1801
   given on the right, but using the extended MIPS16 layout of 16-bit
1802
   immediate fields:
1803 24 jeremybenn
 
1804 225 jeremybenn
        R_MIPS16_GPREL          R_MIPS_GPREL16
1805
        R_MIPS16_GOT16          R_MIPS_GOT16
1806
        R_MIPS16_CALL16         R_MIPS_CALL16
1807
        R_MIPS16_HI16           R_MIPS_HI16
1808
        R_MIPS16_LO16           R_MIPS_LO16
1809
 
1810
   A typical instruction will have a format like this:
1811
 
1812 24 jeremybenn
   +--------------+--------------------------------+
1813
   |    EXTEND    |     Imm 10:5    |   Imm 15:11  |
1814
   +--------------+--------------------------------+
1815
   |    Major     |   rx   |   ry   |   Imm  4:0   |
1816
   +--------------+--------------------------------+
1817
 
1818
   EXTEND is the five bit value 11110.  Major is the instruction
1819
   opcode.
1820
 
1821 225 jeremybenn
   All we need to do here is shuffle the bits appropriately.
1822
   As above, the two 16-bit halves must be swapped on a
1823
   little-endian system.  */
1824 24 jeremybenn
 
1825 225 jeremybenn
static inline bfd_boolean
1826
mips16_reloc_p (int r_type)
1827
{
1828
  switch (r_type)
1829
    {
1830
    case R_MIPS16_26:
1831
    case R_MIPS16_GPREL:
1832
    case R_MIPS16_GOT16:
1833
    case R_MIPS16_CALL16:
1834
    case R_MIPS16_HI16:
1835
    case R_MIPS16_LO16:
1836
      return TRUE;
1837 24 jeremybenn
 
1838 225 jeremybenn
    default:
1839
      return FALSE;
1840
    }
1841
}
1842
 
1843
static inline bfd_boolean
1844
got16_reloc_p (int r_type)
1845
{
1846
  return r_type == R_MIPS_GOT16 || r_type == R_MIPS16_GOT16;
1847
}
1848
 
1849
static inline bfd_boolean
1850
call16_reloc_p (int r_type)
1851
{
1852
  return r_type == R_MIPS_CALL16 || r_type == R_MIPS16_CALL16;
1853
}
1854
 
1855
static inline bfd_boolean
1856
hi16_reloc_p (int r_type)
1857
{
1858
  return r_type == R_MIPS_HI16 || r_type == R_MIPS16_HI16;
1859
}
1860
 
1861
static inline bfd_boolean
1862
lo16_reloc_p (int r_type)
1863
{
1864
  return r_type == R_MIPS_LO16 || r_type == R_MIPS16_LO16;
1865
}
1866
 
1867
static inline bfd_boolean
1868
mips16_call_reloc_p (int r_type)
1869
{
1870
  return r_type == R_MIPS16_26 || r_type == R_MIPS16_CALL16;
1871
}
1872
 
1873 24 jeremybenn
void
1874
_bfd_mips16_elf_reloc_unshuffle (bfd *abfd, int r_type,
1875
                                 bfd_boolean jal_shuffle, bfd_byte *data)
1876
{
1877
  bfd_vma extend, insn, val;
1878
 
1879 225 jeremybenn
  if (!mips16_reloc_p (r_type))
1880 24 jeremybenn
    return;
1881
 
1882
  /* Pick up the mips16 extend instruction and the real instruction.  */
1883
  extend = bfd_get_16 (abfd, data);
1884
  insn = bfd_get_16 (abfd, data + 2);
1885
  if (r_type == R_MIPS16_26)
1886
    {
1887
      if (jal_shuffle)
1888
        val = ((extend & 0xfc00) << 16) | ((extend & 0x3e0) << 11)
1889
              | ((extend & 0x1f) << 21) | insn;
1890
      else
1891
        val = extend << 16 | insn;
1892
    }
1893
  else
1894
    val = ((extend & 0xf800) << 16) | ((insn & 0xffe0) << 11)
1895
          | ((extend & 0x1f) << 11) | (extend & 0x7e0) | (insn & 0x1f);
1896
  bfd_put_32 (abfd, val, data);
1897
}
1898
 
1899
void
1900
_bfd_mips16_elf_reloc_shuffle (bfd *abfd, int r_type,
1901
                               bfd_boolean jal_shuffle, bfd_byte *data)
1902
{
1903
  bfd_vma extend, insn, val;
1904
 
1905 225 jeremybenn
  if (!mips16_reloc_p (r_type))
1906 24 jeremybenn
    return;
1907
 
1908
  val = bfd_get_32 (abfd, data);
1909
  if (r_type == R_MIPS16_26)
1910
    {
1911
      if (jal_shuffle)
1912
        {
1913
          insn = val & 0xffff;
1914
          extend = ((val >> 16) & 0xfc00) | ((val >> 11) & 0x3e0)
1915
                   | ((val >> 21) & 0x1f);
1916
        }
1917
      else
1918
        {
1919
          insn = val & 0xffff;
1920
          extend = val >> 16;
1921
        }
1922
    }
1923
  else
1924
    {
1925
      insn = ((val >> 11) & 0xffe0) | (val & 0x1f);
1926
      extend = ((val >> 16) & 0xf800) | ((val >> 11) & 0x1f) | (val & 0x7e0);
1927
    }
1928
  bfd_put_16 (abfd, insn, data + 2);
1929
  bfd_put_16 (abfd, extend, data);
1930
}
1931
 
1932
bfd_reloc_status_type
1933
_bfd_mips_elf_gprel16_with_gp (bfd *abfd, asymbol *symbol,
1934
                               arelent *reloc_entry, asection *input_section,
1935
                               bfd_boolean relocatable, void *data, bfd_vma gp)
1936
{
1937
  bfd_vma relocation;
1938
  bfd_signed_vma val;
1939
  bfd_reloc_status_type status;
1940
 
1941
  if (bfd_is_com_section (symbol->section))
1942
    relocation = 0;
1943
  else
1944
    relocation = symbol->value;
1945
 
1946
  relocation += symbol->section->output_section->vma;
1947
  relocation += symbol->section->output_offset;
1948
 
1949
  if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
1950
    return bfd_reloc_outofrange;
1951
 
1952
  /* Set val to the offset into the section or symbol.  */
1953
  val = reloc_entry->addend;
1954
 
1955
  _bfd_mips_elf_sign_extend (val, 16);
1956
 
1957
  /* Adjust val for the final section location and GP value.  If we
1958
     are producing relocatable output, we don't want to do this for
1959
     an external symbol.  */
1960
  if (! relocatable
1961
      || (symbol->flags & BSF_SECTION_SYM) != 0)
1962
    val += relocation - gp;
1963
 
1964
  if (reloc_entry->howto->partial_inplace)
1965
    {
1966
      status = _bfd_relocate_contents (reloc_entry->howto, abfd, val,
1967
                                       (bfd_byte *) data
1968
                                       + reloc_entry->address);
1969
      if (status != bfd_reloc_ok)
1970
        return status;
1971
    }
1972
  else
1973
    reloc_entry->addend = val;
1974
 
1975
  if (relocatable)
1976
    reloc_entry->address += input_section->output_offset;
1977
 
1978
  return bfd_reloc_ok;
1979
}
1980
 
1981
/* Used to store a REL high-part relocation such as R_MIPS_HI16 or
1982
   R_MIPS_GOT16.  REL is the relocation, INPUT_SECTION is the section
1983
   that contains the relocation field and DATA points to the start of
1984
   INPUT_SECTION.  */
1985
 
1986
struct mips_hi16
1987
{
1988
  struct mips_hi16 *next;
1989
  bfd_byte *data;
1990
  asection *input_section;
1991
  arelent rel;
1992
};
1993
 
1994
/* FIXME: This should not be a static variable.  */
1995
 
1996
static struct mips_hi16 *mips_hi16_list;
1997
 
1998
/* A howto special_function for REL *HI16 relocations.  We can only
1999
   calculate the correct value once we've seen the partnering
2000
   *LO16 relocation, so just save the information for later.
2001
 
2002
   The ABI requires that the *LO16 immediately follow the *HI16.
2003
   However, as a GNU extension, we permit an arbitrary number of
2004
   *HI16s to be associated with a single *LO16.  This significantly
2005
   simplies the relocation handling in gcc.  */
2006
 
2007
bfd_reloc_status_type
2008
_bfd_mips_elf_hi16_reloc (bfd *abfd ATTRIBUTE_UNUSED, arelent *reloc_entry,
2009
                          asymbol *symbol ATTRIBUTE_UNUSED, void *data,
2010
                          asection *input_section, bfd *output_bfd,
2011
                          char **error_message ATTRIBUTE_UNUSED)
2012
{
2013
  struct mips_hi16 *n;
2014
 
2015
  if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
2016
    return bfd_reloc_outofrange;
2017
 
2018
  n = bfd_malloc (sizeof *n);
2019
  if (n == NULL)
2020
    return bfd_reloc_outofrange;
2021
 
2022
  n->next = mips_hi16_list;
2023
  n->data = data;
2024
  n->input_section = input_section;
2025
  n->rel = *reloc_entry;
2026
  mips_hi16_list = n;
2027
 
2028
  if (output_bfd != NULL)
2029
    reloc_entry->address += input_section->output_offset;
2030
 
2031
  return bfd_reloc_ok;
2032
}
2033
 
2034 225 jeremybenn
/* A howto special_function for REL R_MIPS*_GOT16 relocations.  This is just
2035 24 jeremybenn
   like any other 16-bit relocation when applied to global symbols, but is
2036
   treated in the same as R_MIPS_HI16 when applied to local symbols.  */
2037
 
2038
bfd_reloc_status_type
2039
_bfd_mips_elf_got16_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2040
                           void *data, asection *input_section,
2041
                           bfd *output_bfd, char **error_message)
2042
{
2043
  if ((symbol->flags & (BSF_GLOBAL | BSF_WEAK)) != 0
2044
      || bfd_is_und_section (bfd_get_section (symbol))
2045
      || bfd_is_com_section (bfd_get_section (symbol)))
2046
    /* The relocation is against a global symbol.  */
2047
    return _bfd_mips_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2048
                                        input_section, output_bfd,
2049
                                        error_message);
2050
 
2051
  return _bfd_mips_elf_hi16_reloc (abfd, reloc_entry, symbol, data,
2052
                                   input_section, output_bfd, error_message);
2053
}
2054
 
2055
/* A howto special_function for REL *LO16 relocations.  The *LO16 itself
2056
   is a straightforward 16 bit inplace relocation, but we must deal with
2057
   any partnering high-part relocations as well.  */
2058
 
2059
bfd_reloc_status_type
2060
_bfd_mips_elf_lo16_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2061
                          void *data, asection *input_section,
2062
                          bfd *output_bfd, char **error_message)
2063
{
2064
  bfd_vma vallo;
2065
  bfd_byte *location = (bfd_byte *) data + reloc_entry->address;
2066
 
2067
  if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
2068
    return bfd_reloc_outofrange;
2069
 
2070
  _bfd_mips16_elf_reloc_unshuffle (abfd, reloc_entry->howto->type, FALSE,
2071
                                   location);
2072
  vallo = bfd_get_32 (abfd, location);
2073
  _bfd_mips16_elf_reloc_shuffle (abfd, reloc_entry->howto->type, FALSE,
2074
                                 location);
2075
 
2076
  while (mips_hi16_list != NULL)
2077
    {
2078
      bfd_reloc_status_type ret;
2079
      struct mips_hi16 *hi;
2080
 
2081
      hi = mips_hi16_list;
2082
 
2083 225 jeremybenn
      /* R_MIPS*_GOT16 relocations are something of a special case.  We
2084
         want to install the addend in the same way as for a R_MIPS*_HI16
2085 24 jeremybenn
         relocation (with a rightshift of 16).  However, since GOT16
2086
         relocations can also be used with global symbols, their howto
2087
         has a rightshift of 0.  */
2088
      if (hi->rel.howto->type == R_MIPS_GOT16)
2089
        hi->rel.howto = MIPS_ELF_RTYPE_TO_HOWTO (abfd, R_MIPS_HI16, FALSE);
2090 225 jeremybenn
      else if (hi->rel.howto->type == R_MIPS16_GOT16)
2091
        hi->rel.howto = MIPS_ELF_RTYPE_TO_HOWTO (abfd, R_MIPS16_HI16, FALSE);
2092 24 jeremybenn
 
2093
      /* VALLO is a signed 16-bit number.  Bias it by 0x8000 so that any
2094
         carry or borrow will induce a change of +1 or -1 in the high part.  */
2095
      hi->rel.addend += (vallo + 0x8000) & 0xffff;
2096
 
2097
      ret = _bfd_mips_elf_generic_reloc (abfd, &hi->rel, symbol, hi->data,
2098
                                         hi->input_section, output_bfd,
2099
                                         error_message);
2100
      if (ret != bfd_reloc_ok)
2101
        return ret;
2102
 
2103
      mips_hi16_list = hi->next;
2104
      free (hi);
2105
    }
2106
 
2107
  return _bfd_mips_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2108
                                      input_section, output_bfd,
2109
                                      error_message);
2110
}
2111
 
2112
/* A generic howto special_function.  This calculates and installs the
2113
   relocation itself, thus avoiding the oft-discussed problems in
2114
   bfd_perform_relocation and bfd_install_relocation.  */
2115
 
2116
bfd_reloc_status_type
2117
_bfd_mips_elf_generic_reloc (bfd *abfd ATTRIBUTE_UNUSED, arelent *reloc_entry,
2118
                             asymbol *symbol, void *data ATTRIBUTE_UNUSED,
2119
                             asection *input_section, bfd *output_bfd,
2120
                             char **error_message ATTRIBUTE_UNUSED)
2121
{
2122
  bfd_signed_vma val;
2123
  bfd_reloc_status_type status;
2124
  bfd_boolean relocatable;
2125
 
2126
  relocatable = (output_bfd != NULL);
2127
 
2128
  if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
2129
    return bfd_reloc_outofrange;
2130
 
2131
  /* Build up the field adjustment in VAL.  */
2132
  val = 0;
2133
  if (!relocatable || (symbol->flags & BSF_SECTION_SYM) != 0)
2134
    {
2135
      /* Either we're calculating the final field value or we have a
2136
         relocation against a section symbol.  Add in the section's
2137
         offset or address.  */
2138
      val += symbol->section->output_section->vma;
2139
      val += symbol->section->output_offset;
2140
    }
2141
 
2142
  if (!relocatable)
2143
    {
2144
      /* We're calculating the final field value.  Add in the symbol's value
2145
         and, if pc-relative, subtract the address of the field itself.  */
2146
      val += symbol->value;
2147
      if (reloc_entry->howto->pc_relative)
2148
        {
2149
          val -= input_section->output_section->vma;
2150
          val -= input_section->output_offset;
2151
          val -= reloc_entry->address;
2152
        }
2153
    }
2154
 
2155
  /* VAL is now the final adjustment.  If we're keeping this relocation
2156
     in the output file, and if the relocation uses a separate addend,
2157
     we just need to add VAL to that addend.  Otherwise we need to add
2158
     VAL to the relocation field itself.  */
2159
  if (relocatable && !reloc_entry->howto->partial_inplace)
2160
    reloc_entry->addend += val;
2161
  else
2162
    {
2163
      bfd_byte *location = (bfd_byte *) data + reloc_entry->address;
2164
 
2165
      /* Add in the separate addend, if any.  */
2166
      val += reloc_entry->addend;
2167
 
2168
      /* Add VAL to the relocation field.  */
2169
      _bfd_mips16_elf_reloc_unshuffle (abfd, reloc_entry->howto->type, FALSE,
2170
                                       location);
2171
      status = _bfd_relocate_contents (reloc_entry->howto, abfd, val,
2172
                                       location);
2173
      _bfd_mips16_elf_reloc_shuffle (abfd, reloc_entry->howto->type, FALSE,
2174
                                     location);
2175
 
2176
      if (status != bfd_reloc_ok)
2177
        return status;
2178
    }
2179
 
2180
  if (relocatable)
2181
    reloc_entry->address += input_section->output_offset;
2182
 
2183
  return bfd_reloc_ok;
2184
}
2185
 
2186
/* Swap an entry in a .gptab section.  Note that these routines rely
2187
   on the equivalence of the two elements of the union.  */
2188
 
2189
static void
2190
bfd_mips_elf32_swap_gptab_in (bfd *abfd, const Elf32_External_gptab *ex,
2191
                              Elf32_gptab *in)
2192
{
2193
  in->gt_entry.gt_g_value = H_GET_32 (abfd, ex->gt_entry.gt_g_value);
2194
  in->gt_entry.gt_bytes = H_GET_32 (abfd, ex->gt_entry.gt_bytes);
2195
}
2196
 
2197
static void
2198
bfd_mips_elf32_swap_gptab_out (bfd *abfd, const Elf32_gptab *in,
2199
                               Elf32_External_gptab *ex)
2200
{
2201
  H_PUT_32 (abfd, in->gt_entry.gt_g_value, ex->gt_entry.gt_g_value);
2202
  H_PUT_32 (abfd, in->gt_entry.gt_bytes, ex->gt_entry.gt_bytes);
2203
}
2204
 
2205
static void
2206
bfd_elf32_swap_compact_rel_out (bfd *abfd, const Elf32_compact_rel *in,
2207
                                Elf32_External_compact_rel *ex)
2208
{
2209
  H_PUT_32 (abfd, in->id1, ex->id1);
2210
  H_PUT_32 (abfd, in->num, ex->num);
2211
  H_PUT_32 (abfd, in->id2, ex->id2);
2212
  H_PUT_32 (abfd, in->offset, ex->offset);
2213
  H_PUT_32 (abfd, in->reserved0, ex->reserved0);
2214
  H_PUT_32 (abfd, in->reserved1, ex->reserved1);
2215
}
2216
 
2217
static void
2218
bfd_elf32_swap_crinfo_out (bfd *abfd, const Elf32_crinfo *in,
2219
                           Elf32_External_crinfo *ex)
2220
{
2221
  unsigned long l;
2222
 
2223
  l = (((in->ctype & CRINFO_CTYPE) << CRINFO_CTYPE_SH)
2224
       | ((in->rtype & CRINFO_RTYPE) << CRINFO_RTYPE_SH)
2225
       | ((in->dist2to & CRINFO_DIST2TO) << CRINFO_DIST2TO_SH)
2226
       | ((in->relvaddr & CRINFO_RELVADDR) << CRINFO_RELVADDR_SH));
2227
  H_PUT_32 (abfd, l, ex->info);
2228
  H_PUT_32 (abfd, in->konst, ex->konst);
2229
  H_PUT_32 (abfd, in->vaddr, ex->vaddr);
2230
}
2231
 
2232
/* A .reginfo section holds a single Elf32_RegInfo structure.  These
2233
   routines swap this structure in and out.  They are used outside of
2234
   BFD, so they are globally visible.  */
2235
 
2236
void
2237
bfd_mips_elf32_swap_reginfo_in (bfd *abfd, const Elf32_External_RegInfo *ex,
2238
                                Elf32_RegInfo *in)
2239
{
2240
  in->ri_gprmask = H_GET_32 (abfd, ex->ri_gprmask);
2241
  in->ri_cprmask[0] = H_GET_32 (abfd, ex->ri_cprmask[0]);
2242
  in->ri_cprmask[1] = H_GET_32 (abfd, ex->ri_cprmask[1]);
2243
  in->ri_cprmask[2] = H_GET_32 (abfd, ex->ri_cprmask[2]);
2244
  in->ri_cprmask[3] = H_GET_32 (abfd, ex->ri_cprmask[3]);
2245
  in->ri_gp_value = H_GET_32 (abfd, ex->ri_gp_value);
2246
}
2247
 
2248
void
2249
bfd_mips_elf32_swap_reginfo_out (bfd *abfd, const Elf32_RegInfo *in,
2250
                                 Elf32_External_RegInfo *ex)
2251
{
2252
  H_PUT_32 (abfd, in->ri_gprmask, ex->ri_gprmask);
2253
  H_PUT_32 (abfd, in->ri_cprmask[0], ex->ri_cprmask[0]);
2254
  H_PUT_32 (abfd, in->ri_cprmask[1], ex->ri_cprmask[1]);
2255
  H_PUT_32 (abfd, in->ri_cprmask[2], ex->ri_cprmask[2]);
2256
  H_PUT_32 (abfd, in->ri_cprmask[3], ex->ri_cprmask[3]);
2257
  H_PUT_32 (abfd, in->ri_gp_value, ex->ri_gp_value);
2258
}
2259
 
2260
/* In the 64 bit ABI, the .MIPS.options section holds register
2261
   information in an Elf64_Reginfo structure.  These routines swap
2262
   them in and out.  They are globally visible because they are used
2263
   outside of BFD.  These routines are here so that gas can call them
2264
   without worrying about whether the 64 bit ABI has been included.  */
2265
 
2266
void
2267
bfd_mips_elf64_swap_reginfo_in (bfd *abfd, const Elf64_External_RegInfo *ex,
2268
                                Elf64_Internal_RegInfo *in)
2269
{
2270
  in->ri_gprmask = H_GET_32 (abfd, ex->ri_gprmask);
2271
  in->ri_pad = H_GET_32 (abfd, ex->ri_pad);
2272
  in->ri_cprmask[0] = H_GET_32 (abfd, ex->ri_cprmask[0]);
2273
  in->ri_cprmask[1] = H_GET_32 (abfd, ex->ri_cprmask[1]);
2274
  in->ri_cprmask[2] = H_GET_32 (abfd, ex->ri_cprmask[2]);
2275
  in->ri_cprmask[3] = H_GET_32 (abfd, ex->ri_cprmask[3]);
2276
  in->ri_gp_value = H_GET_64 (abfd, ex->ri_gp_value);
2277
}
2278
 
2279
void
2280
bfd_mips_elf64_swap_reginfo_out (bfd *abfd, const Elf64_Internal_RegInfo *in,
2281
                                 Elf64_External_RegInfo *ex)
2282
{
2283
  H_PUT_32 (abfd, in->ri_gprmask, ex->ri_gprmask);
2284
  H_PUT_32 (abfd, in->ri_pad, ex->ri_pad);
2285
  H_PUT_32 (abfd, in->ri_cprmask[0], ex->ri_cprmask[0]);
2286
  H_PUT_32 (abfd, in->ri_cprmask[1], ex->ri_cprmask[1]);
2287
  H_PUT_32 (abfd, in->ri_cprmask[2], ex->ri_cprmask[2]);
2288
  H_PUT_32 (abfd, in->ri_cprmask[3], ex->ri_cprmask[3]);
2289
  H_PUT_64 (abfd, in->ri_gp_value, ex->ri_gp_value);
2290
}
2291
 
2292
/* Swap in an options header.  */
2293
 
2294
void
2295
bfd_mips_elf_swap_options_in (bfd *abfd, const Elf_External_Options *ex,
2296
                              Elf_Internal_Options *in)
2297
{
2298
  in->kind = H_GET_8 (abfd, ex->kind);
2299
  in->size = H_GET_8 (abfd, ex->size);
2300
  in->section = H_GET_16 (abfd, ex->section);
2301
  in->info = H_GET_32 (abfd, ex->info);
2302
}
2303
 
2304
/* Swap out an options header.  */
2305
 
2306
void
2307
bfd_mips_elf_swap_options_out (bfd *abfd, const Elf_Internal_Options *in,
2308
                               Elf_External_Options *ex)
2309
{
2310
  H_PUT_8 (abfd, in->kind, ex->kind);
2311
  H_PUT_8 (abfd, in->size, ex->size);
2312
  H_PUT_16 (abfd, in->section, ex->section);
2313
  H_PUT_32 (abfd, in->info, ex->info);
2314
}
2315
 
2316
/* This function is called via qsort() to sort the dynamic relocation
2317
   entries by increasing r_symndx value.  */
2318
 
2319
static int
2320
sort_dynamic_relocs (const void *arg1, const void *arg2)
2321
{
2322
  Elf_Internal_Rela int_reloc1;
2323
  Elf_Internal_Rela int_reloc2;
2324
  int diff;
2325
 
2326
  bfd_elf32_swap_reloc_in (reldyn_sorting_bfd, arg1, &int_reloc1);
2327
  bfd_elf32_swap_reloc_in (reldyn_sorting_bfd, arg2, &int_reloc2);
2328
 
2329
  diff = ELF32_R_SYM (int_reloc1.r_info) - ELF32_R_SYM (int_reloc2.r_info);
2330
  if (diff != 0)
2331
    return diff;
2332
 
2333
  if (int_reloc1.r_offset < int_reloc2.r_offset)
2334
    return -1;
2335
  if (int_reloc1.r_offset > int_reloc2.r_offset)
2336
    return 1;
2337
  return 0;
2338
}
2339
 
2340
/* Like sort_dynamic_relocs, but used for elf64 relocations.  */
2341
 
2342
static int
2343
sort_dynamic_relocs_64 (const void *arg1 ATTRIBUTE_UNUSED,
2344
                        const void *arg2 ATTRIBUTE_UNUSED)
2345
{
2346
#ifdef BFD64
2347
  Elf_Internal_Rela int_reloc1[3];
2348
  Elf_Internal_Rela int_reloc2[3];
2349
 
2350
  (*get_elf_backend_data (reldyn_sorting_bfd)->s->swap_reloc_in)
2351
    (reldyn_sorting_bfd, arg1, int_reloc1);
2352
  (*get_elf_backend_data (reldyn_sorting_bfd)->s->swap_reloc_in)
2353
    (reldyn_sorting_bfd, arg2, int_reloc2);
2354
 
2355
  if (ELF64_R_SYM (int_reloc1[0].r_info) < ELF64_R_SYM (int_reloc2[0].r_info))
2356
    return -1;
2357
  if (ELF64_R_SYM (int_reloc1[0].r_info) > ELF64_R_SYM (int_reloc2[0].r_info))
2358
    return 1;
2359
 
2360
  if (int_reloc1[0].r_offset < int_reloc2[0].r_offset)
2361
    return -1;
2362
  if (int_reloc1[0].r_offset > int_reloc2[0].r_offset)
2363
    return 1;
2364
  return 0;
2365
#else
2366
  abort ();
2367
#endif
2368
}
2369
 
2370
 
2371
/* This routine is used to write out ECOFF debugging external symbol
2372
   information.  It is called via mips_elf_link_hash_traverse.  The
2373
   ECOFF external symbol information must match the ELF external
2374
   symbol information.  Unfortunately, at this point we don't know
2375
   whether a symbol is required by reloc information, so the two
2376
   tables may wind up being different.  We must sort out the external
2377
   symbol information before we can set the final size of the .mdebug
2378
   section, and we must set the size of the .mdebug section before we
2379
   can relocate any sections, and we can't know which symbols are
2380
   required by relocation until we relocate the sections.
2381
   Fortunately, it is relatively unlikely that any symbol will be
2382
   stripped but required by a reloc.  In particular, it can not happen
2383
   when generating a final executable.  */
2384
 
2385
static bfd_boolean
2386
mips_elf_output_extsym (struct mips_elf_link_hash_entry *h, void *data)
2387
{
2388
  struct extsym_info *einfo = data;
2389
  bfd_boolean strip;
2390
  asection *sec, *output_section;
2391
 
2392
  if (h->root.root.type == bfd_link_hash_warning)
2393
    h = (struct mips_elf_link_hash_entry *) h->root.root.u.i.link;
2394
 
2395
  if (h->root.indx == -2)
2396
    strip = FALSE;
2397
  else if ((h->root.def_dynamic
2398
            || h->root.ref_dynamic
2399
            || h->root.type == bfd_link_hash_new)
2400
           && !h->root.def_regular
2401
           && !h->root.ref_regular)
2402
    strip = TRUE;
2403
  else if (einfo->info->strip == strip_all
2404
           || (einfo->info->strip == strip_some
2405
               && bfd_hash_lookup (einfo->info->keep_hash,
2406
                                   h->root.root.root.string,
2407
                                   FALSE, FALSE) == NULL))
2408
    strip = TRUE;
2409
  else
2410
    strip = FALSE;
2411
 
2412
  if (strip)
2413
    return TRUE;
2414
 
2415
  if (h->esym.ifd == -2)
2416
    {
2417
      h->esym.jmptbl = 0;
2418
      h->esym.cobol_main = 0;
2419
      h->esym.weakext = 0;
2420
      h->esym.reserved = 0;
2421
      h->esym.ifd = ifdNil;
2422
      h->esym.asym.value = 0;
2423
      h->esym.asym.st = stGlobal;
2424
 
2425
      if (h->root.root.type == bfd_link_hash_undefined
2426
          || h->root.root.type == bfd_link_hash_undefweak)
2427
        {
2428
          const char *name;
2429
 
2430
          /* Use undefined class.  Also, set class and type for some
2431
             special symbols.  */
2432
          name = h->root.root.root.string;
2433
          if (strcmp (name, mips_elf_dynsym_rtproc_names[0]) == 0
2434
              || strcmp (name, mips_elf_dynsym_rtproc_names[1]) == 0)
2435
            {
2436
              h->esym.asym.sc = scData;
2437
              h->esym.asym.st = stLabel;
2438
              h->esym.asym.value = 0;
2439
            }
2440
          else if (strcmp (name, mips_elf_dynsym_rtproc_names[2]) == 0)
2441
            {
2442
              h->esym.asym.sc = scAbs;
2443
              h->esym.asym.st = stLabel;
2444
              h->esym.asym.value =
2445
                mips_elf_hash_table (einfo->info)->procedure_count;
2446
            }
2447
          else if (strcmp (name, "_gp_disp") == 0 && ! NEWABI_P (einfo->abfd))
2448
            {
2449
              h->esym.asym.sc = scAbs;
2450
              h->esym.asym.st = stLabel;
2451
              h->esym.asym.value = elf_gp (einfo->abfd);
2452
            }
2453
          else
2454
            h->esym.asym.sc = scUndefined;
2455
        }
2456
      else if (h->root.root.type != bfd_link_hash_defined
2457
          && h->root.root.type != bfd_link_hash_defweak)
2458
        h->esym.asym.sc = scAbs;
2459
      else
2460
        {
2461
          const char *name;
2462
 
2463
          sec = h->root.root.u.def.section;
2464
          output_section = sec->output_section;
2465
 
2466
          /* When making a shared library and symbol h is the one from
2467
             the another shared library, OUTPUT_SECTION may be null.  */
2468
          if (output_section == NULL)
2469
            h->esym.asym.sc = scUndefined;
2470
          else
2471
            {
2472
              name = bfd_section_name (output_section->owner, output_section);
2473
 
2474
              if (strcmp (name, ".text") == 0)
2475
                h->esym.asym.sc = scText;
2476
              else if (strcmp (name, ".data") == 0)
2477
                h->esym.asym.sc = scData;
2478
              else if (strcmp (name, ".sdata") == 0)
2479
                h->esym.asym.sc = scSData;
2480
              else if (strcmp (name, ".rodata") == 0
2481
                       || strcmp (name, ".rdata") == 0)
2482
                h->esym.asym.sc = scRData;
2483
              else if (strcmp (name, ".bss") == 0)
2484
                h->esym.asym.sc = scBss;
2485
              else if (strcmp (name, ".sbss") == 0)
2486
                h->esym.asym.sc = scSBss;
2487
              else if (strcmp (name, ".init") == 0)
2488
                h->esym.asym.sc = scInit;
2489
              else if (strcmp (name, ".fini") == 0)
2490
                h->esym.asym.sc = scFini;
2491
              else
2492
                h->esym.asym.sc = scAbs;
2493
            }
2494
        }
2495
 
2496
      h->esym.asym.reserved = 0;
2497
      h->esym.asym.index = indexNil;
2498
    }
2499
 
2500
  if (h->root.root.type == bfd_link_hash_common)
2501
    h->esym.asym.value = h->root.root.u.c.size;
2502
  else if (h->root.root.type == bfd_link_hash_defined
2503
           || h->root.root.type == bfd_link_hash_defweak)
2504
    {
2505
      if (h->esym.asym.sc == scCommon)
2506
        h->esym.asym.sc = scBss;
2507
      else if (h->esym.asym.sc == scSCommon)
2508
        h->esym.asym.sc = scSBss;
2509
 
2510
      sec = h->root.root.u.def.section;
2511
      output_section = sec->output_section;
2512
      if (output_section != NULL)
2513
        h->esym.asym.value = (h->root.root.u.def.value
2514
                              + sec->output_offset
2515
                              + output_section->vma);
2516
      else
2517
        h->esym.asym.value = 0;
2518
    }
2519 225 jeremybenn
  else
2520 24 jeremybenn
    {
2521
      struct mips_elf_link_hash_entry *hd = h;
2522
 
2523
      while (hd->root.root.type == bfd_link_hash_indirect)
2524 225 jeremybenn
        hd = (struct mips_elf_link_hash_entry *)h->root.root.u.i.link;
2525 24 jeremybenn
 
2526 225 jeremybenn
      if (hd->needs_lazy_stub)
2527 24 jeremybenn
        {
2528
          /* Set type and value for a symbol with a function stub.  */
2529
          h->esym.asym.st = stProc;
2530
          sec = hd->root.root.u.def.section;
2531
          if (sec == NULL)
2532
            h->esym.asym.value = 0;
2533
          else
2534
            {
2535
              output_section = sec->output_section;
2536
              if (output_section != NULL)
2537
                h->esym.asym.value = (hd->root.plt.offset
2538
                                      + sec->output_offset
2539
                                      + output_section->vma);
2540
              else
2541
                h->esym.asym.value = 0;
2542
            }
2543
        }
2544
    }
2545
 
2546
  if (! bfd_ecoff_debug_one_external (einfo->abfd, einfo->debug, einfo->swap,
2547
                                      h->root.root.root.string,
2548
                                      &h->esym))
2549
    {
2550
      einfo->failed = TRUE;
2551
      return FALSE;
2552
    }
2553
 
2554
  return TRUE;
2555
}
2556
 
2557
/* A comparison routine used to sort .gptab entries.  */
2558
 
2559
static int
2560
gptab_compare (const void *p1, const void *p2)
2561
{
2562
  const Elf32_gptab *a1 = p1;
2563
  const Elf32_gptab *a2 = p2;
2564
 
2565
  return a1->gt_entry.gt_g_value - a2->gt_entry.gt_g_value;
2566
}
2567
 
2568
/* Functions to manage the got entry hash table.  */
2569
 
2570
/* Use all 64 bits of a bfd_vma for the computation of a 32-bit
2571
   hash number.  */
2572
 
2573
static INLINE hashval_t
2574
mips_elf_hash_bfd_vma (bfd_vma addr)
2575
{
2576
#ifdef BFD64
2577
  return addr + (addr >> 32);
2578
#else
2579
  return addr;
2580
#endif
2581
}
2582
 
2583
/* got_entries only match if they're identical, except for gotidx, so
2584
   use all fields to compute the hash, and compare the appropriate
2585
   union members.  */
2586
 
2587
static hashval_t
2588
mips_elf_got_entry_hash (const void *entry_)
2589
{
2590
  const struct mips_got_entry *entry = (struct mips_got_entry *)entry_;
2591
 
2592
  return entry->symndx
2593
    + ((entry->tls_type & GOT_TLS_LDM) << 17)
2594
    + (! entry->abfd ? mips_elf_hash_bfd_vma (entry->d.address)
2595
       : entry->abfd->id
2596
         + (entry->symndx >= 0 ? mips_elf_hash_bfd_vma (entry->d.addend)
2597
            : entry->d.h->root.root.root.hash));
2598
}
2599
 
2600
static int
2601
mips_elf_got_entry_eq (const void *entry1, const void *entry2)
2602
{
2603
  const struct mips_got_entry *e1 = (struct mips_got_entry *)entry1;
2604
  const struct mips_got_entry *e2 = (struct mips_got_entry *)entry2;
2605
 
2606
  /* An LDM entry can only match another LDM entry.  */
2607
  if ((e1->tls_type ^ e2->tls_type) & GOT_TLS_LDM)
2608
    return 0;
2609
 
2610
  return e1->abfd == e2->abfd && e1->symndx == e2->symndx
2611
    && (! e1->abfd ? e1->d.address == e2->d.address
2612
        : e1->symndx >= 0 ? e1->d.addend == e2->d.addend
2613
        : e1->d.h == e2->d.h);
2614
}
2615
 
2616
/* multi_got_entries are still a match in the case of global objects,
2617
   even if the input bfd in which they're referenced differs, so the
2618
   hash computation and compare functions are adjusted
2619
   accordingly.  */
2620
 
2621
static hashval_t
2622
mips_elf_multi_got_entry_hash (const void *entry_)
2623
{
2624
  const struct mips_got_entry *entry = (struct mips_got_entry *)entry_;
2625
 
2626
  return entry->symndx
2627
    + (! entry->abfd
2628
       ? mips_elf_hash_bfd_vma (entry->d.address)
2629
       : entry->symndx >= 0
2630
       ? ((entry->tls_type & GOT_TLS_LDM)
2631
          ? (GOT_TLS_LDM << 17)
2632
          : (entry->abfd->id
2633
             + mips_elf_hash_bfd_vma (entry->d.addend)))
2634
       : entry->d.h->root.root.root.hash);
2635
}
2636
 
2637
static int
2638
mips_elf_multi_got_entry_eq (const void *entry1, const void *entry2)
2639
{
2640
  const struct mips_got_entry *e1 = (struct mips_got_entry *)entry1;
2641
  const struct mips_got_entry *e2 = (struct mips_got_entry *)entry2;
2642
 
2643
  /* Any two LDM entries match.  */
2644
  if (e1->tls_type & e2->tls_type & GOT_TLS_LDM)
2645
    return 1;
2646
 
2647
  /* Nothing else matches an LDM entry.  */
2648
  if ((e1->tls_type ^ e2->tls_type) & GOT_TLS_LDM)
2649
    return 0;
2650
 
2651
  return e1->symndx == e2->symndx
2652
    && (e1->symndx >= 0 ? e1->abfd == e2->abfd && e1->d.addend == e2->d.addend
2653
        : e1->abfd == NULL || e2->abfd == NULL
2654
        ? e1->abfd == e2->abfd && e1->d.address == e2->d.address
2655
        : e1->d.h == e2->d.h);
2656
}
2657
 
2658
static hashval_t
2659
mips_got_page_entry_hash (const void *entry_)
2660
{
2661
  const struct mips_got_page_entry *entry;
2662
 
2663
  entry = (const struct mips_got_page_entry *) entry_;
2664
  return entry->abfd->id + entry->symndx;
2665
}
2666
 
2667
static int
2668
mips_got_page_entry_eq (const void *entry1_, const void *entry2_)
2669
{
2670
  const struct mips_got_page_entry *entry1, *entry2;
2671
 
2672
  entry1 = (const struct mips_got_page_entry *) entry1_;
2673
  entry2 = (const struct mips_got_page_entry *) entry2_;
2674
  return entry1->abfd == entry2->abfd && entry1->symndx == entry2->symndx;
2675
}
2676
 
2677
/* Return the dynamic relocation section.  If it doesn't exist, try to
2678
   create a new it if CREATE_P, otherwise return NULL.  Also return NULL
2679
   if creation fails.  */
2680
 
2681
static asection *
2682
mips_elf_rel_dyn_section (struct bfd_link_info *info, bfd_boolean create_p)
2683
{
2684
  const char *dname;
2685
  asection *sreloc;
2686
  bfd *dynobj;
2687
 
2688
  dname = MIPS_ELF_REL_DYN_NAME (info);
2689
  dynobj = elf_hash_table (info)->dynobj;
2690
  sreloc = bfd_get_section_by_name (dynobj, dname);
2691
  if (sreloc == NULL && create_p)
2692
    {
2693
      sreloc = bfd_make_section_with_flags (dynobj, dname,
2694
                                            (SEC_ALLOC
2695
                                             | SEC_LOAD
2696
                                             | SEC_HAS_CONTENTS
2697
                                             | SEC_IN_MEMORY
2698
                                             | SEC_LINKER_CREATED
2699
                                             | SEC_READONLY));
2700
      if (sreloc == NULL
2701
          || ! bfd_set_section_alignment (dynobj, sreloc,
2702
                                          MIPS_ELF_LOG_FILE_ALIGN (dynobj)))
2703
        return NULL;
2704
    }
2705
  return sreloc;
2706
}
2707
 
2708
/* Count the number of relocations needed for a TLS GOT entry, with
2709
   access types from TLS_TYPE, and symbol H (or a local symbol if H
2710
   is NULL).  */
2711
 
2712
static int
2713
mips_tls_got_relocs (struct bfd_link_info *info, unsigned char tls_type,
2714
                     struct elf_link_hash_entry *h)
2715
{
2716
  int indx = 0;
2717
  int ret = 0;
2718
  bfd_boolean need_relocs = FALSE;
2719
  bfd_boolean dyn = elf_hash_table (info)->dynamic_sections_created;
2720
 
2721
  if (h && WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
2722
      && (!info->shared || !SYMBOL_REFERENCES_LOCAL (info, h)))
2723
    indx = h->dynindx;
2724
 
2725
  if ((info->shared || indx != 0)
2726
      && (h == NULL
2727
          || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2728
          || h->root.type != bfd_link_hash_undefweak))
2729
    need_relocs = TRUE;
2730
 
2731
  if (!need_relocs)
2732
    return FALSE;
2733
 
2734
  if (tls_type & GOT_TLS_GD)
2735
    {
2736
      ret++;
2737
      if (indx != 0)
2738
        ret++;
2739
    }
2740
 
2741
  if (tls_type & GOT_TLS_IE)
2742
    ret++;
2743
 
2744
  if ((tls_type & GOT_TLS_LDM) && info->shared)
2745
    ret++;
2746
 
2747
  return ret;
2748
}
2749
 
2750
/* Count the number of TLS relocations required for the GOT entry in
2751
   ARG1, if it describes a local symbol.  */
2752
 
2753
static int
2754
mips_elf_count_local_tls_relocs (void **arg1, void *arg2)
2755
{
2756
  struct mips_got_entry *entry = * (struct mips_got_entry **) arg1;
2757
  struct mips_elf_count_tls_arg *arg = arg2;
2758
 
2759
  if (entry->abfd != NULL && entry->symndx != -1)
2760
    arg->needed += mips_tls_got_relocs (arg->info, entry->tls_type, NULL);
2761
 
2762
  return 1;
2763
}
2764
 
2765
/* Count the number of TLS GOT entries required for the global (or
2766
   forced-local) symbol in ARG1.  */
2767
 
2768
static int
2769
mips_elf_count_global_tls_entries (void *arg1, void *arg2)
2770
{
2771
  struct mips_elf_link_hash_entry *hm
2772
    = (struct mips_elf_link_hash_entry *) arg1;
2773
  struct mips_elf_count_tls_arg *arg = arg2;
2774
 
2775
  if (hm->tls_type & GOT_TLS_GD)
2776
    arg->needed += 2;
2777
  if (hm->tls_type & GOT_TLS_IE)
2778
    arg->needed += 1;
2779
 
2780
  return 1;
2781
}
2782
 
2783
/* Count the number of TLS relocations required for the global (or
2784
   forced-local) symbol in ARG1.  */
2785
 
2786
static int
2787
mips_elf_count_global_tls_relocs (void *arg1, void *arg2)
2788
{
2789
  struct mips_elf_link_hash_entry *hm
2790
    = (struct mips_elf_link_hash_entry *) arg1;
2791
  struct mips_elf_count_tls_arg *arg = arg2;
2792
 
2793
  arg->needed += mips_tls_got_relocs (arg->info, hm->tls_type, &hm->root);
2794
 
2795
  return 1;
2796
}
2797
 
2798
/* Output a simple dynamic relocation into SRELOC.  */
2799
 
2800
static void
2801
mips_elf_output_dynamic_relocation (bfd *output_bfd,
2802
                                    asection *sreloc,
2803 225 jeremybenn
                                    unsigned long reloc_index,
2804 24 jeremybenn
                                    unsigned long indx,
2805
                                    int r_type,
2806
                                    bfd_vma offset)
2807
{
2808
  Elf_Internal_Rela rel[3];
2809
 
2810
  memset (rel, 0, sizeof (rel));
2811
 
2812
  rel[0].r_info = ELF_R_INFO (output_bfd, indx, r_type);
2813
  rel[0].r_offset = rel[1].r_offset = rel[2].r_offset = offset;
2814
 
2815
  if (ABI_64_P (output_bfd))
2816
    {
2817
      (*get_elf_backend_data (output_bfd)->s->swap_reloc_out)
2818
        (output_bfd, &rel[0],
2819
         (sreloc->contents
2820 225 jeremybenn
          + reloc_index * sizeof (Elf64_Mips_External_Rel)));
2821 24 jeremybenn
    }
2822
  else
2823
    bfd_elf32_swap_reloc_out
2824
      (output_bfd, &rel[0],
2825
       (sreloc->contents
2826 225 jeremybenn
        + reloc_index * sizeof (Elf32_External_Rel)));
2827 24 jeremybenn
}
2828
 
2829
/* Initialize a set of TLS GOT entries for one symbol.  */
2830
 
2831
static void
2832
mips_elf_initialize_tls_slots (bfd *abfd, bfd_vma got_offset,
2833
                               unsigned char *tls_type_p,
2834
                               struct bfd_link_info *info,
2835
                               struct mips_elf_link_hash_entry *h,
2836
                               bfd_vma value)
2837
{
2838 225 jeremybenn
  struct mips_elf_link_hash_table *htab;
2839 24 jeremybenn
  int indx;
2840
  asection *sreloc, *sgot;
2841
  bfd_vma offset, offset2;
2842
  bfd_boolean need_relocs = FALSE;
2843
 
2844 225 jeremybenn
  htab = mips_elf_hash_table (info);
2845
  sgot = htab->sgot;
2846 24 jeremybenn
 
2847
  indx = 0;
2848
  if (h != NULL)
2849
    {
2850
      bfd_boolean dyn = elf_hash_table (info)->dynamic_sections_created;
2851
 
2852
      if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, &h->root)
2853
          && (!info->shared || !SYMBOL_REFERENCES_LOCAL (info, &h->root)))
2854
        indx = h->root.dynindx;
2855
    }
2856
 
2857
  if (*tls_type_p & GOT_TLS_DONE)
2858
    return;
2859
 
2860
  if ((info->shared || indx != 0)
2861
      && (h == NULL
2862
          || ELF_ST_VISIBILITY (h->root.other) == STV_DEFAULT
2863
          || h->root.type != bfd_link_hash_undefweak))
2864
    need_relocs = TRUE;
2865
 
2866
  /* MINUS_ONE means the symbol is not defined in this object.  It may not
2867
     be defined at all; assume that the value doesn't matter in that
2868
     case.  Otherwise complain if we would use the value.  */
2869
  BFD_ASSERT (value != MINUS_ONE || (indx != 0 && need_relocs)
2870
              || h->root.root.type == bfd_link_hash_undefweak);
2871
 
2872
  /* Emit necessary relocations.  */
2873
  sreloc = mips_elf_rel_dyn_section (info, FALSE);
2874
 
2875
  /* General Dynamic.  */
2876
  if (*tls_type_p & GOT_TLS_GD)
2877
    {
2878
      offset = got_offset;
2879
      offset2 = offset + MIPS_ELF_GOT_SIZE (abfd);
2880
 
2881
      if (need_relocs)
2882
        {
2883
          mips_elf_output_dynamic_relocation
2884 225 jeremybenn
            (abfd, sreloc, sreloc->reloc_count++, indx,
2885 24 jeremybenn
             ABI_64_P (abfd) ? R_MIPS_TLS_DTPMOD64 : R_MIPS_TLS_DTPMOD32,
2886
             sgot->output_offset + sgot->output_section->vma + offset);
2887
 
2888
          if (indx)
2889
            mips_elf_output_dynamic_relocation
2890 225 jeremybenn
              (abfd, sreloc, sreloc->reloc_count++, indx,
2891 24 jeremybenn
               ABI_64_P (abfd) ? R_MIPS_TLS_DTPREL64 : R_MIPS_TLS_DTPREL32,
2892
               sgot->output_offset + sgot->output_section->vma + offset2);
2893
          else
2894
            MIPS_ELF_PUT_WORD (abfd, value - dtprel_base (info),
2895
                               sgot->contents + offset2);
2896
        }
2897
      else
2898
        {
2899
          MIPS_ELF_PUT_WORD (abfd, 1,
2900
                             sgot->contents + offset);
2901
          MIPS_ELF_PUT_WORD (abfd, value - dtprel_base (info),
2902
                             sgot->contents + offset2);
2903
        }
2904
 
2905
      got_offset += 2 * MIPS_ELF_GOT_SIZE (abfd);
2906
    }
2907
 
2908
  /* Initial Exec model.  */
2909
  if (*tls_type_p & GOT_TLS_IE)
2910
    {
2911
      offset = got_offset;
2912
 
2913
      if (need_relocs)
2914
        {
2915
          if (indx == 0)
2916
            MIPS_ELF_PUT_WORD (abfd, value - elf_hash_table (info)->tls_sec->vma,
2917
                               sgot->contents + offset);
2918
          else
2919
            MIPS_ELF_PUT_WORD (abfd, 0,
2920
                               sgot->contents + offset);
2921
 
2922
          mips_elf_output_dynamic_relocation
2923 225 jeremybenn
            (abfd, sreloc, sreloc->reloc_count++, indx,
2924 24 jeremybenn
             ABI_64_P (abfd) ? R_MIPS_TLS_TPREL64 : R_MIPS_TLS_TPREL32,
2925
             sgot->output_offset + sgot->output_section->vma + offset);
2926
        }
2927
      else
2928
        MIPS_ELF_PUT_WORD (abfd, value - tprel_base (info),
2929
                           sgot->contents + offset);
2930
    }
2931
 
2932
  if (*tls_type_p & GOT_TLS_LDM)
2933
    {
2934
      /* The initial offset is zero, and the LD offsets will include the
2935
         bias by DTP_OFFSET.  */
2936
      MIPS_ELF_PUT_WORD (abfd, 0,
2937
                         sgot->contents + got_offset
2938
                         + MIPS_ELF_GOT_SIZE (abfd));
2939
 
2940
      if (!info->shared)
2941
        MIPS_ELF_PUT_WORD (abfd, 1,
2942
                           sgot->contents + got_offset);
2943
      else
2944
        mips_elf_output_dynamic_relocation
2945 225 jeremybenn
          (abfd, sreloc, sreloc->reloc_count++, indx,
2946 24 jeremybenn
           ABI_64_P (abfd) ? R_MIPS_TLS_DTPMOD64 : R_MIPS_TLS_DTPMOD32,
2947
           sgot->output_offset + sgot->output_section->vma + got_offset);
2948
    }
2949
 
2950
  *tls_type_p |= GOT_TLS_DONE;
2951
}
2952
 
2953
/* Return the GOT index to use for a relocation of type R_TYPE against
2954
   a symbol accessed using TLS_TYPE models.  The GOT entries for this
2955
   symbol in this GOT start at GOT_INDEX.  This function initializes the
2956
   GOT entries and corresponding relocations.  */
2957
 
2958
static bfd_vma
2959
mips_tls_got_index (bfd *abfd, bfd_vma got_index, unsigned char *tls_type,
2960
                    int r_type, struct bfd_link_info *info,
2961
                    struct mips_elf_link_hash_entry *h, bfd_vma symbol)
2962
{
2963
  BFD_ASSERT (r_type == R_MIPS_TLS_GOTTPREL || r_type == R_MIPS_TLS_GD
2964
              || r_type == R_MIPS_TLS_LDM);
2965
 
2966
  mips_elf_initialize_tls_slots (abfd, got_index, tls_type, info, h, symbol);
2967
 
2968
  if (r_type == R_MIPS_TLS_GOTTPREL)
2969
    {
2970
      BFD_ASSERT (*tls_type & GOT_TLS_IE);
2971
      if (*tls_type & GOT_TLS_GD)
2972
        return got_index + 2 * MIPS_ELF_GOT_SIZE (abfd);
2973
      else
2974
        return got_index;
2975
    }
2976
 
2977
  if (r_type == R_MIPS_TLS_GD)
2978
    {
2979
      BFD_ASSERT (*tls_type & GOT_TLS_GD);
2980
      return got_index;
2981
    }
2982
 
2983
  if (r_type == R_MIPS_TLS_LDM)
2984
    {
2985
      BFD_ASSERT (*tls_type & GOT_TLS_LDM);
2986
      return got_index;
2987
    }
2988
 
2989
  return got_index;
2990
}
2991
 
2992
/* Return the offset from _GLOBAL_OFFSET_TABLE_ of the .got.plt entry
2993
   for global symbol H.  .got.plt comes before the GOT, so the offset
2994
   will be negative.  */
2995
 
2996
static bfd_vma
2997
mips_elf_gotplt_index (struct bfd_link_info *info,
2998
                       struct elf_link_hash_entry *h)
2999
{
3000
  bfd_vma plt_index, got_address, got_value;
3001
  struct mips_elf_link_hash_table *htab;
3002
 
3003
  htab = mips_elf_hash_table (info);
3004
  BFD_ASSERT (h->plt.offset != (bfd_vma) -1);
3005
 
3006 225 jeremybenn
  /* This function only works for VxWorks, because a non-VxWorks .got.plt
3007
     section starts with reserved entries.  */
3008
  BFD_ASSERT (htab->is_vxworks);
3009
 
3010 24 jeremybenn
  /* Calculate the index of the symbol's PLT entry.  */
3011
  plt_index = (h->plt.offset - htab->plt_header_size) / htab->plt_entry_size;
3012
 
3013
  /* Calculate the address of the associated .got.plt entry.  */
3014
  got_address = (htab->sgotplt->output_section->vma
3015
                 + htab->sgotplt->output_offset
3016
                 + plt_index * 4);
3017
 
3018
  /* Calculate the value of _GLOBAL_OFFSET_TABLE_.  */
3019
  got_value = (htab->root.hgot->root.u.def.section->output_section->vma
3020
               + htab->root.hgot->root.u.def.section->output_offset
3021
               + htab->root.hgot->root.u.def.value);
3022
 
3023
  return got_address - got_value;
3024
}
3025
 
3026
/* Return the GOT offset for address VALUE.   If there is not yet a GOT
3027
   entry for this value, create one.  If R_SYMNDX refers to a TLS symbol,
3028
   create a TLS GOT entry instead.  Return -1 if no satisfactory GOT
3029
   offset can be found.  */
3030
 
3031
static bfd_vma
3032
mips_elf_local_got_index (bfd *abfd, bfd *ibfd, struct bfd_link_info *info,
3033
                          bfd_vma value, unsigned long r_symndx,
3034
                          struct mips_elf_link_hash_entry *h, int r_type)
3035
{
3036 225 jeremybenn
  struct mips_elf_link_hash_table *htab;
3037 24 jeremybenn
  struct mips_got_entry *entry;
3038
 
3039 225 jeremybenn
  htab = mips_elf_hash_table (info);
3040
  entry = mips_elf_create_local_got_entry (abfd, info, ibfd, value,
3041
                                           r_symndx, h, r_type);
3042 24 jeremybenn
  if (!entry)
3043
    return MINUS_ONE;
3044
 
3045
  if (TLS_RELOC_P (r_type))
3046
    {
3047 225 jeremybenn
      if (entry->symndx == -1 && htab->got_info->next == NULL)
3048 24 jeremybenn
        /* A type (3) entry in the single-GOT case.  We use the symbol's
3049
           hash table entry to track the index.  */
3050
        return mips_tls_got_index (abfd, h->tls_got_offset, &h->tls_type,
3051
                                   r_type, info, h, value);
3052
      else
3053
        return mips_tls_got_index (abfd, entry->gotidx, &entry->tls_type,
3054
                                   r_type, info, h, value);
3055
    }
3056
  else
3057
    return entry->gotidx;
3058
}
3059
 
3060
/* Returns the GOT index for the global symbol indicated by H.  */
3061
 
3062
static bfd_vma
3063
mips_elf_global_got_index (bfd *abfd, bfd *ibfd, struct elf_link_hash_entry *h,
3064
                           int r_type, struct bfd_link_info *info)
3065
{
3066 225 jeremybenn
  struct mips_elf_link_hash_table *htab;
3067 24 jeremybenn
  bfd_vma index;
3068
  struct mips_got_info *g, *gg;
3069
  long global_got_dynindx = 0;
3070
 
3071 225 jeremybenn
  htab = mips_elf_hash_table (info);
3072
  gg = g = htab->got_info;
3073 24 jeremybenn
  if (g->bfd2got && ibfd)
3074
    {
3075
      struct mips_got_entry e, *p;
3076
 
3077
      BFD_ASSERT (h->dynindx >= 0);
3078
 
3079
      g = mips_elf_got_for_ibfd (g, ibfd);
3080
      if (g->next != gg || TLS_RELOC_P (r_type))
3081
        {
3082
          e.abfd = ibfd;
3083
          e.symndx = -1;
3084
          e.d.h = (struct mips_elf_link_hash_entry *)h;
3085
          e.tls_type = 0;
3086
 
3087
          p = htab_find (g->got_entries, &e);
3088
 
3089
          BFD_ASSERT (p->gotidx > 0);
3090
 
3091
          if (TLS_RELOC_P (r_type))
3092
            {
3093
              bfd_vma value = MINUS_ONE;
3094
              if ((h->root.type == bfd_link_hash_defined
3095
                   || h->root.type == bfd_link_hash_defweak)
3096
                  && h->root.u.def.section->output_section)
3097
                value = (h->root.u.def.value
3098
                         + h->root.u.def.section->output_offset
3099
                         + h->root.u.def.section->output_section->vma);
3100
 
3101
              return mips_tls_got_index (abfd, p->gotidx, &p->tls_type, r_type,
3102
                                         info, e.d.h, value);
3103
            }
3104
          else
3105
            return p->gotidx;
3106
        }
3107
    }
3108
 
3109
  if (gg->global_gotsym != NULL)
3110
    global_got_dynindx = gg->global_gotsym->dynindx;
3111
 
3112
  if (TLS_RELOC_P (r_type))
3113
    {
3114
      struct mips_elf_link_hash_entry *hm
3115
        = (struct mips_elf_link_hash_entry *) h;
3116
      bfd_vma value = MINUS_ONE;
3117
 
3118
      if ((h->root.type == bfd_link_hash_defined
3119
           || h->root.type == bfd_link_hash_defweak)
3120
          && h->root.u.def.section->output_section)
3121
        value = (h->root.u.def.value
3122
                 + h->root.u.def.section->output_offset
3123
                 + h->root.u.def.section->output_section->vma);
3124
 
3125
      index = mips_tls_got_index (abfd, hm->tls_got_offset, &hm->tls_type,
3126
                                  r_type, info, hm, value);
3127
    }
3128
  else
3129
    {
3130
      /* Once we determine the global GOT entry with the lowest dynamic
3131
         symbol table index, we must put all dynamic symbols with greater
3132
         indices into the GOT.  That makes it easy to calculate the GOT
3133
         offset.  */
3134
      BFD_ASSERT (h->dynindx >= global_got_dynindx);
3135
      index = ((h->dynindx - global_got_dynindx + g->local_gotno)
3136
               * MIPS_ELF_GOT_SIZE (abfd));
3137
    }
3138 225 jeremybenn
  BFD_ASSERT (index < htab->sgot->size);
3139 24 jeremybenn
 
3140
  return index;
3141
}
3142
 
3143
/* Find a GOT page entry that points to within 32KB of VALUE.  These
3144
   entries are supposed to be placed at small offsets in the GOT, i.e.,
3145
   within 32KB of GP.  Return the index of the GOT entry, or -1 if no
3146
   entry could be created.  If OFFSETP is nonnull, use it to return the
3147
   offset of the GOT entry from VALUE.  */
3148
 
3149
static bfd_vma
3150
mips_elf_got_page (bfd *abfd, bfd *ibfd, struct bfd_link_info *info,
3151
                   bfd_vma value, bfd_vma *offsetp)
3152
{
3153
  bfd_vma page, index;
3154
  struct mips_got_entry *entry;
3155
 
3156
  page = (value + 0x8000) & ~(bfd_vma) 0xffff;
3157 225 jeremybenn
  entry = mips_elf_create_local_got_entry (abfd, info, ibfd, page, 0,
3158
                                           NULL, R_MIPS_GOT_PAGE);
3159 24 jeremybenn
 
3160
  if (!entry)
3161
    return MINUS_ONE;
3162
 
3163
  index = entry->gotidx;
3164
 
3165
  if (offsetp)
3166
    *offsetp = value - entry->d.address;
3167
 
3168
  return index;
3169
}
3170
 
3171 225 jeremybenn
/* Find a local GOT entry for an R_MIPS*_GOT16 relocation against VALUE.
3172 24 jeremybenn
   EXTERNAL is true if the relocation was against a global symbol
3173
   that has been forced local.  */
3174
 
3175
static bfd_vma
3176
mips_elf_got16_entry (bfd *abfd, bfd *ibfd, struct bfd_link_info *info,
3177
                      bfd_vma value, bfd_boolean external)
3178
{
3179
  struct mips_got_entry *entry;
3180
 
3181
  /* GOT16 relocations against local symbols are followed by a LO16
3182
     relocation; those against global symbols are not.  Thus if the
3183
     symbol was originally local, the GOT16 relocation should load the
3184
     equivalent of %hi(VALUE), otherwise it should load VALUE itself.  */
3185
  if (! external)
3186
    value = mips_elf_high (value) << 16;
3187
 
3188 225 jeremybenn
  /* It doesn't matter whether the original relocation was R_MIPS_GOT16,
3189
     R_MIPS16_GOT16, R_MIPS_CALL16, etc.  The format of the entry is the
3190
     same in all cases.  */
3191
  entry = mips_elf_create_local_got_entry (abfd, info, ibfd, value, 0,
3192
                                           NULL, R_MIPS_GOT16);
3193 24 jeremybenn
  if (entry)
3194
    return entry->gotidx;
3195
  else
3196
    return MINUS_ONE;
3197
}
3198
 
3199
/* Returns the offset for the entry at the INDEXth position
3200
   in the GOT.  */
3201
 
3202
static bfd_vma
3203 225 jeremybenn
mips_elf_got_offset_from_index (struct bfd_link_info *info, bfd *output_bfd,
3204 24 jeremybenn
                                bfd *input_bfd, bfd_vma index)
3205
{
3206 225 jeremybenn
  struct mips_elf_link_hash_table *htab;
3207 24 jeremybenn
  asection *sgot;
3208
  bfd_vma gp;
3209
 
3210 225 jeremybenn
  htab = mips_elf_hash_table (info);
3211
  sgot = htab->sgot;
3212 24 jeremybenn
  gp = _bfd_get_gp_value (output_bfd)
3213 225 jeremybenn
    + mips_elf_adjust_gp (output_bfd, htab->got_info, input_bfd);
3214 24 jeremybenn
 
3215
  return sgot->output_section->vma + sgot->output_offset + index - gp;
3216
}
3217
 
3218
/* Create and return a local GOT entry for VALUE, which was calculated
3219
   from a symbol belonging to INPUT_SECTON.  Return NULL if it could not
3220
   be created.  If R_SYMNDX refers to a TLS symbol, create a TLS entry
3221
   instead.  */
3222
 
3223
static struct mips_got_entry *
3224
mips_elf_create_local_got_entry (bfd *abfd, struct bfd_link_info *info,
3225 225 jeremybenn
                                 bfd *ibfd, bfd_vma value,
3226 24 jeremybenn
                                 unsigned long r_symndx,
3227
                                 struct mips_elf_link_hash_entry *h,
3228
                                 int r_type)
3229
{
3230
  struct mips_got_entry entry, **loc;
3231
  struct mips_got_info *g;
3232
  struct mips_elf_link_hash_table *htab;
3233
 
3234
  htab = mips_elf_hash_table (info);
3235
 
3236
  entry.abfd = NULL;
3237
  entry.symndx = -1;
3238
  entry.d.address = value;
3239
  entry.tls_type = 0;
3240
 
3241 225 jeremybenn
  g = mips_elf_got_for_ibfd (htab->got_info, ibfd);
3242 24 jeremybenn
  if (g == NULL)
3243
    {
3244 225 jeremybenn
      g = mips_elf_got_for_ibfd (htab->got_info, abfd);
3245 24 jeremybenn
      BFD_ASSERT (g != NULL);
3246
    }
3247
 
3248
  /* We might have a symbol, H, if it has been forced local.  Use the
3249
     global entry then.  It doesn't matter whether an entry is local
3250
     or global for TLS, since the dynamic linker does not
3251
     automatically relocate TLS GOT entries.  */
3252
  BFD_ASSERT (h == NULL || h->root.forced_local);
3253
  if (TLS_RELOC_P (r_type))
3254
    {
3255
      struct mips_got_entry *p;
3256
 
3257
      entry.abfd = ibfd;
3258
      if (r_type == R_MIPS_TLS_LDM)
3259
        {
3260
          entry.tls_type = GOT_TLS_LDM;
3261
          entry.symndx = 0;
3262
          entry.d.addend = 0;
3263
        }
3264
      else if (h == NULL)
3265
        {
3266
          entry.symndx = r_symndx;
3267
          entry.d.addend = 0;
3268
        }
3269
      else
3270
        entry.d.h = h;
3271
 
3272
      p = (struct mips_got_entry *)
3273
        htab_find (g->got_entries, &entry);
3274
 
3275
      BFD_ASSERT (p);
3276
      return p;
3277
    }
3278
 
3279
  loc = (struct mips_got_entry **) htab_find_slot (g->got_entries, &entry,
3280
                                                   INSERT);
3281
  if (*loc)
3282
    return *loc;
3283
 
3284
  entry.gotidx = MIPS_ELF_GOT_SIZE (abfd) * g->assigned_gotno++;
3285
  entry.tls_type = 0;
3286
 
3287
  *loc = (struct mips_got_entry *)bfd_alloc (abfd, sizeof entry);
3288
 
3289
  if (! *loc)
3290
    return NULL;
3291
 
3292
  memcpy (*loc, &entry, sizeof entry);
3293
 
3294
  if (g->assigned_gotno > g->local_gotno)
3295
    {
3296
      (*loc)->gotidx = -1;
3297
      /* We didn't allocate enough space in the GOT.  */
3298
      (*_bfd_error_handler)
3299
        (_("not enough GOT space for local GOT entries"));
3300
      bfd_set_error (bfd_error_bad_value);
3301
      return NULL;
3302
    }
3303
 
3304
  MIPS_ELF_PUT_WORD (abfd, value,
3305 225 jeremybenn
                     (htab->sgot->contents + entry.gotidx));
3306 24 jeremybenn
 
3307
  /* These GOT entries need a dynamic relocation on VxWorks.  */
3308
  if (htab->is_vxworks)
3309
    {
3310
      Elf_Internal_Rela outrel;
3311
      asection *s;
3312
      bfd_byte *loc;
3313
      bfd_vma got_address;
3314
 
3315
      s = mips_elf_rel_dyn_section (info, FALSE);
3316 225 jeremybenn
      got_address = (htab->sgot->output_section->vma
3317
                     + htab->sgot->output_offset
3318 24 jeremybenn
                     + entry.gotidx);
3319
 
3320
      loc = s->contents + (s->reloc_count++ * sizeof (Elf32_External_Rela));
3321
      outrel.r_offset = got_address;
3322
      outrel.r_info = ELF32_R_INFO (STN_UNDEF, R_MIPS_32);
3323
      outrel.r_addend = value;
3324
      bfd_elf32_swap_reloca_out (abfd, &outrel, loc);
3325
    }
3326
 
3327
  return *loc;
3328
}
3329
 
3330 225 jeremybenn
/* Return the number of dynamic section symbols required by OUTPUT_BFD.
3331
   The number might be exact or a worst-case estimate, depending on how
3332
   much information is available to elf_backend_omit_section_dynsym at
3333
   the current linking stage.  */
3334
 
3335
static bfd_size_type
3336
count_section_dynsyms (bfd *output_bfd, struct bfd_link_info *info)
3337
{
3338
  bfd_size_type count;
3339
 
3340
  count = 0;
3341
  if (info->shared || elf_hash_table (info)->is_relocatable_executable)
3342
    {
3343
      asection *p;
3344
      const struct elf_backend_data *bed;
3345
 
3346
      bed = get_elf_backend_data (output_bfd);
3347
      for (p = output_bfd->sections; p ; p = p->next)
3348
        if ((p->flags & SEC_EXCLUDE) == 0
3349
            && (p->flags & SEC_ALLOC) != 0
3350
            && !(*bed->elf_backend_omit_section_dynsym) (output_bfd, info, p))
3351
          ++count;
3352
    }
3353
  return count;
3354
}
3355
 
3356 24 jeremybenn
/* Sort the dynamic symbol table so that symbols that need GOT entries
3357 225 jeremybenn
   appear towards the end.  */
3358 24 jeremybenn
 
3359
static bfd_boolean
3360 225 jeremybenn
mips_elf_sort_hash_table (bfd *abfd, struct bfd_link_info *info)
3361 24 jeremybenn
{
3362 225 jeremybenn
  struct mips_elf_link_hash_table *htab;
3363 24 jeremybenn
  struct mips_elf_hash_sort_data hsd;
3364
  struct mips_got_info *g;
3365
 
3366 225 jeremybenn
  if (elf_hash_table (info)->dynsymcount == 0)
3367
    return TRUE;
3368 24 jeremybenn
 
3369 225 jeremybenn
  htab = mips_elf_hash_table (info);
3370
  g = htab->got_info;
3371
  if (g == NULL)
3372
    return TRUE;
3373 24 jeremybenn
 
3374
  hsd.low = NULL;
3375 225 jeremybenn
  hsd.max_unref_got_dynindx
3376
    = hsd.min_got_dynindx
3377
    = (elf_hash_table (info)->dynsymcount - g->reloc_only_gotno);
3378
  hsd.max_non_got_dynindx = count_section_dynsyms (abfd, info) + 1;
3379 24 jeremybenn
  mips_elf_link_hash_traverse (((struct mips_elf_link_hash_table *)
3380
                                elf_hash_table (info)),
3381
                               mips_elf_sort_hash_table_f,
3382
                               &hsd);
3383
 
3384
  /* There should have been enough room in the symbol table to
3385
     accommodate both the GOT and non-GOT symbols.  */
3386
  BFD_ASSERT (hsd.max_non_got_dynindx <= hsd.min_got_dynindx);
3387 225 jeremybenn
  BFD_ASSERT ((unsigned long) hsd.max_unref_got_dynindx
3388
              == elf_hash_table (info)->dynsymcount);
3389
  BFD_ASSERT (elf_hash_table (info)->dynsymcount - hsd.min_got_dynindx
3390
              == g->global_gotno);
3391 24 jeremybenn
 
3392
  /* Now we know which dynamic symbol has the lowest dynamic symbol
3393
     table index in the GOT.  */
3394
  g->global_gotsym = hsd.low;
3395
 
3396
  return TRUE;
3397
}
3398
 
3399
/* If H needs a GOT entry, assign it the highest available dynamic
3400
   index.  Otherwise, assign it the lowest available dynamic
3401
   index.  */
3402
 
3403
static bfd_boolean
3404
mips_elf_sort_hash_table_f (struct mips_elf_link_hash_entry *h, void *data)
3405
{
3406
  struct mips_elf_hash_sort_data *hsd = data;
3407
 
3408
  if (h->root.root.type == bfd_link_hash_warning)
3409
    h = (struct mips_elf_link_hash_entry *) h->root.root.u.i.link;
3410
 
3411
  /* Symbols without dynamic symbol table entries aren't interesting
3412
     at all.  */
3413
  if (h->root.dynindx == -1)
3414
    return TRUE;
3415
 
3416 225 jeremybenn
  switch (h->global_got_area)
3417 24 jeremybenn
    {
3418 225 jeremybenn
    case GGA_NONE:
3419
      h->root.dynindx = hsd->max_non_got_dynindx++;
3420
      break;
3421
 
3422
    case GGA_NORMAL:
3423 24 jeremybenn
      BFD_ASSERT (h->tls_type == GOT_NORMAL);
3424
 
3425 225 jeremybenn
      h->root.dynindx = --hsd->min_got_dynindx;
3426
      hsd->low = (struct elf_link_hash_entry *) h;
3427
      break;
3428
 
3429
    case GGA_RELOC_ONLY:
3430
      BFD_ASSERT (h->tls_type == GOT_NORMAL);
3431
 
3432 24 jeremybenn
      if (hsd->max_unref_got_dynindx == hsd->min_got_dynindx)
3433
        hsd->low = (struct elf_link_hash_entry *) h;
3434
      h->root.dynindx = hsd->max_unref_got_dynindx++;
3435 225 jeremybenn
      break;
3436 24 jeremybenn
    }
3437
 
3438
  return TRUE;
3439
}
3440
 
3441
/* If H is a symbol that needs a global GOT entry, but has a dynamic
3442
   symbol table index lower than any we've seen to date, record it for
3443
   posterity.  */
3444
 
3445
static bfd_boolean
3446
mips_elf_record_global_got_symbol (struct elf_link_hash_entry *h,
3447
                                   bfd *abfd, struct bfd_link_info *info,
3448
                                   unsigned char tls_flag)
3449
{
3450 225 jeremybenn
  struct mips_elf_link_hash_table *htab;
3451
  struct mips_elf_link_hash_entry *hmips;
3452 24 jeremybenn
  struct mips_got_entry entry, **loc;
3453 225 jeremybenn
  struct mips_got_info *g;
3454 24 jeremybenn
 
3455 225 jeremybenn
  htab = mips_elf_hash_table (info);
3456
  hmips = (struct mips_elf_link_hash_entry *) h;
3457
 
3458 24 jeremybenn
  /* A global symbol in the GOT must also be in the dynamic symbol
3459
     table.  */
3460
  if (h->dynindx == -1)
3461
    {
3462
      switch (ELF_ST_VISIBILITY (h->other))
3463
        {
3464
        case STV_INTERNAL:
3465
        case STV_HIDDEN:
3466 225 jeremybenn
          _bfd_elf_link_hash_hide_symbol (info, h, TRUE);
3467 24 jeremybenn
          break;
3468
        }
3469
      if (!bfd_elf_link_record_dynamic_symbol (info, h))
3470
        return FALSE;
3471
    }
3472
 
3473
  /* Make sure we have a GOT to put this entry into.  */
3474 225 jeremybenn
  g = htab->got_info;
3475 24 jeremybenn
  BFD_ASSERT (g != NULL);
3476
 
3477
  entry.abfd = abfd;
3478
  entry.symndx = -1;
3479
  entry.d.h = (struct mips_elf_link_hash_entry *) h;
3480
  entry.tls_type = 0;
3481
 
3482
  loc = (struct mips_got_entry **) htab_find_slot (g->got_entries, &entry,
3483
                                                   INSERT);
3484
 
3485
  /* If we've already marked this entry as needing GOT space, we don't
3486
     need to do it again.  */
3487
  if (*loc)
3488
    {
3489
      (*loc)->tls_type |= tls_flag;
3490
      return TRUE;
3491
    }
3492
 
3493
  *loc = (struct mips_got_entry *)bfd_alloc (abfd, sizeof entry);
3494
 
3495
  if (! *loc)
3496
    return FALSE;
3497
 
3498
  entry.gotidx = -1;
3499
  entry.tls_type = tls_flag;
3500
 
3501
  memcpy (*loc, &entry, sizeof entry);
3502
 
3503
  if (tls_flag == 0)
3504 225 jeremybenn
    hmips->global_got_area = GGA_NORMAL;
3505 24 jeremybenn
 
3506
  return TRUE;
3507
}
3508
 
3509
/* Reserve space in G for a GOT entry containing the value of symbol
3510
   SYMNDX in input bfd ABDF, plus ADDEND.  */
3511
 
3512
static bfd_boolean
3513
mips_elf_record_local_got_symbol (bfd *abfd, long symndx, bfd_vma addend,
3514 225 jeremybenn
                                  struct bfd_link_info *info,
3515 24 jeremybenn
                                  unsigned char tls_flag)
3516
{
3517 225 jeremybenn
  struct mips_elf_link_hash_table *htab;
3518
  struct mips_got_info *g;
3519 24 jeremybenn
  struct mips_got_entry entry, **loc;
3520
 
3521 225 jeremybenn
  htab = mips_elf_hash_table (info);
3522
  g = htab->got_info;
3523
  BFD_ASSERT (g != NULL);
3524
 
3525 24 jeremybenn
  entry.abfd = abfd;
3526
  entry.symndx = symndx;
3527
  entry.d.addend = addend;
3528
  entry.tls_type = tls_flag;
3529
  loc = (struct mips_got_entry **)
3530
    htab_find_slot (g->got_entries, &entry, INSERT);
3531
 
3532
  if (*loc)
3533
    {
3534
      if (tls_flag == GOT_TLS_GD && !((*loc)->tls_type & GOT_TLS_GD))
3535
        {
3536
          g->tls_gotno += 2;
3537
          (*loc)->tls_type |= tls_flag;
3538
        }
3539
      else if (tls_flag == GOT_TLS_IE && !((*loc)->tls_type & GOT_TLS_IE))
3540
        {
3541
          g->tls_gotno += 1;
3542
          (*loc)->tls_type |= tls_flag;
3543
        }
3544
      return TRUE;
3545
    }
3546
 
3547
  if (tls_flag != 0)
3548
    {
3549
      entry.gotidx = -1;
3550
      entry.tls_type = tls_flag;
3551
      if (tls_flag == GOT_TLS_IE)
3552
        g->tls_gotno += 1;
3553
      else if (tls_flag == GOT_TLS_GD)
3554
        g->tls_gotno += 2;
3555
      else if (g->tls_ldm_offset == MINUS_ONE)
3556
        {
3557
          g->tls_ldm_offset = MINUS_TWO;
3558
          g->tls_gotno += 2;
3559
        }
3560
    }
3561
  else
3562
    {
3563
      entry.gotidx = g->local_gotno++;
3564
      entry.tls_type = 0;
3565
    }
3566
 
3567
  *loc = (struct mips_got_entry *)bfd_alloc (abfd, sizeof entry);
3568
 
3569
  if (! *loc)
3570
    return FALSE;
3571
 
3572
  memcpy (*loc, &entry, sizeof entry);
3573
 
3574
  return TRUE;
3575
}
3576
 
3577
/* Return the maximum number of GOT page entries required for RANGE.  */
3578
 
3579
static bfd_vma
3580
mips_elf_pages_for_range (const struct mips_got_page_range *range)
3581
{
3582
  return (range->max_addend - range->min_addend + 0x1ffff) >> 16;
3583
}
3584
 
3585 225 jeremybenn
/* Record that ABFD has a page relocation against symbol SYMNDX and
3586
   that ADDEND is the addend for that relocation.
3587 24 jeremybenn
 
3588 225 jeremybenn
   This function creates an upper bound on the number of GOT slots
3589
   required; no attempt is made to combine references to non-overridable
3590
   global symbols across multiple input files.  */
3591
 
3592 24 jeremybenn
static bfd_boolean
3593 225 jeremybenn
mips_elf_record_got_page_entry (struct bfd_link_info *info, bfd *abfd,
3594
                                long symndx, bfd_signed_vma addend)
3595 24 jeremybenn
{
3596 225 jeremybenn
  struct mips_elf_link_hash_table *htab;
3597
  struct mips_got_info *g;
3598 24 jeremybenn
  struct mips_got_page_entry lookup, *entry;
3599
  struct mips_got_page_range **range_ptr, *range;
3600
  bfd_vma old_pages, new_pages;
3601
  void **loc;
3602
 
3603 225 jeremybenn
  htab = mips_elf_hash_table (info);
3604
  g = htab->got_info;
3605
  BFD_ASSERT (g != NULL);
3606
 
3607 24 jeremybenn
  /* Find the mips_got_page_entry hash table entry for this symbol.  */
3608
  lookup.abfd = abfd;
3609
  lookup.symndx = symndx;
3610
  loc = htab_find_slot (g->got_page_entries, &lookup, INSERT);
3611
  if (loc == NULL)
3612
    return FALSE;
3613
 
3614
  /* Create a mips_got_page_entry if this is the first time we've
3615
     seen the symbol.  */
3616
  entry = (struct mips_got_page_entry *) *loc;
3617
  if (!entry)
3618
    {
3619
      entry = bfd_alloc (abfd, sizeof (*entry));
3620
      if (!entry)
3621
        return FALSE;
3622
 
3623
      entry->abfd = abfd;
3624
      entry->symndx = symndx;
3625
      entry->ranges = NULL;
3626
      entry->num_pages = 0;
3627
      *loc = entry;
3628
    }
3629
 
3630
  /* Skip over ranges whose maximum extent cannot share a page entry
3631
     with ADDEND.  */
3632
  range_ptr = &entry->ranges;
3633
  while (*range_ptr && addend > (*range_ptr)->max_addend + 0xffff)
3634
    range_ptr = &(*range_ptr)->next;
3635
 
3636
  /* If we scanned to the end of the list, or found a range whose
3637
     minimum extent cannot share a page entry with ADDEND, create
3638
     a new singleton range.  */
3639
  range = *range_ptr;
3640
  if (!range || addend < range->min_addend - 0xffff)
3641
    {
3642
      range = bfd_alloc (abfd, sizeof (*range));
3643
      if (!range)
3644
        return FALSE;
3645
 
3646
      range->next = *range_ptr;
3647
      range->min_addend = addend;
3648
      range->max_addend = addend;
3649
 
3650
      *range_ptr = range;
3651
      entry->num_pages++;
3652
      g->page_gotno++;
3653
      return TRUE;
3654
    }
3655
 
3656
  /* Remember how many pages the old range contributed.  */
3657
  old_pages = mips_elf_pages_for_range (range);
3658
 
3659
  /* Update the ranges.  */
3660
  if (addend < range->min_addend)
3661
    range->min_addend = addend;
3662
  else if (addend > range->max_addend)
3663
    {
3664
      if (range->next && addend >= range->next->min_addend - 0xffff)
3665
        {
3666
          old_pages += mips_elf_pages_for_range (range->next);
3667
          range->max_addend = range->next->max_addend;
3668
          range->next = range->next->next;
3669
        }
3670
      else
3671
        range->max_addend = addend;
3672
    }
3673
 
3674
  /* Record any change in the total estimate.  */
3675
  new_pages = mips_elf_pages_for_range (range);
3676
  if (old_pages != new_pages)
3677
    {
3678
      entry->num_pages += new_pages - old_pages;
3679
      g->page_gotno += new_pages - old_pages;
3680
    }
3681
 
3682
  return TRUE;
3683
}
3684 225 jeremybenn
 
3685
/* Add room for N relocations to the .rel(a).dyn section in ABFD.  */
3686
 
3687
static void
3688
mips_elf_allocate_dynamic_relocations (bfd *abfd, struct bfd_link_info *info,
3689
                                       unsigned int n)
3690
{
3691
  asection *s;
3692
  struct mips_elf_link_hash_table *htab;
3693
 
3694
  htab = mips_elf_hash_table (info);
3695
  s = mips_elf_rel_dyn_section (info, FALSE);
3696
  BFD_ASSERT (s != NULL);
3697
 
3698
  if (htab->is_vxworks)
3699
    s->size += n * MIPS_ELF_RELA_SIZE (abfd);
3700
  else
3701
    {
3702
      if (s->size == 0)
3703
        {
3704
          /* Make room for a null element.  */
3705
          s->size += MIPS_ELF_REL_SIZE (abfd);
3706
          ++s->reloc_count;
3707
        }
3708
      s->size += n * MIPS_ELF_REL_SIZE (abfd);
3709
    }
3710
}
3711 24 jeremybenn
 
3712 225 jeremybenn
/* A htab_traverse callback for GOT entries.  Set boolean *DATA to true
3713
   if the GOT entry is for an indirect or warning symbol.  */
3714
 
3715
static int
3716
mips_elf_check_recreate_got (void **entryp, void *data)
3717
{
3718
  struct mips_got_entry *entry;
3719
  bfd_boolean *must_recreate;
3720
 
3721
  entry = (struct mips_got_entry *) *entryp;
3722
  must_recreate = (bfd_boolean *) data;
3723
  if (entry->abfd != NULL && entry->symndx == -1)
3724
    {
3725
      struct mips_elf_link_hash_entry *h;
3726
 
3727
      h = entry->d.h;
3728
      if (h->root.root.type == bfd_link_hash_indirect
3729
          || h->root.root.type == bfd_link_hash_warning)
3730
        {
3731
          *must_recreate = TRUE;
3732
          return 0;
3733
        }
3734
    }
3735
  return 1;
3736
}
3737
 
3738
/* A htab_traverse callback for GOT entries.  Add all entries to
3739
   hash table *DATA, converting entries for indirect and warning
3740
   symbols into entries for the target symbol.  Set *DATA to null
3741
   on error.  */
3742
 
3743
static int
3744
mips_elf_recreate_got (void **entryp, void *data)
3745
{
3746
  htab_t *new_got;
3747
  struct mips_got_entry *entry;
3748
  void **slot;
3749
 
3750
  new_got = (htab_t *) data;
3751
  entry = (struct mips_got_entry *) *entryp;
3752
  if (entry->abfd != NULL && entry->symndx == -1)
3753
    {
3754
      struct mips_elf_link_hash_entry *h;
3755
 
3756
      h = entry->d.h;
3757
      while (h->root.root.type == bfd_link_hash_indirect
3758
             || h->root.root.type == bfd_link_hash_warning)
3759
        {
3760
          BFD_ASSERT (h->global_got_area == GGA_NONE);
3761
          h = (struct mips_elf_link_hash_entry *) h->root.root.u.i.link;
3762
        }
3763
      entry->d.h = h;
3764
    }
3765
  slot = htab_find_slot (*new_got, entry, INSERT);
3766
  if (slot == NULL)
3767
    {
3768
      *new_got = NULL;
3769
      return 0;
3770
    }
3771
  if (*slot == NULL)
3772
    *slot = entry;
3773
  else
3774
    free (entry);
3775
  return 1;
3776
}
3777
 
3778
/* If any entries in G->got_entries are for indirect or warning symbols,
3779
   replace them with entries for the target symbol.  */
3780
 
3781
static bfd_boolean
3782
mips_elf_resolve_final_got_entries (struct mips_got_info *g)
3783
{
3784
  bfd_boolean must_recreate;
3785
  htab_t new_got;
3786
 
3787
  must_recreate = FALSE;
3788
  htab_traverse (g->got_entries, mips_elf_check_recreate_got, &must_recreate);
3789
  if (must_recreate)
3790
    {
3791
      new_got = htab_create (htab_size (g->got_entries),
3792
                             mips_elf_got_entry_hash,
3793
                             mips_elf_got_entry_eq, NULL);
3794
      htab_traverse (g->got_entries, mips_elf_recreate_got, &new_got);
3795
      if (new_got == NULL)
3796
        return FALSE;
3797
 
3798
      /* Each entry in g->got_entries has either been copied to new_got
3799
         or freed.  Now delete the hash table itself.  */
3800
      htab_delete (g->got_entries);
3801
      g->got_entries = new_got;
3802
    }
3803
  return TRUE;
3804
}
3805
 
3806
/* A mips_elf_link_hash_traverse callback for which DATA points
3807
   to a mips_got_info.  Count the number of type (3) entries.  */
3808
 
3809
static int
3810
mips_elf_count_got_symbols (struct mips_elf_link_hash_entry *h, void *data)
3811
{
3812
  struct mips_got_info *g;
3813
 
3814
  g = (struct mips_got_info *) data;
3815
  if (h->global_got_area != GGA_NONE)
3816
    {
3817
      if (h->root.forced_local || h->root.dynindx == -1)
3818
        {
3819
          /* We no longer need this entry if it was only used for
3820
             relocations; those relocations will be against the
3821
             null or section symbol instead of H.  */
3822
          if (h->global_got_area != GGA_RELOC_ONLY)
3823
            g->local_gotno++;
3824
          h->global_got_area = GGA_NONE;
3825
        }
3826
      else
3827
        {
3828
          g->global_gotno++;
3829
          if (h->global_got_area == GGA_RELOC_ONLY)
3830
            g->reloc_only_gotno++;
3831
        }
3832
    }
3833
  return 1;
3834
}
3835
 
3836 24 jeremybenn
/* Compute the hash value of the bfd in a bfd2got hash entry.  */
3837
 
3838
static hashval_t
3839
mips_elf_bfd2got_entry_hash (const void *entry_)
3840
{
3841
  const struct mips_elf_bfd2got_hash *entry
3842
    = (struct mips_elf_bfd2got_hash *)entry_;
3843
 
3844
  return entry->bfd->id;
3845
}
3846
 
3847
/* Check whether two hash entries have the same bfd.  */
3848
 
3849
static int
3850
mips_elf_bfd2got_entry_eq (const void *entry1, const void *entry2)
3851
{
3852
  const struct mips_elf_bfd2got_hash *e1
3853
    = (const struct mips_elf_bfd2got_hash *)entry1;
3854
  const struct mips_elf_bfd2got_hash *e2
3855
    = (const struct mips_elf_bfd2got_hash *)entry2;
3856
 
3857
  return e1->bfd == e2->bfd;
3858
}
3859
 
3860
/* In a multi-got link, determine the GOT to be used for IBFD.  G must
3861
   be the master GOT data.  */
3862
 
3863
static struct mips_got_info *
3864
mips_elf_got_for_ibfd (struct mips_got_info *g, bfd *ibfd)
3865
{
3866
  struct mips_elf_bfd2got_hash e, *p;
3867
 
3868
  if (! g->bfd2got)
3869
    return g;
3870
 
3871
  e.bfd = ibfd;
3872
  p = htab_find (g->bfd2got, &e);
3873
  return p ? p->g : NULL;
3874
}
3875
 
3876
/* Use BFD2GOT to find ABFD's got entry, creating one if none exists.
3877
   Return NULL if an error occured.  */
3878
 
3879
static struct mips_got_info *
3880
mips_elf_get_got_for_bfd (struct htab *bfd2got, bfd *output_bfd,
3881
                          bfd *input_bfd)
3882
{
3883
  struct mips_elf_bfd2got_hash bfdgot_entry, *bfdgot;
3884
  struct mips_got_info *g;
3885
  void **bfdgotp;
3886
 
3887
  bfdgot_entry.bfd = input_bfd;
3888
  bfdgotp = htab_find_slot (bfd2got, &bfdgot_entry, INSERT);
3889
  bfdgot = (struct mips_elf_bfd2got_hash *) *bfdgotp;
3890
 
3891
  if (bfdgot == NULL)
3892
    {
3893
      bfdgot = ((struct mips_elf_bfd2got_hash *)
3894
                bfd_alloc (output_bfd, sizeof (struct mips_elf_bfd2got_hash)));
3895
      if (bfdgot == NULL)
3896
        return NULL;
3897
 
3898
      *bfdgotp = bfdgot;
3899
 
3900
      g = ((struct mips_got_info *)
3901
           bfd_alloc (output_bfd, sizeof (struct mips_got_info)));
3902
      if (g == NULL)
3903
        return NULL;
3904
 
3905
      bfdgot->bfd = input_bfd;
3906
      bfdgot->g = g;
3907
 
3908
      g->global_gotsym = NULL;
3909
      g->global_gotno = 0;
3910 225 jeremybenn
      g->reloc_only_gotno = 0;
3911 24 jeremybenn
      g->local_gotno = 0;
3912
      g->page_gotno = 0;
3913
      g->assigned_gotno = -1;
3914
      g->tls_gotno = 0;
3915
      g->tls_assigned_gotno = 0;
3916
      g->tls_ldm_offset = MINUS_ONE;
3917
      g->got_entries = htab_try_create (1, mips_elf_multi_got_entry_hash,
3918
                                        mips_elf_multi_got_entry_eq, NULL);
3919
      if (g->got_entries == NULL)
3920
        return NULL;
3921
 
3922
      g->got_page_entries = htab_try_create (1, mips_got_page_entry_hash,
3923
                                             mips_got_page_entry_eq, NULL);
3924
      if (g->got_page_entries == NULL)
3925
        return NULL;
3926
 
3927
      g->bfd2got = NULL;
3928
      g->next = NULL;
3929
    }
3930
 
3931
  return bfdgot->g;
3932
}
3933
 
3934
/* A htab_traverse callback for the entries in the master got.
3935
   Create one separate got for each bfd that has entries in the global
3936
   got, such that we can tell how many local and global entries each
3937
   bfd requires.  */
3938
 
3939
static int
3940
mips_elf_make_got_per_bfd (void **entryp, void *p)
3941
{
3942
  struct mips_got_entry *entry = (struct mips_got_entry *)*entryp;
3943
  struct mips_elf_got_per_bfd_arg *arg = (struct mips_elf_got_per_bfd_arg *)p;
3944
  struct mips_got_info *g;
3945
 
3946
  g = mips_elf_get_got_for_bfd (arg->bfd2got, arg->obfd, entry->abfd);
3947
  if (g == NULL)
3948
    {
3949
      arg->obfd = NULL;
3950
      return 0;
3951
    }
3952
 
3953
  /* Insert the GOT entry in the bfd's got entry hash table.  */
3954
  entryp = htab_find_slot (g->got_entries, entry, INSERT);
3955
  if (*entryp != NULL)
3956
    return 1;
3957
 
3958
  *entryp = entry;
3959
 
3960
  if (entry->tls_type)
3961
    {
3962
      if (entry->tls_type & (GOT_TLS_GD | GOT_TLS_LDM))
3963
        g->tls_gotno += 2;
3964
      if (entry->tls_type & GOT_TLS_IE)
3965
        g->tls_gotno += 1;
3966
    }
3967 225 jeremybenn
  else if (entry->symndx >= 0 || entry->d.h->root.forced_local)
3968 24 jeremybenn
    ++g->local_gotno;
3969
  else
3970
    ++g->global_gotno;
3971
 
3972
  return 1;
3973
}
3974
 
3975
/* A htab_traverse callback for the page entries in the master got.
3976
   Associate each page entry with the bfd's got.  */
3977
 
3978
static int
3979
mips_elf_make_got_pages_per_bfd (void **entryp, void *p)
3980
{
3981
  struct mips_got_page_entry *entry = (struct mips_got_page_entry *) *entryp;
3982
  struct mips_elf_got_per_bfd_arg *arg = (struct mips_elf_got_per_bfd_arg *) p;
3983
  struct mips_got_info *g;
3984
 
3985
  g = mips_elf_get_got_for_bfd (arg->bfd2got, arg->obfd, entry->abfd);
3986
  if (g == NULL)
3987
    {
3988
      arg->obfd = NULL;
3989
      return 0;
3990
    }
3991
 
3992
  /* Insert the GOT entry in the bfd's got entry hash table.  */
3993
  entryp = htab_find_slot (g->got_page_entries, entry, INSERT);
3994
  if (*entryp != NULL)
3995
    return 1;
3996
 
3997
  *entryp = entry;
3998
  g->page_gotno += entry->num_pages;
3999
  return 1;
4000
}
4001
 
4002
/* Consider merging the got described by BFD2GOT with TO, using the
4003
   information given by ARG.  Return -1 if this would lead to overflow,
4004
   1 if they were merged successfully, and 0 if a merge failed due to
4005
   lack of memory.  (These values are chosen so that nonnegative return
4006
   values can be returned by a htab_traverse callback.)  */
4007
 
4008
static int
4009
mips_elf_merge_got_with (struct mips_elf_bfd2got_hash *bfd2got,
4010
                         struct mips_got_info *to,
4011
                         struct mips_elf_got_per_bfd_arg *arg)
4012
{
4013
  struct mips_got_info *from = bfd2got->g;
4014
  unsigned int estimate;
4015
 
4016
  /* Work out how many page entries we would need for the combined GOT.  */
4017
  estimate = arg->max_pages;
4018
  if (estimate >= from->page_gotno + to->page_gotno)
4019
    estimate = from->page_gotno + to->page_gotno;
4020
 
4021
  /* And conservatively estimate how many local, global and TLS entries
4022
     would be needed.  */
4023
  estimate += (from->local_gotno
4024
               + from->global_gotno
4025
               + from->tls_gotno
4026
               + to->local_gotno
4027
               + to->global_gotno
4028
               + to->tls_gotno);
4029
 
4030
  /* Bail out if the combined GOT might be too big.  */
4031
  if (estimate > arg->max_count)
4032
    return -1;
4033
 
4034
  /* Commit to the merge.  Record that TO is now the bfd for this got.  */
4035
  bfd2got->g = to;
4036
 
4037
  /* Transfer the bfd's got information from FROM to TO.  */
4038
  htab_traverse (from->got_entries, mips_elf_make_got_per_bfd, arg);
4039
  if (arg->obfd == NULL)
4040
    return 0;
4041
 
4042
  htab_traverse (from->got_page_entries, mips_elf_make_got_pages_per_bfd, arg);
4043
  if (arg->obfd == NULL)
4044
    return 0;
4045
 
4046
  /* We don't have to worry about releasing memory of the actual
4047
     got entries, since they're all in the master got_entries hash
4048
     table anyway.  */
4049
  htab_delete (from->got_entries);
4050
  htab_delete (from->got_page_entries);
4051
  return 1;
4052
}
4053
 
4054
/* Attempt to merge gots of different input bfds.  Try to use as much
4055
   as possible of the primary got, since it doesn't require explicit
4056
   dynamic relocations, but don't use bfds that would reference global
4057
   symbols out of the addressable range.  Failing the primary got,
4058
   attempt to merge with the current got, or finish the current got
4059
   and then make make the new got current.  */
4060
 
4061
static int
4062
mips_elf_merge_gots (void **bfd2got_, void *p)
4063
{
4064
  struct mips_elf_bfd2got_hash *bfd2got
4065
    = (struct mips_elf_bfd2got_hash *)*bfd2got_;
4066
  struct mips_elf_got_per_bfd_arg *arg = (struct mips_elf_got_per_bfd_arg *)p;
4067
  struct mips_got_info *g;
4068
  unsigned int estimate;
4069
  int result;
4070
 
4071
  g = bfd2got->g;
4072
 
4073
  /* Work out the number of page, local and TLS entries.  */
4074
  estimate = arg->max_pages;
4075
  if (estimate > g->page_gotno)
4076
    estimate = g->page_gotno;
4077
  estimate += g->local_gotno + g->tls_gotno;
4078
 
4079
  /* We place TLS GOT entries after both locals and globals.  The globals
4080
     for the primary GOT may overflow the normal GOT size limit, so be
4081
     sure not to merge a GOT which requires TLS with the primary GOT in that
4082
     case.  This doesn't affect non-primary GOTs.  */
4083
  estimate += (g->tls_gotno > 0 ? arg->global_count : g->global_gotno);
4084
 
4085
  if (estimate <= arg->max_count)
4086
    {
4087
      /* If we don't have a primary GOT, use it as
4088
         a starting point for the primary GOT.  */
4089
      if (!arg->primary)
4090
        {
4091
          arg->primary = bfd2got->g;
4092
          return 1;
4093
        }
4094
 
4095
      /* Try merging with the primary GOT.  */
4096
      result = mips_elf_merge_got_with (bfd2got, arg->primary, arg);
4097
      if (result >= 0)
4098
        return result;
4099
    }
4100
 
4101
  /* If we can merge with the last-created got, do it.  */
4102
  if (arg->current)
4103
    {
4104
      result = mips_elf_merge_got_with (bfd2got, arg->current, arg);
4105
      if (result >= 0)
4106
        return result;
4107
    }
4108
 
4109
  /* Well, we couldn't merge, so create a new GOT.  Don't check if it
4110
     fits; if it turns out that it doesn't, we'll get relocation
4111
     overflows anyway.  */
4112
  g->next = arg->current;
4113
  arg->current = g;
4114
 
4115
  return 1;
4116
}
4117
 
4118
/* Set the TLS GOT index for the GOT entry in ENTRYP.  ENTRYP's NEXT field
4119
   is null iff there is just a single GOT.  */
4120
 
4121
static int
4122
mips_elf_initialize_tls_index (void **entryp, void *p)
4123
{
4124
  struct mips_got_entry *entry = (struct mips_got_entry *)*entryp;
4125
  struct mips_got_info *g = p;
4126
  bfd_vma next_index;
4127
  unsigned char tls_type;
4128
 
4129
  /* We're only interested in TLS symbols.  */
4130
  if (entry->tls_type == 0)
4131
    return 1;
4132
 
4133
  next_index = MIPS_ELF_GOT_SIZE (entry->abfd) * (long) g->tls_assigned_gotno;
4134
 
4135
  if (entry->symndx == -1 && g->next == NULL)
4136
    {
4137
      /* A type (3) got entry in the single-GOT case.  We use the symbol's
4138
         hash table entry to track its index.  */
4139
      if (entry->d.h->tls_type & GOT_TLS_OFFSET_DONE)
4140
        return 1;
4141
      entry->d.h->tls_type |= GOT_TLS_OFFSET_DONE;
4142
      entry->d.h->tls_got_offset = next_index;
4143
      tls_type = entry->d.h->tls_type;
4144
    }
4145
  else
4146
    {
4147
      if (entry->tls_type & GOT_TLS_LDM)
4148
        {
4149
          /* There are separate mips_got_entry objects for each input bfd
4150
             that requires an LDM entry.  Make sure that all LDM entries in
4151
             a GOT resolve to the same index.  */
4152
          if (g->tls_ldm_offset != MINUS_TWO && g->tls_ldm_offset != MINUS_ONE)
4153
            {
4154
              entry->gotidx = g->tls_ldm_offset;
4155
              return 1;
4156
            }
4157
          g->tls_ldm_offset = next_index;
4158
        }
4159
      entry->gotidx = next_index;
4160
      tls_type = entry->tls_type;
4161
    }
4162
 
4163
  /* Account for the entries we've just allocated.  */
4164
  if (tls_type & (GOT_TLS_GD | GOT_TLS_LDM))
4165
    g->tls_assigned_gotno += 2;
4166
  if (tls_type & GOT_TLS_IE)
4167
    g->tls_assigned_gotno += 1;
4168
 
4169
  return 1;
4170
}
4171
 
4172
/* If passed a NULL mips_got_info in the argument, set the marker used
4173
   to tell whether a global symbol needs a got entry (in the primary
4174
   got) to the given VALUE.
4175
 
4176
   If passed a pointer G to a mips_got_info in the argument (it must
4177
   not be the primary GOT), compute the offset from the beginning of
4178
   the (primary) GOT section to the entry in G corresponding to the
4179
   global symbol.  G's assigned_gotno must contain the index of the
4180
   first available global GOT entry in G.  VALUE must contain the size
4181
   of a GOT entry in bytes.  For each global GOT entry that requires a
4182
   dynamic relocation, NEEDED_RELOCS is incremented, and the symbol is
4183
   marked as not eligible for lazy resolution through a function
4184
   stub.  */
4185
static int
4186
mips_elf_set_global_got_offset (void **entryp, void *p)
4187
{
4188
  struct mips_got_entry *entry = (struct mips_got_entry *)*entryp;
4189
  struct mips_elf_set_global_got_offset_arg *arg
4190
    = (struct mips_elf_set_global_got_offset_arg *)p;
4191
  struct mips_got_info *g = arg->g;
4192
 
4193
  if (g && entry->tls_type != GOT_NORMAL)
4194
    arg->needed_relocs +=
4195
      mips_tls_got_relocs (arg->info, entry->tls_type,
4196
                           entry->symndx == -1 ? &entry->d.h->root : NULL);
4197
 
4198 225 jeremybenn
  if (entry->abfd != NULL
4199
      && entry->symndx == -1
4200
      && entry->d.h->global_got_area != GGA_NONE)
4201 24 jeremybenn
    {
4202
      if (g)
4203
        {
4204
          BFD_ASSERT (g->global_gotsym == NULL);
4205
 
4206
          entry->gotidx = arg->value * (long) g->assigned_gotno++;
4207
          if (arg->info->shared
4208
              || (elf_hash_table (arg->info)->dynamic_sections_created
4209
                  && entry->d.h->root.def_dynamic
4210
                  && !entry->d.h->root.def_regular))
4211
            ++arg->needed_relocs;
4212
        }
4213
      else
4214 225 jeremybenn
        entry->d.h->global_got_area = arg->value;
4215 24 jeremybenn
    }
4216
 
4217
  return 1;
4218
}
4219
 
4220 225 jeremybenn
/* A htab_traverse callback for GOT entries for which DATA is the
4221
   bfd_link_info.  Forbid any global symbols from having traditional
4222
   lazy-binding stubs.  */
4223
 
4224 24 jeremybenn
static int
4225 225 jeremybenn
mips_elf_forbid_lazy_stubs (void **entryp, void *data)
4226 24 jeremybenn
{
4227 225 jeremybenn
  struct bfd_link_info *info;
4228
  struct mips_elf_link_hash_table *htab;
4229
  struct mips_got_entry *entry;
4230 24 jeremybenn
 
4231 225 jeremybenn
  entry = (struct mips_got_entry *) *entryp;
4232
  info = (struct bfd_link_info *) data;
4233
  htab = mips_elf_hash_table (info);
4234 24 jeremybenn
  if (entry->abfd != NULL
4235
      && entry->symndx == -1
4236 225 jeremybenn
      && entry->d.h->needs_lazy_stub)
4237 24 jeremybenn
    {
4238 225 jeremybenn
      entry->d.h->needs_lazy_stub = FALSE;
4239
      htab->lazy_stub_count--;
4240 24 jeremybenn
    }
4241
 
4242
  return 1;
4243
}
4244
 
4245
/* Return the offset of an input bfd IBFD's GOT from the beginning of
4246
   the primary GOT.  */
4247
static bfd_vma
4248
mips_elf_adjust_gp (bfd *abfd, struct mips_got_info *g, bfd *ibfd)
4249
{
4250
  if (g->bfd2got == NULL)
4251
    return 0;
4252
 
4253
  g = mips_elf_got_for_ibfd (g, ibfd);
4254
  if (! g)
4255
    return 0;
4256
 
4257
  BFD_ASSERT (g->next);
4258
 
4259
  g = g->next;
4260
 
4261
  return (g->local_gotno + g->global_gotno + g->tls_gotno)
4262
    * MIPS_ELF_GOT_SIZE (abfd);
4263
}
4264
 
4265
/* Turn a single GOT that is too big for 16-bit addressing into
4266
   a sequence of GOTs, each one 16-bit addressable.  */
4267
 
4268
static bfd_boolean
4269
mips_elf_multi_got (bfd *abfd, struct bfd_link_info *info,
4270 225 jeremybenn
                    asection *got, bfd_size_type pages)
4271 24 jeremybenn
{
4272 225 jeremybenn
  struct mips_elf_link_hash_table *htab;
4273 24 jeremybenn
  struct mips_elf_got_per_bfd_arg got_per_bfd_arg;
4274
  struct mips_elf_set_global_got_offset_arg set_got_offset_arg;
4275 225 jeremybenn
  struct mips_got_info *g, *gg;
4276
  unsigned int assign, needed_relocs;
4277
  bfd *dynobj;
4278 24 jeremybenn
 
4279 225 jeremybenn
  dynobj = elf_hash_table (info)->dynobj;
4280
  htab = mips_elf_hash_table (info);
4281
  g = htab->got_info;
4282 24 jeremybenn
  g->bfd2got = htab_try_create (1, mips_elf_bfd2got_entry_hash,
4283
                                mips_elf_bfd2got_entry_eq, NULL);
4284
  if (g->bfd2got == NULL)
4285
    return FALSE;
4286
 
4287
  got_per_bfd_arg.bfd2got = g->bfd2got;
4288
  got_per_bfd_arg.obfd = abfd;
4289
  got_per_bfd_arg.info = info;
4290
 
4291
  /* Count how many GOT entries each input bfd requires, creating a
4292
     map from bfd to got info while at that.  */
4293
  htab_traverse (g->got_entries, mips_elf_make_got_per_bfd, &got_per_bfd_arg);
4294
  if (got_per_bfd_arg.obfd == NULL)
4295
    return FALSE;
4296
 
4297
  /* Also count how many page entries each input bfd requires.  */
4298
  htab_traverse (g->got_page_entries, mips_elf_make_got_pages_per_bfd,
4299
                 &got_per_bfd_arg);
4300
  if (got_per_bfd_arg.obfd == NULL)
4301
    return FALSE;
4302
 
4303
  got_per_bfd_arg.current = NULL;
4304
  got_per_bfd_arg.primary = NULL;
4305
  got_per_bfd_arg.max_count = ((MIPS_ELF_GOT_MAX_SIZE (info)
4306
                                / MIPS_ELF_GOT_SIZE (abfd))
4307 225 jeremybenn
                               - htab->reserved_gotno);
4308 24 jeremybenn
  got_per_bfd_arg.max_pages = pages;
4309
  /* The number of globals that will be included in the primary GOT.
4310
     See the calls to mips_elf_set_global_got_offset below for more
4311
     information.  */
4312
  got_per_bfd_arg.global_count = g->global_gotno;
4313
 
4314
  /* Try to merge the GOTs of input bfds together, as long as they
4315
     don't seem to exceed the maximum GOT size, choosing one of them
4316
     to be the primary GOT.  */
4317
  htab_traverse (g->bfd2got, mips_elf_merge_gots, &got_per_bfd_arg);
4318
  if (got_per_bfd_arg.obfd == NULL)
4319
    return FALSE;
4320
 
4321
  /* If we do not find any suitable primary GOT, create an empty one.  */
4322
  if (got_per_bfd_arg.primary == NULL)
4323
    {
4324
      g->next = (struct mips_got_info *)
4325
        bfd_alloc (abfd, sizeof (struct mips_got_info));
4326
      if (g->next == NULL)
4327
        return FALSE;
4328
 
4329
      g->next->global_gotsym = NULL;
4330
      g->next->global_gotno = 0;
4331 225 jeremybenn
      g->next->reloc_only_gotno = 0;
4332 24 jeremybenn
      g->next->local_gotno = 0;
4333
      g->next->page_gotno = 0;
4334
      g->next->tls_gotno = 0;
4335
      g->next->assigned_gotno = 0;
4336
      g->next->tls_assigned_gotno = 0;
4337
      g->next->tls_ldm_offset = MINUS_ONE;
4338
      g->next->got_entries = htab_try_create (1, mips_elf_multi_got_entry_hash,
4339
                                              mips_elf_multi_got_entry_eq,
4340
                                              NULL);
4341
      if (g->next->got_entries == NULL)
4342
        return FALSE;
4343
      g->next->got_page_entries = htab_try_create (1, mips_got_page_entry_hash,
4344
                                                   mips_got_page_entry_eq,
4345
                                                   NULL);
4346
      if (g->next->got_page_entries == NULL)
4347
        return FALSE;
4348
      g->next->bfd2got = NULL;
4349
    }
4350
  else
4351
    g->next = got_per_bfd_arg.primary;
4352
  g->next->next = got_per_bfd_arg.current;
4353
 
4354
  /* GG is now the master GOT, and G is the primary GOT.  */
4355
  gg = g;
4356
  g = g->next;
4357
 
4358
  /* Map the output bfd to the primary got.  That's what we're going
4359
     to use for bfds that use GOT16 or GOT_PAGE relocations that we
4360
     didn't mark in check_relocs, and we want a quick way to find it.
4361
     We can't just use gg->next because we're going to reverse the
4362
     list.  */
4363
  {
4364
    struct mips_elf_bfd2got_hash *bfdgot;
4365
    void **bfdgotp;
4366
 
4367
    bfdgot = (struct mips_elf_bfd2got_hash *)bfd_alloc
4368
      (abfd, sizeof (struct mips_elf_bfd2got_hash));
4369
 
4370
    if (bfdgot == NULL)
4371
      return FALSE;
4372
 
4373
    bfdgot->bfd = abfd;
4374
    bfdgot->g = g;
4375
    bfdgotp = htab_find_slot (gg->bfd2got, bfdgot, INSERT);
4376
 
4377
    BFD_ASSERT (*bfdgotp == NULL);
4378
    *bfdgotp = bfdgot;
4379
  }
4380
 
4381 225 jeremybenn
  /* Every symbol that is referenced in a dynamic relocation must be
4382
     present in the primary GOT, so arrange for them to appear after
4383
     those that are actually referenced.  */
4384
  gg->reloc_only_gotno = gg->global_gotno - g->global_gotno;
4385
  g->global_gotno = gg->global_gotno;
4386 24 jeremybenn
 
4387
  set_got_offset_arg.g = NULL;
4388 225 jeremybenn
  set_got_offset_arg.value = GGA_RELOC_ONLY;
4389 24 jeremybenn
  htab_traverse (gg->got_entries, mips_elf_set_global_got_offset,
4390
                 &set_got_offset_arg);
4391 225 jeremybenn
  set_got_offset_arg.value = GGA_NORMAL;
4392 24 jeremybenn
  htab_traverse (g->got_entries, mips_elf_set_global_got_offset,
4393
                 &set_got_offset_arg);
4394
 
4395
  /* Now go through the GOTs assigning them offset ranges.
4396
     [assigned_gotno, local_gotno[ will be set to the range of local
4397
     entries in each GOT.  We can then compute the end of a GOT by
4398
     adding local_gotno to global_gotno.  We reverse the list and make
4399
     it circular since then we'll be able to quickly compute the
4400
     beginning of a GOT, by computing the end of its predecessor.  To
4401
     avoid special cases for the primary GOT, while still preserving
4402
     assertions that are valid for both single- and multi-got links,
4403
     we arrange for the main got struct to have the right number of
4404
     global entries, but set its local_gotno such that the initial
4405
     offset of the primary GOT is zero.  Remember that the primary GOT
4406
     will become the last item in the circular linked list, so it
4407
     points back to the master GOT.  */
4408
  gg->local_gotno = -g->global_gotno;
4409
  gg->global_gotno = g->global_gotno;
4410
  gg->tls_gotno = 0;
4411
  assign = 0;
4412
  gg->next = gg;
4413
 
4414
  do
4415
    {
4416
      struct mips_got_info *gn;
4417
 
4418 225 jeremybenn
      assign += htab->reserved_gotno;
4419 24 jeremybenn
      g->assigned_gotno = assign;
4420
      g->local_gotno += assign;
4421
      g->local_gotno += (pages < g->page_gotno ? pages : g->page_gotno);
4422
      assign = g->local_gotno + g->global_gotno + g->tls_gotno;
4423
 
4424
      /* Take g out of the direct list, and push it onto the reversed
4425
         list that gg points to.  g->next is guaranteed to be nonnull after
4426
         this operation, as required by mips_elf_initialize_tls_index. */
4427
      gn = g->next;
4428
      g->next = gg->next;
4429
      gg->next = g;
4430
 
4431
      /* Set up any TLS entries.  We always place the TLS entries after
4432
         all non-TLS entries.  */
4433
      g->tls_assigned_gotno = g->local_gotno + g->global_gotno;
4434
      htab_traverse (g->got_entries, mips_elf_initialize_tls_index, g);
4435
 
4436
      /* Move onto the next GOT.  It will be a secondary GOT if nonull.  */
4437
      g = gn;
4438
 
4439 225 jeremybenn
      /* Forbid global symbols in every non-primary GOT from having
4440
         lazy-binding stubs.  */
4441 24 jeremybenn
      if (g)
4442 225 jeremybenn
        htab_traverse (g->got_entries, mips_elf_forbid_lazy_stubs, info);
4443 24 jeremybenn
    }
4444
  while (g);
4445
 
4446
  got->size = (gg->next->local_gotno
4447 225 jeremybenn
               + gg->next->global_gotno
4448
               + gg->next->tls_gotno) * MIPS_ELF_GOT_SIZE (abfd);
4449 24 jeremybenn
 
4450 225 jeremybenn
  needed_relocs = 0;
4451
  set_got_offset_arg.value = MIPS_ELF_GOT_SIZE (abfd);
4452
  set_got_offset_arg.info = info;
4453
  for (g = gg->next; g && g->next != gg; g = g->next)
4454
    {
4455
      unsigned int save_assign;
4456
 
4457
      /* Assign offsets to global GOT entries.  */
4458
      save_assign = g->assigned_gotno;
4459
      g->assigned_gotno = g->local_gotno;
4460
      set_got_offset_arg.g = g;
4461
      set_got_offset_arg.needed_relocs = 0;
4462
      htab_traverse (g->got_entries,
4463
                     mips_elf_set_global_got_offset,
4464
                     &set_got_offset_arg);
4465
      needed_relocs += set_got_offset_arg.needed_relocs;
4466
      BFD_ASSERT (g->assigned_gotno - g->local_gotno <= g->global_gotno);
4467
 
4468
      g->assigned_gotno = save_assign;
4469
      if (info->shared)
4470
        {
4471
          needed_relocs += g->local_gotno - g->assigned_gotno;
4472
          BFD_ASSERT (g->assigned_gotno == g->next->local_gotno
4473
                      + g->next->global_gotno
4474
                      + g->next->tls_gotno
4475
                      + htab->reserved_gotno);
4476
        }
4477
    }
4478
 
4479
  if (needed_relocs)
4480
    mips_elf_allocate_dynamic_relocations (dynobj, info,
4481
                                           needed_relocs);
4482
 
4483 24 jeremybenn
  return TRUE;
4484
}
4485
 
4486
 
4487
/* Returns the first relocation of type r_type found, beginning with
4488
   RELOCATION.  RELEND is one-past-the-end of the relocation table.  */
4489
 
4490
static const Elf_Internal_Rela *
4491
mips_elf_next_relocation (bfd *abfd ATTRIBUTE_UNUSED, unsigned int r_type,
4492
                          const Elf_Internal_Rela *relocation,
4493
                          const Elf_Internal_Rela *relend)
4494
{
4495
  unsigned long r_symndx = ELF_R_SYM (abfd, relocation->r_info);
4496
 
4497
  while (relocation < relend)
4498
    {
4499
      if (ELF_R_TYPE (abfd, relocation->r_info) == r_type
4500
          && ELF_R_SYM (abfd, relocation->r_info) == r_symndx)
4501
        return relocation;
4502
 
4503
      ++relocation;
4504
    }
4505
 
4506
  /* We didn't find it.  */
4507
  return NULL;
4508
}
4509
 
4510
/* Return whether a relocation is against a local symbol.  */
4511
 
4512
static bfd_boolean
4513
mips_elf_local_relocation_p (bfd *input_bfd,
4514
                             const Elf_Internal_Rela *relocation,
4515
                             asection **local_sections,
4516
                             bfd_boolean check_forced)
4517
{
4518
  unsigned long r_symndx;
4519
  Elf_Internal_Shdr *symtab_hdr;
4520
  struct mips_elf_link_hash_entry *h;
4521
  size_t extsymoff;
4522
 
4523
  r_symndx = ELF_R_SYM (input_bfd, relocation->r_info);
4524
  symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
4525
  extsymoff = (elf_bad_symtab (input_bfd)) ? 0 : symtab_hdr->sh_info;
4526
 
4527
  if (r_symndx < extsymoff)
4528
    return TRUE;
4529
  if (elf_bad_symtab (input_bfd) && local_sections[r_symndx] != NULL)
4530
    return TRUE;
4531
 
4532
  if (check_forced)
4533
    {
4534
      /* Look up the hash table to check whether the symbol
4535
         was forced local.  */
4536
      h = (struct mips_elf_link_hash_entry *)
4537
        elf_sym_hashes (input_bfd) [r_symndx - extsymoff];
4538
      /* Find the real hash-table entry for this symbol.  */
4539
      while (h->root.root.type == bfd_link_hash_indirect
4540
             || h->root.root.type == bfd_link_hash_warning)
4541
        h = (struct mips_elf_link_hash_entry *) h->root.root.u.i.link;
4542
      if (h->root.forced_local)
4543
        return TRUE;
4544
    }
4545
 
4546
  return FALSE;
4547
}
4548
 
4549
/* Sign-extend VALUE, which has the indicated number of BITS.  */
4550
 
4551
bfd_vma
4552
_bfd_mips_elf_sign_extend (bfd_vma value, int bits)
4553
{
4554
  if (value & ((bfd_vma) 1 << (bits - 1)))
4555
    /* VALUE is negative.  */
4556
    value |= ((bfd_vma) - 1) << bits;
4557
 
4558
  return value;
4559
}
4560
 
4561
/* Return non-zero if the indicated VALUE has overflowed the maximum
4562
   range expressible by a signed number with the indicated number of
4563
   BITS.  */
4564
 
4565
static bfd_boolean
4566
mips_elf_overflow_p (bfd_vma value, int bits)
4567
{
4568
  bfd_signed_vma svalue = (bfd_signed_vma) value;
4569
 
4570
  if (svalue > (1 << (bits - 1)) - 1)
4571
    /* The value is too big.  */
4572
    return TRUE;
4573
  else if (svalue < -(1 << (bits - 1)))
4574
    /* The value is too small.  */
4575
    return TRUE;
4576
 
4577
  /* All is well.  */
4578
  return FALSE;
4579
}
4580
 
4581
/* Calculate the %high function.  */
4582
 
4583
static bfd_vma
4584
mips_elf_high (bfd_vma value)
4585
{
4586
  return ((value + (bfd_vma) 0x8000) >> 16) & 0xffff;
4587
}
4588
 
4589
/* Calculate the %higher function.  */
4590
 
4591
static bfd_vma
4592
mips_elf_higher (bfd_vma value ATTRIBUTE_UNUSED)
4593
{
4594
#ifdef BFD64
4595
  return ((value + (bfd_vma) 0x80008000) >> 32) & 0xffff;
4596
#else
4597
  abort ();
4598
  return MINUS_ONE;
4599
#endif
4600
}
4601
 
4602
/* Calculate the %highest function.  */
4603
 
4604
static bfd_vma
4605
mips_elf_highest (bfd_vma value ATTRIBUTE_UNUSED)
4606
{
4607
#ifdef BFD64
4608
  return ((value + (((bfd_vma) 0x8000 << 32) | 0x80008000)) >> 48) & 0xffff;
4609
#else
4610
  abort ();
4611
  return MINUS_ONE;
4612
#endif
4613
}
4614
 
4615
/* Create the .compact_rel section.  */
4616
 
4617
static bfd_boolean
4618
mips_elf_create_compact_rel_section
4619
  (bfd *abfd, struct bfd_link_info *info ATTRIBUTE_UNUSED)
4620
{
4621
  flagword flags;
4622
  register asection *s;
4623
 
4624
  if (bfd_get_section_by_name (abfd, ".compact_rel") == NULL)
4625
    {
4626
      flags = (SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED
4627
               | SEC_READONLY);
4628
 
4629
      s = bfd_make_section_with_flags (abfd, ".compact_rel", flags);
4630
      if (s == NULL
4631
          || ! bfd_set_section_alignment (abfd, s,
4632
                                          MIPS_ELF_LOG_FILE_ALIGN (abfd)))
4633
        return FALSE;
4634
 
4635
      s->size = sizeof (Elf32_External_compact_rel);
4636
    }
4637
 
4638
  return TRUE;
4639
}
4640
 
4641
/* Create the .got section to hold the global offset table.  */
4642
 
4643
static bfd_boolean
4644 225 jeremybenn
mips_elf_create_got_section (bfd *abfd, struct bfd_link_info *info)
4645 24 jeremybenn
{
4646
  flagword flags;
4647
  register asection *s;
4648
  struct elf_link_hash_entry *h;
4649
  struct bfd_link_hash_entry *bh;
4650
  struct mips_got_info *g;
4651
  bfd_size_type amt;
4652
  struct mips_elf_link_hash_table *htab;
4653
 
4654
  htab = mips_elf_hash_table (info);
4655
 
4656
  /* This function may be called more than once.  */
4657 225 jeremybenn
  if (htab->sgot)
4658
    return TRUE;
4659 24 jeremybenn
 
4660
  flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4661
           | SEC_LINKER_CREATED);
4662
 
4663
  /* We have to use an alignment of 2**4 here because this is hardcoded
4664
     in the function stub generation and in the linker script.  */
4665
  s = bfd_make_section_with_flags (abfd, ".got", flags);
4666
  if (s == NULL
4667
      || ! bfd_set_section_alignment (abfd, s, 4))
4668
    return FALSE;
4669 225 jeremybenn
  htab->sgot = s;
4670 24 jeremybenn
 
4671
  /* Define the symbol _GLOBAL_OFFSET_TABLE_.  We don't do this in the
4672
     linker script because we don't want to define the symbol if we
4673
     are not creating a global offset table.  */
4674
  bh = NULL;
4675
  if (! (_bfd_generic_link_add_one_symbol
4676
         (info, abfd, "_GLOBAL_OFFSET_TABLE_", BSF_GLOBAL, s,
4677
          0, NULL, FALSE, get_elf_backend_data (abfd)->collect, &bh)))
4678
    return FALSE;
4679
 
4680
  h = (struct elf_link_hash_entry *) bh;
4681
  h->non_elf = 0;
4682
  h->def_regular = 1;
4683
  h->type = STT_OBJECT;
4684
  elf_hash_table (info)->hgot = h;
4685
 
4686
  if (info->shared
4687
      && ! bfd_elf_link_record_dynamic_symbol (info, h))
4688
    return FALSE;
4689
 
4690
  amt = sizeof (struct mips_got_info);
4691
  g = bfd_alloc (abfd, amt);
4692
  if (g == NULL)
4693
    return FALSE;
4694
  g->global_gotsym = NULL;
4695
  g->global_gotno = 0;
4696 225 jeremybenn
  g->reloc_only_gotno = 0;
4697 24 jeremybenn
  g->tls_gotno = 0;
4698 225 jeremybenn
  g->local_gotno = 0;
4699 24 jeremybenn
  g->page_gotno = 0;
4700 225 jeremybenn
  g->assigned_gotno = 0;
4701 24 jeremybenn
  g->bfd2got = NULL;
4702
  g->next = NULL;
4703
  g->tls_ldm_offset = MINUS_ONE;
4704
  g->got_entries = htab_try_create (1, mips_elf_got_entry_hash,
4705
                                    mips_elf_got_entry_eq, NULL);
4706
  if (g->got_entries == NULL)
4707
    return FALSE;
4708
  g->got_page_entries = htab_try_create (1, mips_got_page_entry_hash,
4709
                                         mips_got_page_entry_eq, NULL);
4710
  if (g->got_page_entries == NULL)
4711
    return FALSE;
4712 225 jeremybenn
  htab->got_info = g;
4713 24 jeremybenn
  mips_elf_section_data (s)->elf.this_hdr.sh_flags
4714
    |= SHF_ALLOC | SHF_WRITE | SHF_MIPS_GPREL;
4715
 
4716 225 jeremybenn
  /* We also need a .got.plt section when generating PLTs.  */
4717
  s = bfd_make_section_with_flags (abfd, ".got.plt",
4718
                                   SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS
4719
                                   | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4720
  if (s == NULL)
4721
    return FALSE;
4722
  htab->sgotplt = s;
4723 24 jeremybenn
 
4724
  return TRUE;
4725
}
4726
 
4727
/* Return true if H refers to the special VxWorks __GOTT_BASE__ or
4728
   __GOTT_INDEX__ symbols.  These symbols are only special for
4729
   shared objects; they are not used in executables.  */
4730
 
4731
static bfd_boolean
4732
is_gott_symbol (struct bfd_link_info *info, struct elf_link_hash_entry *h)
4733
{
4734
  return (mips_elf_hash_table (info)->is_vxworks
4735
          && info->shared
4736
          && (strcmp (h->root.root.string, "__GOTT_BASE__") == 0
4737
              || strcmp (h->root.root.string, "__GOTT_INDEX__") == 0));
4738
}
4739 225 jeremybenn
 
4740
/* Return TRUE if a relocation of type R_TYPE from INPUT_BFD might
4741
   require an la25 stub.  See also mips_elf_local_pic_function_p,
4742
   which determines whether the destination function ever requires a
4743
   stub.  */
4744
 
4745
static bfd_boolean
4746
mips_elf_relocation_needs_la25_stub (bfd *input_bfd, int r_type)
4747
{
4748
  /* We specifically ignore branches and jumps from EF_PIC objects,
4749
     where the onus is on the compiler or programmer to perform any
4750
     necessary initialization of $25.  Sometimes such initialization
4751
     is unnecessary; for example, -mno-shared functions do not use
4752
     the incoming value of $25, and may therefore be called directly.  */
4753
  if (PIC_OBJECT_P (input_bfd))
4754
    return FALSE;
4755
 
4756
  switch (r_type)
4757
    {
4758
    case R_MIPS_26:
4759
    case R_MIPS_PC16:
4760
    case R_MIPS16_26:
4761
      return TRUE;
4762
 
4763
    default:
4764
      return FALSE;
4765
    }
4766
}
4767 24 jeremybenn
 
4768
/* Calculate the value produced by the RELOCATION (which comes from
4769
   the INPUT_BFD).  The ADDEND is the addend to use for this
4770
   RELOCATION; RELOCATION->R_ADDEND is ignored.
4771
 
4772
   The result of the relocation calculation is stored in VALUEP.
4773
   REQUIRE_JALXP indicates whether or not the opcode used with this
4774
   relocation must be JALX.
4775
 
4776
   This function returns bfd_reloc_continue if the caller need take no
4777
   further action regarding this relocation, bfd_reloc_notsupported if
4778
   something goes dramatically wrong, bfd_reloc_overflow if an
4779
   overflow occurs, and bfd_reloc_ok to indicate success.  */
4780
 
4781
static bfd_reloc_status_type
4782
mips_elf_calculate_relocation (bfd *abfd, bfd *input_bfd,
4783
                               asection *input_section,
4784
                               struct bfd_link_info *info,
4785
                               const Elf_Internal_Rela *relocation,
4786
                               bfd_vma addend, reloc_howto_type *howto,
4787
                               Elf_Internal_Sym *local_syms,
4788
                               asection **local_sections, bfd_vma *valuep,
4789
                               const char **namep, bfd_boolean *require_jalxp,
4790
                               bfd_boolean save_addend)
4791
{
4792
  /* The eventual value we will return.  */
4793
  bfd_vma value;
4794
  /* The address of the symbol against which the relocation is
4795
     occurring.  */
4796
  bfd_vma symbol = 0;
4797
  /* The final GP value to be used for the relocatable, executable, or
4798
     shared object file being produced.  */
4799 225 jeremybenn
  bfd_vma gp;
4800 24 jeremybenn
  /* The place (section offset or address) of the storage unit being
4801
     relocated.  */
4802
  bfd_vma p;
4803
  /* The value of GP used to create the relocatable object.  */
4804 225 jeremybenn
  bfd_vma gp0;
4805 24 jeremybenn
  /* The offset into the global offset table at which the address of
4806
     the relocation entry symbol, adjusted by the addend, resides
4807
     during execution.  */
4808
  bfd_vma g = MINUS_ONE;
4809
  /* The section in which the symbol referenced by the relocation is
4810
     located.  */
4811
  asection *sec = NULL;
4812
  struct mips_elf_link_hash_entry *h = NULL;
4813
  /* TRUE if the symbol referred to by this relocation is a local
4814
     symbol.  */
4815
  bfd_boolean local_p, was_local_p;
4816
  /* TRUE if the symbol referred to by this relocation is "_gp_disp".  */
4817
  bfd_boolean gp_disp_p = FALSE;
4818
  /* TRUE if the symbol referred to by this relocation is
4819
     "__gnu_local_gp".  */
4820
  bfd_boolean gnu_local_gp_p = FALSE;
4821
  Elf_Internal_Shdr *symtab_hdr;
4822
  size_t extsymoff;
4823
  unsigned long r_symndx;
4824
  int r_type;
4825
  /* TRUE if overflow occurred during the calculation of the
4826
     relocation value.  */
4827
  bfd_boolean overflowed_p;
4828
  /* TRUE if this relocation refers to a MIPS16 function.  */
4829
  bfd_boolean target_is_16_bit_code_p = FALSE;
4830
  struct mips_elf_link_hash_table *htab;
4831
  bfd *dynobj;
4832
 
4833
  dynobj = elf_hash_table (info)->dynobj;
4834
  htab = mips_elf_hash_table (info);
4835
 
4836
  /* Parse the relocation.  */
4837
  r_symndx = ELF_R_SYM (input_bfd, relocation->r_info);
4838
  r_type = ELF_R_TYPE (input_bfd, relocation->r_info);
4839
  p = (input_section->output_section->vma
4840
       + input_section->output_offset
4841
       + relocation->r_offset);
4842
 
4843
  /* Assume that there will be no overflow.  */
4844
  overflowed_p = FALSE;
4845
 
4846
  /* Figure out whether or not the symbol is local, and get the offset
4847
     used in the array of hash table entries.  */
4848
  symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
4849
  local_p = mips_elf_local_relocation_p (input_bfd, relocation,
4850
                                         local_sections, FALSE);
4851
  was_local_p = local_p;
4852
  if (! elf_bad_symtab (input_bfd))
4853
    extsymoff = symtab_hdr->sh_info;
4854
  else
4855
    {
4856
      /* The symbol table does not follow the rule that local symbols
4857
         must come before globals.  */
4858
      extsymoff = 0;
4859
    }
4860
 
4861
  /* Figure out the value of the symbol.  */
4862
  if (local_p)
4863
    {
4864
      Elf_Internal_Sym *sym;
4865
 
4866
      sym = local_syms + r_symndx;
4867
      sec = local_sections[r_symndx];
4868
 
4869
      symbol = sec->output_section->vma + sec->output_offset;
4870
      if (ELF_ST_TYPE (sym->st_info) != STT_SECTION
4871
          || (sec->flags & SEC_MERGE))
4872
        symbol += sym->st_value;
4873
      if ((sec->flags & SEC_MERGE)
4874
          && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
4875
        {
4876
          addend = _bfd_elf_rel_local_sym (abfd, sym, &sec, addend);
4877
          addend -= symbol;
4878
          addend += sec->output_section->vma + sec->output_offset;
4879
        }
4880
 
4881
      /* MIPS16 text labels should be treated as odd.  */
4882 225 jeremybenn
      if (ELF_ST_IS_MIPS16 (sym->st_other))
4883 24 jeremybenn
        ++symbol;
4884
 
4885
      /* Record the name of this symbol, for our caller.  */
4886
      *namep = bfd_elf_string_from_elf_section (input_bfd,
4887
                                                symtab_hdr->sh_link,
4888
                                                sym->st_name);
4889
      if (*namep == '\0')
4890
        *namep = bfd_section_name (input_bfd, sec);
4891
 
4892 225 jeremybenn
      target_is_16_bit_code_p = ELF_ST_IS_MIPS16 (sym->st_other);
4893 24 jeremybenn
    }
4894
  else
4895
    {
4896
      /* ??? Could we use RELOC_FOR_GLOBAL_SYMBOL here ?  */
4897
 
4898
      /* For global symbols we look up the symbol in the hash-table.  */
4899
      h = ((struct mips_elf_link_hash_entry *)
4900
           elf_sym_hashes (input_bfd) [r_symndx - extsymoff]);
4901
      /* Find the real hash-table entry for this symbol.  */
4902
      while (h->root.root.type == bfd_link_hash_indirect
4903
             || h->root.root.type == bfd_link_hash_warning)
4904
        h = (struct mips_elf_link_hash_entry *) h->root.root.u.i.link;
4905
 
4906
      /* Record the name of this symbol, for our caller.  */
4907
      *namep = h->root.root.root.string;
4908
 
4909
      /* See if this is the special _gp_disp symbol.  Note that such a
4910
         symbol must always be a global symbol.  */
4911
      if (strcmp (*namep, "_gp_disp") == 0
4912
          && ! NEWABI_P (input_bfd))
4913
        {
4914
          /* Relocations against _gp_disp are permitted only with
4915
             R_MIPS_HI16 and R_MIPS_LO16 relocations.  */
4916 225 jeremybenn
          if (!hi16_reloc_p (r_type) && !lo16_reloc_p (r_type))
4917 24 jeremybenn
            return bfd_reloc_notsupported;
4918
 
4919
          gp_disp_p = TRUE;
4920
        }
4921
      /* See if this is the special _gp symbol.  Note that such a
4922
         symbol must always be a global symbol.  */
4923
      else if (strcmp (*namep, "__gnu_local_gp") == 0)
4924
        gnu_local_gp_p = TRUE;
4925
 
4926
 
4927
      /* If this symbol is defined, calculate its address.  Note that
4928
         _gp_disp is a magic symbol, always implicitly defined by the
4929
         linker, so it's inappropriate to check to see whether or not
4930
         its defined.  */
4931
      else if ((h->root.root.type == bfd_link_hash_defined
4932
                || h->root.root.type == bfd_link_hash_defweak)
4933
               && h->root.root.u.def.section)
4934
        {
4935
          sec = h->root.root.u.def.section;
4936
          if (sec->output_section)
4937
            symbol = (h->root.root.u.def.value
4938
                      + sec->output_section->vma
4939
                      + sec->output_offset);
4940
          else
4941
            symbol = h->root.root.u.def.value;
4942
        }
4943
      else if (h->root.root.type == bfd_link_hash_undefweak)
4944
        /* We allow relocations against undefined weak symbols, giving
4945
           it the value zero, so that you can undefined weak functions
4946
           and check to see if they exist by looking at their
4947
           addresses.  */
4948
        symbol = 0;
4949
      else if (info->unresolved_syms_in_objects == RM_IGNORE
4950
               && ELF_ST_VISIBILITY (h->root.other) == STV_DEFAULT)
4951
        symbol = 0;
4952
      else if (strcmp (*namep, SGI_COMPAT (input_bfd)
4953
                       ? "_DYNAMIC_LINK" : "_DYNAMIC_LINKING") == 0)
4954
        {
4955
          /* If this is a dynamic link, we should have created a
4956
             _DYNAMIC_LINK symbol or _DYNAMIC_LINKING(for normal mips) symbol
4957
             in in _bfd_mips_elf_create_dynamic_sections.
4958
             Otherwise, we should define the symbol with a value of 0.
4959
             FIXME: It should probably get into the symbol table
4960
             somehow as well.  */
4961
          BFD_ASSERT (! info->shared);
4962
          BFD_ASSERT (bfd_get_section_by_name (abfd, ".dynamic") == NULL);
4963
          symbol = 0;
4964
        }
4965
      else if (ELF_MIPS_IS_OPTIONAL (h->root.other))
4966
        {
4967
          /* This is an optional symbol - an Irix specific extension to the
4968
             ELF spec.  Ignore it for now.
4969
             XXX - FIXME - there is more to the spec for OPTIONAL symbols
4970
             than simply ignoring them, but we do not handle this for now.
4971
             For information see the "64-bit ELF Object File Specification"
4972
             which is available from here:
4973
             http://techpubs.sgi.com/library/manuals/4000/007-4658-001/pdf/007-4658-001.pdf  */
4974
          symbol = 0;
4975
        }
4976
      else
4977
        {
4978
          if (! ((*info->callbacks->undefined_symbol)
4979
                 (info, h->root.root.root.string, input_bfd,
4980
                  input_section, relocation->r_offset,
4981
                  (info->unresolved_syms_in_objects == RM_GENERATE_ERROR)
4982
                   || ELF_ST_VISIBILITY (h->root.other))))
4983
            return bfd_reloc_undefined;
4984
          symbol = 0;
4985
        }
4986
 
4987 225 jeremybenn
      target_is_16_bit_code_p = ELF_ST_IS_MIPS16 (h->root.other);
4988 24 jeremybenn
    }
4989
 
4990 225 jeremybenn
  /* If this is a reference to a 16-bit function with a stub, we need
4991
     to redirect the relocation to the stub unless:
4992
 
4993
     (a) the relocation is for a MIPS16 JAL;
4994
 
4995
     (b) the relocation is for a MIPS16 PIC call, and there are no
4996
         non-MIPS16 uses of the GOT slot; or
4997
 
4998
     (c) the section allows direct references to MIPS16 functions.  */
4999
  if (r_type != R_MIPS16_26
5000
      && !info->relocatable
5001
      && ((h != NULL
5002
           && h->fn_stub != NULL
5003
           && (r_type != R_MIPS16_CALL16 || h->need_fn_stub))
5004 24 jeremybenn
          || (local_p
5005
              && elf_tdata (input_bfd)->local_stubs != NULL
5006
              && elf_tdata (input_bfd)->local_stubs[r_symndx] != NULL))
5007 225 jeremybenn
      && !section_allows_mips16_refs_p (input_section))
5008 24 jeremybenn
    {
5009
      /* This is a 32- or 64-bit call to a 16-bit function.  We should
5010
         have already noticed that we were going to need the
5011
         stub.  */
5012
      if (local_p)
5013
        sec = elf_tdata (input_bfd)->local_stubs[r_symndx];
5014
      else
5015
        {
5016
          BFD_ASSERT (h->need_fn_stub);
5017
          sec = h->fn_stub;
5018
        }
5019
 
5020
      symbol = sec->output_section->vma + sec->output_offset;
5021
      /* The target is 16-bit, but the stub isn't.  */
5022
      target_is_16_bit_code_p = FALSE;
5023
    }
5024
  /* If this is a 16-bit call to a 32- or 64-bit function with a stub, we
5025 225 jeremybenn
     need to redirect the call to the stub.  Note that we specifically
5026
     exclude R_MIPS16_CALL16 from this behavior; indirect calls should
5027
     use an indirect stub instead.  */
5028 24 jeremybenn
  else if (r_type == R_MIPS16_26 && !info->relocatable
5029
           && ((h != NULL && (h->call_stub != NULL || h->call_fp_stub != NULL))
5030
               || (local_p
5031
                   && elf_tdata (input_bfd)->local_call_stubs != NULL
5032
                   && elf_tdata (input_bfd)->local_call_stubs[r_symndx] != NULL))
5033
           && !target_is_16_bit_code_p)
5034
    {
5035
      if (local_p)
5036
        sec = elf_tdata (input_bfd)->local_call_stubs[r_symndx];
5037
      else
5038
        {
5039
          /* If both call_stub and call_fp_stub are defined, we can figure
5040
             out which one to use by checking which one appears in the input
5041
             file.  */
5042
          if (h->call_stub != NULL && h->call_fp_stub != NULL)
5043
            {
5044
              asection *o;
5045
 
5046
              sec = NULL;
5047
              for (o = input_bfd->sections; o != NULL; o = o->next)
5048
                {
5049
                  if (CALL_FP_STUB_P (bfd_get_section_name (input_bfd, o)))
5050
                    {
5051
                      sec = h->call_fp_stub;
5052
                      break;
5053
                    }
5054
                }
5055
              if (sec == NULL)
5056
                sec = h->call_stub;
5057
            }
5058
          else if (h->call_stub != NULL)
5059
            sec = h->call_stub;
5060
          else
5061
            sec = h->call_fp_stub;
5062
        }
5063
 
5064
      BFD_ASSERT (sec->size > 0);
5065
      symbol = sec->output_section->vma + sec->output_offset;
5066
    }
5067 225 jeremybenn
  /* If this is a direct call to a PIC function, redirect to the
5068
     non-PIC stub.  */
5069
  else if (h != NULL && h->la25_stub
5070
           && mips_elf_relocation_needs_la25_stub (input_bfd, r_type))
5071
    symbol = (h->la25_stub->stub_section->output_section->vma
5072
              + h->la25_stub->stub_section->output_offset
5073
              + h->la25_stub->offset);
5074 24 jeremybenn
 
5075
  /* Calls from 16-bit code to 32-bit code and vice versa require the
5076
     special jalx instruction.  */
5077
  *require_jalxp = (!info->relocatable
5078
                    && (((r_type == R_MIPS16_26) && !target_is_16_bit_code_p)
5079
                        || ((r_type == R_MIPS_26) && target_is_16_bit_code_p)));
5080
 
5081
  local_p = mips_elf_local_relocation_p (input_bfd, relocation,
5082
                                         local_sections, TRUE);
5083
 
5084 225 jeremybenn
  gp0 = _bfd_get_gp_value (input_bfd);
5085
  gp = _bfd_get_gp_value (abfd);
5086
  if (htab->got_info)
5087
    gp += mips_elf_adjust_gp (abfd, htab->got_info, input_bfd);
5088
 
5089
  if (gnu_local_gp_p)
5090
    symbol = gp;
5091
 
5092
  /* If we haven't already determined the GOT offset, oand we're going
5093
     to need it, get it now.  */
5094 24 jeremybenn
  switch (r_type)
5095
    {
5096
    case R_MIPS_GOT_PAGE:
5097
    case R_MIPS_GOT_OFST:
5098
      /* We need to decay to GOT_DISP/addend if the symbol doesn't
5099
         bind locally.  */
5100
      local_p = local_p || _bfd_elf_symbol_refs_local_p (&h->root, info, 1);
5101
      if (local_p || r_type == R_MIPS_GOT_OFST)
5102
        break;
5103
      /* Fall through.  */
5104
 
5105 225 jeremybenn
    case R_MIPS16_CALL16:
5106
    case R_MIPS16_GOT16:
5107 24 jeremybenn
    case R_MIPS_CALL16:
5108
    case R_MIPS_GOT16:
5109
    case R_MIPS_GOT_DISP:
5110
    case R_MIPS_GOT_HI16:
5111
    case R_MIPS_CALL_HI16:
5112
    case R_MIPS_GOT_LO16:
5113
    case R_MIPS_CALL_LO16:
5114
    case R_MIPS_TLS_GD:
5115
    case R_MIPS_TLS_GOTTPREL:
5116
    case R_MIPS_TLS_LDM:
5117
      /* Find the index into the GOT where this value is located.  */
5118
      if (r_type == R_MIPS_TLS_LDM)
5119
        {
5120
          g = mips_elf_local_got_index (abfd, input_bfd, info,
5121
                                        0, 0, NULL, r_type);
5122
          if (g == MINUS_ONE)
5123
            return bfd_reloc_outofrange;
5124
        }
5125
      else if (!local_p)
5126
        {
5127
          /* On VxWorks, CALL relocations should refer to the .got.plt
5128
             entry, which is initialized to point at the PLT stub.  */
5129
          if (htab->is_vxworks
5130
              && (r_type == R_MIPS_CALL_HI16
5131
                  || r_type == R_MIPS_CALL_LO16
5132 225 jeremybenn
                  || call16_reloc_p (r_type)))
5133 24 jeremybenn
            {
5134
              BFD_ASSERT (addend == 0);
5135
              BFD_ASSERT (h->root.needs_plt);
5136
              g = mips_elf_gotplt_index (info, &h->root);
5137
            }
5138
          else
5139
            {
5140
              /* GOT_PAGE may take a non-zero addend, that is ignored in a
5141
                 GOT_PAGE relocation that decays to GOT_DISP because the
5142
                 symbol turns out to be global.  The addend is then added
5143
                 as GOT_OFST.  */
5144
              BFD_ASSERT (addend == 0 || r_type == R_MIPS_GOT_PAGE);
5145
              g = mips_elf_global_got_index (dynobj, input_bfd,
5146
                                             &h->root, r_type, info);
5147
              if (h->tls_type == GOT_NORMAL
5148
                  && (! elf_hash_table(info)->dynamic_sections_created
5149
                      || (info->shared
5150
                          && (info->symbolic || h->root.forced_local)
5151
                          && h->root.def_regular)))
5152 225 jeremybenn
                /* This is a static link or a -Bsymbolic link.  The
5153
                   symbol is defined locally, or was forced to be local.
5154
                   We must initialize this entry in the GOT.  */
5155
                MIPS_ELF_PUT_WORD (dynobj, symbol, htab->sgot->contents + g);
5156 24 jeremybenn
            }
5157
        }
5158
      else if (!htab->is_vxworks
5159 225 jeremybenn
               && (call16_reloc_p (r_type) || got16_reloc_p (r_type)))
5160 24 jeremybenn
        /* The calculation below does not involve "g".  */
5161
        break;
5162
      else
5163
        {
5164
          g = mips_elf_local_got_index (abfd, input_bfd, info,
5165
                                        symbol + addend, r_symndx, h, r_type);
5166
          if (g == MINUS_ONE)
5167
            return bfd_reloc_outofrange;
5168
        }
5169
 
5170
      /* Convert GOT indices to actual offsets.  */
5171 225 jeremybenn
      g = mips_elf_got_offset_from_index (info, abfd, input_bfd, g);
5172 24 jeremybenn
      break;
5173
    }
5174
 
5175
  /* Relocations against the VxWorks __GOTT_BASE__ and __GOTT_INDEX__
5176
     symbols are resolved by the loader.  Add them to .rela.dyn.  */
5177
  if (h != NULL && is_gott_symbol (info, &h->root))
5178
    {
5179
      Elf_Internal_Rela outrel;
5180
      bfd_byte *loc;
5181
      asection *s;
5182
 
5183
      s = mips_elf_rel_dyn_section (info, FALSE);
5184
      loc = s->contents + s->reloc_count++ * sizeof (Elf32_External_Rela);
5185
 
5186
      outrel.r_offset = (input_section->output_section->vma
5187
                         + input_section->output_offset
5188
                         + relocation->r_offset);
5189
      outrel.r_info = ELF32_R_INFO (h->root.dynindx, r_type);
5190
      outrel.r_addend = addend;
5191
      bfd_elf32_swap_reloca_out (abfd, &outrel, loc);
5192
 
5193
      /* If we've written this relocation for a readonly section,
5194
         we need to set DF_TEXTREL again, so that we do not delete the
5195
         DT_TEXTREL tag.  */
5196
      if (MIPS_ELF_READONLY_SECTION (input_section))
5197
        info->flags |= DF_TEXTREL;
5198
 
5199
      *valuep = 0;
5200
      return bfd_reloc_ok;
5201
    }
5202
 
5203
  /* Figure out what kind of relocation is being performed.  */
5204
  switch (r_type)
5205
    {
5206
    case R_MIPS_NONE:
5207
      return bfd_reloc_continue;
5208
 
5209
    case R_MIPS_16:
5210
      value = symbol + _bfd_mips_elf_sign_extend (addend, 16);
5211
      overflowed_p = mips_elf_overflow_p (value, 16);
5212
      break;
5213
 
5214
    case R_MIPS_32:
5215
    case R_MIPS_REL32:
5216
    case R_MIPS_64:
5217
      if ((info->shared
5218 225 jeremybenn
           || (htab->root.dynamic_sections_created
5219 24 jeremybenn
               && h != NULL
5220
               && h->root.def_dynamic
5221 225 jeremybenn
               && !h->root.def_regular
5222
               && !h->has_static_relocs))
5223 24 jeremybenn
          && r_symndx != 0
5224 225 jeremybenn
          && (h == NULL
5225
              || h->root.root.type != bfd_link_hash_undefweak
5226
              || ELF_ST_VISIBILITY (h->root.other) == STV_DEFAULT)
5227 24 jeremybenn
          && (input_section->flags & SEC_ALLOC) != 0)
5228
        {
5229 225 jeremybenn
          /* If we're creating a shared library, then we can't know
5230 24 jeremybenn
             where the symbol will end up.  So, we create a relocation
5231
             record in the output, and leave the job up to the dynamic
5232 225 jeremybenn
             linker.  We must do the same for executable references to
5233
             shared library symbols, unless we've decided to use copy
5234
             relocs or PLTs instead.  */
5235 24 jeremybenn
          value = addend;
5236
          if (!mips_elf_create_dynamic_relocation (abfd,
5237
                                                   info,
5238
                                                   relocation,
5239
                                                   h,
5240
                                                   sec,
5241
                                                   symbol,
5242
                                                   &value,
5243
                                                   input_section))
5244
            return bfd_reloc_undefined;
5245
        }
5246
      else
5247
        {
5248
          if (r_type != R_MIPS_REL32)
5249
            value = symbol + addend;
5250
          else
5251
            value = addend;
5252
        }
5253
      value &= howto->dst_mask;
5254
      break;
5255
 
5256
    case R_MIPS_PC32:
5257
      value = symbol + addend - p;
5258
      value &= howto->dst_mask;
5259
      break;
5260
 
5261
    case R_MIPS16_26:
5262
      /* The calculation for R_MIPS16_26 is just the same as for an
5263
         R_MIPS_26.  It's only the storage of the relocated field into
5264
         the output file that's different.  That's handled in
5265
         mips_elf_perform_relocation.  So, we just fall through to the
5266
         R_MIPS_26 case here.  */
5267
    case R_MIPS_26:
5268
      if (local_p)
5269
        value = ((addend | ((p + 4) & 0xf0000000)) + symbol) >> 2;
5270
      else
5271
        {
5272
          value = (_bfd_mips_elf_sign_extend (addend, 28) + symbol) >> 2;
5273
          if (h->root.root.type != bfd_link_hash_undefweak)
5274
            overflowed_p = (value >> 26) != ((p + 4) >> 28);
5275
        }
5276
      value &= howto->dst_mask;
5277
      break;
5278
 
5279
    case R_MIPS_TLS_DTPREL_HI16:
5280
      value = (mips_elf_high (addend + symbol - dtprel_base (info))
5281
               & howto->dst_mask);
5282
      break;
5283
 
5284
    case R_MIPS_TLS_DTPREL_LO16:
5285
    case R_MIPS_TLS_DTPREL32:
5286
    case R_MIPS_TLS_DTPREL64:
5287
      value = (symbol + addend - dtprel_base (info)) & howto->dst_mask;
5288
      break;
5289
 
5290
    case R_MIPS_TLS_TPREL_HI16:
5291
      value = (mips_elf_high (addend + symbol - tprel_base (info))
5292
               & howto->dst_mask);
5293
      break;
5294
 
5295
    case R_MIPS_TLS_TPREL_LO16:
5296
      value = (symbol + addend - tprel_base (info)) & howto->dst_mask;
5297
      break;
5298
 
5299
    case R_MIPS_HI16:
5300
    case R_MIPS16_HI16:
5301
      if (!gp_disp_p)
5302
        {
5303
          value = mips_elf_high (addend + symbol);
5304
          value &= howto->dst_mask;
5305
        }
5306
      else
5307
        {
5308
          /* For MIPS16 ABI code we generate this sequence
5309
                0: li      $v0,%hi(_gp_disp)
5310
                4: addiupc $v1,%lo(_gp_disp)
5311
                8: sll     $v0,16
5312
               12: addu    $v0,$v1
5313
               14: move    $gp,$v0
5314
             So the offsets of hi and lo relocs are the same, but the
5315
             $pc is four higher than $t9 would be, so reduce
5316
             both reloc addends by 4. */
5317
          if (r_type == R_MIPS16_HI16)
5318
            value = mips_elf_high (addend + gp - p - 4);
5319
          else
5320
            value = mips_elf_high (addend + gp - p);
5321
          overflowed_p = mips_elf_overflow_p (value, 16);
5322
        }
5323
      break;
5324
 
5325
    case R_MIPS_LO16:
5326
    case R_MIPS16_LO16:
5327
      if (!gp_disp_p)
5328
        value = (symbol + addend) & howto->dst_mask;
5329
      else
5330
        {
5331
          /* See the comment for R_MIPS16_HI16 above for the reason
5332
             for this conditional.  */
5333
          if (r_type == R_MIPS16_LO16)
5334
            value = addend + gp - p;
5335
          else
5336
            value = addend + gp - p + 4;
5337
          /* The MIPS ABI requires checking the R_MIPS_LO16 relocation
5338
             for overflow.  But, on, say, IRIX5, relocations against
5339
             _gp_disp are normally generated from the .cpload
5340
             pseudo-op.  It generates code that normally looks like
5341
             this:
5342
 
5343
               lui    $gp,%hi(_gp_disp)
5344
               addiu  $gp,$gp,%lo(_gp_disp)
5345
               addu   $gp,$gp,$t9
5346
 
5347
             Here $t9 holds the address of the function being called,
5348
             as required by the MIPS ELF ABI.  The R_MIPS_LO16
5349
             relocation can easily overflow in this situation, but the
5350
             R_MIPS_HI16 relocation will handle the overflow.
5351
             Therefore, we consider this a bug in the MIPS ABI, and do
5352
             not check for overflow here.  */
5353
        }
5354
      break;
5355
 
5356
    case R_MIPS_LITERAL:
5357
      /* Because we don't merge literal sections, we can handle this
5358
         just like R_MIPS_GPREL16.  In the long run, we should merge
5359
         shared literals, and then we will need to additional work
5360
         here.  */
5361
 
5362
      /* Fall through.  */
5363
 
5364
    case R_MIPS16_GPREL:
5365
      /* The R_MIPS16_GPREL performs the same calculation as
5366
         R_MIPS_GPREL16, but stores the relocated bits in a different
5367
         order.  We don't need to do anything special here; the
5368
         differences are handled in mips_elf_perform_relocation.  */
5369
    case R_MIPS_GPREL16:
5370
      /* Only sign-extend the addend if it was extracted from the
5371
         instruction.  If the addend was separate, leave it alone,
5372
         otherwise we may lose significant bits.  */
5373
      if (howto->partial_inplace)
5374
        addend = _bfd_mips_elf_sign_extend (addend, 16);
5375
      value = symbol + addend - gp;
5376
      /* If the symbol was local, any earlier relocatable links will
5377
         have adjusted its addend with the gp offset, so compensate
5378
         for that now.  Don't do it for symbols forced local in this
5379
         link, though, since they won't have had the gp offset applied
5380
         to them before.  */
5381
      if (was_local_p)
5382
        value += gp0;
5383
      overflowed_p = mips_elf_overflow_p (value, 16);
5384
      break;
5385
 
5386 225 jeremybenn
    case R_MIPS16_GOT16:
5387
    case R_MIPS16_CALL16:
5388 24 jeremybenn
    case R_MIPS_GOT16:
5389
    case R_MIPS_CALL16:
5390
      /* VxWorks does not have separate local and global semantics for
5391 225 jeremybenn
         R_MIPS*_GOT16; every relocation evaluates to "G".  */
5392 24 jeremybenn
      if (!htab->is_vxworks && local_p)
5393
        {
5394
          bfd_boolean forced;
5395
 
5396
          forced = ! mips_elf_local_relocation_p (input_bfd, relocation,
5397
                                                  local_sections, FALSE);
5398
          value = mips_elf_got16_entry (abfd, input_bfd, info,
5399
                                        symbol + addend, forced);
5400
          if (value == MINUS_ONE)
5401
            return bfd_reloc_outofrange;
5402
          value
5403 225 jeremybenn
            = mips_elf_got_offset_from_index (info, abfd, input_bfd, value);
5404 24 jeremybenn
          overflowed_p = mips_elf_overflow_p (value, 16);
5405
          break;
5406
        }
5407
 
5408
      /* Fall through.  */
5409
 
5410
    case R_MIPS_TLS_GD:
5411
    case R_MIPS_TLS_GOTTPREL:
5412
    case R_MIPS_TLS_LDM:
5413
    case R_MIPS_GOT_DISP:
5414
    got_disp:
5415
      value = g;
5416
      overflowed_p = mips_elf_overflow_p (value, 16);
5417
      break;
5418
 
5419
    case R_MIPS_GPREL32:
5420
      value = (addend + symbol + gp0 - gp);
5421
      if (!save_addend)
5422
        value &= howto->dst_mask;
5423
      break;
5424
 
5425
    case R_MIPS_PC16:
5426
    case R_MIPS_GNU_REL16_S2:
5427
      value = symbol + _bfd_mips_elf_sign_extend (addend, 18) - p;
5428
      overflowed_p = mips_elf_overflow_p (value, 18);
5429
      value >>= howto->rightshift;
5430
      value &= howto->dst_mask;
5431
      break;
5432
 
5433
    case R_MIPS_GOT_HI16:
5434
    case R_MIPS_CALL_HI16:
5435
      /* We're allowed to handle these two relocations identically.
5436
         The dynamic linker is allowed to handle the CALL relocations
5437
         differently by creating a lazy evaluation stub.  */
5438
      value = g;
5439
      value = mips_elf_high (value);
5440
      value &= howto->dst_mask;
5441
      break;
5442
 
5443
    case R_MIPS_GOT_LO16:
5444
    case R_MIPS_CALL_LO16:
5445
      value = g & howto->dst_mask;
5446
      break;
5447
 
5448
    case R_MIPS_GOT_PAGE:
5449
      /* GOT_PAGE relocations that reference non-local symbols decay
5450
         to GOT_DISP.  The corresponding GOT_OFST relocation decays to
5451
         0.  */
5452
      if (! local_p)
5453
        goto got_disp;
5454
      value = mips_elf_got_page (abfd, input_bfd, info, symbol + addend, NULL);
5455
      if (value == MINUS_ONE)
5456
        return bfd_reloc_outofrange;
5457 225 jeremybenn
      value = mips_elf_got_offset_from_index (info, abfd, input_bfd, value);
5458 24 jeremybenn
      overflowed_p = mips_elf_overflow_p (value, 16);
5459
      break;
5460
 
5461
    case R_MIPS_GOT_OFST:
5462
      if (local_p)
5463
        mips_elf_got_page (abfd, input_bfd, info, symbol + addend, &value);
5464
      else
5465
        value = addend;
5466
      overflowed_p = mips_elf_overflow_p (value, 16);
5467
      break;
5468
 
5469
    case R_MIPS_SUB:
5470
      value = symbol - addend;
5471
      value &= howto->dst_mask;
5472
      break;
5473
 
5474
    case R_MIPS_HIGHER:
5475
      value = mips_elf_higher (addend + symbol);
5476
      value &= howto->dst_mask;
5477
      break;
5478
 
5479
    case R_MIPS_HIGHEST:
5480
      value = mips_elf_highest (addend + symbol);
5481
      value &= howto->dst_mask;
5482
      break;
5483
 
5484
    case R_MIPS_SCN_DISP:
5485
      value = symbol + addend - sec->output_offset;
5486
      value &= howto->dst_mask;
5487
      break;
5488
 
5489
    case R_MIPS_JALR:
5490
      /* This relocation is only a hint.  In some cases, we optimize
5491
         it into a bal instruction.  But we don't try to optimize
5492 225 jeremybenn
         when the symbol does not resolve locally.  */
5493
      if (h != NULL && !SYMBOL_CALLS_LOCAL (info, &h->root))
5494 24 jeremybenn
        return bfd_reloc_continue;
5495
      value = symbol + addend;
5496
      break;
5497
 
5498
    case R_MIPS_PJUMP:
5499
    case R_MIPS_GNU_VTINHERIT:
5500
    case R_MIPS_GNU_VTENTRY:
5501
      /* We don't do anything with these at present.  */
5502
      return bfd_reloc_continue;
5503
 
5504
    default:
5505
      /* An unrecognized relocation type.  */
5506
      return bfd_reloc_notsupported;
5507
    }
5508
 
5509
  /* Store the VALUE for our caller.  */
5510
  *valuep = value;
5511
  return overflowed_p ? bfd_reloc_overflow : bfd_reloc_ok;
5512
}
5513
 
5514
/* Obtain the field relocated by RELOCATION.  */
5515
 
5516
static bfd_vma
5517
mips_elf_obtain_contents (reloc_howto_type *howto,
5518
                          const Elf_Internal_Rela *relocation,
5519
                          bfd *input_bfd, bfd_byte *contents)
5520
{
5521
  bfd_vma x;
5522
  bfd_byte *location = contents + relocation->r_offset;
5523
 
5524
  /* Obtain the bytes.  */
5525
  x = bfd_get ((8 * bfd_get_reloc_size (howto)), input_bfd, location);
5526
 
5527
  return x;
5528
}
5529
 
5530
/* It has been determined that the result of the RELOCATION is the
5531
   VALUE.  Use HOWTO to place VALUE into the output file at the
5532
   appropriate position.  The SECTION is the section to which the
5533
   relocation applies.  If REQUIRE_JALX is TRUE, then the opcode used
5534
   for the relocation must be either JAL or JALX, and it is
5535
   unconditionally converted to JALX.
5536
 
5537
   Returns FALSE if anything goes wrong.  */
5538
 
5539
static bfd_boolean
5540
mips_elf_perform_relocation (struct bfd_link_info *info,
5541
                             reloc_howto_type *howto,
5542
                             const Elf_Internal_Rela *relocation,
5543
                             bfd_vma value, bfd *input_bfd,
5544
                             asection *input_section, bfd_byte *contents,
5545
                             bfd_boolean require_jalx)
5546
{
5547
  bfd_vma x;
5548
  bfd_byte *location;
5549
  int r_type = ELF_R_TYPE (input_bfd, relocation->r_info);
5550
 
5551
  /* Figure out where the relocation is occurring.  */
5552
  location = contents + relocation->r_offset;
5553
 
5554
  _bfd_mips16_elf_reloc_unshuffle (input_bfd, r_type, FALSE, location);
5555
 
5556
  /* Obtain the current value.  */
5557
  x = mips_elf_obtain_contents (howto, relocation, input_bfd, contents);
5558
 
5559
  /* Clear the field we are setting.  */
5560
  x &= ~howto->dst_mask;
5561
 
5562
  /* Set the field.  */
5563
  x |= (value & howto->dst_mask);
5564
 
5565
  /* If required, turn JAL into JALX.  */
5566
  if (require_jalx)
5567
    {
5568
      bfd_boolean ok;
5569
      bfd_vma opcode = x >> 26;
5570
      bfd_vma jalx_opcode;
5571
 
5572
      /* Check to see if the opcode is already JAL or JALX.  */
5573
      if (r_type == R_MIPS16_26)
5574
        {
5575
          ok = ((opcode == 0x6) || (opcode == 0x7));
5576
          jalx_opcode = 0x7;
5577
        }
5578
      else
5579
        {
5580
          ok = ((opcode == 0x3) || (opcode == 0x1d));
5581
          jalx_opcode = 0x1d;
5582
        }
5583
 
5584
      /* If the opcode is not JAL or JALX, there's a problem.  */
5585
      if (!ok)
5586
        {
5587
          (*_bfd_error_handler)
5588
            (_("%B: %A+0x%lx: jump to stub routine which is not jal"),
5589
             input_bfd,
5590
             input_section,
5591
             (unsigned long) relocation->r_offset);
5592
          bfd_set_error (bfd_error_bad_value);
5593
          return FALSE;
5594
        }
5595
 
5596
      /* Make this the JALX opcode.  */
5597
      x = (x & ~(0x3f << 26)) | (jalx_opcode << 26);
5598
    }
5599
 
5600 225 jeremybenn
  /* Try converting JAL and JALR to BAL, if the target is in range.  */
5601
  if (!info->relocatable
5602 24 jeremybenn
      && !require_jalx
5603 225 jeremybenn
      && ((JAL_TO_BAL_P (input_bfd)
5604
           && r_type == R_MIPS_26
5605
           && (x >> 26) == 0x3)         /* jal addr */
5606
          || (JALR_TO_BAL_P (input_bfd)
5607
              && r_type == R_MIPS_JALR
5608
              && x == 0x0320f809)))     /* jalr t9 */
5609 24 jeremybenn
    {
5610
      bfd_vma addr;
5611
      bfd_vma dest;
5612
      bfd_signed_vma off;
5613
 
5614
      addr = (input_section->output_section->vma
5615
              + input_section->output_offset
5616
              + relocation->r_offset
5617
              + 4);
5618
      if (r_type == R_MIPS_26)
5619
        dest = (value << 2) | ((addr >> 28) << 28);
5620
      else
5621
        dest = value;
5622
      off = dest - addr;
5623
      if (off <= 0x1ffff && off >= -0x20000)
5624
        x = 0x04110000 | (((bfd_vma) off >> 2) & 0xffff);   /* bal addr */
5625
    }
5626
 
5627
  /* Put the value into the output.  */
5628
  bfd_put (8 * bfd_get_reloc_size (howto), input_bfd, x, location);
5629
 
5630
  _bfd_mips16_elf_reloc_shuffle(input_bfd, r_type, !info->relocatable,
5631
                                location);
5632
 
5633
  return TRUE;
5634
}
5635
 
5636
/* Create a rel.dyn relocation for the dynamic linker to resolve.  REL
5637
   is the original relocation, which is now being transformed into a
5638
   dynamic relocation.  The ADDENDP is adjusted if necessary; the
5639
   caller should store the result in place of the original addend.  */
5640
 
5641
static bfd_boolean
5642
mips_elf_create_dynamic_relocation (bfd *output_bfd,
5643
                                    struct bfd_link_info *info,
5644
                                    const Elf_Internal_Rela *rel,
5645
                                    struct mips_elf_link_hash_entry *h,
5646
                                    asection *sec, bfd_vma symbol,
5647
                                    bfd_vma *addendp, asection *input_section)
5648
{
5649
  Elf_Internal_Rela outrel[3];
5650
  asection *sreloc;
5651
  bfd *dynobj;
5652
  int r_type;
5653
  long indx;
5654
  bfd_boolean defined_p;
5655
  struct mips_elf_link_hash_table *htab;
5656
 
5657
  htab = mips_elf_hash_table (info);
5658
  r_type = ELF_R_TYPE (output_bfd, rel->r_info);
5659
  dynobj = elf_hash_table (info)->dynobj;
5660
  sreloc = mips_elf_rel_dyn_section (info, FALSE);
5661
  BFD_ASSERT (sreloc != NULL);
5662
  BFD_ASSERT (sreloc->contents != NULL);
5663
  BFD_ASSERT (sreloc->reloc_count * MIPS_ELF_REL_SIZE (output_bfd)
5664
              < sreloc->size);
5665
 
5666
  outrel[0].r_offset =
5667
    _bfd_elf_section_offset (output_bfd, info, input_section, rel[0].r_offset);
5668
  if (ABI_64_P (output_bfd))
5669
    {
5670
      outrel[1].r_offset =
5671
        _bfd_elf_section_offset (output_bfd, info, input_section, rel[1].r_offset);
5672
      outrel[2].r_offset =
5673
        _bfd_elf_section_offset (output_bfd, info, input_section, rel[2].r_offset);
5674
    }
5675
 
5676
  if (outrel[0].r_offset == MINUS_ONE)
5677
    /* The relocation field has been deleted.  */
5678
    return TRUE;
5679
 
5680
  if (outrel[0].r_offset == MINUS_TWO)
5681
    {
5682
      /* The relocation field has been converted into a relative value of
5683
         some sort.  Functions like _bfd_elf_write_section_eh_frame expect
5684
         the field to be fully relocated, so add in the symbol's value.  */
5685
      *addendp += symbol;
5686
      return TRUE;
5687
    }
5688
 
5689
  /* We must now calculate the dynamic symbol table index to use
5690
     in the relocation.  */
5691
  if (h != NULL
5692
      && (!h->root.def_regular
5693
          || (info->shared && !info->symbolic && !h->root.forced_local)))
5694
    {
5695
      indx = h->root.dynindx;
5696
      if (SGI_COMPAT (output_bfd))
5697
        defined_p = h->root.def_regular;
5698
      else
5699
        /* ??? glibc's ld.so just adds the final GOT entry to the
5700
           relocation field.  It therefore treats relocs against
5701
           defined symbols in the same way as relocs against
5702
           undefined symbols.  */
5703
        defined_p = FALSE;
5704
    }
5705
  else
5706
    {
5707
      if (sec != NULL && bfd_is_abs_section (sec))
5708
        indx = 0;
5709
      else if (sec == NULL || sec->owner == NULL)
5710
        {
5711
          bfd_set_error (bfd_error_bad_value);
5712
          return FALSE;
5713
        }
5714
      else
5715
        {
5716
          indx = elf_section_data (sec->output_section)->dynindx;
5717
          if (indx == 0)
5718
            {
5719
              asection *osec = htab->root.text_index_section;
5720
              indx = elf_section_data (osec)->dynindx;
5721
            }
5722
          if (indx == 0)
5723
            abort ();
5724
        }
5725
 
5726
      /* Instead of generating a relocation using the section
5727
         symbol, we may as well make it a fully relative
5728
         relocation.  We want to avoid generating relocations to
5729
         local symbols because we used to generate them
5730
         incorrectly, without adding the original symbol value,
5731
         which is mandated by the ABI for section symbols.  In
5732
         order to give dynamic loaders and applications time to
5733
         phase out the incorrect use, we refrain from emitting
5734
         section-relative relocations.  It's not like they're
5735
         useful, after all.  This should be a bit more efficient
5736
         as well.  */
5737
      /* ??? Although this behavior is compatible with glibc's ld.so,
5738
         the ABI says that relocations against STN_UNDEF should have
5739
         a symbol value of 0.  Irix rld honors this, so relocations
5740
         against STN_UNDEF have no effect.  */
5741
      if (!SGI_COMPAT (output_bfd))
5742
        indx = 0;
5743
      defined_p = TRUE;
5744
    }
5745
 
5746
  /* If the relocation was previously an absolute relocation and
5747
     this symbol will not be referred to by the relocation, we must
5748
     adjust it by the value we give it in the dynamic symbol table.
5749
     Otherwise leave the job up to the dynamic linker.  */
5750
  if (defined_p && r_type != R_MIPS_REL32)
5751
    *addendp += symbol;
5752
 
5753
  if (htab->is_vxworks)
5754
    /* VxWorks uses non-relative relocations for this.  */
5755
    outrel[0].r_info = ELF32_R_INFO (indx, R_MIPS_32);
5756
  else
5757
    /* The relocation is always an REL32 relocation because we don't
5758
       know where the shared library will wind up at load-time.  */
5759
    outrel[0].r_info = ELF_R_INFO (output_bfd, (unsigned long) indx,
5760
                                   R_MIPS_REL32);
5761
 
5762
  /* For strict adherence to the ABI specification, we should
5763
     generate a R_MIPS_64 relocation record by itself before the
5764
     _REL32/_64 record as well, such that the addend is read in as
5765
     a 64-bit value (REL32 is a 32-bit relocation, after all).
5766
     However, since none of the existing ELF64 MIPS dynamic
5767
     loaders seems to care, we don't waste space with these
5768
     artificial relocations.  If this turns out to not be true,
5769
     mips_elf_allocate_dynamic_relocation() should be tweaked so
5770
     as to make room for a pair of dynamic relocations per
5771
     invocation if ABI_64_P, and here we should generate an
5772
     additional relocation record with R_MIPS_64 by itself for a
5773
     NULL symbol before this relocation record.  */
5774
  outrel[1].r_info = ELF_R_INFO (output_bfd, 0,
5775
                                 ABI_64_P (output_bfd)
5776
                                 ? R_MIPS_64
5777
                                 : R_MIPS_NONE);
5778
  outrel[2].r_info = ELF_R_INFO (output_bfd, 0, R_MIPS_NONE);
5779
 
5780
  /* Adjust the output offset of the relocation to reference the
5781
     correct location in the output file.  */
5782
  outrel[0].r_offset += (input_section->output_section->vma
5783
                         + input_section->output_offset);
5784
  outrel[1].r_offset += (input_section->output_section->vma
5785
                         + input_section->output_offset);
5786
  outrel[2].r_offset += (input_section->output_section->vma
5787
                         + input_section->output_offset);
5788
 
5789
  /* Put the relocation back out.  We have to use the special
5790
     relocation outputter in the 64-bit case since the 64-bit
5791
     relocation format is non-standard.  */
5792
  if (ABI_64_P (output_bfd))
5793
    {
5794
      (*get_elf_backend_data (output_bfd)->s->swap_reloc_out)
5795
        (output_bfd, &outrel[0],
5796
         (sreloc->contents
5797
          + sreloc->reloc_count * sizeof (Elf64_Mips_External_Rel)));
5798
    }
5799
  else if (htab->is_vxworks)
5800
    {
5801
      /* VxWorks uses RELA rather than REL dynamic relocations.  */
5802
      outrel[0].r_addend = *addendp;
5803
      bfd_elf32_swap_reloca_out
5804
        (output_bfd, &outrel[0],
5805
         (sreloc->contents
5806
          + sreloc->reloc_count * sizeof (Elf32_External_Rela)));
5807
    }
5808
  else
5809
    bfd_elf32_swap_reloc_out
5810
      (output_bfd, &outrel[0],
5811
       (sreloc->contents + sreloc->reloc_count * sizeof (Elf32_External_Rel)));
5812
 
5813
  /* We've now added another relocation.  */
5814
  ++sreloc->reloc_count;
5815
 
5816
  /* Make sure the output section is writable.  The dynamic linker
5817
     will be writing to it.  */
5818
  elf_section_data (input_section->output_section)->this_hdr.sh_flags
5819
    |= SHF_WRITE;
5820
 
5821
  /* On IRIX5, make an entry of compact relocation info.  */
5822
  if (IRIX_COMPAT (output_bfd) == ict_irix5)
5823
    {
5824
      asection *scpt = bfd_get_section_by_name (dynobj, ".compact_rel");
5825
      bfd_byte *cr;
5826
 
5827
      if (scpt)
5828
        {
5829
          Elf32_crinfo cptrel;
5830
 
5831
          mips_elf_set_cr_format (cptrel, CRF_MIPS_LONG);
5832
          cptrel.vaddr = (rel->r_offset
5833
                          + input_section->output_section->vma
5834
                          + input_section->output_offset);
5835
          if (r_type == R_MIPS_REL32)
5836
            mips_elf_set_cr_type (cptrel, CRT_MIPS_REL32);
5837
          else
5838
            mips_elf_set_cr_type (cptrel, CRT_MIPS_WORD);
5839
          mips_elf_set_cr_dist2to (cptrel, 0);
5840
          cptrel.konst = *addendp;
5841
 
5842
          cr = (scpt->contents
5843
                + sizeof (Elf32_External_compact_rel));
5844
          mips_elf_set_cr_relvaddr (cptrel, 0);
5845
          bfd_elf32_swap_crinfo_out (output_bfd, &cptrel,
5846
                                     ((Elf32_External_crinfo *) cr
5847
                                      + scpt->reloc_count));
5848
          ++scpt->reloc_count;
5849
        }
5850
    }
5851
 
5852
  /* If we've written this relocation for a readonly section,
5853
     we need to set DF_TEXTREL again, so that we do not delete the
5854
     DT_TEXTREL tag.  */
5855
  if (MIPS_ELF_READONLY_SECTION (input_section))
5856
    info->flags |= DF_TEXTREL;
5857
 
5858
  return TRUE;
5859
}
5860
 
5861
/* Return the MACH for a MIPS e_flags value.  */
5862
 
5863
unsigned long
5864
_bfd_elf_mips_mach (flagword flags)
5865
{
5866
  switch (flags & EF_MIPS_MACH)
5867
    {
5868
    case E_MIPS_MACH_3900:
5869
      return bfd_mach_mips3900;
5870
 
5871
    case E_MIPS_MACH_4010:
5872
      return bfd_mach_mips4010;
5873
 
5874
    case E_MIPS_MACH_4100:
5875
      return bfd_mach_mips4100;
5876
 
5877
    case E_MIPS_MACH_4111:
5878
      return bfd_mach_mips4111;
5879
 
5880
    case E_MIPS_MACH_4120:
5881
      return bfd_mach_mips4120;
5882
 
5883
    case E_MIPS_MACH_4650:
5884
      return bfd_mach_mips4650;
5885
 
5886
    case E_MIPS_MACH_5400:
5887
      return bfd_mach_mips5400;
5888
 
5889
    case E_MIPS_MACH_5500:
5890
      return bfd_mach_mips5500;
5891
 
5892
    case E_MIPS_MACH_9000:
5893
      return bfd_mach_mips9000;
5894
 
5895
    case E_MIPS_MACH_SB1:
5896
      return bfd_mach_mips_sb1;
5897
 
5898
    case E_MIPS_MACH_LS2E:
5899
      return bfd_mach_mips_loongson_2e;
5900
 
5901
    case E_MIPS_MACH_LS2F:
5902
      return bfd_mach_mips_loongson_2f;
5903
 
5904
    case E_MIPS_MACH_OCTEON:
5905
      return bfd_mach_mips_octeon;
5906
 
5907 225 jeremybenn
    case E_MIPS_MACH_XLR:
5908
      return bfd_mach_mips_xlr;
5909
 
5910 24 jeremybenn
    default:
5911
      switch (flags & EF_MIPS_ARCH)
5912
        {
5913
        default:
5914
        case E_MIPS_ARCH_1:
5915
          return bfd_mach_mips3000;
5916
 
5917
        case E_MIPS_ARCH_2:
5918
          return bfd_mach_mips6000;
5919
 
5920
        case E_MIPS_ARCH_3:
5921
          return bfd_mach_mips4000;
5922
 
5923
        case E_MIPS_ARCH_4:
5924
          return bfd_mach_mips8000;
5925
 
5926
        case E_MIPS_ARCH_5:
5927
          return bfd_mach_mips5;
5928
 
5929
        case E_MIPS_ARCH_32:
5930
          return bfd_mach_mipsisa32;
5931
 
5932
        case E_MIPS_ARCH_64:
5933
          return bfd_mach_mipsisa64;
5934
 
5935
        case E_MIPS_ARCH_32R2:
5936
          return bfd_mach_mipsisa32r2;
5937
 
5938
        case E_MIPS_ARCH_64R2:
5939
          return bfd_mach_mipsisa64r2;
5940
        }
5941
    }
5942
 
5943
  return 0;
5944
}
5945
 
5946
/* Return printable name for ABI.  */
5947
 
5948
static INLINE char *
5949
elf_mips_abi_name (bfd *abfd)
5950
{
5951
  flagword flags;
5952
 
5953
  flags = elf_elfheader (abfd)->e_flags;
5954
  switch (flags & EF_MIPS_ABI)
5955
    {
5956
    case 0:
5957
      if (ABI_N32_P (abfd))
5958
        return "N32";
5959
      else if (ABI_64_P (abfd))
5960
        return "64";
5961
      else
5962
        return "none";
5963
    case E_MIPS_ABI_O32:
5964
      return "O32";
5965
    case E_MIPS_ABI_O64:
5966
      return "O64";
5967
    case E_MIPS_ABI_EABI32:
5968
      return "EABI32";
5969
    case E_MIPS_ABI_EABI64:
5970
      return "EABI64";
5971
    default:
5972
      return "unknown abi";
5973
    }
5974
}
5975
 
5976
/* MIPS ELF uses two common sections.  One is the usual one, and the
5977
   other is for small objects.  All the small objects are kept
5978
   together, and then referenced via the gp pointer, which yields
5979
   faster assembler code.  This is what we use for the small common
5980
   section.  This approach is copied from ecoff.c.  */
5981
static asection mips_elf_scom_section;
5982
static asymbol mips_elf_scom_symbol;
5983
static asymbol *mips_elf_scom_symbol_ptr;
5984
 
5985
/* MIPS ELF also uses an acommon section, which represents an
5986
   allocated common symbol which may be overridden by a
5987
   definition in a shared library.  */
5988
static asection mips_elf_acom_section;
5989
static asymbol mips_elf_acom_symbol;
5990
static asymbol *mips_elf_acom_symbol_ptr;
5991
 
5992 225 jeremybenn
/* This is used for both the 32-bit and the 64-bit ABI.  */
5993 24 jeremybenn
 
5994
void
5995
_bfd_mips_elf_symbol_processing (bfd *abfd, asymbol *asym)
5996
{
5997
  elf_symbol_type *elfsym;
5998
 
5999 225 jeremybenn
  /* Handle the special MIPS section numbers that a symbol may use.  */
6000 24 jeremybenn
  elfsym = (elf_symbol_type *) asym;
6001
  switch (elfsym->internal_elf_sym.st_shndx)
6002
    {
6003
    case SHN_MIPS_ACOMMON:
6004
      /* This section is used in a dynamically linked executable file.
6005
         It is an allocated common section.  The dynamic linker can
6006
         either resolve these symbols to something in a shared
6007
         library, or it can just leave them here.  For our purposes,
6008
         we can consider these symbols to be in a new section.  */
6009
      if (mips_elf_acom_section.name == NULL)
6010
        {
6011
          /* Initialize the acommon section.  */
6012
          mips_elf_acom_section.name = ".acommon";
6013
          mips_elf_acom_section.flags = SEC_ALLOC;
6014
          mips_elf_acom_section.output_section = &mips_elf_acom_section;
6015
          mips_elf_acom_section.symbol = &mips_elf_acom_symbol;
6016
          mips_elf_acom_section.symbol_ptr_ptr = &mips_elf_acom_symbol_ptr;
6017
          mips_elf_acom_symbol.name = ".acommon";
6018
          mips_elf_acom_symbol.flags = BSF_SECTION_SYM;
6019
          mips_elf_acom_symbol.section = &mips_elf_acom_section;
6020
          mips_elf_acom_symbol_ptr = &mips_elf_acom_symbol;
6021
        }
6022
      asym->section = &mips_elf_acom_section;
6023
      break;
6024
 
6025
    case SHN_COMMON:
6026
      /* Common symbols less than the GP size are automatically
6027
         treated as SHN_MIPS_SCOMMON symbols on IRIX5.  */
6028
      if (asym->value > elf_gp_size (abfd)
6029
          || ELF_ST_TYPE (elfsym->internal_elf_sym.st_info) == STT_TLS
6030
          || IRIX_COMPAT (abfd) == ict_irix6)
6031
        break;
6032
      /* Fall through.  */
6033
    case SHN_MIPS_SCOMMON:
6034
      if (mips_elf_scom_section.name == NULL)
6035
        {
6036
          /* Initialize the small common section.  */
6037
          mips_elf_scom_section.name = ".scommon";
6038
          mips_elf_scom_section.flags = SEC_IS_COMMON;
6039
          mips_elf_scom_section.output_section = &mips_elf_scom_section;
6040
          mips_elf_scom_section.symbol = &mips_elf_scom_symbol;
6041
          mips_elf_scom_section.symbol_ptr_ptr = &mips_elf_scom_symbol_ptr;
6042
          mips_elf_scom_symbol.name = ".scommon";
6043
          mips_elf_scom_symbol.flags = BSF_SECTION_SYM;
6044
          mips_elf_scom_symbol.section = &mips_elf_scom_section;
6045
          mips_elf_scom_symbol_ptr = &mips_elf_scom_symbol;
6046
        }
6047
      asym->section = &mips_elf_scom_section;
6048
      asym->value = elfsym->internal_elf_sym.st_size;
6049
      break;
6050
 
6051
    case SHN_MIPS_SUNDEFINED:
6052
      asym->section = bfd_und_section_ptr;
6053
      break;
6054
 
6055
    case SHN_MIPS_TEXT:
6056
      {
6057
        asection *section = bfd_get_section_by_name (abfd, ".text");
6058
 
6059
        BFD_ASSERT (SGI_COMPAT (abfd));
6060
        if (section != NULL)
6061
          {
6062
            asym->section = section;
6063
            /* MIPS_TEXT is a bit special, the address is not an offset
6064
               to the base of the .text section.  So substract the section
6065
               base address to make it an offset.  */
6066
            asym->value -= section->vma;
6067
          }
6068
      }
6069
      break;
6070
 
6071
    case SHN_MIPS_DATA:
6072
      {
6073
        asection *section = bfd_get_section_by_name (abfd, ".data");
6074
 
6075
        BFD_ASSERT (SGI_COMPAT (abfd));
6076
        if (section != NULL)
6077
          {
6078
            asym->section = section;
6079
            /* MIPS_DATA is a bit special, the address is not an offset
6080
               to the base of the .data section.  So substract the section
6081
               base address to make it an offset.  */
6082
            asym->value -= section->vma;
6083
          }
6084
      }
6085
      break;
6086
    }
6087 225 jeremybenn
 
6088
  /* If this is an odd-valued function symbol, assume it's a MIPS16 one.  */
6089
  if (ELF_ST_TYPE (elfsym->internal_elf_sym.st_info) == STT_FUNC
6090
      && (asym->value & 1) != 0)
6091
    {
6092
      asym->value--;
6093
      elfsym->internal_elf_sym.st_other
6094
        = ELF_ST_SET_MIPS16 (elfsym->internal_elf_sym.st_other);
6095
    }
6096 24 jeremybenn
}
6097
 
6098
/* Implement elf_backend_eh_frame_address_size.  This differs from
6099
   the default in the way it handles EABI64.
6100
 
6101
   EABI64 was originally specified as an LP64 ABI, and that is what
6102
   -mabi=eabi normally gives on a 64-bit target.  However, gcc has
6103
   historically accepted the combination of -mabi=eabi and -mlong32,
6104
   and this ILP32 variation has become semi-official over time.
6105
   Both forms use elf32 and have pointer-sized FDE addresses.
6106
 
6107
   If an EABI object was generated by GCC 4.0 or above, it will have
6108
   an empty .gcc_compiled_longXX section, where XX is the size of longs
6109
   in bits.  Unfortunately, ILP32 objects generated by earlier compilers
6110
   have no special marking to distinguish them from LP64 objects.
6111
 
6112
   We don't want users of the official LP64 ABI to be punished for the
6113
   existence of the ILP32 variant, but at the same time, we don't want
6114
   to mistakenly interpret pre-4.0 ILP32 objects as being LP64 objects.
6115
   We therefore take the following approach:
6116
 
6117
      - If ABFD contains a .gcc_compiled_longXX section, use it to
6118
        determine the pointer size.
6119
 
6120
      - Otherwise check the type of the first relocation.  Assume that
6121
        the LP64 ABI is being used if the relocation is of type R_MIPS_64.
6122
 
6123
      - Otherwise punt.
6124
 
6125
   The second check is enough to detect LP64 objects generated by pre-4.0
6126
   compilers because, in the kind of output generated by those compilers,
6127
   the first relocation will be associated with either a CIE personality
6128
   routine or an FDE start address.  Furthermore, the compilers never
6129
   used a special (non-pointer) encoding for this ABI.
6130
 
6131
   Checking the relocation type should also be safe because there is no
6132
   reason to use R_MIPS_64 in an ILP32 object.  Pre-4.0 compilers never
6133
   did so.  */
6134
 
6135
unsigned int
6136
_bfd_mips_elf_eh_frame_address_size (bfd *abfd, asection *sec)
6137
{
6138
  if (elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS64)
6139
    return 8;
6140
  if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64)
6141
    {
6142
      bfd_boolean long32_p, long64_p;
6143
 
6144
      long32_p = bfd_get_section_by_name (abfd, ".gcc_compiled_long32") != 0;
6145
      long64_p = bfd_get_section_by_name (abfd, ".gcc_compiled_long64") != 0;
6146
      if (long32_p && long64_p)
6147
        return 0;
6148
      if (long32_p)
6149
        return 4;
6150
      if (long64_p)
6151
        return 8;
6152
 
6153
      if (sec->reloc_count > 0
6154
          && elf_section_data (sec)->relocs != NULL
6155
          && (ELF32_R_TYPE (elf_section_data (sec)->relocs[0].r_info)
6156
              == R_MIPS_64))
6157
        return 8;
6158
 
6159
      return 0;
6160
    }
6161
  return 4;
6162
}
6163
 
6164
/* There appears to be a bug in the MIPSpro linker that causes GOT_DISP
6165
   relocations against two unnamed section symbols to resolve to the
6166
   same address.  For example, if we have code like:
6167
 
6168
        lw      $4,%got_disp(.data)($gp)
6169
        lw      $25,%got_disp(.text)($gp)
6170
        jalr    $25
6171
 
6172
   then the linker will resolve both relocations to .data and the program
6173
   will jump there rather than to .text.
6174
 
6175
   We can work around this problem by giving names to local section symbols.
6176
   This is also what the MIPSpro tools do.  */
6177
 
6178
bfd_boolean
6179
_bfd_mips_elf_name_local_section_symbols (bfd *abfd)
6180
{
6181
  return SGI_COMPAT (abfd);
6182
}
6183
 
6184
/* Work over a section just before writing it out.  This routine is
6185
   used by both the 32-bit and the 64-bit ABI.  FIXME: We recognize
6186
   sections that need the SHF_MIPS_GPREL flag by name; there has to be
6187
   a better way.  */
6188
 
6189
bfd_boolean
6190
_bfd_mips_elf_section_processing (bfd *abfd, Elf_Internal_Shdr *hdr)
6191
{
6192
  if (hdr->sh_type == SHT_MIPS_REGINFO
6193
      && hdr->sh_size > 0)
6194
    {
6195
      bfd_byte buf[4];
6196
 
6197
      BFD_ASSERT (hdr->sh_size == sizeof (Elf32_External_RegInfo));
6198
      BFD_ASSERT (hdr->contents == NULL);
6199
 
6200
      if (bfd_seek (abfd,
6201
                    hdr->sh_offset + sizeof (Elf32_External_RegInfo) - 4,
6202
                    SEEK_SET) != 0)
6203
        return FALSE;
6204
      H_PUT_32 (abfd, elf_gp (abfd), buf);
6205
      if (bfd_bwrite (buf, 4, abfd) != 4)
6206
        return FALSE;
6207
    }
6208
 
6209
  if (hdr->sh_type == SHT_MIPS_OPTIONS
6210
      && hdr->bfd_section != NULL
6211
      && mips_elf_section_data (hdr->bfd_section) != NULL
6212
      && mips_elf_section_data (hdr->bfd_section)->u.tdata != NULL)
6213
    {
6214
      bfd_byte *contents, *l, *lend;
6215
 
6216
      /* We stored the section contents in the tdata field in the
6217
         set_section_contents routine.  We save the section contents
6218
         so that we don't have to read them again.
6219
         At this point we know that elf_gp is set, so we can look
6220
         through the section contents to see if there is an
6221
         ODK_REGINFO structure.  */
6222
 
6223
      contents = mips_elf_section_data (hdr->bfd_section)->u.tdata;
6224
      l = contents;
6225
      lend = contents + hdr->sh_size;
6226
      while (l + sizeof (Elf_External_Options) <= lend)
6227
        {
6228
          Elf_Internal_Options intopt;
6229
 
6230
          bfd_mips_elf_swap_options_in (abfd, (Elf_External_Options *) l,
6231
                                        &intopt);
6232
          if (intopt.size < sizeof (Elf_External_Options))
6233
            {
6234
              (*_bfd_error_handler)
6235
                (_("%B: Warning: bad `%s' option size %u smaller than its header"),
6236
                abfd, MIPS_ELF_OPTIONS_SECTION_NAME (abfd), intopt.size);
6237
              break;
6238
            }
6239
          if (ABI_64_P (abfd) && intopt.kind == ODK_REGINFO)
6240
            {
6241
              bfd_byte buf[8];
6242
 
6243
              if (bfd_seek (abfd,
6244
                            (hdr->sh_offset
6245
                             + (l - contents)
6246
                             + sizeof (Elf_External_Options)
6247
                             + (sizeof (Elf64_External_RegInfo) - 8)),
6248
                             SEEK_SET) != 0)
6249
                return FALSE;
6250
              H_PUT_64 (abfd, elf_gp (abfd), buf);
6251
              if (bfd_bwrite (buf, 8, abfd) != 8)
6252
                return FALSE;
6253
            }
6254
          else if (intopt.kind == ODK_REGINFO)
6255
            {
6256
              bfd_byte buf[4];
6257
 
6258
              if (bfd_seek (abfd,
6259
                            (hdr->sh_offset
6260
                             + (l - contents)
6261
                             + sizeof (Elf_External_Options)
6262
                             + (sizeof (Elf32_External_RegInfo) - 4)),
6263
                            SEEK_SET) != 0)
6264
                return FALSE;
6265
              H_PUT_32 (abfd, elf_gp (abfd), buf);
6266
              if (bfd_bwrite (buf, 4, abfd) != 4)
6267
                return FALSE;
6268
            }
6269
          l += intopt.size;
6270
        }
6271
    }
6272
 
6273
  if (hdr->bfd_section != NULL)
6274
    {
6275
      const char *name = bfd_get_section_name (abfd, hdr->bfd_section);
6276
 
6277 225 jeremybenn
      /* .sbss is not handled specially here because the GNU/Linux
6278
         prelinker can convert .sbss from NOBITS to PROGBITS and
6279
         changing it back to NOBITS breaks the binary.  The entry in
6280
         _bfd_mips_elf_special_sections will ensure the correct flags
6281
         are set on .sbss if BFD creates it without reading it from an
6282
         input file, and without special handling here the flags set
6283
         on it in an input file will be followed.  */
6284 24 jeremybenn
      if (strcmp (name, ".sdata") == 0
6285
          || strcmp (name, ".lit8") == 0
6286
          || strcmp (name, ".lit4") == 0)
6287
        {
6288
          hdr->sh_flags |= SHF_ALLOC | SHF_WRITE | SHF_MIPS_GPREL;
6289
          hdr->sh_type = SHT_PROGBITS;
6290
        }
6291
      else if (strcmp (name, ".srdata") == 0)
6292
        {
6293
          hdr->sh_flags |= SHF_ALLOC | SHF_MIPS_GPREL;
6294
          hdr->sh_type = SHT_PROGBITS;
6295
        }
6296
      else if (strcmp (name, ".compact_rel") == 0)
6297
        {
6298
          hdr->sh_flags = 0;
6299
          hdr->sh_type = SHT_PROGBITS;
6300
        }
6301
      else if (strcmp (name, ".rtproc") == 0)
6302
        {
6303
          if (hdr->sh_addralign != 0 && hdr->sh_entsize == 0)
6304
            {
6305
              unsigned int adjust;
6306
 
6307
              adjust = hdr->sh_size % hdr->sh_addralign;
6308
              if (adjust != 0)
6309
                hdr->sh_size += hdr->sh_addralign - adjust;
6310
            }
6311
        }
6312
    }
6313
 
6314
  return TRUE;
6315
}
6316
 
6317
/* Handle a MIPS specific section when reading an object file.  This
6318
   is called when elfcode.h finds a section with an unknown type.
6319
   This routine supports both the 32-bit and 64-bit ELF ABI.
6320
 
6321
   FIXME: We need to handle the SHF_MIPS_GPREL flag, but I'm not sure
6322
   how to.  */
6323
 
6324
bfd_boolean
6325
_bfd_mips_elf_section_from_shdr (bfd *abfd,
6326
                                 Elf_Internal_Shdr *hdr,
6327
                                 const char *name,
6328
                                 int shindex)
6329
{
6330
  flagword flags = 0;
6331
 
6332
  /* There ought to be a place to keep ELF backend specific flags, but
6333
     at the moment there isn't one.  We just keep track of the
6334
     sections by their name, instead.  Fortunately, the ABI gives
6335
     suggested names for all the MIPS specific sections, so we will
6336
     probably get away with this.  */
6337
  switch (hdr->sh_type)
6338
    {
6339
    case SHT_MIPS_LIBLIST:
6340
      if (strcmp (name, ".liblist") != 0)
6341
        return FALSE;
6342
      break;
6343
    case SHT_MIPS_MSYM:
6344
      if (strcmp (name, ".msym") != 0)
6345
        return FALSE;
6346
      break;
6347
    case SHT_MIPS_CONFLICT:
6348
      if (strcmp (name, ".conflict") != 0)
6349
        return FALSE;
6350
      break;
6351
    case SHT_MIPS_GPTAB:
6352
      if (! CONST_STRNEQ (name, ".gptab."))
6353
        return FALSE;
6354
      break;
6355
    case SHT_MIPS_UCODE:
6356
      if (strcmp (name, ".ucode") != 0)
6357
        return FALSE;
6358
      break;
6359
    case SHT_MIPS_DEBUG:
6360
      if (strcmp (name, ".mdebug") != 0)
6361
        return FALSE;
6362
      flags = SEC_DEBUGGING;
6363
      break;
6364
    case SHT_MIPS_REGINFO:
6365
      if (strcmp (name, ".reginfo") != 0
6366
          || hdr->sh_size != sizeof (Elf32_External_RegInfo))
6367
        return FALSE;
6368
      flags = (SEC_LINK_ONCE | SEC_LINK_DUPLICATES_SAME_SIZE);
6369
      break;
6370
    case SHT_MIPS_IFACE:
6371
      if (strcmp (name, ".MIPS.interfaces") != 0)
6372
        return FALSE;
6373
      break;
6374
    case SHT_MIPS_CONTENT:
6375
      if (! CONST_STRNEQ (name, ".MIPS.content"))
6376
        return FALSE;
6377
      break;
6378
    case SHT_MIPS_OPTIONS:
6379
      if (!MIPS_ELF_OPTIONS_SECTION_NAME_P (name))
6380
        return FALSE;
6381
      break;
6382
    case SHT_MIPS_DWARF:
6383 225 jeremybenn
      if (! CONST_STRNEQ (name, ".debug_")
6384
          && ! CONST_STRNEQ (name, ".zdebug_"))
6385 24 jeremybenn
        return FALSE;
6386
      break;
6387
    case SHT_MIPS_SYMBOL_LIB:
6388
      if (strcmp (name, ".MIPS.symlib") != 0)
6389
        return FALSE;
6390
      break;
6391
    case SHT_MIPS_EVENTS:
6392
      if (! CONST_STRNEQ (name, ".MIPS.events")
6393
          && ! CONST_STRNEQ (name, ".MIPS.post_rel"))
6394
        return FALSE;
6395
      break;
6396
    default:
6397
      break;
6398
    }
6399
 
6400
  if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
6401
    return FALSE;
6402
 
6403
  if (flags)
6404
    {
6405
      if (! bfd_set_section_flags (abfd, hdr->bfd_section,
6406
                                   (bfd_get_section_flags (abfd,
6407
                                                           hdr->bfd_section)
6408
                                    | flags)))
6409
        return FALSE;
6410
    }
6411
 
6412
  /* FIXME: We should record sh_info for a .gptab section.  */
6413
 
6414
  /* For a .reginfo section, set the gp value in the tdata information
6415
     from the contents of this section.  We need the gp value while
6416
     processing relocs, so we just get it now.  The .reginfo section
6417
     is not used in the 64-bit MIPS ELF ABI.  */
6418
  if (hdr->sh_type == SHT_MIPS_REGINFO)
6419
    {
6420
      Elf32_External_RegInfo ext;
6421
      Elf32_RegInfo s;
6422
 
6423
      if (! bfd_get_section_contents (abfd, hdr->bfd_section,
6424
                                      &ext, 0, sizeof ext))
6425
        return FALSE;
6426
      bfd_mips_elf32_swap_reginfo_in (abfd, &ext, &s);
6427
      elf_gp (abfd) = s.ri_gp_value;
6428
    }
6429
 
6430
  /* For a SHT_MIPS_OPTIONS section, look for a ODK_REGINFO entry, and
6431
     set the gp value based on what we find.  We may see both
6432
     SHT_MIPS_REGINFO and SHT_MIPS_OPTIONS/ODK_REGINFO; in that case,
6433
     they should agree.  */
6434
  if (hdr->sh_type == SHT_MIPS_OPTIONS)
6435
    {
6436
      bfd_byte *contents, *l, *lend;
6437
 
6438
      contents = bfd_malloc (hdr->sh_size);
6439
      if (contents == NULL)
6440
        return FALSE;
6441
      if (! bfd_get_section_contents (abfd, hdr->bfd_section, contents,
6442
                                      0, hdr->sh_size))
6443
        {
6444
          free (contents);
6445
          return FALSE;
6446
        }
6447
      l = contents;
6448
      lend = contents + hdr->sh_size;
6449
      while (l + sizeof (Elf_External_Options) <= lend)
6450
        {
6451
          Elf_Internal_Options intopt;
6452
 
6453
          bfd_mips_elf_swap_options_in (abfd, (Elf_External_Options *) l,
6454
                                        &intopt);
6455
          if (intopt.size < sizeof (Elf_External_Options))
6456
            {
6457
              (*_bfd_error_handler)
6458
                (_("%B: Warning: bad `%s' option size %u smaller than its header"),
6459
                abfd, MIPS_ELF_OPTIONS_SECTION_NAME (abfd), intopt.size);
6460
              break;
6461
            }
6462
          if (ABI_64_P (abfd) && intopt.kind == ODK_REGINFO)
6463
            {
6464
              Elf64_Internal_RegInfo intreg;
6465
 
6466
              bfd_mips_elf64_swap_reginfo_in
6467
                (abfd,
6468
                 ((Elf64_External_RegInfo *)
6469
                  (l + sizeof (Elf_External_Options))),
6470
                 &intreg);
6471
              elf_gp (abfd) = intreg.ri_gp_value;
6472
            }
6473
          else if (intopt.kind == ODK_REGINFO)
6474
            {
6475
              Elf32_RegInfo intreg;
6476
 
6477
              bfd_mips_elf32_swap_reginfo_in
6478
                (abfd,
6479
                 ((Elf32_External_RegInfo *)
6480
                  (l + sizeof (Elf_External_Options))),
6481
                 &intreg);
6482
              elf_gp (abfd) = intreg.ri_gp_value;
6483
            }
6484
          l += intopt.size;
6485
        }
6486
      free (contents);
6487
    }
6488
 
6489
  return TRUE;
6490
}
6491
 
6492
/* Set the correct type for a MIPS ELF section.  We do this by the
6493
   section name, which is a hack, but ought to work.  This routine is
6494
   used by both the 32-bit and the 64-bit ABI.  */
6495
 
6496
bfd_boolean
6497
_bfd_mips_elf_fake_sections (bfd *abfd, Elf_Internal_Shdr *hdr, asection *sec)
6498
{
6499
  const char *name = bfd_get_section_name (abfd, sec);
6500
 
6501
  if (strcmp (name, ".liblist") == 0)
6502
    {
6503
      hdr->sh_type = SHT_MIPS_LIBLIST;
6504
      hdr->sh_info = sec->size / sizeof (Elf32_Lib);
6505
      /* The sh_link field is set in final_write_processing.  */
6506
    }
6507
  else if (strcmp (name, ".conflict") == 0)
6508
    hdr->sh_type = SHT_MIPS_CONFLICT;
6509
  else if (CONST_STRNEQ (name, ".gptab."))
6510
    {
6511
      hdr->sh_type = SHT_MIPS_GPTAB;
6512
      hdr->sh_entsize = sizeof (Elf32_External_gptab);
6513
      /* The sh_info field is set in final_write_processing.  */
6514
    }
6515
  else if (strcmp (name, ".ucode") == 0)
6516
    hdr->sh_type = SHT_MIPS_UCODE;
6517
  else if (strcmp (name, ".mdebug") == 0)
6518
    {
6519
      hdr->sh_type = SHT_MIPS_DEBUG;
6520
      /* In a shared object on IRIX 5.3, the .mdebug section has an
6521
         entsize of 0.  FIXME: Does this matter?  */
6522
      if (SGI_COMPAT (abfd) && (abfd->flags & DYNAMIC) != 0)
6523
        hdr->sh_entsize = 0;
6524
      else
6525
        hdr->sh_entsize = 1;
6526
    }
6527
  else if (strcmp (name, ".reginfo") == 0)
6528
    {
6529
      hdr->sh_type = SHT_MIPS_REGINFO;
6530
      /* In a shared object on IRIX 5.3, the .reginfo section has an
6531
         entsize of 0x18.  FIXME: Does this matter?  */
6532
      if (SGI_COMPAT (abfd))
6533
        {
6534
          if ((abfd->flags & DYNAMIC) != 0)
6535
            hdr->sh_entsize = sizeof (Elf32_External_RegInfo);
6536
          else
6537
            hdr->sh_entsize = 1;
6538
        }
6539
      else
6540
        hdr->sh_entsize = sizeof (Elf32_External_RegInfo);
6541
    }
6542
  else if (SGI_COMPAT (abfd)
6543
           && (strcmp (name, ".hash") == 0
6544
               || strcmp (name, ".dynamic") == 0
6545
               || strcmp (name, ".dynstr") == 0))
6546
    {
6547
      if (SGI_COMPAT (abfd))
6548
        hdr->sh_entsize = 0;
6549
#if 0
6550
      /* This isn't how the IRIX6 linker behaves.  */
6551
      hdr->sh_info = SIZEOF_MIPS_DYNSYM_SECNAMES;
6552
#endif
6553
    }
6554
  else if (strcmp (name, ".got") == 0
6555
           || strcmp (name, ".srdata") == 0
6556
           || strcmp (name, ".sdata") == 0
6557
           || strcmp (name, ".sbss") == 0
6558
           || strcmp (name, ".lit4") == 0
6559
           || strcmp (name, ".lit8") == 0)
6560
    hdr->sh_flags |= SHF_MIPS_GPREL;
6561
  else if (strcmp (name, ".MIPS.interfaces") == 0)
6562
    {
6563
      hdr->sh_type = SHT_MIPS_IFACE;
6564
      hdr->sh_flags |= SHF_MIPS_NOSTRIP;
6565
    }
6566
  else if (CONST_STRNEQ (name, ".MIPS.content"))
6567
    {
6568
      hdr->sh_type = SHT_MIPS_CONTENT;
6569
      hdr->sh_flags |= SHF_MIPS_NOSTRIP;
6570
      /* The sh_info field is set in final_write_processing.  */
6571
    }
6572
  else if (MIPS_ELF_OPTIONS_SECTION_NAME_P (name))
6573
    {
6574
      hdr->sh_type = SHT_MIPS_OPTIONS;
6575
      hdr->sh_entsize = 1;
6576
      hdr->sh_flags |= SHF_MIPS_NOSTRIP;
6577
    }
6578 225 jeremybenn
  else if (CONST_STRNEQ (name, ".debug_")
6579
           || CONST_STRNEQ (name, ".zdebug_"))
6580 24 jeremybenn
    {
6581
      hdr->sh_type = SHT_MIPS_DWARF;
6582
 
6583
      /* Irix facilities such as libexc expect a single .debug_frame
6584
         per executable, the system ones have NOSTRIP set and the linker
6585
         doesn't merge sections with different flags so ...  */
6586
      if (SGI_COMPAT (abfd) && CONST_STRNEQ (name, ".debug_frame"))
6587
        hdr->sh_flags |= SHF_MIPS_NOSTRIP;
6588
    }
6589
  else if (strcmp (name, ".MIPS.symlib") == 0)
6590
    {
6591
      hdr->sh_type = SHT_MIPS_SYMBOL_LIB;
6592
      /* The sh_link and sh_info fields are set in
6593
         final_write_processing.  */
6594
    }
6595
  else if (CONST_STRNEQ (name, ".MIPS.events")
6596
           || CONST_STRNEQ (name, ".MIPS.post_rel"))
6597
    {
6598
      hdr->sh_type = SHT_MIPS_EVENTS;
6599
      hdr->sh_flags |= SHF_MIPS_NOSTRIP;
6600
      /* The sh_link field is set in final_write_processing.  */
6601
    }
6602
  else if (strcmp (name, ".msym") == 0)
6603
    {
6604
      hdr->sh_type = SHT_MIPS_MSYM;
6605
      hdr->sh_flags |= SHF_ALLOC;
6606
      hdr->sh_entsize = 8;
6607
    }
6608
 
6609
  /* The generic elf_fake_sections will set up REL_HDR using the default
6610
   kind of relocations.  We used to set up a second header for the
6611
   non-default kind of relocations here, but only NewABI would use
6612
   these, and the IRIX ld doesn't like resulting empty RELA sections.
6613
   Thus we create those header only on demand now.  */
6614
 
6615
  return TRUE;
6616
}
6617
 
6618
/* Given a BFD section, try to locate the corresponding ELF section
6619
   index.  This is used by both the 32-bit and the 64-bit ABI.
6620
   Actually, it's not clear to me that the 64-bit ABI supports these,
6621
   but for non-PIC objects we will certainly want support for at least
6622
   the .scommon section.  */
6623
 
6624
bfd_boolean
6625
_bfd_mips_elf_section_from_bfd_section (bfd *abfd ATTRIBUTE_UNUSED,
6626
                                        asection *sec, int *retval)
6627
{
6628
  if (strcmp (bfd_get_section_name (abfd, sec), ".scommon") == 0)
6629
    {
6630
      *retval = SHN_MIPS_SCOMMON;
6631
      return TRUE;
6632
    }
6633
  if (strcmp (bfd_get_section_name (abfd, sec), ".acommon") == 0)
6634
    {
6635
      *retval = SHN_MIPS_ACOMMON;
6636
      return TRUE;
6637
    }
6638
  return FALSE;
6639
}
6640
 
6641
/* Hook called by the linker routine which adds symbols from an object
6642
   file.  We must handle the special MIPS section numbers here.  */
6643
 
6644
bfd_boolean
6645
_bfd_mips_elf_add_symbol_hook (bfd *abfd, struct bfd_link_info *info,
6646
                               Elf_Internal_Sym *sym, const char **namep,
6647
                               flagword *flagsp ATTRIBUTE_UNUSED,
6648
                               asection **secp, bfd_vma *valp)
6649
{
6650
  if (SGI_COMPAT (abfd)
6651
      && (abfd->flags & DYNAMIC) != 0
6652
      && strcmp (*namep, "_rld_new_interface") == 0)
6653
    {
6654
      /* Skip IRIX5 rld entry name.  */
6655
      *namep = NULL;
6656
      return TRUE;
6657
    }
6658
 
6659
  /* Shared objects may have a dynamic symbol '_gp_disp' defined as
6660
     a SECTION *ABS*.  This causes ld to think it can resolve _gp_disp
6661
     by setting a DT_NEEDED for the shared object.  Since _gp_disp is
6662
     a magic symbol resolved by the linker, we ignore this bogus definition
6663
     of _gp_disp.  New ABI objects do not suffer from this problem so this
6664
     is not done for them. */
6665
  if (!NEWABI_P(abfd)
6666
      && (sym->st_shndx == SHN_ABS)
6667
      && (strcmp (*namep, "_gp_disp") == 0))
6668
    {
6669
      *namep = NULL;
6670
      return TRUE;
6671
    }
6672
 
6673
  switch (sym->st_shndx)
6674
    {
6675
    case SHN_COMMON:
6676
      /* Common symbols less than the GP size are automatically
6677
         treated as SHN_MIPS_SCOMMON symbols.  */
6678
      if (sym->st_size > elf_gp_size (abfd)
6679
          || ELF_ST_TYPE (sym->st_info) == STT_TLS
6680
          || IRIX_COMPAT (abfd) == ict_irix6)
6681
        break;
6682
      /* Fall through.  */
6683
    case SHN_MIPS_SCOMMON:
6684
      *secp = bfd_make_section_old_way (abfd, ".scommon");
6685
      (*secp)->flags |= SEC_IS_COMMON;
6686
      *valp = sym->st_size;
6687
      break;
6688
 
6689
    case SHN_MIPS_TEXT:
6690
      /* This section is used in a shared object.  */
6691
      if (elf_tdata (abfd)->elf_text_section == NULL)
6692
        {
6693
          asymbol *elf_text_symbol;
6694
          asection *elf_text_section;
6695
          bfd_size_type amt = sizeof (asection);
6696
 
6697
          elf_text_section = bfd_zalloc (abfd, amt);
6698
          if (elf_text_section == NULL)
6699
            return FALSE;
6700
 
6701
          amt = sizeof (asymbol);
6702
          elf_text_symbol = bfd_zalloc (abfd, amt);
6703
          if (elf_text_symbol == NULL)
6704
            return FALSE;
6705
 
6706
          /* Initialize the section.  */
6707
 
6708
          elf_tdata (abfd)->elf_text_section = elf_text_section;
6709
          elf_tdata (abfd)->elf_text_symbol = elf_text_symbol;
6710
 
6711
          elf_text_section->symbol = elf_text_symbol;
6712
          elf_text_section->symbol_ptr_ptr = &elf_tdata (abfd)->elf_text_symbol;
6713
 
6714
          elf_text_section->name = ".text";
6715
          elf_text_section->flags = SEC_NO_FLAGS;
6716
          elf_text_section->output_section = NULL;
6717
          elf_text_section->owner = abfd;
6718
          elf_text_symbol->name = ".text";
6719
          elf_text_symbol->flags = BSF_SECTION_SYM | BSF_DYNAMIC;
6720
          elf_text_symbol->section = elf_text_section;
6721
        }
6722
      /* This code used to do *secp = bfd_und_section_ptr if
6723
         info->shared.  I don't know why, and that doesn't make sense,
6724
         so I took it out.  */
6725
      *secp = elf_tdata (abfd)->elf_text_section;
6726
      break;
6727
 
6728
    case SHN_MIPS_ACOMMON:
6729
      /* Fall through. XXX Can we treat this as allocated data?  */
6730
    case SHN_MIPS_DATA:
6731
      /* This section is used in a shared object.  */
6732
      if (elf_tdata (abfd)->elf_data_section == NULL)
6733
        {
6734
          asymbol *elf_data_symbol;
6735
          asection *elf_data_section;
6736
          bfd_size_type amt = sizeof (asection);
6737
 
6738
          elf_data_section = bfd_zalloc (abfd, amt);
6739
          if (elf_data_section == NULL)
6740
            return FALSE;
6741
 
6742
          amt = sizeof (asymbol);
6743
          elf_data_symbol = bfd_zalloc (abfd, amt);
6744
          if (elf_data_symbol == NULL)
6745
            return FALSE;
6746
 
6747
          /* Initialize the section.  */
6748
 
6749
          elf_tdata (abfd)->elf_data_section = elf_data_section;
6750
          elf_tdata (abfd)->elf_data_symbol = elf_data_symbol;
6751
 
6752
          elf_data_section->symbol = elf_data_symbol;
6753
          elf_data_section->symbol_ptr_ptr = &elf_tdata (abfd)->elf_data_symbol;
6754
 
6755
          elf_data_section->name = ".data";
6756
          elf_data_section->flags = SEC_NO_FLAGS;
6757
          elf_data_section->output_section = NULL;
6758
          elf_data_section->owner = abfd;
6759
          elf_data_symbol->name = ".data";
6760
          elf_data_symbol->flags = BSF_SECTION_SYM | BSF_DYNAMIC;
6761
          elf_data_symbol->section = elf_data_section;
6762
        }
6763
      /* This code used to do *secp = bfd_und_section_ptr if
6764
         info->shared.  I don't know why, and that doesn't make sense,
6765
         so I took it out.  */
6766
      *secp = elf_tdata (abfd)->elf_data_section;
6767
      break;
6768
 
6769
    case SHN_MIPS_SUNDEFINED:
6770
      *secp = bfd_und_section_ptr;
6771
      break;
6772
    }
6773
 
6774
  if (SGI_COMPAT (abfd)
6775
      && ! info->shared
6776
      && info->output_bfd->xvec == abfd->xvec
6777
      && strcmp (*namep, "__rld_obj_head") == 0)
6778
    {
6779
      struct elf_link_hash_entry *h;
6780
      struct bfd_link_hash_entry *bh;
6781
 
6782
      /* Mark __rld_obj_head as dynamic.  */
6783
      bh = NULL;
6784
      if (! (_bfd_generic_link_add_one_symbol
6785
             (info, abfd, *namep, BSF_GLOBAL, *secp, *valp, NULL, FALSE,
6786
              get_elf_backend_data (abfd)->collect, &bh)))
6787
        return FALSE;
6788
 
6789
      h = (struct elf_link_hash_entry *) bh;
6790
      h->non_elf = 0;
6791
      h->def_regular = 1;
6792
      h->type = STT_OBJECT;
6793
 
6794
      if (! bfd_elf_link_record_dynamic_symbol (info, h))
6795
        return FALSE;
6796
 
6797
      mips_elf_hash_table (info)->use_rld_obj_head = TRUE;
6798
    }
6799
 
6800
  /* If this is a mips16 text symbol, add 1 to the value to make it
6801
     odd.  This will cause something like .word SYM to come up with
6802
     the right value when it is loaded into the PC.  */
6803 225 jeremybenn
  if (ELF_ST_IS_MIPS16 (sym->st_other))
6804 24 jeremybenn
    ++*valp;
6805
 
6806
  return TRUE;
6807
}
6808
 
6809
/* This hook function is called before the linker writes out a global
6810
   symbol.  We mark symbols as small common if appropriate.  This is
6811
   also where we undo the increment of the value for a mips16 symbol.  */
6812
 
6813 225 jeremybenn
int
6814 24 jeremybenn
_bfd_mips_elf_link_output_symbol_hook
6815
  (struct bfd_link_info *info ATTRIBUTE_UNUSED,
6816
   const char *name ATTRIBUTE_UNUSED, Elf_Internal_Sym *sym,
6817
   asection *input_sec, struct elf_link_hash_entry *h ATTRIBUTE_UNUSED)
6818
{
6819
  /* If we see a common symbol, which implies a relocatable link, then
6820
     if a symbol was small common in an input file, mark it as small
6821
     common in the output file.  */
6822
  if (sym->st_shndx == SHN_COMMON
6823
      && strcmp (input_sec->name, ".scommon") == 0)
6824
    sym->st_shndx = SHN_MIPS_SCOMMON;
6825
 
6826 225 jeremybenn
  if (ELF_ST_IS_MIPS16 (sym->st_other))
6827 24 jeremybenn
    sym->st_value &= ~1;
6828
 
6829 225 jeremybenn
  return 1;
6830 24 jeremybenn
}
6831
 
6832
/* Functions for the dynamic linker.  */
6833
 
6834
/* Create dynamic sections when linking against a dynamic object.  */
6835
 
6836
bfd_boolean
6837
_bfd_mips_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
6838
{
6839
  struct elf_link_hash_entry *h;
6840
  struct bfd_link_hash_entry *bh;
6841
  flagword flags;
6842
  register asection *s;
6843
  const char * const *namep;
6844
  struct mips_elf_link_hash_table *htab;
6845
 
6846
  htab = mips_elf_hash_table (info);
6847
  flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
6848
           | SEC_LINKER_CREATED | SEC_READONLY);
6849
 
6850
  /* The psABI requires a read-only .dynamic section, but the VxWorks
6851
     EABI doesn't.  */
6852
  if (!htab->is_vxworks)
6853
    {
6854
      s = bfd_get_section_by_name (abfd, ".dynamic");
6855
      if (s != NULL)
6856
        {
6857
          if (! bfd_set_section_flags (abfd, s, flags))
6858
            return FALSE;
6859
        }
6860
    }
6861
 
6862
  /* We need to create .got section.  */
6863 225 jeremybenn
  if (!mips_elf_create_got_section (abfd, info))
6864 24 jeremybenn
    return FALSE;
6865
 
6866
  if (! mips_elf_rel_dyn_section (info, TRUE))
6867
    return FALSE;
6868
 
6869
  /* Create .stub section.  */
6870 225 jeremybenn
  s = bfd_make_section_with_flags (abfd,
6871
                                   MIPS_ELF_STUB_SECTION_NAME (abfd),
6872
                                   flags | SEC_CODE);
6873
  if (s == NULL
6874
      || ! bfd_set_section_alignment (abfd, s,
6875
                                      MIPS_ELF_LOG_FILE_ALIGN (abfd)))
6876
    return FALSE;
6877
  htab->sstubs = s;
6878 24 jeremybenn
 
6879
  if ((IRIX_COMPAT (abfd) == ict_irix5 || IRIX_COMPAT (abfd) == ict_none)
6880
      && !info->shared
6881
      && bfd_get_section_by_name (abfd, ".rld_map") == NULL)
6882
    {
6883
      s = bfd_make_section_with_flags (abfd, ".rld_map",
6884
                                       flags &~ (flagword) SEC_READONLY);
6885
      if (s == NULL
6886
          || ! bfd_set_section_alignment (abfd, s,
6887
                                          MIPS_ELF_LOG_FILE_ALIGN (abfd)))
6888
        return FALSE;
6889
    }
6890
 
6891
  /* On IRIX5, we adjust add some additional symbols and change the
6892
     alignments of several sections.  There is no ABI documentation
6893
     indicating that this is necessary on IRIX6, nor any evidence that
6894
     the linker takes such action.  */
6895
  if (IRIX_COMPAT (abfd) == ict_irix5)
6896
    {
6897
      for (namep = mips_elf_dynsym_rtproc_names; *namep != NULL; namep++)
6898
        {
6899
          bh = NULL;
6900
          if (! (_bfd_generic_link_add_one_symbol
6901
                 (info, abfd, *namep, BSF_GLOBAL, bfd_und_section_ptr, 0,
6902
                  NULL, FALSE, get_elf_backend_data (abfd)->collect, &bh)))
6903
            return FALSE;
6904
 
6905
          h = (struct elf_link_hash_entry *) bh;
6906
          h->non_elf = 0;
6907
          h->def_regular = 1;
6908
          h->type = STT_SECTION;
6909
 
6910
          if (! bfd_elf_link_record_dynamic_symbol (info, h))
6911
            return FALSE;
6912
        }
6913
 
6914
      /* We need to create a .compact_rel section.  */
6915
      if (SGI_COMPAT (abfd))
6916
        {
6917
          if (!mips_elf_create_compact_rel_section (abfd, info))
6918
            return FALSE;
6919
        }
6920
 
6921
      /* Change alignments of some sections.  */
6922
      s = bfd_get_section_by_name (abfd, ".hash");
6923
      if (s != NULL)
6924
        bfd_set_section_alignment (abfd, s, MIPS_ELF_LOG_FILE_ALIGN (abfd));
6925
      s = bfd_get_section_by_name (abfd, ".dynsym");
6926
      if (s != NULL)
6927
        bfd_set_section_alignment (abfd, s, MIPS_ELF_LOG_FILE_ALIGN (abfd));
6928
      s = bfd_get_section_by_name (abfd, ".dynstr");
6929
      if (s != NULL)
6930
        bfd_set_section_alignment (abfd, s, MIPS_ELF_LOG_FILE_ALIGN (abfd));
6931
      s = bfd_get_section_by_name (abfd, ".reginfo");
6932
      if (s != NULL)
6933
        bfd_set_section_alignment (abfd, s, MIPS_ELF_LOG_FILE_ALIGN (abfd));
6934
      s = bfd_get_section_by_name (abfd, ".dynamic");
6935
      if (s != NULL)
6936
        bfd_set_section_alignment (abfd, s, MIPS_ELF_LOG_FILE_ALIGN (abfd));
6937
    }
6938
 
6939
  if (!info->shared)
6940
    {
6941
      const char *name;
6942
 
6943
      name = SGI_COMPAT (abfd) ? "_DYNAMIC_LINK" : "_DYNAMIC_LINKING";
6944
      bh = NULL;
6945
      if (!(_bfd_generic_link_add_one_symbol
6946
            (info, abfd, name, BSF_GLOBAL, bfd_abs_section_ptr, 0,
6947
             NULL, FALSE, get_elf_backend_data (abfd)->collect, &bh)))
6948
        return FALSE;
6949
 
6950
      h = (struct elf_link_hash_entry *) bh;
6951
      h->non_elf = 0;
6952
      h->def_regular = 1;
6953
      h->type = STT_SECTION;
6954
 
6955
      if (! bfd_elf_link_record_dynamic_symbol (info, h))
6956
        return FALSE;
6957
 
6958
      if (! mips_elf_hash_table (info)->use_rld_obj_head)
6959
        {
6960
          /* __rld_map is a four byte word located in the .data section
6961
             and is filled in by the rtld to contain a pointer to
6962
             the _r_debug structure. Its symbol value will be set in
6963
             _bfd_mips_elf_finish_dynamic_symbol.  */
6964
          s = bfd_get_section_by_name (abfd, ".rld_map");
6965
          BFD_ASSERT (s != NULL);
6966
 
6967
          name = SGI_COMPAT (abfd) ? "__rld_map" : "__RLD_MAP";
6968
          bh = NULL;
6969
          if (!(_bfd_generic_link_add_one_symbol
6970
                (info, abfd, name, BSF_GLOBAL, s, 0, NULL, FALSE,
6971
                 get_elf_backend_data (abfd)->collect, &bh)))
6972
            return FALSE;
6973
 
6974
          h = (struct elf_link_hash_entry *) bh;
6975
          h->non_elf = 0;
6976
          h->def_regular = 1;
6977
          h->type = STT_OBJECT;
6978
 
6979
          if (! bfd_elf_link_record_dynamic_symbol (info, h))
6980
            return FALSE;
6981
        }
6982
    }
6983
 
6984 225 jeremybenn
  /* Create the .plt, .rel(a).plt, .dynbss and .rel(a).bss sections.
6985
     Also create the _PROCEDURE_LINKAGE_TABLE symbol.  */
6986
  if (!_bfd_elf_create_dynamic_sections (abfd, info))
6987
    return FALSE;
6988
 
6989
  /* Cache the sections created above.  */
6990
  htab->splt = bfd_get_section_by_name (abfd, ".plt");
6991
  htab->sdynbss = bfd_get_section_by_name (abfd, ".dynbss");
6992 24 jeremybenn
  if (htab->is_vxworks)
6993
    {
6994
      htab->srelbss = bfd_get_section_by_name (abfd, ".rela.bss");
6995
      htab->srelplt = bfd_get_section_by_name (abfd, ".rela.plt");
6996 225 jeremybenn
    }
6997
  else
6998
    htab->srelplt = bfd_get_section_by_name (abfd, ".rel.plt");
6999
  if (!htab->sdynbss
7000
      || (htab->is_vxworks && !htab->srelbss && !info->shared)
7001
      || !htab->srelplt
7002
      || !htab->splt)
7003
    abort ();
7004 24 jeremybenn
 
7005 225 jeremybenn
  if (htab->is_vxworks)
7006
    {
7007 24 jeremybenn
      /* Do the usual VxWorks handling.  */
7008
      if (!elf_vxworks_create_dynamic_sections (abfd, info, &htab->srelplt2))
7009
        return FALSE;
7010
 
7011
      /* Work out the PLT sizes.  */
7012
      if (info->shared)
7013
        {
7014
          htab->plt_header_size
7015
            = 4 * ARRAY_SIZE (mips_vxworks_shared_plt0_entry);
7016
          htab->plt_entry_size
7017
            = 4 * ARRAY_SIZE (mips_vxworks_shared_plt_entry);
7018
        }
7019
      else
7020
        {
7021
          htab->plt_header_size
7022
            = 4 * ARRAY_SIZE (mips_vxworks_exec_plt0_entry);
7023
          htab->plt_entry_size
7024
            = 4 * ARRAY_SIZE (mips_vxworks_exec_plt_entry);
7025
        }
7026
    }
7027 225 jeremybenn
  else if (!info->shared)
7028
    {
7029
      /* All variants of the plt0 entry are the same size.  */
7030
      htab->plt_header_size = 4 * ARRAY_SIZE (mips_o32_exec_plt0_entry);
7031
      htab->plt_entry_size = 4 * ARRAY_SIZE (mips_exec_plt_entry);
7032
    }
7033 24 jeremybenn
 
7034
  return TRUE;
7035
}
7036
 
7037
/* Return true if relocation REL against section SEC is a REL rather than
7038
   RELA relocation.  RELOCS is the first relocation in the section and
7039
   ABFD is the bfd that contains SEC.  */
7040
 
7041
static bfd_boolean
7042
mips_elf_rel_relocation_p (bfd *abfd, asection *sec,
7043
                           const Elf_Internal_Rela *relocs,
7044
                           const Elf_Internal_Rela *rel)
7045
{
7046
  Elf_Internal_Shdr *rel_hdr;
7047
  const struct elf_backend_data *bed;
7048
 
7049
  /* To determine which flavor or relocation this is, we depend on the
7050
     fact that the INPUT_SECTION's REL_HDR is read before its REL_HDR2.  */
7051
  rel_hdr = &elf_section_data (sec)->rel_hdr;
7052
  bed = get_elf_backend_data (abfd);
7053
  if ((size_t) (rel - relocs)
7054
      >= (NUM_SHDR_ENTRIES (rel_hdr) * bed->s->int_rels_per_ext_rel))
7055
    rel_hdr = elf_section_data (sec)->rel_hdr2;
7056
  return rel_hdr->sh_entsize == MIPS_ELF_REL_SIZE (abfd);
7057
}
7058
 
7059
/* Read the addend for REL relocation REL, which belongs to bfd ABFD.
7060
   HOWTO is the relocation's howto and CONTENTS points to the contents
7061
   of the section that REL is against.  */
7062
 
7063
static bfd_vma
7064
mips_elf_read_rel_addend (bfd *abfd, const Elf_Internal_Rela *rel,
7065
                          reloc_howto_type *howto, bfd_byte *contents)
7066
{
7067
  bfd_byte *location;
7068
  unsigned int r_type;
7069
  bfd_vma addend;
7070
 
7071
  r_type = ELF_R_TYPE (abfd, rel->r_info);
7072
  location = contents + rel->r_offset;
7073
 
7074
  /* Get the addend, which is stored in the input file.  */
7075
  _bfd_mips16_elf_reloc_unshuffle (abfd, r_type, FALSE, location);
7076
  addend = mips_elf_obtain_contents (howto, rel, abfd, contents);
7077
  _bfd_mips16_elf_reloc_shuffle (abfd, r_type, FALSE, location);
7078
 
7079
  return addend & howto->src_mask;
7080
}
7081
 
7082
/* REL is a relocation in ABFD that needs a partnering LO16 relocation
7083
   and *ADDEND is the addend for REL itself.  Look for the LO16 relocation
7084
   and update *ADDEND with the final addend.  Return true on success
7085
   or false if the LO16 could not be found.  RELEND is the exclusive
7086
   upper bound on the relocations for REL's section.  */
7087
 
7088
static bfd_boolean
7089
mips_elf_add_lo16_rel_addend (bfd *abfd,
7090
                              const Elf_Internal_Rela *rel,
7091
                              const Elf_Internal_Rela *relend,
7092
                              bfd_byte *contents, bfd_vma *addend)
7093
{
7094
  unsigned int r_type, lo16_type;
7095
  const Elf_Internal_Rela *lo16_relocation;
7096
  reloc_howto_type *lo16_howto;
7097
  bfd_vma l;
7098
 
7099
  r_type = ELF_R_TYPE (abfd, rel->r_info);
7100 225 jeremybenn
  if (mips16_reloc_p (r_type))
7101 24 jeremybenn
    lo16_type = R_MIPS16_LO16;
7102
  else
7103
    lo16_type = R_MIPS_LO16;
7104
 
7105
  /* The combined value is the sum of the HI16 addend, left-shifted by
7106
     sixteen bits, and the LO16 addend, sign extended.  (Usually, the
7107
     code does a `lui' of the HI16 value, and then an `addiu' of the
7108
     LO16 value.)
7109
 
7110
     Scan ahead to find a matching LO16 relocation.
7111
 
7112
     According to the MIPS ELF ABI, the R_MIPS_LO16 relocation must
7113
     be immediately following.  However, for the IRIX6 ABI, the next
7114
     relocation may be a composed relocation consisting of several
7115
     relocations for the same address.  In that case, the R_MIPS_LO16
7116
     relocation may occur as one of these.  We permit a similar
7117
     extension in general, as that is useful for GCC.
7118
 
7119
     In some cases GCC dead code elimination removes the LO16 but keeps
7120
     the corresponding HI16.  This is strictly speaking a violation of
7121
     the ABI but not immediately harmful.  */
7122
  lo16_relocation = mips_elf_next_relocation (abfd, lo16_type, rel, relend);
7123
  if (lo16_relocation == NULL)
7124
    return FALSE;
7125
 
7126
  /* Obtain the addend kept there.  */
7127
  lo16_howto = MIPS_ELF_RTYPE_TO_HOWTO (abfd, lo16_type, FALSE);
7128
  l = mips_elf_read_rel_addend (abfd, lo16_relocation, lo16_howto, contents);
7129
 
7130
  l <<= lo16_howto->rightshift;
7131
  l = _bfd_mips_elf_sign_extend (l, 16);
7132
 
7133
  *addend <<= 16;
7134
  *addend += l;
7135
  return TRUE;
7136
}
7137
 
7138
/* Try to read the contents of section SEC in bfd ABFD.  Return true and
7139
   store the contents in *CONTENTS on success.  Assume that *CONTENTS
7140
   already holds the contents if it is nonull on entry.  */
7141
 
7142
static bfd_boolean
7143
mips_elf_get_section_contents (bfd *abfd, asection *sec, bfd_byte **contents)
7144
{
7145
  if (*contents)
7146
    return TRUE;
7147
 
7148
  /* Get cached copy if it exists.  */
7149
  if (elf_section_data (sec)->this_hdr.contents != NULL)
7150
    {
7151
      *contents = elf_section_data (sec)->this_hdr.contents;
7152
      return TRUE;
7153
    }
7154
 
7155
  return bfd_malloc_and_get_section (abfd, sec, contents);
7156
}
7157
 
7158
/* Look through the relocs for a section during the first phase, and
7159
   allocate space in the global offset table.  */
7160
 
7161
bfd_boolean
7162
_bfd_mips_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
7163
                            asection *sec, const Elf_Internal_Rela *relocs)
7164
{
7165
  const char *name;
7166
  bfd *dynobj;
7167
  Elf_Internal_Shdr *symtab_hdr;
7168
  struct elf_link_hash_entry **sym_hashes;
7169
  size_t extsymoff;
7170
  const Elf_Internal_Rela *rel;
7171
  const Elf_Internal_Rela *rel_end;
7172
  asection *sreloc;
7173
  const struct elf_backend_data *bed;
7174
  struct mips_elf_link_hash_table *htab;
7175
  bfd_byte *contents;
7176
  bfd_vma addend;
7177
  reloc_howto_type *howto;
7178
 
7179
  if (info->relocatable)
7180
    return TRUE;
7181
 
7182
  htab = mips_elf_hash_table (info);
7183
  dynobj = elf_hash_table (info)->dynobj;
7184
  symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
7185
  sym_hashes = elf_sym_hashes (abfd);
7186
  extsymoff = (elf_bad_symtab (abfd)) ? 0 : symtab_hdr->sh_info;
7187
 
7188 225 jeremybenn
  bed = get_elf_backend_data (abfd);
7189
  rel_end = relocs + sec->reloc_count * bed->s->int_rels_per_ext_rel;
7190
 
7191 24 jeremybenn
  /* Check for the mips16 stub sections.  */
7192
 
7193
  name = bfd_get_section_name (abfd, sec);
7194
  if (FN_STUB_P (name))
7195
    {
7196
      unsigned long r_symndx;
7197
 
7198
      /* Look at the relocation information to figure out which symbol
7199
         this is for.  */
7200
 
7201 225 jeremybenn
      r_symndx = mips16_stub_symndx (sec, relocs, rel_end);
7202
      if (r_symndx == 0)
7203
        {
7204
          (*_bfd_error_handler)
7205
            (_("%B: Warning: cannot determine the target function for"
7206
               " stub section `%s'"),
7207
             abfd, name);
7208
          bfd_set_error (bfd_error_bad_value);
7209
          return FALSE;
7210
        }
7211 24 jeremybenn
 
7212
      if (r_symndx < extsymoff
7213
          || sym_hashes[r_symndx - extsymoff] == NULL)
7214
        {
7215
          asection *o;
7216
 
7217
          /* This stub is for a local symbol.  This stub will only be
7218
             needed if there is some relocation in this BFD, other
7219
             than a 16 bit function call, which refers to this symbol.  */
7220
          for (o = abfd->sections; o != NULL; o = o->next)
7221
            {
7222
              Elf_Internal_Rela *sec_relocs;
7223
              const Elf_Internal_Rela *r, *rend;
7224
 
7225
              /* We can ignore stub sections when looking for relocs.  */
7226
              if ((o->flags & SEC_RELOC) == 0
7227
                  || o->reloc_count == 0
7228 225 jeremybenn
                  || section_allows_mips16_refs_p (o))
7229 24 jeremybenn
                continue;
7230
 
7231
              sec_relocs
7232
                = _bfd_elf_link_read_relocs (abfd, o, NULL, NULL,
7233
                                             info->keep_memory);
7234
              if (sec_relocs == NULL)
7235
                return FALSE;
7236
 
7237
              rend = sec_relocs + o->reloc_count;
7238
              for (r = sec_relocs; r < rend; r++)
7239
                if (ELF_R_SYM (abfd, r->r_info) == r_symndx
7240 225 jeremybenn
                    && !mips16_call_reloc_p (ELF_R_TYPE (abfd, r->r_info)))
7241 24 jeremybenn
                  break;
7242
 
7243
              if (elf_section_data (o)->relocs != sec_relocs)
7244
                free (sec_relocs);
7245
 
7246
              if (r < rend)
7247
                break;
7248
            }
7249
 
7250
          if (o == NULL)
7251
            {
7252
              /* There is no non-call reloc for this stub, so we do
7253
                 not need it.  Since this function is called before
7254
                 the linker maps input sections to output sections, we
7255
                 can easily discard it by setting the SEC_EXCLUDE
7256
                 flag.  */
7257
              sec->flags |= SEC_EXCLUDE;
7258
              return TRUE;
7259
            }
7260
 
7261
          /* Record this stub in an array of local symbol stubs for
7262
             this BFD.  */
7263
          if (elf_tdata (abfd)->local_stubs == NULL)
7264
            {
7265
              unsigned long symcount;
7266
              asection **n;
7267
              bfd_size_type amt;
7268
 
7269
              if (elf_bad_symtab (abfd))
7270
                symcount = NUM_SHDR_ENTRIES (symtab_hdr);
7271
              else
7272
                symcount = symtab_hdr->sh_info;
7273
              amt = symcount * sizeof (asection *);
7274
              n = bfd_zalloc (abfd, amt);
7275
              if (n == NULL)
7276
                return FALSE;
7277
              elf_tdata (abfd)->local_stubs = n;
7278
            }
7279
 
7280
          sec->flags |= SEC_KEEP;
7281
          elf_tdata (abfd)->local_stubs[r_symndx] = sec;
7282
 
7283
          /* We don't need to set mips16_stubs_seen in this case.
7284
             That flag is used to see whether we need to look through
7285
             the global symbol table for stubs.  We don't need to set
7286
             it here, because we just have a local stub.  */
7287
        }
7288
      else
7289
        {
7290
          struct mips_elf_link_hash_entry *h;
7291
 
7292
          h = ((struct mips_elf_link_hash_entry *)
7293
               sym_hashes[r_symndx - extsymoff]);
7294
 
7295
          while (h->root.root.type == bfd_link_hash_indirect
7296
                 || h->root.root.type == bfd_link_hash_warning)
7297
            h = (struct mips_elf_link_hash_entry *) h->root.root.u.i.link;
7298
 
7299
          /* H is the symbol this stub is for.  */
7300
 
7301
          /* If we already have an appropriate stub for this function, we
7302
             don't need another one, so we can discard this one.  Since
7303
             this function is called before the linker maps input sections
7304
             to output sections, we can easily discard it by setting the
7305
             SEC_EXCLUDE flag.  */
7306
          if (h->fn_stub != NULL)
7307
            {
7308
              sec->flags |= SEC_EXCLUDE;
7309
              return TRUE;
7310
            }
7311
 
7312
          sec->flags |= SEC_KEEP;
7313
          h->fn_stub = sec;
7314
          mips_elf_hash_table (info)->mips16_stubs_seen = TRUE;
7315
        }
7316
    }
7317
  else if (CALL_STUB_P (name) || CALL_FP_STUB_P (name))
7318
    {
7319
      unsigned long r_symndx;
7320
      struct mips_elf_link_hash_entry *h;
7321
      asection **loc;
7322
 
7323
      /* Look at the relocation information to figure out which symbol
7324
         this is for.  */
7325
 
7326 225 jeremybenn
      r_symndx = mips16_stub_symndx (sec, relocs, rel_end);
7327
      if (r_symndx == 0)
7328
        {
7329
          (*_bfd_error_handler)
7330
            (_("%B: Warning: cannot determine the target function for"
7331
               " stub section `%s'"),
7332
             abfd, name);
7333
          bfd_set_error (bfd_error_bad_value);
7334
          return FALSE;
7335
        }
7336 24 jeremybenn
 
7337
      if (r_symndx < extsymoff
7338
          || sym_hashes[r_symndx - extsymoff] == NULL)
7339
        {
7340
          asection *o;
7341
 
7342
          /* This stub is for a local symbol.  This stub will only be
7343
             needed if there is some relocation (R_MIPS16_26) in this BFD
7344
             that refers to this symbol.  */
7345
          for (o = abfd->sections; o != NULL; o = o->next)
7346
            {
7347
              Elf_Internal_Rela *sec_relocs;
7348
              const Elf_Internal_Rela *r, *rend;
7349
 
7350
              /* We can ignore stub sections when looking for relocs.  */
7351
              if ((o->flags & SEC_RELOC) == 0
7352
                  || o->reloc_count == 0
7353 225 jeremybenn
                  || section_allows_mips16_refs_p (o))
7354 24 jeremybenn
                continue;
7355
 
7356
              sec_relocs
7357
                = _bfd_elf_link_read_relocs (abfd, o, NULL, NULL,
7358
                                             info->keep_memory);
7359
              if (sec_relocs == NULL)
7360
                return FALSE;
7361
 
7362
              rend = sec_relocs + o->reloc_count;
7363
              for (r = sec_relocs; r < rend; r++)
7364
                if (ELF_R_SYM (abfd, r->r_info) == r_symndx
7365
                    && ELF_R_TYPE (abfd, r->r_info) == R_MIPS16_26)
7366
                    break;
7367
 
7368
              if (elf_section_data (o)->relocs != sec_relocs)
7369
                free (sec_relocs);
7370
 
7371
              if (r < rend)
7372
                break;
7373
            }
7374
 
7375
          if (o == NULL)
7376
            {
7377
              /* There is no non-call reloc for this stub, so we do
7378
                 not need it.  Since this function is called before
7379
                 the linker maps input sections to output sections, we
7380
                 can easily discard it by setting the SEC_EXCLUDE
7381
                 flag.  */
7382
              sec->flags |= SEC_EXCLUDE;
7383
              return TRUE;
7384
            }
7385
 
7386
          /* Record this stub in an array of local symbol call_stubs for
7387
             this BFD.  */
7388
          if (elf_tdata (abfd)->local_call_stubs == NULL)
7389
            {
7390
              unsigned long symcount;
7391
              asection **n;
7392
              bfd_size_type amt;
7393
 
7394
              if (elf_bad_symtab (abfd))
7395
                symcount = NUM_SHDR_ENTRIES (symtab_hdr);
7396
              else
7397
                symcount = symtab_hdr->sh_info;
7398
              amt = symcount * sizeof (asection *);
7399
              n = bfd_zalloc (abfd, amt);
7400
              if (n == NULL)
7401
                return FALSE;
7402
              elf_tdata (abfd)->local_call_stubs = n;
7403
            }
7404
 
7405
          sec->flags |= SEC_KEEP;
7406
          elf_tdata (abfd)->local_call_stubs[r_symndx] = sec;
7407
 
7408
          /* We don't need to set mips16_stubs_seen in this case.
7409
             That flag is used to see whether we need to look through
7410
             the global symbol table for stubs.  We don't need to set
7411
             it here, because we just have a local stub.  */
7412
        }
7413
      else
7414
        {
7415
          h = ((struct mips_elf_link_hash_entry *)
7416
               sym_hashes[r_symndx - extsymoff]);
7417
 
7418
          /* H is the symbol this stub is for.  */
7419
 
7420
          if (CALL_FP_STUB_P (name))
7421
            loc = &h->call_fp_stub;
7422
          else
7423
            loc = &h->call_stub;
7424
 
7425
          /* If we already have an appropriate stub for this function, we
7426
             don't need another one, so we can discard this one.  Since
7427
             this function is called before the linker maps input sections
7428
             to output sections, we can easily discard it by setting the
7429
             SEC_EXCLUDE flag.  */
7430
          if (*loc != NULL)
7431
            {
7432
              sec->flags |= SEC_EXCLUDE;
7433
              return TRUE;
7434
            }
7435
 
7436
          sec->flags |= SEC_KEEP;
7437
          *loc = sec;
7438
          mips_elf_hash_table (info)->mips16_stubs_seen = TRUE;
7439
        }
7440
    }
7441
 
7442
  sreloc = NULL;
7443
  contents = NULL;
7444
  for (rel = relocs; rel < rel_end; ++rel)
7445
    {
7446
      unsigned long r_symndx;
7447
      unsigned int r_type;
7448
      struct elf_link_hash_entry *h;
7449 225 jeremybenn
      bfd_boolean can_make_dynamic_p;
7450 24 jeremybenn
 
7451
      r_symndx = ELF_R_SYM (abfd, rel->r_info);
7452
      r_type = ELF_R_TYPE (abfd, rel->r_info);
7453
 
7454
      if (r_symndx < extsymoff)
7455
        h = NULL;
7456
      else if (r_symndx >= extsymoff + NUM_SHDR_ENTRIES (symtab_hdr))
7457
        {
7458
          (*_bfd_error_handler)
7459
            (_("%B: Malformed reloc detected for section %s"),
7460
             abfd, name);
7461
          bfd_set_error (bfd_error_bad_value);
7462
          return FALSE;
7463
        }
7464
      else
7465
        {
7466
          h = sym_hashes[r_symndx - extsymoff];
7467 225 jeremybenn
          while (h != NULL
7468
                 && (h->root.type == bfd_link_hash_indirect
7469
                     || h->root.type == bfd_link_hash_warning))
7470
            h = (struct elf_link_hash_entry *) h->root.u.i.link;
7471
        }
7472 24 jeremybenn
 
7473 225 jeremybenn
      /* Set CAN_MAKE_DYNAMIC_P to true if we can convert this
7474
         relocation into a dynamic one.  */
7475
      can_make_dynamic_p = FALSE;
7476
      switch (r_type)
7477
        {
7478
        case R_MIPS16_GOT16:
7479
        case R_MIPS16_CALL16:
7480
        case R_MIPS_GOT16:
7481
        case R_MIPS_CALL16:
7482
        case R_MIPS_CALL_HI16:
7483
        case R_MIPS_CALL_LO16:
7484
        case R_MIPS_GOT_HI16:
7485
        case R_MIPS_GOT_LO16:
7486
        case R_MIPS_GOT_PAGE:
7487
        case R_MIPS_GOT_OFST:
7488
        case R_MIPS_GOT_DISP:
7489
        case R_MIPS_TLS_GOTTPREL:
7490
        case R_MIPS_TLS_GD:
7491
        case R_MIPS_TLS_LDM:
7492
          if (dynobj == NULL)
7493
            elf_hash_table (info)->dynobj = dynobj = abfd;
7494
          if (!mips_elf_create_got_section (dynobj, info))
7495
            return FALSE;
7496
          if (htab->is_vxworks && !info->shared)
7497 24 jeremybenn
            {
7498 225 jeremybenn
              (*_bfd_error_handler)
7499
                (_("%B: GOT reloc at 0x%lx not expected in executables"),
7500
                 abfd, (unsigned long) rel->r_offset);
7501
              bfd_set_error (bfd_error_bad_value);
7502
              return FALSE;
7503 24 jeremybenn
            }
7504 225 jeremybenn
          break;
7505 24 jeremybenn
 
7506 225 jeremybenn
          /* This is just a hint; it can safely be ignored.  Don't set
7507
             has_static_relocs for the corresponding symbol.  */
7508
        case R_MIPS_JALR:
7509
          break;
7510
 
7511
        case R_MIPS_32:
7512
        case R_MIPS_REL32:
7513
        case R_MIPS_64:
7514
          /* In VxWorks executables, references to external symbols
7515
             must be handled using copy relocs or PLT entries; it is not
7516
             possible to convert this relocation into a dynamic one.
7517
 
7518
             For executables that use PLTs and copy-relocs, we have a
7519
             choice between converting the relocation into a dynamic
7520
             one or using copy relocations or PLT entries.  It is
7521
             usually better to do the former, unless the relocation is
7522
             against a read-only section.  */
7523
          if ((info->shared
7524
               || (h != NULL
7525
                   && !htab->is_vxworks
7526
                   && strcmp (h->root.root.string, "__gnu_local_gp") != 0
7527
                   && !(!info->nocopyreloc
7528
                        && !PIC_OBJECT_P (abfd)
7529
                        && MIPS_ELF_READONLY_SECTION (sec))))
7530
              && (sec->flags & SEC_ALLOC) != 0)
7531 24 jeremybenn
            {
7532 225 jeremybenn
              can_make_dynamic_p = TRUE;
7533 24 jeremybenn
              if (dynobj == NULL)
7534
                elf_hash_table (info)->dynobj = dynobj = abfd;
7535
              break;
7536 225 jeremybenn
            }
7537
          /* Fall through.  */
7538 24 jeremybenn
 
7539 225 jeremybenn
        default:
7540
          /* Most static relocations require pointer equality, except
7541
             for branches.  */
7542
          if (h)
7543
            h->pointer_equality_needed = TRUE;
7544
          /* Fall through.  */
7545 24 jeremybenn
 
7546 225 jeremybenn
        case R_MIPS_26:
7547
        case R_MIPS_PC16:
7548
        case R_MIPS16_26:
7549
          if (h)
7550
            ((struct mips_elf_link_hash_entry *) h)->has_static_relocs = TRUE;
7551
          break;
7552 24 jeremybenn
        }
7553
 
7554
      if (h)
7555
        {
7556
          /* Relocations against the special VxWorks __GOTT_BASE__ and
7557
             __GOTT_INDEX__ symbols must be left to the loader.  Allocate
7558
             room for them in .rela.dyn.  */
7559
          if (is_gott_symbol (info, h))
7560
            {
7561
              if (sreloc == NULL)
7562
                {
7563
                  sreloc = mips_elf_rel_dyn_section (info, TRUE);
7564
                  if (sreloc == NULL)
7565
                    return FALSE;
7566
                }
7567
              mips_elf_allocate_dynamic_relocations (dynobj, info, 1);
7568
              if (MIPS_ELF_READONLY_SECTION (sec))
7569
                /* We tell the dynamic linker that there are
7570
                   relocations against the text segment.  */
7571
                info->flags |= DF_TEXTREL;
7572
            }
7573
        }
7574
      else if (r_type == R_MIPS_CALL_LO16
7575
               || r_type == R_MIPS_GOT_LO16
7576
               || r_type == R_MIPS_GOT_DISP
7577 225 jeremybenn
               || (got16_reloc_p (r_type) && htab->is_vxworks))
7578 24 jeremybenn
        {
7579
          /* We may need a local GOT entry for this relocation.  We
7580
             don't count R_MIPS_GOT_PAGE because we can estimate the
7581
             maximum number of pages needed by looking at the size of
7582 225 jeremybenn
             the segment.  Similar comments apply to R_MIPS*_GOT16 and
7583
             R_MIPS*_CALL16, except on VxWorks, where GOT relocations
7584 24 jeremybenn
             always evaluate to "G".  We don't count R_MIPS_GOT_HI16, or
7585
             R_MIPS_CALL_HI16 because these are always followed by an
7586
             R_MIPS_GOT_LO16 or R_MIPS_CALL_LO16.  */
7587 225 jeremybenn
          if (!mips_elf_record_local_got_symbol (abfd, r_symndx,
7588
                                                 rel->r_addend, info, 0))
7589 24 jeremybenn
            return FALSE;
7590
        }
7591
 
7592 225 jeremybenn
      if (h != NULL && mips_elf_relocation_needs_la25_stub (abfd, r_type))
7593
        ((struct mips_elf_link_hash_entry *) h)->has_nonpic_branches = TRUE;
7594
 
7595 24 jeremybenn
      switch (r_type)
7596
        {
7597
        case R_MIPS_CALL16:
7598 225 jeremybenn
        case R_MIPS16_CALL16:
7599 24 jeremybenn
          if (h == NULL)
7600
            {
7601
              (*_bfd_error_handler)
7602
                (_("%B: CALL16 reloc at 0x%lx not against global symbol"),
7603
                 abfd, (unsigned long) rel->r_offset);
7604
              bfd_set_error (bfd_error_bad_value);
7605
              return FALSE;
7606
            }
7607
          /* Fall through.  */
7608
 
7609
        case R_MIPS_CALL_HI16:
7610
        case R_MIPS_CALL_LO16:
7611
          if (h != NULL)
7612
            {
7613 225 jeremybenn
              /* VxWorks call relocations point at the function's .got.plt
7614 24 jeremybenn
                 entry, which will be allocated by adjust_dynamic_symbol.
7615
                 Otherwise, this symbol requires a global GOT entry.  */
7616
              if ((!htab->is_vxworks || h->forced_local)
7617 225 jeremybenn
                  && !mips_elf_record_global_got_symbol (h, abfd, info, 0))
7618 24 jeremybenn
                return FALSE;
7619
 
7620
              /* We need a stub, not a plt entry for the undefined
7621
                 function.  But we record it as if it needs plt.  See
7622
                 _bfd_elf_adjust_dynamic_symbol.  */
7623
              h->needs_plt = 1;
7624
              h->type = STT_FUNC;
7625
            }
7626
          break;
7627
 
7628
        case R_MIPS_GOT_PAGE:
7629
          /* If this is a global, overridable symbol, GOT_PAGE will
7630
             decay to GOT_DISP, so we'll need a GOT entry for it.  */
7631
          if (h)
7632
            {
7633
              struct mips_elf_link_hash_entry *hmips =
7634
                (struct mips_elf_link_hash_entry *) h;
7635
 
7636 225 jeremybenn
              /* This symbol is definitely not overridable.  */
7637 24 jeremybenn
              if (hmips->root.def_regular
7638
                  && ! (info->shared && ! info->symbolic
7639
                        && ! hmips->root.forced_local))
7640
                h = NULL;
7641
            }
7642
          /* Fall through.  */
7643
 
7644 225 jeremybenn
        case R_MIPS16_GOT16:
7645 24 jeremybenn
        case R_MIPS_GOT16:
7646
        case R_MIPS_GOT_HI16:
7647
        case R_MIPS_GOT_LO16:
7648 225 jeremybenn
          if (!h || r_type == R_MIPS_GOT_PAGE)
7649 24 jeremybenn
            {
7650 225 jeremybenn
              /* This relocation needs (or may need, if h != NULL) a
7651
                 page entry in the GOT.  For R_MIPS_GOT_PAGE we do not
7652
                 know for sure until we know whether the symbol is
7653
                 preemptible.  */
7654 24 jeremybenn
              if (mips_elf_rel_relocation_p (abfd, sec, relocs, rel))
7655
                {
7656
                  if (!mips_elf_get_section_contents (abfd, sec, &contents))
7657
                    return FALSE;
7658
                  howto = MIPS_ELF_RTYPE_TO_HOWTO (abfd, r_type, FALSE);
7659
                  addend = mips_elf_read_rel_addend (abfd, rel,
7660
                                                     howto, contents);
7661
                  if (r_type == R_MIPS_GOT16)
7662
                    mips_elf_add_lo16_rel_addend (abfd, rel, rel_end,
7663
                                                  contents, &addend);
7664
                  else
7665
                    addend <<= howto->rightshift;
7666
                }
7667
              else
7668
                addend = rel->r_addend;
7669 225 jeremybenn
              if (!mips_elf_record_got_page_entry (info, abfd, r_symndx,
7670
                                                   addend))
7671 24 jeremybenn
                return FALSE;
7672
              break;
7673
            }
7674
          /* Fall through.  */
7675
 
7676
        case R_MIPS_GOT_DISP:
7677 225 jeremybenn
          if (h && !mips_elf_record_global_got_symbol (h, abfd, info, 0))
7678 24 jeremybenn
            return FALSE;
7679
          break;
7680
 
7681
        case R_MIPS_TLS_GOTTPREL:
7682
          if (info->shared)
7683
            info->flags |= DF_STATIC_TLS;
7684
          /* Fall through */
7685
 
7686
        case R_MIPS_TLS_LDM:
7687
          if (r_type == R_MIPS_TLS_LDM)
7688
            {
7689
              r_symndx = 0;
7690
              h = NULL;
7691
            }
7692
          /* Fall through */
7693
 
7694
        case R_MIPS_TLS_GD:
7695
          /* This symbol requires a global offset table entry, or two
7696
             for TLS GD relocations.  */
7697
          {
7698
            unsigned char flag = (r_type == R_MIPS_TLS_GD
7699
                                  ? GOT_TLS_GD
7700
                                  : r_type == R_MIPS_TLS_LDM
7701
                                  ? GOT_TLS_LDM
7702
                                  : GOT_TLS_IE);
7703
            if (h != NULL)
7704
              {
7705
                struct mips_elf_link_hash_entry *hmips =
7706
                  (struct mips_elf_link_hash_entry *) h;
7707
                hmips->tls_type |= flag;
7708
 
7709 225 jeremybenn
                if (h && !mips_elf_record_global_got_symbol (h, abfd,
7710
                                                             info, flag))
7711 24 jeremybenn
                  return FALSE;
7712
              }
7713
            else
7714
              {
7715
                BFD_ASSERT (flag == GOT_TLS_LDM || r_symndx != 0);
7716
 
7717 225 jeremybenn
                if (!mips_elf_record_local_got_symbol (abfd, r_symndx,
7718
                                                       rel->r_addend,
7719
                                                       info, flag))
7720 24 jeremybenn
                  return FALSE;
7721
              }
7722
          }
7723
          break;
7724
 
7725
        case R_MIPS_32:
7726
        case R_MIPS_REL32:
7727
        case R_MIPS_64:
7728
          /* In VxWorks executables, references to external symbols
7729
             are handled using copy relocs or PLT stubs, so there's
7730
             no need to add a .rela.dyn entry for this relocation.  */
7731 225 jeremybenn
          if (can_make_dynamic_p)
7732 24 jeremybenn
            {
7733
              if (sreloc == NULL)
7734
                {
7735
                  sreloc = mips_elf_rel_dyn_section (info, TRUE);
7736
                  if (sreloc == NULL)
7737
                    return FALSE;
7738
                }
7739 225 jeremybenn
              if (info->shared && h == NULL)
7740 24 jeremybenn
                {
7741
                  /* When creating a shared object, we must copy these
7742
                     reloc types into the output file as R_MIPS_REL32
7743
                     relocs.  Make room for this reloc in .rel(a).dyn.  */
7744
                  mips_elf_allocate_dynamic_relocations (dynobj, info, 1);
7745
                  if (MIPS_ELF_READONLY_SECTION (sec))
7746
                    /* We tell the dynamic linker that there are
7747
                       relocations against the text segment.  */
7748
                    info->flags |= DF_TEXTREL;
7749
                }
7750
              else
7751
                {
7752
                  struct mips_elf_link_hash_entry *hmips;
7753
 
7754 225 jeremybenn
                  /* For a shared object, we must copy this relocation
7755
                     unless the symbol turns out to be undefined and
7756
                     weak with non-default visibility, in which case
7757
                     it will be left as zero.
7758
 
7759
                     We could elide R_MIPS_REL32 for locally binding symbols
7760
                     in shared libraries, but do not yet do so.
7761
 
7762
                     For an executable, we only need to copy this
7763
                     reloc if the symbol is defined in a dynamic
7764
                     object.  */
7765 24 jeremybenn
                  hmips = (struct mips_elf_link_hash_entry *) h;
7766
                  ++hmips->possibly_dynamic_relocs;
7767
                  if (MIPS_ELF_READONLY_SECTION (sec))
7768
                    /* We need it to tell the dynamic linker if there
7769
                       are relocations against the text segment.  */
7770
                    hmips->readonly_reloc = TRUE;
7771
                }
7772
            }
7773
 
7774
          if (SGI_COMPAT (abfd))
7775
            mips_elf_hash_table (info)->compact_rel_size +=
7776
              sizeof (Elf32_External_crinfo);
7777
          break;
7778
 
7779
        case R_MIPS_26:
7780
        case R_MIPS_GPREL16:
7781
        case R_MIPS_LITERAL:
7782
        case R_MIPS_GPREL32:
7783
          if (SGI_COMPAT (abfd))
7784
            mips_elf_hash_table (info)->compact_rel_size +=
7785
              sizeof (Elf32_External_crinfo);
7786
          break;
7787
 
7788
          /* This relocation describes the C++ object vtable hierarchy.
7789
             Reconstruct it for later use during GC.  */
7790
        case R_MIPS_GNU_VTINHERIT:
7791
          if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
7792
            return FALSE;
7793
          break;
7794
 
7795
          /* This relocation describes which C++ vtable entries are actually
7796
             used.  Record for later use during GC.  */
7797
        case R_MIPS_GNU_VTENTRY:
7798
          BFD_ASSERT (h != NULL);
7799
          if (h != NULL
7800
              && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_offset))
7801
            return FALSE;
7802
          break;
7803
 
7804
        default:
7805
          break;
7806
        }
7807
 
7808
      /* We must not create a stub for a symbol that has relocations
7809
         related to taking the function's address.  This doesn't apply to
7810
         VxWorks, where CALL relocs refer to a .got.plt entry instead of
7811
         a normal .got entry.  */
7812
      if (!htab->is_vxworks && h != NULL)
7813
        switch (r_type)
7814
          {
7815
          default:
7816
            ((struct mips_elf_link_hash_entry *) h)->no_fn_stub = TRUE;
7817
            break;
7818 225 jeremybenn
          case R_MIPS16_CALL16:
7819 24 jeremybenn
          case R_MIPS_CALL16:
7820
          case R_MIPS_CALL_HI16:
7821
          case R_MIPS_CALL_LO16:
7822
          case R_MIPS_JALR:
7823
            break;
7824
          }
7825
 
7826 225 jeremybenn
      /* See if this reloc would need to refer to a MIPS16 hard-float stub,
7827
         if there is one.  We only need to handle global symbols here;
7828
         we decide whether to keep or delete stubs for local symbols
7829
         when processing the stub's relocations.  */
7830 24 jeremybenn
      if (h != NULL
7831 225 jeremybenn
          && !mips16_call_reloc_p (r_type)
7832
          && !section_allows_mips16_refs_p (sec))
7833 24 jeremybenn
        {
7834
          struct mips_elf_link_hash_entry *mh;
7835
 
7836
          mh = (struct mips_elf_link_hash_entry *) h;
7837
          mh->need_fn_stub = TRUE;
7838
        }
7839 225 jeremybenn
 
7840
      /* Refuse some position-dependent relocations when creating a
7841
         shared library.  Do not refuse R_MIPS_32 / R_MIPS_64; they're
7842
         not PIC, but we can create dynamic relocations and the result
7843
         will be fine.  Also do not refuse R_MIPS_LO16, which can be
7844
         combined with R_MIPS_GOT16.  */
7845
      if (info->shared)
7846
        {
7847
          switch (r_type)
7848
            {
7849
            case R_MIPS16_HI16:
7850
            case R_MIPS_HI16:
7851
            case R_MIPS_HIGHER:
7852
            case R_MIPS_HIGHEST:
7853
              /* Don't refuse a high part relocation if it's against
7854
                 no symbol (e.g. part of a compound relocation).  */
7855
              if (r_symndx == 0)
7856
                break;
7857
 
7858
              /* R_MIPS_HI16 against _gp_disp is used for $gp setup,
7859
                 and has a special meaning.  */
7860
              if (!NEWABI_P (abfd) && h != NULL
7861
                  && strcmp (h->root.root.string, "_gp_disp") == 0)
7862
                break;
7863
 
7864
              /* FALLTHROUGH */
7865
 
7866
            case R_MIPS16_26:
7867
            case R_MIPS_26:
7868
              howto = MIPS_ELF_RTYPE_TO_HOWTO (abfd, r_type, FALSE);
7869
              (*_bfd_error_handler)
7870
                (_("%B: relocation %s against `%s' can not be used when making a shared object; recompile with -fPIC"),
7871
                 abfd, howto->name,
7872
                 (h) ? h->root.root.string : "a local symbol");
7873
              bfd_set_error (bfd_error_bad_value);
7874
              return FALSE;
7875
            default:
7876
              break;
7877
            }
7878
        }
7879 24 jeremybenn
    }
7880
 
7881
  return TRUE;
7882
}
7883
 
7884
bfd_boolean
7885
_bfd_mips_relax_section (bfd *abfd, asection *sec,
7886
                         struct bfd_link_info *link_info,
7887
                         bfd_boolean *again)
7888
{
7889
  Elf_Internal_Rela *internal_relocs;
7890
  Elf_Internal_Rela *irel, *irelend;
7891
  Elf_Internal_Shdr *symtab_hdr;
7892
  bfd_byte *contents = NULL;
7893
  size_t extsymoff;
7894
  bfd_boolean changed_contents = FALSE;
7895
  bfd_vma sec_start = sec->output_section->vma + sec->output_offset;
7896
  Elf_Internal_Sym *isymbuf = NULL;
7897
 
7898
  /* We are not currently changing any sizes, so only one pass.  */
7899
  *again = FALSE;
7900
 
7901
  if (link_info->relocatable)
7902
    return TRUE;
7903
 
7904
  internal_relocs = _bfd_elf_link_read_relocs (abfd, sec, NULL, NULL,
7905
                                               link_info->keep_memory);
7906
  if (internal_relocs == NULL)
7907
    return TRUE;
7908
 
7909
  irelend = internal_relocs + sec->reloc_count
7910
    * get_elf_backend_data (abfd)->s->int_rels_per_ext_rel;
7911
  symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
7912
  extsymoff = (elf_bad_symtab (abfd)) ? 0 : symtab_hdr->sh_info;
7913
 
7914
  for (irel = internal_relocs; irel < irelend; irel++)
7915
    {
7916
      bfd_vma symval;
7917
      bfd_signed_vma sym_offset;
7918
      unsigned int r_type;
7919
      unsigned long r_symndx;
7920
      asection *sym_sec;
7921
      unsigned long instruction;
7922
 
7923
      /* Turn jalr into bgezal, and jr into beq, if they're marked
7924
         with a JALR relocation, that indicate where they jump to.
7925
         This saves some pipeline bubbles.  */
7926
      r_type = ELF_R_TYPE (abfd, irel->r_info);
7927
      if (r_type != R_MIPS_JALR)
7928
        continue;
7929
 
7930
      r_symndx = ELF_R_SYM (abfd, irel->r_info);
7931
      /* Compute the address of the jump target.  */
7932
      if (r_symndx >= extsymoff)
7933
        {
7934
          struct mips_elf_link_hash_entry *h
7935
            = ((struct mips_elf_link_hash_entry *)
7936
               elf_sym_hashes (abfd) [r_symndx - extsymoff]);
7937
 
7938
          while (h->root.root.type == bfd_link_hash_indirect
7939
                 || h->root.root.type == bfd_link_hash_warning)
7940
            h = (struct mips_elf_link_hash_entry *) h->root.root.u.i.link;
7941
 
7942
          /* If a symbol is undefined, or if it may be overridden,
7943
             skip it.  */
7944
          if (! ((h->root.root.type == bfd_link_hash_defined
7945
                  || h->root.root.type == bfd_link_hash_defweak)
7946
                 && h->root.root.u.def.section)
7947
              || (link_info->shared && ! link_info->symbolic
7948
                  && !h->root.forced_local))
7949
            continue;
7950
 
7951
          sym_sec = h->root.root.u.def.section;
7952
          if (sym_sec->output_section)
7953
            symval = (h->root.root.u.def.value
7954
                      + sym_sec->output_section->vma
7955
                      + sym_sec->output_offset);
7956
          else
7957
            symval = h->root.root.u.def.value;
7958
        }
7959
      else
7960
        {
7961
          Elf_Internal_Sym *isym;
7962
 
7963
          /* Read this BFD's symbols if we haven't done so already.  */
7964
          if (isymbuf == NULL && symtab_hdr->sh_info != 0)
7965
            {
7966
              isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
7967
              if (isymbuf == NULL)
7968
                isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
7969
                                                symtab_hdr->sh_info, 0,
7970
                                                NULL, NULL, NULL);
7971
              if (isymbuf == NULL)
7972
                goto relax_return;
7973
            }
7974
 
7975
          isym = isymbuf + r_symndx;
7976
          if (isym->st_shndx == SHN_UNDEF)
7977
            continue;
7978
          else if (isym->st_shndx == SHN_ABS)
7979
            sym_sec = bfd_abs_section_ptr;
7980
          else if (isym->st_shndx == SHN_COMMON)
7981
            sym_sec = bfd_com_section_ptr;
7982
          else
7983
            sym_sec
7984
              = bfd_section_from_elf_index (abfd, isym->st_shndx);
7985
          symval = isym->st_value
7986
            + sym_sec->output_section->vma
7987
            + sym_sec->output_offset;
7988
        }
7989
 
7990
      /* Compute branch offset, from delay slot of the jump to the
7991
         branch target.  */
7992
      sym_offset = (symval + irel->r_addend)
7993
        - (sec_start + irel->r_offset + 4);
7994
 
7995
      /* Branch offset must be properly aligned.  */
7996
      if ((sym_offset & 3) != 0)
7997
        continue;
7998
 
7999
      sym_offset >>= 2;
8000
 
8001
      /* Check that it's in range.  */
8002
      if (sym_offset < -0x8000 || sym_offset >= 0x8000)
8003
        continue;
8004
 
8005
      /* Get the section contents if we haven't done so already.  */
8006
      if (!mips_elf_get_section_contents (abfd, sec, &contents))
8007
        goto relax_return;
8008
 
8009
      instruction = bfd_get_32 (abfd, contents + irel->r_offset);
8010
 
8011
      /* If it was jalr <reg>, turn it into bgezal $zero, <target>.  */
8012
      if ((instruction & 0xfc1fffff) == 0x0000f809)
8013
        instruction = 0x04110000;
8014
      /* If it was jr <reg>, turn it into b <target>.  */
8015
      else if ((instruction & 0xfc1fffff) == 0x00000008)
8016
        instruction = 0x10000000;
8017
      else
8018
        continue;
8019
 
8020
      instruction |= (sym_offset & 0xffff);
8021
      bfd_put_32 (abfd, instruction, contents + irel->r_offset);
8022
      changed_contents = TRUE;
8023
    }
8024
 
8025
  if (contents != NULL
8026
      && elf_section_data (sec)->this_hdr.contents != contents)
8027
    {
8028
      if (!changed_contents && !link_info->keep_memory)
8029
        free (contents);
8030
      else
8031
        {
8032
          /* Cache the section contents for elf_link_input_bfd.  */
8033
          elf_section_data (sec)->this_hdr.contents = contents;
8034
        }
8035
    }
8036
  return TRUE;
8037
 
8038
 relax_return:
8039
  if (contents != NULL
8040
      && elf_section_data (sec)->this_hdr.contents != contents)
8041
    free (contents);
8042
  return FALSE;
8043
}
8044
 
8045 225 jeremybenn
/* Allocate space for global sym dynamic relocs.  */
8046 24 jeremybenn
 
8047 225 jeremybenn
static bfd_boolean
8048
allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
8049 24 jeremybenn
{
8050 225 jeremybenn
  struct bfd_link_info *info = inf;
8051 24 jeremybenn
  bfd *dynobj;
8052
  struct mips_elf_link_hash_entry *hmips;
8053
  struct mips_elf_link_hash_table *htab;
8054
 
8055
  htab = mips_elf_hash_table (info);
8056
  dynobj = elf_hash_table (info)->dynobj;
8057 225 jeremybenn
  hmips = (struct mips_elf_link_hash_entry *) h;
8058 24 jeremybenn
 
8059 225 jeremybenn
  /* VxWorks executables are handled elsewhere; we only need to
8060
     allocate relocations in shared objects.  */
8061
  if (htab->is_vxworks && !info->shared)
8062
    return TRUE;
8063 24 jeremybenn
 
8064 225 jeremybenn
  /* Ignore indirect and warning symbols.  All relocations against
8065
     such symbols will be redirected to the target symbol.  */
8066
  if (h->root.type == bfd_link_hash_indirect
8067
      || h->root.type == bfd_link_hash_warning)
8068
    return TRUE;
8069
 
8070
  /* If this symbol is defined in a dynamic object, or we are creating
8071
     a shared library, we will need to copy any R_MIPS_32 or
8072
     R_MIPS_REL32 relocs against it into the output file.  */
8073 24 jeremybenn
  if (! info->relocatable
8074
      && hmips->possibly_dynamic_relocs != 0
8075
      && (h->root.type == bfd_link_hash_defweak
8076 225 jeremybenn
          || !h->def_regular
8077
          || info->shared))
8078 24 jeremybenn
    {
8079 225 jeremybenn
      bfd_boolean do_copy = TRUE;
8080 24 jeremybenn
 
8081 225 jeremybenn
      if (h->root.type == bfd_link_hash_undefweak)
8082 24 jeremybenn
        {
8083 225 jeremybenn
          /* Do not copy relocations for undefined weak symbols with
8084
             non-default visibility.  */
8085
          if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
8086
            do_copy = FALSE;
8087 24 jeremybenn
 
8088 225 jeremybenn
          /* Make sure undefined weak symbols are output as a dynamic
8089
             symbol in PIEs.  */
8090
          else if (h->dynindx == -1 && !h->forced_local)
8091
            {
8092
              if (! bfd_elf_link_record_dynamic_symbol (info, h))
8093
                return FALSE;
8094
            }
8095
        }
8096 24 jeremybenn
 
8097 225 jeremybenn
      if (do_copy)
8098
        {
8099
          /* Even though we don't directly need a GOT entry for this symbol,
8100
             a symbol must have a dynamic symbol table index greater that
8101
             DT_MIPS_GOTSYM if there are dynamic relocations against it.  */
8102
          if (hmips->global_got_area > GGA_RELOC_ONLY)
8103
            hmips->global_got_area = GGA_RELOC_ONLY;
8104 24 jeremybenn
 
8105 225 jeremybenn
          mips_elf_allocate_dynamic_relocations
8106
            (dynobj, info, hmips->possibly_dynamic_relocs);
8107
          if (hmips->readonly_reloc)
8108
            /* We tell the dynamic linker that there are relocations
8109
               against the text segment.  */
8110
            info->flags |= DF_TEXTREL;
8111 24 jeremybenn
        }
8112
    }
8113
 
8114
  return TRUE;
8115
}
8116
 
8117 225 jeremybenn
/* Adjust a symbol defined by a dynamic object and referenced by a
8118
   regular object.  The current definition is in some section of the
8119
   dynamic object, but we're not including those sections.  We have to
8120
   change the definition to something the rest of the link can
8121
   understand.  */
8122 24 jeremybenn
 
8123
bfd_boolean
8124 225 jeremybenn
_bfd_mips_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
8125
                                     struct elf_link_hash_entry *h)
8126 24 jeremybenn
{
8127
  bfd *dynobj;
8128
  struct mips_elf_link_hash_entry *hmips;
8129
  struct mips_elf_link_hash_table *htab;
8130
 
8131
  htab = mips_elf_hash_table (info);
8132
  dynobj = elf_hash_table (info)->dynobj;
8133
  hmips = (struct mips_elf_link_hash_entry *) h;
8134
 
8135
  /* Make sure we know what is going on here.  */
8136
  BFD_ASSERT (dynobj != NULL
8137
              && (h->needs_plt
8138
                  || h->u.weakdef != NULL
8139
                  || (h->def_dynamic
8140
                      && h->ref_regular
8141
                      && !h->def_regular)));
8142
 
8143 225 jeremybenn
  hmips = (struct mips_elf_link_hash_entry *) h;
8144 24 jeremybenn
 
8145 225 jeremybenn
  /* If there are call relocations against an externally-defined symbol,
8146
     see whether we can create a MIPS lazy-binding stub for it.  We can
8147
     only do this if all references to the function are through call
8148
     relocations, and in that case, the traditional lazy-binding stubs
8149
     are much more efficient than PLT entries.
8150
 
8151
     Traditional stubs are only available on SVR4 psABI-based systems;
8152
     VxWorks always uses PLTs instead.  */
8153
  if (!htab->is_vxworks && h->needs_plt && !hmips->no_fn_stub)
8154 24 jeremybenn
    {
8155 225 jeremybenn
      if (! elf_hash_table (info)->dynamic_sections_created)
8156
        return TRUE;
8157
 
8158
      /* If this symbol is not defined in a regular file, then set
8159
         the symbol to the stub location.  This is required to make
8160
         function pointers compare as equal between the normal
8161
         executable and the shared library.  */
8162
      if (!h->def_regular)
8163
        {
8164
          hmips->needs_lazy_stub = TRUE;
8165
          htab->lazy_stub_count++;
8166
          return TRUE;
8167
        }
8168 24 jeremybenn
    }
8169 225 jeremybenn
  /* As above, VxWorks requires PLT entries for externally-defined
8170
     functions that are only accessed through call relocations.
8171 24 jeremybenn
 
8172 225 jeremybenn
     Both VxWorks and non-VxWorks targets also need PLT entries if there
8173
     are static-only relocations against an externally-defined function.
8174
     This can technically occur for shared libraries if there are
8175
     branches to the symbol, although it is unlikely that this will be
8176
     used in practice due to the short ranges involved.  It can occur
8177
     for any relative or absolute relocation in executables; in that
8178
     case, the PLT entry becomes the function's canonical address.  */
8179
  else if (((h->needs_plt && !hmips->no_fn_stub)
8180
            || (h->type == STT_FUNC && hmips->has_static_relocs))
8181
           && htab->use_plts_and_copy_relocs
8182
           && !SYMBOL_CALLS_LOCAL (info, h)
8183
           && !(ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
8184
                && h->root.type == bfd_link_hash_undefweak))
8185 24 jeremybenn
    {
8186
      /* If this is the first symbol to need a PLT entry, allocate room
8187 225 jeremybenn
         for the header.  */
8188 24 jeremybenn
      if (htab->splt->size == 0)
8189
        {
8190 225 jeremybenn
          BFD_ASSERT (htab->sgotplt->size == 0);
8191
 
8192
          /* If we're using the PLT additions to the psABI, each PLT
8193
             entry is 16 bytes and the PLT0 entry is 32 bytes.
8194
             Encourage better cache usage by aligning.  We do this
8195
             lazily to avoid pessimizing traditional objects.  */
8196
          if (!htab->is_vxworks
8197
              && !bfd_set_section_alignment (dynobj, htab->splt, 5))
8198
            return FALSE;
8199
 
8200
          /* Make sure that .got.plt is word-aligned.  We do this lazily
8201
             for the same reason as above.  */
8202
          if (!bfd_set_section_alignment (dynobj, htab->sgotplt,
8203
                                          MIPS_ELF_LOG_FILE_ALIGN (dynobj)))
8204
            return FALSE;
8205
 
8206 24 jeremybenn
          htab->splt->size += htab->plt_header_size;
8207 225 jeremybenn
 
8208
          /* On non-VxWorks targets, the first two entries in .got.plt
8209
             are reserved.  */
8210
          if (!htab->is_vxworks)
8211
            htab->sgotplt->size += 2 * MIPS_ELF_GOT_SIZE (dynobj);
8212
 
8213
          /* On VxWorks, also allocate room for the header's
8214
             .rela.plt.unloaded entries.  */
8215
          if (htab->is_vxworks && !info->shared)
8216 24 jeremybenn
            htab->srelplt2->size += 2 * sizeof (Elf32_External_Rela);
8217
        }
8218
 
8219
      /* Assign the next .plt entry to this symbol.  */
8220
      h->plt.offset = htab->splt->size;
8221
      htab->splt->size += htab->plt_entry_size;
8222
 
8223
      /* If the output file has no definition of the symbol, set the
8224 225 jeremybenn
         symbol's value to the address of the stub.  */
8225
      if (!info->shared && !h->def_regular)
8226 24 jeremybenn
        {
8227
          h->root.u.def.section = htab->splt;
8228
          h->root.u.def.value = h->plt.offset;
8229 225 jeremybenn
          /* For VxWorks, point at the PLT load stub rather than the
8230
             lazy resolution stub; this stub will become the canonical
8231
             function address.  */
8232
          if (htab->is_vxworks)
8233 24 jeremybenn
            h->root.u.def.value += 8;
8234
        }
8235
 
8236 225 jeremybenn
      /* Make room for the .got.plt entry and the R_MIPS_JUMP_SLOT
8237
         relocation.  */
8238
      htab->sgotplt->size += MIPS_ELF_GOT_SIZE (dynobj);
8239
      htab->srelplt->size += (htab->is_vxworks
8240
                              ? MIPS_ELF_RELA_SIZE (dynobj)
8241
                              : MIPS_ELF_REL_SIZE (dynobj));
8242 24 jeremybenn
 
8243
      /* Make room for the .rela.plt.unloaded relocations.  */
8244 225 jeremybenn
      if (htab->is_vxworks && !info->shared)
8245 24 jeremybenn
        htab->srelplt2->size += 3 * sizeof (Elf32_External_Rela);
8246
 
8247 225 jeremybenn
      /* All relocations against this symbol that could have been made
8248
         dynamic will now refer to the PLT entry instead.  */
8249
      hmips->possibly_dynamic_relocs = 0;
8250 24 jeremybenn
 
8251
      return TRUE;
8252
    }
8253
 
8254
  /* If this is a weak symbol, and there is a real definition, the
8255
     processor independent code will have arranged for us to see the
8256
     real definition first, and we can just use the same value.  */
8257
  if (h->u.weakdef != NULL)
8258
    {
8259
      BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
8260
                  || h->u.weakdef->root.type == bfd_link_hash_defweak);
8261
      h->root.u.def.section = h->u.weakdef->root.u.def.section;
8262
      h->root.u.def.value = h->u.weakdef->root.u.def.value;
8263
      return TRUE;
8264
    }
8265
 
8266 225 jeremybenn
  /* Otherwise, there is nothing further to do for symbols defined
8267
     in regular objects.  */
8268
  if (h->def_regular)
8269 24 jeremybenn
    return TRUE;
8270
 
8271 225 jeremybenn
  /* There's also nothing more to do if we'll convert all relocations
8272
     against this symbol into dynamic relocations.  */
8273
  if (!hmips->has_static_relocs)
8274
    return TRUE;
8275
 
8276
  /* We're now relying on copy relocations.  Complain if we have
8277
     some that we can't convert.  */
8278
  if (!htab->use_plts_and_copy_relocs || info->shared)
8279
    {
8280
      (*_bfd_error_handler) (_("non-dynamic relocations refer to "
8281
                               "dynamic symbol %s"),
8282
                             h->root.root.string);
8283
      bfd_set_error (bfd_error_bad_value);
8284
      return FALSE;
8285
    }
8286
 
8287 24 jeremybenn
  /* We must allocate the symbol in our .dynbss section, which will
8288
     become part of the .bss section of the executable.  There will be
8289
     an entry for this symbol in the .dynsym section.  The dynamic
8290
     object will contain position independent code, so all references
8291
     from the dynamic object to this symbol will go through the global
8292
     offset table.  The dynamic linker will use the .dynsym entry to
8293
     determine the address it must put in the global offset table, so
8294
     both the dynamic object and the regular object will refer to the
8295
     same memory location for the variable.  */
8296
 
8297
  if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
8298
    {
8299 225 jeremybenn
      if (htab->is_vxworks)
8300
        htab->srelbss->size += sizeof (Elf32_External_Rela);
8301
      else
8302
        mips_elf_allocate_dynamic_relocations (dynobj, info, 1);
8303 24 jeremybenn
      h->needs_copy = 1;
8304
    }
8305
 
8306 225 jeremybenn
  /* All relocations against this symbol that could have been made
8307
     dynamic will now refer to the local copy instead.  */
8308
  hmips->possibly_dynamic_relocs = 0;
8309
 
8310 24 jeremybenn
  return _bfd_elf_adjust_dynamic_copy (h, htab->sdynbss);
8311
}
8312
 
8313
/* This function is called after all the input files have been read,
8314
   and the input sections have been assigned to output sections.  We
8315
   check for any mips16 stub sections that we can discard.  */
8316
 
8317
bfd_boolean
8318
_bfd_mips_elf_always_size_sections (bfd *output_bfd,
8319
                                    struct bfd_link_info *info)
8320
{
8321
  asection *ri;
8322 225 jeremybenn
  struct mips_elf_link_hash_table *htab;
8323
  struct mips_htab_traverse_info hti;
8324 24 jeremybenn
 
8325 225 jeremybenn
  htab = mips_elf_hash_table (info);
8326
 
8327
  /* The .reginfo section has a fixed size.  */
8328
  ri = bfd_get_section_by_name (output_bfd, ".reginfo");
8329
  if (ri != NULL)
8330
    bfd_set_section_size (output_bfd, ri, sizeof (Elf32_External_RegInfo));
8331
 
8332
  hti.info = info;
8333
  hti.output_bfd = output_bfd;
8334
  hti.error = FALSE;
8335
  mips_elf_link_hash_traverse (mips_elf_hash_table (info),
8336
                               mips_elf_check_symbols, &hti);
8337
  if (hti.error)
8338
    return FALSE;
8339
 
8340
  return TRUE;
8341
}
8342
 
8343
/* If the link uses a GOT, lay it out and work out its size.  */
8344
 
8345
static bfd_boolean
8346
mips_elf_lay_out_got (bfd *output_bfd, struct bfd_link_info *info)
8347
{
8348 24 jeremybenn
  bfd *dynobj;
8349
  asection *s;
8350
  struct mips_got_info *g;
8351
  bfd_size_type loadable_size = 0;
8352
  bfd_size_type page_gotno;
8353
  bfd *sub;
8354
  struct mips_elf_count_tls_arg count_tls_arg;
8355
  struct mips_elf_link_hash_table *htab;
8356
 
8357
  htab = mips_elf_hash_table (info);
8358 225 jeremybenn
  s = htab->sgot;
8359
  if (s == NULL)
8360
    return TRUE;
8361 24 jeremybenn
 
8362 225 jeremybenn
  dynobj = elf_hash_table (info)->dynobj;
8363
  g = htab->got_info;
8364 24 jeremybenn
 
8365 225 jeremybenn
  /* Allocate room for the reserved entries.  VxWorks always reserves
8366
     3 entries; other objects only reserve 2 entries.  */
8367
  BFD_ASSERT (g->assigned_gotno == 0);
8368
  if (htab->is_vxworks)
8369
    htab->reserved_gotno = 3;
8370
  else
8371
    htab->reserved_gotno = 2;
8372
  g->local_gotno += htab->reserved_gotno;
8373
  g->assigned_gotno = htab->reserved_gotno;
8374 24 jeremybenn
 
8375 225 jeremybenn
  /* Replace entries for indirect and warning symbols with entries for
8376
     the target symbol.  */
8377
  if (!mips_elf_resolve_final_got_entries (g))
8378
    return FALSE;
8379 24 jeremybenn
 
8380 225 jeremybenn
  /* Count the number of GOT symbols.  */
8381
  mips_elf_link_hash_traverse (htab, mips_elf_count_got_symbols, g);
8382 24 jeremybenn
 
8383
  /* Calculate the total loadable size of the output.  That
8384
     will give us the maximum number of GOT_PAGE entries
8385
     required.  */
8386
  for (sub = info->input_bfds; sub; sub = sub->link_next)
8387
    {
8388
      asection *subsection;
8389
 
8390
      for (subsection = sub->sections;
8391
           subsection;
8392
           subsection = subsection->next)
8393
        {
8394
          if ((subsection->flags & SEC_ALLOC) == 0)
8395
            continue;
8396
          loadable_size += ((subsection->size + 0xf)
8397
                            &~ (bfd_size_type) 0xf);
8398
        }
8399
    }
8400
 
8401
  if (htab->is_vxworks)
8402 225 jeremybenn
    /* There's no need to allocate page entries for VxWorks; R_MIPS*_GOT16
8403 24 jeremybenn
       relocations against local symbols evaluate to "G", and the EABI does
8404
       not include R_MIPS_GOT_PAGE.  */
8405
    page_gotno = 0;
8406
  else
8407
    /* Assume there are two loadable segments consisting of contiguous
8408
       sections.  Is 5 enough?  */
8409
    page_gotno = (loadable_size >> 16) + 5;
8410
 
8411
  /* Choose the smaller of the two estimates; both are intended to be
8412
     conservative.  */
8413
  if (page_gotno > g->page_gotno)
8414
    page_gotno = g->page_gotno;
8415
 
8416
  g->local_gotno += page_gotno;
8417
  s->size += g->local_gotno * MIPS_ELF_GOT_SIZE (output_bfd);
8418 225 jeremybenn
  s->size += g->global_gotno * MIPS_ELF_GOT_SIZE (output_bfd);
8419 24 jeremybenn
 
8420
  /* We need to calculate tls_gotno for global symbols at this point
8421
     instead of building it up earlier, to avoid doublecounting
8422
     entries for one global symbol from multiple input files.  */
8423
  count_tls_arg.info = info;
8424
  count_tls_arg.needed = 0;
8425
  elf_link_hash_traverse (elf_hash_table (info),
8426
                          mips_elf_count_global_tls_entries,
8427
                          &count_tls_arg);
8428
  g->tls_gotno += count_tls_arg.needed;
8429
  s->size += g->tls_gotno * MIPS_ELF_GOT_SIZE (output_bfd);
8430
 
8431
  /* VxWorks does not support multiple GOTs.  It initializes $gp to
8432
     __GOTT_BASE__[__GOTT_INDEX__], the value of which is set by the
8433
     dynamic loader.  */
8434 225 jeremybenn
  if (htab->is_vxworks)
8435 24 jeremybenn
    {
8436 225 jeremybenn
      /* VxWorks executables do not need a GOT.  */
8437
      if (info->shared)
8438
        {
8439
          /* Each VxWorks GOT entry needs an explicit relocation.  */
8440
          unsigned int count;
8441
 
8442
          count = g->global_gotno + g->local_gotno - htab->reserved_gotno;
8443
          if (count)
8444
            mips_elf_allocate_dynamic_relocations (dynobj, info, count);
8445
        }
8446
    }
8447
  else if (s->size > MIPS_ELF_GOT_MAX_SIZE (info))
8448
    {
8449
      if (!mips_elf_multi_got (output_bfd, info, s, page_gotno))
8450 24 jeremybenn
        return FALSE;
8451
    }
8452
  else
8453
    {
8454 225 jeremybenn
      struct mips_elf_count_tls_arg arg;
8455
 
8456
      /* Set up TLS entries.  */
8457 24 jeremybenn
      g->tls_assigned_gotno = g->global_gotno + g->local_gotno;
8458
      htab_traverse (g->got_entries, mips_elf_initialize_tls_index, g);
8459 225 jeremybenn
 
8460
      /* Allocate room for the TLS relocations.  */
8461
      arg.info = info;
8462
      arg.needed = 0;
8463
      htab_traverse (g->got_entries, mips_elf_count_local_tls_relocs, &arg);
8464
      elf_link_hash_traverse (elf_hash_table (info),
8465
                              mips_elf_count_global_tls_relocs,
8466
                              &arg);
8467
      if (arg.needed)
8468
        mips_elf_allocate_dynamic_relocations (dynobj, info, arg.needed);
8469 24 jeremybenn
    }
8470
 
8471
  return TRUE;
8472
}
8473
 
8474 225 jeremybenn
/* Estimate the size of the .MIPS.stubs section.  */
8475
 
8476
static void
8477
mips_elf_estimate_stub_size (bfd *output_bfd, struct bfd_link_info *info)
8478
{
8479
  struct mips_elf_link_hash_table *htab;
8480
  bfd_size_type dynsymcount;
8481
 
8482
  htab = mips_elf_hash_table (info);
8483
  if (htab->lazy_stub_count == 0)
8484
    return;
8485
 
8486
  /* IRIX rld assumes that a function stub isn't at the end of the .text
8487
     section, so add a dummy entry to the end.  */
8488
  htab->lazy_stub_count++;
8489
 
8490
  /* Get a worst-case estimate of the number of dynamic symbols needed.
8491
     At this point, dynsymcount does not account for section symbols
8492
     and count_section_dynsyms may overestimate the number that will
8493
     be needed.  */
8494
  dynsymcount = (elf_hash_table (info)->dynsymcount
8495
                 + count_section_dynsyms (output_bfd, info));
8496
 
8497
  /* Determine the size of one stub entry.  */
8498
  htab->function_stub_size = (dynsymcount > 0x10000
8499
                              ? MIPS_FUNCTION_STUB_BIG_SIZE
8500
                              : MIPS_FUNCTION_STUB_NORMAL_SIZE);
8501
 
8502
  htab->sstubs->size = htab->lazy_stub_count * htab->function_stub_size;
8503
}
8504
 
8505
/* A mips_elf_link_hash_traverse callback for which DATA points to the
8506
   MIPS hash table.  If H needs a traditional MIPS lazy-binding stub,
8507
   allocate an entry in the stubs section.  */
8508
 
8509
static bfd_boolean
8510
mips_elf_allocate_lazy_stub (struct mips_elf_link_hash_entry *h, void **data)
8511
{
8512
  struct mips_elf_link_hash_table *htab;
8513
 
8514
  htab = (struct mips_elf_link_hash_table *) data;
8515
  if (h->needs_lazy_stub)
8516
    {
8517
      h->root.root.u.def.section = htab->sstubs;
8518
      h->root.root.u.def.value = htab->sstubs->size;
8519
      h->root.plt.offset = htab->sstubs->size;
8520
      htab->sstubs->size += htab->function_stub_size;
8521
    }
8522
  return TRUE;
8523
}
8524
 
8525
/* Allocate offsets in the stubs section to each symbol that needs one.
8526
   Set the final size of the .MIPS.stub section.  */
8527
 
8528
static void
8529
mips_elf_lay_out_lazy_stubs (struct bfd_link_info *info)
8530
{
8531
  struct mips_elf_link_hash_table *htab;
8532
 
8533
  htab = mips_elf_hash_table (info);
8534
  if (htab->lazy_stub_count == 0)
8535
    return;
8536
 
8537
  htab->sstubs->size = 0;
8538
  mips_elf_link_hash_traverse (mips_elf_hash_table (info),
8539
                               mips_elf_allocate_lazy_stub, htab);
8540
  htab->sstubs->size += htab->function_stub_size;
8541
  BFD_ASSERT (htab->sstubs->size
8542
              == htab->lazy_stub_count * htab->function_stub_size);
8543
}
8544
 
8545 24 jeremybenn
/* Set the sizes of the dynamic sections.  */
8546
 
8547
bfd_boolean
8548
_bfd_mips_elf_size_dynamic_sections (bfd *output_bfd,
8549
                                     struct bfd_link_info *info)
8550
{
8551
  bfd *dynobj;
8552
  asection *s, *sreldyn;
8553
  bfd_boolean reltext;
8554
  struct mips_elf_link_hash_table *htab;
8555
 
8556
  htab = mips_elf_hash_table (info);
8557
  dynobj = elf_hash_table (info)->dynobj;
8558
  BFD_ASSERT (dynobj != NULL);
8559
 
8560
  if (elf_hash_table (info)->dynamic_sections_created)
8561
    {
8562
      /* Set the contents of the .interp section to the interpreter.  */
8563
      if (info->executable)
8564
        {
8565
          s = bfd_get_section_by_name (dynobj, ".interp");
8566
          BFD_ASSERT (s != NULL);
8567
          s->size
8568
            = strlen (ELF_DYNAMIC_INTERPRETER (output_bfd)) + 1;
8569
          s->contents
8570
            = (bfd_byte *) ELF_DYNAMIC_INTERPRETER (output_bfd);
8571
        }
8572 225 jeremybenn
 
8573
      /* Create a symbol for the PLT, if we know that we are using it.  */
8574
      if (htab->splt && htab->splt->size > 0 && htab->root.hplt == NULL)
8575
        {
8576
          struct elf_link_hash_entry *h;
8577
 
8578
          BFD_ASSERT (htab->use_plts_and_copy_relocs);
8579
 
8580
          h = _bfd_elf_define_linkage_sym (dynobj, info, htab->splt,
8581
                                           "_PROCEDURE_LINKAGE_TABLE_");
8582
          htab->root.hplt = h;
8583
          if (h == NULL)
8584
            return FALSE;
8585
          h->type = STT_FUNC;
8586
        }
8587 24 jeremybenn
    }
8588
 
8589 225 jeremybenn
  /* Allocate space for global sym dynamic relocs.  */
8590
  elf_link_hash_traverse (&htab->root, allocate_dynrelocs, (PTR) info);
8591
 
8592
  mips_elf_estimate_stub_size (output_bfd, info);
8593
 
8594
  if (!mips_elf_lay_out_got (output_bfd, info))
8595
    return FALSE;
8596
 
8597
  mips_elf_lay_out_lazy_stubs (info);
8598
 
8599 24 jeremybenn
  /* The check_relocs and adjust_dynamic_symbol entry points have
8600
     determined the sizes of the various dynamic sections.  Allocate
8601
     memory for them.  */
8602
  reltext = FALSE;
8603
  for (s = dynobj->sections; s != NULL; s = s->next)
8604
    {
8605
      const char *name;
8606
 
8607
      /* It's OK to base decisions on the section name, because none
8608
         of the dynobj section names depend upon the input files.  */
8609
      name = bfd_get_section_name (dynobj, s);
8610
 
8611
      if ((s->flags & SEC_LINKER_CREATED) == 0)
8612
        continue;
8613
 
8614
      if (CONST_STRNEQ (name, ".rel"))
8615
        {
8616
          if (s->size != 0)
8617
            {
8618
              const char *outname;
8619
              asection *target;
8620
 
8621
              /* If this relocation section applies to a read only
8622
                 section, then we probably need a DT_TEXTREL entry.
8623
                 If the relocation section is .rel(a).dyn, we always
8624
                 assert a DT_TEXTREL entry rather than testing whether
8625
                 there exists a relocation to a read only section or
8626
                 not.  */
8627
              outname = bfd_get_section_name (output_bfd,
8628
                                              s->output_section);
8629
              target = bfd_get_section_by_name (output_bfd, outname + 4);
8630
              if ((target != NULL
8631
                   && (target->flags & SEC_READONLY) != 0
8632
                   && (target->flags & SEC_ALLOC) != 0)
8633
                  || strcmp (outname, MIPS_ELF_REL_DYN_NAME (info)) == 0)
8634
                reltext = TRUE;
8635
 
8636
              /* We use the reloc_count field as a counter if we need
8637
                 to copy relocs into the output file.  */
8638
              if (strcmp (name, MIPS_ELF_REL_DYN_NAME (info)) != 0)
8639
                s->reloc_count = 0;
8640
 
8641
              /* If combreloc is enabled, elf_link_sort_relocs() will
8642
                 sort relocations, but in a different way than we do,
8643
                 and before we're done creating relocations.  Also, it
8644
                 will move them around between input sections'
8645
                 relocation's contents, so our sorting would be
8646
                 broken, so don't let it run.  */
8647
              info->combreloc = 0;
8648
            }
8649
        }
8650
      else if (! info->shared
8651
               && ! mips_elf_hash_table (info)->use_rld_obj_head
8652
               && CONST_STRNEQ (name, ".rld_map"))
8653
        {
8654
          /* We add a room for __rld_map.  It will be filled in by the
8655
             rtld to contain a pointer to the _r_debug structure.  */
8656
          s->size += 4;
8657
        }
8658
      else if (SGI_COMPAT (output_bfd)
8659
               && CONST_STRNEQ (name, ".compact_rel"))
8660
        s->size += mips_elf_hash_table (info)->compact_rel_size;
8661 225 jeremybenn
      else if (s == htab->splt)
8662
        {
8663
          /* If the last PLT entry has a branch delay slot, allocate
8664
             room for an extra nop to fill the delay slot.  This is
8665
             for CPUs without load interlocking.  */
8666
          if (! LOAD_INTERLOCKS_P (output_bfd)
8667
              && ! htab->is_vxworks && s->size > 0)
8668
            s->size += 4;
8669
        }
8670 24 jeremybenn
      else if (! CONST_STRNEQ (name, ".init")
8671 225 jeremybenn
               && s != htab->sgot
8672 24 jeremybenn
               && s != htab->sgotplt
8673 225 jeremybenn
               && s != htab->sstubs
8674
               && s != htab->sdynbss)
8675 24 jeremybenn
        {
8676
          /* It's not one of our sections, so don't allocate space.  */
8677
          continue;
8678
        }
8679
 
8680
      if (s->size == 0)
8681
        {
8682
          s->flags |= SEC_EXCLUDE;
8683
          continue;
8684
        }
8685
 
8686
      if ((s->flags & SEC_HAS_CONTENTS) == 0)
8687
        continue;
8688
 
8689
      /* Allocate memory for the section contents.  */
8690
      s->contents = bfd_zalloc (dynobj, s->size);
8691
      if (s->contents == NULL)
8692
        {
8693
          bfd_set_error (bfd_error_no_memory);
8694
          return FALSE;
8695
        }
8696
    }
8697
 
8698
  if (elf_hash_table (info)->dynamic_sections_created)
8699
    {
8700
      /* Add some entries to the .dynamic section.  We fill in the
8701
         values later, in _bfd_mips_elf_finish_dynamic_sections, but we
8702
         must add the entries now so that we get the correct size for
8703
         the .dynamic section.  */
8704
 
8705
      /* SGI object has the equivalence of DT_DEBUG in the
8706
         DT_MIPS_RLD_MAP entry.  This must come first because glibc
8707
         only fills in DT_MIPS_RLD_MAP (not DT_DEBUG) and GDB only
8708
         looks at the first one it sees.  */
8709
      if (!info->shared
8710
          && !MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_RLD_MAP, 0))
8711
        return FALSE;
8712
 
8713
      /* The DT_DEBUG entry may be filled in by the dynamic linker and
8714
         used by the debugger.  */
8715
      if (info->executable
8716
          && !SGI_COMPAT (output_bfd)
8717
          && !MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_DEBUG, 0))
8718
        return FALSE;
8719
 
8720
      if (reltext && (SGI_COMPAT (output_bfd) || htab->is_vxworks))
8721
        info->flags |= DF_TEXTREL;
8722
 
8723
      if ((info->flags & DF_TEXTREL) != 0)
8724
        {
8725
          if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_TEXTREL, 0))
8726
            return FALSE;
8727
 
8728
          /* Clear the DF_TEXTREL flag.  It will be set again if we
8729
             write out an actual text relocation; we may not, because
8730
             at this point we do not know whether e.g. any .eh_frame
8731
             absolute relocations have been converted to PC-relative.  */
8732
          info->flags &= ~DF_TEXTREL;
8733
        }
8734
 
8735
      if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_PLTGOT, 0))
8736
        return FALSE;
8737
 
8738 225 jeremybenn
      sreldyn = mips_elf_rel_dyn_section (info, FALSE);
8739 24 jeremybenn
      if (htab->is_vxworks)
8740
        {
8741
          /* VxWorks uses .rela.dyn instead of .rel.dyn.  It does not
8742
             use any of the DT_MIPS_* tags.  */
8743 225 jeremybenn
          if (sreldyn && sreldyn->size > 0)
8744 24 jeremybenn
            {
8745
              if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_RELA, 0))
8746
                return FALSE;
8747
 
8748
              if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_RELASZ, 0))
8749
                return FALSE;
8750
 
8751
              if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_RELAENT, 0))
8752
                return FALSE;
8753
            }
8754
        }
8755
      else
8756
        {
8757 225 jeremybenn
          if (sreldyn && sreldyn->size > 0)
8758 24 jeremybenn
            {
8759
              if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_REL, 0))
8760
                return FALSE;
8761
 
8762
              if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_RELSZ, 0))
8763
                return FALSE;
8764
 
8765
              if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_RELENT, 0))
8766
                return FALSE;
8767
            }
8768
 
8769
          if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_RLD_VERSION, 0))
8770
            return FALSE;
8771
 
8772
          if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_FLAGS, 0))
8773
            return FALSE;
8774
 
8775
          if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_BASE_ADDRESS, 0))
8776
            return FALSE;
8777
 
8778
          if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_LOCAL_GOTNO, 0))
8779
            return FALSE;
8780
 
8781
          if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_SYMTABNO, 0))
8782
            return FALSE;
8783
 
8784
          if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_UNREFEXTNO, 0))
8785
            return FALSE;
8786
 
8787
          if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_GOTSYM, 0))
8788
            return FALSE;
8789
 
8790
          if (IRIX_COMPAT (dynobj) == ict_irix5
8791
              && ! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_HIPAGENO, 0))
8792
            return FALSE;
8793
 
8794
          if (IRIX_COMPAT (dynobj) == ict_irix6
8795
              && (bfd_get_section_by_name
8796
                  (dynobj, MIPS_ELF_OPTIONS_SECTION_NAME (dynobj)))
8797
              && !MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_OPTIONS, 0))
8798
            return FALSE;
8799
        }
8800 225 jeremybenn
      if (htab->splt->size > 0)
8801
        {
8802
          if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_PLTREL, 0))
8803
            return FALSE;
8804
 
8805
          if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_JMPREL, 0))
8806
            return FALSE;
8807
 
8808
          if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_PLTRELSZ, 0))
8809
            return FALSE;
8810
 
8811
          if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_PLTGOT, 0))
8812
            return FALSE;
8813
        }
8814 24 jeremybenn
      if (htab->is_vxworks
8815
          && !elf_vxworks_add_dynamic_entries (output_bfd, info))
8816
        return FALSE;
8817
    }
8818
 
8819
  return TRUE;
8820
}
8821
 
8822
/* REL is a relocation in INPUT_BFD that is being copied to OUTPUT_BFD.
8823
   Adjust its R_ADDEND field so that it is correct for the output file.
8824
   LOCAL_SYMS and LOCAL_SECTIONS are arrays of INPUT_BFD's local symbols
8825
   and sections respectively; both use symbol indexes.  */
8826
 
8827
static void
8828
mips_elf_adjust_addend (bfd *output_bfd, struct bfd_link_info *info,
8829
                        bfd *input_bfd, Elf_Internal_Sym *local_syms,
8830
                        asection **local_sections, Elf_Internal_Rela *rel)
8831
{
8832
  unsigned int r_type, r_symndx;
8833
  Elf_Internal_Sym *sym;
8834
  asection *sec;
8835
 
8836
  if (mips_elf_local_relocation_p (input_bfd, rel, local_sections, FALSE))
8837
    {
8838
      r_type = ELF_R_TYPE (output_bfd, rel->r_info);
8839
      if (r_type == R_MIPS16_GPREL
8840
          || r_type == R_MIPS_GPREL16
8841
          || r_type == R_MIPS_GPREL32
8842
          || r_type == R_MIPS_LITERAL)
8843
        {
8844
          rel->r_addend += _bfd_get_gp_value (input_bfd);
8845
          rel->r_addend -= _bfd_get_gp_value (output_bfd);
8846
        }
8847
 
8848
      r_symndx = ELF_R_SYM (output_bfd, rel->r_info);
8849
      sym = local_syms + r_symndx;
8850
 
8851
      /* Adjust REL's addend to account for section merging.  */
8852
      if (!info->relocatable)
8853
        {
8854
          sec = local_sections[r_symndx];
8855
          _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
8856
        }
8857
 
8858
      /* This would normally be done by the rela_normal code in elflink.c.  */
8859
      if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
8860
        rel->r_addend += local_sections[r_symndx]->output_offset;
8861
    }
8862
}
8863
 
8864
/* Relocate a MIPS ELF section.  */
8865
 
8866
bfd_boolean
8867
_bfd_mips_elf_relocate_section (bfd *output_bfd, struct bfd_link_info *info,
8868
                                bfd *input_bfd, asection *input_section,
8869
                                bfd_byte *contents, Elf_Internal_Rela *relocs,
8870
                                Elf_Internal_Sym *local_syms,
8871
                                asection **local_sections)
8872
{
8873
  Elf_Internal_Rela *rel;
8874
  const Elf_Internal_Rela *relend;
8875
  bfd_vma addend = 0;
8876
  bfd_boolean use_saved_addend_p = FALSE;
8877
  const struct elf_backend_data *bed;
8878
 
8879
  bed = get_elf_backend_data (output_bfd);
8880
  relend = relocs + input_section->reloc_count * bed->s->int_rels_per_ext_rel;
8881
  for (rel = relocs; rel < relend; ++rel)
8882
    {
8883
      const char *name;
8884
      bfd_vma value = 0;
8885
      reloc_howto_type *howto;
8886
      bfd_boolean require_jalx;
8887
      /* TRUE if the relocation is a RELA relocation, rather than a
8888
         REL relocation.  */
8889
      bfd_boolean rela_relocation_p = TRUE;
8890
      unsigned int r_type = ELF_R_TYPE (output_bfd, rel->r_info);
8891
      const char *msg;
8892
      unsigned long r_symndx;
8893
      asection *sec;
8894
      Elf_Internal_Shdr *symtab_hdr;
8895
      struct elf_link_hash_entry *h;
8896
 
8897
      /* Find the relocation howto for this relocation.  */
8898
      howto = MIPS_ELF_RTYPE_TO_HOWTO (input_bfd, r_type,
8899
                                       NEWABI_P (input_bfd)
8900
                                       && (MIPS_RELOC_RELA_P
8901
                                           (input_bfd, input_section,
8902
                                            rel - relocs)));
8903
 
8904
      r_symndx = ELF_R_SYM (input_bfd, rel->r_info);
8905
      symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
8906
      if (mips_elf_local_relocation_p (input_bfd, rel, local_sections, FALSE))
8907
        {
8908
          sec = local_sections[r_symndx];
8909
          h = NULL;
8910
        }
8911
      else
8912
        {
8913
          unsigned long extsymoff;
8914
 
8915
          extsymoff = 0;
8916
          if (!elf_bad_symtab (input_bfd))
8917
            extsymoff = symtab_hdr->sh_info;
8918
          h = elf_sym_hashes (input_bfd) [r_symndx - extsymoff];
8919
          while (h->root.type == bfd_link_hash_indirect
8920
                 || h->root.type == bfd_link_hash_warning)
8921
            h = (struct elf_link_hash_entry *) h->root.u.i.link;
8922
 
8923
          sec = NULL;
8924
          if (h->root.type == bfd_link_hash_defined
8925
              || h->root.type == bfd_link_hash_defweak)
8926
            sec = h->root.u.def.section;
8927
        }
8928
 
8929
      if (sec != NULL && elf_discarded_section (sec))
8930
        {
8931
          /* For relocs against symbols from removed linkonce sections,
8932
             or sections discarded by a linker script, we just want the
8933
             section contents zeroed.  Avoid any special processing.  */
8934
          _bfd_clear_contents (howto, input_bfd, contents + rel->r_offset);
8935
          rel->r_info = 0;
8936
          rel->r_addend = 0;
8937
          continue;
8938
        }
8939
 
8940
      if (r_type == R_MIPS_64 && ! NEWABI_P (input_bfd))
8941
        {
8942
          /* Some 32-bit code uses R_MIPS_64.  In particular, people use
8943
             64-bit code, but make sure all their addresses are in the
8944
             lowermost or uppermost 32-bit section of the 64-bit address
8945
             space.  Thus, when they use an R_MIPS_64 they mean what is
8946
             usually meant by R_MIPS_32, with the exception that the
8947
             stored value is sign-extended to 64 bits.  */
8948
          howto = MIPS_ELF_RTYPE_TO_HOWTO (input_bfd, R_MIPS_32, FALSE);
8949
 
8950
          /* On big-endian systems, we need to lie about the position
8951
             of the reloc.  */
8952
          if (bfd_big_endian (input_bfd))
8953
            rel->r_offset += 4;
8954
        }
8955
 
8956
      if (!use_saved_addend_p)
8957
        {
8958
          /* If these relocations were originally of the REL variety,
8959
             we must pull the addend out of the field that will be
8960
             relocated.  Otherwise, we simply use the contents of the
8961
             RELA relocation.  */
8962
          if (mips_elf_rel_relocation_p (input_bfd, input_section,
8963
                                         relocs, rel))
8964
            {
8965
              rela_relocation_p = FALSE;
8966
              addend = mips_elf_read_rel_addend (input_bfd, rel,
8967
                                                 howto, contents);
8968 225 jeremybenn
              if (hi16_reloc_p (r_type)
8969
                  || (got16_reloc_p (r_type)
8970 24 jeremybenn
                      && mips_elf_local_relocation_p (input_bfd, rel,
8971
                                                      local_sections, FALSE)))
8972
                {
8973
                  if (!mips_elf_add_lo16_rel_addend (input_bfd, rel, relend,
8974
                                                     contents, &addend))
8975
                    {
8976
                      const char *name;
8977
 
8978
                      if (h)
8979
                        name = h->root.root.string;
8980
                      else
8981
                        name = bfd_elf_sym_name (input_bfd, symtab_hdr,
8982
                                                 local_syms + r_symndx,
8983
                                                 sec);
8984
                      (*_bfd_error_handler)
8985
                        (_("%B: Can't find matching LO16 reloc against `%s' for %s at 0x%lx in section `%A'"),
8986
                         input_bfd, input_section, name, howto->name,
8987
                         rel->r_offset);
8988
                    }
8989
                }
8990
              else
8991
                addend <<= howto->rightshift;
8992
            }
8993
          else
8994
            addend = rel->r_addend;
8995
          mips_elf_adjust_addend (output_bfd, info, input_bfd,
8996
                                  local_syms, local_sections, rel);
8997
        }
8998
 
8999
      if (info->relocatable)
9000
        {
9001
          if (r_type == R_MIPS_64 && ! NEWABI_P (output_bfd)
9002
              && bfd_big_endian (input_bfd))
9003
            rel->r_offset -= 4;
9004
 
9005
          if (!rela_relocation_p && rel->r_addend)
9006
            {
9007
              addend += rel->r_addend;
9008 225 jeremybenn
              if (hi16_reloc_p (r_type) || got16_reloc_p (r_type))
9009 24 jeremybenn
                addend = mips_elf_high (addend);
9010
              else if (r_type == R_MIPS_HIGHER)
9011
                addend = mips_elf_higher (addend);
9012
              else if (r_type == R_MIPS_HIGHEST)
9013
                addend = mips_elf_highest (addend);
9014
              else
9015
                addend >>= howto->rightshift;
9016
 
9017
              /* We use the source mask, rather than the destination
9018
                 mask because the place to which we are writing will be
9019
                 source of the addend in the final link.  */
9020
              addend &= howto->src_mask;
9021
 
9022
              if (r_type == R_MIPS_64 && ! NEWABI_P (output_bfd))
9023
                /* See the comment above about using R_MIPS_64 in the 32-bit
9024
                   ABI.  Here, we need to update the addend.  It would be
9025
                   possible to get away with just using the R_MIPS_32 reloc
9026
                   but for endianness.  */
9027
                {
9028
                  bfd_vma sign_bits;
9029
                  bfd_vma low_bits;
9030
                  bfd_vma high_bits;
9031
 
9032
                  if (addend & ((bfd_vma) 1 << 31))
9033
#ifdef BFD64
9034
                    sign_bits = ((bfd_vma) 1 << 32) - 1;
9035
#else
9036
                    sign_bits = -1;
9037
#endif
9038
                  else
9039
                    sign_bits = 0;
9040
 
9041
                  /* If we don't know that we have a 64-bit type,
9042
                     do two separate stores.  */
9043
                  if (bfd_big_endian (input_bfd))
9044
                    {
9045
                      /* Store the sign-bits (which are most significant)
9046
                         first.  */
9047
                      low_bits = sign_bits;
9048
                      high_bits = addend;
9049
                    }
9050
                  else
9051
                    {
9052
                      low_bits = addend;
9053
                      high_bits = sign_bits;
9054
                    }
9055
                  bfd_put_32 (input_bfd, low_bits,
9056
                              contents + rel->r_offset);
9057
                  bfd_put_32 (input_bfd, high_bits,
9058
                              contents + rel->r_offset + 4);
9059
                  continue;
9060
                }
9061
 
9062
              if (! mips_elf_perform_relocation (info, howto, rel, addend,
9063
                                                 input_bfd, input_section,
9064
                                                 contents, FALSE))
9065
                return FALSE;
9066
            }
9067
 
9068
          /* Go on to the next relocation.  */
9069
          continue;
9070
        }
9071
 
9072
      /* In the N32 and 64-bit ABIs there may be multiple consecutive
9073
         relocations for the same offset.  In that case we are
9074
         supposed to treat the output of each relocation as the addend
9075
         for the next.  */
9076
      if (rel + 1 < relend
9077
          && rel->r_offset == rel[1].r_offset
9078
          && ELF_R_TYPE (input_bfd, rel[1].r_info) != R_MIPS_NONE)
9079
        use_saved_addend_p = TRUE;
9080
      else
9081
        use_saved_addend_p = FALSE;
9082
 
9083
      /* Figure out what value we are supposed to relocate.  */
9084
      switch (mips_elf_calculate_relocation (output_bfd, input_bfd,
9085
                                             input_section, info, rel,
9086
                                             addend, howto, local_syms,
9087
                                             local_sections, &value,
9088
                                             &name, &require_jalx,
9089
                                             use_saved_addend_p))
9090
        {
9091
        case bfd_reloc_continue:
9092
          /* There's nothing to do.  */
9093
          continue;
9094
 
9095
        case bfd_reloc_undefined:
9096
          /* mips_elf_calculate_relocation already called the
9097
             undefined_symbol callback.  There's no real point in
9098
             trying to perform the relocation at this point, so we
9099
             just skip ahead to the next relocation.  */
9100
          continue;
9101
 
9102
        case bfd_reloc_notsupported:
9103
          msg = _("internal error: unsupported relocation error");
9104
          info->callbacks->warning
9105
            (info, msg, name, input_bfd, input_section, rel->r_offset);
9106
          return FALSE;
9107
 
9108
        case bfd_reloc_overflow:
9109
          if (use_saved_addend_p)
9110
            /* Ignore overflow until we reach the last relocation for
9111
               a given location.  */
9112
            ;
9113
          else
9114
            {
9115
              struct mips_elf_link_hash_table *htab;
9116
 
9117
              htab = mips_elf_hash_table (info);
9118
              BFD_ASSERT (name != NULL);
9119
              if (!htab->small_data_overflow_reported
9120
                  && (howto->type == R_MIPS_GPREL16
9121
                      || howto->type == R_MIPS_LITERAL))
9122
                {
9123
                  const char *msg =
9124
                    _("small-data section exceeds 64KB;"
9125
                      " lower small-data size limit (see option -G)");
9126
 
9127
                  htab->small_data_overflow_reported = TRUE;
9128
                  (*info->callbacks->einfo) ("%P: %s\n", msg);
9129
                }
9130
              if (! ((*info->callbacks->reloc_overflow)
9131
                     (info, NULL, name, howto->name, (bfd_vma) 0,
9132
                      input_bfd, input_section, rel->r_offset)))
9133
                return FALSE;
9134
            }
9135
          break;
9136
 
9137
        case bfd_reloc_ok:
9138
          break;
9139
 
9140
        default:
9141
          abort ();
9142
          break;
9143
        }
9144
 
9145
      /* If we've got another relocation for the address, keep going
9146
         until we reach the last one.  */
9147
      if (use_saved_addend_p)
9148
        {
9149
          addend = value;
9150
          continue;
9151
        }
9152
 
9153
      if (r_type == R_MIPS_64 && ! NEWABI_P (output_bfd))
9154
        /* See the comment above about using R_MIPS_64 in the 32-bit
9155
           ABI.  Until now, we've been using the HOWTO for R_MIPS_32;
9156
           that calculated the right value.  Now, however, we
9157
           sign-extend the 32-bit result to 64-bits, and store it as a
9158
           64-bit value.  We are especially generous here in that we
9159
           go to extreme lengths to support this usage on systems with
9160
           only a 32-bit VMA.  */
9161
        {
9162
          bfd_vma sign_bits;
9163
          bfd_vma low_bits;
9164
          bfd_vma high_bits;
9165
 
9166
          if (value & ((bfd_vma) 1 << 31))
9167
#ifdef BFD64
9168
            sign_bits = ((bfd_vma) 1 << 32) - 1;
9169
#else
9170
            sign_bits = -1;
9171
#endif
9172
          else
9173
            sign_bits = 0;
9174
 
9175
          /* If we don't know that we have a 64-bit type,
9176
             do two separate stores.  */
9177
          if (bfd_big_endian (input_bfd))
9178
            {
9179
              /* Undo what we did above.  */
9180
              rel->r_offset -= 4;
9181
              /* Store the sign-bits (which are most significant)
9182
                 first.  */
9183
              low_bits = sign_bits;
9184
              high_bits = value;
9185
            }
9186
          else
9187
            {
9188
              low_bits = value;
9189
              high_bits = sign_bits;
9190
            }
9191
          bfd_put_32 (input_bfd, low_bits,
9192
                      contents + rel->r_offset);
9193
          bfd_put_32 (input_bfd, high_bits,
9194
                      contents + rel->r_offset + 4);
9195
          continue;
9196
        }
9197
 
9198
      /* Actually perform the relocation.  */
9199
      if (! mips_elf_perform_relocation (info, howto, rel, value,
9200
                                         input_bfd, input_section,
9201
                                         contents, require_jalx))
9202
        return FALSE;
9203
    }
9204
 
9205
  return TRUE;
9206
}
9207
 
9208 225 jeremybenn
/* A function that iterates over each entry in la25_stubs and fills
9209
   in the code for each one.  DATA points to a mips_htab_traverse_info.  */
9210
 
9211
static int
9212
mips_elf_create_la25_stub (void **slot, void *data)
9213
{
9214
  struct mips_htab_traverse_info *hti;
9215
  struct mips_elf_link_hash_table *htab;
9216
  struct mips_elf_la25_stub *stub;
9217
  asection *s;
9218
  bfd_byte *loc;
9219
  bfd_vma offset, target, target_high, target_low;
9220
 
9221
  stub = (struct mips_elf_la25_stub *) *slot;
9222
  hti = (struct mips_htab_traverse_info *) data;
9223
  htab = mips_elf_hash_table (hti->info);
9224
 
9225
  /* Create the section contents, if we haven't already.  */
9226
  s = stub->stub_section;
9227
  loc = s->contents;
9228
  if (loc == NULL)
9229
    {
9230
      loc = bfd_malloc (s->size);
9231
      if (loc == NULL)
9232
        {
9233
          hti->error = TRUE;
9234
          return FALSE;
9235
        }
9236
      s->contents = loc;
9237
    }
9238
 
9239
  /* Work out where in the section this stub should go.  */
9240
  offset = stub->offset;
9241
 
9242
  /* Work out the target address.  */
9243
  target = (stub->h->root.root.u.def.section->output_section->vma
9244
            + stub->h->root.root.u.def.section->output_offset
9245
            + stub->h->root.root.u.def.value);
9246
  target_high = ((target + 0x8000) >> 16) & 0xffff;
9247
  target_low = (target & 0xffff);
9248
 
9249
  if (stub->stub_section != htab->strampoline)
9250
    {
9251
      /* This is a simple LUI/ADIDU stub.  Zero out the beginning
9252
         of the section and write the two instructions at the end.  */
9253
      memset (loc, 0, offset);
9254
      loc += offset;
9255
      bfd_put_32 (hti->output_bfd, LA25_LUI (target_high), loc);
9256
      bfd_put_32 (hti->output_bfd, LA25_ADDIU (target_low), loc + 4);
9257
    }
9258
  else
9259
    {
9260
      /* This is trampoline.  */
9261
      loc += offset;
9262
      bfd_put_32 (hti->output_bfd, LA25_LUI (target_high), loc);
9263
      bfd_put_32 (hti->output_bfd, LA25_J (target), loc + 4);
9264
      bfd_put_32 (hti->output_bfd, LA25_ADDIU (target_low), loc + 8);
9265
      bfd_put_32 (hti->output_bfd, 0, loc + 12);
9266
    }
9267
  return TRUE;
9268
}
9269
 
9270 24 jeremybenn
/* If NAME is one of the special IRIX6 symbols defined by the linker,
9271
   adjust it appropriately now.  */
9272
 
9273
static void
9274
mips_elf_irix6_finish_dynamic_symbol (bfd *abfd ATTRIBUTE_UNUSED,
9275
                                      const char *name, Elf_Internal_Sym *sym)
9276
{
9277
  /* The linker script takes care of providing names and values for
9278
     these, but we must place them into the right sections.  */
9279
  static const char* const text_section_symbols[] = {
9280
    "_ftext",
9281
    "_etext",
9282
    "__dso_displacement",
9283
    "__elf_header",
9284
    "__program_header_table",
9285
    NULL
9286
  };
9287
 
9288
  static const char* const data_section_symbols[] = {
9289
    "_fdata",
9290
    "_edata",
9291
    "_end",
9292
    "_fbss",
9293
    NULL
9294
  };
9295
 
9296
  const char* const *p;
9297
  int i;
9298
 
9299
  for (i = 0; i < 2; ++i)
9300
    for (p = (i == 0) ? text_section_symbols : data_section_symbols;
9301
         *p;
9302
         ++p)
9303
      if (strcmp (*p, name) == 0)
9304
        {
9305
          /* All of these symbols are given type STT_SECTION by the
9306
             IRIX6 linker.  */
9307
          sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
9308
          sym->st_other = STO_PROTECTED;
9309
 
9310
          /* The IRIX linker puts these symbols in special sections.  */
9311
          if (i == 0)
9312
            sym->st_shndx = SHN_MIPS_TEXT;
9313
          else
9314
            sym->st_shndx = SHN_MIPS_DATA;
9315
 
9316
          break;
9317
        }
9318
}
9319
 
9320
/* Finish up dynamic symbol handling.  We set the contents of various
9321
   dynamic sections here.  */
9322
 
9323
bfd_boolean
9324
_bfd_mips_elf_finish_dynamic_symbol (bfd *output_bfd,
9325
                                     struct bfd_link_info *info,
9326
                                     struct elf_link_hash_entry *h,
9327
                                     Elf_Internal_Sym *sym)
9328
{
9329
  bfd *dynobj;
9330
  asection *sgot;
9331
  struct mips_got_info *g, *gg;
9332
  const char *name;
9333
  int idx;
9334
  struct mips_elf_link_hash_table *htab;
9335 225 jeremybenn
  struct mips_elf_link_hash_entry *hmips;
9336 24 jeremybenn
 
9337
  htab = mips_elf_hash_table (info);
9338
  dynobj = elf_hash_table (info)->dynobj;
9339 225 jeremybenn
  hmips = (struct mips_elf_link_hash_entry *) h;
9340 24 jeremybenn
 
9341 225 jeremybenn
  BFD_ASSERT (!htab->is_vxworks);
9342
 
9343
  if (h->plt.offset != MINUS_ONE && hmips->no_fn_stub)
9344 24 jeremybenn
    {
9345 225 jeremybenn
      /* We've decided to create a PLT entry for this symbol.  */
9346
      bfd_byte *loc;
9347
      bfd_vma header_address, plt_index, got_address;
9348
      bfd_vma got_address_high, got_address_low, load;
9349
      const bfd_vma *plt_entry;
9350
 
9351
      BFD_ASSERT (htab->use_plts_and_copy_relocs);
9352
      BFD_ASSERT (h->dynindx != -1);
9353
      BFD_ASSERT (htab->splt != NULL);
9354
      BFD_ASSERT (h->plt.offset <= htab->splt->size);
9355
      BFD_ASSERT (!h->def_regular);
9356
 
9357
      /* Calculate the address of the PLT header.  */
9358
      header_address = (htab->splt->output_section->vma
9359
                        + htab->splt->output_offset);
9360
 
9361
      /* Calculate the index of the entry.  */
9362
      plt_index = ((h->plt.offset - htab->plt_header_size)
9363
                   / htab->plt_entry_size);
9364
 
9365
      /* Calculate the address of the .got.plt entry.  */
9366
      got_address = (htab->sgotplt->output_section->vma
9367
                     + htab->sgotplt->output_offset
9368
                     + (2 + plt_index) * MIPS_ELF_GOT_SIZE (dynobj));
9369
      got_address_high = ((got_address + 0x8000) >> 16) & 0xffff;
9370
      got_address_low = got_address & 0xffff;
9371
 
9372
      /* Initially point the .got.plt entry at the PLT header.  */
9373
      loc = (htab->sgotplt->contents
9374
             + (2 + plt_index) * MIPS_ELF_GOT_SIZE (dynobj));
9375
      if (ABI_64_P (output_bfd))
9376
        bfd_put_64 (output_bfd, header_address, loc);
9377
      else
9378
        bfd_put_32 (output_bfd, header_address, loc);
9379
 
9380
      /* Find out where the .plt entry should go.  */
9381
      loc = htab->splt->contents + h->plt.offset;
9382
 
9383
      /* Pick the load opcode.  */
9384
      load = MIPS_ELF_LOAD_WORD (output_bfd);
9385
 
9386
      /* Fill in the PLT entry itself.  */
9387
      plt_entry = mips_exec_plt_entry;
9388
      bfd_put_32 (output_bfd, plt_entry[0] | got_address_high, loc);
9389
      bfd_put_32 (output_bfd, plt_entry[1] | got_address_low | load, loc + 4);
9390
 
9391
      if (! LOAD_INTERLOCKS_P (output_bfd))
9392
        {
9393
          bfd_put_32 (output_bfd, plt_entry[2] | got_address_low, loc + 8);
9394
          bfd_put_32 (output_bfd, plt_entry[3], loc + 12);
9395
        }
9396
      else
9397
        {
9398
          bfd_put_32 (output_bfd, plt_entry[3], loc + 8);
9399
          bfd_put_32 (output_bfd, plt_entry[2] | got_address_low, loc + 12);
9400
        }
9401
 
9402
      /* Emit an R_MIPS_JUMP_SLOT relocation against the .got.plt entry.  */
9403
      mips_elf_output_dynamic_relocation (output_bfd, htab->srelplt,
9404
                                          plt_index, h->dynindx,
9405
                                          R_MIPS_JUMP_SLOT, got_address);
9406
 
9407
      /* We distinguish between PLT entries and lazy-binding stubs by
9408
         giving the former an st_other value of STO_MIPS_PLT.  Set the
9409
         flag and leave the value if there are any relocations in the
9410
         binary where pointer equality matters.  */
9411
      sym->st_shndx = SHN_UNDEF;
9412
      if (h->pointer_equality_needed)
9413
        sym->st_other = STO_MIPS_PLT;
9414
      else
9415
        sym->st_value = 0;
9416
    }
9417
  else if (h->plt.offset != MINUS_ONE)
9418
    {
9419
      /* We've decided to create a lazy-binding stub.  */
9420 24 jeremybenn
      bfd_byte stub[MIPS_FUNCTION_STUB_BIG_SIZE];
9421
 
9422
      /* This symbol has a stub.  Set it up.  */
9423
 
9424
      BFD_ASSERT (h->dynindx != -1);
9425
 
9426
      BFD_ASSERT ((htab->function_stub_size == MIPS_FUNCTION_STUB_BIG_SIZE)
9427
                  || (h->dynindx <= 0xffff));
9428
 
9429
      /* Values up to 2^31 - 1 are allowed.  Larger values would cause
9430
         sign extension at runtime in the stub, resulting in a negative
9431
         index value.  */
9432
      if (h->dynindx & ~0x7fffffff)
9433
        return FALSE;
9434
 
9435
      /* Fill the stub.  */
9436
      idx = 0;
9437
      bfd_put_32 (output_bfd, STUB_LW (output_bfd), stub + idx);
9438
      idx += 4;
9439
      bfd_put_32 (output_bfd, STUB_MOVE (output_bfd), stub + idx);
9440
      idx += 4;
9441
      if (htab->function_stub_size == MIPS_FUNCTION_STUB_BIG_SIZE)
9442
        {
9443
          bfd_put_32 (output_bfd, STUB_LUI ((h->dynindx >> 16) & 0x7fff),
9444
                      stub + idx);
9445
          idx += 4;
9446
        }
9447
      bfd_put_32 (output_bfd, STUB_JALR, stub + idx);
9448
      idx += 4;
9449
 
9450
      /* If a large stub is not required and sign extension is not a
9451
         problem, then use legacy code in the stub.  */
9452
      if (htab->function_stub_size == MIPS_FUNCTION_STUB_BIG_SIZE)
9453
        bfd_put_32 (output_bfd, STUB_ORI (h->dynindx & 0xffff), stub + idx);
9454
      else if (h->dynindx & ~0x7fff)
9455
        bfd_put_32 (output_bfd, STUB_LI16U (h->dynindx & 0xffff), stub + idx);
9456
      else
9457
        bfd_put_32 (output_bfd, STUB_LI16S (output_bfd, h->dynindx),
9458
                    stub + idx);
9459
 
9460 225 jeremybenn
      BFD_ASSERT (h->plt.offset <= htab->sstubs->size);
9461
      memcpy (htab->sstubs->contents + h->plt.offset,
9462
              stub, htab->function_stub_size);
9463 24 jeremybenn
 
9464
      /* Mark the symbol as undefined.  plt.offset != -1 occurs
9465
         only for the referenced symbol.  */
9466
      sym->st_shndx = SHN_UNDEF;
9467
 
9468
      /* The run-time linker uses the st_value field of the symbol
9469
         to reset the global offset table entry for this external
9470
         to its stub address when unlinking a shared object.  */
9471 225 jeremybenn
      sym->st_value = (htab->sstubs->output_section->vma
9472
                       + htab->sstubs->output_offset
9473 24 jeremybenn
                       + h->plt.offset);
9474
    }
9475
 
9476 225 jeremybenn
  /* If we have a MIPS16 function with a stub, the dynamic symbol must
9477
     refer to the stub, since only the stub uses the standard calling
9478
     conventions.  */
9479
  if (h->dynindx != -1 && hmips->fn_stub != NULL)
9480
    {
9481
      BFD_ASSERT (hmips->need_fn_stub);
9482
      sym->st_value = (hmips->fn_stub->output_section->vma
9483
                       + hmips->fn_stub->output_offset);
9484
      sym->st_size = hmips->fn_stub->size;
9485
      sym->st_other = ELF_ST_VISIBILITY (sym->st_other);
9486
    }
9487
 
9488 24 jeremybenn
  BFD_ASSERT (h->dynindx != -1
9489
              || h->forced_local);
9490
 
9491 225 jeremybenn
  sgot = htab->sgot;
9492
  g = htab->got_info;
9493 24 jeremybenn
  BFD_ASSERT (g != NULL);
9494
 
9495
  /* Run through the global symbol table, creating GOT entries for all
9496
     the symbols that need them.  */
9497
  if (g->global_gotsym != NULL
9498
      && h->dynindx >= g->global_gotsym->dynindx)
9499
    {
9500
      bfd_vma offset;
9501
      bfd_vma value;
9502
 
9503
      value = sym->st_value;
9504 225 jeremybenn
      offset = mips_elf_global_got_index (dynobj, output_bfd, h,
9505
                                          R_MIPS_GOT16, info);
9506 24 jeremybenn
      MIPS_ELF_PUT_WORD (output_bfd, value, sgot->contents + offset);
9507
    }
9508
 
9509
  if (g->next && h->dynindx != -1 && h->type != STT_TLS)
9510
    {
9511
      struct mips_got_entry e, *p;
9512
      bfd_vma entry;
9513
      bfd_vma offset;
9514
 
9515
      gg = g;
9516
 
9517
      e.abfd = output_bfd;
9518
      e.symndx = -1;
9519 225 jeremybenn
      e.d.h = hmips;
9520 24 jeremybenn
      e.tls_type = 0;
9521
 
9522
      for (g = g->next; g->next != gg; g = g->next)
9523
        {
9524
          if (g->got_entries
9525
              && (p = (struct mips_got_entry *) htab_find (g->got_entries,
9526
                                                           &e)))
9527
            {
9528
              offset = p->gotidx;
9529
              if (info->shared
9530
                  || (elf_hash_table (info)->dynamic_sections_created
9531
                      && p->d.h != NULL
9532
                      && p->d.h->root.def_dynamic
9533
                      && !p->d.h->root.def_regular))
9534
                {
9535
                  /* Create an R_MIPS_REL32 relocation for this entry.  Due to
9536
                     the various compatibility problems, it's easier to mock
9537
                     up an R_MIPS_32 or R_MIPS_64 relocation and leave
9538
                     mips_elf_create_dynamic_relocation to calculate the
9539
                     appropriate addend.  */
9540
                  Elf_Internal_Rela rel[3];
9541
 
9542
                  memset (rel, 0, sizeof (rel));
9543
                  if (ABI_64_P (output_bfd))
9544
                    rel[0].r_info = ELF_R_INFO (output_bfd, 0, R_MIPS_64);
9545
                  else
9546
                    rel[0].r_info = ELF_R_INFO (output_bfd, 0, R_MIPS_32);
9547
                  rel[0].r_offset = rel[1].r_offset = rel[2].r_offset = offset;
9548
 
9549
                  entry = 0;
9550
                  if (! (mips_elf_create_dynamic_relocation
9551
                         (output_bfd, info, rel,
9552
                          e.d.h, NULL, sym->st_value, &entry, sgot)))
9553
                    return FALSE;
9554
                }
9555
              else
9556
                entry = sym->st_value;
9557
              MIPS_ELF_PUT_WORD (output_bfd, entry, sgot->contents + offset);
9558
            }
9559
        }
9560
    }
9561
 
9562
  /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute.  */
9563
  name = h->root.root.string;
9564
  if (strcmp (name, "_DYNAMIC") == 0
9565
      || h == elf_hash_table (info)->hgot)
9566
    sym->st_shndx = SHN_ABS;
9567
  else if (strcmp (name, "_DYNAMIC_LINK") == 0
9568
           || strcmp (name, "_DYNAMIC_LINKING") == 0)
9569
    {
9570
      sym->st_shndx = SHN_ABS;
9571
      sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
9572
      sym->st_value = 1;
9573
    }
9574
  else if (strcmp (name, "_gp_disp") == 0 && ! NEWABI_P (output_bfd))
9575
    {
9576
      sym->st_shndx = SHN_ABS;
9577
      sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
9578
      sym->st_value = elf_gp (output_bfd);
9579
    }
9580
  else if (SGI_COMPAT (output_bfd))
9581
    {
9582
      if (strcmp (name, mips_elf_dynsym_rtproc_names[0]) == 0
9583
          || strcmp (name, mips_elf_dynsym_rtproc_names[1]) == 0)
9584
        {
9585
          sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
9586
          sym->st_other = STO_PROTECTED;
9587
          sym->st_value = 0;
9588
          sym->st_shndx = SHN_MIPS_DATA;
9589
        }
9590
      else if (strcmp (name, mips_elf_dynsym_rtproc_names[2]) == 0)
9591
        {
9592
          sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
9593
          sym->st_other = STO_PROTECTED;
9594
          sym->st_value = mips_elf_hash_table (info)->procedure_count;
9595
          sym->st_shndx = SHN_ABS;
9596
        }
9597
      else if (sym->st_shndx != SHN_UNDEF && sym->st_shndx != SHN_ABS)
9598
        {
9599
          if (h->type == STT_FUNC)
9600
            sym->st_shndx = SHN_MIPS_TEXT;
9601
          else if (h->type == STT_OBJECT)
9602
            sym->st_shndx = SHN_MIPS_DATA;
9603
        }
9604
    }
9605
 
9606 225 jeremybenn
  /* Emit a copy reloc, if needed.  */
9607
  if (h->needs_copy)
9608
    {
9609
      asection *s;
9610
      bfd_vma symval;
9611
 
9612
      BFD_ASSERT (h->dynindx != -1);
9613
      BFD_ASSERT (htab->use_plts_and_copy_relocs);
9614
 
9615
      s = mips_elf_rel_dyn_section (info, FALSE);
9616
      symval = (h->root.u.def.section->output_section->vma
9617
                + h->root.u.def.section->output_offset
9618
                + h->root.u.def.value);
9619
      mips_elf_output_dynamic_relocation (output_bfd, s, s->reloc_count++,
9620
                                          h->dynindx, R_MIPS_COPY, symval);
9621
    }
9622
 
9623 24 jeremybenn
  /* Handle the IRIX6-specific symbols.  */
9624
  if (IRIX_COMPAT (output_bfd) == ict_irix6)
9625
    mips_elf_irix6_finish_dynamic_symbol (output_bfd, name, sym);
9626
 
9627
  if (! info->shared)
9628
    {
9629
      if (! mips_elf_hash_table (info)->use_rld_obj_head
9630
          && (strcmp (name, "__rld_map") == 0
9631
              || strcmp (name, "__RLD_MAP") == 0))
9632
        {
9633
          asection *s = bfd_get_section_by_name (dynobj, ".rld_map");
9634
          BFD_ASSERT (s != NULL);
9635
          sym->st_value = s->output_section->vma + s->output_offset;
9636
          bfd_put_32 (output_bfd, 0, s->contents);
9637
          if (mips_elf_hash_table (info)->rld_value == 0)
9638
            mips_elf_hash_table (info)->rld_value = sym->st_value;
9639
        }
9640
      else if (mips_elf_hash_table (info)->use_rld_obj_head
9641
               && strcmp (name, "__rld_obj_head") == 0)
9642
        {
9643
          /* IRIX6 does not use a .rld_map section.  */
9644
          if (IRIX_COMPAT (output_bfd) == ict_irix5
9645
              || IRIX_COMPAT (output_bfd) == ict_none)
9646
            BFD_ASSERT (bfd_get_section_by_name (dynobj, ".rld_map")
9647
                        != NULL);
9648
          mips_elf_hash_table (info)->rld_value = sym->st_value;
9649
        }
9650
    }
9651
 
9652 225 jeremybenn
  /* Keep dynamic MIPS16 symbols odd.  This allows the dynamic linker to
9653
     treat MIPS16 symbols like any other.  */
9654
  if (ELF_ST_IS_MIPS16 (sym->st_other))
9655
    {
9656
      BFD_ASSERT (sym->st_value & 1);
9657
      sym->st_other -= STO_MIPS16;
9658
    }
9659 24 jeremybenn
 
9660
  return TRUE;
9661
}
9662
 
9663
/* Likewise, for VxWorks.  */
9664
 
9665
bfd_boolean
9666
_bfd_mips_vxworks_finish_dynamic_symbol (bfd *output_bfd,
9667
                                         struct bfd_link_info *info,
9668
                                         struct elf_link_hash_entry *h,
9669
                                         Elf_Internal_Sym *sym)
9670
{
9671
  bfd *dynobj;
9672
  asection *sgot;
9673
  struct mips_got_info *g;
9674
  struct mips_elf_link_hash_table *htab;
9675
 
9676
  htab = mips_elf_hash_table (info);
9677
  dynobj = elf_hash_table (info)->dynobj;
9678
 
9679
  if (h->plt.offset != (bfd_vma) -1)
9680
    {
9681
      bfd_byte *loc;
9682
      bfd_vma plt_address, plt_index, got_address, got_offset, branch_offset;
9683
      Elf_Internal_Rela rel;
9684
      static const bfd_vma *plt_entry;
9685
 
9686
      BFD_ASSERT (h->dynindx != -1);
9687
      BFD_ASSERT (htab->splt != NULL);
9688
      BFD_ASSERT (h->plt.offset <= htab->splt->size);
9689
 
9690
      /* Calculate the address of the .plt entry.  */
9691
      plt_address = (htab->splt->output_section->vma
9692
                     + htab->splt->output_offset
9693
                     + h->plt.offset);
9694
 
9695
      /* Calculate the index of the entry.  */
9696
      plt_index = ((h->plt.offset - htab->plt_header_size)
9697
                   / htab->plt_entry_size);
9698
 
9699
      /* Calculate the address of the .got.plt entry.  */
9700
      got_address = (htab->sgotplt->output_section->vma
9701
                     + htab->sgotplt->output_offset
9702
                     + plt_index * 4);
9703
 
9704
      /* Calculate the offset of the .got.plt entry from
9705
         _GLOBAL_OFFSET_TABLE_.  */
9706
      got_offset = mips_elf_gotplt_index (info, h);
9707
 
9708
      /* Calculate the offset for the branch at the start of the PLT
9709
         entry.  The branch jumps to the beginning of .plt.  */
9710
      branch_offset = -(h->plt.offset / 4 + 1) & 0xffff;
9711
 
9712
      /* Fill in the initial value of the .got.plt entry.  */
9713
      bfd_put_32 (output_bfd, plt_address,
9714
                  htab->sgotplt->contents + plt_index * 4);
9715
 
9716
      /* Find out where the .plt entry should go.  */
9717
      loc = htab->splt->contents + h->plt.offset;
9718
 
9719
      if (info->shared)
9720
        {
9721
          plt_entry = mips_vxworks_shared_plt_entry;
9722
          bfd_put_32 (output_bfd, plt_entry[0] | branch_offset, loc);
9723
          bfd_put_32 (output_bfd, plt_entry[1] | plt_index, loc + 4);
9724
        }
9725
      else
9726
        {
9727
          bfd_vma got_address_high, got_address_low;
9728
 
9729
          plt_entry = mips_vxworks_exec_plt_entry;
9730
          got_address_high = ((got_address + 0x8000) >> 16) & 0xffff;
9731
          got_address_low = got_address & 0xffff;
9732
 
9733
          bfd_put_32 (output_bfd, plt_entry[0] | branch_offset, loc);
9734
          bfd_put_32 (output_bfd, plt_entry[1] | plt_index, loc + 4);
9735
          bfd_put_32 (output_bfd, plt_entry[2] | got_address_high, loc + 8);
9736
          bfd_put_32 (output_bfd, plt_entry[3] | got_address_low, loc + 12);
9737
          bfd_put_32 (output_bfd, plt_entry[4], loc + 16);
9738
          bfd_put_32 (output_bfd, plt_entry[5], loc + 20);
9739
          bfd_put_32 (output_bfd, plt_entry[6], loc + 24);
9740
          bfd_put_32 (output_bfd, plt_entry[7], loc + 28);
9741
 
9742
          loc = (htab->srelplt2->contents
9743
                 + (plt_index * 3 + 2) * sizeof (Elf32_External_Rela));
9744
 
9745
          /* Emit a relocation for the .got.plt entry.  */
9746
          rel.r_offset = got_address;
9747
          rel.r_info = ELF32_R_INFO (htab->root.hplt->indx, R_MIPS_32);
9748
          rel.r_addend = h->plt.offset;
9749
          bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
9750
 
9751
          /* Emit a relocation for the lui of %hi(<.got.plt slot>).  */
9752
          loc += sizeof (Elf32_External_Rela);
9753
          rel.r_offset = plt_address + 8;
9754
          rel.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_MIPS_HI16);
9755
          rel.r_addend = got_offset;
9756
          bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
9757
 
9758
          /* Emit a relocation for the addiu of %lo(<.got.plt slot>).  */
9759
          loc += sizeof (Elf32_External_Rela);
9760
          rel.r_offset += 4;
9761
          rel.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_MIPS_LO16);
9762
          bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
9763
        }
9764
 
9765
      /* Emit an R_MIPS_JUMP_SLOT relocation against the .got.plt entry.  */
9766
      loc = htab->srelplt->contents + plt_index * sizeof (Elf32_External_Rela);
9767
      rel.r_offset = got_address;
9768
      rel.r_info = ELF32_R_INFO (h->dynindx, R_MIPS_JUMP_SLOT);
9769
      rel.r_addend = 0;
9770
      bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
9771
 
9772
      if (!h->def_regular)
9773
        sym->st_shndx = SHN_UNDEF;
9774
    }
9775
 
9776
  BFD_ASSERT (h->dynindx != -1 || h->forced_local);
9777
 
9778 225 jeremybenn
  sgot = htab->sgot;
9779
  g = htab->got_info;
9780 24 jeremybenn
  BFD_ASSERT (g != NULL);
9781
 
9782
  /* See if this symbol has an entry in the GOT.  */
9783
  if (g->global_gotsym != NULL
9784
      && h->dynindx >= g->global_gotsym->dynindx)
9785
    {
9786
      bfd_vma offset;
9787
      Elf_Internal_Rela outrel;
9788
      bfd_byte *loc;
9789
      asection *s;
9790
 
9791
      /* Install the symbol value in the GOT.   */
9792
      offset = mips_elf_global_got_index (dynobj, output_bfd, h,
9793
                                          R_MIPS_GOT16, info);
9794
      MIPS_ELF_PUT_WORD (output_bfd, sym->st_value, sgot->contents + offset);
9795
 
9796
      /* Add a dynamic relocation for it.  */
9797
      s = mips_elf_rel_dyn_section (info, FALSE);
9798
      loc = s->contents + (s->reloc_count++ * sizeof (Elf32_External_Rela));
9799
      outrel.r_offset = (sgot->output_section->vma
9800
                         + sgot->output_offset
9801
                         + offset);
9802
      outrel.r_info = ELF32_R_INFO (h->dynindx, R_MIPS_32);
9803
      outrel.r_addend = 0;
9804
      bfd_elf32_swap_reloca_out (dynobj, &outrel, loc);
9805
    }
9806
 
9807
  /* Emit a copy reloc, if needed.  */
9808
  if (h->needs_copy)
9809
    {
9810
      Elf_Internal_Rela rel;
9811
 
9812
      BFD_ASSERT (h->dynindx != -1);
9813
 
9814
      rel.r_offset = (h->root.u.def.section->output_section->vma
9815
                      + h->root.u.def.section->output_offset
9816
                      + h->root.u.def.value);
9817
      rel.r_info = ELF32_R_INFO (h->dynindx, R_MIPS_COPY);
9818
      rel.r_addend = 0;
9819
      bfd_elf32_swap_reloca_out (output_bfd, &rel,
9820
                                 htab->srelbss->contents
9821
                                 + (htab->srelbss->reloc_count
9822
                                    * sizeof (Elf32_External_Rela)));
9823
      ++htab->srelbss->reloc_count;
9824
    }
9825
 
9826
  /* If this is a mips16 symbol, force the value to be even.  */
9827 225 jeremybenn
  if (ELF_ST_IS_MIPS16 (sym->st_other))
9828 24 jeremybenn
    sym->st_value &= ~1;
9829
 
9830
  return TRUE;
9831
}
9832
 
9833 225 jeremybenn
/* Write out a plt0 entry to the beginning of .plt.  */
9834
 
9835
static void
9836
mips_finish_exec_plt (bfd *output_bfd, struct bfd_link_info *info)
9837
{
9838
  bfd_byte *loc;
9839
  bfd_vma gotplt_value, gotplt_value_high, gotplt_value_low;
9840
  static const bfd_vma *plt_entry;
9841
  struct mips_elf_link_hash_table *htab;
9842
 
9843
  htab = mips_elf_hash_table (info);
9844
  if (ABI_64_P (output_bfd))
9845
    plt_entry = mips_n64_exec_plt0_entry;
9846
  else if (ABI_N32_P (output_bfd))
9847
    plt_entry = mips_n32_exec_plt0_entry;
9848
  else
9849
    plt_entry = mips_o32_exec_plt0_entry;
9850
 
9851
  /* Calculate the value of .got.plt.  */
9852
  gotplt_value = (htab->sgotplt->output_section->vma
9853
                  + htab->sgotplt->output_offset);
9854
  gotplt_value_high = ((gotplt_value + 0x8000) >> 16) & 0xffff;
9855
  gotplt_value_low = gotplt_value & 0xffff;
9856
 
9857
  /* The PLT sequence is not safe for N64 if .got.plt's address can
9858
     not be loaded in two instructions.  */
9859
  BFD_ASSERT ((gotplt_value & ~(bfd_vma) 0x7fffffff) == 0
9860
              || ~(gotplt_value | 0x7fffffff) == 0);
9861
 
9862
  /* Install the PLT header.  */
9863
  loc = htab->splt->contents;
9864
  bfd_put_32 (output_bfd, plt_entry[0] | gotplt_value_high, loc);
9865
  bfd_put_32 (output_bfd, plt_entry[1] | gotplt_value_low, loc + 4);
9866
  bfd_put_32 (output_bfd, plt_entry[2] | gotplt_value_low, loc + 8);
9867
  bfd_put_32 (output_bfd, plt_entry[3], loc + 12);
9868
  bfd_put_32 (output_bfd, plt_entry[4], loc + 16);
9869
  bfd_put_32 (output_bfd, plt_entry[5], loc + 20);
9870
  bfd_put_32 (output_bfd, plt_entry[6], loc + 24);
9871
  bfd_put_32 (output_bfd, plt_entry[7], loc + 28);
9872
}
9873
 
9874 24 jeremybenn
/* Install the PLT header for a VxWorks executable and finalize the
9875
   contents of .rela.plt.unloaded.  */
9876
 
9877
static void
9878
mips_vxworks_finish_exec_plt (bfd *output_bfd, struct bfd_link_info *info)
9879
{
9880
  Elf_Internal_Rela rela;
9881
  bfd_byte *loc;
9882
  bfd_vma got_value, got_value_high, got_value_low, plt_address;
9883
  static const bfd_vma *plt_entry;
9884
  struct mips_elf_link_hash_table *htab;
9885
 
9886
  htab = mips_elf_hash_table (info);
9887
  plt_entry = mips_vxworks_exec_plt0_entry;
9888
 
9889
  /* Calculate the value of _GLOBAL_OFFSET_TABLE_.  */
9890
  got_value = (htab->root.hgot->root.u.def.section->output_section->vma
9891
               + htab->root.hgot->root.u.def.section->output_offset
9892
               + htab->root.hgot->root.u.def.value);
9893
 
9894
  got_value_high = ((got_value + 0x8000) >> 16) & 0xffff;
9895
  got_value_low = got_value & 0xffff;
9896
 
9897
  /* Calculate the address of the PLT header.  */
9898
  plt_address = htab->splt->output_section->vma + htab->splt->output_offset;
9899
 
9900
  /* Install the PLT header.  */
9901
  loc = htab->splt->contents;
9902
  bfd_put_32 (output_bfd, plt_entry[0] | got_value_high, loc);
9903
  bfd_put_32 (output_bfd, plt_entry[1] | got_value_low, loc + 4);
9904
  bfd_put_32 (output_bfd, plt_entry[2], loc + 8);
9905
  bfd_put_32 (output_bfd, plt_entry[3], loc + 12);
9906
  bfd_put_32 (output_bfd, plt_entry[4], loc + 16);
9907
  bfd_put_32 (output_bfd, plt_entry[5], loc + 20);
9908
 
9909
  /* Output the relocation for the lui of %hi(_GLOBAL_OFFSET_TABLE_).  */
9910
  loc = htab->srelplt2->contents;
9911
  rela.r_offset = plt_address;
9912
  rela.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_MIPS_HI16);
9913
  rela.r_addend = 0;
9914
  bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
9915
  loc += sizeof (Elf32_External_Rela);
9916
 
9917
  /* Output the relocation for the following addiu of
9918
     %lo(_GLOBAL_OFFSET_TABLE_).  */
9919
  rela.r_offset += 4;
9920
  rela.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_MIPS_LO16);
9921
  bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
9922
  loc += sizeof (Elf32_External_Rela);
9923
 
9924
  /* Fix up the remaining relocations.  They may have the wrong
9925
     symbol index for _G_O_T_ or _P_L_T_ depending on the order
9926
     in which symbols were output.  */
9927
  while (loc < htab->srelplt2->contents + htab->srelplt2->size)
9928
    {
9929
      Elf_Internal_Rela rel;
9930
 
9931
      bfd_elf32_swap_reloca_in (output_bfd, loc, &rel);
9932
      rel.r_info = ELF32_R_INFO (htab->root.hplt->indx, R_MIPS_32);
9933
      bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
9934
      loc += sizeof (Elf32_External_Rela);
9935
 
9936
      bfd_elf32_swap_reloca_in (output_bfd, loc, &rel);
9937
      rel.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_MIPS_HI16);
9938
      bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
9939
      loc += sizeof (Elf32_External_Rela);
9940
 
9941
      bfd_elf32_swap_reloca_in (output_bfd, loc, &rel);
9942
      rel.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_MIPS_LO16);
9943
      bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
9944
      loc += sizeof (Elf32_External_Rela);
9945
    }
9946
}
9947
 
9948
/* Install the PLT header for a VxWorks shared library.  */
9949
 
9950
static void
9951
mips_vxworks_finish_shared_plt (bfd *output_bfd, struct bfd_link_info *info)
9952
{
9953
  unsigned int i;
9954
  struct mips_elf_link_hash_table *htab;
9955
 
9956
  htab = mips_elf_hash_table (info);
9957
 
9958
  /* We just need to copy the entry byte-by-byte.  */
9959
  for (i = 0; i < ARRAY_SIZE (mips_vxworks_shared_plt0_entry); i++)
9960
    bfd_put_32 (output_bfd, mips_vxworks_shared_plt0_entry[i],
9961
                htab->splt->contents + i * 4);
9962
}
9963
 
9964
/* Finish up the dynamic sections.  */
9965
 
9966
bfd_boolean
9967
_bfd_mips_elf_finish_dynamic_sections (bfd *output_bfd,
9968
                                       struct bfd_link_info *info)
9969
{
9970
  bfd *dynobj;
9971
  asection *sdyn;
9972
  asection *sgot;
9973
  struct mips_got_info *gg, *g;
9974
  struct mips_elf_link_hash_table *htab;
9975
 
9976
  htab = mips_elf_hash_table (info);
9977
  dynobj = elf_hash_table (info)->dynobj;
9978
 
9979
  sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
9980
 
9981 225 jeremybenn
  sgot = htab->sgot;
9982
  gg = htab->got_info;
9983 24 jeremybenn
 
9984
  if (elf_hash_table (info)->dynamic_sections_created)
9985
    {
9986
      bfd_byte *b;
9987
      int dyn_to_skip = 0, dyn_skipped = 0;
9988
 
9989
      BFD_ASSERT (sdyn != NULL);
9990 225 jeremybenn
      BFD_ASSERT (gg != NULL);
9991
 
9992
      g = mips_elf_got_for_ibfd (gg, output_bfd);
9993 24 jeremybenn
      BFD_ASSERT (g != NULL);
9994
 
9995
      for (b = sdyn->contents;
9996
           b < sdyn->contents + sdyn->size;
9997
           b += MIPS_ELF_DYN_SIZE (dynobj))
9998
        {
9999
          Elf_Internal_Dyn dyn;
10000
          const char *name;
10001
          size_t elemsize;
10002
          asection *s;
10003
          bfd_boolean swap_out_p;
10004
 
10005
          /* Read in the current dynamic entry.  */
10006
          (*get_elf_backend_data (dynobj)->s->swap_dyn_in) (dynobj, b, &dyn);
10007
 
10008
          /* Assume that we're going to modify it and write it out.  */
10009
          swap_out_p = TRUE;
10010
 
10011
          switch (dyn.d_tag)
10012
            {
10013
            case DT_RELENT:
10014
              dyn.d_un.d_val = MIPS_ELF_REL_SIZE (dynobj);
10015
              break;
10016
 
10017
            case DT_RELAENT:
10018
              BFD_ASSERT (htab->is_vxworks);
10019
              dyn.d_un.d_val = MIPS_ELF_RELA_SIZE (dynobj);
10020
              break;
10021
 
10022
            case DT_STRSZ:
10023
              /* Rewrite DT_STRSZ.  */
10024
              dyn.d_un.d_val =
10025
                _bfd_elf_strtab_size (elf_hash_table (info)->dynstr);
10026
              break;
10027
 
10028
            case DT_PLTGOT:
10029 225 jeremybenn
              s = htab->sgot;
10030
              dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
10031 24 jeremybenn
              break;
10032
 
10033 225 jeremybenn
            case DT_MIPS_PLTGOT:
10034
              s = htab->sgotplt;
10035
              dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
10036
              break;
10037
 
10038 24 jeremybenn
            case DT_MIPS_RLD_VERSION:
10039
              dyn.d_un.d_val = 1; /* XXX */
10040
              break;
10041
 
10042
            case DT_MIPS_FLAGS:
10043
              dyn.d_un.d_val = RHF_NOTPOT; /* XXX */
10044
              break;
10045
 
10046
            case DT_MIPS_TIME_STAMP:
10047
              {
10048
                time_t t;
10049
                time (&t);
10050
                dyn.d_un.d_val = t;
10051
              }
10052
              break;
10053
 
10054
            case DT_MIPS_ICHECKSUM:
10055
              /* XXX FIXME: */
10056
              swap_out_p = FALSE;
10057
              break;
10058
 
10059
            case DT_MIPS_IVERSION:
10060
              /* XXX FIXME: */
10061
              swap_out_p = FALSE;
10062
              break;
10063
 
10064
            case DT_MIPS_BASE_ADDRESS:
10065
              s = output_bfd->sections;
10066
              BFD_ASSERT (s != NULL);
10067
              dyn.d_un.d_ptr = s->vma & ~(bfd_vma) 0xffff;
10068
              break;
10069
 
10070
            case DT_MIPS_LOCAL_GOTNO:
10071
              dyn.d_un.d_val = g->local_gotno;
10072
              break;
10073
 
10074
            case DT_MIPS_UNREFEXTNO:
10075
              /* The index into the dynamic symbol table which is the
10076
                 entry of the first external symbol that is not
10077
                 referenced within the same object.  */
10078
              dyn.d_un.d_val = bfd_count_sections (output_bfd) + 1;
10079
              break;
10080
 
10081
            case DT_MIPS_GOTSYM:
10082
              if (gg->global_gotsym)
10083
                {
10084
                  dyn.d_un.d_val = gg->global_gotsym->dynindx;
10085
                  break;
10086
                }
10087
              /* In case if we don't have global got symbols we default
10088
                 to setting DT_MIPS_GOTSYM to the same value as
10089
                 DT_MIPS_SYMTABNO, so we just fall through.  */
10090
 
10091
            case DT_MIPS_SYMTABNO:
10092
              name = ".dynsym";
10093
              elemsize = MIPS_ELF_SYM_SIZE (output_bfd);
10094
              s = bfd_get_section_by_name (output_bfd, name);
10095
              BFD_ASSERT (s != NULL);
10096
 
10097
              dyn.d_un.d_val = s->size / elemsize;
10098
              break;
10099
 
10100
            case DT_MIPS_HIPAGENO:
10101 225 jeremybenn
              dyn.d_un.d_val = g->local_gotno - htab->reserved_gotno;
10102 24 jeremybenn
              break;
10103
 
10104
            case DT_MIPS_RLD_MAP:
10105
              dyn.d_un.d_ptr = mips_elf_hash_table (info)->rld_value;
10106
              break;
10107
 
10108
            case DT_MIPS_OPTIONS:
10109
              s = (bfd_get_section_by_name
10110
                   (output_bfd, MIPS_ELF_OPTIONS_SECTION_NAME (output_bfd)));
10111
              dyn.d_un.d_ptr = s->vma;
10112
              break;
10113
 
10114
            case DT_RELASZ:
10115
              BFD_ASSERT (htab->is_vxworks);
10116
              /* The count does not include the JUMP_SLOT relocations.  */
10117
              if (htab->srelplt)
10118
                dyn.d_un.d_val -= htab->srelplt->size;
10119
              break;
10120
 
10121
            case DT_PLTREL:
10122 225 jeremybenn
              BFD_ASSERT (htab->use_plts_and_copy_relocs);
10123
              if (htab->is_vxworks)
10124
                dyn.d_un.d_val = DT_RELA;
10125
              else
10126
                dyn.d_un.d_val = DT_REL;
10127 24 jeremybenn
              break;
10128
 
10129
            case DT_PLTRELSZ:
10130 225 jeremybenn
              BFD_ASSERT (htab->use_plts_and_copy_relocs);
10131 24 jeremybenn
              dyn.d_un.d_val = htab->srelplt->size;
10132
              break;
10133
 
10134
            case DT_JMPREL:
10135 225 jeremybenn
              BFD_ASSERT (htab->use_plts_and_copy_relocs);
10136
              dyn.d_un.d_ptr = (htab->srelplt->output_section->vma
10137 24 jeremybenn
                                + htab->srelplt->output_offset);
10138
              break;
10139
 
10140
            case DT_TEXTREL:
10141
              /* If we didn't need any text relocations after all, delete
10142
                 the dynamic tag.  */
10143
              if (!(info->flags & DF_TEXTREL))
10144
                {
10145
                  dyn_to_skip = MIPS_ELF_DYN_SIZE (dynobj);
10146
                  swap_out_p = FALSE;
10147
                }
10148
              break;
10149
 
10150
            case DT_FLAGS:
10151
              /* If we didn't need any text relocations after all, clear
10152
                 DF_TEXTREL from DT_FLAGS.  */
10153
              if (!(info->flags & DF_TEXTREL))
10154
                dyn.d_un.d_val &= ~DF_TEXTREL;
10155
              else
10156
                swap_out_p = FALSE;
10157
              break;
10158
 
10159
            default:
10160
              swap_out_p = FALSE;
10161
              if (htab->is_vxworks
10162
                  && elf_vxworks_finish_dynamic_entry (output_bfd, &dyn))
10163
                swap_out_p = TRUE;
10164
              break;
10165
            }
10166
 
10167
          if (swap_out_p || dyn_skipped)
10168
            (*get_elf_backend_data (dynobj)->s->swap_dyn_out)
10169
              (dynobj, &dyn, b - dyn_skipped);
10170
 
10171
          if (dyn_to_skip)
10172
            {
10173
              dyn_skipped += dyn_to_skip;
10174
              dyn_to_skip = 0;
10175
            }
10176
        }
10177
 
10178
      /* Wipe out any trailing entries if we shifted down a dynamic tag.  */
10179
      if (dyn_skipped > 0)
10180
        memset (b - dyn_skipped, 0, dyn_skipped);
10181
    }
10182
 
10183
  if (sgot != NULL && sgot->size > 0
10184
      && !bfd_is_abs_section (sgot->output_section))
10185
    {
10186
      if (htab->is_vxworks)
10187
        {
10188
          /* The first entry of the global offset table points to the
10189
             ".dynamic" section.  The second is initialized by the
10190
             loader and contains the shared library identifier.
10191
             The third is also initialized by the loader and points
10192
             to the lazy resolution stub.  */
10193
          MIPS_ELF_PUT_WORD (output_bfd,
10194
                             sdyn->output_offset + sdyn->output_section->vma,
10195
                             sgot->contents);
10196
          MIPS_ELF_PUT_WORD (output_bfd, 0,
10197
                             sgot->contents + MIPS_ELF_GOT_SIZE (output_bfd));
10198
          MIPS_ELF_PUT_WORD (output_bfd, 0,
10199
                             sgot->contents
10200
                             + 2 * MIPS_ELF_GOT_SIZE (output_bfd));
10201
        }
10202
      else
10203
        {
10204
          /* The first entry of the global offset table will be filled at
10205
             runtime. The second entry will be used by some runtime loaders.
10206
             This isn't the case of IRIX rld.  */
10207
          MIPS_ELF_PUT_WORD (output_bfd, (bfd_vma) 0, sgot->contents);
10208 225 jeremybenn
          MIPS_ELF_PUT_WORD (output_bfd, MIPS_ELF_GNU_GOT1_MASK (output_bfd),
10209 24 jeremybenn
                             sgot->contents + MIPS_ELF_GOT_SIZE (output_bfd));
10210
        }
10211
 
10212
      elf_section_data (sgot->output_section)->this_hdr.sh_entsize
10213
         = MIPS_ELF_GOT_SIZE (output_bfd);
10214
    }
10215
 
10216
  /* Generate dynamic relocations for the non-primary gots.  */
10217
  if (gg != NULL && gg->next)
10218
    {
10219
      Elf_Internal_Rela rel[3];
10220
      bfd_vma addend = 0;
10221
 
10222
      memset (rel, 0, sizeof (rel));
10223
      rel[0].r_info = ELF_R_INFO (output_bfd, 0, R_MIPS_REL32);
10224
 
10225
      for (g = gg->next; g->next != gg; g = g->next)
10226
        {
10227
          bfd_vma index = g->next->local_gotno + g->next->global_gotno
10228
            + g->next->tls_gotno;
10229
 
10230
          MIPS_ELF_PUT_WORD (output_bfd, 0, sgot->contents
10231
                             + index++ * MIPS_ELF_GOT_SIZE (output_bfd));
10232 225 jeremybenn
          MIPS_ELF_PUT_WORD (output_bfd, MIPS_ELF_GNU_GOT1_MASK (output_bfd),
10233
                             sgot->contents
10234 24 jeremybenn
                             + index++ * MIPS_ELF_GOT_SIZE (output_bfd));
10235
 
10236
          if (! info->shared)
10237
            continue;
10238
 
10239
          while (index < g->assigned_gotno)
10240
            {
10241
              rel[0].r_offset = rel[1].r_offset = rel[2].r_offset
10242
                = index++ * MIPS_ELF_GOT_SIZE (output_bfd);
10243
              if (!(mips_elf_create_dynamic_relocation
10244
                    (output_bfd, info, rel, NULL,
10245
                     bfd_abs_section_ptr,
10246
                     0, &addend, sgot)))
10247
                return FALSE;
10248
              BFD_ASSERT (addend == 0);
10249
            }
10250
        }
10251
    }
10252
 
10253
  /* The generation of dynamic relocations for the non-primary gots
10254
     adds more dynamic relocations.  We cannot count them until
10255
     here.  */
10256
 
10257
  if (elf_hash_table (info)->dynamic_sections_created)
10258
    {
10259
      bfd_byte *b;
10260
      bfd_boolean swap_out_p;
10261
 
10262
      BFD_ASSERT (sdyn != NULL);
10263
 
10264
      for (b = sdyn->contents;
10265
           b < sdyn->contents + sdyn->size;
10266
           b += MIPS_ELF_DYN_SIZE (dynobj))
10267
        {
10268
          Elf_Internal_Dyn dyn;
10269
          asection *s;
10270
 
10271
          /* Read in the current dynamic entry.  */
10272
          (*get_elf_backend_data (dynobj)->s->swap_dyn_in) (dynobj, b, &dyn);
10273
 
10274
          /* Assume that we're going to modify it and write it out.  */
10275
          swap_out_p = TRUE;
10276
 
10277
          switch (dyn.d_tag)
10278
            {
10279
            case DT_RELSZ:
10280
              /* Reduce DT_RELSZ to account for any relocations we
10281
                 decided not to make.  This is for the n64 irix rld,
10282
                 which doesn't seem to apply any relocations if there
10283
                 are trailing null entries.  */
10284
              s = mips_elf_rel_dyn_section (info, FALSE);
10285
              dyn.d_un.d_val = (s->reloc_count
10286
                                * (ABI_64_P (output_bfd)
10287
                                   ? sizeof (Elf64_Mips_External_Rel)
10288
                                   : sizeof (Elf32_External_Rel)));
10289
              /* Adjust the section size too.  Tools like the prelinker
10290
                 can reasonably expect the values to the same.  */
10291
              elf_section_data (s->output_section)->this_hdr.sh_size
10292
                = dyn.d_un.d_val;
10293
              break;
10294
 
10295
            default:
10296
              swap_out_p = FALSE;
10297
              break;
10298
            }
10299
 
10300
          if (swap_out_p)
10301
            (*get_elf_backend_data (dynobj)->s->swap_dyn_out)
10302
              (dynobj, &dyn, b);
10303
        }
10304
    }
10305
 
10306
  {
10307
    asection *s;
10308
    Elf32_compact_rel cpt;
10309
 
10310
    if (SGI_COMPAT (output_bfd))
10311
      {
10312
        /* Write .compact_rel section out.  */
10313
        s = bfd_get_section_by_name (dynobj, ".compact_rel");
10314
        if (s != NULL)
10315
          {
10316
            cpt.id1 = 1;
10317
            cpt.num = s->reloc_count;
10318
            cpt.id2 = 2;
10319
            cpt.offset = (s->output_section->filepos
10320
                          + sizeof (Elf32_External_compact_rel));
10321
            cpt.reserved0 = 0;
10322
            cpt.reserved1 = 0;
10323
            bfd_elf32_swap_compact_rel_out (output_bfd, &cpt,
10324
                                            ((Elf32_External_compact_rel *)
10325
                                             s->contents));
10326
 
10327
            /* Clean up a dummy stub function entry in .text.  */
10328 225 jeremybenn
            if (htab->sstubs != NULL)
10329 24 jeremybenn
              {
10330
                file_ptr dummy_offset;
10331
 
10332 225 jeremybenn
                BFD_ASSERT (htab->sstubs->size >= htab->function_stub_size);
10333
                dummy_offset = htab->sstubs->size - htab->function_stub_size;
10334
                memset (htab->sstubs->contents + dummy_offset, 0,
10335 24 jeremybenn
                        htab->function_stub_size);
10336
              }
10337
          }
10338
      }
10339
 
10340
    /* The psABI says that the dynamic relocations must be sorted in
10341
       increasing order of r_symndx.  The VxWorks EABI doesn't require
10342
       this, and because the code below handles REL rather than RELA
10343
       relocations, using it for VxWorks would be outright harmful.  */
10344
    if (!htab->is_vxworks)
10345
      {
10346
        s = mips_elf_rel_dyn_section (info, FALSE);
10347
        if (s != NULL
10348
            && s->size > (bfd_vma)2 * MIPS_ELF_REL_SIZE (output_bfd))
10349
          {
10350
            reldyn_sorting_bfd = output_bfd;
10351
 
10352
            if (ABI_64_P (output_bfd))
10353
              qsort ((Elf64_External_Rel *) s->contents + 1,
10354
                     s->reloc_count - 1, sizeof (Elf64_Mips_External_Rel),
10355
                     sort_dynamic_relocs_64);
10356
            else
10357
              qsort ((Elf32_External_Rel *) s->contents + 1,
10358
                     s->reloc_count - 1, sizeof (Elf32_External_Rel),
10359
                     sort_dynamic_relocs);
10360
          }
10361
      }
10362
  }
10363
 
10364 225 jeremybenn
  if (htab->splt && htab->splt->size > 0)
10365 24 jeremybenn
    {
10366 225 jeremybenn
      if (htab->is_vxworks)
10367
        {
10368
          if (info->shared)
10369
            mips_vxworks_finish_shared_plt (output_bfd, info);
10370
          else
10371
            mips_vxworks_finish_exec_plt (output_bfd, info);
10372
        }
10373 24 jeremybenn
      else
10374 225 jeremybenn
        {
10375
          BFD_ASSERT (!info->shared);
10376
          mips_finish_exec_plt (output_bfd, info);
10377
        }
10378 24 jeremybenn
    }
10379
  return TRUE;
10380
}
10381
 
10382
 
10383
/* Set ABFD's EF_MIPS_ARCH and EF_MIPS_MACH flags.  */
10384
 
10385
static void
10386
mips_set_isa_flags (bfd *abfd)
10387
{
10388
  flagword val;
10389
 
10390
  switch (bfd_get_mach (abfd))
10391
    {
10392
    default:
10393
    case bfd_mach_mips3000:
10394
      val = E_MIPS_ARCH_1;
10395
      break;
10396
 
10397
    case bfd_mach_mips3900:
10398
      val = E_MIPS_ARCH_1 | E_MIPS_MACH_3900;
10399
      break;
10400
 
10401
    case bfd_mach_mips6000:
10402
      val = E_MIPS_ARCH_2;
10403
      break;
10404
 
10405
    case bfd_mach_mips4000:
10406
    case bfd_mach_mips4300:
10407
    case bfd_mach_mips4400:
10408
    case bfd_mach_mips4600:
10409
      val = E_MIPS_ARCH_3;
10410
      break;
10411
 
10412
    case bfd_mach_mips4010:
10413
      val = E_MIPS_ARCH_3 | E_MIPS_MACH_4010;
10414
      break;
10415
 
10416
    case bfd_mach_mips4100:
10417
      val = E_MIPS_ARCH_3 | E_MIPS_MACH_4100;
10418
      break;
10419
 
10420
    case bfd_mach_mips4111:
10421
      val = E_MIPS_ARCH_3 | E_MIPS_MACH_4111;
10422
      break;
10423
 
10424
    case bfd_mach_mips4120:
10425
      val = E_MIPS_ARCH_3 | E_MIPS_MACH_4120;
10426
      break;
10427
 
10428
    case bfd_mach_mips4650:
10429
      val = E_MIPS_ARCH_3 | E_MIPS_MACH_4650;
10430
      break;
10431
 
10432
    case bfd_mach_mips5400:
10433
      val = E_MIPS_ARCH_4 | E_MIPS_MACH_5400;
10434
      break;
10435
 
10436
    case bfd_mach_mips5500:
10437
      val = E_MIPS_ARCH_4 | E_MIPS_MACH_5500;
10438
      break;
10439
 
10440
    case bfd_mach_mips9000:
10441
      val = E_MIPS_ARCH_4 | E_MIPS_MACH_9000;
10442
      break;
10443
 
10444
    case bfd_mach_mips5000:
10445
    case bfd_mach_mips7000:
10446
    case bfd_mach_mips8000:
10447
    case bfd_mach_mips10000:
10448
    case bfd_mach_mips12000:
10449 225 jeremybenn
    case bfd_mach_mips14000:
10450
    case bfd_mach_mips16000:
10451 24 jeremybenn
      val = E_MIPS_ARCH_4;
10452
      break;
10453
 
10454
    case bfd_mach_mips5:
10455
      val = E_MIPS_ARCH_5;
10456
      break;
10457
 
10458
    case bfd_mach_mips_loongson_2e:
10459
      val = E_MIPS_ARCH_3 | E_MIPS_MACH_LS2E;
10460
      break;
10461
 
10462
    case bfd_mach_mips_loongson_2f:
10463
      val = E_MIPS_ARCH_3 | E_MIPS_MACH_LS2F;
10464
      break;
10465
 
10466
    case bfd_mach_mips_sb1:
10467
      val = E_MIPS_ARCH_64 | E_MIPS_MACH_SB1;
10468
      break;
10469
 
10470
    case bfd_mach_mips_octeon:
10471
      val = E_MIPS_ARCH_64R2 | E_MIPS_MACH_OCTEON;
10472
      break;
10473
 
10474 225 jeremybenn
    case bfd_mach_mips_xlr:
10475
      val = E_MIPS_ARCH_64 | E_MIPS_MACH_XLR;
10476
      break;
10477
 
10478 24 jeremybenn
    case bfd_mach_mipsisa32:
10479
      val = E_MIPS_ARCH_32;
10480
      break;
10481
 
10482
    case bfd_mach_mipsisa64:
10483
      val = E_MIPS_ARCH_64;
10484
      break;
10485
 
10486
    case bfd_mach_mipsisa32r2:
10487
      val = E_MIPS_ARCH_32R2;
10488
      break;
10489
 
10490
    case bfd_mach_mipsisa64r2:
10491
      val = E_MIPS_ARCH_64R2;
10492
      break;
10493
    }
10494
  elf_elfheader (abfd)->e_flags &= ~(EF_MIPS_ARCH | EF_MIPS_MACH);
10495
  elf_elfheader (abfd)->e_flags |= val;
10496
 
10497
}
10498
 
10499
 
10500
/* The final processing done just before writing out a MIPS ELF object
10501
   file.  This gets the MIPS architecture right based on the machine
10502
   number.  This is used by both the 32-bit and the 64-bit ABI.  */
10503
 
10504
void
10505
_bfd_mips_elf_final_write_processing (bfd *abfd,
10506
                                      bfd_boolean linker ATTRIBUTE_UNUSED)
10507
{
10508
  unsigned int i;
10509
  Elf_Internal_Shdr **hdrpp;
10510
  const char *name;
10511
  asection *sec;
10512
 
10513
  /* Keep the existing EF_MIPS_MACH and EF_MIPS_ARCH flags if the former
10514
     is nonzero.  This is for compatibility with old objects, which used
10515
     a combination of a 32-bit EF_MIPS_ARCH and a 64-bit EF_MIPS_MACH.  */
10516
  if ((elf_elfheader (abfd)->e_flags & EF_MIPS_MACH) == 0)
10517
    mips_set_isa_flags (abfd);
10518
 
10519
  /* Set the sh_info field for .gptab sections and other appropriate
10520
     info for each special section.  */
10521
  for (i = 1, hdrpp = elf_elfsections (abfd) + 1;
10522
       i < elf_numsections (abfd);
10523
       i++, hdrpp++)
10524
    {
10525
      switch ((*hdrpp)->sh_type)
10526
        {
10527
        case SHT_MIPS_MSYM:
10528
        case SHT_MIPS_LIBLIST:
10529
          sec = bfd_get_section_by_name (abfd, ".dynstr");
10530
          if (sec != NULL)
10531
            (*hdrpp)->sh_link = elf_section_data (sec)->this_idx;
10532
          break;
10533
 
10534
        case SHT_MIPS_GPTAB:
10535
          BFD_ASSERT ((*hdrpp)->bfd_section != NULL);
10536
          name = bfd_get_section_name (abfd, (*hdrpp)->bfd_section);
10537
          BFD_ASSERT (name != NULL
10538
                      && CONST_STRNEQ (name, ".gptab."));
10539
          sec = bfd_get_section_by_name (abfd, name + sizeof ".gptab" - 1);
10540
          BFD_ASSERT (sec != NULL);
10541
          (*hdrpp)->sh_info = elf_section_data (sec)->this_idx;
10542
          break;
10543
 
10544
        case SHT_MIPS_CONTENT:
10545
          BFD_ASSERT ((*hdrpp)->bfd_section != NULL);
10546
          name = bfd_get_section_name (abfd, (*hdrpp)->bfd_section);
10547
          BFD_ASSERT (name != NULL
10548
                      && CONST_STRNEQ (name, ".MIPS.content"));
10549
          sec = bfd_get_section_by_name (abfd,
10550
                                         name + sizeof ".MIPS.content" - 1);
10551
          BFD_ASSERT (sec != NULL);
10552
          (*hdrpp)->sh_link = elf_section_data (sec)->this_idx;
10553
          break;
10554
 
10555
        case SHT_MIPS_SYMBOL_LIB:
10556
          sec = bfd_get_section_by_name (abfd, ".dynsym");
10557
          if (sec != NULL)
10558
            (*hdrpp)->sh_link = elf_section_data (sec)->this_idx;
10559
          sec = bfd_get_section_by_name (abfd, ".liblist");
10560
          if (sec != NULL)
10561
            (*hdrpp)->sh_info = elf_section_data (sec)->this_idx;
10562
          break;
10563
 
10564
        case SHT_MIPS_EVENTS:
10565
          BFD_ASSERT ((*hdrpp)->bfd_section != NULL);
10566
          name = bfd_get_section_name (abfd, (*hdrpp)->bfd_section);
10567
          BFD_ASSERT (name != NULL);
10568
          if (CONST_STRNEQ (name, ".MIPS.events"))
10569
            sec = bfd_get_section_by_name (abfd,
10570
                                           name + sizeof ".MIPS.events" - 1);
10571
          else
10572
            {
10573
              BFD_ASSERT (CONST_STRNEQ (name, ".MIPS.post_rel"));
10574
              sec = bfd_get_section_by_name (abfd,
10575
                                             (name
10576
                                              + sizeof ".MIPS.post_rel" - 1));
10577
            }
10578
          BFD_ASSERT (sec != NULL);
10579
          (*hdrpp)->sh_link = elf_section_data (sec)->this_idx;
10580
          break;
10581
 
10582
        }
10583
    }
10584
}
10585
 
10586
/* When creating an IRIX5 executable, we need REGINFO and RTPROC
10587
   segments.  */
10588
 
10589
int
10590
_bfd_mips_elf_additional_program_headers (bfd *abfd,
10591
                                          struct bfd_link_info *info ATTRIBUTE_UNUSED)
10592
{
10593
  asection *s;
10594
  int ret = 0;
10595
 
10596
  /* See if we need a PT_MIPS_REGINFO segment.  */
10597
  s = bfd_get_section_by_name (abfd, ".reginfo");
10598
  if (s && (s->flags & SEC_LOAD))
10599
    ++ret;
10600
 
10601
  /* See if we need a PT_MIPS_OPTIONS segment.  */
10602
  if (IRIX_COMPAT (abfd) == ict_irix6
10603
      && bfd_get_section_by_name (abfd,
10604
                                  MIPS_ELF_OPTIONS_SECTION_NAME (abfd)))
10605
    ++ret;
10606
 
10607
  /* See if we need a PT_MIPS_RTPROC segment.  */
10608
  if (IRIX_COMPAT (abfd) == ict_irix5
10609
      && bfd_get_section_by_name (abfd, ".dynamic")
10610
      && bfd_get_section_by_name (abfd, ".mdebug"))
10611
    ++ret;
10612
 
10613
  /* Allocate a PT_NULL header in dynamic objects.  See
10614
     _bfd_mips_elf_modify_segment_map for details.  */
10615
  if (!SGI_COMPAT (abfd)
10616
      && bfd_get_section_by_name (abfd, ".dynamic"))
10617
    ++ret;
10618
 
10619
  return ret;
10620
}
10621
 
10622
/* Modify the segment map for an IRIX5 executable.  */
10623
 
10624
bfd_boolean
10625
_bfd_mips_elf_modify_segment_map (bfd *abfd,
10626
                                  struct bfd_link_info *info)
10627
{
10628
  asection *s;
10629
  struct elf_segment_map *m, **pm;
10630
  bfd_size_type amt;
10631
 
10632
  /* If there is a .reginfo section, we need a PT_MIPS_REGINFO
10633
     segment.  */
10634
  s = bfd_get_section_by_name (abfd, ".reginfo");
10635
  if (s != NULL && (s->flags & SEC_LOAD) != 0)
10636
    {
10637
      for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
10638
        if (m->p_type == PT_MIPS_REGINFO)
10639
          break;
10640
      if (m == NULL)
10641
        {
10642
          amt = sizeof *m;
10643
          m = bfd_zalloc (abfd, amt);
10644
          if (m == NULL)
10645
            return FALSE;
10646
 
10647
          m->p_type = PT_MIPS_REGINFO;
10648
          m->count = 1;
10649
          m->sections[0] = s;
10650
 
10651
          /* We want to put it after the PHDR and INTERP segments.  */
10652
          pm = &elf_tdata (abfd)->segment_map;
10653
          while (*pm != NULL
10654
                 && ((*pm)->p_type == PT_PHDR
10655
                     || (*pm)->p_type == PT_INTERP))
10656
            pm = &(*pm)->next;
10657
 
10658
          m->next = *pm;
10659
          *pm = m;
10660
        }
10661
    }
10662
 
10663
  /* For IRIX 6, we don't have .mdebug sections, nor does anything but
10664
     .dynamic end up in PT_DYNAMIC.  However, we do have to insert a
10665
     PT_MIPS_OPTIONS segment immediately following the program header
10666
     table.  */
10667
  if (NEWABI_P (abfd)
10668
      /* On non-IRIX6 new abi, we'll have already created a segment
10669
         for this section, so don't create another.  I'm not sure this
10670
         is not also the case for IRIX 6, but I can't test it right
10671
         now.  */
10672
      && IRIX_COMPAT (abfd) == ict_irix6)
10673
    {
10674
      for (s = abfd->sections; s; s = s->next)
10675
        if (elf_section_data (s)->this_hdr.sh_type == SHT_MIPS_OPTIONS)
10676
          break;
10677
 
10678
      if (s)
10679
        {
10680
          struct elf_segment_map *options_segment;
10681
 
10682
          pm = &elf_tdata (abfd)->segment_map;
10683
          while (*pm != NULL
10684
                 && ((*pm)->p_type == PT_PHDR
10685
                     || (*pm)->p_type == PT_INTERP))
10686
            pm = &(*pm)->next;
10687
 
10688
          if (*pm == NULL || (*pm)->p_type != PT_MIPS_OPTIONS)
10689
            {
10690
              amt = sizeof (struct elf_segment_map);
10691
              options_segment = bfd_zalloc (abfd, amt);
10692
              options_segment->next = *pm;
10693
              options_segment->p_type = PT_MIPS_OPTIONS;
10694
              options_segment->p_flags = PF_R;
10695
              options_segment->p_flags_valid = TRUE;
10696
              options_segment->count = 1;
10697
              options_segment->sections[0] = s;
10698
              *pm = options_segment;
10699
            }
10700
        }
10701
    }
10702
  else
10703
    {
10704
      if (IRIX_COMPAT (abfd) == ict_irix5)
10705
        {
10706
          /* If there are .dynamic and .mdebug sections, we make a room
10707
             for the RTPROC header.  FIXME: Rewrite without section names.  */
10708
          if (bfd_get_section_by_name (abfd, ".interp") == NULL
10709
              && bfd_get_section_by_name (abfd, ".dynamic") != NULL
10710
              && bfd_get_section_by_name (abfd, ".mdebug") != NULL)
10711
            {
10712
              for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
10713
                if (m->p_type == PT_MIPS_RTPROC)
10714
                  break;
10715
              if (m == NULL)
10716
                {
10717
                  amt = sizeof *m;
10718
                  m = bfd_zalloc (abfd, amt);
10719
                  if (m == NULL)
10720
                    return FALSE;
10721
 
10722
                  m->p_type = PT_MIPS_RTPROC;
10723
 
10724
                  s = bfd_get_section_by_name (abfd, ".rtproc");
10725
                  if (s == NULL)
10726
                    {
10727
                      m->count = 0;
10728
                      m->p_flags = 0;
10729
                      m->p_flags_valid = 1;
10730
                    }
10731
                  else
10732
                    {
10733
                      m->count = 1;
10734
                      m->sections[0] = s;
10735
                    }
10736
 
10737
                  /* We want to put it after the DYNAMIC segment.  */
10738
                  pm = &elf_tdata (abfd)->segment_map;
10739
                  while (*pm != NULL && (*pm)->p_type != PT_DYNAMIC)
10740
                    pm = &(*pm)->next;
10741
                  if (*pm != NULL)
10742
                    pm = &(*pm)->next;
10743
 
10744
                  m->next = *pm;
10745
                  *pm = m;
10746
                }
10747
            }
10748
        }
10749
      /* On IRIX5, the PT_DYNAMIC segment includes the .dynamic,
10750
         .dynstr, .dynsym, and .hash sections, and everything in
10751
         between.  */
10752
      for (pm = &elf_tdata (abfd)->segment_map; *pm != NULL;
10753
           pm = &(*pm)->next)
10754
        if ((*pm)->p_type == PT_DYNAMIC)
10755
          break;
10756
      m = *pm;
10757
      if (m != NULL && IRIX_COMPAT (abfd) == ict_none)
10758
        {
10759
          /* For a normal mips executable the permissions for the PT_DYNAMIC
10760
             segment are read, write and execute. We do that here since
10761
             the code in elf.c sets only the read permission. This matters
10762
             sometimes for the dynamic linker.  */
10763
          if (bfd_get_section_by_name (abfd, ".dynamic") != NULL)
10764
            {
10765
              m->p_flags = PF_R | PF_W | PF_X;
10766
              m->p_flags_valid = 1;
10767
            }
10768
        }
10769
      /* GNU/Linux binaries do not need the extended PT_DYNAMIC section.
10770
         glibc's dynamic linker has traditionally derived the number of
10771
         tags from the p_filesz field, and sometimes allocates stack
10772
         arrays of that size.  An overly-big PT_DYNAMIC segment can
10773
         be actively harmful in such cases.  Making PT_DYNAMIC contain
10774
         other sections can also make life hard for the prelinker,
10775
         which might move one of the other sections to a different
10776
         PT_LOAD segment.  */
10777
      if (SGI_COMPAT (abfd)
10778
          && m != NULL
10779
          && m->count == 1
10780
          && strcmp (m->sections[0]->name, ".dynamic") == 0)
10781
        {
10782
          static const char *sec_names[] =
10783
          {
10784
            ".dynamic", ".dynstr", ".dynsym", ".hash"
10785
          };
10786
          bfd_vma low, high;
10787
          unsigned int i, c;
10788
          struct elf_segment_map *n;
10789
 
10790
          low = ~(bfd_vma) 0;
10791
          high = 0;
10792
          for (i = 0; i < sizeof sec_names / sizeof sec_names[0]; i++)
10793
            {
10794
              s = bfd_get_section_by_name (abfd, sec_names[i]);
10795
              if (s != NULL && (s->flags & SEC_LOAD) != 0)
10796
                {
10797
                  bfd_size_type sz;
10798
 
10799
                  if (low > s->vma)
10800
                    low = s->vma;
10801
                  sz = s->size;
10802
                  if (high < s->vma + sz)
10803
                    high = s->vma + sz;
10804
                }
10805
            }
10806
 
10807
          c = 0;
10808
          for (s = abfd->sections; s != NULL; s = s->next)
10809
            if ((s->flags & SEC_LOAD) != 0
10810
                && s->vma >= low
10811
                && s->vma + s->size <= high)
10812
              ++c;
10813
 
10814
          amt = sizeof *n + (bfd_size_type) (c - 1) * sizeof (asection *);
10815
          n = bfd_zalloc (abfd, amt);
10816
          if (n == NULL)
10817
            return FALSE;
10818
          *n = *m;
10819
          n->count = c;
10820
 
10821
          i = 0;
10822
          for (s = abfd->sections; s != NULL; s = s->next)
10823
            {
10824
              if ((s->flags & SEC_LOAD) != 0
10825
                  && s->vma >= low
10826
                  && s->vma + s->size <= high)
10827
                {
10828
                  n->sections[i] = s;
10829
                  ++i;
10830
                }
10831
            }
10832
 
10833
          *pm = n;
10834
        }
10835
    }
10836
 
10837
  /* Allocate a spare program header in dynamic objects so that tools
10838
     like the prelinker can add an extra PT_LOAD entry.
10839
 
10840
     If the prelinker needs to make room for a new PT_LOAD entry, its
10841
     standard procedure is to move the first (read-only) sections into
10842
     the new (writable) segment.  However, the MIPS ABI requires
10843
     .dynamic to be in a read-only segment, and the section will often
10844
     start within sizeof (ElfNN_Phdr) bytes of the last program header.
10845
 
10846
     Although the prelinker could in principle move .dynamic to a
10847
     writable segment, it seems better to allocate a spare program
10848
     header instead, and avoid the need to move any sections.
10849
     There is a long tradition of allocating spare dynamic tags,
10850
     so allocating a spare program header seems like a natural
10851
     extension.
10852
 
10853
     If INFO is NULL, we may be copying an already prelinked binary
10854
     with objcopy or strip, so do not add this header.  */
10855
  if (info != NULL
10856
      && !SGI_COMPAT (abfd)
10857
      && bfd_get_section_by_name (abfd, ".dynamic"))
10858
    {
10859
      for (pm = &elf_tdata (abfd)->segment_map; *pm != NULL; pm = &(*pm)->next)
10860
        if ((*pm)->p_type == PT_NULL)
10861
          break;
10862
      if (*pm == NULL)
10863
        {
10864
          m = bfd_zalloc (abfd, sizeof (*m));
10865
          if (m == NULL)
10866
            return FALSE;
10867
 
10868
          m->p_type = PT_NULL;
10869
          *pm = m;
10870
        }
10871
    }
10872
 
10873
  return TRUE;
10874
}
10875
 
10876
/* Return the section that should be marked against GC for a given
10877
   relocation.  */
10878
 
10879
asection *
10880
_bfd_mips_elf_gc_mark_hook (asection *sec,
10881
                            struct bfd_link_info *info,
10882
                            Elf_Internal_Rela *rel,
10883
                            struct elf_link_hash_entry *h,
10884
                            Elf_Internal_Sym *sym)
10885
{
10886
  /* ??? Do mips16 stub sections need to be handled special?  */
10887
 
10888
  if (h != NULL)
10889
    switch (ELF_R_TYPE (sec->owner, rel->r_info))
10890
      {
10891
      case R_MIPS_GNU_VTINHERIT:
10892
      case R_MIPS_GNU_VTENTRY:
10893
        return NULL;
10894
      }
10895
 
10896
  return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
10897
}
10898
 
10899
/* Update the got entry reference counts for the section being removed.  */
10900
 
10901
bfd_boolean
10902
_bfd_mips_elf_gc_sweep_hook (bfd *abfd ATTRIBUTE_UNUSED,
10903
                             struct bfd_link_info *info ATTRIBUTE_UNUSED,
10904
                             asection *sec ATTRIBUTE_UNUSED,
10905
                             const Elf_Internal_Rela *relocs ATTRIBUTE_UNUSED)
10906
{
10907
#if 0
10908
  Elf_Internal_Shdr *symtab_hdr;
10909
  struct elf_link_hash_entry **sym_hashes;
10910
  bfd_signed_vma *local_got_refcounts;
10911
  const Elf_Internal_Rela *rel, *relend;
10912
  unsigned long r_symndx;
10913
  struct elf_link_hash_entry *h;
10914
 
10915
  if (info->relocatable)
10916
    return TRUE;
10917
 
10918
  symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
10919
  sym_hashes = elf_sym_hashes (abfd);
10920
  local_got_refcounts = elf_local_got_refcounts (abfd);
10921
 
10922
  relend = relocs + sec->reloc_count;
10923
  for (rel = relocs; rel < relend; rel++)
10924
    switch (ELF_R_TYPE (abfd, rel->r_info))
10925
      {
10926 225 jeremybenn
      case R_MIPS16_GOT16:
10927
      case R_MIPS16_CALL16:
10928 24 jeremybenn
      case R_MIPS_GOT16:
10929
      case R_MIPS_CALL16:
10930
      case R_MIPS_CALL_HI16:
10931
      case R_MIPS_CALL_LO16:
10932
      case R_MIPS_GOT_HI16:
10933
      case R_MIPS_GOT_LO16:
10934
      case R_MIPS_GOT_DISP:
10935
      case R_MIPS_GOT_PAGE:
10936
      case R_MIPS_GOT_OFST:
10937
        /* ??? It would seem that the existing MIPS code does no sort
10938
           of reference counting or whatnot on its GOT and PLT entries,
10939
           so it is not possible to garbage collect them at this time.  */
10940
        break;
10941
 
10942
      default:
10943
        break;
10944
      }
10945
#endif
10946
 
10947
  return TRUE;
10948
}
10949
 
10950
/* Copy data from a MIPS ELF indirect symbol to its direct symbol,
10951
   hiding the old indirect symbol.  Process additional relocation
10952
   information.  Also called for weakdefs, in which case we just let
10953
   _bfd_elf_link_hash_copy_indirect copy the flags for us.  */
10954
 
10955
void
10956
_bfd_mips_elf_copy_indirect_symbol (struct bfd_link_info *info,
10957
                                    struct elf_link_hash_entry *dir,
10958
                                    struct elf_link_hash_entry *ind)
10959
{
10960
  struct mips_elf_link_hash_entry *dirmips, *indmips;
10961
 
10962
  _bfd_elf_link_hash_copy_indirect (info, dir, ind);
10963
 
10964 225 jeremybenn
  dirmips = (struct mips_elf_link_hash_entry *) dir;
10965
  indmips = (struct mips_elf_link_hash_entry *) ind;
10966
  /* Any absolute non-dynamic relocations against an indirect or weak
10967
     definition will be against the target symbol.  */
10968
  if (indmips->has_static_relocs)
10969
    dirmips->has_static_relocs = TRUE;
10970
 
10971 24 jeremybenn
  if (ind->root.type != bfd_link_hash_indirect)
10972
    return;
10973
 
10974
  dirmips->possibly_dynamic_relocs += indmips->possibly_dynamic_relocs;
10975
  if (indmips->readonly_reloc)
10976
    dirmips->readonly_reloc = TRUE;
10977
  if (indmips->no_fn_stub)
10978
    dirmips->no_fn_stub = TRUE;
10979 225 jeremybenn
  if (indmips->fn_stub)
10980
    {
10981
      dirmips->fn_stub = indmips->fn_stub;
10982
      indmips->fn_stub = NULL;
10983
    }
10984
  if (indmips->need_fn_stub)
10985
    {
10986
      dirmips->need_fn_stub = TRUE;
10987
      indmips->need_fn_stub = FALSE;
10988
    }
10989
  if (indmips->call_stub)
10990
    {
10991
      dirmips->call_stub = indmips->call_stub;
10992
      indmips->call_stub = NULL;
10993
    }
10994
  if (indmips->call_fp_stub)
10995
    {
10996
      dirmips->call_fp_stub = indmips->call_fp_stub;
10997
      indmips->call_fp_stub = NULL;
10998
    }
10999
  if (indmips->global_got_area < dirmips->global_got_area)
11000
    dirmips->global_got_area = indmips->global_got_area;
11001
  if (indmips->global_got_area < GGA_NONE)
11002
    indmips->global_got_area = GGA_NONE;
11003
  if (indmips->has_nonpic_branches)
11004
    dirmips->has_nonpic_branches = TRUE;
11005 24 jeremybenn
 
11006
  if (dirmips->tls_type == 0)
11007
    dirmips->tls_type = indmips->tls_type;
11008
}
11009
 
11010
#define PDR_SIZE 32
11011
 
11012
bfd_boolean
11013
_bfd_mips_elf_discard_info (bfd *abfd, struct elf_reloc_cookie *cookie,
11014
                            struct bfd_link_info *info)
11015
{
11016
  asection *o;
11017
  bfd_boolean ret = FALSE;
11018
  unsigned char *tdata;
11019
  size_t i, skip;
11020
 
11021
  o = bfd_get_section_by_name (abfd, ".pdr");
11022
  if (! o)
11023
    return FALSE;
11024
  if (o->size == 0)
11025
    return FALSE;
11026
  if (o->size % PDR_SIZE != 0)
11027
    return FALSE;
11028
  if (o->output_section != NULL
11029
      && bfd_is_abs_section (o->output_section))
11030
    return FALSE;
11031
 
11032
  tdata = bfd_zmalloc (o->size / PDR_SIZE);
11033
  if (! tdata)
11034
    return FALSE;
11035
 
11036
  cookie->rels = _bfd_elf_link_read_relocs (abfd, o, NULL, NULL,
11037
                                            info->keep_memory);
11038
  if (!cookie->rels)
11039
    {
11040
      free (tdata);
11041
      return FALSE;
11042
    }
11043
 
11044
  cookie->rel = cookie->rels;
11045
  cookie->relend = cookie->rels + o->reloc_count;
11046
 
11047
  for (i = 0, skip = 0; i < o->size / PDR_SIZE; i ++)
11048
    {
11049
      if (bfd_elf_reloc_symbol_deleted_p (i * PDR_SIZE, cookie))
11050
        {
11051
          tdata[i] = 1;
11052
          skip ++;
11053
        }
11054
    }
11055
 
11056
  if (skip != 0)
11057
    {
11058
      mips_elf_section_data (o)->u.tdata = tdata;
11059
      o->size -= skip * PDR_SIZE;
11060
      ret = TRUE;
11061
    }
11062
  else
11063
    free (tdata);
11064
 
11065
  if (! info->keep_memory)
11066
    free (cookie->rels);
11067
 
11068
  return ret;
11069
}
11070
 
11071
bfd_boolean
11072
_bfd_mips_elf_ignore_discarded_relocs (asection *sec)
11073
{
11074
  if (strcmp (sec->name, ".pdr") == 0)
11075
    return TRUE;
11076
  return FALSE;
11077
}
11078
 
11079
bfd_boolean
11080
_bfd_mips_elf_write_section (bfd *output_bfd,
11081
                             struct bfd_link_info *link_info ATTRIBUTE_UNUSED,
11082
                             asection *sec, bfd_byte *contents)
11083
{
11084
  bfd_byte *to, *from, *end;
11085
  int i;
11086
 
11087
  if (strcmp (sec->name, ".pdr") != 0)
11088
    return FALSE;
11089
 
11090
  if (mips_elf_section_data (sec)->u.tdata == NULL)
11091
    return FALSE;
11092
 
11093
  to = contents;
11094
  end = contents + sec->size;
11095
  for (from = contents, i = 0;
11096
       from < end;
11097
       from += PDR_SIZE, i++)
11098
    {
11099
      if ((mips_elf_section_data (sec)->u.tdata)[i] == 1)
11100
        continue;
11101
      if (to != from)
11102
        memcpy (to, from, PDR_SIZE);
11103
      to += PDR_SIZE;
11104
    }
11105
  bfd_set_section_contents (output_bfd, sec->output_section, contents,
11106
                            sec->output_offset, sec->size);
11107
  return TRUE;
11108
}
11109
 
11110
/* MIPS ELF uses a special find_nearest_line routine in order the
11111
   handle the ECOFF debugging information.  */
11112
 
11113
struct mips_elf_find_line
11114
{
11115
  struct ecoff_debug_info d;
11116
  struct ecoff_find_line i;
11117
};
11118
 
11119
bfd_boolean
11120
_bfd_mips_elf_find_nearest_line (bfd *abfd, asection *section,
11121
                                 asymbol **symbols, bfd_vma offset,
11122
                                 const char **filename_ptr,
11123
                                 const char **functionname_ptr,
11124
                                 unsigned int *line_ptr)
11125
{
11126
  asection *msec;
11127
 
11128
  if (_bfd_dwarf1_find_nearest_line (abfd, section, symbols, offset,
11129
                                     filename_ptr, functionname_ptr,
11130
                                     line_ptr))
11131
    return TRUE;
11132
 
11133
  if (_bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset,
11134
                                     filename_ptr, functionname_ptr,
11135
                                     line_ptr, ABI_64_P (abfd) ? 8 : 0,
11136
                                     &elf_tdata (abfd)->dwarf2_find_line_info))
11137
    return TRUE;
11138
 
11139
  msec = bfd_get_section_by_name (abfd, ".mdebug");
11140
  if (msec != NULL)
11141
    {
11142
      flagword origflags;
11143
      struct mips_elf_find_line *fi;
11144
      const struct ecoff_debug_swap * const swap =
11145
        get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
11146
 
11147
      /* If we are called during a link, mips_elf_final_link may have
11148
         cleared the SEC_HAS_CONTENTS field.  We force it back on here
11149
         if appropriate (which it normally will be).  */
11150
      origflags = msec->flags;
11151
      if (elf_section_data (msec)->this_hdr.sh_type != SHT_NOBITS)
11152
        msec->flags |= SEC_HAS_CONTENTS;
11153
 
11154
      fi = elf_tdata (abfd)->find_line_info;
11155
      if (fi == NULL)
11156
        {
11157
          bfd_size_type external_fdr_size;
11158
          char *fraw_src;
11159
          char *fraw_end;
11160
          struct fdr *fdr_ptr;
11161
          bfd_size_type amt = sizeof (struct mips_elf_find_line);
11162
 
11163
          fi = bfd_zalloc (abfd, amt);
11164
          if (fi == NULL)
11165
            {
11166
              msec->flags = origflags;
11167
              return FALSE;
11168
            }
11169
 
11170
          if (! _bfd_mips_elf_read_ecoff_info (abfd, msec, &fi->d))
11171
            {
11172
              msec->flags = origflags;
11173
              return FALSE;
11174
            }
11175
 
11176
          /* Swap in the FDR information.  */
11177
          amt = fi->d.symbolic_header.ifdMax * sizeof (struct fdr);
11178
          fi->d.fdr = bfd_alloc (abfd, amt);
11179
          if (fi->d.fdr == NULL)
11180
            {
11181
              msec->flags = origflags;
11182
              return FALSE;
11183
            }
11184
          external_fdr_size = swap->external_fdr_size;
11185
          fdr_ptr = fi->d.fdr;
11186
          fraw_src = (char *) fi->d.external_fdr;
11187
          fraw_end = (fraw_src
11188
                      + fi->d.symbolic_header.ifdMax * external_fdr_size);
11189
          for (; fraw_src < fraw_end; fraw_src += external_fdr_size, fdr_ptr++)
11190
            (*swap->swap_fdr_in) (abfd, fraw_src, fdr_ptr);
11191
 
11192
          elf_tdata (abfd)->find_line_info = fi;
11193
 
11194
          /* Note that we don't bother to ever free this information.
11195
             find_nearest_line is either called all the time, as in
11196
             objdump -l, so the information should be saved, or it is
11197
             rarely called, as in ld error messages, so the memory
11198
             wasted is unimportant.  Still, it would probably be a
11199
             good idea for free_cached_info to throw it away.  */
11200
        }
11201
 
11202
      if (_bfd_ecoff_locate_line (abfd, section, offset, &fi->d, swap,
11203
                                  &fi->i, filename_ptr, functionname_ptr,
11204
                                  line_ptr))
11205
        {
11206
          msec->flags = origflags;
11207
          return TRUE;
11208
        }
11209
 
11210
      msec->flags = origflags;
11211
    }
11212
 
11213
  /* Fall back on the generic ELF find_nearest_line routine.  */
11214
 
11215
  return _bfd_elf_find_nearest_line (abfd, section, symbols, offset,
11216
                                     filename_ptr, functionname_ptr,
11217
                                     line_ptr);
11218
}
11219
 
11220
bfd_boolean
11221
_bfd_mips_elf_find_inliner_info (bfd *abfd,
11222
                                 const char **filename_ptr,
11223
                                 const char **functionname_ptr,
11224
                                 unsigned int *line_ptr)
11225
{
11226
  bfd_boolean found;
11227
  found = _bfd_dwarf2_find_inliner_info (abfd, filename_ptr,
11228
                                         functionname_ptr, line_ptr,
11229
                                         & elf_tdata (abfd)->dwarf2_find_line_info);
11230
  return found;
11231
}
11232
 
11233
 
11234
/* When are writing out the .options or .MIPS.options section,
11235
   remember the bytes we are writing out, so that we can install the
11236
   GP value in the section_processing routine.  */
11237
 
11238
bfd_boolean
11239
_bfd_mips_elf_set_section_contents (bfd *abfd, sec_ptr section,
11240
                                    const void *location,
11241
                                    file_ptr offset, bfd_size_type count)
11242
{
11243
  if (MIPS_ELF_OPTIONS_SECTION_NAME_P (section->name))
11244
    {
11245
      bfd_byte *c;
11246
 
11247
      if (elf_section_data (section) == NULL)
11248
        {
11249
          bfd_size_type amt = sizeof (struct bfd_elf_section_data);
11250
          section->used_by_bfd = bfd_zalloc (abfd, amt);
11251
          if (elf_section_data (section) == NULL)
11252
            return FALSE;
11253
        }
11254
      c = mips_elf_section_data (section)->u.tdata;
11255
      if (c == NULL)
11256
        {
11257
          c = bfd_zalloc (abfd, section->size);
11258
          if (c == NULL)
11259
            return FALSE;
11260
          mips_elf_section_data (section)->u.tdata = c;
11261
        }
11262
 
11263
      memcpy (c + offset, location, count);
11264
    }
11265
 
11266
  return _bfd_elf_set_section_contents (abfd, section, location, offset,
11267
                                        count);
11268
}
11269
 
11270
/* This is almost identical to bfd_generic_get_... except that some
11271
   MIPS relocations need to be handled specially.  Sigh.  */
11272
 
11273
bfd_byte *
11274
_bfd_elf_mips_get_relocated_section_contents
11275
  (bfd *abfd,
11276
   struct bfd_link_info *link_info,
11277
   struct bfd_link_order *link_order,
11278
   bfd_byte *data,
11279
   bfd_boolean relocatable,
11280
   asymbol **symbols)
11281
{
11282
  /* Get enough memory to hold the stuff */
11283
  bfd *input_bfd = link_order->u.indirect.section->owner;
11284
  asection *input_section = link_order->u.indirect.section;
11285
  bfd_size_type sz;
11286
 
11287
  long reloc_size = bfd_get_reloc_upper_bound (input_bfd, input_section);
11288
  arelent **reloc_vector = NULL;
11289
  long reloc_count;
11290
 
11291
  if (reloc_size < 0)
11292
    goto error_return;
11293
 
11294
  reloc_vector = bfd_malloc (reloc_size);
11295
  if (reloc_vector == NULL && reloc_size != 0)
11296
    goto error_return;
11297
 
11298
  /* read in the section */
11299
  sz = input_section->rawsize ? input_section->rawsize : input_section->size;
11300
  if (!bfd_get_section_contents (input_bfd, input_section, data, 0, sz))
11301
    goto error_return;
11302
 
11303
  reloc_count = bfd_canonicalize_reloc (input_bfd,
11304
                                        input_section,
11305
                                        reloc_vector,
11306
                                        symbols);
11307
  if (reloc_count < 0)
11308
    goto error_return;
11309
 
11310
  if (reloc_count > 0)
11311
    {
11312
      arelent **parent;
11313
      /* for mips */
11314
      int gp_found;
11315
      bfd_vma gp = 0x12345678;  /* initialize just to shut gcc up */
11316
 
11317
      {
11318
        struct bfd_hash_entry *h;
11319
        struct bfd_link_hash_entry *lh;
11320
        /* Skip all this stuff if we aren't mixing formats.  */
11321
        if (abfd && input_bfd
11322
            && abfd->xvec == input_bfd->xvec)
11323
          lh = 0;
11324
        else
11325
          {
11326
            h = bfd_hash_lookup (&link_info->hash->table, "_gp", FALSE, FALSE);
11327
            lh = (struct bfd_link_hash_entry *) h;
11328
          }
11329
      lookup:
11330
        if (lh)
11331
          {
11332
            switch (lh->type)
11333
              {
11334
              case bfd_link_hash_undefined:
11335
              case bfd_link_hash_undefweak:
11336
              case bfd_link_hash_common:
11337
                gp_found = 0;
11338
                break;
11339
              case bfd_link_hash_defined:
11340
              case bfd_link_hash_defweak:
11341
                gp_found = 1;
11342
                gp = lh->u.def.value;
11343
                break;
11344
              case bfd_link_hash_indirect:
11345
              case bfd_link_hash_warning:
11346
                lh = lh->u.i.link;
11347
                /* @@FIXME  ignoring warning for now */
11348
                goto lookup;
11349
              case bfd_link_hash_new:
11350
              default:
11351
                abort ();
11352
              }
11353
          }
11354
        else
11355
          gp_found = 0;
11356
      }
11357
      /* end mips */
11358
      for (parent = reloc_vector; *parent != NULL; parent++)
11359
        {
11360
          char *error_message = NULL;
11361
          bfd_reloc_status_type r;
11362
 
11363
          /* Specific to MIPS: Deal with relocation types that require
11364
             knowing the gp of the output bfd.  */
11365
          asymbol *sym = *(*parent)->sym_ptr_ptr;
11366
 
11367
          /* If we've managed to find the gp and have a special
11368
             function for the relocation then go ahead, else default
11369
             to the generic handling.  */
11370
          if (gp_found
11371
              && (*parent)->howto->special_function
11372
              == _bfd_mips_elf32_gprel16_reloc)
11373
            r = _bfd_mips_elf_gprel16_with_gp (input_bfd, sym, *parent,
11374
                                               input_section, relocatable,
11375
                                               data, gp);
11376
          else
11377
            r = bfd_perform_relocation (input_bfd, *parent, data,
11378
                                        input_section,
11379
                                        relocatable ? abfd : NULL,
11380
                                        &error_message);
11381
 
11382
          if (relocatable)
11383
            {
11384
              asection *os = input_section->output_section;
11385
 
11386
              /* A partial link, so keep the relocs */
11387
              os->orelocation[os->reloc_count] = *parent;
11388
              os->reloc_count++;
11389
            }
11390
 
11391
          if (r != bfd_reloc_ok)
11392
            {
11393
              switch (r)
11394
                {
11395
                case bfd_reloc_undefined:
11396
                  if (!((*link_info->callbacks->undefined_symbol)
11397
                        (link_info, bfd_asymbol_name (*(*parent)->sym_ptr_ptr),
11398
                         input_bfd, input_section, (*parent)->address, TRUE)))
11399
                    goto error_return;
11400
                  break;
11401
                case bfd_reloc_dangerous:
11402
                  BFD_ASSERT (error_message != NULL);
11403
                  if (!((*link_info->callbacks->reloc_dangerous)
11404
                        (link_info, error_message, input_bfd, input_section,
11405
                         (*parent)->address)))
11406
                    goto error_return;
11407
                  break;
11408
                case bfd_reloc_overflow:
11409
                  if (!((*link_info->callbacks->reloc_overflow)
11410
                        (link_info, NULL,
11411
                         bfd_asymbol_name (*(*parent)->sym_ptr_ptr),
11412
                         (*parent)->howto->name, (*parent)->addend,
11413
                         input_bfd, input_section, (*parent)->address)))
11414
                    goto error_return;
11415
                  break;
11416
                case bfd_reloc_outofrange:
11417
                default:
11418
                  abort ();
11419
                  break;
11420
                }
11421
 
11422
            }
11423
        }
11424
    }
11425
  if (reloc_vector != NULL)
11426
    free (reloc_vector);
11427
  return data;
11428
 
11429
error_return:
11430
  if (reloc_vector != NULL)
11431
    free (reloc_vector);
11432
  return NULL;
11433
}
11434
 
11435 225 jeremybenn
/* Allocate ABFD's target-dependent data.  */
11436
 
11437
bfd_boolean
11438
_bfd_mips_elf_mkobject (bfd *abfd)
11439
{
11440
  return bfd_elf_allocate_object (abfd, sizeof (struct elf_obj_tdata),
11441
                                  MIPS_ELF_TDATA);
11442
}
11443
 
11444 24 jeremybenn
/* Create a MIPS ELF linker hash table.  */
11445
 
11446
struct bfd_link_hash_table *
11447
_bfd_mips_elf_link_hash_table_create (bfd *abfd)
11448
{
11449
  struct mips_elf_link_hash_table *ret;
11450
  bfd_size_type amt = sizeof (struct mips_elf_link_hash_table);
11451
 
11452
  ret = bfd_malloc (amt);
11453
  if (ret == NULL)
11454
    return NULL;
11455
 
11456
  if (!_bfd_elf_link_hash_table_init (&ret->root, abfd,
11457
                                      mips_elf_link_hash_newfunc,
11458
                                      sizeof (struct mips_elf_link_hash_entry)))
11459
    {
11460
      free (ret);
11461
      return NULL;
11462
    }
11463
 
11464
#if 0
11465
  /* We no longer use this.  */
11466
  for (i = 0; i < SIZEOF_MIPS_DYNSYM_SECNAMES; i++)
11467
    ret->dynsym_sec_strindex[i] = (bfd_size_type) -1;
11468
#endif
11469
  ret->procedure_count = 0;
11470
  ret->compact_rel_size = 0;
11471
  ret->use_rld_obj_head = FALSE;
11472
  ret->rld_value = 0;
11473
  ret->mips16_stubs_seen = FALSE;
11474 225 jeremybenn
  ret->use_plts_and_copy_relocs = FALSE;
11475 24 jeremybenn
  ret->is_vxworks = FALSE;
11476
  ret->small_data_overflow_reported = FALSE;
11477
  ret->srelbss = NULL;
11478
  ret->sdynbss = NULL;
11479
  ret->srelplt = NULL;
11480
  ret->srelplt2 = NULL;
11481
  ret->sgotplt = NULL;
11482
  ret->splt = NULL;
11483 225 jeremybenn
  ret->sstubs = NULL;
11484
  ret->sgot = NULL;
11485
  ret->got_info = NULL;
11486 24 jeremybenn
  ret->plt_header_size = 0;
11487
  ret->plt_entry_size = 0;
11488 225 jeremybenn
  ret->lazy_stub_count = 0;
11489 24 jeremybenn
  ret->function_stub_size = 0;
11490 225 jeremybenn
  ret->strampoline = NULL;
11491
  ret->la25_stubs = NULL;
11492
  ret->add_stub_section = NULL;
11493 24 jeremybenn
 
11494
  return &ret->root.root;
11495
}
11496
 
11497
/* Likewise, but indicate that the target is VxWorks.  */
11498
 
11499
struct bfd_link_hash_table *
11500
_bfd_mips_vxworks_link_hash_table_create (bfd *abfd)
11501
{
11502
  struct bfd_link_hash_table *ret;
11503
 
11504
  ret = _bfd_mips_elf_link_hash_table_create (abfd);
11505
  if (ret)
11506
    {
11507
      struct mips_elf_link_hash_table *htab;
11508
 
11509
      htab = (struct mips_elf_link_hash_table *) ret;
11510 225 jeremybenn
      htab->use_plts_and_copy_relocs = TRUE;
11511
      htab->is_vxworks = TRUE;
11512 24 jeremybenn
    }
11513
  return ret;
11514
}
11515 225 jeremybenn
 
11516
/* A function that the linker calls if we are allowed to use PLTs
11517
   and copy relocs.  */
11518
 
11519
void
11520
_bfd_mips_elf_use_plts_and_copy_relocs (struct bfd_link_info *info)
11521
{
11522
  mips_elf_hash_table (info)->use_plts_and_copy_relocs = TRUE;
11523
}
11524 24 jeremybenn
 
11525
/* We need to use a special link routine to handle the .reginfo and
11526
   the .mdebug sections.  We need to merge all instances of these
11527
   sections together, not write them all out sequentially.  */
11528
 
11529
bfd_boolean
11530
_bfd_mips_elf_final_link (bfd *abfd, struct bfd_link_info *info)
11531
{
11532
  asection *o;
11533
  struct bfd_link_order *p;
11534
  asection *reginfo_sec, *mdebug_sec, *gptab_data_sec, *gptab_bss_sec;
11535
  asection *rtproc_sec;
11536
  Elf32_RegInfo reginfo;
11537
  struct ecoff_debug_info debug;
11538 225 jeremybenn
  struct mips_htab_traverse_info hti;
11539 24 jeremybenn
  const struct elf_backend_data *bed = get_elf_backend_data (abfd);
11540
  const struct ecoff_debug_swap *swap = bed->elf_backend_ecoff_debug_swap;
11541
  HDRR *symhdr = &debug.symbolic_header;
11542
  void *mdebug_handle = NULL;
11543
  asection *s;
11544
  EXTR esym;
11545
  unsigned int i;
11546
  bfd_size_type amt;
11547
  struct mips_elf_link_hash_table *htab;
11548
 
11549
  static const char * const secname[] =
11550
  {
11551
    ".text", ".init", ".fini", ".data",
11552
    ".rodata", ".sdata", ".sbss", ".bss"
11553
  };
11554
  static const int sc[] =
11555
  {
11556
    scText, scInit, scFini, scData,
11557
    scRData, scSData, scSBss, scBss
11558
  };
11559
 
11560 225 jeremybenn
  /* Sort the dynamic symbols so that those with GOT entries come after
11561
     those without.  */
11562 24 jeremybenn
  htab = mips_elf_hash_table (info);
11563 225 jeremybenn
  if (!mips_elf_sort_hash_table (abfd, info))
11564
    return FALSE;
11565 24 jeremybenn
 
11566 225 jeremybenn
  /* Create any scheduled LA25 stubs.  */
11567
  hti.info = info;
11568
  hti.output_bfd = abfd;
11569
  hti.error = FALSE;
11570
  htab_traverse (htab->la25_stubs, mips_elf_create_la25_stub, &hti);
11571
  if (hti.error)
11572
    return FALSE;
11573 24 jeremybenn
 
11574
  /* Get a value for the GP register.  */
11575
  if (elf_gp (abfd) == 0)
11576
    {
11577
      struct bfd_link_hash_entry *h;
11578
 
11579
      h = bfd_link_hash_lookup (info->hash, "_gp", FALSE, FALSE, TRUE);
11580
      if (h != NULL && h->type == bfd_link_hash_defined)
11581
        elf_gp (abfd) = (h->u.def.value
11582
                         + h->u.def.section->output_section->vma
11583
                         + h->u.def.section->output_offset);
11584
      else if (htab->is_vxworks
11585
               && (h = bfd_link_hash_lookup (info->hash,
11586
                                             "_GLOBAL_OFFSET_TABLE_",
11587
                                             FALSE, FALSE, TRUE))
11588
               && h->type == bfd_link_hash_defined)
11589
        elf_gp (abfd) = (h->u.def.section->output_section->vma
11590
                         + h->u.def.section->output_offset
11591
                         + h->u.def.value);
11592
      else if (info->relocatable)
11593
        {
11594
          bfd_vma lo = MINUS_ONE;
11595
 
11596
          /* Find the GP-relative section with the lowest offset.  */
11597
          for (o = abfd->sections; o != NULL; o = o->next)
11598
            if (o->vma < lo
11599
                && (elf_section_data (o)->this_hdr.sh_flags & SHF_MIPS_GPREL))
11600
              lo = o->vma;
11601
 
11602
          /* And calculate GP relative to that.  */
11603
          elf_gp (abfd) = lo + ELF_MIPS_GP_OFFSET (info);
11604
        }
11605
      else
11606
        {
11607
          /* If the relocate_section function needs to do a reloc
11608
             involving the GP value, it should make a reloc_dangerous
11609
             callback to warn that GP is not defined.  */
11610
        }
11611
    }
11612
 
11613
  /* Go through the sections and collect the .reginfo and .mdebug
11614
     information.  */
11615
  reginfo_sec = NULL;
11616
  mdebug_sec = NULL;
11617
  gptab_data_sec = NULL;
11618
  gptab_bss_sec = NULL;
11619
  for (o = abfd->sections; o != NULL; o = o->next)
11620
    {
11621
      if (strcmp (o->name, ".reginfo") == 0)
11622
        {
11623
          memset (&reginfo, 0, sizeof reginfo);
11624
 
11625
          /* We have found the .reginfo section in the output file.
11626
             Look through all the link_orders comprising it and merge
11627
             the information together.  */
11628
          for (p = o->map_head.link_order; p != NULL; p = p->next)
11629
            {
11630
              asection *input_section;
11631
              bfd *input_bfd;
11632
              Elf32_External_RegInfo ext;
11633
              Elf32_RegInfo sub;
11634
 
11635
              if (p->type != bfd_indirect_link_order)
11636
                {
11637
                  if (p->type == bfd_data_link_order)
11638
                    continue;
11639
                  abort ();
11640
                }
11641
 
11642
              input_section = p->u.indirect.section;
11643
              input_bfd = input_section->owner;
11644
 
11645
              if (! bfd_get_section_contents (input_bfd, input_section,
11646
                                              &ext, 0, sizeof ext))
11647
                return FALSE;
11648
 
11649
              bfd_mips_elf32_swap_reginfo_in (input_bfd, &ext, &sub);
11650
 
11651
              reginfo.ri_gprmask |= sub.ri_gprmask;
11652
              reginfo.ri_cprmask[0] |= sub.ri_cprmask[0];
11653
              reginfo.ri_cprmask[1] |= sub.ri_cprmask[1];
11654
              reginfo.ri_cprmask[2] |= sub.ri_cprmask[2];
11655
              reginfo.ri_cprmask[3] |= sub.ri_cprmask[3];
11656
 
11657
              /* ri_gp_value is set by the function
11658
                 mips_elf32_section_processing when the section is
11659
                 finally written out.  */
11660
 
11661
              /* Hack: reset the SEC_HAS_CONTENTS flag so that
11662
                 elf_link_input_bfd ignores this section.  */
11663
              input_section->flags &= ~SEC_HAS_CONTENTS;
11664
            }
11665
 
11666
          /* Size has been set in _bfd_mips_elf_always_size_sections.  */
11667
          BFD_ASSERT(o->size == sizeof (Elf32_External_RegInfo));
11668
 
11669
          /* Skip this section later on (I don't think this currently
11670
             matters, but someday it might).  */
11671
          o->map_head.link_order = NULL;
11672
 
11673
          reginfo_sec = o;
11674
        }
11675
 
11676
      if (strcmp (o->name, ".mdebug") == 0)
11677
        {
11678
          struct extsym_info einfo;
11679
          bfd_vma last;
11680
 
11681
          /* We have found the .mdebug section in the output file.
11682
             Look through all the link_orders comprising it and merge
11683
             the information together.  */
11684
          symhdr->magic = swap->sym_magic;
11685
          /* FIXME: What should the version stamp be?  */
11686
          symhdr->vstamp = 0;
11687
          symhdr->ilineMax = 0;
11688
          symhdr->cbLine = 0;
11689
          symhdr->idnMax = 0;
11690
          symhdr->ipdMax = 0;
11691
          symhdr->isymMax = 0;
11692
          symhdr->ioptMax = 0;
11693
          symhdr->iauxMax = 0;
11694
          symhdr->issMax = 0;
11695
          symhdr->issExtMax = 0;
11696
          symhdr->ifdMax = 0;
11697
          symhdr->crfd = 0;
11698
          symhdr->iextMax = 0;
11699
 
11700
          /* We accumulate the debugging information itself in the
11701
             debug_info structure.  */
11702
          debug.line = NULL;
11703
          debug.external_dnr = NULL;
11704
          debug.external_pdr = NULL;
11705
          debug.external_sym = NULL;
11706
          debug.external_opt = NULL;
11707
          debug.external_aux = NULL;
11708
          debug.ss = NULL;
11709
          debug.ssext = debug.ssext_end = NULL;
11710
          debug.external_fdr = NULL;
11711
          debug.external_rfd = NULL;
11712
          debug.external_ext = debug.external_ext_end = NULL;
11713
 
11714
          mdebug_handle = bfd_ecoff_debug_init (abfd, &debug, swap, info);
11715
          if (mdebug_handle == NULL)
11716
            return FALSE;
11717
 
11718
          esym.jmptbl = 0;
11719
          esym.cobol_main = 0;
11720
          esym.weakext = 0;
11721
          esym.reserved = 0;
11722
          esym.ifd = ifdNil;
11723
          esym.asym.iss = issNil;
11724
          esym.asym.st = stLocal;
11725
          esym.asym.reserved = 0;
11726
          esym.asym.index = indexNil;
11727
          last = 0;
11728
          for (i = 0; i < sizeof (secname) / sizeof (secname[0]); i++)
11729
            {
11730
              esym.asym.sc = sc[i];
11731
              s = bfd_get_section_by_name (abfd, secname[i]);
11732
              if (s != NULL)
11733
                {
11734
                  esym.asym.value = s->vma;
11735
                  last = s->vma + s->size;
11736
                }
11737
              else
11738
                esym.asym.value = last;
11739
              if (!bfd_ecoff_debug_one_external (abfd, &debug, swap,
11740
                                                 secname[i], &esym))
11741
                return FALSE;
11742
            }
11743
 
11744
          for (p = o->map_head.link_order; p != NULL; p = p->next)
11745
            {
11746
              asection *input_section;
11747
              bfd *input_bfd;
11748
              const struct ecoff_debug_swap *input_swap;
11749
              struct ecoff_debug_info input_debug;
11750
              char *eraw_src;
11751
              char *eraw_end;
11752
 
11753
              if (p->type != bfd_indirect_link_order)
11754
                {
11755
                  if (p->type == bfd_data_link_order)
11756
                    continue;
11757
                  abort ();
11758
                }
11759
 
11760
              input_section = p->u.indirect.section;
11761
              input_bfd = input_section->owner;
11762
 
11763 225 jeremybenn
              if (!is_mips_elf (input_bfd))
11764 24 jeremybenn
                {
11765
                  /* I don't know what a non MIPS ELF bfd would be
11766
                     doing with a .mdebug section, but I don't really
11767
                     want to deal with it.  */
11768
                  continue;
11769
                }
11770
 
11771
              input_swap = (get_elf_backend_data (input_bfd)
11772
                            ->elf_backend_ecoff_debug_swap);
11773
 
11774
              BFD_ASSERT (p->size == input_section->size);
11775
 
11776
              /* The ECOFF linking code expects that we have already
11777
                 read in the debugging information and set up an
11778
                 ecoff_debug_info structure, so we do that now.  */
11779
              if (! _bfd_mips_elf_read_ecoff_info (input_bfd, input_section,
11780
                                                   &input_debug))
11781
                return FALSE;
11782
 
11783
              if (! (bfd_ecoff_debug_accumulate
11784
                     (mdebug_handle, abfd, &debug, swap, input_bfd,
11785
                      &input_debug, input_swap, info)))
11786
                return FALSE;
11787
 
11788
              /* Loop through the external symbols.  For each one with
11789
                 interesting information, try to find the symbol in
11790
                 the linker global hash table and save the information
11791
                 for the output external symbols.  */
11792
              eraw_src = input_debug.external_ext;
11793
              eraw_end = (eraw_src
11794
                          + (input_debug.symbolic_header.iextMax
11795
                             * input_swap->external_ext_size));
11796
              for (;
11797
                   eraw_src < eraw_end;
11798
                   eraw_src += input_swap->external_ext_size)
11799
                {
11800
                  EXTR ext;
11801
                  const char *name;
11802
                  struct mips_elf_link_hash_entry *h;
11803
 
11804
                  (*input_swap->swap_ext_in) (input_bfd, eraw_src, &ext);
11805
                  if (ext.asym.sc == scNil
11806
                      || ext.asym.sc == scUndefined
11807
                      || ext.asym.sc == scSUndefined)
11808
                    continue;
11809
 
11810
                  name = input_debug.ssext + ext.asym.iss;
11811
                  h = mips_elf_link_hash_lookup (mips_elf_hash_table (info),
11812
                                                 name, FALSE, FALSE, TRUE);
11813
                  if (h == NULL || h->esym.ifd != -2)
11814
                    continue;
11815
 
11816
                  if (ext.ifd != -1)
11817
                    {
11818
                      BFD_ASSERT (ext.ifd
11819
                                  < input_debug.symbolic_header.ifdMax);
11820
                      ext.ifd = input_debug.ifdmap[ext.ifd];
11821
                    }
11822
 
11823
                  h->esym = ext;
11824
                }
11825
 
11826
              /* Free up the information we just read.  */
11827
              free (input_debug.line);
11828
              free (input_debug.external_dnr);
11829
              free (input_debug.external_pdr);
11830
              free (input_debug.external_sym);
11831
              free (input_debug.external_opt);
11832
              free (input_debug.external_aux);
11833
              free (input_debug.ss);
11834
              free (input_debug.ssext);
11835
              free (input_debug.external_fdr);
11836
              free (input_debug.external_rfd);
11837
              free (input_debug.external_ext);
11838
 
11839
              /* Hack: reset the SEC_HAS_CONTENTS flag so that
11840
                 elf_link_input_bfd ignores this section.  */
11841
              input_section->flags &= ~SEC_HAS_CONTENTS;
11842
            }
11843
 
11844
          if (SGI_COMPAT (abfd) && info->shared)
11845
            {
11846
              /* Create .rtproc section.  */
11847
              rtproc_sec = bfd_get_section_by_name (abfd, ".rtproc");
11848
              if (rtproc_sec == NULL)
11849
                {
11850
                  flagword flags = (SEC_HAS_CONTENTS | SEC_IN_MEMORY
11851
                                    | SEC_LINKER_CREATED | SEC_READONLY);
11852
 
11853
                  rtproc_sec = bfd_make_section_with_flags (abfd,
11854
                                                            ".rtproc",
11855
                                                            flags);
11856
                  if (rtproc_sec == NULL
11857
                      || ! bfd_set_section_alignment (abfd, rtproc_sec, 4))
11858
                    return FALSE;
11859
                }
11860
 
11861
              if (! mips_elf_create_procedure_table (mdebug_handle, abfd,
11862
                                                     info, rtproc_sec,
11863
                                                     &debug))
11864
                return FALSE;
11865
            }
11866
 
11867
          /* Build the external symbol information.  */
11868
          einfo.abfd = abfd;
11869
          einfo.info = info;
11870
          einfo.debug = &debug;
11871
          einfo.swap = swap;
11872
          einfo.failed = FALSE;
11873
          mips_elf_link_hash_traverse (mips_elf_hash_table (info),
11874
                                       mips_elf_output_extsym, &einfo);
11875
          if (einfo.failed)
11876
            return FALSE;
11877
 
11878
          /* Set the size of the .mdebug section.  */
11879
          o->size = bfd_ecoff_debug_size (abfd, &debug, swap);
11880
 
11881
          /* Skip this section later on (I don't think this currently
11882
             matters, but someday it might).  */
11883
          o->map_head.link_order = NULL;
11884
 
11885
          mdebug_sec = o;
11886
        }
11887
 
11888
      if (CONST_STRNEQ (o->name, ".gptab."))
11889
        {
11890
          const char *subname;
11891
          unsigned int c;
11892
          Elf32_gptab *tab;
11893
          Elf32_External_gptab *ext_tab;
11894
          unsigned int j;
11895
 
11896
          /* The .gptab.sdata and .gptab.sbss sections hold
11897
             information describing how the small data area would
11898
             change depending upon the -G switch.  These sections
11899
             not used in executables files.  */
11900
          if (! info->relocatable)
11901
            {
11902
              for (p = o->map_head.link_order; p != NULL; p = p->next)
11903
                {
11904
                  asection *input_section;
11905
 
11906
                  if (p->type != bfd_indirect_link_order)
11907
                    {
11908
                      if (p->type == bfd_data_link_order)
11909
                        continue;
11910
                      abort ();
11911
                    }
11912
 
11913
                  input_section = p->u.indirect.section;
11914
 
11915
                  /* Hack: reset the SEC_HAS_CONTENTS flag so that
11916
                     elf_link_input_bfd ignores this section.  */
11917
                  input_section->flags &= ~SEC_HAS_CONTENTS;
11918
                }
11919
 
11920
              /* Skip this section later on (I don't think this
11921
                 currently matters, but someday it might).  */
11922
              o->map_head.link_order = NULL;
11923
 
11924
              /* Really remove the section.  */
11925
              bfd_section_list_remove (abfd, o);
11926
              --abfd->section_count;
11927
 
11928
              continue;
11929
            }
11930
 
11931
          /* There is one gptab for initialized data, and one for
11932
             uninitialized data.  */
11933
          if (strcmp (o->name, ".gptab.sdata") == 0)
11934
            gptab_data_sec = o;
11935
          else if (strcmp (o->name, ".gptab.sbss") == 0)
11936
            gptab_bss_sec = o;
11937
          else
11938
            {
11939
              (*_bfd_error_handler)
11940
                (_("%s: illegal section name `%s'"),
11941
                 bfd_get_filename (abfd), o->name);
11942
              bfd_set_error (bfd_error_nonrepresentable_section);
11943
              return FALSE;
11944
            }
11945
 
11946
          /* The linker script always combines .gptab.data and
11947
             .gptab.sdata into .gptab.sdata, and likewise for
11948
             .gptab.bss and .gptab.sbss.  It is possible that there is
11949
             no .sdata or .sbss section in the output file, in which
11950
             case we must change the name of the output section.  */
11951
          subname = o->name + sizeof ".gptab" - 1;
11952
          if (bfd_get_section_by_name (abfd, subname) == NULL)
11953
            {
11954
              if (o == gptab_data_sec)
11955
                o->name = ".gptab.data";
11956
              else
11957
                o->name = ".gptab.bss";
11958
              subname = o->name + sizeof ".gptab" - 1;
11959
              BFD_ASSERT (bfd_get_section_by_name (abfd, subname) != NULL);
11960
            }
11961
 
11962
          /* Set up the first entry.  */
11963
          c = 1;
11964
          amt = c * sizeof (Elf32_gptab);
11965
          tab = bfd_malloc (amt);
11966
          if (tab == NULL)
11967
            return FALSE;
11968
          tab[0].gt_header.gt_current_g_value = elf_gp_size (abfd);
11969
          tab[0].gt_header.gt_unused = 0;
11970
 
11971
          /* Combine the input sections.  */
11972
          for (p = o->map_head.link_order; p != NULL; p = p->next)
11973
            {
11974
              asection *input_section;
11975
              bfd *input_bfd;
11976
              bfd_size_type size;
11977
              unsigned long last;
11978
              bfd_size_type gpentry;
11979
 
11980
              if (p->type != bfd_indirect_link_order)
11981
                {
11982
                  if (p->type == bfd_data_link_order)
11983
                    continue;
11984
                  abort ();
11985
                }
11986
 
11987
              input_section = p->u.indirect.section;
11988
              input_bfd = input_section->owner;
11989
 
11990
              /* Combine the gptab entries for this input section one
11991
                 by one.  We know that the input gptab entries are
11992
                 sorted by ascending -G value.  */
11993
              size = input_section->size;
11994
              last = 0;
11995
              for (gpentry = sizeof (Elf32_External_gptab);
11996
                   gpentry < size;
11997
                   gpentry += sizeof (Elf32_External_gptab))
11998
                {
11999
                  Elf32_External_gptab ext_gptab;
12000
                  Elf32_gptab int_gptab;
12001
                  unsigned long val;
12002
                  unsigned long add;
12003
                  bfd_boolean exact;
12004
                  unsigned int look;
12005
 
12006
                  if (! (bfd_get_section_contents
12007
                         (input_bfd, input_section, &ext_gptab, gpentry,
12008
                          sizeof (Elf32_External_gptab))))
12009
                    {
12010
                      free (tab);
12011
                      return FALSE;
12012
                    }
12013
 
12014
                  bfd_mips_elf32_swap_gptab_in (input_bfd, &ext_gptab,
12015
                                                &int_gptab);
12016
                  val = int_gptab.gt_entry.gt_g_value;
12017
                  add = int_gptab.gt_entry.gt_bytes - last;
12018
 
12019
                  exact = FALSE;
12020
                  for (look = 1; look < c; look++)
12021
                    {
12022
                      if (tab[look].gt_entry.gt_g_value >= val)
12023
                        tab[look].gt_entry.gt_bytes += add;
12024
 
12025
                      if (tab[look].gt_entry.gt_g_value == val)
12026
                        exact = TRUE;
12027
                    }
12028
 
12029
                  if (! exact)
12030
                    {
12031
                      Elf32_gptab *new_tab;
12032
                      unsigned int max;
12033
 
12034
                      /* We need a new table entry.  */
12035
                      amt = (bfd_size_type) (c + 1) * sizeof (Elf32_gptab);
12036
                      new_tab = bfd_realloc (tab, amt);
12037
                      if (new_tab == NULL)
12038
                        {
12039
                          free (tab);
12040
                          return FALSE;
12041
                        }
12042
                      tab = new_tab;
12043
                      tab[c].gt_entry.gt_g_value = val;
12044
                      tab[c].gt_entry.gt_bytes = add;
12045
 
12046
                      /* Merge in the size for the next smallest -G
12047
                         value, since that will be implied by this new
12048
                         value.  */
12049
                      max = 0;
12050
                      for (look = 1; look < c; look++)
12051
                        {
12052
                          if (tab[look].gt_entry.gt_g_value < val
12053
                              && (max == 0
12054
                                  || (tab[look].gt_entry.gt_g_value
12055
                                      > tab[max].gt_entry.gt_g_value)))
12056
                            max = look;
12057
                        }
12058
                      if (max != 0)
12059
                        tab[c].gt_entry.gt_bytes +=
12060
                          tab[max].gt_entry.gt_bytes;
12061
 
12062
                      ++c;
12063
                    }
12064
 
12065
                  last = int_gptab.gt_entry.gt_bytes;
12066
                }
12067
 
12068
              /* Hack: reset the SEC_HAS_CONTENTS flag so that
12069
                 elf_link_input_bfd ignores this section.  */
12070
              input_section->flags &= ~SEC_HAS_CONTENTS;
12071
            }
12072
 
12073
          /* The table must be sorted by -G value.  */
12074
          if (c > 2)
12075
            qsort (tab + 1, c - 1, sizeof (tab[0]), gptab_compare);
12076
 
12077
          /* Swap out the table.  */
12078
          amt = (bfd_size_type) c * sizeof (Elf32_External_gptab);
12079
          ext_tab = bfd_alloc (abfd, amt);
12080
          if (ext_tab == NULL)
12081
            {
12082
              free (tab);
12083
              return FALSE;
12084
            }
12085
 
12086
          for (j = 0; j < c; j++)
12087
            bfd_mips_elf32_swap_gptab_out (abfd, tab + j, ext_tab + j);
12088
          free (tab);
12089
 
12090
          o->size = c * sizeof (Elf32_External_gptab);
12091
          o->contents = (bfd_byte *) ext_tab;
12092
 
12093
          /* Skip this section later on (I don't think this currently
12094
             matters, but someday it might).  */
12095
          o->map_head.link_order = NULL;
12096
        }
12097
    }
12098
 
12099
  /* Invoke the regular ELF backend linker to do all the work.  */
12100
  if (!bfd_elf_final_link (abfd, info))
12101
    return FALSE;
12102
 
12103
  /* Now write out the computed sections.  */
12104
 
12105
  if (reginfo_sec != NULL)
12106
    {
12107
      Elf32_External_RegInfo ext;
12108
 
12109
      bfd_mips_elf32_swap_reginfo_out (abfd, &reginfo, &ext);
12110
      if (! bfd_set_section_contents (abfd, reginfo_sec, &ext, 0, sizeof ext))
12111
        return FALSE;
12112
    }
12113
 
12114
  if (mdebug_sec != NULL)
12115
    {
12116
      BFD_ASSERT (abfd->output_has_begun);
12117
      if (! bfd_ecoff_write_accumulated_debug (mdebug_handle, abfd, &debug,
12118
                                               swap, info,
12119
                                               mdebug_sec->filepos))
12120
        return FALSE;
12121
 
12122
      bfd_ecoff_debug_free (mdebug_handle, abfd, &debug, swap, info);
12123
    }
12124
 
12125
  if (gptab_data_sec != NULL)
12126
    {
12127
      if (! bfd_set_section_contents (abfd, gptab_data_sec,
12128
                                      gptab_data_sec->contents,
12129
                                      0, gptab_data_sec->size))
12130
        return FALSE;
12131
    }
12132
 
12133
  if (gptab_bss_sec != NULL)
12134
    {
12135
      if (! bfd_set_section_contents (abfd, gptab_bss_sec,
12136
                                      gptab_bss_sec->contents,
12137
                                      0, gptab_bss_sec->size))
12138
        return FALSE;
12139
    }
12140
 
12141
  if (SGI_COMPAT (abfd))
12142
    {
12143
      rtproc_sec = bfd_get_section_by_name (abfd, ".rtproc");
12144
      if (rtproc_sec != NULL)
12145
        {
12146
          if (! bfd_set_section_contents (abfd, rtproc_sec,
12147
                                          rtproc_sec->contents,
12148
                                          0, rtproc_sec->size))
12149
            return FALSE;
12150
        }
12151
    }
12152
 
12153
  return TRUE;
12154
}
12155
 
12156
/* Structure for saying that BFD machine EXTENSION extends BASE.  */
12157
 
12158
struct mips_mach_extension {
12159
  unsigned long extension, base;
12160
};
12161
 
12162
 
12163
/* An array describing how BFD machines relate to one another.  The entries
12164
   are ordered topologically with MIPS I extensions listed last.  */
12165
 
12166
static const struct mips_mach_extension mips_mach_extensions[] = {
12167
  /* MIPS64r2 extensions.  */
12168
  { bfd_mach_mips_octeon, bfd_mach_mipsisa64r2 },
12169
 
12170
  /* MIPS64 extensions.  */
12171
  { bfd_mach_mipsisa64r2, bfd_mach_mipsisa64 },
12172
  { bfd_mach_mips_sb1, bfd_mach_mipsisa64 },
12173 225 jeremybenn
  { bfd_mach_mips_xlr, bfd_mach_mipsisa64 },
12174 24 jeremybenn
 
12175
  /* MIPS V extensions.  */
12176
  { bfd_mach_mipsisa64, bfd_mach_mips5 },
12177
 
12178
  /* R10000 extensions.  */
12179
  { bfd_mach_mips12000, bfd_mach_mips10000 },
12180 225 jeremybenn
  { bfd_mach_mips14000, bfd_mach_mips10000 },
12181
  { bfd_mach_mips16000, bfd_mach_mips10000 },
12182 24 jeremybenn
 
12183
  /* R5000 extensions.  Note: the vr5500 ISA is an extension of the core
12184
     vr5400 ISA, but doesn't include the multimedia stuff.  It seems
12185
     better to allow vr5400 and vr5500 code to be merged anyway, since
12186
     many libraries will just use the core ISA.  Perhaps we could add
12187
     some sort of ASE flag if this ever proves a problem.  */
12188
  { bfd_mach_mips5500, bfd_mach_mips5400 },
12189
  { bfd_mach_mips5400, bfd_mach_mips5000 },
12190
 
12191
  /* MIPS IV extensions.  */
12192
  { bfd_mach_mips5, bfd_mach_mips8000 },
12193
  { bfd_mach_mips10000, bfd_mach_mips8000 },
12194
  { bfd_mach_mips5000, bfd_mach_mips8000 },
12195
  { bfd_mach_mips7000, bfd_mach_mips8000 },
12196
  { bfd_mach_mips9000, bfd_mach_mips8000 },
12197
 
12198
  /* VR4100 extensions.  */
12199
  { bfd_mach_mips4120, bfd_mach_mips4100 },
12200
  { bfd_mach_mips4111, bfd_mach_mips4100 },
12201
 
12202
  /* MIPS III extensions.  */
12203
  { bfd_mach_mips_loongson_2e, bfd_mach_mips4000 },
12204
  { bfd_mach_mips_loongson_2f, bfd_mach_mips4000 },
12205
  { bfd_mach_mips8000, bfd_mach_mips4000 },
12206
  { bfd_mach_mips4650, bfd_mach_mips4000 },
12207
  { bfd_mach_mips4600, bfd_mach_mips4000 },
12208
  { bfd_mach_mips4400, bfd_mach_mips4000 },
12209
  { bfd_mach_mips4300, bfd_mach_mips4000 },
12210
  { bfd_mach_mips4100, bfd_mach_mips4000 },
12211
  { bfd_mach_mips4010, bfd_mach_mips4000 },
12212
 
12213
  /* MIPS32 extensions.  */
12214
  { bfd_mach_mipsisa32r2, bfd_mach_mipsisa32 },
12215
 
12216
  /* MIPS II extensions.  */
12217
  { bfd_mach_mips4000, bfd_mach_mips6000 },
12218
  { bfd_mach_mipsisa32, bfd_mach_mips6000 },
12219
 
12220
  /* MIPS I extensions.  */
12221
  { bfd_mach_mips6000, bfd_mach_mips3000 },
12222
  { bfd_mach_mips3900, bfd_mach_mips3000 }
12223
};
12224
 
12225
 
12226
/* Return true if bfd machine EXTENSION is an extension of machine BASE.  */
12227
 
12228
static bfd_boolean
12229
mips_mach_extends_p (unsigned long base, unsigned long extension)
12230
{
12231
  size_t i;
12232
 
12233
  if (extension == base)
12234
    return TRUE;
12235
 
12236
  if (base == bfd_mach_mipsisa32
12237
      && mips_mach_extends_p (bfd_mach_mipsisa64, extension))
12238
    return TRUE;
12239
 
12240
  if (base == bfd_mach_mipsisa32r2
12241
      && mips_mach_extends_p (bfd_mach_mipsisa64r2, extension))
12242
    return TRUE;
12243
 
12244
  for (i = 0; i < ARRAY_SIZE (mips_mach_extensions); i++)
12245
    if (extension == mips_mach_extensions[i].extension)
12246
      {
12247
        extension = mips_mach_extensions[i].base;
12248
        if (extension == base)
12249
          return TRUE;
12250
      }
12251
 
12252
  return FALSE;
12253
}
12254
 
12255
 
12256
/* Return true if the given ELF header flags describe a 32-bit binary.  */
12257
 
12258
static bfd_boolean
12259
mips_32bit_flags_p (flagword flags)
12260
{
12261
  return ((flags & EF_MIPS_32BITMODE) != 0
12262
          || (flags & EF_MIPS_ABI) == E_MIPS_ABI_O32
12263
          || (flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI32
12264
          || (flags & EF_MIPS_ARCH) == E_MIPS_ARCH_1
12265
          || (flags & EF_MIPS_ARCH) == E_MIPS_ARCH_2
12266
          || (flags & EF_MIPS_ARCH) == E_MIPS_ARCH_32
12267
          || (flags & EF_MIPS_ARCH) == E_MIPS_ARCH_32R2);
12268
}
12269
 
12270
 
12271
/* Merge object attributes from IBFD into OBFD.  Raise an error if
12272
   there are conflicting attributes.  */
12273
static bfd_boolean
12274
mips_elf_merge_obj_attributes (bfd *ibfd, bfd *obfd)
12275
{
12276
  obj_attribute *in_attr;
12277
  obj_attribute *out_attr;
12278
 
12279
  if (!elf_known_obj_attributes_proc (obfd)[0].i)
12280
    {
12281
      /* This is the first object.  Copy the attributes.  */
12282
      _bfd_elf_copy_obj_attributes (ibfd, obfd);
12283
 
12284
      /* Use the Tag_null value to indicate the attributes have been
12285
         initialized.  */
12286
      elf_known_obj_attributes_proc (obfd)[0].i = 1;
12287
 
12288
      return TRUE;
12289
    }
12290
 
12291
  /* Check for conflicting Tag_GNU_MIPS_ABI_FP attributes and merge
12292
     non-conflicting ones.  */
12293
  in_attr = elf_known_obj_attributes (ibfd)[OBJ_ATTR_GNU];
12294
  out_attr = elf_known_obj_attributes (obfd)[OBJ_ATTR_GNU];
12295
  if (in_attr[Tag_GNU_MIPS_ABI_FP].i != out_attr[Tag_GNU_MIPS_ABI_FP].i)
12296
    {
12297
      out_attr[Tag_GNU_MIPS_ABI_FP].type = 1;
12298
      if (out_attr[Tag_GNU_MIPS_ABI_FP].i == 0)
12299
        out_attr[Tag_GNU_MIPS_ABI_FP].i = in_attr[Tag_GNU_MIPS_ABI_FP].i;
12300
      else if (in_attr[Tag_GNU_MIPS_ABI_FP].i == 0)
12301
        ;
12302
      else if (in_attr[Tag_GNU_MIPS_ABI_FP].i > 4)
12303
        _bfd_error_handler
12304
          (_("Warning: %B uses unknown floating point ABI %d"), ibfd,
12305
           in_attr[Tag_GNU_MIPS_ABI_FP].i);
12306
      else if (out_attr[Tag_GNU_MIPS_ABI_FP].i > 4)
12307
        _bfd_error_handler
12308
          (_("Warning: %B uses unknown floating point ABI %d"), obfd,
12309
           out_attr[Tag_GNU_MIPS_ABI_FP].i);
12310
      else
12311
        switch (out_attr[Tag_GNU_MIPS_ABI_FP].i)
12312
          {
12313
          case 1:
12314
            switch (in_attr[Tag_GNU_MIPS_ABI_FP].i)
12315
              {
12316
              case 2:
12317
                _bfd_error_handler
12318
                  (_("Warning: %B uses -msingle-float, %B uses -mdouble-float"),
12319
                   obfd, ibfd);
12320
                break;
12321
 
12322
              case 3:
12323
                _bfd_error_handler
12324
                  (_("Warning: %B uses hard float, %B uses soft float"),
12325
                   obfd, ibfd);
12326
                break;
12327
 
12328
              case 4:
12329
                _bfd_error_handler
12330
                  (_("Warning: %B uses -msingle-float, %B uses -mips32r2 -mfp64"),
12331
                   obfd, ibfd);
12332
                break;
12333
 
12334
              default:
12335
                abort ();
12336
              }
12337
            break;
12338
 
12339
          case 2:
12340
            switch (in_attr[Tag_GNU_MIPS_ABI_FP].i)
12341
              {
12342
              case 1:
12343
                _bfd_error_handler
12344
                  (_("Warning: %B uses -msingle-float, %B uses -mdouble-float"),
12345
                   ibfd, obfd);
12346
                break;
12347
 
12348
              case 3:
12349
                _bfd_error_handler
12350
                  (_("Warning: %B uses hard float, %B uses soft float"),
12351
                   obfd, ibfd);
12352
                break;
12353
 
12354
              case 4:
12355
                _bfd_error_handler
12356
                  (_("Warning: %B uses -mdouble-float, %B uses -mips32r2 -mfp64"),
12357
                   obfd, ibfd);
12358
                break;
12359
 
12360
              default:
12361
                abort ();
12362
              }
12363
            break;
12364
 
12365
          case 3:
12366
            switch (in_attr[Tag_GNU_MIPS_ABI_FP].i)
12367
              {
12368
              case 1:
12369
              case 2:
12370
              case 4:
12371
                _bfd_error_handler
12372
                  (_("Warning: %B uses hard float, %B uses soft float"),
12373
                   ibfd, obfd);
12374
                break;
12375
 
12376
              default:
12377
                abort ();
12378
              }
12379
            break;
12380
 
12381
          case 4:
12382
            switch (in_attr[Tag_GNU_MIPS_ABI_FP].i)
12383
              {
12384
              case 1:
12385
                _bfd_error_handler
12386
                  (_("Warning: %B uses -msingle-float, %B uses -mips32r2 -mfp64"),
12387
                   ibfd, obfd);
12388
                break;
12389
 
12390
              case 2:
12391
                _bfd_error_handler
12392
                  (_("Warning: %B uses -mdouble-float, %B uses -mips32r2 -mfp64"),
12393
                   ibfd, obfd);
12394
                break;
12395
 
12396
              case 3:
12397
                _bfd_error_handler
12398
                  (_("Warning: %B uses hard float, %B uses soft float"),
12399
                   obfd, ibfd);
12400
                break;
12401
 
12402
              default:
12403
                abort ();
12404
              }
12405
            break;
12406
 
12407
          default:
12408
            abort ();
12409
          }
12410
    }
12411
 
12412
  /* Merge Tag_compatibility attributes and any common GNU ones.  */
12413
  _bfd_elf_merge_object_attributes (ibfd, obfd);
12414
 
12415
  return TRUE;
12416
}
12417
 
12418
/* Merge backend specific data from an object file to the output
12419
   object file when linking.  */
12420
 
12421
bfd_boolean
12422
_bfd_mips_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
12423
{
12424
  flagword old_flags;
12425
  flagword new_flags;
12426
  bfd_boolean ok;
12427
  bfd_boolean null_input_bfd = TRUE;
12428
  asection *sec;
12429
 
12430
  /* Check if we have the same endianess */
12431
  if (! _bfd_generic_verify_endian_match (ibfd, obfd))
12432
    {
12433
      (*_bfd_error_handler)
12434
        (_("%B: endianness incompatible with that of the selected emulation"),
12435
         ibfd);
12436
      return FALSE;
12437
    }
12438
 
12439 225 jeremybenn
  if (!is_mips_elf (ibfd) || !is_mips_elf (obfd))
12440 24 jeremybenn
    return TRUE;
12441
 
12442
  if (strcmp (bfd_get_target (ibfd), bfd_get_target (obfd)) != 0)
12443
    {
12444
      (*_bfd_error_handler)
12445
        (_("%B: ABI is incompatible with that of the selected emulation"),
12446
         ibfd);
12447
      return FALSE;
12448
    }
12449
 
12450
  if (!mips_elf_merge_obj_attributes (ibfd, obfd))
12451
    return FALSE;
12452
 
12453
  new_flags = elf_elfheader (ibfd)->e_flags;
12454
  elf_elfheader (obfd)->e_flags |= new_flags & EF_MIPS_NOREORDER;
12455
  old_flags = elf_elfheader (obfd)->e_flags;
12456
 
12457
  if (! elf_flags_init (obfd))
12458
    {
12459
      elf_flags_init (obfd) = TRUE;
12460
      elf_elfheader (obfd)->e_flags = new_flags;
12461
      elf_elfheader (obfd)->e_ident[EI_CLASS]
12462
        = elf_elfheader (ibfd)->e_ident[EI_CLASS];
12463
 
12464
      if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
12465
          && (bfd_get_arch_info (obfd)->the_default
12466
              || mips_mach_extends_p (bfd_get_mach (obfd),
12467
                                      bfd_get_mach (ibfd))))
12468
        {
12469
          if (! bfd_set_arch_mach (obfd, bfd_get_arch (ibfd),
12470
                                   bfd_get_mach (ibfd)))
12471
            return FALSE;
12472
        }
12473
 
12474
      return TRUE;
12475
    }
12476
 
12477
  /* Check flag compatibility.  */
12478
 
12479
  new_flags &= ~EF_MIPS_NOREORDER;
12480
  old_flags &= ~EF_MIPS_NOREORDER;
12481
 
12482
  /* Some IRIX 6 BSD-compatibility objects have this bit set.  It
12483
     doesn't seem to matter.  */
12484
  new_flags &= ~EF_MIPS_XGOT;
12485
  old_flags &= ~EF_MIPS_XGOT;
12486
 
12487
  /* MIPSpro generates ucode info in n64 objects.  Again, we should
12488
     just be able to ignore this.  */
12489
  new_flags &= ~EF_MIPS_UCODE;
12490
  old_flags &= ~EF_MIPS_UCODE;
12491
 
12492 225 jeremybenn
  /* DSOs should only be linked with CPIC code.  */
12493
  if ((ibfd->flags & DYNAMIC) != 0)
12494
    new_flags |= EF_MIPS_PIC | EF_MIPS_CPIC;
12495 24 jeremybenn
 
12496
  if (new_flags == old_flags)
12497
    return TRUE;
12498
 
12499
  /* Check to see if the input BFD actually contains any sections.
12500
     If not, its flags may not have been initialised either, but it cannot
12501
     actually cause any incompatibility.  */
12502
  for (sec = ibfd->sections; sec != NULL; sec = sec->next)
12503
    {
12504
      /* Ignore synthetic sections and empty .text, .data and .bss sections
12505
          which are automatically generated by gas.  */
12506
      if (strcmp (sec->name, ".reginfo")
12507
          && strcmp (sec->name, ".mdebug")
12508
          && (sec->size != 0
12509
              || (strcmp (sec->name, ".text")
12510
                  && strcmp (sec->name, ".data")
12511
                  && strcmp (sec->name, ".bss"))))
12512
        {
12513
          null_input_bfd = FALSE;
12514
          break;
12515
        }
12516
    }
12517
  if (null_input_bfd)
12518
    return TRUE;
12519
 
12520
  ok = TRUE;
12521
 
12522
  if (((new_flags & (EF_MIPS_PIC | EF_MIPS_CPIC)) != 0)
12523
      != ((old_flags & (EF_MIPS_PIC | EF_MIPS_CPIC)) != 0))
12524
    {
12525
      (*_bfd_error_handler)
12526 225 jeremybenn
        (_("%B: warning: linking abicalls files with non-abicalls files"),
12527 24 jeremybenn
         ibfd);
12528
      ok = TRUE;
12529
    }
12530
 
12531
  if (new_flags & (EF_MIPS_PIC | EF_MIPS_CPIC))
12532
    elf_elfheader (obfd)->e_flags |= EF_MIPS_CPIC;
12533
  if (! (new_flags & EF_MIPS_PIC))
12534
    elf_elfheader (obfd)->e_flags &= ~EF_MIPS_PIC;
12535
 
12536
  new_flags &= ~ (EF_MIPS_PIC | EF_MIPS_CPIC);
12537
  old_flags &= ~ (EF_MIPS_PIC | EF_MIPS_CPIC);
12538
 
12539
  /* Compare the ISAs.  */
12540
  if (mips_32bit_flags_p (old_flags) != mips_32bit_flags_p (new_flags))
12541
    {
12542
      (*_bfd_error_handler)
12543
        (_("%B: linking 32-bit code with 64-bit code"),
12544
         ibfd);
12545
      ok = FALSE;
12546
    }
12547
  else if (!mips_mach_extends_p (bfd_get_mach (ibfd), bfd_get_mach (obfd)))
12548
    {
12549
      /* OBFD's ISA isn't the same as, or an extension of, IBFD's.  */
12550
      if (mips_mach_extends_p (bfd_get_mach (obfd), bfd_get_mach (ibfd)))
12551
        {
12552
          /* Copy the architecture info from IBFD to OBFD.  Also copy
12553
             the 32-bit flag (if set) so that we continue to recognise
12554
             OBFD as a 32-bit binary.  */
12555
          bfd_set_arch_info (obfd, bfd_get_arch_info (ibfd));
12556
          elf_elfheader (obfd)->e_flags &= ~(EF_MIPS_ARCH | EF_MIPS_MACH);
12557
          elf_elfheader (obfd)->e_flags
12558
            |= new_flags & (EF_MIPS_ARCH | EF_MIPS_MACH | EF_MIPS_32BITMODE);
12559
 
12560
          /* Copy across the ABI flags if OBFD doesn't use them
12561
             and if that was what caused us to treat IBFD as 32-bit.  */
12562
          if ((old_flags & EF_MIPS_ABI) == 0
12563
              && mips_32bit_flags_p (new_flags)
12564
              && !mips_32bit_flags_p (new_flags & ~EF_MIPS_ABI))
12565
            elf_elfheader (obfd)->e_flags |= new_flags & EF_MIPS_ABI;
12566
        }
12567
      else
12568
        {
12569
          /* The ISAs aren't compatible.  */
12570
          (*_bfd_error_handler)
12571
            (_("%B: linking %s module with previous %s modules"),
12572
             ibfd,
12573
             bfd_printable_name (ibfd),
12574
             bfd_printable_name (obfd));
12575
          ok = FALSE;
12576
        }
12577
    }
12578
 
12579
  new_flags &= ~(EF_MIPS_ARCH | EF_MIPS_MACH | EF_MIPS_32BITMODE);
12580
  old_flags &= ~(EF_MIPS_ARCH | EF_MIPS_MACH | EF_MIPS_32BITMODE);
12581
 
12582
  /* Compare ABIs.  The 64-bit ABI does not use EF_MIPS_ABI.  But, it
12583
     does set EI_CLASS differently from any 32-bit ABI.  */
12584
  if ((new_flags & EF_MIPS_ABI) != (old_flags & EF_MIPS_ABI)
12585
      || (elf_elfheader (ibfd)->e_ident[EI_CLASS]
12586
          != elf_elfheader (obfd)->e_ident[EI_CLASS]))
12587
    {
12588
      /* Only error if both are set (to different values).  */
12589
      if (((new_flags & EF_MIPS_ABI) && (old_flags & EF_MIPS_ABI))
12590
          || (elf_elfheader (ibfd)->e_ident[EI_CLASS]
12591
              != elf_elfheader (obfd)->e_ident[EI_CLASS]))
12592
        {
12593
          (*_bfd_error_handler)
12594
            (_("%B: ABI mismatch: linking %s module with previous %s modules"),
12595
             ibfd,
12596
             elf_mips_abi_name (ibfd),
12597
             elf_mips_abi_name (obfd));
12598
          ok = FALSE;
12599
        }
12600
      new_flags &= ~EF_MIPS_ABI;
12601
      old_flags &= ~EF_MIPS_ABI;
12602
    }
12603
 
12604
  /* For now, allow arbitrary mixing of ASEs (retain the union).  */
12605
  if ((new_flags & EF_MIPS_ARCH_ASE) != (old_flags & EF_MIPS_ARCH_ASE))
12606
    {
12607
      elf_elfheader (obfd)->e_flags |= new_flags & EF_MIPS_ARCH_ASE;
12608
 
12609
      new_flags &= ~ EF_MIPS_ARCH_ASE;
12610
      old_flags &= ~ EF_MIPS_ARCH_ASE;
12611
    }
12612
 
12613
  /* Warn about any other mismatches */
12614
  if (new_flags != old_flags)
12615
    {
12616
      (*_bfd_error_handler)
12617
        (_("%B: uses different e_flags (0x%lx) fields than previous modules (0x%lx)"),
12618
         ibfd, (unsigned long) new_flags,
12619
         (unsigned long) old_flags);
12620
      ok = FALSE;
12621
    }
12622
 
12623
  if (! ok)
12624
    {
12625
      bfd_set_error (bfd_error_bad_value);
12626
      return FALSE;
12627
    }
12628
 
12629
  return TRUE;
12630
}
12631
 
12632
/* Function to keep MIPS specific file flags like as EF_MIPS_PIC.  */
12633
 
12634
bfd_boolean
12635
_bfd_mips_elf_set_private_flags (bfd *abfd, flagword flags)
12636
{
12637
  BFD_ASSERT (!elf_flags_init (abfd)
12638
              || elf_elfheader (abfd)->e_flags == flags);
12639
 
12640
  elf_elfheader (abfd)->e_flags = flags;
12641
  elf_flags_init (abfd) = TRUE;
12642
  return TRUE;
12643
}
12644
 
12645 225 jeremybenn
char *
12646
_bfd_mips_elf_get_target_dtag (bfd_vma dtag)
12647
{
12648
  switch (dtag)
12649
    {
12650
    default: return "";
12651
    case DT_MIPS_RLD_VERSION:
12652
      return "MIPS_RLD_VERSION";
12653
    case DT_MIPS_TIME_STAMP:
12654
      return "MIPS_TIME_STAMP";
12655
    case DT_MIPS_ICHECKSUM:
12656
      return "MIPS_ICHECKSUM";
12657
    case DT_MIPS_IVERSION:
12658
      return "MIPS_IVERSION";
12659
    case DT_MIPS_FLAGS:
12660
      return "MIPS_FLAGS";
12661
    case DT_MIPS_BASE_ADDRESS:
12662
      return "MIPS_BASE_ADDRESS";
12663
    case DT_MIPS_MSYM:
12664
      return "MIPS_MSYM";
12665
    case DT_MIPS_CONFLICT:
12666
      return "MIPS_CONFLICT";
12667
    case DT_MIPS_LIBLIST:
12668
      return "MIPS_LIBLIST";
12669
    case DT_MIPS_LOCAL_GOTNO:
12670
      return "MIPS_LOCAL_GOTNO";
12671
    case DT_MIPS_CONFLICTNO:
12672
      return "MIPS_CONFLICTNO";
12673
    case DT_MIPS_LIBLISTNO:
12674
      return "MIPS_LIBLISTNO";
12675
    case DT_MIPS_SYMTABNO:
12676
      return "MIPS_SYMTABNO";
12677
    case DT_MIPS_UNREFEXTNO:
12678
      return "MIPS_UNREFEXTNO";
12679
    case DT_MIPS_GOTSYM:
12680
      return "MIPS_GOTSYM";
12681
    case DT_MIPS_HIPAGENO:
12682
      return "MIPS_HIPAGENO";
12683
    case DT_MIPS_RLD_MAP:
12684
      return "MIPS_RLD_MAP";
12685
    case DT_MIPS_DELTA_CLASS:
12686
      return "MIPS_DELTA_CLASS";
12687
    case DT_MIPS_DELTA_CLASS_NO:
12688
      return "MIPS_DELTA_CLASS_NO";
12689
    case DT_MIPS_DELTA_INSTANCE:
12690
      return "MIPS_DELTA_INSTANCE";
12691
    case DT_MIPS_DELTA_INSTANCE_NO:
12692
      return "MIPS_DELTA_INSTANCE_NO";
12693
    case DT_MIPS_DELTA_RELOC:
12694
      return "MIPS_DELTA_RELOC";
12695
    case DT_MIPS_DELTA_RELOC_NO:
12696
      return "MIPS_DELTA_RELOC_NO";
12697
    case DT_MIPS_DELTA_SYM:
12698
      return "MIPS_DELTA_SYM";
12699
    case DT_MIPS_DELTA_SYM_NO:
12700
      return "MIPS_DELTA_SYM_NO";
12701
    case DT_MIPS_DELTA_CLASSSYM:
12702
      return "MIPS_DELTA_CLASSSYM";
12703
    case DT_MIPS_DELTA_CLASSSYM_NO:
12704
      return "MIPS_DELTA_CLASSSYM_NO";
12705
    case DT_MIPS_CXX_FLAGS:
12706
      return "MIPS_CXX_FLAGS";
12707
    case DT_MIPS_PIXIE_INIT:
12708
      return "MIPS_PIXIE_INIT";
12709
    case DT_MIPS_SYMBOL_LIB:
12710
      return "MIPS_SYMBOL_LIB";
12711
    case DT_MIPS_LOCALPAGE_GOTIDX:
12712
      return "MIPS_LOCALPAGE_GOTIDX";
12713
    case DT_MIPS_LOCAL_GOTIDX:
12714
      return "MIPS_LOCAL_GOTIDX";
12715
    case DT_MIPS_HIDDEN_GOTIDX:
12716
      return "MIPS_HIDDEN_GOTIDX";
12717
    case DT_MIPS_PROTECTED_GOTIDX:
12718
      return "MIPS_PROTECTED_GOT_IDX";
12719
    case DT_MIPS_OPTIONS:
12720
      return "MIPS_OPTIONS";
12721
    case DT_MIPS_INTERFACE:
12722
      return "MIPS_INTERFACE";
12723
    case DT_MIPS_DYNSTR_ALIGN:
12724
      return "DT_MIPS_DYNSTR_ALIGN";
12725
    case DT_MIPS_INTERFACE_SIZE:
12726
      return "DT_MIPS_INTERFACE_SIZE";
12727
    case DT_MIPS_RLD_TEXT_RESOLVE_ADDR:
12728
      return "DT_MIPS_RLD_TEXT_RESOLVE_ADDR";
12729
    case DT_MIPS_PERF_SUFFIX:
12730
      return "DT_MIPS_PERF_SUFFIX";
12731
    case DT_MIPS_COMPACT_SIZE:
12732
      return "DT_MIPS_COMPACT_SIZE";
12733
    case DT_MIPS_GP_VALUE:
12734
      return "DT_MIPS_GP_VALUE";
12735
    case DT_MIPS_AUX_DYNAMIC:
12736
      return "DT_MIPS_AUX_DYNAMIC";
12737
    case DT_MIPS_PLTGOT:
12738
      return "DT_MIPS_PLTGOT";
12739
    case DT_MIPS_RWPLT:
12740
      return "DT_MIPS_RWPLT";
12741
    }
12742
}
12743
 
12744 24 jeremybenn
bfd_boolean
12745
_bfd_mips_elf_print_private_bfd_data (bfd *abfd, void *ptr)
12746
{
12747
  FILE *file = ptr;
12748
 
12749
  BFD_ASSERT (abfd != NULL && ptr != NULL);
12750
 
12751
  /* Print normal ELF private data.  */
12752
  _bfd_elf_print_private_bfd_data (abfd, ptr);
12753
 
12754
  /* xgettext:c-format */
12755
  fprintf (file, _("private flags = %lx:"), elf_elfheader (abfd)->e_flags);
12756
 
12757
  if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI) == E_MIPS_ABI_O32)
12758
    fprintf (file, _(" [abi=O32]"));
12759
  else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI) == E_MIPS_ABI_O64)
12760
    fprintf (file, _(" [abi=O64]"));
12761
  else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI32)
12762
    fprintf (file, _(" [abi=EABI32]"));
12763
  else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64)
12764
    fprintf (file, _(" [abi=EABI64]"));
12765
  else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI))
12766
    fprintf (file, _(" [abi unknown]"));
12767
  else if (ABI_N32_P (abfd))
12768
    fprintf (file, _(" [abi=N32]"));
12769
  else if (ABI_64_P (abfd))
12770
    fprintf (file, _(" [abi=64]"));
12771
  else
12772
    fprintf (file, _(" [no abi set]"));
12773
 
12774
  if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_1)
12775
    fprintf (file, " [mips1]");
12776
  else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_2)
12777
    fprintf (file, " [mips2]");
12778
  else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_3)
12779
    fprintf (file, " [mips3]");
12780
  else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_4)
12781
    fprintf (file, " [mips4]");
12782
  else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_5)
12783
    fprintf (file, " [mips5]");
12784
  else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_32)
12785
    fprintf (file, " [mips32]");
12786
  else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_64)
12787
    fprintf (file, " [mips64]");
12788
  else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_32R2)
12789
    fprintf (file, " [mips32r2]");
12790
  else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_64R2)
12791
    fprintf (file, " [mips64r2]");
12792
  else
12793
    fprintf (file, _(" [unknown ISA]"));
12794
 
12795
  if (elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH_ASE_MDMX)
12796
    fprintf (file, " [mdmx]");
12797
 
12798
  if (elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH_ASE_M16)
12799
    fprintf (file, " [mips16]");
12800
 
12801
  if (elf_elfheader (abfd)->e_flags & EF_MIPS_32BITMODE)
12802
    fprintf (file, " [32bitmode]");
12803
  else
12804
    fprintf (file, _(" [not 32bitmode]"));
12805
 
12806
  if (elf_elfheader (abfd)->e_flags & EF_MIPS_NOREORDER)
12807
    fprintf (file, " [noreorder]");
12808
 
12809
  if (elf_elfheader (abfd)->e_flags & EF_MIPS_PIC)
12810
    fprintf (file, " [PIC]");
12811
 
12812
  if (elf_elfheader (abfd)->e_flags & EF_MIPS_CPIC)
12813
    fprintf (file, " [CPIC]");
12814
 
12815
  if (elf_elfheader (abfd)->e_flags & EF_MIPS_XGOT)
12816
    fprintf (file, " [XGOT]");
12817
 
12818
  if (elf_elfheader (abfd)->e_flags & EF_MIPS_UCODE)
12819
    fprintf (file, " [UCODE]");
12820
 
12821
  fputc ('\n', file);
12822
 
12823
  return TRUE;
12824
}
12825
 
12826
const struct bfd_elf_special_section _bfd_mips_elf_special_sections[] =
12827
{
12828
  { STRING_COMMA_LEN (".lit4"),   0, SHT_PROGBITS,   SHF_ALLOC + SHF_WRITE + SHF_MIPS_GPREL },
12829
  { STRING_COMMA_LEN (".lit8"),   0, SHT_PROGBITS,   SHF_ALLOC + SHF_WRITE + SHF_MIPS_GPREL },
12830
  { STRING_COMMA_LEN (".mdebug"), 0, SHT_MIPS_DEBUG, 0 },
12831
  { STRING_COMMA_LEN (".sbss"),  -2, SHT_NOBITS,     SHF_ALLOC + SHF_WRITE + SHF_MIPS_GPREL },
12832
  { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS,   SHF_ALLOC + SHF_WRITE + SHF_MIPS_GPREL },
12833
  { STRING_COMMA_LEN (".ucode"),  0, SHT_MIPS_UCODE, 0 },
12834
  { NULL,                     0,  0, 0,              0 }
12835
};
12836
 
12837
/* Merge non visibility st_other attributes.  Ensure that the
12838
   STO_OPTIONAL flag is copied into h->other, even if this is not a
12839
   definiton of the symbol.  */
12840
void
12841
_bfd_mips_elf_merge_symbol_attribute (struct elf_link_hash_entry *h,
12842
                                      const Elf_Internal_Sym *isym,
12843
                                      bfd_boolean definition,
12844
                                      bfd_boolean dynamic ATTRIBUTE_UNUSED)
12845
{
12846
  if ((isym->st_other & ~ELF_ST_VISIBILITY (-1)) != 0)
12847
    {
12848
      unsigned char other;
12849
 
12850
      other = (definition ? isym->st_other : h->other);
12851
      other &= ~ELF_ST_VISIBILITY (-1);
12852
      h->other = other | ELF_ST_VISIBILITY (h->other);
12853
    }
12854
 
12855
  if (!definition
12856
      && ELF_MIPS_IS_OPTIONAL (isym->st_other))
12857
    h->other |= STO_OPTIONAL;
12858
}
12859
 
12860
/* Decide whether an undefined symbol is special and can be ignored.
12861
   This is the case for OPTIONAL symbols on IRIX.  */
12862
bfd_boolean
12863
_bfd_mips_elf_ignore_undef_symbol (struct elf_link_hash_entry *h)
12864
{
12865
  return ELF_MIPS_IS_OPTIONAL (h->other) ? TRUE : FALSE;
12866
}
12867
 
12868
bfd_boolean
12869
_bfd_mips_elf_common_definition (Elf_Internal_Sym *sym)
12870
{
12871
  return (sym->st_shndx == SHN_COMMON
12872
          || sym->st_shndx == SHN_MIPS_ACOMMON
12873
          || sym->st_shndx == SHN_MIPS_SCOMMON);
12874
}
12875 225 jeremybenn
 
12876
/* Return address for Ith PLT stub in section PLT, for relocation REL
12877
   or (bfd_vma) -1 if it should not be included.  */
12878
 
12879
bfd_vma
12880
_bfd_mips_elf_plt_sym_val (bfd_vma i, const asection *plt,
12881
                           const arelent *rel ATTRIBUTE_UNUSED)
12882
{
12883
  return (plt->vma
12884
          + 4 * ARRAY_SIZE (mips_o32_exec_plt0_entry)
12885
          + i * 4 * ARRAY_SIZE (mips_exec_plt_entry));
12886
}
12887
 
12888
void
12889
_bfd_mips_post_process_headers (bfd *abfd, struct bfd_link_info *link_info)
12890
{
12891
  struct mips_elf_link_hash_table *htab;
12892
  Elf_Internal_Ehdr *i_ehdrp;
12893
 
12894
  i_ehdrp = elf_elfheader (abfd);
12895
  if (link_info)
12896
    {
12897
      htab = mips_elf_hash_table (link_info);
12898
      if (htab->use_plts_and_copy_relocs && !htab->is_vxworks)
12899
        i_ehdrp->e_ident[EI_ABIVERSION] = 1;
12900
    }
12901
}

powered by: WebSVN 2.1.0

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