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

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [binutils-2.18.50/] [bfd/] [elfxx-mips.c] - Blame information for rev 156

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 38 julius
/* MIPS-specific support for ELF
2
   Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
3
   2003, 2004, 2005, 2006, 2007, 2008 Free Software Foundation, Inc.
4
 
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
  /* The number of .got slots used for TLS.  */
149
  unsigned int tls_gotno;
150
  /* The first unused TLS .got entry.  Used only during
151
     mips_elf_initialize_tls_index.  */
152
  unsigned int tls_assigned_gotno;
153
  /* The number of local .got entries, eventually including page entries.  */
154
  unsigned int local_gotno;
155
  /* The maximum number of page entries needed.  */
156
  unsigned int page_gotno;
157
  /* The number of local .got entries we have used.  */
158
  unsigned int assigned_gotno;
159
  /* A hash table holding members of the got.  */
160
  struct htab *got_entries;
161
  /* A hash table of mips_got_page_entry structures.  */
162
  struct htab *got_page_entries;
163
  /* A hash table mapping input bfds to other mips_got_info.  NULL
164
     unless multi-got was necessary.  */
165
  struct htab *bfd2got;
166
  /* In multi-got links, a pointer to the next got (err, rather, most
167
     of the time, it points to the previous got).  */
168
  struct mips_got_info *next;
169
  /* This is the GOT index of the TLS LDM entry for the GOT, MINUS_ONE
170
     for none, or MINUS_TWO for not yet assigned.  This is needed
171
     because a single-GOT link may have multiple hash table entries
172
     for the LDM.  It does not get initialized in multi-GOT mode.  */
173
  bfd_vma tls_ldm_offset;
174
};
175
 
176
/* Map an input bfd to a got in a multi-got link.  */
177
 
178
struct mips_elf_bfd2got_hash {
179
  bfd *bfd;
180
  struct mips_got_info *g;
181
};
182
 
183
/* Structure passed when traversing the bfd2got hash table, used to
184
   create and merge bfd's gots.  */
185
 
186
struct mips_elf_got_per_bfd_arg
187
{
188
  /* A hashtable that maps bfds to gots.  */
189
  htab_t bfd2got;
190
  /* The output bfd.  */
191
  bfd *obfd;
192
  /* The link information.  */
193
  struct bfd_link_info *info;
194
  /* A pointer to the primary got, i.e., the one that's going to get
195
     the implicit relocations from DT_MIPS_LOCAL_GOTNO and
196
     DT_MIPS_GOTSYM.  */
197
  struct mips_got_info *primary;
198
  /* A non-primary got we're trying to merge with other input bfd's
199
     gots.  */
200
  struct mips_got_info *current;
201
  /* The maximum number of got entries that can be addressed with a
202
     16-bit offset.  */
203
  unsigned int max_count;
204
  /* The maximum number of page entries needed by each got.  */
205
  unsigned int max_pages;
206
  /* The total number of global entries which will live in the
207
     primary got and be automatically relocated.  This includes
208
     those not referenced by the primary GOT but included in
209
     the "master" GOT.  */
210
  unsigned int global_count;
211
};
212
 
213
/* Another structure used to pass arguments for got entries traversal.  */
214
 
215
struct mips_elf_set_global_got_offset_arg
216
{
217
  struct mips_got_info *g;
218
  int value;
219
  unsigned int needed_relocs;
220
  struct bfd_link_info *info;
221
};
222
 
223
/* A structure used to count TLS relocations or GOT entries, for GOT
224
   entry or ELF symbol table traversal.  */
225
 
226
struct mips_elf_count_tls_arg
227
{
228
  struct bfd_link_info *info;
229
  unsigned int needed;
230
};
231
 
232
struct _mips_elf_section_data
233
{
234
  struct bfd_elf_section_data elf;
235
  union
236
  {
237
    struct mips_got_info *got_info;
238
    bfd_byte *tdata;
239
  } u;
240
};
241
 
242
#define mips_elf_section_data(sec) \
243
  ((struct _mips_elf_section_data *) elf_section_data (sec))
244
 
245
/* This structure is passed to mips_elf_sort_hash_table_f when sorting
246
   the dynamic symbols.  */
247
 
248
struct mips_elf_hash_sort_data
249
{
250
  /* The symbol in the global GOT with the lowest dynamic symbol table
251
     index.  */
252
  struct elf_link_hash_entry *low;
253
  /* The least dynamic symbol table index corresponding to a non-TLS
254
     symbol with a GOT entry.  */
255
  long min_got_dynindx;
256
  /* The greatest dynamic symbol table index corresponding to a symbol
257
     with a GOT entry that is not referenced (e.g., a dynamic symbol
258
     with dynamic relocations pointing to it from non-primary GOTs).  */
259
  long max_unref_got_dynindx;
260
  /* The greatest dynamic symbol table index not corresponding to a
261
     symbol without a GOT entry.  */
262
  long max_non_got_dynindx;
263
};
264
 
265
/* The MIPS ELF linker needs additional information for each symbol in
266
   the global hash table.  */
267
 
268
struct mips_elf_link_hash_entry
269
{
270
  struct elf_link_hash_entry root;
271
 
272
  /* External symbol information.  */
273
  EXTR esym;
274
 
275
  /* Number of R_MIPS_32, R_MIPS_REL32, or R_MIPS_64 relocs against
276
     this symbol.  */
277
  unsigned int possibly_dynamic_relocs;
278
 
279
  /* If the R_MIPS_32, R_MIPS_REL32, or R_MIPS_64 reloc is against
280
     a readonly section.  */
281
  bfd_boolean readonly_reloc;
282
 
283
  /* We must not create a stub for a symbol that has relocations
284
     related to taking the function's address, i.e. any but
285
     R_MIPS_CALL*16 ones -- see "MIPS ABI Supplement, 3rd Edition",
286
     p. 4-20.  */
287
  bfd_boolean no_fn_stub;
288
 
289
  /* If there is a stub that 32 bit functions should use to call this
290
     16 bit function, this points to the section containing the stub.  */
291
  asection *fn_stub;
292
 
293
  /* Whether we need the fn_stub; this is set if this symbol appears
294
     in any relocs other than a 16 bit call.  */
295
  bfd_boolean need_fn_stub;
296
 
297
  /* If there is a stub that 16 bit functions should use to call this
298
     32 bit function, this points to the section containing the stub.  */
299
  asection *call_stub;
300
 
301
  /* This is like the call_stub field, but it is used if the function
302
     being called returns a floating point value.  */
303
  asection *call_fp_stub;
304
 
305
  /* Are we forced local?  This will only be set if we have converted
306
     the initial global GOT entry to a local GOT entry.  */
307
  bfd_boolean forced_local;
308
 
309
  /* Are we referenced by some kind of relocation?  */
310
  bfd_boolean is_relocation_target;
311
 
312
  /* Are we referenced by branch relocations?  */
313
  bfd_boolean is_branch_target;
314
 
315
#define GOT_NORMAL      0
316
#define GOT_TLS_GD      1
317
#define GOT_TLS_LDM     2
318
#define GOT_TLS_IE      4
319
#define GOT_TLS_OFFSET_DONE    0x40
320
#define GOT_TLS_DONE    0x80
321
  unsigned char tls_type;
322
  /* This is only used in single-GOT mode; in multi-GOT mode there
323
     is one mips_got_entry per GOT entry, so the offset is stored
324
     there.  In single-GOT mode there may be many mips_got_entry
325
     structures all referring to the same GOT slot.  It might be
326
     possible to use root.got.offset instead, but that field is
327
     overloaded already.  */
328
  bfd_vma tls_got_offset;
329
};
330
 
331
/* MIPS ELF linker hash table.  */
332
 
333
struct mips_elf_link_hash_table
334
{
335
  struct elf_link_hash_table root;
336
#if 0
337
  /* We no longer use this.  */
338
  /* String section indices for the dynamic section symbols.  */
339
  bfd_size_type dynsym_sec_strindex[SIZEOF_MIPS_DYNSYM_SECNAMES];
340
#endif
341
  /* The number of .rtproc entries.  */
342
  bfd_size_type procedure_count;
343
  /* The size of the .compact_rel section (if SGI_COMPAT).  */
344
  bfd_size_type compact_rel_size;
345
  /* This flag indicates that the value of DT_MIPS_RLD_MAP dynamic
346
     entry is set to the address of __rld_obj_head as in IRIX5.  */
347
  bfd_boolean use_rld_obj_head;
348
  /* This is the value of the __rld_map or __rld_obj_head symbol.  */
349
  bfd_vma rld_value;
350
  /* This is set if we see any mips16 stub sections.  */
351
  bfd_boolean mips16_stubs_seen;
352
  /* True if we've computed the size of the GOT.  */
353
  bfd_boolean computed_got_sizes;
354
  /* True if we're generating code for VxWorks.  */
355
  bfd_boolean is_vxworks;
356
  /* True if we already reported the small-data section overflow.  */
357
  bfd_boolean small_data_overflow_reported;
358
  /* Shortcuts to some dynamic sections, or NULL if they are not
359
     being used.  */
360
  asection *srelbss;
361
  asection *sdynbss;
362
  asection *srelplt;
363
  asection *srelplt2;
364
  asection *sgotplt;
365
  asection *splt;
366
  /* The size of the PLT header in bytes (VxWorks only).  */
367
  bfd_vma plt_header_size;
368
  /* The size of a PLT entry in bytes (VxWorks only).  */
369
  bfd_vma plt_entry_size;
370
  /* The size of a function stub entry in bytes.  */
371
  bfd_vma function_stub_size;
372
};
373
 
374
#define TLS_RELOC_P(r_type) \
375
  (r_type == R_MIPS_TLS_DTPMOD32                \
376
   || r_type == R_MIPS_TLS_DTPMOD64             \
377
   || r_type == R_MIPS_TLS_DTPREL32             \
378
   || r_type == R_MIPS_TLS_DTPREL64             \
379
   || r_type == R_MIPS_TLS_GD                   \
380
   || r_type == R_MIPS_TLS_LDM                  \
381
   || r_type == R_MIPS_TLS_DTPREL_HI16          \
382
   || r_type == R_MIPS_TLS_DTPREL_LO16          \
383
   || r_type == R_MIPS_TLS_GOTTPREL             \
384
   || r_type == R_MIPS_TLS_TPREL32              \
385
   || r_type == R_MIPS_TLS_TPREL64              \
386
   || r_type == R_MIPS_TLS_TPREL_HI16           \
387
   || r_type == R_MIPS_TLS_TPREL_LO16)
388
 
389
/* Structure used to pass information to mips_elf_output_extsym.  */
390
 
391
struct extsym_info
392
{
393
  bfd *abfd;
394
  struct bfd_link_info *info;
395
  struct ecoff_debug_info *debug;
396
  const struct ecoff_debug_swap *swap;
397
  bfd_boolean failed;
398
};
399
 
400
/* The names of the runtime procedure table symbols used on IRIX5.  */
401
 
402
static const char * const mips_elf_dynsym_rtproc_names[] =
403
{
404
  "_procedure_table",
405
  "_procedure_string_table",
406
  "_procedure_table_size",
407
  NULL
408
};
409
 
410
/* These structures are used to generate the .compact_rel section on
411
   IRIX5.  */
412
 
413
typedef struct
414
{
415
  unsigned long id1;            /* Always one?  */
416
  unsigned long num;            /* Number of compact relocation entries.  */
417
  unsigned long id2;            /* Always two?  */
418
  unsigned long offset;         /* The file offset of the first relocation.  */
419
  unsigned long reserved0;      /* Zero?  */
420
  unsigned long reserved1;      /* Zero?  */
421
} Elf32_compact_rel;
422
 
423
typedef struct
424
{
425
  bfd_byte id1[4];
426
  bfd_byte num[4];
427
  bfd_byte id2[4];
428
  bfd_byte offset[4];
429
  bfd_byte reserved0[4];
430
  bfd_byte reserved1[4];
431
} Elf32_External_compact_rel;
432
 
433
typedef struct
434
{
435
  unsigned int ctype : 1;       /* 1: long 0: short format. See below.  */
436
  unsigned int rtype : 4;       /* Relocation types. See below.  */
437
  unsigned int dist2to : 8;
438
  unsigned int relvaddr : 19;   /* (VADDR - vaddr of the previous entry)/ 4 */
439
  unsigned long konst;          /* KONST field. See below.  */
440
  unsigned long vaddr;          /* VADDR to be relocated.  */
441
} Elf32_crinfo;
442
 
443
typedef struct
444
{
445
  unsigned int ctype : 1;       /* 1: long 0: short format. See below.  */
446
  unsigned int rtype : 4;       /* Relocation types. See below.  */
447
  unsigned int dist2to : 8;
448
  unsigned int relvaddr : 19;   /* (VADDR - vaddr of the previous entry)/ 4 */
449
  unsigned long konst;          /* KONST field. See below.  */
450
} Elf32_crinfo2;
451
 
452
typedef struct
453
{
454
  bfd_byte info[4];
455
  bfd_byte konst[4];
456
  bfd_byte vaddr[4];
457
} Elf32_External_crinfo;
458
 
459
typedef struct
460
{
461
  bfd_byte info[4];
462
  bfd_byte konst[4];
463
} Elf32_External_crinfo2;
464
 
465
/* These are the constants used to swap the bitfields in a crinfo.  */
466
 
467
#define CRINFO_CTYPE (0x1)
468
#define CRINFO_CTYPE_SH (31)
469
#define CRINFO_RTYPE (0xf)
470
#define CRINFO_RTYPE_SH (27)
471
#define CRINFO_DIST2TO (0xff)
472
#define CRINFO_DIST2TO_SH (19)
473
#define CRINFO_RELVADDR (0x7ffff)
474
#define CRINFO_RELVADDR_SH (0)
475
 
476
/* A compact relocation info has long (3 words) or short (2 words)
477
   formats.  A short format doesn't have VADDR field and relvaddr
478
   fields contains ((VADDR - vaddr of the previous entry) >> 2).  */
479
#define CRF_MIPS_LONG                   1
480
#define CRF_MIPS_SHORT                  0
481
 
482
/* There are 4 types of compact relocation at least. The value KONST
483
   has different meaning for each type:
484
 
485
   (type)               (konst)
486
   CT_MIPS_REL32        Address in data
487
   CT_MIPS_WORD         Address in word (XXX)
488
   CT_MIPS_GPHI_LO      GP - vaddr
489
   CT_MIPS_JMPAD        Address to jump
490
   */
491
 
492
#define CRT_MIPS_REL32                  0xa
493
#define CRT_MIPS_WORD                   0xb
494
#define CRT_MIPS_GPHI_LO                0xc
495
#define CRT_MIPS_JMPAD                  0xd
496
 
497
#define mips_elf_set_cr_format(x,format)        ((x).ctype = (format))
498
#define mips_elf_set_cr_type(x,type)            ((x).rtype = (type))
499
#define mips_elf_set_cr_dist2to(x,v)            ((x).dist2to = (v))
500
#define mips_elf_set_cr_relvaddr(x,d)           ((x).relvaddr = (d)<<2)
501
 
502
/* The structure of the runtime procedure descriptor created by the
503
   loader for use by the static exception system.  */
504
 
505
typedef struct runtime_pdr {
506
        bfd_vma adr;            /* Memory address of start of procedure.  */
507
        long    regmask;        /* Save register mask.  */
508
        long    regoffset;      /* Save register offset.  */
509
        long    fregmask;       /* Save floating point register mask.  */
510
        long    fregoffset;     /* Save floating point register offset.  */
511
        long    frameoffset;    /* Frame size.  */
512
        short   framereg;       /* Frame pointer register.  */
513
        short   pcreg;          /* Offset or reg of return pc.  */
514
        long    irpss;          /* Index into the runtime string table.  */
515
        long    reserved;
516
        struct exception_info *exception_info;/* Pointer to exception array.  */
517
} RPDR, *pRPDR;
518
#define cbRPDR sizeof (RPDR)
519
#define rpdNil ((pRPDR) 0)
520
 
521
static struct mips_got_entry *mips_elf_create_local_got_entry
522
  (bfd *, struct bfd_link_info *, bfd *, struct mips_got_info *, asection *,
523
   bfd_vma, unsigned long, struct mips_elf_link_hash_entry *, int);
524
static bfd_boolean mips_elf_sort_hash_table_f
525
  (struct mips_elf_link_hash_entry *, void *);
526
static bfd_vma mips_elf_high
527
  (bfd_vma);
528
static bfd_boolean mips16_stub_section_p
529
  (bfd *, asection *);
530
static bfd_boolean mips_elf_create_dynamic_relocation
531
  (bfd *, struct bfd_link_info *, const Elf_Internal_Rela *,
532
   struct mips_elf_link_hash_entry *, asection *, bfd_vma,
533
   bfd_vma *, asection *);
534
static hashval_t mips_elf_got_entry_hash
535
  (const void *);
536
static bfd_vma mips_elf_adjust_gp
537
  (bfd *, struct mips_got_info *, bfd *);
538
static struct mips_got_info *mips_elf_got_for_ibfd
539
  (struct mips_got_info *, bfd *);
540
 
541
/* This will be used when we sort the dynamic relocation records.  */
542
static bfd *reldyn_sorting_bfd;
543
 
544
/* Nonzero if ABFD is using the N32 ABI.  */
545
#define ABI_N32_P(abfd) \
546
  ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI2) != 0)
547
 
548
/* Nonzero if ABFD is using the N64 ABI.  */
549
#define ABI_64_P(abfd) \
550
  (get_elf_backend_data (abfd)->s->elfclass == ELFCLASS64)
551
 
552
/* Nonzero if ABFD is using NewABI conventions.  */
553
#define NEWABI_P(abfd) (ABI_N32_P (abfd) || ABI_64_P (abfd))
554
 
555
/* The IRIX compatibility level we are striving for.  */
556
#define IRIX_COMPAT(abfd) \
557
  (get_elf_backend_data (abfd)->elf_backend_mips_irix_compat (abfd))
558
 
559
/* Whether we are trying to be compatible with IRIX at all.  */
560
#define SGI_COMPAT(abfd) \
561
  (IRIX_COMPAT (abfd) != ict_none)
562
 
563
/* The name of the options section.  */
564
#define MIPS_ELF_OPTIONS_SECTION_NAME(abfd) \
565
  (NEWABI_P (abfd) ? ".MIPS.options" : ".options")
566
 
567
/* True if NAME is the recognized name of any SHT_MIPS_OPTIONS section.
568
   Some IRIX system files do not use MIPS_ELF_OPTIONS_SECTION_NAME.  */
569
#define MIPS_ELF_OPTIONS_SECTION_NAME_P(NAME) \
570
  (strcmp (NAME, ".MIPS.options") == 0 || strcmp (NAME, ".options") == 0)
571
 
572
/* Whether the section is readonly.  */
573
#define MIPS_ELF_READONLY_SECTION(sec) \
574
  ((sec->flags & (SEC_ALLOC | SEC_LOAD | SEC_READONLY))         \
575
   == (SEC_ALLOC | SEC_LOAD | SEC_READONLY))
576
 
577
/* The name of the stub section.  */
578
#define MIPS_ELF_STUB_SECTION_NAME(abfd) ".MIPS.stubs"
579
 
580
/* The size of an external REL relocation.  */
581
#define MIPS_ELF_REL_SIZE(abfd) \
582
  (get_elf_backend_data (abfd)->s->sizeof_rel)
583
 
584
/* The size of an external RELA relocation.  */
585
#define MIPS_ELF_RELA_SIZE(abfd) \
586
  (get_elf_backend_data (abfd)->s->sizeof_rela)
587
 
588
/* The size of an external dynamic table entry.  */
589
#define MIPS_ELF_DYN_SIZE(abfd) \
590
  (get_elf_backend_data (abfd)->s->sizeof_dyn)
591
 
592
/* The size of a GOT entry.  */
593
#define MIPS_ELF_GOT_SIZE(abfd) \
594
  (get_elf_backend_data (abfd)->s->arch_size / 8)
595
 
596
/* The size of a symbol-table entry.  */
597
#define MIPS_ELF_SYM_SIZE(abfd) \
598
  (get_elf_backend_data (abfd)->s->sizeof_sym)
599
 
600
/* The default alignment for sections, as a power of two.  */
601
#define MIPS_ELF_LOG_FILE_ALIGN(abfd)                           \
602
  (get_elf_backend_data (abfd)->s->log_file_align)
603
 
604
/* Get word-sized data.  */
605
#define MIPS_ELF_GET_WORD(abfd, ptr) \
606
  (ABI_64_P (abfd) ? bfd_get_64 (abfd, ptr) : bfd_get_32 (abfd, ptr))
607
 
608
/* Put out word-sized data.  */
609
#define MIPS_ELF_PUT_WORD(abfd, val, ptr)       \
610
  (ABI_64_P (abfd)                              \
611
   ? bfd_put_64 (abfd, val, ptr)                \
612
   : bfd_put_32 (abfd, val, ptr))
613
 
614
/* Add a dynamic symbol table-entry.  */
615
#define MIPS_ELF_ADD_DYNAMIC_ENTRY(info, tag, val)      \
616
  _bfd_elf_add_dynamic_entry (info, tag, val)
617
 
618
#define MIPS_ELF_RTYPE_TO_HOWTO(abfd, rtype, rela)                      \
619
  (get_elf_backend_data (abfd)->elf_backend_mips_rtype_to_howto (rtype, rela))
620
 
621
/* Determine whether the internal relocation of index REL_IDX is REL
622
   (zero) or RELA (non-zero).  The assumption is that, if there are
623
   two relocation sections for this section, one of them is REL and
624
   the other is RELA.  If the index of the relocation we're testing is
625
   in range for the first relocation section, check that the external
626
   relocation size is that for RELA.  It is also assumed that, if
627
   rel_idx is not in range for the first section, and this first
628
   section contains REL relocs, then the relocation is in the second
629
   section, that is RELA.  */
630
#define MIPS_RELOC_RELA_P(abfd, sec, rel_idx)                           \
631
  ((NUM_SHDR_ENTRIES (&elf_section_data (sec)->rel_hdr)                 \
632
    * get_elf_backend_data (abfd)->s->int_rels_per_ext_rel              \
633
    > (bfd_vma)(rel_idx))                                               \
634
   == (elf_section_data (sec)->rel_hdr.sh_entsize                       \
635
       == (ABI_64_P (abfd) ? sizeof (Elf64_External_Rela)               \
636
           : sizeof (Elf32_External_Rela))))
637
 
638
/* The name of the dynamic relocation section.  */
639
#define MIPS_ELF_REL_DYN_NAME(INFO) \
640
  (mips_elf_hash_table (INFO)->is_vxworks ? ".rela.dyn" : ".rel.dyn")
641
 
642
/* In case we're on a 32-bit machine, construct a 64-bit "-1" value
643
   from smaller values.  Start with zero, widen, *then* decrement.  */
644
#define MINUS_ONE       (((bfd_vma)0) - 1)
645
#define MINUS_TWO       (((bfd_vma)0) - 2)
646
 
647
/* The number of local .got entries we reserve.  */
648
#define MIPS_RESERVED_GOTNO(INFO) \
649
  (mips_elf_hash_table (INFO)->is_vxworks ? 3 : 2)
650
 
651
/* The value to write into got[1] for SVR4 targets, to identify it is
652
   a GNU object.  The dynamic linker can then use got[1] to store the
653
   module pointer.  */
654
#define MIPS_ELF_GNU_GOT1_MASK(abfd) \
655
  ((bfd_vma) 1 << (ABI_64_P (abfd) ? 63 : 31))
656
 
657
/* The offset of $gp from the beginning of the .got section.  */
658
#define ELF_MIPS_GP_OFFSET(INFO) \
659
  (mips_elf_hash_table (INFO)->is_vxworks ? 0x0 : 0x7ff0)
660
 
661
/* The maximum size of the GOT for it to be addressable using 16-bit
662
   offsets from $gp.  */
663
#define MIPS_ELF_GOT_MAX_SIZE(INFO) (ELF_MIPS_GP_OFFSET (INFO) + 0x7fff)
664
 
665
/* Instructions which appear in a stub.  */
666
#define STUB_LW(abfd)                                                   \
667
  ((ABI_64_P (abfd)                                                     \
668
    ? 0xdf998010                                /* ld t9,0x8010(gp) */  \
669
    : 0x8f998010))                              /* lw t9,0x8010(gp) */
670
#define STUB_MOVE(abfd)                                                 \
671
   ((ABI_64_P (abfd)                                                    \
672
     ? 0x03e0782d                               /* daddu t7,ra */       \
673
     : 0x03e07821))                             /* addu t7,ra */
674
#define STUB_LUI(VAL) (0x3c180000 + (VAL))      /* lui t8,VAL */
675
#define STUB_JALR 0x0320f809                    /* jalr t9,ra */
676
#define STUB_ORI(VAL) (0x37180000 + (VAL))      /* ori t8,t8,VAL */
677
#define STUB_LI16U(VAL) (0x34180000 + (VAL))    /* ori t8,zero,VAL unsigned */
678
#define STUB_LI16S(abfd, VAL)                                           \
679
   ((ABI_64_P (abfd)                                                    \
680
    ? (0x64180000 + (VAL))      /* daddiu t8,zero,VAL sign extended */  \
681
    : (0x24180000 + (VAL))))    /* addiu t8,zero,VAL sign extended */
682
 
683
#define MIPS_FUNCTION_STUB_NORMAL_SIZE 16
684
#define MIPS_FUNCTION_STUB_BIG_SIZE 20
685
 
686
/* The name of the dynamic interpreter.  This is put in the .interp
687
   section.  */
688
 
689
#define ELF_DYNAMIC_INTERPRETER(abfd)           \
690
   (ABI_N32_P (abfd) ? "/usr/lib32/libc.so.1"   \
691
    : ABI_64_P (abfd) ? "/usr/lib64/libc.so.1"  \
692
    : "/usr/lib/libc.so.1")
693
 
694
#ifdef BFD64
695
#define MNAME(bfd,pre,pos) \
696
  (ABI_64_P (bfd) ? CONCAT4 (pre,64,_,pos) : CONCAT4 (pre,32,_,pos))
697
#define ELF_R_SYM(bfd, i)                                       \
698
  (ABI_64_P (bfd) ? ELF64_R_SYM (i) : ELF32_R_SYM (i))
699
#define ELF_R_TYPE(bfd, i)                                      \
700
  (ABI_64_P (bfd) ? ELF64_MIPS_R_TYPE (i) : ELF32_R_TYPE (i))
701
#define ELF_R_INFO(bfd, s, t)                                   \
702
  (ABI_64_P (bfd) ? ELF64_R_INFO (s, t) : ELF32_R_INFO (s, t))
703
#else
704
#define MNAME(bfd,pre,pos) CONCAT4 (pre,32,_,pos)
705
#define ELF_R_SYM(bfd, i)                                       \
706
  (ELF32_R_SYM (i))
707
#define ELF_R_TYPE(bfd, i)                                      \
708
  (ELF32_R_TYPE (i))
709
#define ELF_R_INFO(bfd, s, t)                                   \
710
  (ELF32_R_INFO (s, t))
711
#endif
712
 
713
  /* The mips16 compiler uses a couple of special sections to handle
714
     floating point arguments.
715
 
716
     Section names that look like .mips16.fn.FNNAME contain stubs that
717
     copy floating point arguments from the fp regs to the gp regs and
718
     then jump to FNNAME.  If any 32 bit function calls FNNAME, the
719
     call should be redirected to the stub instead.  If no 32 bit
720
     function calls FNNAME, the stub should be discarded.  We need to
721
     consider any reference to the function, not just a call, because
722
     if the address of the function is taken we will need the stub,
723
     since the address might be passed to a 32 bit function.
724
 
725
     Section names that look like .mips16.call.FNNAME contain stubs
726
     that copy floating point arguments from the gp regs to the fp
727
     regs and then jump to FNNAME.  If FNNAME is a 32 bit function,
728
     then any 16 bit function that calls FNNAME should be redirected
729
     to the stub instead.  If FNNAME is not a 32 bit function, the
730
     stub should be discarded.
731
 
732
     .mips16.call.fp.FNNAME sections are similar, but contain stubs
733
     which call FNNAME and then copy the return value from the fp regs
734
     to the gp regs.  These stubs store the return value in $18 while
735
     calling FNNAME; any function which might call one of these stubs
736
     must arrange to save $18 around the call.  (This case is not
737
     needed for 32 bit functions that call 16 bit functions, because
738
     16 bit functions always return floating point values in both
739
     $f0/$f1 and $2/$3.)
740
 
741
     Note that in all cases FNNAME might be defined statically.
742
     Therefore, FNNAME is not used literally.  Instead, the relocation
743
     information will indicate which symbol the section is for.
744
 
745
     We record any stubs that we find in the symbol table.  */
746
 
747
#define FN_STUB ".mips16.fn."
748
#define CALL_STUB ".mips16.call."
749
#define CALL_FP_STUB ".mips16.call.fp."
750
 
751
#define FN_STUB_P(name) CONST_STRNEQ (name, FN_STUB)
752
#define CALL_STUB_P(name) CONST_STRNEQ (name, CALL_STUB)
753
#define CALL_FP_STUB_P(name) CONST_STRNEQ (name, CALL_FP_STUB)
754
 
755
/* The format of the first PLT entry in a VxWorks executable.  */
756
static const bfd_vma mips_vxworks_exec_plt0_entry[] = {
757
  0x3c190000,   /* lui t9, %hi(_GLOBAL_OFFSET_TABLE_)           */
758
  0x27390000,   /* addiu t9, t9, %lo(_GLOBAL_OFFSET_TABLE_)     */
759
  0x8f390008,   /* lw t9, 8(t9)                                 */
760
  0x00000000,   /* nop                                          */
761
  0x03200008,   /* jr t9                                        */
762
  0x00000000    /* nop                                          */
763
};
764
 
765
/* The format of subsequent PLT entries.  */
766
static const bfd_vma mips_vxworks_exec_plt_entry[] = {
767
  0x10000000,   /* b .PLT_resolver                      */
768
  0x24180000,   /* li t8, <pltindex>                    */
769
  0x3c190000,   /* lui t9, %hi(<.got.plt slot>)         */
770
  0x27390000,   /* addiu t9, t9, %lo(<.got.plt slot>)   */
771
  0x8f390000,   /* lw t9, 0(t9)                         */
772
  0x00000000,   /* nop                                  */
773
  0x03200008,   /* jr t9                                */
774
  0x00000000    /* nop                                  */
775
};
776
 
777
/* The format of the first PLT entry in a VxWorks shared object.  */
778
static const bfd_vma mips_vxworks_shared_plt0_entry[] = {
779
  0x8f990008,   /* lw t9, 8(gp)         */
780
  0x00000000,   /* nop                  */
781
  0x03200008,   /* jr t9                */
782
  0x00000000,   /* nop                  */
783
  0x00000000,   /* nop                  */
784
  0x00000000    /* nop                  */
785
};
786
 
787
/* The format of subsequent PLT entries.  */
788
static const bfd_vma mips_vxworks_shared_plt_entry[] = {
789
  0x10000000,   /* b .PLT_resolver      */
790
  0x24180000    /* li t8, <pltindex>    */
791
};
792
 
793
/* Look up an entry in a MIPS ELF linker hash table.  */
794
 
795
#define mips_elf_link_hash_lookup(table, string, create, copy, follow)  \
796
  ((struct mips_elf_link_hash_entry *)                                  \
797
   elf_link_hash_lookup (&(table)->root, (string), (create),            \
798
                         (copy), (follow)))
799
 
800
/* Traverse a MIPS ELF linker hash table.  */
801
 
802
#define mips_elf_link_hash_traverse(table, func, info)                  \
803
  (elf_link_hash_traverse                                               \
804
   (&(table)->root,                                                     \
805
    (bfd_boolean (*) (struct elf_link_hash_entry *, void *)) (func),    \
806
    (info)))
807
 
808
/* Get the MIPS ELF linker hash table from a link_info structure.  */
809
 
810
#define mips_elf_hash_table(p) \
811
  ((struct mips_elf_link_hash_table *) ((p)->hash))
812
 
813
/* Find the base offsets for thread-local storage in this object,
814
   for GD/LD and IE/LE respectively.  */
815
 
816
#define TP_OFFSET 0x7000
817
#define DTP_OFFSET 0x8000
818
 
819
static bfd_vma
820
dtprel_base (struct bfd_link_info *info)
821
{
822
  /* If tls_sec is NULL, we should have signalled an error already.  */
823
  if (elf_hash_table (info)->tls_sec == NULL)
824
    return 0;
825
  return elf_hash_table (info)->tls_sec->vma + DTP_OFFSET;
826
}
827
 
828
static bfd_vma
829
tprel_base (struct bfd_link_info *info)
830
{
831
  /* If tls_sec is NULL, we should have signalled an error already.  */
832
  if (elf_hash_table (info)->tls_sec == NULL)
833
    return 0;
834
  return elf_hash_table (info)->tls_sec->vma + TP_OFFSET;
835
}
836
 
837
/* Create an entry in a MIPS ELF linker hash table.  */
838
 
839
static struct bfd_hash_entry *
840
mips_elf_link_hash_newfunc (struct bfd_hash_entry *entry,
841
                            struct bfd_hash_table *table, const char *string)
842
{
843
  struct mips_elf_link_hash_entry *ret =
844
    (struct mips_elf_link_hash_entry *) entry;
845
 
846
  /* Allocate the structure if it has not already been allocated by a
847
     subclass.  */
848
  if (ret == NULL)
849
    ret = bfd_hash_allocate (table, sizeof (struct mips_elf_link_hash_entry));
850
  if (ret == NULL)
851
    return (struct bfd_hash_entry *) ret;
852
 
853
  /* Call the allocation method of the superclass.  */
854
  ret = ((struct mips_elf_link_hash_entry *)
855
         _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
856
                                     table, string));
857
  if (ret != NULL)
858
    {
859
      /* Set local fields.  */
860
      memset (&ret->esym, 0, sizeof (EXTR));
861
      /* We use -2 as a marker to indicate that the information has
862
         not been set.  -1 means there is no associated ifd.  */
863
      ret->esym.ifd = -2;
864
      ret->possibly_dynamic_relocs = 0;
865
      ret->readonly_reloc = FALSE;
866
      ret->no_fn_stub = FALSE;
867
      ret->fn_stub = NULL;
868
      ret->need_fn_stub = FALSE;
869
      ret->call_stub = NULL;
870
      ret->call_fp_stub = NULL;
871
      ret->forced_local = FALSE;
872
      ret->is_branch_target = FALSE;
873
      ret->is_relocation_target = FALSE;
874
      ret->tls_type = GOT_NORMAL;
875
    }
876
 
877
  return (struct bfd_hash_entry *) ret;
878
}
879
 
880
bfd_boolean
881
_bfd_mips_elf_new_section_hook (bfd *abfd, asection *sec)
882
{
883
  if (!sec->used_by_bfd)
884
    {
885
      struct _mips_elf_section_data *sdata;
886
      bfd_size_type amt = sizeof (*sdata);
887
 
888
      sdata = bfd_zalloc (abfd, amt);
889
      if (sdata == NULL)
890
        return FALSE;
891
      sec->used_by_bfd = sdata;
892
    }
893
 
894
  return _bfd_elf_new_section_hook (abfd, sec);
895
}
896
 
897
/* Read ECOFF debugging information from a .mdebug section into a
898
   ecoff_debug_info structure.  */
899
 
900
bfd_boolean
901
_bfd_mips_elf_read_ecoff_info (bfd *abfd, asection *section,
902
                               struct ecoff_debug_info *debug)
903
{
904
  HDRR *symhdr;
905
  const struct ecoff_debug_swap *swap;
906
  char *ext_hdr;
907
 
908
  swap = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
909
  memset (debug, 0, sizeof (*debug));
910
 
911
  ext_hdr = bfd_malloc (swap->external_hdr_size);
912
  if (ext_hdr == NULL && swap->external_hdr_size != 0)
913
    goto error_return;
914
 
915
  if (! bfd_get_section_contents (abfd, section, ext_hdr, 0,
916
                                  swap->external_hdr_size))
917
    goto error_return;
918
 
919
  symhdr = &debug->symbolic_header;
920
  (*swap->swap_hdr_in) (abfd, ext_hdr, symhdr);
921
 
922
  /* The symbolic header contains absolute file offsets and sizes to
923
     read.  */
924
#define READ(ptr, offset, count, size, type)                            \
925
  if (symhdr->count == 0)                                                \
926
    debug->ptr = NULL;                                                  \
927
  else                                                                  \
928
    {                                                                   \
929
      bfd_size_type amt = (bfd_size_type) size * symhdr->count;         \
930
      debug->ptr = bfd_malloc (amt);                                    \
931
      if (debug->ptr == NULL)                                           \
932
        goto error_return;                                              \
933
      if (bfd_seek (abfd, symhdr->offset, SEEK_SET) != 0         \
934
          || bfd_bread (debug->ptr, amt, abfd) != amt)                  \
935
        goto error_return;                                              \
936
    }
937
 
938
  READ (line, cbLineOffset, cbLine, sizeof (unsigned char), unsigned char *);
939
  READ (external_dnr, cbDnOffset, idnMax, swap->external_dnr_size, void *);
940
  READ (external_pdr, cbPdOffset, ipdMax, swap->external_pdr_size, void *);
941
  READ (external_sym, cbSymOffset, isymMax, swap->external_sym_size, void *);
942
  READ (external_opt, cbOptOffset, ioptMax, swap->external_opt_size, void *);
943
  READ (external_aux, cbAuxOffset, iauxMax, sizeof (union aux_ext),
944
        union aux_ext *);
945
  READ (ss, cbSsOffset, issMax, sizeof (char), char *);
946
  READ (ssext, cbSsExtOffset, issExtMax, sizeof (char), char *);
947
  READ (external_fdr, cbFdOffset, ifdMax, swap->external_fdr_size, void *);
948
  READ (external_rfd, cbRfdOffset, crfd, swap->external_rfd_size, void *);
949
  READ (external_ext, cbExtOffset, iextMax, swap->external_ext_size, void *);
950
#undef READ
951
 
952
  debug->fdr = NULL;
953
 
954
  return TRUE;
955
 
956
 error_return:
957
  if (ext_hdr != NULL)
958
    free (ext_hdr);
959
  if (debug->line != NULL)
960
    free (debug->line);
961
  if (debug->external_dnr != NULL)
962
    free (debug->external_dnr);
963
  if (debug->external_pdr != NULL)
964
    free (debug->external_pdr);
965
  if (debug->external_sym != NULL)
966
    free (debug->external_sym);
967
  if (debug->external_opt != NULL)
968
    free (debug->external_opt);
969
  if (debug->external_aux != NULL)
970
    free (debug->external_aux);
971
  if (debug->ss != NULL)
972
    free (debug->ss);
973
  if (debug->ssext != NULL)
974
    free (debug->ssext);
975
  if (debug->external_fdr != NULL)
976
    free (debug->external_fdr);
977
  if (debug->external_rfd != NULL)
978
    free (debug->external_rfd);
979
  if (debug->external_ext != NULL)
980
    free (debug->external_ext);
981
  return FALSE;
982
}
983
 
984
/* Swap RPDR (runtime procedure table entry) for output.  */
985
 
986
static void
987
ecoff_swap_rpdr_out (bfd *abfd, const RPDR *in, struct rpdr_ext *ex)
988
{
989
  H_PUT_S32 (abfd, in->adr, ex->p_adr);
990
  H_PUT_32 (abfd, in->regmask, ex->p_regmask);
991
  H_PUT_32 (abfd, in->regoffset, ex->p_regoffset);
992
  H_PUT_32 (abfd, in->fregmask, ex->p_fregmask);
993
  H_PUT_32 (abfd, in->fregoffset, ex->p_fregoffset);
994
  H_PUT_32 (abfd, in->frameoffset, ex->p_frameoffset);
995
 
996
  H_PUT_16 (abfd, in->framereg, ex->p_framereg);
997
  H_PUT_16 (abfd, in->pcreg, ex->p_pcreg);
998
 
999
  H_PUT_32 (abfd, in->irpss, ex->p_irpss);
1000
}
1001
 
1002
/* Create a runtime procedure table from the .mdebug section.  */
1003
 
1004
static bfd_boolean
1005
mips_elf_create_procedure_table (void *handle, bfd *abfd,
1006
                                 struct bfd_link_info *info, asection *s,
1007
                                 struct ecoff_debug_info *debug)
1008
{
1009
  const struct ecoff_debug_swap *swap;
1010
  HDRR *hdr = &debug->symbolic_header;
1011
  RPDR *rpdr, *rp;
1012
  struct rpdr_ext *erp;
1013
  void *rtproc;
1014
  struct pdr_ext *epdr;
1015
  struct sym_ext *esym;
1016
  char *ss, **sv;
1017
  char *str;
1018
  bfd_size_type size;
1019
  bfd_size_type count;
1020
  unsigned long sindex;
1021
  unsigned long i;
1022
  PDR pdr;
1023
  SYMR sym;
1024
  const char *no_name_func = _("static procedure (no name)");
1025
 
1026
  epdr = NULL;
1027
  rpdr = NULL;
1028
  esym = NULL;
1029
  ss = NULL;
1030
  sv = NULL;
1031
 
1032
  swap = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
1033
 
1034
  sindex = strlen (no_name_func) + 1;
1035
  count = hdr->ipdMax;
1036
  if (count > 0)
1037
    {
1038
      size = swap->external_pdr_size;
1039
 
1040
      epdr = bfd_malloc (size * count);
1041
      if (epdr == NULL)
1042
        goto error_return;
1043
 
1044
      if (! _bfd_ecoff_get_accumulated_pdr (handle, (bfd_byte *) epdr))
1045
        goto error_return;
1046
 
1047
      size = sizeof (RPDR);
1048
      rp = rpdr = bfd_malloc (size * count);
1049
      if (rpdr == NULL)
1050
        goto error_return;
1051
 
1052
      size = sizeof (char *);
1053
      sv = bfd_malloc (size * count);
1054
      if (sv == NULL)
1055
        goto error_return;
1056
 
1057
      count = hdr->isymMax;
1058
      size = swap->external_sym_size;
1059
      esym = bfd_malloc (size * count);
1060
      if (esym == NULL)
1061
        goto error_return;
1062
 
1063
      if (! _bfd_ecoff_get_accumulated_sym (handle, (bfd_byte *) esym))
1064
        goto error_return;
1065
 
1066
      count = hdr->issMax;
1067
      ss = bfd_malloc (count);
1068
      if (ss == NULL)
1069
        goto error_return;
1070
      if (! _bfd_ecoff_get_accumulated_ss (handle, (bfd_byte *) ss))
1071
        goto error_return;
1072
 
1073
      count = hdr->ipdMax;
1074
      for (i = 0; i < (unsigned long) count; i++, rp++)
1075
        {
1076
          (*swap->swap_pdr_in) (abfd, epdr + i, &pdr);
1077
          (*swap->swap_sym_in) (abfd, &esym[pdr.isym], &sym);
1078
          rp->adr = sym.value;
1079
          rp->regmask = pdr.regmask;
1080
          rp->regoffset = pdr.regoffset;
1081
          rp->fregmask = pdr.fregmask;
1082
          rp->fregoffset = pdr.fregoffset;
1083
          rp->frameoffset = pdr.frameoffset;
1084
          rp->framereg = pdr.framereg;
1085
          rp->pcreg = pdr.pcreg;
1086
          rp->irpss = sindex;
1087
          sv[i] = ss + sym.iss;
1088
          sindex += strlen (sv[i]) + 1;
1089
        }
1090
    }
1091
 
1092
  size = sizeof (struct rpdr_ext) * (count + 2) + sindex;
1093
  size = BFD_ALIGN (size, 16);
1094
  rtproc = bfd_alloc (abfd, size);
1095
  if (rtproc == NULL)
1096
    {
1097
      mips_elf_hash_table (info)->procedure_count = 0;
1098
      goto error_return;
1099
    }
1100
 
1101
  mips_elf_hash_table (info)->procedure_count = count + 2;
1102
 
1103
  erp = rtproc;
1104
  memset (erp, 0, sizeof (struct rpdr_ext));
1105
  erp++;
1106
  str = (char *) rtproc + sizeof (struct rpdr_ext) * (count + 2);
1107
  strcpy (str, no_name_func);
1108
  str += strlen (no_name_func) + 1;
1109
  for (i = 0; i < count; i++)
1110
    {
1111
      ecoff_swap_rpdr_out (abfd, rpdr + i, erp + i);
1112
      strcpy (str, sv[i]);
1113
      str += strlen (sv[i]) + 1;
1114
    }
1115
  H_PUT_S32 (abfd, -1, (erp + count)->p_adr);
1116
 
1117
  /* Set the size and contents of .rtproc section.  */
1118
  s->size = size;
1119
  s->contents = rtproc;
1120
 
1121
  /* Skip this section later on (I don't think this currently
1122
     matters, but someday it might).  */
1123
  s->map_head.link_order = NULL;
1124
 
1125
  if (epdr != NULL)
1126
    free (epdr);
1127
  if (rpdr != NULL)
1128
    free (rpdr);
1129
  if (esym != NULL)
1130
    free (esym);
1131
  if (ss != NULL)
1132
    free (ss);
1133
  if (sv != NULL)
1134
    free (sv);
1135
 
1136
  return TRUE;
1137
 
1138
 error_return:
1139
  if (epdr != NULL)
1140
    free (epdr);
1141
  if (rpdr != NULL)
1142
    free (rpdr);
1143
  if (esym != NULL)
1144
    free (esym);
1145
  if (ss != NULL)
1146
    free (ss);
1147
  if (sv != NULL)
1148
    free (sv);
1149
  return FALSE;
1150
}
1151
 
1152
/* Check the mips16 stubs for a particular symbol, and see if we can
1153
   discard them.  */
1154
 
1155
static bfd_boolean
1156
mips_elf_check_mips16_stubs (struct mips_elf_link_hash_entry *h,
1157
                             void *data ATTRIBUTE_UNUSED)
1158
{
1159
  if (h->root.root.type == bfd_link_hash_warning)
1160
    h = (struct mips_elf_link_hash_entry *) h->root.root.u.i.link;
1161
 
1162
  if (h->fn_stub != NULL
1163
      && ! h->need_fn_stub)
1164
    {
1165
      /* We don't need the fn_stub; the only references to this symbol
1166
         are 16 bit calls.  Clobber the size to 0 to prevent it from
1167
         being included in the link.  */
1168
      h->fn_stub->size = 0;
1169
      h->fn_stub->flags &= ~SEC_RELOC;
1170
      h->fn_stub->reloc_count = 0;
1171
      h->fn_stub->flags |= SEC_EXCLUDE;
1172
    }
1173
 
1174
  if (h->call_stub != NULL
1175
      && h->root.other == STO_MIPS16)
1176
    {
1177
      /* We don't need the call_stub; this is a 16 bit function, so
1178
         calls from other 16 bit functions are OK.  Clobber the size
1179
         to 0 to prevent it from being included in the link.  */
1180
      h->call_stub->size = 0;
1181
      h->call_stub->flags &= ~SEC_RELOC;
1182
      h->call_stub->reloc_count = 0;
1183
      h->call_stub->flags |= SEC_EXCLUDE;
1184
    }
1185
 
1186
  if (h->call_fp_stub != NULL
1187
      && h->root.other == STO_MIPS16)
1188
    {
1189
      /* We don't need the call_stub; this is a 16 bit function, so
1190
         calls from other 16 bit functions are OK.  Clobber the size
1191
         to 0 to prevent it from being included in the link.  */
1192
      h->call_fp_stub->size = 0;
1193
      h->call_fp_stub->flags &= ~SEC_RELOC;
1194
      h->call_fp_stub->reloc_count = 0;
1195
      h->call_fp_stub->flags |= SEC_EXCLUDE;
1196
    }
1197
 
1198
  return TRUE;
1199
}
1200
 
1201
/* R_MIPS16_26 is used for the mips16 jal and jalx instructions.
1202
   Most mips16 instructions are 16 bits, but these instructions
1203
   are 32 bits.
1204
 
1205
   The format of these instructions is:
1206
 
1207
   +--------------+--------------------------------+
1208
   |     JALX     | X|   Imm 20:16  |   Imm 25:21  |
1209
   +--------------+--------------------------------+
1210
   |                Immediate  15:0                |
1211
   +-----------------------------------------------+
1212
 
1213
   JALX is the 5-bit value 00011.  X is 0 for jal, 1 for jalx.
1214
   Note that the immediate value in the first word is swapped.
1215
 
1216
   When producing a relocatable object file, R_MIPS16_26 is
1217
   handled mostly like R_MIPS_26.  In particular, the addend is
1218
   stored as a straight 26-bit value in a 32-bit instruction.
1219
   (gas makes life simpler for itself by never adjusting a
1220
   R_MIPS16_26 reloc to be against a section, so the addend is
1221
   always zero).  However, the 32 bit instruction is stored as 2
1222
   16-bit values, rather than a single 32-bit value.  In a
1223
   big-endian file, the result is the same; in a little-endian
1224
   file, the two 16-bit halves of the 32 bit value are swapped.
1225
   This is so that a disassembler can recognize the jal
1226
   instruction.
1227
 
1228
   When doing a final link, R_MIPS16_26 is treated as a 32 bit
1229
   instruction stored as two 16-bit values.  The addend A is the
1230
   contents of the targ26 field.  The calculation is the same as
1231
   R_MIPS_26.  When storing the calculated value, reorder the
1232
   immediate value as shown above, and don't forget to store the
1233
   value as two 16-bit values.
1234
 
1235
   To put it in MIPS ABI terms, the relocation field is T-targ26-16,
1236
   defined as
1237
 
1238
   big-endian:
1239
   +--------+----------------------+
1240
   |        |                      |
1241
   |        |    targ26-16         |
1242
   |31    26|25                   0|
1243
   +--------+----------------------+
1244
 
1245
   little-endian:
1246
   +----------+------+-------------+
1247
   |          |      |             |
1248
   |  sub1    |      |     sub2    |
1249
   |0        9|10  15|16         31|
1250
   +----------+--------------------+
1251
   where targ26-16 is sub1 followed by sub2 (i.e., the addend field A is
1252
   ((sub1 << 16) | sub2)).
1253
 
1254
   When producing a relocatable object file, the calculation is
1255
   (((A < 2) | ((P + 4) & 0xf0000000) + S) >> 2)
1256
   When producing a fully linked file, the calculation is
1257
   let R = (((A < 2) | ((P + 4) & 0xf0000000) + S) >> 2)
1258
   ((R & 0x1f0000) << 5) | ((R & 0x3e00000) >> 5) | (R & 0xffff)
1259
 
1260
   R_MIPS16_GPREL is used for GP-relative addressing in mips16
1261
   mode.  A typical instruction will have a format like this:
1262
 
1263
   +--------------+--------------------------------+
1264
   |    EXTEND    |     Imm 10:5    |   Imm 15:11  |
1265
   +--------------+--------------------------------+
1266
   |    Major     |   rx   |   ry   |   Imm  4:0   |
1267
   +--------------+--------------------------------+
1268
 
1269
   EXTEND is the five bit value 11110.  Major is the instruction
1270
   opcode.
1271
 
1272
   This is handled exactly like R_MIPS_GPREL16, except that the
1273
   addend is retrieved and stored as shown in this diagram; that
1274
   is, the Imm fields above replace the V-rel16 field.
1275
 
1276
   All we need to do here is shuffle the bits appropriately.  As
1277
   above, the two 16-bit halves must be swapped on a
1278
   little-endian system.
1279
 
1280
   R_MIPS16_HI16 and R_MIPS16_LO16 are used in mips16 mode to
1281
   access data when neither GP-relative nor PC-relative addressing
1282
   can be used.  They are handled like R_MIPS_HI16 and R_MIPS_LO16,
1283
   except that the addend is retrieved and stored as shown above
1284
   for R_MIPS16_GPREL.
1285
  */
1286
void
1287
_bfd_mips16_elf_reloc_unshuffle (bfd *abfd, int r_type,
1288
                                 bfd_boolean jal_shuffle, bfd_byte *data)
1289
{
1290
  bfd_vma extend, insn, val;
1291
 
1292
  if (r_type != R_MIPS16_26 && r_type != R_MIPS16_GPREL
1293
      && r_type != R_MIPS16_HI16 && r_type != R_MIPS16_LO16)
1294
    return;
1295
 
1296
  /* Pick up the mips16 extend instruction and the real instruction.  */
1297
  extend = bfd_get_16 (abfd, data);
1298
  insn = bfd_get_16 (abfd, data + 2);
1299
  if (r_type == R_MIPS16_26)
1300
    {
1301
      if (jal_shuffle)
1302
        val = ((extend & 0xfc00) << 16) | ((extend & 0x3e0) << 11)
1303
              | ((extend & 0x1f) << 21) | insn;
1304
      else
1305
        val = extend << 16 | insn;
1306
    }
1307
  else
1308
    val = ((extend & 0xf800) << 16) | ((insn & 0xffe0) << 11)
1309
          | ((extend & 0x1f) << 11) | (extend & 0x7e0) | (insn & 0x1f);
1310
  bfd_put_32 (abfd, val, data);
1311
}
1312
 
1313
void
1314
_bfd_mips16_elf_reloc_shuffle (bfd *abfd, int r_type,
1315
                               bfd_boolean jal_shuffle, bfd_byte *data)
1316
{
1317
  bfd_vma extend, insn, val;
1318
 
1319
  if (r_type != R_MIPS16_26 && r_type != R_MIPS16_GPREL
1320
      && r_type != R_MIPS16_HI16 && r_type != R_MIPS16_LO16)
1321
    return;
1322
 
1323
  val = bfd_get_32 (abfd, data);
1324
  if (r_type == R_MIPS16_26)
1325
    {
1326
      if (jal_shuffle)
1327
        {
1328
          insn = val & 0xffff;
1329
          extend = ((val >> 16) & 0xfc00) | ((val >> 11) & 0x3e0)
1330
                   | ((val >> 21) & 0x1f);
1331
        }
1332
      else
1333
        {
1334
          insn = val & 0xffff;
1335
          extend = val >> 16;
1336
        }
1337
    }
1338
  else
1339
    {
1340
      insn = ((val >> 11) & 0xffe0) | (val & 0x1f);
1341
      extend = ((val >> 16) & 0xf800) | ((val >> 11) & 0x1f) | (val & 0x7e0);
1342
    }
1343
  bfd_put_16 (abfd, insn, data + 2);
1344
  bfd_put_16 (abfd, extend, data);
1345
}
1346
 
1347
bfd_reloc_status_type
1348
_bfd_mips_elf_gprel16_with_gp (bfd *abfd, asymbol *symbol,
1349
                               arelent *reloc_entry, asection *input_section,
1350
                               bfd_boolean relocatable, void *data, bfd_vma gp)
1351
{
1352
  bfd_vma relocation;
1353
  bfd_signed_vma val;
1354
  bfd_reloc_status_type status;
1355
 
1356
  if (bfd_is_com_section (symbol->section))
1357
    relocation = 0;
1358
  else
1359
    relocation = symbol->value;
1360
 
1361
  relocation += symbol->section->output_section->vma;
1362
  relocation += symbol->section->output_offset;
1363
 
1364
  if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
1365
    return bfd_reloc_outofrange;
1366
 
1367
  /* Set val to the offset into the section or symbol.  */
1368
  val = reloc_entry->addend;
1369
 
1370
  _bfd_mips_elf_sign_extend (val, 16);
1371
 
1372
  /* Adjust val for the final section location and GP value.  If we
1373
     are producing relocatable output, we don't want to do this for
1374
     an external symbol.  */
1375
  if (! relocatable
1376
      || (symbol->flags & BSF_SECTION_SYM) != 0)
1377
    val += relocation - gp;
1378
 
1379
  if (reloc_entry->howto->partial_inplace)
1380
    {
1381
      status = _bfd_relocate_contents (reloc_entry->howto, abfd, val,
1382
                                       (bfd_byte *) data
1383
                                       + reloc_entry->address);
1384
      if (status != bfd_reloc_ok)
1385
        return status;
1386
    }
1387
  else
1388
    reloc_entry->addend = val;
1389
 
1390
  if (relocatable)
1391
    reloc_entry->address += input_section->output_offset;
1392
 
1393
  return bfd_reloc_ok;
1394
}
1395
 
1396
/* Used to store a REL high-part relocation such as R_MIPS_HI16 or
1397
   R_MIPS_GOT16.  REL is the relocation, INPUT_SECTION is the section
1398
   that contains the relocation field and DATA points to the start of
1399
   INPUT_SECTION.  */
1400
 
1401
struct mips_hi16
1402
{
1403
  struct mips_hi16 *next;
1404
  bfd_byte *data;
1405
  asection *input_section;
1406
  arelent rel;
1407
};
1408
 
1409
/* FIXME: This should not be a static variable.  */
1410
 
1411
static struct mips_hi16 *mips_hi16_list;
1412
 
1413
/* A howto special_function for REL *HI16 relocations.  We can only
1414
   calculate the correct value once we've seen the partnering
1415
   *LO16 relocation, so just save the information for later.
1416
 
1417
   The ABI requires that the *LO16 immediately follow the *HI16.
1418
   However, as a GNU extension, we permit an arbitrary number of
1419
   *HI16s to be associated with a single *LO16.  This significantly
1420
   simplies the relocation handling in gcc.  */
1421
 
1422
bfd_reloc_status_type
1423
_bfd_mips_elf_hi16_reloc (bfd *abfd ATTRIBUTE_UNUSED, arelent *reloc_entry,
1424
                          asymbol *symbol ATTRIBUTE_UNUSED, void *data,
1425
                          asection *input_section, bfd *output_bfd,
1426
                          char **error_message ATTRIBUTE_UNUSED)
1427
{
1428
  struct mips_hi16 *n;
1429
 
1430
  if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
1431
    return bfd_reloc_outofrange;
1432
 
1433
  n = bfd_malloc (sizeof *n);
1434
  if (n == NULL)
1435
    return bfd_reloc_outofrange;
1436
 
1437
  n->next = mips_hi16_list;
1438
  n->data = data;
1439
  n->input_section = input_section;
1440
  n->rel = *reloc_entry;
1441
  mips_hi16_list = n;
1442
 
1443
  if (output_bfd != NULL)
1444
    reloc_entry->address += input_section->output_offset;
1445
 
1446
  return bfd_reloc_ok;
1447
}
1448
 
1449
/* A howto special_function for REL R_MIPS_GOT16 relocations.  This is just
1450
   like any other 16-bit relocation when applied to global symbols, but is
1451
   treated in the same as R_MIPS_HI16 when applied to local symbols.  */
1452
 
1453
bfd_reloc_status_type
1454
_bfd_mips_elf_got16_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
1455
                           void *data, asection *input_section,
1456
                           bfd *output_bfd, char **error_message)
1457
{
1458
  if ((symbol->flags & (BSF_GLOBAL | BSF_WEAK)) != 0
1459
      || bfd_is_und_section (bfd_get_section (symbol))
1460
      || bfd_is_com_section (bfd_get_section (symbol)))
1461
    /* The relocation is against a global symbol.  */
1462
    return _bfd_mips_elf_generic_reloc (abfd, reloc_entry, symbol, data,
1463
                                        input_section, output_bfd,
1464
                                        error_message);
1465
 
1466
  return _bfd_mips_elf_hi16_reloc (abfd, reloc_entry, symbol, data,
1467
                                   input_section, output_bfd, error_message);
1468
}
1469
 
1470
/* A howto special_function for REL *LO16 relocations.  The *LO16 itself
1471
   is a straightforward 16 bit inplace relocation, but we must deal with
1472
   any partnering high-part relocations as well.  */
1473
 
1474
bfd_reloc_status_type
1475
_bfd_mips_elf_lo16_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
1476
                          void *data, asection *input_section,
1477
                          bfd *output_bfd, char **error_message)
1478
{
1479
  bfd_vma vallo;
1480
  bfd_byte *location = (bfd_byte *) data + reloc_entry->address;
1481
 
1482
  if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
1483
    return bfd_reloc_outofrange;
1484
 
1485
  _bfd_mips16_elf_reloc_unshuffle (abfd, reloc_entry->howto->type, FALSE,
1486
                                   location);
1487
  vallo = bfd_get_32 (abfd, location);
1488
  _bfd_mips16_elf_reloc_shuffle (abfd, reloc_entry->howto->type, FALSE,
1489
                                 location);
1490
 
1491
  while (mips_hi16_list != NULL)
1492
    {
1493
      bfd_reloc_status_type ret;
1494
      struct mips_hi16 *hi;
1495
 
1496
      hi = mips_hi16_list;
1497
 
1498
      /* R_MIPS_GOT16 relocations are something of a special case.  We
1499
         want to install the addend in the same way as for a R_MIPS_HI16
1500
         relocation (with a rightshift of 16).  However, since GOT16
1501
         relocations can also be used with global symbols, their howto
1502
         has a rightshift of 0.  */
1503
      if (hi->rel.howto->type == R_MIPS_GOT16)
1504
        hi->rel.howto = MIPS_ELF_RTYPE_TO_HOWTO (abfd, R_MIPS_HI16, FALSE);
1505
 
1506
      /* VALLO is a signed 16-bit number.  Bias it by 0x8000 so that any
1507
         carry or borrow will induce a change of +1 or -1 in the high part.  */
1508
      hi->rel.addend += (vallo + 0x8000) & 0xffff;
1509
 
1510
      ret = _bfd_mips_elf_generic_reloc (abfd, &hi->rel, symbol, hi->data,
1511
                                         hi->input_section, output_bfd,
1512
                                         error_message);
1513
      if (ret != bfd_reloc_ok)
1514
        return ret;
1515
 
1516
      mips_hi16_list = hi->next;
1517
      free (hi);
1518
    }
1519
 
1520
  return _bfd_mips_elf_generic_reloc (abfd, reloc_entry, symbol, data,
1521
                                      input_section, output_bfd,
1522
                                      error_message);
1523
}
1524
 
1525
/* A generic howto special_function.  This calculates and installs the
1526
   relocation itself, thus avoiding the oft-discussed problems in
1527
   bfd_perform_relocation and bfd_install_relocation.  */
1528
 
1529
bfd_reloc_status_type
1530
_bfd_mips_elf_generic_reloc (bfd *abfd ATTRIBUTE_UNUSED, arelent *reloc_entry,
1531
                             asymbol *symbol, void *data ATTRIBUTE_UNUSED,
1532
                             asection *input_section, bfd *output_bfd,
1533
                             char **error_message ATTRIBUTE_UNUSED)
1534
{
1535
  bfd_signed_vma val;
1536
  bfd_reloc_status_type status;
1537
  bfd_boolean relocatable;
1538
 
1539
  relocatable = (output_bfd != NULL);
1540
 
1541
  if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
1542
    return bfd_reloc_outofrange;
1543
 
1544
  /* Build up the field adjustment in VAL.  */
1545
  val = 0;
1546
  if (!relocatable || (symbol->flags & BSF_SECTION_SYM) != 0)
1547
    {
1548
      /* Either we're calculating the final field value or we have a
1549
         relocation against a section symbol.  Add in the section's
1550
         offset or address.  */
1551
      val += symbol->section->output_section->vma;
1552
      val += symbol->section->output_offset;
1553
    }
1554
 
1555
  if (!relocatable)
1556
    {
1557
      /* We're calculating the final field value.  Add in the symbol's value
1558
         and, if pc-relative, subtract the address of the field itself.  */
1559
      val += symbol->value;
1560
      if (reloc_entry->howto->pc_relative)
1561
        {
1562
          val -= input_section->output_section->vma;
1563
          val -= input_section->output_offset;
1564
          val -= reloc_entry->address;
1565
        }
1566
    }
1567
 
1568
  /* VAL is now the final adjustment.  If we're keeping this relocation
1569
     in the output file, and if the relocation uses a separate addend,
1570
     we just need to add VAL to that addend.  Otherwise we need to add
1571
     VAL to the relocation field itself.  */
1572
  if (relocatable && !reloc_entry->howto->partial_inplace)
1573
    reloc_entry->addend += val;
1574
  else
1575
    {
1576
      bfd_byte *location = (bfd_byte *) data + reloc_entry->address;
1577
 
1578
      /* Add in the separate addend, if any.  */
1579
      val += reloc_entry->addend;
1580
 
1581
      /* Add VAL to the relocation field.  */
1582
      _bfd_mips16_elf_reloc_unshuffle (abfd, reloc_entry->howto->type, FALSE,
1583
                                       location);
1584
      status = _bfd_relocate_contents (reloc_entry->howto, abfd, val,
1585
                                       location);
1586
      _bfd_mips16_elf_reloc_shuffle (abfd, reloc_entry->howto->type, FALSE,
1587
                                     location);
1588
 
1589
      if (status != bfd_reloc_ok)
1590
        return status;
1591
    }
1592
 
1593
  if (relocatable)
1594
    reloc_entry->address += input_section->output_offset;
1595
 
1596
  return bfd_reloc_ok;
1597
}
1598
 
1599
/* Swap an entry in a .gptab section.  Note that these routines rely
1600
   on the equivalence of the two elements of the union.  */
1601
 
1602
static void
1603
bfd_mips_elf32_swap_gptab_in (bfd *abfd, const Elf32_External_gptab *ex,
1604
                              Elf32_gptab *in)
1605
{
1606
  in->gt_entry.gt_g_value = H_GET_32 (abfd, ex->gt_entry.gt_g_value);
1607
  in->gt_entry.gt_bytes = H_GET_32 (abfd, ex->gt_entry.gt_bytes);
1608
}
1609
 
1610
static void
1611
bfd_mips_elf32_swap_gptab_out (bfd *abfd, const Elf32_gptab *in,
1612
                               Elf32_External_gptab *ex)
1613
{
1614
  H_PUT_32 (abfd, in->gt_entry.gt_g_value, ex->gt_entry.gt_g_value);
1615
  H_PUT_32 (abfd, in->gt_entry.gt_bytes, ex->gt_entry.gt_bytes);
1616
}
1617
 
1618
static void
1619
bfd_elf32_swap_compact_rel_out (bfd *abfd, const Elf32_compact_rel *in,
1620
                                Elf32_External_compact_rel *ex)
1621
{
1622
  H_PUT_32 (abfd, in->id1, ex->id1);
1623
  H_PUT_32 (abfd, in->num, ex->num);
1624
  H_PUT_32 (abfd, in->id2, ex->id2);
1625
  H_PUT_32 (abfd, in->offset, ex->offset);
1626
  H_PUT_32 (abfd, in->reserved0, ex->reserved0);
1627
  H_PUT_32 (abfd, in->reserved1, ex->reserved1);
1628
}
1629
 
1630
static void
1631
bfd_elf32_swap_crinfo_out (bfd *abfd, const Elf32_crinfo *in,
1632
                           Elf32_External_crinfo *ex)
1633
{
1634
  unsigned long l;
1635
 
1636
  l = (((in->ctype & CRINFO_CTYPE) << CRINFO_CTYPE_SH)
1637
       | ((in->rtype & CRINFO_RTYPE) << CRINFO_RTYPE_SH)
1638
       | ((in->dist2to & CRINFO_DIST2TO) << CRINFO_DIST2TO_SH)
1639
       | ((in->relvaddr & CRINFO_RELVADDR) << CRINFO_RELVADDR_SH));
1640
  H_PUT_32 (abfd, l, ex->info);
1641
  H_PUT_32 (abfd, in->konst, ex->konst);
1642
  H_PUT_32 (abfd, in->vaddr, ex->vaddr);
1643
}
1644
 
1645
/* A .reginfo section holds a single Elf32_RegInfo structure.  These
1646
   routines swap this structure in and out.  They are used outside of
1647
   BFD, so they are globally visible.  */
1648
 
1649
void
1650
bfd_mips_elf32_swap_reginfo_in (bfd *abfd, const Elf32_External_RegInfo *ex,
1651
                                Elf32_RegInfo *in)
1652
{
1653
  in->ri_gprmask = H_GET_32 (abfd, ex->ri_gprmask);
1654
  in->ri_cprmask[0] = H_GET_32 (abfd, ex->ri_cprmask[0]);
1655
  in->ri_cprmask[1] = H_GET_32 (abfd, ex->ri_cprmask[1]);
1656
  in->ri_cprmask[2] = H_GET_32 (abfd, ex->ri_cprmask[2]);
1657
  in->ri_cprmask[3] = H_GET_32 (abfd, ex->ri_cprmask[3]);
1658
  in->ri_gp_value = H_GET_32 (abfd, ex->ri_gp_value);
1659
}
1660
 
1661
void
1662
bfd_mips_elf32_swap_reginfo_out (bfd *abfd, const Elf32_RegInfo *in,
1663
                                 Elf32_External_RegInfo *ex)
1664
{
1665
  H_PUT_32 (abfd, in->ri_gprmask, ex->ri_gprmask);
1666
  H_PUT_32 (abfd, in->ri_cprmask[0], ex->ri_cprmask[0]);
1667
  H_PUT_32 (abfd, in->ri_cprmask[1], ex->ri_cprmask[1]);
1668
  H_PUT_32 (abfd, in->ri_cprmask[2], ex->ri_cprmask[2]);
1669
  H_PUT_32 (abfd, in->ri_cprmask[3], ex->ri_cprmask[3]);
1670
  H_PUT_32 (abfd, in->ri_gp_value, ex->ri_gp_value);
1671
}
1672
 
1673
/* In the 64 bit ABI, the .MIPS.options section holds register
1674
   information in an Elf64_Reginfo structure.  These routines swap
1675
   them in and out.  They are globally visible because they are used
1676
   outside of BFD.  These routines are here so that gas can call them
1677
   without worrying about whether the 64 bit ABI has been included.  */
1678
 
1679
void
1680
bfd_mips_elf64_swap_reginfo_in (bfd *abfd, const Elf64_External_RegInfo *ex,
1681
                                Elf64_Internal_RegInfo *in)
1682
{
1683
  in->ri_gprmask = H_GET_32 (abfd, ex->ri_gprmask);
1684
  in->ri_pad = H_GET_32 (abfd, ex->ri_pad);
1685
  in->ri_cprmask[0] = H_GET_32 (abfd, ex->ri_cprmask[0]);
1686
  in->ri_cprmask[1] = H_GET_32 (abfd, ex->ri_cprmask[1]);
1687
  in->ri_cprmask[2] = H_GET_32 (abfd, ex->ri_cprmask[2]);
1688
  in->ri_cprmask[3] = H_GET_32 (abfd, ex->ri_cprmask[3]);
1689
  in->ri_gp_value = H_GET_64 (abfd, ex->ri_gp_value);
1690
}
1691
 
1692
void
1693
bfd_mips_elf64_swap_reginfo_out (bfd *abfd, const Elf64_Internal_RegInfo *in,
1694
                                 Elf64_External_RegInfo *ex)
1695
{
1696
  H_PUT_32 (abfd, in->ri_gprmask, ex->ri_gprmask);
1697
  H_PUT_32 (abfd, in->ri_pad, ex->ri_pad);
1698
  H_PUT_32 (abfd, in->ri_cprmask[0], ex->ri_cprmask[0]);
1699
  H_PUT_32 (abfd, in->ri_cprmask[1], ex->ri_cprmask[1]);
1700
  H_PUT_32 (abfd, in->ri_cprmask[2], ex->ri_cprmask[2]);
1701
  H_PUT_32 (abfd, in->ri_cprmask[3], ex->ri_cprmask[3]);
1702
  H_PUT_64 (abfd, in->ri_gp_value, ex->ri_gp_value);
1703
}
1704
 
1705
/* Swap in an options header.  */
1706
 
1707
void
1708
bfd_mips_elf_swap_options_in (bfd *abfd, const Elf_External_Options *ex,
1709
                              Elf_Internal_Options *in)
1710
{
1711
  in->kind = H_GET_8 (abfd, ex->kind);
1712
  in->size = H_GET_8 (abfd, ex->size);
1713
  in->section = H_GET_16 (abfd, ex->section);
1714
  in->info = H_GET_32 (abfd, ex->info);
1715
}
1716
 
1717
/* Swap out an options header.  */
1718
 
1719
void
1720
bfd_mips_elf_swap_options_out (bfd *abfd, const Elf_Internal_Options *in,
1721
                               Elf_External_Options *ex)
1722
{
1723
  H_PUT_8 (abfd, in->kind, ex->kind);
1724
  H_PUT_8 (abfd, in->size, ex->size);
1725
  H_PUT_16 (abfd, in->section, ex->section);
1726
  H_PUT_32 (abfd, in->info, ex->info);
1727
}
1728
 
1729
/* This function is called via qsort() to sort the dynamic relocation
1730
   entries by increasing r_symndx value.  */
1731
 
1732
static int
1733
sort_dynamic_relocs (const void *arg1, const void *arg2)
1734
{
1735
  Elf_Internal_Rela int_reloc1;
1736
  Elf_Internal_Rela int_reloc2;
1737
  int diff;
1738
 
1739
  bfd_elf32_swap_reloc_in (reldyn_sorting_bfd, arg1, &int_reloc1);
1740
  bfd_elf32_swap_reloc_in (reldyn_sorting_bfd, arg2, &int_reloc2);
1741
 
1742
  diff = ELF32_R_SYM (int_reloc1.r_info) - ELF32_R_SYM (int_reloc2.r_info);
1743
  if (diff != 0)
1744
    return diff;
1745
 
1746
  if (int_reloc1.r_offset < int_reloc2.r_offset)
1747
    return -1;
1748
  if (int_reloc1.r_offset > int_reloc2.r_offset)
1749
    return 1;
1750
  return 0;
1751
}
1752
 
1753
/* Like sort_dynamic_relocs, but used for elf64 relocations.  */
1754
 
1755
static int
1756
sort_dynamic_relocs_64 (const void *arg1 ATTRIBUTE_UNUSED,
1757
                        const void *arg2 ATTRIBUTE_UNUSED)
1758
{
1759
#ifdef BFD64
1760
  Elf_Internal_Rela int_reloc1[3];
1761
  Elf_Internal_Rela int_reloc2[3];
1762
 
1763
  (*get_elf_backend_data (reldyn_sorting_bfd)->s->swap_reloc_in)
1764
    (reldyn_sorting_bfd, arg1, int_reloc1);
1765
  (*get_elf_backend_data (reldyn_sorting_bfd)->s->swap_reloc_in)
1766
    (reldyn_sorting_bfd, arg2, int_reloc2);
1767
 
1768
  if (ELF64_R_SYM (int_reloc1[0].r_info) < ELF64_R_SYM (int_reloc2[0].r_info))
1769
    return -1;
1770
  if (ELF64_R_SYM (int_reloc1[0].r_info) > ELF64_R_SYM (int_reloc2[0].r_info))
1771
    return 1;
1772
 
1773
  if (int_reloc1[0].r_offset < int_reloc2[0].r_offset)
1774
    return -1;
1775
  if (int_reloc1[0].r_offset > int_reloc2[0].r_offset)
1776
    return 1;
1777
  return 0;
1778
#else
1779
  abort ();
1780
#endif
1781
}
1782
 
1783
 
1784
/* This routine is used to write out ECOFF debugging external symbol
1785
   information.  It is called via mips_elf_link_hash_traverse.  The
1786
   ECOFF external symbol information must match the ELF external
1787
   symbol information.  Unfortunately, at this point we don't know
1788
   whether a symbol is required by reloc information, so the two
1789
   tables may wind up being different.  We must sort out the external
1790
   symbol information before we can set the final size of the .mdebug
1791
   section, and we must set the size of the .mdebug section before we
1792
   can relocate any sections, and we can't know which symbols are
1793
   required by relocation until we relocate the sections.
1794
   Fortunately, it is relatively unlikely that any symbol will be
1795
   stripped but required by a reloc.  In particular, it can not happen
1796
   when generating a final executable.  */
1797
 
1798
static bfd_boolean
1799
mips_elf_output_extsym (struct mips_elf_link_hash_entry *h, void *data)
1800
{
1801
  struct extsym_info *einfo = data;
1802
  bfd_boolean strip;
1803
  asection *sec, *output_section;
1804
 
1805
  if (h->root.root.type == bfd_link_hash_warning)
1806
    h = (struct mips_elf_link_hash_entry *) h->root.root.u.i.link;
1807
 
1808
  if (h->root.indx == -2)
1809
    strip = FALSE;
1810
  else if ((h->root.def_dynamic
1811
            || h->root.ref_dynamic
1812
            || h->root.type == bfd_link_hash_new)
1813
           && !h->root.def_regular
1814
           && !h->root.ref_regular)
1815
    strip = TRUE;
1816
  else if (einfo->info->strip == strip_all
1817
           || (einfo->info->strip == strip_some
1818
               && bfd_hash_lookup (einfo->info->keep_hash,
1819
                                   h->root.root.root.string,
1820
                                   FALSE, FALSE) == NULL))
1821
    strip = TRUE;
1822
  else
1823
    strip = FALSE;
1824
 
1825
  if (strip)
1826
    return TRUE;
1827
 
1828
  if (h->esym.ifd == -2)
1829
    {
1830
      h->esym.jmptbl = 0;
1831
      h->esym.cobol_main = 0;
1832
      h->esym.weakext = 0;
1833
      h->esym.reserved = 0;
1834
      h->esym.ifd = ifdNil;
1835
      h->esym.asym.value = 0;
1836
      h->esym.asym.st = stGlobal;
1837
 
1838
      if (h->root.root.type == bfd_link_hash_undefined
1839
          || h->root.root.type == bfd_link_hash_undefweak)
1840
        {
1841
          const char *name;
1842
 
1843
          /* Use undefined class.  Also, set class and type for some
1844
             special symbols.  */
1845
          name = h->root.root.root.string;
1846
          if (strcmp (name, mips_elf_dynsym_rtproc_names[0]) == 0
1847
              || strcmp (name, mips_elf_dynsym_rtproc_names[1]) == 0)
1848
            {
1849
              h->esym.asym.sc = scData;
1850
              h->esym.asym.st = stLabel;
1851
              h->esym.asym.value = 0;
1852
            }
1853
          else if (strcmp (name, mips_elf_dynsym_rtproc_names[2]) == 0)
1854
            {
1855
              h->esym.asym.sc = scAbs;
1856
              h->esym.asym.st = stLabel;
1857
              h->esym.asym.value =
1858
                mips_elf_hash_table (einfo->info)->procedure_count;
1859
            }
1860
          else if (strcmp (name, "_gp_disp") == 0 && ! NEWABI_P (einfo->abfd))
1861
            {
1862
              h->esym.asym.sc = scAbs;
1863
              h->esym.asym.st = stLabel;
1864
              h->esym.asym.value = elf_gp (einfo->abfd);
1865
            }
1866
          else
1867
            h->esym.asym.sc = scUndefined;
1868
        }
1869
      else if (h->root.root.type != bfd_link_hash_defined
1870
          && h->root.root.type != bfd_link_hash_defweak)
1871
        h->esym.asym.sc = scAbs;
1872
      else
1873
        {
1874
          const char *name;
1875
 
1876
          sec = h->root.root.u.def.section;
1877
          output_section = sec->output_section;
1878
 
1879
          /* When making a shared library and symbol h is the one from
1880
             the another shared library, OUTPUT_SECTION may be null.  */
1881
          if (output_section == NULL)
1882
            h->esym.asym.sc = scUndefined;
1883
          else
1884
            {
1885
              name = bfd_section_name (output_section->owner, output_section);
1886
 
1887
              if (strcmp (name, ".text") == 0)
1888
                h->esym.asym.sc = scText;
1889
              else if (strcmp (name, ".data") == 0)
1890
                h->esym.asym.sc = scData;
1891
              else if (strcmp (name, ".sdata") == 0)
1892
                h->esym.asym.sc = scSData;
1893
              else if (strcmp (name, ".rodata") == 0
1894
                       || strcmp (name, ".rdata") == 0)
1895
                h->esym.asym.sc = scRData;
1896
              else if (strcmp (name, ".bss") == 0)
1897
                h->esym.asym.sc = scBss;
1898
              else if (strcmp (name, ".sbss") == 0)
1899
                h->esym.asym.sc = scSBss;
1900
              else if (strcmp (name, ".init") == 0)
1901
                h->esym.asym.sc = scInit;
1902
              else if (strcmp (name, ".fini") == 0)
1903
                h->esym.asym.sc = scFini;
1904
              else
1905
                h->esym.asym.sc = scAbs;
1906
            }
1907
        }
1908
 
1909
      h->esym.asym.reserved = 0;
1910
      h->esym.asym.index = indexNil;
1911
    }
1912
 
1913
  if (h->root.root.type == bfd_link_hash_common)
1914
    h->esym.asym.value = h->root.root.u.c.size;
1915
  else if (h->root.root.type == bfd_link_hash_defined
1916
           || h->root.root.type == bfd_link_hash_defweak)
1917
    {
1918
      if (h->esym.asym.sc == scCommon)
1919
        h->esym.asym.sc = scBss;
1920
      else if (h->esym.asym.sc == scSCommon)
1921
        h->esym.asym.sc = scSBss;
1922
 
1923
      sec = h->root.root.u.def.section;
1924
      output_section = sec->output_section;
1925
      if (output_section != NULL)
1926
        h->esym.asym.value = (h->root.root.u.def.value
1927
                              + sec->output_offset
1928
                              + output_section->vma);
1929
      else
1930
        h->esym.asym.value = 0;
1931
    }
1932
  else if (h->root.needs_plt)
1933
    {
1934
      struct mips_elf_link_hash_entry *hd = h;
1935
      bfd_boolean no_fn_stub = h->no_fn_stub;
1936
 
1937
      while (hd->root.root.type == bfd_link_hash_indirect)
1938
        {
1939
          hd = (struct mips_elf_link_hash_entry *)h->root.root.u.i.link;
1940
          no_fn_stub = no_fn_stub || hd->no_fn_stub;
1941
        }
1942
 
1943
      if (!no_fn_stub)
1944
        {
1945
          /* Set type and value for a symbol with a function stub.  */
1946
          h->esym.asym.st = stProc;
1947
          sec = hd->root.root.u.def.section;
1948
          if (sec == NULL)
1949
            h->esym.asym.value = 0;
1950
          else
1951
            {
1952
              output_section = sec->output_section;
1953
              if (output_section != NULL)
1954
                h->esym.asym.value = (hd->root.plt.offset
1955
                                      + sec->output_offset
1956
                                      + output_section->vma);
1957
              else
1958
                h->esym.asym.value = 0;
1959
            }
1960
        }
1961
    }
1962
 
1963
  if (! bfd_ecoff_debug_one_external (einfo->abfd, einfo->debug, einfo->swap,
1964
                                      h->root.root.root.string,
1965
                                      &h->esym))
1966
    {
1967
      einfo->failed = TRUE;
1968
      return FALSE;
1969
    }
1970
 
1971
  return TRUE;
1972
}
1973
 
1974
/* A comparison routine used to sort .gptab entries.  */
1975
 
1976
static int
1977
gptab_compare (const void *p1, const void *p2)
1978
{
1979
  const Elf32_gptab *a1 = p1;
1980
  const Elf32_gptab *a2 = p2;
1981
 
1982
  return a1->gt_entry.gt_g_value - a2->gt_entry.gt_g_value;
1983
}
1984
 
1985
/* Functions to manage the got entry hash table.  */
1986
 
1987
/* Use all 64 bits of a bfd_vma for the computation of a 32-bit
1988
   hash number.  */
1989
 
1990
static INLINE hashval_t
1991
mips_elf_hash_bfd_vma (bfd_vma addr)
1992
{
1993
#ifdef BFD64
1994
  return addr + (addr >> 32);
1995
#else
1996
  return addr;
1997
#endif
1998
}
1999
 
2000
/* got_entries only match if they're identical, except for gotidx, so
2001
   use all fields to compute the hash, and compare the appropriate
2002
   union members.  */
2003
 
2004
static hashval_t
2005
mips_elf_got_entry_hash (const void *entry_)
2006
{
2007
  const struct mips_got_entry *entry = (struct mips_got_entry *)entry_;
2008
 
2009
  return entry->symndx
2010
    + ((entry->tls_type & GOT_TLS_LDM) << 17)
2011
    + (! entry->abfd ? mips_elf_hash_bfd_vma (entry->d.address)
2012
       : entry->abfd->id
2013
         + (entry->symndx >= 0 ? mips_elf_hash_bfd_vma (entry->d.addend)
2014
            : entry->d.h->root.root.root.hash));
2015
}
2016
 
2017
static int
2018
mips_elf_got_entry_eq (const void *entry1, const void *entry2)
2019
{
2020
  const struct mips_got_entry *e1 = (struct mips_got_entry *)entry1;
2021
  const struct mips_got_entry *e2 = (struct mips_got_entry *)entry2;
2022
 
2023
  /* An LDM entry can only match another LDM entry.  */
2024
  if ((e1->tls_type ^ e2->tls_type) & GOT_TLS_LDM)
2025
    return 0;
2026
 
2027
  return e1->abfd == e2->abfd && e1->symndx == e2->symndx
2028
    && (! e1->abfd ? e1->d.address == e2->d.address
2029
        : e1->symndx >= 0 ? e1->d.addend == e2->d.addend
2030
        : e1->d.h == e2->d.h);
2031
}
2032
 
2033
/* multi_got_entries are still a match in the case of global objects,
2034
   even if the input bfd in which they're referenced differs, so the
2035
   hash computation and compare functions are adjusted
2036
   accordingly.  */
2037
 
2038
static hashval_t
2039
mips_elf_multi_got_entry_hash (const void *entry_)
2040
{
2041
  const struct mips_got_entry *entry = (struct mips_got_entry *)entry_;
2042
 
2043
  return entry->symndx
2044
    + (! entry->abfd
2045
       ? mips_elf_hash_bfd_vma (entry->d.address)
2046
       : entry->symndx >= 0
2047
       ? ((entry->tls_type & GOT_TLS_LDM)
2048
          ? (GOT_TLS_LDM << 17)
2049
          : (entry->abfd->id
2050
             + mips_elf_hash_bfd_vma (entry->d.addend)))
2051
       : entry->d.h->root.root.root.hash);
2052
}
2053
 
2054
static int
2055
mips_elf_multi_got_entry_eq (const void *entry1, const void *entry2)
2056
{
2057
  const struct mips_got_entry *e1 = (struct mips_got_entry *)entry1;
2058
  const struct mips_got_entry *e2 = (struct mips_got_entry *)entry2;
2059
 
2060
  /* Any two LDM entries match.  */
2061
  if (e1->tls_type & e2->tls_type & GOT_TLS_LDM)
2062
    return 1;
2063
 
2064
  /* Nothing else matches an LDM entry.  */
2065
  if ((e1->tls_type ^ e2->tls_type) & GOT_TLS_LDM)
2066
    return 0;
2067
 
2068
  return e1->symndx == e2->symndx
2069
    && (e1->symndx >= 0 ? e1->abfd == e2->abfd && e1->d.addend == e2->d.addend
2070
        : e1->abfd == NULL || e2->abfd == NULL
2071
        ? e1->abfd == e2->abfd && e1->d.address == e2->d.address
2072
        : e1->d.h == e2->d.h);
2073
}
2074
 
2075
static hashval_t
2076
mips_got_page_entry_hash (const void *entry_)
2077
{
2078
  const struct mips_got_page_entry *entry;
2079
 
2080
  entry = (const struct mips_got_page_entry *) entry_;
2081
  return entry->abfd->id + entry->symndx;
2082
}
2083
 
2084
static int
2085
mips_got_page_entry_eq (const void *entry1_, const void *entry2_)
2086
{
2087
  const struct mips_got_page_entry *entry1, *entry2;
2088
 
2089
  entry1 = (const struct mips_got_page_entry *) entry1_;
2090
  entry2 = (const struct mips_got_page_entry *) entry2_;
2091
  return entry1->abfd == entry2->abfd && entry1->symndx == entry2->symndx;
2092
}
2093
 
2094
/* Return the dynamic relocation section.  If it doesn't exist, try to
2095
   create a new it if CREATE_P, otherwise return NULL.  Also return NULL
2096
   if creation fails.  */
2097
 
2098
static asection *
2099
mips_elf_rel_dyn_section (struct bfd_link_info *info, bfd_boolean create_p)
2100
{
2101
  const char *dname;
2102
  asection *sreloc;
2103
  bfd *dynobj;
2104
 
2105
  dname = MIPS_ELF_REL_DYN_NAME (info);
2106
  dynobj = elf_hash_table (info)->dynobj;
2107
  sreloc = bfd_get_section_by_name (dynobj, dname);
2108
  if (sreloc == NULL && create_p)
2109
    {
2110
      sreloc = bfd_make_section_with_flags (dynobj, dname,
2111
                                            (SEC_ALLOC
2112
                                             | SEC_LOAD
2113
                                             | SEC_HAS_CONTENTS
2114
                                             | SEC_IN_MEMORY
2115
                                             | SEC_LINKER_CREATED
2116
                                             | SEC_READONLY));
2117
      if (sreloc == NULL
2118
          || ! bfd_set_section_alignment (dynobj, sreloc,
2119
                                          MIPS_ELF_LOG_FILE_ALIGN (dynobj)))
2120
        return NULL;
2121
    }
2122
  return sreloc;
2123
}
2124
 
2125
/* Returns the GOT section for ABFD.  */
2126
 
2127
static asection *
2128
mips_elf_got_section (bfd *abfd, bfd_boolean maybe_excluded)
2129
{
2130
  asection *sgot = bfd_get_section_by_name (abfd, ".got");
2131
  if (sgot == NULL
2132
      || (! maybe_excluded && (sgot->flags & SEC_EXCLUDE) != 0))
2133
    return NULL;
2134
  return sgot;
2135
}
2136
 
2137
/* Returns the GOT information associated with the link indicated by
2138
   INFO.  If SGOTP is non-NULL, it is filled in with the GOT
2139
   section.  */
2140
 
2141
static struct mips_got_info *
2142
mips_elf_got_info (bfd *abfd, asection **sgotp)
2143
{
2144
  asection *sgot;
2145
  struct mips_got_info *g;
2146
 
2147
  sgot = mips_elf_got_section (abfd, TRUE);
2148
  BFD_ASSERT (sgot != NULL);
2149
  BFD_ASSERT (mips_elf_section_data (sgot) != NULL);
2150
  g = mips_elf_section_data (sgot)->u.got_info;
2151
  BFD_ASSERT (g != NULL);
2152
 
2153
  if (sgotp)
2154
    *sgotp = (sgot->flags & SEC_EXCLUDE) == 0 ? sgot : NULL;
2155
 
2156
  return g;
2157
}
2158
 
2159
/* Count the number of relocations needed for a TLS GOT entry, with
2160
   access types from TLS_TYPE, and symbol H (or a local symbol if H
2161
   is NULL).  */
2162
 
2163
static int
2164
mips_tls_got_relocs (struct bfd_link_info *info, unsigned char tls_type,
2165
                     struct elf_link_hash_entry *h)
2166
{
2167
  int indx = 0;
2168
  int ret = 0;
2169
  bfd_boolean need_relocs = FALSE;
2170
  bfd_boolean dyn = elf_hash_table (info)->dynamic_sections_created;
2171
 
2172
  if (h && WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
2173
      && (!info->shared || !SYMBOL_REFERENCES_LOCAL (info, h)))
2174
    indx = h->dynindx;
2175
 
2176
  if ((info->shared || indx != 0)
2177
      && (h == NULL
2178
          || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2179
          || h->root.type != bfd_link_hash_undefweak))
2180
    need_relocs = TRUE;
2181
 
2182
  if (!need_relocs)
2183
    return FALSE;
2184
 
2185
  if (tls_type & GOT_TLS_GD)
2186
    {
2187
      ret++;
2188
      if (indx != 0)
2189
        ret++;
2190
    }
2191
 
2192
  if (tls_type & GOT_TLS_IE)
2193
    ret++;
2194
 
2195
  if ((tls_type & GOT_TLS_LDM) && info->shared)
2196
    ret++;
2197
 
2198
  return ret;
2199
}
2200
 
2201
/* Count the number of TLS relocations required for the GOT entry in
2202
   ARG1, if it describes a local symbol.  */
2203
 
2204
static int
2205
mips_elf_count_local_tls_relocs (void **arg1, void *arg2)
2206
{
2207
  struct mips_got_entry *entry = * (struct mips_got_entry **) arg1;
2208
  struct mips_elf_count_tls_arg *arg = arg2;
2209
 
2210
  if (entry->abfd != NULL && entry->symndx != -1)
2211
    arg->needed += mips_tls_got_relocs (arg->info, entry->tls_type, NULL);
2212
 
2213
  return 1;
2214
}
2215
 
2216
/* Count the number of TLS GOT entries required for the global (or
2217
   forced-local) symbol in ARG1.  */
2218
 
2219
static int
2220
mips_elf_count_global_tls_entries (void *arg1, void *arg2)
2221
{
2222
  struct mips_elf_link_hash_entry *hm
2223
    = (struct mips_elf_link_hash_entry *) arg1;
2224
  struct mips_elf_count_tls_arg *arg = arg2;
2225
 
2226
  if (hm->tls_type & GOT_TLS_GD)
2227
    arg->needed += 2;
2228
  if (hm->tls_type & GOT_TLS_IE)
2229
    arg->needed += 1;
2230
 
2231
  return 1;
2232
}
2233
 
2234
/* Count the number of TLS relocations required for the global (or
2235
   forced-local) symbol in ARG1.  */
2236
 
2237
static int
2238
mips_elf_count_global_tls_relocs (void *arg1, void *arg2)
2239
{
2240
  struct mips_elf_link_hash_entry *hm
2241
    = (struct mips_elf_link_hash_entry *) arg1;
2242
  struct mips_elf_count_tls_arg *arg = arg2;
2243
 
2244
  arg->needed += mips_tls_got_relocs (arg->info, hm->tls_type, &hm->root);
2245
 
2246
  return 1;
2247
}
2248
 
2249
/* Output a simple dynamic relocation into SRELOC.  */
2250
 
2251
static void
2252
mips_elf_output_dynamic_relocation (bfd *output_bfd,
2253
                                    asection *sreloc,
2254
                                    unsigned long indx,
2255
                                    int r_type,
2256
                                    bfd_vma offset)
2257
{
2258
  Elf_Internal_Rela rel[3];
2259
 
2260
  memset (rel, 0, sizeof (rel));
2261
 
2262
  rel[0].r_info = ELF_R_INFO (output_bfd, indx, r_type);
2263
  rel[0].r_offset = rel[1].r_offset = rel[2].r_offset = offset;
2264
 
2265
  if (ABI_64_P (output_bfd))
2266
    {
2267
      (*get_elf_backend_data (output_bfd)->s->swap_reloc_out)
2268
        (output_bfd, &rel[0],
2269
         (sreloc->contents
2270
          + sreloc->reloc_count * sizeof (Elf64_Mips_External_Rel)));
2271
    }
2272
  else
2273
    bfd_elf32_swap_reloc_out
2274
      (output_bfd, &rel[0],
2275
       (sreloc->contents
2276
        + sreloc->reloc_count * sizeof (Elf32_External_Rel)));
2277
  ++sreloc->reloc_count;
2278
}
2279
 
2280
/* Initialize a set of TLS GOT entries for one symbol.  */
2281
 
2282
static void
2283
mips_elf_initialize_tls_slots (bfd *abfd, bfd_vma got_offset,
2284
                               unsigned char *tls_type_p,
2285
                               struct bfd_link_info *info,
2286
                               struct mips_elf_link_hash_entry *h,
2287
                               bfd_vma value)
2288
{
2289
  int indx;
2290
  asection *sreloc, *sgot;
2291
  bfd_vma offset, offset2;
2292
  bfd *dynobj;
2293
  bfd_boolean need_relocs = FALSE;
2294
 
2295
  dynobj = elf_hash_table (info)->dynobj;
2296
  sgot = mips_elf_got_section (dynobj, FALSE);
2297
 
2298
  indx = 0;
2299
  if (h != NULL)
2300
    {
2301
      bfd_boolean dyn = elf_hash_table (info)->dynamic_sections_created;
2302
 
2303
      if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, &h->root)
2304
          && (!info->shared || !SYMBOL_REFERENCES_LOCAL (info, &h->root)))
2305
        indx = h->root.dynindx;
2306
    }
2307
 
2308
  if (*tls_type_p & GOT_TLS_DONE)
2309
    return;
2310
 
2311
  if ((info->shared || indx != 0)
2312
      && (h == NULL
2313
          || ELF_ST_VISIBILITY (h->root.other) == STV_DEFAULT
2314
          || h->root.type != bfd_link_hash_undefweak))
2315
    need_relocs = TRUE;
2316
 
2317
  /* MINUS_ONE means the symbol is not defined in this object.  It may not
2318
     be defined at all; assume that the value doesn't matter in that
2319
     case.  Otherwise complain if we would use the value.  */
2320
  BFD_ASSERT (value != MINUS_ONE || (indx != 0 && need_relocs)
2321
              || h->root.root.type == bfd_link_hash_undefweak);
2322
 
2323
  /* Emit necessary relocations.  */
2324
  sreloc = mips_elf_rel_dyn_section (info, FALSE);
2325
 
2326
  /* General Dynamic.  */
2327
  if (*tls_type_p & GOT_TLS_GD)
2328
    {
2329
      offset = got_offset;
2330
      offset2 = offset + MIPS_ELF_GOT_SIZE (abfd);
2331
 
2332
      if (need_relocs)
2333
        {
2334
          mips_elf_output_dynamic_relocation
2335
            (abfd, sreloc, indx,
2336
             ABI_64_P (abfd) ? R_MIPS_TLS_DTPMOD64 : R_MIPS_TLS_DTPMOD32,
2337
             sgot->output_offset + sgot->output_section->vma + offset);
2338
 
2339
          if (indx)
2340
            mips_elf_output_dynamic_relocation
2341
              (abfd, sreloc, indx,
2342
               ABI_64_P (abfd) ? R_MIPS_TLS_DTPREL64 : R_MIPS_TLS_DTPREL32,
2343
               sgot->output_offset + sgot->output_section->vma + offset2);
2344
          else
2345
            MIPS_ELF_PUT_WORD (abfd, value - dtprel_base (info),
2346
                               sgot->contents + offset2);
2347
        }
2348
      else
2349
        {
2350
          MIPS_ELF_PUT_WORD (abfd, 1,
2351
                             sgot->contents + offset);
2352
          MIPS_ELF_PUT_WORD (abfd, value - dtprel_base (info),
2353
                             sgot->contents + offset2);
2354
        }
2355
 
2356
      got_offset += 2 * MIPS_ELF_GOT_SIZE (abfd);
2357
    }
2358
 
2359
  /* Initial Exec model.  */
2360
  if (*tls_type_p & GOT_TLS_IE)
2361
    {
2362
      offset = got_offset;
2363
 
2364
      if (need_relocs)
2365
        {
2366
          if (indx == 0)
2367
            MIPS_ELF_PUT_WORD (abfd, value - elf_hash_table (info)->tls_sec->vma,
2368
                               sgot->contents + offset);
2369
          else
2370
            MIPS_ELF_PUT_WORD (abfd, 0,
2371
                               sgot->contents + offset);
2372
 
2373
          mips_elf_output_dynamic_relocation
2374
            (abfd, sreloc, indx,
2375
             ABI_64_P (abfd) ? R_MIPS_TLS_TPREL64 : R_MIPS_TLS_TPREL32,
2376
             sgot->output_offset + sgot->output_section->vma + offset);
2377
        }
2378
      else
2379
        MIPS_ELF_PUT_WORD (abfd, value - tprel_base (info),
2380
                           sgot->contents + offset);
2381
    }
2382
 
2383
  if (*tls_type_p & GOT_TLS_LDM)
2384
    {
2385
      /* The initial offset is zero, and the LD offsets will include the
2386
         bias by DTP_OFFSET.  */
2387
      MIPS_ELF_PUT_WORD (abfd, 0,
2388
                         sgot->contents + got_offset
2389
                         + MIPS_ELF_GOT_SIZE (abfd));
2390
 
2391
      if (!info->shared)
2392
        MIPS_ELF_PUT_WORD (abfd, 1,
2393
                           sgot->contents + got_offset);
2394
      else
2395
        mips_elf_output_dynamic_relocation
2396
          (abfd, sreloc, indx,
2397
           ABI_64_P (abfd) ? R_MIPS_TLS_DTPMOD64 : R_MIPS_TLS_DTPMOD32,
2398
           sgot->output_offset + sgot->output_section->vma + got_offset);
2399
    }
2400
 
2401
  *tls_type_p |= GOT_TLS_DONE;
2402
}
2403
 
2404
/* Return the GOT index to use for a relocation of type R_TYPE against
2405
   a symbol accessed using TLS_TYPE models.  The GOT entries for this
2406
   symbol in this GOT start at GOT_INDEX.  This function initializes the
2407
   GOT entries and corresponding relocations.  */
2408
 
2409
static bfd_vma
2410
mips_tls_got_index (bfd *abfd, bfd_vma got_index, unsigned char *tls_type,
2411
                    int r_type, struct bfd_link_info *info,
2412
                    struct mips_elf_link_hash_entry *h, bfd_vma symbol)
2413
{
2414
  BFD_ASSERT (r_type == R_MIPS_TLS_GOTTPREL || r_type == R_MIPS_TLS_GD
2415
              || r_type == R_MIPS_TLS_LDM);
2416
 
2417
  mips_elf_initialize_tls_slots (abfd, got_index, tls_type, info, h, symbol);
2418
 
2419
  if (r_type == R_MIPS_TLS_GOTTPREL)
2420
    {
2421
      BFD_ASSERT (*tls_type & GOT_TLS_IE);
2422
      if (*tls_type & GOT_TLS_GD)
2423
        return got_index + 2 * MIPS_ELF_GOT_SIZE (abfd);
2424
      else
2425
        return got_index;
2426
    }
2427
 
2428
  if (r_type == R_MIPS_TLS_GD)
2429
    {
2430
      BFD_ASSERT (*tls_type & GOT_TLS_GD);
2431
      return got_index;
2432
    }
2433
 
2434
  if (r_type == R_MIPS_TLS_LDM)
2435
    {
2436
      BFD_ASSERT (*tls_type & GOT_TLS_LDM);
2437
      return got_index;
2438
    }
2439
 
2440
  return got_index;
2441
}
2442
 
2443
/* Return the offset from _GLOBAL_OFFSET_TABLE_ of the .got.plt entry
2444
   for global symbol H.  .got.plt comes before the GOT, so the offset
2445
   will be negative.  */
2446
 
2447
static bfd_vma
2448
mips_elf_gotplt_index (struct bfd_link_info *info,
2449
                       struct elf_link_hash_entry *h)
2450
{
2451
  bfd_vma plt_index, got_address, got_value;
2452
  struct mips_elf_link_hash_table *htab;
2453
 
2454
  htab = mips_elf_hash_table (info);
2455
  BFD_ASSERT (h->plt.offset != (bfd_vma) -1);
2456
 
2457
  /* Calculate the index of the symbol's PLT entry.  */
2458
  plt_index = (h->plt.offset - htab->plt_header_size) / htab->plt_entry_size;
2459
 
2460
  /* Calculate the address of the associated .got.plt entry.  */
2461
  got_address = (htab->sgotplt->output_section->vma
2462
                 + htab->sgotplt->output_offset
2463
                 + plt_index * 4);
2464
 
2465
  /* Calculate the value of _GLOBAL_OFFSET_TABLE_.  */
2466
  got_value = (htab->root.hgot->root.u.def.section->output_section->vma
2467
               + htab->root.hgot->root.u.def.section->output_offset
2468
               + htab->root.hgot->root.u.def.value);
2469
 
2470
  return got_address - got_value;
2471
}
2472
 
2473
/* Return the GOT offset for address VALUE.   If there is not yet a GOT
2474
   entry for this value, create one.  If R_SYMNDX refers to a TLS symbol,
2475
   create a TLS GOT entry instead.  Return -1 if no satisfactory GOT
2476
   offset can be found.  */
2477
 
2478
static bfd_vma
2479
mips_elf_local_got_index (bfd *abfd, bfd *ibfd, struct bfd_link_info *info,
2480
                          bfd_vma value, unsigned long r_symndx,
2481
                          struct mips_elf_link_hash_entry *h, int r_type)
2482
{
2483
  asection *sgot;
2484
  struct mips_got_info *g;
2485
  struct mips_got_entry *entry;
2486
 
2487
  g = mips_elf_got_info (elf_hash_table (info)->dynobj, &sgot);
2488
 
2489
  entry = mips_elf_create_local_got_entry (abfd, info, ibfd, g, sgot,
2490
                                           value, r_symndx, h, r_type);
2491
  if (!entry)
2492
    return MINUS_ONE;
2493
 
2494
  if (TLS_RELOC_P (r_type))
2495
    {
2496
      if (entry->symndx == -1 && g->next == NULL)
2497
        /* A type (3) entry in the single-GOT case.  We use the symbol's
2498
           hash table entry to track the index.  */
2499
        return mips_tls_got_index (abfd, h->tls_got_offset, &h->tls_type,
2500
                                   r_type, info, h, value);
2501
      else
2502
        return mips_tls_got_index (abfd, entry->gotidx, &entry->tls_type,
2503
                                   r_type, info, h, value);
2504
    }
2505
  else
2506
    return entry->gotidx;
2507
}
2508
 
2509
/* Returns the GOT index for the global symbol indicated by H.  */
2510
 
2511
static bfd_vma
2512
mips_elf_global_got_index (bfd *abfd, bfd *ibfd, struct elf_link_hash_entry *h,
2513
                           int r_type, struct bfd_link_info *info)
2514
{
2515
  bfd_vma index;
2516
  asection *sgot;
2517
  struct mips_got_info *g, *gg;
2518
  long global_got_dynindx = 0;
2519
 
2520
  gg = g = mips_elf_got_info (abfd, &sgot);
2521
  if (g->bfd2got && ibfd)
2522
    {
2523
      struct mips_got_entry e, *p;
2524
 
2525
      BFD_ASSERT (h->dynindx >= 0);
2526
 
2527
      g = mips_elf_got_for_ibfd (g, ibfd);
2528
      if (g->next != gg || TLS_RELOC_P (r_type))
2529
        {
2530
          e.abfd = ibfd;
2531
          e.symndx = -1;
2532
          e.d.h = (struct mips_elf_link_hash_entry *)h;
2533
          e.tls_type = 0;
2534
 
2535
          p = htab_find (g->got_entries, &e);
2536
 
2537
          BFD_ASSERT (p->gotidx > 0);
2538
 
2539
          if (TLS_RELOC_P (r_type))
2540
            {
2541
              bfd_vma value = MINUS_ONE;
2542
              if ((h->root.type == bfd_link_hash_defined
2543
                   || h->root.type == bfd_link_hash_defweak)
2544
                  && h->root.u.def.section->output_section)
2545
                value = (h->root.u.def.value
2546
                         + h->root.u.def.section->output_offset
2547
                         + h->root.u.def.section->output_section->vma);
2548
 
2549
              return mips_tls_got_index (abfd, p->gotidx, &p->tls_type, r_type,
2550
                                         info, e.d.h, value);
2551
            }
2552
          else
2553
            return p->gotidx;
2554
        }
2555
    }
2556
 
2557
  if (gg->global_gotsym != NULL)
2558
    global_got_dynindx = gg->global_gotsym->dynindx;
2559
 
2560
  if (TLS_RELOC_P (r_type))
2561
    {
2562
      struct mips_elf_link_hash_entry *hm
2563
        = (struct mips_elf_link_hash_entry *) h;
2564
      bfd_vma value = MINUS_ONE;
2565
 
2566
      if ((h->root.type == bfd_link_hash_defined
2567
           || h->root.type == bfd_link_hash_defweak)
2568
          && h->root.u.def.section->output_section)
2569
        value = (h->root.u.def.value
2570
                 + h->root.u.def.section->output_offset
2571
                 + h->root.u.def.section->output_section->vma);
2572
 
2573
      index = mips_tls_got_index (abfd, hm->tls_got_offset, &hm->tls_type,
2574
                                  r_type, info, hm, value);
2575
    }
2576
  else
2577
    {
2578
      /* Once we determine the global GOT entry with the lowest dynamic
2579
         symbol table index, we must put all dynamic symbols with greater
2580
         indices into the GOT.  That makes it easy to calculate the GOT
2581
         offset.  */
2582
      BFD_ASSERT (h->dynindx >= global_got_dynindx);
2583
      index = ((h->dynindx - global_got_dynindx + g->local_gotno)
2584
               * MIPS_ELF_GOT_SIZE (abfd));
2585
    }
2586
  BFD_ASSERT (index < sgot->size);
2587
 
2588
  return index;
2589
}
2590
 
2591
/* Find a GOT page entry that points to within 32KB of VALUE.  These
2592
   entries are supposed to be placed at small offsets in the GOT, i.e.,
2593
   within 32KB of GP.  Return the index of the GOT entry, or -1 if no
2594
   entry could be created.  If OFFSETP is nonnull, use it to return the
2595
   offset of the GOT entry from VALUE.  */
2596
 
2597
static bfd_vma
2598
mips_elf_got_page (bfd *abfd, bfd *ibfd, struct bfd_link_info *info,
2599
                   bfd_vma value, bfd_vma *offsetp)
2600
{
2601
  asection *sgot;
2602
  struct mips_got_info *g;
2603
  bfd_vma page, index;
2604
  struct mips_got_entry *entry;
2605
 
2606
  g = mips_elf_got_info (elf_hash_table (info)->dynobj, &sgot);
2607
 
2608
  page = (value + 0x8000) & ~(bfd_vma) 0xffff;
2609
  entry = mips_elf_create_local_got_entry (abfd, info, ibfd, g, sgot,
2610
                                           page, 0, NULL, R_MIPS_GOT_PAGE);
2611
 
2612
  if (!entry)
2613
    return MINUS_ONE;
2614
 
2615
  index = entry->gotidx;
2616
 
2617
  if (offsetp)
2618
    *offsetp = value - entry->d.address;
2619
 
2620
  return index;
2621
}
2622
 
2623
/* Find a local GOT entry for an R_MIPS_GOT16 relocation against VALUE.
2624
   EXTERNAL is true if the relocation was against a global symbol
2625
   that has been forced local.  */
2626
 
2627
static bfd_vma
2628
mips_elf_got16_entry (bfd *abfd, bfd *ibfd, struct bfd_link_info *info,
2629
                      bfd_vma value, bfd_boolean external)
2630
{
2631
  asection *sgot;
2632
  struct mips_got_info *g;
2633
  struct mips_got_entry *entry;
2634
 
2635
  /* GOT16 relocations against local symbols are followed by a LO16
2636
     relocation; those against global symbols are not.  Thus if the
2637
     symbol was originally local, the GOT16 relocation should load the
2638
     equivalent of %hi(VALUE), otherwise it should load VALUE itself.  */
2639
  if (! external)
2640
    value = mips_elf_high (value) << 16;
2641
 
2642
  g = mips_elf_got_info (elf_hash_table (info)->dynobj, &sgot);
2643
 
2644
  entry = mips_elf_create_local_got_entry (abfd, info, ibfd, g, sgot,
2645
                                           value, 0, NULL, R_MIPS_GOT16);
2646
  if (entry)
2647
    return entry->gotidx;
2648
  else
2649
    return MINUS_ONE;
2650
}
2651
 
2652
/* Returns the offset for the entry at the INDEXth position
2653
   in the GOT.  */
2654
 
2655
static bfd_vma
2656
mips_elf_got_offset_from_index (bfd *dynobj, bfd *output_bfd,
2657
                                bfd *input_bfd, bfd_vma index)
2658
{
2659
  asection *sgot;
2660
  bfd_vma gp;
2661
  struct mips_got_info *g;
2662
 
2663
  g = mips_elf_got_info (dynobj, &sgot);
2664
  gp = _bfd_get_gp_value (output_bfd)
2665
    + mips_elf_adjust_gp (output_bfd, g, input_bfd);
2666
 
2667
  return sgot->output_section->vma + sgot->output_offset + index - gp;
2668
}
2669
 
2670
/* Create and return a local GOT entry for VALUE, which was calculated
2671
   from a symbol belonging to INPUT_SECTON.  Return NULL if it could not
2672
   be created.  If R_SYMNDX refers to a TLS symbol, create a TLS entry
2673
   instead.  */
2674
 
2675
static struct mips_got_entry *
2676
mips_elf_create_local_got_entry (bfd *abfd, struct bfd_link_info *info,
2677
                                 bfd *ibfd, struct mips_got_info *gg,
2678
                                 asection *sgot, bfd_vma value,
2679
                                 unsigned long r_symndx,
2680
                                 struct mips_elf_link_hash_entry *h,
2681
                                 int r_type)
2682
{
2683
  struct mips_got_entry entry, **loc;
2684
  struct mips_got_info *g;
2685
  struct mips_elf_link_hash_table *htab;
2686
 
2687
  htab = mips_elf_hash_table (info);
2688
 
2689
  entry.abfd = NULL;
2690
  entry.symndx = -1;
2691
  entry.d.address = value;
2692
  entry.tls_type = 0;
2693
 
2694
  g = mips_elf_got_for_ibfd (gg, ibfd);
2695
  if (g == NULL)
2696
    {
2697
      g = mips_elf_got_for_ibfd (gg, abfd);
2698
      BFD_ASSERT (g != NULL);
2699
    }
2700
 
2701
  /* We might have a symbol, H, if it has been forced local.  Use the
2702
     global entry then.  It doesn't matter whether an entry is local
2703
     or global for TLS, since the dynamic linker does not
2704
     automatically relocate TLS GOT entries.  */
2705
  BFD_ASSERT (h == NULL || h->root.forced_local);
2706
  if (TLS_RELOC_P (r_type))
2707
    {
2708
      struct mips_got_entry *p;
2709
 
2710
      entry.abfd = ibfd;
2711
      if (r_type == R_MIPS_TLS_LDM)
2712
        {
2713
          entry.tls_type = GOT_TLS_LDM;
2714
          entry.symndx = 0;
2715
          entry.d.addend = 0;
2716
        }
2717
      else if (h == NULL)
2718
        {
2719
          entry.symndx = r_symndx;
2720
          entry.d.addend = 0;
2721
        }
2722
      else
2723
        entry.d.h = h;
2724
 
2725
      p = (struct mips_got_entry *)
2726
        htab_find (g->got_entries, &entry);
2727
 
2728
      BFD_ASSERT (p);
2729
      return p;
2730
    }
2731
 
2732
  loc = (struct mips_got_entry **) htab_find_slot (g->got_entries, &entry,
2733
                                                   INSERT);
2734
  if (*loc)
2735
    return *loc;
2736
 
2737
  entry.gotidx = MIPS_ELF_GOT_SIZE (abfd) * g->assigned_gotno++;
2738
  entry.tls_type = 0;
2739
 
2740
  *loc = (struct mips_got_entry *)bfd_alloc (abfd, sizeof entry);
2741
 
2742
  if (! *loc)
2743
    return NULL;
2744
 
2745
  memcpy (*loc, &entry, sizeof entry);
2746
 
2747
  if (g->assigned_gotno > g->local_gotno)
2748
    {
2749
      (*loc)->gotidx = -1;
2750
      /* We didn't allocate enough space in the GOT.  */
2751
      (*_bfd_error_handler)
2752
        (_("not enough GOT space for local GOT entries"));
2753
      bfd_set_error (bfd_error_bad_value);
2754
      return NULL;
2755
    }
2756
 
2757
  MIPS_ELF_PUT_WORD (abfd, value,
2758
                     (sgot->contents + entry.gotidx));
2759
 
2760
  /* These GOT entries need a dynamic relocation on VxWorks.  */
2761
  if (htab->is_vxworks)
2762
    {
2763
      Elf_Internal_Rela outrel;
2764
      asection *s;
2765
      bfd_byte *loc;
2766
      bfd_vma got_address;
2767
 
2768
      s = mips_elf_rel_dyn_section (info, FALSE);
2769
      got_address = (sgot->output_section->vma
2770
                     + sgot->output_offset
2771
                     + entry.gotidx);
2772
 
2773
      loc = s->contents + (s->reloc_count++ * sizeof (Elf32_External_Rela));
2774
      outrel.r_offset = got_address;
2775
      outrel.r_info = ELF32_R_INFO (STN_UNDEF, R_MIPS_32);
2776
      outrel.r_addend = value;
2777
      bfd_elf32_swap_reloca_out (abfd, &outrel, loc);
2778
    }
2779
 
2780
  return *loc;
2781
}
2782
 
2783
/* Sort the dynamic symbol table so that symbols that need GOT entries
2784
   appear towards the end.  This reduces the amount of GOT space
2785
   required.  MAX_LOCAL is used to set the number of local symbols
2786
   known to be in the dynamic symbol table.  During
2787
   _bfd_mips_elf_size_dynamic_sections, this value is 1.  Afterward, the
2788
   section symbols are added and the count is higher.  */
2789
 
2790
static bfd_boolean
2791
mips_elf_sort_hash_table (struct bfd_link_info *info, unsigned long max_local)
2792
{
2793
  struct mips_elf_hash_sort_data hsd;
2794
  struct mips_got_info *g;
2795
  bfd *dynobj;
2796
 
2797
  dynobj = elf_hash_table (info)->dynobj;
2798
 
2799
  g = mips_elf_got_info (dynobj, NULL);
2800
 
2801
  hsd.low = NULL;
2802
  hsd.max_unref_got_dynindx =
2803
  hsd.min_got_dynindx = elf_hash_table (info)->dynsymcount
2804
    /* In the multi-got case, assigned_gotno of the master got_info
2805
       indicate the number of entries that aren't referenced in the
2806
       primary GOT, but that must have entries because there are
2807
       dynamic relocations that reference it.  Since they aren't
2808
       referenced, we move them to the end of the GOT, so that they
2809
       don't prevent other entries that are referenced from getting
2810
       too large offsets.  */
2811
    - (g->next ? g->assigned_gotno : 0);
2812
  hsd.max_non_got_dynindx = max_local;
2813
  mips_elf_link_hash_traverse (((struct mips_elf_link_hash_table *)
2814
                                elf_hash_table (info)),
2815
                               mips_elf_sort_hash_table_f,
2816
                               &hsd);
2817
 
2818
  /* There should have been enough room in the symbol table to
2819
     accommodate both the GOT and non-GOT symbols.  */
2820
  BFD_ASSERT (hsd.max_non_got_dynindx <= hsd.min_got_dynindx);
2821
  BFD_ASSERT ((unsigned long)hsd.max_unref_got_dynindx
2822
              <= elf_hash_table (info)->dynsymcount);
2823
 
2824
  /* Now we know which dynamic symbol has the lowest dynamic symbol
2825
     table index in the GOT.  */
2826
  g->global_gotsym = hsd.low;
2827
 
2828
  return TRUE;
2829
}
2830
 
2831
/* If H needs a GOT entry, assign it the highest available dynamic
2832
   index.  Otherwise, assign it the lowest available dynamic
2833
   index.  */
2834
 
2835
static bfd_boolean
2836
mips_elf_sort_hash_table_f (struct mips_elf_link_hash_entry *h, void *data)
2837
{
2838
  struct mips_elf_hash_sort_data *hsd = data;
2839
 
2840
  if (h->root.root.type == bfd_link_hash_warning)
2841
    h = (struct mips_elf_link_hash_entry *) h->root.root.u.i.link;
2842
 
2843
  /* Symbols without dynamic symbol table entries aren't interesting
2844
     at all.  */
2845
  if (h->root.dynindx == -1)
2846
    return TRUE;
2847
 
2848
  /* Global symbols that need GOT entries that are not explicitly
2849
     referenced are marked with got offset 2.  Those that are
2850
     referenced get a 1, and those that don't need GOT entries get
2851
     -1.  Forced local symbols may also be marked with got offset 1,
2852
     but are never given global GOT entries.  */
2853
  if (h->root.got.offset == 2)
2854
    {
2855
      BFD_ASSERT (h->tls_type == GOT_NORMAL);
2856
 
2857
      if (hsd->max_unref_got_dynindx == hsd->min_got_dynindx)
2858
        hsd->low = (struct elf_link_hash_entry *) h;
2859
      h->root.dynindx = hsd->max_unref_got_dynindx++;
2860
    }
2861
  else if (h->root.got.offset != 1 || h->forced_local)
2862
    h->root.dynindx = hsd->max_non_got_dynindx++;
2863
  else
2864
    {
2865
      BFD_ASSERT (h->tls_type == GOT_NORMAL);
2866
 
2867
      h->root.dynindx = --hsd->min_got_dynindx;
2868
      hsd->low = (struct elf_link_hash_entry *) h;
2869
    }
2870
 
2871
  return TRUE;
2872
}
2873
 
2874
/* If H is a symbol that needs a global GOT entry, but has a dynamic
2875
   symbol table index lower than any we've seen to date, record it for
2876
   posterity.  */
2877
 
2878
static bfd_boolean
2879
mips_elf_record_global_got_symbol (struct elf_link_hash_entry *h,
2880
                                   bfd *abfd, struct bfd_link_info *info,
2881
                                   struct mips_got_info *g,
2882
                                   unsigned char tls_flag)
2883
{
2884
  struct mips_got_entry entry, **loc;
2885
 
2886
  /* A global symbol in the GOT must also be in the dynamic symbol
2887
     table.  */
2888
  if (h->dynindx == -1)
2889
    {
2890
      switch (ELF_ST_VISIBILITY (h->other))
2891
        {
2892
        case STV_INTERNAL:
2893
        case STV_HIDDEN:
2894
          _bfd_mips_elf_hide_symbol (info, h, TRUE);
2895
          break;
2896
        }
2897
      if (!bfd_elf_link_record_dynamic_symbol (info, h))
2898
        return FALSE;
2899
    }
2900
 
2901
  /* Make sure we have a GOT to put this entry into.  */
2902
  BFD_ASSERT (g != NULL);
2903
 
2904
  entry.abfd = abfd;
2905
  entry.symndx = -1;
2906
  entry.d.h = (struct mips_elf_link_hash_entry *) h;
2907
  entry.tls_type = 0;
2908
 
2909
  loc = (struct mips_got_entry **) htab_find_slot (g->got_entries, &entry,
2910
                                                   INSERT);
2911
 
2912
  /* If we've already marked this entry as needing GOT space, we don't
2913
     need to do it again.  */
2914
  if (*loc)
2915
    {
2916
      (*loc)->tls_type |= tls_flag;
2917
      return TRUE;
2918
    }
2919
 
2920
  *loc = (struct mips_got_entry *)bfd_alloc (abfd, sizeof entry);
2921
 
2922
  if (! *loc)
2923
    return FALSE;
2924
 
2925
  entry.gotidx = -1;
2926
  entry.tls_type = tls_flag;
2927
 
2928
  memcpy (*loc, &entry, sizeof entry);
2929
 
2930
  if (h->got.offset != MINUS_ONE)
2931
    return TRUE;
2932
 
2933
  if (tls_flag == 0)
2934
    {
2935
      /* By setting this to a value other than -1, we are indicating that
2936
         there needs to be a GOT entry for H.  Avoid using zero, as the
2937
         generic ELF copy_indirect_symbol tests for <= 0.  */
2938
      h->got.offset = 1;
2939
      if (h->forced_local)
2940
        g->local_gotno++;
2941
    }
2942
 
2943
  return TRUE;
2944
}
2945
 
2946
/* Reserve space in G for a GOT entry containing the value of symbol
2947
   SYMNDX in input bfd ABDF, plus ADDEND.  */
2948
 
2949
static bfd_boolean
2950
mips_elf_record_local_got_symbol (bfd *abfd, long symndx, bfd_vma addend,
2951
                                  struct mips_got_info *g,
2952
                                  unsigned char tls_flag)
2953
{
2954
  struct mips_got_entry entry, **loc;
2955
 
2956
  entry.abfd = abfd;
2957
  entry.symndx = symndx;
2958
  entry.d.addend = addend;
2959
  entry.tls_type = tls_flag;
2960
  loc = (struct mips_got_entry **)
2961
    htab_find_slot (g->got_entries, &entry, INSERT);
2962
 
2963
  if (*loc)
2964
    {
2965
      if (tls_flag == GOT_TLS_GD && !((*loc)->tls_type & GOT_TLS_GD))
2966
        {
2967
          g->tls_gotno += 2;
2968
          (*loc)->tls_type |= tls_flag;
2969
        }
2970
      else if (tls_flag == GOT_TLS_IE && !((*loc)->tls_type & GOT_TLS_IE))
2971
        {
2972
          g->tls_gotno += 1;
2973
          (*loc)->tls_type |= tls_flag;
2974
        }
2975
      return TRUE;
2976
    }
2977
 
2978
  if (tls_flag != 0)
2979
    {
2980
      entry.gotidx = -1;
2981
      entry.tls_type = tls_flag;
2982
      if (tls_flag == GOT_TLS_IE)
2983
        g->tls_gotno += 1;
2984
      else if (tls_flag == GOT_TLS_GD)
2985
        g->tls_gotno += 2;
2986
      else if (g->tls_ldm_offset == MINUS_ONE)
2987
        {
2988
          g->tls_ldm_offset = MINUS_TWO;
2989
          g->tls_gotno += 2;
2990
        }
2991
    }
2992
  else
2993
    {
2994
      entry.gotidx = g->local_gotno++;
2995
      entry.tls_type = 0;
2996
    }
2997
 
2998
  *loc = (struct mips_got_entry *)bfd_alloc (abfd, sizeof entry);
2999
 
3000
  if (! *loc)
3001
    return FALSE;
3002
 
3003
  memcpy (*loc, &entry, sizeof entry);
3004
 
3005
  return TRUE;
3006
}
3007
 
3008
/* Return the maximum number of GOT page entries required for RANGE.  */
3009
 
3010
static bfd_vma
3011
mips_elf_pages_for_range (const struct mips_got_page_range *range)
3012
{
3013
  return (range->max_addend - range->min_addend + 0x1ffff) >> 16;
3014
}
3015
 
3016
/* Record that ABFD has a page relocation against symbol SYMNDX and
3017
   that ADDEND is the addend for that relocation.  G is the GOT
3018
   information.  This function creates an upper bound on the number of
3019
   GOT slots required; no attempt is made to combine references to
3020
   non-overridable global symbols across multiple input files.  */
3021
 
3022
static bfd_boolean
3023
mips_elf_record_got_page_entry (bfd *abfd, long symndx, bfd_signed_vma addend,
3024
                                struct mips_got_info *g)
3025
{
3026
  struct mips_got_page_entry lookup, *entry;
3027
  struct mips_got_page_range **range_ptr, *range;
3028
  bfd_vma old_pages, new_pages;
3029
  void **loc;
3030
 
3031
  /* Find the mips_got_page_entry hash table entry for this symbol.  */
3032
  lookup.abfd = abfd;
3033
  lookup.symndx = symndx;
3034
  loc = htab_find_slot (g->got_page_entries, &lookup, INSERT);
3035
  if (loc == NULL)
3036
    return FALSE;
3037
 
3038
  /* Create a mips_got_page_entry if this is the first time we've
3039
     seen the symbol.  */
3040
  entry = (struct mips_got_page_entry *) *loc;
3041
  if (!entry)
3042
    {
3043
      entry = bfd_alloc (abfd, sizeof (*entry));
3044
      if (!entry)
3045
        return FALSE;
3046
 
3047
      entry->abfd = abfd;
3048
      entry->symndx = symndx;
3049
      entry->ranges = NULL;
3050
      entry->num_pages = 0;
3051
      *loc = entry;
3052
    }
3053
 
3054
  /* Skip over ranges whose maximum extent cannot share a page entry
3055
     with ADDEND.  */
3056
  range_ptr = &entry->ranges;
3057
  while (*range_ptr && addend > (*range_ptr)->max_addend + 0xffff)
3058
    range_ptr = &(*range_ptr)->next;
3059
 
3060
  /* If we scanned to the end of the list, or found a range whose
3061
     minimum extent cannot share a page entry with ADDEND, create
3062
     a new singleton range.  */
3063
  range = *range_ptr;
3064
  if (!range || addend < range->min_addend - 0xffff)
3065
    {
3066
      range = bfd_alloc (abfd, sizeof (*range));
3067
      if (!range)
3068
        return FALSE;
3069
 
3070
      range->next = *range_ptr;
3071
      range->min_addend = addend;
3072
      range->max_addend = addend;
3073
 
3074
      *range_ptr = range;
3075
      entry->num_pages++;
3076
      g->page_gotno++;
3077
      return TRUE;
3078
    }
3079
 
3080
  /* Remember how many pages the old range contributed.  */
3081
  old_pages = mips_elf_pages_for_range (range);
3082
 
3083
  /* Update the ranges.  */
3084
  if (addend < range->min_addend)
3085
    range->min_addend = addend;
3086
  else if (addend > range->max_addend)
3087
    {
3088
      if (range->next && addend >= range->next->min_addend - 0xffff)
3089
        {
3090
          old_pages += mips_elf_pages_for_range (range->next);
3091
          range->max_addend = range->next->max_addend;
3092
          range->next = range->next->next;
3093
        }
3094
      else
3095
        range->max_addend = addend;
3096
    }
3097
 
3098
  /* Record any change in the total estimate.  */
3099
  new_pages = mips_elf_pages_for_range (range);
3100
  if (old_pages != new_pages)
3101
    {
3102
      entry->num_pages += new_pages - old_pages;
3103
      g->page_gotno += new_pages - old_pages;
3104
    }
3105
 
3106
  return TRUE;
3107
}
3108
 
3109
/* Compute the hash value of the bfd in a bfd2got hash entry.  */
3110
 
3111
static hashval_t
3112
mips_elf_bfd2got_entry_hash (const void *entry_)
3113
{
3114
  const struct mips_elf_bfd2got_hash *entry
3115
    = (struct mips_elf_bfd2got_hash *)entry_;
3116
 
3117
  return entry->bfd->id;
3118
}
3119
 
3120
/* Check whether two hash entries have the same bfd.  */
3121
 
3122
static int
3123
mips_elf_bfd2got_entry_eq (const void *entry1, const void *entry2)
3124
{
3125
  const struct mips_elf_bfd2got_hash *e1
3126
    = (const struct mips_elf_bfd2got_hash *)entry1;
3127
  const struct mips_elf_bfd2got_hash *e2
3128
    = (const struct mips_elf_bfd2got_hash *)entry2;
3129
 
3130
  return e1->bfd == e2->bfd;
3131
}
3132
 
3133
/* In a multi-got link, determine the GOT to be used for IBFD.  G must
3134
   be the master GOT data.  */
3135
 
3136
static struct mips_got_info *
3137
mips_elf_got_for_ibfd (struct mips_got_info *g, bfd *ibfd)
3138
{
3139
  struct mips_elf_bfd2got_hash e, *p;
3140
 
3141
  if (! g->bfd2got)
3142
    return g;
3143
 
3144
  e.bfd = ibfd;
3145
  p = htab_find (g->bfd2got, &e);
3146
  return p ? p->g : NULL;
3147
}
3148
 
3149
/* Use BFD2GOT to find ABFD's got entry, creating one if none exists.
3150
   Return NULL if an error occured.  */
3151
 
3152
static struct mips_got_info *
3153
mips_elf_get_got_for_bfd (struct htab *bfd2got, bfd *output_bfd,
3154
                          bfd *input_bfd)
3155
{
3156
  struct mips_elf_bfd2got_hash bfdgot_entry, *bfdgot;
3157
  struct mips_got_info *g;
3158
  void **bfdgotp;
3159
 
3160
  bfdgot_entry.bfd = input_bfd;
3161
  bfdgotp = htab_find_slot (bfd2got, &bfdgot_entry, INSERT);
3162
  bfdgot = (struct mips_elf_bfd2got_hash *) *bfdgotp;
3163
 
3164
  if (bfdgot == NULL)
3165
    {
3166
      bfdgot = ((struct mips_elf_bfd2got_hash *)
3167
                bfd_alloc (output_bfd, sizeof (struct mips_elf_bfd2got_hash)));
3168
      if (bfdgot == NULL)
3169
        return NULL;
3170
 
3171
      *bfdgotp = bfdgot;
3172
 
3173
      g = ((struct mips_got_info *)
3174
           bfd_alloc (output_bfd, sizeof (struct mips_got_info)));
3175
      if (g == NULL)
3176
        return NULL;
3177
 
3178
      bfdgot->bfd = input_bfd;
3179
      bfdgot->g = g;
3180
 
3181
      g->global_gotsym = NULL;
3182
      g->global_gotno = 0;
3183
      g->local_gotno = 0;
3184
      g->page_gotno = 0;
3185
      g->assigned_gotno = -1;
3186
      g->tls_gotno = 0;
3187
      g->tls_assigned_gotno = 0;
3188
      g->tls_ldm_offset = MINUS_ONE;
3189
      g->got_entries = htab_try_create (1, mips_elf_multi_got_entry_hash,
3190
                                        mips_elf_multi_got_entry_eq, NULL);
3191
      if (g->got_entries == NULL)
3192
        return NULL;
3193
 
3194
      g->got_page_entries = htab_try_create (1, mips_got_page_entry_hash,
3195
                                             mips_got_page_entry_eq, NULL);
3196
      if (g->got_page_entries == NULL)
3197
        return NULL;
3198
 
3199
      g->bfd2got = NULL;
3200
      g->next = NULL;
3201
    }
3202
 
3203
  return bfdgot->g;
3204
}
3205
 
3206
/* A htab_traverse callback for the entries in the master got.
3207
   Create one separate got for each bfd that has entries in the global
3208
   got, such that we can tell how many local and global entries each
3209
   bfd requires.  */
3210
 
3211
static int
3212
mips_elf_make_got_per_bfd (void **entryp, void *p)
3213
{
3214
  struct mips_got_entry *entry = (struct mips_got_entry *)*entryp;
3215
  struct mips_elf_got_per_bfd_arg *arg = (struct mips_elf_got_per_bfd_arg *)p;
3216
  struct mips_got_info *g;
3217
 
3218
  g = mips_elf_get_got_for_bfd (arg->bfd2got, arg->obfd, entry->abfd);
3219
  if (g == NULL)
3220
    {
3221
      arg->obfd = NULL;
3222
      return 0;
3223
    }
3224
 
3225
  /* Insert the GOT entry in the bfd's got entry hash table.  */
3226
  entryp = htab_find_slot (g->got_entries, entry, INSERT);
3227
  if (*entryp != NULL)
3228
    return 1;
3229
 
3230
  *entryp = entry;
3231
 
3232
  if (entry->tls_type)
3233
    {
3234
      if (entry->tls_type & (GOT_TLS_GD | GOT_TLS_LDM))
3235
        g->tls_gotno += 2;
3236
      if (entry->tls_type & GOT_TLS_IE)
3237
        g->tls_gotno += 1;
3238
    }
3239
  else if (entry->symndx >= 0 || entry->d.h->forced_local)
3240
    ++g->local_gotno;
3241
  else
3242
    ++g->global_gotno;
3243
 
3244
  return 1;
3245
}
3246
 
3247
/* A htab_traverse callback for the page entries in the master got.
3248
   Associate each page entry with the bfd's got.  */
3249
 
3250
static int
3251
mips_elf_make_got_pages_per_bfd (void **entryp, void *p)
3252
{
3253
  struct mips_got_page_entry *entry = (struct mips_got_page_entry *) *entryp;
3254
  struct mips_elf_got_per_bfd_arg *arg = (struct mips_elf_got_per_bfd_arg *) p;
3255
  struct mips_got_info *g;
3256
 
3257
  g = mips_elf_get_got_for_bfd (arg->bfd2got, arg->obfd, entry->abfd);
3258
  if (g == NULL)
3259
    {
3260
      arg->obfd = NULL;
3261
      return 0;
3262
    }
3263
 
3264
  /* Insert the GOT entry in the bfd's got entry hash table.  */
3265
  entryp = htab_find_slot (g->got_page_entries, entry, INSERT);
3266
  if (*entryp != NULL)
3267
    return 1;
3268
 
3269
  *entryp = entry;
3270
  g->page_gotno += entry->num_pages;
3271
  return 1;
3272
}
3273
 
3274
/* Consider merging the got described by BFD2GOT with TO, using the
3275
   information given by ARG.  Return -1 if this would lead to overflow,
3276
   1 if they were merged successfully, and 0 if a merge failed due to
3277
   lack of memory.  (These values are chosen so that nonnegative return
3278
   values can be returned by a htab_traverse callback.)  */
3279
 
3280
static int
3281
mips_elf_merge_got_with (struct mips_elf_bfd2got_hash *bfd2got,
3282
                         struct mips_got_info *to,
3283
                         struct mips_elf_got_per_bfd_arg *arg)
3284
{
3285
  struct mips_got_info *from = bfd2got->g;
3286
  unsigned int estimate;
3287
 
3288
  /* Work out how many page entries we would need for the combined GOT.  */
3289
  estimate = arg->max_pages;
3290
  if (estimate >= from->page_gotno + to->page_gotno)
3291
    estimate = from->page_gotno + to->page_gotno;
3292
 
3293
  /* And conservatively estimate how many local, global and TLS entries
3294
     would be needed.  */
3295
  estimate += (from->local_gotno
3296
               + from->global_gotno
3297
               + from->tls_gotno
3298
               + to->local_gotno
3299
               + to->global_gotno
3300
               + to->tls_gotno);
3301
 
3302
  /* Bail out if the combined GOT might be too big.  */
3303
  if (estimate > arg->max_count)
3304
    return -1;
3305
 
3306
  /* Commit to the merge.  Record that TO is now the bfd for this got.  */
3307
  bfd2got->g = to;
3308
 
3309
  /* Transfer the bfd's got information from FROM to TO.  */
3310
  htab_traverse (from->got_entries, mips_elf_make_got_per_bfd, arg);
3311
  if (arg->obfd == NULL)
3312
    return 0;
3313
 
3314
  htab_traverse (from->got_page_entries, mips_elf_make_got_pages_per_bfd, arg);
3315
  if (arg->obfd == NULL)
3316
    return 0;
3317
 
3318
  /* We don't have to worry about releasing memory of the actual
3319
     got entries, since they're all in the master got_entries hash
3320
     table anyway.  */
3321
  htab_delete (from->got_entries);
3322
  htab_delete (from->got_page_entries);
3323
  return 1;
3324
}
3325
 
3326
/* Attempt to merge gots of different input bfds.  Try to use as much
3327
   as possible of the primary got, since it doesn't require explicit
3328
   dynamic relocations, but don't use bfds that would reference global
3329
   symbols out of the addressable range.  Failing the primary got,
3330
   attempt to merge with the current got, or finish the current got
3331
   and then make make the new got current.  */
3332
 
3333
static int
3334
mips_elf_merge_gots (void **bfd2got_, void *p)
3335
{
3336
  struct mips_elf_bfd2got_hash *bfd2got
3337
    = (struct mips_elf_bfd2got_hash *)*bfd2got_;
3338
  struct mips_elf_got_per_bfd_arg *arg = (struct mips_elf_got_per_bfd_arg *)p;
3339
  struct mips_got_info *g;
3340
  unsigned int estimate;
3341
  int result;
3342
 
3343
  g = bfd2got->g;
3344
 
3345
  /* Work out the number of page, local and TLS entries.  */
3346
  estimate = arg->max_pages;
3347
  if (estimate > g->page_gotno)
3348
    estimate = g->page_gotno;
3349
  estimate += g->local_gotno + g->tls_gotno;
3350
 
3351
  /* We place TLS GOT entries after both locals and globals.  The globals
3352
     for the primary GOT may overflow the normal GOT size limit, so be
3353
     sure not to merge a GOT which requires TLS with the primary GOT in that
3354
     case.  This doesn't affect non-primary GOTs.  */
3355
  estimate += (g->tls_gotno > 0 ? arg->global_count : g->global_gotno);
3356
 
3357
  if (estimate <= arg->max_count)
3358
    {
3359
      /* If we don't have a primary GOT, use it as
3360
         a starting point for the primary GOT.  */
3361
      if (!arg->primary)
3362
        {
3363
          arg->primary = bfd2got->g;
3364
          return 1;
3365
        }
3366
 
3367
      /* Try merging with the primary GOT.  */
3368
      result = mips_elf_merge_got_with (bfd2got, arg->primary, arg);
3369
      if (result >= 0)
3370
        return result;
3371
    }
3372
 
3373
  /* If we can merge with the last-created got, do it.  */
3374
  if (arg->current)
3375
    {
3376
      result = mips_elf_merge_got_with (bfd2got, arg->current, arg);
3377
      if (result >= 0)
3378
        return result;
3379
    }
3380
 
3381
  /* Well, we couldn't merge, so create a new GOT.  Don't check if it
3382
     fits; if it turns out that it doesn't, we'll get relocation
3383
     overflows anyway.  */
3384
  g->next = arg->current;
3385
  arg->current = g;
3386
 
3387
  return 1;
3388
}
3389
 
3390
/* Set the TLS GOT index for the GOT entry in ENTRYP.  ENTRYP's NEXT field
3391
   is null iff there is just a single GOT.  */
3392
 
3393
static int
3394
mips_elf_initialize_tls_index (void **entryp, void *p)
3395
{
3396
  struct mips_got_entry *entry = (struct mips_got_entry *)*entryp;
3397
  struct mips_got_info *g = p;
3398
  bfd_vma next_index;
3399
  unsigned char tls_type;
3400
 
3401
  /* We're only interested in TLS symbols.  */
3402
  if (entry->tls_type == 0)
3403
    return 1;
3404
 
3405
  next_index = MIPS_ELF_GOT_SIZE (entry->abfd) * (long) g->tls_assigned_gotno;
3406
 
3407
  if (entry->symndx == -1 && g->next == NULL)
3408
    {
3409
      /* A type (3) got entry in the single-GOT case.  We use the symbol's
3410
         hash table entry to track its index.  */
3411
      if (entry->d.h->tls_type & GOT_TLS_OFFSET_DONE)
3412
        return 1;
3413
      entry->d.h->tls_type |= GOT_TLS_OFFSET_DONE;
3414
      entry->d.h->tls_got_offset = next_index;
3415
      tls_type = entry->d.h->tls_type;
3416
    }
3417
  else
3418
    {
3419
      if (entry->tls_type & GOT_TLS_LDM)
3420
        {
3421
          /* There are separate mips_got_entry objects for each input bfd
3422
             that requires an LDM entry.  Make sure that all LDM entries in
3423
             a GOT resolve to the same index.  */
3424
          if (g->tls_ldm_offset != MINUS_TWO && g->tls_ldm_offset != MINUS_ONE)
3425
            {
3426
              entry->gotidx = g->tls_ldm_offset;
3427
              return 1;
3428
            }
3429
          g->tls_ldm_offset = next_index;
3430
        }
3431
      entry->gotidx = next_index;
3432
      tls_type = entry->tls_type;
3433
    }
3434
 
3435
  /* Account for the entries we've just allocated.  */
3436
  if (tls_type & (GOT_TLS_GD | GOT_TLS_LDM))
3437
    g->tls_assigned_gotno += 2;
3438
  if (tls_type & GOT_TLS_IE)
3439
    g->tls_assigned_gotno += 1;
3440
 
3441
  return 1;
3442
}
3443
 
3444
/* If passed a NULL mips_got_info in the argument, set the marker used
3445
   to tell whether a global symbol needs a got entry (in the primary
3446
   got) to the given VALUE.
3447
 
3448
   If passed a pointer G to a mips_got_info in the argument (it must
3449
   not be the primary GOT), compute the offset from the beginning of
3450
   the (primary) GOT section to the entry in G corresponding to the
3451
   global symbol.  G's assigned_gotno must contain the index of the
3452
   first available global GOT entry in G.  VALUE must contain the size
3453
   of a GOT entry in bytes.  For each global GOT entry that requires a
3454
   dynamic relocation, NEEDED_RELOCS is incremented, and the symbol is
3455
   marked as not eligible for lazy resolution through a function
3456
   stub.  */
3457
static int
3458
mips_elf_set_global_got_offset (void **entryp, void *p)
3459
{
3460
  struct mips_got_entry *entry = (struct mips_got_entry *)*entryp;
3461
  struct mips_elf_set_global_got_offset_arg *arg
3462
    = (struct mips_elf_set_global_got_offset_arg *)p;
3463
  struct mips_got_info *g = arg->g;
3464
 
3465
  if (g && entry->tls_type != GOT_NORMAL)
3466
    arg->needed_relocs +=
3467
      mips_tls_got_relocs (arg->info, entry->tls_type,
3468
                           entry->symndx == -1 ? &entry->d.h->root : NULL);
3469
 
3470
  if (entry->abfd != NULL && entry->symndx == -1
3471
      && entry->d.h->root.dynindx != -1
3472
      && !entry->d.h->forced_local
3473
      && entry->d.h->tls_type == GOT_NORMAL)
3474
    {
3475
      if (g)
3476
        {
3477
          BFD_ASSERT (g->global_gotsym == NULL);
3478
 
3479
          entry->gotidx = arg->value * (long) g->assigned_gotno++;
3480
          if (arg->info->shared
3481
              || (elf_hash_table (arg->info)->dynamic_sections_created
3482
                  && entry->d.h->root.def_dynamic
3483
                  && !entry->d.h->root.def_regular))
3484
            ++arg->needed_relocs;
3485
        }
3486
      else
3487
        entry->d.h->root.got.offset = arg->value;
3488
    }
3489
 
3490
  return 1;
3491
}
3492
 
3493
/* Mark any global symbols referenced in the GOT we are iterating over
3494
   as inelligible for lazy resolution stubs.  */
3495
static int
3496
mips_elf_set_no_stub (void **entryp, void *p ATTRIBUTE_UNUSED)
3497
{
3498
  struct mips_got_entry *entry = (struct mips_got_entry *)*entryp;
3499
 
3500
  if (entry->abfd != NULL
3501
      && entry->symndx == -1
3502
      && entry->d.h->root.dynindx != -1)
3503
    entry->d.h->no_fn_stub = TRUE;
3504
 
3505
  return 1;
3506
}
3507
 
3508
/* Follow indirect and warning hash entries so that each got entry
3509
   points to the final symbol definition.  P must point to a pointer
3510
   to the hash table we're traversing.  Since this traversal may
3511
   modify the hash table, we set this pointer to NULL to indicate
3512
   we've made a potentially-destructive change to the hash table, so
3513
   the traversal must be restarted.  */
3514
static int
3515
mips_elf_resolve_final_got_entry (void **entryp, void *p)
3516
{
3517
  struct mips_got_entry *entry = (struct mips_got_entry *)*entryp;
3518
  htab_t got_entries = *(htab_t *)p;
3519
 
3520
  if (entry->abfd != NULL && entry->symndx == -1)
3521
    {
3522
      struct mips_elf_link_hash_entry *h = entry->d.h;
3523
 
3524
      while (h->root.root.type == bfd_link_hash_indirect
3525
             || h->root.root.type == bfd_link_hash_warning)
3526
        h = (struct mips_elf_link_hash_entry *) h->root.root.u.i.link;
3527
 
3528
      if (entry->d.h == h)
3529
        return 1;
3530
 
3531
      entry->d.h = h;
3532
 
3533
      /* If we can't find this entry with the new bfd hash, re-insert
3534
         it, and get the traversal restarted.  */
3535
      if (! htab_find (got_entries, entry))
3536
        {
3537
          htab_clear_slot (got_entries, entryp);
3538
          entryp = htab_find_slot (got_entries, entry, INSERT);
3539
          if (! *entryp)
3540
            *entryp = entry;
3541
          /* Abort the traversal, since the whole table may have
3542
             moved, and leave it up to the parent to restart the
3543
             process.  */
3544
          *(htab_t *)p = NULL;
3545
          return 0;
3546
        }
3547
      /* We might want to decrement the global_gotno count, but it's
3548
         either too early or too late for that at this point.  */
3549
    }
3550
 
3551
  return 1;
3552
}
3553
 
3554
/* Turn indirect got entries in a got_entries table into their final
3555
   locations.  */
3556
static void
3557
mips_elf_resolve_final_got_entries (struct mips_got_info *g)
3558
{
3559
  htab_t got_entries;
3560
 
3561
  do
3562
    {
3563
      got_entries = g->got_entries;
3564
 
3565
      htab_traverse (got_entries,
3566
                     mips_elf_resolve_final_got_entry,
3567
                     &got_entries);
3568
    }
3569
  while (got_entries == NULL);
3570
}
3571
 
3572
/* Return the offset of an input bfd IBFD's GOT from the beginning of
3573
   the primary GOT.  */
3574
static bfd_vma
3575
mips_elf_adjust_gp (bfd *abfd, struct mips_got_info *g, bfd *ibfd)
3576
{
3577
  if (g->bfd2got == NULL)
3578
    return 0;
3579
 
3580
  g = mips_elf_got_for_ibfd (g, ibfd);
3581
  if (! g)
3582
    return 0;
3583
 
3584
  BFD_ASSERT (g->next);
3585
 
3586
  g = g->next;
3587
 
3588
  return (g->local_gotno + g->global_gotno + g->tls_gotno)
3589
    * MIPS_ELF_GOT_SIZE (abfd);
3590
}
3591
 
3592
/* Turn a single GOT that is too big for 16-bit addressing into
3593
   a sequence of GOTs, each one 16-bit addressable.  */
3594
 
3595
static bfd_boolean
3596
mips_elf_multi_got (bfd *abfd, struct bfd_link_info *info,
3597
                    struct mips_got_info *g, asection *got,
3598
                    bfd_size_type pages)
3599
{
3600
  struct mips_elf_got_per_bfd_arg got_per_bfd_arg;
3601
  struct mips_elf_set_global_got_offset_arg set_got_offset_arg;
3602
  struct mips_got_info *gg;
3603
  unsigned int assign;
3604
 
3605
  g->bfd2got = htab_try_create (1, mips_elf_bfd2got_entry_hash,
3606
                                mips_elf_bfd2got_entry_eq, NULL);
3607
  if (g->bfd2got == NULL)
3608
    return FALSE;
3609
 
3610
  got_per_bfd_arg.bfd2got = g->bfd2got;
3611
  got_per_bfd_arg.obfd = abfd;
3612
  got_per_bfd_arg.info = info;
3613
 
3614
  /* Count how many GOT entries each input bfd requires, creating a
3615
     map from bfd to got info while at that.  */
3616
  htab_traverse (g->got_entries, mips_elf_make_got_per_bfd, &got_per_bfd_arg);
3617
  if (got_per_bfd_arg.obfd == NULL)
3618
    return FALSE;
3619
 
3620
  /* Also count how many page entries each input bfd requires.  */
3621
  htab_traverse (g->got_page_entries, mips_elf_make_got_pages_per_bfd,
3622
                 &got_per_bfd_arg);
3623
  if (got_per_bfd_arg.obfd == NULL)
3624
    return FALSE;
3625
 
3626
  got_per_bfd_arg.current = NULL;
3627
  got_per_bfd_arg.primary = NULL;
3628
  got_per_bfd_arg.max_count = ((MIPS_ELF_GOT_MAX_SIZE (info)
3629
                                / MIPS_ELF_GOT_SIZE (abfd))
3630
                               - MIPS_RESERVED_GOTNO (info));
3631
  got_per_bfd_arg.max_pages = pages;
3632
  /* The number of globals that will be included in the primary GOT.
3633
     See the calls to mips_elf_set_global_got_offset below for more
3634
     information.  */
3635
  got_per_bfd_arg.global_count = g->global_gotno;
3636
 
3637
  /* Try to merge the GOTs of input bfds together, as long as they
3638
     don't seem to exceed the maximum GOT size, choosing one of them
3639
     to be the primary GOT.  */
3640
  htab_traverse (g->bfd2got, mips_elf_merge_gots, &got_per_bfd_arg);
3641
  if (got_per_bfd_arg.obfd == NULL)
3642
    return FALSE;
3643
 
3644
  /* If we do not find any suitable primary GOT, create an empty one.  */
3645
  if (got_per_bfd_arg.primary == NULL)
3646
    {
3647
      g->next = (struct mips_got_info *)
3648
        bfd_alloc (abfd, sizeof (struct mips_got_info));
3649
      if (g->next == NULL)
3650
        return FALSE;
3651
 
3652
      g->next->global_gotsym = NULL;
3653
      g->next->global_gotno = 0;
3654
      g->next->local_gotno = 0;
3655
      g->next->page_gotno = 0;
3656
      g->next->tls_gotno = 0;
3657
      g->next->assigned_gotno = 0;
3658
      g->next->tls_assigned_gotno = 0;
3659
      g->next->tls_ldm_offset = MINUS_ONE;
3660
      g->next->got_entries = htab_try_create (1, mips_elf_multi_got_entry_hash,
3661
                                              mips_elf_multi_got_entry_eq,
3662
                                              NULL);
3663
      if (g->next->got_entries == NULL)
3664
        return FALSE;
3665
      g->next->got_page_entries = htab_try_create (1, mips_got_page_entry_hash,
3666
                                                   mips_got_page_entry_eq,
3667
                                                   NULL);
3668
      if (g->next->got_page_entries == NULL)
3669
        return FALSE;
3670
      g->next->bfd2got = NULL;
3671
    }
3672
  else
3673
    g->next = got_per_bfd_arg.primary;
3674
  g->next->next = got_per_bfd_arg.current;
3675
 
3676
  /* GG is now the master GOT, and G is the primary GOT.  */
3677
  gg = g;
3678
  g = g->next;
3679
 
3680
  /* Map the output bfd to the primary got.  That's what we're going
3681
     to use for bfds that use GOT16 or GOT_PAGE relocations that we
3682
     didn't mark in check_relocs, and we want a quick way to find it.
3683
     We can't just use gg->next because we're going to reverse the
3684
     list.  */
3685
  {
3686
    struct mips_elf_bfd2got_hash *bfdgot;
3687
    void **bfdgotp;
3688
 
3689
    bfdgot = (struct mips_elf_bfd2got_hash *)bfd_alloc
3690
      (abfd, sizeof (struct mips_elf_bfd2got_hash));
3691
 
3692
    if (bfdgot == NULL)
3693
      return FALSE;
3694
 
3695
    bfdgot->bfd = abfd;
3696
    bfdgot->g = g;
3697
    bfdgotp = htab_find_slot (gg->bfd2got, bfdgot, INSERT);
3698
 
3699
    BFD_ASSERT (*bfdgotp == NULL);
3700
    *bfdgotp = bfdgot;
3701
  }
3702
 
3703
  /* The IRIX dynamic linker requires every symbol that is referenced
3704
     in a dynamic relocation to be present in the primary GOT, so
3705
     arrange for them to appear after those that are actually
3706
     referenced.
3707
 
3708
     GNU/Linux could very well do without it, but it would slow down
3709
     the dynamic linker, since it would have to resolve every dynamic
3710
     symbol referenced in other GOTs more than once, without help from
3711
     the cache.  Also, knowing that every external symbol has a GOT
3712
     helps speed up the resolution of local symbols too, so GNU/Linux
3713
     follows IRIX's practice.
3714
 
3715
     The number 2 is used by mips_elf_sort_hash_table_f to count
3716
     global GOT symbols that are unreferenced in the primary GOT, with
3717
     an initial dynamic index computed from gg->assigned_gotno, where
3718
     the number of unreferenced global entries in the primary GOT is
3719
     preserved.  */
3720
  if (1)
3721
    {
3722
      gg->assigned_gotno = gg->global_gotno - g->global_gotno;
3723
      g->global_gotno = gg->global_gotno;
3724
      set_got_offset_arg.value = 2;
3725
    }
3726
  else
3727
    {
3728
      /* This could be used for dynamic linkers that don't optimize
3729
         symbol resolution while applying relocations so as to use
3730
         primary GOT entries or assuming the symbol is locally-defined.
3731
         With this code, we assign lower dynamic indices to global
3732
         symbols that are not referenced in the primary GOT, so that
3733
         their entries can be omitted.  */
3734
      gg->assigned_gotno = 0;
3735
      set_got_offset_arg.value = -1;
3736
    }
3737
 
3738
  /* Reorder dynamic symbols as described above (which behavior
3739
     depends on the setting of VALUE).  */
3740
  set_got_offset_arg.g = NULL;
3741
  htab_traverse (gg->got_entries, mips_elf_set_global_got_offset,
3742
                 &set_got_offset_arg);
3743
  set_got_offset_arg.value = 1;
3744
  htab_traverse (g->got_entries, mips_elf_set_global_got_offset,
3745
                 &set_got_offset_arg);
3746
  if (! mips_elf_sort_hash_table (info, 1))
3747
    return FALSE;
3748
 
3749
  /* Now go through the GOTs assigning them offset ranges.
3750
     [assigned_gotno, local_gotno[ will be set to the range of local
3751
     entries in each GOT.  We can then compute the end of a GOT by
3752
     adding local_gotno to global_gotno.  We reverse the list and make
3753
     it circular since then we'll be able to quickly compute the
3754
     beginning of a GOT, by computing the end of its predecessor.  To
3755
     avoid special cases for the primary GOT, while still preserving
3756
     assertions that are valid for both single- and multi-got links,
3757
     we arrange for the main got struct to have the right number of
3758
     global entries, but set its local_gotno such that the initial
3759
     offset of the primary GOT is zero.  Remember that the primary GOT
3760
     will become the last item in the circular linked list, so it
3761
     points back to the master GOT.  */
3762
  gg->local_gotno = -g->global_gotno;
3763
  gg->global_gotno = g->global_gotno;
3764
  gg->tls_gotno = 0;
3765
  assign = 0;
3766
  gg->next = gg;
3767
 
3768
  do
3769
    {
3770
      struct mips_got_info *gn;
3771
 
3772
      assign += MIPS_RESERVED_GOTNO (info);
3773
      g->assigned_gotno = assign;
3774
      g->local_gotno += assign;
3775
      g->local_gotno += (pages < g->page_gotno ? pages : g->page_gotno);
3776
      assign = g->local_gotno + g->global_gotno + g->tls_gotno;
3777
 
3778
      /* Take g out of the direct list, and push it onto the reversed
3779
         list that gg points to.  g->next is guaranteed to be nonnull after
3780
         this operation, as required by mips_elf_initialize_tls_index. */
3781
      gn = g->next;
3782
      g->next = gg->next;
3783
      gg->next = g;
3784
 
3785
      /* Set up any TLS entries.  We always place the TLS entries after
3786
         all non-TLS entries.  */
3787
      g->tls_assigned_gotno = g->local_gotno + g->global_gotno;
3788
      htab_traverse (g->got_entries, mips_elf_initialize_tls_index, g);
3789
 
3790
      /* Move onto the next GOT.  It will be a secondary GOT if nonull.  */
3791
      g = gn;
3792
 
3793
      /* Mark global symbols in every non-primary GOT as ineligible for
3794
         stubs.  */
3795
      if (g)
3796
        htab_traverse (g->got_entries, mips_elf_set_no_stub, NULL);
3797
    }
3798
  while (g);
3799
 
3800
  got->size = (gg->next->local_gotno
3801
                    + gg->next->global_gotno
3802
                    + gg->next->tls_gotno) * MIPS_ELF_GOT_SIZE (abfd);
3803
 
3804
  return TRUE;
3805
}
3806
 
3807
 
3808
/* Returns the first relocation of type r_type found, beginning with
3809
   RELOCATION.  RELEND is one-past-the-end of the relocation table.  */
3810
 
3811
static const Elf_Internal_Rela *
3812
mips_elf_next_relocation (bfd *abfd ATTRIBUTE_UNUSED, unsigned int r_type,
3813
                          const Elf_Internal_Rela *relocation,
3814
                          const Elf_Internal_Rela *relend)
3815
{
3816
  unsigned long r_symndx = ELF_R_SYM (abfd, relocation->r_info);
3817
 
3818
  while (relocation < relend)
3819
    {
3820
      if (ELF_R_TYPE (abfd, relocation->r_info) == r_type
3821
          && ELF_R_SYM (abfd, relocation->r_info) == r_symndx)
3822
        return relocation;
3823
 
3824
      ++relocation;
3825
    }
3826
 
3827
  /* We didn't find it.  */
3828
  return NULL;
3829
}
3830
 
3831
/* Return whether a relocation is against a local symbol.  */
3832
 
3833
static bfd_boolean
3834
mips_elf_local_relocation_p (bfd *input_bfd,
3835
                             const Elf_Internal_Rela *relocation,
3836
                             asection **local_sections,
3837
                             bfd_boolean check_forced)
3838
{
3839
  unsigned long r_symndx;
3840
  Elf_Internal_Shdr *symtab_hdr;
3841
  struct mips_elf_link_hash_entry *h;
3842
  size_t extsymoff;
3843
 
3844
  r_symndx = ELF_R_SYM (input_bfd, relocation->r_info);
3845
  symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
3846
  extsymoff = (elf_bad_symtab (input_bfd)) ? 0 : symtab_hdr->sh_info;
3847
 
3848
  if (r_symndx < extsymoff)
3849
    return TRUE;
3850
  if (elf_bad_symtab (input_bfd) && local_sections[r_symndx] != NULL)
3851
    return TRUE;
3852
 
3853
  if (check_forced)
3854
    {
3855
      /* Look up the hash table to check whether the symbol
3856
         was forced local.  */
3857
      h = (struct mips_elf_link_hash_entry *)
3858
        elf_sym_hashes (input_bfd) [r_symndx - extsymoff];
3859
      /* Find the real hash-table entry for this symbol.  */
3860
      while (h->root.root.type == bfd_link_hash_indirect
3861
             || h->root.root.type == bfd_link_hash_warning)
3862
        h = (struct mips_elf_link_hash_entry *) h->root.root.u.i.link;
3863
      if (h->root.forced_local)
3864
        return TRUE;
3865
    }
3866
 
3867
  return FALSE;
3868
}
3869
 
3870
/* Sign-extend VALUE, which has the indicated number of BITS.  */
3871
 
3872
bfd_vma
3873
_bfd_mips_elf_sign_extend (bfd_vma value, int bits)
3874
{
3875
  if (value & ((bfd_vma) 1 << (bits - 1)))
3876
    /* VALUE is negative.  */
3877
    value |= ((bfd_vma) - 1) << bits;
3878
 
3879
  return value;
3880
}
3881
 
3882
/* Return non-zero if the indicated VALUE has overflowed the maximum
3883
   range expressible by a signed number with the indicated number of
3884
   BITS.  */
3885
 
3886
static bfd_boolean
3887
mips_elf_overflow_p (bfd_vma value, int bits)
3888
{
3889
  bfd_signed_vma svalue = (bfd_signed_vma) value;
3890
 
3891
  if (svalue > (1 << (bits - 1)) - 1)
3892
    /* The value is too big.  */
3893
    return TRUE;
3894
  else if (svalue < -(1 << (bits - 1)))
3895
    /* The value is too small.  */
3896
    return TRUE;
3897
 
3898
  /* All is well.  */
3899
  return FALSE;
3900
}
3901
 
3902
/* Calculate the %high function.  */
3903
 
3904
static bfd_vma
3905
mips_elf_high (bfd_vma value)
3906
{
3907
  return ((value + (bfd_vma) 0x8000) >> 16) & 0xffff;
3908
}
3909
 
3910
/* Calculate the %higher function.  */
3911
 
3912
static bfd_vma
3913
mips_elf_higher (bfd_vma value ATTRIBUTE_UNUSED)
3914
{
3915
#ifdef BFD64
3916
  return ((value + (bfd_vma) 0x80008000) >> 32) & 0xffff;
3917
#else
3918
  abort ();
3919
  return MINUS_ONE;
3920
#endif
3921
}
3922
 
3923
/* Calculate the %highest function.  */
3924
 
3925
static bfd_vma
3926
mips_elf_highest (bfd_vma value ATTRIBUTE_UNUSED)
3927
{
3928
#ifdef BFD64
3929
  return ((value + (((bfd_vma) 0x8000 << 32) | 0x80008000)) >> 48) & 0xffff;
3930
#else
3931
  abort ();
3932
  return MINUS_ONE;
3933
#endif
3934
}
3935
 
3936
/* Create the .compact_rel section.  */
3937
 
3938
static bfd_boolean
3939
mips_elf_create_compact_rel_section
3940
  (bfd *abfd, struct bfd_link_info *info ATTRIBUTE_UNUSED)
3941
{
3942
  flagword flags;
3943
  register asection *s;
3944
 
3945
  if (bfd_get_section_by_name (abfd, ".compact_rel") == NULL)
3946
    {
3947
      flags = (SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED
3948
               | SEC_READONLY);
3949
 
3950
      s = bfd_make_section_with_flags (abfd, ".compact_rel", flags);
3951
      if (s == NULL
3952
          || ! bfd_set_section_alignment (abfd, s,
3953
                                          MIPS_ELF_LOG_FILE_ALIGN (abfd)))
3954
        return FALSE;
3955
 
3956
      s->size = sizeof (Elf32_External_compact_rel);
3957
    }
3958
 
3959
  return TRUE;
3960
}
3961
 
3962
/* Create the .got section to hold the global offset table.  */
3963
 
3964
static bfd_boolean
3965
mips_elf_create_got_section (bfd *abfd, struct bfd_link_info *info,
3966
                             bfd_boolean maybe_exclude)
3967
{
3968
  flagword flags;
3969
  register asection *s;
3970
  struct elf_link_hash_entry *h;
3971
  struct bfd_link_hash_entry *bh;
3972
  struct mips_got_info *g;
3973
  bfd_size_type amt;
3974
  struct mips_elf_link_hash_table *htab;
3975
 
3976
  htab = mips_elf_hash_table (info);
3977
 
3978
  /* This function may be called more than once.  */
3979
  s = mips_elf_got_section (abfd, TRUE);
3980
  if (s)
3981
    {
3982
      if (! maybe_exclude)
3983
        s->flags &= ~SEC_EXCLUDE;
3984
      return TRUE;
3985
    }
3986
 
3987
  flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
3988
           | SEC_LINKER_CREATED);
3989
 
3990
  if (maybe_exclude)
3991
    flags |= SEC_EXCLUDE;
3992
 
3993
  /* We have to use an alignment of 2**4 here because this is hardcoded
3994
     in the function stub generation and in the linker script.  */
3995
  s = bfd_make_section_with_flags (abfd, ".got", flags);
3996
  if (s == NULL
3997
      || ! bfd_set_section_alignment (abfd, s, 4))
3998
    return FALSE;
3999
 
4000
  /* Define the symbol _GLOBAL_OFFSET_TABLE_.  We don't do this in the
4001
     linker script because we don't want to define the symbol if we
4002
     are not creating a global offset table.  */
4003
  bh = NULL;
4004
  if (! (_bfd_generic_link_add_one_symbol
4005
         (info, abfd, "_GLOBAL_OFFSET_TABLE_", BSF_GLOBAL, s,
4006
          0, NULL, FALSE, get_elf_backend_data (abfd)->collect, &bh)))
4007
    return FALSE;
4008
 
4009
  h = (struct elf_link_hash_entry *) bh;
4010
  h->non_elf = 0;
4011
  h->def_regular = 1;
4012
  h->type = STT_OBJECT;
4013
  elf_hash_table (info)->hgot = h;
4014
 
4015
  if (info->shared
4016
      && ! bfd_elf_link_record_dynamic_symbol (info, h))
4017
    return FALSE;
4018
 
4019
  amt = sizeof (struct mips_got_info);
4020
  g = bfd_alloc (abfd, amt);
4021
  if (g == NULL)
4022
    return FALSE;
4023
  g->global_gotsym = NULL;
4024
  g->global_gotno = 0;
4025
  g->tls_gotno = 0;
4026
  g->local_gotno = MIPS_RESERVED_GOTNO (info);
4027
  g->page_gotno = 0;
4028
  g->assigned_gotno = MIPS_RESERVED_GOTNO (info);
4029
  g->bfd2got = NULL;
4030
  g->next = NULL;
4031
  g->tls_ldm_offset = MINUS_ONE;
4032
  g->got_entries = htab_try_create (1, mips_elf_got_entry_hash,
4033
                                    mips_elf_got_entry_eq, NULL);
4034
  if (g->got_entries == NULL)
4035
    return FALSE;
4036
  g->got_page_entries = htab_try_create (1, mips_got_page_entry_hash,
4037
                                         mips_got_page_entry_eq, NULL);
4038
  if (g->got_page_entries == NULL)
4039
    return FALSE;
4040
  mips_elf_section_data (s)->u.got_info = g;
4041
  mips_elf_section_data (s)->elf.this_hdr.sh_flags
4042
    |= SHF_ALLOC | SHF_WRITE | SHF_MIPS_GPREL;
4043
 
4044
  /* VxWorks also needs a .got.plt section.  */
4045
  if (htab->is_vxworks)
4046
    {
4047
      s = bfd_make_section_with_flags (abfd, ".got.plt",
4048
                                       SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS
4049
                                       | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4050
      if (s == NULL || !bfd_set_section_alignment (abfd, s, 4))
4051
        return FALSE;
4052
 
4053
      htab->sgotplt = s;
4054
    }
4055
  return TRUE;
4056
}
4057
 
4058
/* Return true if H refers to the special VxWorks __GOTT_BASE__ or
4059
   __GOTT_INDEX__ symbols.  These symbols are only special for
4060
   shared objects; they are not used in executables.  */
4061
 
4062
static bfd_boolean
4063
is_gott_symbol (struct bfd_link_info *info, struct elf_link_hash_entry *h)
4064
{
4065
  return (mips_elf_hash_table (info)->is_vxworks
4066
          && info->shared
4067
          && (strcmp (h->root.root.string, "__GOTT_BASE__") == 0
4068
              || strcmp (h->root.root.string, "__GOTT_INDEX__") == 0));
4069
}
4070
 
4071
/* Calculate the value produced by the RELOCATION (which comes from
4072
   the INPUT_BFD).  The ADDEND is the addend to use for this
4073
   RELOCATION; RELOCATION->R_ADDEND is ignored.
4074
 
4075
   The result of the relocation calculation is stored in VALUEP.
4076
   REQUIRE_JALXP indicates whether or not the opcode used with this
4077
   relocation must be JALX.
4078
 
4079
   This function returns bfd_reloc_continue if the caller need take no
4080
   further action regarding this relocation, bfd_reloc_notsupported if
4081
   something goes dramatically wrong, bfd_reloc_overflow if an
4082
   overflow occurs, and bfd_reloc_ok to indicate success.  */
4083
 
4084
static bfd_reloc_status_type
4085
mips_elf_calculate_relocation (bfd *abfd, bfd *input_bfd,
4086
                               asection *input_section,
4087
                               struct bfd_link_info *info,
4088
                               const Elf_Internal_Rela *relocation,
4089
                               bfd_vma addend, reloc_howto_type *howto,
4090
                               Elf_Internal_Sym *local_syms,
4091
                               asection **local_sections, bfd_vma *valuep,
4092
                               const char **namep, bfd_boolean *require_jalxp,
4093
                               bfd_boolean save_addend)
4094
{
4095
  /* The eventual value we will return.  */
4096
  bfd_vma value;
4097
  /* The address of the symbol against which the relocation is
4098
     occurring.  */
4099
  bfd_vma symbol = 0;
4100
  /* The final GP value to be used for the relocatable, executable, or
4101
     shared object file being produced.  */
4102
  bfd_vma gp = MINUS_ONE;
4103
  /* The place (section offset or address) of the storage unit being
4104
     relocated.  */
4105
  bfd_vma p;
4106
  /* The value of GP used to create the relocatable object.  */
4107
  bfd_vma gp0 = MINUS_ONE;
4108
  /* The offset into the global offset table at which the address of
4109
     the relocation entry symbol, adjusted by the addend, resides
4110
     during execution.  */
4111
  bfd_vma g = MINUS_ONE;
4112
  /* The section in which the symbol referenced by the relocation is
4113
     located.  */
4114
  asection *sec = NULL;
4115
  struct mips_elf_link_hash_entry *h = NULL;
4116
  /* TRUE if the symbol referred to by this relocation is a local
4117
     symbol.  */
4118
  bfd_boolean local_p, was_local_p;
4119
  /* TRUE if the symbol referred to by this relocation is "_gp_disp".  */
4120
  bfd_boolean gp_disp_p = FALSE;
4121
  /* TRUE if the symbol referred to by this relocation is
4122
     "__gnu_local_gp".  */
4123
  bfd_boolean gnu_local_gp_p = FALSE;
4124
  Elf_Internal_Shdr *symtab_hdr;
4125
  size_t extsymoff;
4126
  unsigned long r_symndx;
4127
  int r_type;
4128
  /* TRUE if overflow occurred during the calculation of the
4129
     relocation value.  */
4130
  bfd_boolean overflowed_p;
4131
  /* TRUE if this relocation refers to a MIPS16 function.  */
4132
  bfd_boolean target_is_16_bit_code_p = FALSE;
4133
  struct mips_elf_link_hash_table *htab;
4134
  bfd *dynobj;
4135
 
4136
  dynobj = elf_hash_table (info)->dynobj;
4137
  htab = mips_elf_hash_table (info);
4138
 
4139
  /* Parse the relocation.  */
4140
  r_symndx = ELF_R_SYM (input_bfd, relocation->r_info);
4141
  r_type = ELF_R_TYPE (input_bfd, relocation->r_info);
4142
  p = (input_section->output_section->vma
4143
       + input_section->output_offset
4144
       + relocation->r_offset);
4145
 
4146
  /* Assume that there will be no overflow.  */
4147
  overflowed_p = FALSE;
4148
 
4149
  /* Figure out whether or not the symbol is local, and get the offset
4150
     used in the array of hash table entries.  */
4151
  symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
4152
  local_p = mips_elf_local_relocation_p (input_bfd, relocation,
4153
                                         local_sections, FALSE);
4154
  was_local_p = local_p;
4155
  if (! elf_bad_symtab (input_bfd))
4156
    extsymoff = symtab_hdr->sh_info;
4157
  else
4158
    {
4159
      /* The symbol table does not follow the rule that local symbols
4160
         must come before globals.  */
4161
      extsymoff = 0;
4162
    }
4163
 
4164
  /* Figure out the value of the symbol.  */
4165
  if (local_p)
4166
    {
4167
      Elf_Internal_Sym *sym;
4168
 
4169
      sym = local_syms + r_symndx;
4170
      sec = local_sections[r_symndx];
4171
 
4172
      symbol = sec->output_section->vma + sec->output_offset;
4173
      if (ELF_ST_TYPE (sym->st_info) != STT_SECTION
4174
          || (sec->flags & SEC_MERGE))
4175
        symbol += sym->st_value;
4176
      if ((sec->flags & SEC_MERGE)
4177
          && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
4178
        {
4179
          addend = _bfd_elf_rel_local_sym (abfd, sym, &sec, addend);
4180
          addend -= symbol;
4181
          addend += sec->output_section->vma + sec->output_offset;
4182
        }
4183
 
4184
      /* MIPS16 text labels should be treated as odd.  */
4185
      if (sym->st_other == STO_MIPS16)
4186
        ++symbol;
4187
 
4188
      /* Record the name of this symbol, for our caller.  */
4189
      *namep = bfd_elf_string_from_elf_section (input_bfd,
4190
                                                symtab_hdr->sh_link,
4191
                                                sym->st_name);
4192
      if (*namep == '\0')
4193
        *namep = bfd_section_name (input_bfd, sec);
4194
 
4195
      target_is_16_bit_code_p = (sym->st_other == STO_MIPS16);
4196
    }
4197
  else
4198
    {
4199
      /* ??? Could we use RELOC_FOR_GLOBAL_SYMBOL here ?  */
4200
 
4201
      /* For global symbols we look up the symbol in the hash-table.  */
4202
      h = ((struct mips_elf_link_hash_entry *)
4203
           elf_sym_hashes (input_bfd) [r_symndx - extsymoff]);
4204
      /* Find the real hash-table entry for this symbol.  */
4205
      while (h->root.root.type == bfd_link_hash_indirect
4206
             || h->root.root.type == bfd_link_hash_warning)
4207
        h = (struct mips_elf_link_hash_entry *) h->root.root.u.i.link;
4208
 
4209
      /* Record the name of this symbol, for our caller.  */
4210
      *namep = h->root.root.root.string;
4211
 
4212
      /* See if this is the special _gp_disp symbol.  Note that such a
4213
         symbol must always be a global symbol.  */
4214
      if (strcmp (*namep, "_gp_disp") == 0
4215
          && ! NEWABI_P (input_bfd))
4216
        {
4217
          /* Relocations against _gp_disp are permitted only with
4218
             R_MIPS_HI16 and R_MIPS_LO16 relocations.  */
4219
          if (r_type != R_MIPS_HI16 && r_type != R_MIPS_LO16
4220
              && r_type != R_MIPS16_HI16 && r_type != R_MIPS16_LO16)
4221
            return bfd_reloc_notsupported;
4222
 
4223
          gp_disp_p = TRUE;
4224
        }
4225
      /* See if this is the special _gp symbol.  Note that such a
4226
         symbol must always be a global symbol.  */
4227
      else if (strcmp (*namep, "__gnu_local_gp") == 0)
4228
        gnu_local_gp_p = TRUE;
4229
 
4230
 
4231
      /* If this symbol is defined, calculate its address.  Note that
4232
         _gp_disp is a magic symbol, always implicitly defined by the
4233
         linker, so it's inappropriate to check to see whether or not
4234
         its defined.  */
4235
      else if ((h->root.root.type == bfd_link_hash_defined
4236
                || h->root.root.type == bfd_link_hash_defweak)
4237
               && h->root.root.u.def.section)
4238
        {
4239
          sec = h->root.root.u.def.section;
4240
          if (sec->output_section)
4241
            symbol = (h->root.root.u.def.value
4242
                      + sec->output_section->vma
4243
                      + sec->output_offset);
4244
          else
4245
            symbol = h->root.root.u.def.value;
4246
        }
4247
      else if (h->root.root.type == bfd_link_hash_undefweak)
4248
        /* We allow relocations against undefined weak symbols, giving
4249
           it the value zero, so that you can undefined weak functions
4250
           and check to see if they exist by looking at their
4251
           addresses.  */
4252
        symbol = 0;
4253
      else if (info->unresolved_syms_in_objects == RM_IGNORE
4254
               && ELF_ST_VISIBILITY (h->root.other) == STV_DEFAULT)
4255
        symbol = 0;
4256
      else if (strcmp (*namep, SGI_COMPAT (input_bfd)
4257
                       ? "_DYNAMIC_LINK" : "_DYNAMIC_LINKING") == 0)
4258
        {
4259
          /* If this is a dynamic link, we should have created a
4260
             _DYNAMIC_LINK symbol or _DYNAMIC_LINKING(for normal mips) symbol
4261
             in in _bfd_mips_elf_create_dynamic_sections.
4262
             Otherwise, we should define the symbol with a value of 0.
4263
             FIXME: It should probably get into the symbol table
4264
             somehow as well.  */
4265
          BFD_ASSERT (! info->shared);
4266
          BFD_ASSERT (bfd_get_section_by_name (abfd, ".dynamic") == NULL);
4267
          symbol = 0;
4268
        }
4269
      else if (ELF_MIPS_IS_OPTIONAL (h->root.other))
4270
        {
4271
          /* This is an optional symbol - an Irix specific extension to the
4272
             ELF spec.  Ignore it for now.
4273
             XXX - FIXME - there is more to the spec for OPTIONAL symbols
4274
             than simply ignoring them, but we do not handle this for now.
4275
             For information see the "64-bit ELF Object File Specification"
4276
             which is available from here:
4277
             http://techpubs.sgi.com/library/manuals/4000/007-4658-001/pdf/007-4658-001.pdf  */
4278
          symbol = 0;
4279
        }
4280
      else
4281
        {
4282
          if (! ((*info->callbacks->undefined_symbol)
4283
                 (info, h->root.root.root.string, input_bfd,
4284
                  input_section, relocation->r_offset,
4285
                  (info->unresolved_syms_in_objects == RM_GENERATE_ERROR)
4286
                   || ELF_ST_VISIBILITY (h->root.other))))
4287
            return bfd_reloc_undefined;
4288
          symbol = 0;
4289
        }
4290
 
4291
      target_is_16_bit_code_p = (h->root.other == STO_MIPS16);
4292
    }
4293
 
4294
  /* If this is a 32- or 64-bit call to a 16-bit function with a stub, we
4295
     need to redirect the call to the stub, unless we're already *in*
4296
     a stub.  */
4297
  if (r_type != R_MIPS16_26 && !info->relocatable
4298
      && ((h != NULL && h->fn_stub != NULL)
4299
          || (local_p
4300
              && elf_tdata (input_bfd)->local_stubs != NULL
4301
              && elf_tdata (input_bfd)->local_stubs[r_symndx] != NULL))
4302
      && !mips16_stub_section_p (input_bfd, input_section))
4303
    {
4304
      /* This is a 32- or 64-bit call to a 16-bit function.  We should
4305
         have already noticed that we were going to need the
4306
         stub.  */
4307
      if (local_p)
4308
        sec = elf_tdata (input_bfd)->local_stubs[r_symndx];
4309
      else
4310
        {
4311
          BFD_ASSERT (h->need_fn_stub);
4312
          sec = h->fn_stub;
4313
        }
4314
 
4315
      symbol = sec->output_section->vma + sec->output_offset;
4316
      /* The target is 16-bit, but the stub isn't.  */
4317
      target_is_16_bit_code_p = FALSE;
4318
    }
4319
  /* If this is a 16-bit call to a 32- or 64-bit function with a stub, we
4320
     need to redirect the call to the stub.  */
4321
  else if (r_type == R_MIPS16_26 && !info->relocatable
4322
           && ((h != NULL && (h->call_stub != NULL || h->call_fp_stub != NULL))
4323
               || (local_p
4324
                   && elf_tdata (input_bfd)->local_call_stubs != NULL
4325
                   && elf_tdata (input_bfd)->local_call_stubs[r_symndx] != NULL))
4326
           && !target_is_16_bit_code_p)
4327
    {
4328
      if (local_p)
4329
        sec = elf_tdata (input_bfd)->local_call_stubs[r_symndx];
4330
      else
4331
        {
4332
          /* If both call_stub and call_fp_stub are defined, we can figure
4333
             out which one to use by checking which one appears in the input
4334
             file.  */
4335
          if (h->call_stub != NULL && h->call_fp_stub != NULL)
4336
            {
4337
              asection *o;
4338
 
4339
              sec = NULL;
4340
              for (o = input_bfd->sections; o != NULL; o = o->next)
4341
                {
4342
                  if (CALL_FP_STUB_P (bfd_get_section_name (input_bfd, o)))
4343
                    {
4344
                      sec = h->call_fp_stub;
4345
                      break;
4346
                    }
4347
                }
4348
              if (sec == NULL)
4349
                sec = h->call_stub;
4350
            }
4351
          else if (h->call_stub != NULL)
4352
            sec = h->call_stub;
4353
          else
4354
            sec = h->call_fp_stub;
4355
        }
4356
 
4357
      BFD_ASSERT (sec->size > 0);
4358
      symbol = sec->output_section->vma + sec->output_offset;
4359
    }
4360
 
4361
  /* Calls from 16-bit code to 32-bit code and vice versa require the
4362
     special jalx instruction.  */
4363
  *require_jalxp = (!info->relocatable
4364
                    && (((r_type == R_MIPS16_26) && !target_is_16_bit_code_p)
4365
                        || ((r_type == R_MIPS_26) && target_is_16_bit_code_p)));
4366
 
4367
  local_p = mips_elf_local_relocation_p (input_bfd, relocation,
4368
                                         local_sections, TRUE);
4369
 
4370
  /* If we haven't already determined the GOT offset, or the GP value,
4371
     and we're going to need it, get it now.  */
4372
  switch (r_type)
4373
    {
4374
    case R_MIPS_GOT_PAGE:
4375
    case R_MIPS_GOT_OFST:
4376
      /* We need to decay to GOT_DISP/addend if the symbol doesn't
4377
         bind locally.  */
4378
      local_p = local_p || _bfd_elf_symbol_refs_local_p (&h->root, info, 1);
4379
      if (local_p || r_type == R_MIPS_GOT_OFST)
4380
        break;
4381
      /* Fall through.  */
4382
 
4383
    case R_MIPS_CALL16:
4384
    case R_MIPS_GOT16:
4385
    case R_MIPS_GOT_DISP:
4386
    case R_MIPS_GOT_HI16:
4387
    case R_MIPS_CALL_HI16:
4388
    case R_MIPS_GOT_LO16:
4389
    case R_MIPS_CALL_LO16:
4390
    case R_MIPS_TLS_GD:
4391
    case R_MIPS_TLS_GOTTPREL:
4392
    case R_MIPS_TLS_LDM:
4393
      /* Find the index into the GOT where this value is located.  */
4394
      if (r_type == R_MIPS_TLS_LDM)
4395
        {
4396
          g = mips_elf_local_got_index (abfd, input_bfd, info,
4397
                                        0, 0, NULL, r_type);
4398
          if (g == MINUS_ONE)
4399
            return bfd_reloc_outofrange;
4400
        }
4401
      else if (!local_p)
4402
        {
4403
          /* On VxWorks, CALL relocations should refer to the .got.plt
4404
             entry, which is initialized to point at the PLT stub.  */
4405
          if (htab->is_vxworks
4406
              && (r_type == R_MIPS_CALL_HI16
4407
                  || r_type == R_MIPS_CALL_LO16
4408
                  || r_type == R_MIPS_CALL16))
4409
            {
4410
              BFD_ASSERT (addend == 0);
4411
              BFD_ASSERT (h->root.needs_plt);
4412
              g = mips_elf_gotplt_index (info, &h->root);
4413
            }
4414
          else
4415
            {
4416
              /* GOT_PAGE may take a non-zero addend, that is ignored in a
4417
                 GOT_PAGE relocation that decays to GOT_DISP because the
4418
                 symbol turns out to be global.  The addend is then added
4419
                 as GOT_OFST.  */
4420
              BFD_ASSERT (addend == 0 || r_type == R_MIPS_GOT_PAGE);
4421
              g = mips_elf_global_got_index (dynobj, input_bfd,
4422
                                             &h->root, r_type, info);
4423
              if (h->tls_type == GOT_NORMAL
4424
                  && (! elf_hash_table(info)->dynamic_sections_created
4425
                      || (info->shared
4426
                          && (info->symbolic || h->root.forced_local)
4427
                          && h->root.def_regular)))
4428
                {
4429
                  /* This is a static link or a -Bsymbolic link.  The
4430
                     symbol is defined locally, or was forced to be local.
4431
                     We must initialize this entry in the GOT.  */
4432
                  asection *sgot = mips_elf_got_section (dynobj, FALSE);
4433
                  MIPS_ELF_PUT_WORD (dynobj, symbol, sgot->contents + g);
4434
                }
4435
            }
4436
        }
4437
      else if (!htab->is_vxworks
4438
               && (r_type == R_MIPS_CALL16 || (r_type == R_MIPS_GOT16)))
4439
        /* The calculation below does not involve "g".  */
4440
        break;
4441
      else
4442
        {
4443
          g = mips_elf_local_got_index (abfd, input_bfd, info,
4444
                                        symbol + addend, r_symndx, h, r_type);
4445
          if (g == MINUS_ONE)
4446
            return bfd_reloc_outofrange;
4447
        }
4448
 
4449
      /* Convert GOT indices to actual offsets.  */
4450
      g = mips_elf_got_offset_from_index (dynobj, abfd, input_bfd, g);
4451
      break;
4452
 
4453
    case R_MIPS_HI16:
4454
    case R_MIPS_LO16:
4455
    case R_MIPS_GPREL16:
4456
    case R_MIPS_GPREL32:
4457
    case R_MIPS_LITERAL:
4458
    case R_MIPS16_HI16:
4459
    case R_MIPS16_LO16:
4460
    case R_MIPS16_GPREL:
4461
      gp0 = _bfd_get_gp_value (input_bfd);
4462
      gp = _bfd_get_gp_value (abfd);
4463
      if (dynobj)
4464
        gp += mips_elf_adjust_gp (abfd, mips_elf_got_info (dynobj, NULL),
4465
                                  input_bfd);
4466
      break;
4467
 
4468
    default:
4469
      break;
4470
    }
4471
 
4472
  if (gnu_local_gp_p)
4473
    symbol = gp;
4474
 
4475
  /* Relocations against the VxWorks __GOTT_BASE__ and __GOTT_INDEX__
4476
     symbols are resolved by the loader.  Add them to .rela.dyn.  */
4477
  if (h != NULL && is_gott_symbol (info, &h->root))
4478
    {
4479
      Elf_Internal_Rela outrel;
4480
      bfd_byte *loc;
4481
      asection *s;
4482
 
4483
      s = mips_elf_rel_dyn_section (info, FALSE);
4484
      loc = s->contents + s->reloc_count++ * sizeof (Elf32_External_Rela);
4485
 
4486
      outrel.r_offset = (input_section->output_section->vma
4487
                         + input_section->output_offset
4488
                         + relocation->r_offset);
4489
      outrel.r_info = ELF32_R_INFO (h->root.dynindx, r_type);
4490
      outrel.r_addend = addend;
4491
      bfd_elf32_swap_reloca_out (abfd, &outrel, loc);
4492
 
4493
      /* If we've written this relocation for a readonly section,
4494
         we need to set DF_TEXTREL again, so that we do not delete the
4495
         DT_TEXTREL tag.  */
4496
      if (MIPS_ELF_READONLY_SECTION (input_section))
4497
        info->flags |= DF_TEXTREL;
4498
 
4499
      *valuep = 0;
4500
      return bfd_reloc_ok;
4501
    }
4502
 
4503
  /* Figure out what kind of relocation is being performed.  */
4504
  switch (r_type)
4505
    {
4506
    case R_MIPS_NONE:
4507
      return bfd_reloc_continue;
4508
 
4509
    case R_MIPS_16:
4510
      value = symbol + _bfd_mips_elf_sign_extend (addend, 16);
4511
      overflowed_p = mips_elf_overflow_p (value, 16);
4512
      break;
4513
 
4514
    case R_MIPS_32:
4515
    case R_MIPS_REL32:
4516
    case R_MIPS_64:
4517
      if ((info->shared
4518
           || (!htab->is_vxworks
4519
               && htab->root.dynamic_sections_created
4520
               && h != NULL
4521
               && h->root.def_dynamic
4522
               && !h->root.def_regular))
4523
          && r_symndx != 0
4524
          && (input_section->flags & SEC_ALLOC) != 0)
4525
        {
4526
          /* If we're creating a shared library, or this relocation is
4527
             against a symbol in a shared library, then we can't know
4528
             where the symbol will end up.  So, we create a relocation
4529
             record in the output, and leave the job up to the dynamic
4530
             linker.
4531
 
4532
             In VxWorks executables, references to external symbols
4533
             are handled using copy relocs or PLT stubs, so there's
4534
             no need to add a dynamic relocation here.  */
4535
          value = addend;
4536
          if (!mips_elf_create_dynamic_relocation (abfd,
4537
                                                   info,
4538
                                                   relocation,
4539
                                                   h,
4540
                                                   sec,
4541
                                                   symbol,
4542
                                                   &value,
4543
                                                   input_section))
4544
            return bfd_reloc_undefined;
4545
        }
4546
      else
4547
        {
4548
          if (r_type != R_MIPS_REL32)
4549
            value = symbol + addend;
4550
          else
4551
            value = addend;
4552
        }
4553
      value &= howto->dst_mask;
4554
      break;
4555
 
4556
    case R_MIPS_PC32:
4557
      value = symbol + addend - p;
4558
      value &= howto->dst_mask;
4559
      break;
4560
 
4561
    case R_MIPS16_26:
4562
      /* The calculation for R_MIPS16_26 is just the same as for an
4563
         R_MIPS_26.  It's only the storage of the relocated field into
4564
         the output file that's different.  That's handled in
4565
         mips_elf_perform_relocation.  So, we just fall through to the
4566
         R_MIPS_26 case here.  */
4567
    case R_MIPS_26:
4568
      if (local_p)
4569
        value = ((addend | ((p + 4) & 0xf0000000)) + symbol) >> 2;
4570
      else
4571
        {
4572
          value = (_bfd_mips_elf_sign_extend (addend, 28) + symbol) >> 2;
4573
          if (h->root.root.type != bfd_link_hash_undefweak)
4574
            overflowed_p = (value >> 26) != ((p + 4) >> 28);
4575
        }
4576
      value &= howto->dst_mask;
4577
      break;
4578
 
4579
    case R_MIPS_TLS_DTPREL_HI16:
4580
      value = (mips_elf_high (addend + symbol - dtprel_base (info))
4581
               & howto->dst_mask);
4582
      break;
4583
 
4584
    case R_MIPS_TLS_DTPREL_LO16:
4585
    case R_MIPS_TLS_DTPREL32:
4586
    case R_MIPS_TLS_DTPREL64:
4587
      value = (symbol + addend - dtprel_base (info)) & howto->dst_mask;
4588
      break;
4589
 
4590
    case R_MIPS_TLS_TPREL_HI16:
4591
      value = (mips_elf_high (addend + symbol - tprel_base (info))
4592
               & howto->dst_mask);
4593
      break;
4594
 
4595
    case R_MIPS_TLS_TPREL_LO16:
4596
      value = (symbol + addend - tprel_base (info)) & howto->dst_mask;
4597
      break;
4598
 
4599
    case R_MIPS_HI16:
4600
    case R_MIPS16_HI16:
4601
      if (!gp_disp_p)
4602
        {
4603
          value = mips_elf_high (addend + symbol);
4604
          value &= howto->dst_mask;
4605
        }
4606
      else
4607
        {
4608
          /* For MIPS16 ABI code we generate this sequence
4609
                0: li      $v0,%hi(_gp_disp)
4610
                4: addiupc $v1,%lo(_gp_disp)
4611
                8: sll     $v0,16
4612
               12: addu    $v0,$v1
4613
               14: move    $gp,$v0
4614
             So the offsets of hi and lo relocs are the same, but the
4615
             $pc is four higher than $t9 would be, so reduce
4616
             both reloc addends by 4. */
4617
          if (r_type == R_MIPS16_HI16)
4618
            value = mips_elf_high (addend + gp - p - 4);
4619
          else
4620
            value = mips_elf_high (addend + gp - p);
4621
          overflowed_p = mips_elf_overflow_p (value, 16);
4622
        }
4623
      break;
4624
 
4625
    case R_MIPS_LO16:
4626
    case R_MIPS16_LO16:
4627
      if (!gp_disp_p)
4628
        value = (symbol + addend) & howto->dst_mask;
4629
      else
4630
        {
4631
          /* See the comment for R_MIPS16_HI16 above for the reason
4632
             for this conditional.  */
4633
          if (r_type == R_MIPS16_LO16)
4634
            value = addend + gp - p;
4635
          else
4636
            value = addend + gp - p + 4;
4637
          /* The MIPS ABI requires checking the R_MIPS_LO16 relocation
4638
             for overflow.  But, on, say, IRIX5, relocations against
4639
             _gp_disp are normally generated from the .cpload
4640
             pseudo-op.  It generates code that normally looks like
4641
             this:
4642
 
4643
               lui    $gp,%hi(_gp_disp)
4644
               addiu  $gp,$gp,%lo(_gp_disp)
4645
               addu   $gp,$gp,$t9
4646
 
4647
             Here $t9 holds the address of the function being called,
4648
             as required by the MIPS ELF ABI.  The R_MIPS_LO16
4649
             relocation can easily overflow in this situation, but the
4650
             R_MIPS_HI16 relocation will handle the overflow.
4651
             Therefore, we consider this a bug in the MIPS ABI, and do
4652
             not check for overflow here.  */
4653
        }
4654
      break;
4655
 
4656
    case R_MIPS_LITERAL:
4657
      /* Because we don't merge literal sections, we can handle this
4658
         just like R_MIPS_GPREL16.  In the long run, we should merge
4659
         shared literals, and then we will need to additional work
4660
         here.  */
4661
 
4662
      /* Fall through.  */
4663
 
4664
    case R_MIPS16_GPREL:
4665
      /* The R_MIPS16_GPREL performs the same calculation as
4666
         R_MIPS_GPREL16, but stores the relocated bits in a different
4667
         order.  We don't need to do anything special here; the
4668
         differences are handled in mips_elf_perform_relocation.  */
4669
    case R_MIPS_GPREL16:
4670
      /* Only sign-extend the addend if it was extracted from the
4671
         instruction.  If the addend was separate, leave it alone,
4672
         otherwise we may lose significant bits.  */
4673
      if (howto->partial_inplace)
4674
        addend = _bfd_mips_elf_sign_extend (addend, 16);
4675
      value = symbol + addend - gp;
4676
      /* If the symbol was local, any earlier relocatable links will
4677
         have adjusted its addend with the gp offset, so compensate
4678
         for that now.  Don't do it for symbols forced local in this
4679
         link, though, since they won't have had the gp offset applied
4680
         to them before.  */
4681
      if (was_local_p)
4682
        value += gp0;
4683
      overflowed_p = mips_elf_overflow_p (value, 16);
4684
      break;
4685
 
4686
    case R_MIPS_GOT16:
4687
    case R_MIPS_CALL16:
4688
      /* VxWorks does not have separate local and global semantics for
4689
         R_MIPS_GOT16; every relocation evaluates to "G".  */
4690
      if (!htab->is_vxworks && local_p)
4691
        {
4692
          bfd_boolean forced;
4693
 
4694
          forced = ! mips_elf_local_relocation_p (input_bfd, relocation,
4695
                                                  local_sections, FALSE);
4696
          value = mips_elf_got16_entry (abfd, input_bfd, info,
4697
                                        symbol + addend, forced);
4698
          if (value == MINUS_ONE)
4699
            return bfd_reloc_outofrange;
4700
          value
4701
            = mips_elf_got_offset_from_index (dynobj, abfd, input_bfd, value);
4702
          overflowed_p = mips_elf_overflow_p (value, 16);
4703
          break;
4704
        }
4705
 
4706
      /* Fall through.  */
4707
 
4708
    case R_MIPS_TLS_GD:
4709
    case R_MIPS_TLS_GOTTPREL:
4710
    case R_MIPS_TLS_LDM:
4711
    case R_MIPS_GOT_DISP:
4712
    got_disp:
4713
      value = g;
4714
      overflowed_p = mips_elf_overflow_p (value, 16);
4715
      break;
4716
 
4717
    case R_MIPS_GPREL32:
4718
      value = (addend + symbol + gp0 - gp);
4719
      if (!save_addend)
4720
        value &= howto->dst_mask;
4721
      break;
4722
 
4723
    case R_MIPS_PC16:
4724
    case R_MIPS_GNU_REL16_S2:
4725
      value = symbol + _bfd_mips_elf_sign_extend (addend, 18) - p;
4726
      overflowed_p = mips_elf_overflow_p (value, 18);
4727
      value >>= howto->rightshift;
4728
      value &= howto->dst_mask;
4729
      break;
4730
 
4731
    case R_MIPS_GOT_HI16:
4732
    case R_MIPS_CALL_HI16:
4733
      /* We're allowed to handle these two relocations identically.
4734
         The dynamic linker is allowed to handle the CALL relocations
4735
         differently by creating a lazy evaluation stub.  */
4736
      value = g;
4737
      value = mips_elf_high (value);
4738
      value &= howto->dst_mask;
4739
      break;
4740
 
4741
    case R_MIPS_GOT_LO16:
4742
    case R_MIPS_CALL_LO16:
4743
      value = g & howto->dst_mask;
4744
      break;
4745
 
4746
    case R_MIPS_GOT_PAGE:
4747
      /* GOT_PAGE relocations that reference non-local symbols decay
4748
         to GOT_DISP.  The corresponding GOT_OFST relocation decays to
4749
         0.  */
4750
      if (! local_p)
4751
        goto got_disp;
4752
      value = mips_elf_got_page (abfd, input_bfd, info, symbol + addend, NULL);
4753
      if (value == MINUS_ONE)
4754
        return bfd_reloc_outofrange;
4755
      value = mips_elf_got_offset_from_index (dynobj, abfd, input_bfd, value);
4756
      overflowed_p = mips_elf_overflow_p (value, 16);
4757
      break;
4758
 
4759
    case R_MIPS_GOT_OFST:
4760
      if (local_p)
4761
        mips_elf_got_page (abfd, input_bfd, info, symbol + addend, &value);
4762
      else
4763
        value = addend;
4764
      overflowed_p = mips_elf_overflow_p (value, 16);
4765
      break;
4766
 
4767
    case R_MIPS_SUB:
4768
      value = symbol - addend;
4769
      value &= howto->dst_mask;
4770
      break;
4771
 
4772
    case R_MIPS_HIGHER:
4773
      value = mips_elf_higher (addend + symbol);
4774
      value &= howto->dst_mask;
4775
      break;
4776
 
4777
    case R_MIPS_HIGHEST:
4778
      value = mips_elf_highest (addend + symbol);
4779
      value &= howto->dst_mask;
4780
      break;
4781
 
4782
    case R_MIPS_SCN_DISP:
4783
      value = symbol + addend - sec->output_offset;
4784
      value &= howto->dst_mask;
4785
      break;
4786
 
4787
    case R_MIPS_JALR:
4788
      /* This relocation is only a hint.  In some cases, we optimize
4789
         it into a bal instruction.  But we don't try to optimize
4790
         branches to the PLT; that will wind up wasting time.  */
4791
      if (h != NULL && h->root.plt.offset != (bfd_vma) -1)
4792
        return bfd_reloc_continue;
4793
      value = symbol + addend;
4794
      break;
4795
 
4796
    case R_MIPS_PJUMP:
4797
    case R_MIPS_GNU_VTINHERIT:
4798
    case R_MIPS_GNU_VTENTRY:
4799
      /* We don't do anything with these at present.  */
4800
      return bfd_reloc_continue;
4801
 
4802
    default:
4803
      /* An unrecognized relocation type.  */
4804
      return bfd_reloc_notsupported;
4805
    }
4806
 
4807
  /* Store the VALUE for our caller.  */
4808
  *valuep = value;
4809
  return overflowed_p ? bfd_reloc_overflow : bfd_reloc_ok;
4810
}
4811
 
4812
/* Obtain the field relocated by RELOCATION.  */
4813
 
4814
static bfd_vma
4815
mips_elf_obtain_contents (reloc_howto_type *howto,
4816
                          const Elf_Internal_Rela *relocation,
4817
                          bfd *input_bfd, bfd_byte *contents)
4818
{
4819
  bfd_vma x;
4820
  bfd_byte *location = contents + relocation->r_offset;
4821
 
4822
  /* Obtain the bytes.  */
4823
  x = bfd_get ((8 * bfd_get_reloc_size (howto)), input_bfd, location);
4824
 
4825
  return x;
4826
}
4827
 
4828
/* It has been determined that the result of the RELOCATION is the
4829
   VALUE.  Use HOWTO to place VALUE into the output file at the
4830
   appropriate position.  The SECTION is the section to which the
4831
   relocation applies.  If REQUIRE_JALX is TRUE, then the opcode used
4832
   for the relocation must be either JAL or JALX, and it is
4833
   unconditionally converted to JALX.
4834
 
4835
   Returns FALSE if anything goes wrong.  */
4836
 
4837
static bfd_boolean
4838
mips_elf_perform_relocation (struct bfd_link_info *info,
4839
                             reloc_howto_type *howto,
4840
                             const Elf_Internal_Rela *relocation,
4841
                             bfd_vma value, bfd *input_bfd,
4842
                             asection *input_section, bfd_byte *contents,
4843
                             bfd_boolean require_jalx)
4844
{
4845
  bfd_vma x;
4846
  bfd_byte *location;
4847
  int r_type = ELF_R_TYPE (input_bfd, relocation->r_info);
4848
 
4849
  /* Figure out where the relocation is occurring.  */
4850
  location = contents + relocation->r_offset;
4851
 
4852
  _bfd_mips16_elf_reloc_unshuffle (input_bfd, r_type, FALSE, location);
4853
 
4854
  /* Obtain the current value.  */
4855
  x = mips_elf_obtain_contents (howto, relocation, input_bfd, contents);
4856
 
4857
  /* Clear the field we are setting.  */
4858
  x &= ~howto->dst_mask;
4859
 
4860
  /* Set the field.  */
4861
  x |= (value & howto->dst_mask);
4862
 
4863
  /* If required, turn JAL into JALX.  */
4864
  if (require_jalx)
4865
    {
4866
      bfd_boolean ok;
4867
      bfd_vma opcode = x >> 26;
4868
      bfd_vma jalx_opcode;
4869
 
4870
      /* Check to see if the opcode is already JAL or JALX.  */
4871
      if (r_type == R_MIPS16_26)
4872
        {
4873
          ok = ((opcode == 0x6) || (opcode == 0x7));
4874
          jalx_opcode = 0x7;
4875
        }
4876
      else
4877
        {
4878
          ok = ((opcode == 0x3) || (opcode == 0x1d));
4879
          jalx_opcode = 0x1d;
4880
        }
4881
 
4882
      /* If the opcode is not JAL or JALX, there's a problem.  */
4883
      if (!ok)
4884
        {
4885
          (*_bfd_error_handler)
4886
            (_("%B: %A+0x%lx: jump to stub routine which is not jal"),
4887
             input_bfd,
4888
             input_section,
4889
             (unsigned long) relocation->r_offset);
4890
          bfd_set_error (bfd_error_bad_value);
4891
          return FALSE;
4892
        }
4893
 
4894
      /* Make this the JALX opcode.  */
4895
      x = (x & ~(0x3f << 26)) | (jalx_opcode << 26);
4896
    }
4897
 
4898
  /* On the RM9000, bal is faster than jal, because bal uses branch
4899
     prediction hardware.  If we are linking for the RM9000, and we
4900
     see jal, and bal fits, use it instead.  Note that this
4901
     transformation should be safe for all architectures.  */
4902
  if (bfd_get_mach (input_bfd) == bfd_mach_mips9000
4903
      && !info->relocatable
4904
      && !require_jalx
4905
      && ((r_type == R_MIPS_26 && (x >> 26) == 0x3)         /* jal addr */
4906
          || (r_type == R_MIPS_JALR && x == 0x0320f809)))   /* jalr t9 */
4907
    {
4908
      bfd_vma addr;
4909
      bfd_vma dest;
4910
      bfd_signed_vma off;
4911
 
4912
      addr = (input_section->output_section->vma
4913
              + input_section->output_offset
4914
              + relocation->r_offset
4915
              + 4);
4916
      if (r_type == R_MIPS_26)
4917
        dest = (value << 2) | ((addr >> 28) << 28);
4918
      else
4919
        dest = value;
4920
      off = dest - addr;
4921
      if (off <= 0x1ffff && off >= -0x20000)
4922
        x = 0x04110000 | (((bfd_vma) off >> 2) & 0xffff);   /* bal addr */
4923
    }
4924
 
4925
  /* Put the value into the output.  */
4926
  bfd_put (8 * bfd_get_reloc_size (howto), input_bfd, x, location);
4927
 
4928
  _bfd_mips16_elf_reloc_shuffle(input_bfd, r_type, !info->relocatable,
4929
                                location);
4930
 
4931
  return TRUE;
4932
}
4933
 
4934
/* Returns TRUE if SECTION is a MIPS16 stub section.  */
4935
 
4936
static bfd_boolean
4937
mips16_stub_section_p (bfd *abfd ATTRIBUTE_UNUSED, asection *section)
4938
{
4939
  const char *name = bfd_get_section_name (abfd, section);
4940
 
4941
  return FN_STUB_P (name) || CALL_STUB_P (name) || CALL_FP_STUB_P (name);
4942
}
4943
 
4944
/* Add room for N relocations to the .rel(a).dyn section in ABFD.  */
4945
 
4946
static void
4947
mips_elf_allocate_dynamic_relocations (bfd *abfd, struct bfd_link_info *info,
4948
                                       unsigned int n)
4949
{
4950
  asection *s;
4951
  struct mips_elf_link_hash_table *htab;
4952
 
4953
  htab = mips_elf_hash_table (info);
4954
  s = mips_elf_rel_dyn_section (info, FALSE);
4955
  BFD_ASSERT (s != NULL);
4956
 
4957
  if (htab->is_vxworks)
4958
    s->size += n * MIPS_ELF_RELA_SIZE (abfd);
4959
  else
4960
    {
4961
      if (s->size == 0)
4962
        {
4963
          /* Make room for a null element.  */
4964
          s->size += MIPS_ELF_REL_SIZE (abfd);
4965
          ++s->reloc_count;
4966
        }
4967
      s->size += n * MIPS_ELF_REL_SIZE (abfd);
4968
    }
4969
}
4970
 
4971
/* Create a rel.dyn relocation for the dynamic linker to resolve.  REL
4972
   is the original relocation, which is now being transformed into a
4973
   dynamic relocation.  The ADDENDP is adjusted if necessary; the
4974
   caller should store the result in place of the original addend.  */
4975
 
4976
static bfd_boolean
4977
mips_elf_create_dynamic_relocation (bfd *output_bfd,
4978
                                    struct bfd_link_info *info,
4979
                                    const Elf_Internal_Rela *rel,
4980
                                    struct mips_elf_link_hash_entry *h,
4981
                                    asection *sec, bfd_vma symbol,
4982
                                    bfd_vma *addendp, asection *input_section)
4983
{
4984
  Elf_Internal_Rela outrel[3];
4985
  asection *sreloc;
4986
  bfd *dynobj;
4987
  int r_type;
4988
  long indx;
4989
  bfd_boolean defined_p;
4990
  struct mips_elf_link_hash_table *htab;
4991
 
4992
  htab = mips_elf_hash_table (info);
4993
  r_type = ELF_R_TYPE (output_bfd, rel->r_info);
4994
  dynobj = elf_hash_table (info)->dynobj;
4995
  sreloc = mips_elf_rel_dyn_section (info, FALSE);
4996
  BFD_ASSERT (sreloc != NULL);
4997
  BFD_ASSERT (sreloc->contents != NULL);
4998
  BFD_ASSERT (sreloc->reloc_count * MIPS_ELF_REL_SIZE (output_bfd)
4999
              < sreloc->size);
5000
 
5001
  outrel[0].r_offset =
5002
    _bfd_elf_section_offset (output_bfd, info, input_section, rel[0].r_offset);
5003
  if (ABI_64_P (output_bfd))
5004
    {
5005
      outrel[1].r_offset =
5006
        _bfd_elf_section_offset (output_bfd, info, input_section, rel[1].r_offset);
5007
      outrel[2].r_offset =
5008
        _bfd_elf_section_offset (output_bfd, info, input_section, rel[2].r_offset);
5009
    }
5010
 
5011
  if (outrel[0].r_offset == MINUS_ONE)
5012
    /* The relocation field has been deleted.  */
5013
    return TRUE;
5014
 
5015
  if (outrel[0].r_offset == MINUS_TWO)
5016
    {
5017
      /* The relocation field has been converted into a relative value of
5018
         some sort.  Functions like _bfd_elf_write_section_eh_frame expect
5019
         the field to be fully relocated, so add in the symbol's value.  */
5020
      *addendp += symbol;
5021
      return TRUE;
5022
    }
5023
 
5024
  /* We must now calculate the dynamic symbol table index to use
5025
     in the relocation.  */
5026
  if (h != NULL
5027
      && (!h->root.def_regular
5028
          || (info->shared && !info->symbolic && !h->root.forced_local)))
5029
    {
5030
      indx = h->root.dynindx;
5031
      if (SGI_COMPAT (output_bfd))
5032
        defined_p = h->root.def_regular;
5033
      else
5034
        /* ??? glibc's ld.so just adds the final GOT entry to the
5035
           relocation field.  It therefore treats relocs against
5036
           defined symbols in the same way as relocs against
5037
           undefined symbols.  */
5038
        defined_p = FALSE;
5039
    }
5040
  else
5041
    {
5042
      if (sec != NULL && bfd_is_abs_section (sec))
5043
        indx = 0;
5044
      else if (sec == NULL || sec->owner == NULL)
5045
        {
5046
          bfd_set_error (bfd_error_bad_value);
5047
          return FALSE;
5048
        }
5049
      else
5050
        {
5051
          indx = elf_section_data (sec->output_section)->dynindx;
5052
          if (indx == 0)
5053
            {
5054
              asection *osec = htab->root.text_index_section;
5055
              indx = elf_section_data (osec)->dynindx;
5056
            }
5057
          if (indx == 0)
5058
            abort ();
5059
        }
5060
 
5061
      /* Instead of generating a relocation using the section
5062
         symbol, we may as well make it a fully relative
5063
         relocation.  We want to avoid generating relocations to
5064
         local symbols because we used to generate them
5065
         incorrectly, without adding the original symbol value,
5066
         which is mandated by the ABI for section symbols.  In
5067
         order to give dynamic loaders and applications time to
5068
         phase out the incorrect use, we refrain from emitting
5069
         section-relative relocations.  It's not like they're
5070
         useful, after all.  This should be a bit more efficient
5071
         as well.  */
5072
      /* ??? Although this behavior is compatible with glibc's ld.so,
5073
         the ABI says that relocations against STN_UNDEF should have
5074
         a symbol value of 0.  Irix rld honors this, so relocations
5075
         against STN_UNDEF have no effect.  */
5076
      if (!SGI_COMPAT (output_bfd))
5077
        indx = 0;
5078
      defined_p = TRUE;
5079
    }
5080
 
5081
  /* If the relocation was previously an absolute relocation and
5082
     this symbol will not be referred to by the relocation, we must
5083
     adjust it by the value we give it in the dynamic symbol table.
5084
     Otherwise leave the job up to the dynamic linker.  */
5085
  if (defined_p && r_type != R_MIPS_REL32)
5086
    *addendp += symbol;
5087
 
5088
  if (htab->is_vxworks)
5089
    /* VxWorks uses non-relative relocations for this.  */
5090
    outrel[0].r_info = ELF32_R_INFO (indx, R_MIPS_32);
5091
  else
5092
    /* The relocation is always an REL32 relocation because we don't
5093
       know where the shared library will wind up at load-time.  */
5094
    outrel[0].r_info = ELF_R_INFO (output_bfd, (unsigned long) indx,
5095
                                   R_MIPS_REL32);
5096
 
5097
  /* For strict adherence to the ABI specification, we should
5098
     generate a R_MIPS_64 relocation record by itself before the
5099
     _REL32/_64 record as well, such that the addend is read in as
5100
     a 64-bit value (REL32 is a 32-bit relocation, after all).
5101
     However, since none of the existing ELF64 MIPS dynamic
5102
     loaders seems to care, we don't waste space with these
5103
     artificial relocations.  If this turns out to not be true,
5104
     mips_elf_allocate_dynamic_relocation() should be tweaked so
5105
     as to make room for a pair of dynamic relocations per
5106
     invocation if ABI_64_P, and here we should generate an
5107
     additional relocation record with R_MIPS_64 by itself for a
5108
     NULL symbol before this relocation record.  */
5109
  outrel[1].r_info = ELF_R_INFO (output_bfd, 0,
5110
                                 ABI_64_P (output_bfd)
5111
                                 ? R_MIPS_64
5112
                                 : R_MIPS_NONE);
5113
  outrel[2].r_info = ELF_R_INFO (output_bfd, 0, R_MIPS_NONE);
5114
 
5115
  /* Adjust the output offset of the relocation to reference the
5116
     correct location in the output file.  */
5117
  outrel[0].r_offset += (input_section->output_section->vma
5118
                         + input_section->output_offset);
5119
  outrel[1].r_offset += (input_section->output_section->vma
5120
                         + input_section->output_offset);
5121
  outrel[2].r_offset += (input_section->output_section->vma
5122
                         + input_section->output_offset);
5123
 
5124
  /* Put the relocation back out.  We have to use the special
5125
     relocation outputter in the 64-bit case since the 64-bit
5126
     relocation format is non-standard.  */
5127
  if (ABI_64_P (output_bfd))
5128
    {
5129
      (*get_elf_backend_data (output_bfd)->s->swap_reloc_out)
5130
        (output_bfd, &outrel[0],
5131
         (sreloc->contents
5132
          + sreloc->reloc_count * sizeof (Elf64_Mips_External_Rel)));
5133
    }
5134
  else if (htab->is_vxworks)
5135
    {
5136
      /* VxWorks uses RELA rather than REL dynamic relocations.  */
5137
      outrel[0].r_addend = *addendp;
5138
      bfd_elf32_swap_reloca_out
5139
        (output_bfd, &outrel[0],
5140
         (sreloc->contents
5141
          + sreloc->reloc_count * sizeof (Elf32_External_Rela)));
5142
    }
5143
  else
5144
    bfd_elf32_swap_reloc_out
5145
      (output_bfd, &outrel[0],
5146
       (sreloc->contents + sreloc->reloc_count * sizeof (Elf32_External_Rel)));
5147
 
5148
  /* We've now added another relocation.  */
5149
  ++sreloc->reloc_count;
5150
 
5151
  /* Make sure the output section is writable.  The dynamic linker
5152
     will be writing to it.  */
5153
  elf_section_data (input_section->output_section)->this_hdr.sh_flags
5154
    |= SHF_WRITE;
5155
 
5156
  /* On IRIX5, make an entry of compact relocation info.  */
5157
  if (IRIX_COMPAT (output_bfd) == ict_irix5)
5158
    {
5159
      asection *scpt = bfd_get_section_by_name (dynobj, ".compact_rel");
5160
      bfd_byte *cr;
5161
 
5162
      if (scpt)
5163
        {
5164
          Elf32_crinfo cptrel;
5165
 
5166
          mips_elf_set_cr_format (cptrel, CRF_MIPS_LONG);
5167
          cptrel.vaddr = (rel->r_offset
5168
                          + input_section->output_section->vma
5169
                          + input_section->output_offset);
5170
          if (r_type == R_MIPS_REL32)
5171
            mips_elf_set_cr_type (cptrel, CRT_MIPS_REL32);
5172
          else
5173
            mips_elf_set_cr_type (cptrel, CRT_MIPS_WORD);
5174
          mips_elf_set_cr_dist2to (cptrel, 0);
5175
          cptrel.konst = *addendp;
5176
 
5177
          cr = (scpt->contents
5178
                + sizeof (Elf32_External_compact_rel));
5179
          mips_elf_set_cr_relvaddr (cptrel, 0);
5180
          bfd_elf32_swap_crinfo_out (output_bfd, &cptrel,
5181
                                     ((Elf32_External_crinfo *) cr
5182
                                      + scpt->reloc_count));
5183
          ++scpt->reloc_count;
5184
        }
5185
    }
5186
 
5187
  /* If we've written this relocation for a readonly section,
5188
     we need to set DF_TEXTREL again, so that we do not delete the
5189
     DT_TEXTREL tag.  */
5190
  if (MIPS_ELF_READONLY_SECTION (input_section))
5191
    info->flags |= DF_TEXTREL;
5192
 
5193
  return TRUE;
5194
}
5195
 
5196
/* Return the MACH for a MIPS e_flags value.  */
5197
 
5198
unsigned long
5199
_bfd_elf_mips_mach (flagword flags)
5200
{
5201
  switch (flags & EF_MIPS_MACH)
5202
    {
5203
    case E_MIPS_MACH_3900:
5204
      return bfd_mach_mips3900;
5205
 
5206
    case E_MIPS_MACH_4010:
5207
      return bfd_mach_mips4010;
5208
 
5209
    case E_MIPS_MACH_4100:
5210
      return bfd_mach_mips4100;
5211
 
5212
    case E_MIPS_MACH_4111:
5213
      return bfd_mach_mips4111;
5214
 
5215
    case E_MIPS_MACH_4120:
5216
      return bfd_mach_mips4120;
5217
 
5218
    case E_MIPS_MACH_4650:
5219
      return bfd_mach_mips4650;
5220
 
5221
    case E_MIPS_MACH_5400:
5222
      return bfd_mach_mips5400;
5223
 
5224
    case E_MIPS_MACH_5500:
5225
      return bfd_mach_mips5500;
5226
 
5227
    case E_MIPS_MACH_9000:
5228
      return bfd_mach_mips9000;
5229
 
5230
    case E_MIPS_MACH_SB1:
5231
      return bfd_mach_mips_sb1;
5232
 
5233
    case E_MIPS_MACH_LS2E:
5234
      return bfd_mach_mips_loongson_2e;
5235
 
5236
    case E_MIPS_MACH_LS2F:
5237
      return bfd_mach_mips_loongson_2f;
5238
 
5239
    case E_MIPS_MACH_OCTEON:
5240
      return bfd_mach_mips_octeon;
5241
 
5242
    default:
5243
      switch (flags & EF_MIPS_ARCH)
5244
        {
5245
        default:
5246
        case E_MIPS_ARCH_1:
5247
          return bfd_mach_mips3000;
5248
 
5249
        case E_MIPS_ARCH_2:
5250
          return bfd_mach_mips6000;
5251
 
5252
        case E_MIPS_ARCH_3:
5253
          return bfd_mach_mips4000;
5254
 
5255
        case E_MIPS_ARCH_4:
5256
          return bfd_mach_mips8000;
5257
 
5258
        case E_MIPS_ARCH_5:
5259
          return bfd_mach_mips5;
5260
 
5261
        case E_MIPS_ARCH_32:
5262
          return bfd_mach_mipsisa32;
5263
 
5264
        case E_MIPS_ARCH_64:
5265
          return bfd_mach_mipsisa64;
5266
 
5267
        case E_MIPS_ARCH_32R2:
5268
          return bfd_mach_mipsisa32r2;
5269
 
5270
        case E_MIPS_ARCH_64R2:
5271
          return bfd_mach_mipsisa64r2;
5272
        }
5273
    }
5274
 
5275
  return 0;
5276
}
5277
 
5278
/* Return printable name for ABI.  */
5279
 
5280
static INLINE char *
5281
elf_mips_abi_name (bfd *abfd)
5282
{
5283
  flagword flags;
5284
 
5285
  flags = elf_elfheader (abfd)->e_flags;
5286
  switch (flags & EF_MIPS_ABI)
5287
    {
5288
    case 0:
5289
      if (ABI_N32_P (abfd))
5290
        return "N32";
5291
      else if (ABI_64_P (abfd))
5292
        return "64";
5293
      else
5294
        return "none";
5295
    case E_MIPS_ABI_O32:
5296
      return "O32";
5297
    case E_MIPS_ABI_O64:
5298
      return "O64";
5299
    case E_MIPS_ABI_EABI32:
5300
      return "EABI32";
5301
    case E_MIPS_ABI_EABI64:
5302
      return "EABI64";
5303
    default:
5304
      return "unknown abi";
5305
    }
5306
}
5307
 
5308
/* MIPS ELF uses two common sections.  One is the usual one, and the
5309
   other is for small objects.  All the small objects are kept
5310
   together, and then referenced via the gp pointer, which yields
5311
   faster assembler code.  This is what we use for the small common
5312
   section.  This approach is copied from ecoff.c.  */
5313
static asection mips_elf_scom_section;
5314
static asymbol mips_elf_scom_symbol;
5315
static asymbol *mips_elf_scom_symbol_ptr;
5316
 
5317
/* MIPS ELF also uses an acommon section, which represents an
5318
   allocated common symbol which may be overridden by a
5319
   definition in a shared library.  */
5320
static asection mips_elf_acom_section;
5321
static asymbol mips_elf_acom_symbol;
5322
static asymbol *mips_elf_acom_symbol_ptr;
5323
 
5324
/* Handle the special MIPS section numbers that a symbol may use.
5325
   This is used for both the 32-bit and the 64-bit ABI.  */
5326
 
5327
void
5328
_bfd_mips_elf_symbol_processing (bfd *abfd, asymbol *asym)
5329
{
5330
  elf_symbol_type *elfsym;
5331
 
5332
  elfsym = (elf_symbol_type *) asym;
5333
  switch (elfsym->internal_elf_sym.st_shndx)
5334
    {
5335
    case SHN_MIPS_ACOMMON:
5336
      /* This section is used in a dynamically linked executable file.
5337
         It is an allocated common section.  The dynamic linker can
5338
         either resolve these symbols to something in a shared
5339
         library, or it can just leave them here.  For our purposes,
5340
         we can consider these symbols to be in a new section.  */
5341
      if (mips_elf_acom_section.name == NULL)
5342
        {
5343
          /* Initialize the acommon section.  */
5344
          mips_elf_acom_section.name = ".acommon";
5345
          mips_elf_acom_section.flags = SEC_ALLOC;
5346
          mips_elf_acom_section.output_section = &mips_elf_acom_section;
5347
          mips_elf_acom_section.symbol = &mips_elf_acom_symbol;
5348
          mips_elf_acom_section.symbol_ptr_ptr = &mips_elf_acom_symbol_ptr;
5349
          mips_elf_acom_symbol.name = ".acommon";
5350
          mips_elf_acom_symbol.flags = BSF_SECTION_SYM;
5351
          mips_elf_acom_symbol.section = &mips_elf_acom_section;
5352
          mips_elf_acom_symbol_ptr = &mips_elf_acom_symbol;
5353
        }
5354
      asym->section = &mips_elf_acom_section;
5355
      break;
5356
 
5357
    case SHN_COMMON:
5358
      /* Common symbols less than the GP size are automatically
5359
         treated as SHN_MIPS_SCOMMON symbols on IRIX5.  */
5360
      if (asym->value > elf_gp_size (abfd)
5361
          || ELF_ST_TYPE (elfsym->internal_elf_sym.st_info) == STT_TLS
5362
          || IRIX_COMPAT (abfd) == ict_irix6)
5363
        break;
5364
      /* Fall through.  */
5365
    case SHN_MIPS_SCOMMON:
5366
      if (mips_elf_scom_section.name == NULL)
5367
        {
5368
          /* Initialize the small common section.  */
5369
          mips_elf_scom_section.name = ".scommon";
5370
          mips_elf_scom_section.flags = SEC_IS_COMMON;
5371
          mips_elf_scom_section.output_section = &mips_elf_scom_section;
5372
          mips_elf_scom_section.symbol = &mips_elf_scom_symbol;
5373
          mips_elf_scom_section.symbol_ptr_ptr = &mips_elf_scom_symbol_ptr;
5374
          mips_elf_scom_symbol.name = ".scommon";
5375
          mips_elf_scom_symbol.flags = BSF_SECTION_SYM;
5376
          mips_elf_scom_symbol.section = &mips_elf_scom_section;
5377
          mips_elf_scom_symbol_ptr = &mips_elf_scom_symbol;
5378
        }
5379
      asym->section = &mips_elf_scom_section;
5380
      asym->value = elfsym->internal_elf_sym.st_size;
5381
      break;
5382
 
5383
    case SHN_MIPS_SUNDEFINED:
5384
      asym->section = bfd_und_section_ptr;
5385
      break;
5386
 
5387
    case SHN_MIPS_TEXT:
5388
      {
5389
        asection *section = bfd_get_section_by_name (abfd, ".text");
5390
 
5391
        BFD_ASSERT (SGI_COMPAT (abfd));
5392
        if (section != NULL)
5393
          {
5394
            asym->section = section;
5395
            /* MIPS_TEXT is a bit special, the address is not an offset
5396
               to the base of the .text section.  So substract the section
5397
               base address to make it an offset.  */
5398
            asym->value -= section->vma;
5399
          }
5400
      }
5401
      break;
5402
 
5403
    case SHN_MIPS_DATA:
5404
      {
5405
        asection *section = bfd_get_section_by_name (abfd, ".data");
5406
 
5407
        BFD_ASSERT (SGI_COMPAT (abfd));
5408
        if (section != NULL)
5409
          {
5410
            asym->section = section;
5411
            /* MIPS_DATA is a bit special, the address is not an offset
5412
               to the base of the .data section.  So substract the section
5413
               base address to make it an offset.  */
5414
            asym->value -= section->vma;
5415
          }
5416
      }
5417
      break;
5418
    }
5419
}
5420
 
5421
/* Implement elf_backend_eh_frame_address_size.  This differs from
5422
   the default in the way it handles EABI64.
5423
 
5424
   EABI64 was originally specified as an LP64 ABI, and that is what
5425
   -mabi=eabi normally gives on a 64-bit target.  However, gcc has
5426
   historically accepted the combination of -mabi=eabi and -mlong32,
5427
   and this ILP32 variation has become semi-official over time.
5428
   Both forms use elf32 and have pointer-sized FDE addresses.
5429
 
5430
   If an EABI object was generated by GCC 4.0 or above, it will have
5431
   an empty .gcc_compiled_longXX section, where XX is the size of longs
5432
   in bits.  Unfortunately, ILP32 objects generated by earlier compilers
5433
   have no special marking to distinguish them from LP64 objects.
5434
 
5435
   We don't want users of the official LP64 ABI to be punished for the
5436
   existence of the ILP32 variant, but at the same time, we don't want
5437
   to mistakenly interpret pre-4.0 ILP32 objects as being LP64 objects.
5438
   We therefore take the following approach:
5439
 
5440
      - If ABFD contains a .gcc_compiled_longXX section, use it to
5441
        determine the pointer size.
5442
 
5443
      - Otherwise check the type of the first relocation.  Assume that
5444
        the LP64 ABI is being used if the relocation is of type R_MIPS_64.
5445
 
5446
      - Otherwise punt.
5447
 
5448
   The second check is enough to detect LP64 objects generated by pre-4.0
5449
   compilers because, in the kind of output generated by those compilers,
5450
   the first relocation will be associated with either a CIE personality
5451
   routine or an FDE start address.  Furthermore, the compilers never
5452
   used a special (non-pointer) encoding for this ABI.
5453
 
5454
   Checking the relocation type should also be safe because there is no
5455
   reason to use R_MIPS_64 in an ILP32 object.  Pre-4.0 compilers never
5456
   did so.  */
5457
 
5458
unsigned int
5459
_bfd_mips_elf_eh_frame_address_size (bfd *abfd, asection *sec)
5460
{
5461
  if (elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS64)
5462
    return 8;
5463
  if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64)
5464
    {
5465
      bfd_boolean long32_p, long64_p;
5466
 
5467
      long32_p = bfd_get_section_by_name (abfd, ".gcc_compiled_long32") != 0;
5468
      long64_p = bfd_get_section_by_name (abfd, ".gcc_compiled_long64") != 0;
5469
      if (long32_p && long64_p)
5470
        return 0;
5471
      if (long32_p)
5472
        return 4;
5473
      if (long64_p)
5474
        return 8;
5475
 
5476
      if (sec->reloc_count > 0
5477
          && elf_section_data (sec)->relocs != NULL
5478
          && (ELF32_R_TYPE (elf_section_data (sec)->relocs[0].r_info)
5479
              == R_MIPS_64))
5480
        return 8;
5481
 
5482
      return 0;
5483
    }
5484
  return 4;
5485
}
5486
 
5487
/* There appears to be a bug in the MIPSpro linker that causes GOT_DISP
5488
   relocations against two unnamed section symbols to resolve to the
5489
   same address.  For example, if we have code like:
5490
 
5491
        lw      $4,%got_disp(.data)($gp)
5492
        lw      $25,%got_disp(.text)($gp)
5493
        jalr    $25
5494
 
5495
   then the linker will resolve both relocations to .data and the program
5496
   will jump there rather than to .text.
5497
 
5498
   We can work around this problem by giving names to local section symbols.
5499
   This is also what the MIPSpro tools do.  */
5500
 
5501
bfd_boolean
5502
_bfd_mips_elf_name_local_section_symbols (bfd *abfd)
5503
{
5504
  return SGI_COMPAT (abfd);
5505
}
5506
 
5507
/* Work over a section just before writing it out.  This routine is
5508
   used by both the 32-bit and the 64-bit ABI.  FIXME: We recognize
5509
   sections that need the SHF_MIPS_GPREL flag by name; there has to be
5510
   a better way.  */
5511
 
5512
bfd_boolean
5513
_bfd_mips_elf_section_processing (bfd *abfd, Elf_Internal_Shdr *hdr)
5514
{
5515
  if (hdr->sh_type == SHT_MIPS_REGINFO
5516
      && hdr->sh_size > 0)
5517
    {
5518
      bfd_byte buf[4];
5519
 
5520
      BFD_ASSERT (hdr->sh_size == sizeof (Elf32_External_RegInfo));
5521
      BFD_ASSERT (hdr->contents == NULL);
5522
 
5523
      if (bfd_seek (abfd,
5524
                    hdr->sh_offset + sizeof (Elf32_External_RegInfo) - 4,
5525
                    SEEK_SET) != 0)
5526
        return FALSE;
5527
      H_PUT_32 (abfd, elf_gp (abfd), buf);
5528
      if (bfd_bwrite (buf, 4, abfd) != 4)
5529
        return FALSE;
5530
    }
5531
 
5532
  if (hdr->sh_type == SHT_MIPS_OPTIONS
5533
      && hdr->bfd_section != NULL
5534
      && mips_elf_section_data (hdr->bfd_section) != NULL
5535
      && mips_elf_section_data (hdr->bfd_section)->u.tdata != NULL)
5536
    {
5537
      bfd_byte *contents, *l, *lend;
5538
 
5539
      /* We stored the section contents in the tdata field in the
5540
         set_section_contents routine.  We save the section contents
5541
         so that we don't have to read them again.
5542
         At this point we know that elf_gp is set, so we can look
5543
         through the section contents to see if there is an
5544
         ODK_REGINFO structure.  */
5545
 
5546
      contents = mips_elf_section_data (hdr->bfd_section)->u.tdata;
5547
      l = contents;
5548
      lend = contents + hdr->sh_size;
5549
      while (l + sizeof (Elf_External_Options) <= lend)
5550
        {
5551
          Elf_Internal_Options intopt;
5552
 
5553
          bfd_mips_elf_swap_options_in (abfd, (Elf_External_Options *) l,
5554
                                        &intopt);
5555
          if (intopt.size < sizeof (Elf_External_Options))
5556
            {
5557
              (*_bfd_error_handler)
5558
                (_("%B: Warning: bad `%s' option size %u smaller than its header"),
5559
                abfd, MIPS_ELF_OPTIONS_SECTION_NAME (abfd), intopt.size);
5560
              break;
5561
            }
5562
          if (ABI_64_P (abfd) && intopt.kind == ODK_REGINFO)
5563
            {
5564
              bfd_byte buf[8];
5565
 
5566
              if (bfd_seek (abfd,
5567
                            (hdr->sh_offset
5568
                             + (l - contents)
5569
                             + sizeof (Elf_External_Options)
5570
                             + (sizeof (Elf64_External_RegInfo) - 8)),
5571
                             SEEK_SET) != 0)
5572
                return FALSE;
5573
              H_PUT_64 (abfd, elf_gp (abfd), buf);
5574
              if (bfd_bwrite (buf, 8, abfd) != 8)
5575
                return FALSE;
5576
            }
5577
          else if (intopt.kind == ODK_REGINFO)
5578
            {
5579
              bfd_byte buf[4];
5580
 
5581
              if (bfd_seek (abfd,
5582
                            (hdr->sh_offset
5583
                             + (l - contents)
5584
                             + sizeof (Elf_External_Options)
5585
                             + (sizeof (Elf32_External_RegInfo) - 4)),
5586
                            SEEK_SET) != 0)
5587
                return FALSE;
5588
              H_PUT_32 (abfd, elf_gp (abfd), buf);
5589
              if (bfd_bwrite (buf, 4, abfd) != 4)
5590
                return FALSE;
5591
            }
5592
          l += intopt.size;
5593
        }
5594
    }
5595
 
5596
  if (hdr->bfd_section != NULL)
5597
    {
5598
      const char *name = bfd_get_section_name (abfd, hdr->bfd_section);
5599
 
5600
      if (strcmp (name, ".sdata") == 0
5601
          || strcmp (name, ".lit8") == 0
5602
          || strcmp (name, ".lit4") == 0)
5603
        {
5604
          hdr->sh_flags |= SHF_ALLOC | SHF_WRITE | SHF_MIPS_GPREL;
5605
          hdr->sh_type = SHT_PROGBITS;
5606
        }
5607
      else if (strcmp (name, ".sbss") == 0)
5608
        {
5609
          hdr->sh_flags |= SHF_ALLOC | SHF_WRITE | SHF_MIPS_GPREL;
5610
          hdr->sh_type = SHT_NOBITS;
5611
        }
5612
      else if (strcmp (name, ".srdata") == 0)
5613
        {
5614
          hdr->sh_flags |= SHF_ALLOC | SHF_MIPS_GPREL;
5615
          hdr->sh_type = SHT_PROGBITS;
5616
        }
5617
      else if (strcmp (name, ".compact_rel") == 0)
5618
        {
5619
          hdr->sh_flags = 0;
5620
          hdr->sh_type = SHT_PROGBITS;
5621
        }
5622
      else if (strcmp (name, ".rtproc") == 0)
5623
        {
5624
          if (hdr->sh_addralign != 0 && hdr->sh_entsize == 0)
5625
            {
5626
              unsigned int adjust;
5627
 
5628
              adjust = hdr->sh_size % hdr->sh_addralign;
5629
              if (adjust != 0)
5630
                hdr->sh_size += hdr->sh_addralign - adjust;
5631
            }
5632
        }
5633
    }
5634
 
5635
  return TRUE;
5636
}
5637
 
5638
/* Handle a MIPS specific section when reading an object file.  This
5639
   is called when elfcode.h finds a section with an unknown type.
5640
   This routine supports both the 32-bit and 64-bit ELF ABI.
5641
 
5642
   FIXME: We need to handle the SHF_MIPS_GPREL flag, but I'm not sure
5643
   how to.  */
5644
 
5645
bfd_boolean
5646
_bfd_mips_elf_section_from_shdr (bfd *abfd,
5647
                                 Elf_Internal_Shdr *hdr,
5648
                                 const char *name,
5649
                                 int shindex)
5650
{
5651
  flagword flags = 0;
5652
 
5653
  /* There ought to be a place to keep ELF backend specific flags, but
5654
     at the moment there isn't one.  We just keep track of the
5655
     sections by their name, instead.  Fortunately, the ABI gives
5656
     suggested names for all the MIPS specific sections, so we will
5657
     probably get away with this.  */
5658
  switch (hdr->sh_type)
5659
    {
5660
    case SHT_MIPS_LIBLIST:
5661
      if (strcmp (name, ".liblist") != 0)
5662
        return FALSE;
5663
      break;
5664
    case SHT_MIPS_MSYM:
5665
      if (strcmp (name, ".msym") != 0)
5666
        return FALSE;
5667
      break;
5668
    case SHT_MIPS_CONFLICT:
5669
      if (strcmp (name, ".conflict") != 0)
5670
        return FALSE;
5671
      break;
5672
    case SHT_MIPS_GPTAB:
5673
      if (! CONST_STRNEQ (name, ".gptab."))
5674
        return FALSE;
5675
      break;
5676
    case SHT_MIPS_UCODE:
5677
      if (strcmp (name, ".ucode") != 0)
5678
        return FALSE;
5679
      break;
5680
    case SHT_MIPS_DEBUG:
5681
      if (strcmp (name, ".mdebug") != 0)
5682
        return FALSE;
5683
      flags = SEC_DEBUGGING;
5684
      break;
5685
    case SHT_MIPS_REGINFO:
5686
      if (strcmp (name, ".reginfo") != 0
5687
          || hdr->sh_size != sizeof (Elf32_External_RegInfo))
5688
        return FALSE;
5689
      flags = (SEC_LINK_ONCE | SEC_LINK_DUPLICATES_SAME_SIZE);
5690
      break;
5691
    case SHT_MIPS_IFACE:
5692
      if (strcmp (name, ".MIPS.interfaces") != 0)
5693
        return FALSE;
5694
      break;
5695
    case SHT_MIPS_CONTENT:
5696
      if (! CONST_STRNEQ (name, ".MIPS.content"))
5697
        return FALSE;
5698
      break;
5699
    case SHT_MIPS_OPTIONS:
5700
      if (!MIPS_ELF_OPTIONS_SECTION_NAME_P (name))
5701
        return FALSE;
5702
      break;
5703
    case SHT_MIPS_DWARF:
5704
      if (! CONST_STRNEQ (name, ".debug_"))
5705
        return FALSE;
5706
      break;
5707
    case SHT_MIPS_SYMBOL_LIB:
5708
      if (strcmp (name, ".MIPS.symlib") != 0)
5709
        return FALSE;
5710
      break;
5711
    case SHT_MIPS_EVENTS:
5712
      if (! CONST_STRNEQ (name, ".MIPS.events")
5713
          && ! CONST_STRNEQ (name, ".MIPS.post_rel"))
5714
        return FALSE;
5715
      break;
5716
    default:
5717
      break;
5718
    }
5719
 
5720
  if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
5721
    return FALSE;
5722
 
5723
  if (flags)
5724
    {
5725
      if (! bfd_set_section_flags (abfd, hdr->bfd_section,
5726
                                   (bfd_get_section_flags (abfd,
5727
                                                           hdr->bfd_section)
5728
                                    | flags)))
5729
        return FALSE;
5730
    }
5731
 
5732
  /* FIXME: We should record sh_info for a .gptab section.  */
5733
 
5734
  /* For a .reginfo section, set the gp value in the tdata information
5735
     from the contents of this section.  We need the gp value while
5736
     processing relocs, so we just get it now.  The .reginfo section
5737
     is not used in the 64-bit MIPS ELF ABI.  */
5738
  if (hdr->sh_type == SHT_MIPS_REGINFO)
5739
    {
5740
      Elf32_External_RegInfo ext;
5741
      Elf32_RegInfo s;
5742
 
5743
      if (! bfd_get_section_contents (abfd, hdr->bfd_section,
5744
                                      &ext, 0, sizeof ext))
5745
        return FALSE;
5746
      bfd_mips_elf32_swap_reginfo_in (abfd, &ext, &s);
5747
      elf_gp (abfd) = s.ri_gp_value;
5748
    }
5749
 
5750
  /* For a SHT_MIPS_OPTIONS section, look for a ODK_REGINFO entry, and
5751
     set the gp value based on what we find.  We may see both
5752
     SHT_MIPS_REGINFO and SHT_MIPS_OPTIONS/ODK_REGINFO; in that case,
5753
     they should agree.  */
5754
  if (hdr->sh_type == SHT_MIPS_OPTIONS)
5755
    {
5756
      bfd_byte *contents, *l, *lend;
5757
 
5758
      contents = bfd_malloc (hdr->sh_size);
5759
      if (contents == NULL)
5760
        return FALSE;
5761
      if (! bfd_get_section_contents (abfd, hdr->bfd_section, contents,
5762
                                      0, hdr->sh_size))
5763
        {
5764
          free (contents);
5765
          return FALSE;
5766
        }
5767
      l = contents;
5768
      lend = contents + hdr->sh_size;
5769
      while (l + sizeof (Elf_External_Options) <= lend)
5770
        {
5771
          Elf_Internal_Options intopt;
5772
 
5773
          bfd_mips_elf_swap_options_in (abfd, (Elf_External_Options *) l,
5774
                                        &intopt);
5775
          if (intopt.size < sizeof (Elf_External_Options))
5776
            {
5777
              (*_bfd_error_handler)
5778
                (_("%B: Warning: bad `%s' option size %u smaller than its header"),
5779
                abfd, MIPS_ELF_OPTIONS_SECTION_NAME (abfd), intopt.size);
5780
              break;
5781
            }
5782
          if (ABI_64_P (abfd) && intopt.kind == ODK_REGINFO)
5783
            {
5784
              Elf64_Internal_RegInfo intreg;
5785
 
5786
              bfd_mips_elf64_swap_reginfo_in
5787
                (abfd,
5788
                 ((Elf64_External_RegInfo *)
5789
                  (l + sizeof (Elf_External_Options))),
5790
                 &intreg);
5791
              elf_gp (abfd) = intreg.ri_gp_value;
5792
            }
5793
          else if (intopt.kind == ODK_REGINFO)
5794
            {
5795
              Elf32_RegInfo intreg;
5796
 
5797
              bfd_mips_elf32_swap_reginfo_in
5798
                (abfd,
5799
                 ((Elf32_External_RegInfo *)
5800
                  (l + sizeof (Elf_External_Options))),
5801
                 &intreg);
5802
              elf_gp (abfd) = intreg.ri_gp_value;
5803
            }
5804
          l += intopt.size;
5805
        }
5806
      free (contents);
5807
    }
5808
 
5809
  return TRUE;
5810
}
5811
 
5812
/* Set the correct type for a MIPS ELF section.  We do this by the
5813
   section name, which is a hack, but ought to work.  This routine is
5814
   used by both the 32-bit and the 64-bit ABI.  */
5815
 
5816
bfd_boolean
5817
_bfd_mips_elf_fake_sections (bfd *abfd, Elf_Internal_Shdr *hdr, asection *sec)
5818
{
5819
  const char *name = bfd_get_section_name (abfd, sec);
5820
 
5821
  if (strcmp (name, ".liblist") == 0)
5822
    {
5823
      hdr->sh_type = SHT_MIPS_LIBLIST;
5824
      hdr->sh_info = sec->size / sizeof (Elf32_Lib);
5825
      /* The sh_link field is set in final_write_processing.  */
5826
    }
5827
  else if (strcmp (name, ".conflict") == 0)
5828
    hdr->sh_type = SHT_MIPS_CONFLICT;
5829
  else if (CONST_STRNEQ (name, ".gptab."))
5830
    {
5831
      hdr->sh_type = SHT_MIPS_GPTAB;
5832
      hdr->sh_entsize = sizeof (Elf32_External_gptab);
5833
      /* The sh_info field is set in final_write_processing.  */
5834
    }
5835
  else if (strcmp (name, ".ucode") == 0)
5836
    hdr->sh_type = SHT_MIPS_UCODE;
5837
  else if (strcmp (name, ".mdebug") == 0)
5838
    {
5839
      hdr->sh_type = SHT_MIPS_DEBUG;
5840
      /* In a shared object on IRIX 5.3, the .mdebug section has an
5841
         entsize of 0.  FIXME: Does this matter?  */
5842
      if (SGI_COMPAT (abfd) && (abfd->flags & DYNAMIC) != 0)
5843
        hdr->sh_entsize = 0;
5844
      else
5845
        hdr->sh_entsize = 1;
5846
    }
5847
  else if (strcmp (name, ".reginfo") == 0)
5848
    {
5849
      hdr->sh_type = SHT_MIPS_REGINFO;
5850
      /* In a shared object on IRIX 5.3, the .reginfo section has an
5851
         entsize of 0x18.  FIXME: Does this matter?  */
5852
      if (SGI_COMPAT (abfd))
5853
        {
5854
          if ((abfd->flags & DYNAMIC) != 0)
5855
            hdr->sh_entsize = sizeof (Elf32_External_RegInfo);
5856
          else
5857
            hdr->sh_entsize = 1;
5858
        }
5859
      else
5860
        hdr->sh_entsize = sizeof (Elf32_External_RegInfo);
5861
    }
5862
  else if (SGI_COMPAT (abfd)
5863
           && (strcmp (name, ".hash") == 0
5864
               || strcmp (name, ".dynamic") == 0
5865
               || strcmp (name, ".dynstr") == 0))
5866
    {
5867
      if (SGI_COMPAT (abfd))
5868
        hdr->sh_entsize = 0;
5869
#if 0
5870
      /* This isn't how the IRIX6 linker behaves.  */
5871
      hdr->sh_info = SIZEOF_MIPS_DYNSYM_SECNAMES;
5872
#endif
5873
    }
5874
  else if (strcmp (name, ".got") == 0
5875
           || strcmp (name, ".srdata") == 0
5876
           || strcmp (name, ".sdata") == 0
5877
           || strcmp (name, ".sbss") == 0
5878
           || strcmp (name, ".lit4") == 0
5879
           || strcmp (name, ".lit8") == 0)
5880
    hdr->sh_flags |= SHF_MIPS_GPREL;
5881
  else if (strcmp (name, ".MIPS.interfaces") == 0)
5882
    {
5883
      hdr->sh_type = SHT_MIPS_IFACE;
5884
      hdr->sh_flags |= SHF_MIPS_NOSTRIP;
5885
    }
5886
  else if (CONST_STRNEQ (name, ".MIPS.content"))
5887
    {
5888
      hdr->sh_type = SHT_MIPS_CONTENT;
5889
      hdr->sh_flags |= SHF_MIPS_NOSTRIP;
5890
      /* The sh_info field is set in final_write_processing.  */
5891
    }
5892
  else if (MIPS_ELF_OPTIONS_SECTION_NAME_P (name))
5893
    {
5894
      hdr->sh_type = SHT_MIPS_OPTIONS;
5895
      hdr->sh_entsize = 1;
5896
      hdr->sh_flags |= SHF_MIPS_NOSTRIP;
5897
    }
5898
  else if (CONST_STRNEQ (name, ".debug_"))
5899
    {
5900
      hdr->sh_type = SHT_MIPS_DWARF;
5901
 
5902
      /* Irix facilities such as libexc expect a single .debug_frame
5903
         per executable, the system ones have NOSTRIP set and the linker
5904
         doesn't merge sections with different flags so ...  */
5905
      if (SGI_COMPAT (abfd) && CONST_STRNEQ (name, ".debug_frame"))
5906
        hdr->sh_flags |= SHF_MIPS_NOSTRIP;
5907
    }
5908
  else if (strcmp (name, ".MIPS.symlib") == 0)
5909
    {
5910
      hdr->sh_type = SHT_MIPS_SYMBOL_LIB;
5911
      /* The sh_link and sh_info fields are set in
5912
         final_write_processing.  */
5913
    }
5914
  else if (CONST_STRNEQ (name, ".MIPS.events")
5915
           || CONST_STRNEQ (name, ".MIPS.post_rel"))
5916
    {
5917
      hdr->sh_type = SHT_MIPS_EVENTS;
5918
      hdr->sh_flags |= SHF_MIPS_NOSTRIP;
5919
      /* The sh_link field is set in final_write_processing.  */
5920
    }
5921
  else if (strcmp (name, ".msym") == 0)
5922
    {
5923
      hdr->sh_type = SHT_MIPS_MSYM;
5924
      hdr->sh_flags |= SHF_ALLOC;
5925
      hdr->sh_entsize = 8;
5926
    }
5927
 
5928
  /* The generic elf_fake_sections will set up REL_HDR using the default
5929
   kind of relocations.  We used to set up a second header for the
5930
   non-default kind of relocations here, but only NewABI would use
5931
   these, and the IRIX ld doesn't like resulting empty RELA sections.
5932
   Thus we create those header only on demand now.  */
5933
 
5934
  return TRUE;
5935
}
5936
 
5937
/* Given a BFD section, try to locate the corresponding ELF section
5938
   index.  This is used by both the 32-bit and the 64-bit ABI.
5939
   Actually, it's not clear to me that the 64-bit ABI supports these,
5940
   but for non-PIC objects we will certainly want support for at least
5941
   the .scommon section.  */
5942
 
5943
bfd_boolean
5944
_bfd_mips_elf_section_from_bfd_section (bfd *abfd ATTRIBUTE_UNUSED,
5945
                                        asection *sec, int *retval)
5946
{
5947
  if (strcmp (bfd_get_section_name (abfd, sec), ".scommon") == 0)
5948
    {
5949
      *retval = SHN_MIPS_SCOMMON;
5950
      return TRUE;
5951
    }
5952
  if (strcmp (bfd_get_section_name (abfd, sec), ".acommon") == 0)
5953
    {
5954
      *retval = SHN_MIPS_ACOMMON;
5955
      return TRUE;
5956
    }
5957
  return FALSE;
5958
}
5959
 
5960
/* Hook called by the linker routine which adds symbols from an object
5961
   file.  We must handle the special MIPS section numbers here.  */
5962
 
5963
bfd_boolean
5964
_bfd_mips_elf_add_symbol_hook (bfd *abfd, struct bfd_link_info *info,
5965
                               Elf_Internal_Sym *sym, const char **namep,
5966
                               flagword *flagsp ATTRIBUTE_UNUSED,
5967
                               asection **secp, bfd_vma *valp)
5968
{
5969
  if (SGI_COMPAT (abfd)
5970
      && (abfd->flags & DYNAMIC) != 0
5971
      && strcmp (*namep, "_rld_new_interface") == 0)
5972
    {
5973
      /* Skip IRIX5 rld entry name.  */
5974
      *namep = NULL;
5975
      return TRUE;
5976
    }
5977
 
5978
  /* Shared objects may have a dynamic symbol '_gp_disp' defined as
5979
     a SECTION *ABS*.  This causes ld to think it can resolve _gp_disp
5980
     by setting a DT_NEEDED for the shared object.  Since _gp_disp is
5981
     a magic symbol resolved by the linker, we ignore this bogus definition
5982
     of _gp_disp.  New ABI objects do not suffer from this problem so this
5983
     is not done for them. */
5984
  if (!NEWABI_P(abfd)
5985
      && (sym->st_shndx == SHN_ABS)
5986
      && (strcmp (*namep, "_gp_disp") == 0))
5987
    {
5988
      *namep = NULL;
5989
      return TRUE;
5990
    }
5991
 
5992
  switch (sym->st_shndx)
5993
    {
5994
    case SHN_COMMON:
5995
      /* Common symbols less than the GP size are automatically
5996
         treated as SHN_MIPS_SCOMMON symbols.  */
5997
      if (sym->st_size > elf_gp_size (abfd)
5998
          || ELF_ST_TYPE (sym->st_info) == STT_TLS
5999
          || IRIX_COMPAT (abfd) == ict_irix6)
6000
        break;
6001
      /* Fall through.  */
6002
    case SHN_MIPS_SCOMMON:
6003
      *secp = bfd_make_section_old_way (abfd, ".scommon");
6004
      (*secp)->flags |= SEC_IS_COMMON;
6005
      *valp = sym->st_size;
6006
      break;
6007
 
6008
    case SHN_MIPS_TEXT:
6009
      /* This section is used in a shared object.  */
6010
      if (elf_tdata (abfd)->elf_text_section == NULL)
6011
        {
6012
          asymbol *elf_text_symbol;
6013
          asection *elf_text_section;
6014
          bfd_size_type amt = sizeof (asection);
6015
 
6016
          elf_text_section = bfd_zalloc (abfd, amt);
6017
          if (elf_text_section == NULL)
6018
            return FALSE;
6019
 
6020
          amt = sizeof (asymbol);
6021
          elf_text_symbol = bfd_zalloc (abfd, amt);
6022
          if (elf_text_symbol == NULL)
6023
            return FALSE;
6024
 
6025
          /* Initialize the section.  */
6026
 
6027
          elf_tdata (abfd)->elf_text_section = elf_text_section;
6028
          elf_tdata (abfd)->elf_text_symbol = elf_text_symbol;
6029
 
6030
          elf_text_section->symbol = elf_text_symbol;
6031
          elf_text_section->symbol_ptr_ptr = &elf_tdata (abfd)->elf_text_symbol;
6032
 
6033
          elf_text_section->name = ".text";
6034
          elf_text_section->flags = SEC_NO_FLAGS;
6035
          elf_text_section->output_section = NULL;
6036
          elf_text_section->owner = abfd;
6037
          elf_text_symbol->name = ".text";
6038
          elf_text_symbol->flags = BSF_SECTION_SYM | BSF_DYNAMIC;
6039
          elf_text_symbol->section = elf_text_section;
6040
        }
6041
      /* This code used to do *secp = bfd_und_section_ptr if
6042
         info->shared.  I don't know why, and that doesn't make sense,
6043
         so I took it out.  */
6044
      *secp = elf_tdata (abfd)->elf_text_section;
6045
      break;
6046
 
6047
    case SHN_MIPS_ACOMMON:
6048
      /* Fall through. XXX Can we treat this as allocated data?  */
6049
    case SHN_MIPS_DATA:
6050
      /* This section is used in a shared object.  */
6051
      if (elf_tdata (abfd)->elf_data_section == NULL)
6052
        {
6053
          asymbol *elf_data_symbol;
6054
          asection *elf_data_section;
6055
          bfd_size_type amt = sizeof (asection);
6056
 
6057
          elf_data_section = bfd_zalloc (abfd, amt);
6058
          if (elf_data_section == NULL)
6059
            return FALSE;
6060
 
6061
          amt = sizeof (asymbol);
6062
          elf_data_symbol = bfd_zalloc (abfd, amt);
6063
          if (elf_data_symbol == NULL)
6064
            return FALSE;
6065
 
6066
          /* Initialize the section.  */
6067
 
6068
          elf_tdata (abfd)->elf_data_section = elf_data_section;
6069
          elf_tdata (abfd)->elf_data_symbol = elf_data_symbol;
6070
 
6071
          elf_data_section->symbol = elf_data_symbol;
6072
          elf_data_section->symbol_ptr_ptr = &elf_tdata (abfd)->elf_data_symbol;
6073
 
6074
          elf_data_section->name = ".data";
6075
          elf_data_section->flags = SEC_NO_FLAGS;
6076
          elf_data_section->output_section = NULL;
6077
          elf_data_section->owner = abfd;
6078
          elf_data_symbol->name = ".data";
6079
          elf_data_symbol->flags = BSF_SECTION_SYM | BSF_DYNAMIC;
6080
          elf_data_symbol->section = elf_data_section;
6081
        }
6082
      /* This code used to do *secp = bfd_und_section_ptr if
6083
         info->shared.  I don't know why, and that doesn't make sense,
6084
         so I took it out.  */
6085
      *secp = elf_tdata (abfd)->elf_data_section;
6086
      break;
6087
 
6088
    case SHN_MIPS_SUNDEFINED:
6089
      *secp = bfd_und_section_ptr;
6090
      break;
6091
    }
6092
 
6093
  if (SGI_COMPAT (abfd)
6094
      && ! info->shared
6095
      && info->output_bfd->xvec == abfd->xvec
6096
      && strcmp (*namep, "__rld_obj_head") == 0)
6097
    {
6098
      struct elf_link_hash_entry *h;
6099
      struct bfd_link_hash_entry *bh;
6100
 
6101
      /* Mark __rld_obj_head as dynamic.  */
6102
      bh = NULL;
6103
      if (! (_bfd_generic_link_add_one_symbol
6104
             (info, abfd, *namep, BSF_GLOBAL, *secp, *valp, NULL, FALSE,
6105
              get_elf_backend_data (abfd)->collect, &bh)))
6106
        return FALSE;
6107
 
6108
      h = (struct elf_link_hash_entry *) bh;
6109
      h->non_elf = 0;
6110
      h->def_regular = 1;
6111
      h->type = STT_OBJECT;
6112
 
6113
      if (! bfd_elf_link_record_dynamic_symbol (info, h))
6114
        return FALSE;
6115
 
6116
      mips_elf_hash_table (info)->use_rld_obj_head = TRUE;
6117
    }
6118
 
6119
  /* If this is a mips16 text symbol, add 1 to the value to make it
6120
     odd.  This will cause something like .word SYM to come up with
6121
     the right value when it is loaded into the PC.  */
6122
  if (sym->st_other == STO_MIPS16)
6123
    ++*valp;
6124
 
6125
  return TRUE;
6126
}
6127
 
6128
/* This hook function is called before the linker writes out a global
6129
   symbol.  We mark symbols as small common if appropriate.  This is
6130
   also where we undo the increment of the value for a mips16 symbol.  */
6131
 
6132
bfd_boolean
6133
_bfd_mips_elf_link_output_symbol_hook
6134
  (struct bfd_link_info *info ATTRIBUTE_UNUSED,
6135
   const char *name ATTRIBUTE_UNUSED, Elf_Internal_Sym *sym,
6136
   asection *input_sec, struct elf_link_hash_entry *h ATTRIBUTE_UNUSED)
6137
{
6138
  /* If we see a common symbol, which implies a relocatable link, then
6139
     if a symbol was small common in an input file, mark it as small
6140
     common in the output file.  */
6141
  if (sym->st_shndx == SHN_COMMON
6142
      && strcmp (input_sec->name, ".scommon") == 0)
6143
    sym->st_shndx = SHN_MIPS_SCOMMON;
6144
 
6145
  if (sym->st_other == STO_MIPS16)
6146
    sym->st_value &= ~1;
6147
 
6148
  return TRUE;
6149
}
6150
 
6151
/* Functions for the dynamic linker.  */
6152
 
6153
/* Create dynamic sections when linking against a dynamic object.  */
6154
 
6155
bfd_boolean
6156
_bfd_mips_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
6157
{
6158
  struct elf_link_hash_entry *h;
6159
  struct bfd_link_hash_entry *bh;
6160
  flagword flags;
6161
  register asection *s;
6162
  const char * const *namep;
6163
  struct mips_elf_link_hash_table *htab;
6164
 
6165
  htab = mips_elf_hash_table (info);
6166
  flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
6167
           | SEC_LINKER_CREATED | SEC_READONLY);
6168
 
6169
  /* The psABI requires a read-only .dynamic section, but the VxWorks
6170
     EABI doesn't.  */
6171
  if (!htab->is_vxworks)
6172
    {
6173
      s = bfd_get_section_by_name (abfd, ".dynamic");
6174
      if (s != NULL)
6175
        {
6176
          if (! bfd_set_section_flags (abfd, s, flags))
6177
            return FALSE;
6178
        }
6179
    }
6180
 
6181
  /* We need to create .got section.  */
6182
  if (! mips_elf_create_got_section (abfd, info, FALSE))
6183
    return FALSE;
6184
 
6185
  if (! mips_elf_rel_dyn_section (info, TRUE))
6186
    return FALSE;
6187
 
6188
  /* Create .stub section.  */
6189
  if (bfd_get_section_by_name (abfd,
6190
                               MIPS_ELF_STUB_SECTION_NAME (abfd)) == NULL)
6191
    {
6192
      s = bfd_make_section_with_flags (abfd,
6193
                                       MIPS_ELF_STUB_SECTION_NAME (abfd),
6194
                                       flags | SEC_CODE);
6195
      if (s == NULL
6196
          || ! bfd_set_section_alignment (abfd, s,
6197
                                          MIPS_ELF_LOG_FILE_ALIGN (abfd)))
6198
        return FALSE;
6199
    }
6200
 
6201
  if ((IRIX_COMPAT (abfd) == ict_irix5 || IRIX_COMPAT (abfd) == ict_none)
6202
      && !info->shared
6203
      && bfd_get_section_by_name (abfd, ".rld_map") == NULL)
6204
    {
6205
      s = bfd_make_section_with_flags (abfd, ".rld_map",
6206
                                       flags &~ (flagword) SEC_READONLY);
6207
      if (s == NULL
6208
          || ! bfd_set_section_alignment (abfd, s,
6209
                                          MIPS_ELF_LOG_FILE_ALIGN (abfd)))
6210
        return FALSE;
6211
    }
6212
 
6213
  /* On IRIX5, we adjust add some additional symbols and change the
6214
     alignments of several sections.  There is no ABI documentation
6215
     indicating that this is necessary on IRIX6, nor any evidence that
6216
     the linker takes such action.  */
6217
  if (IRIX_COMPAT (abfd) == ict_irix5)
6218
    {
6219
      for (namep = mips_elf_dynsym_rtproc_names; *namep != NULL; namep++)
6220
        {
6221
          bh = NULL;
6222
          if (! (_bfd_generic_link_add_one_symbol
6223
                 (info, abfd, *namep, BSF_GLOBAL, bfd_und_section_ptr, 0,
6224
                  NULL, FALSE, get_elf_backend_data (abfd)->collect, &bh)))
6225
            return FALSE;
6226
 
6227
          h = (struct elf_link_hash_entry *) bh;
6228
          h->non_elf = 0;
6229
          h->def_regular = 1;
6230
          h->type = STT_SECTION;
6231
 
6232
          if (! bfd_elf_link_record_dynamic_symbol (info, h))
6233
            return FALSE;
6234
        }
6235
 
6236
      /* We need to create a .compact_rel section.  */
6237
      if (SGI_COMPAT (abfd))
6238
        {
6239
          if (!mips_elf_create_compact_rel_section (abfd, info))
6240
            return FALSE;
6241
        }
6242
 
6243
      /* Change alignments of some sections.  */
6244
      s = bfd_get_section_by_name (abfd, ".hash");
6245
      if (s != NULL)
6246
        bfd_set_section_alignment (abfd, s, MIPS_ELF_LOG_FILE_ALIGN (abfd));
6247
      s = bfd_get_section_by_name (abfd, ".dynsym");
6248
      if (s != NULL)
6249
        bfd_set_section_alignment (abfd, s, MIPS_ELF_LOG_FILE_ALIGN (abfd));
6250
      s = bfd_get_section_by_name (abfd, ".dynstr");
6251
      if (s != NULL)
6252
        bfd_set_section_alignment (abfd, s, MIPS_ELF_LOG_FILE_ALIGN (abfd));
6253
      s = bfd_get_section_by_name (abfd, ".reginfo");
6254
      if (s != NULL)
6255
        bfd_set_section_alignment (abfd, s, MIPS_ELF_LOG_FILE_ALIGN (abfd));
6256
      s = bfd_get_section_by_name (abfd, ".dynamic");
6257
      if (s != NULL)
6258
        bfd_set_section_alignment (abfd, s, MIPS_ELF_LOG_FILE_ALIGN (abfd));
6259
    }
6260
 
6261
  if (!info->shared)
6262
    {
6263
      const char *name;
6264
 
6265
      name = SGI_COMPAT (abfd) ? "_DYNAMIC_LINK" : "_DYNAMIC_LINKING";
6266
      bh = NULL;
6267
      if (!(_bfd_generic_link_add_one_symbol
6268
            (info, abfd, name, BSF_GLOBAL, bfd_abs_section_ptr, 0,
6269
             NULL, FALSE, get_elf_backend_data (abfd)->collect, &bh)))
6270
        return FALSE;
6271
 
6272
      h = (struct elf_link_hash_entry *) bh;
6273
      h->non_elf = 0;
6274
      h->def_regular = 1;
6275
      h->type = STT_SECTION;
6276
 
6277
      if (! bfd_elf_link_record_dynamic_symbol (info, h))
6278
        return FALSE;
6279
 
6280
      if (! mips_elf_hash_table (info)->use_rld_obj_head)
6281
        {
6282
          /* __rld_map is a four byte word located in the .data section
6283
             and is filled in by the rtld to contain a pointer to
6284
             the _r_debug structure. Its symbol value will be set in
6285
             _bfd_mips_elf_finish_dynamic_symbol.  */
6286
          s = bfd_get_section_by_name (abfd, ".rld_map");
6287
          BFD_ASSERT (s != NULL);
6288
 
6289
          name = SGI_COMPAT (abfd) ? "__rld_map" : "__RLD_MAP";
6290
          bh = NULL;
6291
          if (!(_bfd_generic_link_add_one_symbol
6292
                (info, abfd, name, BSF_GLOBAL, s, 0, NULL, FALSE,
6293
                 get_elf_backend_data (abfd)->collect, &bh)))
6294
            return FALSE;
6295
 
6296
          h = (struct elf_link_hash_entry *) bh;
6297
          h->non_elf = 0;
6298
          h->def_regular = 1;
6299
          h->type = STT_OBJECT;
6300
 
6301
          if (! bfd_elf_link_record_dynamic_symbol (info, h))
6302
            return FALSE;
6303
        }
6304
    }
6305
 
6306
  if (htab->is_vxworks)
6307
    {
6308
      /* Create the .plt, .rela.plt, .dynbss and .rela.bss sections.
6309
         Also create the _PROCEDURE_LINKAGE_TABLE symbol.  */
6310
      if (!_bfd_elf_create_dynamic_sections (abfd, info))
6311
        return FALSE;
6312
 
6313
      /* Cache the sections created above.  */
6314
      htab->sdynbss = bfd_get_section_by_name (abfd, ".dynbss");
6315
      htab->srelbss = bfd_get_section_by_name (abfd, ".rela.bss");
6316
      htab->srelplt = bfd_get_section_by_name (abfd, ".rela.plt");
6317
      htab->splt = bfd_get_section_by_name (abfd, ".plt");
6318
      if (!htab->sdynbss
6319
          || (!htab->srelbss && !info->shared)
6320
          || !htab->srelplt
6321
          || !htab->splt)
6322
        abort ();
6323
 
6324
      /* Do the usual VxWorks handling.  */
6325
      if (!elf_vxworks_create_dynamic_sections (abfd, info, &htab->srelplt2))
6326
        return FALSE;
6327
 
6328
      /* Work out the PLT sizes.  */
6329
      if (info->shared)
6330
        {
6331
          htab->plt_header_size
6332
            = 4 * ARRAY_SIZE (mips_vxworks_shared_plt0_entry);
6333
          htab->plt_entry_size
6334
            = 4 * ARRAY_SIZE (mips_vxworks_shared_plt_entry);
6335
        }
6336
      else
6337
        {
6338
          htab->plt_header_size
6339
            = 4 * ARRAY_SIZE (mips_vxworks_exec_plt0_entry);
6340
          htab->plt_entry_size
6341
            = 4 * ARRAY_SIZE (mips_vxworks_exec_plt_entry);
6342
        }
6343
    }
6344
 
6345
  return TRUE;
6346
}
6347
 
6348
/* Return true if relocation REL against section SEC is a REL rather than
6349
   RELA relocation.  RELOCS is the first relocation in the section and
6350
   ABFD is the bfd that contains SEC.  */
6351
 
6352
static bfd_boolean
6353
mips_elf_rel_relocation_p (bfd *abfd, asection *sec,
6354
                           const Elf_Internal_Rela *relocs,
6355
                           const Elf_Internal_Rela *rel)
6356
{
6357
  Elf_Internal_Shdr *rel_hdr;
6358
  const struct elf_backend_data *bed;
6359
 
6360
  /* To determine which flavor or relocation this is, we depend on the
6361
     fact that the INPUT_SECTION's REL_HDR is read before its REL_HDR2.  */
6362
  rel_hdr = &elf_section_data (sec)->rel_hdr;
6363
  bed = get_elf_backend_data (abfd);
6364
  if ((size_t) (rel - relocs)
6365
      >= (NUM_SHDR_ENTRIES (rel_hdr) * bed->s->int_rels_per_ext_rel))
6366
    rel_hdr = elf_section_data (sec)->rel_hdr2;
6367
  return rel_hdr->sh_entsize == MIPS_ELF_REL_SIZE (abfd);
6368
}
6369
 
6370
/* Read the addend for REL relocation REL, which belongs to bfd ABFD.
6371
   HOWTO is the relocation's howto and CONTENTS points to the contents
6372
   of the section that REL is against.  */
6373
 
6374
static bfd_vma
6375
mips_elf_read_rel_addend (bfd *abfd, const Elf_Internal_Rela *rel,
6376
                          reloc_howto_type *howto, bfd_byte *contents)
6377
{
6378
  bfd_byte *location;
6379
  unsigned int r_type;
6380
  bfd_vma addend;
6381
 
6382
  r_type = ELF_R_TYPE (abfd, rel->r_info);
6383
  location = contents + rel->r_offset;
6384
 
6385
  /* Get the addend, which is stored in the input file.  */
6386
  _bfd_mips16_elf_reloc_unshuffle (abfd, r_type, FALSE, location);
6387
  addend = mips_elf_obtain_contents (howto, rel, abfd, contents);
6388
  _bfd_mips16_elf_reloc_shuffle (abfd, r_type, FALSE, location);
6389
 
6390
  return addend & howto->src_mask;
6391
}
6392
 
6393
/* REL is a relocation in ABFD that needs a partnering LO16 relocation
6394
   and *ADDEND is the addend for REL itself.  Look for the LO16 relocation
6395
   and update *ADDEND with the final addend.  Return true on success
6396
   or false if the LO16 could not be found.  RELEND is the exclusive
6397
   upper bound on the relocations for REL's section.  */
6398
 
6399
static bfd_boolean
6400
mips_elf_add_lo16_rel_addend (bfd *abfd,
6401
                              const Elf_Internal_Rela *rel,
6402
                              const Elf_Internal_Rela *relend,
6403
                              bfd_byte *contents, bfd_vma *addend)
6404
{
6405
  unsigned int r_type, lo16_type;
6406
  const Elf_Internal_Rela *lo16_relocation;
6407
  reloc_howto_type *lo16_howto;
6408
  bfd_vma l;
6409
 
6410
  r_type = ELF_R_TYPE (abfd, rel->r_info);
6411
  if (r_type == R_MIPS16_HI16)
6412
    lo16_type = R_MIPS16_LO16;
6413
  else
6414
    lo16_type = R_MIPS_LO16;
6415
 
6416
  /* The combined value is the sum of the HI16 addend, left-shifted by
6417
     sixteen bits, and the LO16 addend, sign extended.  (Usually, the
6418
     code does a `lui' of the HI16 value, and then an `addiu' of the
6419
     LO16 value.)
6420
 
6421
     Scan ahead to find a matching LO16 relocation.
6422
 
6423
     According to the MIPS ELF ABI, the R_MIPS_LO16 relocation must
6424
     be immediately following.  However, for the IRIX6 ABI, the next
6425
     relocation may be a composed relocation consisting of several
6426
     relocations for the same address.  In that case, the R_MIPS_LO16
6427
     relocation may occur as one of these.  We permit a similar
6428
     extension in general, as that is useful for GCC.
6429
 
6430
     In some cases GCC dead code elimination removes the LO16 but keeps
6431
     the corresponding HI16.  This is strictly speaking a violation of
6432
     the ABI but not immediately harmful.  */
6433
  lo16_relocation = mips_elf_next_relocation (abfd, lo16_type, rel, relend);
6434
  if (lo16_relocation == NULL)
6435
    return FALSE;
6436
 
6437
  /* Obtain the addend kept there.  */
6438
  lo16_howto = MIPS_ELF_RTYPE_TO_HOWTO (abfd, lo16_type, FALSE);
6439
  l = mips_elf_read_rel_addend (abfd, lo16_relocation, lo16_howto, contents);
6440
 
6441
  l <<= lo16_howto->rightshift;
6442
  l = _bfd_mips_elf_sign_extend (l, 16);
6443
 
6444
  *addend <<= 16;
6445
  *addend += l;
6446
  return TRUE;
6447
}
6448
 
6449
/* Try to read the contents of section SEC in bfd ABFD.  Return true and
6450
   store the contents in *CONTENTS on success.  Assume that *CONTENTS
6451
   already holds the contents if it is nonull on entry.  */
6452
 
6453
static bfd_boolean
6454
mips_elf_get_section_contents (bfd *abfd, asection *sec, bfd_byte **contents)
6455
{
6456
  if (*contents)
6457
    return TRUE;
6458
 
6459
  /* Get cached copy if it exists.  */
6460
  if (elf_section_data (sec)->this_hdr.contents != NULL)
6461
    {
6462
      *contents = elf_section_data (sec)->this_hdr.contents;
6463
      return TRUE;
6464
    }
6465
 
6466
  return bfd_malloc_and_get_section (abfd, sec, contents);
6467
}
6468
 
6469
/* Look through the relocs for a section during the first phase, and
6470
   allocate space in the global offset table.  */
6471
 
6472
bfd_boolean
6473
_bfd_mips_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
6474
                            asection *sec, const Elf_Internal_Rela *relocs)
6475
{
6476
  const char *name;
6477
  bfd *dynobj;
6478
  Elf_Internal_Shdr *symtab_hdr;
6479
  struct elf_link_hash_entry **sym_hashes;
6480
  struct mips_got_info *g;
6481
  size_t extsymoff;
6482
  const Elf_Internal_Rela *rel;
6483
  const Elf_Internal_Rela *rel_end;
6484
  asection *sgot;
6485
  asection *sreloc;
6486
  const struct elf_backend_data *bed;
6487
  struct mips_elf_link_hash_table *htab;
6488
  bfd_byte *contents;
6489
  bfd_vma addend;
6490
  reloc_howto_type *howto;
6491
 
6492
  if (info->relocatable)
6493
    return TRUE;
6494
 
6495
  htab = mips_elf_hash_table (info);
6496
  dynobj = elf_hash_table (info)->dynobj;
6497
  symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
6498
  sym_hashes = elf_sym_hashes (abfd);
6499
  extsymoff = (elf_bad_symtab (abfd)) ? 0 : symtab_hdr->sh_info;
6500
 
6501
  /* Check for the mips16 stub sections.  */
6502
 
6503
  name = bfd_get_section_name (abfd, sec);
6504
  if (FN_STUB_P (name))
6505
    {
6506
      unsigned long r_symndx;
6507
 
6508
      /* Look at the relocation information to figure out which symbol
6509
         this is for.  */
6510
 
6511
      r_symndx = ELF_R_SYM (abfd, relocs->r_info);
6512
 
6513
      if (r_symndx < extsymoff
6514
          || sym_hashes[r_symndx - extsymoff] == NULL)
6515
        {
6516
          asection *o;
6517
 
6518
          /* This stub is for a local symbol.  This stub will only be
6519
             needed if there is some relocation in this BFD, other
6520
             than a 16 bit function call, which refers to this symbol.  */
6521
          for (o = abfd->sections; o != NULL; o = o->next)
6522
            {
6523
              Elf_Internal_Rela *sec_relocs;
6524
              const Elf_Internal_Rela *r, *rend;
6525
 
6526
              /* We can ignore stub sections when looking for relocs.  */
6527
              if ((o->flags & SEC_RELOC) == 0
6528
                  || o->reloc_count == 0
6529
                  || mips16_stub_section_p (abfd, o))
6530
                continue;
6531
 
6532
              sec_relocs
6533
                = _bfd_elf_link_read_relocs (abfd, o, NULL, NULL,
6534
                                             info->keep_memory);
6535
              if (sec_relocs == NULL)
6536
                return FALSE;
6537
 
6538
              rend = sec_relocs + o->reloc_count;
6539
              for (r = sec_relocs; r < rend; r++)
6540
                if (ELF_R_SYM (abfd, r->r_info) == r_symndx
6541
                    && ELF_R_TYPE (abfd, r->r_info) != R_MIPS16_26)
6542
                  break;
6543
 
6544
              if (elf_section_data (o)->relocs != sec_relocs)
6545
                free (sec_relocs);
6546
 
6547
              if (r < rend)
6548
                break;
6549
            }
6550
 
6551
          if (o == NULL)
6552
            {
6553
              /* There is no non-call reloc for this stub, so we do
6554
                 not need it.  Since this function is called before
6555
                 the linker maps input sections to output sections, we
6556
                 can easily discard it by setting the SEC_EXCLUDE
6557
                 flag.  */
6558
              sec->flags |= SEC_EXCLUDE;
6559
              return TRUE;
6560
            }
6561
 
6562
          /* Record this stub in an array of local symbol stubs for
6563
             this BFD.  */
6564
          if (elf_tdata (abfd)->local_stubs == NULL)
6565
            {
6566
              unsigned long symcount;
6567
              asection **n;
6568
              bfd_size_type amt;
6569
 
6570
              if (elf_bad_symtab (abfd))
6571
                symcount = NUM_SHDR_ENTRIES (symtab_hdr);
6572
              else
6573
                symcount = symtab_hdr->sh_info;
6574
              amt = symcount * sizeof (asection *);
6575
              n = bfd_zalloc (abfd, amt);
6576
              if (n == NULL)
6577
                return FALSE;
6578
              elf_tdata (abfd)->local_stubs = n;
6579
            }
6580
 
6581
          sec->flags |= SEC_KEEP;
6582
          elf_tdata (abfd)->local_stubs[r_symndx] = sec;
6583
 
6584
          /* We don't need to set mips16_stubs_seen in this case.
6585
             That flag is used to see whether we need to look through
6586
             the global symbol table for stubs.  We don't need to set
6587
             it here, because we just have a local stub.  */
6588
        }
6589
      else
6590
        {
6591
          struct mips_elf_link_hash_entry *h;
6592
 
6593
          h = ((struct mips_elf_link_hash_entry *)
6594
               sym_hashes[r_symndx - extsymoff]);
6595
 
6596
          while (h->root.root.type == bfd_link_hash_indirect
6597
                 || h->root.root.type == bfd_link_hash_warning)
6598
            h = (struct mips_elf_link_hash_entry *) h->root.root.u.i.link;
6599
 
6600
          /* H is the symbol this stub is for.  */
6601
 
6602
          /* If we already have an appropriate stub for this function, we
6603
             don't need another one, so we can discard this one.  Since
6604
             this function is called before the linker maps input sections
6605
             to output sections, we can easily discard it by setting the
6606
             SEC_EXCLUDE flag.  */
6607
          if (h->fn_stub != NULL)
6608
            {
6609
              sec->flags |= SEC_EXCLUDE;
6610
              return TRUE;
6611
            }
6612
 
6613
          sec->flags |= SEC_KEEP;
6614
          h->fn_stub = sec;
6615
          mips_elf_hash_table (info)->mips16_stubs_seen = TRUE;
6616
        }
6617
    }
6618
  else if (CALL_STUB_P (name) || CALL_FP_STUB_P (name))
6619
    {
6620
      unsigned long r_symndx;
6621
      struct mips_elf_link_hash_entry *h;
6622
      asection **loc;
6623
 
6624
      /* Look at the relocation information to figure out which symbol
6625
         this is for.  */
6626
 
6627
      r_symndx = ELF_R_SYM (abfd, relocs->r_info);
6628
 
6629
      if (r_symndx < extsymoff
6630
          || sym_hashes[r_symndx - extsymoff] == NULL)
6631
        {
6632
          asection *o;
6633
 
6634
          /* This stub is for a local symbol.  This stub will only be
6635
             needed if there is some relocation (R_MIPS16_26) in this BFD
6636
             that refers to this symbol.  */
6637
          for (o = abfd->sections; o != NULL; o = o->next)
6638
            {
6639
              Elf_Internal_Rela *sec_relocs;
6640
              const Elf_Internal_Rela *r, *rend;
6641
 
6642
              /* We can ignore stub sections when looking for relocs.  */
6643
              if ((o->flags & SEC_RELOC) == 0
6644
                  || o->reloc_count == 0
6645
                  || mips16_stub_section_p (abfd, o))
6646
                continue;
6647
 
6648
              sec_relocs
6649
                = _bfd_elf_link_read_relocs (abfd, o, NULL, NULL,
6650
                                             info->keep_memory);
6651
              if (sec_relocs == NULL)
6652
                return FALSE;
6653
 
6654
              rend = sec_relocs + o->reloc_count;
6655
              for (r = sec_relocs; r < rend; r++)
6656
                if (ELF_R_SYM (abfd, r->r_info) == r_symndx
6657
                    && ELF_R_TYPE (abfd, r->r_info) == R_MIPS16_26)
6658
                    break;
6659
 
6660
              if (elf_section_data (o)->relocs != sec_relocs)
6661
                free (sec_relocs);
6662
 
6663
              if (r < rend)
6664
                break;
6665
            }
6666
 
6667
          if (o == NULL)
6668
            {
6669
              /* There is no non-call reloc for this stub, so we do
6670
                 not need it.  Since this function is called before
6671
                 the linker maps input sections to output sections, we
6672
                 can easily discard it by setting the SEC_EXCLUDE
6673
                 flag.  */
6674
              sec->flags |= SEC_EXCLUDE;
6675
              return TRUE;
6676
            }
6677
 
6678
          /* Record this stub in an array of local symbol call_stubs for
6679
             this BFD.  */
6680
          if (elf_tdata (abfd)->local_call_stubs == NULL)
6681
            {
6682
              unsigned long symcount;
6683
              asection **n;
6684
              bfd_size_type amt;
6685
 
6686
              if (elf_bad_symtab (abfd))
6687
                symcount = NUM_SHDR_ENTRIES (symtab_hdr);
6688
              else
6689
                symcount = symtab_hdr->sh_info;
6690
              amt = symcount * sizeof (asection *);
6691
              n = bfd_zalloc (abfd, amt);
6692
              if (n == NULL)
6693
                return FALSE;
6694
              elf_tdata (abfd)->local_call_stubs = n;
6695
            }
6696
 
6697
          sec->flags |= SEC_KEEP;
6698
          elf_tdata (abfd)->local_call_stubs[r_symndx] = sec;
6699
 
6700
          /* We don't need to set mips16_stubs_seen in this case.
6701
             That flag is used to see whether we need to look through
6702
             the global symbol table for stubs.  We don't need to set
6703
             it here, because we just have a local stub.  */
6704
        }
6705
      else
6706
        {
6707
          h = ((struct mips_elf_link_hash_entry *)
6708
               sym_hashes[r_symndx - extsymoff]);
6709
 
6710
          /* H is the symbol this stub is for.  */
6711
 
6712
          if (CALL_FP_STUB_P (name))
6713
            loc = &h->call_fp_stub;
6714
          else
6715
            loc = &h->call_stub;
6716
 
6717
          /* If we already have an appropriate stub for this function, we
6718
             don't need another one, so we can discard this one.  Since
6719
             this function is called before the linker maps input sections
6720
             to output sections, we can easily discard it by setting the
6721
             SEC_EXCLUDE flag.  */
6722
          if (*loc != NULL)
6723
            {
6724
              sec->flags |= SEC_EXCLUDE;
6725
              return TRUE;
6726
            }
6727
 
6728
          sec->flags |= SEC_KEEP;
6729
          *loc = sec;
6730
          mips_elf_hash_table (info)->mips16_stubs_seen = TRUE;
6731
        }
6732
    }
6733
 
6734
  if (dynobj == NULL)
6735
    {
6736
      sgot = NULL;
6737
      g = NULL;
6738
    }
6739
  else
6740
    {
6741
      sgot = mips_elf_got_section (dynobj, FALSE);
6742
      if (sgot == NULL)
6743
        g = NULL;
6744
      else
6745
        {
6746
          BFD_ASSERT (mips_elf_section_data (sgot) != NULL);
6747
          g = mips_elf_section_data (sgot)->u.got_info;
6748
          BFD_ASSERT (g != NULL);
6749
        }
6750
    }
6751
 
6752
  sreloc = NULL;
6753
  bed = get_elf_backend_data (abfd);
6754
  rel_end = relocs + sec->reloc_count * bed->s->int_rels_per_ext_rel;
6755
  contents = NULL;
6756
  for (rel = relocs; rel < rel_end; ++rel)
6757
    {
6758
      unsigned long r_symndx;
6759
      unsigned int r_type;
6760
      struct elf_link_hash_entry *h;
6761
 
6762
      r_symndx = ELF_R_SYM (abfd, rel->r_info);
6763
      r_type = ELF_R_TYPE (abfd, rel->r_info);
6764
 
6765
      if (r_symndx < extsymoff)
6766
        h = NULL;
6767
      else if (r_symndx >= extsymoff + NUM_SHDR_ENTRIES (symtab_hdr))
6768
        {
6769
          (*_bfd_error_handler)
6770
            (_("%B: Malformed reloc detected for section %s"),
6771
             abfd, name);
6772
          bfd_set_error (bfd_error_bad_value);
6773
          return FALSE;
6774
        }
6775
      else
6776
        {
6777
          h = sym_hashes[r_symndx - extsymoff];
6778
 
6779
          /* This may be an indirect symbol created because of a version.  */
6780
          if (h != NULL)
6781
            {
6782
              while (h->root.type == bfd_link_hash_indirect)
6783
                h = (struct elf_link_hash_entry *) h->root.u.i.link;
6784
            }
6785
        }
6786
 
6787
      /* Some relocs require a global offset table.  */
6788
      if (dynobj == NULL || sgot == NULL)
6789
        {
6790
          switch (r_type)
6791
            {
6792
            case R_MIPS_GOT16:
6793
            case R_MIPS_CALL16:
6794
            case R_MIPS_CALL_HI16:
6795
            case R_MIPS_CALL_LO16:
6796
            case R_MIPS_GOT_HI16:
6797
            case R_MIPS_GOT_LO16:
6798
            case R_MIPS_GOT_PAGE:
6799
            case R_MIPS_GOT_OFST:
6800
            case R_MIPS_GOT_DISP:
6801
            case R_MIPS_TLS_GOTTPREL:
6802
            case R_MIPS_TLS_GD:
6803
            case R_MIPS_TLS_LDM:
6804
              if (dynobj == NULL)
6805
                elf_hash_table (info)->dynobj = dynobj = abfd;
6806
              if (! mips_elf_create_got_section (dynobj, info, FALSE))
6807
                return FALSE;
6808
              g = mips_elf_got_info (dynobj, &sgot);
6809
              if (htab->is_vxworks && !info->shared)
6810
                {
6811
                  (*_bfd_error_handler)
6812
                    (_("%B: GOT reloc at 0x%lx not expected in executables"),
6813
                     abfd, (unsigned long) rel->r_offset);
6814
                  bfd_set_error (bfd_error_bad_value);
6815
                  return FALSE;
6816
                }
6817
              break;
6818
 
6819
            case R_MIPS_32:
6820
            case R_MIPS_REL32:
6821
            case R_MIPS_64:
6822
              /* In VxWorks executables, references to external symbols
6823
                 are handled using copy relocs or PLT stubs, so there's
6824
                 no need to add a dynamic relocation here.  */
6825
              if (dynobj == NULL
6826
                  && (info->shared || (h != NULL && !htab->is_vxworks))
6827
                  && (sec->flags & SEC_ALLOC) != 0)
6828
                elf_hash_table (info)->dynobj = dynobj = abfd;
6829
              break;
6830
 
6831
            default:
6832
              break;
6833
            }
6834
        }
6835
 
6836
      if (h)
6837
        {
6838
          ((struct mips_elf_link_hash_entry *) h)->is_relocation_target = TRUE;
6839
 
6840
          /* Relocations against the special VxWorks __GOTT_BASE__ and
6841
             __GOTT_INDEX__ symbols must be left to the loader.  Allocate
6842
             room for them in .rela.dyn.  */
6843
          if (is_gott_symbol (info, h))
6844
            {
6845
              if (sreloc == NULL)
6846
                {
6847
                  sreloc = mips_elf_rel_dyn_section (info, TRUE);
6848
                  if (sreloc == NULL)
6849
                    return FALSE;
6850
                }
6851
              mips_elf_allocate_dynamic_relocations (dynobj, info, 1);
6852
              if (MIPS_ELF_READONLY_SECTION (sec))
6853
                /* We tell the dynamic linker that there are
6854
                   relocations against the text segment.  */
6855
                info->flags |= DF_TEXTREL;
6856
            }
6857
        }
6858
      else if (r_type == R_MIPS_CALL_LO16
6859
               || r_type == R_MIPS_GOT_LO16
6860
               || r_type == R_MIPS_GOT_DISP
6861
               || (r_type == R_MIPS_GOT16 && htab->is_vxworks))
6862
        {
6863
          /* We may need a local GOT entry for this relocation.  We
6864
             don't count R_MIPS_GOT_PAGE because we can estimate the
6865
             maximum number of pages needed by looking at the size of
6866
             the segment.  Similar comments apply to R_MIPS_GOT16 and
6867
             R_MIPS_CALL16, except on VxWorks, where GOT relocations
6868
             always evaluate to "G".  We don't count R_MIPS_GOT_HI16, or
6869
             R_MIPS_CALL_HI16 because these are always followed by an
6870
             R_MIPS_GOT_LO16 or R_MIPS_CALL_LO16.  */
6871
          if (! mips_elf_record_local_got_symbol (abfd, r_symndx,
6872
                                                  rel->r_addend, g, 0))
6873
            return FALSE;
6874
        }
6875
 
6876
      switch (r_type)
6877
        {
6878
        case R_MIPS_CALL16:
6879
          if (h == NULL)
6880
            {
6881
              (*_bfd_error_handler)
6882
                (_("%B: CALL16 reloc at 0x%lx not against global symbol"),
6883
                 abfd, (unsigned long) rel->r_offset);
6884
              bfd_set_error (bfd_error_bad_value);
6885
              return FALSE;
6886
            }
6887
          /* Fall through.  */
6888
 
6889
        case R_MIPS_CALL_HI16:
6890
        case R_MIPS_CALL_LO16:
6891
          if (h != NULL)
6892
            {
6893
              /* VxWorks call relocations point the function's .got.plt
6894
                 entry, which will be allocated by adjust_dynamic_symbol.
6895
                 Otherwise, this symbol requires a global GOT entry.  */
6896
              if ((!htab->is_vxworks || h->forced_local)
6897
                  && !mips_elf_record_global_got_symbol (h, abfd, info, g, 0))
6898
                return FALSE;
6899
 
6900
              /* We need a stub, not a plt entry for the undefined
6901
                 function.  But we record it as if it needs plt.  See
6902
                 _bfd_elf_adjust_dynamic_symbol.  */
6903
              h->needs_plt = 1;
6904
              h->type = STT_FUNC;
6905
            }
6906
          break;
6907
 
6908
        case R_MIPS_GOT_PAGE:
6909
          /* If this is a global, overridable symbol, GOT_PAGE will
6910
             decay to GOT_DISP, so we'll need a GOT entry for it.  */
6911
          if (h)
6912
            {
6913
              struct mips_elf_link_hash_entry *hmips =
6914
                (struct mips_elf_link_hash_entry *) h;
6915
 
6916
              while (hmips->root.root.type == bfd_link_hash_indirect
6917
                     || hmips->root.root.type == bfd_link_hash_warning)
6918
                hmips = (struct mips_elf_link_hash_entry *)
6919
                  hmips->root.root.u.i.link;
6920
 
6921
              /* This symbol is definitely not overridable.  */
6922
              if (hmips->root.def_regular
6923
                  && ! (info->shared && ! info->symbolic
6924
                        && ! hmips->root.forced_local))
6925
                h = NULL;
6926
            }
6927
          /* Fall through.  */
6928
 
6929
        case R_MIPS_GOT16:
6930
        case R_MIPS_GOT_HI16:
6931
        case R_MIPS_GOT_LO16:
6932
          if (!h || r_type == R_MIPS_GOT_PAGE)
6933
            {
6934
              /* This relocation needs (or may need, if h != NULL) a
6935
                 page entry in the GOT.  For R_MIPS_GOT_PAGE we do not
6936
                 know for sure until we know whether the symbol is
6937
                 preemptible.  */
6938
              if (mips_elf_rel_relocation_p (abfd, sec, relocs, rel))
6939
                {
6940
                  if (!mips_elf_get_section_contents (abfd, sec, &contents))
6941
                    return FALSE;
6942
                  howto = MIPS_ELF_RTYPE_TO_HOWTO (abfd, r_type, FALSE);
6943
                  addend = mips_elf_read_rel_addend (abfd, rel,
6944
                                                     howto, contents);
6945
                  if (r_type == R_MIPS_GOT16)
6946
                    mips_elf_add_lo16_rel_addend (abfd, rel, rel_end,
6947
                                                  contents, &addend);
6948
                  else
6949
                    addend <<= howto->rightshift;
6950
                }
6951
              else
6952
                addend = rel->r_addend;
6953
              if (!mips_elf_record_got_page_entry (abfd, r_symndx, addend, g))
6954
                return FALSE;
6955
              break;
6956
            }
6957
          /* Fall through.  */
6958
 
6959
        case R_MIPS_GOT_DISP:
6960
          if (h && ! mips_elf_record_global_got_symbol (h, abfd, info, g, 0))
6961
            return FALSE;
6962
          break;
6963
 
6964
        case R_MIPS_TLS_GOTTPREL:
6965
          if (info->shared)
6966
            info->flags |= DF_STATIC_TLS;
6967
          /* Fall through */
6968
 
6969
        case R_MIPS_TLS_LDM:
6970
          if (r_type == R_MIPS_TLS_LDM)
6971
            {
6972
              r_symndx = 0;
6973
              h = NULL;
6974
            }
6975
          /* Fall through */
6976
 
6977
        case R_MIPS_TLS_GD:
6978
          /* This symbol requires a global offset table entry, or two
6979
             for TLS GD relocations.  */
6980
          {
6981
            unsigned char flag = (r_type == R_MIPS_TLS_GD
6982
                                  ? GOT_TLS_GD
6983
                                  : r_type == R_MIPS_TLS_LDM
6984
                                  ? GOT_TLS_LDM
6985
                                  : GOT_TLS_IE);
6986
            if (h != NULL)
6987
              {
6988
                struct mips_elf_link_hash_entry *hmips =
6989
                  (struct mips_elf_link_hash_entry *) h;
6990
                hmips->tls_type |= flag;
6991
 
6992
                if (h && ! mips_elf_record_global_got_symbol (h, abfd, info, g, flag))
6993
                  return FALSE;
6994
              }
6995
            else
6996
              {
6997
                BFD_ASSERT (flag == GOT_TLS_LDM || r_symndx != 0);
6998
 
6999
                if (! mips_elf_record_local_got_symbol (abfd, r_symndx,
7000
                                                        rel->r_addend, g, flag))
7001
                  return FALSE;
7002
              }
7003
          }
7004
          break;
7005
 
7006
        case R_MIPS_32:
7007
        case R_MIPS_REL32:
7008
        case R_MIPS_64:
7009
          /* In VxWorks executables, references to external symbols
7010
             are handled using copy relocs or PLT stubs, so there's
7011
             no need to add a .rela.dyn entry for this relocation.  */
7012
          if ((info->shared || (h != NULL && !htab->is_vxworks))
7013
              && (sec->flags & SEC_ALLOC) != 0)
7014
            {
7015
              if (sreloc == NULL)
7016
                {
7017
                  sreloc = mips_elf_rel_dyn_section (info, TRUE);
7018
                  if (sreloc == NULL)
7019
                    return FALSE;
7020
                }
7021
              if (info->shared)
7022
                {
7023
                  /* When creating a shared object, we must copy these
7024
                     reloc types into the output file as R_MIPS_REL32
7025
                     relocs.  Make room for this reloc in .rel(a).dyn.  */
7026
                  mips_elf_allocate_dynamic_relocations (dynobj, info, 1);
7027
                  if (MIPS_ELF_READONLY_SECTION (sec))
7028
                    /* We tell the dynamic linker that there are
7029
                       relocations against the text segment.  */
7030
                    info->flags |= DF_TEXTREL;
7031
                }
7032
              else
7033
                {
7034
                  struct mips_elf_link_hash_entry *hmips;
7035
 
7036
                  /* We only need to copy this reloc if the symbol is
7037
                     defined in a dynamic object.  */
7038
                  hmips = (struct mips_elf_link_hash_entry *) h;
7039
                  ++hmips->possibly_dynamic_relocs;
7040
                  if (MIPS_ELF_READONLY_SECTION (sec))
7041
                    /* We need it to tell the dynamic linker if there
7042
                       are relocations against the text segment.  */
7043
                    hmips->readonly_reloc = TRUE;
7044
                }
7045
 
7046
              /* Even though we don't directly need a GOT entry for
7047
                 this symbol, a symbol must have a dynamic symbol
7048
                 table index greater that DT_MIPS_GOTSYM if there are
7049
                 dynamic relocations against it.  This does not apply
7050
                 to VxWorks, which does not have the usual coupling
7051
                 between global GOT entries and .dynsym entries.  */
7052
              if (h != NULL && !htab->is_vxworks)
7053
                {
7054
                  if (dynobj == NULL)
7055
                    elf_hash_table (info)->dynobj = dynobj = abfd;
7056
                  if (! mips_elf_create_got_section (dynobj, info, TRUE))
7057
                    return FALSE;
7058
                  g = mips_elf_got_info (dynobj, &sgot);
7059
                  if (! mips_elf_record_global_got_symbol (h, abfd, info, g, 0))
7060
                    return FALSE;
7061
                }
7062
            }
7063
 
7064
          if (SGI_COMPAT (abfd))
7065
            mips_elf_hash_table (info)->compact_rel_size +=
7066
              sizeof (Elf32_External_crinfo);
7067
          break;
7068
 
7069
        case R_MIPS_PC16:
7070
          if (h)
7071
            ((struct mips_elf_link_hash_entry *) h)->is_branch_target = TRUE;
7072
          break;
7073
 
7074
        case R_MIPS_26:
7075
          if (h)
7076
            ((struct mips_elf_link_hash_entry *) h)->is_branch_target = TRUE;
7077
          /* Fall through.  */
7078
 
7079
        case R_MIPS_GPREL16:
7080
        case R_MIPS_LITERAL:
7081
        case R_MIPS_GPREL32:
7082
          if (SGI_COMPAT (abfd))
7083
            mips_elf_hash_table (info)->compact_rel_size +=
7084
              sizeof (Elf32_External_crinfo);
7085
          break;
7086
 
7087
          /* This relocation describes the C++ object vtable hierarchy.
7088
             Reconstruct it for later use during GC.  */
7089
        case R_MIPS_GNU_VTINHERIT:
7090
          if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
7091
            return FALSE;
7092
          break;
7093
 
7094
          /* This relocation describes which C++ vtable entries are actually
7095
             used.  Record for later use during GC.  */
7096
        case R_MIPS_GNU_VTENTRY:
7097
          BFD_ASSERT (h != NULL);
7098
          if (h != NULL
7099
              && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_offset))
7100
            return FALSE;
7101
          break;
7102
 
7103
        default:
7104
          break;
7105
        }
7106
 
7107
      /* We must not create a stub for a symbol that has relocations
7108
         related to taking the function's address.  This doesn't apply to
7109
         VxWorks, where CALL relocs refer to a .got.plt entry instead of
7110
         a normal .got entry.  */
7111
      if (!htab->is_vxworks && h != NULL)
7112
        switch (r_type)
7113
          {
7114
          default:
7115
            ((struct mips_elf_link_hash_entry *) h)->no_fn_stub = TRUE;
7116
            break;
7117
          case R_MIPS_CALL16:
7118
          case R_MIPS_CALL_HI16:
7119
          case R_MIPS_CALL_LO16:
7120
          case R_MIPS_JALR:
7121
            break;
7122
          }
7123
 
7124
      /* If this reloc is not a 16 bit call, and it has a global
7125
         symbol, then we will need the fn_stub if there is one.
7126
         References from a stub section do not count.  */
7127
      if (h != NULL
7128
          && r_type != R_MIPS16_26
7129
          && !mips16_stub_section_p (abfd, sec))
7130
        {
7131
          struct mips_elf_link_hash_entry *mh;
7132
 
7133
          mh = (struct mips_elf_link_hash_entry *) h;
7134
          mh->need_fn_stub = TRUE;
7135
        }
7136
    }
7137
 
7138
  return TRUE;
7139
}
7140
 
7141
bfd_boolean
7142
_bfd_mips_relax_section (bfd *abfd, asection *sec,
7143
                         struct bfd_link_info *link_info,
7144
                         bfd_boolean *again)
7145
{
7146
  Elf_Internal_Rela *internal_relocs;
7147
  Elf_Internal_Rela *irel, *irelend;
7148
  Elf_Internal_Shdr *symtab_hdr;
7149
  bfd_byte *contents = NULL;
7150
  size_t extsymoff;
7151
  bfd_boolean changed_contents = FALSE;
7152
  bfd_vma sec_start = sec->output_section->vma + sec->output_offset;
7153
  Elf_Internal_Sym *isymbuf = NULL;
7154
 
7155
  /* We are not currently changing any sizes, so only one pass.  */
7156
  *again = FALSE;
7157
 
7158
  if (link_info->relocatable)
7159
    return TRUE;
7160
 
7161
  internal_relocs = _bfd_elf_link_read_relocs (abfd, sec, NULL, NULL,
7162
                                               link_info->keep_memory);
7163
  if (internal_relocs == NULL)
7164
    return TRUE;
7165
 
7166
  irelend = internal_relocs + sec->reloc_count
7167
    * get_elf_backend_data (abfd)->s->int_rels_per_ext_rel;
7168
  symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
7169
  extsymoff = (elf_bad_symtab (abfd)) ? 0 : symtab_hdr->sh_info;
7170
 
7171
  for (irel = internal_relocs; irel < irelend; irel++)
7172
    {
7173
      bfd_vma symval;
7174
      bfd_signed_vma sym_offset;
7175
      unsigned int r_type;
7176
      unsigned long r_symndx;
7177
      asection *sym_sec;
7178
      unsigned long instruction;
7179
 
7180
      /* Turn jalr into bgezal, and jr into beq, if they're marked
7181
         with a JALR relocation, that indicate where they jump to.
7182
         This saves some pipeline bubbles.  */
7183
      r_type = ELF_R_TYPE (abfd, irel->r_info);
7184
      if (r_type != R_MIPS_JALR)
7185
        continue;
7186
 
7187
      r_symndx = ELF_R_SYM (abfd, irel->r_info);
7188
      /* Compute the address of the jump target.  */
7189
      if (r_symndx >= extsymoff)
7190
        {
7191
          struct mips_elf_link_hash_entry *h
7192
            = ((struct mips_elf_link_hash_entry *)
7193
               elf_sym_hashes (abfd) [r_symndx - extsymoff]);
7194
 
7195
          while (h->root.root.type == bfd_link_hash_indirect
7196
                 || h->root.root.type == bfd_link_hash_warning)
7197
            h = (struct mips_elf_link_hash_entry *) h->root.root.u.i.link;
7198
 
7199
          /* If a symbol is undefined, or if it may be overridden,
7200
             skip it.  */
7201
          if (! ((h->root.root.type == bfd_link_hash_defined
7202
                  || h->root.root.type == bfd_link_hash_defweak)
7203
                 && h->root.root.u.def.section)
7204
              || (link_info->shared && ! link_info->symbolic
7205
                  && !h->root.forced_local))
7206
            continue;
7207
 
7208
          sym_sec = h->root.root.u.def.section;
7209
          if (sym_sec->output_section)
7210
            symval = (h->root.root.u.def.value
7211
                      + sym_sec->output_section->vma
7212
                      + sym_sec->output_offset);
7213
          else
7214
            symval = h->root.root.u.def.value;
7215
        }
7216
      else
7217
        {
7218
          Elf_Internal_Sym *isym;
7219
 
7220
          /* Read this BFD's symbols if we haven't done so already.  */
7221
          if (isymbuf == NULL && symtab_hdr->sh_info != 0)
7222
            {
7223
              isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
7224
              if (isymbuf == NULL)
7225
                isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
7226
                                                symtab_hdr->sh_info, 0,
7227
                                                NULL, NULL, NULL);
7228
              if (isymbuf == NULL)
7229
                goto relax_return;
7230
            }
7231
 
7232
          isym = isymbuf + r_symndx;
7233
          if (isym->st_shndx == SHN_UNDEF)
7234
            continue;
7235
          else if (isym->st_shndx == SHN_ABS)
7236
            sym_sec = bfd_abs_section_ptr;
7237
          else if (isym->st_shndx == SHN_COMMON)
7238
            sym_sec = bfd_com_section_ptr;
7239
          else
7240
            sym_sec
7241
              = bfd_section_from_elf_index (abfd, isym->st_shndx);
7242
          symval = isym->st_value
7243
            + sym_sec->output_section->vma
7244
            + sym_sec->output_offset;
7245
        }
7246
 
7247
      /* Compute branch offset, from delay slot of the jump to the
7248
         branch target.  */
7249
      sym_offset = (symval + irel->r_addend)
7250
        - (sec_start + irel->r_offset + 4);
7251
 
7252
      /* Branch offset must be properly aligned.  */
7253
      if ((sym_offset & 3) != 0)
7254
        continue;
7255
 
7256
      sym_offset >>= 2;
7257
 
7258
      /* Check that it's in range.  */
7259
      if (sym_offset < -0x8000 || sym_offset >= 0x8000)
7260
        continue;
7261
 
7262
      /* Get the section contents if we haven't done so already.  */
7263
      if (!mips_elf_get_section_contents (abfd, sec, &contents))
7264
        goto relax_return;
7265
 
7266
      instruction = bfd_get_32 (abfd, contents + irel->r_offset);
7267
 
7268
      /* If it was jalr <reg>, turn it into bgezal $zero, <target>.  */
7269
      if ((instruction & 0xfc1fffff) == 0x0000f809)
7270
        instruction = 0x04110000;
7271
      /* If it was jr <reg>, turn it into b <target>.  */
7272
      else if ((instruction & 0xfc1fffff) == 0x00000008)
7273
        instruction = 0x10000000;
7274
      else
7275
        continue;
7276
 
7277
      instruction |= (sym_offset & 0xffff);
7278
      bfd_put_32 (abfd, instruction, contents + irel->r_offset);
7279
      changed_contents = TRUE;
7280
    }
7281
 
7282
  if (contents != NULL
7283
      && elf_section_data (sec)->this_hdr.contents != contents)
7284
    {
7285
      if (!changed_contents && !link_info->keep_memory)
7286
        free (contents);
7287
      else
7288
        {
7289
          /* Cache the section contents for elf_link_input_bfd.  */
7290
          elf_section_data (sec)->this_hdr.contents = contents;
7291
        }
7292
    }
7293
  return TRUE;
7294
 
7295
 relax_return:
7296
  if (contents != NULL
7297
      && elf_section_data (sec)->this_hdr.contents != contents)
7298
    free (contents);
7299
  return FALSE;
7300
}
7301
 
7302
/* Adjust a symbol defined by a dynamic object and referenced by a
7303
   regular object.  The current definition is in some section of the
7304
   dynamic object, but we're not including those sections.  We have to
7305
   change the definition to something the rest of the link can
7306
   understand.  */
7307
 
7308
bfd_boolean
7309
_bfd_mips_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
7310
                                     struct elf_link_hash_entry *h)
7311
{
7312
  bfd *dynobj;
7313
  struct mips_elf_link_hash_entry *hmips;
7314
  asection *s;
7315
  struct mips_elf_link_hash_table *htab;
7316
 
7317
  htab = mips_elf_hash_table (info);
7318
  dynobj = elf_hash_table (info)->dynobj;
7319
 
7320
  /* Make sure we know what is going on here.  */
7321
  BFD_ASSERT (dynobj != NULL
7322
              && (h->needs_plt
7323
                  || h->u.weakdef != NULL
7324
                  || (h->def_dynamic
7325
                      && h->ref_regular
7326
                      && !h->def_regular)));
7327
 
7328
  /* If this symbol is defined in a dynamic object, we need to copy
7329
     any R_MIPS_32 or R_MIPS_REL32 relocs against it into the output
7330
     file.  */
7331
  hmips = (struct mips_elf_link_hash_entry *) h;
7332
  if (! info->relocatable
7333
      && hmips->possibly_dynamic_relocs != 0
7334
      && (h->root.type == bfd_link_hash_defweak
7335
          || !h->def_regular))
7336
    {
7337
      mips_elf_allocate_dynamic_relocations
7338
        (dynobj, info, hmips->possibly_dynamic_relocs);
7339
      if (hmips->readonly_reloc)
7340
        /* We tell the dynamic linker that there are relocations
7341
           against the text segment.  */
7342
        info->flags |= DF_TEXTREL;
7343
    }
7344
 
7345
  /* For a function, create a stub, if allowed.  */
7346
  if (! hmips->no_fn_stub
7347
      && h->needs_plt)
7348
    {
7349
      if (! elf_hash_table (info)->dynamic_sections_created)
7350
        return TRUE;
7351
 
7352
      /* If this symbol is not defined in a regular file, then set
7353
         the symbol to the stub location.  This is required to make
7354
         function pointers compare as equal between the normal
7355
         executable and the shared library.  */
7356
      if (!h->def_regular)
7357
        {
7358
          /* We need .stub section.  */
7359
          s = bfd_get_section_by_name (dynobj,
7360
                                       MIPS_ELF_STUB_SECTION_NAME (dynobj));
7361
          BFD_ASSERT (s != NULL);
7362
 
7363
          h->root.u.def.section = s;
7364
          h->root.u.def.value = s->size;
7365
 
7366
          /* XXX Write this stub address somewhere.  */
7367
          h->plt.offset = s->size;
7368
 
7369
          /* Make room for this stub code.  */
7370
          s->size += htab->function_stub_size;
7371
 
7372
          /* The last half word of the stub will be filled with the index
7373
             of this symbol in .dynsym section.  */
7374
          return TRUE;
7375
        }
7376
    }
7377
  else if ((h->type == STT_FUNC)
7378
           && !h->needs_plt)
7379
    {
7380
      /* This will set the entry for this symbol in the GOT to 0, and
7381
         the dynamic linker will take care of this.  */
7382
      h->root.u.def.value = 0;
7383
      return TRUE;
7384
    }
7385
 
7386
  /* If this is a weak symbol, and there is a real definition, the
7387
     processor independent code will have arranged for us to see the
7388
     real definition first, and we can just use the same value.  */
7389
  if (h->u.weakdef != NULL)
7390
    {
7391
      BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
7392
                  || h->u.weakdef->root.type == bfd_link_hash_defweak);
7393
      h->root.u.def.section = h->u.weakdef->root.u.def.section;
7394
      h->root.u.def.value = h->u.weakdef->root.u.def.value;
7395
      return TRUE;
7396
    }
7397
 
7398
  /* This is a reference to a symbol defined by a dynamic object which
7399
     is not a function.  */
7400
 
7401
  return TRUE;
7402
}
7403
 
7404
/* Likewise, for VxWorks.  */
7405
 
7406
bfd_boolean
7407
_bfd_mips_vxworks_adjust_dynamic_symbol (struct bfd_link_info *info,
7408
                                         struct elf_link_hash_entry *h)
7409
{
7410
  bfd *dynobj;
7411
  struct mips_elf_link_hash_entry *hmips;
7412
  struct mips_elf_link_hash_table *htab;
7413
 
7414
  htab = mips_elf_hash_table (info);
7415
  dynobj = elf_hash_table (info)->dynobj;
7416
  hmips = (struct mips_elf_link_hash_entry *) h;
7417
 
7418
  /* Make sure we know what is going on here.  */
7419
  BFD_ASSERT (dynobj != NULL
7420
              && (h->needs_plt
7421
                  || h->needs_copy
7422
                  || h->u.weakdef != NULL
7423
                  || (h->def_dynamic
7424
                      && h->ref_regular
7425
                      && !h->def_regular)));
7426
 
7427
  /* If the symbol is defined by a dynamic object, we need a PLT stub if
7428
     either (a) we want to branch to the symbol or (b) we're linking an
7429
     executable that needs a canonical function address.  In the latter
7430
     case, the canonical address will be the address of the executable's
7431
     load stub.  */
7432
  if ((hmips->is_branch_target
7433
       || (!info->shared
7434
           && h->type == STT_FUNC
7435
           && hmips->is_relocation_target))
7436
      && h->def_dynamic
7437
      && h->ref_regular
7438
      && !h->def_regular
7439
      && !h->forced_local)
7440
    h->needs_plt = 1;
7441
 
7442
  /* Locally-binding symbols do not need a PLT stub; we can refer to
7443
     the functions directly.  */
7444
  else if (h->needs_plt
7445
           && (SYMBOL_CALLS_LOCAL (info, h)
7446
               || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
7447
                   && h->root.type == bfd_link_hash_undefweak)))
7448
    {
7449
      h->needs_plt = 0;
7450
      return TRUE;
7451
    }
7452
 
7453
  if (h->needs_plt)
7454
    {
7455
      /* If this is the first symbol to need a PLT entry, allocate room
7456
         for the header, and for the header's .rela.plt.unloaded entries.  */
7457
      if (htab->splt->size == 0)
7458
        {
7459
          htab->splt->size += htab->plt_header_size;
7460
          if (!info->shared)
7461
            htab->srelplt2->size += 2 * sizeof (Elf32_External_Rela);
7462
        }
7463
 
7464
      /* Assign the next .plt entry to this symbol.  */
7465
      h->plt.offset = htab->splt->size;
7466
      htab->splt->size += htab->plt_entry_size;
7467
 
7468
      /* If the output file has no definition of the symbol, set the
7469
         symbol's value to the address of the stub.  Point at the PLT
7470
         load stub rather than the lazy resolution stub; this stub
7471
         will become the canonical function address.  */
7472
      if (!info->shared && !h->def_regular)
7473
        {
7474
          h->root.u.def.section = htab->splt;
7475
          h->root.u.def.value = h->plt.offset;
7476
          h->root.u.def.value += 8;
7477
        }
7478
 
7479
      /* Make room for the .got.plt entry and the R_JUMP_SLOT relocation.  */
7480
      htab->sgotplt->size += 4;
7481
      htab->srelplt->size += sizeof (Elf32_External_Rela);
7482
 
7483
      /* Make room for the .rela.plt.unloaded relocations.  */
7484
      if (!info->shared)
7485
        htab->srelplt2->size += 3 * sizeof (Elf32_External_Rela);
7486
 
7487
      return TRUE;
7488
    }
7489
 
7490
  /* If a function symbol is defined by a dynamic object, and we do not
7491
     need a PLT stub for it, the symbol's value should be zero.  */
7492
  if (h->type == STT_FUNC
7493
      && h->def_dynamic
7494
      && h->ref_regular
7495
      && !h->def_regular)
7496
    {
7497
      h->root.u.def.value = 0;
7498
      return TRUE;
7499
    }
7500
 
7501
  /* If this is a weak symbol, and there is a real definition, the
7502
     processor independent code will have arranged for us to see the
7503
     real definition first, and we can just use the same value.  */
7504
  if (h->u.weakdef != NULL)
7505
    {
7506
      BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
7507
                  || h->u.weakdef->root.type == bfd_link_hash_defweak);
7508
      h->root.u.def.section = h->u.weakdef->root.u.def.section;
7509
      h->root.u.def.value = h->u.weakdef->root.u.def.value;
7510
      return TRUE;
7511
    }
7512
 
7513
  /* This is a reference to a symbol defined by a dynamic object which
7514
     is not a function.  */
7515
  if (info->shared)
7516
    return TRUE;
7517
 
7518
  /* We must allocate the symbol in our .dynbss section, which will
7519
     become part of the .bss section of the executable.  There will be
7520
     an entry for this symbol in the .dynsym section.  The dynamic
7521
     object will contain position independent code, so all references
7522
     from the dynamic object to this symbol will go through the global
7523
     offset table.  The dynamic linker will use the .dynsym entry to
7524
     determine the address it must put in the global offset table, so
7525
     both the dynamic object and the regular object will refer to the
7526
     same memory location for the variable.  */
7527
 
7528
  if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
7529
    {
7530
      htab->srelbss->size += sizeof (Elf32_External_Rela);
7531
      h->needs_copy = 1;
7532
    }
7533
 
7534
  return _bfd_elf_adjust_dynamic_copy (h, htab->sdynbss);
7535
}
7536
 
7537
/* Return the number of dynamic section symbols required by OUTPUT_BFD.
7538
   The number might be exact or a worst-case estimate, depending on how
7539
   much information is available to elf_backend_omit_section_dynsym at
7540
   the current linking stage.  */
7541
 
7542
static bfd_size_type
7543
count_section_dynsyms (bfd *output_bfd, struct bfd_link_info *info)
7544
{
7545
  bfd_size_type count;
7546
 
7547
  count = 0;
7548
  if (info->shared || elf_hash_table (info)->is_relocatable_executable)
7549
    {
7550
      asection *p;
7551
      const struct elf_backend_data *bed;
7552
 
7553
      bed = get_elf_backend_data (output_bfd);
7554
      for (p = output_bfd->sections; p ; p = p->next)
7555
        if ((p->flags & SEC_EXCLUDE) == 0
7556
            && (p->flags & SEC_ALLOC) != 0
7557
            && !(*bed->elf_backend_omit_section_dynsym) (output_bfd, info, p))
7558
          ++count;
7559
    }
7560
  return count;
7561
}
7562
 
7563
/* This function is called after all the input files have been read,
7564
   and the input sections have been assigned to output sections.  We
7565
   check for any mips16 stub sections that we can discard.  */
7566
 
7567
bfd_boolean
7568
_bfd_mips_elf_always_size_sections (bfd *output_bfd,
7569
                                    struct bfd_link_info *info)
7570
{
7571
  asection *ri;
7572
 
7573
  bfd *dynobj;
7574
  asection *s;
7575
  struct mips_got_info *g;
7576
  int i;
7577
  bfd_size_type loadable_size = 0;
7578
  bfd_size_type page_gotno;
7579
  bfd_size_type dynsymcount;
7580
  bfd *sub;
7581
  struct mips_elf_count_tls_arg count_tls_arg;
7582
  struct mips_elf_link_hash_table *htab;
7583
 
7584
  htab = mips_elf_hash_table (info);
7585
 
7586
  /* The .reginfo section has a fixed size.  */
7587
  ri = bfd_get_section_by_name (output_bfd, ".reginfo");
7588
  if (ri != NULL)
7589
    bfd_set_section_size (output_bfd, ri, sizeof (Elf32_External_RegInfo));
7590
 
7591
  if (! (info->relocatable
7592
         || ! mips_elf_hash_table (info)->mips16_stubs_seen))
7593
    mips_elf_link_hash_traverse (mips_elf_hash_table (info),
7594
                                 mips_elf_check_mips16_stubs, NULL);
7595
 
7596
  dynobj = elf_hash_table (info)->dynobj;
7597
  if (dynobj == NULL)
7598
    /* Relocatable links don't have it.  */
7599
    return TRUE;
7600
 
7601
  g = mips_elf_got_info (dynobj, &s);
7602
  if (s == NULL)
7603
    return TRUE;
7604
 
7605
  /* Calculate the total loadable size of the output.  That
7606
     will give us the maximum number of GOT_PAGE entries
7607
     required.  */
7608
  for (sub = info->input_bfds; sub; sub = sub->link_next)
7609
    {
7610
      asection *subsection;
7611
 
7612
      for (subsection = sub->sections;
7613
           subsection;
7614
           subsection = subsection->next)
7615
        {
7616
          if ((subsection->flags & SEC_ALLOC) == 0)
7617
            continue;
7618
          loadable_size += ((subsection->size + 0xf)
7619
                            &~ (bfd_size_type) 0xf);
7620
        }
7621
    }
7622
 
7623
  /* There has to be a global GOT entry for every symbol with
7624
     a dynamic symbol table index of DT_MIPS_GOTSYM or
7625
     higher.  Therefore, it make sense to put those symbols
7626
     that need GOT entries at the end of the symbol table.  We
7627
     do that here.  */
7628
  if (! mips_elf_sort_hash_table (info, 1))
7629
    return FALSE;
7630
 
7631
  if (g->global_gotsym != NULL)
7632
    i = elf_hash_table (info)->dynsymcount - g->global_gotsym->dynindx;
7633
  else
7634
    /* If there are no global symbols, or none requiring
7635
       relocations, then GLOBAL_GOTSYM will be NULL.  */
7636
    i = 0;
7637
 
7638
  /* Get a worst-case estimate of the number of dynamic symbols needed.
7639
     At this point, dynsymcount does not account for section symbols
7640
     and count_section_dynsyms may overestimate the number that will
7641
     be needed.  */
7642
  dynsymcount = (elf_hash_table (info)->dynsymcount
7643
                 + count_section_dynsyms (output_bfd, info));
7644
 
7645
  /* Determine the size of one stub entry.  */
7646
  htab->function_stub_size = (dynsymcount > 0x10000
7647
                              ? MIPS_FUNCTION_STUB_BIG_SIZE
7648
                              : MIPS_FUNCTION_STUB_NORMAL_SIZE);
7649
 
7650
  /* In the worst case, we'll get one stub per dynamic symbol, plus
7651
     one to account for the dummy entry at the end required by IRIX
7652
     rld.  */
7653
  loadable_size += htab->function_stub_size * (i + 1);
7654
 
7655
  if (htab->is_vxworks)
7656
    /* There's no need to allocate page entries for VxWorks; R_MIPS_GOT16
7657
       relocations against local symbols evaluate to "G", and the EABI does
7658
       not include R_MIPS_GOT_PAGE.  */
7659
    page_gotno = 0;
7660
  else
7661
    /* Assume there are two loadable segments consisting of contiguous
7662
       sections.  Is 5 enough?  */
7663
    page_gotno = (loadable_size >> 16) + 5;
7664
 
7665
  /* Choose the smaller of the two estimates; both are intended to be
7666
     conservative.  */
7667
  if (page_gotno > g->page_gotno)
7668
    page_gotno = g->page_gotno;
7669
 
7670
  g->local_gotno += page_gotno;
7671
  s->size += g->local_gotno * MIPS_ELF_GOT_SIZE (output_bfd);
7672
 
7673
  g->global_gotno = i;
7674
  s->size += i * MIPS_ELF_GOT_SIZE (output_bfd);
7675
 
7676
  /* We need to calculate tls_gotno for global symbols at this point
7677
     instead of building it up earlier, to avoid doublecounting
7678
     entries for one global symbol from multiple input files.  */
7679
  count_tls_arg.info = info;
7680
  count_tls_arg.needed = 0;
7681
  elf_link_hash_traverse (elf_hash_table (info),
7682
                          mips_elf_count_global_tls_entries,
7683
                          &count_tls_arg);
7684
  g->tls_gotno += count_tls_arg.needed;
7685
  s->size += g->tls_gotno * MIPS_ELF_GOT_SIZE (output_bfd);
7686
 
7687
  mips_elf_resolve_final_got_entries (g);
7688
 
7689
  /* VxWorks does not support multiple GOTs.  It initializes $gp to
7690
     __GOTT_BASE__[__GOTT_INDEX__], the value of which is set by the
7691
     dynamic loader.  */
7692
  if (!htab->is_vxworks && s->size > MIPS_ELF_GOT_MAX_SIZE (info))
7693
    {
7694
      if (! mips_elf_multi_got (output_bfd, info, g, s, page_gotno))
7695
        return FALSE;
7696
    }
7697
  else
7698
    {
7699
      /* Set up TLS entries for the first GOT.  */
7700
      g->tls_assigned_gotno = g->global_gotno + g->local_gotno;
7701
      htab_traverse (g->got_entries, mips_elf_initialize_tls_index, g);
7702
    }
7703
  htab->computed_got_sizes = TRUE;
7704
 
7705
  return TRUE;
7706
}
7707
 
7708
/* Set the sizes of the dynamic sections.  */
7709
 
7710
bfd_boolean
7711
_bfd_mips_elf_size_dynamic_sections (bfd *output_bfd,
7712
                                     struct bfd_link_info *info)
7713
{
7714
  bfd *dynobj;
7715
  asection *s, *sreldyn;
7716
  bfd_boolean reltext;
7717
  struct mips_elf_link_hash_table *htab;
7718
 
7719
  htab = mips_elf_hash_table (info);
7720
  dynobj = elf_hash_table (info)->dynobj;
7721
  BFD_ASSERT (dynobj != NULL);
7722
 
7723
  if (elf_hash_table (info)->dynamic_sections_created)
7724
    {
7725
      /* Set the contents of the .interp section to the interpreter.  */
7726
      if (info->executable)
7727
        {
7728
          s = bfd_get_section_by_name (dynobj, ".interp");
7729
          BFD_ASSERT (s != NULL);
7730
          s->size
7731
            = strlen (ELF_DYNAMIC_INTERPRETER (output_bfd)) + 1;
7732
          s->contents
7733
            = (bfd_byte *) ELF_DYNAMIC_INTERPRETER (output_bfd);
7734
        }
7735
    }
7736
 
7737
  /* The check_relocs and adjust_dynamic_symbol entry points have
7738
     determined the sizes of the various dynamic sections.  Allocate
7739
     memory for them.  */
7740
  reltext = FALSE;
7741
  sreldyn = NULL;
7742
  for (s = dynobj->sections; s != NULL; s = s->next)
7743
    {
7744
      const char *name;
7745
 
7746
      /* It's OK to base decisions on the section name, because none
7747
         of the dynobj section names depend upon the input files.  */
7748
      name = bfd_get_section_name (dynobj, s);
7749
 
7750
      if ((s->flags & SEC_LINKER_CREATED) == 0)
7751
        continue;
7752
 
7753
      if (CONST_STRNEQ (name, ".rel"))
7754
        {
7755
          if (s->size != 0)
7756
            {
7757
              const char *outname;
7758
              asection *target;
7759
 
7760
              /* If this relocation section applies to a read only
7761
                 section, then we probably need a DT_TEXTREL entry.
7762
                 If the relocation section is .rel(a).dyn, we always
7763
                 assert a DT_TEXTREL entry rather than testing whether
7764
                 there exists a relocation to a read only section or
7765
                 not.  */
7766
              outname = bfd_get_section_name (output_bfd,
7767
                                              s->output_section);
7768
              target = bfd_get_section_by_name (output_bfd, outname + 4);
7769
              if ((target != NULL
7770
                   && (target->flags & SEC_READONLY) != 0
7771
                   && (target->flags & SEC_ALLOC) != 0)
7772
                  || strcmp (outname, MIPS_ELF_REL_DYN_NAME (info)) == 0)
7773
                reltext = TRUE;
7774
 
7775
              /* We use the reloc_count field as a counter if we need
7776
                 to copy relocs into the output file.  */
7777
              if (strcmp (name, MIPS_ELF_REL_DYN_NAME (info)) != 0)
7778
                s->reloc_count = 0;
7779
 
7780
              /* If combreloc is enabled, elf_link_sort_relocs() will
7781
                 sort relocations, but in a different way than we do,
7782
                 and before we're done creating relocations.  Also, it
7783
                 will move them around between input sections'
7784
                 relocation's contents, so our sorting would be
7785
                 broken, so don't let it run.  */
7786
              info->combreloc = 0;
7787
            }
7788
        }
7789
      else if (htab->is_vxworks && strcmp (name, ".got") == 0)
7790
        {
7791
          /* Executables do not need a GOT.  */
7792
          if (info->shared)
7793
            {
7794
              /* Allocate relocations for all but the reserved entries.  */
7795
              struct mips_got_info *g;
7796
              unsigned int count;
7797
 
7798
              g = mips_elf_got_info (dynobj, NULL);
7799
              count = (g->global_gotno
7800
                       + g->local_gotno
7801
                       - MIPS_RESERVED_GOTNO (info));
7802
              mips_elf_allocate_dynamic_relocations (dynobj, info, count);
7803
            }
7804
        }
7805
      else if (!htab->is_vxworks && CONST_STRNEQ (name, ".got"))
7806
        {
7807
          /* _bfd_mips_elf_always_size_sections() has already done
7808
             most of the work, but some symbols may have been mapped
7809
             to versions that we must now resolve in the got_entries
7810
             hash tables.  */
7811
          struct mips_got_info *gg = mips_elf_got_info (dynobj, NULL);
7812
          struct mips_got_info *g = gg;
7813
          struct mips_elf_set_global_got_offset_arg set_got_offset_arg;
7814
          unsigned int needed_relocs = 0;
7815
 
7816
          if (gg->next)
7817
            {
7818
              set_got_offset_arg.value = MIPS_ELF_GOT_SIZE (output_bfd);
7819
              set_got_offset_arg.info = info;
7820
 
7821
              /* NOTE 2005-02-03: How can this call, or the next, ever
7822
                 find any indirect entries to resolve?  They were all
7823
                 resolved in mips_elf_multi_got.  */
7824
              mips_elf_resolve_final_got_entries (gg);
7825
              for (g = gg->next; g && g->next != gg; g = g->next)
7826
                {
7827
                  unsigned int save_assign;
7828
 
7829
                  mips_elf_resolve_final_got_entries (g);
7830
 
7831
                  /* Assign offsets to global GOT entries.  */
7832
                  save_assign = g->assigned_gotno;
7833
                  g->assigned_gotno = g->local_gotno;
7834
                  set_got_offset_arg.g = g;
7835
                  set_got_offset_arg.needed_relocs = 0;
7836
                  htab_traverse (g->got_entries,
7837
                                 mips_elf_set_global_got_offset,
7838
                                 &set_got_offset_arg);
7839
                  needed_relocs += set_got_offset_arg.needed_relocs;
7840
                  BFD_ASSERT (g->assigned_gotno - g->local_gotno
7841
                              <= g->global_gotno);
7842
 
7843
                  g->assigned_gotno = save_assign;
7844
                  if (info->shared)
7845
                    {
7846
                      needed_relocs += g->local_gotno - g->assigned_gotno;
7847
                      BFD_ASSERT (g->assigned_gotno == g->next->local_gotno
7848
                                  + g->next->global_gotno
7849
                                  + g->next->tls_gotno
7850
                                  + MIPS_RESERVED_GOTNO (info));
7851
                    }
7852
                }
7853
            }
7854
          else
7855
            {
7856
              struct mips_elf_count_tls_arg arg;
7857
              arg.info = info;
7858
              arg.needed = 0;
7859
 
7860
              htab_traverse (gg->got_entries, mips_elf_count_local_tls_relocs,
7861
                             &arg);
7862
              elf_link_hash_traverse (elf_hash_table (info),
7863
                                      mips_elf_count_global_tls_relocs,
7864
                                      &arg);
7865
 
7866
              needed_relocs += arg.needed;
7867
            }
7868
 
7869
          if (needed_relocs)
7870
            mips_elf_allocate_dynamic_relocations (dynobj, info,
7871
                                                   needed_relocs);
7872
        }
7873
      else if (strcmp (name, MIPS_ELF_STUB_SECTION_NAME (output_bfd)) == 0)
7874
        {
7875
          /* IRIX rld assumes that the function stub isn't at the end
7876
             of .text section.  So put a dummy.  XXX  */
7877
          s->size += htab->function_stub_size;
7878
        }
7879
      else if (! info->shared
7880
               && ! mips_elf_hash_table (info)->use_rld_obj_head
7881
               && CONST_STRNEQ (name, ".rld_map"))
7882
        {
7883
          /* We add a room for __rld_map.  It will be filled in by the
7884
             rtld to contain a pointer to the _r_debug structure.  */
7885
          s->size += 4;
7886
        }
7887
      else if (SGI_COMPAT (output_bfd)
7888
               && CONST_STRNEQ (name, ".compact_rel"))
7889
        s->size += mips_elf_hash_table (info)->compact_rel_size;
7890
      else if (! CONST_STRNEQ (name, ".init")
7891
               && s != htab->sgotplt
7892
               && s != htab->splt)
7893
        {
7894
          /* It's not one of our sections, so don't allocate space.  */
7895
          continue;
7896
        }
7897
 
7898
      if (s->size == 0)
7899
        {
7900
          s->flags |= SEC_EXCLUDE;
7901
          continue;
7902
        }
7903
 
7904
      if ((s->flags & SEC_HAS_CONTENTS) == 0)
7905
        continue;
7906
 
7907
      /* Allocate memory for this section last, since we may increase its
7908
         size above.  */
7909
      if (strcmp (name, MIPS_ELF_REL_DYN_NAME (info)) == 0)
7910
        {
7911
          sreldyn = s;
7912
          continue;
7913
        }
7914
 
7915
      /* Allocate memory for the section contents.  */
7916
      s->contents = bfd_zalloc (dynobj, s->size);
7917
      if (s->contents == NULL)
7918
        {
7919
          bfd_set_error (bfd_error_no_memory);
7920
          return FALSE;
7921
        }
7922
    }
7923
 
7924
  /* Allocate memory for the .rel(a).dyn section.  */
7925
  if (sreldyn != NULL)
7926
    {
7927
      sreldyn->contents = bfd_zalloc (dynobj, sreldyn->size);
7928
      if (sreldyn->contents == NULL)
7929
        {
7930
          bfd_set_error (bfd_error_no_memory);
7931
          return FALSE;
7932
        }
7933
    }
7934
 
7935
  if (elf_hash_table (info)->dynamic_sections_created)
7936
    {
7937
      /* Add some entries to the .dynamic section.  We fill in the
7938
         values later, in _bfd_mips_elf_finish_dynamic_sections, but we
7939
         must add the entries now so that we get the correct size for
7940
         the .dynamic section.  */
7941
 
7942
      /* SGI object has the equivalence of DT_DEBUG in the
7943
         DT_MIPS_RLD_MAP entry.  This must come first because glibc
7944
         only fills in DT_MIPS_RLD_MAP (not DT_DEBUG) and GDB only
7945
         looks at the first one it sees.  */
7946
      if (!info->shared
7947
          && !MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_RLD_MAP, 0))
7948
        return FALSE;
7949
 
7950
      /* The DT_DEBUG entry may be filled in by the dynamic linker and
7951
         used by the debugger.  */
7952
      if (info->executable
7953
          && !SGI_COMPAT (output_bfd)
7954
          && !MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_DEBUG, 0))
7955
        return FALSE;
7956
 
7957
      if (reltext && (SGI_COMPAT (output_bfd) || htab->is_vxworks))
7958
        info->flags |= DF_TEXTREL;
7959
 
7960
      if ((info->flags & DF_TEXTREL) != 0)
7961
        {
7962
          if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_TEXTREL, 0))
7963
            return FALSE;
7964
 
7965
          /* Clear the DF_TEXTREL flag.  It will be set again if we
7966
             write out an actual text relocation; we may not, because
7967
             at this point we do not know whether e.g. any .eh_frame
7968
             absolute relocations have been converted to PC-relative.  */
7969
          info->flags &= ~DF_TEXTREL;
7970
        }
7971
 
7972
      if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_PLTGOT, 0))
7973
        return FALSE;
7974
 
7975
      if (htab->is_vxworks)
7976
        {
7977
          /* VxWorks uses .rela.dyn instead of .rel.dyn.  It does not
7978
             use any of the DT_MIPS_* tags.  */
7979
          if (mips_elf_rel_dyn_section (info, FALSE))
7980
            {
7981
              if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_RELA, 0))
7982
                return FALSE;
7983
 
7984
              if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_RELASZ, 0))
7985
                return FALSE;
7986
 
7987
              if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_RELAENT, 0))
7988
                return FALSE;
7989
            }
7990
          if (htab->splt->size > 0)
7991
            {
7992
              if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_PLTREL, 0))
7993
                return FALSE;
7994
 
7995
              if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_JMPREL, 0))
7996
                return FALSE;
7997
 
7998
              if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_PLTRELSZ, 0))
7999
                return FALSE;
8000
            }
8001
        }
8002
      else
8003
        {
8004
          if (mips_elf_rel_dyn_section (info, FALSE))
8005
            {
8006
              if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_REL, 0))
8007
                return FALSE;
8008
 
8009
              if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_RELSZ, 0))
8010
                return FALSE;
8011
 
8012
              if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_RELENT, 0))
8013
                return FALSE;
8014
            }
8015
 
8016
          if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_RLD_VERSION, 0))
8017
            return FALSE;
8018
 
8019
          if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_FLAGS, 0))
8020
            return FALSE;
8021
 
8022
          if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_BASE_ADDRESS, 0))
8023
            return FALSE;
8024
 
8025
          if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_LOCAL_GOTNO, 0))
8026
            return FALSE;
8027
 
8028
          if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_SYMTABNO, 0))
8029
            return FALSE;
8030
 
8031
          if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_UNREFEXTNO, 0))
8032
            return FALSE;
8033
 
8034
          if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_GOTSYM, 0))
8035
            return FALSE;
8036
 
8037
          if (IRIX_COMPAT (dynobj) == ict_irix5
8038
              && ! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_HIPAGENO, 0))
8039
            return FALSE;
8040
 
8041
          if (IRIX_COMPAT (dynobj) == ict_irix6
8042
              && (bfd_get_section_by_name
8043
                  (dynobj, MIPS_ELF_OPTIONS_SECTION_NAME (dynobj)))
8044
              && !MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_OPTIONS, 0))
8045
            return FALSE;
8046
        }
8047
      if (htab->is_vxworks
8048
          && !elf_vxworks_add_dynamic_entries (output_bfd, info))
8049
        return FALSE;
8050
    }
8051
 
8052
  return TRUE;
8053
}
8054
 
8055
/* REL is a relocation in INPUT_BFD that is being copied to OUTPUT_BFD.
8056
   Adjust its R_ADDEND field so that it is correct for the output file.
8057
   LOCAL_SYMS and LOCAL_SECTIONS are arrays of INPUT_BFD's local symbols
8058
   and sections respectively; both use symbol indexes.  */
8059
 
8060
static void
8061
mips_elf_adjust_addend (bfd *output_bfd, struct bfd_link_info *info,
8062
                        bfd *input_bfd, Elf_Internal_Sym *local_syms,
8063
                        asection **local_sections, Elf_Internal_Rela *rel)
8064
{
8065
  unsigned int r_type, r_symndx;
8066
  Elf_Internal_Sym *sym;
8067
  asection *sec;
8068
 
8069
  if (mips_elf_local_relocation_p (input_bfd, rel, local_sections, FALSE))
8070
    {
8071
      r_type = ELF_R_TYPE (output_bfd, rel->r_info);
8072
      if (r_type == R_MIPS16_GPREL
8073
          || r_type == R_MIPS_GPREL16
8074
          || r_type == R_MIPS_GPREL32
8075
          || r_type == R_MIPS_LITERAL)
8076
        {
8077
          rel->r_addend += _bfd_get_gp_value (input_bfd);
8078
          rel->r_addend -= _bfd_get_gp_value (output_bfd);
8079
        }
8080
 
8081
      r_symndx = ELF_R_SYM (output_bfd, rel->r_info);
8082
      sym = local_syms + r_symndx;
8083
 
8084
      /* Adjust REL's addend to account for section merging.  */
8085
      if (!info->relocatable)
8086
        {
8087
          sec = local_sections[r_symndx];
8088
          _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
8089
        }
8090
 
8091
      /* This would normally be done by the rela_normal code in elflink.c.  */
8092
      if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
8093
        rel->r_addend += local_sections[r_symndx]->output_offset;
8094
    }
8095
}
8096
 
8097
/* Relocate a MIPS ELF section.  */
8098
 
8099
bfd_boolean
8100
_bfd_mips_elf_relocate_section (bfd *output_bfd, struct bfd_link_info *info,
8101
                                bfd *input_bfd, asection *input_section,
8102
                                bfd_byte *contents, Elf_Internal_Rela *relocs,
8103
                                Elf_Internal_Sym *local_syms,
8104
                                asection **local_sections)
8105
{
8106
  Elf_Internal_Rela *rel;
8107
  const Elf_Internal_Rela *relend;
8108
  bfd_vma addend = 0;
8109
  bfd_boolean use_saved_addend_p = FALSE;
8110
  const struct elf_backend_data *bed;
8111
 
8112
  bed = get_elf_backend_data (output_bfd);
8113
  relend = relocs + input_section->reloc_count * bed->s->int_rels_per_ext_rel;
8114
  for (rel = relocs; rel < relend; ++rel)
8115
    {
8116
      const char *name;
8117
      bfd_vma value = 0;
8118
      reloc_howto_type *howto;
8119
      bfd_boolean require_jalx;
8120
      /* TRUE if the relocation is a RELA relocation, rather than a
8121
         REL relocation.  */
8122
      bfd_boolean rela_relocation_p = TRUE;
8123
      unsigned int r_type = ELF_R_TYPE (output_bfd, rel->r_info);
8124
      const char *msg;
8125
      unsigned long r_symndx;
8126
      asection *sec;
8127
      Elf_Internal_Shdr *symtab_hdr;
8128
      struct elf_link_hash_entry *h;
8129
 
8130
      /* Find the relocation howto for this relocation.  */
8131
      howto = MIPS_ELF_RTYPE_TO_HOWTO (input_bfd, r_type,
8132
                                       NEWABI_P (input_bfd)
8133
                                       && (MIPS_RELOC_RELA_P
8134
                                           (input_bfd, input_section,
8135
                                            rel - relocs)));
8136
 
8137
      r_symndx = ELF_R_SYM (input_bfd, rel->r_info);
8138
      symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
8139
      if (mips_elf_local_relocation_p (input_bfd, rel, local_sections, FALSE))
8140
        {
8141
          sec = local_sections[r_symndx];
8142
          h = NULL;
8143
        }
8144
      else
8145
        {
8146
          unsigned long extsymoff;
8147
 
8148
          extsymoff = 0;
8149
          if (!elf_bad_symtab (input_bfd))
8150
            extsymoff = symtab_hdr->sh_info;
8151
          h = elf_sym_hashes (input_bfd) [r_symndx - extsymoff];
8152
          while (h->root.type == bfd_link_hash_indirect
8153
                 || h->root.type == bfd_link_hash_warning)
8154
            h = (struct elf_link_hash_entry *) h->root.u.i.link;
8155
 
8156
          sec = NULL;
8157
          if (h->root.type == bfd_link_hash_defined
8158
              || h->root.type == bfd_link_hash_defweak)
8159
            sec = h->root.u.def.section;
8160
        }
8161
 
8162
      if (sec != NULL && elf_discarded_section (sec))
8163
        {
8164
          /* For relocs against symbols from removed linkonce sections,
8165
             or sections discarded by a linker script, we just want the
8166
             section contents zeroed.  Avoid any special processing.  */
8167
          _bfd_clear_contents (howto, input_bfd, contents + rel->r_offset);
8168
          rel->r_info = 0;
8169
          rel->r_addend = 0;
8170
          continue;
8171
        }
8172
 
8173
      if (r_type == R_MIPS_64 && ! NEWABI_P (input_bfd))
8174
        {
8175
          /* Some 32-bit code uses R_MIPS_64.  In particular, people use
8176
             64-bit code, but make sure all their addresses are in the
8177
             lowermost or uppermost 32-bit section of the 64-bit address
8178
             space.  Thus, when they use an R_MIPS_64 they mean what is
8179
             usually meant by R_MIPS_32, with the exception that the
8180
             stored value is sign-extended to 64 bits.  */
8181
          howto = MIPS_ELF_RTYPE_TO_HOWTO (input_bfd, R_MIPS_32, FALSE);
8182
 
8183
          /* On big-endian systems, we need to lie about the position
8184
             of the reloc.  */
8185
          if (bfd_big_endian (input_bfd))
8186
            rel->r_offset += 4;
8187
        }
8188
 
8189
      if (!use_saved_addend_p)
8190
        {
8191
          /* If these relocations were originally of the REL variety,
8192
             we must pull the addend out of the field that will be
8193
             relocated.  Otherwise, we simply use the contents of the
8194
             RELA relocation.  */
8195
          if (mips_elf_rel_relocation_p (input_bfd, input_section,
8196
                                         relocs, rel))
8197
            {
8198
              rela_relocation_p = FALSE;
8199
              addend = mips_elf_read_rel_addend (input_bfd, rel,
8200
                                                 howto, contents);
8201
              if (r_type == R_MIPS_HI16
8202
                  || r_type == R_MIPS16_HI16
8203
                  || (r_type == R_MIPS_GOT16
8204
                      && mips_elf_local_relocation_p (input_bfd, rel,
8205
                                                      local_sections, FALSE)))
8206
                {
8207
                  if (!mips_elf_add_lo16_rel_addend (input_bfd, rel, relend,
8208
                                                     contents, &addend))
8209
                    {
8210
                      const char *name;
8211
 
8212
                      if (h)
8213
                        name = h->root.root.string;
8214
                      else
8215
                        name = bfd_elf_sym_name (input_bfd, symtab_hdr,
8216
                                                 local_syms + r_symndx,
8217
                                                 sec);
8218
                      (*_bfd_error_handler)
8219
                        (_("%B: Can't find matching LO16 reloc against `%s' for %s at 0x%lx in section `%A'"),
8220
                         input_bfd, input_section, name, howto->name,
8221
                         rel->r_offset);
8222
                    }
8223
                }
8224
              else
8225
                addend <<= howto->rightshift;
8226
            }
8227
          else
8228
            addend = rel->r_addend;
8229
          mips_elf_adjust_addend (output_bfd, info, input_bfd,
8230
                                  local_syms, local_sections, rel);
8231
        }
8232
 
8233
      if (info->relocatable)
8234
        {
8235
          if (r_type == R_MIPS_64 && ! NEWABI_P (output_bfd)
8236
              && bfd_big_endian (input_bfd))
8237
            rel->r_offset -= 4;
8238
 
8239
          if (!rela_relocation_p && rel->r_addend)
8240
            {
8241
              addend += rel->r_addend;
8242
              if (r_type == R_MIPS_HI16
8243
                  || r_type == R_MIPS_GOT16)
8244
                addend = mips_elf_high (addend);
8245
              else if (r_type == R_MIPS_HIGHER)
8246
                addend = mips_elf_higher (addend);
8247
              else if (r_type == R_MIPS_HIGHEST)
8248
                addend = mips_elf_highest (addend);
8249
              else
8250
                addend >>= howto->rightshift;
8251
 
8252
              /* We use the source mask, rather than the destination
8253
                 mask because the place to which we are writing will be
8254
                 source of the addend in the final link.  */
8255
              addend &= howto->src_mask;
8256
 
8257
              if (r_type == R_MIPS_64 && ! NEWABI_P (output_bfd))
8258
                /* See the comment above about using R_MIPS_64 in the 32-bit
8259
                   ABI.  Here, we need to update the addend.  It would be
8260
                   possible to get away with just using the R_MIPS_32 reloc
8261
                   but for endianness.  */
8262
                {
8263
                  bfd_vma sign_bits;
8264
                  bfd_vma low_bits;
8265
                  bfd_vma high_bits;
8266
 
8267
                  if (addend & ((bfd_vma) 1 << 31))
8268
#ifdef BFD64
8269
                    sign_bits = ((bfd_vma) 1 << 32) - 1;
8270
#else
8271
                    sign_bits = -1;
8272
#endif
8273
                  else
8274
                    sign_bits = 0;
8275
 
8276
                  /* If we don't know that we have a 64-bit type,
8277
                     do two separate stores.  */
8278
                  if (bfd_big_endian (input_bfd))
8279
                    {
8280
                      /* Store the sign-bits (which are most significant)
8281
                         first.  */
8282
                      low_bits = sign_bits;
8283
                      high_bits = addend;
8284
                    }
8285
                  else
8286
                    {
8287
                      low_bits = addend;
8288
                      high_bits = sign_bits;
8289
                    }
8290
                  bfd_put_32 (input_bfd, low_bits,
8291
                              contents + rel->r_offset);
8292
                  bfd_put_32 (input_bfd, high_bits,
8293
                              contents + rel->r_offset + 4);
8294
                  continue;
8295
                }
8296
 
8297
              if (! mips_elf_perform_relocation (info, howto, rel, addend,
8298
                                                 input_bfd, input_section,
8299
                                                 contents, FALSE))
8300
                return FALSE;
8301
            }
8302
 
8303
          /* Go on to the next relocation.  */
8304
          continue;
8305
        }
8306
 
8307
      /* In the N32 and 64-bit ABIs there may be multiple consecutive
8308
         relocations for the same offset.  In that case we are
8309
         supposed to treat the output of each relocation as the addend
8310
         for the next.  */
8311
      if (rel + 1 < relend
8312
          && rel->r_offset == rel[1].r_offset
8313
          && ELF_R_TYPE (input_bfd, rel[1].r_info) != R_MIPS_NONE)
8314
        use_saved_addend_p = TRUE;
8315
      else
8316
        use_saved_addend_p = FALSE;
8317
 
8318
      /* Figure out what value we are supposed to relocate.  */
8319
      switch (mips_elf_calculate_relocation (output_bfd, input_bfd,
8320
                                             input_section, info, rel,
8321
                                             addend, howto, local_syms,
8322
                                             local_sections, &value,
8323
                                             &name, &require_jalx,
8324
                                             use_saved_addend_p))
8325
        {
8326
        case bfd_reloc_continue:
8327
          /* There's nothing to do.  */
8328
          continue;
8329
 
8330
        case bfd_reloc_undefined:
8331
          /* mips_elf_calculate_relocation already called the
8332
             undefined_symbol callback.  There's no real point in
8333
             trying to perform the relocation at this point, so we
8334
             just skip ahead to the next relocation.  */
8335
          continue;
8336
 
8337
        case bfd_reloc_notsupported:
8338
          msg = _("internal error: unsupported relocation error");
8339
          info->callbacks->warning
8340
            (info, msg, name, input_bfd, input_section, rel->r_offset);
8341
          return FALSE;
8342
 
8343
        case bfd_reloc_overflow:
8344
          if (use_saved_addend_p)
8345
            /* Ignore overflow until we reach the last relocation for
8346
               a given location.  */
8347
            ;
8348
          else
8349
            {
8350
              struct mips_elf_link_hash_table *htab;
8351
 
8352
              htab = mips_elf_hash_table (info);
8353
              BFD_ASSERT (name != NULL);
8354
              if (!htab->small_data_overflow_reported
8355
                  && (howto->type == R_MIPS_GPREL16
8356
                      || howto->type == R_MIPS_LITERAL))
8357
                {
8358
                  const char *msg =
8359
                    _("small-data section exceeds 64KB;"
8360
                      " lower small-data size limit (see option -G)");
8361
 
8362
                  htab->small_data_overflow_reported = TRUE;
8363
                  (*info->callbacks->einfo) ("%P: %s\n", msg);
8364
                }
8365
              if (! ((*info->callbacks->reloc_overflow)
8366
                     (info, NULL, name, howto->name, (bfd_vma) 0,
8367
                      input_bfd, input_section, rel->r_offset)))
8368
                return FALSE;
8369
            }
8370
          break;
8371
 
8372
        case bfd_reloc_ok:
8373
          break;
8374
 
8375
        default:
8376
          abort ();
8377
          break;
8378
        }
8379
 
8380
      /* If we've got another relocation for the address, keep going
8381
         until we reach the last one.  */
8382
      if (use_saved_addend_p)
8383
        {
8384
          addend = value;
8385
          continue;
8386
        }
8387
 
8388
      if (r_type == R_MIPS_64 && ! NEWABI_P (output_bfd))
8389
        /* See the comment above about using R_MIPS_64 in the 32-bit
8390
           ABI.  Until now, we've been using the HOWTO for R_MIPS_32;
8391
           that calculated the right value.  Now, however, we
8392
           sign-extend the 32-bit result to 64-bits, and store it as a
8393
           64-bit value.  We are especially generous here in that we
8394
           go to extreme lengths to support this usage on systems with
8395
           only a 32-bit VMA.  */
8396
        {
8397
          bfd_vma sign_bits;
8398
          bfd_vma low_bits;
8399
          bfd_vma high_bits;
8400
 
8401
          if (value & ((bfd_vma) 1 << 31))
8402
#ifdef BFD64
8403
            sign_bits = ((bfd_vma) 1 << 32) - 1;
8404
#else
8405
            sign_bits = -1;
8406
#endif
8407
          else
8408
            sign_bits = 0;
8409
 
8410
          /* If we don't know that we have a 64-bit type,
8411
             do two separate stores.  */
8412
          if (bfd_big_endian (input_bfd))
8413
            {
8414
              /* Undo what we did above.  */
8415
              rel->r_offset -= 4;
8416
              /* Store the sign-bits (which are most significant)
8417
                 first.  */
8418
              low_bits = sign_bits;
8419
              high_bits = value;
8420
            }
8421
          else
8422
            {
8423
              low_bits = value;
8424
              high_bits = sign_bits;
8425
            }
8426
          bfd_put_32 (input_bfd, low_bits,
8427
                      contents + rel->r_offset);
8428
          bfd_put_32 (input_bfd, high_bits,
8429
                      contents + rel->r_offset + 4);
8430
          continue;
8431
        }
8432
 
8433
      /* Actually perform the relocation.  */
8434
      if (! mips_elf_perform_relocation (info, howto, rel, value,
8435
                                         input_bfd, input_section,
8436
                                         contents, require_jalx))
8437
        return FALSE;
8438
    }
8439
 
8440
  return TRUE;
8441
}
8442
 
8443
/* If NAME is one of the special IRIX6 symbols defined by the linker,
8444
   adjust it appropriately now.  */
8445
 
8446
static void
8447
mips_elf_irix6_finish_dynamic_symbol (bfd *abfd ATTRIBUTE_UNUSED,
8448
                                      const char *name, Elf_Internal_Sym *sym)
8449
{
8450
  /* The linker script takes care of providing names and values for
8451
     these, but we must place them into the right sections.  */
8452
  static const char* const text_section_symbols[] = {
8453
    "_ftext",
8454
    "_etext",
8455
    "__dso_displacement",
8456
    "__elf_header",
8457
    "__program_header_table",
8458
    NULL
8459
  };
8460
 
8461
  static const char* const data_section_symbols[] = {
8462
    "_fdata",
8463
    "_edata",
8464
    "_end",
8465
    "_fbss",
8466
    NULL
8467
  };
8468
 
8469
  const char* const *p;
8470
  int i;
8471
 
8472
  for (i = 0; i < 2; ++i)
8473
    for (p = (i == 0) ? text_section_symbols : data_section_symbols;
8474
         *p;
8475
         ++p)
8476
      if (strcmp (*p, name) == 0)
8477
        {
8478
          /* All of these symbols are given type STT_SECTION by the
8479
             IRIX6 linker.  */
8480
          sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
8481
          sym->st_other = STO_PROTECTED;
8482
 
8483
          /* The IRIX linker puts these symbols in special sections.  */
8484
          if (i == 0)
8485
            sym->st_shndx = SHN_MIPS_TEXT;
8486
          else
8487
            sym->st_shndx = SHN_MIPS_DATA;
8488
 
8489
          break;
8490
        }
8491
}
8492
 
8493
/* Finish up dynamic symbol handling.  We set the contents of various
8494
   dynamic sections here.  */
8495
 
8496
bfd_boolean
8497
_bfd_mips_elf_finish_dynamic_symbol (bfd *output_bfd,
8498
                                     struct bfd_link_info *info,
8499
                                     struct elf_link_hash_entry *h,
8500
                                     Elf_Internal_Sym *sym)
8501
{
8502
  bfd *dynobj;
8503
  asection *sgot;
8504
  struct mips_got_info *g, *gg;
8505
  const char *name;
8506
  int idx;
8507
  struct mips_elf_link_hash_table *htab;
8508
 
8509
  htab = mips_elf_hash_table (info);
8510
  dynobj = elf_hash_table (info)->dynobj;
8511
 
8512
  if (h->plt.offset != MINUS_ONE)
8513
    {
8514
      asection *s;
8515
      bfd_byte stub[MIPS_FUNCTION_STUB_BIG_SIZE];
8516
 
8517
      /* This symbol has a stub.  Set it up.  */
8518
 
8519
      BFD_ASSERT (h->dynindx != -1);
8520
 
8521
      s = bfd_get_section_by_name (dynobj,
8522
                                   MIPS_ELF_STUB_SECTION_NAME (dynobj));
8523
      BFD_ASSERT (s != NULL);
8524
 
8525
      BFD_ASSERT ((htab->function_stub_size == MIPS_FUNCTION_STUB_BIG_SIZE)
8526
                  || (h->dynindx <= 0xffff));
8527
 
8528
      /* Values up to 2^31 - 1 are allowed.  Larger values would cause
8529
         sign extension at runtime in the stub, resulting in a negative
8530
         index value.  */
8531
      if (h->dynindx & ~0x7fffffff)
8532
        return FALSE;
8533
 
8534
      /* Fill the stub.  */
8535
      idx = 0;
8536
      bfd_put_32 (output_bfd, STUB_LW (output_bfd), stub + idx);
8537
      idx += 4;
8538
      bfd_put_32 (output_bfd, STUB_MOVE (output_bfd), stub + idx);
8539
      idx += 4;
8540
      if (htab->function_stub_size == MIPS_FUNCTION_STUB_BIG_SIZE)
8541
        {
8542
          bfd_put_32 (output_bfd, STUB_LUI ((h->dynindx >> 16) & 0x7fff),
8543
                      stub + idx);
8544
          idx += 4;
8545
        }
8546
      bfd_put_32 (output_bfd, STUB_JALR, stub + idx);
8547
      idx += 4;
8548
 
8549
      /* If a large stub is not required and sign extension is not a
8550
         problem, then use legacy code in the stub.  */
8551
      if (htab->function_stub_size == MIPS_FUNCTION_STUB_BIG_SIZE)
8552
        bfd_put_32 (output_bfd, STUB_ORI (h->dynindx & 0xffff), stub + idx);
8553
      else if (h->dynindx & ~0x7fff)
8554
        bfd_put_32 (output_bfd, STUB_LI16U (h->dynindx & 0xffff), stub + idx);
8555
      else
8556
        bfd_put_32 (output_bfd, STUB_LI16S (output_bfd, h->dynindx),
8557
                    stub + idx);
8558
 
8559
      BFD_ASSERT (h->plt.offset <= s->size);
8560
      memcpy (s->contents + h->plt.offset, stub, htab->function_stub_size);
8561
 
8562
      /* Mark the symbol as undefined.  plt.offset != -1 occurs
8563
         only for the referenced symbol.  */
8564
      sym->st_shndx = SHN_UNDEF;
8565
 
8566
      /* The run-time linker uses the st_value field of the symbol
8567
         to reset the global offset table entry for this external
8568
         to its stub address when unlinking a shared object.  */
8569
      sym->st_value = (s->output_section->vma + s->output_offset
8570
                       + h->plt.offset);
8571
    }
8572
 
8573
  BFD_ASSERT (h->dynindx != -1
8574
              || h->forced_local);
8575
 
8576
  sgot = mips_elf_got_section (dynobj, FALSE);
8577
  BFD_ASSERT (sgot != NULL);
8578
  BFD_ASSERT (mips_elf_section_data (sgot) != NULL);
8579
  g = mips_elf_section_data (sgot)->u.got_info;
8580
  BFD_ASSERT (g != NULL);
8581
 
8582
  /* Run through the global symbol table, creating GOT entries for all
8583
     the symbols that need them.  */
8584
  if (g->global_gotsym != NULL
8585
      && h->dynindx >= g->global_gotsym->dynindx)
8586
    {
8587
      bfd_vma offset;
8588
      bfd_vma value;
8589
 
8590
      value = sym->st_value;
8591
      offset = mips_elf_global_got_index (dynobj, output_bfd, h, R_MIPS_GOT16, info);
8592
      MIPS_ELF_PUT_WORD (output_bfd, value, sgot->contents + offset);
8593
    }
8594
 
8595
  if (g->next && h->dynindx != -1 && h->type != STT_TLS)
8596
    {
8597
      struct mips_got_entry e, *p;
8598
      bfd_vma entry;
8599
      bfd_vma offset;
8600
 
8601
      gg = g;
8602
 
8603
      e.abfd = output_bfd;
8604
      e.symndx = -1;
8605
      e.d.h = (struct mips_elf_link_hash_entry *)h;
8606
      e.tls_type = 0;
8607
 
8608
      for (g = g->next; g->next != gg; g = g->next)
8609
        {
8610
          if (g->got_entries
8611
              && (p = (struct mips_got_entry *) htab_find (g->got_entries,
8612
                                                           &e)))
8613
            {
8614
              offset = p->gotidx;
8615
              if (info->shared
8616
                  || (elf_hash_table (info)->dynamic_sections_created
8617
                      && p->d.h != NULL
8618
                      && p->d.h->root.def_dynamic
8619
                      && !p->d.h->root.def_regular))
8620
                {
8621
                  /* Create an R_MIPS_REL32 relocation for this entry.  Due to
8622
                     the various compatibility problems, it's easier to mock
8623
                     up an R_MIPS_32 or R_MIPS_64 relocation and leave
8624
                     mips_elf_create_dynamic_relocation to calculate the
8625
                     appropriate addend.  */
8626
                  Elf_Internal_Rela rel[3];
8627
 
8628
                  memset (rel, 0, sizeof (rel));
8629
                  if (ABI_64_P (output_bfd))
8630
                    rel[0].r_info = ELF_R_INFO (output_bfd, 0, R_MIPS_64);
8631
                  else
8632
                    rel[0].r_info = ELF_R_INFO (output_bfd, 0, R_MIPS_32);
8633
                  rel[0].r_offset = rel[1].r_offset = rel[2].r_offset = offset;
8634
 
8635
                  entry = 0;
8636
                  if (! (mips_elf_create_dynamic_relocation
8637
                         (output_bfd, info, rel,
8638
                          e.d.h, NULL, sym->st_value, &entry, sgot)))
8639
                    return FALSE;
8640
                }
8641
              else
8642
                entry = sym->st_value;
8643
              MIPS_ELF_PUT_WORD (output_bfd, entry, sgot->contents + offset);
8644
            }
8645
        }
8646
    }
8647
 
8648
  /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute.  */
8649
  name = h->root.root.string;
8650
  if (strcmp (name, "_DYNAMIC") == 0
8651
      || h == elf_hash_table (info)->hgot)
8652
    sym->st_shndx = SHN_ABS;
8653
  else if (strcmp (name, "_DYNAMIC_LINK") == 0
8654
           || strcmp (name, "_DYNAMIC_LINKING") == 0)
8655
    {
8656
      sym->st_shndx = SHN_ABS;
8657
      sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
8658
      sym->st_value = 1;
8659
    }
8660
  else if (strcmp (name, "_gp_disp") == 0 && ! NEWABI_P (output_bfd))
8661
    {
8662
      sym->st_shndx = SHN_ABS;
8663
      sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
8664
      sym->st_value = elf_gp (output_bfd);
8665
    }
8666
  else if (SGI_COMPAT (output_bfd))
8667
    {
8668
      if (strcmp (name, mips_elf_dynsym_rtproc_names[0]) == 0
8669
          || strcmp (name, mips_elf_dynsym_rtproc_names[1]) == 0)
8670
        {
8671
          sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
8672
          sym->st_other = STO_PROTECTED;
8673
          sym->st_value = 0;
8674
          sym->st_shndx = SHN_MIPS_DATA;
8675
        }
8676
      else if (strcmp (name, mips_elf_dynsym_rtproc_names[2]) == 0)
8677
        {
8678
          sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
8679
          sym->st_other = STO_PROTECTED;
8680
          sym->st_value = mips_elf_hash_table (info)->procedure_count;
8681
          sym->st_shndx = SHN_ABS;
8682
        }
8683
      else if (sym->st_shndx != SHN_UNDEF && sym->st_shndx != SHN_ABS)
8684
        {
8685
          if (h->type == STT_FUNC)
8686
            sym->st_shndx = SHN_MIPS_TEXT;
8687
          else if (h->type == STT_OBJECT)
8688
            sym->st_shndx = SHN_MIPS_DATA;
8689
        }
8690
    }
8691
 
8692
  /* Handle the IRIX6-specific symbols.  */
8693
  if (IRIX_COMPAT (output_bfd) == ict_irix6)
8694
    mips_elf_irix6_finish_dynamic_symbol (output_bfd, name, sym);
8695
 
8696
  if (! info->shared)
8697
    {
8698
      if (! mips_elf_hash_table (info)->use_rld_obj_head
8699
          && (strcmp (name, "__rld_map") == 0
8700
              || strcmp (name, "__RLD_MAP") == 0))
8701
        {
8702
          asection *s = bfd_get_section_by_name (dynobj, ".rld_map");
8703
          BFD_ASSERT (s != NULL);
8704
          sym->st_value = s->output_section->vma + s->output_offset;
8705
          bfd_put_32 (output_bfd, 0, s->contents);
8706
          if (mips_elf_hash_table (info)->rld_value == 0)
8707
            mips_elf_hash_table (info)->rld_value = sym->st_value;
8708
        }
8709
      else if (mips_elf_hash_table (info)->use_rld_obj_head
8710
               && strcmp (name, "__rld_obj_head") == 0)
8711
        {
8712
          /* IRIX6 does not use a .rld_map section.  */
8713
          if (IRIX_COMPAT (output_bfd) == ict_irix5
8714
              || IRIX_COMPAT (output_bfd) == ict_none)
8715
            BFD_ASSERT (bfd_get_section_by_name (dynobj, ".rld_map")
8716
                        != NULL);
8717
          mips_elf_hash_table (info)->rld_value = sym->st_value;
8718
        }
8719
    }
8720
 
8721
  /* If this is a mips16 symbol, force the value to be even.  */
8722
  if (sym->st_other == STO_MIPS16)
8723
    sym->st_value &= ~1;
8724
 
8725
  return TRUE;
8726
}
8727
 
8728
/* Likewise, for VxWorks.  */
8729
 
8730
bfd_boolean
8731
_bfd_mips_vxworks_finish_dynamic_symbol (bfd *output_bfd,
8732
                                         struct bfd_link_info *info,
8733
                                         struct elf_link_hash_entry *h,
8734
                                         Elf_Internal_Sym *sym)
8735
{
8736
  bfd *dynobj;
8737
  asection *sgot;
8738
  struct mips_got_info *g;
8739
  struct mips_elf_link_hash_table *htab;
8740
 
8741
  htab = mips_elf_hash_table (info);
8742
  dynobj = elf_hash_table (info)->dynobj;
8743
 
8744
  if (h->plt.offset != (bfd_vma) -1)
8745
    {
8746
      bfd_byte *loc;
8747
      bfd_vma plt_address, plt_index, got_address, got_offset, branch_offset;
8748
      Elf_Internal_Rela rel;
8749
      static const bfd_vma *plt_entry;
8750
 
8751
      BFD_ASSERT (h->dynindx != -1);
8752
      BFD_ASSERT (htab->splt != NULL);
8753
      BFD_ASSERT (h->plt.offset <= htab->splt->size);
8754
 
8755
      /* Calculate the address of the .plt entry.  */
8756
      plt_address = (htab->splt->output_section->vma
8757
                     + htab->splt->output_offset
8758
                     + h->plt.offset);
8759
 
8760
      /* Calculate the index of the entry.  */
8761
      plt_index = ((h->plt.offset - htab->plt_header_size)
8762
                   / htab->plt_entry_size);
8763
 
8764
      /* Calculate the address of the .got.plt entry.  */
8765
      got_address = (htab->sgotplt->output_section->vma
8766
                     + htab->sgotplt->output_offset
8767
                     + plt_index * 4);
8768
 
8769
      /* Calculate the offset of the .got.plt entry from
8770
         _GLOBAL_OFFSET_TABLE_.  */
8771
      got_offset = mips_elf_gotplt_index (info, h);
8772
 
8773
      /* Calculate the offset for the branch at the start of the PLT
8774
         entry.  The branch jumps to the beginning of .plt.  */
8775
      branch_offset = -(h->plt.offset / 4 + 1) & 0xffff;
8776
 
8777
      /* Fill in the initial value of the .got.plt entry.  */
8778
      bfd_put_32 (output_bfd, plt_address,
8779
                  htab->sgotplt->contents + plt_index * 4);
8780
 
8781
      /* Find out where the .plt entry should go.  */
8782
      loc = htab->splt->contents + h->plt.offset;
8783
 
8784
      if (info->shared)
8785
        {
8786
          plt_entry = mips_vxworks_shared_plt_entry;
8787
          bfd_put_32 (output_bfd, plt_entry[0] | branch_offset, loc);
8788
          bfd_put_32 (output_bfd, plt_entry[1] | plt_index, loc + 4);
8789
        }
8790
      else
8791
        {
8792
          bfd_vma got_address_high, got_address_low;
8793
 
8794
          plt_entry = mips_vxworks_exec_plt_entry;
8795
          got_address_high = ((got_address + 0x8000) >> 16) & 0xffff;
8796
          got_address_low = got_address & 0xffff;
8797
 
8798
          bfd_put_32 (output_bfd, plt_entry[0] | branch_offset, loc);
8799
          bfd_put_32 (output_bfd, plt_entry[1] | plt_index, loc + 4);
8800
          bfd_put_32 (output_bfd, plt_entry[2] | got_address_high, loc + 8);
8801
          bfd_put_32 (output_bfd, plt_entry[3] | got_address_low, loc + 12);
8802
          bfd_put_32 (output_bfd, plt_entry[4], loc + 16);
8803
          bfd_put_32 (output_bfd, plt_entry[5], loc + 20);
8804
          bfd_put_32 (output_bfd, plt_entry[6], loc + 24);
8805
          bfd_put_32 (output_bfd, plt_entry[7], loc + 28);
8806
 
8807
          loc = (htab->srelplt2->contents
8808
                 + (plt_index * 3 + 2) * sizeof (Elf32_External_Rela));
8809
 
8810
          /* Emit a relocation for the .got.plt entry.  */
8811
          rel.r_offset = got_address;
8812
          rel.r_info = ELF32_R_INFO (htab->root.hplt->indx, R_MIPS_32);
8813
          rel.r_addend = h->plt.offset;
8814
          bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
8815
 
8816
          /* Emit a relocation for the lui of %hi(<.got.plt slot>).  */
8817
          loc += sizeof (Elf32_External_Rela);
8818
          rel.r_offset = plt_address + 8;
8819
          rel.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_MIPS_HI16);
8820
          rel.r_addend = got_offset;
8821
          bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
8822
 
8823
          /* Emit a relocation for the addiu of %lo(<.got.plt slot>).  */
8824
          loc += sizeof (Elf32_External_Rela);
8825
          rel.r_offset += 4;
8826
          rel.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_MIPS_LO16);
8827
          bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
8828
        }
8829
 
8830
      /* Emit an R_MIPS_JUMP_SLOT relocation against the .got.plt entry.  */
8831
      loc = htab->srelplt->contents + plt_index * sizeof (Elf32_External_Rela);
8832
      rel.r_offset = got_address;
8833
      rel.r_info = ELF32_R_INFO (h->dynindx, R_MIPS_JUMP_SLOT);
8834
      rel.r_addend = 0;
8835
      bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
8836
 
8837
      if (!h->def_regular)
8838
        sym->st_shndx = SHN_UNDEF;
8839
    }
8840
 
8841
  BFD_ASSERT (h->dynindx != -1 || h->forced_local);
8842
 
8843
  sgot = mips_elf_got_section (dynobj, FALSE);
8844
  BFD_ASSERT (sgot != NULL);
8845
  BFD_ASSERT (mips_elf_section_data (sgot) != NULL);
8846
  g = mips_elf_section_data (sgot)->u.got_info;
8847
  BFD_ASSERT (g != NULL);
8848
 
8849
  /* See if this symbol has an entry in the GOT.  */
8850
  if (g->global_gotsym != NULL
8851
      && h->dynindx >= g->global_gotsym->dynindx)
8852
    {
8853
      bfd_vma offset;
8854
      Elf_Internal_Rela outrel;
8855
      bfd_byte *loc;
8856
      asection *s;
8857
 
8858
      /* Install the symbol value in the GOT.   */
8859
      offset = mips_elf_global_got_index (dynobj, output_bfd, h,
8860
                                          R_MIPS_GOT16, info);
8861
      MIPS_ELF_PUT_WORD (output_bfd, sym->st_value, sgot->contents + offset);
8862
 
8863
      /* Add a dynamic relocation for it.  */
8864
      s = mips_elf_rel_dyn_section (info, FALSE);
8865
      loc = s->contents + (s->reloc_count++ * sizeof (Elf32_External_Rela));
8866
      outrel.r_offset = (sgot->output_section->vma
8867
                         + sgot->output_offset
8868
                         + offset);
8869
      outrel.r_info = ELF32_R_INFO (h->dynindx, R_MIPS_32);
8870
      outrel.r_addend = 0;
8871
      bfd_elf32_swap_reloca_out (dynobj, &outrel, loc);
8872
    }
8873
 
8874
  /* Emit a copy reloc, if needed.  */
8875
  if (h->needs_copy)
8876
    {
8877
      Elf_Internal_Rela rel;
8878
 
8879
      BFD_ASSERT (h->dynindx != -1);
8880
 
8881
      rel.r_offset = (h->root.u.def.section->output_section->vma
8882
                      + h->root.u.def.section->output_offset
8883
                      + h->root.u.def.value);
8884
      rel.r_info = ELF32_R_INFO (h->dynindx, R_MIPS_COPY);
8885
      rel.r_addend = 0;
8886
      bfd_elf32_swap_reloca_out (output_bfd, &rel,
8887
                                 htab->srelbss->contents
8888
                                 + (htab->srelbss->reloc_count
8889
                                    * sizeof (Elf32_External_Rela)));
8890
      ++htab->srelbss->reloc_count;
8891
    }
8892
 
8893
  /* If this is a mips16 symbol, force the value to be even.  */
8894
  if (sym->st_other == STO_MIPS16)
8895
    sym->st_value &= ~1;
8896
 
8897
  return TRUE;
8898
}
8899
 
8900
/* Install the PLT header for a VxWorks executable and finalize the
8901
   contents of .rela.plt.unloaded.  */
8902
 
8903
static void
8904
mips_vxworks_finish_exec_plt (bfd *output_bfd, struct bfd_link_info *info)
8905
{
8906
  Elf_Internal_Rela rela;
8907
  bfd_byte *loc;
8908
  bfd_vma got_value, got_value_high, got_value_low, plt_address;
8909
  static const bfd_vma *plt_entry;
8910
  struct mips_elf_link_hash_table *htab;
8911
 
8912
  htab = mips_elf_hash_table (info);
8913
  plt_entry = mips_vxworks_exec_plt0_entry;
8914
 
8915
  /* Calculate the value of _GLOBAL_OFFSET_TABLE_.  */
8916
  got_value = (htab->root.hgot->root.u.def.section->output_section->vma
8917
               + htab->root.hgot->root.u.def.section->output_offset
8918
               + htab->root.hgot->root.u.def.value);
8919
 
8920
  got_value_high = ((got_value + 0x8000) >> 16) & 0xffff;
8921
  got_value_low = got_value & 0xffff;
8922
 
8923
  /* Calculate the address of the PLT header.  */
8924
  plt_address = htab->splt->output_section->vma + htab->splt->output_offset;
8925
 
8926
  /* Install the PLT header.  */
8927
  loc = htab->splt->contents;
8928
  bfd_put_32 (output_bfd, plt_entry[0] | got_value_high, loc);
8929
  bfd_put_32 (output_bfd, plt_entry[1] | got_value_low, loc + 4);
8930
  bfd_put_32 (output_bfd, plt_entry[2], loc + 8);
8931
  bfd_put_32 (output_bfd, plt_entry[3], loc + 12);
8932
  bfd_put_32 (output_bfd, plt_entry[4], loc + 16);
8933
  bfd_put_32 (output_bfd, plt_entry[5], loc + 20);
8934
 
8935
  /* Output the relocation for the lui of %hi(_GLOBAL_OFFSET_TABLE_).  */
8936
  loc = htab->srelplt2->contents;
8937
  rela.r_offset = plt_address;
8938
  rela.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_MIPS_HI16);
8939
  rela.r_addend = 0;
8940
  bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
8941
  loc += sizeof (Elf32_External_Rela);
8942
 
8943
  /* Output the relocation for the following addiu of
8944
     %lo(_GLOBAL_OFFSET_TABLE_).  */
8945
  rela.r_offset += 4;
8946
  rela.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_MIPS_LO16);
8947
  bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
8948
  loc += sizeof (Elf32_External_Rela);
8949
 
8950
  /* Fix up the remaining relocations.  They may have the wrong
8951
     symbol index for _G_O_T_ or _P_L_T_ depending on the order
8952
     in which symbols were output.  */
8953
  while (loc < htab->srelplt2->contents + htab->srelplt2->size)
8954
    {
8955
      Elf_Internal_Rela rel;
8956
 
8957
      bfd_elf32_swap_reloca_in (output_bfd, loc, &rel);
8958
      rel.r_info = ELF32_R_INFO (htab->root.hplt->indx, R_MIPS_32);
8959
      bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
8960
      loc += sizeof (Elf32_External_Rela);
8961
 
8962
      bfd_elf32_swap_reloca_in (output_bfd, loc, &rel);
8963
      rel.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_MIPS_HI16);
8964
      bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
8965
      loc += sizeof (Elf32_External_Rela);
8966
 
8967
      bfd_elf32_swap_reloca_in (output_bfd, loc, &rel);
8968
      rel.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_MIPS_LO16);
8969
      bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
8970
      loc += sizeof (Elf32_External_Rela);
8971
    }
8972
}
8973
 
8974
/* Install the PLT header for a VxWorks shared library.  */
8975
 
8976
static void
8977
mips_vxworks_finish_shared_plt (bfd *output_bfd, struct bfd_link_info *info)
8978
{
8979
  unsigned int i;
8980
  struct mips_elf_link_hash_table *htab;
8981
 
8982
  htab = mips_elf_hash_table (info);
8983
 
8984
  /* We just need to copy the entry byte-by-byte.  */
8985
  for (i = 0; i < ARRAY_SIZE (mips_vxworks_shared_plt0_entry); i++)
8986
    bfd_put_32 (output_bfd, mips_vxworks_shared_plt0_entry[i],
8987
                htab->splt->contents + i * 4);
8988
}
8989
 
8990
/* Finish up the dynamic sections.  */
8991
 
8992
bfd_boolean
8993
_bfd_mips_elf_finish_dynamic_sections (bfd *output_bfd,
8994
                                       struct bfd_link_info *info)
8995
{
8996
  bfd *dynobj;
8997
  asection *sdyn;
8998
  asection *sgot;
8999
  struct mips_got_info *gg, *g;
9000
  struct mips_elf_link_hash_table *htab;
9001
 
9002
  htab = mips_elf_hash_table (info);
9003
  dynobj = elf_hash_table (info)->dynobj;
9004
 
9005
  sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
9006
 
9007
  sgot = mips_elf_got_section (dynobj, FALSE);
9008
  if (sgot == NULL)
9009
    gg = g = NULL;
9010
  else
9011
    {
9012
      BFD_ASSERT (mips_elf_section_data (sgot) != NULL);
9013
      gg = mips_elf_section_data (sgot)->u.got_info;
9014
      BFD_ASSERT (gg != NULL);
9015
      g = mips_elf_got_for_ibfd (gg, output_bfd);
9016
      BFD_ASSERT (g != NULL);
9017
    }
9018
 
9019
  if (elf_hash_table (info)->dynamic_sections_created)
9020
    {
9021
      bfd_byte *b;
9022
      int dyn_to_skip = 0, dyn_skipped = 0;
9023
 
9024
      BFD_ASSERT (sdyn != NULL);
9025
      BFD_ASSERT (g != NULL);
9026
 
9027
      for (b = sdyn->contents;
9028
           b < sdyn->contents + sdyn->size;
9029
           b += MIPS_ELF_DYN_SIZE (dynobj))
9030
        {
9031
          Elf_Internal_Dyn dyn;
9032
          const char *name;
9033
          size_t elemsize;
9034
          asection *s;
9035
          bfd_boolean swap_out_p;
9036
 
9037
          /* Read in the current dynamic entry.  */
9038
          (*get_elf_backend_data (dynobj)->s->swap_dyn_in) (dynobj, b, &dyn);
9039
 
9040
          /* Assume that we're going to modify it and write it out.  */
9041
          swap_out_p = TRUE;
9042
 
9043
          switch (dyn.d_tag)
9044
            {
9045
            case DT_RELENT:
9046
              dyn.d_un.d_val = MIPS_ELF_REL_SIZE (dynobj);
9047
              break;
9048
 
9049
            case DT_RELAENT:
9050
              BFD_ASSERT (htab->is_vxworks);
9051
              dyn.d_un.d_val = MIPS_ELF_RELA_SIZE (dynobj);
9052
              break;
9053
 
9054
            case DT_STRSZ:
9055
              /* Rewrite DT_STRSZ.  */
9056
              dyn.d_un.d_val =
9057
                _bfd_elf_strtab_size (elf_hash_table (info)->dynstr);
9058
              break;
9059
 
9060
            case DT_PLTGOT:
9061
              name = ".got";
9062
              if (htab->is_vxworks)
9063
                {
9064
                  /* _GLOBAL_OFFSET_TABLE_ is defined to be the beginning
9065
                     of the ".got" section in DYNOBJ.  */
9066
                  s = bfd_get_section_by_name (dynobj, name);
9067
                  BFD_ASSERT (s != NULL);
9068
                  dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
9069
                }
9070
              else
9071
                {
9072
                  s = bfd_get_section_by_name (output_bfd, name);
9073
                  BFD_ASSERT (s != NULL);
9074
                  dyn.d_un.d_ptr = s->vma;
9075
                }
9076
              break;
9077
 
9078
            case DT_MIPS_RLD_VERSION:
9079
              dyn.d_un.d_val = 1; /* XXX */
9080
              break;
9081
 
9082
            case DT_MIPS_FLAGS:
9083
              dyn.d_un.d_val = RHF_NOTPOT; /* XXX */
9084
              break;
9085
 
9086
            case DT_MIPS_TIME_STAMP:
9087
              {
9088
                time_t t;
9089
                time (&t);
9090
                dyn.d_un.d_val = t;
9091
              }
9092
              break;
9093
 
9094
            case DT_MIPS_ICHECKSUM:
9095
              /* XXX FIXME: */
9096
              swap_out_p = FALSE;
9097
              break;
9098
 
9099
            case DT_MIPS_IVERSION:
9100
              /* XXX FIXME: */
9101
              swap_out_p = FALSE;
9102
              break;
9103
 
9104
            case DT_MIPS_BASE_ADDRESS:
9105
              s = output_bfd->sections;
9106
              BFD_ASSERT (s != NULL);
9107
              dyn.d_un.d_ptr = s->vma & ~(bfd_vma) 0xffff;
9108
              break;
9109
 
9110
            case DT_MIPS_LOCAL_GOTNO:
9111
              dyn.d_un.d_val = g->local_gotno;
9112
              break;
9113
 
9114
            case DT_MIPS_UNREFEXTNO:
9115
              /* The index into the dynamic symbol table which is the
9116
                 entry of the first external symbol that is not
9117
                 referenced within the same object.  */
9118
              dyn.d_un.d_val = bfd_count_sections (output_bfd) + 1;
9119
              break;
9120
 
9121
            case DT_MIPS_GOTSYM:
9122
              if (gg->global_gotsym)
9123
                {
9124
                  dyn.d_un.d_val = gg->global_gotsym->dynindx;
9125
                  break;
9126
                }
9127
              /* In case if we don't have global got symbols we default
9128
                 to setting DT_MIPS_GOTSYM to the same value as
9129
                 DT_MIPS_SYMTABNO, so we just fall through.  */
9130
 
9131
            case DT_MIPS_SYMTABNO:
9132
              name = ".dynsym";
9133
              elemsize = MIPS_ELF_SYM_SIZE (output_bfd);
9134
              s = bfd_get_section_by_name (output_bfd, name);
9135
              BFD_ASSERT (s != NULL);
9136
 
9137
              dyn.d_un.d_val = s->size / elemsize;
9138
              break;
9139
 
9140
            case DT_MIPS_HIPAGENO:
9141
              dyn.d_un.d_val = g->local_gotno - MIPS_RESERVED_GOTNO (info);
9142
              break;
9143
 
9144
            case DT_MIPS_RLD_MAP:
9145
              dyn.d_un.d_ptr = mips_elf_hash_table (info)->rld_value;
9146
              break;
9147
 
9148
            case DT_MIPS_OPTIONS:
9149
              s = (bfd_get_section_by_name
9150
                   (output_bfd, MIPS_ELF_OPTIONS_SECTION_NAME (output_bfd)));
9151
              dyn.d_un.d_ptr = s->vma;
9152
              break;
9153
 
9154
            case DT_RELASZ:
9155
              BFD_ASSERT (htab->is_vxworks);
9156
              /* The count does not include the JUMP_SLOT relocations.  */
9157
              if (htab->srelplt)
9158
                dyn.d_un.d_val -= htab->srelplt->size;
9159
              break;
9160
 
9161
            case DT_PLTREL:
9162
              BFD_ASSERT (htab->is_vxworks);
9163
              dyn.d_un.d_val = DT_RELA;
9164
              break;
9165
 
9166
            case DT_PLTRELSZ:
9167
              BFD_ASSERT (htab->is_vxworks);
9168
              dyn.d_un.d_val = htab->srelplt->size;
9169
              break;
9170
 
9171
            case DT_JMPREL:
9172
              BFD_ASSERT (htab->is_vxworks);
9173
              dyn.d_un.d_val = (htab->srelplt->output_section->vma
9174
                                + htab->srelplt->output_offset);
9175
              break;
9176
 
9177
            case DT_TEXTREL:
9178
              /* If we didn't need any text relocations after all, delete
9179
                 the dynamic tag.  */
9180
              if (!(info->flags & DF_TEXTREL))
9181
                {
9182
                  dyn_to_skip = MIPS_ELF_DYN_SIZE (dynobj);
9183
                  swap_out_p = FALSE;
9184
                }
9185
              break;
9186
 
9187
            case DT_FLAGS:
9188
              /* If we didn't need any text relocations after all, clear
9189
                 DF_TEXTREL from DT_FLAGS.  */
9190
              if (!(info->flags & DF_TEXTREL))
9191
                dyn.d_un.d_val &= ~DF_TEXTREL;
9192
              else
9193
                swap_out_p = FALSE;
9194
              break;
9195
 
9196
            default:
9197
              swap_out_p = FALSE;
9198
              if (htab->is_vxworks
9199
                  && elf_vxworks_finish_dynamic_entry (output_bfd, &dyn))
9200
                swap_out_p = TRUE;
9201
              break;
9202
            }
9203
 
9204
          if (swap_out_p || dyn_skipped)
9205
            (*get_elf_backend_data (dynobj)->s->swap_dyn_out)
9206
              (dynobj, &dyn, b - dyn_skipped);
9207
 
9208
          if (dyn_to_skip)
9209
            {
9210
              dyn_skipped += dyn_to_skip;
9211
              dyn_to_skip = 0;
9212
            }
9213
        }
9214
 
9215
      /* Wipe out any trailing entries if we shifted down a dynamic tag.  */
9216
      if (dyn_skipped > 0)
9217
        memset (b - dyn_skipped, 0, dyn_skipped);
9218
    }
9219
 
9220
  if (sgot != NULL && sgot->size > 0
9221
      && !bfd_is_abs_section (sgot->output_section))
9222
    {
9223
      if (htab->is_vxworks)
9224
        {
9225
          /* The first entry of the global offset table points to the
9226
             ".dynamic" section.  The second is initialized by the
9227
             loader and contains the shared library identifier.
9228
             The third is also initialized by the loader and points
9229
             to the lazy resolution stub.  */
9230
          MIPS_ELF_PUT_WORD (output_bfd,
9231
                             sdyn->output_offset + sdyn->output_section->vma,
9232
                             sgot->contents);
9233
          MIPS_ELF_PUT_WORD (output_bfd, 0,
9234
                             sgot->contents + MIPS_ELF_GOT_SIZE (output_bfd));
9235
          MIPS_ELF_PUT_WORD (output_bfd, 0,
9236
                             sgot->contents
9237
                             + 2 * MIPS_ELF_GOT_SIZE (output_bfd));
9238
        }
9239
      else
9240
        {
9241
          /* The first entry of the global offset table will be filled at
9242
             runtime. The second entry will be used by some runtime loaders.
9243
             This isn't the case of IRIX rld.  */
9244
          MIPS_ELF_PUT_WORD (output_bfd, (bfd_vma) 0, sgot->contents);
9245
          MIPS_ELF_PUT_WORD (output_bfd, MIPS_ELF_GNU_GOT1_MASK (output_bfd),
9246
                             sgot->contents + MIPS_ELF_GOT_SIZE (output_bfd));
9247
        }
9248
 
9249
      elf_section_data (sgot->output_section)->this_hdr.sh_entsize
9250
         = MIPS_ELF_GOT_SIZE (output_bfd);
9251
    }
9252
 
9253
  /* Generate dynamic relocations for the non-primary gots.  */
9254
  if (gg != NULL && gg->next)
9255
    {
9256
      Elf_Internal_Rela rel[3];
9257
      bfd_vma addend = 0;
9258
 
9259
      memset (rel, 0, sizeof (rel));
9260
      rel[0].r_info = ELF_R_INFO (output_bfd, 0, R_MIPS_REL32);
9261
 
9262
      for (g = gg->next; g->next != gg; g = g->next)
9263
        {
9264
          bfd_vma index = g->next->local_gotno + g->next->global_gotno
9265
            + g->next->tls_gotno;
9266
 
9267
          MIPS_ELF_PUT_WORD (output_bfd, 0, sgot->contents
9268
                             + index++ * MIPS_ELF_GOT_SIZE (output_bfd));
9269
          MIPS_ELF_PUT_WORD (output_bfd, MIPS_ELF_GNU_GOT1_MASK (output_bfd),
9270
                             sgot->contents
9271
                             + index++ * MIPS_ELF_GOT_SIZE (output_bfd));
9272
 
9273
          if (! info->shared)
9274
            continue;
9275
 
9276
          while (index < g->assigned_gotno)
9277
            {
9278
              rel[0].r_offset = rel[1].r_offset = rel[2].r_offset
9279
                = index++ * MIPS_ELF_GOT_SIZE (output_bfd);
9280
              if (!(mips_elf_create_dynamic_relocation
9281
                    (output_bfd, info, rel, NULL,
9282
                     bfd_abs_section_ptr,
9283
                     0, &addend, sgot)))
9284
                return FALSE;
9285
              BFD_ASSERT (addend == 0);
9286
            }
9287
        }
9288
    }
9289
 
9290
  /* The generation of dynamic relocations for the non-primary gots
9291
     adds more dynamic relocations.  We cannot count them until
9292
     here.  */
9293
 
9294
  if (elf_hash_table (info)->dynamic_sections_created)
9295
    {
9296
      bfd_byte *b;
9297
      bfd_boolean swap_out_p;
9298
 
9299
      BFD_ASSERT (sdyn != NULL);
9300
 
9301
      for (b = sdyn->contents;
9302
           b < sdyn->contents + sdyn->size;
9303
           b += MIPS_ELF_DYN_SIZE (dynobj))
9304
        {
9305
          Elf_Internal_Dyn dyn;
9306
          asection *s;
9307
 
9308
          /* Read in the current dynamic entry.  */
9309
          (*get_elf_backend_data (dynobj)->s->swap_dyn_in) (dynobj, b, &dyn);
9310
 
9311
          /* Assume that we're going to modify it and write it out.  */
9312
          swap_out_p = TRUE;
9313
 
9314
          switch (dyn.d_tag)
9315
            {
9316
            case DT_RELSZ:
9317
              /* Reduce DT_RELSZ to account for any relocations we
9318
                 decided not to make.  This is for the n64 irix rld,
9319
                 which doesn't seem to apply any relocations if there
9320
                 are trailing null entries.  */
9321
              s = mips_elf_rel_dyn_section (info, FALSE);
9322
              dyn.d_un.d_val = (s->reloc_count
9323
                                * (ABI_64_P (output_bfd)
9324
                                   ? sizeof (Elf64_Mips_External_Rel)
9325
                                   : sizeof (Elf32_External_Rel)));
9326
              /* Adjust the section size too.  Tools like the prelinker
9327
                 can reasonably expect the values to the same.  */
9328
              elf_section_data (s->output_section)->this_hdr.sh_size
9329
                = dyn.d_un.d_val;
9330
              break;
9331
 
9332
            default:
9333
              swap_out_p = FALSE;
9334
              break;
9335
            }
9336
 
9337
          if (swap_out_p)
9338
            (*get_elf_backend_data (dynobj)->s->swap_dyn_out)
9339
              (dynobj, &dyn, b);
9340
        }
9341
    }
9342
 
9343
  {
9344
    asection *s;
9345
    Elf32_compact_rel cpt;
9346
 
9347
    if (SGI_COMPAT (output_bfd))
9348
      {
9349
        /* Write .compact_rel section out.  */
9350
        s = bfd_get_section_by_name (dynobj, ".compact_rel");
9351
        if (s != NULL)
9352
          {
9353
            cpt.id1 = 1;
9354
            cpt.num = s->reloc_count;
9355
            cpt.id2 = 2;
9356
            cpt.offset = (s->output_section->filepos
9357
                          + sizeof (Elf32_External_compact_rel));
9358
            cpt.reserved0 = 0;
9359
            cpt.reserved1 = 0;
9360
            bfd_elf32_swap_compact_rel_out (output_bfd, &cpt,
9361
                                            ((Elf32_External_compact_rel *)
9362
                                             s->contents));
9363
 
9364
            /* Clean up a dummy stub function entry in .text.  */
9365
            s = bfd_get_section_by_name (dynobj,
9366
                                         MIPS_ELF_STUB_SECTION_NAME (dynobj));
9367
            if (s != NULL)
9368
              {
9369
                file_ptr dummy_offset;
9370
 
9371
                BFD_ASSERT (s->size >= htab->function_stub_size);
9372
                dummy_offset = s->size - htab->function_stub_size;
9373
                memset (s->contents + dummy_offset, 0,
9374
                        htab->function_stub_size);
9375
              }
9376
          }
9377
      }
9378
 
9379
    /* The psABI says that the dynamic relocations must be sorted in
9380
       increasing order of r_symndx.  The VxWorks EABI doesn't require
9381
       this, and because the code below handles REL rather than RELA
9382
       relocations, using it for VxWorks would be outright harmful.  */
9383
    if (!htab->is_vxworks)
9384
      {
9385
        s = mips_elf_rel_dyn_section (info, FALSE);
9386
        if (s != NULL
9387
            && s->size > (bfd_vma)2 * MIPS_ELF_REL_SIZE (output_bfd))
9388
          {
9389
            reldyn_sorting_bfd = output_bfd;
9390
 
9391
            if (ABI_64_P (output_bfd))
9392
              qsort ((Elf64_External_Rel *) s->contents + 1,
9393
                     s->reloc_count - 1, sizeof (Elf64_Mips_External_Rel),
9394
                     sort_dynamic_relocs_64);
9395
            else
9396
              qsort ((Elf32_External_Rel *) s->contents + 1,
9397
                     s->reloc_count - 1, sizeof (Elf32_External_Rel),
9398
                     sort_dynamic_relocs);
9399
          }
9400
      }
9401
  }
9402
 
9403
  if (htab->is_vxworks && htab->splt->size > 0)
9404
    {
9405
      if (info->shared)
9406
        mips_vxworks_finish_shared_plt (output_bfd, info);
9407
      else
9408
        mips_vxworks_finish_exec_plt (output_bfd, info);
9409
    }
9410
  return TRUE;
9411
}
9412
 
9413
 
9414
/* Set ABFD's EF_MIPS_ARCH and EF_MIPS_MACH flags.  */
9415
 
9416
static void
9417
mips_set_isa_flags (bfd *abfd)
9418
{
9419
  flagword val;
9420
 
9421
  switch (bfd_get_mach (abfd))
9422
    {
9423
    default:
9424
    case bfd_mach_mips3000:
9425
      val = E_MIPS_ARCH_1;
9426
      break;
9427
 
9428
    case bfd_mach_mips3900:
9429
      val = E_MIPS_ARCH_1 | E_MIPS_MACH_3900;
9430
      break;
9431
 
9432
    case bfd_mach_mips6000:
9433
      val = E_MIPS_ARCH_2;
9434
      break;
9435
 
9436
    case bfd_mach_mips4000:
9437
    case bfd_mach_mips4300:
9438
    case bfd_mach_mips4400:
9439
    case bfd_mach_mips4600:
9440
      val = E_MIPS_ARCH_3;
9441
      break;
9442
 
9443
    case bfd_mach_mips4010:
9444
      val = E_MIPS_ARCH_3 | E_MIPS_MACH_4010;
9445
      break;
9446
 
9447
    case bfd_mach_mips4100:
9448
      val = E_MIPS_ARCH_3 | E_MIPS_MACH_4100;
9449
      break;
9450
 
9451
    case bfd_mach_mips4111:
9452
      val = E_MIPS_ARCH_3 | E_MIPS_MACH_4111;
9453
      break;
9454
 
9455
    case bfd_mach_mips4120:
9456
      val = E_MIPS_ARCH_3 | E_MIPS_MACH_4120;
9457
      break;
9458
 
9459
    case bfd_mach_mips4650:
9460
      val = E_MIPS_ARCH_3 | E_MIPS_MACH_4650;
9461
      break;
9462
 
9463
    case bfd_mach_mips5400:
9464
      val = E_MIPS_ARCH_4 | E_MIPS_MACH_5400;
9465
      break;
9466
 
9467
    case bfd_mach_mips5500:
9468
      val = E_MIPS_ARCH_4 | E_MIPS_MACH_5500;
9469
      break;
9470
 
9471
    case bfd_mach_mips9000:
9472
      val = E_MIPS_ARCH_4 | E_MIPS_MACH_9000;
9473
      break;
9474
 
9475
    case bfd_mach_mips5000:
9476
    case bfd_mach_mips7000:
9477
    case bfd_mach_mips8000:
9478
    case bfd_mach_mips10000:
9479
    case bfd_mach_mips12000:
9480
      val = E_MIPS_ARCH_4;
9481
      break;
9482
 
9483
    case bfd_mach_mips5:
9484
      val = E_MIPS_ARCH_5;
9485
      break;
9486
 
9487
    case bfd_mach_mips_loongson_2e:
9488
      val = E_MIPS_ARCH_3 | E_MIPS_MACH_LS2E;
9489
      break;
9490
 
9491
    case bfd_mach_mips_loongson_2f:
9492
      val = E_MIPS_ARCH_3 | E_MIPS_MACH_LS2F;
9493
      break;
9494
 
9495
    case bfd_mach_mips_sb1:
9496
      val = E_MIPS_ARCH_64 | E_MIPS_MACH_SB1;
9497
      break;
9498
 
9499
    case bfd_mach_mips_octeon:
9500
      val = E_MIPS_ARCH_64R2 | E_MIPS_MACH_OCTEON;
9501
      break;
9502
 
9503
    case bfd_mach_mipsisa32:
9504
      val = E_MIPS_ARCH_32;
9505
      break;
9506
 
9507
    case bfd_mach_mipsisa64:
9508
      val = E_MIPS_ARCH_64;
9509
      break;
9510
 
9511
    case bfd_mach_mipsisa32r2:
9512
      val = E_MIPS_ARCH_32R2;
9513
      break;
9514
 
9515
    case bfd_mach_mipsisa64r2:
9516
      val = E_MIPS_ARCH_64R2;
9517
      break;
9518
    }
9519
  elf_elfheader (abfd)->e_flags &= ~(EF_MIPS_ARCH | EF_MIPS_MACH);
9520
  elf_elfheader (abfd)->e_flags |= val;
9521
 
9522
}
9523
 
9524
 
9525
/* The final processing done just before writing out a MIPS ELF object
9526
   file.  This gets the MIPS architecture right based on the machine
9527
   number.  This is used by both the 32-bit and the 64-bit ABI.  */
9528
 
9529
void
9530
_bfd_mips_elf_final_write_processing (bfd *abfd,
9531
                                      bfd_boolean linker ATTRIBUTE_UNUSED)
9532
{
9533
  unsigned int i;
9534
  Elf_Internal_Shdr **hdrpp;
9535
  const char *name;
9536
  asection *sec;
9537
 
9538
  /* Keep the existing EF_MIPS_MACH and EF_MIPS_ARCH flags if the former
9539
     is nonzero.  This is for compatibility with old objects, which used
9540
     a combination of a 32-bit EF_MIPS_ARCH and a 64-bit EF_MIPS_MACH.  */
9541
  if ((elf_elfheader (abfd)->e_flags & EF_MIPS_MACH) == 0)
9542
    mips_set_isa_flags (abfd);
9543
 
9544
  /* Set the sh_info field for .gptab sections and other appropriate
9545
     info for each special section.  */
9546
  for (i = 1, hdrpp = elf_elfsections (abfd) + 1;
9547
       i < elf_numsections (abfd);
9548
       i++, hdrpp++)
9549
    {
9550
      switch ((*hdrpp)->sh_type)
9551
        {
9552
        case SHT_MIPS_MSYM:
9553
        case SHT_MIPS_LIBLIST:
9554
          sec = bfd_get_section_by_name (abfd, ".dynstr");
9555
          if (sec != NULL)
9556
            (*hdrpp)->sh_link = elf_section_data (sec)->this_idx;
9557
          break;
9558
 
9559
        case SHT_MIPS_GPTAB:
9560
          BFD_ASSERT ((*hdrpp)->bfd_section != NULL);
9561
          name = bfd_get_section_name (abfd, (*hdrpp)->bfd_section);
9562
          BFD_ASSERT (name != NULL
9563
                      && CONST_STRNEQ (name, ".gptab."));
9564
          sec = bfd_get_section_by_name (abfd, name + sizeof ".gptab" - 1);
9565
          BFD_ASSERT (sec != NULL);
9566
          (*hdrpp)->sh_info = elf_section_data (sec)->this_idx;
9567
          break;
9568
 
9569
        case SHT_MIPS_CONTENT:
9570
          BFD_ASSERT ((*hdrpp)->bfd_section != NULL);
9571
          name = bfd_get_section_name (abfd, (*hdrpp)->bfd_section);
9572
          BFD_ASSERT (name != NULL
9573
                      && CONST_STRNEQ (name, ".MIPS.content"));
9574
          sec = bfd_get_section_by_name (abfd,
9575
                                         name + sizeof ".MIPS.content" - 1);
9576
          BFD_ASSERT (sec != NULL);
9577
          (*hdrpp)->sh_link = elf_section_data (sec)->this_idx;
9578
          break;
9579
 
9580
        case SHT_MIPS_SYMBOL_LIB:
9581
          sec = bfd_get_section_by_name (abfd, ".dynsym");
9582
          if (sec != NULL)
9583
            (*hdrpp)->sh_link = elf_section_data (sec)->this_idx;
9584
          sec = bfd_get_section_by_name (abfd, ".liblist");
9585
          if (sec != NULL)
9586
            (*hdrpp)->sh_info = elf_section_data (sec)->this_idx;
9587
          break;
9588
 
9589
        case SHT_MIPS_EVENTS:
9590
          BFD_ASSERT ((*hdrpp)->bfd_section != NULL);
9591
          name = bfd_get_section_name (abfd, (*hdrpp)->bfd_section);
9592
          BFD_ASSERT (name != NULL);
9593
          if (CONST_STRNEQ (name, ".MIPS.events"))
9594
            sec = bfd_get_section_by_name (abfd,
9595
                                           name + sizeof ".MIPS.events" - 1);
9596
          else
9597
            {
9598
              BFD_ASSERT (CONST_STRNEQ (name, ".MIPS.post_rel"));
9599
              sec = bfd_get_section_by_name (abfd,
9600
                                             (name
9601
                                              + sizeof ".MIPS.post_rel" - 1));
9602
            }
9603
          BFD_ASSERT (sec != NULL);
9604
          (*hdrpp)->sh_link = elf_section_data (sec)->this_idx;
9605
          break;
9606
 
9607
        }
9608
    }
9609
}
9610
 
9611
/* When creating an IRIX5 executable, we need REGINFO and RTPROC
9612
   segments.  */
9613
 
9614
int
9615
_bfd_mips_elf_additional_program_headers (bfd *abfd,
9616
                                          struct bfd_link_info *info ATTRIBUTE_UNUSED)
9617
{
9618
  asection *s;
9619
  int ret = 0;
9620
 
9621
  /* See if we need a PT_MIPS_REGINFO segment.  */
9622
  s = bfd_get_section_by_name (abfd, ".reginfo");
9623
  if (s && (s->flags & SEC_LOAD))
9624
    ++ret;
9625
 
9626
  /* See if we need a PT_MIPS_OPTIONS segment.  */
9627
  if (IRIX_COMPAT (abfd) == ict_irix6
9628
      && bfd_get_section_by_name (abfd,
9629
                                  MIPS_ELF_OPTIONS_SECTION_NAME (abfd)))
9630
    ++ret;
9631
 
9632
  /* See if we need a PT_MIPS_RTPROC segment.  */
9633
  if (IRIX_COMPAT (abfd) == ict_irix5
9634
      && bfd_get_section_by_name (abfd, ".dynamic")
9635
      && bfd_get_section_by_name (abfd, ".mdebug"))
9636
    ++ret;
9637
 
9638
  /* Allocate a PT_NULL header in dynamic objects.  See
9639
     _bfd_mips_elf_modify_segment_map for details.  */
9640
  if (!SGI_COMPAT (abfd)
9641
      && bfd_get_section_by_name (abfd, ".dynamic"))
9642
    ++ret;
9643
 
9644
  return ret;
9645
}
9646
 
9647
/* Modify the segment map for an IRIX5 executable.  */
9648
 
9649
bfd_boolean
9650
_bfd_mips_elf_modify_segment_map (bfd *abfd,
9651
                                  struct bfd_link_info *info)
9652
{
9653
  asection *s;
9654
  struct elf_segment_map *m, **pm;
9655
  bfd_size_type amt;
9656
 
9657
  /* If there is a .reginfo section, we need a PT_MIPS_REGINFO
9658
     segment.  */
9659
  s = bfd_get_section_by_name (abfd, ".reginfo");
9660
  if (s != NULL && (s->flags & SEC_LOAD) != 0)
9661
    {
9662
      for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
9663
        if (m->p_type == PT_MIPS_REGINFO)
9664
          break;
9665
      if (m == NULL)
9666
        {
9667
          amt = sizeof *m;
9668
          m = bfd_zalloc (abfd, amt);
9669
          if (m == NULL)
9670
            return FALSE;
9671
 
9672
          m->p_type = PT_MIPS_REGINFO;
9673
          m->count = 1;
9674
          m->sections[0] = s;
9675
 
9676
          /* We want to put it after the PHDR and INTERP segments.  */
9677
          pm = &elf_tdata (abfd)->segment_map;
9678
          while (*pm != NULL
9679
                 && ((*pm)->p_type == PT_PHDR
9680
                     || (*pm)->p_type == PT_INTERP))
9681
            pm = &(*pm)->next;
9682
 
9683
          m->next = *pm;
9684
          *pm = m;
9685
        }
9686
    }
9687
 
9688
  /* For IRIX 6, we don't have .mdebug sections, nor does anything but
9689
     .dynamic end up in PT_DYNAMIC.  However, we do have to insert a
9690
     PT_MIPS_OPTIONS segment immediately following the program header
9691
     table.  */
9692
  if (NEWABI_P (abfd)
9693
      /* On non-IRIX6 new abi, we'll have already created a segment
9694
         for this section, so don't create another.  I'm not sure this
9695
         is not also the case for IRIX 6, but I can't test it right
9696
         now.  */
9697
      && IRIX_COMPAT (abfd) == ict_irix6)
9698
    {
9699
      for (s = abfd->sections; s; s = s->next)
9700
        if (elf_section_data (s)->this_hdr.sh_type == SHT_MIPS_OPTIONS)
9701
          break;
9702
 
9703
      if (s)
9704
        {
9705
          struct elf_segment_map *options_segment;
9706
 
9707
          pm = &elf_tdata (abfd)->segment_map;
9708
          while (*pm != NULL
9709
                 && ((*pm)->p_type == PT_PHDR
9710
                     || (*pm)->p_type == PT_INTERP))
9711
            pm = &(*pm)->next;
9712
 
9713
          if (*pm == NULL || (*pm)->p_type != PT_MIPS_OPTIONS)
9714
            {
9715
              amt = sizeof (struct elf_segment_map);
9716
              options_segment = bfd_zalloc (abfd, amt);
9717
              options_segment->next = *pm;
9718
              options_segment->p_type = PT_MIPS_OPTIONS;
9719
              options_segment->p_flags = PF_R;
9720
              options_segment->p_flags_valid = TRUE;
9721
              options_segment->count = 1;
9722
              options_segment->sections[0] = s;
9723
              *pm = options_segment;
9724
            }
9725
        }
9726
    }
9727
  else
9728
    {
9729
      if (IRIX_COMPAT (abfd) == ict_irix5)
9730
        {
9731
          /* If there are .dynamic and .mdebug sections, we make a room
9732
             for the RTPROC header.  FIXME: Rewrite without section names.  */
9733
          if (bfd_get_section_by_name (abfd, ".interp") == NULL
9734
              && bfd_get_section_by_name (abfd, ".dynamic") != NULL
9735
              && bfd_get_section_by_name (abfd, ".mdebug") != NULL)
9736
            {
9737
              for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
9738
                if (m->p_type == PT_MIPS_RTPROC)
9739
                  break;
9740
              if (m == NULL)
9741
                {
9742
                  amt = sizeof *m;
9743
                  m = bfd_zalloc (abfd, amt);
9744
                  if (m == NULL)
9745
                    return FALSE;
9746
 
9747
                  m->p_type = PT_MIPS_RTPROC;
9748
 
9749
                  s = bfd_get_section_by_name (abfd, ".rtproc");
9750
                  if (s == NULL)
9751
                    {
9752
                      m->count = 0;
9753
                      m->p_flags = 0;
9754
                      m->p_flags_valid = 1;
9755
                    }
9756
                  else
9757
                    {
9758
                      m->count = 1;
9759
                      m->sections[0] = s;
9760
                    }
9761
 
9762
                  /* We want to put it after the DYNAMIC segment.  */
9763
                  pm = &elf_tdata (abfd)->segment_map;
9764
                  while (*pm != NULL && (*pm)->p_type != PT_DYNAMIC)
9765
                    pm = &(*pm)->next;
9766
                  if (*pm != NULL)
9767
                    pm = &(*pm)->next;
9768
 
9769
                  m->next = *pm;
9770
                  *pm = m;
9771
                }
9772
            }
9773
        }
9774
      /* On IRIX5, the PT_DYNAMIC segment includes the .dynamic,
9775
         .dynstr, .dynsym, and .hash sections, and everything in
9776
         between.  */
9777
      for (pm = &elf_tdata (abfd)->segment_map; *pm != NULL;
9778
           pm = &(*pm)->next)
9779
        if ((*pm)->p_type == PT_DYNAMIC)
9780
          break;
9781
      m = *pm;
9782
      if (m != NULL && IRIX_COMPAT (abfd) == ict_none)
9783
        {
9784
          /* For a normal mips executable the permissions for the PT_DYNAMIC
9785
             segment are read, write and execute. We do that here since
9786
             the code in elf.c sets only the read permission. This matters
9787
             sometimes for the dynamic linker.  */
9788
          if (bfd_get_section_by_name (abfd, ".dynamic") != NULL)
9789
            {
9790
              m->p_flags = PF_R | PF_W | PF_X;
9791
              m->p_flags_valid = 1;
9792
            }
9793
        }
9794
      /* GNU/Linux binaries do not need the extended PT_DYNAMIC section.
9795
         glibc's dynamic linker has traditionally derived the number of
9796
         tags from the p_filesz field, and sometimes allocates stack
9797
         arrays of that size.  An overly-big PT_DYNAMIC segment can
9798
         be actively harmful in such cases.  Making PT_DYNAMIC contain
9799
         other sections can also make life hard for the prelinker,
9800
         which might move one of the other sections to a different
9801
         PT_LOAD segment.  */
9802
      if (SGI_COMPAT (abfd)
9803
          && m != NULL
9804
          && m->count == 1
9805
          && strcmp (m->sections[0]->name, ".dynamic") == 0)
9806
        {
9807
          static const char *sec_names[] =
9808
          {
9809
            ".dynamic", ".dynstr", ".dynsym", ".hash"
9810
          };
9811
          bfd_vma low, high;
9812
          unsigned int i, c;
9813
          struct elf_segment_map *n;
9814
 
9815
          low = ~(bfd_vma) 0;
9816
          high = 0;
9817
          for (i = 0; i < sizeof sec_names / sizeof sec_names[0]; i++)
9818
            {
9819
              s = bfd_get_section_by_name (abfd, sec_names[i]);
9820
              if (s != NULL && (s->flags & SEC_LOAD) != 0)
9821
                {
9822
                  bfd_size_type sz;
9823
 
9824
                  if (low > s->vma)
9825
                    low = s->vma;
9826
                  sz = s->size;
9827
                  if (high < s->vma + sz)
9828
                    high = s->vma + sz;
9829
                }
9830
            }
9831
 
9832
          c = 0;
9833
          for (s = abfd->sections; s != NULL; s = s->next)
9834
            if ((s->flags & SEC_LOAD) != 0
9835
                && s->vma >= low
9836
                && s->vma + s->size <= high)
9837
              ++c;
9838
 
9839
          amt = sizeof *n + (bfd_size_type) (c - 1) * sizeof (asection *);
9840
          n = bfd_zalloc (abfd, amt);
9841
          if (n == NULL)
9842
            return FALSE;
9843
          *n = *m;
9844
          n->count = c;
9845
 
9846
          i = 0;
9847
          for (s = abfd->sections; s != NULL; s = s->next)
9848
            {
9849
              if ((s->flags & SEC_LOAD) != 0
9850
                  && s->vma >= low
9851
                  && s->vma + s->size <= high)
9852
                {
9853
                  n->sections[i] = s;
9854
                  ++i;
9855
                }
9856
            }
9857
 
9858
          *pm = n;
9859
        }
9860
    }
9861
 
9862
  /* Allocate a spare program header in dynamic objects so that tools
9863
     like the prelinker can add an extra PT_LOAD entry.
9864
 
9865
     If the prelinker needs to make room for a new PT_LOAD entry, its
9866
     standard procedure is to move the first (read-only) sections into
9867
     the new (writable) segment.  However, the MIPS ABI requires
9868
     .dynamic to be in a read-only segment, and the section will often
9869
     start within sizeof (ElfNN_Phdr) bytes of the last program header.
9870
 
9871
     Although the prelinker could in principle move .dynamic to a
9872
     writable segment, it seems better to allocate a spare program
9873
     header instead, and avoid the need to move any sections.
9874
     There is a long tradition of allocating spare dynamic tags,
9875
     so allocating a spare program header seems like a natural
9876
     extension.
9877
 
9878
     If INFO is NULL, we may be copying an already prelinked binary
9879
     with objcopy or strip, so do not add this header.  */
9880
  if (info != NULL
9881
      && !SGI_COMPAT (abfd)
9882
      && bfd_get_section_by_name (abfd, ".dynamic"))
9883
    {
9884
      for (pm = &elf_tdata (abfd)->segment_map; *pm != NULL; pm = &(*pm)->next)
9885
        if ((*pm)->p_type == PT_NULL)
9886
          break;
9887
      if (*pm == NULL)
9888
        {
9889
          m = bfd_zalloc (abfd, sizeof (*m));
9890
          if (m == NULL)
9891
            return FALSE;
9892
 
9893
          m->p_type = PT_NULL;
9894
          *pm = m;
9895
        }
9896
    }
9897
 
9898
  return TRUE;
9899
}
9900
 
9901
/* Return the section that should be marked against GC for a given
9902
   relocation.  */
9903
 
9904
asection *
9905
_bfd_mips_elf_gc_mark_hook (asection *sec,
9906
                            struct bfd_link_info *info,
9907
                            Elf_Internal_Rela *rel,
9908
                            struct elf_link_hash_entry *h,
9909
                            Elf_Internal_Sym *sym)
9910
{
9911
  /* ??? Do mips16 stub sections need to be handled special?  */
9912
 
9913
  if (h != NULL)
9914
    switch (ELF_R_TYPE (sec->owner, rel->r_info))
9915
      {
9916
      case R_MIPS_GNU_VTINHERIT:
9917
      case R_MIPS_GNU_VTENTRY:
9918
        return NULL;
9919
      }
9920
 
9921
  return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
9922
}
9923
 
9924
/* Update the got entry reference counts for the section being removed.  */
9925
 
9926
bfd_boolean
9927
_bfd_mips_elf_gc_sweep_hook (bfd *abfd ATTRIBUTE_UNUSED,
9928
                             struct bfd_link_info *info ATTRIBUTE_UNUSED,
9929
                             asection *sec ATTRIBUTE_UNUSED,
9930
                             const Elf_Internal_Rela *relocs ATTRIBUTE_UNUSED)
9931
{
9932
#if 0
9933
  Elf_Internal_Shdr *symtab_hdr;
9934
  struct elf_link_hash_entry **sym_hashes;
9935
  bfd_signed_vma *local_got_refcounts;
9936
  const Elf_Internal_Rela *rel, *relend;
9937
  unsigned long r_symndx;
9938
  struct elf_link_hash_entry *h;
9939
 
9940
  if (info->relocatable)
9941
    return TRUE;
9942
 
9943
  symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
9944
  sym_hashes = elf_sym_hashes (abfd);
9945
  local_got_refcounts = elf_local_got_refcounts (abfd);
9946
 
9947
  relend = relocs + sec->reloc_count;
9948
  for (rel = relocs; rel < relend; rel++)
9949
    switch (ELF_R_TYPE (abfd, rel->r_info))
9950
      {
9951
      case R_MIPS_GOT16:
9952
      case R_MIPS_CALL16:
9953
      case R_MIPS_CALL_HI16:
9954
      case R_MIPS_CALL_LO16:
9955
      case R_MIPS_GOT_HI16:
9956
      case R_MIPS_GOT_LO16:
9957
      case R_MIPS_GOT_DISP:
9958
      case R_MIPS_GOT_PAGE:
9959
      case R_MIPS_GOT_OFST:
9960
        /* ??? It would seem that the existing MIPS code does no sort
9961
           of reference counting or whatnot on its GOT and PLT entries,
9962
           so it is not possible to garbage collect them at this time.  */
9963
        break;
9964
 
9965
      default:
9966
        break;
9967
      }
9968
#endif
9969
 
9970
  return TRUE;
9971
}
9972
 
9973
/* Copy data from a MIPS ELF indirect symbol to its direct symbol,
9974
   hiding the old indirect symbol.  Process additional relocation
9975
   information.  Also called for weakdefs, in which case we just let
9976
   _bfd_elf_link_hash_copy_indirect copy the flags for us.  */
9977
 
9978
void
9979
_bfd_mips_elf_copy_indirect_symbol (struct bfd_link_info *info,
9980
                                    struct elf_link_hash_entry *dir,
9981
                                    struct elf_link_hash_entry *ind)
9982
{
9983
  struct mips_elf_link_hash_entry *dirmips, *indmips;
9984
 
9985
  _bfd_elf_link_hash_copy_indirect (info, dir, ind);
9986
 
9987
  if (ind->root.type != bfd_link_hash_indirect)
9988
    return;
9989
 
9990
  dirmips = (struct mips_elf_link_hash_entry *) dir;
9991
  indmips = (struct mips_elf_link_hash_entry *) ind;
9992
  dirmips->possibly_dynamic_relocs += indmips->possibly_dynamic_relocs;
9993
  if (indmips->readonly_reloc)
9994
    dirmips->readonly_reloc = TRUE;
9995
  if (indmips->no_fn_stub)
9996
    dirmips->no_fn_stub = TRUE;
9997
 
9998
  if (dirmips->tls_type == 0)
9999
    dirmips->tls_type = indmips->tls_type;
10000
}
10001
 
10002
void
10003
_bfd_mips_elf_hide_symbol (struct bfd_link_info *info,
10004
                           struct elf_link_hash_entry *entry,
10005
                           bfd_boolean force_local)
10006
{
10007
  bfd *dynobj;
10008
  asection *got;
10009
  struct mips_got_info *g;
10010
  struct mips_elf_link_hash_entry *h;
10011
  struct mips_elf_link_hash_table *htab;
10012
 
10013
  h = (struct mips_elf_link_hash_entry *) entry;
10014
  if (h->forced_local)
10015
    return;
10016
  h->forced_local = force_local;
10017
 
10018
  dynobj = elf_hash_table (info)->dynobj;
10019
  htab = mips_elf_hash_table (info);
10020
  if (dynobj != NULL && force_local && h->root.type != STT_TLS
10021
      && (got = mips_elf_got_section (dynobj, TRUE)) != NULL
10022
      && (g = mips_elf_section_data (got)->u.got_info) != NULL)
10023
    {
10024
      if (g->next)
10025
        {
10026
          struct mips_got_entry e;
10027
          struct mips_got_info *gg = g;
10028
 
10029
          /* Since we're turning what used to be a global symbol into a
10030
             local one, bump up the number of local entries of each GOT
10031
             that had an entry for it.  This will automatically decrease
10032
             the number of global entries, since global_gotno is actually
10033
             the upper limit of global entries.  */
10034
          e.abfd = dynobj;
10035
          e.symndx = -1;
10036
          e.d.h = h;
10037
          e.tls_type = 0;
10038
 
10039
          for (g = g->next; g != gg; g = g->next)
10040
            if (htab_find (g->got_entries, &e))
10041
              {
10042
                BFD_ASSERT (g->global_gotno > 0);
10043
                g->local_gotno++;
10044
                g->global_gotno--;
10045
              }
10046
 
10047
          /* If this was a global symbol forced into the primary GOT, we
10048
             no longer need an entry for it.  We can't release the entry
10049
             at this point, but we must at least stop counting it as one
10050
             of the symbols that required a forced got entry.  */
10051
          if (h->root.got.offset == 2)
10052
            {
10053
              BFD_ASSERT (gg->assigned_gotno > 0);
10054
              gg->assigned_gotno--;
10055
            }
10056
        }
10057
      else if (h->root.got.offset == 1)
10058
        {
10059
          /* check_relocs didn't know that this symbol would be
10060
             forced-local, so add an extra local got entry.  */
10061
          g->local_gotno++;
10062
          if (htab->computed_got_sizes)
10063
            {
10064
              /* We'll have treated this symbol as global rather
10065
                 than local.  */
10066
              BFD_ASSERT (g->global_gotno > 0);
10067
              g->global_gotno--;
10068
            }
10069
        }
10070
      else if (htab->is_vxworks && h->root.needs_plt)
10071
        {
10072
          /* check_relocs didn't know that this symbol would be
10073
             forced-local, so add an extra local got entry.  */
10074
          g->local_gotno++;
10075
          if (htab->computed_got_sizes)
10076
            /* The symbol is only used in call relocations, so we'll
10077
               have assumed it only needs a .got.plt entry.  Increase
10078
               the size of .got accordingly.  */
10079
            got->size += MIPS_ELF_GOT_SIZE (dynobj);
10080
        }
10081
    }
10082
 
10083
  _bfd_elf_link_hash_hide_symbol (info, &h->root, force_local);
10084
}
10085
 
10086
#define PDR_SIZE 32
10087
 
10088
bfd_boolean
10089
_bfd_mips_elf_discard_info (bfd *abfd, struct elf_reloc_cookie *cookie,
10090
                            struct bfd_link_info *info)
10091
{
10092
  asection *o;
10093
  bfd_boolean ret = FALSE;
10094
  unsigned char *tdata;
10095
  size_t i, skip;
10096
 
10097
  o = bfd_get_section_by_name (abfd, ".pdr");
10098
  if (! o)
10099
    return FALSE;
10100
  if (o->size == 0)
10101
    return FALSE;
10102
  if (o->size % PDR_SIZE != 0)
10103
    return FALSE;
10104
  if (o->output_section != NULL
10105
      && bfd_is_abs_section (o->output_section))
10106
    return FALSE;
10107
 
10108
  tdata = bfd_zmalloc (o->size / PDR_SIZE);
10109
  if (! tdata)
10110
    return FALSE;
10111
 
10112
  cookie->rels = _bfd_elf_link_read_relocs (abfd, o, NULL, NULL,
10113
                                            info->keep_memory);
10114
  if (!cookie->rels)
10115
    {
10116
      free (tdata);
10117
      return FALSE;
10118
    }
10119
 
10120
  cookie->rel = cookie->rels;
10121
  cookie->relend = cookie->rels + o->reloc_count;
10122
 
10123
  for (i = 0, skip = 0; i < o->size / PDR_SIZE; i ++)
10124
    {
10125
      if (bfd_elf_reloc_symbol_deleted_p (i * PDR_SIZE, cookie))
10126
        {
10127
          tdata[i] = 1;
10128
          skip ++;
10129
        }
10130
    }
10131
 
10132
  if (skip != 0)
10133
    {
10134
      mips_elf_section_data (o)->u.tdata = tdata;
10135
      o->size -= skip * PDR_SIZE;
10136
      ret = TRUE;
10137
    }
10138
  else
10139
    free (tdata);
10140
 
10141
  if (! info->keep_memory)
10142
    free (cookie->rels);
10143
 
10144
  return ret;
10145
}
10146
 
10147
bfd_boolean
10148
_bfd_mips_elf_ignore_discarded_relocs (asection *sec)
10149
{
10150
  if (strcmp (sec->name, ".pdr") == 0)
10151
    return TRUE;
10152
  return FALSE;
10153
}
10154
 
10155
bfd_boolean
10156
_bfd_mips_elf_write_section (bfd *output_bfd,
10157
                             struct bfd_link_info *link_info ATTRIBUTE_UNUSED,
10158
                             asection *sec, bfd_byte *contents)
10159
{
10160
  bfd_byte *to, *from, *end;
10161
  int i;
10162
 
10163
  if (strcmp (sec->name, ".pdr") != 0)
10164
    return FALSE;
10165
 
10166
  if (mips_elf_section_data (sec)->u.tdata == NULL)
10167
    return FALSE;
10168
 
10169
  to = contents;
10170
  end = contents + sec->size;
10171
  for (from = contents, i = 0;
10172
       from < end;
10173
       from += PDR_SIZE, i++)
10174
    {
10175
      if ((mips_elf_section_data (sec)->u.tdata)[i] == 1)
10176
        continue;
10177
      if (to != from)
10178
        memcpy (to, from, PDR_SIZE);
10179
      to += PDR_SIZE;
10180
    }
10181
  bfd_set_section_contents (output_bfd, sec->output_section, contents,
10182
                            sec->output_offset, sec->size);
10183
  return TRUE;
10184
}
10185
 
10186
/* MIPS ELF uses a special find_nearest_line routine in order the
10187
   handle the ECOFF debugging information.  */
10188
 
10189
struct mips_elf_find_line
10190
{
10191
  struct ecoff_debug_info d;
10192
  struct ecoff_find_line i;
10193
};
10194
 
10195
bfd_boolean
10196
_bfd_mips_elf_find_nearest_line (bfd *abfd, asection *section,
10197
                                 asymbol **symbols, bfd_vma offset,
10198
                                 const char **filename_ptr,
10199
                                 const char **functionname_ptr,
10200
                                 unsigned int *line_ptr)
10201
{
10202
  asection *msec;
10203
 
10204
  if (_bfd_dwarf1_find_nearest_line (abfd, section, symbols, offset,
10205
                                     filename_ptr, functionname_ptr,
10206
                                     line_ptr))
10207
    return TRUE;
10208
 
10209
  if (_bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset,
10210
                                     filename_ptr, functionname_ptr,
10211
                                     line_ptr, ABI_64_P (abfd) ? 8 : 0,
10212
                                     &elf_tdata (abfd)->dwarf2_find_line_info))
10213
    return TRUE;
10214
 
10215
  msec = bfd_get_section_by_name (abfd, ".mdebug");
10216
  if (msec != NULL)
10217
    {
10218
      flagword origflags;
10219
      struct mips_elf_find_line *fi;
10220
      const struct ecoff_debug_swap * const swap =
10221
        get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
10222
 
10223
      /* If we are called during a link, mips_elf_final_link may have
10224
         cleared the SEC_HAS_CONTENTS field.  We force it back on here
10225
         if appropriate (which it normally will be).  */
10226
      origflags = msec->flags;
10227
      if (elf_section_data (msec)->this_hdr.sh_type != SHT_NOBITS)
10228
        msec->flags |= SEC_HAS_CONTENTS;
10229
 
10230
      fi = elf_tdata (abfd)->find_line_info;
10231
      if (fi == NULL)
10232
        {
10233
          bfd_size_type external_fdr_size;
10234
          char *fraw_src;
10235
          char *fraw_end;
10236
          struct fdr *fdr_ptr;
10237
          bfd_size_type amt = sizeof (struct mips_elf_find_line);
10238
 
10239
          fi = bfd_zalloc (abfd, amt);
10240
          if (fi == NULL)
10241
            {
10242
              msec->flags = origflags;
10243
              return FALSE;
10244
            }
10245
 
10246
          if (! _bfd_mips_elf_read_ecoff_info (abfd, msec, &fi->d))
10247
            {
10248
              msec->flags = origflags;
10249
              return FALSE;
10250
            }
10251
 
10252
          /* Swap in the FDR information.  */
10253
          amt = fi->d.symbolic_header.ifdMax * sizeof (struct fdr);
10254
          fi->d.fdr = bfd_alloc (abfd, amt);
10255
          if (fi->d.fdr == NULL)
10256
            {
10257
              msec->flags = origflags;
10258
              return FALSE;
10259
            }
10260
          external_fdr_size = swap->external_fdr_size;
10261
          fdr_ptr = fi->d.fdr;
10262
          fraw_src = (char *) fi->d.external_fdr;
10263
          fraw_end = (fraw_src
10264
                      + fi->d.symbolic_header.ifdMax * external_fdr_size);
10265
          for (; fraw_src < fraw_end; fraw_src += external_fdr_size, fdr_ptr++)
10266
            (*swap->swap_fdr_in) (abfd, fraw_src, fdr_ptr);
10267
 
10268
          elf_tdata (abfd)->find_line_info = fi;
10269
 
10270
          /* Note that we don't bother to ever free this information.
10271
             find_nearest_line is either called all the time, as in
10272
             objdump -l, so the information should be saved, or it is
10273
             rarely called, as in ld error messages, so the memory
10274
             wasted is unimportant.  Still, it would probably be a
10275
             good idea for free_cached_info to throw it away.  */
10276
        }
10277
 
10278
      if (_bfd_ecoff_locate_line (abfd, section, offset, &fi->d, swap,
10279
                                  &fi->i, filename_ptr, functionname_ptr,
10280
                                  line_ptr))
10281
        {
10282
          msec->flags = origflags;
10283
          return TRUE;
10284
        }
10285
 
10286
      msec->flags = origflags;
10287
    }
10288
 
10289
  /* Fall back on the generic ELF find_nearest_line routine.  */
10290
 
10291
  return _bfd_elf_find_nearest_line (abfd, section, symbols, offset,
10292
                                     filename_ptr, functionname_ptr,
10293
                                     line_ptr);
10294
}
10295
 
10296
bfd_boolean
10297
_bfd_mips_elf_find_inliner_info (bfd *abfd,
10298
                                 const char **filename_ptr,
10299
                                 const char **functionname_ptr,
10300
                                 unsigned int *line_ptr)
10301
{
10302
  bfd_boolean found;
10303
  found = _bfd_dwarf2_find_inliner_info (abfd, filename_ptr,
10304
                                         functionname_ptr, line_ptr,
10305
                                         & elf_tdata (abfd)->dwarf2_find_line_info);
10306
  return found;
10307
}
10308
 
10309
 
10310
/* When are writing out the .options or .MIPS.options section,
10311
   remember the bytes we are writing out, so that we can install the
10312
   GP value in the section_processing routine.  */
10313
 
10314
bfd_boolean
10315
_bfd_mips_elf_set_section_contents (bfd *abfd, sec_ptr section,
10316
                                    const void *location,
10317
                                    file_ptr offset, bfd_size_type count)
10318
{
10319
  if (MIPS_ELF_OPTIONS_SECTION_NAME_P (section->name))
10320
    {
10321
      bfd_byte *c;
10322
 
10323
      if (elf_section_data (section) == NULL)
10324
        {
10325
          bfd_size_type amt = sizeof (struct bfd_elf_section_data);
10326
          section->used_by_bfd = bfd_zalloc (abfd, amt);
10327
          if (elf_section_data (section) == NULL)
10328
            return FALSE;
10329
        }
10330
      c = mips_elf_section_data (section)->u.tdata;
10331
      if (c == NULL)
10332
        {
10333
          c = bfd_zalloc (abfd, section->size);
10334
          if (c == NULL)
10335
            return FALSE;
10336
          mips_elf_section_data (section)->u.tdata = c;
10337
        }
10338
 
10339
      memcpy (c + offset, location, count);
10340
    }
10341
 
10342
  return _bfd_elf_set_section_contents (abfd, section, location, offset,
10343
                                        count);
10344
}
10345
 
10346
/* This is almost identical to bfd_generic_get_... except that some
10347
   MIPS relocations need to be handled specially.  Sigh.  */
10348
 
10349
bfd_byte *
10350
_bfd_elf_mips_get_relocated_section_contents
10351
  (bfd *abfd,
10352
   struct bfd_link_info *link_info,
10353
   struct bfd_link_order *link_order,
10354
   bfd_byte *data,
10355
   bfd_boolean relocatable,
10356
   asymbol **symbols)
10357
{
10358
  /* Get enough memory to hold the stuff */
10359
  bfd *input_bfd = link_order->u.indirect.section->owner;
10360
  asection *input_section = link_order->u.indirect.section;
10361
  bfd_size_type sz;
10362
 
10363
  long reloc_size = bfd_get_reloc_upper_bound (input_bfd, input_section);
10364
  arelent **reloc_vector = NULL;
10365
  long reloc_count;
10366
 
10367
  if (reloc_size < 0)
10368
    goto error_return;
10369
 
10370
  reloc_vector = bfd_malloc (reloc_size);
10371
  if (reloc_vector == NULL && reloc_size != 0)
10372
    goto error_return;
10373
 
10374
  /* read in the section */
10375
  sz = input_section->rawsize ? input_section->rawsize : input_section->size;
10376
  if (!bfd_get_section_contents (input_bfd, input_section, data, 0, sz))
10377
    goto error_return;
10378
 
10379
  reloc_count = bfd_canonicalize_reloc (input_bfd,
10380
                                        input_section,
10381
                                        reloc_vector,
10382
                                        symbols);
10383
  if (reloc_count < 0)
10384
    goto error_return;
10385
 
10386
  if (reloc_count > 0)
10387
    {
10388
      arelent **parent;
10389
      /* for mips */
10390
      int gp_found;
10391
      bfd_vma gp = 0x12345678;  /* initialize just to shut gcc up */
10392
 
10393
      {
10394
        struct bfd_hash_entry *h;
10395
        struct bfd_link_hash_entry *lh;
10396
        /* Skip all this stuff if we aren't mixing formats.  */
10397
        if (abfd && input_bfd
10398
            && abfd->xvec == input_bfd->xvec)
10399
          lh = 0;
10400
        else
10401
          {
10402
            h = bfd_hash_lookup (&link_info->hash->table, "_gp", FALSE, FALSE);
10403
            lh = (struct bfd_link_hash_entry *) h;
10404
          }
10405
      lookup:
10406
        if (lh)
10407
          {
10408
            switch (lh->type)
10409
              {
10410
              case bfd_link_hash_undefined:
10411
              case bfd_link_hash_undefweak:
10412
              case bfd_link_hash_common:
10413
                gp_found = 0;
10414
                break;
10415
              case bfd_link_hash_defined:
10416
              case bfd_link_hash_defweak:
10417
                gp_found = 1;
10418
                gp = lh->u.def.value;
10419
                break;
10420
              case bfd_link_hash_indirect:
10421
              case bfd_link_hash_warning:
10422
                lh = lh->u.i.link;
10423
                /* @@FIXME  ignoring warning for now */
10424
                goto lookup;
10425
              case bfd_link_hash_new:
10426
              default:
10427
                abort ();
10428
              }
10429
          }
10430
        else
10431
          gp_found = 0;
10432
      }
10433
      /* end mips */
10434
      for (parent = reloc_vector; *parent != NULL; parent++)
10435
        {
10436
          char *error_message = NULL;
10437
          bfd_reloc_status_type r;
10438
 
10439
          /* Specific to MIPS: Deal with relocation types that require
10440
             knowing the gp of the output bfd.  */
10441
          asymbol *sym = *(*parent)->sym_ptr_ptr;
10442
 
10443
          /* If we've managed to find the gp and have a special
10444
             function for the relocation then go ahead, else default
10445
             to the generic handling.  */
10446
          if (gp_found
10447
              && (*parent)->howto->special_function
10448
              == _bfd_mips_elf32_gprel16_reloc)
10449
            r = _bfd_mips_elf_gprel16_with_gp (input_bfd, sym, *parent,
10450
                                               input_section, relocatable,
10451
                                               data, gp);
10452
          else
10453
            r = bfd_perform_relocation (input_bfd, *parent, data,
10454
                                        input_section,
10455
                                        relocatable ? abfd : NULL,
10456
                                        &error_message);
10457
 
10458
          if (relocatable)
10459
            {
10460
              asection *os = input_section->output_section;
10461
 
10462
              /* A partial link, so keep the relocs */
10463
              os->orelocation[os->reloc_count] = *parent;
10464
              os->reloc_count++;
10465
            }
10466
 
10467
          if (r != bfd_reloc_ok)
10468
            {
10469
              switch (r)
10470
                {
10471
                case bfd_reloc_undefined:
10472
                  if (!((*link_info->callbacks->undefined_symbol)
10473
                        (link_info, bfd_asymbol_name (*(*parent)->sym_ptr_ptr),
10474
                         input_bfd, input_section, (*parent)->address, TRUE)))
10475
                    goto error_return;
10476
                  break;
10477
                case bfd_reloc_dangerous:
10478
                  BFD_ASSERT (error_message != NULL);
10479
                  if (!((*link_info->callbacks->reloc_dangerous)
10480
                        (link_info, error_message, input_bfd, input_section,
10481
                         (*parent)->address)))
10482
                    goto error_return;
10483
                  break;
10484
                case bfd_reloc_overflow:
10485
                  if (!((*link_info->callbacks->reloc_overflow)
10486
                        (link_info, NULL,
10487
                         bfd_asymbol_name (*(*parent)->sym_ptr_ptr),
10488
                         (*parent)->howto->name, (*parent)->addend,
10489
                         input_bfd, input_section, (*parent)->address)))
10490
                    goto error_return;
10491
                  break;
10492
                case bfd_reloc_outofrange:
10493
                default:
10494
                  abort ();
10495
                  break;
10496
                }
10497
 
10498
            }
10499
        }
10500
    }
10501
  if (reloc_vector != NULL)
10502
    free (reloc_vector);
10503
  return data;
10504
 
10505
error_return:
10506
  if (reloc_vector != NULL)
10507
    free (reloc_vector);
10508
  return NULL;
10509
}
10510
 
10511
/* Create a MIPS ELF linker hash table.  */
10512
 
10513
struct bfd_link_hash_table *
10514
_bfd_mips_elf_link_hash_table_create (bfd *abfd)
10515
{
10516
  struct mips_elf_link_hash_table *ret;
10517
  bfd_size_type amt = sizeof (struct mips_elf_link_hash_table);
10518
 
10519
  ret = bfd_malloc (amt);
10520
  if (ret == NULL)
10521
    return NULL;
10522
 
10523
  if (!_bfd_elf_link_hash_table_init (&ret->root, abfd,
10524
                                      mips_elf_link_hash_newfunc,
10525
                                      sizeof (struct mips_elf_link_hash_entry)))
10526
    {
10527
      free (ret);
10528
      return NULL;
10529
    }
10530
 
10531
#if 0
10532
  /* We no longer use this.  */
10533
  for (i = 0; i < SIZEOF_MIPS_DYNSYM_SECNAMES; i++)
10534
    ret->dynsym_sec_strindex[i] = (bfd_size_type) -1;
10535
#endif
10536
  ret->procedure_count = 0;
10537
  ret->compact_rel_size = 0;
10538
  ret->use_rld_obj_head = FALSE;
10539
  ret->rld_value = 0;
10540
  ret->mips16_stubs_seen = FALSE;
10541
  ret->computed_got_sizes = FALSE;
10542
  ret->is_vxworks = FALSE;
10543
  ret->small_data_overflow_reported = FALSE;
10544
  ret->srelbss = NULL;
10545
  ret->sdynbss = NULL;
10546
  ret->srelplt = NULL;
10547
  ret->srelplt2 = NULL;
10548
  ret->sgotplt = NULL;
10549
  ret->splt = NULL;
10550
  ret->plt_header_size = 0;
10551
  ret->plt_entry_size = 0;
10552
  ret->function_stub_size = 0;
10553
 
10554
  return &ret->root.root;
10555
}
10556
 
10557
/* Likewise, but indicate that the target is VxWorks.  */
10558
 
10559
struct bfd_link_hash_table *
10560
_bfd_mips_vxworks_link_hash_table_create (bfd *abfd)
10561
{
10562
  struct bfd_link_hash_table *ret;
10563
 
10564
  ret = _bfd_mips_elf_link_hash_table_create (abfd);
10565
  if (ret)
10566
    {
10567
      struct mips_elf_link_hash_table *htab;
10568
 
10569
      htab = (struct mips_elf_link_hash_table *) ret;
10570
      htab->is_vxworks = 1;
10571
    }
10572
  return ret;
10573
}
10574
 
10575
/* We need to use a special link routine to handle the .reginfo and
10576
   the .mdebug sections.  We need to merge all instances of these
10577
   sections together, not write them all out sequentially.  */
10578
 
10579
bfd_boolean
10580
_bfd_mips_elf_final_link (bfd *abfd, struct bfd_link_info *info)
10581
{
10582
  asection *o;
10583
  struct bfd_link_order *p;
10584
  asection *reginfo_sec, *mdebug_sec, *gptab_data_sec, *gptab_bss_sec;
10585
  asection *rtproc_sec;
10586
  Elf32_RegInfo reginfo;
10587
  struct ecoff_debug_info debug;
10588
  const struct elf_backend_data *bed = get_elf_backend_data (abfd);
10589
  const struct ecoff_debug_swap *swap = bed->elf_backend_ecoff_debug_swap;
10590
  HDRR *symhdr = &debug.symbolic_header;
10591
  void *mdebug_handle = NULL;
10592
  asection *s;
10593
  EXTR esym;
10594
  unsigned int i;
10595
  bfd_size_type amt;
10596
  struct mips_elf_link_hash_table *htab;
10597
 
10598
  static const char * const secname[] =
10599
  {
10600
    ".text", ".init", ".fini", ".data",
10601
    ".rodata", ".sdata", ".sbss", ".bss"
10602
  };
10603
  static const int sc[] =
10604
  {
10605
    scText, scInit, scFini, scData,
10606
    scRData, scSData, scSBss, scBss
10607
  };
10608
 
10609
  /* We'd carefully arranged the dynamic symbol indices, and then the
10610
     generic size_dynamic_sections renumbered them out from under us.
10611
     Rather than trying somehow to prevent the renumbering, just do
10612
     the sort again.  */
10613
  htab = mips_elf_hash_table (info);
10614
  if (elf_hash_table (info)->dynamic_sections_created)
10615
    {
10616
      bfd *dynobj;
10617
      asection *got;
10618
      struct mips_got_info *g;
10619
      bfd_size_type dynsecsymcount;
10620
 
10621
      /* When we resort, we must tell mips_elf_sort_hash_table what
10622
         the lowest index it may use is.  That's the number of section
10623
         symbols we're going to add.  The generic ELF linker only
10624
         adds these symbols when building a shared object.  Note that
10625
         we count the sections after (possibly) removing the .options
10626
         section above.  */
10627
 
10628
      dynsecsymcount = count_section_dynsyms (abfd, info);
10629
      if (! mips_elf_sort_hash_table (info, dynsecsymcount + 1))
10630
        return FALSE;
10631
 
10632
      /* Make sure we didn't grow the global .got region.  */
10633
      dynobj = elf_hash_table (info)->dynobj;
10634
      got = mips_elf_got_section (dynobj, FALSE);
10635
      g = mips_elf_section_data (got)->u.got_info;
10636
 
10637
      if (g->global_gotsym != NULL)
10638
        BFD_ASSERT ((elf_hash_table (info)->dynsymcount
10639
                     - g->global_gotsym->dynindx)
10640
                    <= g->global_gotno);
10641
    }
10642
 
10643
  /* Get a value for the GP register.  */
10644
  if (elf_gp (abfd) == 0)
10645
    {
10646
      struct bfd_link_hash_entry *h;
10647
 
10648
      h = bfd_link_hash_lookup (info->hash, "_gp", FALSE, FALSE, TRUE);
10649
      if (h != NULL && h->type == bfd_link_hash_defined)
10650
        elf_gp (abfd) = (h->u.def.value
10651
                         + h->u.def.section->output_section->vma
10652
                         + h->u.def.section->output_offset);
10653
      else if (htab->is_vxworks
10654
               && (h = bfd_link_hash_lookup (info->hash,
10655
                                             "_GLOBAL_OFFSET_TABLE_",
10656
                                             FALSE, FALSE, TRUE))
10657
               && h->type == bfd_link_hash_defined)
10658
        elf_gp (abfd) = (h->u.def.section->output_section->vma
10659
                         + h->u.def.section->output_offset
10660
                         + h->u.def.value);
10661
      else if (info->relocatable)
10662
        {
10663
          bfd_vma lo = MINUS_ONE;
10664
 
10665
          /* Find the GP-relative section with the lowest offset.  */
10666
          for (o = abfd->sections; o != NULL; o = o->next)
10667
            if (o->vma < lo
10668
                && (elf_section_data (o)->this_hdr.sh_flags & SHF_MIPS_GPREL))
10669
              lo = o->vma;
10670
 
10671
          /* And calculate GP relative to that.  */
10672
          elf_gp (abfd) = lo + ELF_MIPS_GP_OFFSET (info);
10673
        }
10674
      else
10675
        {
10676
          /* If the relocate_section function needs to do a reloc
10677
             involving the GP value, it should make a reloc_dangerous
10678
             callback to warn that GP is not defined.  */
10679
        }
10680
    }
10681
 
10682
  /* Go through the sections and collect the .reginfo and .mdebug
10683
     information.  */
10684
  reginfo_sec = NULL;
10685
  mdebug_sec = NULL;
10686
  gptab_data_sec = NULL;
10687
  gptab_bss_sec = NULL;
10688
  for (o = abfd->sections; o != NULL; o = o->next)
10689
    {
10690
      if (strcmp (o->name, ".reginfo") == 0)
10691
        {
10692
          memset (&reginfo, 0, sizeof reginfo);
10693
 
10694
          /* We have found the .reginfo section in the output file.
10695
             Look through all the link_orders comprising it and merge
10696
             the information together.  */
10697
          for (p = o->map_head.link_order; p != NULL; p = p->next)
10698
            {
10699
              asection *input_section;
10700
              bfd *input_bfd;
10701
              Elf32_External_RegInfo ext;
10702
              Elf32_RegInfo sub;
10703
 
10704
              if (p->type != bfd_indirect_link_order)
10705
                {
10706
                  if (p->type == bfd_data_link_order)
10707
                    continue;
10708
                  abort ();
10709
                }
10710
 
10711
              input_section = p->u.indirect.section;
10712
              input_bfd = input_section->owner;
10713
 
10714
              if (! bfd_get_section_contents (input_bfd, input_section,
10715
                                              &ext, 0, sizeof ext))
10716
                return FALSE;
10717
 
10718
              bfd_mips_elf32_swap_reginfo_in (input_bfd, &ext, &sub);
10719
 
10720
              reginfo.ri_gprmask |= sub.ri_gprmask;
10721
              reginfo.ri_cprmask[0] |= sub.ri_cprmask[0];
10722
              reginfo.ri_cprmask[1] |= sub.ri_cprmask[1];
10723
              reginfo.ri_cprmask[2] |= sub.ri_cprmask[2];
10724
              reginfo.ri_cprmask[3] |= sub.ri_cprmask[3];
10725
 
10726
              /* ri_gp_value is set by the function
10727
                 mips_elf32_section_processing when the section is
10728
                 finally written out.  */
10729
 
10730
              /* Hack: reset the SEC_HAS_CONTENTS flag so that
10731
                 elf_link_input_bfd ignores this section.  */
10732
              input_section->flags &= ~SEC_HAS_CONTENTS;
10733
            }
10734
 
10735
          /* Size has been set in _bfd_mips_elf_always_size_sections.  */
10736
          BFD_ASSERT(o->size == sizeof (Elf32_External_RegInfo));
10737
 
10738
          /* Skip this section later on (I don't think this currently
10739
             matters, but someday it might).  */
10740
          o->map_head.link_order = NULL;
10741
 
10742
          reginfo_sec = o;
10743
        }
10744
 
10745
      if (strcmp (o->name, ".mdebug") == 0)
10746
        {
10747
          struct extsym_info einfo;
10748
          bfd_vma last;
10749
 
10750
          /* We have found the .mdebug section in the output file.
10751
             Look through all the link_orders comprising it and merge
10752
             the information together.  */
10753
          symhdr->magic = swap->sym_magic;
10754
          /* FIXME: What should the version stamp be?  */
10755
          symhdr->vstamp = 0;
10756
          symhdr->ilineMax = 0;
10757
          symhdr->cbLine = 0;
10758
          symhdr->idnMax = 0;
10759
          symhdr->ipdMax = 0;
10760
          symhdr->isymMax = 0;
10761
          symhdr->ioptMax = 0;
10762
          symhdr->iauxMax = 0;
10763
          symhdr->issMax = 0;
10764
          symhdr->issExtMax = 0;
10765
          symhdr->ifdMax = 0;
10766
          symhdr->crfd = 0;
10767
          symhdr->iextMax = 0;
10768
 
10769
          /* We accumulate the debugging information itself in the
10770
             debug_info structure.  */
10771
          debug.line = NULL;
10772
          debug.external_dnr = NULL;
10773
          debug.external_pdr = NULL;
10774
          debug.external_sym = NULL;
10775
          debug.external_opt = NULL;
10776
          debug.external_aux = NULL;
10777
          debug.ss = NULL;
10778
          debug.ssext = debug.ssext_end = NULL;
10779
          debug.external_fdr = NULL;
10780
          debug.external_rfd = NULL;
10781
          debug.external_ext = debug.external_ext_end = NULL;
10782
 
10783
          mdebug_handle = bfd_ecoff_debug_init (abfd, &debug, swap, info);
10784
          if (mdebug_handle == NULL)
10785
            return FALSE;
10786
 
10787
          esym.jmptbl = 0;
10788
          esym.cobol_main = 0;
10789
          esym.weakext = 0;
10790
          esym.reserved = 0;
10791
          esym.ifd = ifdNil;
10792
          esym.asym.iss = issNil;
10793
          esym.asym.st = stLocal;
10794
          esym.asym.reserved = 0;
10795
          esym.asym.index = indexNil;
10796
          last = 0;
10797
          for (i = 0; i < sizeof (secname) / sizeof (secname[0]); i++)
10798
            {
10799
              esym.asym.sc = sc[i];
10800
              s = bfd_get_section_by_name (abfd, secname[i]);
10801
              if (s != NULL)
10802
                {
10803
                  esym.asym.value = s->vma;
10804
                  last = s->vma + s->size;
10805
                }
10806
              else
10807
                esym.asym.value = last;
10808
              if (!bfd_ecoff_debug_one_external (abfd, &debug, swap,
10809
                                                 secname[i], &esym))
10810
                return FALSE;
10811
            }
10812
 
10813
          for (p = o->map_head.link_order; p != NULL; p = p->next)
10814
            {
10815
              asection *input_section;
10816
              bfd *input_bfd;
10817
              const struct ecoff_debug_swap *input_swap;
10818
              struct ecoff_debug_info input_debug;
10819
              char *eraw_src;
10820
              char *eraw_end;
10821
 
10822
              if (p->type != bfd_indirect_link_order)
10823
                {
10824
                  if (p->type == bfd_data_link_order)
10825
                    continue;
10826
                  abort ();
10827
                }
10828
 
10829
              input_section = p->u.indirect.section;
10830
              input_bfd = input_section->owner;
10831
 
10832
              if (bfd_get_flavour (input_bfd) != bfd_target_elf_flavour
10833
                  || (get_elf_backend_data (input_bfd)
10834
                      ->elf_backend_ecoff_debug_swap) == NULL)
10835
                {
10836
                  /* I don't know what a non MIPS ELF bfd would be
10837
                     doing with a .mdebug section, but I don't really
10838
                     want to deal with it.  */
10839
                  continue;
10840
                }
10841
 
10842
              input_swap = (get_elf_backend_data (input_bfd)
10843
                            ->elf_backend_ecoff_debug_swap);
10844
 
10845
              BFD_ASSERT (p->size == input_section->size);
10846
 
10847
              /* The ECOFF linking code expects that we have already
10848
                 read in the debugging information and set up an
10849
                 ecoff_debug_info structure, so we do that now.  */
10850
              if (! _bfd_mips_elf_read_ecoff_info (input_bfd, input_section,
10851
                                                   &input_debug))
10852
                return FALSE;
10853
 
10854
              if (! (bfd_ecoff_debug_accumulate
10855
                     (mdebug_handle, abfd, &debug, swap, input_bfd,
10856
                      &input_debug, input_swap, info)))
10857
                return FALSE;
10858
 
10859
              /* Loop through the external symbols.  For each one with
10860
                 interesting information, try to find the symbol in
10861
                 the linker global hash table and save the information
10862
                 for the output external symbols.  */
10863
              eraw_src = input_debug.external_ext;
10864
              eraw_end = (eraw_src
10865
                          + (input_debug.symbolic_header.iextMax
10866
                             * input_swap->external_ext_size));
10867
              for (;
10868
                   eraw_src < eraw_end;
10869
                   eraw_src += input_swap->external_ext_size)
10870
                {
10871
                  EXTR ext;
10872
                  const char *name;
10873
                  struct mips_elf_link_hash_entry *h;
10874
 
10875
                  (*input_swap->swap_ext_in) (input_bfd, eraw_src, &ext);
10876
                  if (ext.asym.sc == scNil
10877
                      || ext.asym.sc == scUndefined
10878
                      || ext.asym.sc == scSUndefined)
10879
                    continue;
10880
 
10881
                  name = input_debug.ssext + ext.asym.iss;
10882
                  h = mips_elf_link_hash_lookup (mips_elf_hash_table (info),
10883
                                                 name, FALSE, FALSE, TRUE);
10884
                  if (h == NULL || h->esym.ifd != -2)
10885
                    continue;
10886
 
10887
                  if (ext.ifd != -1)
10888
                    {
10889
                      BFD_ASSERT (ext.ifd
10890
                                  < input_debug.symbolic_header.ifdMax);
10891
                      ext.ifd = input_debug.ifdmap[ext.ifd];
10892
                    }
10893
 
10894
                  h->esym = ext;
10895
                }
10896
 
10897
              /* Free up the information we just read.  */
10898
              free (input_debug.line);
10899
              free (input_debug.external_dnr);
10900
              free (input_debug.external_pdr);
10901
              free (input_debug.external_sym);
10902
              free (input_debug.external_opt);
10903
              free (input_debug.external_aux);
10904
              free (input_debug.ss);
10905
              free (input_debug.ssext);
10906
              free (input_debug.external_fdr);
10907
              free (input_debug.external_rfd);
10908
              free (input_debug.external_ext);
10909
 
10910
              /* Hack: reset the SEC_HAS_CONTENTS flag so that
10911
                 elf_link_input_bfd ignores this section.  */
10912
              input_section->flags &= ~SEC_HAS_CONTENTS;
10913
            }
10914
 
10915
          if (SGI_COMPAT (abfd) && info->shared)
10916
            {
10917
              /* Create .rtproc section.  */
10918
              rtproc_sec = bfd_get_section_by_name (abfd, ".rtproc");
10919
              if (rtproc_sec == NULL)
10920
                {
10921
                  flagword flags = (SEC_HAS_CONTENTS | SEC_IN_MEMORY
10922
                                    | SEC_LINKER_CREATED | SEC_READONLY);
10923
 
10924
                  rtproc_sec = bfd_make_section_with_flags (abfd,
10925
                                                            ".rtproc",
10926
                                                            flags);
10927
                  if (rtproc_sec == NULL
10928
                      || ! bfd_set_section_alignment (abfd, rtproc_sec, 4))
10929
                    return FALSE;
10930
                }
10931
 
10932
              if (! mips_elf_create_procedure_table (mdebug_handle, abfd,
10933
                                                     info, rtproc_sec,
10934
                                                     &debug))
10935
                return FALSE;
10936
            }
10937
 
10938
          /* Build the external symbol information.  */
10939
          einfo.abfd = abfd;
10940
          einfo.info = info;
10941
          einfo.debug = &debug;
10942
          einfo.swap = swap;
10943
          einfo.failed = FALSE;
10944
          mips_elf_link_hash_traverse (mips_elf_hash_table (info),
10945
                                       mips_elf_output_extsym, &einfo);
10946
          if (einfo.failed)
10947
            return FALSE;
10948
 
10949
          /* Set the size of the .mdebug section.  */
10950
          o->size = bfd_ecoff_debug_size (abfd, &debug, swap);
10951
 
10952
          /* Skip this section later on (I don't think this currently
10953
             matters, but someday it might).  */
10954
          o->map_head.link_order = NULL;
10955
 
10956
          mdebug_sec = o;
10957
        }
10958
 
10959
      if (CONST_STRNEQ (o->name, ".gptab."))
10960
        {
10961
          const char *subname;
10962
          unsigned int c;
10963
          Elf32_gptab *tab;
10964
          Elf32_External_gptab *ext_tab;
10965
          unsigned int j;
10966
 
10967
          /* The .gptab.sdata and .gptab.sbss sections hold
10968
             information describing how the small data area would
10969
             change depending upon the -G switch.  These sections
10970
             not used in executables files.  */
10971
          if (! info->relocatable)
10972
            {
10973
              for (p = o->map_head.link_order; p != NULL; p = p->next)
10974
                {
10975
                  asection *input_section;
10976
 
10977
                  if (p->type != bfd_indirect_link_order)
10978
                    {
10979
                      if (p->type == bfd_data_link_order)
10980
                        continue;
10981
                      abort ();
10982
                    }
10983
 
10984
                  input_section = p->u.indirect.section;
10985
 
10986
                  /* Hack: reset the SEC_HAS_CONTENTS flag so that
10987
                     elf_link_input_bfd ignores this section.  */
10988
                  input_section->flags &= ~SEC_HAS_CONTENTS;
10989
                }
10990
 
10991
              /* Skip this section later on (I don't think this
10992
                 currently matters, but someday it might).  */
10993
              o->map_head.link_order = NULL;
10994
 
10995
              /* Really remove the section.  */
10996
              bfd_section_list_remove (abfd, o);
10997
              --abfd->section_count;
10998
 
10999
              continue;
11000
            }
11001
 
11002
          /* There is one gptab for initialized data, and one for
11003
             uninitialized data.  */
11004
          if (strcmp (o->name, ".gptab.sdata") == 0)
11005
            gptab_data_sec = o;
11006
          else if (strcmp (o->name, ".gptab.sbss") == 0)
11007
            gptab_bss_sec = o;
11008
          else
11009
            {
11010
              (*_bfd_error_handler)
11011
                (_("%s: illegal section name `%s'"),
11012
                 bfd_get_filename (abfd), o->name);
11013
              bfd_set_error (bfd_error_nonrepresentable_section);
11014
              return FALSE;
11015
            }
11016
 
11017
          /* The linker script always combines .gptab.data and
11018
             .gptab.sdata into .gptab.sdata, and likewise for
11019
             .gptab.bss and .gptab.sbss.  It is possible that there is
11020
             no .sdata or .sbss section in the output file, in which
11021
             case we must change the name of the output section.  */
11022
          subname = o->name + sizeof ".gptab" - 1;
11023
          if (bfd_get_section_by_name (abfd, subname) == NULL)
11024
            {
11025
              if (o == gptab_data_sec)
11026
                o->name = ".gptab.data";
11027
              else
11028
                o->name = ".gptab.bss";
11029
              subname = o->name + sizeof ".gptab" - 1;
11030
              BFD_ASSERT (bfd_get_section_by_name (abfd, subname) != NULL);
11031
            }
11032
 
11033
          /* Set up the first entry.  */
11034
          c = 1;
11035
          amt = c * sizeof (Elf32_gptab);
11036
          tab = bfd_malloc (amt);
11037
          if (tab == NULL)
11038
            return FALSE;
11039
          tab[0].gt_header.gt_current_g_value = elf_gp_size (abfd);
11040
          tab[0].gt_header.gt_unused = 0;
11041
 
11042
          /* Combine the input sections.  */
11043
          for (p = o->map_head.link_order; p != NULL; p = p->next)
11044
            {
11045
              asection *input_section;
11046
              bfd *input_bfd;
11047
              bfd_size_type size;
11048
              unsigned long last;
11049
              bfd_size_type gpentry;
11050
 
11051
              if (p->type != bfd_indirect_link_order)
11052
                {
11053
                  if (p->type == bfd_data_link_order)
11054
                    continue;
11055
                  abort ();
11056
                }
11057
 
11058
              input_section = p->u.indirect.section;
11059
              input_bfd = input_section->owner;
11060
 
11061
              /* Combine the gptab entries for this input section one
11062
                 by one.  We know that the input gptab entries are
11063
                 sorted by ascending -G value.  */
11064
              size = input_section->size;
11065
              last = 0;
11066
              for (gpentry = sizeof (Elf32_External_gptab);
11067
                   gpentry < size;
11068
                   gpentry += sizeof (Elf32_External_gptab))
11069
                {
11070
                  Elf32_External_gptab ext_gptab;
11071
                  Elf32_gptab int_gptab;
11072
                  unsigned long val;
11073
                  unsigned long add;
11074
                  bfd_boolean exact;
11075
                  unsigned int look;
11076
 
11077
                  if (! (bfd_get_section_contents
11078
                         (input_bfd, input_section, &ext_gptab, gpentry,
11079
                          sizeof (Elf32_External_gptab))))
11080
                    {
11081
                      free (tab);
11082
                      return FALSE;
11083
                    }
11084
 
11085
                  bfd_mips_elf32_swap_gptab_in (input_bfd, &ext_gptab,
11086
                                                &int_gptab);
11087
                  val = int_gptab.gt_entry.gt_g_value;
11088
                  add = int_gptab.gt_entry.gt_bytes - last;
11089
 
11090
                  exact = FALSE;
11091
                  for (look = 1; look < c; look++)
11092
                    {
11093
                      if (tab[look].gt_entry.gt_g_value >= val)
11094
                        tab[look].gt_entry.gt_bytes += add;
11095
 
11096
                      if (tab[look].gt_entry.gt_g_value == val)
11097
                        exact = TRUE;
11098
                    }
11099
 
11100
                  if (! exact)
11101
                    {
11102
                      Elf32_gptab *new_tab;
11103
                      unsigned int max;
11104
 
11105
                      /* We need a new table entry.  */
11106
                      amt = (bfd_size_type) (c + 1) * sizeof (Elf32_gptab);
11107
                      new_tab = bfd_realloc (tab, amt);
11108
                      if (new_tab == NULL)
11109
                        {
11110
                          free (tab);
11111
                          return FALSE;
11112
                        }
11113
                      tab = new_tab;
11114
                      tab[c].gt_entry.gt_g_value = val;
11115
                      tab[c].gt_entry.gt_bytes = add;
11116
 
11117
                      /* Merge in the size for the next smallest -G
11118
                         value, since that will be implied by this new
11119
                         value.  */
11120
                      max = 0;
11121
                      for (look = 1; look < c; look++)
11122
                        {
11123
                          if (tab[look].gt_entry.gt_g_value < val
11124
                              && (max == 0
11125
                                  || (tab[look].gt_entry.gt_g_value
11126
                                      > tab[max].gt_entry.gt_g_value)))
11127
                            max = look;
11128
                        }
11129
                      if (max != 0)
11130
                        tab[c].gt_entry.gt_bytes +=
11131
                          tab[max].gt_entry.gt_bytes;
11132
 
11133
                      ++c;
11134
                    }
11135
 
11136
                  last = int_gptab.gt_entry.gt_bytes;
11137
                }
11138
 
11139
              /* Hack: reset the SEC_HAS_CONTENTS flag so that
11140
                 elf_link_input_bfd ignores this section.  */
11141
              input_section->flags &= ~SEC_HAS_CONTENTS;
11142
            }
11143
 
11144
          /* The table must be sorted by -G value.  */
11145
          if (c > 2)
11146
            qsort (tab + 1, c - 1, sizeof (tab[0]), gptab_compare);
11147
 
11148
          /* Swap out the table.  */
11149
          amt = (bfd_size_type) c * sizeof (Elf32_External_gptab);
11150
          ext_tab = bfd_alloc (abfd, amt);
11151
          if (ext_tab == NULL)
11152
            {
11153
              free (tab);
11154
              return FALSE;
11155
            }
11156
 
11157
          for (j = 0; j < c; j++)
11158
            bfd_mips_elf32_swap_gptab_out (abfd, tab + j, ext_tab + j);
11159
          free (tab);
11160
 
11161
          o->size = c * sizeof (Elf32_External_gptab);
11162
          o->contents = (bfd_byte *) ext_tab;
11163
 
11164
          /* Skip this section later on (I don't think this currently
11165
             matters, but someday it might).  */
11166
          o->map_head.link_order = NULL;
11167
        }
11168
    }
11169
 
11170
  /* Invoke the regular ELF backend linker to do all the work.  */
11171
  if (!bfd_elf_final_link (abfd, info))
11172
    return FALSE;
11173
 
11174
  /* Now write out the computed sections.  */
11175
 
11176
  if (reginfo_sec != NULL)
11177
    {
11178
      Elf32_External_RegInfo ext;
11179
 
11180
      bfd_mips_elf32_swap_reginfo_out (abfd, &reginfo, &ext);
11181
      if (! bfd_set_section_contents (abfd, reginfo_sec, &ext, 0, sizeof ext))
11182
        return FALSE;
11183
    }
11184
 
11185
  if (mdebug_sec != NULL)
11186
    {
11187
      BFD_ASSERT (abfd->output_has_begun);
11188
      if (! bfd_ecoff_write_accumulated_debug (mdebug_handle, abfd, &debug,
11189
                                               swap, info,
11190
                                               mdebug_sec->filepos))
11191
        return FALSE;
11192
 
11193
      bfd_ecoff_debug_free (mdebug_handle, abfd, &debug, swap, info);
11194
    }
11195
 
11196
  if (gptab_data_sec != NULL)
11197
    {
11198
      if (! bfd_set_section_contents (abfd, gptab_data_sec,
11199
                                      gptab_data_sec->contents,
11200
                                      0, gptab_data_sec->size))
11201
        return FALSE;
11202
    }
11203
 
11204
  if (gptab_bss_sec != NULL)
11205
    {
11206
      if (! bfd_set_section_contents (abfd, gptab_bss_sec,
11207
                                      gptab_bss_sec->contents,
11208
                                      0, gptab_bss_sec->size))
11209
        return FALSE;
11210
    }
11211
 
11212
  if (SGI_COMPAT (abfd))
11213
    {
11214
      rtproc_sec = bfd_get_section_by_name (abfd, ".rtproc");
11215
      if (rtproc_sec != NULL)
11216
        {
11217
          if (! bfd_set_section_contents (abfd, rtproc_sec,
11218
                                          rtproc_sec->contents,
11219
                                          0, rtproc_sec->size))
11220
            return FALSE;
11221
        }
11222
    }
11223
 
11224
  return TRUE;
11225
}
11226
 
11227
/* Structure for saying that BFD machine EXTENSION extends BASE.  */
11228
 
11229
struct mips_mach_extension {
11230
  unsigned long extension, base;
11231
};
11232
 
11233
 
11234
/* An array describing how BFD machines relate to one another.  The entries
11235
   are ordered topologically with MIPS I extensions listed last.  */
11236
 
11237
static const struct mips_mach_extension mips_mach_extensions[] = {
11238
  /* MIPS64r2 extensions.  */
11239
  { bfd_mach_mips_octeon, bfd_mach_mipsisa64r2 },
11240
 
11241
  /* MIPS64 extensions.  */
11242
  { bfd_mach_mipsisa64r2, bfd_mach_mipsisa64 },
11243
  { bfd_mach_mips_sb1, bfd_mach_mipsisa64 },
11244
 
11245
  /* MIPS V extensions.  */
11246
  { bfd_mach_mipsisa64, bfd_mach_mips5 },
11247
 
11248
  /* R10000 extensions.  */
11249
  { bfd_mach_mips12000, bfd_mach_mips10000 },
11250
 
11251
  /* R5000 extensions.  Note: the vr5500 ISA is an extension of the core
11252
     vr5400 ISA, but doesn't include the multimedia stuff.  It seems
11253
     better to allow vr5400 and vr5500 code to be merged anyway, since
11254
     many libraries will just use the core ISA.  Perhaps we could add
11255
     some sort of ASE flag if this ever proves a problem.  */
11256
  { bfd_mach_mips5500, bfd_mach_mips5400 },
11257
  { bfd_mach_mips5400, bfd_mach_mips5000 },
11258
 
11259
  /* MIPS IV extensions.  */
11260
  { bfd_mach_mips5, bfd_mach_mips8000 },
11261
  { bfd_mach_mips10000, bfd_mach_mips8000 },
11262
  { bfd_mach_mips5000, bfd_mach_mips8000 },
11263
  { bfd_mach_mips7000, bfd_mach_mips8000 },
11264
  { bfd_mach_mips9000, bfd_mach_mips8000 },
11265
 
11266
  /* VR4100 extensions.  */
11267
  { bfd_mach_mips4120, bfd_mach_mips4100 },
11268
  { bfd_mach_mips4111, bfd_mach_mips4100 },
11269
 
11270
  /* MIPS III extensions.  */
11271
  { bfd_mach_mips_loongson_2e, bfd_mach_mips4000 },
11272
  { bfd_mach_mips_loongson_2f, bfd_mach_mips4000 },
11273
  { bfd_mach_mips8000, bfd_mach_mips4000 },
11274
  { bfd_mach_mips4650, bfd_mach_mips4000 },
11275
  { bfd_mach_mips4600, bfd_mach_mips4000 },
11276
  { bfd_mach_mips4400, bfd_mach_mips4000 },
11277
  { bfd_mach_mips4300, bfd_mach_mips4000 },
11278
  { bfd_mach_mips4100, bfd_mach_mips4000 },
11279
  { bfd_mach_mips4010, bfd_mach_mips4000 },
11280
 
11281
  /* MIPS32 extensions.  */
11282
  { bfd_mach_mipsisa32r2, bfd_mach_mipsisa32 },
11283
 
11284
  /* MIPS II extensions.  */
11285
  { bfd_mach_mips4000, bfd_mach_mips6000 },
11286
  { bfd_mach_mipsisa32, bfd_mach_mips6000 },
11287
 
11288
  /* MIPS I extensions.  */
11289
  { bfd_mach_mips6000, bfd_mach_mips3000 },
11290
  { bfd_mach_mips3900, bfd_mach_mips3000 }
11291
};
11292
 
11293
 
11294
/* Return true if bfd machine EXTENSION is an extension of machine BASE.  */
11295
 
11296
static bfd_boolean
11297
mips_mach_extends_p (unsigned long base, unsigned long extension)
11298
{
11299
  size_t i;
11300
 
11301
  if (extension == base)
11302
    return TRUE;
11303
 
11304
  if (base == bfd_mach_mipsisa32
11305
      && mips_mach_extends_p (bfd_mach_mipsisa64, extension))
11306
    return TRUE;
11307
 
11308
  if (base == bfd_mach_mipsisa32r2
11309
      && mips_mach_extends_p (bfd_mach_mipsisa64r2, extension))
11310
    return TRUE;
11311
 
11312
  for (i = 0; i < ARRAY_SIZE (mips_mach_extensions); i++)
11313
    if (extension == mips_mach_extensions[i].extension)
11314
      {
11315
        extension = mips_mach_extensions[i].base;
11316
        if (extension == base)
11317
          return TRUE;
11318
      }
11319
 
11320
  return FALSE;
11321
}
11322
 
11323
 
11324
/* Return true if the given ELF header flags describe a 32-bit binary.  */
11325
 
11326
static bfd_boolean
11327
mips_32bit_flags_p (flagword flags)
11328
{
11329
  return ((flags & EF_MIPS_32BITMODE) != 0
11330
          || (flags & EF_MIPS_ABI) == E_MIPS_ABI_O32
11331
          || (flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI32
11332
          || (flags & EF_MIPS_ARCH) == E_MIPS_ARCH_1
11333
          || (flags & EF_MIPS_ARCH) == E_MIPS_ARCH_2
11334
          || (flags & EF_MIPS_ARCH) == E_MIPS_ARCH_32
11335
          || (flags & EF_MIPS_ARCH) == E_MIPS_ARCH_32R2);
11336
}
11337
 
11338
 
11339
/* Merge object attributes from IBFD into OBFD.  Raise an error if
11340
   there are conflicting attributes.  */
11341
static bfd_boolean
11342
mips_elf_merge_obj_attributes (bfd *ibfd, bfd *obfd)
11343
{
11344
  obj_attribute *in_attr;
11345
  obj_attribute *out_attr;
11346
 
11347
  if (!elf_known_obj_attributes_proc (obfd)[0].i)
11348
    {
11349
      /* This is the first object.  Copy the attributes.  */
11350
      _bfd_elf_copy_obj_attributes (ibfd, obfd);
11351
 
11352
      /* Use the Tag_null value to indicate the attributes have been
11353
         initialized.  */
11354
      elf_known_obj_attributes_proc (obfd)[0].i = 1;
11355
 
11356
      return TRUE;
11357
    }
11358
 
11359
  /* Check for conflicting Tag_GNU_MIPS_ABI_FP attributes and merge
11360
     non-conflicting ones.  */
11361
  in_attr = elf_known_obj_attributes (ibfd)[OBJ_ATTR_GNU];
11362
  out_attr = elf_known_obj_attributes (obfd)[OBJ_ATTR_GNU];
11363
  if (in_attr[Tag_GNU_MIPS_ABI_FP].i != out_attr[Tag_GNU_MIPS_ABI_FP].i)
11364
    {
11365
      out_attr[Tag_GNU_MIPS_ABI_FP].type = 1;
11366
      if (out_attr[Tag_GNU_MIPS_ABI_FP].i == 0)
11367
        out_attr[Tag_GNU_MIPS_ABI_FP].i = in_attr[Tag_GNU_MIPS_ABI_FP].i;
11368
      else if (in_attr[Tag_GNU_MIPS_ABI_FP].i == 0)
11369
        ;
11370
      else if (in_attr[Tag_GNU_MIPS_ABI_FP].i > 4)
11371
        _bfd_error_handler
11372
          (_("Warning: %B uses unknown floating point ABI %d"), ibfd,
11373
           in_attr[Tag_GNU_MIPS_ABI_FP].i);
11374
      else if (out_attr[Tag_GNU_MIPS_ABI_FP].i > 4)
11375
        _bfd_error_handler
11376
          (_("Warning: %B uses unknown floating point ABI %d"), obfd,
11377
           out_attr[Tag_GNU_MIPS_ABI_FP].i);
11378
      else
11379
        switch (out_attr[Tag_GNU_MIPS_ABI_FP].i)
11380
          {
11381
          case 1:
11382
            switch (in_attr[Tag_GNU_MIPS_ABI_FP].i)
11383
              {
11384
              case 2:
11385
                _bfd_error_handler
11386
                  (_("Warning: %B uses -msingle-float, %B uses -mdouble-float"),
11387
                   obfd, ibfd);
11388
                break;
11389
 
11390
              case 3:
11391
                _bfd_error_handler
11392
                  (_("Warning: %B uses hard float, %B uses soft float"),
11393
                   obfd, ibfd);
11394
                break;
11395
 
11396
              case 4:
11397
                _bfd_error_handler
11398
                  (_("Warning: %B uses -msingle-float, %B uses -mips32r2 -mfp64"),
11399
                   obfd, ibfd);
11400
                break;
11401
 
11402
              default:
11403
                abort ();
11404
              }
11405
            break;
11406
 
11407
          case 2:
11408
            switch (in_attr[Tag_GNU_MIPS_ABI_FP].i)
11409
              {
11410
              case 1:
11411
                _bfd_error_handler
11412
                  (_("Warning: %B uses -msingle-float, %B uses -mdouble-float"),
11413
                   ibfd, obfd);
11414
                break;
11415
 
11416
              case 3:
11417
                _bfd_error_handler
11418
                  (_("Warning: %B uses hard float, %B uses soft float"),
11419
                   obfd, ibfd);
11420
                break;
11421
 
11422
              case 4:
11423
                _bfd_error_handler
11424
                  (_("Warning: %B uses -mdouble-float, %B uses -mips32r2 -mfp64"),
11425
                   obfd, ibfd);
11426
                break;
11427
 
11428
              default:
11429
                abort ();
11430
              }
11431
            break;
11432
 
11433
          case 3:
11434
            switch (in_attr[Tag_GNU_MIPS_ABI_FP].i)
11435
              {
11436
              case 1:
11437
              case 2:
11438
              case 4:
11439
                _bfd_error_handler
11440
                  (_("Warning: %B uses hard float, %B uses soft float"),
11441
                   ibfd, obfd);
11442
                break;
11443
 
11444
              default:
11445
                abort ();
11446
              }
11447
            break;
11448
 
11449
          case 4:
11450
            switch (in_attr[Tag_GNU_MIPS_ABI_FP].i)
11451
              {
11452
              case 1:
11453
                _bfd_error_handler
11454
                  (_("Warning: %B uses -msingle-float, %B uses -mips32r2 -mfp64"),
11455
                   ibfd, obfd);
11456
                break;
11457
 
11458
              case 2:
11459
                _bfd_error_handler
11460
                  (_("Warning: %B uses -mdouble-float, %B uses -mips32r2 -mfp64"),
11461
                   ibfd, obfd);
11462
                break;
11463
 
11464
              case 3:
11465
                _bfd_error_handler
11466
                  (_("Warning: %B uses hard float, %B uses soft float"),
11467
                   obfd, ibfd);
11468
                break;
11469
 
11470
              default:
11471
                abort ();
11472
              }
11473
            break;
11474
 
11475
          default:
11476
            abort ();
11477
          }
11478
    }
11479
 
11480
  /* Merge Tag_compatibility attributes and any common GNU ones.  */
11481
  _bfd_elf_merge_object_attributes (ibfd, obfd);
11482
 
11483
  return TRUE;
11484
}
11485
 
11486
/* Merge backend specific data from an object file to the output
11487
   object file when linking.  */
11488
 
11489
bfd_boolean
11490
_bfd_mips_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
11491
{
11492
  flagword old_flags;
11493
  flagword new_flags;
11494
  bfd_boolean ok;
11495
  bfd_boolean null_input_bfd = TRUE;
11496
  asection *sec;
11497
 
11498
  /* Check if we have the same endianess */
11499
  if (! _bfd_generic_verify_endian_match (ibfd, obfd))
11500
    {
11501
      (*_bfd_error_handler)
11502
        (_("%B: endianness incompatible with that of the selected emulation"),
11503
         ibfd);
11504
      return FALSE;
11505
    }
11506
 
11507
  if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
11508
      || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
11509
    return TRUE;
11510
 
11511
  if (strcmp (bfd_get_target (ibfd), bfd_get_target (obfd)) != 0)
11512
    {
11513
      (*_bfd_error_handler)
11514
        (_("%B: ABI is incompatible with that of the selected emulation"),
11515
         ibfd);
11516
      return FALSE;
11517
    }
11518
 
11519
  if (!mips_elf_merge_obj_attributes (ibfd, obfd))
11520
    return FALSE;
11521
 
11522
  new_flags = elf_elfheader (ibfd)->e_flags;
11523
  elf_elfheader (obfd)->e_flags |= new_flags & EF_MIPS_NOREORDER;
11524
  old_flags = elf_elfheader (obfd)->e_flags;
11525
 
11526
  if (! elf_flags_init (obfd))
11527
    {
11528
      elf_flags_init (obfd) = TRUE;
11529
      elf_elfheader (obfd)->e_flags = new_flags;
11530
      elf_elfheader (obfd)->e_ident[EI_CLASS]
11531
        = elf_elfheader (ibfd)->e_ident[EI_CLASS];
11532
 
11533
      if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
11534
          && (bfd_get_arch_info (obfd)->the_default
11535
              || mips_mach_extends_p (bfd_get_mach (obfd),
11536
                                      bfd_get_mach (ibfd))))
11537
        {
11538
          if (! bfd_set_arch_mach (obfd, bfd_get_arch (ibfd),
11539
                                   bfd_get_mach (ibfd)))
11540
            return FALSE;
11541
        }
11542
 
11543
      return TRUE;
11544
    }
11545
 
11546
  /* Check flag compatibility.  */
11547
 
11548
  new_flags &= ~EF_MIPS_NOREORDER;
11549
  old_flags &= ~EF_MIPS_NOREORDER;
11550
 
11551
  /* Some IRIX 6 BSD-compatibility objects have this bit set.  It
11552
     doesn't seem to matter.  */
11553
  new_flags &= ~EF_MIPS_XGOT;
11554
  old_flags &= ~EF_MIPS_XGOT;
11555
 
11556
  /* MIPSpro generates ucode info in n64 objects.  Again, we should
11557
     just be able to ignore this.  */
11558
  new_flags &= ~EF_MIPS_UCODE;
11559
  old_flags &= ~EF_MIPS_UCODE;
11560
 
11561
  /* Don't care about the PIC flags from dynamic objects; they are
11562
     PIC by design.  */
11563
  if ((new_flags & (EF_MIPS_PIC | EF_MIPS_CPIC)) != 0
11564
      && (ibfd->flags & DYNAMIC) != 0)
11565
    new_flags &= ~ (EF_MIPS_PIC | EF_MIPS_CPIC);
11566
 
11567
  if (new_flags == old_flags)
11568
    return TRUE;
11569
 
11570
  /* Check to see if the input BFD actually contains any sections.
11571
     If not, its flags may not have been initialised either, but it cannot
11572
     actually cause any incompatibility.  */
11573
  for (sec = ibfd->sections; sec != NULL; sec = sec->next)
11574
    {
11575
      /* Ignore synthetic sections and empty .text, .data and .bss sections
11576
          which are automatically generated by gas.  */
11577
      if (strcmp (sec->name, ".reginfo")
11578
          && strcmp (sec->name, ".mdebug")
11579
          && (sec->size != 0
11580
              || (strcmp (sec->name, ".text")
11581
                  && strcmp (sec->name, ".data")
11582
                  && strcmp (sec->name, ".bss"))))
11583
        {
11584
          null_input_bfd = FALSE;
11585
          break;
11586
        }
11587
    }
11588
  if (null_input_bfd)
11589
    return TRUE;
11590
 
11591
  ok = TRUE;
11592
 
11593
  if (((new_flags & (EF_MIPS_PIC | EF_MIPS_CPIC)) != 0)
11594
      != ((old_flags & (EF_MIPS_PIC | EF_MIPS_CPIC)) != 0))
11595
    {
11596
      (*_bfd_error_handler)
11597
        (_("%B: warning: linking PIC files with non-PIC files"),
11598
         ibfd);
11599
      ok = TRUE;
11600
    }
11601
 
11602
  if (new_flags & (EF_MIPS_PIC | EF_MIPS_CPIC))
11603
    elf_elfheader (obfd)->e_flags |= EF_MIPS_CPIC;
11604
  if (! (new_flags & EF_MIPS_PIC))
11605
    elf_elfheader (obfd)->e_flags &= ~EF_MIPS_PIC;
11606
 
11607
  new_flags &= ~ (EF_MIPS_PIC | EF_MIPS_CPIC);
11608
  old_flags &= ~ (EF_MIPS_PIC | EF_MIPS_CPIC);
11609
 
11610
  /* Compare the ISAs.  */
11611
  if (mips_32bit_flags_p (old_flags) != mips_32bit_flags_p (new_flags))
11612
    {
11613
      (*_bfd_error_handler)
11614
        (_("%B: linking 32-bit code with 64-bit code"),
11615
         ibfd);
11616
      ok = FALSE;
11617
    }
11618
  else if (!mips_mach_extends_p (bfd_get_mach (ibfd), bfd_get_mach (obfd)))
11619
    {
11620
      /* OBFD's ISA isn't the same as, or an extension of, IBFD's.  */
11621
      if (mips_mach_extends_p (bfd_get_mach (obfd), bfd_get_mach (ibfd)))
11622
        {
11623
          /* Copy the architecture info from IBFD to OBFD.  Also copy
11624
             the 32-bit flag (if set) so that we continue to recognise
11625
             OBFD as a 32-bit binary.  */
11626
          bfd_set_arch_info (obfd, bfd_get_arch_info (ibfd));
11627
          elf_elfheader (obfd)->e_flags &= ~(EF_MIPS_ARCH | EF_MIPS_MACH);
11628
          elf_elfheader (obfd)->e_flags
11629
            |= new_flags & (EF_MIPS_ARCH | EF_MIPS_MACH | EF_MIPS_32BITMODE);
11630
 
11631
          /* Copy across the ABI flags if OBFD doesn't use them
11632
             and if that was what caused us to treat IBFD as 32-bit.  */
11633
          if ((old_flags & EF_MIPS_ABI) == 0
11634
              && mips_32bit_flags_p (new_flags)
11635
              && !mips_32bit_flags_p (new_flags & ~EF_MIPS_ABI))
11636
            elf_elfheader (obfd)->e_flags |= new_flags & EF_MIPS_ABI;
11637
        }
11638
      else
11639
        {
11640
          /* The ISAs aren't compatible.  */
11641
          (*_bfd_error_handler)
11642
            (_("%B: linking %s module with previous %s modules"),
11643
             ibfd,
11644
             bfd_printable_name (ibfd),
11645
             bfd_printable_name (obfd));
11646
          ok = FALSE;
11647
        }
11648
    }
11649
 
11650
  new_flags &= ~(EF_MIPS_ARCH | EF_MIPS_MACH | EF_MIPS_32BITMODE);
11651
  old_flags &= ~(EF_MIPS_ARCH | EF_MIPS_MACH | EF_MIPS_32BITMODE);
11652
 
11653
  /* Compare ABIs.  The 64-bit ABI does not use EF_MIPS_ABI.  But, it
11654
     does set EI_CLASS differently from any 32-bit ABI.  */
11655
  if ((new_flags & EF_MIPS_ABI) != (old_flags & EF_MIPS_ABI)
11656
      || (elf_elfheader (ibfd)->e_ident[EI_CLASS]
11657
          != elf_elfheader (obfd)->e_ident[EI_CLASS]))
11658
    {
11659
      /* Only error if both are set (to different values).  */
11660
      if (((new_flags & EF_MIPS_ABI) && (old_flags & EF_MIPS_ABI))
11661
          || (elf_elfheader (ibfd)->e_ident[EI_CLASS]
11662
              != elf_elfheader (obfd)->e_ident[EI_CLASS]))
11663
        {
11664
          (*_bfd_error_handler)
11665
            (_("%B: ABI mismatch: linking %s module with previous %s modules"),
11666
             ibfd,
11667
             elf_mips_abi_name (ibfd),
11668
             elf_mips_abi_name (obfd));
11669
          ok = FALSE;
11670
        }
11671
      new_flags &= ~EF_MIPS_ABI;
11672
      old_flags &= ~EF_MIPS_ABI;
11673
    }
11674
 
11675
  /* For now, allow arbitrary mixing of ASEs (retain the union).  */
11676
  if ((new_flags & EF_MIPS_ARCH_ASE) != (old_flags & EF_MIPS_ARCH_ASE))
11677
    {
11678
      elf_elfheader (obfd)->e_flags |= new_flags & EF_MIPS_ARCH_ASE;
11679
 
11680
      new_flags &= ~ EF_MIPS_ARCH_ASE;
11681
      old_flags &= ~ EF_MIPS_ARCH_ASE;
11682
    }
11683
 
11684
  /* Warn about any other mismatches */
11685
  if (new_flags != old_flags)
11686
    {
11687
      (*_bfd_error_handler)
11688
        (_("%B: uses different e_flags (0x%lx) fields than previous modules (0x%lx)"),
11689
         ibfd, (unsigned long) new_flags,
11690
         (unsigned long) old_flags);
11691
      ok = FALSE;
11692
    }
11693
 
11694
  if (! ok)
11695
    {
11696
      bfd_set_error (bfd_error_bad_value);
11697
      return FALSE;
11698
    }
11699
 
11700
  return TRUE;
11701
}
11702
 
11703
/* Function to keep MIPS specific file flags like as EF_MIPS_PIC.  */
11704
 
11705
bfd_boolean
11706
_bfd_mips_elf_set_private_flags (bfd *abfd, flagword flags)
11707
{
11708
  BFD_ASSERT (!elf_flags_init (abfd)
11709
              || elf_elfheader (abfd)->e_flags == flags);
11710
 
11711
  elf_elfheader (abfd)->e_flags = flags;
11712
  elf_flags_init (abfd) = TRUE;
11713
  return TRUE;
11714
}
11715
 
11716
char *
11717
_bfd_mips_elf_get_target_dtag (bfd_vma dtag)
11718
{
11719
  switch (dtag)
11720
    {
11721
    default: return "";
11722
    case DT_MIPS_RLD_VERSION:
11723
      return "MIPS_RLD_VERSION";
11724
    case DT_MIPS_TIME_STAMP:
11725
      return "MIPS_TIME_STAMP";
11726
    case DT_MIPS_ICHECKSUM:
11727
      return "MIPS_ICHECKSUM";
11728
    case DT_MIPS_IVERSION:
11729
      return "MIPS_IVERSION";
11730
    case DT_MIPS_FLAGS:
11731
      return "MIPS_FLAGS";
11732
    case DT_MIPS_BASE_ADDRESS:
11733
      return "MIPS_BASE_ADDRESS";
11734
    case DT_MIPS_MSYM:
11735
      return "MIPS_MSYM";
11736
    case DT_MIPS_CONFLICT:
11737
      return "MIPS_CONFLICT";
11738
    case DT_MIPS_LIBLIST:
11739
      return "MIPS_LIBLIST";
11740
    case DT_MIPS_LOCAL_GOTNO:
11741
      return "MIPS_LOCAL_GOTNO";
11742
    case DT_MIPS_CONFLICTNO:
11743
      return "MIPS_CONFLICTNO";
11744
    case DT_MIPS_LIBLISTNO:
11745
      return "MIPS_LIBLISTNO";
11746
    case DT_MIPS_SYMTABNO:
11747
      return "MIPS_SYMTABNO";
11748
    case DT_MIPS_UNREFEXTNO:
11749
      return "MIPS_UNREFEXTNO";
11750
    case DT_MIPS_GOTSYM:
11751
      return "MIPS_GOTSYM";
11752
    case DT_MIPS_HIPAGENO:
11753
      return "MIPS_HIPAGENO";
11754
    case DT_MIPS_RLD_MAP:
11755
      return "MIPS_RLD_MAP";
11756
    case DT_MIPS_DELTA_CLASS:
11757
      return "MIPS_DELTA_CLASS";
11758
    case DT_MIPS_DELTA_CLASS_NO:
11759
      return "MIPS_DELTA_CLASS_NO";
11760
    case DT_MIPS_DELTA_INSTANCE:
11761
      return "MIPS_DELTA_INSTANCE";
11762
    case DT_MIPS_DELTA_INSTANCE_NO:
11763
      return "MIPS_DELTA_INSTANCE_NO";
11764
    case DT_MIPS_DELTA_RELOC:
11765
      return "MIPS_DELTA_RELOC";
11766
    case DT_MIPS_DELTA_RELOC_NO:
11767
      return "MIPS_DELTA_RELOC_NO";
11768
    case DT_MIPS_DELTA_SYM:
11769
      return "MIPS_DELTA_SYM";
11770
    case DT_MIPS_DELTA_SYM_NO:
11771
      return "MIPS_DELTA_SYM_NO";
11772
    case DT_MIPS_DELTA_CLASSSYM:
11773
      return "MIPS_DELTA_CLASSSYM";
11774
    case DT_MIPS_DELTA_CLASSSYM_NO:
11775
      return "MIPS_DELTA_CLASSSYM_NO";
11776
    case DT_MIPS_CXX_FLAGS:
11777
      return "MIPS_CXX_FLAGS";
11778
    case DT_MIPS_PIXIE_INIT:
11779
      return "MIPS_PIXIE_INIT";
11780
    case DT_MIPS_SYMBOL_LIB:
11781
      return "MIPS_SYMBOL_LIB";
11782
    case DT_MIPS_LOCALPAGE_GOTIDX:
11783
      return "MIPS_LOCALPAGE_GOTIDX";
11784
    case DT_MIPS_LOCAL_GOTIDX:
11785
      return "MIPS_LOCAL_GOTIDX";
11786
    case DT_MIPS_HIDDEN_GOTIDX:
11787
      return "MIPS_HIDDEN_GOTIDX";
11788
    case DT_MIPS_PROTECTED_GOTIDX:
11789
      return "MIPS_PROTECTED_GOT_IDX";
11790
    case DT_MIPS_OPTIONS:
11791
      return "MIPS_OPTIONS";
11792
    case DT_MIPS_INTERFACE:
11793
      return "MIPS_INTERFACE";
11794
    case DT_MIPS_DYNSTR_ALIGN:
11795
      return "DT_MIPS_DYNSTR_ALIGN";
11796
    case DT_MIPS_INTERFACE_SIZE:
11797
      return "DT_MIPS_INTERFACE_SIZE";
11798
    case DT_MIPS_RLD_TEXT_RESOLVE_ADDR:
11799
      return "DT_MIPS_RLD_TEXT_RESOLVE_ADDR";
11800
    case DT_MIPS_PERF_SUFFIX:
11801
      return "DT_MIPS_PERF_SUFFIX";
11802
    case DT_MIPS_COMPACT_SIZE:
11803
      return "DT_MIPS_COMPACT_SIZE";
11804
    case DT_MIPS_GP_VALUE:
11805
      return "DT_MIPS_GP_VALUE";
11806
    case DT_MIPS_AUX_DYNAMIC:
11807
      return "DT_MIPS_AUX_DYNAMIC";
11808
    }
11809
}
11810
 
11811
bfd_boolean
11812
_bfd_mips_elf_print_private_bfd_data (bfd *abfd, void *ptr)
11813
{
11814
  FILE *file = ptr;
11815
 
11816
  BFD_ASSERT (abfd != NULL && ptr != NULL);
11817
 
11818
  /* Print normal ELF private data.  */
11819
  _bfd_elf_print_private_bfd_data (abfd, ptr);
11820
 
11821
  /* xgettext:c-format */
11822
  fprintf (file, _("private flags = %lx:"), elf_elfheader (abfd)->e_flags);
11823
 
11824
  if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI) == E_MIPS_ABI_O32)
11825
    fprintf (file, _(" [abi=O32]"));
11826
  else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI) == E_MIPS_ABI_O64)
11827
    fprintf (file, _(" [abi=O64]"));
11828
  else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI32)
11829
    fprintf (file, _(" [abi=EABI32]"));
11830
  else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64)
11831
    fprintf (file, _(" [abi=EABI64]"));
11832
  else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI))
11833
    fprintf (file, _(" [abi unknown]"));
11834
  else if (ABI_N32_P (abfd))
11835
    fprintf (file, _(" [abi=N32]"));
11836
  else if (ABI_64_P (abfd))
11837
    fprintf (file, _(" [abi=64]"));
11838
  else
11839
    fprintf (file, _(" [no abi set]"));
11840
 
11841
  if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_1)
11842
    fprintf (file, " [mips1]");
11843
  else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_2)
11844
    fprintf (file, " [mips2]");
11845
  else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_3)
11846
    fprintf (file, " [mips3]");
11847
  else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_4)
11848
    fprintf (file, " [mips4]");
11849
  else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_5)
11850
    fprintf (file, " [mips5]");
11851
  else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_32)
11852
    fprintf (file, " [mips32]");
11853
  else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_64)
11854
    fprintf (file, " [mips64]");
11855
  else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_32R2)
11856
    fprintf (file, " [mips32r2]");
11857
  else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_64R2)
11858
    fprintf (file, " [mips64r2]");
11859
  else
11860
    fprintf (file, _(" [unknown ISA]"));
11861
 
11862
  if (elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH_ASE_MDMX)
11863
    fprintf (file, " [mdmx]");
11864
 
11865
  if (elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH_ASE_M16)
11866
    fprintf (file, " [mips16]");
11867
 
11868
  if (elf_elfheader (abfd)->e_flags & EF_MIPS_32BITMODE)
11869
    fprintf (file, " [32bitmode]");
11870
  else
11871
    fprintf (file, _(" [not 32bitmode]"));
11872
 
11873
  if (elf_elfheader (abfd)->e_flags & EF_MIPS_NOREORDER)
11874
    fprintf (file, " [noreorder]");
11875
 
11876
  if (elf_elfheader (abfd)->e_flags & EF_MIPS_PIC)
11877
    fprintf (file, " [PIC]");
11878
 
11879
  if (elf_elfheader (abfd)->e_flags & EF_MIPS_CPIC)
11880
    fprintf (file, " [CPIC]");
11881
 
11882
  if (elf_elfheader (abfd)->e_flags & EF_MIPS_XGOT)
11883
    fprintf (file, " [XGOT]");
11884
 
11885
  if (elf_elfheader (abfd)->e_flags & EF_MIPS_UCODE)
11886
    fprintf (file, " [UCODE]");
11887
 
11888
  fputc ('\n', file);
11889
 
11890
  return TRUE;
11891
}
11892
 
11893
const struct bfd_elf_special_section _bfd_mips_elf_special_sections[] =
11894
{
11895
  { STRING_COMMA_LEN (".lit4"),   0, SHT_PROGBITS,   SHF_ALLOC + SHF_WRITE + SHF_MIPS_GPREL },
11896
  { STRING_COMMA_LEN (".lit8"),   0, SHT_PROGBITS,   SHF_ALLOC + SHF_WRITE + SHF_MIPS_GPREL },
11897
  { STRING_COMMA_LEN (".mdebug"), 0, SHT_MIPS_DEBUG, 0 },
11898
  { STRING_COMMA_LEN (".sbss"),  -2, SHT_NOBITS,     SHF_ALLOC + SHF_WRITE + SHF_MIPS_GPREL },
11899
  { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS,   SHF_ALLOC + SHF_WRITE + SHF_MIPS_GPREL },
11900
  { STRING_COMMA_LEN (".ucode"),  0, SHT_MIPS_UCODE, 0 },
11901
  { NULL,                     0,  0, 0,              0 }
11902
};
11903
 
11904
/* Merge non visibility st_other attributes.  Ensure that the
11905
   STO_OPTIONAL flag is copied into h->other, even if this is not a
11906
   definiton of the symbol.  */
11907
void
11908
_bfd_mips_elf_merge_symbol_attribute (struct elf_link_hash_entry *h,
11909
                                      const Elf_Internal_Sym *isym,
11910
                                      bfd_boolean definition,
11911
                                      bfd_boolean dynamic ATTRIBUTE_UNUSED)
11912
{
11913
  if ((isym->st_other & ~ELF_ST_VISIBILITY (-1)) != 0)
11914
    {
11915
      unsigned char other;
11916
 
11917
      other = (definition ? isym->st_other : h->other);
11918
      other &= ~ELF_ST_VISIBILITY (-1);
11919
      h->other = other | ELF_ST_VISIBILITY (h->other);
11920
    }
11921
 
11922
  if (!definition
11923
      && ELF_MIPS_IS_OPTIONAL (isym->st_other))
11924
    h->other |= STO_OPTIONAL;
11925
}
11926
 
11927
/* Decide whether an undefined symbol is special and can be ignored.
11928
   This is the case for OPTIONAL symbols on IRIX.  */
11929
bfd_boolean
11930
_bfd_mips_elf_ignore_undef_symbol (struct elf_link_hash_entry *h)
11931
{
11932
  return ELF_MIPS_IS_OPTIONAL (h->other) ? TRUE : FALSE;
11933
}
11934
 
11935
bfd_boolean
11936
_bfd_mips_elf_common_definition (Elf_Internal_Sym *sym)
11937
{
11938
  return (sym->st_shndx == SHN_COMMON
11939
          || sym->st_shndx == SHN_MIPS_ACOMMON
11940
          || sym->st_shndx == SHN_MIPS_SCOMMON);
11941
}

powered by: WebSVN 2.1.0

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