bfd/elfxx-mips.c

   1 /* MIPS-specific support for ELF
   2    Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
   3    2003, 2004 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 2 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  27
  28 /* This file handles functionality common to the different MIPS ABI's.  */
  29
  30 #include "bfd.h"
  31 #include "sysdep.h"
  32 #include "libbfd.h"
  33 #include "libiberty.h"
  34 #include "elf-bfd.h"
  35 #include "elfxx-mips.h"
  36 #include "elf/mips.h"
  37
  38 /* Get the ECOFF swapping routines.  */
  39 #include "coff/sym.h"
  40 #include "coff/symconst.h"
  41 #include "coff/ecoff.h"
  42 #include "coff/mips.h"
  43
  44 #include "hashtab.h"
  45
  46 /* This structure is used to hold .got entries while estimating got
  47    sizes.  */
  48 struct mips_got_entry
  49 {
  50   /* The input bfd in which the symbol is defined.  */
  51   bfd *abfd;
  52   /* The index of the symbol, as stored in the relocation r_info, if
  53      we have a local symbol; -1 otherwise.  */
  54   long symndx;
  55   union
  56   {
  57     /* If abfd == NULL, an address that must be stored in the got.  */
  58     bfd_vma address;
  59     /* If abfd != NULL && symndx != -1, the addend of the relocation
  60        that should be added to the symbol value.  */
  61     bfd_vma addend;
  62     /* If abfd != NULL && symndx == -1, the hash table entry
  63        corresponding to a global symbol in the got (or, local, if
  64        h->forced_local).  */
  65     struct mips_elf_link_hash_entry *h;
  66   } d;
  67   /* The offset from the beginning of the .got section to the entry
  68      corresponding to this symbol+addend.  If it's a global symbol
  69      whose offset is yet to be decided, it's going to be -1.  */
  70   long gotidx;
  71 };
  72
  73 /* This structure is used to hold .got information when linking.  */
  74
  75 struct mips_got_info
  76 {
  77   /* The global symbol in the GOT with the lowest index in the dynamic
  78      symbol table.  */
  79   struct elf_link_hash_entry *global_gotsym;
  80   /* The number of global .got entries.  */
  81   unsigned int global_gotno;
  82   /* The number of local .got entries.  */
  83   unsigned int local_gotno;
  84   /* The number of local .got entries we have used.  */
  85   unsigned int assigned_gotno;
  86   /* A hash table holding members of the got.  */
  87   struct htab *got_entries;
  88   /* A hash table mapping input bfds to other mips_got_info.  NULL
  89      unless multi-got was necessary.  */
  90   struct htab *bfd2got;
  91   /* In multi-got links, a pointer to the next got (err, rather, most
  92      of the time, it points to the previous got).  */
  93   struct mips_got_info *next;
  94 };
  95
  96 /* Map an input bfd to a got in a multi-got link.  */
  97
  98 struct mips_elf_bfd2got_hash {
  99   bfd *bfd;
 100   struct mips_got_info *g;
 101 };
 102
 103 /* Structure passed when traversing the bfd2got hash table, used to
 104    create and merge bfd's gots.  */
 105
 106 struct mips_elf_got_per_bfd_arg
 107 {
 108   /* A hashtable that maps bfds to gots.  */
 109   htab_t bfd2got;
 110   /* The output bfd.  */
 111   bfd *obfd;
 112   /* The link information.  */
 113   struct bfd_link_info *info;
 114   /* A pointer to the primary got, i.e., the one that's going to get
 115      the implicit relocations from DT_MIPS_LOCAL_GOTNO and
 116      DT_MIPS_GOTSYM.  */
 117   struct mips_got_info *primary;
 118   /* A non-primary got we're trying to merge with other input bfd's
 119      gots.  */
 120   struct mips_got_info *current;
 121   /* The maximum number of got entries that can be addressed with a
 122      16-bit offset.  */
 123   unsigned int max_count;
 124   /* The number of local and global entries in the primary got.  */
 125   unsigned int primary_count;
 126   /* The number of local and global entries in the current got.  */
 127   unsigned int current_count;
 128 };
 129
 130 /* Another structure used to pass arguments for got entries traversal.  */
 131
 132 struct mips_elf_set_global_got_offset_arg
 133 {
 134   struct mips_got_info *g;
 135   int value;
 136   unsigned int needed_relocs;
 137   struct bfd_link_info *info;
 138 };
 139
 140 struct _mips_elf_section_data
 141 {
 142   struct bfd_elf_section_data elf;
 143   union
 144   {
 145     struct mips_got_info *got_info;
 146     bfd_byte *tdata;
 147   } u;
 148 };
 149
 150 #define mips_elf_section_data(sec) \
 151   ((struct _mips_elf_section_data *) elf_section_data (sec))
 152
 153 /* This structure is passed to mips_elf_sort_hash_table_f when sorting
 154    the dynamic symbols.  */
 155
 156 struct mips_elf_hash_sort_data
 157 {
 158   /* The symbol in the global GOT with the lowest dynamic symbol table
 159      index.  */
 160   struct elf_link_hash_entry *low;
 161   /* The least dynamic symbol table index corresponding to a symbol
 162      with a GOT entry.  */
 163   long min_got_dynindx;
 164   /* The greatest dynamic symbol table index corresponding to a symbol
 165      with a GOT entry that is not referenced (e.g., a dynamic symbol
 166      with dynamic relocations pointing to it from non-primary GOTs).  */
 167   long max_unref_got_dynindx;
 168   /* The greatest dynamic symbol table index not corresponding to a
 169      symbol without a GOT entry.  */
 170   long max_non_got_dynindx;
 171 };
 172
 173 /* The MIPS ELF linker needs additional information for each symbol in
 174    the global hash table.  */
 175
 176 struct mips_elf_link_hash_entry
 177 {
 178   struct elf_link_hash_entry root;
 179
 180   /* External symbol information.  */
 181   EXTR esym;
 182
 183   /* Number of R_MIPS_32, R_MIPS_REL32, or R_MIPS_64 relocs against
 184      this symbol.  */
 185   unsigned int possibly_dynamic_relocs;
 186
 187   /* If the R_MIPS_32, R_MIPS_REL32, or R_MIPS_64 reloc is against
 188      a readonly section.  */
 189   bfd_boolean readonly_reloc;
 190
 191   /* We must not create a stub for a symbol that has relocations
 192      related to taking the function's address, i.e. any but
 193      R_MIPS_CALL*16 ones -- see "MIPS ABI Supplement, 3rd Edition",
 194      p. 4-20.  */
 195   bfd_boolean no_fn_stub;
 196
 197   /* If there is a stub that 32 bit functions should use to call this
 198      16 bit function, this points to the section containing the stub.  */
 199   asection *fn_stub;
 200
 201   /* Whether we need the fn_stub; this is set if this symbol appears
 202      in any relocs other than a 16 bit call.  */
 203   bfd_boolean need_fn_stub;
 204
 205   /* If there is a stub that 16 bit functions should use to call this
 206      32 bit function, this points to the section containing the stub.  */
 207   asection *call_stub;
 208
 209   /* This is like the call_stub field, but it is used if the function
 210      being called returns a floating point value.  */
 211   asection *call_fp_stub;
 212
 213   /* Are we forced local?  .*/
 214   bfd_boolean forced_local;
 215 };
 216
 217 /* MIPS ELF linker hash table.  */
 218
 219 struct mips_elf_link_hash_table
 220 {
 221   struct elf_link_hash_table root;
 222 #if 0
 223   /* We no longer use this.  */
 224   /* String section indices for the dynamic section symbols.  */
 225   bfd_size_type dynsym_sec_strindex[SIZEOF_MIPS_DYNSYM_SECNAMES];
 226 #endif
 227   /* The number of .rtproc entries.  */
 228   bfd_size_type procedure_count;
 229   /* The size of the .compact_rel section (if SGI_COMPAT).  */
 230   bfd_size_type compact_rel_size;
 231   /* This flag indicates that the value of DT_MIPS_RLD_MAP dynamic
 232      entry is set to the address of __rld_obj_head as in IRIX5.  */
 233   bfd_boolean use_rld_obj_head;
 234   /* This is the value of the __rld_map or __rld_obj_head symbol.  */
 235   bfd_vma rld_value;
 236   /* This is set if we see any mips16 stub sections.  */
 237   bfd_boolean mips16_stubs_seen;
 238 };
 239
 240 /* Structure used to pass information to mips_elf_output_extsym.  */
 241
 242 struct extsym_info
 243 {
 244   bfd *abfd;
 245   struct bfd_link_info *info;
 246   struct ecoff_debug_info *debug;
 247   const struct ecoff_debug_swap *swap;
 248   bfd_boolean failed;
 249 };
 250
 251 /* The names of the runtime procedure table symbols used on IRIX5.  */
 252
 253 static const char * const mips_elf_dynsym_rtproc_names[] =
 254 {
 255   "_procedure_table",
 256   "_procedure_string_table",
 257   "_procedure_table_size",
 258   NULL
 259 };
 260
 261 /* These structures are used to generate the .compact_rel section on
 262    IRIX5.  */
 263
 264 typedef struct
 265 {
 266   unsigned long id1;            /* Always one?  */
 267   unsigned long num;            /* Number of compact relocation entries.  */
 268   unsigned long id2;            /* Always two?  */
 269   unsigned long offset;         /* The file offset of the first relocation.  */
 270   unsigned long reserved0;      /* Zero?  */
 271   unsigned long reserved1;      /* Zero?  */
 272 } Elf32_compact_rel;
 273
 274 typedef struct
 275 {
 276   bfd_byte id1[4];
 277   bfd_byte num[4];
 278   bfd_byte id2[4];
 279   bfd_byte offset[4];
 280   bfd_byte reserved0[4];
 281   bfd_byte reserved1[4];
 282 } Elf32_External_compact_rel;
 283
 284 typedef struct
 285 {
 286   unsigned int ctype : 1;       /* 1: long 0: short format. See below.  */
 287   unsigned int rtype : 4;       /* Relocation types. See below.  */
 288   unsigned int dist2to : 8;
 289   unsigned int relvaddr : 19;   /* (VADDR - vaddr of the previous entry)/ 4 */
 290   unsigned long konst;          /* KONST field. See below.  */
 291   unsigned long vaddr;          /* VADDR to be relocated.  */
 292 } Elf32_crinfo;
 293
 294 typedef struct
 295 {
 296   unsigned int ctype : 1;       /* 1: long 0: short format. See below.  */
 297   unsigned int rtype : 4;       /* Relocation types. See below.  */
 298   unsigned int dist2to : 8;
 299   unsigned int relvaddr : 19;   /* (VADDR - vaddr of the previous entry)/ 4 */
 300   unsigned long konst;          /* KONST field. See below.  */
 301 } Elf32_crinfo2;
 302
 303 typedef struct
 304 {
 305   bfd_byte info[4];
 306   bfd_byte konst[4];
 307   bfd_byte vaddr[4];
 308 } Elf32_External_crinfo;
 309
 310 typedef struct
 311 {
 312   bfd_byte info[4];
 313   bfd_byte konst[4];
 314 } Elf32_External_crinfo2;
 315
 316 /* These are the constants used to swap the bitfields in a crinfo.  */
 317
 318 #define CRINFO_CTYPE (0x1)
 319 #define CRINFO_CTYPE_SH (31)
 320 #define CRINFO_RTYPE (0xf)
 321 #define CRINFO_RTYPE_SH (27)
 322 #define CRINFO_DIST2TO (0xff)
 323 #define CRINFO_DIST2TO_SH (19)
 324 #define CRINFO_RELVADDR (0x7ffff)
 325 #define CRINFO_RELVADDR_SH (0)
 326
 327 /* A compact relocation info has long (3 words) or short (2 words)
 328    formats.  A short format doesn't have VADDR field and relvaddr
 329    fields contains ((VADDR - vaddr of the previous entry) >> 2).  */
 330 #define CRF_MIPS_LONG                   1
 331 #define CRF_MIPS_SHORT                  0
 332
 333 /* There are 4 types of compact relocation at least. The value KONST
 334    has different meaning for each type:
 335
 336    (type)               (konst)
 337    CT_MIPS_REL32        Address in data
 338    CT_MIPS_WORD         Address in word (XXX)
 339    CT_MIPS_GPHI_LO      GP - vaddr
 340    CT_MIPS_JMPAD        Address to jump
 341    */
 342
 343 #define CRT_MIPS_REL32                  0xa
 344 #define CRT_MIPS_WORD                   0xb
 345 #define CRT_MIPS_GPHI_LO                0xc
 346 #define CRT_MIPS_JMPAD                  0xd
 347
 348 #define mips_elf_set_cr_format(x,format)        ((x).ctype = (format))
 349 #define mips_elf_set_cr_type(x,type)            ((x).rtype = (type))
 350 #define mips_elf_set_cr_dist2to(x,v)            ((x).dist2to = (v))
 351 #define mips_elf_set_cr_relvaddr(x,d)           ((x).relvaddr = (d)<<2)
 352 \f
 353 /* The structure of the runtime procedure descriptor created by the
 354    loader for use by the static exception system.  */
 355
 356 typedef struct runtime_pdr {
 357         bfd_vma adr;            /* Memory address of start of procedure.  */
 358         long    regmask;        /* Save register mask.  */
 359         long    regoffset;      /* Save register offset.  */
 360         long    fregmask;       /* Save floating point register mask.  */
 361         long    fregoffset;     /* Save floating point register offset.  */
 362         long    frameoffset;    /* Frame size.  */
 363         short   framereg;       /* Frame pointer register.  */
 364         short   pcreg;          /* Offset or reg of return pc.  */
 365         long    irpss;          /* Index into the runtime string table.  */
 366         long    reserved;
 367         struct exception_info *exception_info;/* Pointer to exception array.  */
 368 } RPDR, *pRPDR;
 369 #define cbRPDR sizeof (RPDR)
 370 #define rpdNil ((pRPDR) 0)
 371 \f
 372 static struct bfd_hash_entry *mips_elf_link_hash_newfunc
 373   (struct bfd_hash_entry *, struct bfd_hash_table *, const char *);
 374 static void ecoff_swap_rpdr_out
 375   (bfd *, const RPDR *, struct rpdr_ext *);
 376 static bfd_boolean mips_elf_create_procedure_table
 377   (void *, bfd *, struct bfd_link_info *, asection *,
 378    struct ecoff_debug_info *);
 379 static bfd_boolean mips_elf_check_mips16_stubs
 380   (struct mips_elf_link_hash_entry *, void *);
 381 static void bfd_mips_elf32_swap_gptab_in
 382   (bfd *, const Elf32_External_gptab *, Elf32_gptab *);
 383 static void bfd_mips_elf32_swap_gptab_out
 384   (bfd *, const Elf32_gptab *, Elf32_External_gptab *);
 385 static void bfd_elf32_swap_compact_rel_out
 386   (bfd *, const Elf32_compact_rel *, Elf32_External_compact_rel *);
 387 static void bfd_elf32_swap_crinfo_out
 388   (bfd *, const Elf32_crinfo *, Elf32_External_crinfo *);
 389 static int sort_dynamic_relocs
 390   (const void *, const void *);
 391 static int sort_dynamic_relocs_64
 392   (const void *, const void *);
 393 static bfd_boolean mips_elf_output_extsym
 394   (struct mips_elf_link_hash_entry *, void *);
 395 static int gptab_compare
 396   (const void *, const void *);
 397 static asection *mips_elf_rel_dyn_section
 398   (bfd *, bfd_boolean);
 399 static asection *mips_elf_got_section
 400   (bfd *, bfd_boolean);
 401 static struct mips_got_info *mips_elf_got_info
 402   (bfd *, asection **);
 403 static bfd_vma mips_elf_local_got_index
 404   (bfd *, bfd *, struct bfd_link_info *, bfd_vma);
 405 static bfd_vma mips_elf_global_got_index
 406   (bfd *, bfd *, struct elf_link_hash_entry *);
 407 static bfd_vma mips_elf_got_page
 408   (bfd *, bfd *, struct bfd_link_info *, bfd_vma, bfd_vma *);
 409 static bfd_vma mips_elf_got16_entry
 410   (bfd *, bfd *, struct bfd_link_info *, bfd_vma, bfd_boolean);
 411 static bfd_vma mips_elf_got_offset_from_index
 412   (bfd *, bfd *, bfd *, bfd_vma);
 413 static struct mips_got_entry *mips_elf_create_local_got_entry
 414   (bfd *, bfd *, struct mips_got_info *, asection *, bfd_vma);
 415 static bfd_boolean mips_elf_sort_hash_table
 416   (struct bfd_link_info *, unsigned long);
 417 static bfd_boolean mips_elf_sort_hash_table_f
 418   (struct mips_elf_link_hash_entry *, void *);
 419 static bfd_boolean mips_elf_record_local_got_symbol
 420   (bfd *, long, bfd_vma, struct mips_got_info *);
 421 static bfd_boolean mips_elf_record_global_got_symbol
 422   (struct elf_link_hash_entry *, bfd *, struct bfd_link_info *,
 423    struct mips_got_info *);
 424 static const Elf_Internal_Rela *mips_elf_next_relocation
 425   (bfd *, unsigned int, const Elf_Internal_Rela *, const Elf_Internal_Rela *);
 426 static bfd_boolean mips_elf_local_relocation_p
 427   (bfd *, const Elf_Internal_Rela *, asection **, bfd_boolean);
 428 static bfd_boolean mips_elf_overflow_p
 429   (bfd_vma, int);
 430 static bfd_vma mips_elf_high
 431   (bfd_vma);
 432 static bfd_vma mips_elf_higher
 433   (bfd_vma);
 434 static bfd_vma mips_elf_highest
 435   (bfd_vma);
 436 static bfd_boolean mips_elf_create_compact_rel_section
 437   (bfd *, struct bfd_link_info *);
 438 static bfd_boolean mips_elf_create_got_section
 439   (bfd *, struct bfd_link_info *, bfd_boolean);
 440 static bfd_reloc_status_type mips_elf_calculate_relocation
 441   (bfd *, bfd *, asection *, struct bfd_link_info *,
 442    const Elf_Internal_Rela *, bfd_vma, reloc_howto_type *,
 443    Elf_Internal_Sym *, asection **, bfd_vma *, const char **,
 444    bfd_boolean *, bfd_boolean);
 445 static bfd_vma mips_elf_obtain_contents
 446   (reloc_howto_type *, const Elf_Internal_Rela *, bfd *, bfd_byte *);
 447 static bfd_boolean mips_elf_perform_relocation
 448   (struct bfd_link_info *, reloc_howto_type *, const Elf_Internal_Rela *,
 449    bfd_vma, bfd *, asection *, bfd_byte *, bfd_boolean);
 450 static bfd_boolean mips_elf_stub_section_p
 451   (bfd *, asection *);
 452 static void mips_elf_allocate_dynamic_relocations
 453   (bfd *, unsigned int);
 454 static bfd_boolean mips_elf_create_dynamic_relocation
 455   (bfd *, struct bfd_link_info *, const Elf_Internal_Rela *,
 456    struct mips_elf_link_hash_entry *, asection *, bfd_vma,
 457    bfd_vma *, asection *);
 458 static void mips_set_isa_flags
 459   (bfd *);
 460 static INLINE char *elf_mips_abi_name
 461   (bfd *);
 462 static void mips_elf_irix6_finish_dynamic_symbol
 463   (bfd *, const char *, Elf_Internal_Sym *);
 464 static bfd_boolean mips_mach_extends_p
 465   (unsigned long, unsigned long);
 466 static bfd_boolean mips_32bit_flags_p
 467   (flagword);
 468 static INLINE hashval_t mips_elf_hash_bfd_vma
 469   (bfd_vma);
 470 static hashval_t mips_elf_got_entry_hash
 471   (const void *);
 472 static int mips_elf_got_entry_eq
 473   (const void *, const void *);
 474
 475 static bfd_boolean mips_elf_multi_got
 476   (bfd *, struct bfd_link_info *, struct mips_got_info *,
 477    asection *, bfd_size_type);
 478 static hashval_t mips_elf_multi_got_entry_hash
 479   (const void *);
 480 static int mips_elf_multi_got_entry_eq
 481   (const void *, const void *);
 482 static hashval_t mips_elf_bfd2got_entry_hash
 483   (const void *);
 484 static int mips_elf_bfd2got_entry_eq
 485   (const void *, const void *);
 486 static int mips_elf_make_got_per_bfd
 487   (void **, void *);
 488 static int mips_elf_merge_gots
 489   (void **, void *);
 490 static int mips_elf_set_global_got_offset
 491   (void **, void *);
 492 static int mips_elf_set_no_stub
 493   (void **, void *);
 494 static int mips_elf_resolve_final_got_entry
 495   (void **, void *);
 496 static void mips_elf_resolve_final_got_entries
 497   (struct mips_got_info *);
 498 static bfd_vma mips_elf_adjust_gp
 499   (bfd *, struct mips_got_info *, bfd *);
 500 static struct mips_got_info *mips_elf_got_for_ibfd
 501   (struct mips_got_info *, bfd *);
 502
 503 /* This will be used when we sort the dynamic relocation records.  */
 504 static bfd *reldyn_sorting_bfd;
 505
 506 /* Nonzero if ABFD is using the N32 ABI.  */
 507
 508 #define ABI_N32_P(abfd) \
 509   ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI2) != 0)
 510
 511 /* Nonzero if ABFD is using the N64 ABI.  */
 512 #define ABI_64_P(abfd) \
 513   (get_elf_backend_data (abfd)->s->elfclass == ELFCLASS64)
 514
 515 /* Nonzero if ABFD is using NewABI conventions.  */
 516 #define NEWABI_P(abfd) (ABI_N32_P (abfd) || ABI_64_P (abfd))
 517
 518 /* The IRIX compatibility level we are striving for.  */
 519 #define IRIX_COMPAT(abfd) \
 520   (get_elf_backend_data (abfd)->elf_backend_mips_irix_compat (abfd))
 521
 522 /* Whether we are trying to be compatible with IRIX at all.  */
 523 #define SGI_COMPAT(abfd) \
 524   (IRIX_COMPAT (abfd) != ict_none)
 525
 526 /* The name of the options section.  */
 527 #define MIPS_ELF_OPTIONS_SECTION_NAME(abfd) \
 528   (NEWABI_P (abfd) ? ".MIPS.options" : ".options")
 529
 530 /* The name of the stub section.  */
 531 #define MIPS_ELF_STUB_SECTION_NAME(abfd) ".MIPS.stubs"
 532
 533 /* The size of an external REL relocation.  */
 534 #define MIPS_ELF_REL_SIZE(abfd) \
 535   (get_elf_backend_data (abfd)->s->sizeof_rel)
 536
 537 /* The size of an external dynamic table entry.  */
 538 #define MIPS_ELF_DYN_SIZE(abfd) \
 539   (get_elf_backend_data (abfd)->s->sizeof_dyn)
 540
 541 /* The size of a GOT entry.  */
 542 #define MIPS_ELF_GOT_SIZE(abfd) \
 543   (get_elf_backend_data (abfd)->s->arch_size / 8)
 544
 545 /* The size of a symbol-table entry.  */
 546 #define MIPS_ELF_SYM_SIZE(abfd) \
 547   (get_elf_backend_data (abfd)->s->sizeof_sym)
 548
 549 /* The default alignment for sections, as a power of two.  */
 550 #define MIPS_ELF_LOG_FILE_ALIGN(abfd)                           \
 551   (get_elf_backend_data (abfd)->s->log_file_align)
 552
 553 /* Get word-sized data.  */
 554 #define MIPS_ELF_GET_WORD(abfd, ptr) \
 555   (ABI_64_P (abfd) ? bfd_get_64 (abfd, ptr) : bfd_get_32 (abfd, ptr))
 556
 557 /* Put out word-sized data.  */
 558 #define MIPS_ELF_PUT_WORD(abfd, val, ptr)       \
 559   (ABI_64_P (abfd)                              \
 560    ? bfd_put_64 (abfd, val, ptr)                \
 561    : bfd_put_32 (abfd, val, ptr))
 562
 563 /* Add a dynamic symbol table-entry.  */
 564 #define MIPS_ELF_ADD_DYNAMIC_ENTRY(info, tag, val)      \
 565   _bfd_elf_add_dynamic_entry (info, tag, val)
 566
 567 #define MIPS_ELF_RTYPE_TO_HOWTO(abfd, rtype, rela)                      \
 568   (get_elf_backend_data (abfd)->elf_backend_mips_rtype_to_howto (rtype, rela))
 569
 570 /* Determine whether the internal relocation of index REL_IDX is REL
 571    (zero) or RELA (non-zero).  The assumption is that, if there are
 572    two relocation sections for this section, one of them is REL and
 573    the other is RELA.  If the index of the relocation we're testing is
 574    in range for the first relocation section, check that the external
 575    relocation size is that for RELA.  It is also assumed that, if
 576    rel_idx is not in range for the first section, and this first
 577    section contains REL relocs, then the relocation is in the second
 578    section, that is RELA.  */
 579 #define MIPS_RELOC_RELA_P(abfd, sec, rel_idx)                           \
 580   ((NUM_SHDR_ENTRIES (&elf_section_data (sec)->rel_hdr)                 \
 581     * get_elf_backend_data (abfd)->s->int_rels_per_ext_rel              \
 582     > (bfd_vma)(rel_idx))                                               \
 583    == (elf_section_data (sec)->rel_hdr.sh_entsize                       \
 584        == (ABI_64_P (abfd) ? sizeof (Elf64_External_Rela)               \
 585            : sizeof (Elf32_External_Rela))))
 586
 587 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value
 588    from smaller values.  Start with zero, widen, *then* decrement.  */
 589 #define MINUS_ONE       (((bfd_vma)0) - 1)
 590 #define MINUS_TWO       (((bfd_vma)0) - 2)
 591
 592 /* The number of local .got entries we reserve.  */
 593 #define MIPS_RESERVED_GOTNO (2)
 594
 595 /* The offset of $gp from the beginning of the .got section.  */
 596 #define ELF_MIPS_GP_OFFSET(abfd) (0x7ff0)
 597
 598 /* The maximum size of the GOT for it to be addressable using 16-bit
 599    offsets from $gp.  */
 600 #define MIPS_ELF_GOT_MAX_SIZE(abfd) (ELF_MIPS_GP_OFFSET(abfd) + 0x7fff)
 601
 602 /* Instructions which appear in a stub.  */
 603 #define STUB_LW(abfd)                                           \
 604   ((ABI_64_P (abfd)                                             \
 605     ? 0xdf998010                /* ld t9,0x8010(gp) */          \
 606     : 0x8f998010))              /* lw t9,0x8010(gp) */
 607 #define STUB_MOVE(abfd)                                         \
 608    ((ABI_64_P (abfd)                                            \
 609      ? 0x03e0782d               /* daddu t7,ra */               \
 610      : 0x03e07821))             /* addu t7,ra */
 611 #define STUB_JALR 0x0320f809    /* jalr t9,ra */
 612 #define STUB_LI16(abfd)                                         \
 613   ((ABI_64_P (abfd)                                             \
 614    ? 0x64180000                 /* daddiu t8,zero,0 */          \
 615    : 0x24180000))               /* addiu t8,zero,0 */
 616 #define MIPS_FUNCTION_STUB_SIZE (16)
 617
 618 /* The name of the dynamic interpreter.  This is put in the .interp
 619    section.  */
 620
 621 #define ELF_DYNAMIC_INTERPRETER(abfd)           \
 622    (ABI_N32_P (abfd) ? "/usr/lib32/libc.so.1"   \
 623     : ABI_64_P (abfd) ? "/usr/lib64/libc.so.1"  \
 624     : "/usr/lib/libc.so.1")
 625
 626 #ifdef BFD64
 627 #define MNAME(bfd,pre,pos) \
 628   (ABI_64_P (bfd) ? CONCAT4 (pre,64,_,pos) : CONCAT4 (pre,32,_,pos))
 629 #define ELF_R_SYM(bfd, i)                                       \
 630   (ABI_64_P (bfd) ? ELF64_R_SYM (i) : ELF32_R_SYM (i))
 631 #define ELF_R_TYPE(bfd, i)                                      \
 632   (ABI_64_P (bfd) ? ELF64_MIPS_R_TYPE (i) : ELF32_R_TYPE (i))
 633 #define ELF_R_INFO(bfd, s, t)                                   \
 634   (ABI_64_P (bfd) ? ELF64_R_INFO (s, t) : ELF32_R_INFO (s, t))
 635 #else
 636 #define MNAME(bfd,pre,pos) CONCAT4 (pre,32,_,pos)
 637 #define ELF_R_SYM(bfd, i)                                       \
 638   (ELF32_R_SYM (i))
 639 #define ELF_R_TYPE(bfd, i)                                      \
 640   (ELF32_R_TYPE (i))
 641 #define ELF_R_INFO(bfd, s, t)                                   \
 642   (ELF32_R_INFO (s, t))
 643 #endif
 644 \f
 645   /* The mips16 compiler uses a couple of special sections to handle
 646      floating point arguments.
 647
 648      Section names that look like .mips16.fn.FNNAME contain stubs that
 649      copy floating point arguments from the fp regs to the gp regs and
 650      then jump to FNNAME.  If any 32 bit function calls FNNAME, the
 651      call should be redirected to the stub instead.  If no 32 bit
 652      function calls FNNAME, the stub should be discarded.  We need to
 653      consider any reference to the function, not just a call, because
 654      if the address of the function is taken we will need the stub,
 655      since the address might be passed to a 32 bit function.
 656
 657      Section names that look like .mips16.call.FNNAME contain stubs
 658      that copy floating point arguments from the gp regs to the fp
 659      regs and then jump to FNNAME.  If FNNAME is a 32 bit function,
 660      then any 16 bit function that calls FNNAME should be redirected
 661      to the stub instead.  If FNNAME is not a 32 bit function, the
 662      stub should be discarded.
 663
 664      .mips16.call.fp.FNNAME sections are similar, but contain stubs
 665      which call FNNAME and then copy the return value from the fp regs
 666      to the gp regs.  These stubs store the return value in $18 while
 667      calling FNNAME; any function which might call one of these stubs
 668      must arrange to save $18 around the call.  (This case is not
 669      needed for 32 bit functions that call 16 bit functions, because
 670      16 bit functions always return floating point values in both
 671      $f0/$f1 and $2/$3.)
 672
 673      Note that in all cases FNNAME might be defined statically.
 674      Therefore, FNNAME is not used literally.  Instead, the relocation
 675      information will indicate which symbol the section is for.
 676
 677      We record any stubs that we find in the symbol table.  */
 678
 679 #define FN_STUB ".mips16.fn."
 680 #define CALL_STUB ".mips16.call."
 681 #define CALL_FP_STUB ".mips16.call.fp."
 682 \f
 683 /* Look up an entry in a MIPS ELF linker hash table.  */
 684
 685 #define mips_elf_link_hash_lookup(table, string, create, copy, follow)  \
 686   ((struct mips_elf_link_hash_entry *)                                  \
 687    elf_link_hash_lookup (&(table)->root, (string), (create),            \
 688                          (copy), (follow)))
 689
 690 /* Traverse a MIPS ELF linker hash table.  */
 691
 692 #define mips_elf_link_hash_traverse(table, func, info)                  \
 693   (elf_link_hash_traverse                                               \
 694    (&(table)->root,                                                     \
 695     (bfd_boolean (*) (struct elf_link_hash_entry *, void *)) (func),    \
 696     (info)))
 697
 698 /* Get the MIPS ELF linker hash table from a link_info structure.  */
 699
 700 #define mips_elf_hash_table(p) \
 701   ((struct mips_elf_link_hash_table *) ((p)->hash))
 702
 703 /* Create an entry in a MIPS ELF linker hash table.  */
 704
 705 static struct bfd_hash_entry *
 706 mips_elf_link_hash_newfunc (struct bfd_hash_entry *entry,
 707                             struct bfd_hash_table *table, const char *string)
 708 {
 709   struct mips_elf_link_hash_entry *ret =
 710     (struct mips_elf_link_hash_entry *) entry;
 711
 712   /* Allocate the structure if it has not already been allocated by a
 713      subclass.  */
 714   if (ret == NULL)
 715     ret = bfd_hash_allocate (table, sizeof (struct mips_elf_link_hash_entry));
 716   if (ret == NULL)
 717     return (struct bfd_hash_entry *) ret;
 718
 719   /* Call the allocation method of the superclass.  */
 720   ret = ((struct mips_elf_link_hash_entry *)
 721          _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
 722                                      table, string));
 723   if (ret != NULL)
 724     {
 725       /* Set local fields.  */
 726       memset (&ret->esym, 0, sizeof (EXTR));
 727       /* We use -2 as a marker to indicate that the information has
 728          not been set.  -1 means there is no associated ifd.  */
 729       ret->esym.ifd = -2;
 730       ret->possibly_dynamic_relocs = 0;
 731       ret->readonly_reloc = FALSE;
 732       ret->no_fn_stub = FALSE;
 733       ret->fn_stub = NULL;
 734       ret->need_fn_stub = FALSE;
 735       ret->call_stub = NULL;
 736       ret->call_fp_stub = NULL;
 737       ret->forced_local = FALSE;
 738     }
 739
 740   return (struct bfd_hash_entry *) ret;
 741 }
 742
 743 bfd_boolean
 744 _bfd_mips_elf_new_section_hook (bfd *abfd, asection *sec)
 745 {
 746   struct _mips_elf_section_data *sdata;
 747   bfd_size_type amt = sizeof (*sdata);
 748
 749   sdata = bfd_zalloc (abfd, amt);
 750   if (sdata == NULL)
 751     return FALSE;
 752   sec->used_by_bfd = sdata;
 753
 754   return _bfd_elf_new_section_hook (abfd, sec);
 755 }
 756 \f
 757 /* Read ECOFF debugging information from a .mdebug section into a
 758    ecoff_debug_info structure.  */
 759
 760 bfd_boolean
 761 _bfd_mips_elf_read_ecoff_info (bfd *abfd, asection *section,
 762                                struct ecoff_debug_info *debug)
 763 {
 764   HDRR *symhdr;
 765   const struct ecoff_debug_swap *swap;
 766   char *ext_hdr;
 767
 768   swap = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
 769   memset (debug, 0, sizeof (*debug));
 770
 771   ext_hdr = bfd_malloc (swap->external_hdr_size);
 772   if (ext_hdr == NULL && swap->external_hdr_size != 0)
 773     goto error_return;
 774
 775   if (! bfd_get_section_contents (abfd, section, ext_hdr, 0,
 776                                   swap->external_hdr_size))
 777     goto error_return;
 778
 779   symhdr = &debug->symbolic_header;
 780   (*swap->swap_hdr_in) (abfd, ext_hdr, symhdr);
 781
 782   /* The symbolic header contains absolute file offsets and sizes to
 783      read.  */
 784 #define READ(ptr, offset, count, size, type)                            \
 785   if (symhdr->count == 0)                                               \
 786     debug->ptr = NULL;                                                  \
 787   else                                                                  \
 788     {                                                                   \
 789       bfd_size_type amt = (bfd_size_type) size * symhdr->count;         \
 790       debug->ptr = bfd_malloc (amt);                                    \
 791       if (debug->ptr == NULL)                                           \
 792         goto error_return;                                              \
 793       if (bfd_seek (abfd, symhdr->offset, SEEK_SET) != 0                \
 794           || bfd_bread (debug->ptr, amt, abfd) != amt)                  \
 795         goto error_return;                                              \
 796     }
 797
 798   READ (line, cbLineOffset, cbLine, sizeof (unsigned char), unsigned char *);
 799   READ (external_dnr, cbDnOffset, idnMax, swap->external_dnr_size, void *);
 800   READ (external_pdr, cbPdOffset, ipdMax, swap->external_pdr_size, void *);
 801   READ (external_sym, cbSymOffset, isymMax, swap->external_sym_size, void *);
 802   READ (external_opt, cbOptOffset, ioptMax, swap->external_opt_size, void *);
 803   READ (external_aux, cbAuxOffset, iauxMax, sizeof (union aux_ext),
 804         union aux_ext *);
 805   READ (ss, cbSsOffset, issMax, sizeof (char), char *);
 806   READ (ssext, cbSsExtOffset, issExtMax, sizeof (char), char *);
 807   READ (external_fdr, cbFdOffset, ifdMax, swap->external_fdr_size, void *);
 808   READ (external_rfd, cbRfdOffset, crfd, swap->external_rfd_size, void *);
 809   READ (external_ext, cbExtOffset, iextMax, swap->external_ext_size, void *);
 810 #undef READ
 811
 812   debug->fdr = NULL;
 813
 814   return TRUE;
 815
 816  error_return:
 817   if (ext_hdr != NULL)
 818     free (ext_hdr);
 819   if (debug->line != NULL)
 820     free (debug->line);
 821   if (debug->external_dnr != NULL)
 822     free (debug->external_dnr);
 823   if (debug->external_pdr != NULL)
 824     free (debug->external_pdr);
 825   if (debug->external_sym != NULL)
 826     free (debug->external_sym);
 827   if (debug->external_opt != NULL)
 828     free (debug->external_opt);
 829   if (debug->external_aux != NULL)
 830     free (debug->external_aux);
 831   if (debug->ss != NULL)
 832     free (debug->ss);
 833   if (debug->ssext != NULL)
 834     free (debug->ssext);
 835   if (debug->external_fdr != NULL)
 836     free (debug->external_fdr);
 837   if (debug->external_rfd != NULL)
 838     free (debug->external_rfd);
 839   if (debug->external_ext != NULL)
 840     free (debug->external_ext);
 841   return FALSE;
 842 }
 843 \f
 844 /* Swap RPDR (runtime procedure table entry) for output.  */
 845
 846 static void
 847 ecoff_swap_rpdr_out (bfd *abfd, const RPDR *in, struct rpdr_ext *ex)
 848 {
 849   H_PUT_S32 (abfd, in->adr, ex->p_adr);
 850   H_PUT_32 (abfd, in->regmask, ex->p_regmask);
 851   H_PUT_32 (abfd, in->regoffset, ex->p_regoffset);
 852   H_PUT_32 (abfd, in->fregmask, ex->p_fregmask);
 853   H_PUT_32 (abfd, in->fregoffset, ex->p_fregoffset);
 854   H_PUT_32 (abfd, in->frameoffset, ex->p_frameoffset);
 855
 856   H_PUT_16 (abfd, in->framereg, ex->p_framereg);
 857   H_PUT_16 (abfd, in->pcreg, ex->p_pcreg);
 858
 859   H_PUT_32 (abfd, in->irpss, ex->p_irpss);
 860 #if 0 /* FIXME */
 861   H_PUT_S32 (abfd, in->exception_info, ex->p_exception_info);
 862 #endif
 863 }
 864
 865 /* Create a runtime procedure table from the .mdebug section.  */
 866
 867 static bfd_boolean
 868 mips_elf_create_procedure_table (void *handle, bfd *abfd,
 869                                  struct bfd_link_info *info, asection *s,
 870                                  struct ecoff_debug_info *debug)
 871 {
 872   const struct ecoff_debug_swap *swap;
 873   HDRR *hdr = &debug->symbolic_header;
 874   RPDR *rpdr, *rp;
 875   struct rpdr_ext *erp;
 876   void *rtproc;
 877   struct pdr_ext *epdr;
 878   struct sym_ext *esym;
 879   char *ss, **sv;
 880   char *str;
 881   bfd_size_type size;
 882   bfd_size_type count;
 883   unsigned long sindex;
 884   unsigned long i;
 885   PDR pdr;
 886   SYMR sym;
 887   const char *no_name_func = _("static procedure (no name)");
 888
 889   epdr = NULL;
 890   rpdr = NULL;
 891   esym = NULL;
 892   ss = NULL;
 893   sv = NULL;
 894
 895   swap = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
 896
 897   sindex = strlen (no_name_func) + 1;
 898   count = hdr->ipdMax;
 899   if (count > 0)
 900     {
 901       size = swap->external_pdr_size;
 902
 903       epdr = bfd_malloc (size * count);
 904       if (epdr == NULL)
 905         goto error_return;
 906
 907       if (! _bfd_ecoff_get_accumulated_pdr (handle, (bfd_byte *) epdr))
 908         goto error_return;
 909
 910       size = sizeof (RPDR);
 911       rp = rpdr = bfd_malloc (size * count);
 912       if (rpdr == NULL)
 913         goto error_return;
 914
 915       size = sizeof (char *);
 916       sv = bfd_malloc (size * count);
 917       if (sv == NULL)
 918         goto error_return;
 919
 920       count = hdr->isymMax;
 921       size = swap->external_sym_size;
 922       esym = bfd_malloc (size * count);
 923       if (esym == NULL)
 924         goto error_return;
 925
 926       if (! _bfd_ecoff_get_accumulated_sym (handle, (bfd_byte *) esym))
 927         goto error_return;
 928
 929       count = hdr->issMax;
 930       ss = bfd_malloc (count);
 931       if (ss == NULL)
 932         goto error_return;
 933       if (! _bfd_ecoff_get_accumulated_ss (handle, ss))
 934         goto error_return;
 935
 936       count = hdr->ipdMax;
 937       for (i = 0; i < (unsigned long) count; i++, rp++)
 938         {
 939           (*swap->swap_pdr_in) (abfd, epdr + i, &pdr);
 940           (*swap->swap_sym_in) (abfd, &esym[pdr.isym], &sym);
 941           rp->adr = sym.value;
 942           rp->regmask = pdr.regmask;
 943           rp->regoffset = pdr.regoffset;
 944           rp->fregmask = pdr.fregmask;
 945           rp->fregoffset = pdr.fregoffset;
 946           rp->frameoffset = pdr.frameoffset;
 947           rp->framereg = pdr.framereg;
 948           rp->pcreg = pdr.pcreg;
 949           rp->irpss = sindex;
 950           sv[i] = ss + sym.iss;
 951           sindex += strlen (sv[i]) + 1;
 952         }
 953     }
 954
 955   size = sizeof (struct rpdr_ext) * (count + 2) + sindex;
 956   size = BFD_ALIGN (size, 16);
 957   rtproc = bfd_alloc (abfd, size);
 958   if (rtproc == NULL)
 959     {
 960       mips_elf_hash_table (info)->procedure_count = 0;
 961       goto error_return;
 962     }
 963
 964   mips_elf_hash_table (info)->procedure_count = count + 2;
 965
 966   erp = rtproc;
 967   memset (erp, 0, sizeof (struct rpdr_ext));
 968   erp++;
 969   str = (char *) rtproc + sizeof (struct rpdr_ext) * (count + 2);
 970   strcpy (str, no_name_func);
 971   str += strlen (no_name_func) + 1;
 972   for (i = 0; i < count; i++)
 973     {
 974       ecoff_swap_rpdr_out (abfd, rpdr + i, erp + i);
 975       strcpy (str, sv[i]);
 976       str += strlen (sv[i]) + 1;
 977     }
 978   H_PUT_S32 (abfd, -1, (erp + count)->p_adr);
 979
 980   /* Set the size and contents of .rtproc section.  */
 981   s->size = size;
 982   s->contents = rtproc;
 983
 984   /* Skip this section later on (I don't think this currently
 985      matters, but someday it might).  */
 986   s->link_order_head = NULL;
 987
 988   if (epdr != NULL)
 989     free (epdr);
 990   if (rpdr != NULL)
 991     free (rpdr);
 992   if (esym != NULL)
 993     free (esym);
 994   if (ss != NULL)
 995     free (ss);
 996   if (sv != NULL)
 997     free (sv);
 998
 999   return TRUE;
1000
1001  error_return:
1002   if (epdr != NULL)
1003     free (epdr);
1004   if (rpdr != NULL)
1005     free (rpdr);
1006   if (esym != NULL)
1007     free (esym);
1008   if (ss != NULL)
1009     free (ss);
1010   if (sv != NULL)
1011     free (sv);
1012   return FALSE;
1013 }
1014
1015 /* Check the mips16 stubs for a particular symbol, and see if we can
1016    discard them.  */
1017
1018 static bfd_boolean
1019 mips_elf_check_mips16_stubs (struct mips_elf_link_hash_entry *h,
1020                              void *data ATTRIBUTE_UNUSED)
1021 {
1022   if (h->root.root.type == bfd_link_hash_warning)
1023     h = (struct mips_elf_link_hash_entry *) h->root.root.u.i.link;
1024
1025   if (h->fn_stub != NULL
1026       && ! h->need_fn_stub)
1027     {
1028       /* We don't need the fn_stub; the only references to this symbol
1029          are 16 bit calls.  Clobber the size to 0 to prevent it from
1030          being included in the link.  */
1031       h->fn_stub->size = 0;
1032       h->fn_stub->flags &= ~SEC_RELOC;
1033       h->fn_stub->reloc_count = 0;
1034       h->fn_stub->flags |= SEC_EXCLUDE;
1035     }
1036
1037   if (h->call_stub != NULL
1038       && h->root.other == STO_MIPS16)
1039     {
1040       /* We don't need the call_stub; this is a 16 bit function, so
1041          calls from other 16 bit functions are OK.  Clobber the size
1042          to 0 to prevent it from being included in the link.  */
1043       h->call_stub->size = 0;
1044       h->call_stub->flags &= ~SEC_RELOC;
1045       h->call_stub->reloc_count = 0;
1046       h->call_stub->flags |= SEC_EXCLUDE;
1047     }
1048
1049   if (h->call_fp_stub != NULL
1050       && h->root.other == STO_MIPS16)
1051     {
1052       /* We don't need the call_stub; this is a 16 bit function, so
1053          calls from other 16 bit functions are OK.  Clobber the size
1054          to 0 to prevent it from being included in the link.  */
1055       h->call_fp_stub->size = 0;
1056       h->call_fp_stub->flags &= ~SEC_RELOC;
1057       h->call_fp_stub->reloc_count = 0;
1058       h->call_fp_stub->flags |= SEC_EXCLUDE;
1059     }
1060
1061   return TRUE;
1062 }
1063 \f
1064 bfd_reloc_status_type
1065 _bfd_mips_elf_gprel16_with_gp (bfd *abfd, asymbol *symbol,
1066                                arelent *reloc_entry, asection *input_section,
1067                                bfd_boolean relocatable, void *data, bfd_vma gp)
1068 {
1069   bfd_vma relocation;
1070   bfd_signed_vma val;
1071   bfd_reloc_status_type status;
1072
1073   if (bfd_is_com_section (symbol->section))
1074     relocation = 0;
1075   else
1076     relocation = symbol->value;
1077
1078   relocation += symbol->section->output_section->vma;
1079   relocation += symbol->section->output_offset;
1080
1081   if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
1082     return bfd_reloc_outofrange;
1083
1084   /* Set val to the offset into the section or symbol.  */
1085   val = reloc_entry->addend;
1086
1087   _bfd_mips_elf_sign_extend (val, 16);
1088
1089   /* Adjust val for the final section location and GP value.  If we
1090      are producing relocatable output, we don't want to do this for
1091      an external symbol.  */
1092   if (! relocatable
1093       || (symbol->flags & BSF_SECTION_SYM) != 0)
1094     val += relocation - gp;
1095
1096   if (reloc_entry->howto->partial_inplace)
1097     {
1098       status = _bfd_relocate_contents (reloc_entry->howto, abfd, val,
1099                                        (bfd_byte *) data
1100                                        + reloc_entry->address);
1101       if (status != bfd_reloc_ok)
1102         return status;
1103     }
1104   else
1105     reloc_entry->addend = val;
1106
1107   if (relocatable)
1108     reloc_entry->address += input_section->output_offset;
1109
1110   return bfd_reloc_ok;
1111 }
1112
1113 /* Used to store a REL high-part relocation such as R_MIPS_HI16 or
1114    R_MIPS_GOT16.  REL is the relocation, INPUT_SECTION is the section
1115    that contains the relocation field and DATA points to the start of
1116    INPUT_SECTION.  */
1117
1118 struct mips_hi16
1119 {
1120   struct mips_hi16 *next;
1121   bfd_byte *data;
1122   asection *input_section;
1123   arelent rel;
1124 };
1125
1126 /* FIXME: This should not be a static variable.  */
1127
1128 static struct mips_hi16 *mips_hi16_list;
1129
1130 /* A howto special_function for REL *HI16 relocations.  We can only
1131    calculate the correct value once we've seen the partnering
1132    *LO16 relocation, so just save the information for later.
1133
1134    The ABI requires that the *LO16 immediately follow the *HI16.
1135    However, as a GNU extension, we permit an arbitrary number of
1136    *HI16s to be associated with a single *LO16.  This significantly
1137    simplies the relocation handling in gcc.  */
1138
1139 bfd_reloc_status_type
1140 _bfd_mips_elf_hi16_reloc (bfd *abfd ATTRIBUTE_UNUSED, arelent *reloc_entry,
1141                           asymbol *symbol ATTRIBUTE_UNUSED, void *data,
1142                           asection *input_section, bfd *output_bfd,
1143                           char **error_message ATTRIBUTE_UNUSED)
1144 {
1145   struct mips_hi16 *n;
1146
1147   if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
1148     return bfd_reloc_outofrange;
1149
1150   n = bfd_malloc (sizeof *n);
1151   if (n == NULL)
1152     return bfd_reloc_outofrange;
1153
1154   n->next = mips_hi16_list;
1155   n->data = data;
1156   n->input_section = input_section;
1157   n->rel = *reloc_entry;
1158   mips_hi16_list = n;
1159
1160   if (output_bfd != NULL)
1161     reloc_entry->address += input_section->output_offset;
1162
1163   return bfd_reloc_ok;
1164 }
1165
1166 /* A howto special_function for REL R_MIPS_GOT16 relocations.  This is just
1167    like any other 16-bit relocation when applied to global symbols, but is
1168    treated in the same as R_MIPS_HI16 when applied to local symbols.  */
1169
1170 bfd_reloc_status_type
1171 _bfd_mips_elf_got16_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
1172                            void *data, asection *input_section,
1173                            bfd *output_bfd, char **error_message)
1174 {
1175   if ((symbol->flags & (BSF_GLOBAL | BSF_WEAK)) != 0
1176       || bfd_is_und_section (bfd_get_section (symbol))
1177       || bfd_is_com_section (bfd_get_section (symbol)))
1178     /* The relocation is against a global symbol.  */
1179     return _bfd_mips_elf_generic_reloc (abfd, reloc_entry, symbol, data,
1180                                         input_section, output_bfd,
1181                                         error_message);
1182
1183   return _bfd_mips_elf_hi16_reloc (abfd, reloc_entry, symbol, data,
1184                                    input_section, output_bfd, error_message);
1185 }
1186
1187 /* A howto special_function for REL *LO16 relocations.  The *LO16 itself
1188    is a straightforward 16 bit inplace relocation, but we must deal with
1189    any partnering high-part relocations as well.  */
1190
1191 bfd_reloc_status_type
1192 _bfd_mips_elf_lo16_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
1193                           void *data, asection *input_section,
1194                           bfd *output_bfd, char **error_message)
1195 {
1196   bfd_vma vallo;
1197
1198   if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
1199     return bfd_reloc_outofrange;
1200
1201   vallo = bfd_get_32 (abfd, (bfd_byte *) data + reloc_entry->address);
1202   while (mips_hi16_list != NULL)
1203     {
1204       bfd_reloc_status_type ret;
1205       struct mips_hi16 *hi;
1206
1207       hi = mips_hi16_list;
1208
1209       /* R_MIPS_GOT16 relocations are something of a special case.  We
1210          want to install the addend in the same way as for a R_MIPS_HI16
1211          relocation (with a rightshift of 16).  However, since GOT16
1212          relocations can also be used with global symbols, their howto
1213          has a rightshift of 0.  */
1214       if (hi->rel.howto->type == R_MIPS_GOT16)
1215         hi->rel.howto = MIPS_ELF_RTYPE_TO_HOWTO (abfd, R_MIPS_HI16, FALSE);
1216
1217       /* VALLO is a signed 16-bit number.  Bias it by 0x8000 so that any
1218          carry or borrow will induce a change of +1 or -1 in the high part.  */
1219       hi->rel.addend += (vallo + 0x8000) & 0xffff;
1220
1221       ret = _bfd_mips_elf_generic_reloc (abfd, &hi->rel, symbol, hi->data,
1222                                          hi->input_section, output_bfd,
1223                                          error_message);
1224       if (ret != bfd_reloc_ok)
1225         return ret;
1226
1227       mips_hi16_list = hi->next;
1228       free (hi);
1229     }
1230
1231   return _bfd_mips_elf_generic_reloc (abfd, reloc_entry, symbol, data,
1232                                       input_section, output_bfd,
1233                                       error_message);
1234 }
1235
1236 /* A generic howto special_function.  This calculates and installs the
1237    relocation itself, thus avoiding the oft-discussed problems in
1238    bfd_perform_relocation and bfd_install_relocation.  */
1239
1240 bfd_reloc_status_type
1241 _bfd_mips_elf_generic_reloc (bfd *abfd ATTRIBUTE_UNUSED, arelent *reloc_entry,
1242                              asymbol *symbol, void *data ATTRIBUTE_UNUSED,
1243                              asection *input_section, bfd *output_bfd,
1244                              char **error_message ATTRIBUTE_UNUSED)
1245 {
1246   bfd_signed_vma val;
1247   bfd_reloc_status_type status;
1248   bfd_boolean relocatable;
1249
1250   relocatable = (output_bfd != NULL);
1251
1252   if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
1253     return bfd_reloc_outofrange;
1254
1255   /* Build up the field adjustment in VAL.  */
1256   val = 0;
1257   if (!relocatable || (symbol->flags & BSF_SECTION_SYM) != 0)
1258     {
1259       /* Either we're calculating the final field value or we have a
1260          relocation against a section symbol.  Add in the section's
1261          offset or address.  */
1262       val += symbol->section->output_section->vma;
1263       val += symbol->section->output_offset;
1264     }
1265
1266   if (!relocatable)
1267     {
1268       /* We're calculating the final field value.  Add in the symbol's value
1269          and, if pc-relative, subtract the address of the field itself.  */
1270       val += symbol->value;
1271       if (reloc_entry->howto->pc_relative)
1272         {
1273           val -= input_section->output_section->vma;
1274           val -= input_section->output_offset;
1275           val -= reloc_entry->address;
1276         }
1277     }
1278
1279   /* VAL is now the final adjustment.  If we're keeping this relocation
1280      in the output file, and if the relocation uses a separate addend,
1281      we just need to add VAL to that addend.  Otherwise we need to add
1282      VAL to the relocation field itself.  */
1283   if (relocatable && !reloc_entry->howto->partial_inplace)
1284     reloc_entry->addend += val;
1285   else
1286     {
1287       /* Add in the separate addend, if any.  */
1288       val += reloc_entry->addend;
1289
1290       /* Add VAL to the relocation field.  */
1291       status = _bfd_relocate_contents (reloc_entry->howto, abfd, val,
1292                                        (bfd_byte *) data
1293                                        + reloc_entry->address);
1294       if (status != bfd_reloc_ok)
1295         return status;
1296     }
1297
1298   if (relocatable)
1299     reloc_entry->address += input_section->output_offset;
1300
1301   return bfd_reloc_ok;
1302 }
1303 \f
1304 /* Swap an entry in a .gptab section.  Note that these routines rely
1305    on the equivalence of the two elements of the union.  */
1306
1307 static void
1308 bfd_mips_elf32_swap_gptab_in (bfd *abfd, const Elf32_External_gptab *ex,
1309                               Elf32_gptab *in)
1310 {
1311   in->gt_entry.gt_g_value = H_GET_32 (abfd, ex->gt_entry.gt_g_value);
1312   in->gt_entry.gt_bytes = H_GET_32 (abfd, ex->gt_entry.gt_bytes);
1313 }
1314
1315 static void
1316 bfd_mips_elf32_swap_gptab_out (bfd *abfd, const Elf32_gptab *in,
1317                                Elf32_External_gptab *ex)
1318 {
1319   H_PUT_32 (abfd, in->gt_entry.gt_g_value, ex->gt_entry.gt_g_value);
1320   H_PUT_32 (abfd, in->gt_entry.gt_bytes, ex->gt_entry.gt_bytes);
1321 }
1322
1323 static void
1324 bfd_elf32_swap_compact_rel_out (bfd *abfd, const Elf32_compact_rel *in,
1325                                 Elf32_External_compact_rel *ex)
1326 {
1327   H_PUT_32 (abfd, in->id1, ex->id1);
1328   H_PUT_32 (abfd, in->num, ex->num);
1329   H_PUT_32 (abfd, in->id2, ex->id2);
1330   H_PUT_32 (abfd, in->offset, ex->offset);
1331   H_PUT_32 (abfd, in->reserved0, ex->reserved0);
1332   H_PUT_32 (abfd, in->reserved1, ex->reserved1);
1333 }
1334
1335 static void
1336 bfd_elf32_swap_crinfo_out (bfd *abfd, const Elf32_crinfo *in,
1337                            Elf32_External_crinfo *ex)
1338 {
1339   unsigned long l;
1340
1341   l = (((in->ctype & CRINFO_CTYPE) << CRINFO_CTYPE_SH)
1342        | ((in->rtype & CRINFO_RTYPE) << CRINFO_RTYPE_SH)
1343        | ((in->dist2to & CRINFO_DIST2TO) << CRINFO_DIST2TO_SH)
1344        | ((in->relvaddr & CRINFO_RELVADDR) << CRINFO_RELVADDR_SH));
1345   H_PUT_32 (abfd, l, ex->info);
1346   H_PUT_32 (abfd, in->konst, ex->konst);
1347   H_PUT_32 (abfd, in->vaddr, ex->vaddr);
1348 }
1349 \f
1350 /* A .reginfo section holds a single Elf32_RegInfo structure.  These
1351    routines swap this structure in and out.  They are used outside of
1352    BFD, so they are globally visible.  */
1353
1354 void
1355 bfd_mips_elf32_swap_reginfo_in (bfd *abfd, const Elf32_External_RegInfo *ex,
1356                                 Elf32_RegInfo *in)
1357 {
1358   in->ri_gprmask = H_GET_32 (abfd, ex->ri_gprmask);
1359   in->ri_cprmask[0] = H_GET_32 (abfd, ex->ri_cprmask[0]);
1360   in->ri_cprmask[1] = H_GET_32 (abfd, ex->ri_cprmask[1]);
1361   in->ri_cprmask[2] = H_GET_32 (abfd, ex->ri_cprmask[2]);
1362   in->ri_cprmask[3] = H_GET_32 (abfd, ex->ri_cprmask[3]);
1363   in->ri_gp_value = H_GET_32 (abfd, ex->ri_gp_value);
1364 }
1365
1366 void
1367 bfd_mips_elf32_swap_reginfo_out (bfd *abfd, const Elf32_RegInfo *in,
1368                                  Elf32_External_RegInfo *ex)
1369 {
1370   H_PUT_32 (abfd, in->ri_gprmask, ex->ri_gprmask);
1371   H_PUT_32 (abfd, in->ri_cprmask[0], ex->ri_cprmask[0]);
1372   H_PUT_32 (abfd, in->ri_cprmask[1], ex->ri_cprmask[1]);
1373   H_PUT_32 (abfd, in->ri_cprmask[2], ex->ri_cprmask[2]);
1374   H_PUT_32 (abfd, in->ri_cprmask[3], ex->ri_cprmask[3]);
1375   H_PUT_32 (abfd, in->ri_gp_value, ex->ri_gp_value);
1376 }
1377
1378 /* In the 64 bit ABI, the .MIPS.options section holds register
1379    information in an Elf64_Reginfo structure.  These routines swap
1380    them in and out.  They are globally visible because they are used
1381    outside of BFD.  These routines are here so that gas can call them
1382    without worrying about whether the 64 bit ABI has been included.  */
1383
1384 void
1385 bfd_mips_elf64_swap_reginfo_in (bfd *abfd, const Elf64_External_RegInfo *ex,
1386                                 Elf64_Internal_RegInfo *in)
1387 {
1388   in->ri_gprmask = H_GET_32 (abfd, ex->ri_gprmask);
1389   in->ri_pad = H_GET_32 (abfd, ex->ri_pad);
1390   in->ri_cprmask[0] = H_GET_32 (abfd, ex->ri_cprmask[0]);
1391   in->ri_cprmask[1] = H_GET_32 (abfd, ex->ri_cprmask[1]);
1392   in->ri_cprmask[2] = H_GET_32 (abfd, ex->ri_cprmask[2]);
1393   in->ri_cprmask[3] = H_GET_32 (abfd, ex->ri_cprmask[3]);
1394   in->ri_gp_value = H_GET_64 (abfd, ex->ri_gp_value);
1395 }
1396
1397 void
1398 bfd_mips_elf64_swap_reginfo_out (bfd *abfd, const Elf64_Internal_RegInfo *in,
1399                                  Elf64_External_RegInfo *ex)
1400 {
1401   H_PUT_32 (abfd, in->ri_gprmask, ex->ri_gprmask);
1402   H_PUT_32 (abfd, in->ri_pad, ex->ri_pad);
1403   H_PUT_32 (abfd, in->ri_cprmask[0], ex->ri_cprmask[0]);
1404   H_PUT_32 (abfd, in->ri_cprmask[1], ex->ri_cprmask[1]);
1405   H_PUT_32 (abfd, in->ri_cprmask[2], ex->ri_cprmask[2]);
1406   H_PUT_32 (abfd, in->ri_cprmask[3], ex->ri_cprmask[3]);
1407   H_PUT_64 (abfd, in->ri_gp_value, ex->ri_gp_value);
1408 }
1409
1410 /* Swap in an options header.  */
1411
1412 void
1413 bfd_mips_elf_swap_options_in (bfd *abfd, const Elf_External_Options *ex,
1414                               Elf_Internal_Options *in)
1415 {
1416   in->kind = H_GET_8 (abfd, ex->kind);
1417   in->size = H_GET_8 (abfd, ex->size);
1418   in->section = H_GET_16 (abfd, ex->section);
1419   in->info = H_GET_32 (abfd, ex->info);
1420 }
1421
1422 /* Swap out an options header.  */
1423
1424 void
1425 bfd_mips_elf_swap_options_out (bfd *abfd, const Elf_Internal_Options *in,
1426                                Elf_External_Options *ex)
1427 {
1428   H_PUT_8 (abfd, in->kind, ex->kind);
1429   H_PUT_8 (abfd, in->size, ex->size);
1430   H_PUT_16 (abfd, in->section, ex->section);
1431   H_PUT_32 (abfd, in->info, ex->info);
1432 }
1433 \f
1434 /* This function is called via qsort() to sort the dynamic relocation
1435    entries by increasing r_symndx value.  */
1436
1437 static int
1438 sort_dynamic_relocs (const void *arg1, const void *arg2)
1439 {
1440   Elf_Internal_Rela int_reloc1;
1441   Elf_Internal_Rela int_reloc2;
1442
1443   bfd_elf32_swap_reloc_in (reldyn_sorting_bfd, arg1, &int_reloc1);
1444   bfd_elf32_swap_reloc_in (reldyn_sorting_bfd, arg2, &int_reloc2);
1445
1446   return ELF32_R_SYM (int_reloc1.r_info) - ELF32_R_SYM (int_reloc2.r_info);
1447 }
1448
1449 /* Like sort_dynamic_relocs, but used for elf64 relocations.  */
1450
1451 static int
1452 sort_dynamic_relocs_64 (const void *arg1, const void *arg2)
1453 {
1454   Elf_Internal_Rela int_reloc1[3];
1455   Elf_Internal_Rela int_reloc2[3];
1456
1457   (*get_elf_backend_data (reldyn_sorting_bfd)->s->swap_reloc_in)
1458     (reldyn_sorting_bfd, arg1, int_reloc1);
1459   (*get_elf_backend_data (reldyn_sorting_bfd)->s->swap_reloc_in)
1460     (reldyn_sorting_bfd, arg2, int_reloc2);
1461
1462   return (ELF64_R_SYM (int_reloc1[0].r_info)
1463           - ELF64_R_SYM (int_reloc2[0].r_info));
1464 }
1465
1466
1467 /* This routine is used to write out ECOFF debugging external symbol
1468    information.  It is called via mips_elf_link_hash_traverse.  The
1469    ECOFF external symbol information must match the ELF external
1470    symbol information.  Unfortunately, at this point we don't know
1471    whether a symbol is required by reloc information, so the two
1472    tables may wind up being different.  We must sort out the external
1473    symbol information before we can set the final size of the .mdebug
1474    section, and we must set the size of the .mdebug section before we
1475    can relocate any sections, and we can't know which symbols are
1476    required by relocation until we relocate the sections.
1477    Fortunately, it is relatively unlikely that any symbol will be
1478    stripped but required by a reloc.  In particular, it can not happen
1479    when generating a final executable.  */
1480
1481 static bfd_boolean
1482 mips_elf_output_extsym (struct mips_elf_link_hash_entry *h, void *data)
1483 {
1484   struct extsym_info *einfo = data;
1485   bfd_boolean strip;
1486   asection *sec, *output_section;
1487
1488   if (h->root.root.type == bfd_link_hash_warning)
1489     h = (struct mips_elf_link_hash_entry *) h->root.root.u.i.link;
1490
1491   if (h->root.indx == -2)
1492     strip = FALSE;
1493   else if ((h->root.def_dynamic
1494             || h->root.ref_dynamic)
1495            && !h->root.def_regular
1496            && !h->root.ref_regular)
1497     strip = TRUE;
1498   else if (einfo->info->strip == strip_all
1499            || (einfo->info->strip == strip_some
1500                && bfd_hash_lookup (einfo->info->keep_hash,
1501                                    h->root.root.root.string,
1502                                    FALSE, FALSE) == NULL))
1503     strip = TRUE;
1504   else
1505     strip = FALSE;
1506
1507   if (strip)
1508     return TRUE;
1509
1510   if (h->esym.ifd == -2)
1511     {
1512       h->esym.jmptbl = 0;
1513       h->esym.cobol_main = 0;
1514       h->esym.weakext = 0;
1515       h->esym.reserved = 0;
1516       h->esym.ifd = ifdNil;
1517       h->esym.asym.value = 0;
1518       h->esym.asym.st = stGlobal;
1519
1520       if (h->root.root.type == bfd_link_hash_undefined
1521           || h->root.root.type == bfd_link_hash_undefweak)
1522         {
1523           const char *name;
1524
1525           /* Use undefined class.  Also, set class and type for some
1526              special symbols.  */
1527           name = h->root.root.root.string;
1528           if (strcmp (name, mips_elf_dynsym_rtproc_names[0]) == 0
1529               || strcmp (name, mips_elf_dynsym_rtproc_names[1]) == 0)
1530             {
1531               h->esym.asym.sc = scData;
1532               h->esym.asym.st = stLabel;
1533               h->esym.asym.value = 0;
1534             }
1535           else if (strcmp (name, mips_elf_dynsym_rtproc_names[2]) == 0)
1536             {
1537               h->esym.asym.sc = scAbs;
1538               h->esym.asym.st = stLabel;
1539               h->esym.asym.value =
1540                 mips_elf_hash_table (einfo->info)->procedure_count;
1541             }
1542           else if (strcmp (name, "_gp_disp") == 0 && ! NEWABI_P (einfo->abfd))
1543             {
1544               h->esym.asym.sc = scAbs;
1545               h->esym.asym.st = stLabel;
1546               h->esym.asym.value = elf_gp (einfo->abfd);
1547             }
1548           else
1549             h->esym.asym.sc = scUndefined;
1550         }
1551       else if (h->root.root.type != bfd_link_hash_defined
1552           && h->root.root.type != bfd_link_hash_defweak)
1553         h->esym.asym.sc = scAbs;
1554       else
1555         {
1556           const char *name;
1557
1558           sec = h->root.root.u.def.section;
1559           output_section = sec->output_section;
1560
1561           /* When making a shared library and symbol h is the one from
1562              the another shared library, OUTPUT_SECTION may be null.  */
1563           if (output_section == NULL)
1564             h->esym.asym.sc = scUndefined;
1565           else
1566             {
1567               name = bfd_section_name (output_section->owner, output_section);
1568
1569               if (strcmp (name, ".text") == 0)
1570                 h->esym.asym.sc = scText;
1571               else if (strcmp (name, ".data") == 0)
1572                 h->esym.asym.sc = scData;
1573               else if (strcmp (name, ".sdata") == 0)
1574                 h->esym.asym.sc = scSData;
1575               else if (strcmp (name, ".rodata") == 0
1576                        || strcmp (name, ".rdata") == 0)
1577                 h->esym.asym.sc = scRData;
1578               else if (strcmp (name, ".bss") == 0)
1579                 h->esym.asym.sc = scBss;
1580               else if (strcmp (name, ".sbss") == 0)
1581                 h->esym.asym.sc = scSBss;
1582               else if (strcmp (name, ".init") == 0)
1583                 h->esym.asym.sc = scInit;
1584               else if (strcmp (name, ".fini") == 0)
1585                 h->esym.asym.sc = scFini;
1586               else
1587                 h->esym.asym.sc = scAbs;
1588             }
1589         }
1590
1591       h->esym.asym.reserved = 0;
1592       h->esym.asym.index = indexNil;
1593     }
1594
1595   if (h->root.root.type == bfd_link_hash_common)
1596     h->esym.asym.value = h->root.root.u.c.size;
1597   else if (h->root.root.type == bfd_link_hash_defined
1598            || h->root.root.type == bfd_link_hash_defweak)
1599     {
1600       if (h->esym.asym.sc == scCommon)
1601         h->esym.asym.sc = scBss;
1602       else if (h->esym.asym.sc == scSCommon)
1603         h->esym.asym.sc = scSBss;
1604
1605       sec = h->root.root.u.def.section;
1606       output_section = sec->output_section;
1607       if (output_section != NULL)
1608         h->esym.asym.value = (h->root.root.u.def.value
1609                               + sec->output_offset
1610                               + output_section->vma);
1611       else
1612         h->esym.asym.value = 0;
1613     }
1614   else if (h->root.needs_plt)
1615     {
1616       struct mips_elf_link_hash_entry *hd = h;
1617       bfd_boolean no_fn_stub = h->no_fn_stub;
1618
1619       while (hd->root.root.type == bfd_link_hash_indirect)
1620         {
1621           hd = (struct mips_elf_link_hash_entry *)h->root.root.u.i.link;
1622           no_fn_stub = no_fn_stub || hd->no_fn_stub;
1623         }
1624
1625       if (!no_fn_stub)
1626         {
1627           /* Set type and value for a symbol with a function stub.  */
1628           h->esym.asym.st = stProc;
1629           sec = hd->root.root.u.def.section;
1630           if (sec == NULL)
1631             h->esym.asym.value = 0;
1632           else
1633             {
1634               output_section = sec->output_section;
1635               if (output_section != NULL)
1636                 h->esym.asym.value = (hd->root.plt.offset
1637                                       + sec->output_offset
1638                                       + output_section->vma);
1639               else
1640                 h->esym.asym.value = 0;
1641             }
1642 #if 0 /* FIXME?  */
1643           h->esym.ifd = 0;
1644 #endif
1645         }
1646     }
1647
1648   if (! bfd_ecoff_debug_one_external (einfo->abfd, einfo->debug, einfo->swap,
1649                                       h->root.root.root.string,
1650                                       &h->esym))
1651     {
1652       einfo->failed = TRUE;
1653       return FALSE;
1654     }
1655
1656   return TRUE;
1657 }
1658
1659 /* A comparison routine used to sort .gptab entries.  */
1660
1661 static int
1662 gptab_compare (const void *p1, const void *p2)
1663 {
1664   const Elf32_gptab *a1 = p1;
1665   const Elf32_gptab *a2 = p2;
1666
1667   return a1->gt_entry.gt_g_value - a2->gt_entry.gt_g_value;
1668 }
1669 \f
1670 /* Functions to manage the got entry hash table.  */
1671
1672 /* Use all 64 bits of a bfd_vma for the computation of a 32-bit
1673    hash number.  */
1674
1675 static INLINE hashval_t
1676 mips_elf_hash_bfd_vma (bfd_vma addr)
1677 {
1678 #ifdef BFD64
1679   return addr + (addr >> 32);
1680 #else
1681   return addr;
1682 #endif
1683 }
1684
1685 /* got_entries only match if they're identical, except for gotidx, so
1686    use all fields to compute the hash, and compare the appropriate
1687    union members.  */
1688
1689 static hashval_t
1690 mips_elf_got_entry_hash (const void *entry_)
1691 {
1692   const struct mips_got_entry *entry = (struct mips_got_entry *)entry_;
1693
1694   return entry->symndx
1695     + (! entry->abfd ? mips_elf_hash_bfd_vma (entry->d.address)
1696        : entry->abfd->id
1697          + (entry->symndx >= 0 ? mips_elf_hash_bfd_vma (entry->d.addend)
1698             : entry->d.h->root.root.root.hash));
1699 }
1700
1701 static int
1702 mips_elf_got_entry_eq (const void *entry1, const void *entry2)
1703 {
1704   const struct mips_got_entry *e1 = (struct mips_got_entry *)entry1;
1705   const struct mips_got_entry *e2 = (struct mips_got_entry *)entry2;
1706
1707   return e1->abfd == e2->abfd && e1->symndx == e2->symndx
1708     && (! e1->abfd ? e1->d.address == e2->d.address
1709         : e1->symndx >= 0 ? e1->d.addend == e2->d.addend
1710         : e1->d.h == e2->d.h);
1711 }
1712
1713 /* multi_got_entries are still a match in the case of global objects,
1714    even if the input bfd in which they're referenced differs, so the
1715    hash computation and compare functions are adjusted
1716    accordingly.  */
1717
1718 static hashval_t
1719 mips_elf_multi_got_entry_hash (const void *entry_)
1720 {
1721   const struct mips_got_entry *entry = (struct mips_got_entry *)entry_;
1722
1723   return entry->symndx
1724     + (! entry->abfd
1725        ? mips_elf_hash_bfd_vma (entry->d.address)
1726        : entry->symndx >= 0
1727        ? (entry->abfd->id
1728           + mips_elf_hash_bfd_vma (entry->d.addend))
1729        : entry->d.h->root.root.root.hash);
1730 }
1731
1732 static int
1733 mips_elf_multi_got_entry_eq (const void *entry1, const void *entry2)
1734 {
1735   const struct mips_got_entry *e1 = (struct mips_got_entry *)entry1;
1736   const struct mips_got_entry *e2 = (struct mips_got_entry *)entry2;
1737
1738   return e1->symndx == e2->symndx
1739     && (e1->symndx >= 0 ? e1->abfd == e2->abfd && e1->d.addend == e2->d.addend
1740         : e1->abfd == NULL || e2->abfd == NULL
1741         ? e1->abfd == e2->abfd && e1->d.address == e2->d.address
1742         : e1->d.h == e2->d.h);
1743 }
1744 \f
1745 /* Returns the dynamic relocation section for DYNOBJ.  */
1746
1747 static asection *
1748 mips_elf_rel_dyn_section (bfd *dynobj, bfd_boolean create_p)
1749 {
1750   static const char dname[] = ".rel.dyn";
1751   asection *sreloc;
1752
1753   sreloc = bfd_get_section_by_name (dynobj, dname);
1754   if (sreloc == NULL && create_p)
1755     {
1756       sreloc = bfd_make_section (dynobj, dname);
1757       if (sreloc == NULL
1758           || ! bfd_set_section_flags (dynobj, sreloc,
1759                                       (SEC_ALLOC
1760                                        | SEC_LOAD
1761                                        | SEC_HAS_CONTENTS
1762                                        | SEC_IN_MEMORY
1763                                        | SEC_LINKER_CREATED
1764                                        | SEC_READONLY))
1765           || ! bfd_set_section_alignment (dynobj, sreloc,
1766                                           MIPS_ELF_LOG_FILE_ALIGN (dynobj)))
1767         return NULL;
1768     }
1769   return sreloc;
1770 }
1771
1772 /* Returns the GOT section for ABFD.  */
1773
1774 static asection *
1775 mips_elf_got_section (bfd *abfd, bfd_boolean maybe_excluded)
1776 {
1777   asection *sgot = bfd_get_section_by_name (abfd, ".got");
1778   if (sgot == NULL
1779       || (! maybe_excluded && (sgot->flags & SEC_EXCLUDE) != 0))
1780     return NULL;
1781   return sgot;
1782 }
1783
1784 /* Returns the GOT information associated with the link indicated by
1785    INFO.  If SGOTP is non-NULL, it is filled in with the GOT
1786    section.  */
1787
1788 static struct mips_got_info *
1789 mips_elf_got_info (bfd *abfd, asection **sgotp)
1790 {
1791   asection *sgot;
1792   struct mips_got_info *g;
1793
1794   sgot = mips_elf_got_section (abfd, TRUE);
1795   BFD_ASSERT (sgot != NULL);
1796   BFD_ASSERT (mips_elf_section_data (sgot) != NULL);
1797   g = mips_elf_section_data (sgot)->u.got_info;
1798   BFD_ASSERT (g != NULL);
1799
1800   if (sgotp)
1801     *sgotp = (sgot->flags & SEC_EXCLUDE) == 0 ? sgot : NULL;
1802
1803   return g;
1804 }
1805
1806 /* Returns the GOT offset at which the indicated address can be found.
1807    If there is not yet a GOT entry for this value, create one.  Returns
1808    -1 if no satisfactory GOT offset can be found.  */
1809
1810 static bfd_vma
1811 mips_elf_local_got_index (bfd *abfd, bfd *ibfd, struct bfd_link_info *info,
1812                           bfd_vma value)
1813 {
1814   asection *sgot;
1815   struct mips_got_info *g;
1816   struct mips_got_entry *entry;
1817
1818   g = mips_elf_got_info (elf_hash_table (info)->dynobj, &sgot);
1819
1820   entry = mips_elf_create_local_got_entry (abfd, ibfd, g, sgot, value);
1821   if (entry)
1822     return entry->gotidx;
1823   else
1824     return MINUS_ONE;
1825 }
1826
1827 /* Returns the GOT index for the global symbol indicated by H.  */
1828
1829 static bfd_vma
1830 mips_elf_global_got_index (bfd *abfd, bfd *ibfd, struct elf_link_hash_entry *h)
1831 {
1832   bfd_vma index;
1833   asection *sgot;
1834   struct mips_got_info *g, *gg;
1835   long global_got_dynindx = 0;
1836
1837   gg = g = mips_elf_got_info (abfd, &sgot);
1838   if (g->bfd2got && ibfd)
1839     {
1840       struct mips_got_entry e, *p;
1841
1842       BFD_ASSERT (h->dynindx >= 0);
1843
1844       g = mips_elf_got_for_ibfd (g, ibfd);
1845       if (g->next != gg)
1846         {
1847           e.abfd = ibfd;
1848           e.symndx = -1;
1849           e.d.h = (struct mips_elf_link_hash_entry *)h;
1850
1851           p = htab_find (g->got_entries, &e);
1852
1853           BFD_ASSERT (p->gotidx > 0);
1854           return p->gotidx;
1855         }
1856     }
1857
1858   if (gg->global_gotsym != NULL)
1859     global_got_dynindx = gg->global_gotsym->dynindx;
1860
1861   /* Once we determine the global GOT entry with the lowest dynamic
1862      symbol table index, we must put all dynamic symbols with greater
1863      indices into the GOT.  That makes it easy to calculate the GOT
1864      offset.  */
1865   BFD_ASSERT (h->dynindx >= global_got_dynindx);
1866   index = ((h->dynindx - global_got_dynindx + g->local_gotno)
1867            * MIPS_ELF_GOT_SIZE (abfd));
1868   BFD_ASSERT (index < sgot->size);
1869
1870   return index;
1871 }
1872
1873 /* Find a GOT entry that is within 32KB of the VALUE.  These entries
1874    are supposed to be placed at small offsets in the GOT, i.e.,
1875    within 32KB of GP.  Return the index into the GOT for this page,
1876    and store the offset from this entry to the desired address in
1877    OFFSETP, if it is non-NULL.  */
1878
1879 static bfd_vma
1880 mips_elf_got_page (bfd *abfd, bfd *ibfd, struct bfd_link_info *info,
1881                    bfd_vma value, bfd_vma *offsetp)
1882 {
1883   asection *sgot;
1884   struct mips_got_info *g;
1885   bfd_vma index;
1886   struct mips_got_entry *entry;
1887
1888   g = mips_elf_got_info (elf_hash_table (info)->dynobj, &sgot);
1889
1890   entry = mips_elf_create_local_got_entry (abfd, ibfd, g, sgot,
1891                                            (value + 0x8000)
1892                                            & (~(bfd_vma)0xffff));
1893
1894   if (!entry)
1895     return MINUS_ONE;
1896
1897   index = entry->gotidx;
1898
1899   if (offsetp)
1900     *offsetp = value - entry->d.address;
1901
1902   return index;
1903 }
1904
1905 /* Find a GOT entry whose higher-order 16 bits are the same as those
1906    for value.  Return the index into the GOT for this entry.  */
1907
1908 static bfd_vma
1909 mips_elf_got16_entry (bfd *abfd, bfd *ibfd, struct bfd_link_info *info,
1910                       bfd_vma value, bfd_boolean external)
1911 {
1912   asection *sgot;
1913   struct mips_got_info *g;
1914   struct mips_got_entry *entry;
1915
1916   if (! external)
1917     {
1918       /* Although the ABI says that it is "the high-order 16 bits" that we
1919          want, it is really the %high value.  The complete value is
1920          calculated with a `addiu' of a LO16 relocation, just as with a
1921          HI16/LO16 pair.  */
1922       value = mips_elf_high (value) << 16;
1923     }
1924
1925   g = mips_elf_got_info (elf_hash_table (info)->dynobj, &sgot);
1926
1927   entry = mips_elf_create_local_got_entry (abfd, ibfd, g, sgot, value);
1928   if (entry)
1929     return entry->gotidx;
1930   else
1931     return MINUS_ONE;
1932 }
1933
1934 /* Returns the offset for the entry at the INDEXth position
1935    in the GOT.  */
1936
1937 static bfd_vma
1938 mips_elf_got_offset_from_index (bfd *dynobj, bfd *output_bfd,
1939                                 bfd *input_bfd, bfd_vma index)
1940 {
1941   asection *sgot;
1942   bfd_vma gp;
1943   struct mips_got_info *g;
1944
1945   g = mips_elf_got_info (dynobj, &sgot);
1946   gp = _bfd_get_gp_value (output_bfd)
1947     + mips_elf_adjust_gp (output_bfd, g, input_bfd);
1948
1949   return sgot->output_section->vma + sgot->output_offset + index - gp;
1950 }
1951
1952 /* Create a local GOT entry for VALUE.  Return the index of the entry,
1953    or -1 if it could not be created.  */
1954
1955 static struct mips_got_entry *
1956 mips_elf_create_local_got_entry (bfd *abfd, bfd *ibfd,
1957                                  struct mips_got_info *gg,
1958                                  asection *sgot, bfd_vma value)
1959 {
1960   struct mips_got_entry entry, **loc;
1961   struct mips_got_info *g;
1962
1963   entry.abfd = NULL;
1964   entry.symndx = -1;
1965   entry.d.address = value;
1966
1967   g = mips_elf_got_for_ibfd (gg, ibfd);
1968   if (g == NULL)
1969     {
1970       g = mips_elf_got_for_ibfd (gg, abfd);
1971       BFD_ASSERT (g != NULL);
1972     }
1973
1974   loc = (struct mips_got_entry **) htab_find_slot (g->got_entries, &entry,
1975                                                    INSERT);
1976   if (*loc)
1977     return *loc;
1978
1979   entry.gotidx = MIPS_ELF_GOT_SIZE (abfd) * g->assigned_gotno++;
1980
1981   *loc = (struct mips_got_entry *)bfd_alloc (abfd, sizeof entry);
1982
1983   if (! *loc)
1984     return NULL;
1985
1986   memcpy (*loc, &entry, sizeof entry);
1987
1988   if (g->assigned_gotno >= g->local_gotno)
1989     {
1990       (*loc)->gotidx = -1;
1991       /* We didn't allocate enough space in the GOT.  */
1992       (*_bfd_error_handler)
1993         (_("not enough GOT space for local GOT entries"));
1994       bfd_set_error (bfd_error_bad_value);
1995       return NULL;
1996     }
1997
1998   MIPS_ELF_PUT_WORD (abfd, value,
1999                      (sgot->contents + entry.gotidx));
2000
2001   return *loc;
2002 }
2003
2004 /* Sort the dynamic symbol table so that symbols that need GOT entries
2005    appear towards the end.  This reduces the amount of GOT space
2006    required.  MAX_LOCAL is used to set the number of local symbols
2007    known to be in the dynamic symbol table.  During
2008    _bfd_mips_elf_size_dynamic_sections, this value is 1.  Afterward, the
2009    section symbols are added and the count is higher.  */
2010
2011 static bfd_boolean
2012 mips_elf_sort_hash_table (struct bfd_link_info *info, unsigned long max_local)
2013 {
2014   struct mips_elf_hash_sort_data hsd;
2015   struct mips_got_info *g;
2016   bfd *dynobj;
2017
2018   dynobj = elf_hash_table (info)->dynobj;
2019
2020   g = mips_elf_got_info (dynobj, NULL);
2021
2022   hsd.low = NULL;
2023   hsd.max_unref_got_dynindx =
2024   hsd.min_got_dynindx = elf_hash_table (info)->dynsymcount
2025     /* In the multi-got case, assigned_gotno of the master got_info
2026        indicate the number of entries that aren't referenced in the
2027        primary GOT, but that must have entries because there are
2028        dynamic relocations that reference it.  Since they aren't
2029        referenced, we move them to the end of the GOT, so that they
2030        don't prevent other entries that are referenced from getting
2031        too large offsets.  */
2032     - (g->next ? g->assigned_gotno : 0);
2033   hsd.max_non_got_dynindx = max_local;
2034   mips_elf_link_hash_traverse (((struct mips_elf_link_hash_table *)
2035                                 elf_hash_table (info)),
2036                                mips_elf_sort_hash_table_f,
2037                                &hsd);
2038
2039   /* There should have been enough room in the symbol table to
2040      accommodate both the GOT and non-GOT symbols.  */
2041   BFD_ASSERT (hsd.max_non_got_dynindx <= hsd.min_got_dynindx);
2042   BFD_ASSERT ((unsigned long)hsd.max_unref_got_dynindx
2043               <= elf_hash_table (info)->dynsymcount);
2044
2045   /* Now we know which dynamic symbol has the lowest dynamic symbol
2046      table index in the GOT.  */
2047   g->global_gotsym = hsd.low;
2048
2049   return TRUE;
2050 }
2051
2052 /* If H needs a GOT entry, assign it the highest available dynamic
2053    index.  Otherwise, assign it the lowest available dynamic
2054    index.  */
2055
2056 static bfd_boolean
2057 mips_elf_sort_hash_table_f (struct mips_elf_link_hash_entry *h, void *data)
2058 {
2059   struct mips_elf_hash_sort_data *hsd = data;
2060
2061   if (h->root.root.type == bfd_link_hash_warning)
2062     h = (struct mips_elf_link_hash_entry *) h->root.root.u.i.link;
2063
2064   /* Symbols without dynamic symbol table entries aren't interesting
2065      at all.  */
2066   if (h->root.dynindx == -1)
2067     return TRUE;
2068
2069   /* Global symbols that need GOT entries that are not explicitly
2070      referenced are marked with got offset 2.  Those that are
2071      referenced get a 1, and those that don't need GOT entries get
2072      -1.  */
2073   if (h->root.got.offset == 2)
2074     {
2075       if (hsd->max_unref_got_dynindx == hsd->min_got_dynindx)
2076         hsd->low = (struct elf_link_hash_entry *) h;
2077       h->root.dynindx = hsd->max_unref_got_dynindx++;
2078     }
2079   else if (h->root.got.offset != 1)
2080     h->root.dynindx = hsd->max_non_got_dynindx++;
2081   else
2082     {
2083       h->root.dynindx = --hsd->min_got_dynindx;
2084       hsd->low = (struct elf_link_hash_entry *) h;
2085     }
2086
2087   return TRUE;
2088 }
2089
2090 /* If H is a symbol that needs a global GOT entry, but has a dynamic
2091    symbol table index lower than any we've seen to date, record it for
2092    posterity.  */
2093
2094 static bfd_boolean
2095 mips_elf_record_global_got_symbol (struct elf_link_hash_entry *h,
2096                                    bfd *abfd, struct bfd_link_info *info,
2097                                    struct mips_got_info *g)
2098 {
2099   struct mips_got_entry entry, **loc;
2100
2101   /* A global symbol in the GOT must also be in the dynamic symbol
2102      table.  */
2103   if (h->dynindx == -1)
2104     {
2105       switch (ELF_ST_VISIBILITY (h->other))
2106         {
2107         case STV_INTERNAL:
2108         case STV_HIDDEN:
2109           _bfd_mips_elf_hide_symbol (info, h, TRUE);
2110           break;
2111         }
2112       if (!bfd_elf_link_record_dynamic_symbol (info, h))
2113         return FALSE;
2114     }
2115
2116   entry.abfd = abfd;
2117   entry.symndx = -1;
2118   entry.d.h = (struct mips_elf_link_hash_entry *) h;
2119
2120   loc = (struct mips_got_entry **) htab_find_slot (g->got_entries, &entry,
2121                                                    INSERT);
2122
2123   /* If we've already marked this entry as needing GOT space, we don't
2124      need to do it again.  */
2125   if (*loc)
2126     return TRUE;
2127
2128   *loc = (struct mips_got_entry *)bfd_alloc (abfd, sizeof entry);
2129
2130   if (! *loc)
2131     return FALSE;
2132
2133   entry.gotidx = -1;
2134   memcpy (*loc, &entry, sizeof entry);
2135
2136   if (h->got.offset != MINUS_ONE)
2137     return TRUE;
2138
2139   /* By setting this to a value other than -1, we are indicating that
2140      there needs to be a GOT entry for H.  Avoid using zero, as the
2141      generic ELF copy_indirect_symbol tests for <= 0.  */
2142   h->got.offset = 1;
2143
2144   return TRUE;
2145 }
2146
2147 /* Reserve space in G for a GOT entry containing the value of symbol
2148    SYMNDX in input bfd ABDF, plus ADDEND.  */
2149
2150 static bfd_boolean
2151 mips_elf_record_local_got_symbol (bfd *abfd, long symndx, bfd_vma addend,
2152                                   struct mips_got_info *g)
2153 {
2154   struct mips_got_entry entry, **loc;
2155
2156   entry.abfd = abfd;
2157   entry.symndx = symndx;
2158   entry.d.addend = addend;
2159   loc = (struct mips_got_entry **)
2160     htab_find_slot (g->got_entries, &entry, INSERT);
2161
2162   if (*loc)
2163     return TRUE;
2164
2165   entry.gotidx = g->local_gotno++;
2166
2167   *loc = (struct mips_got_entry *)bfd_alloc (abfd, sizeof entry);
2168
2169   if (! *loc)
2170     return FALSE;
2171
2172   memcpy (*loc, &entry, sizeof entry);
2173
2174   return TRUE;
2175 }
2176 \f
2177 /* Compute the hash value of the bfd in a bfd2got hash entry.  */
2178
2179 static hashval_t
2180 mips_elf_bfd2got_entry_hash (const void *entry_)
2181 {
2182   const struct mips_elf_bfd2got_hash *entry
2183     = (struct mips_elf_bfd2got_hash *)entry_;
2184
2185   return entry->bfd->id;
2186 }
2187
2188 /* Check whether two hash entries have the same bfd.  */
2189
2190 static int
2191 mips_elf_bfd2got_entry_eq (const void *entry1, const void *entry2)
2192 {
2193   const struct mips_elf_bfd2got_hash *e1
2194     = (const struct mips_elf_bfd2got_hash *)entry1;
2195   const struct mips_elf_bfd2got_hash *e2
2196     = (const struct mips_elf_bfd2got_hash *)entry2;
2197
2198   return e1->bfd == e2->bfd;
2199 }
2200
2201 /* In a multi-got link, determine the GOT to be used for IBDF.  G must
2202    be the master GOT data.  */
2203
2204 static struct mips_got_info *
2205 mips_elf_got_for_ibfd (struct mips_got_info *g, bfd *ibfd)
2206 {
2207   struct mips_elf_bfd2got_hash e, *p;
2208
2209   if (! g->bfd2got)
2210     return g;
2211
2212   e.bfd = ibfd;
2213   p = htab_find (g->bfd2got, &e);
2214   return p ? p->g : NULL;
2215 }
2216
2217 /* Create one separate got for each bfd that has entries in the global
2218    got, such that we can tell how many local and global entries each
2219    bfd requires.  */
2220
2221 static int
2222 mips_elf_make_got_per_bfd (void **entryp, void *p)
2223 {
2224   struct mips_got_entry *entry = (struct mips_got_entry *)*entryp;
2225   struct mips_elf_got_per_bfd_arg *arg = (struct mips_elf_got_per_bfd_arg *)p;
2226   htab_t bfd2got = arg->bfd2got;
2227   struct mips_got_info *g;
2228   struct mips_elf_bfd2got_hash bfdgot_entry, *bfdgot;
2229   void **bfdgotp;
2230
2231   /* Find the got_info for this GOT entry's input bfd.  Create one if
2232      none exists.  */
2233   bfdgot_entry.bfd = entry->abfd;
2234   bfdgotp = htab_find_slot (bfd2got, &bfdgot_entry, INSERT);
2235   bfdgot = (struct mips_elf_bfd2got_hash *)*bfdgotp;
2236
2237   if (bfdgot != NULL)
2238     g = bfdgot->g;
2239   else
2240     {
2241       bfdgot = (struct mips_elf_bfd2got_hash *)bfd_alloc
2242         (arg->obfd, sizeof (struct mips_elf_bfd2got_hash));
2243
2244       if (bfdgot == NULL)
2245         {
2246           arg->obfd = 0;
2247           return 0;
2248         }
2249
2250       *bfdgotp = bfdgot;
2251
2252       bfdgot->bfd = entry->abfd;
2253       bfdgot->g = g = (struct mips_got_info *)
2254         bfd_alloc (arg->obfd, sizeof (struct mips_got_info));
2255       if (g == NULL)
2256         {
2257           arg->obfd = 0;
2258           return 0;
2259         }
2260
2261       g->global_gotsym = NULL;
2262       g->global_gotno = 0;
2263       g->local_gotno = 0;
2264       g->assigned_gotno = -1;
2265       g->got_entries = htab_try_create (1, mips_elf_multi_got_entry_hash,
2266                                         mips_elf_multi_got_entry_eq, NULL);
2267       if (g->got_entries == NULL)
2268         {
2269           arg->obfd = 0;
2270           return 0;
2271         }
2272
2273       g->bfd2got = NULL;
2274       g->next = NULL;
2275     }
2276
2277   /* Insert the GOT entry in the bfd's got entry hash table.  */
2278   entryp = htab_find_slot (g->got_entries, entry, INSERT);
2279   if (*entryp != NULL)
2280     return 1;
2281
2282   *entryp = entry;
2283
2284   if (entry->symndx >= 0 || entry->d.h->forced_local)
2285     ++g->local_gotno;
2286   else
2287     ++g->global_gotno;
2288
2289   return 1;
2290 }
2291
2292 /* Attempt to merge gots of different input bfds.  Try to use as much
2293    as possible of the primary got, since it doesn't require explicit
2294    dynamic relocations, but don't use bfds that would reference global
2295    symbols out of the addressable range.  Failing the primary got,
2296    attempt to merge with the current got, or finish the current got
2297    and then make make the new got current.  */
2298
2299 static int
2300 mips_elf_merge_gots (void **bfd2got_, void *p)
2301 {
2302   struct mips_elf_bfd2got_hash *bfd2got
2303     = (struct mips_elf_bfd2got_hash *)*bfd2got_;
2304   struct mips_elf_got_per_bfd_arg *arg = (struct mips_elf_got_per_bfd_arg *)p;
2305   unsigned int lcount = bfd2got->g->local_gotno;
2306   unsigned int gcount = bfd2got->g->global_gotno;
2307   unsigned int maxcnt = arg->max_count;
2308
2309   /* If we don't have a primary GOT and this is not too big, use it as
2310      a starting point for the primary GOT.  */
2311   if (! arg->primary && lcount + gcount <= maxcnt)
2312     {
2313       arg->primary = bfd2got->g;
2314       arg->primary_count = lcount + gcount;
2315     }
2316   /* If it looks like we can merge this bfd's entries with those of
2317      the primary, merge them.  The heuristics is conservative, but we
2318      don't have to squeeze it too hard.  */
2319   else if (arg->primary
2320            && (arg->primary_count + lcount + gcount) <= maxcnt)
2321     {
2322       struct mips_got_info *g = bfd2got->g;
2323       int old_lcount = arg->primary->local_gotno;
2324       int old_gcount = arg->primary->global_gotno;
2325
2326       bfd2got->g = arg->primary;
2327
2328       htab_traverse (g->got_entries,
2329                      mips_elf_make_got_per_bfd,
2330                      arg);
2331       if (arg->obfd == NULL)
2332         return 0;
2333
2334       htab_delete (g->got_entries);
2335       /* We don't have to worry about releasing memory of the actual
2336          got entries, since they're all in the master got_entries hash
2337          table anyway.  */
2338
2339       BFD_ASSERT (old_lcount + lcount >= arg->primary->local_gotno);
2340       BFD_ASSERT (old_gcount + gcount >= arg->primary->global_gotno);
2341
2342       arg->primary_count = arg->primary->local_gotno
2343         + arg->primary->global_gotno;
2344     }
2345   /* If we can merge with the last-created got, do it.  */
2346   else if (arg->current
2347            && arg->current_count + lcount + gcount <= maxcnt)
2348     {
2349       struct mips_got_info *g = bfd2got->g;
2350       int old_lcount = arg->current->local_gotno;
2351       int old_gcount = arg->current->global_gotno;
2352
2353       bfd2got->g = arg->current;
2354
2355       htab_traverse (g->got_entries,
2356                      mips_elf_make_got_per_bfd,
2357                      arg);
2358       if (arg->obfd == NULL)
2359         return 0;
2360
2361       htab_delete (g->got_entries);
2362
2363       BFD_ASSERT (old_lcount + lcount >= arg->current->local_gotno);
2364       BFD_ASSERT (old_gcount + gcount >= arg->current->global_gotno);
2365
2366       arg->current_count = arg->current->local_gotno
2367         + arg->current->global_gotno;
2368     }
2369   /* Well, we couldn't merge, so create a new GOT.  Don't check if it
2370      fits; if it turns out that it doesn't, we'll get relocation
2371      overflows anyway.  */
2372   else
2373     {
2374       bfd2got->g->next = arg->current;
2375       arg->current = bfd2got->g;
2376
2377       arg->current_count = lcount + gcount;
2378     }
2379
2380   return 1;
2381 }
2382
2383 /* If passed a NULL mips_got_info in the argument, set the marker used
2384    to tell whether a global symbol needs a got entry (in the primary
2385    got) to the given VALUE.
2386
2387    If passed a pointer G to a mips_got_info in the argument (it must
2388    not be the primary GOT), compute the offset from the beginning of
2389    the (primary) GOT section to the entry in G corresponding to the
2390    global symbol.  G's assigned_gotno must contain the index of the
2391    first available global GOT entry in G.  VALUE must contain the size
2392    of a GOT entry in bytes.  For each global GOT entry that requires a
2393    dynamic relocation, NEEDED_RELOCS is incremented, and the symbol is
2394    marked as not eligible for lazy resolution through a function
2395    stub.  */
2396 static int
2397 mips_elf_set_global_got_offset (void **entryp, void *p)
2398 {
2399   struct mips_got_entry *entry = (struct mips_got_entry *)*entryp;
2400   struct mips_elf_set_global_got_offset_arg *arg
2401     = (struct mips_elf_set_global_got_offset_arg *)p;
2402   struct mips_got_info *g = arg->g;
2403
2404   if (entry->abfd != NULL && entry->symndx == -1
2405       && entry->d.h->root.dynindx != -1)
2406     {
2407       if (g)
2408         {
2409           BFD_ASSERT (g->global_gotsym == NULL);
2410
2411           entry->gotidx = arg->value * (long) g->assigned_gotno++;
2412           if (arg->info->shared
2413               || (elf_hash_table (arg->info)->dynamic_sections_created
2414                   && entry->d.h->root.def_dynamic
2415                   && !entry->d.h->root.def_regular))
2416             ++arg->needed_relocs;
2417         }
2418       else
2419         entry->d.h->root.got.offset = arg->value;
2420     }
2421
2422   return 1;
2423 }
2424
2425 /* Mark any global symbols referenced in the GOT we are iterating over
2426    as inelligible for lazy resolution stubs.  */
2427 static int
2428 mips_elf_set_no_stub (void **entryp, void *p ATTRIBUTE_UNUSED)
2429 {
2430   struct mips_got_entry *entry = (struct mips_got_entry *)*entryp;
2431
2432   if (entry->abfd != NULL
2433       && entry->symndx == -1
2434       && entry->d.h->root.dynindx != -1)
2435     entry->d.h->no_fn_stub = TRUE;
2436
2437   return 1;
2438 }
2439
2440 /* Follow indirect and warning hash entries so that each got entry
2441    points to the final symbol definition.  P must point to a pointer
2442    to the hash table we're traversing.  Since this traversal may
2443    modify the hash table, we set this pointer to NULL to indicate
2444    we've made a potentially-destructive change to the hash table, so
2445    the traversal must be restarted.  */
2446 static int
2447 mips_elf_resolve_final_got_entry (void **entryp, void *p)
2448 {
2449   struct mips_got_entry *entry = (struct mips_got_entry *)*entryp;
2450   htab_t got_entries = *(htab_t *)p;
2451
2452   if (entry->abfd != NULL && entry->symndx == -1)
2453     {
2454       struct mips_elf_link_hash_entry *h = entry->d.h;
2455
2456       while (h->root.root.type == bfd_link_hash_indirect
2457              || h->root.root.type == bfd_link_hash_warning)
2458         h = (struct mips_elf_link_hash_entry *) h->root.root.u.i.link;
2459
2460       if (entry->d.h == h)
2461         return 1;
2462
2463       entry->d.h = h;
2464
2465       /* If we can't find this entry with the new bfd hash, re-insert
2466          it, and get the traversal restarted.  */
2467       if (! htab_find (got_entries, entry))
2468         {
2469           htab_clear_slot (got_entries, entryp);
2470           entryp = htab_find_slot (got_entries, entry, INSERT);
2471           if (! *entryp)
2472             *entryp = entry;
2473           /* Abort the traversal, since the whole table may have
2474              moved, and leave it up to the parent to restart the
2475              process.  */
2476           *(htab_t *)p = NULL;
2477           return 0;
2478         }
2479       /* We might want to decrement the global_gotno count, but it's
2480          either too early or too late for that at this point.  */
2481     }
2482
2483   return 1;
2484 }
2485
2486 /* Turn indirect got entries in a got_entries table into their final
2487    locations.  */
2488 static void
2489 mips_elf_resolve_final_got_entries (struct mips_got_info *g)
2490 {
2491   htab_t got_entries;
2492
2493   do
2494     {
2495       got_entries = g->got_entries;
2496
2497       htab_traverse (got_entries,
2498                      mips_elf_resolve_final_got_entry,
2499                      &got_entries);
2500     }
2501   while (got_entries == NULL);
2502 }
2503
2504 /* Return the offset of an input bfd IBFD's GOT from the beginning of
2505    the primary GOT.  */
2506 static bfd_vma
2507 mips_elf_adjust_gp (bfd *abfd, struct mips_got_info *g, bfd *ibfd)
2508 {
2509   if (g->bfd2got == NULL)
2510     return 0;
2511
2512   g = mips_elf_got_for_ibfd (g, ibfd);
2513   if (! g)
2514     return 0;
2515
2516   BFD_ASSERT (g->next);
2517
2518   g = g->next;
2519
2520   return (g->local_gotno + g->global_gotno) * MIPS_ELF_GOT_SIZE (abfd);
2521 }
2522
2523 /* Turn a single GOT that is too big for 16-bit addressing into
2524    a sequence of GOTs, each one 16-bit addressable.  */
2525
2526 static bfd_boolean
2527 mips_elf_multi_got (bfd *abfd, struct bfd_link_info *info,
2528                     struct mips_got_info *g, asection *got,
2529                     bfd_size_type pages)
2530 {
2531   struct mips_elf_got_per_bfd_arg got_per_bfd_arg;
2532   struct mips_elf_set_global_got_offset_arg set_got_offset_arg;
2533   struct mips_got_info *gg;
2534   unsigned int assign;
2535
2536   g->bfd2got = htab_try_create (1, mips_elf_bfd2got_entry_hash,
2537                                 mips_elf_bfd2got_entry_eq, NULL);
2538   if (g->bfd2got == NULL)
2539     return FALSE;
2540
2541   got_per_bfd_arg.bfd2got = g->bfd2got;
2542   got_per_bfd_arg.obfd = abfd;
2543   got_per_bfd_arg.info = info;
2544
2545   /* Count how many GOT entries each input bfd requires, creating a
2546      map from bfd to got info while at that.  */
2547   mips_elf_resolve_final_got_entries (g);
2548   htab_traverse (g->got_entries, mips_elf_make_got_per_bfd, &got_per_bfd_arg);
2549   if (got_per_bfd_arg.obfd == NULL)
2550     return FALSE;
2551
2552   got_per_bfd_arg.current = NULL;
2553   got_per_bfd_arg.primary = NULL;
2554   /* Taking out PAGES entries is a worst-case estimate.  We could
2555      compute the maximum number of pages that each separate input bfd
2556      uses, but it's probably not worth it.  */
2557   got_per_bfd_arg.max_count = ((MIPS_ELF_GOT_MAX_SIZE (abfd)
2558                                 / MIPS_ELF_GOT_SIZE (abfd))
2559                                - MIPS_RESERVED_GOTNO - pages);
2560
2561   /* Try to merge the GOTs of input bfds together, as long as they
2562      don't seem to exceed the maximum GOT size, choosing one of them
2563      to be the primary GOT.  */
2564   htab_traverse (g->bfd2got, mips_elf_merge_gots, &got_per_bfd_arg);
2565   if (got_per_bfd_arg.obfd == NULL)
2566     return FALSE;
2567
2568   /* If we find any suitable primary GOT, create an empty one.  */
2569   if (got_per_bfd_arg.primary == NULL)
2570     {
2571       g->next = (struct mips_got_info *)
2572         bfd_alloc (abfd, sizeof (struct mips_got_info));
2573       if (g->next == NULL)
2574         return FALSE;
2575
2576       g->next->global_gotsym = NULL;
2577       g->next->global_gotno = 0;
2578       g->next->local_gotno = 0;
2579       g->next->assigned_gotno = 0;
2580       g->next->got_entries = htab_try_create (1, mips_elf_multi_got_entry_hash,
2581                                               mips_elf_multi_got_entry_eq,
2582                                               NULL);
2583       if (g->next->got_entries == NULL)
2584         return FALSE;
2585       g->next->bfd2got = NULL;
2586     }
2587   else
2588     g->next = got_per_bfd_arg.primary;
2589   g->next->next = got_per_bfd_arg.current;
2590
2591   /* GG is now the master GOT, and G is the primary GOT.  */
2592   gg = g;
2593   g = g->next;
2594
2595   /* Map the output bfd to the primary got.  That's what we're going
2596      to use for bfds that use GOT16 or GOT_PAGE relocations that we
2597      didn't mark in check_relocs, and we want a quick way to find it.
2598      We can't just use gg->next because we're going to reverse the
2599      list.  */
2600   {
2601     struct mips_elf_bfd2got_hash *bfdgot;
2602     void **bfdgotp;
2603
2604     bfdgot = (struct mips_elf_bfd2got_hash *)bfd_alloc
2605       (abfd, sizeof (struct mips_elf_bfd2got_hash));
2606
2607     if (bfdgot == NULL)
2608       return FALSE;
2609
2610     bfdgot->bfd = abfd;
2611     bfdgot->g = g;
2612     bfdgotp = htab_find_slot (gg->bfd2got, bfdgot, INSERT);
2613
2614     BFD_ASSERT (*bfdgotp == NULL);
2615     *bfdgotp = bfdgot;
2616   }
2617
2618   /* The IRIX dynamic linker requires every symbol that is referenced
2619      in a dynamic relocation to be present in the primary GOT, so
2620      arrange for them to appear after those that are actually
2621      referenced.
2622
2623      GNU/Linux could very well do without it, but it would slow down
2624      the dynamic linker, since it would have to resolve every dynamic
2625      symbol referenced in other GOTs more than once, without help from
2626      the cache.  Also, knowing that every external symbol has a GOT
2627      helps speed up the resolution of local symbols too, so GNU/Linux
2628      follows IRIX's practice.
2629
2630      The number 2 is used by mips_elf_sort_hash_table_f to count
2631      global GOT symbols that are unreferenced in the primary GOT, with
2632      an initial dynamic index computed from gg->assigned_gotno, where
2633      the number of unreferenced global entries in the primary GOT is
2634      preserved.  */
2635   if (1)
2636     {
2637       gg->assigned_gotno = gg->global_gotno - g->global_gotno;
2638       g->global_gotno = gg->global_gotno;
2639       set_got_offset_arg.value = 2;
2640     }
2641   else
2642     {
2643       /* This could be used for dynamic linkers that don't optimize
2644          symbol resolution while applying relocations so as to use
2645          primary GOT entries or assuming the symbol is locally-defined.
2646          With this code, we assign lower dynamic indices to global
2647          symbols that are not referenced in the primary GOT, so that
2648          their entries can be omitted.  */
2649       gg->assigned_gotno = 0;
2650       set_got_offset_arg.value = -1;
2651     }
2652
2653   /* Reorder dynamic symbols as described above (which behavior
2654      depends on the setting of VALUE).  */
2655   set_got_offset_arg.g = NULL;
2656   htab_traverse (gg->got_entries, mips_elf_set_global_got_offset,
2657                  &set_got_offset_arg);
2658   set_got_offset_arg.value = 1;
2659   htab_traverse (g->got_entries, mips_elf_set_global_got_offset,
2660                  &set_got_offset_arg);
2661   if (! mips_elf_sort_hash_table (info, 1))
2662     return FALSE;
2663
2664   /* Now go through the GOTs assigning them offset ranges.
2665      [assigned_gotno, local_gotno[ will be set to the range of local
2666      entries in each GOT.  We can then compute the end of a GOT by
2667      adding local_gotno to global_gotno.  We reverse the list and make
2668      it circular since then we'll be able to quickly compute the
2669      beginning of a GOT, by computing the end of its predecessor.  To
2670      avoid special cases for the primary GOT, while still preserving
2671      assertions that are valid for both single- and multi-got links,
2672      we arrange for the main got struct to have the right number of
2673      global entries, but set its local_gotno such that the initial
2674      offset of the primary GOT is zero.  Remember that the primary GOT
2675      will become the last item in the circular linked list, so it
2676      points back to the master GOT.  */
2677   gg->local_gotno = -g->global_gotno;
2678   gg->global_gotno = g->global_gotno;
2679   assign = 0;
2680   gg->next = gg;
2681
2682   do
2683     {
2684       struct mips_got_info *gn;
2685
2686       assign += MIPS_RESERVED_GOTNO;
2687       g->assigned_gotno = assign;
2688       g->local_gotno += assign + pages;
2689       assign = g->local_gotno + g->global_gotno;
2690
2691       /* Take g out of the direct list, and push it onto the reversed
2692          list that gg points to.  */
2693       gn = g->next;
2694       g->next = gg->next;
2695       gg->next = g;
2696       g = gn;
2697
2698       /* Mark global symbols in every non-primary GOT as ineligible for
2699          stubs.  */
2700       if (g)
2701         htab_traverse (g->got_entries, mips_elf_set_no_stub, NULL);
2702     }
2703   while (g);
2704
2705   got->size = (gg->next->local_gotno
2706                     + gg->next->global_gotno) * MIPS_ELF_GOT_SIZE (abfd);
2707
2708   return TRUE;
2709 }
2710
2711 \f
2712 /* Returns the first relocation of type r_type found, beginning with
2713    RELOCATION.  RELEND is one-past-the-end of the relocation table.  */
2714
2715 static const Elf_Internal_Rela *
2716 mips_elf_next_relocation (bfd *abfd ATTRIBUTE_UNUSED, unsigned int r_type,
2717                           const Elf_Internal_Rela *relocation,
2718                           const Elf_Internal_Rela *relend)
2719 {
2720   while (relocation < relend)
2721     {
2722       if (ELF_R_TYPE (abfd, relocation->r_info) == r_type)
2723         return relocation;
2724
2725       ++relocation;
2726     }
2727
2728   /* We didn't find it.  */
2729   bfd_set_error (bfd_error_bad_value);
2730   return NULL;
2731 }
2732
2733 /* Return whether a relocation is against a local symbol.  */
2734
2735 static bfd_boolean
2736 mips_elf_local_relocation_p (bfd *input_bfd,
2737                              const Elf_Internal_Rela *relocation,
2738                              asection **local_sections,
2739                              bfd_boolean check_forced)
2740 {
2741   unsigned long r_symndx;
2742   Elf_Internal_Shdr *symtab_hdr;
2743   struct mips_elf_link_hash_entry *h;
2744   size_t extsymoff;
2745
2746   r_symndx = ELF_R_SYM (input_bfd, relocation->r_info);
2747   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2748   extsymoff = (elf_bad_symtab (input_bfd)) ? 0 : symtab_hdr->sh_info;
2749
2750   if (r_symndx < extsymoff)
2751     return TRUE;
2752   if (elf_bad_symtab (input_bfd) && local_sections[r_symndx] != NULL)
2753     return TRUE;
2754
2755   if (check_forced)
2756     {
2757       /* Look up the hash table to check whether the symbol
2758          was forced local.  */
2759       h = (struct mips_elf_link_hash_entry *)
2760         elf_sym_hashes (input_bfd) [r_symndx - extsymoff];
2761       /* Find the real hash-table entry for this symbol.  */
2762       while (h->root.root.type == bfd_link_hash_indirect
2763              || h->root.root.type == bfd_link_hash_warning)
2764         h = (struct mips_elf_link_hash_entry *) h->root.root.u.i.link;
2765       if (h->root.forced_local)
2766         return TRUE;
2767     }
2768
2769   return FALSE;
2770 }
2771 \f
2772 /* Sign-extend VALUE, which has the indicated number of BITS.  */
2773
2774 bfd_vma
2775 _bfd_mips_elf_sign_extend (bfd_vma value, int bits)
2776 {
2777   if (value & ((bfd_vma) 1 << (bits - 1)))
2778     /* VALUE is negative.  */
2779     value |= ((bfd_vma) - 1) << bits;
2780
2781   return value;
2782 }
2783
2784 /* Return non-zero if the indicated VALUE has overflowed the maximum
2785    range expressible by a signed number with the indicated number of
2786    BITS.  */
2787
2788 static bfd_boolean
2789 mips_elf_overflow_p (bfd_vma value, int bits)
2790 {
2791   bfd_signed_vma svalue = (bfd_signed_vma) value;
2792
2793   if (svalue > (1 << (bits - 1)) - 1)
2794     /* The value is too big.  */
2795     return TRUE;
2796   else if (svalue < -(1 << (bits - 1)))
2797     /* The value is too small.  */
2798     return TRUE;
2799
2800   /* All is well.  */
2801   return FALSE;
2802 }
2803
2804 /* Calculate the %high function.  */
2805
2806 static bfd_vma
2807 mips_elf_high (bfd_vma value)
2808 {
2809   return ((value + (bfd_vma) 0x8000) >> 16) & 0xffff;
2810 }
2811
2812 /* Calculate the %higher function.  */
2813
2814 static bfd_vma
2815 mips_elf_higher (bfd_vma value ATTRIBUTE_UNUSED)
2816 {
2817 #ifdef BFD64
2818   return ((value + (bfd_vma) 0x80008000) >> 32) & 0xffff;
2819 #else
2820   abort ();
2821   return MINUS_ONE;
2822 #endif
2823 }
2824
2825 /* Calculate the %highest function.  */
2826
2827 static bfd_vma
2828 mips_elf_highest (bfd_vma value ATTRIBUTE_UNUSED)
2829 {
2830 #ifdef BFD64
2831   return ((value + (((bfd_vma) 0x8000 << 32) | 0x80008000)) >> 48) & 0xffff;
2832 #else
2833   abort ();
2834   return MINUS_ONE;
2835 #endif
2836 }
2837 \f
2838 /* Create the .compact_rel section.  */
2839
2840 static bfd_boolean
2841 mips_elf_create_compact_rel_section
2842   (bfd *abfd, struct bfd_link_info *info ATTRIBUTE_UNUSED)
2843 {
2844   flagword flags;
2845   register asection *s;
2846
2847   if (bfd_get_section_by_name (abfd, ".compact_rel") == NULL)
2848     {
2849       flags = (SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED
2850                | SEC_READONLY);
2851
2852       s = bfd_make_section (abfd, ".compact_rel");
2853       if (s == NULL
2854           || ! bfd_set_section_flags (abfd, s, flags)
2855           || ! bfd_set_section_alignment (abfd, s,
2856                                           MIPS_ELF_LOG_FILE_ALIGN (abfd)))
2857         return FALSE;
2858
2859       s->size = sizeof (Elf32_External_compact_rel);
2860     }
2861
2862   return TRUE;
2863 }
2864
2865 /* Create the .got section to hold the global offset table.  */
2866
2867 static bfd_boolean
2868 mips_elf_create_got_section (bfd *abfd, struct bfd_link_info *info,
2869                              bfd_boolean maybe_exclude)
2870 {
2871   flagword flags;
2872   register asection *s;
2873   struct elf_link_hash_entry *h;
2874   struct bfd_link_hash_entry *bh;
2875   struct mips_got_info *g;
2876   bfd_size_type amt;
2877
2878   /* This function may be called more than once.  */
2879   s = mips_elf_got_section (abfd, TRUE);
2880   if (s)
2881     {
2882       if (! maybe_exclude)
2883         s->flags &= ~SEC_EXCLUDE;
2884       return TRUE;
2885     }
2886
2887   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
2888            | SEC_LINKER_CREATED);
2889
2890   if (maybe_exclude)
2891     flags |= SEC_EXCLUDE;
2892
2893   /* We have to use an alignment of 2**4 here because this is hardcoded
2894      in the function stub generation and in the linker script.  */
2895   s = bfd_make_section (abfd, ".got");
2896   if (s == NULL
2897       || ! bfd_set_section_flags (abfd, s, flags)
2898       || ! bfd_set_section_alignment (abfd, s, 4))
2899     return FALSE;
2900
2901   /* Define the symbol _GLOBAL_OFFSET_TABLE_.  We don't do this in the
2902      linker script because we don't want to define the symbol if we
2903      are not creating a global offset table.  */
2904   bh = NULL;
2905   if (! (_bfd_generic_link_add_one_symbol
2906          (info, abfd, "_GLOBAL_OFFSET_TABLE_", BSF_GLOBAL, s,
2907           0, NULL, FALSE, get_elf_backend_data (abfd)->collect, &bh)))
2908     return FALSE;
2909
2910   h = (struct elf_link_hash_entry *) bh;
2911   h->non_elf = 0;
2912   h->def_regular = 1;
2913   h->type = STT_OBJECT;
2914
2915   if (info->shared
2916       && ! bfd_elf_link_record_dynamic_symbol (info, h))
2917     return FALSE;
2918
2919   amt = sizeof (struct mips_got_info);
2920   g = bfd_alloc (abfd, amt);
2921   if (g == NULL)
2922     return FALSE;
2923   g->global_gotsym = NULL;
2924   g->global_gotno = 0;
2925   g->local_gotno = MIPS_RESERVED_GOTNO;
2926   g->assigned_gotno = MIPS_RESERVED_GOTNO;
2927   g->bfd2got = NULL;
2928   g->next = NULL;
2929   g->got_entries = htab_try_create (1, mips_elf_got_entry_hash,
2930                                     mips_elf_got_entry_eq, NULL);
2931   if (g->got_entries == NULL)
2932     return FALSE;
2933   mips_elf_section_data (s)->u.got_info = g;
2934   mips_elf_section_data (s)->elf.this_hdr.sh_flags
2935     |= SHF_ALLOC | SHF_WRITE | SHF_MIPS_GPREL;
2936
2937   return TRUE;
2938 }
2939 \f
2940 /* Calculate the value produced by the RELOCATION (which comes from
2941    the INPUT_BFD).  The ADDEND is the addend to use for this
2942    RELOCATION; RELOCATION->R_ADDEND is ignored.
2943
2944    The result of the relocation calculation is stored in VALUEP.
2945    REQUIRE_JALXP indicates whether or not the opcode used with this
2946    relocation must be JALX.
2947
2948    This function returns bfd_reloc_continue if the caller need take no
2949    further action regarding this relocation, bfd_reloc_notsupported if
2950    something goes dramatically wrong, bfd_reloc_overflow if an
2951    overflow occurs, and bfd_reloc_ok to indicate success.  */
2952
2953 static bfd_reloc_status_type
2954 mips_elf_calculate_relocation (bfd *abfd, bfd *input_bfd,
2955                                asection *input_section,
2956                                struct bfd_link_info *info,
2957                                const Elf_Internal_Rela *relocation,
2958                                bfd_vma addend, reloc_howto_type *howto,
2959                                Elf_Internal_Sym *local_syms,
2960                                asection **local_sections, bfd_vma *valuep,
2961                                const char **namep, bfd_boolean *require_jalxp,
2962                                bfd_boolean save_addend)
2963 {
2964   /* The eventual value we will return.  */
2965   bfd_vma value;
2966   /* The address of the symbol against which the relocation is
2967      occurring.  */
2968   bfd_vma symbol = 0;
2969   /* The final GP value to be used for the relocatable, executable, or
2970      shared object file being produced.  */
2971   bfd_vma gp = MINUS_ONE;
2972   /* The place (section offset or address) of the storage unit being
2973      relocated.  */
2974   bfd_vma p;
2975   /* The value of GP used to create the relocatable object.  */
2976   bfd_vma gp0 = MINUS_ONE;
2977   /* The offset into the global offset table at which the address of
2978      the relocation entry symbol, adjusted by the addend, resides
2979      during execution.  */
2980   bfd_vma g = MINUS_ONE;
2981   /* The section in which the symbol referenced by the relocation is
2982      located.  */
2983   asection *sec = NULL;
2984   struct mips_elf_link_hash_entry *h = NULL;
2985   /* TRUE if the symbol referred to by this relocation is a local
2986      symbol.  */
2987   bfd_boolean local_p, was_local_p;
2988   /* TRUE if the symbol referred to by this relocation is "_gp_disp".  */
2989   bfd_boolean gp_disp_p = FALSE;
2990   Elf_Internal_Shdr *symtab_hdr;
2991   size_t extsymoff;
2992   unsigned long r_symndx;
2993   int r_type;
2994   /* TRUE if overflow occurred during the calculation of the
2995      relocation value.  */
2996   bfd_boolean overflowed_p;
2997   /* TRUE if this relocation refers to a MIPS16 function.  */
2998   bfd_boolean target_is_16_bit_code_p = FALSE;
2999
3000   /* Parse the relocation.  */
3001   r_symndx = ELF_R_SYM (input_bfd, relocation->r_info);
3002   r_type = ELF_R_TYPE (input_bfd, relocation->r_info);
3003   p = (input_section->output_section->vma
3004        + input_section->output_offset
3005        + relocation->r_offset);
3006
3007   /* Assume that there will be no overflow.  */
3008   overflowed_p = FALSE;
3009
3010   /* Figure out whether or not the symbol is local, and get the offset
3011      used in the array of hash table entries.  */
3012   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
3013   local_p = mips_elf_local_relocation_p (input_bfd, relocation,
3014                                          local_sections, FALSE);
3015   was_local_p = local_p;
3016   if (! elf_bad_symtab (input_bfd))
3017     extsymoff = symtab_hdr->sh_info;
3018   else
3019     {
3020       /* The symbol table does not follow the rule that local symbols
3021          must come before globals.  */
3022       extsymoff = 0;
3023     }
3024
3025   /* Figure out the value of the symbol.  */
3026   if (local_p)
3027     {
3028       Elf_Internal_Sym *sym;
3029
3030       sym = local_syms + r_symndx;
3031       sec = local_sections[r_symndx];
3032
3033       symbol = sec->output_section->vma + sec->output_offset;
3034       if (ELF_ST_TYPE (sym->st_info) != STT_SECTION
3035           || (sec->flags & SEC_MERGE))
3036         symbol += sym->st_value;
3037       if ((sec->flags & SEC_MERGE)
3038           && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
3039         {
3040           addend = _bfd_elf_rel_local_sym (abfd, sym, &sec, addend);
3041           addend -= symbol;
3042           addend += sec->output_section->vma + sec->output_offset;
3043         }
3044
3045       /* MIPS16 text labels should be treated as odd.  */
3046       if (sym->st_other == STO_MIPS16)
3047         ++symbol;
3048
3049       /* Record the name of this symbol, for our caller.  */
3050       *namep = bfd_elf_string_from_elf_section (input_bfd,
3051                                                 symtab_hdr->sh_link,
3052                                                 sym->st_name);
3053       if (*namep == '\0')
3054         *namep = bfd_section_name (input_bfd, sec);
3055
3056       target_is_16_bit_code_p = (sym->st_other == STO_MIPS16);
3057     }
3058   else
3059     {
3060       /* ??? Could we use RELOC_FOR_GLOBAL_SYMBOL here ?  */
3061
3062       /* For global symbols we look up the symbol in the hash-table.  */
3063       h = ((struct mips_elf_link_hash_entry *)
3064            elf_sym_hashes (input_bfd) [r_symndx - extsymoff]);
3065       /* Find the real hash-table entry for this symbol.  */
3066       while (h->root.root.type == bfd_link_hash_indirect
3067              || h->root.root.type == bfd_link_hash_warning)
3068         h = (struct mips_elf_link_hash_entry *) h->root.root.u.i.link;
3069
3070       /* Record the name of this symbol, for our caller.  */
3071       *namep = h->root.root.root.string;
3072
3073       /* See if this is the special _gp_disp symbol.  Note that such a
3074          symbol must always be a global symbol.  */
3075       if (strcmp (*namep, "_gp_disp") == 0
3076           && ! NEWABI_P (input_bfd))
3077         {
3078           /* Relocations against _gp_disp are permitted only with
3079              R_MIPS_HI16 and R_MIPS_LO16 relocations.  */
3080           if (r_type != R_MIPS_HI16 && r_type != R_MIPS_LO16)
3081             return bfd_reloc_notsupported;
3082
3083           gp_disp_p = TRUE;
3084         }
3085       /* If this symbol is defined, calculate its address.  Note that
3086          _gp_disp is a magic symbol, always implicitly defined by the
3087          linker, so it's inappropriate to check to see whether or not
3088          its defined.  */
3089       else if ((h->root.root.type == bfd_link_hash_defined
3090                 || h->root.root.type == bfd_link_hash_defweak)
3091                && h->root.root.u.def.section)
3092         {
3093           sec = h->root.root.u.def.section;
3094           if (sec->output_section)
3095             symbol = (h->root.root.u.def.value
3096                       + sec->output_section->vma
3097                       + sec->output_offset);
3098           else
3099             symbol = h->root.root.u.def.value;
3100         }
3101       else if (h->root.root.type == bfd_link_hash_undefweak)
3102         /* We allow relocations against undefined weak symbols, giving
3103            it the value zero, so that you can undefined weak functions
3104            and check to see if they exist by looking at their
3105            addresses.  */
3106         symbol = 0;
3107       else if (info->unresolved_syms_in_objects == RM_IGNORE
3108                && ELF_ST_VISIBILITY (h->root.other) == STV_DEFAULT)
3109         symbol = 0;
3110       else if (strcmp (*namep, SGI_COMPAT (input_bfd)
3111                        ? "_DYNAMIC_LINK" : "_DYNAMIC_LINKING") == 0)
3112         {
3113           /* If this is a dynamic link, we should have created a
3114              _DYNAMIC_LINK symbol or _DYNAMIC_LINKING(for normal mips) symbol
3115              in in _bfd_mips_elf_create_dynamic_sections.
3116              Otherwise, we should define the symbol with a value of 0.
3117              FIXME: It should probably get into the symbol table
3118              somehow as well.  */
3119           BFD_ASSERT (! info->shared);
3120           BFD_ASSERT (bfd_get_section_by_name (abfd, ".dynamic") == NULL);
3121           symbol = 0;
3122         }
3123       else
3124         {
3125           if (! ((*info->callbacks->undefined_symbol)
3126                  (info, h->root.root.root.string, input_bfd,
3127                   input_section, relocation->r_offset,
3128                   (info->unresolved_syms_in_objects == RM_GENERATE_ERROR)
3129                    || ELF_ST_VISIBILITY (h->root.other))))
3130             return bfd_reloc_undefined;
3131           symbol = 0;
3132         }
3133
3134       target_is_16_bit_code_p = (h->root.other == STO_MIPS16);
3135     }
3136
3137   /* If this is a 32- or 64-bit call to a 16-bit function with a stub, we
3138      need to redirect the call to the stub, unless we're already *in*
3139      a stub.  */
3140   if (r_type != R_MIPS16_26 && !info->relocatable
3141       && ((h != NULL && h->fn_stub != NULL)
3142           || (local_p && elf_tdata (input_bfd)->local_stubs != NULL
3143               && elf_tdata (input_bfd)->local_stubs[r_symndx] != NULL))
3144       && !mips_elf_stub_section_p (input_bfd, input_section))
3145     {
3146       /* This is a 32- or 64-bit call to a 16-bit function.  We should
3147          have already noticed that we were going to need the
3148          stub.  */
3149       if (local_p)
3150         sec = elf_tdata (input_bfd)->local_stubs[r_symndx];
3151       else
3152         {
3153           BFD_ASSERT (h->need_fn_stub);
3154           sec = h->fn_stub;
3155         }
3156
3157       symbol = sec->output_section->vma + sec->output_offset;
3158     }
3159   /* If this is a 16-bit call to a 32- or 64-bit function with a stub, we
3160      need to redirect the call to the stub.  */
3161   else if (r_type == R_MIPS16_26 && !info->relocatable
3162            && h != NULL
3163            && (h->call_stub != NULL || h->call_fp_stub != NULL)
3164            && !target_is_16_bit_code_p)
3165     {
3166       /* If both call_stub and call_fp_stub are defined, we can figure
3167          out which one to use by seeing which one appears in the input
3168          file.  */
3169       if (h->call_stub != NULL && h->call_fp_stub != NULL)
3170         {
3171           asection *o;
3172
3173           sec = NULL;
3174           for (o = input_bfd->sections; o != NULL; o = o->next)
3175             {
3176               if (strncmp (bfd_get_section_name (input_bfd, o),
3177                            CALL_FP_STUB, sizeof CALL_FP_STUB - 1) == 0)
3178                 {
3179                   sec = h->call_fp_stub;
3180                   break;
3181                 }
3182             }
3183           if (sec == NULL)
3184             sec = h->call_stub;
3185         }
3186       else if (h->call_stub != NULL)
3187         sec = h->call_stub;
3188       else
3189         sec = h->call_fp_stub;
3190
3191       BFD_ASSERT (sec->size > 0);
3192       symbol = sec->output_section->vma + sec->output_offset;
3193     }
3194
3195   /* Calls from 16-bit code to 32-bit code and vice versa require the
3196      special jalx instruction.  */
3197   *require_jalxp = (!info->relocatable
3198                     && (((r_type == R_MIPS16_26) && !target_is_16_bit_code_p)
3199                         || ((r_type == R_MIPS_26) && target_is_16_bit_code_p)));
3200
3201   local_p = mips_elf_local_relocation_p (input_bfd, relocation,
3202                                          local_sections, TRUE);
3203
3204   /* If we haven't already determined the GOT offset, or the GP value,
3205      and we're going to need it, get it now.  */
3206   switch (r_type)
3207     {
3208     case R_MIPS_GOT_PAGE:
3209     case R_MIPS_GOT_OFST:
3210       /* We need to decay to GOT_DISP/addend if the symbol doesn't
3211          bind locally.  */
3212       local_p = local_p || _bfd_elf_symbol_refs_local_p (&h->root, info, 1);
3213       if (local_p || r_type == R_MIPS_GOT_OFST)
3214         break;
3215       /* Fall through.  */
3216
3217     case R_MIPS_CALL16:
3218     case R_MIPS_GOT16:
3219     case R_MIPS_GOT_DISP:
3220     case R_MIPS_GOT_HI16:
3221     case R_MIPS_CALL_HI16:
3222     case R_MIPS_GOT_LO16:
3223     case R_MIPS_CALL_LO16:
3224       /* Find the index into the GOT where this value is located.  */
3225       if (!local_p)
3226         {
3227           /* GOT_PAGE may take a non-zero addend, that is ignored in a
3228              GOT_PAGE relocation that decays to GOT_DISP because the
3229              symbol turns out to be global.  The addend is then added
3230              as GOT_OFST.  */
3231           BFD_ASSERT (addend == 0 || r_type == R_MIPS_GOT_PAGE);
3232           g = mips_elf_global_got_index (elf_hash_table (info)->dynobj,
3233                                          input_bfd,
3234                                          (struct elf_link_hash_entry *) h);
3235           if (! elf_hash_table(info)->dynamic_sections_created
3236               || (info->shared
3237                   && (info->symbolic || h->root.dynindx == -1)
3238                   && h->root.def_regular))
3239             {
3240               /* This is a static link or a -Bsymbolic link.  The
3241                  symbol is defined locally, or was forced to be local.
3242                  We must initialize this entry in the GOT.  */
3243               bfd *tmpbfd = elf_hash_table (info)->dynobj;
3244               asection *sgot = mips_elf_got_section (tmpbfd, FALSE);
3245               MIPS_ELF_PUT_WORD (tmpbfd, symbol, sgot->contents + g);
3246             }
3247         }
3248       else if (r_type == R_MIPS_GOT16 || r_type == R_MIPS_CALL16)
3249         /* There's no need to create a local GOT entry here; the
3250            calculation for a local GOT16 entry does not involve G.  */
3251         break;
3252       else
3253         {
3254           g = mips_elf_local_got_index (abfd, input_bfd,
3255                                         info, symbol + addend);
3256           if (g == MINUS_ONE)
3257             return bfd_reloc_outofrange;
3258         }
3259
3260       /* Convert GOT indices to actual offsets.  */
3261       g = mips_elf_got_offset_from_index (elf_hash_table (info)->dynobj,
3262                                           abfd, input_bfd, g);
3263       break;
3264
3265     case R_MIPS_HI16:
3266     case R_MIPS_LO16:
3267     case R_MIPS16_GPREL:
3268     case R_MIPS_GPREL16:
3269     case R_MIPS_GPREL32:
3270     case R_MIPS_LITERAL:
3271       gp0 = _bfd_get_gp_value (input_bfd);
3272       gp = _bfd_get_gp_value (abfd);
3273       if (elf_hash_table (info)->dynobj)
3274         gp += mips_elf_adjust_gp (abfd,
3275                                   mips_elf_got_info
3276                                   (elf_hash_table (info)->dynobj, NULL),
3277                                   input_bfd);
3278       break;
3279
3280     default:
3281       break;
3282     }
3283
3284   /* Figure out what kind of relocation is being performed.  */
3285   switch (r_type)
3286     {
3287     case R_MIPS_NONE:
3288       return bfd_reloc_continue;
3289
3290     case R_MIPS_16:
3291       value = symbol + _bfd_mips_elf_sign_extend (addend, 16);
3292       overflowed_p = mips_elf_overflow_p (value, 16);
3293       break;
3294
3295     case R_MIPS_32:
3296     case R_MIPS_REL32:
3297     case R_MIPS_64:
3298       if ((info->shared
3299            || (elf_hash_table (info)->dynamic_sections_created
3300                && h != NULL
3301                && h->root.def_dynamic
3302                && !h->root.def_regular))
3303           && r_symndx != 0
3304           && (input_section->flags & SEC_ALLOC) != 0)
3305         {
3306           /* If we're creating a shared library, or this relocation is
3307              against a symbol in a shared library, then we can't know
3308              where the symbol will end up.  So, we create a relocation
3309              record in the output, and leave the job up to the dynamic
3310              linker.  */
3311           value = addend;
3312           if (!mips_elf_create_dynamic_relocation (abfd,
3313                                                    info,
3314                                                    relocation,
3315                                                    h,
3316                                                    sec,
3317                                                    symbol,
3318                                                    &value,
3319                                                    input_section))
3320             return bfd_reloc_undefined;
3321         }
3322       else
3323         {
3324           if (r_type != R_MIPS_REL32)
3325             value = symbol + addend;
3326           else
3327             value = addend;
3328         }
3329       value &= howto->dst_mask;
3330       break;
3331
3332     case R_MIPS_PC32:
3333       value = symbol + addend - p;
3334       value &= howto->dst_mask;
3335       break;
3336
3337     case R_MIPS_GNU_REL16_S2:
3338       value = symbol + _bfd_mips_elf_sign_extend (addend, 18) - p;
3339       overflowed_p = mips_elf_overflow_p (value, 18);
3340       value = (value >> 2) & howto->dst_mask;
3341       break;
3342
3343     case R_MIPS16_26:
3344       /* The calculation for R_MIPS16_26 is just the same as for an
3345          R_MIPS_26.  It's only the storage of the relocated field into
3346          the output file that's different.  That's handled in
3347          mips_elf_perform_relocation.  So, we just fall through to the
3348          R_MIPS_26 case here.  */
3349     case R_MIPS_26:
3350       if (local_p)
3351         value = ((addend | ((p + 4) & 0xf0000000)) + symbol) >> 2;
3352       else
3353         value = (_bfd_mips_elf_sign_extend (addend, 28) + symbol) >> 2;
3354       value &= howto->dst_mask;
3355       break;
3356
3357     case R_MIPS_HI16:
3358       if (!gp_disp_p)
3359         {
3360           value = mips_elf_high (addend + symbol);
3361           value &= howto->dst_mask;
3362         }
3363       else
3364         {
3365           value = mips_elf_high (addend + gp - p);
3366           overflowed_p = mips_elf_overflow_p (value, 16);
3367         }
3368       break;
3369
3370     case R_MIPS_LO16:
3371       if (!gp_disp_p)
3372         value = (symbol + addend) & howto->dst_mask;
3373       else
3374         {
3375           value = addend + gp - p + 4;
3376           /* The MIPS ABI requires checking the R_MIPS_LO16 relocation
3377              for overflow.  But, on, say, IRIX5, relocations against
3378              _gp_disp are normally generated from the .cpload
3379              pseudo-op.  It generates code that normally looks like
3380              this:
3381
3382                lui    $gp,%hi(_gp_disp)
3383                addiu  $gp,$gp,%lo(_gp_disp)
3384                addu   $gp,$gp,$t9
3385
3386              Here $t9 holds the address of the function being called,
3387              as required by the MIPS ELF ABI.  The R_MIPS_LO16
3388              relocation can easily overflow in this situation, but the
3389              R_MIPS_HI16 relocation will handle the overflow.
3390              Therefore, we consider this a bug in the MIPS ABI, and do
3391              not check for overflow here.  */
3392         }
3393       break;
3394
3395     case R_MIPS_LITERAL:
3396       /* Because we don't merge literal sections, we can handle this
3397          just like R_MIPS_GPREL16.  In the long run, we should merge
3398          shared literals, and then we will need to additional work
3399          here.  */
3400
3401       /* Fall through.  */
3402
3403     case R_MIPS16_GPREL:
3404       /* The R_MIPS16_GPREL performs the same calculation as
3405          R_MIPS_GPREL16, but stores the relocated bits in a different
3406          order.  We don't need to do anything special here; the
3407          differences are handled in mips_elf_perform_relocation.  */
3408     case R_MIPS_GPREL16:
3409       /* Only sign-extend the addend if it was extracted from the
3410          instruction.  If the addend was separate, leave it alone,
3411          otherwise we may lose significant bits.  */
3412       if (howto->partial_inplace)
3413         addend = _bfd_mips_elf_sign_extend (addend, 16);
3414       value = symbol + addend - gp;
3415       /* If the symbol was local, any earlier relocatable links will
3416          have adjusted its addend with the gp offset, so compensate
3417          for that now.  Don't do it for symbols forced local in this
3418          link, though, since they won't have had the gp offset applied
3419          to them before.  */
3420       if (was_local_p)
3421         value += gp0;
3422       overflowed_p = mips_elf_overflow_p (value, 16);
3423       break;
3424
3425     case R_MIPS_GOT16:
3426     case R_MIPS_CALL16:
3427       if (local_p)
3428         {
3429           bfd_boolean forced;
3430
3431           /* The special case is when the symbol is forced to be local.  We
3432              need the full address in the GOT since no R_MIPS_LO16 relocation
3433              follows.  */
3434           forced = ! mips_elf_local_relocation_p (input_bfd, relocation,
3435                                                   local_sections, FALSE);
3436           value = mips_elf_got16_entry (abfd, input_bfd, info,
3437                                         symbol + addend, forced);
3438           if (value == MINUS_ONE)
3439             return bfd_reloc_outofrange;
3440           value
3441             = mips_elf_got_offset_from_index (elf_hash_table (info)->dynobj,
3442                                               abfd, input_bfd, value);
3443           overflowed_p = mips_elf_overflow_p (value, 16);
3444           break;
3445         }
3446
3447       /* Fall through.  */
3448
3449     case R_MIPS_GOT_DISP:
3450     got_disp:
3451       value = g;
3452       overflowed_p = mips_elf_overflow_p (value, 16);
3453       break;
3454
3455     case R_MIPS_GPREL32:
3456       value = (addend + symbol + gp0 - gp);
3457       if (!save_addend)
3458         value &= howto->dst_mask;
3459       break;
3460
3461     case R_MIPS_PC16:
3462       value = _bfd_mips_elf_sign_extend (addend, 16) + symbol - p;
3463       overflowed_p = mips_elf_overflow_p (value, 16);
3464       break;
3465
3466     case R_MIPS_GOT_HI16:
3467     case R_MIPS_CALL_HI16:
3468       /* We're allowed to handle these two relocations identically.
3469          The dynamic linker is allowed to handle the CALL relocations
3470          differently by creating a lazy evaluation stub.  */
3471       value = g;
3472       value = mips_elf_high (value);
3473       value &= howto->dst_mask;
3474       break;
3475
3476     case R_MIPS_GOT_LO16:
3477     case R_MIPS_CALL_LO16:
3478       value = g & howto->dst_mask;
3479       break;
3480
3481     case R_MIPS_GOT_PAGE:
3482       /* GOT_PAGE relocations that reference non-local symbols decay
3483          to GOT_DISP.  The corresponding GOT_OFST relocation decays to
3484          0.  */
3485       if (! local_p)
3486         goto got_disp;
3487       value = mips_elf_got_page (abfd, input_bfd, info, symbol + addend, NULL);
3488       if (value == MINUS_ONE)
3489         return bfd_reloc_outofrange;
3490       value = mips_elf_got_offset_from_index (elf_hash_table (info)->dynobj,
3491                                               abfd, input_bfd, value);
3492       overflowed_p = mips_elf_overflow_p (value, 16);
3493       break;
3494
3495     case R_MIPS_GOT_OFST:
3496       if (local_p)
3497         mips_elf_got_page (abfd, input_bfd, info, symbol + addend, &value);
3498       else
3499         value = addend;
3500       overflowed_p = mips_elf_overflow_p (value, 16);
3501       break;
3502
3503     case R_MIPS_SUB:
3504       value = symbol - addend;
3505       value &= howto->dst_mask;
3506       break;
3507
3508     case R_MIPS_HIGHER:
3509       value = mips_elf_higher (addend + symbol);
3510       value &= howto->dst_mask;
3511       break;
3512
3513     case R_MIPS_HIGHEST:
3514       value = mips_elf_highest (addend + symbol);
3515       value &= howto->dst_mask;
3516       break;
3517
3518     case R_MIPS_SCN_DISP:
3519       value = symbol + addend - sec->output_offset;
3520       value &= howto->dst_mask;
3521       break;
3522
3523     case R_MIPS_PJUMP:
3524     case R_MIPS_JALR:
3525       /* Both of these may be ignored.  R_MIPS_JALR is an optimization
3526          hint; we could improve performance by honoring that hint.  */
3527       return bfd_reloc_continue;
3528
3529     case R_MIPS_GNU_VTINHERIT:
3530     case R_MIPS_GNU_VTENTRY:
3531       /* We don't do anything with these at present.  */
3532       return bfd_reloc_continue;
3533
3534     default:
3535       /* An unrecognized relocation type.  */
3536       return bfd_reloc_notsupported;
3537     }
3538
3539   /* Store the VALUE for our caller.  */
3540   *valuep = value;
3541   return overflowed_p ? bfd_reloc_overflow : bfd_reloc_ok;
3542 }
3543
3544 /* Obtain the field relocated by RELOCATION.  */
3545
3546 static bfd_vma
3547 mips_elf_obtain_contents (reloc_howto_type *howto,
3548                           const Elf_Internal_Rela *relocation,
3549                           bfd *input_bfd, bfd_byte *contents)
3550 {
3551   bfd_vma x;
3552   bfd_byte *location = contents + relocation->r_offset;
3553
3554   /* Obtain the bytes.  */
3555   x = bfd_get ((8 * bfd_get_reloc_size (howto)), input_bfd, location);
3556
3557   if ((ELF_R_TYPE (input_bfd, relocation->r_info) == R_MIPS16_26
3558        || ELF_R_TYPE (input_bfd, relocation->r_info) == R_MIPS16_GPREL)
3559       && bfd_little_endian (input_bfd))
3560     /* The two 16-bit words will be reversed on a little-endian system.
3561        See mips_elf_perform_relocation for more details.  */
3562     x = (((x & 0xffff) << 16) | ((x & 0xffff0000) >> 16));
3563
3564   return x;
3565 }
3566
3567 /* It has been determined that the result of the RELOCATION is the
3568    VALUE.  Use HOWTO to place VALUE into the output file at the
3569    appropriate position.  The SECTION is the section to which the
3570    relocation applies.  If REQUIRE_JALX is TRUE, then the opcode used
3571    for the relocation must be either JAL or JALX, and it is
3572    unconditionally converted to JALX.
3573
3574    Returns FALSE if anything goes wrong.  */
3575
3576 static bfd_boolean
3577 mips_elf_perform_relocation (struct bfd_link_info *info,
3578                              reloc_howto_type *howto,
3579                              const Elf_Internal_Rela *relocation,
3580                              bfd_vma value, bfd *input_bfd,
3581                              asection *input_section, bfd_byte *contents,
3582                              bfd_boolean require_jalx)
3583 {
3584   bfd_vma x;
3585   bfd_byte *location;
3586   int r_type = ELF_R_TYPE (input_bfd, relocation->r_info);
3587
3588   /* Figure out where the relocation is occurring.  */
3589   location = contents + relocation->r_offset;
3590
3591   /* Obtain the current value.  */
3592   x = mips_elf_obtain_contents (howto, relocation, input_bfd, contents);
3593
3594   /* Clear the field we are setting.  */
3595   x &= ~howto->dst_mask;
3596
3597   /* If this is the R_MIPS16_26 relocation, we must store the
3598      value in a funny way.  */
3599   if (r_type == R_MIPS16_26)
3600     {
3601       /* R_MIPS16_26 is used for the mips16 jal and jalx instructions.
3602          Most mips16 instructions are 16 bits, but these instructions
3603          are 32 bits.
3604
3605          The format of these instructions is:
3606
3607          +--------------+--------------------------------+
3608          !     JALX     ! X!   Imm 20:16  !   Imm 25:21  !
3609          +--------------+--------------------------------+
3610          !                Immediate  15:0                   !
3611          +-----------------------------------------------+
3612
3613          JALX is the 5-bit value 00011.  X is 0 for jal, 1 for jalx.
3614          Note that the immediate value in the first word is swapped.
3615
3616          When producing a relocatable object file, R_MIPS16_26 is
3617          handled mostly like R_MIPS_26.  In particular, the addend is
3618          stored as a straight 26-bit value in a 32-bit instruction.
3619          (gas makes life simpler for itself by never adjusting a
3620          R_MIPS16_26 reloc to be against a section, so the addend is
3621          always zero).  However, the 32 bit instruction is stored as 2
3622          16-bit values, rather than a single 32-bit value.  In a
3623          big-endian file, the result is the same; in a little-endian
3624          file, the two 16-bit halves of the 32 bit value are swapped.
3625          This is so that a disassembler can recognize the jal
3626          instruction.
3627
3628          When doing a final link, R_MIPS16_26 is treated as a 32 bit
3629          instruction stored as two 16-bit values.  The addend A is the
3630          contents of the targ26 field.  The calculation is the same as
3631          R_MIPS_26.  When storing the calculated value, reorder the
3632          immediate value as shown above, and don't forget to store the
3633          value as two 16-bit values.
3634
3635          To put it in MIPS ABI terms, the relocation field is T-targ26-16,
3636          defined as
3637
3638          big-endian:
3639          +--------+----------------------+
3640          |        |                      |
3641          |        |    targ26-16         |
3642          |31    26|25                   0|
3643          +--------+----------------------+
3644
3645          little-endian:
3646          +----------+------+-------------+
3647          |          |      |             |
3648          |  sub1    |      |     sub2    |
3649          |0        9|10  15|16         31|
3650          +----------+--------------------+
3651          where targ26-16 is sub1 followed by sub2 (i.e., the addend field A is
3652          ((sub1 << 16) | sub2)).
3653
3654          When producing a relocatable object file, the calculation is
3655          (((A < 2) | ((P + 4) & 0xf0000000) + S) >> 2)
3656          When producing a fully linked file, the calculation is
3657          let R = (((A < 2) | ((P + 4) & 0xf0000000) + S) >> 2)
3658          ((R & 0x1f0000) << 5) | ((R & 0x3e00000) >> 5) | (R & 0xffff)  */
3659
3660       if (!info->relocatable)
3661         /* Shuffle the bits according to the formula above.  */
3662         value = (((value & 0x1f0000) << 5)
3663                  | ((value & 0x3e00000) >> 5)
3664                  | (value & 0xffff));
3665     }
3666   else if (r_type == R_MIPS16_GPREL)
3667     {
3668       /* R_MIPS16_GPREL is used for GP-relative addressing in mips16
3669          mode.  A typical instruction will have a format like this:
3670
3671          +--------------+--------------------------------+
3672          !    EXTEND    !     Imm 10:5    !   Imm 15:11  !
3673          +--------------+--------------------------------+
3674          !    Major     !   rx   !   ry   !   Imm  4:0   !
3675          +--------------+--------------------------------+
3676
3677          EXTEND is the five bit value 11110.  Major is the instruction
3678          opcode.
3679
3680          This is handled exactly like R_MIPS_GPREL16, except that the
3681          addend is retrieved and stored as shown in this diagram; that
3682          is, the Imm fields above replace the V-rel16 field.
3683
3684          All we need to do here is shuffle the bits appropriately.  As
3685          above, the two 16-bit halves must be swapped on a
3686          little-endian system.  */
3687       value = (((value & 0x7e0) << 16)
3688                | ((value & 0xf800) << 5)
3689                | (value & 0x1f));
3690     }
3691
3692   /* Set the field.  */
3693   x |= (value & howto->dst_mask);
3694
3695   /* If required, turn JAL into JALX.  */
3696   if (require_jalx)
3697     {
3698       bfd_boolean ok;
3699       bfd_vma opcode = x >> 26;
3700       bfd_vma jalx_opcode;
3701
3702       /* Check to see if the opcode is already JAL or JALX.  */
3703       if (r_type == R_MIPS16_26)
3704         {
3705           ok = ((opcode == 0x6) || (opcode == 0x7));
3706           jalx_opcode = 0x7;
3707         }
3708       else
3709         {
3710           ok = ((opcode == 0x3) || (opcode == 0x1d));
3711           jalx_opcode = 0x1d;
3712         }
3713
3714       /* If the opcode is not JAL or JALX, there's a problem.  */
3715       if (!ok)
3716         {
3717           (*_bfd_error_handler)
3718             (_("%B: %A+0x%lx: jump to stub routine which is not jal"),
3719              input_bfd,
3720              input_section,
3721              (unsigned long) relocation->r_offset);
3722           bfd_set_error (bfd_error_bad_value);
3723           return FALSE;
3724         }
3725
3726       /* Make this the JALX opcode.  */
3727       x = (x & ~(0x3f << 26)) | (jalx_opcode << 26);
3728     }
3729
3730   /* Swap the high- and low-order 16 bits on little-endian systems
3731      when doing a MIPS16 relocation.  */
3732   if ((r_type == R_MIPS16_GPREL || r_type == R_MIPS16_26)
3733       && bfd_little_endian (input_bfd))
3734     x = (((x & 0xffff) << 16) | ((x & 0xffff0000) >> 16));
3735
3736   /* Put the value into the output.  */
3737   bfd_put (8 * bfd_get_reloc_size (howto), input_bfd, x, location);
3738   return TRUE;
3739 }
3740
3741 /* Returns TRUE if SECTION is a MIPS16 stub section.  */
3742
3743 static bfd_boolean
3744 mips_elf_stub_section_p (bfd *abfd ATTRIBUTE_UNUSED, asection *section)
3745 {
3746   const char *name = bfd_get_section_name (abfd, section);
3747
3748   return (strncmp (name, FN_STUB, sizeof FN_STUB - 1) == 0
3749           || strncmp (name, CALL_STUB, sizeof CALL_STUB - 1) == 0
3750           || strncmp (name, CALL_FP_STUB, sizeof CALL_FP_STUB - 1) == 0);
3751 }
3752 \f
3753 /* Add room for N relocations to the .rel.dyn section in ABFD.  */
3754
3755 static void
3756 mips_elf_allocate_dynamic_relocations (bfd *abfd, unsigned int n)
3757 {
3758   asection *s;
3759
3760   s = mips_elf_rel_dyn_section (abfd, FALSE);
3761   BFD_ASSERT (s != NULL);
3762
3763   if (s->size == 0)
3764     {
3765       /* Make room for a null element.  */
3766       s->size += MIPS_ELF_REL_SIZE (abfd);
3767       ++s->reloc_count;
3768     }
3769   s->size += n * MIPS_ELF_REL_SIZE (abfd);
3770 }
3771
3772 /* Create a rel.dyn relocation for the dynamic linker to resolve.  REL
3773    is the original relocation, which is now being transformed into a
3774    dynamic relocation.  The ADDENDP is adjusted if necessary; the
3775    caller should store the result in place of the original addend.  */
3776
3777 static bfd_boolean
3778 mips_elf_create_dynamic_relocation (bfd *output_bfd,
3779                                     struct bfd_link_info *info,
3780                                     const Elf_Internal_Rela *rel,
3781                                     struct mips_elf_link_hash_entry *h,
3782                                     asection *sec, bfd_vma symbol,
3783                                     bfd_vma *addendp, asection *input_section)
3784 {
3785   Elf_Internal_Rela outrel[3];
3786   asection *sreloc;
3787   bfd *dynobj;
3788   int r_type;
3789   long indx;
3790   bfd_boolean defined_p;
3791
3792   r_type = ELF_R_TYPE (output_bfd, rel->r_info);
3793   dynobj = elf_hash_table (info)->dynobj;
3794   sreloc = mips_elf_rel_dyn_section (dynobj, FALSE);
3795   BFD_ASSERT (sreloc != NULL);
3796   BFD_ASSERT (sreloc->contents != NULL);
3797   BFD_ASSERT (sreloc->reloc_count * MIPS_ELF_REL_SIZE (output_bfd)
3798               < sreloc->size);
3799
3800   outrel[0].r_offset =
3801     _bfd_elf_section_offset (output_bfd, info, input_section, rel[0].r_offset);
3802   outrel[1].r_offset =
3803     _bfd_elf_section_offset (output_bfd, info, input_section, rel[1].r_offset);
3804   outrel[2].r_offset =
3805     _bfd_elf_section_offset (output_bfd, info, input_section, rel[2].r_offset);
3806
3807 #if 0
3808   /* We begin by assuming that the offset for the dynamic relocation
3809      is the same as for the original relocation.  We'll adjust this
3810      later to reflect the correct output offsets.  */
3811   if (input_section->sec_info_type != ELF_INFO_TYPE_STABS)
3812     {
3813       outrel[1].r_offset = rel[1].r_offset;
3814       outrel[2].r_offset = rel[2].r_offset;
3815     }
3816   else
3817     {
3818       /* Except that in a stab section things are more complex.
3819          Because we compress stab information, the offset given in the
3820          relocation may not be the one we want; we must let the stabs
3821          machinery tell us the offset.  */
3822       outrel[1].r_offset = outrel[0].r_offset;
3823       outrel[2].r_offset = outrel[0].r_offset;
3824       /* If we didn't need the relocation at all, this value will be
3825          -1.  */
3826       if (outrel[0].r_offset == MINUS_ONE)
3827         skip = TRUE;
3828     }
3829 #endif
3830
3831   if (outrel[0].r_offset == MINUS_ONE)
3832     /* The relocation field has been deleted.  */
3833     return TRUE;
3834
3835   if (outrel[0].r_offset == MINUS_TWO)
3836     {
3837       /* The relocation field has been converted into a relative value of
3838          some sort.  Functions like _bfd_elf_write_section_eh_frame expect
3839          the field to be fully relocated, so add in the symbol's value.  */
3840       *addendp += symbol;
3841       return TRUE;
3842     }
3843
3844   /* We must now calculate the dynamic symbol table index to use
3845      in the relocation.  */
3846   if (h != NULL
3847       && (! info->symbolic || !h->root.def_regular)
3848       /* h->root.dynindx may be -1 if this symbol was marked to
3849          become local.  */
3850       && h->root.dynindx != -1)
3851     {
3852       indx = h->root.dynindx;
3853       if (SGI_COMPAT (output_bfd))
3854         defined_p = h->root.def_regular;
3855       else
3856         /* ??? glibc's ld.so just adds the final GOT entry to the
3857            relocation field.  It therefore treats relocs against
3858            defined symbols in the same way as relocs against
3859            undefined symbols.  */
3860         defined_p = FALSE;
3861     }
3862   else
3863     {
3864       if (sec != NULL && bfd_is_abs_section (sec))
3865         indx = 0;
3866       else if (sec == NULL || sec->owner == NULL)
3867         {
3868           bfd_set_error (bfd_error_bad_value);
3869           return FALSE;
3870         }
3871       else
3872         {
3873           indx = elf_section_data (sec->output_section)->dynindx;
3874           if (indx == 0)
3875             abort ();
3876         }
3877
3878       /* Instead of generating a relocation using the section
3879          symbol, we may as well make it a fully relative
3880          relocation.  We want to avoid generating relocations to
3881          local symbols because we used to generate them
3882          incorrectly, without adding the original symbol value,
3883          which is mandated by the ABI for section symbols.  In
3884          order to give dynamic loaders and applications time to
3885          phase out the incorrect use, we refrain from emitting
3886          section-relative relocations.  It's not like they're
3887          useful, after all.  This should be a bit more efficient
3888          as well.  */
3889       /* ??? Although this behavior is compatible with glibc's ld.so,
3890          the ABI says that relocations against STN_UNDEF should have
3891          a symbol value of 0.  Irix rld honors this, so relocations
3892          against STN_UNDEF have no effect.  */
3893       if (!SGI_COMPAT (output_bfd))
3894         indx = 0;
3895       defined_p = TRUE;
3896     }
3897
3898   /* If the relocation was previously an absolute relocation and
3899      this symbol will not be referred to by the relocation, we must
3900      adjust it by the value we give it in the dynamic symbol table.
3901      Otherwise leave the job up to the dynamic linker.  */
3902   if (defined_p && r_type != R_MIPS_REL32)
3903     *addendp += symbol;
3904
3905   /* The relocation is always an REL32 relocation because we don't
3906      know where the shared library will wind up at load-time.  */
3907   outrel[0].r_info = ELF_R_INFO (output_bfd, (unsigned long) indx,
3908                                  R_MIPS_REL32);
3909   /* For strict adherence to the ABI specification, we should
3910      generate a R_MIPS_64 relocation record by itself before the
3911      _REL32/_64 record as well, such that the addend is read in as
3912      a 64-bit value (REL32 is a 32-bit relocation, after all).
3913      However, since none of the existing ELF64 MIPS dynamic
3914      loaders seems to care, we don't waste space with these
3915      artificial relocations.  If this turns out to not be true,
3916      mips_elf_allocate_dynamic_relocation() should be tweaked so
3917      as to make room for a pair of dynamic relocations per
3918      invocation if ABI_64_P, and here we should generate an
3919      additional relocation record with R_MIPS_64 by itself for a
3920      NULL symbol before this relocation record.  */
3921   outrel[1].r_info = ELF_R_INFO (output_bfd, 0,
3922                                  ABI_64_P (output_bfd)
3923                                  ? R_MIPS_64
3924                                  : R_MIPS_NONE);
3925   outrel[2].r_info = ELF_R_INFO (output_bfd, 0, R_MIPS_NONE);
3926
3927   /* Adjust the output offset of the relocation to reference the
3928      correct location in the output file.  */
3929   outrel[0].r_offset += (input_section->output_section->vma
3930                          + input_section->output_offset);
3931   outrel[1].r_offset += (input_section->output_section->vma
3932                          + input_section->output_offset);
3933   outrel[2].r_offset += (input_section->output_section->vma
3934                          + input_section->output_offset);
3935
3936   /* Put the relocation back out.  We have to use the special
3937      relocation outputter in the 64-bit case since the 64-bit
3938      relocation format is non-standard.  */
3939   if (ABI_64_P (output_bfd))
3940     {
3941       (*get_elf_backend_data (output_bfd)->s->swap_reloc_out)
3942         (output_bfd, &outrel[0],
3943          (sreloc->contents
3944           + sreloc->reloc_count * sizeof (Elf64_Mips_External_Rel)));
3945     }
3946   else
3947     bfd_elf32_swap_reloc_out
3948       (output_bfd, &outrel[0],
3949        (sreloc->contents + sreloc->reloc_count * sizeof (Elf32_External_Rel)));
3950
3951   /* We've now added another relocation.  */
3952   ++sreloc->reloc_count;
3953
3954   /* Make sure the output section is writable.  The dynamic linker
3955      will be writing to it.  */
3956   elf_section_data (input_section->output_section)->this_hdr.sh_flags
3957     |= SHF_WRITE;
3958
3959   /* On IRIX5, make an entry of compact relocation info.  */
3960   if (IRIX_COMPAT (output_bfd) == ict_irix5)
3961     {
3962       asection *scpt = bfd_get_section_by_name (dynobj, ".compact_rel");
3963       bfd_byte *cr;
3964
3965       if (scpt)
3966         {
3967           Elf32_crinfo cptrel;
3968
3969           mips_elf_set_cr_format (cptrel, CRF_MIPS_LONG);
3970           cptrel.vaddr = (rel->r_offset
3971                           + input_section->output_section->vma
3972                           + input_section->output_offset);
3973           if (r_type == R_MIPS_REL32)
3974             mips_elf_set_cr_type (cptrel, CRT_MIPS_REL32);
3975           else
3976             mips_elf_set_cr_type (cptrel, CRT_MIPS_WORD);
3977           mips_elf_set_cr_dist2to (cptrel, 0);
3978           cptrel.konst = *addendp;
3979
3980           cr = (scpt->contents
3981                 + sizeof (Elf32_External_compact_rel));
3982           bfd_elf32_swap_crinfo_out (output_bfd, &cptrel,
3983                                      ((Elf32_External_crinfo *) cr
3984                                       + scpt->reloc_count));
3985           ++scpt->reloc_count;
3986         }
3987     }
3988
3989   return TRUE;
3990 }
3991 \f
3992 /* Return the MACH for a MIPS e_flags value.  */
3993
3994 unsigned long
3995 _bfd_elf_mips_mach (flagword flags)
3996 {
3997   switch (flags & EF_MIPS_MACH)
3998     {
3999     case E_MIPS_MACH_3900:
4000       return bfd_mach_mips3900;
4001
4002     case E_MIPS_MACH_4010:
4003       return bfd_mach_mips4010;
4004
4005     case E_MIPS_MACH_4100:
4006       return bfd_mach_mips4100;
4007
4008     case E_MIPS_MACH_4111:
4009       return bfd_mach_mips4111;
4010
4011     case E_MIPS_MACH_4120:
4012       return bfd_mach_mips4120;
4013
4014     case E_MIPS_MACH_4650:
4015       return bfd_mach_mips4650;
4016
4017     case E_MIPS_MACH_5400:
4018       return bfd_mach_mips5400;
4019
4020     case E_MIPS_MACH_5500:
4021       return bfd_mach_mips5500;
4022
4023     case E_MIPS_MACH_SB1:
4024       return bfd_mach_mips_sb1;
4025
4026     default:
4027       switch (flags & EF_MIPS_ARCH)
4028         {
4029         default:
4030         case E_MIPS_ARCH_1:
4031           return bfd_mach_mips3000;
4032           break;
4033
4034         case E_MIPS_ARCH_2:
4035           return bfd_mach_mips6000;
4036           break;
4037
4038         case E_MIPS_ARCH_3:
4039           return bfd_mach_mips4000;
4040           break;
4041
4042         case E_MIPS_ARCH_4:
4043           return bfd_mach_mips8000;
4044           break;
4045
4046         case E_MIPS_ARCH_5:
4047           return bfd_mach_mips5;
4048           break;
4049
4050         case E_MIPS_ARCH_32:
4051           return bfd_mach_mipsisa32;
4052           break;
4053
4054         case E_MIPS_ARCH_64:
4055           return bfd_mach_mipsisa64;
4056           break;
4057
4058         case E_MIPS_ARCH_32R2:
4059           return bfd_mach_mipsisa32r2;
4060           break;
4061
4062         case E_MIPS_ARCH_64R2:
4063           return bfd_mach_mipsisa64r2;
4064           break;
4065         }
4066     }
4067
4068   return 0;
4069 }
4070
4071 /* Return printable name for ABI.  */
4072
4073 static INLINE char *
4074 elf_mips_abi_name (bfd *abfd)
4075 {
4076   flagword flags;
4077
4078   flags = elf_elfheader (abfd)->e_flags;
4079   switch (flags & EF_MIPS_ABI)
4080     {
4081     case 0:
4082       if (ABI_N32_P (abfd))
4083         return "N32";
4084       else if (ABI_64_P (abfd))
4085         return "64";
4086       else
4087         return "none";
4088     case E_MIPS_ABI_O32:
4089       return "O32";
4090     case E_MIPS_ABI_O64:
4091       return "O64";
4092     case E_MIPS_ABI_EABI32:
4093       return "EABI32";
4094     case E_MIPS_ABI_EABI64:
4095       return "EABI64";
4096     default:
4097       return "unknown abi";
4098     }
4099 }
4100 \f
4101 /* MIPS ELF uses two common sections.  One is the usual one, and the
4102    other is for small objects.  All the small objects are kept
4103    together, and then referenced via the gp pointer, which yields
4104    faster assembler code.  This is what we use for the small common
4105    section.  This approach is copied from ecoff.c.  */
4106 static asection mips_elf_scom_section;
4107 static asymbol mips_elf_scom_symbol;
4108 static asymbol *mips_elf_scom_symbol_ptr;
4109
4110 /* MIPS ELF also uses an acommon section, which represents an
4111    allocated common symbol which may be overridden by a
4112    definition in a shared library.  */
4113 static asection mips_elf_acom_section;
4114 static asymbol mips_elf_acom_symbol;
4115 static asymbol *mips_elf_acom_symbol_ptr;
4116
4117 /* Handle the special MIPS section numbers that a symbol may use.
4118    This is used for both the 32-bit and the 64-bit ABI.  */
4119
4120 void
4121 _bfd_mips_elf_symbol_processing (bfd *abfd, asymbol *asym)
4122 {
4123   elf_symbol_type *elfsym;
4124
4125   elfsym = (elf_symbol_type *) asym;
4126   switch (elfsym->internal_elf_sym.st_shndx)
4127     {
4128     case SHN_MIPS_ACOMMON:
4129       /* This section is used in a dynamically linked executable file.
4130          It is an allocated common section.  The dynamic linker can
4131          either resolve these symbols to something in a shared
4132          library, or it can just leave them here.  For our purposes,
4133          we can consider these symbols to be in a new section.  */
4134       if (mips_elf_acom_section.name == NULL)
4135         {
4136           /* Initialize the acommon section.  */
4137           mips_elf_acom_section.name = ".acommon";
4138           mips_elf_acom_section.flags = SEC_ALLOC;
4139           mips_elf_acom_section.output_section = &mips_elf_acom_section;
4140           mips_elf_acom_section.symbol = &mips_elf_acom_symbol;
4141           mips_elf_acom_section.symbol_ptr_ptr = &mips_elf_acom_symbol_ptr;
4142           mips_elf_acom_symbol.name = ".acommon";
4143           mips_elf_acom_symbol.flags = BSF_SECTION_SYM;
4144           mips_elf_acom_symbol.section = &mips_elf_acom_section;
4145           mips_elf_acom_symbol_ptr = &mips_elf_acom_symbol;
4146         }
4147       asym->section = &mips_elf_acom_section;
4148       break;
4149
4150     case SHN_COMMON:
4151       /* Common symbols less than the GP size are automatically
4152          treated as SHN_MIPS_SCOMMON symbols on IRIX5.  */
4153       if (asym->value > elf_gp_size (abfd)
4154           || IRIX_COMPAT (abfd) == ict_irix6)
4155         break;
4156       /* Fall through.  */
4157     case SHN_MIPS_SCOMMON:
4158       if (mips_elf_scom_section.name == NULL)
4159         {
4160           /* Initialize the small common section.  */
4161           mips_elf_scom_section.name = ".scommon";
4162           mips_elf_scom_section.flags = SEC_IS_COMMON;
4163           mips_elf_scom_section.output_section = &mips_elf_scom_section;
4164           mips_elf_scom_section.symbol = &mips_elf_scom_symbol;
4165           mips_elf_scom_section.symbol_ptr_ptr = &mips_elf_scom_symbol_ptr;
4166           mips_elf_scom_symbol.name = ".scommon";
4167           mips_elf_scom_symbol.flags = BSF_SECTION_SYM;
4168           mips_elf_scom_symbol.section = &mips_elf_scom_section;
4169           mips_elf_scom_symbol_ptr = &mips_elf_scom_symbol;
4170         }
4171       asym->section = &mips_elf_scom_section;
4172       asym->value = elfsym->internal_elf_sym.st_size;
4173       break;
4174
4175     case SHN_MIPS_SUNDEFINED:
4176       asym->section = bfd_und_section_ptr;
4177       break;
4178
4179     case SHN_MIPS_TEXT:
4180       {
4181         asection *section = bfd_get_section_by_name (abfd, ".text");
4182
4183         BFD_ASSERT (SGI_COMPAT (abfd));
4184         if (section != NULL)
4185           {
4186             asym->section = section;
4187             /* MIPS_TEXT is a bit special, the address is not an offset
4188                to the base of the .text section.  So substract the section
4189                base address to make it an offset.  */
4190             asym->value -= section->vma;
4191           }
4192       }
4193       break;
4194
4195     case SHN_MIPS_DATA:
4196       {
4197         asection *section = bfd_get_section_by_name (abfd, ".data");
4198
4199         BFD_ASSERT (SGI_COMPAT (abfd));
4200         if (section != NULL)
4201           {
4202             asym->section = section;
4203             /* MIPS_DATA is a bit special, the address is not an offset
4204                to the base of the .data section.  So substract the section
4205                base address to make it an offset.  */
4206             asym->value -= section->vma;
4207           }
4208       }
4209       break;
4210     }
4211 }
4212 \f
4213 /* There appears to be a bug in the MIPSpro linker that causes GOT_DISP
4214    relocations against two unnamed section symbols to resolve to the
4215    same address.  For example, if we have code like:
4216
4217         lw      $4,%got_disp(.data)($gp)
4218         lw      $25,%got_disp(.text)($gp)
4219         jalr    $25
4220
4221    then the linker will resolve both relocations to .data and the program
4222    will jump there rather than to .text.
4223
4224    We can work around this problem by giving names to local section symbols.
4225    This is also what the MIPSpro tools do.  */
4226
4227 bfd_boolean
4228 _bfd_mips_elf_name_local_section_symbols (bfd *abfd)
4229 {
4230   return SGI_COMPAT (abfd);
4231 }
4232 \f
4233 /* Work over a section just before writing it out.  This routine is
4234    used by both the 32-bit and the 64-bit ABI.  FIXME: We recognize
4235    sections that need the SHF_MIPS_GPREL flag by name; there has to be
4236    a better way.  */
4237
4238 bfd_boolean
4239 _bfd_mips_elf_section_processing (bfd *abfd, Elf_Internal_Shdr *hdr)
4240 {
4241   if (hdr->sh_type == SHT_MIPS_REGINFO
4242       && hdr->sh_size > 0)
4243     {
4244       bfd_byte buf[4];
4245
4246       BFD_ASSERT (hdr->sh_size == sizeof (Elf32_External_RegInfo));
4247       BFD_ASSERT (hdr->contents == NULL);
4248
4249       if (bfd_seek (abfd,
4250                     hdr->sh_offset + sizeof (Elf32_External_RegInfo) - 4,
4251                     SEEK_SET) != 0)
4252         return FALSE;
4253       H_PUT_32 (abfd, elf_gp (abfd), buf);
4254       if (bfd_bwrite (buf, 4, abfd) != 4)
4255         return FALSE;
4256     }
4257
4258   if (hdr->sh_type == SHT_MIPS_OPTIONS
4259       && hdr->bfd_section != NULL
4260       && mips_elf_section_data (hdr->bfd_section) != NULL
4261       && mips_elf_section_data (hdr->bfd_section)->u.tdata != NULL)
4262     {
4263       bfd_byte *contents, *l, *lend;
4264
4265       /* We stored the section contents in the tdata field in the
4266          set_section_contents routine.  We save the section contents
4267          so that we don't have to read them again.
4268          At this point we know that elf_gp is set, so we can look
4269          through the section contents to see if there is an
4270          ODK_REGINFO structure.  */
4271
4272       contents = mips_elf_section_data (hdr->bfd_section)->u.tdata;
4273       l = contents;
4274       lend = contents + hdr->sh_size;
4275       while (l + sizeof (Elf_External_Options) <= lend)
4276         {
4277           Elf_Internal_Options intopt;
4278
4279           bfd_mips_elf_swap_options_in (abfd, (Elf_External_Options *) l,
4280                                         &intopt);
4281           if (ABI_64_P (abfd) && intopt.kind == ODK_REGINFO)
4282             {
4283               bfd_byte buf[8];
4284
4285               if (bfd_seek (abfd,
4286                             (hdr->sh_offset
4287                              + (l - contents)
4288                              + sizeof (Elf_External_Options)
4289                              + (sizeof (Elf64_External_RegInfo) - 8)),
4290                              SEEK_SET) != 0)
4291                 return FALSE;
4292               H_PUT_64 (abfd, elf_gp (abfd), buf);
4293               if (bfd_bwrite (buf, 8, abfd) != 8)
4294                 return FALSE;
4295             }
4296           else if (intopt.kind == ODK_REGINFO)
4297             {
4298               bfd_byte buf[4];
4299
4300               if (bfd_seek (abfd,
4301                             (hdr->sh_offset
4302                              + (l - contents)
4303                              + sizeof (Elf_External_Options)
4304                              + (sizeof (Elf32_External_RegInfo) - 4)),
4305                             SEEK_SET) != 0)
4306                 return FALSE;
4307               H_PUT_32 (abfd, elf_gp (abfd), buf);
4308               if (bfd_bwrite (buf, 4, abfd) != 4)
4309                 return FALSE;
4310             }
4311           l += intopt.size;
4312         }
4313     }
4314
4315   if (hdr->bfd_section != NULL)
4316     {
4317       const char *name = bfd_get_section_name (abfd, hdr->bfd_section);
4318
4319       if (strcmp (name, ".sdata") == 0
4320           || strcmp (name, ".lit8") == 0
4321           || strcmp (name, ".lit4") == 0)
4322         {
4323           hdr->sh_flags |= SHF_ALLOC | SHF_WRITE | SHF_MIPS_GPREL;
4324           hdr->sh_type = SHT_PROGBITS;
4325         }
4326       else if (strcmp (name, ".sbss") == 0)
4327         {
4328           hdr->sh_flags |= SHF_ALLOC | SHF_WRITE | SHF_MIPS_GPREL;
4329           hdr->sh_type = SHT_NOBITS;
4330         }
4331       else if (strcmp (name, ".srdata") == 0)
4332         {
4333           hdr->sh_flags |= SHF_ALLOC | SHF_MIPS_GPREL;
4334           hdr->sh_type = SHT_PROGBITS;
4335         }
4336       else if (strcmp (name, ".compact_rel") == 0)
4337         {
4338           hdr->sh_flags = 0;
4339           hdr->sh_type = SHT_PROGBITS;
4340         }
4341       else if (strcmp (name, ".rtproc") == 0)
4342         {
4343           if (hdr->sh_addralign != 0 && hdr->sh_entsize == 0)
4344             {
4345               unsigned int adjust;
4346
4347               adjust = hdr->sh_size % hdr->sh_addralign;
4348               if (adjust != 0)
4349                 hdr->sh_size += hdr->sh_addralign - adjust;
4350             }
4351         }
4352     }
4353
4354   return TRUE;
4355 }
4356
4357 /* Handle a MIPS specific section when reading an object file.  This
4358    is called when elfcode.h finds a section with an unknown type.
4359    This routine supports both the 32-bit and 64-bit ELF ABI.
4360
4361    FIXME: We need to handle the SHF_MIPS_GPREL flag, but I'm not sure
4362    how to.  */
4363
4364 bfd_boolean
4365 _bfd_mips_elf_section_from_shdr (bfd *abfd, Elf_Internal_Shdr *hdr,
4366                                  const char *name)
4367 {
4368   flagword flags = 0;
4369
4370   /* There ought to be a place to keep ELF backend specific flags, but
4371      at the moment there isn't one.  We just keep track of the
4372      sections by their name, instead.  Fortunately, the ABI gives
4373      suggested names for all the MIPS specific sections, so we will
4374      probably get away with this.  */
4375   switch (hdr->sh_type)
4376     {
4377     case SHT_MIPS_LIBLIST:
4378       if (strcmp (name, ".liblist") != 0)
4379         return FALSE;
4380       break;
4381     case SHT_MIPS_MSYM:
4382       if (strcmp (name, ".msym") != 0)
4383         return FALSE;
4384       break;
4385     case SHT_MIPS_CONFLICT:
4386       if (strcmp (name, ".conflict") != 0)
4387         return FALSE;
4388       break;
4389     case SHT_MIPS_GPTAB:
4390       if (strncmp (name, ".gptab.", sizeof ".gptab." - 1) != 0)
4391         return FALSE;
4392       break;
4393     case SHT_MIPS_UCODE:
4394       if (strcmp (name, ".ucode") != 0)
4395         return FALSE;
4396       break;
4397     case SHT_MIPS_DEBUG:
4398       if (strcmp (name, ".mdebug") != 0)
4399         return FALSE;
4400       flags = SEC_DEBUGGING;
4401       break;
4402     case SHT_MIPS_REGINFO:
4403       if (strcmp (name, ".reginfo") != 0
4404           || hdr->sh_size != sizeof (Elf32_External_RegInfo))
4405         return FALSE;
4406       flags = (SEC_LINK_ONCE | SEC_LINK_DUPLICATES_SAME_SIZE);
4407       break;
4408     case SHT_MIPS_IFACE:
4409       if (strcmp (name, ".MIPS.interfaces") != 0)
4410         return FALSE;
4411       break;
4412     case SHT_MIPS_CONTENT:
4413       if (strncmp (name, ".MIPS.content", sizeof ".MIPS.content" - 1) != 0)
4414         return FALSE;
4415       break;
4416     case SHT_MIPS_OPTIONS:
4417       if (strcmp (name, MIPS_ELF_OPTIONS_SECTION_NAME (abfd)) != 0)
4418         return FALSE;
4419       break;
4420     case SHT_MIPS_DWARF:
4421       if (strncmp (name, ".debug_", sizeof ".debug_" - 1) != 0)
4422         return FALSE;
4423       break;
4424     case SHT_MIPS_SYMBOL_LIB:
4425       if (strcmp (name, ".MIPS.symlib") != 0)
4426         return FALSE;
4427       break;
4428     case SHT_MIPS_EVENTS:
4429       if (strncmp (name, ".MIPS.events", sizeof ".MIPS.events" - 1) != 0
4430           && strncmp (name, ".MIPS.post_rel",
4431                       sizeof ".MIPS.post_rel" - 1) != 0)
4432         return FALSE;
4433       break;
4434     default:
4435       return FALSE;
4436     }
4437
4438   if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name))
4439     return FALSE;
4440
4441   if (flags)
4442     {
4443       if (! bfd_set_section_flags (abfd, hdr->bfd_section,
4444                                    (bfd_get_section_flags (abfd,
4445                                                            hdr->bfd_section)
4446                                     | flags)))
4447         return FALSE;
4448     }
4449
4450   /* FIXME: We should record sh_info for a .gptab section.  */
4451
4452   /* For a .reginfo section, set the gp value in the tdata information
4453      from the contents of this section.  We need the gp value while
4454      processing relocs, so we just get it now.  The .reginfo section
4455      is not used in the 64-bit MIPS ELF ABI.  */
4456   if (hdr->sh_type == SHT_MIPS_REGINFO)
4457     {
4458       Elf32_External_RegInfo ext;
4459       Elf32_RegInfo s;
4460
4461       if (! bfd_get_section_contents (abfd, hdr->bfd_section,
4462                                       &ext, 0, sizeof ext))
4463         return FALSE;
4464       bfd_mips_elf32_swap_reginfo_in (abfd, &ext, &s);
4465       elf_gp (abfd) = s.ri_gp_value;
4466     }
4467
4468   /* For a SHT_MIPS_OPTIONS section, look for a ODK_REGINFO entry, and
4469      set the gp value based on what we find.  We may see both
4470      SHT_MIPS_REGINFO and SHT_MIPS_OPTIONS/ODK_REGINFO; in that case,
4471      they should agree.  */
4472   if (hdr->sh_type == SHT_MIPS_OPTIONS)
4473     {
4474       bfd_byte *contents, *l, *lend;
4475
4476       contents = bfd_malloc (hdr->sh_size);
4477       if (contents == NULL)
4478         return FALSE;
4479       if (! bfd_get_section_contents (abfd, hdr->bfd_section, contents,
4480                                       0, hdr->sh_size))
4481         {
4482           free (contents);
4483           return FALSE;
4484         }
4485       l = contents;
4486       lend = contents + hdr->sh_size;
4487       while (l + sizeof (Elf_External_Options) <= lend)
4488         {
4489           Elf_Internal_Options intopt;
4490
4491           bfd_mips_elf_swap_options_in (abfd, (Elf_External_Options *) l,
4492                                         &intopt);
4493           if (ABI_64_P (abfd) && intopt.kind == ODK_REGINFO)
4494             {
4495               Elf64_Internal_RegInfo intreg;
4496
4497               bfd_mips_elf64_swap_reginfo_in
4498                 (abfd,
4499                  ((Elf64_External_RegInfo *)
4500                   (l + sizeof (Elf_External_Options))),
4501                  &intreg);
4502               elf_gp (abfd) = intreg.ri_gp_value;
4503             }
4504           else if (intopt.kind == ODK_REGINFO)
4505             {
4506               Elf32_RegInfo intreg;
4507
4508               bfd_mips_elf32_swap_reginfo_in
4509                 (abfd,
4510                  ((Elf32_External_RegInfo *)
4511                   (l + sizeof (Elf_External_Options))),
4512                  &intreg);
4513               elf_gp (abfd) = intreg.ri_gp_value;
4514             }
4515           l += intopt.size;
4516         }
4517       free (contents);
4518     }
4519
4520   return TRUE;
4521 }
4522
4523 /* Set the correct type for a MIPS ELF section.  We do this by the
4524    section name, which is a hack, but ought to work.  This routine is
4525    used by both the 32-bit and the 64-bit ABI.  */
4526
4527 bfd_boolean
4528 _bfd_mips_elf_fake_sections (bfd *abfd, Elf_Internal_Shdr *hdr, asection *sec)
4529 {
4530   register const char *name;
4531
4532   name = bfd_get_section_name (abfd, sec);
4533
4534   if (strcmp (name, ".liblist") == 0)
4535     {
4536       hdr->sh_type = SHT_MIPS_LIBLIST;
4537       hdr->sh_info = sec->size / sizeof (Elf32_Lib);
4538       /* The sh_link field is set in final_write_processing.  */
4539     }
4540   else if (strcmp (name, ".conflict") == 0)
4541     hdr->sh_type = SHT_MIPS_CONFLICT;
4542   else if (strncmp (name, ".gptab.", sizeof ".gptab." - 1) == 0)
4543     {
4544       hdr->sh_type = SHT_MIPS_GPTAB;
4545       hdr->sh_entsize = sizeof (Elf32_External_gptab);
4546       /* The sh_info field is set in final_write_processing.  */
4547     }
4548   else if (strcmp (name, ".ucode") == 0)
4549     hdr->sh_type = SHT_MIPS_UCODE;
4550   else if (strcmp (name, ".mdebug") == 0)
4551     {
4552       hdr->sh_type = SHT_MIPS_DEBUG;
4553       /* In a shared object on IRIX 5.3, the .mdebug section has an
4554          entsize of 0.  FIXME: Does this matter?  */
4555       if (SGI_COMPAT (abfd) && (abfd->flags & DYNAMIC) != 0)
4556         hdr->sh_entsize = 0;
4557       else
4558         hdr->sh_entsize = 1;
4559     }
4560   else if (strcmp (name, ".reginfo") == 0)
4561     {
4562       hdr->sh_type = SHT_MIPS_REGINFO;
4563       /* In a shared object on IRIX 5.3, the .reginfo section has an
4564          entsize of 0x18.  FIXME: Does this matter?  */
4565       if (SGI_COMPAT (abfd))
4566         {
4567           if ((abfd->flags & DYNAMIC) != 0)
4568             hdr->sh_entsize = sizeof (Elf32_External_RegInfo);
4569           else
4570             hdr->sh_entsize = 1;
4571         }
4572       else
4573         hdr->sh_entsize = sizeof (Elf32_External_RegInfo);
4574     }
4575   else if (SGI_COMPAT (abfd)
4576            && (strcmp (name, ".hash") == 0
4577                || strcmp (name, ".dynamic") == 0
4578                || strcmp (name, ".dynstr") == 0))
4579     {
4580       if (SGI_COMPAT (abfd))
4581         hdr->sh_entsize = 0;
4582 #if 0
4583       /* This isn't how the IRIX6 linker behaves.  */
4584       hdr->sh_info = SIZEOF_MIPS_DYNSYM_SECNAMES;
4585 #endif
4586     }
4587   else if (strcmp (name, ".got") == 0
4588            || strcmp (name, ".srdata") == 0
4589            || strcmp (name, ".sdata") == 0
4590            || strcmp (name, ".sbss") == 0
4591            || strcmp (name, ".lit4") == 0
4592            || strcmp (name, ".lit8") == 0)
4593     hdr->sh_flags |= SHF_MIPS_GPREL;
4594   else if (strcmp (name, ".MIPS.interfaces") == 0)
4595     {
4596       hdr->sh_type = SHT_MIPS_IFACE;
4597       hdr->sh_flags |= SHF_MIPS_NOSTRIP;
4598     }
4599   else if (strncmp (name, ".MIPS.content", strlen (".MIPS.content")) == 0)
4600     {
4601       hdr->sh_type = SHT_MIPS_CONTENT;
4602       hdr->sh_flags |= SHF_MIPS_NOSTRIP;
4603       /* The sh_info field is set in final_write_processing.  */
4604     }
4605   else if (strcmp (name, MIPS_ELF_OPTIONS_SECTION_NAME (abfd)) == 0)
4606     {
4607       hdr->sh_type = SHT_MIPS_OPTIONS;
4608       hdr->sh_entsize = 1;
4609       hdr->sh_flags |= SHF_MIPS_NOSTRIP;
4610     }
4611   else if (strncmp (name, ".debug_", sizeof ".debug_" - 1) == 0)
4612     hdr->sh_type = SHT_MIPS_DWARF;
4613   else if (strcmp (name, ".MIPS.symlib") == 0)
4614     {
4615       hdr->sh_type = SHT_MIPS_SYMBOL_LIB;
4616       /* The sh_link and sh_info fields are set in
4617          final_write_processing.  */
4618     }
4619   else if (strncmp (name, ".MIPS.events", sizeof ".MIPS.events" - 1) == 0
4620            || strncmp (name, ".MIPS.post_rel",
4621                        sizeof ".MIPS.post_rel" - 1) == 0)
4622     {
4623       hdr->sh_type = SHT_MIPS_EVENTS;
4624       hdr->sh_flags |= SHF_MIPS_NOSTRIP;
4625       /* The sh_link field is set in final_write_processing.  */
4626     }
4627   else if (strcmp (name, ".msym") == 0)
4628     {
4629       hdr->sh_type = SHT_MIPS_MSYM;
4630       hdr->sh_flags |= SHF_ALLOC;
4631       hdr->sh_entsize = 8;
4632     }
4633
4634   /* The generic elf_fake_sections will set up REL_HDR using the default
4635    kind of relocations.  We used to set up a second header for the
4636    non-default kind of relocations here, but only NewABI would use
4637    these, and the IRIX ld doesn't like resulting empty RELA sections.
4638    Thus we create those header only on demand now.  */
4639
4640   return TRUE;
4641 }
4642
4643 /* Given a BFD section, try to locate the corresponding ELF section
4644    index.  This is used by both the 32-bit and the 64-bit ABI.
4645    Actually, it's not clear to me that the 64-bit ABI supports these,
4646    but for non-PIC objects we will certainly want support for at least
4647    the .scommon section.  */
4648
4649 bfd_boolean
4650 _bfd_mips_elf_section_from_bfd_section (bfd *abfd ATTRIBUTE_UNUSED,
4651                                         asection *sec, int *retval)
4652 {
4653   if (strcmp (bfd_get_section_name (abfd, sec), ".scommon") == 0)
4654     {
4655       *retval = SHN_MIPS_SCOMMON;
4656       return TRUE;
4657     }
4658   if (strcmp (bfd_get_section_name (abfd, sec), ".acommon") == 0)
4659     {
4660       *retval = SHN_MIPS_ACOMMON;
4661       return TRUE;
4662     }
4663   return FALSE;
4664 }
4665 \f
4666 /* Hook called by the linker routine which adds symbols from an object
4667    file.  We must handle the special MIPS section numbers here.  */
4668
4669 bfd_boolean
4670 _bfd_mips_elf_add_symbol_hook (bfd *abfd, struct bfd_link_info *info,
4671                                Elf_Internal_Sym *sym, const char **namep,
4672                                flagword *flagsp ATTRIBUTE_UNUSED,
4673                                asection **secp, bfd_vma *valp)
4674 {
4675   if (SGI_COMPAT (abfd)
4676       && (abfd->flags & DYNAMIC) != 0
4677       && strcmp (*namep, "_rld_new_interface") == 0)
4678     {
4679       /* Skip IRIX5 rld entry name.  */
4680       *namep = NULL;
4681       return TRUE;
4682     }
4683
4684   switch (sym->st_shndx)
4685     {
4686     case SHN_COMMON:
4687       /* Common symbols less than the GP size are automatically
4688          treated as SHN_MIPS_SCOMMON symbols.  */
4689       if (sym->st_size > elf_gp_size (abfd)
4690           || IRIX_COMPAT (abfd) == ict_irix6)
4691         break;
4692       /* Fall through.  */
4693     case SHN_MIPS_SCOMMON:
4694       *secp = bfd_make_section_old_way (abfd, ".scommon");
4695       (*secp)->flags |= SEC_IS_COMMON;
4696       *valp = sym->st_size;
4697       break;
4698
4699     case SHN_MIPS_TEXT:
4700       /* This section is used in a shared object.  */
4701       if (elf_tdata (abfd)->elf_text_section == NULL)
4702         {
4703           asymbol *elf_text_symbol;
4704           asection *elf_text_section;
4705           bfd_size_type amt = sizeof (asection);
4706
4707           elf_text_section = bfd_zalloc (abfd, amt);
4708           if (elf_text_section == NULL)
4709             return FALSE;
4710
4711           amt = sizeof (asymbol);
4712           elf_text_symbol = bfd_zalloc (abfd, amt);
4713           if (elf_text_symbol == NULL)
4714             return FALSE;
4715
4716           /* Initialize the section.  */
4717
4718           elf_tdata (abfd)->elf_text_section = elf_text_section;
4719           elf_tdata (abfd)->elf_text_symbol = elf_text_symbol;
4720
4721           elf_text_section->symbol = elf_text_symbol;
4722           elf_text_section->symbol_ptr_ptr = &elf_tdata (abfd)->elf_text_symbol;
4723
4724           elf_text_section->name = ".text";
4725           elf_text_section->flags = SEC_NO_FLAGS;
4726           elf_text_section->output_section = NULL;
4727           elf_text_section->owner = abfd;
4728           elf_text_symbol->name = ".text";
4729           elf_text_symbol->flags = BSF_SECTION_SYM | BSF_DYNAMIC;
4730           elf_text_symbol->section = elf_text_section;
4731         }
4732       /* This code used to do *secp = bfd_und_section_ptr if
4733          info->shared.  I don't know why, and that doesn't make sense,
4734          so I took it out.  */
4735       *secp = elf_tdata (abfd)->elf_text_section;
4736       break;
4737
4738     case SHN_MIPS_ACOMMON:
4739       /* Fall through. XXX Can we treat this as allocated data?  */
4740     case SHN_MIPS_DATA:
4741       /* This section is used in a shared object.  */
4742       if (elf_tdata (abfd)->elf_data_section == NULL)
4743         {
4744           asymbol *elf_data_symbol;
4745           asection *elf_data_section;
4746           bfd_size_type amt = sizeof (asection);
4747
4748           elf_data_section = bfd_zalloc (abfd, amt);
4749           if (elf_data_section == NULL)
4750             return FALSE;
4751
4752           amt = sizeof (asymbol);
4753           elf_data_symbol = bfd_zalloc (abfd, amt);
4754           if (elf_data_symbol == NULL)
4755             return FALSE;
4756
4757           /* Initialize the section.  */
4758
4759           elf_tdata (abfd)->elf_data_section = elf_data_section;
4760           elf_tdata (abfd)->elf_data_symbol = elf_data_symbol;
4761
4762           elf_data_section->symbol = elf_data_symbol;
4763           elf_data_section->symbol_ptr_ptr = &elf_tdata (abfd)->elf_data_symbol;
4764
4765           elf_data_section->name = ".data";
4766           elf_data_section->flags = SEC_NO_FLAGS;
4767           elf_data_section->output_section = NULL;
4768           elf_data_section->owner = abfd;
4769           elf_data_symbol->name = ".data";
4770           elf_data_symbol->flags = BSF_SECTION_SYM | BSF_DYNAMIC;
4771           elf_data_symbol->section = elf_data_section;
4772         }
4773       /* This code used to do *secp = bfd_und_section_ptr if
4774          info->shared.  I don't know why, and that doesn't make sense,
4775          so I took it out.  */
4776       *secp = elf_tdata (abfd)->elf_data_section;
4777       break;
4778
4779     case SHN_MIPS_SUNDEFINED:
4780       *secp = bfd_und_section_ptr;
4781       break;
4782     }
4783
4784   if (SGI_COMPAT (abfd)
4785       && ! info->shared
4786       && info->hash->creator == abfd->xvec
4787       && strcmp (*namep, "__rld_obj_head") == 0)
4788     {
4789       struct elf_link_hash_entry *h;
4790       struct bfd_link_hash_entry *bh;
4791
4792       /* Mark __rld_obj_head as dynamic.  */
4793       bh = NULL;
4794       if (! (_bfd_generic_link_add_one_symbol
4795              (info, abfd, *namep, BSF_GLOBAL, *secp, *valp, NULL, FALSE,
4796               get_elf_backend_data (abfd)->collect, &bh)))
4797         return FALSE;
4798
4799       h = (struct elf_link_hash_entry *) bh;
4800       h->non_elf = 0;
4801       h->def_regular = 1;
4802       h->type = STT_OBJECT;
4803
4804       if (! bfd_elf_link_record_dynamic_symbol (info, h))
4805         return FALSE;
4806
4807       mips_elf_hash_table (info)->use_rld_obj_head = TRUE;
4808     }
4809
4810   /* If this is a mips16 text symbol, add 1 to the value to make it
4811      odd.  This will cause something like .word SYM to come up with
4812      the right value when it is loaded into the PC.  */
4813   if (sym->st_other == STO_MIPS16)
4814     ++*valp;
4815
4816   return TRUE;
4817 }
4818
4819 /* This hook function is called before the linker writes out a global
4820    symbol.  We mark symbols as small common if appropriate.  This is
4821    also where we undo the increment of the value for a mips16 symbol.  */
4822
4823 bfd_boolean
4824 _bfd_mips_elf_link_output_symbol_hook
4825   (struct bfd_link_info *info ATTRIBUTE_UNUSED,
4826    const char *name ATTRIBUTE_UNUSED, Elf_Internal_Sym *sym,
4827    asection *input_sec, struct elf_link_hash_entry *h ATTRIBUTE_UNUSED)
4828 {
4829   /* If we see a common symbol, which implies a relocatable link, then
4830      if a symbol was small common in an input file, mark it as small
4831      common in the output file.  */
4832   if (sym->st_shndx == SHN_COMMON
4833       && strcmp (input_sec->name, ".scommon") == 0)
4834     sym->st_shndx = SHN_MIPS_SCOMMON;
4835
4836   if (sym->st_other == STO_MIPS16)
4837     sym->st_value &= ~1;
4838
4839   return TRUE;
4840 }
4841 \f
4842 /* Functions for the dynamic linker.  */
4843
4844 /* Create dynamic sections when linking against a dynamic object.  */
4845
4846 bfd_boolean
4847 _bfd_mips_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
4848 {
4849   struct elf_link_hash_entry *h;
4850   struct bfd_link_hash_entry *bh;
4851   flagword flags;
4852   register asection *s;
4853   const char * const *namep;
4854
4855   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4856            | SEC_LINKER_CREATED | SEC_READONLY);
4857
4858   /* Mips ABI requests the .dynamic section to be read only.  */
4859   s = bfd_get_section_by_name (abfd, ".dynamic");
4860   if (s != NULL)
4861     {
4862       if (! bfd_set_section_flags (abfd, s, flags))
4863         return FALSE;
4864     }
4865
4866   /* We need to create .got section.  */
4867   if (! mips_elf_create_got_section (abfd, info, FALSE))
4868     return FALSE;
4869
4870   if (! mips_elf_rel_dyn_section (elf_hash_table (info)->dynobj, TRUE))
4871     return FALSE;
4872
4873   /* Create .stub section.  */
4874   if (bfd_get_section_by_name (abfd,
4875                                MIPS_ELF_STUB_SECTION_NAME (abfd)) == NULL)
4876     {
4877       s = bfd_make_section (abfd, MIPS_ELF_STUB_SECTION_NAME (abfd));
4878       if (s == NULL
4879           || ! bfd_set_section_flags (abfd, s, flags | SEC_CODE)
4880           || ! bfd_set_section_alignment (abfd, s,
4881                                           MIPS_ELF_LOG_FILE_ALIGN (abfd)))
4882         return FALSE;
4883     }
4884
4885   if ((IRIX_COMPAT (abfd) == ict_irix5 || IRIX_COMPAT (abfd) == ict_none)
4886       && !info->shared
4887       && bfd_get_section_by_name (abfd, ".rld_map") == NULL)
4888     {
4889       s = bfd_make_section (abfd, ".rld_map");
4890       if (s == NULL
4891           || ! bfd_set_section_flags (abfd, s, flags &~ (flagword) SEC_READONLY)
4892           || ! bfd_set_section_alignment (abfd, s,
4893                                           MIPS_ELF_LOG_FILE_ALIGN (abfd)))
4894         return FALSE;
4895     }
4896
4897   /* On IRIX5, we adjust add some additional symbols and change the
4898      alignments of several sections.  There is no ABI documentation
4899      indicating that this is necessary on IRIX6, nor any evidence that
4900      the linker takes such action.  */
4901   if (IRIX_COMPAT (abfd) == ict_irix5)
4902     {
4903       for (namep = mips_elf_dynsym_rtproc_names; *namep != NULL; namep++)
4904         {
4905           bh = NULL;
4906           if (! (_bfd_generic_link_add_one_symbol
4907                  (info, abfd, *namep, BSF_GLOBAL, bfd_und_section_ptr, 0,
4908                   NULL, FALSE, get_elf_backend_data (abfd)->collect, &bh)))
4909             return FALSE;
4910
4911           h = (struct elf_link_hash_entry *) bh;
4912           h->non_elf = 0;
4913           h->def_regular = 1;
4914           h->type = STT_SECTION;
4915
4916           if (! bfd_elf_link_record_dynamic_symbol (info, h))
4917             return FALSE;
4918         }
4919
4920       /* We need to create a .compact_rel section.  */
4921       if (SGI_COMPAT (abfd))
4922         {
4923           if (!mips_elf_create_compact_rel_section (abfd, info))
4924             return FALSE;
4925         }
4926
4927       /* Change alignments of some sections.  */
4928       s = bfd_get_section_by_name (abfd, ".hash");
4929       if (s != NULL)
4930         bfd_set_section_alignment (abfd, s, MIPS_ELF_LOG_FILE_ALIGN (abfd));
4931       s = bfd_get_section_by_name (abfd, ".dynsym");
4932       if (s != NULL)
4933         bfd_set_section_alignment (abfd, s, MIPS_ELF_LOG_FILE_ALIGN (abfd));
4934       s = bfd_get_section_by_name (abfd, ".dynstr");
4935       if (s != NULL)
4936         bfd_set_section_alignment (abfd, s, MIPS_ELF_LOG_FILE_ALIGN (abfd));
4937       s = bfd_get_section_by_name (abfd, ".reginfo");
4938       if (s != NULL)
4939         bfd_set_section_alignment (abfd, s, MIPS_ELF_LOG_FILE_ALIGN (abfd));
4940       s = bfd_get_section_by_name (abfd, ".dynamic");
4941       if (s != NULL)
4942         bfd_set_section_alignment (abfd, s, MIPS_ELF_LOG_FILE_ALIGN (abfd));
4943     }
4944
4945   if (!info->shared)
4946     {
4947       const char *name;
4948
4949       name = SGI_COMPAT (abfd) ? "_DYNAMIC_LINK" : "_DYNAMIC_LINKING";
4950       bh = NULL;
4951       if (!(_bfd_generic_link_add_one_symbol
4952             (info, abfd, name, BSF_GLOBAL, bfd_abs_section_ptr, 0,
4953              NULL, FALSE, get_elf_backend_data (abfd)->collect, &bh)))
4954         return FALSE;
4955
4956       h = (struct elf_link_hash_entry *) bh;
4957       h->non_elf = 0;
4958       h->def_regular = 1;
4959       h->type = STT_SECTION;
4960
4961       if (! bfd_elf_link_record_dynamic_symbol (info, h))
4962         return FALSE;
4963
4964       if (! mips_elf_hash_table (info)->use_rld_obj_head)
4965         {
4966           /* __rld_map is a four byte word located in the .data section
4967              and is filled in by the rtld to contain a pointer to
4968              the _r_debug structure. Its symbol value will be set in
4969              _bfd_mips_elf_finish_dynamic_symbol.  */
4970           s = bfd_get_section_by_name (abfd, ".rld_map");
4971           BFD_ASSERT (s != NULL);
4972
4973           name = SGI_COMPAT (abfd) ? "__rld_map" : "__RLD_MAP";
4974           bh = NULL;
4975           if (!(_bfd_generic_link_add_one_symbol
4976                 (info, abfd, name, BSF_GLOBAL, s, 0, NULL, FALSE,
4977                  get_elf_backend_data (abfd)->collect, &bh)))
4978             return FALSE;
4979
4980           h = (struct elf_link_hash_entry *) bh;
4981           h->non_elf = 0;
4982           h->def_regular = 1;
4983           h->type = STT_OBJECT;
4984
4985           if (! bfd_elf_link_record_dynamic_symbol (info, h))
4986             return FALSE;
4987         }
4988     }
4989
4990   return TRUE;
4991 }
4992 \f
4993 /* Look through the relocs for a section during the first phase, and
4994    allocate space in the global offset table.  */
4995
4996 bfd_boolean
4997 _bfd_mips_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
4998                             asection *sec, const Elf_Internal_Rela *relocs)
4999 {
5000   const char *name;
5001   bfd *dynobj;
5002   Elf_Internal_Shdr *symtab_hdr;
5003   struct elf_link_hash_entry **sym_hashes;
5004   struct mips_got_info *g;
5005   size_t extsymoff;
5006   const Elf_Internal_Rela *rel;
5007   const Elf_Internal_Rela *rel_end;
5008   asection *sgot;
5009   asection *sreloc;
5010   const struct elf_backend_data *bed;
5011
5012   if (info->relocatable)
5013     return TRUE;
5014
5015   dynobj = elf_hash_table (info)->dynobj;
5016   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
5017   sym_hashes = elf_sym_hashes (abfd);
5018   extsymoff = (elf_bad_symtab (abfd)) ? 0 : symtab_hdr->sh_info;
5019
5020   /* Check for the mips16 stub sections.  */
5021
5022   name = bfd_get_section_name (abfd, sec);
5023   if (strncmp (name, FN_STUB, sizeof FN_STUB - 1) == 0)
5024     {
5025       unsigned long r_symndx;
5026
5027       /* Look at the relocation information to figure out which symbol
5028          this is for.  */
5029
5030       r_symndx = ELF_R_SYM (abfd, relocs->r_info);
5031
5032       if (r_symndx < extsymoff
5033           || sym_hashes[r_symndx - extsymoff] == NULL)
5034         {
5035           asection *o;
5036
5037           /* This stub is for a local symbol.  This stub will only be
5038              needed if there is some relocation in this BFD, other
5039              than a 16 bit function call, which refers to this symbol.  */
5040           for (o = abfd->sections; o != NULL; o = o->next)
5041             {
5042               Elf_Internal_Rela *sec_relocs;
5043               const Elf_Internal_Rela *r, *rend;
5044
5045               /* We can ignore stub sections when looking for relocs.  */
5046               if ((o->flags & SEC_RELOC) == 0
5047                   || o->reloc_count == 0
5048                   || strncmp (bfd_get_section_name (abfd, o), FN_STUB,
5049                               sizeof FN_STUB - 1) == 0
5050                   || strncmp (bfd_get_section_name (abfd, o), CALL_STUB,
5051                               sizeof CALL_STUB - 1) == 0
5052                   || strncmp (bfd_get_section_name (abfd, o), CALL_FP_STUB,
5053                               sizeof CALL_FP_STUB - 1) == 0)
5054                 continue;
5055
5056               sec_relocs
5057                 = _bfd_elf_link_read_relocs (abfd, o, NULL, NULL,
5058                                              info->keep_memory);
5059               if (sec_relocs == NULL)
5060                 return FALSE;
5061
5062               rend = sec_relocs + o->reloc_count;
5063               for (r = sec_relocs; r < rend; r++)
5064                 if (ELF_R_SYM (abfd, r->r_info) == r_symndx
5065                     && ELF_R_TYPE (abfd, r->r_info) != R_MIPS16_26)
5066                   break;
5067
5068               if (elf_section_data (o)->relocs != sec_relocs)
5069                 free (sec_relocs);
5070
5071               if (r < rend)
5072                 break;
5073             }
5074
5075           if (o == NULL)
5076             {
5077               /* There is no non-call reloc for this stub, so we do
5078                  not need it.  Since this function is called before
5079                  the linker maps input sections to output sections, we
5080                  can easily discard it by setting the SEC_EXCLUDE
5081                  flag.  */
5082               sec->flags |= SEC_EXCLUDE;
5083               return TRUE;
5084             }
5085
5086           /* Record this stub in an array of local symbol stubs for
5087              this BFD.  */
5088           if (elf_tdata (abfd)->local_stubs == NULL)
5089             {
5090               unsigned long symcount;
5091               asection **n;
5092               bfd_size_type amt;
5093
5094               if (elf_bad_symtab (abfd))
5095                 symcount = NUM_SHDR_ENTRIES (symtab_hdr);
5096               else
5097                 symcount = symtab_hdr->sh_info;
5098               amt = symcount * sizeof (asection *);
5099               n = bfd_zalloc (abfd, amt);
5100               if (n == NULL)
5101                 return FALSE;
5102               elf_tdata (abfd)->local_stubs = n;
5103             }
5104
5105           elf_tdata (abfd)->local_stubs[r_symndx] = sec;
5106
5107           /* We don't need to set mips16_stubs_seen in this case.
5108              That flag is used to see whether we need to look through
5109              the global symbol table for stubs.  We don't need to set
5110              it here, because we just have a local stub.  */
5111         }
5112       else
5113         {
5114           struct mips_elf_link_hash_entry *h;
5115
5116           h = ((struct mips_elf_link_hash_entry *)
5117                sym_hashes[r_symndx - extsymoff]);
5118
5119           /* H is the symbol this stub is for.  */
5120
5121           h->fn_stub = sec;
5122           mips_elf_hash_table (info)->mips16_stubs_seen = TRUE;
5123         }
5124     }
5125   else if (strncmp (name, CALL_STUB, sizeof CALL_STUB - 1) == 0
5126            || strncmp (name, CALL_FP_STUB, sizeof CALL_FP_STUB - 1) == 0)
5127     {
5128       unsigned long r_symndx;
5129       struct mips_elf_link_hash_entry *h;
5130       asection **loc;
5131
5132       /* Look at the relocation information to figure out which symbol
5133          this is for.  */
5134
5135       r_symndx = ELF_R_SYM (abfd, relocs->r_info);
5136
5137       if (r_symndx < extsymoff
5138           || sym_hashes[r_symndx - extsymoff] == NULL)
5139         {
5140           /* This stub was actually built for a static symbol defined
5141              in the same file.  We assume that all static symbols in
5142              mips16 code are themselves mips16, so we can simply
5143              discard this stub.  Since this function is called before
5144              the linker maps input sections to output sections, we can
5145              easily discard it by setting the SEC_EXCLUDE flag.  */
5146           sec->flags |= SEC_EXCLUDE;
5147           return TRUE;
5148         }
5149
5150       h = ((struct mips_elf_link_hash_entry *)
5151            sym_hashes[r_symndx - extsymoff]);
5152
5153       /* H is the symbol this stub is for.  */
5154
5155       if (strncmp (name, CALL_FP_STUB, sizeof CALL_FP_STUB - 1) == 0)
5156         loc = &h->call_fp_stub;
5157       else
5158         loc = &h->call_stub;
5159
5160       /* If we already have an appropriate stub for this function, we
5161          don't need another one, so we can discard this one.  Since
5162          this function is called before the linker maps input sections
5163          to output sections, we can easily discard it by setting the
5164          SEC_EXCLUDE flag.  We can also discard this section if we
5165          happen to already know that this is a mips16 function; it is
5166          not necessary to check this here, as it is checked later, but
5167          it is slightly faster to check now.  */
5168       if (*loc != NULL || h->root.other == STO_MIPS16)
5169         {
5170           sec->flags |= SEC_EXCLUDE;
5171           return TRUE;
5172         }
5173
5174       *loc = sec;
5175       mips_elf_hash_table (info)->mips16_stubs_seen = TRUE;
5176     }
5177
5178   if (dynobj == NULL)
5179     {
5180       sgot = NULL;
5181       g = NULL;
5182     }
5183   else
5184     {
5185       sgot = mips_elf_got_section (dynobj, FALSE);
5186       if (sgot == NULL)
5187         g = NULL;
5188       else
5189         {
5190           BFD_ASSERT (mips_elf_section_data (sgot) != NULL);
5191           g = mips_elf_section_data (sgot)->u.got_info;
5192           BFD_ASSERT (g != NULL);
5193         }
5194     }
5195
5196   sreloc = NULL;
5197   bed = get_elf_backend_data (abfd);
5198   rel_end = relocs + sec->reloc_count * bed->s->int_rels_per_ext_rel;
5199   for (rel = relocs; rel < rel_end; ++rel)
5200     {
5201       unsigned long r_symndx;
5202       unsigned int r_type;
5203       struct elf_link_hash_entry *h;
5204
5205       r_symndx = ELF_R_SYM (abfd, rel->r_info);
5206       r_type = ELF_R_TYPE (abfd, rel->r_info);
5207
5208       if (r_symndx < extsymoff)
5209         h = NULL;
5210       else if (r_symndx >= extsymoff + NUM_SHDR_ENTRIES (symtab_hdr))
5211         {
5212           (*_bfd_error_handler)
5213             (_("%B: Malformed reloc detected for section %s"),
5214              abfd, name);
5215           bfd_set_error (bfd_error_bad_value);
5216           return FALSE;
5217         }
5218       else
5219         {
5220           h = sym_hashes[r_symndx - extsymoff];
5221
5222           /* This may be an indirect symbol created because of a version.  */
5223           if (h != NULL)
5224             {
5225               while (h->root.type == bfd_link_hash_indirect)
5226                 h = (struct elf_link_hash_entry *) h->root.u.i.link;
5227             }
5228         }
5229
5230       /* Some relocs require a global offset table.  */
5231       if (dynobj == NULL || sgot == NULL)
5232         {
5233           switch (r_type)
5234             {
5235             case R_MIPS_GOT16:
5236             case R_MIPS_CALL16:
5237             case R_MIPS_CALL_HI16:
5238             case R_MIPS_CALL_LO16:
5239             case R_MIPS_GOT_HI16:
5240             case R_MIPS_GOT_LO16:
5241             case R_MIPS_GOT_PAGE:
5242             case R_MIPS_GOT_OFST:
5243             case R_MIPS_GOT_DISP:
5244               if (dynobj == NULL)
5245                 elf_hash_table (info)->dynobj = dynobj = abfd;
5246               if (! mips_elf_create_got_section (dynobj, info, FALSE))
5247                 return FALSE;
5248               g = mips_elf_got_info (dynobj, &sgot);
5249               break;
5250
5251             case R_MIPS_32:
5252             case R_MIPS_REL32:
5253             case R_MIPS_64:
5254               if (dynobj == NULL
5255                   && (info->shared || h != NULL)
5256                   && (sec->flags & SEC_ALLOC) != 0)
5257                 elf_hash_table (info)->dynobj = dynobj = abfd;
5258               break;
5259
5260             default:
5261               break;
5262             }
5263         }
5264
5265       if (!h && (r_type == R_MIPS_CALL_LO16
5266                  || r_type == R_MIPS_GOT_LO16
5267                  || r_type == R_MIPS_GOT_DISP))
5268         {
5269           /* We may need a local GOT entry for this relocation.  We
5270              don't count R_MIPS_GOT_PAGE because we can estimate the
5271              maximum number of pages needed by looking at the size of
5272              the segment.  Similar comments apply to R_MIPS_GOT16 and
5273              R_MIPS_CALL16.  We don't count R_MIPS_GOT_HI16, or
5274              R_MIPS_CALL_HI16 because these are always followed by an
5275              R_MIPS_GOT_LO16 or R_MIPS_CALL_LO16.  */
5276           if (! mips_elf_record_local_got_symbol (abfd, r_symndx,
5277                                                   rel->r_addend, g))
5278             return FALSE;
5279         }
5280
5281       switch (r_type)
5282         {
5283         case R_MIPS_CALL16:
5284           if (h == NULL)
5285             {
5286               (*_bfd_error_handler)
5287                 (_("%B: CALL16 reloc at 0x%lx not against global symbol"),
5288                  abfd, (unsigned long) rel->r_offset);
5289               bfd_set_error (bfd_error_bad_value);
5290               return FALSE;
5291             }
5292           /* Fall through.  */
5293
5294         case R_MIPS_CALL_HI16:
5295         case R_MIPS_CALL_LO16:
5296           if (h != NULL)
5297             {
5298               /* This symbol requires a global offset table entry.  */
5299               if (! mips_elf_record_global_got_symbol (h, abfd, info, g))
5300                 return FALSE;
5301
5302               /* We need a stub, not a plt entry for the undefined
5303                  function.  But we record it as if it needs plt.  See
5304                  _bfd_elf_adjust_dynamic_symbol.  */
5305               h->needs_plt = 1;
5306               h->type = STT_FUNC;
5307             }
5308           break;
5309
5310         case R_MIPS_GOT_PAGE:
5311           /* If this is a global, overridable symbol, GOT_PAGE will
5312              decay to GOT_DISP, so we'll need a GOT entry for it.  */
5313           if (h == NULL)
5314             break;
5315           else
5316             {
5317               struct mips_elf_link_hash_entry *hmips =
5318                 (struct mips_elf_link_hash_entry *) h;
5319
5320               while (hmips->root.root.type == bfd_link_hash_indirect
5321                      || hmips->root.root.type == bfd_link_hash_warning)
5322                 hmips = (struct mips_elf_link_hash_entry *)
5323                   hmips->root.root.u.i.link;
5324
5325               if (hmips->root.def_regular
5326                   && ! (info->shared && ! info->symbolic
5327                         && ! hmips->root.forced_local))
5328                 break;
5329             }
5330           /* Fall through.  */
5331
5332         case R_MIPS_GOT16:
5333         case R_MIPS_GOT_HI16:
5334         case R_MIPS_GOT_LO16:
5335         case R_MIPS_GOT_DISP:
5336           /* This symbol requires a global offset table entry.  */
5337           if (h && ! mips_elf_record_global_got_symbol (h, abfd, info, g))
5338             return FALSE;
5339           break;
5340
5341         case R_MIPS_32:
5342         case R_MIPS_REL32:
5343         case R_MIPS_64:
5344           if ((info->shared || h != NULL)
5345               && (sec->flags & SEC_ALLOC) != 0)
5346             {
5347               if (sreloc == NULL)
5348                 {
5349                   sreloc = mips_elf_rel_dyn_section (dynobj, TRUE);
5350                   if (sreloc == NULL)
5351                     return FALSE;
5352                 }
5353 #define MIPS_READONLY_SECTION (SEC_ALLOC | SEC_LOAD | SEC_READONLY)
5354               if (info->shared)
5355                 {
5356                   /* When creating a shared object, we must copy these
5357                      reloc types into the output file as R_MIPS_REL32
5358                      relocs.  We make room for this reloc in the
5359                      .rel.dyn reloc section.  */
5360                   mips_elf_allocate_dynamic_relocations (dynobj, 1);
5361                   if ((sec->flags & MIPS_READONLY_SECTION)
5362                       == MIPS_READONLY_SECTION)
5363                     /* We tell the dynamic linker that there are
5364                        relocations against the text segment.  */
5365                     info->flags |= DF_TEXTREL;
5366                 }
5367               else
5368                 {
5369                   struct mips_elf_link_hash_entry *hmips;
5370
5371                   /* We only need to copy this reloc if the symbol is
5372                      defined in a dynamic object.  */
5373                   hmips = (struct mips_elf_link_hash_entry *) h;
5374                   ++hmips->possibly_dynamic_relocs;
5375                   if ((sec->flags & MIPS_READONLY_SECTION)
5376                       == MIPS_READONLY_SECTION)
5377                     /* We need it to tell the dynamic linker if there
5378                        are relocations against the text segment.  */
5379                     hmips->readonly_reloc = TRUE;
5380                 }
5381
5382               /* Even though we don't directly need a GOT entry for
5383                  this symbol, a symbol must have a dynamic symbol
5384                  table index greater that DT_MIPS_GOTSYM if there are
5385                  dynamic relocations against it.  */
5386               if (h != NULL)
5387                 {
5388                   if (dynobj == NULL)
5389                     elf_hash_table (info)->dynobj = dynobj = abfd;
5390                   if (! mips_elf_create_got_section (dynobj, info, TRUE))
5391                     return FALSE;
5392                   g = mips_elf_got_info (dynobj, &sgot);
5393                   if (! mips_elf_record_global_got_symbol (h, abfd, info, g))
5394                     return FALSE;
5395                 }
5396             }
5397
5398           if (SGI_COMPAT (abfd))
5399             mips_elf_hash_table (info)->compact_rel_size +=
5400               sizeof (Elf32_External_crinfo);
5401           break;
5402
5403         case R_MIPS_26:
5404         case R_MIPS_GPREL16:
5405         case R_MIPS_LITERAL:
5406         case R_MIPS_GPREL32:
5407           if (SGI_COMPAT (abfd))
5408             mips_elf_hash_table (info)->compact_rel_size +=
5409               sizeof (Elf32_External_crinfo);
5410           break;
5411
5412           /* This relocation describes the C++ object vtable hierarchy.
5413              Reconstruct it for later use during GC.  */
5414         case R_MIPS_GNU_VTINHERIT:
5415           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
5416             return FALSE;
5417           break;
5418
5419           /* This relocation describes which C++ vtable entries are actually
5420              used.  Record for later use during GC.  */
5421         case R_MIPS_GNU_VTENTRY:
5422           if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_offset))
5423             return FALSE;
5424           break;
5425
5426         default:
5427           break;
5428         }
5429
5430       /* We must not create a stub for a symbol that has relocations
5431          related to taking the function's address.  */
5432       switch (r_type)
5433         {
5434         default:
5435           if (h != NULL)
5436             {
5437               struct mips_elf_link_hash_entry *mh;
5438
5439               mh = (struct mips_elf_link_hash_entry *) h;
5440               mh->no_fn_stub = TRUE;
5441             }
5442           break;
5443         case R_MIPS_CALL16:
5444         case R_MIPS_CALL_HI16:
5445         case R_MIPS_CALL_LO16:
5446         case R_MIPS_JALR:
5447           break;
5448         }
5449
5450       /* If this reloc is not a 16 bit call, and it has a global
5451          symbol, then we will need the fn_stub if there is one.
5452          References from a stub section do not count.  */
5453       if (h != NULL
5454           && r_type != R_MIPS16_26
5455           && strncmp (bfd_get_section_name (abfd, sec), FN_STUB,
5456                       sizeof FN_STUB - 1) != 0
5457           && strncmp (bfd_get_section_name (abfd, sec), CALL_STUB,
5458                       sizeof CALL_STUB - 1) != 0
5459           && strncmp (bfd_get_section_name (abfd, sec), CALL_FP_STUB,
5460                       sizeof CALL_FP_STUB - 1) != 0)
5461         {
5462           struct mips_elf_link_hash_entry *mh;
5463
5464           mh = (struct mips_elf_link_hash_entry *) h;
5465           mh->need_fn_stub = TRUE;
5466         }
5467     }
5468
5469   return TRUE;
5470 }
5471 \f
5472 bfd_boolean
5473 _bfd_mips_relax_section (bfd *abfd, asection *sec,
5474                          struct bfd_link_info *link_info,
5475                          bfd_boolean *again)
5476 {
5477   Elf_Internal_Rela *internal_relocs;
5478   Elf_Internal_Rela *irel, *irelend;
5479   Elf_Internal_Shdr *symtab_hdr;
5480   bfd_byte *contents = NULL;
5481   size_t extsymoff;
5482   bfd_boolean changed_contents = FALSE;
5483   bfd_vma sec_start = sec->output_section->vma + sec->output_offset;
5484   Elf_Internal_Sym *isymbuf = NULL;
5485
5486   /* We are not currently changing any sizes, so only one pass.  */
5487   *again = FALSE;
5488
5489   if (link_info->relocatable)
5490     return TRUE;
5491
5492   internal_relocs = _bfd_elf_link_read_relocs (abfd, sec, NULL, NULL,
5493                                                link_info->keep_memory);
5494   if (internal_relocs == NULL)
5495     return TRUE;
5496
5497   irelend = internal_relocs + sec->reloc_count
5498     * get_elf_backend_data (abfd)->s->int_rels_per_ext_rel;
5499   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
5500   extsymoff = (elf_bad_symtab (abfd)) ? 0 : symtab_hdr->sh_info;
5501
5502   for (irel = internal_relocs; irel < irelend; irel++)
5503     {
5504       bfd_vma symval;
5505       bfd_signed_vma sym_offset;
5506       unsigned int r_type;
5507       unsigned long r_symndx;
5508       asection *sym_sec;
5509       unsigned long instruction;
5510
5511       /* Turn jalr into bgezal, and jr into beq, if they're marked
5512          with a JALR relocation, that indicate where they jump to.
5513          This saves some pipeline bubbles.  */
5514       r_type = ELF_R_TYPE (abfd, irel->r_info);
5515       if (r_type != R_MIPS_JALR)
5516         continue;
5517
5518       r_symndx = ELF_R_SYM (abfd, irel->r_info);
5519       /* Compute the address of the jump target.  */
5520       if (r_symndx >= extsymoff)
5521         {
5522           struct mips_elf_link_hash_entry *h
5523             = ((struct mips_elf_link_hash_entry *)
5524                elf_sym_hashes (abfd) [r_symndx - extsymoff]);
5525
5526           while (h->root.root.type == bfd_link_hash_indirect
5527                  || h->root.root.type == bfd_link_hash_warning)
5528             h = (struct mips_elf_link_hash_entry *) h->root.root.u.i.link;
5529
5530           /* If a symbol is undefined, or if it may be overridden,
5531              skip it.  */
5532           if (! ((h->root.root.type == bfd_link_hash_defined
5533                   || h->root.root.type == bfd_link_hash_defweak)
5534                  && h->root.root.u.def.section)
5535               || (link_info->shared && ! link_info->symbolic
5536                   && !h->root.forced_local))
5537             continue;
5538
5539           sym_sec = h->root.root.u.def.section;
5540           if (sym_sec->output_section)
5541             symval = (h->root.root.u.def.value
5542                       + sym_sec->output_section->vma
5543                       + sym_sec->output_offset);
5544           else
5545             symval = h->root.root.u.def.value;
5546         }
5547       else
5548         {
5549           Elf_Internal_Sym *isym;
5550
5551           /* Read this BFD's symbols if we haven't done so already.  */
5552           if (isymbuf == NULL && symtab_hdr->sh_info != 0)
5553             {
5554               isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
5555               if (isymbuf == NULL)
5556                 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
5557                                                 symtab_hdr->sh_info, 0,
5558                                                 NULL, NULL, NULL);
5559               if (isymbuf == NULL)
5560                 goto relax_return;
5561             }
5562
5563           isym = isymbuf + r_symndx;
5564           if (isym->st_shndx == SHN_UNDEF)
5565             continue;
5566           else if (isym->st_shndx == SHN_ABS)
5567             sym_sec = bfd_abs_section_ptr;
5568           else if (isym->st_shndx == SHN_COMMON)
5569             sym_sec = bfd_com_section_ptr;
5570           else
5571             sym_sec
5572               = bfd_section_from_elf_index (abfd, isym->st_shndx);
5573           symval = isym->st_value
5574             + sym_sec->output_section->vma
5575             + sym_sec->output_offset;
5576         }
5577
5578       /* Compute branch offset, from delay slot of the jump to the
5579          branch target.  */
5580       sym_offset = (symval + irel->r_addend)
5581         - (sec_start + irel->r_offset + 4);
5582
5583       /* Branch offset must be properly aligned.  */
5584       if ((sym_offset & 3) != 0)
5585         continue;
5586
5587       sym_offset >>= 2;
5588
5589       /* Check that it's in range.  */
5590       if (sym_offset < -0x8000 || sym_offset >= 0x8000)
5591         continue;
5592
5593       /* Get the section contents if we haven't done so already.  */
5594       if (contents == NULL)
5595         {
5596           /* Get cached copy if it exists.  */
5597           if (elf_section_data (sec)->this_hdr.contents != NULL)
5598             contents = elf_section_data (sec)->this_hdr.contents;
5599           else
5600             {
5601               if (!bfd_malloc_and_get_section (abfd, sec, &contents))
5602                 goto relax_return;
5603             }
5604         }
5605
5606       instruction = bfd_get_32 (abfd, contents + irel->r_offset);
5607
5608       /* If it was jalr <reg>, turn it into bgezal $zero, <target>.  */
5609       if ((instruction & 0xfc1fffff) == 0x0000f809)
5610         instruction = 0x04110000;
5611       /* If it was jr <reg>, turn it into b <target>.  */
5612       else if ((instruction & 0xfc1fffff) == 0x00000008)
5613         instruction = 0x10000000;
5614       else
5615         continue;
5616
5617       instruction |= (sym_offset & 0xffff);
5618       bfd_put_32 (abfd, instruction, contents + irel->r_offset);
5619       changed_contents = TRUE;
5620     }
5621
5622   if (contents != NULL
5623       && elf_section_data (sec)->this_hdr.contents != contents)
5624     {
5625       if (!changed_contents && !link_info->keep_memory)
5626         free (contents);
5627       else
5628         {
5629           /* Cache the section contents for elf_link_input_bfd.  */
5630           elf_section_data (sec)->this_hdr.contents = contents;
5631         }
5632     }
5633   return TRUE;
5634
5635  relax_return:
5636   if (contents != NULL
5637       && elf_section_data (sec)->this_hdr.contents != contents)
5638     free (contents);
5639   return FALSE;
5640 }
5641 \f
5642 /* Adjust a symbol defined by a dynamic object and referenced by a
5643    regular object.  The current definition is in some section of the
5644    dynamic object, but we're not including those sections.  We have to
5645    change the definition to something the rest of the link can
5646    understand.  */
5647
5648 bfd_boolean
5649 _bfd_mips_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
5650                                      struct elf_link_hash_entry *h)
5651 {
5652   bfd *dynobj;
5653   struct mips_elf_link_hash_entry *hmips;
5654   asection *s;
5655
5656   dynobj = elf_hash_table (info)->dynobj;
5657
5658   /* Make sure we know what is going on here.  */
5659   BFD_ASSERT (dynobj != NULL
5660               && (h->needs_plt
5661                   || h->u.weakdef != NULL
5662                   || (h->def_dynamic
5663                       && h->ref_regular
5664                       && !h->def_regular)));
5665
5666   /* If this symbol is defined in a dynamic object, we need to copy
5667      any R_MIPS_32 or R_MIPS_REL32 relocs against it into the output
5668      file.  */
5669   hmips = (struct mips_elf_link_hash_entry *) h;
5670   if (! info->relocatable
5671       && hmips->possibly_dynamic_relocs != 0
5672       && (h->root.type == bfd_link_hash_defweak
5673           || !h->def_regular))
5674     {
5675       mips_elf_allocate_dynamic_relocations (dynobj,
5676                                              hmips->possibly_dynamic_relocs);
5677       if (hmips->readonly_reloc)
5678         /* We tell the dynamic linker that there are relocations
5679            against the text segment.  */
5680         info->flags |= DF_TEXTREL;
5681     }
5682
5683   /* For a function, create a stub, if allowed.  */
5684   if (! hmips->no_fn_stub
5685       && h->needs_plt)
5686     {
5687       if (! elf_hash_table (info)->dynamic_sections_created)
5688         return TRUE;
5689
5690       /* If this symbol is not defined in a regular file, then set
5691          the symbol to the stub location.  This is required to make
5692          function pointers compare as equal between the normal
5693          executable and the shared library.  */
5694       if (!h->def_regular)
5695         {
5696           /* We need .stub section.  */
5697           s = bfd_get_section_by_name (dynobj,
5698                                        MIPS_ELF_STUB_SECTION_NAME (dynobj));
5699           BFD_ASSERT (s != NULL);
5700
5701           h->root.u.def.section = s;
5702           h->root.u.def.value = s->size;
5703
5704           /* XXX Write this stub address somewhere.  */
5705           h->plt.offset = s->size;
5706
5707           /* Make room for this stub code.  */
5708           s->size += MIPS_FUNCTION_STUB_SIZE;
5709
5710           /* The last half word of the stub will be filled with the index
5711              of this symbol in .dynsym section.  */
5712           return TRUE;
5713         }
5714     }
5715   else if ((h->type == STT_FUNC)
5716            && !h->needs_plt)
5717     {
5718       /* This will set the entry for this symbol in the GOT to 0, and
5719          the dynamic linker will take care of this.  */
5720       h->root.u.def.value = 0;
5721       return TRUE;
5722     }
5723
5724   /* If this is a weak symbol, and there is a real definition, the
5725      processor independent code will have arranged for us to see the
5726      real definition first, and we can just use the same value.  */
5727   if (h->u.weakdef != NULL)
5728     {
5729       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
5730                   || h->u.weakdef->root.type == bfd_link_hash_defweak);
5731       h->root.u.def.section = h->u.weakdef->root.u.def.section;
5732       h->root.u.def.value = h->u.weakdef->root.u.def.value;
5733       return TRUE;
5734     }
5735
5736   /* This is a reference to a symbol defined by a dynamic object which
5737      is not a function.  */
5738
5739   return TRUE;
5740 }
5741 \f
5742 /* This function is called after all the input files have been read,
5743    and the input sections have been assigned to output sections.  We
5744    check for any mips16 stub sections that we can discard.  */
5745
5746 bfd_boolean
5747 _bfd_mips_elf_always_size_sections (bfd *output_bfd,
5748                                     struct bfd_link_info *info)
5749 {
5750   asection *ri;
5751
5752   bfd *dynobj;
5753   asection *s;
5754   struct mips_got_info *g;
5755   int i;
5756   bfd_size_type loadable_size = 0;
5757   bfd_size_type local_gotno;
5758   bfd *sub;
5759
5760   /* The .reginfo section has a fixed size.  */
5761   ri = bfd_get_section_by_name (output_bfd, ".reginfo");
5762   if (ri != NULL)
5763     bfd_set_section_size (output_bfd, ri, sizeof (Elf32_External_RegInfo));
5764
5765   if (! (info->relocatable
5766          || ! mips_elf_hash_table (info)->mips16_stubs_seen))
5767     mips_elf_link_hash_traverse (mips_elf_hash_table (info),
5768                                  mips_elf_check_mips16_stubs, NULL);
5769
5770   dynobj = elf_hash_table (info)->dynobj;
5771   if (dynobj == NULL)
5772     /* Relocatable links don't have it.  */
5773     return TRUE;
5774
5775   g = mips_elf_got_info (dynobj, &s);
5776   if (s == NULL)
5777     return TRUE;
5778
5779   /* Calculate the total loadable size of the output.  That
5780      will give us the maximum number of GOT_PAGE entries
5781      required.  */
5782   for (sub = info->input_bfds; sub; sub = sub->link_next)
5783     {
5784       asection *subsection;
5785
5786       for (subsection = sub->sections;
5787            subsection;
5788            subsection = subsection->next)
5789         {
5790           if ((subsection->flags & SEC_ALLOC) == 0)
5791             continue;
5792           loadable_size += ((subsection->size + 0xf)
5793                             &~ (bfd_size_type) 0xf);
5794         }
5795     }
5796
5797   /* There has to be a global GOT entry for every symbol with
5798      a dynamic symbol table index of DT_MIPS_GOTSYM or
5799      higher.  Therefore, it make sense to put those symbols
5800      that need GOT entries at the end of the symbol table.  We
5801      do that here.  */
5802   if (! mips_elf_sort_hash_table (info, 1))
5803     return FALSE;
5804
5805   if (g->global_gotsym != NULL)
5806     i = elf_hash_table (info)->dynsymcount - g->global_gotsym->dynindx;
5807   else
5808     /* If there are no global symbols, or none requiring
5809        relocations, then GLOBAL_GOTSYM will be NULL.  */
5810     i = 0;
5811
5812   /* In the worst case, we'll get one stub per dynamic symbol, plus
5813      one to account for the dummy entry at the end required by IRIX
5814      rld.  */
5815   loadable_size += MIPS_FUNCTION_STUB_SIZE * (i + 1);
5816
5817   /* Assume there are two loadable segments consisting of
5818      contiguous sections.  Is 5 enough?  */
5819   local_gotno = (loadable_size >> 16) + 5;
5820
5821   g->local_gotno += local_gotno;
5822   s->size += g->local_gotno * MIPS_ELF_GOT_SIZE (output_bfd);
5823
5824   g->global_gotno = i;
5825   s->size += i * MIPS_ELF_GOT_SIZE (output_bfd);
5826
5827   if (s->size > MIPS_ELF_GOT_MAX_SIZE (output_bfd)
5828       && ! mips_elf_multi_got (output_bfd, info, g, s, local_gotno))
5829     return FALSE;
5830
5831   return TRUE;
5832 }
5833
5834 /* Set the sizes of the dynamic sections.  */
5835
5836 bfd_boolean
5837 _bfd_mips_elf_size_dynamic_sections (bfd *output_bfd,
5838                                      struct bfd_link_info *info)
5839 {
5840   bfd *dynobj;
5841   asection *s;
5842   bfd_boolean reltext;
5843
5844   dynobj = elf_hash_table (info)->dynobj;
5845   BFD_ASSERT (dynobj != NULL);
5846
5847   if (elf_hash_table (info)->dynamic_sections_created)
5848     {
5849       /* Set the contents of the .interp section to the interpreter.  */
5850       if (info->executable)
5851         {
5852           s = bfd_get_section_by_name (dynobj, ".interp");
5853           BFD_ASSERT (s != NULL);
5854           s->size
5855             = strlen (ELF_DYNAMIC_INTERPRETER (output_bfd)) + 1;
5856           s->contents
5857             = (bfd_byte *) ELF_DYNAMIC_INTERPRETER (output_bfd);
5858         }
5859     }
5860
5861   /* The check_relocs and adjust_dynamic_symbol entry points have
5862      determined the sizes of the various dynamic sections.  Allocate
5863      memory for them.  */
5864   reltext = FALSE;
5865   for (s = dynobj->sections; s != NULL; s = s->next)
5866     {
5867       const char *name;
5868       bfd_boolean strip;
5869
5870       /* It's OK to base decisions on the section name, because none
5871          of the dynobj section names depend upon the input files.  */
5872       name = bfd_get_section_name (dynobj, s);
5873
5874       if ((s->flags & SEC_LINKER_CREATED) == 0)
5875         continue;
5876
5877       strip = FALSE;
5878
5879       if (strncmp (name, ".rel", 4) == 0)
5880         {
5881           if (s->size == 0)
5882             {
5883               /* We only strip the section if the output section name
5884                  has the same name.  Otherwise, there might be several
5885                  input sections for this output section.  FIXME: This
5886                  code is probably not needed these days anyhow, since
5887                  the linker now does not create empty output sections.  */
5888               if (s->output_section != NULL
5889                   && strcmp (name,
5890                              bfd_get_section_name (s->output_section->owner,
5891                                                    s->output_section)) == 0)
5892                 strip = TRUE;
5893             }
5894           else
5895             {
5896               const char *outname;
5897               asection *target;
5898
5899               /* If this relocation section applies to a read only
5900                  section, then we probably need a DT_TEXTREL entry.
5901                  If the relocation section is .rel.dyn, we always
5902                  assert a DT_TEXTREL entry rather than testing whether
5903                  there exists a relocation to a read only section or
5904                  not.  */
5905               outname = bfd_get_section_name (output_bfd,
5906                                               s->output_section);
5907               target = bfd_get_section_by_name (output_bfd, outname + 4);
5908               if ((target != NULL
5909                    && (target->flags & SEC_READONLY) != 0
5910                    && (target->flags & SEC_ALLOC) != 0)
5911                   || strcmp (outname, ".rel.dyn") == 0)
5912                 reltext = TRUE;
5913
5914               /* We use the reloc_count field as a counter if we need
5915                  to copy relocs into the output file.  */
5916               if (strcmp (name, ".rel.dyn") != 0)
5917                 s->reloc_count = 0;
5918
5919               /* If combreloc is enabled, elf_link_sort_relocs() will
5920                  sort relocations, but in a different way than we do,
5921                  and before we're done creating relocations.  Also, it
5922                  will move them around between input sections'
5923                  relocation's contents, so our sorting would be
5924                  broken, so don't let it run.  */
5925               info->combreloc = 0;
5926             }
5927         }
5928       else if (strncmp (name, ".got", 4) == 0)
5929         {
5930           /* _bfd_mips_elf_always_size_sections() has already done
5931              most of the work, but some symbols may have been mapped
5932              to versions that we must now resolve in the got_entries
5933              hash tables.  */
5934           struct mips_got_info *gg = mips_elf_got_info (dynobj, NULL);
5935           struct mips_got_info *g = gg;
5936           struct mips_elf_set_global_got_offset_arg set_got_offset_arg;
5937           unsigned int needed_relocs = 0;
5938
5939           if (gg->next)
5940             {
5941               set_got_offset_arg.value = MIPS_ELF_GOT_SIZE (output_bfd);
5942               set_got_offset_arg.info = info;
5943
5944               mips_elf_resolve_final_got_entries (gg);
5945               for (g = gg->next; g && g->next != gg; g = g->next)
5946                 {
5947                   unsigned int save_assign;
5948
5949                   mips_elf_resolve_final_got_entries (g);
5950
5951                   /* Assign offsets to global GOT entries.  */
5952                   save_assign = g->assigned_gotno;
5953                   g->assigned_gotno = g->local_gotno;
5954                   set_got_offset_arg.g = g;
5955                   set_got_offset_arg.needed_relocs = 0;
5956                   htab_traverse (g->got_entries,
5957                                  mips_elf_set_global_got_offset,
5958                                  &set_got_offset_arg);
5959                   needed_relocs += set_got_offset_arg.needed_relocs;
5960                   BFD_ASSERT (g->assigned_gotno - g->local_gotno
5961                               <= g->global_gotno);
5962
5963                   g->assigned_gotno = save_assign;
5964                   if (info->shared)
5965                     {
5966                       needed_relocs += g->local_gotno - g->assigned_gotno;
5967                       BFD_ASSERT (g->assigned_gotno == g->next->local_gotno
5968                                   + g->next->global_gotno
5969                                   + MIPS_RESERVED_GOTNO);
5970                     }
5971                 }
5972
5973               if (needed_relocs)
5974                 mips_elf_allocate_dynamic_relocations (dynobj, needed_relocs);
5975             }
5976         }
5977       else if (strcmp (name, MIPS_ELF_STUB_SECTION_NAME (output_bfd)) == 0)
5978         {
5979           /* IRIX rld assumes that the function stub isn't at the end
5980              of .text section. So put a dummy. XXX  */
5981           s->size += MIPS_FUNCTION_STUB_SIZE;
5982         }
5983       else if (! info->shared
5984                && ! mips_elf_hash_table (info)->use_rld_obj_head
5985                && strncmp (name, ".rld_map", 8) == 0)
5986         {
5987           /* We add a room for __rld_map. It will be filled in by the
5988              rtld to contain a pointer to the _r_debug structure.  */
5989           s->size += 4;
5990         }
5991       else if (SGI_COMPAT (output_bfd)
5992                && strncmp (name, ".compact_rel", 12) == 0)
5993         s->size += mips_elf_hash_table (info)->compact_rel_size;
5994       else if (strncmp (name, ".init", 5) != 0)
5995         {
5996           /* It's not one of our sections, so don't allocate space.  */
5997           continue;
5998         }
5999
6000       if (strip)
6001         {
6002           _bfd_strip_section_from_output (info, s);
6003           continue;
6004         }
6005
6006       /* Allocate memory for the section contents.  */
6007       s->contents = bfd_zalloc (dynobj, s->size);
6008       if (s->contents == NULL && s->size != 0)
6009         {
6010           bfd_set_error (bfd_error_no_memory);
6011           return FALSE;
6012         }
6013     }
6014
6015   if (elf_hash_table (info)->dynamic_sections_created)
6016     {
6017       /* Add some entries to the .dynamic section.  We fill in the
6018          values later, in _bfd_mips_elf_finish_dynamic_sections, but we
6019          must add the entries now so that we get the correct size for
6020          the .dynamic section.  The DT_DEBUG entry is filled in by the
6021          dynamic linker and used by the debugger.  */
6022       if (! info->shared)
6023         {
6024           /* SGI object has the equivalence of DT_DEBUG in the
6025              DT_MIPS_RLD_MAP entry.  */
6026           if (!MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_RLD_MAP, 0))
6027             return FALSE;
6028           if (!SGI_COMPAT (output_bfd))
6029             {
6030               if (!MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_DEBUG, 0))
6031                 return FALSE;
6032             }
6033         }
6034       else
6035         {
6036           /* Shared libraries on traditional mips have DT_DEBUG.  */
6037           if (!SGI_COMPAT (output_bfd))
6038             {
6039               if (!MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_DEBUG, 0))
6040                 return FALSE;
6041             }
6042         }
6043
6044       if (reltext && SGI_COMPAT (output_bfd))
6045         info->flags |= DF_TEXTREL;
6046
6047       if ((info->flags & DF_TEXTREL) != 0)
6048         {
6049           if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_TEXTREL, 0))
6050             return FALSE;
6051         }
6052
6053       if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_PLTGOT, 0))
6054         return FALSE;
6055
6056       if (mips_elf_rel_dyn_section (dynobj, FALSE))
6057         {
6058           if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_REL, 0))
6059             return FALSE;
6060
6061           if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_RELSZ, 0))
6062             return FALSE;
6063
6064           if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_RELENT, 0))
6065             return FALSE;
6066         }
6067
6068       if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_RLD_VERSION, 0))
6069         return FALSE;
6070
6071       if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_FLAGS, 0))
6072         return FALSE;
6073
6074 #if 0
6075       /* Time stamps in executable files are a bad idea.  */
6076       if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_TIME_STAMP, 0))
6077         return FALSE;
6078 #endif
6079
6080 #if 0 /* FIXME  */
6081       if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_ICHECKSUM, 0))
6082         return FALSE;
6083 #endif
6084
6085 #if 0 /* FIXME  */
6086       if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_IVERSION, 0))
6087         return FALSE;
6088 #endif
6089
6090       if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_BASE_ADDRESS, 0))
6091         return FALSE;
6092
6093       if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_LOCAL_GOTNO, 0))
6094         return FALSE;
6095
6096       if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_SYMTABNO, 0))
6097         return FALSE;
6098
6099       if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_UNREFEXTNO, 0))
6100         return FALSE;
6101
6102       if (! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_GOTSYM, 0))
6103         return FALSE;
6104
6105       if (IRIX_COMPAT (dynobj) == ict_irix5
6106           && ! MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_HIPAGENO, 0))
6107         return FALSE;
6108
6109       if (IRIX_COMPAT (dynobj) == ict_irix6
6110           && (bfd_get_section_by_name
6111               (dynobj, MIPS_ELF_OPTIONS_SECTION_NAME (dynobj)))
6112           && !MIPS_ELF_ADD_DYNAMIC_ENTRY (info, DT_MIPS_OPTIONS, 0))
6113         return FALSE;
6114     }
6115
6116   return TRUE;
6117 }
6118 \f
6119 /* Relocate a MIPS ELF section.  */
6120
6121 bfd_boolean
6122 _bfd_mips_elf_relocate_section (bfd *output_bfd, struct bfd_link_info *info,
6123                                 bfd *input_bfd, asection *input_section,
6124                                 bfd_byte *contents, Elf_Internal_Rela *relocs,
6125                                 Elf_Internal_Sym *local_syms,
6126                                 asection **local_sections)
6127 {
6128   Elf_Internal_Rela *rel;
6129   const Elf_Internal_Rela *relend;
6130   bfd_vma addend = 0;
6131   bfd_boolean use_saved_addend_p = FALSE;
6132   const struct elf_backend_data *bed;
6133
6134   bed = get_elf_backend_data (output_bfd);
6135   relend = relocs + input_section->reloc_count * bed->s->int_rels_per_ext_rel;
6136   for (rel = relocs; rel < relend; ++rel)
6137     {
6138       const char *name;
6139       bfd_vma value;
6140       reloc_howto_type *howto;
6141       bfd_boolean require_jalx;
6142       /* TRUE if the relocation is a RELA relocation, rather than a
6143          REL relocation.  */
6144       bfd_boolean rela_relocation_p = TRUE;
6145       unsigned int r_type = ELF_R_TYPE (output_bfd, rel->r_info);
6146       const char *msg;
6147
6148       /* Find the relocation howto for this relocation.  */
6149       if (r_type == R_MIPS_64 && ! NEWABI_P (input_bfd))
6150         {
6151           /* Some 32-bit code uses R_MIPS_64.  In particular, people use
6152              64-bit code, but make sure all their addresses are in the
6153              lowermost or uppermost 32-bit section of the 64-bit address
6154              space.  Thus, when they use an R_MIPS_64 they mean what is
6155              usually meant by R_MIPS_32, with the exception that the
6156              stored value is sign-extended to 64 bits.  */
6157           howto = MIPS_ELF_RTYPE_TO_HOWTO (input_bfd, R_MIPS_32, FALSE);
6158
6159           /* On big-endian systems, we need to lie about the position
6160              of the reloc.  */
6161           if (bfd_big_endian (input_bfd))
6162             rel->r_offset += 4;
6163         }
6164       else
6165         /* NewABI defaults to RELA relocations.  */
6166         howto = MIPS_ELF_RTYPE_TO_HOWTO (input_bfd, r_type,
6167                                          NEWABI_P (input_bfd)
6168                                          && (MIPS_RELOC_RELA_P
6169                                              (input_bfd, input_section,
6170                                               rel - relocs)));
6171
6172       if (!use_saved_addend_p)
6173         {
6174           Elf_Internal_Shdr *rel_hdr;
6175
6176           /* If these relocations were originally of the REL variety,
6177              we must pull the addend out of the field that will be
6178              relocated.  Otherwise, we simply use the contents of the
6179              RELA relocation.  To determine which flavor or relocation
6180              this is, we depend on the fact that the INPUT_SECTION's
6181              REL_HDR is read before its REL_HDR2.  */
6182           rel_hdr = &elf_section_data (input_section)->rel_hdr;
6183           if ((size_t) (rel - relocs)
6184               >= (NUM_SHDR_ENTRIES (rel_hdr) * bed->s->int_rels_per_ext_rel))
6185             rel_hdr = elf_section_data (input_section)->rel_hdr2;
6186           if (rel_hdr->sh_entsize == MIPS_ELF_REL_SIZE (input_bfd))
6187             {
6188               /* Note that this is a REL relocation.  */
6189               rela_relocation_p = FALSE;
6190
6191               /* Get the addend, which is stored in the input file.  */
6192               addend = mips_elf_obtain_contents (howto, rel, input_bfd,
6193                                                  contents);
6194               addend &= howto->src_mask;
6195
6196               /* For some kinds of relocations, the ADDEND is a
6197                  combination of the addend stored in two different
6198                  relocations.   */
6199               if (r_type == R_MIPS_HI16
6200                   || (r_type == R_MIPS_GOT16
6201                       && mips_elf_local_relocation_p (input_bfd, rel,
6202                                                       local_sections, FALSE)))
6203                 {
6204                   bfd_vma l;
6205                   const Elf_Internal_Rela *lo16_relocation;
6206                   reloc_howto_type *lo16_howto;
6207
6208                   /* The combined value is the sum of the HI16 addend,
6209                      left-shifted by sixteen bits, and the LO16
6210                      addend, sign extended.  (Usually, the code does
6211                      a `lui' of the HI16 value, and then an `addiu' of
6212                      the LO16 value.)
6213
6214                      Scan ahead to find a matching LO16 relocation.
6215
6216                      According to the MIPS ELF ABI, the R_MIPS_LO16
6217                      relocation must be immediately following.
6218                      However, for the IRIX6 ABI, the next relocation
6219                      may be a composed relocation consisting of
6220                      several relocations for the same address.  In
6221                      that case, the R_MIPS_LO16 relocation may occur
6222                      as one of these.  We permit a similar extension
6223                      in general, as that is useful for GCC.  */
6224                   lo16_relocation = mips_elf_next_relocation (input_bfd,
6225                                                               R_MIPS_LO16,
6226                                                               rel, relend);
6227                   if (lo16_relocation == NULL)
6228                     return FALSE;
6229
6230                   /* Obtain the addend kept there.  */
6231                   lo16_howto = MIPS_ELF_RTYPE_TO_HOWTO (input_bfd,
6232                                                         R_MIPS_LO16, FALSE);
6233                   l = mips_elf_obtain_contents (lo16_howto, lo16_relocation,
6234                                                 input_bfd, contents);
6235                   l &= lo16_howto->src_mask;
6236                   l <<= lo16_howto->rightshift;
6237                   l = _bfd_mips_elf_sign_extend (l, 16);
6238
6239                   addend <<= 16;
6240
6241                   /* Compute the combined addend.  */
6242                   addend += l;
6243                 }
6244               else if (r_type == R_MIPS16_GPREL)
6245                 {
6246                   /* The addend is scrambled in the object file.  See
6247                      mips_elf_perform_relocation for details on the
6248                      format.  */
6249                   addend = (((addend & 0x1f0000) >> 5)
6250                             | ((addend & 0x7e00000) >> 16)
6251                             | (addend & 0x1f));
6252                 }
6253               else
6254                 addend <<= howto->rightshift;
6255             }
6256           else
6257             addend = rel->r_addend;
6258         }
6259
6260       if (info->relocatable)
6261         {
6262           Elf_Internal_Sym *sym;
6263           unsigned long r_symndx;
6264
6265           if (r_type == R_MIPS_64 && ! NEWABI_P (output_bfd)
6266               && bfd_big_endian (input_bfd))
6267             rel->r_offset -= 4;
6268
6269           /* Since we're just relocating, all we need to do is copy
6270              the relocations back out to the object file, unless
6271              they're against a section symbol, in which case we need
6272              to adjust by the section offset, or unless they're GP
6273              relative in which case we need to adjust by the amount
6274              that we're adjusting GP in this relocatable object.  */
6275
6276           if (! mips_elf_local_relocation_p (input_bfd, rel, local_sections,
6277                                              FALSE))
6278             /* There's nothing to do for non-local relocations.  */
6279             continue;
6280
6281           if (r_type == R_MIPS16_GPREL
6282               || r_type == R_MIPS_GPREL16
6283               || r_type == R_MIPS_GPREL32
6284               || r_type == R_MIPS_LITERAL)
6285             addend -= (_bfd_get_gp_value (output_bfd)
6286                        - _bfd_get_gp_value (input_bfd));
6287
6288           r_symndx = ELF_R_SYM (output_bfd, rel->r_info);
6289           sym = local_syms + r_symndx;
6290           if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
6291             /* Adjust the addend appropriately.  */
6292             addend += local_sections[r_symndx]->output_offset;
6293
6294           if (rela_relocation_p)
6295             /* If this is a RELA relocation, just update the addend.  */
6296             rel->r_addend = addend;
6297           else
6298             {
6299               if (r_type == R_MIPS_HI16
6300                   || r_type == R_MIPS_GOT16)
6301                 addend = mips_elf_high (addend);
6302               else if (r_type == R_MIPS_HIGHER)
6303                 addend = mips_elf_higher (addend);
6304               else if (r_type == R_MIPS_HIGHEST)
6305                 addend = mips_elf_highest (addend);
6306               else
6307                 addend >>= howto->rightshift;
6308
6309               /* We use the source mask, rather than the destination
6310                  mask because the place to which we are writing will be
6311                  source of the addend in the final link.  */
6312               addend &= howto->src_mask;
6313
6314               if (r_type == R_MIPS_64 && ! NEWABI_P (output_bfd))
6315                 /* See the comment above about using R_MIPS_64 in the 32-bit
6316                    ABI.  Here, we need to update the addend.  It would be
6317                    possible to get away with just using the R_MIPS_32 reloc
6318                    but for endianness.  */
6319                 {
6320                   bfd_vma sign_bits;
6321                   bfd_vma low_bits;
6322                   bfd_vma high_bits;
6323
6324                   if (addend & ((bfd_vma) 1 << 31))
6325 #ifdef BFD64
6326                     sign_bits = ((bfd_vma) 1 << 32) - 1;
6327 #else
6328                     sign_bits = -1;
6329 #endif
6330                   else
6331                     sign_bits = 0;
6332
6333                   /* If we don't know that we have a 64-bit type,
6334                      do two separate stores.  */
6335                   if (bfd_big_endian (input_bfd))
6336                     {
6337                       /* Store the sign-bits (which are most significant)
6338                          first.  */
6339                       low_bits = sign_bits;
6340                       high_bits = addend;
6341                     }
6342                   else
6343                     {
6344                       low_bits = addend;
6345                       high_bits = sign_bits;
6346                     }
6347                   bfd_put_32 (input_bfd, low_bits,
6348                               contents + rel->r_offset);
6349                   bfd_put_32 (input_bfd, high_bits,
6350                               contents + rel->r_offset + 4);
6351                   continue;
6352                 }
6353
6354               if (! mips_elf_perform_relocation (info, howto, rel, addend,
6355                                                  input_bfd, input_section,
6356                                                  contents, FALSE))
6357                 return FALSE;
6358             }
6359
6360           /* Go on to the next relocation.  */
6361           continue;
6362         }
6363
6364       /* In the N32 and 64-bit ABIs there may be multiple consecutive
6365          relocations for the same offset.  In that case we are
6366          supposed to treat the output of each relocation as the addend
6367          for the next.  */
6368       if (rel + 1 < relend
6369           && rel->r_offset == rel[1].r_offset
6370           && ELF_R_TYPE (input_bfd, rel[1].r_info) != R_MIPS_NONE)
6371         use_saved_addend_p = TRUE;
6372       else
6373         use_saved_addend_p = FALSE;
6374
6375       /* Figure out what value we are supposed to relocate.  */
6376       switch (mips_elf_calculate_relocation (output_bfd, input_bfd,
6377                                              input_section, info, rel,
6378                                              addend, howto, local_syms,
6379                                              local_sections, &value,
6380                                              &name, &require_jalx,
6381                                              use_saved_addend_p))
6382         {
6383         case bfd_reloc_continue:
6384           /* There's nothing to do.  */
6385           continue;
6386
6387         case bfd_reloc_undefined:
6388           /* mips_elf_calculate_relocation already called the
6389              undefined_symbol callback.  There's no real point in
6390              trying to perform the relocation at this point, so we
6391              just skip ahead to the next relocation.  */
6392           continue;
6393
6394         case bfd_reloc_notsupported:
6395           msg = _("internal error: unsupported relocation error");
6396           info->callbacks->warning
6397             (info, msg, name, input_bfd, input_section, rel->r_offset);
6398           return FALSE;
6399
6400         case bfd_reloc_overflow:
6401           if (use_saved_addend_p)
6402             /* Ignore overflow until we reach the last relocation for
6403                a given location.  */
6404             ;
6405           else
6406             {
6407               BFD_ASSERT (name != NULL);
6408               if (! ((*info->callbacks->reloc_overflow)
6409                      (info, NULL, name, howto->name, (bfd_vma) 0,
6410                       input_bfd, input_section, rel->r_offset)))
6411                 return FALSE;
6412             }
6413           break;
6414
6415         case bfd_reloc_ok:
6416           break;
6417
6418         default:
6419           abort ();
6420           break;
6421         }
6422
6423       /* If we've got another relocation for the address, keep going
6424          until we reach the last one.  */
6425       if (use_saved_addend_p)
6426         {
6427           addend = value;
6428           continue;
6429         }
6430
6431       if (r_type == R_MIPS_64 && ! NEWABI_P (output_bfd))
6432         /* See the comment above about using R_MIPS_64 in the 32-bit
6433            ABI.  Until now, we've been using the HOWTO for R_MIPS_32;
6434            that calculated the right value.  Now, however, we
6435            sign-extend the 32-bit result to 64-bits, and store it as a
6436            64-bit value.  We are especially generous here in that we
6437            go to extreme lengths to support this usage on systems with
6438            only a 32-bit VMA.  */
6439         {
6440           bfd_vma sign_bits;
6441           bfd_vma low_bits;
6442           bfd_vma high_bits;
6443
6444           if (value & ((bfd_vma) 1 << 31))
6445 #ifdef BFD64
6446             sign_bits = ((bfd_vma) 1 << 32) - 1;
6447 #else
6448             sign_bits = -1;
6449 #endif
6450           else
6451             sign_bits = 0;
6452
6453           /* If we don't know that we have a 64-bit type,
6454              do two separate stores.  */
6455           if (bfd_big_endian (input_bfd))
6456             {
6457               /* Undo what we did above.  */
6458               rel->r_offset -= 4;
6459               /* Store the sign-bits (which are most significant)
6460                  first.  */
6461               low_bits = sign_bits;
6462               high_bits = value;
6463             }
6464           else
6465             {
6466               low_bits = value;
6467               high_bits = sign_bits;
6468             }
6469           bfd_put_32 (input_bfd, low_bits,
6470                       contents + rel->r_offset);
6471           bfd_put_32 (input_bfd, high_bits,
6472                       contents + rel->r_offset + 4);
6473           continue;
6474         }
6475
6476       /* Actually perform the relocation.  */
6477       if (! mips_elf_perform_relocation (info, howto, rel, value,
6478                                          input_bfd, input_section,
6479                                          contents, require_jalx))
6480         return FALSE;
6481     }
6482
6483   return TRUE;
6484 }
6485 \f
6486 /* If NAME is one of the special IRIX6 symbols defined by the linker,
6487    adjust it appropriately now.  */
6488
6489 static void
6490 mips_elf_irix6_finish_dynamic_symbol (bfd *abfd ATTRIBUTE_UNUSED,
6491                                       const char *name, Elf_Internal_Sym *sym)
6492 {
6493   /* The linker script takes care of providing names and values for
6494      these, but we must place them into the right sections.  */
6495   static const char* const text_section_symbols[] = {
6496     "_ftext",
6497     "_etext",
6498     "__dso_displacement",
6499     "__elf_header",
6500     "__program_header_table",
6501     NULL
6502   };
6503
6504   static const char* const data_section_symbols[] = {
6505     "_fdata",
6506     "_edata",
6507     "_end",
6508     "_fbss",
6509     NULL
6510   };
6511
6512   const char* const *p;
6513   int i;
6514
6515   for (i = 0; i < 2; ++i)
6516     for (p = (i == 0) ? text_section_symbols : data_section_symbols;
6517          *p;
6518          ++p)
6519       if (strcmp (*p, name) == 0)
6520         {
6521           /* All of these symbols are given type STT_SECTION by the
6522              IRIX6 linker.  */
6523           sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
6524           sym->st_other = STO_PROTECTED;
6525
6526           /* The IRIX linker puts these symbols in special sections.  */
6527           if (i == 0)
6528             sym->st_shndx = SHN_MIPS_TEXT;
6529           else
6530             sym->st_shndx = SHN_MIPS_DATA;
6531
6532           break;
6533         }
6534 }
6535
6536 /* Finish up dynamic symbol handling.  We set the contents of various
6537    dynamic sections here.  */
6538
6539 bfd_boolean
6540 _bfd_mips_elf_finish_dynamic_symbol (bfd *output_bfd,
6541                                      struct bfd_link_info *info,
6542                                      struct elf_link_hash_entry *h,
6543                                      Elf_Internal_Sym *sym)
6544 {
6545   bfd *dynobj;
6546   asection *sgot;
6547   struct mips_got_info *g, *gg;
6548   const char *name;
6549
6550   dynobj = elf_hash_table (info)->dynobj;
6551
6552   if (h->plt.offset != MINUS_ONE)
6553     {
6554       asection *s;
6555       bfd_byte stub[MIPS_FUNCTION_STUB_SIZE];
6556
6557       /* This symbol has a stub.  Set it up.  */
6558
6559       BFD_ASSERT (h->dynindx != -1);
6560
6561       s = bfd_get_section_by_name (dynobj,
6562                                    MIPS_ELF_STUB_SECTION_NAME (dynobj));
6563       BFD_ASSERT (s != NULL);
6564
6565       /* FIXME: Can h->dynindex be more than 64K?  */
6566       if (h->dynindx & 0xffff0000)
6567         return FALSE;
6568
6569       /* Fill the stub.  */
6570       bfd_put_32 (output_bfd, STUB_LW (output_bfd), stub);
6571       bfd_put_32 (output_bfd, STUB_MOVE (output_bfd), stub + 4);
6572       bfd_put_32 (output_bfd, STUB_JALR, stub + 8);
6573       bfd_put_32 (output_bfd, STUB_LI16 (output_bfd) + h->dynindx, stub + 12);
6574
6575       BFD_ASSERT (h->plt.offset <= s->size);
6576       memcpy (s->contents + h->plt.offset, stub, MIPS_FUNCTION_STUB_SIZE);
6577
6578       /* Mark the symbol as undefined.  plt.offset != -1 occurs
6579          only for the referenced symbol.  */
6580       sym->st_shndx = SHN_UNDEF;
6581
6582       /* The run-time linker uses the st_value field of the symbol
6583          to reset the global offset table entry for this external
6584          to its stub address when unlinking a shared object.  */
6585       sym->st_value = (s->output_section->vma + s->output_offset
6586                        + h->plt.offset);
6587     }
6588
6589   BFD_ASSERT (h->dynindx != -1
6590               || h->forced_local);
6591
6592   sgot = mips_elf_got_section (dynobj, FALSE);
6593   BFD_ASSERT (sgot != NULL);
6594   BFD_ASSERT (mips_elf_section_data (sgot) != NULL);
6595   g = mips_elf_section_data (sgot)->u.got_info;
6596   BFD_ASSERT (g != NULL);
6597
6598   /* Run through the global symbol table, creating GOT entries for all
6599      the symbols that need them.  */
6600   if (g->global_gotsym != NULL
6601       && h->dynindx >= g->global_gotsym->dynindx)
6602     {
6603       bfd_vma offset;
6604       bfd_vma value;
6605
6606       value = sym->st_value;
6607       offset = mips_elf_global_got_index (dynobj, output_bfd, h);
6608       MIPS_ELF_PUT_WORD (output_bfd, value, sgot->contents + offset);
6609     }
6610
6611   if (g->next && h->dynindx != -1)
6612     {
6613       struct mips_got_entry e, *p;
6614       bfd_vma entry;
6615       bfd_vma offset;
6616
6617       gg = g;
6618
6619       e.abfd = output_bfd;
6620       e.symndx = -1;
6621       e.d.h = (struct mips_elf_link_hash_entry *)h;
6622
6623       for (g = g->next; g->next != gg; g = g->next)
6624         {
6625           if (g->got_entries
6626               && (p = (struct mips_got_entry *) htab_find (g->got_entries,
6627                                                            &e)))
6628             {
6629               offset = p->gotidx;
6630               if (info->shared
6631                   || (elf_hash_table (info)->dynamic_sections_created
6632                       && p->d.h != NULL
6633                       && p->d.h->root.def_dynamic
6634                       && !p->d.h->root.def_regular))
6635                 {
6636                   /* Create an R_MIPS_REL32 relocation for this entry.  Due to
6637                      the various compatibility problems, it's easier to mock
6638                      up an R_MIPS_32 or R_MIPS_64 relocation and leave
6639                      mips_elf_create_dynamic_relocation to calculate the
6640                      appropriate addend.  */
6641                   Elf_Internal_Rela rel[3];
6642
6643                   memset (rel, 0, sizeof (rel));
6644                   if (ABI_64_P (output_bfd))
6645                     rel[0].r_info = ELF_R_INFO (output_bfd, 0, R_MIPS_64);
6646                   else
6647                     rel[0].r_info = ELF_R_INFO (output_bfd, 0, R_MIPS_32);
6648                   rel[0].r_offset = rel[1].r_offset = rel[2].r_offset = offset;
6649
6650                   entry = 0;
6651                   if (! (mips_elf_create_dynamic_relocation
6652                          (output_bfd, info, rel,
6653                           e.d.h, NULL, sym->st_value, &entry, sgot)))
6654                     return FALSE;
6655                 }
6656               else
6657                 entry = sym->st_value;
6658               MIPS_ELF_PUT_WORD (output_bfd, entry, sgot->contents + offset);
6659             }
6660         }
6661     }
6662
6663   /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute.  */
6664   name = h->root.root.string;
6665   if (strcmp (name, "_DYNAMIC") == 0
6666       || strcmp (name, "_GLOBAL_OFFSET_TABLE_") == 0)
6667     sym->st_shndx = SHN_ABS;
6668   else if (strcmp (name, "_DYNAMIC_LINK") == 0
6669            || strcmp (name, "_DYNAMIC_LINKING") == 0)
6670     {
6671       sym->st_shndx = SHN_ABS;
6672       sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
6673       sym->st_value = 1;
6674     }
6675   else if (strcmp (name, "_gp_disp") == 0 && ! NEWABI_P (output_bfd))
6676     {
6677       sym->st_shndx = SHN_ABS;
6678       sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
6679       sym->st_value = elf_gp (output_bfd);
6680     }
6681   else if (SGI_COMPAT (output_bfd))
6682     {
6683       if (strcmp (name, mips_elf_dynsym_rtproc_names[0]) == 0
6684           || strcmp (name, mips_elf_dynsym_rtproc_names[1]) == 0)
6685         {
6686           sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
6687           sym->st_other = STO_PROTECTED;
6688           sym->st_value = 0;
6689           sym->st_shndx = SHN_MIPS_DATA;
6690         }
6691       else if (strcmp (name, mips_elf_dynsym_rtproc_names[2]) == 0)
6692         {
6693           sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
6694           sym->st_other = STO_PROTECTED;
6695           sym->st_value = mips_elf_hash_table (info)->procedure_count;
6696           sym->st_shndx = SHN_ABS;
6697         }
6698       else if (sym->st_shndx != SHN_UNDEF && sym->st_shndx != SHN_ABS)
6699         {
6700           if (h->type == STT_FUNC)
6701             sym->st_shndx = SHN_MIPS_TEXT;
6702           else if (h->type == STT_OBJECT)
6703             sym->st_shndx = SHN_MIPS_DATA;
6704         }
6705     }
6706
6707   /* Handle the IRIX6-specific symbols.  */
6708   if (IRIX_COMPAT (output_bfd) == ict_irix6)
6709     mips_elf_irix6_finish_dynamic_symbol (output_bfd, name, sym);
6710
6711   if (! info->shared)
6712     {
6713       if (! mips_elf_hash_table (info)->use_rld_obj_head
6714           && (strcmp (name, "__rld_map") == 0
6715               || strcmp (name, "__RLD_MAP") == 0))
6716         {
6717           asection *s = bfd_get_section_by_name (dynobj, ".rld_map");
6718           BFD_ASSERT (s != NULL);
6719           sym->st_value = s->output_section->vma + s->output_offset;
6720           bfd_put_32 (output_bfd, 0, s->contents);
6721           if (mips_elf_hash_table (info)->rld_value == 0)
6722             mips_elf_hash_table (info)->rld_value = sym->st_value;
6723         }
6724       else if (mips_elf_hash_table (info)->use_rld_obj_head
6725                && strcmp (name, "__rld_obj_head") == 0)
6726         {
6727           /* IRIX6 does not use a .rld_map section.  */
6728           if (IRIX_COMPAT (output_bfd) == ict_irix5
6729               || IRIX_COMPAT (output_bfd) == ict_none)
6730             BFD_ASSERT (bfd_get_section_by_name (dynobj, ".rld_map")
6731                         != NULL);
6732           mips_elf_hash_table (info)->rld_value = sym->st_value;
6733         }
6734     }
6735
6736   /* If this is a mips16 symbol, force the value to be even.  */
6737   if (sym->st_other == STO_MIPS16)
6738     sym->st_value &= ~1;
6739
6740   return TRUE;
6741 }
6742
6743 /* Finish up the dynamic sections.  */
6744
6745 bfd_boolean
6746 _bfd_mips_elf_finish_dynamic_sections (bfd *output_bfd,
6747                                        struct bfd_link_info *info)
6748 {
6749   bfd *dynobj;
6750   asection *sdyn;
6751   asection *sgot;
6752   struct mips_got_info *gg, *g;
6753
6754   dynobj = elf_hash_table (info)->dynobj;
6755
6756   sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
6757
6758   sgot = mips_elf_got_section (dynobj, FALSE);
6759   if (sgot == NULL)
6760     gg = g = NULL;
6761   else
6762     {
6763       BFD_ASSERT (mips_elf_section_data (sgot) != NULL);
6764       gg = mips_elf_section_data (sgot)->u.got_info;
6765       BFD_ASSERT (gg != NULL);
6766       g = mips_elf_got_for_ibfd (gg, output_bfd);
6767       BFD_ASSERT (g != NULL);
6768     }
6769
6770   if (elf_hash_table (info)->dynamic_sections_created)
6771     {
6772       bfd_byte *b;
6773
6774       BFD_ASSERT (sdyn != NULL);
6775       BFD_ASSERT (g != NULL);
6776
6777       for (b = sdyn->contents;
6778            b < sdyn->contents + sdyn->size;
6779            b += MIPS_ELF_DYN_SIZE (dynobj))
6780         {
6781           Elf_Internal_Dyn dyn;
6782           const char *name;
6783           size_t elemsize;
6784           asection *s;
6785           bfd_boolean swap_out_p;
6786
6787           /* Read in the current dynamic entry.  */
6788           (*get_elf_backend_data (dynobj)->s->swap_dyn_in) (dynobj, b, &dyn);
6789
6790           /* Assume that we're going to modify it and write it out.  */
6791           swap_out_p = TRUE;
6792
6793           switch (dyn.d_tag)
6794             {
6795             case DT_RELENT:
6796               s = mips_elf_rel_dyn_section (dynobj, FALSE);
6797               BFD_ASSERT (s != NULL);
6798               dyn.d_un.d_val = MIPS_ELF_REL_SIZE (dynobj);
6799               break;
6800
6801             case DT_STRSZ:
6802               /* Rewrite DT_STRSZ.  */
6803               dyn.d_un.d_val =
6804                 _bfd_elf_strtab_size (elf_hash_table (info)->dynstr);
6805               break;
6806
6807             case DT_PLTGOT:
6808               name = ".got";
6809               s = bfd_get_section_by_name (output_bfd, name);
6810               BFD_ASSERT (s != NULL);
6811               dyn.d_un.d_ptr = s->vma;
6812               break;
6813
6814             case DT_MIPS_RLD_VERSION:
6815               dyn.d_un.d_val = 1; /* XXX */
6816               break;
6817
6818             case DT_MIPS_FLAGS:
6819               dyn.d_un.d_val = RHF_NOTPOT; /* XXX */
6820               break;
6821
6822             case DT_MIPS_TIME_STAMP:
6823               time ((time_t *) &dyn.d_un.d_val);
6824               break;
6825
6826             case DT_MIPS_ICHECKSUM:
6827               /* XXX FIXME: */
6828               swap_out_p = FALSE;
6829               break;
6830
6831             case DT_MIPS_IVERSION:
6832               /* XXX FIXME: */
6833               swap_out_p = FALSE;
6834               break;
6835
6836             case DT_MIPS_BASE_ADDRESS:
6837               s = output_bfd->sections;
6838               BFD_ASSERT (s != NULL);
6839               dyn.d_un.d_ptr = s->vma & ~(bfd_vma) 0xffff;
6840               break;
6841
6842             case DT_MIPS_LOCAL_GOTNO:
6843               dyn.d_un.d_val = g->local_gotno;
6844               break;
6845
6846             case DT_MIPS_UNREFEXTNO:
6847               /* The index into the dynamic symbol table which is the
6848                  entry of the first external symbol that is not
6849                  referenced within the same object.  */
6850               dyn.d_un.d_val = bfd_count_sections (output_bfd) + 1;
6851               break;
6852
6853             case DT_MIPS_GOTSYM:
6854               if (gg->global_gotsym)
6855                 {
6856                   dyn.d_un.d_val = gg->global_gotsym->dynindx;
6857                   break;
6858                 }
6859               /* In case if we don't have global got symbols we default
6860                  to setting DT_MIPS_GOTSYM to the same value as
6861                  DT_MIPS_SYMTABNO, so we just fall through.  */
6862
6863             case DT_MIPS_SYMTABNO:
6864               name = ".dynsym";
6865               elemsize = MIPS_ELF_SYM_SIZE (output_bfd);
6866               s = bfd_get_section_by_name (output_bfd, name);
6867               BFD_ASSERT (s != NULL);
6868
6869               dyn.d_un.d_val = s->size / elemsize;
6870               break;
6871
6872             case DT_MIPS_HIPAGENO:
6873               dyn.d_un.d_val = g->local_gotno - MIPS_RESERVED_GOTNO;
6874               break;
6875
6876             case DT_MIPS_RLD_MAP:
6877               dyn.d_un.d_ptr = mips_elf_hash_table (info)->rld_value;
6878               break;
6879
6880             case DT_MIPS_OPTIONS:
6881               s = (bfd_get_section_by_name
6882                    (output_bfd, MIPS_ELF_OPTIONS_SECTION_NAME (output_bfd)));
6883               dyn.d_un.d_ptr = s->vma;
6884               break;
6885
6886             case DT_RELSZ:
6887               /* Reduce DT_RELSZ to account for any relocations we
6888                  decided not to make.  This is for the n64 irix rld,
6889                  which doesn't seem to apply any relocations if there
6890                  are trailing null entries.  */
6891               s = mips_elf_rel_dyn_section (dynobj, FALSE);
6892               dyn.d_un.d_val = (s->reloc_count
6893                                 * (ABI_64_P (output_bfd)
6894                                    ? sizeof (Elf64_Mips_External_Rel)
6895                                    : sizeof (Elf32_External_Rel)));
6896               break;
6897
6898             default:
6899               swap_out_p = FALSE;
6900               break;
6901             }
6902
6903           if (swap_out_p)
6904             (*get_elf_backend_data (dynobj)->s->swap_dyn_out)
6905               (dynobj, &dyn, b);
6906         }
6907     }
6908
6909   /* The first entry of the global offset table will be filled at
6910      runtime. The second entry will be used by some runtime loaders.
6911      This isn't the case of IRIX rld.  */
6912   if (sgot != NULL && sgot->size > 0)
6913     {
6914       MIPS_ELF_PUT_WORD (output_bfd, 0, sgot->contents);
6915       MIPS_ELF_PUT_WORD (output_bfd, 0x80000000,
6916                          sgot->contents + MIPS_ELF_GOT_SIZE (output_bfd));
6917     }
6918
6919   if (sgot != NULL)
6920     elf_section_data (sgot->output_section)->this_hdr.sh_entsize
6921       = MIPS_ELF_GOT_SIZE (output_bfd);
6922
6923   /* Generate dynamic relocations for the non-primary gots.  */
6924   if (gg != NULL && gg->next)
6925     {
6926       Elf_Internal_Rela rel[3];
6927       bfd_vma addend = 0;
6928
6929       memset (rel, 0, sizeof (rel));
6930       rel[0].r_info = ELF_R_INFO (output_bfd, 0, R_MIPS_REL32);
6931
6932       for (g = gg->next; g->next != gg; g = g->next)
6933         {
6934           bfd_vma index = g->next->local_gotno + g->next->global_gotno;
6935
6936           MIPS_ELF_PUT_WORD (output_bfd, 0, sgot->contents
6937                              + index++ * MIPS_ELF_GOT_SIZE (output_bfd));
6938           MIPS_ELF_PUT_WORD (output_bfd, 0x80000000, sgot->contents
6939                              + index++ * MIPS_ELF_GOT_SIZE (output_bfd));
6940
6941           if (! info->shared)
6942             continue;
6943
6944           while (index < g->assigned_gotno)
6945             {
6946               rel[0].r_offset = rel[1].r_offset = rel[2].r_offset
6947                 = index++ * MIPS_ELF_GOT_SIZE (output_bfd);
6948               if (!(mips_elf_create_dynamic_relocation
6949                     (output_bfd, info, rel, NULL,
6950                      bfd_abs_section_ptr,
6951                      0, &addend, sgot)))
6952                 return FALSE;
6953               BFD_ASSERT (addend == 0);
6954             }
6955         }
6956     }
6957
6958   {
6959     asection *s;
6960     Elf32_compact_rel cpt;
6961
6962     if (SGI_COMPAT (output_bfd))
6963       {
6964         /* Write .compact_rel section out.  */
6965         s = bfd_get_section_by_name (dynobj, ".compact_rel");
6966         if (s != NULL)
6967           {
6968             cpt.id1 = 1;
6969             cpt.num = s->reloc_count;
6970             cpt.id2 = 2;
6971             cpt.offset = (s->output_section->filepos
6972                           + sizeof (Elf32_External_compact_rel));
6973             cpt.reserved0 = 0;
6974             cpt.reserved1 = 0;
6975             bfd_elf32_swap_compact_rel_out (output_bfd, &cpt,
6976                                             ((Elf32_External_compact_rel *)
6977                                              s->contents));
6978
6979             /* Clean up a dummy stub function entry in .text.  */
6980             s = bfd_get_section_by_name (dynobj,
6981                                          MIPS_ELF_STUB_SECTION_NAME (dynobj));
6982             if (s != NULL)
6983               {
6984                 file_ptr dummy_offset;
6985
6986                 BFD_ASSERT (s->size >= MIPS_FUNCTION_STUB_SIZE);
6987                 dummy_offset = s->size - MIPS_FUNCTION_STUB_SIZE;
6988                 memset (s->contents + dummy_offset, 0,
6989                         MIPS_FUNCTION_STUB_SIZE);
6990               }
6991           }
6992       }
6993
6994     /* We need to sort the entries of the dynamic relocation section.  */
6995
6996     s = mips_elf_rel_dyn_section (dynobj, FALSE);
6997
6998     if (s != NULL
6999         && s->size > (bfd_vma)2 * MIPS_ELF_REL_SIZE (output_bfd))
7000       {
7001         reldyn_sorting_bfd = output_bfd;
7002
7003         if (ABI_64_P (output_bfd))
7004           qsort ((Elf64_External_Rel *) s->contents + 1, s->reloc_count - 1,
7005                  sizeof (Elf64_Mips_External_Rel), sort_dynamic_relocs_64);
7006         else
7007           qsort ((Elf32_External_Rel *) s->contents + 1, s->reloc_count - 1,
7008                  sizeof (Elf32_External_Rel), sort_dynamic_relocs);
7009       }
7010   }
7011
7012   return TRUE;
7013 }
7014
7015
7016 /* Set ABFD's EF_MIPS_ARCH and EF_MIPS_MACH flags.  */
7017
7018 static void
7019 mips_set_isa_flags (bfd *abfd)
7020 {
7021   flagword val;
7022
7023   switch (bfd_get_mach (abfd))
7024     {
7025     default:
7026     case bfd_mach_mips3000:
7027       val = E_MIPS_ARCH_1;
7028       break;
7029
7030     case bfd_mach_mips3900:
7031       val = E_MIPS_ARCH_1 | E_MIPS_MACH_3900;
7032       break;
7033
7034     case bfd_mach_mips6000:
7035       val = E_MIPS_ARCH_2;
7036       break;
7037
7038     case bfd_mach_mips4000:
7039     case bfd_mach_mips4300:
7040     case bfd_mach_mips4400:
7041     case bfd_mach_mips4600:
7042       val = E_MIPS_ARCH_3;
7043       break;
7044
7045     case bfd_mach_mips4010:
7046       val = E_MIPS_ARCH_3 | E_MIPS_MACH_4010;
7047       break;
7048
7049     case bfd_mach_mips4100:
7050       val = E_MIPS_ARCH_3 | E_MIPS_MACH_4100;
7051       break;
7052
7053     case bfd_mach_mips4111:
7054       val = E_MIPS_ARCH_3 | E_MIPS_MACH_4111;
7055       break;
7056
7057     case bfd_mach_mips4120:
7058       val = E_MIPS_ARCH_3 | E_MIPS_MACH_4120;
7059       break;
7060
7061     case bfd_mach_mips4650:
7062       val = E_MIPS_ARCH_3 | E_MIPS_MACH_4650;
7063       break;
7064
7065     case bfd_mach_mips5400:
7066       val = E_MIPS_ARCH_4 | E_MIPS_MACH_5400;
7067       break;
7068
7069     case bfd_mach_mips5500:
7070       val = E_MIPS_ARCH_4 | E_MIPS_MACH_5500;
7071       break;
7072
7073     case bfd_mach_mips5000:
7074     case bfd_mach_mips7000:
7075     case bfd_mach_mips8000:
7076     case bfd_mach_mips10000:
7077     case bfd_mach_mips12000:
7078       val = E_MIPS_ARCH_4;
7079       break;
7080
7081     case bfd_mach_mips5:
7082       val = E_MIPS_ARCH_5;
7083       break;
7084
7085     case bfd_mach_mips_sb1:
7086       val = E_MIPS_ARCH_64 | E_MIPS_MACH_SB1;
7087       break;
7088
7089     case bfd_mach_mipsisa32:
7090       val = E_MIPS_ARCH_32;
7091       break;
7092
7093     case bfd_mach_mipsisa64:
7094       val = E_MIPS_ARCH_64;
7095       break;
7096
7097     case bfd_mach_mipsisa32r2:
7098       val = E_MIPS_ARCH_32R2;
7099       break;
7100
7101     case bfd_mach_mipsisa64r2:
7102       val = E_MIPS_ARCH_64R2;
7103       break;
7104     }
7105   elf_elfheader (abfd)->e_flags &= ~(EF_MIPS_ARCH | EF_MIPS_MACH);
7106   elf_elfheader (abfd)->e_flags |= val;
7107
7108 }
7109
7110
7111 /* The final processing done just before writing out a MIPS ELF object
7112    file.  This gets the MIPS architecture right based on the machine
7113    number.  This is used by both the 32-bit and the 64-bit ABI.  */
7114
7115 void
7116 _bfd_mips_elf_final_write_processing (bfd *abfd,
7117                                       bfd_boolean linker ATTRIBUTE_UNUSED)
7118 {
7119   unsigned int i;
7120   Elf_Internal_Shdr **hdrpp;
7121   const char *name;
7122   asection *sec;
7123
7124   /* Keep the existing EF_MIPS_MACH and EF_MIPS_ARCH flags if the former
7125      is nonzero.  This is for compatibility with old objects, which used
7126      a combination of a 32-bit EF_MIPS_ARCH and a 64-bit EF_MIPS_MACH.  */
7127   if ((elf_elfheader (abfd)->e_flags & EF_MIPS_MACH) == 0)
7128     mips_set_isa_flags (abfd);
7129
7130   /* Set the sh_info field for .gptab sections and other appropriate
7131      info for each special section.  */
7132   for (i = 1, hdrpp = elf_elfsections (abfd) + 1;
7133        i < elf_numsections (abfd);
7134        i++, hdrpp++)
7135     {
7136       switch ((*hdrpp)->sh_type)
7137         {
7138         case SHT_MIPS_MSYM:
7139         case SHT_MIPS_LIBLIST:
7140           sec = bfd_get_section_by_name (abfd, ".dynstr");
7141           if (sec != NULL)
7142             (*hdrpp)->sh_link = elf_section_data (sec)->this_idx;
7143           break;
7144
7145         case SHT_MIPS_GPTAB:
7146           BFD_ASSERT ((*hdrpp)->bfd_section != NULL);
7147           name = bfd_get_section_name (abfd, (*hdrpp)->bfd_section);
7148           BFD_ASSERT (name != NULL
7149                       && strncmp (name, ".gptab.", sizeof ".gptab." - 1) == 0);
7150           sec = bfd_get_section_by_name (abfd, name + sizeof ".gptab" - 1);
7151           BFD_ASSERT (sec != NULL);
7152           (*hdrpp)->sh_info = elf_section_data (sec)->this_idx;
7153           break;
7154
7155         case SHT_MIPS_CONTENT:
7156           BFD_ASSERT ((*hdrpp)->bfd_section != NULL);
7157           name = bfd_get_section_name (abfd, (*hdrpp)->bfd_section);
7158           BFD_ASSERT (name != NULL
7159                       && strncmp (name, ".MIPS.content",
7160                                   sizeof ".MIPS.content" - 1) == 0);
7161           sec = bfd_get_section_by_name (abfd,
7162                                          name + sizeof ".MIPS.content" - 1);
7163           BFD_ASSERT (sec != NULL);
7164           (*hdrpp)->sh_link = elf_section_data (sec)->this_idx;
7165           break;
7166
7167         case SHT_MIPS_SYMBOL_LIB:
7168           sec = bfd_get_section_by_name (abfd, ".dynsym");
7169           if (sec != NULL)
7170             (*hdrpp)->sh_link = elf_section_data (sec)->this_idx;
7171           sec = bfd_get_section_by_name (abfd, ".liblist");
7172           if (sec != NULL)
7173             (*hdrpp)->sh_info = elf_section_data (sec)->this_idx;
7174           break;
7175
7176         case SHT_MIPS_EVENTS:
7177           BFD_ASSERT ((*hdrpp)->bfd_section != NULL);
7178           name = bfd_get_section_name (abfd, (*hdrpp)->bfd_section);
7179           BFD_ASSERT (name != NULL);
7180           if (strncmp (name, ".MIPS.events", sizeof ".MIPS.events" - 1) == 0)
7181             sec = bfd_get_section_by_name (abfd,
7182                                            name + sizeof ".MIPS.events" - 1);
7183           else
7184             {
7185               BFD_ASSERT (strncmp (name, ".MIPS.post_rel",
7186                                    sizeof ".MIPS.post_rel" - 1) == 0);
7187               sec = bfd_get_section_by_name (abfd,
7188                                              (name
7189                                               + sizeof ".MIPS.post_rel" - 1));
7190             }
7191           BFD_ASSERT (sec != NULL);
7192           (*hdrpp)->sh_link = elf_section_data (sec)->this_idx;
7193           break;
7194
7195         }
7196     }
7197 }
7198 \f
7199 /* When creating an IRIX5 executable, we need REGINFO and RTPROC
7200    segments.  */
7201
7202 int
7203 _bfd_mips_elf_additional_program_headers (bfd *abfd)
7204 {
7205   asection *s;
7206   int ret = 0;
7207
7208   /* See if we need a PT_MIPS_REGINFO segment.  */
7209   s = bfd_get_section_by_name (abfd, ".reginfo");
7210   if (s && (s->flags & SEC_LOAD))
7211     ++ret;
7212
7213   /* See if we need a PT_MIPS_OPTIONS segment.  */
7214   if (IRIX_COMPAT (abfd) == ict_irix6
7215       && bfd_get_section_by_name (abfd,
7216                                   MIPS_ELF_OPTIONS_SECTION_NAME (abfd)))
7217     ++ret;
7218
7219   /* See if we need a PT_MIPS_RTPROC segment.  */
7220   if (IRIX_COMPAT (abfd) == ict_irix5
7221       && bfd_get_section_by_name (abfd, ".dynamic")
7222       && bfd_get_section_by_name (abfd, ".mdebug"))
7223     ++ret;
7224
7225   return ret;
7226 }
7227
7228 /* Modify the segment map for an IRIX5 executable.  */
7229
7230 bfd_boolean
7231 _bfd_mips_elf_modify_segment_map (bfd *abfd,
7232                                   struct bfd_link_info *info ATTRIBUTE_UNUSED)
7233 {
7234   asection *s;
7235   struct elf_segment_map *m, **pm;
7236   bfd_size_type amt;
7237
7238   /* If there is a .reginfo section, we need a PT_MIPS_REGINFO
7239      segment.  */
7240   s = bfd_get_section_by_name (abfd, ".reginfo");
7241   if (s != NULL && (s->flags & SEC_LOAD) != 0)
7242     {
7243       for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
7244         if (m->p_type == PT_MIPS_REGINFO)
7245           break;
7246       if (m == NULL)
7247         {
7248           amt = sizeof *m;
7249           m = bfd_zalloc (abfd, amt);
7250           if (m == NULL)
7251             return FALSE;
7252
7253           m->p_type = PT_MIPS_REGINFO;
7254           m->count = 1;
7255           m->sections[0] = s;
7256
7257           /* We want to put it after the PHDR and INTERP segments.  */
7258           pm = &elf_tdata (abfd)->segment_map;
7259           while (*pm != NULL
7260                  && ((*pm)->p_type == PT_PHDR
7261                      || (*pm)->p_type == PT_INTERP))
7262             pm = &(*pm)->next;
7263
7264           m->next = *pm;
7265           *pm = m;
7266         }
7267     }
7268
7269   /* For IRIX 6, we don't have .mdebug sections, nor does anything but
7270      .dynamic end up in PT_DYNAMIC.  However, we do have to insert a
7271      PT_MIPS_OPTIONS segment immediately following the program header
7272      table.  */
7273   if (NEWABI_P (abfd)
7274       /* On non-IRIX6 new abi, we'll have already created a segment
7275          for this section, so don't create another.  I'm not sure this
7276          is not also the case for IRIX 6, but I can't test it right
7277          now.  */
7278       && IRIX_COMPAT (abfd) == ict_irix6)
7279     {
7280       for (s = abfd->sections; s; s = s->next)
7281         if (elf_section_data (s)->this_hdr.sh_type == SHT_MIPS_OPTIONS)
7282           break;
7283
7284       if (s)
7285         {
7286           struct elf_segment_map *options_segment;
7287
7288           pm = &elf_tdata (abfd)->segment_map;
7289           while (*pm != NULL
7290                  && ((*pm)->p_type == PT_PHDR
7291                      || (*pm)->p_type == PT_INTERP))
7292             pm = &(*pm)->next;
7293
7294           amt = sizeof (struct elf_segment_map);
7295           options_segment = bfd_zalloc (abfd, amt);
7296           options_segment->next = *pm;
7297           options_segment->p_type = PT_MIPS_OPTIONS;
7298           options_segment->p_flags = PF_R;
7299           options_segment->p_flags_valid = TRUE;
7300           options_segment->count = 1;
7301           options_segment->sections[0] = s;
7302           *pm = options_segment;
7303         }
7304     }
7305   else
7306     {
7307       if (IRIX_COMPAT (abfd) == ict_irix5)
7308         {
7309           /* If there are .dynamic and .mdebug sections, we make a room
7310              for the RTPROC header.  FIXME: Rewrite without section names.  */
7311           if (bfd_get_section_by_name (abfd, ".interp") == NULL
7312               && bfd_get_section_by_name (abfd, ".dynamic") != NULL
7313               && bfd_get_section_by_name (abfd, ".mdebug") != NULL)
7314             {
7315               for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
7316                 if (m->p_type == PT_MIPS_RTPROC)
7317                   break;
7318               if (m == NULL)
7319                 {
7320                   amt = sizeof *m;
7321                   m = bfd_zalloc (abfd, amt);
7322                   if (m == NULL)
7323                     return FALSE;
7324
7325                   m->p_type = PT_MIPS_RTPROC;
7326
7327                   s = bfd_get_section_by_name (abfd, ".rtproc");
7328                   if (s == NULL)
7329                     {
7330                       m->count = 0;
7331                       m->p_flags = 0;
7332                       m->p_flags_valid = 1;
7333                     }
7334                   else
7335                     {
7336                       m->count = 1;
7337                       m->sections[0] = s;
7338                     }
7339
7340                   /* We want to put it after the DYNAMIC segment.  */
7341                   pm = &elf_tdata (abfd)->segment_map;
7342                   while (*pm != NULL && (*pm)->p_type != PT_DYNAMIC)
7343                     pm = &(*pm)->next;
7344                   if (*pm != NULL)
7345                     pm = &(*pm)->next;
7346
7347                   m->next = *pm;
7348                   *pm = m;
7349                 }
7350             }
7351         }
7352       /* On IRIX5, the PT_DYNAMIC segment includes the .dynamic,
7353          .dynstr, .dynsym, and .hash sections, and everything in
7354          between.  */
7355       for (pm = &elf_tdata (abfd)->segment_map; *pm != NULL;
7356            pm = &(*pm)->next)
7357         if ((*pm)->p_type == PT_DYNAMIC)
7358           break;
7359       m = *pm;
7360       if (m != NULL && IRIX_COMPAT (abfd) == ict_none)
7361         {
7362           /* For a normal mips executable the permissions for the PT_DYNAMIC
7363              segment are read, write and execute. We do that here since
7364              the code in elf.c sets only the read permission. This matters
7365              sometimes for the dynamic linker.  */
7366           if (bfd_get_section_by_name (abfd, ".dynamic") != NULL)
7367             {
7368               m->p_flags = PF_R | PF_W | PF_X;
7369               m->p_flags_valid = 1;
7370             }
7371         }
7372       if (m != NULL
7373           && m->count == 1 && strcmp (m->sections[0]->name, ".dynamic") == 0)
7374         {
7375           static const char *sec_names[] =
7376           {
7377             ".dynamic", ".dynstr", ".dynsym", ".hash"
7378           };
7379           bfd_vma low, high;
7380           unsigned int i, c;
7381           struct elf_segment_map *n;
7382
7383           low = ~(bfd_vma) 0;
7384           high = 0;
7385           for (i = 0; i < sizeof sec_names / sizeof sec_names[0]; i++)
7386             {
7387               s = bfd_get_section_by_name (abfd, sec_names[i]);
7388               if (s != NULL && (s->flags & SEC_LOAD) != 0)
7389                 {
7390                   bfd_size_type sz;
7391
7392                   if (low > s->vma)
7393                     low = s->vma;
7394                   sz = s->size;
7395                   if (high < s->vma + sz)
7396                     high = s->vma + sz;
7397                 }
7398             }
7399
7400           c = 0;
7401           for (s = abfd->sections; s != NULL; s = s->next)
7402             if ((s->flags & SEC_LOAD) != 0
7403                 && s->vma >= low
7404                 && s->vma + s->size <= high)
7405               ++c;
7406
7407           amt = sizeof *n + (bfd_size_type) (c - 1) * sizeof (asection *);
7408           n = bfd_zalloc (abfd, amt);
7409           if (n == NULL)
7410             return FALSE;
7411           *n = *m;
7412           n->count = c;
7413
7414           i = 0;
7415           for (s = abfd->sections; s != NULL; s = s->next)
7416             {
7417               if ((s->flags & SEC_LOAD) != 0
7418                   && s->vma >= low
7419                   && s->vma + s->size <= high)
7420                 {
7421                   n->sections[i] = s;
7422                   ++i;
7423                 }
7424             }
7425
7426           *pm = n;
7427         }
7428     }
7429
7430   return TRUE;
7431 }
7432 \f
7433 /* Return the section that should be marked against GC for a given
7434    relocation.  */
7435
7436 asection *
7437 _bfd_mips_elf_gc_mark_hook (asection *sec,
7438                             struct bfd_link_info *info ATTRIBUTE_UNUSED,
7439                             Elf_Internal_Rela *rel,
7440                             struct elf_link_hash_entry *h,
7441                             Elf_Internal_Sym *sym)
7442 {
7443   /* ??? Do mips16 stub sections need to be handled special?  */
7444
7445   if (h != NULL)
7446     {
7447       switch (ELF_R_TYPE (sec->owner, rel->r_info))
7448         {
7449         case R_MIPS_GNU_VTINHERIT:
7450         case R_MIPS_GNU_VTENTRY:
7451           break;
7452
7453         default:
7454           switch (h->root.type)
7455             {
7456             case bfd_link_hash_defined:
7457             case bfd_link_hash_defweak:
7458               return h->root.u.def.section;
7459
7460             case bfd_link_hash_common:
7461               return h->root.u.c.p->section;
7462
7463             default:
7464               break;
7465             }
7466         }
7467     }
7468   else
7469     return bfd_section_from_elf_index (sec->owner, sym->st_shndx);
7470
7471   return NULL;
7472 }
7473
7474 /* Update the got entry reference counts for the section being removed.  */
7475
7476 bfd_boolean
7477 _bfd_mips_elf_gc_sweep_hook (bfd *abfd ATTRIBUTE_UNUSED,
7478                              struct bfd_link_info *info ATTRIBUTE_UNUSED,
7479                              asection *sec ATTRIBUTE_UNUSED,
7480                              const Elf_Internal_Rela *relocs ATTRIBUTE_UNUSED)
7481 {
7482 #if 0
7483   Elf_Internal_Shdr *symtab_hdr;
7484   struct elf_link_hash_entry **sym_hashes;
7485   bfd_signed_vma *local_got_refcounts;
7486   const Elf_Internal_Rela *rel, *relend;
7487   unsigned long r_symndx;
7488   struct elf_link_hash_entry *h;
7489
7490   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
7491   sym_hashes = elf_sym_hashes (abfd);
7492   local_got_refcounts = elf_local_got_refcounts (abfd);
7493
7494   relend = relocs + sec->reloc_count;
7495   for (rel = relocs; rel < relend; rel++)
7496     switch (ELF_R_TYPE (abfd, rel->r_info))
7497       {
7498       case R_MIPS_GOT16:
7499       case R_MIPS_CALL16:
7500       case R_MIPS_CALL_HI16:
7501       case R_MIPS_CALL_LO16:
7502       case R_MIPS_GOT_HI16:
7503       case R_MIPS_GOT_LO16:
7504       case R_MIPS_GOT_DISP:
7505       case R_MIPS_GOT_PAGE:
7506       case R_MIPS_GOT_OFST:
7507         /* ??? It would seem that the existing MIPS code does no sort
7508            of reference counting or whatnot on its GOT and PLT entries,
7509            so it is not possible to garbage collect them at this time.  */
7510         break;
7511
7512       default:
7513         break;
7514       }
7515 #endif
7516
7517   return TRUE;
7518 }
7519 \f
7520 /* Copy data from a MIPS ELF indirect symbol to its direct symbol,
7521    hiding the old indirect symbol.  Process additional relocation
7522    information.  Also called for weakdefs, in which case we just let
7523    _bfd_elf_link_hash_copy_indirect copy the flags for us.  */
7524
7525 void
7526 _bfd_mips_elf_copy_indirect_symbol (const struct elf_backend_data *bed,
7527                                     struct elf_link_hash_entry *dir,
7528                                     struct elf_link_hash_entry *ind)
7529 {
7530   struct mips_elf_link_hash_entry *dirmips, *indmips;
7531
7532   _bfd_elf_link_hash_copy_indirect (bed, dir, ind);
7533
7534   if (ind->root.type != bfd_link_hash_indirect)
7535     return;
7536
7537   dirmips = (struct mips_elf_link_hash_entry *) dir;
7538   indmips = (struct mips_elf_link_hash_entry *) ind;
7539   dirmips->possibly_dynamic_relocs += indmips->possibly_dynamic_relocs;
7540   if (indmips->readonly_reloc)
7541     dirmips->readonly_reloc = TRUE;
7542   if (indmips->no_fn_stub)
7543     dirmips->no_fn_stub = TRUE;
7544 }
7545
7546 void
7547 _bfd_mips_elf_hide_symbol (struct bfd_link_info *info,
7548                            struct elf_link_hash_entry *entry,
7549                            bfd_boolean force_local)
7550 {
7551   bfd *dynobj;
7552   asection *got;
7553   struct mips_got_info *g;
7554   struct mips_elf_link_hash_entry *h;
7555
7556   h = (struct mips_elf_link_hash_entry *) entry;
7557   if (h->forced_local)
7558     return;
7559   h->forced_local = force_local;
7560
7561   dynobj = elf_hash_table (info)->dynobj;
7562   if (dynobj != NULL && force_local)
7563     {
7564       got = mips_elf_got_section (dynobj, FALSE);
7565       g = mips_elf_section_data (got)->u.got_info;
7566
7567       if (g->next)
7568         {
7569           struct mips_got_entry e;
7570           struct mips_got_info *gg = g;
7571
7572           /* Since we're turning what used to be a global symbol into a
7573              local one, bump up the number of local entries of each GOT
7574              that had an entry for it.  This will automatically decrease
7575              the number of global entries, since global_gotno is actually
7576              the upper limit of global entries.  */
7577           e.abfd = dynobj;
7578           e.symndx = -1;
7579           e.d.h = h;
7580
7581           for (g = g->next; g != gg; g = g->next)
7582             if (htab_find (g->got_entries, &e))
7583               {
7584                 BFD_ASSERT (g->global_gotno > 0);
7585                 g->local_gotno++;
7586                 g->global_gotno--;
7587               }
7588
7589           /* If this was a global symbol forced into the primary GOT, we
7590              no longer need an entry for it.  We can't release the entry
7591              at this point, but we must at least stop counting it as one
7592              of the symbols that required a forced got entry.  */
7593           if (h->root.got.offset == 2)
7594             {
7595               BFD_ASSERT (gg->assigned_gotno > 0);
7596               gg->assigned_gotno--;
7597             }
7598         }
7599       else if (g->global_gotno == 0 && g->global_gotsym == NULL)
7600         /* If we haven't got through GOT allocation yet, just bump up the
7601            number of local entries, as this symbol won't be counted as
7602            global.  */
7603         g->local_gotno++;
7604       else if (h->root.got.offset == 1)
7605         {
7606           /* If we're past non-multi-GOT allocation and this symbol had
7607              been marked for a global got entry, give it a local entry
7608              instead.  */
7609           BFD_ASSERT (g->global_gotno > 0);
7610           g->local_gotno++;
7611           g->global_gotno--;
7612         }
7613     }
7614
7615   _bfd_elf_link_hash_hide_symbol (info, &h->root, force_local);
7616 }
7617 \f
7618 #define PDR_SIZE 32
7619
7620 bfd_boolean
7621 _bfd_mips_elf_discard_info (bfd *abfd, struct elf_reloc_cookie *cookie,
7622                             struct bfd_link_info *info)
7623 {
7624   asection *o;
7625   bfd_boolean ret = FALSE;
7626   unsigned char *tdata;
7627   size_t i, skip;
7628
7629   o = bfd_get_section_by_name (abfd, ".pdr");
7630   if (! o)
7631     return FALSE;
7632   if (o->size == 0)
7633     return FALSE;
7634   if (o->size % PDR_SIZE != 0)
7635     return FALSE;
7636   if (o->output_section != NULL
7637       && bfd_is_abs_section (o->output_section))
7638     return FALSE;
7639
7640   tdata = bfd_zmalloc (o->size / PDR_SIZE);
7641   if (! tdata)
7642     return FALSE;
7643
7644   cookie->rels = _bfd_elf_link_read_relocs (abfd, o, NULL, NULL,
7645                                             info->keep_memory);
7646   if (!cookie->rels)
7647     {
7648       free (tdata);
7649       return FALSE;
7650     }
7651
7652   cookie->rel = cookie->rels;
7653   cookie->relend = cookie->rels + o->reloc_count;
7654
7655   for (i = 0, skip = 0; i < o->size / PDR_SIZE; i ++)
7656     {
7657       if (bfd_elf_reloc_symbol_deleted_p (i * PDR_SIZE, cookie))
7658         {
7659           tdata[i] = 1;
7660           skip ++;
7661         }
7662     }
7663
7664   if (skip != 0)
7665     {
7666       mips_elf_section_data (o)->u.tdata = tdata;
7667       o->size -= skip * PDR_SIZE;
7668       ret = TRUE;
7669     }
7670   else
7671     free (tdata);
7672
7673   if (! info->keep_memory)
7674     free (cookie->rels);
7675
7676   return ret;
7677 }
7678
7679 bfd_boolean
7680 _bfd_mips_elf_ignore_discarded_relocs (asection *sec)
7681 {
7682   if (strcmp (sec->name, ".pdr") == 0)
7683     return TRUE;
7684   return FALSE;
7685 }
7686
7687 bfd_boolean
7688 _bfd_mips_elf_write_section (bfd *output_bfd, asection *sec,
7689                              bfd_byte *contents)
7690 {
7691   bfd_byte *to, *from, *end;
7692   int i;
7693
7694   if (strcmp (sec->name, ".pdr") != 0)
7695     return FALSE;
7696
7697   if (mips_elf_section_data (sec)->u.tdata == NULL)
7698     return FALSE;
7699
7700   to = contents;
7701   end = contents + sec->size;
7702   for (from = contents, i = 0;
7703        from < end;
7704        from += PDR_SIZE, i++)
7705     {
7706       if ((mips_elf_section_data (sec)->u.tdata)[i] == 1)
7707         continue;
7708       if (to != from)
7709         memcpy (to, from, PDR_SIZE);
7710       to += PDR_SIZE;
7711     }
7712   bfd_set_section_contents (output_bfd, sec->output_section, contents,
7713                             sec->output_offset, sec->size);
7714   return TRUE;
7715 }
7716 \f
7717 /* MIPS ELF uses a special find_nearest_line routine in order the
7718    handle the ECOFF debugging information.  */
7719
7720 struct mips_elf_find_line
7721 {
7722   struct ecoff_debug_info d;
7723   struct ecoff_find_line i;
7724 };
7725
7726 bfd_boolean
7727 _bfd_mips_elf_find_nearest_line (bfd *abfd, asection *section,
7728                                  asymbol **symbols, bfd_vma offset,
7729                                  const char **filename_ptr,
7730                                  const char **functionname_ptr,
7731                                  unsigned int *line_ptr)
7732 {
7733   asection *msec;
7734
7735   if (_bfd_dwarf1_find_nearest_line (abfd, section, symbols, offset,
7736                                      filename_ptr, functionname_ptr,
7737                                      line_ptr))
7738     return TRUE;
7739
7740   if (_bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset,
7741                                      filename_ptr, functionname_ptr,
7742                                      line_ptr, ABI_64_P (abfd) ? 8 : 0,
7743                                      &elf_tdata (abfd)->dwarf2_find_line_info))
7744     return TRUE;
7745
7746   msec = bfd_get_section_by_name (abfd, ".mdebug");
7747   if (msec != NULL)
7748     {
7749       flagword origflags;
7750       struct mips_elf_find_line *fi;
7751       const struct ecoff_debug_swap * const swap =
7752         get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
7753
7754       /* If we are called during a link, mips_elf_final_link may have
7755          cleared the SEC_HAS_CONTENTS field.  We force it back on here
7756          if appropriate (which it normally will be).  */
7757       origflags = msec->flags;
7758       if (elf_section_data (msec)->this_hdr.sh_type != SHT_NOBITS)
7759         msec->flags |= SEC_HAS_CONTENTS;
7760
7761       fi = elf_tdata (abfd)->find_line_info;
7762       if (fi == NULL)
7763         {
7764           bfd_size_type external_fdr_size;
7765           char *fraw_src;
7766           char *fraw_end;
7767           struct fdr *fdr_ptr;
7768           bfd_size_type amt = sizeof (struct mips_elf_find_line);
7769
7770           fi = bfd_zalloc (abfd, amt);
7771           if (fi == NULL)
7772             {
7773               msec->flags = origflags;
7774               return FALSE;
7775             }
7776
7777           if (! _bfd_mips_elf_read_ecoff_info (abfd, msec, &fi->d))
7778             {
7779               msec->flags = origflags;
7780               return FALSE;
7781             }
7782
7783           /* Swap in the FDR information.  */
7784           amt = fi->d.symbolic_header.ifdMax * sizeof (struct fdr);
7785           fi->d.fdr = bfd_alloc (abfd, amt);
7786           if (fi->d.fdr == NULL)
7787             {
7788               msec->flags = origflags;
7789               return FALSE;
7790             }
7791           external_fdr_size = swap->external_fdr_size;
7792           fdr_ptr = fi->d.fdr;
7793           fraw_src = (char *) fi->d.external_fdr;
7794           fraw_end = (fraw_src
7795                       + fi->d.symbolic_header.ifdMax * external_fdr_size);
7796           for (; fraw_src < fraw_end; fraw_src += external_fdr_size, fdr_ptr++)
7797             (*swap->swap_fdr_in) (abfd, fraw_src, fdr_ptr);
7798
7799           elf_tdata (abfd)->find_line_info = fi;
7800
7801           /* Note that we don't bother to ever free this information.
7802              find_nearest_line is either called all the time, as in
7803              objdump -l, so the information should be saved, or it is
7804              rarely called, as in ld error messages, so the memory
7805              wasted is unimportant.  Still, it would probably be a
7806              good idea for free_cached_info to throw it away.  */
7807         }
7808
7809       if (_bfd_ecoff_locate_line (abfd, section, offset, &fi->d, swap,
7810                                   &fi->i, filename_ptr, functionname_ptr,
7811                                   line_ptr))
7812         {
7813           msec->flags = origflags;
7814           return TRUE;
7815         }
7816
7817       msec->flags = origflags;
7818     }
7819
7820   /* Fall back on the generic ELF find_nearest_line routine.  */
7821
7822   return _bfd_elf_find_nearest_line (abfd, section, symbols, offset,
7823                                      filename_ptr, functionname_ptr,
7824                                      line_ptr);
7825 }
7826 \f
7827 /* When are writing out the .options or .MIPS.options section,
7828    remember the bytes we are writing out, so that we can install the
7829    GP value in the section_processing routine.  */
7830
7831 bfd_boolean
7832 _bfd_mips_elf_set_section_contents (bfd *abfd, sec_ptr section,
7833                                     const void *location,
7834                                     file_ptr offset, bfd_size_type count)
7835 {
7836   if (strcmp (section->name, MIPS_ELF_OPTIONS_SECTION_NAME (abfd)) == 0)
7837     {
7838       bfd_byte *c;
7839
7840       if (elf_section_data (section) == NULL)
7841         {
7842           bfd_size_type amt = sizeof (struct bfd_elf_section_data);
7843           section->used_by_bfd = bfd_zalloc (abfd, amt);
7844           if (elf_section_data (section) == NULL)
7845             return FALSE;
7846         }
7847       c = mips_elf_section_data (section)->u.tdata;
7848       if (c == NULL)
7849         {
7850           c = bfd_zalloc (abfd, section->size);
7851           if (c == NULL)
7852             return FALSE;
7853           mips_elf_section_data (section)->u.tdata = c;
7854         }
7855
7856       memcpy (c + offset, location, count);
7857     }
7858
7859   return _bfd_elf_set_section_contents (abfd, section, location, offset,
7860                                         count);
7861 }
7862
7863 /* This is almost identical to bfd_generic_get_... except that some
7864    MIPS relocations need to be handled specially.  Sigh.  */
7865
7866 bfd_byte *
7867 _bfd_elf_mips_get_relocated_section_contents
7868   (bfd *abfd,
7869    struct bfd_link_info *link_info,
7870    struct bfd_link_order *link_order,
7871    bfd_byte *data,
7872    bfd_boolean relocatable,
7873    asymbol **symbols)
7874 {
7875   /* Get enough memory to hold the stuff */
7876   bfd *input_bfd = link_order->u.indirect.section->owner;
7877   asection *input_section = link_order->u.indirect.section;
7878   bfd_size_type sz;
7879
7880   long reloc_size = bfd_get_reloc_upper_bound (input_bfd, input_section);
7881   arelent **reloc_vector = NULL;
7882   long reloc_count;
7883
7884   if (reloc_size < 0)
7885     goto error_return;
7886
7887   reloc_vector = bfd_malloc (reloc_size);
7888   if (reloc_vector == NULL && reloc_size != 0)
7889     goto error_return;
7890
7891   /* read in the section */
7892   sz = input_section->rawsize ? input_section->rawsize : input_section->size;
7893   if (!bfd_get_section_contents (input_bfd, input_section, data, 0, sz))
7894     goto error_return;
7895
7896   reloc_count = bfd_canonicalize_reloc (input_bfd,
7897                                         input_section,
7898                                         reloc_vector,
7899                                         symbols);
7900   if (reloc_count < 0)
7901     goto error_return;
7902
7903   if (reloc_count > 0)
7904     {
7905       arelent **parent;
7906       /* for mips */
7907       int gp_found;
7908       bfd_vma gp = 0x12345678;  /* initialize just to shut gcc up */
7909
7910       {
7911         struct bfd_hash_entry *h;
7912         struct bfd_link_hash_entry *lh;
7913         /* Skip all this stuff if we aren't mixing formats.  */
7914         if (abfd && input_bfd
7915             && abfd->xvec == input_bfd->xvec)
7916           lh = 0;
7917         else
7918           {
7919             h = bfd_hash_lookup (&link_info->hash->table, "_gp", FALSE, FALSE);
7920             lh = (struct bfd_link_hash_entry *) h;
7921           }
7922       lookup:
7923         if (lh)
7924           {
7925             switch (lh->type)
7926               {
7927               case bfd_link_hash_undefined:
7928               case bfd_link_hash_undefweak:
7929               case bfd_link_hash_common:
7930                 gp_found = 0;
7931                 break;
7932               case bfd_link_hash_defined:
7933               case bfd_link_hash_defweak:
7934                 gp_found = 1;
7935                 gp = lh->u.def.value;
7936                 break;
7937               case bfd_link_hash_indirect:
7938               case bfd_link_hash_warning:
7939                 lh = lh->u.i.link;
7940                 /* @@FIXME  ignoring warning for now */
7941                 goto lookup;
7942               case bfd_link_hash_new:
7943               default:
7944                 abort ();
7945               }
7946           }
7947         else
7948           gp_found = 0;
7949       }
7950       /* end mips */
7951       for (parent = reloc_vector; *parent != NULL; parent++)
7952         {
7953           char *error_message = NULL;
7954           bfd_reloc_status_type r;
7955
7956           /* Specific to MIPS: Deal with relocation types that require
7957              knowing the gp of the output bfd.  */
7958           asymbol *sym = *(*parent)->sym_ptr_ptr;
7959           if (bfd_is_abs_section (sym->section) && abfd)
7960             {
7961               /* The special_function wouldn't get called anyway.  */
7962             }
7963           else if (!gp_found)
7964             {
7965               /* The gp isn't there; let the special function code
7966                  fall over on its own.  */
7967             }
7968           else if ((*parent)->howto->special_function
7969                    == _bfd_mips_elf32_gprel16_reloc)
7970             {
7971               /* bypass special_function call */
7972               r = _bfd_mips_elf_gprel16_with_gp (input_bfd, sym, *parent,
7973                                                  input_section, relocatable,
7974                                                  data, gp);
7975               goto skip_bfd_perform_relocation;
7976             }
7977           /* end mips specific stuff */
7978
7979           r = bfd_perform_relocation (input_bfd, *parent, data, input_section,
7980                                       relocatable ? abfd : NULL,
7981                                       &error_message);
7982         skip_bfd_perform_relocation:
7983
7984           if (relocatable)
7985             {
7986               asection *os = input_section->output_section;
7987
7988               /* A partial link, so keep the relocs */
7989               os->orelocation[os->reloc_count] = *parent;
7990               os->reloc_count++;
7991             }
7992
7993           if (r != bfd_reloc_ok)
7994             {
7995               switch (r)
7996                 {
7997                 case bfd_reloc_undefined:
7998                   if (!((*link_info->callbacks->undefined_symbol)
7999                         (link_info, bfd_asymbol_name (*(*parent)->sym_ptr_ptr),
8000                          input_bfd, input_section, (*parent)->address,
8001                          TRUE)))
8002                     goto error_return;
8003                   break;
8004                 case bfd_reloc_dangerous:
8005                   BFD_ASSERT (error_message != NULL);
8006                   if (!((*link_info->callbacks->reloc_dangerous)
8007                         (link_info, error_message, input_bfd, input_section,
8008                          (*parent)->address)))
8009                     goto error_return;
8010                   break;
8011                 case bfd_reloc_overflow:
8012                   if (!((*link_info->callbacks->reloc_overflow)
8013                         (link_info, NULL,
8014                          bfd_asymbol_name (*(*parent)->sym_ptr_ptr),
8015                          (*parent)->howto->name, (*parent)->addend,
8016                          input_bfd, input_section, (*parent)->address)))
8017                     goto error_return;
8018                   break;
8019                 case bfd_reloc_outofrange:
8020                 default:
8021                   abort ();
8022                   break;
8023                 }
8024
8025             }
8026         }
8027     }
8028   if (reloc_vector != NULL)
8029     free (reloc_vector);
8030   return data;
8031
8032 error_return:
8033   if (reloc_vector != NULL)
8034     free (reloc_vector);
8035   return NULL;
8036 }
8037 \f
8038 /* Create a MIPS ELF linker hash table.  */
8039
8040 struct bfd_link_hash_table *
8041 _bfd_mips_elf_link_hash_table_create (bfd *abfd)
8042 {
8043   struct mips_elf_link_hash_table *ret;
8044   bfd_size_type amt = sizeof (struct mips_elf_link_hash_table);
8045
8046   ret = bfd_malloc (amt);
8047   if (ret == NULL)
8048     return NULL;
8049
8050   if (! _bfd_elf_link_hash_table_init (&ret->root, abfd,
8051                                        mips_elf_link_hash_newfunc))
8052     {
8053       free (ret);
8054       return NULL;
8055     }
8056
8057 #if 0
8058   /* We no longer use this.  */
8059   for (i = 0; i < SIZEOF_MIPS_DYNSYM_SECNAMES; i++)
8060     ret->dynsym_sec_strindex[i] = (bfd_size_type) -1;
8061 #endif
8062   ret->procedure_count = 0;
8063   ret->compact_rel_size = 0;
8064   ret->use_rld_obj_head = FALSE;
8065   ret->rld_value = 0;
8066   ret->mips16_stubs_seen = FALSE;
8067
8068   return &ret->root.root;
8069 }
8070 \f
8071 /* We need to use a special link routine to handle the .reginfo and
8072    the .mdebug sections.  We need to merge all instances of these
8073    sections together, not write them all out sequentially.  */
8074
8075 bfd_boolean
8076 _bfd_mips_elf_final_link (bfd *abfd, struct bfd_link_info *info)
8077 {
8078   asection **secpp;
8079   asection *o;
8080   struct bfd_link_order *p;
8081   asection *reginfo_sec, *mdebug_sec, *gptab_data_sec, *gptab_bss_sec;
8082   asection *rtproc_sec;
8083   Elf32_RegInfo reginfo;
8084   struct ecoff_debug_info debug;
8085   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
8086   const struct ecoff_debug_swap *swap = bed->elf_backend_ecoff_debug_swap;
8087   HDRR *symhdr = &debug.symbolic_header;
8088   void *mdebug_handle = NULL;
8089   asection *s;
8090   EXTR esym;
8091   unsigned int i;
8092   bfd_size_type amt;
8093
8094   static const char * const secname[] =
8095   {
8096     ".text", ".init", ".fini", ".data",
8097     ".rodata", ".sdata", ".sbss", ".bss"
8098   };
8099   static const int sc[] =
8100   {
8101     scText, scInit, scFini, scData,
8102     scRData, scSData, scSBss, scBss
8103   };
8104
8105   /* We'd carefully arranged the dynamic symbol indices, and then the
8106      generic size_dynamic_sections renumbered them out from under us.
8107      Rather than trying somehow to prevent the renumbering, just do
8108      the sort again.  */
8109   if (elf_hash_table (info)->dynamic_sections_created)
8110     {
8111       bfd *dynobj;
8112       asection *got;
8113       struct mips_got_info *g;
8114       bfd_size_type dynsecsymcount;
8115
8116       /* When we resort, we must tell mips_elf_sort_hash_table what
8117          the lowest index it may use is.  That's the number of section
8118          symbols we're going to add.  The generic ELF linker only
8119          adds these symbols when building a shared object.  Note that
8120          we count the sections after (possibly) removing the .options
8121          section above.  */
8122
8123       dynsecsymcount = 0;
8124       if (info->shared)
8125         {
8126           asection * p;
8127
8128           for (p = abfd->sections; p ; p = p->next)
8129             if ((p->flags & SEC_EXCLUDE) == 0
8130                 && (p->flags & SEC_ALLOC) != 0
8131                 && !(*bed->elf_backend_omit_section_dynsym) (abfd, info, p))
8132               ++ dynsecsymcount;
8133         }
8134
8135       if (! mips_elf_sort_hash_table (info, dynsecsymcount + 1))
8136         return FALSE;
8137
8138       /* Make sure we didn't grow the global .got region.  */
8139       dynobj = elf_hash_table (info)->dynobj;
8140       got = mips_elf_got_section (dynobj, FALSE);
8141       g = mips_elf_section_data (got)->u.got_info;
8142
8143       if (g->global_gotsym != NULL)
8144         BFD_ASSERT ((elf_hash_table (info)->dynsymcount
8145                      - g->global_gotsym->dynindx)
8146                     <= g->global_gotno);
8147     }
8148
8149 #if 0
8150   /* We want to set the GP value for ld -r.  */
8151   /* On IRIX5, we omit the .options section.  On IRIX6, however, we
8152      include it, even though we don't process it quite right.  (Some
8153      entries are supposed to be merged.)  Empirically, we seem to be
8154      better off including it then not.  */
8155   if (IRIX_COMPAT (abfd) == ict_irix5 || IRIX_COMPAT (abfd) == ict_none)
8156     for (secpp = &abfd->sections; *secpp != NULL; secpp = &(*secpp)->next)
8157       {
8158         if (strcmp ((*secpp)->name, MIPS_ELF_OPTIONS_SECTION_NAME (abfd)) == 0)
8159           {
8160             for (p = (*secpp)->link_order_head; p != NULL; p = p->next)
8161               if (p->type == bfd_indirect_link_order)
8162                 p->u.indirect.section->flags &= ~SEC_HAS_CONTENTS;
8163             (*secpp)->link_order_head = NULL;
8164             bfd_section_list_remove (abfd, secpp);
8165             --abfd->section_count;
8166
8167             break;
8168           }
8169       }
8170
8171   /* We include .MIPS.options, even though we don't process it quite right.
8172      (Some entries are supposed to be merged.)  At IRIX6 empirically we seem
8173      to be better off including it than not.  */
8174   for (secpp = &abfd->sections; *secpp != NULL; secpp = &(*secpp)->next)
8175     {
8176       if (strcmp ((*secpp)->name, ".MIPS.options") == 0)
8177         {
8178           for (p = (*secpp)->link_order_head; p != NULL; p = p->next)
8179             if (p->type == bfd_indirect_link_order)
8180               p->u.indirect.section->flags &=~ SEC_HAS_CONTENTS;
8181           (*secpp)->link_order_head = NULL;
8182           bfd_section_list_remove (abfd, secpp);
8183           --abfd->section_count;
8184
8185           break;
8186         }
8187     }
8188 #endif
8189
8190   /* Get a value for the GP register.  */
8191   if (elf_gp (abfd) == 0)
8192     {
8193       struct bfd_link_hash_entry *h;
8194
8195       h = bfd_link_hash_lookup (info->hash, "_gp", FALSE, FALSE, TRUE);
8196       if (h != NULL && h->type == bfd_link_hash_defined)
8197         elf_gp (abfd) = (h->u.def.value
8198                          + h->u.def.section->output_section->vma
8199                          + h->u.def.section->output_offset);
8200       else if (info->relocatable)
8201         {
8202           bfd_vma lo = MINUS_ONE;
8203
8204           /* Find the GP-relative section with the lowest offset.  */
8205           for (o = abfd->sections; o != NULL; o = o->next)
8206             if (o->vma < lo
8207                 && (elf_section_data (o)->this_hdr.sh_flags & SHF_MIPS_GPREL))
8208               lo = o->vma;
8209
8210           /* And calculate GP relative to that.  */
8211           elf_gp (abfd) = lo + ELF_MIPS_GP_OFFSET (abfd);
8212         }
8213       else
8214         {
8215           /* If the relocate_section function needs to do a reloc
8216              involving the GP value, it should make a reloc_dangerous
8217              callback to warn that GP is not defined.  */
8218         }
8219     }
8220
8221   /* Go through the sections and collect the .reginfo and .mdebug
8222      information.  */
8223   reginfo_sec = NULL;
8224   mdebug_sec = NULL;
8225   gptab_data_sec = NULL;
8226   gptab_bss_sec = NULL;
8227   for (o = abfd->sections; o != NULL; o = o->next)
8228     {
8229       if (strcmp (o->name, ".reginfo") == 0)
8230         {
8231           memset (&reginfo, 0, sizeof reginfo);
8232
8233           /* We have found the .reginfo section in the output file.
8234              Look through all the link_orders comprising it and merge
8235              the information together.  */
8236           for (p = o->link_order_head; p != NULL; p = p->next)
8237             {
8238               asection *input_section;
8239               bfd *input_bfd;
8240               Elf32_External_RegInfo ext;
8241               Elf32_RegInfo sub;
8242
8243               if (p->type != bfd_indirect_link_order)
8244                 {
8245                   if (p->type == bfd_data_link_order)
8246                     continue;
8247                   abort ();
8248                 }
8249
8250               input_section = p->u.indirect.section;
8251               input_bfd = input_section->owner;
8252
8253               if (! bfd_get_section_contents (input_bfd, input_section,
8254                                               &ext, 0, sizeof ext))
8255                 return FALSE;
8256
8257               bfd_mips_elf32_swap_reginfo_in (input_bfd, &ext, &sub);
8258
8259               reginfo.ri_gprmask |= sub.ri_gprmask;
8260               reginfo.ri_cprmask[0] |= sub.ri_cprmask[0];
8261               reginfo.ri_cprmask[1] |= sub.ri_cprmask[1];
8262               reginfo.ri_cprmask[2] |= sub.ri_cprmask[2];
8263               reginfo.ri_cprmask[3] |= sub.ri_cprmask[3];
8264
8265               /* ri_gp_value is set by the function
8266                  mips_elf32_section_processing when the section is
8267                  finally written out.  */
8268
8269               /* Hack: reset the SEC_HAS_CONTENTS flag so that
8270                  elf_link_input_bfd ignores this section.  */
8271               input_section->flags &= ~SEC_HAS_CONTENTS;
8272             }
8273
8274           /* Size has been set in _bfd_mips_elf_always_size_sections.  */
8275           BFD_ASSERT(o->size == sizeof (Elf32_External_RegInfo));
8276
8277           /* Skip this section later on (I don't think this currently
8278              matters, but someday it might).  */
8279           o->link_order_head = NULL;
8280
8281           reginfo_sec = o;
8282         }
8283
8284       if (strcmp (o->name, ".mdebug") == 0)
8285         {
8286           struct extsym_info einfo;
8287           bfd_vma last;
8288
8289           /* We have found the .mdebug section in the output file.
8290              Look through all the link_orders comprising it and merge
8291              the information together.  */
8292           symhdr->magic = swap->sym_magic;
8293           /* FIXME: What should the version stamp be?  */
8294           symhdr->vstamp = 0;
8295           symhdr->ilineMax = 0;
8296           symhdr->cbLine = 0;
8297           symhdr->idnMax = 0;
8298           symhdr->ipdMax = 0;
8299           symhdr->isymMax = 0;
8300           symhdr->ioptMax = 0;
8301           symhdr->iauxMax = 0;
8302           symhdr->issMax = 0;
8303           symhdr->issExtMax = 0;
8304           symhdr->ifdMax = 0;
8305           symhdr->crfd = 0;
8306           symhdr->iextMax = 0;
8307
8308           /* We accumulate the debugging information itself in the
8309              debug_info structure.  */
8310           debug.line = NULL;
8311           debug.external_dnr = NULL;
8312           debug.external_pdr = NULL;
8313           debug.external_sym = NULL;
8314           debug.external_opt = NULL;
8315           debug.external_aux = NULL;
8316           debug.ss = NULL;
8317           debug.ssext = debug.ssext_end = NULL;
8318           debug.external_fdr = NULL;
8319           debug.external_rfd = NULL;
8320           debug.external_ext = debug.external_ext_end = NULL;
8321
8322           mdebug_handle = bfd_ecoff_debug_init (abfd, &debug, swap, info);
8323           if (mdebug_handle == NULL)
8324             return FALSE;
8325
8326           esym.jmptbl = 0;
8327           esym.cobol_main = 0;
8328           esym.weakext = 0;
8329           esym.reserved = 0;
8330           esym.ifd = ifdNil;
8331           esym.asym.iss = issNil;
8332           esym.asym.st = stLocal;
8333           esym.asym.reserved = 0;
8334           esym.asym.index = indexNil;
8335           last = 0;
8336           for (i = 0; i < sizeof (secname) / sizeof (secname[0]); i++)
8337             {
8338               esym.asym.sc = sc[i];
8339               s = bfd_get_section_by_name (abfd, secname[i]);
8340               if (s != NULL)
8341                 {
8342                   esym.asym.value = s->vma;
8343                   last = s->vma + s->size;
8344                 }
8345               else
8346                 esym.asym.value = last;
8347               if (!bfd_ecoff_debug_one_external (abfd, &debug, swap,
8348                                                  secname[i], &esym))
8349                 return FALSE;
8350             }
8351
8352           for (p = o->link_order_head; p != NULL; p = p->next)
8353             {
8354               asection *input_section;
8355               bfd *input_bfd;
8356               const struct ecoff_debug_swap *input_swap;
8357               struct ecoff_debug_info input_debug;
8358               char *eraw_src;
8359               char *eraw_end;
8360
8361               if (p->type != bfd_indirect_link_order)
8362                 {
8363                   if (p->type == bfd_data_link_order)
8364                     continue;
8365                   abort ();
8366                 }
8367
8368               input_section = p->u.indirect.section;
8369               input_bfd = input_section->owner;
8370
8371               if (bfd_get_flavour (input_bfd) != bfd_target_elf_flavour
8372                   || (get_elf_backend_data (input_bfd)
8373                       ->elf_backend_ecoff_debug_swap) == NULL)
8374                 {
8375                   /* I don't know what a non MIPS ELF bfd would be
8376                      doing with a .mdebug section, but I don't really
8377                      want to deal with it.  */
8378                   continue;
8379                 }
8380
8381               input_swap = (get_elf_backend_data (input_bfd)
8382                             ->elf_backend_ecoff_debug_swap);
8383
8384               BFD_ASSERT (p->size == input_section->size);
8385
8386               /* The ECOFF linking code expects that we have already
8387                  read in the debugging information and set up an
8388                  ecoff_debug_info structure, so we do that now.  */
8389               if (! _bfd_mips_elf_read_ecoff_info (input_bfd, input_section,
8390                                                    &input_debug))
8391                 return FALSE;
8392
8393               if (! (bfd_ecoff_debug_accumulate
8394                      (mdebug_handle, abfd, &debug, swap, input_bfd,
8395                       &input_debug, input_swap, info)))
8396                 return FALSE;
8397
8398               /* Loop through the external symbols.  For each one with
8399                  interesting information, try to find the symbol in
8400                  the linker global hash table and save the information
8401                  for the output external symbols.  */
8402               eraw_src = input_debug.external_ext;
8403               eraw_end = (eraw_src
8404                           + (input_debug.symbolic_header.iextMax
8405                              * input_swap->external_ext_size));
8406               for (;
8407                    eraw_src < eraw_end;
8408                    eraw_src += input_swap->external_ext_size)
8409                 {
8410                   EXTR ext;
8411                   const char *name;
8412                   struct mips_elf_link_hash_entry *h;
8413
8414                   (*input_swap->swap_ext_in) (input_bfd, eraw_src, &ext);
8415                   if (ext.asym.sc == scNil
8416                       || ext.asym.sc == scUndefined
8417                       || ext.asym.sc == scSUndefined)
8418                     continue;
8419
8420                   name = input_debug.ssext + ext.asym.iss;
8421                   h = mips_elf_link_hash_lookup (mips_elf_hash_table (info),
8422                                                  name, FALSE, FALSE, TRUE);
8423                   if (h == NULL || h->esym.ifd != -2)
8424                     continue;
8425
8426                   if (ext.ifd != -1)
8427                     {
8428                       BFD_ASSERT (ext.ifd
8429                                   < input_debug.symbolic_header.ifdMax);
8430                       ext.ifd = input_debug.ifdmap[ext.ifd];
8431                     }
8432
8433                   h->esym = ext;
8434                 }
8435
8436               /* Free up the information we just read.  */
8437               free (input_debug.line);
8438               free (input_debug.external_dnr);
8439               free (input_debug.external_pdr);
8440               free (input_debug.external_sym);
8441               free (input_debug.external_opt);
8442               free (input_debug.external_aux);
8443               free (input_debug.ss);
8444               free (input_debug.ssext);
8445               free (input_debug.external_fdr);
8446               free (input_debug.external_rfd);
8447               free (input_debug.external_ext);
8448
8449               /* Hack: reset the SEC_HAS_CONTENTS flag so that
8450                  elf_link_input_bfd ignores this section.  */
8451               input_section->flags &= ~SEC_HAS_CONTENTS;
8452             }
8453
8454           if (SGI_COMPAT (abfd) && info->shared)
8455             {
8456               /* Create .rtproc section.  */
8457               rtproc_sec = bfd_get_section_by_name (abfd, ".rtproc");
8458               if (rtproc_sec == NULL)
8459                 {
8460                   flagword flags = (SEC_HAS_CONTENTS | SEC_IN_MEMORY
8461                                     | SEC_LINKER_CREATED | SEC_READONLY);
8462
8463                   rtproc_sec = bfd_make_section (abfd, ".rtproc");
8464                   if (rtproc_sec == NULL
8465                       || ! bfd_set_section_flags (abfd, rtproc_sec, flags)
8466                       || ! bfd_set_section_alignment (abfd, rtproc_sec, 4))
8467                     return FALSE;
8468                 }
8469
8470               if (! mips_elf_create_procedure_table (mdebug_handle, abfd,
8471                                                      info, rtproc_sec,
8472                                                      &debug))
8473                 return FALSE;
8474             }
8475
8476           /* Build the external symbol information.  */
8477           einfo.abfd = abfd;
8478           einfo.info = info;
8479           einfo.debug = &debug;
8480           einfo.swap = swap;
8481           einfo.failed = FALSE;
8482           mips_elf_link_hash_traverse (mips_elf_hash_table (info),
8483                                        mips_elf_output_extsym, &einfo);
8484           if (einfo.failed)
8485             return FALSE;
8486
8487           /* Set the size of the .mdebug section.  */
8488           o->size = bfd_ecoff_debug_size (abfd, &debug, swap);
8489
8490           /* Skip this section later on (I don't think this currently
8491              matters, but someday it might).  */
8492           o->link_order_head = NULL;
8493
8494           mdebug_sec = o;
8495         }
8496
8497       if (strncmp (o->name, ".gptab.", sizeof ".gptab." - 1) == 0)
8498         {
8499           const char *subname;
8500           unsigned int c;
8501           Elf32_gptab *tab;
8502           Elf32_External_gptab *ext_tab;
8503           unsigned int j;
8504
8505           /* The .gptab.sdata and .gptab.sbss sections hold
8506              information describing how the small data area would
8507              change depending upon the -G switch.  These sections
8508              not used in executables files.  */
8509           if (! info->relocatable)
8510             {
8511               for (p = o->link_order_head; p != NULL; p = p->next)
8512                 {
8513                   asection *input_section;
8514
8515                   if (p->type != bfd_indirect_link_order)
8516                     {
8517                       if (p->type == bfd_data_link_order)
8518                         continue;
8519                       abort ();
8520                     }
8521
8522                   input_section = p->u.indirect.section;
8523
8524                   /* Hack: reset the SEC_HAS_CONTENTS flag so that
8525                      elf_link_input_bfd ignores this section.  */
8526                   input_section->flags &= ~SEC_HAS_CONTENTS;
8527                 }
8528
8529               /* Skip this section later on (I don't think this
8530                  currently matters, but someday it might).  */
8531               o->link_order_head = NULL;
8532
8533               /* Really remove the section.  */
8534               for (secpp = &abfd->sections;
8535                    *secpp != o;
8536                    secpp = &(*secpp)->next)
8537                 ;
8538               bfd_section_list_remove (abfd, secpp);
8539               --abfd->section_count;
8540
8541               continue;
8542             }
8543
8544           /* There is one gptab for initialized data, and one for
8545              uninitialized data.  */
8546           if (strcmp (o->name, ".gptab.sdata") == 0)
8547             gptab_data_sec = o;
8548           else if (strcmp (o->name, ".gptab.sbss") == 0)
8549             gptab_bss_sec = o;
8550           else
8551             {
8552               (*_bfd_error_handler)
8553                 (_("%s: illegal section name `%s'"),
8554                  bfd_get_filename (abfd), o->name);
8555               bfd_set_error (bfd_error_nonrepresentable_section);
8556               return FALSE;
8557             }
8558
8559           /* The linker script always combines .gptab.data and
8560              .gptab.sdata into .gptab.sdata, and likewise for
8561              .gptab.bss and .gptab.sbss.  It is possible that there is
8562              no .sdata or .sbss section in the output file, in which
8563              case we must change the name of the output section.  */
8564           subname = o->name + sizeof ".gptab" - 1;
8565           if (bfd_get_section_by_name (abfd, subname) == NULL)
8566             {
8567               if (o == gptab_data_sec)
8568                 o->name = ".gptab.data";
8569               else
8570                 o->name = ".gptab.bss";
8571               subname = o->name + sizeof ".gptab" - 1;
8572               BFD_ASSERT (bfd_get_section_by_name (abfd, subname) != NULL);
8573             }
8574
8575           /* Set up the first entry.  */
8576           c = 1;
8577           amt = c * sizeof (Elf32_gptab);
8578           tab = bfd_malloc (amt);
8579           if (tab == NULL)
8580             return FALSE;
8581           tab[0].gt_header.gt_current_g_value = elf_gp_size (abfd);
8582           tab[0].gt_header.gt_unused = 0;
8583
8584           /* Combine the input sections.  */
8585           for (p = o->link_order_head; p != NULL; p = p->next)
8586             {
8587               asection *input_section;
8588               bfd *input_bfd;
8589               bfd_size_type size;
8590               unsigned long last;
8591               bfd_size_type gpentry;
8592
8593               if (p->type != bfd_indirect_link_order)
8594                 {
8595                   if (p->type == bfd_data_link_order)
8596                     continue;
8597                   abort ();
8598                 }
8599
8600               input_section = p->u.indirect.section;
8601               input_bfd = input_section->owner;
8602
8603               /* Combine the gptab entries for this input section one
8604                  by one.  We know that the input gptab entries are
8605                  sorted by ascending -G value.  */
8606               size = input_section->size;
8607               last = 0;
8608               for (gpentry = sizeof (Elf32_External_gptab);
8609                    gpentry < size;
8610                    gpentry += sizeof (Elf32_External_gptab))
8611                 {
8612                   Elf32_External_gptab ext_gptab;
8613                   Elf32_gptab int_gptab;
8614                   unsigned long val;
8615                   unsigned long add;
8616                   bfd_boolean exact;
8617                   unsigned int look;
8618
8619                   if (! (bfd_get_section_contents
8620                          (input_bfd, input_section, &ext_gptab, gpentry,
8621                           sizeof (Elf32_External_gptab))))
8622                     {
8623                       free (tab);
8624                       return FALSE;
8625                     }
8626
8627                   bfd_mips_elf32_swap_gptab_in (input_bfd, &ext_gptab,
8628                                                 &int_gptab);
8629                   val = int_gptab.gt_entry.gt_g_value;
8630                   add = int_gptab.gt_entry.gt_bytes - last;
8631
8632                   exact = FALSE;
8633                   for (look = 1; look < c; look++)
8634                     {
8635                       if (tab[look].gt_entry.gt_g_value >= val)
8636                         tab[look].gt_entry.gt_bytes += add;
8637
8638                       if (tab[look].gt_entry.gt_g_value == val)
8639                         exact = TRUE;
8640                     }
8641
8642                   if (! exact)
8643                     {
8644                       Elf32_gptab *new_tab;
8645                       unsigned int max;
8646
8647                       /* We need a new table entry.  */
8648                       amt = (bfd_size_type) (c + 1) * sizeof (Elf32_gptab);
8649                       new_tab = bfd_realloc (tab, amt);
8650                       if (new_tab == NULL)
8651                         {
8652                           free (tab);
8653                           return FALSE;
8654                         }
8655                       tab = new_tab;
8656                       tab[c].gt_entry.gt_g_value = val;
8657                       tab[c].gt_entry.gt_bytes = add;
8658
8659                       /* Merge in the size for the next smallest -G
8660                          value, since that will be implied by this new
8661                          value.  */
8662                       max = 0;
8663                       for (look = 1; look < c; look++)
8664                         {
8665                           if (tab[look].gt_entry.gt_g_value < val
8666                               && (max == 0
8667                                   || (tab[look].gt_entry.gt_g_value
8668                                       > tab[max].gt_entry.gt_g_value)))
8669                             max = look;
8670                         }
8671                       if (max != 0)
8672                         tab[c].gt_entry.gt_bytes +=
8673                           tab[max].gt_entry.gt_bytes;
8674
8675                       ++c;
8676                     }
8677
8678                   last = int_gptab.gt_entry.gt_bytes;
8679                 }
8680
8681               /* Hack: reset the SEC_HAS_CONTENTS flag so that
8682                  elf_link_input_bfd ignores this section.  */
8683               input_section->flags &= ~SEC_HAS_CONTENTS;
8684             }
8685
8686           /* The table must be sorted by -G value.  */
8687           if (c > 2)
8688             qsort (tab + 1, c - 1, sizeof (tab[0]), gptab_compare);
8689
8690           /* Swap out the table.  */
8691           amt = (bfd_size_type) c * sizeof (Elf32_External_gptab);
8692           ext_tab = bfd_alloc (abfd, amt);
8693           if (ext_tab == NULL)
8694             {
8695               free (tab);
8696               return FALSE;
8697             }
8698
8699           for (j = 0; j < c; j++)
8700             bfd_mips_elf32_swap_gptab_out (abfd, tab + j, ext_tab + j);
8701           free (tab);
8702
8703           o->size = c * sizeof (Elf32_External_gptab);
8704           o->contents = (bfd_byte *) ext_tab;
8705
8706           /* Skip this section later on (I don't think this currently
8707              matters, but someday it might).  */
8708           o->link_order_head = NULL;
8709         }
8710     }
8711
8712   /* Invoke the regular ELF backend linker to do all the work.  */
8713   if (!bfd_elf_final_link (abfd, info))
8714     return FALSE;
8715
8716   /* Now write out the computed sections.  */
8717
8718   if (reginfo_sec != NULL)
8719     {
8720       Elf32_External_RegInfo ext;
8721
8722       bfd_mips_elf32_swap_reginfo_out (abfd, &reginfo, &ext);
8723       if (! bfd_set_section_contents (abfd, reginfo_sec, &ext, 0, sizeof ext))
8724         return FALSE;
8725     }
8726
8727   if (mdebug_sec != NULL)
8728     {
8729       BFD_ASSERT (abfd->output_has_begun);
8730       if (! bfd_ecoff_write_accumulated_debug (mdebug_handle, abfd, &debug,
8731                                                swap, info,
8732                                                mdebug_sec->filepos))
8733         return FALSE;
8734
8735       bfd_ecoff_debug_free (mdebug_handle, abfd, &debug, swap, info);
8736     }
8737
8738   if (gptab_data_sec != NULL)
8739     {
8740       if (! bfd_set_section_contents (abfd, gptab_data_sec,
8741                                       gptab_data_sec->contents,
8742                                       0, gptab_data_sec->size))
8743         return FALSE;
8744     }
8745
8746   if (gptab_bss_sec != NULL)
8747     {
8748       if (! bfd_set_section_contents (abfd, gptab_bss_sec,
8749                                       gptab_bss_sec->contents,
8750                                       0, gptab_bss_sec->size))
8751         return FALSE;
8752     }
8753
8754   if (SGI_COMPAT (abfd))
8755     {
8756       rtproc_sec = bfd_get_section_by_name (abfd, ".rtproc");
8757       if (rtproc_sec != NULL)
8758         {
8759           if (! bfd_set_section_contents (abfd, rtproc_sec,
8760                                           rtproc_sec->contents,
8761                                           0, rtproc_sec->size))
8762             return FALSE;
8763         }
8764     }
8765
8766   return TRUE;
8767 }
8768 \f
8769 /* Structure for saying that BFD machine EXTENSION extends BASE.  */
8770
8771 struct mips_mach_extension {
8772   unsigned long extension, base;
8773 };
8774
8775
8776 /* An array describing how BFD machines relate to one another.  The entries
8777    are ordered topologically with MIPS I extensions listed last.  */
8778
8779 static const struct mips_mach_extension mips_mach_extensions[] = {
8780   /* MIPS64 extensions.  */
8781   { bfd_mach_mipsisa64r2, bfd_mach_mipsisa64 },
8782   { bfd_mach_mips_sb1, bfd_mach_mipsisa64 },
8783
8784   /* MIPS V extensions.  */
8785   { bfd_mach_mipsisa64, bfd_mach_mips5 },
8786
8787   /* R10000 extensions.  */
8788   { bfd_mach_mips12000, bfd_mach_mips10000 },
8789
8790   /* R5000 extensions.  Note: the vr5500 ISA is an extension of the core
8791      vr5400 ISA, but doesn't include the multimedia stuff.  It seems
8792      better to allow vr5400 and vr5500 code to be merged anyway, since
8793      many libraries will just use the core ISA.  Perhaps we could add
8794      some sort of ASE flag if this ever proves a problem.  */
8795   { bfd_mach_mips5500, bfd_mach_mips5400 },
8796   { bfd_mach_mips5400, bfd_mach_mips5000 },
8797
8798   /* MIPS IV extensions.  */
8799   { bfd_mach_mips5, bfd_mach_mips8000 },
8800   { bfd_mach_mips10000, bfd_mach_mips8000 },
8801   { bfd_mach_mips5000, bfd_mach_mips8000 },
8802   { bfd_mach_mips7000, bfd_mach_mips8000 },
8803
8804   /* VR4100 extensions.  */
8805   { bfd_mach_mips4120, bfd_mach_mips4100 },
8806   { bfd_mach_mips4111, bfd_mach_mips4100 },
8807
8808   /* MIPS III extensions.  */
8809   { bfd_mach_mips8000, bfd_mach_mips4000 },
8810   { bfd_mach_mips4650, bfd_mach_mips4000 },
8811   { bfd_mach_mips4600, bfd_mach_mips4000 },
8812   { bfd_mach_mips4400, bfd_mach_mips4000 },
8813   { bfd_mach_mips4300, bfd_mach_mips4000 },
8814   { bfd_mach_mips4100, bfd_mach_mips4000 },
8815   { bfd_mach_mips4010, bfd_mach_mips4000 },
8816
8817   /* MIPS32 extensions.  */
8818   { bfd_mach_mipsisa32r2, bfd_mach_mipsisa32 },
8819
8820   /* MIPS II extensions.  */
8821   { bfd_mach_mips4000, bfd_mach_mips6000 },
8822   { bfd_mach_mipsisa32, bfd_mach_mips6000 },
8823
8824   /* MIPS I extensions.  */
8825   { bfd_mach_mips6000, bfd_mach_mips3000 },
8826   { bfd_mach_mips3900, bfd_mach_mips3000 }
8827 };
8828
8829
8830 /* Return true if bfd machine EXTENSION is an extension of machine BASE.  */
8831
8832 static bfd_boolean
8833 mips_mach_extends_p (unsigned long base, unsigned long extension)
8834 {
8835   size_t i;
8836
8837   for (i = 0; extension != base && i < ARRAY_SIZE (mips_mach_extensions); i++)
8838     if (extension == mips_mach_extensions[i].extension)
8839       extension = mips_mach_extensions[i].base;
8840
8841   return extension == base;
8842 }
8843
8844
8845 /* Return true if the given ELF header flags describe a 32-bit binary.  */
8846
8847 static bfd_boolean
8848 mips_32bit_flags_p (flagword flags)
8849 {
8850   return ((flags & EF_MIPS_32BITMODE) != 0
8851           || (flags & EF_MIPS_ABI) == E_MIPS_ABI_O32
8852           || (flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI32
8853           || (flags & EF_MIPS_ARCH) == E_MIPS_ARCH_1
8854           || (flags & EF_MIPS_ARCH) == E_MIPS_ARCH_2
8855           || (flags & EF_MIPS_ARCH) == E_MIPS_ARCH_32
8856           || (flags & EF_MIPS_ARCH) == E_MIPS_ARCH_32R2);
8857 }
8858
8859
8860 /* Merge backend specific data from an object file to the output
8861    object file when linking.  */
8862
8863 bfd_boolean
8864 _bfd_mips_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
8865 {
8866   flagword old_flags;
8867   flagword new_flags;
8868   bfd_boolean ok;
8869   bfd_boolean null_input_bfd = TRUE;
8870   asection *sec;
8871
8872   /* Check if we have the same endianess */
8873   if (! _bfd_generic_verify_endian_match (ibfd, obfd))
8874     {
8875       (*_bfd_error_handler)
8876         (_("%B: endianness incompatible with that of the selected emulation"),
8877          ibfd);
8878       return FALSE;
8879     }
8880
8881   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
8882       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
8883     return TRUE;
8884
8885   if (strcmp (bfd_get_target (ibfd), bfd_get_target (obfd)) != 0)
8886     {
8887       (*_bfd_error_handler)
8888         (_("%B: ABI is incompatible with that of the selected emulation"),
8889          ibfd);
8890       return FALSE;
8891     }
8892
8893   new_flags = elf_elfheader (ibfd)->e_flags;
8894   elf_elfheader (obfd)->e_flags |= new_flags & EF_MIPS_NOREORDER;
8895   old_flags = elf_elfheader (obfd)->e_flags;
8896
8897   if (! elf_flags_init (obfd))
8898     {
8899       elf_flags_init (obfd) = TRUE;
8900       elf_elfheader (obfd)->e_flags = new_flags;
8901       elf_elfheader (obfd)->e_ident[EI_CLASS]
8902         = elf_elfheader (ibfd)->e_ident[EI_CLASS];
8903
8904       if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
8905           && bfd_get_arch_info (obfd)->the_default)
8906         {
8907           if (! bfd_set_arch_mach (obfd, bfd_get_arch (ibfd),
8908                                    bfd_get_mach (ibfd)))
8909             return FALSE;
8910         }
8911
8912       return TRUE;
8913     }
8914
8915   /* Check flag compatibility.  */
8916
8917   new_flags &= ~EF_MIPS_NOREORDER;
8918   old_flags &= ~EF_MIPS_NOREORDER;
8919
8920   /* Some IRIX 6 BSD-compatibility objects have this bit set.  It
8921      doesn't seem to matter.  */
8922   new_flags &= ~EF_MIPS_XGOT;
8923   old_flags &= ~EF_MIPS_XGOT;
8924
8925   /* MIPSpro generates ucode info in n64 objects.  Again, we should
8926      just be able to ignore this.  */
8927   new_flags &= ~EF_MIPS_UCODE;
8928   old_flags &= ~EF_MIPS_UCODE;
8929
8930   if (new_flags == old_flags)
8931     return TRUE;
8932
8933   /* Check to see if the input BFD actually contains any sections.
8934      If not, its flags may not have been initialised either, but it cannot
8935      actually cause any incompatibility.  */
8936   for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8937     {
8938       /* Ignore synthetic sections and empty .text, .data and .bss sections
8939           which are automatically generated by gas.  */
8940       if (strcmp (sec->name, ".reginfo")
8941           && strcmp (sec->name, ".mdebug")
8942           && (sec->size != 0
8943               || (strcmp (sec->name, ".text")
8944                   && strcmp (sec->name, ".data")
8945                   && strcmp (sec->name, ".bss"))))
8946         {
8947           null_input_bfd = FALSE;
8948           break;
8949         }
8950     }
8951   if (null_input_bfd)
8952     return TRUE;
8953
8954   ok = TRUE;
8955
8956   if (((new_flags & (EF_MIPS_PIC | EF_MIPS_CPIC)) != 0)
8957       != ((old_flags & (EF_MIPS_PIC | EF_MIPS_CPIC)) != 0))
8958     {
8959       (*_bfd_error_handler)
8960         (_("%B: warning: linking PIC files with non-PIC files"),
8961          ibfd);
8962       ok = TRUE;
8963     }
8964
8965   if (new_flags & (EF_MIPS_PIC | EF_MIPS_CPIC))
8966     elf_elfheader (obfd)->e_flags |= EF_MIPS_CPIC;
8967   if (! (new_flags & EF_MIPS_PIC))
8968     elf_elfheader (obfd)->e_flags &= ~EF_MIPS_PIC;
8969
8970   new_flags &= ~ (EF_MIPS_PIC | EF_MIPS_CPIC);
8971   old_flags &= ~ (EF_MIPS_PIC | EF_MIPS_CPIC);
8972
8973   /* Compare the ISAs.  */
8974   if (mips_32bit_flags_p (old_flags) != mips_32bit_flags_p (new_flags))
8975     {
8976       (*_bfd_error_handler)
8977         (_("%B: linking 32-bit code with 64-bit code"),
8978          ibfd);
8979       ok = FALSE;
8980     }
8981   else if (!mips_mach_extends_p (bfd_get_mach (ibfd), bfd_get_mach (obfd)))
8982     {
8983       /* OBFD's ISA isn't the same as, or an extension of, IBFD's.  */
8984       if (mips_mach_extends_p (bfd_get_mach (obfd), bfd_get_mach (ibfd)))
8985         {
8986           /* Copy the architecture info from IBFD to OBFD.  Also copy
8987              the 32-bit flag (if set) so that we continue to recognise
8988              OBFD as a 32-bit binary.  */
8989           bfd_set_arch_info (obfd, bfd_get_arch_info (ibfd));
8990           elf_elfheader (obfd)->e_flags &= ~(EF_MIPS_ARCH | EF_MIPS_MACH);
8991           elf_elfheader (obfd)->e_flags
8992             |= new_flags & (EF_MIPS_ARCH | EF_MIPS_MACH | EF_MIPS_32BITMODE);
8993
8994           /* Copy across the ABI flags if OBFD doesn't use them
8995              and if that was what caused us to treat IBFD as 32-bit.  */
8996           if ((old_flags & EF_MIPS_ABI) == 0
8997               && mips_32bit_flags_p (new_flags)
8998               && !mips_32bit_flags_p (new_flags & ~EF_MIPS_ABI))
8999             elf_elfheader (obfd)->e_flags |= new_flags & EF_MIPS_ABI;
9000         }
9001       else
9002         {
9003           /* The ISAs aren't compatible.  */
9004           (*_bfd_error_handler)
9005             (_("%B: linking %s module with previous %s modules"),
9006              ibfd,
9007              bfd_printable_name (ibfd),
9008              bfd_printable_name (obfd));
9009           ok = FALSE;
9010         }
9011     }
9012
9013   new_flags &= ~(EF_MIPS_ARCH | EF_MIPS_MACH | EF_MIPS_32BITMODE);
9014   old_flags &= ~(EF_MIPS_ARCH | EF_MIPS_MACH | EF_MIPS_32BITMODE);
9015
9016   /* Compare ABIs.  The 64-bit ABI does not use EF_MIPS_ABI.  But, it
9017      does set EI_CLASS differently from any 32-bit ABI.  */
9018   if ((new_flags & EF_MIPS_ABI) != (old_flags & EF_MIPS_ABI)
9019       || (elf_elfheader (ibfd)->e_ident[EI_CLASS]
9020           != elf_elfheader (obfd)->e_ident[EI_CLASS]))
9021     {
9022       /* Only error if both are set (to different values).  */
9023       if (((new_flags & EF_MIPS_ABI) && (old_flags & EF_MIPS_ABI))
9024           || (elf_elfheader (ibfd)->e_ident[EI_CLASS]
9025               != elf_elfheader (obfd)->e_ident[EI_CLASS]))
9026         {
9027           (*_bfd_error_handler)
9028             (_("%B: ABI mismatch: linking %s module with previous %s modules"),
9029              ibfd,
9030              elf_mips_abi_name (ibfd),
9031              elf_mips_abi_name (obfd));
9032           ok = FALSE;
9033         }
9034       new_flags &= ~EF_MIPS_ABI;
9035       old_flags &= ~EF_MIPS_ABI;
9036     }
9037
9038   /* For now, allow arbitrary mixing of ASEs (retain the union).  */
9039   if ((new_flags & EF_MIPS_ARCH_ASE) != (old_flags & EF_MIPS_ARCH_ASE))
9040     {
9041       elf_elfheader (obfd)->e_flags |= new_flags & EF_MIPS_ARCH_ASE;
9042
9043       new_flags &= ~ EF_MIPS_ARCH_ASE;
9044       old_flags &= ~ EF_MIPS_ARCH_ASE;
9045     }
9046
9047   /* Warn about any other mismatches */
9048   if (new_flags != old_flags)
9049     {
9050       (*_bfd_error_handler)
9051         (_("%B: uses different e_flags (0x%lx) fields than previous modules (0x%lx)"),
9052          ibfd, (unsigned long) new_flags,
9053          (unsigned long) old_flags);
9054       ok = FALSE;
9055     }
9056
9057   if (! ok)
9058     {
9059       bfd_set_error (bfd_error_bad_value);
9060       return FALSE;
9061     }
9062
9063   return TRUE;
9064 }
9065
9066 /* Function to keep MIPS specific file flags like as EF_MIPS_PIC.  */
9067
9068 bfd_boolean
9069 _bfd_mips_elf_set_private_flags (bfd *abfd, flagword flags)
9070 {
9071   BFD_ASSERT (!elf_flags_init (abfd)
9072               || elf_elfheader (abfd)->e_flags == flags);
9073
9074   elf_elfheader (abfd)->e_flags = flags;
9075   elf_flags_init (abfd) = TRUE;
9076   return TRUE;
9077 }
9078
9079 bfd_boolean
9080 _bfd_mips_elf_print_private_bfd_data (bfd *abfd, void *ptr)
9081 {
9082   FILE *file = ptr;
9083
9084   BFD_ASSERT (abfd != NULL && ptr != NULL);
9085
9086   /* Print normal ELF private data.  */
9087   _bfd_elf_print_private_bfd_data (abfd, ptr);
9088
9089   /* xgettext:c-format */
9090   fprintf (file, _("private flags = %lx:"), elf_elfheader (abfd)->e_flags);
9091
9092   if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI) == E_MIPS_ABI_O32)
9093     fprintf (file, _(" [abi=O32]"));
9094   else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI) == E_MIPS_ABI_O64)
9095     fprintf (file, _(" [abi=O64]"));
9096   else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI32)
9097     fprintf (file, _(" [abi=EABI32]"));
9098   else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64)
9099     fprintf (file, _(" [abi=EABI64]"));
9100   else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ABI))
9101     fprintf (file, _(" [abi unknown]"));
9102   else if (ABI_N32_P (abfd))
9103     fprintf (file, _(" [abi=N32]"));
9104   else if (ABI_64_P (abfd))
9105     fprintf (file, _(" [abi=64]"));
9106   else
9107     fprintf (file, _(" [no abi set]"));
9108
9109   if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_1)
9110     fprintf (file, _(" [mips1]"));
9111   else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_2)
9112     fprintf (file, _(" [mips2]"));
9113   else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_3)
9114     fprintf (file, _(" [mips3]"));
9115   else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_4)
9116     fprintf (file, _(" [mips4]"));
9117   else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_5)
9118     fprintf (file, _(" [mips5]"));
9119   else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_32)
9120     fprintf (file, _(" [mips32]"));
9121   else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_64)
9122     fprintf (file, _(" [mips64]"));
9123   else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_32R2)
9124     fprintf (file, _(" [mips32r2]"));
9125   else if ((elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_64R2)
9126     fprintf (file, _(" [mips64r2]"));
9127   else
9128     fprintf (file, _(" [unknown ISA]"));
9129
9130   if (elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH_ASE_MDMX)
9131     fprintf (file, _(" [mdmx]"));
9132
9133   if (elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH_ASE_M16)
9134     fprintf (file, _(" [mips16]"));
9135
9136   if (elf_elfheader (abfd)->e_flags & EF_MIPS_32BITMODE)
9137     fprintf (file, _(" [32bitmode]"));
9138   else
9139     fprintf (file, _(" [not 32bitmode]"));
9140
9141   fputc ('\n', file);
9142
9143   return TRUE;
9144 }
9145
9146 struct bfd_elf_special_section const _bfd_mips_elf_special_sections[]=
9147 {
9148   { ".sdata",  6, -2, SHT_PROGBITS,   SHF_ALLOC + SHF_WRITE + SHF_MIPS_GPREL },
9149   { ".sbss",   5, -2, SHT_NOBITS,     SHF_ALLOC + SHF_WRITE + SHF_MIPS_GPREL },
9150   { ".lit4",   5,  0, SHT_PROGBITS,   SHF_ALLOC + SHF_WRITE + SHF_MIPS_GPREL },
9151   { ".lit8",   5,  0, SHT_PROGBITS,   SHF_ALLOC + SHF_WRITE + SHF_MIPS_GPREL },
9152   { ".ucode",  6,  0, SHT_MIPS_UCODE, 0 },
9153   { ".mdebug", 7,  0, SHT_MIPS_DEBUG, 0 },
9154   { NULL,      0,  0, 0,              0 }
9155 };