bfd/elfxx-mips.c

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