bfd/elf32-mips.c

   1 /* MIPS-specific support for 32-bit ELF
   2    Copyright 1993 Free Software Foundation, Inc.
   3
   4    Most of the information added by Ian Lance Taylor, Cygnus Support,
   5    <[email protected]>.
   6
   7 This file is part of BFD, the Binary File Descriptor library.
   8
   9 This program is free software; you can redistribute it and/or modify
  10 it under the terms of the GNU General Public License as published by
  11 the Free Software Foundation; either version 2 of the License, or
  12 (at your option) any later version.
  13
  14 This program is distributed in the hope that it will be useful,
  15 but WITHOUT ANY WARRANTY; without even the implied warranty of
  16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17 GNU General Public License for more details.
  18
  19 You should have received a copy of the GNU General Public License
  20 along with this program; if not, write to the Free Software
  21 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  22
  23 #include "bfd.h"
  24 #include "sysdep.h"
  25 #include "libbfd.h"
  26 #include "bfdlink.h"
  27 #include "genlink.h"
  28 #include "libelf.h"
  29 #include "elf/mips.h"
  30
  31 /* Get the ECOFF swapping routines.  */
  32 #include "coff/sym.h"
  33 #include "coff/symconst.h"
  34 #include "coff/internal.h"
  35 #include "coff/ecoff.h"
  36 #include "coff/mips.h"
  37 #define ECOFF_32
  38 #include "ecoffswap.h"
  39
  40 static bfd_reloc_status_type mips_elf_hi16_reloc PARAMS ((bfd *abfd,
  41                                                           arelent *reloc,
  42                                                           asymbol *symbol,
  43                                                           PTR data,
  44                                                           asection *section,
  45                                                           bfd *output_bfd,
  46                                                           char **error));
  47 static bfd_reloc_status_type mips_elf_got16_reloc PARAMS ((bfd *abfd,
  48                                                            arelent *reloc,
  49                                                            asymbol *symbol,
  50                                                            PTR data,
  51                                                            asection *section,
  52                                                            bfd *output_bfd,
  53                                                            char **error));
  54 static bfd_reloc_status_type mips_elf_lo16_reloc PARAMS ((bfd *abfd,
  55                                                           arelent *reloc,
  56                                                           asymbol *symbol,
  57                                                           PTR data,
  58                                                           asection *section,
  59                                                           bfd *output_bfd,
  60                                                           char **error));
  61 static bfd_reloc_status_type mips_elf_gprel16_reloc PARAMS ((bfd *abfd,
  62                                                              arelent *reloc,
  63                                                              asymbol *symbol,
  64                                                              PTR data,
  65                                                              asection *section,
  66                                                              bfd *output_bfd,
  67                                                              char **error));
  68
  69 #define USE_REL 1               /* MIPS uses REL relocations instead of RELA */
  70
  71 enum reloc_type
  72 {
  73   R_MIPS_NONE = 0,
  74   R_MIPS_16,            R_MIPS_32,
  75   R_MIPS_REL32,         R_MIPS_26,
  76   R_MIPS_HI16,          R_MIPS_LO16,
  77   R_MIPS_GPREL16,       R_MIPS_LITERAL,
  78   R_MIPS_GOT16,         R_MIPS_PC16,
  79   R_MIPS_CALL16,        R_MIPS_GPREL32,
  80   R_MIPS_max
  81 };
  82
  83 static reloc_howto_type elf_mips_howto_table[] =
  84 {
  85   /* No relocation.  */
  86   HOWTO (R_MIPS_NONE,           /* type */
  87          0,                     /* rightshift */
  88          0,                     /* size (0 = byte, 1 = short, 2 = long) */
  89          0,                     /* bitsize */
  90          false,                 /* pc_relative */
  91          0,                     /* bitpos */
  92          complain_overflow_dont, /* complain_on_overflow */
  93          bfd_elf_generic_reloc, /* special_function */
  94          "R_MIPS_NONE",         /* name */
  95          false,                 /* partial_inplace */
  96          0,                     /* src_mask */
  97          0,                     /* dst_mask */
  98          false),                /* pcrel_offset */
  99
 100   /* 16 bit relocation.  */
 101   HOWTO (R_MIPS_16,             /* type */
 102          0,                     /* rightshift */
 103          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 104          16,                    /* bitsize */
 105          false,                 /* pc_relative */
 106          0,                     /* bitpos */
 107          complain_overflow_bitfield, /* complain_on_overflow */
 108          bfd_elf_generic_reloc, /* special_function */
 109          "R_MIPS_16",           /* name */
 110          true,                  /* partial_inplace */
 111          0xffff,                /* src_mask */
 112          0xffff,                /* dst_mask */
 113          false),                /* pcrel_offset */
 114
 115   /* 32 bit relocation.  */
 116   HOWTO (R_MIPS_32,             /* type */
 117          0,                     /* rightshift */
 118          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 119          32,                    /* bitsize */
 120          false,                 /* pc_relative */
 121          0,                     /* bitpos */
 122          complain_overflow_bitfield, /* complain_on_overflow */
 123          bfd_elf_generic_reloc, /* special_function */
 124          "R_MIPS_32",           /* name */
 125          true,                  /* partial_inplace */
 126          0xffffffff,            /* src_mask */
 127          0xffffffff,            /* dst_mask */
 128          false),                /* pcrel_offset */
 129
 130   /* 32 bit symbol relative relocation.  */
 131   HOWTO (R_MIPS_REL32,          /* type */
 132          0,                     /* rightshift */
 133          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 134          32,                    /* bitsize */
 135          false,                 /* pc_relative */
 136          0,                     /* bitpos */
 137          complain_overflow_bitfield, /* complain_on_overflow */
 138          bfd_elf_generic_reloc, /* special_function */
 139          "R_MIPS_REL32",        /* name */
 140          true,                  /* partial_inplace */
 141          0xffffffff,            /* src_mask */
 142          0xffffffff,            /* dst_mask */
 143          false),                /* pcrel_offset */
 144
 145   /* 26 bit branch address.  */
 146   HOWTO (R_MIPS_26,             /* type */
 147          2,                     /* rightshift */
 148          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 149          26,                    /* bitsize */
 150          false,                 /* pc_relative */
 151          0,                     /* bitpos */
 152          complain_overflow_dont, /* complain_on_overflow */
 153                                 /* This needs complex overflow
 154                                    detection, because the upper four
 155                                    bits must match the PC.  */
 156          bfd_elf_generic_reloc, /* special_function */
 157          "R_MIPS_26",           /* name */
 158          true,                  /* partial_inplace */
 159          0x3ffffff,             /* src_mask */
 160          0x3ffffff,             /* dst_mask */
 161          false),                /* pcrel_offset */
 162
 163   /* High 16 bits of symbol value.  */
 164   HOWTO (R_MIPS_HI16,           /* type */
 165          0,                     /* rightshift */
 166          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 167          16,                    /* bitsize */
 168          false,                 /* pc_relative */
 169          0,                     /* bitpos */
 170          complain_overflow_dont, /* complain_on_overflow */
 171          mips_elf_hi16_reloc,   /* special_function */
 172          "R_MIPS_HI16",         /* name */
 173          true,                  /* partial_inplace */
 174          0xffff,                /* src_mask */
 175          0xffff,                /* dst_mask */
 176          false),                /* pcrel_offset */
 177
 178   /* Low 16 bits of symbol value.  */
 179   HOWTO (R_MIPS_LO16,           /* type */
 180          0,                     /* rightshift */
 181          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 182          16,                    /* bitsize */
 183          false,                 /* pc_relative */
 184          0,                     /* bitpos */
 185          complain_overflow_dont, /* complain_on_overflow */
 186          mips_elf_lo16_reloc,   /* special_function */
 187          "R_MIPS_LO16",         /* name */
 188          true,                  /* partial_inplace */
 189          0xffff,                /* src_mask */
 190          0xffff,                /* dst_mask */
 191          false),                /* pcrel_offset */
 192
 193   /* GP relative reference.  */
 194   HOWTO (R_MIPS_GPREL16,        /* type */
 195          0,                     /* rightshift */
 196          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 197          16,                    /* bitsize */
 198          false,                 /* pc_relative */
 199          0,                     /* bitpos */
 200          complain_overflow_signed, /* complain_on_overflow */
 201          mips_elf_gprel16_reloc, /* special_function */
 202          "R_MIPS_GPREL16",      /* name */
 203          true,                  /* partial_inplace */
 204          0xffff,                /* src_mask */
 205          0xffff,                /* dst_mask */
 206          false),                /* pcrel_offset */
 207
 208   /* Reference to literal section.  */
 209   HOWTO (R_MIPS_LITERAL,        /* type */
 210          0,                     /* rightshift */
 211          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 212          16,                    /* bitsize */
 213          false,                 /* pc_relative */
 214          0,                     /* bitpos */
 215          complain_overflow_signed, /* complain_on_overflow */
 216          mips_elf_gprel16_reloc, /* special_function */
 217          "R_MIPS_LITERAL",      /* name */
 218          true,                  /* partial_inplace */
 219          0xffff,                /* src_mask */
 220          0xffff,                /* dst_mask */
 221          false),                /* pcrel_offset */
 222
 223   /* Reference to global offset table.  */
 224   /* FIXME: This is not handled correctly.  */
 225   HOWTO (R_MIPS_GOT16,          /* type */
 226          0,                     /* rightshift */
 227          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 228          16,                    /* bitsize */
 229          false,                 /* pc_relative */
 230          0,                     /* bitpos */
 231          complain_overflow_signed, /* complain_on_overflow */
 232          mips_elf_got16_reloc,  /* special_function */
 233          "R_MIPS_GOT16",        /* name */
 234          false,                 /* partial_inplace */
 235          0,                     /* src_mask */
 236          0xffff,                /* dst_mask */
 237          false),                /* pcrel_offset */
 238
 239   /* 16 bit PC relative reference.  */
 240   HOWTO (R_MIPS_PC16,           /* type */
 241          0,                     /* rightshift */
 242          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 243          16,                    /* bitsize */
 244          true,                  /* pc_relative */
 245          0,                     /* bitpos */
 246          complain_overflow_signed, /* complain_on_overflow */
 247          bfd_elf_generic_reloc, /* special_function */
 248          "R_MIPS_PC16",         /* name */
 249          true,                  /* partial_inplace */
 250          0xffff,                /* src_mask */
 251          0xffff,                /* dst_mask */
 252          false),                /* pcrel_offset */
 253
 254   /* 16 bit call through global offset table.  */
 255   /* FIXME: This is not handled correctly.  */
 256   HOWTO (R_MIPS_CALL16,         /* type */
 257          0,                     /* rightshift */
 258          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 259          16,                    /* bitsize */
 260          false,                 /* pc_relative */
 261          0,                     /* bitpos */
 262          complain_overflow_signed, /* complain_on_overflow */
 263          bfd_elf_generic_reloc, /* special_function */
 264          "R_MIPS_CALL16",       /* name */
 265          false,                 /* partial_inplace */
 266          0,                     /* src_mask */
 267          0xffff,                /* dst_mask */
 268          false),                /* pcrel_offset */
 269
 270   /* 32 bit GP relative reference.  */
 271   /* FIXME: This is not handled correctly.  */
 272   HOWTO (R_MIPS_GPREL32,        /* type */
 273          0,                     /* rightshift */
 274          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 275          32,                    /* bitsize */
 276          false,                 /* pc_relative */
 277          0,                     /* bitpos */
 278          complain_overflow_bitfield, /* complain_on_overflow */
 279          bfd_elf_generic_reloc, /* special_function */
 280          "R_MIPS_GPREL32",      /* name */
 281          true,                  /* partial_inplace */
 282          0xffffffff,            /* src_mask */
 283          0xffffffff,            /* dst_mask */
 284          false)                 /* pcrel_offset */
 285 };
 286
 287 /* Do a R_MIPS_HI16 relocation.  This has to be done in combination
 288    with a R_MIPS_LO16 reloc, because there is a carry from the LO16 to
 289    the HI16.  Here we just save the information we need; we do the
 290    actual relocation when we see the LO16.  MIPS ELF requires that the
 291    LO16 immediately follow the HI16, so this ought to work.  */
 292
 293 static bfd_byte *mips_hi16_addr;
 294 static bfd_vma mips_hi16_addend;
 295
 296 static bfd_reloc_status_type
 297 mips_elf_hi16_reloc (abfd,
 298                      reloc_entry,
 299                      symbol,
 300                      data,
 301                      input_section,
 302                      output_bfd,
 303                      error_message)
 304      bfd *abfd;
 305      arelent *reloc_entry;
 306      asymbol *symbol;
 307      PTR data;
 308      asection *input_section;
 309      bfd *output_bfd;
 310      char **error_message;
 311 {
 312   bfd_reloc_status_type ret;
 313   bfd_vma relocation;
 314
 315   /* If we're relocating, and this an external symbol, we don't want
 316      to change anything.  */
 317   if (output_bfd != (bfd *) NULL
 318       && (symbol->flags & BSF_SECTION_SYM) == 0
 319       && reloc_entry->addend == 0)
 320     {
 321       reloc_entry->address += input_section->output_offset;
 322       return bfd_reloc_ok;
 323     }
 324
 325   /* FIXME: The symbol _gp_disp requires special handling, which we do
 326      not do.  */
 327   if (strcmp (bfd_asymbol_name (symbol), "_gp_disp") == 0)
 328     abort ();
 329
 330   ret = bfd_reloc_ok;
 331   if (symbol->section == &bfd_und_section
 332       && output_bfd == (bfd *) NULL)
 333     ret = bfd_reloc_undefined;
 334
 335   if (bfd_is_com_section (symbol->section))
 336     relocation = 0;
 337   else
 338     relocation = symbol->value;
 339
 340   relocation += symbol->section->output_section->vma;
 341   relocation += symbol->section->output_offset;
 342   relocation += reloc_entry->addend;
 343
 344   if (reloc_entry->address > input_section->_cooked_size)
 345     return bfd_reloc_outofrange;
 346
 347   /* Save the information, and let LO16 do the actual relocation.  */
 348   mips_hi16_addr = (bfd_byte *) data + reloc_entry->address;
 349   mips_hi16_addend = relocation;
 350
 351   if (output_bfd != (bfd *) NULL)
 352     reloc_entry->address += input_section->output_offset;
 353
 354   return ret;
 355 }
 356
 357 /* Do a R_MIPS_LO16 relocation.  This is a straightforward 16 bit
 358    inplace relocation; this function exists in order to do the
 359    R_MIPS_HI16 relocation described above.  */
 360
 361 static bfd_reloc_status_type
 362 mips_elf_lo16_reloc (abfd,
 363                      reloc_entry,
 364                      symbol,
 365                      data,
 366                      input_section,
 367                      output_bfd,
 368                      error_message)
 369      bfd *abfd;
 370      arelent *reloc_entry;
 371      asymbol *symbol;
 372      PTR data;
 373      asection *input_section;
 374      bfd *output_bfd;
 375      char **error_message;
 376 {
 377   /* FIXME: The symbol _gp_disp requires special handling, which we do
 378      not do.  */
 379   if (output_bfd == (bfd *) NULL
 380       && strcmp (bfd_asymbol_name (symbol), "_gp_disp") == 0)
 381     abort ();
 382
 383   if (mips_hi16_addr != (bfd_byte *) NULL)
 384     {
 385       unsigned long insn;
 386       unsigned long val;
 387       unsigned long vallo;
 388
 389       /* Do the HI16 relocation.  Note that we actually don't need to
 390          know anything about the LO16 itself, except where to find the
 391          low 16 bits of the addend needed by the LO16.  */
 392       insn = bfd_get_32 (abfd, mips_hi16_addr);
 393       vallo = (bfd_get_32 (abfd, (bfd_byte *) data + reloc_entry->address)
 394                & 0xffff);
 395       val = ((insn & 0xffff) << 16) + vallo;
 396       val += mips_hi16_addend;
 397
 398       /* The low order 16 bits are always treated as a signed value.
 399          Therefore, a negative value in the low order bits requires an
 400          adjustment in the high order bits.  We need to make this
 401          adjustment in two ways: once for the bits we took from the
 402          data, and once for the bits we are putting back in to the
 403          data.  */
 404       if ((vallo & 0x8000) != 0)
 405         val -= 0x10000;
 406       if ((val & 0x8000) != 0)
 407         val += 0x10000;
 408
 409       insn = (insn &~ 0xffff) | ((val >> 16) & 0xffff);
 410       bfd_put_32 (abfd, insn, mips_hi16_addr);
 411
 412       mips_hi16_addr = (bfd_byte *) NULL;
 413     }
 414
 415   /* Now do the LO16 reloc in the usual way.  */
 416   return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
 417                                 input_section, output_bfd, error_message);
 418 }
 419
 420 /* Do a R_MIPS_GOT16 reloc.  This is a reloc against the global offset
 421    table used for PIC code.  If the symbol is an external symbol, the
 422    instruction is modified to contain the offset of the appropriate
 423    entry in the global offset table.  If the symbol is a section
 424    symbol, the next reloc is a R_MIPS_LO16 reloc.  The two 16 bit
 425    addends are combined to form the real addend against the section
 426    symbol; the GOT16 is modified to contain the offset of an entry in
 427    the global offset table, and the LO16 is modified to offset it
 428    appropriately.  Thus an offset larger than 16 bits requires a
 429    modified value in the global offset table.
 430
 431    This implementation suffices for the assembler, but the linker does
 432    not yet know how to create global offset tables.  */
 433
 434 static bfd_reloc_status_type
 435 mips_elf_got16_reloc (abfd,
 436                       reloc_entry,
 437                       symbol,
 438                       data,
 439                       input_section,
 440                       output_bfd,
 441                       error_message)
 442      bfd *abfd;
 443      arelent *reloc_entry;
 444      asymbol *symbol;
 445      PTR data;
 446      asection *input_section;
 447      bfd *output_bfd;
 448      char **error_message;
 449 {
 450   /* If we're relocating, and this an external symbol, we don't want
 451      to change anything.  */
 452   if (output_bfd != (bfd *) NULL
 453       && (symbol->flags & BSF_SECTION_SYM) == 0
 454       && reloc_entry->addend == 0)
 455     {
 456       reloc_entry->address += input_section->output_offset;
 457       return bfd_reloc_ok;
 458     }
 459
 460   /* If we're relocating, and this is a local symbol, we can handle it
 461      just like HI16.  */
 462   if (output_bfd != (bfd *) NULL
 463       && (symbol->flags & BSF_SECTION_SYM) != 0)
 464     return mips_elf_hi16_reloc (abfd, reloc_entry, symbol, data,
 465                                 input_section, output_bfd, error_message);
 466
 467   abort ();
 468 }
 469
 470 /* Do a R_MIPS_GPREL16 relocation.  This is a 16 bit value which must
 471    become the offset from the gp register.  This function also handles
 472    R_MIPS_LITERAL relocations, although those can be handled more
 473    cleverly because the entries in the .lit8 and .lit4 sections can be
 474    merged.  */
 475
 476 static bfd_reloc_status_type
 477 mips_elf_gprel16_reloc (abfd,
 478                         reloc_entry,
 479                         symbol,
 480                         data,
 481                         input_section,
 482                         output_bfd,
 483                         error_message)
 484      bfd *abfd;
 485      arelent *reloc_entry;
 486      asymbol *symbol;
 487      PTR data;
 488      asection *input_section;
 489      bfd *output_bfd;
 490      char **error_message;
 491 {
 492   boolean relocateable;
 493   bfd_vma relocation;
 494   unsigned long val;
 495   unsigned long insn;
 496
 497   /* If we're relocating, and this is an external symbol with no
 498      addend, we don't want to change anything.  We will only have an
 499      addend if this is a newly created reloc, not read from an ELF
 500      file.  */
 501   if (output_bfd != (bfd *) NULL
 502       && (symbol->flags & BSF_SECTION_SYM) == 0
 503       && reloc_entry->addend == 0)
 504     {
 505       reloc_entry->address += input_section->output_offset;
 506       return bfd_reloc_ok;
 507     }
 508
 509   if (output_bfd != (bfd *) NULL)
 510     relocateable = true;
 511   else
 512     {
 513       relocateable = false;
 514       output_bfd = symbol->section->output_section->owner;
 515     }
 516
 517   if (symbol->section == &bfd_und_section
 518       && relocateable == false)
 519     return bfd_reloc_undefined;
 520
 521   /* We have to figure out the gp value, so that we can adjust the
 522      symbol value correctly.  We look up the symbol _gp in the output
 523      BFD.  If we can't find it, we're stuck.  We cache it in the ELF
 524      target data.  We don't need to adjust the symbol value for an
 525      external symbol if we are producing relocateable output.  */
 526   if (elf_gp (output_bfd) == 0
 527       && (relocateable == false
 528           || (symbol->flags & BSF_SECTION_SYM) != 0))
 529     {
 530       if (relocateable != false)
 531         {
 532           /* Make up a value.  */
 533           elf_gp (output_bfd) =
 534             symbol->section->output_section->vma + 0x4000;
 535         }
 536       else
 537         {
 538           unsigned int count;
 539           asymbol **sym;
 540           unsigned int i;
 541
 542           count = bfd_get_symcount (output_bfd);
 543           sym = bfd_get_outsymbols (output_bfd);
 544
 545           if (sym == (asymbol **) NULL)
 546             i = count;
 547           else
 548             {
 549               for (i = 0; i < count; i++, sym++)
 550                 {
 551                   register CONST char *name;
 552
 553                   name = bfd_asymbol_name (*sym);
 554                   if (*name == '_' && strcmp (name, "_gp") == 0)
 555                     {
 556                       elf_gp (output_bfd) = bfd_asymbol_value (*sym);
 557                       break;
 558                     }
 559                 }
 560             }
 561
 562           if (i >= count)
 563             {
 564               /* Only get the error once.  */
 565               elf_gp (output_bfd) = 4;
 566               *error_message =
 567                 (char *) "GP relative relocation when _gp not defined";
 568               return bfd_reloc_dangerous;
 569             }
 570         }
 571     }
 572
 573   if (bfd_is_com_section (symbol->section))
 574     relocation = 0;
 575   else
 576     relocation = symbol->value;
 577
 578   relocation += symbol->section->output_section->vma;
 579   relocation += symbol->section->output_offset;
 580
 581   if (reloc_entry->address > input_section->_cooked_size)
 582     return bfd_reloc_outofrange;
 583
 584   insn = bfd_get_32 (abfd, (bfd_byte *) data + reloc_entry->address);
 585
 586   /* Set val to the offset into the section or symbol.  */
 587   val = ((insn & 0xffff) + reloc_entry->addend) & 0xffff;
 588   if (val & 0x8000)
 589     val -= 0x10000;
 590
 591   /* Adjust val for the final section location and GP value.  If we
 592      are producing relocateable output, we don't want to do this for
 593      an external symbol.  */
 594   if (relocateable == false
 595       || (symbol->flags & BSF_SECTION_SYM) != 0)
 596     val += relocation - elf_gp (output_bfd);
 597
 598   insn = (insn &~ 0xffff) | (val & 0xffff);
 599   bfd_put_32 (abfd, insn, (bfd_byte *) data + reloc_entry->address);
 600
 601   if (relocateable != false)
 602     reloc_entry->address += input_section->output_offset;
 603
 604   /* Make sure it fit in 16 bits.  */
 605   if (val >= 0x8000 && val < 0xffff8000)
 606     return bfd_reloc_overflow;
 607
 608   return bfd_reloc_ok;
 609 }
 610
 611 /* A mapping from BFD reloc types to MIPS ELF reloc types.  */
 612
 613 struct elf_reloc_map {
 614   bfd_reloc_code_real_type bfd_reloc_val;
 615   enum reloc_type elf_reloc_val;
 616 };
 617
 618 static CONST struct elf_reloc_map mips_reloc_map[] =
 619 {
 620   { BFD_RELOC_NONE, R_MIPS_NONE, },
 621   { BFD_RELOC_16, R_MIPS_16 },
 622   { BFD_RELOC_32, R_MIPS_32 },
 623   { BFD_RELOC_CTOR, R_MIPS_32 },
 624   { BFD_RELOC_32_PCREL, R_MIPS_REL32 },
 625   { BFD_RELOC_MIPS_JMP, R_MIPS_26 },
 626   { BFD_RELOC_HI16_S, R_MIPS_HI16 },
 627   { BFD_RELOC_LO16, R_MIPS_LO16 },
 628   { BFD_RELOC_MIPS_GPREL, R_MIPS_GPREL16 },
 629   { BFD_RELOC_MIPS_LITERAL, R_MIPS_LITERAL },
 630   { BFD_RELOC_MIPS_GOT16, R_MIPS_GOT16 },
 631   { BFD_RELOC_16_PCREL, R_MIPS_PC16 },
 632   { BFD_RELOC_MIPS_CALL16, R_MIPS_CALL16 },
 633   { BFD_RELOC_MIPS_GPREL32, R_MIPS_GPREL32 }
 634 };
 635
 636 /* Given a BFD reloc type, return a howto structure.  */
 637
 638 static CONST struct reloc_howto_struct *
 639 bfd_elf32_bfd_reloc_type_lookup (abfd, code)
 640      bfd *abfd;
 641      bfd_reloc_code_real_type code;
 642 {
 643   int i;
 644
 645   for (i = 0; i < sizeof (mips_reloc_map) / sizeof (struct elf_reloc_map); i++)
 646     {
 647       if (mips_reloc_map[i].bfd_reloc_val == code)
 648         return &elf_mips_howto_table[(int) mips_reloc_map[i].elf_reloc_val];
 649     }
 650   return NULL;
 651 }
 652
 653 /* Given a MIPS reloc type, fill in an arelent structure.  */
 654
 655 static void
 656 mips_info_to_howto_rel (abfd, cache_ptr, dst)
 657      bfd *abfd;
 658      arelent *cache_ptr;
 659      Elf32_Internal_Rel *dst;
 660 {
 661   unsigned int r_type;
 662
 663   r_type = ELF32_R_TYPE (dst->r_info);
 664   BFD_ASSERT (r_type < (unsigned int) R_MIPS_max);
 665   cache_ptr->howto = &elf_mips_howto_table[r_type];
 666
 667   /* The addend for a GPREL16 or LITERAL relocation comes from the GP
 668      value for the object file.  We get the addend now, rather than
 669      when we do the relocation, because the symbol manipulations done
 670      by the linker may cause us to lose track of the input BFD.  */
 671   if (((*cache_ptr->sym_ptr_ptr)->flags & BSF_SECTION_SYM) != 0
 672       && (r_type == (unsigned int) R_MIPS_GPREL16
 673           || r_type == (unsigned int) R_MIPS_LITERAL))
 674     cache_ptr->addend = elf_gp (abfd);
 675 }
 676 \f
 677 /* A .reginfo section holds a single Elf32_RegInfo structure.  These
 678    routines swap this structure in and out.  They are used outside of
 679    BFD, so they are globally visible.  */
 680
 681 void
 682 bfd_mips_elf32_swap_reginfo_in (abfd, ex, in)
 683      bfd *abfd;
 684      const Elf32_External_RegInfo *ex;
 685      Elf32_RegInfo *in;
 686 {
 687   in->ri_gprmask = bfd_h_get_32 (abfd, (bfd_byte *) ex->ri_gprmask);
 688   in->ri_cprmask[0] = bfd_h_get_32 (abfd, (bfd_byte *) ex->ri_cprmask[0]);
 689   in->ri_cprmask[1] = bfd_h_get_32 (abfd, (bfd_byte *) ex->ri_cprmask[1]);
 690   in->ri_cprmask[2] = bfd_h_get_32 (abfd, (bfd_byte *) ex->ri_cprmask[2]);
 691   in->ri_cprmask[3] = bfd_h_get_32 (abfd, (bfd_byte *) ex->ri_cprmask[3]);
 692   in->ri_gp_value = bfd_h_get_32 (abfd, (bfd_byte *) ex->ri_gp_value);
 693 }
 694
 695 void
 696 bfd_mips_elf32_swap_reginfo_out (abfd, in, ex)
 697      bfd *abfd;
 698      const Elf32_RegInfo *in;
 699      Elf32_External_RegInfo *ex;
 700 {
 701   bfd_h_put_32 (abfd, (bfd_vma) in->ri_gprmask,
 702                 (bfd_byte *) ex->ri_gprmask);
 703   bfd_h_put_32 (abfd, (bfd_vma) in->ri_cprmask[0],
 704                 (bfd_byte *) ex->ri_cprmask[0]);
 705   bfd_h_put_32 (abfd, (bfd_vma) in->ri_cprmask[1],
 706                 (bfd_byte *) ex->ri_cprmask[1]);
 707   bfd_h_put_32 (abfd, (bfd_vma) in->ri_cprmask[2],
 708                 (bfd_byte *) ex->ri_cprmask[2]);
 709   bfd_h_put_32 (abfd, (bfd_vma) in->ri_cprmask[3],
 710                 (bfd_byte *) ex->ri_cprmask[3]);
 711   bfd_h_put_32 (abfd, (bfd_vma) in->ri_gp_value,
 712                 (bfd_byte *) ex->ri_gp_value);
 713 }
 714 \f
 715 /* Determine whether a symbol is global for the purposes of splitting
 716    the symbol table into global symbols and local symbols.  At least
 717    on Irix 5, this split must be between section symbols and all other
 718    symbols.  On most ELF targets the split is between static symbols
 719    and externally visible symbols.  */
 720
 721 /*ARGSUSED*/
 722 static boolean
 723 mips_elf_sym_is_global (abfd, sym)
 724      bfd *abfd;
 725      asymbol *sym;
 726 {
 727   return (sym->flags & BSF_SECTION_SYM) == 0 ? true : false;
 728 }
 729 \f
 730 /* Set the right machine number for a MIPS ELF file.  */
 731
 732 static boolean
 733 mips_elf_object_p (abfd)
 734      bfd *abfd;
 735 {
 736   switch (elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH)
 737     {
 738     default:
 739     case E_MIPS_ARCH_1:
 740       /* Just use the default, which was set in elfcode.h.  */
 741       break;
 742
 743     case E_MIPS_ARCH_2:
 744       (void) bfd_default_set_arch_mach (abfd, bfd_arch_mips, 6000);
 745       break;
 746
 747     case E_MIPS_ARCH_3:
 748       (void) bfd_default_set_arch_mach (abfd, bfd_arch_mips, 4000);
 749       break;
 750     }
 751
 752   return true;
 753 }
 754
 755 /* The final processing done just before writing out a MIPS ELF object
 756    file.  This gets the MIPS architecture right based on the machine
 757    number.  */
 758
 759 static void
 760 mips_elf_final_write_processing (abfd)
 761      bfd *abfd;
 762 {
 763   unsigned long val;
 764
 765   switch (bfd_get_mach (abfd))
 766     {
 767     case 3000:
 768       val = E_MIPS_ARCH_1;
 769       break;
 770
 771     case 6000:
 772       val = E_MIPS_ARCH_2;
 773       break;
 774
 775     case 4000:
 776       val = E_MIPS_ARCH_3;
 777       break;
 778
 779     default:
 780       return;
 781     }
 782
 783   elf_elfheader (abfd)->e_flags &=~ EF_MIPS_ARCH;
 784   elf_elfheader (abfd)->e_flags |= val;
 785 }
 786 \f
 787 /* Handle a MIPS specific section when reading an object file.  This
 788    is called when elfcode.h finds a section with an unknown type.
 789    FIXME: We need to handle the SHF_MIPS_GPREL flag, but I'm not sure
 790    how to.  */
 791
 792 static boolean
 793 mips_elf_section_from_shdr (abfd, hdr, name)
 794      bfd *abfd;
 795      Elf32_Internal_Shdr *hdr;
 796      char *name;
 797 {
 798   /* There ought to be a place to keep ELF backend specific flags, but
 799      at the moment there isn't one.  We just keep track of the
 800      sections by their name, instead.  Fortunately, the ABI gives
 801      suggested names for all the MIPS specific sections, so we will
 802      probably get away with this.  */
 803   switch (hdr->sh_type)
 804     {
 805     case SHT_MIPS_LIBLIST:
 806       if (strcmp (name, ".liblist") != 0)
 807         return false;
 808       break;
 809     case SHT_MIPS_CONFLICT:
 810       if (strcmp (name, ".conflict") != 0)
 811         return false;
 812       break;
 813     case SHT_MIPS_GPTAB:
 814       if (strncmp (name, ".gptab.", sizeof ".gptab." - 1) != 0)
 815         return false;
 816       break;
 817     case SHT_MIPS_UCODE:
 818       if (strcmp (name, ".ucode") != 0)
 819         return false;
 820       break;
 821     case SHT_MIPS_DEBUG:
 822       if (strcmp (name, ".mdebug") != 0)
 823         return false;
 824       break;
 825     case SHT_MIPS_REGINFO:
 826       if (strcmp (name, ".reginfo") != 0
 827           || hdr->sh_size != sizeof (Elf32_External_RegInfo))
 828         return false;
 829       break;
 830     case SHT_MIPS_OPTIONS:
 831       if (strcmp (name, ".options") != 0)
 832         return false;
 833       break;
 834     default:
 835       return false;
 836     }
 837
 838   if (hdr->rawdata == NULL)
 839     {
 840       asection *newsect;
 841
 842       newsect = bfd_make_section (abfd, name);
 843       if (newsect != NULL)
 844         {
 845           newsect->filepos = hdr->sh_offset;
 846           newsect->flags |= SEC_HAS_CONTENTS;
 847           newsect->vma = hdr->sh_addr;
 848           newsect->_raw_size = hdr->sh_size;
 849           newsect->alignment_power = bfd_log2 (hdr->sh_addralign);
 850
 851           if (hdr->sh_flags & SHF_ALLOC)
 852             {
 853               newsect->flags |= SEC_ALLOC;
 854               newsect->flags |= SEC_LOAD;
 855             }
 856
 857           if (!(hdr->sh_flags & SHF_WRITE))
 858             newsect->flags |= SEC_READONLY;
 859
 860           if (hdr->sh_flags & SHF_EXECINSTR)
 861             newsect->flags |= SEC_CODE;
 862           else if (newsect->flags & SEC_ALLOC)
 863             newsect->flags |= SEC_DATA;
 864
 865           if (hdr->sh_type == SHT_MIPS_DEBUG)
 866             newsect->flags |= SEC_DEBUGGING;
 867
 868           hdr->rawdata = (void *) newsect;
 869
 870           /* FIXME: We should record the sh_info field for a .gptab
 871              section.  */
 872
 873           /* For a .reginfo section, set the gp value in the tdata
 874              information from the contents of this section.  We need
 875              the gp value while processing relocs, so we just get it
 876              now.  */
 877           if (hdr->sh_type == SHT_MIPS_REGINFO)
 878             {
 879               Elf32_External_RegInfo ext;
 880               Elf32_RegInfo s;
 881
 882               if (bfd_get_section_contents (abfd, newsect, (PTR) &ext,
 883                                             (file_ptr) 0,
 884                                             sizeof ext) == false)
 885                 return false;
 886               bfd_mips_elf32_swap_reginfo_in (abfd, &ext, &s);
 887               elf_gp (abfd) = s.ri_gp_value;
 888             }
 889         }
 890       else
 891         hdr->rawdata = (void *) bfd_get_section_by_name (abfd, name);
 892     }
 893
 894   return true;
 895 }
 896
 897 /* Set the correct type for a MIPS ELF section.  We do this by the
 898    section name, which is a hack, but ought to work.  */
 899
 900 static boolean
 901 mips_elf_fake_sections (abfd, hdr, sec)
 902      bfd *abfd;
 903      Elf32_Internal_Shdr *hdr;
 904      asection *sec;
 905 {
 906   register const char *name;
 907
 908   name = bfd_get_section_name (abfd, sec);
 909
 910   if (strcmp (name, ".liblist") == 0)
 911     {
 912       hdr->sh_type = SHT_MIPS_LIBLIST;
 913       hdr->sh_info = sec->_raw_size / sizeof (Elf32_Lib);
 914       /* FIXME: Set the sh_link field.  */
 915     }
 916   else if (strcmp (name, ".conflict") == 0)
 917     hdr->sh_type = SHT_MIPS_CONFLICT;
 918   else if (strncmp (name, ".gptab.", sizeof ".gptab." - 1) == 0)
 919     {
 920       hdr->sh_type = SHT_MIPS_GPTAB;
 921       /* FIXME: Set the sh_info field.  */
 922     }
 923   else if (strcmp (name, ".ucode") == 0)
 924     hdr->sh_type = SHT_MIPS_UCODE;
 925   else if (strcmp (name, ".mdebug") == 0)
 926     {
 927       hdr->sh_type = SHT_MIPS_DEBUG;
 928       hdr->sh_entsize = 1;
 929     }
 930   else if (strcmp (name, ".reginfo") == 0)
 931     {
 932       hdr->sh_type = SHT_MIPS_REGINFO;
 933       hdr->sh_entsize = 1;
 934
 935       /* Force the section size to the correct value, even if the
 936          linker thinks it is larger.  The link routine below will only
 937          write out this much data for .reginfo.  */
 938       hdr->sh_size = sec->_raw_size = sizeof (Elf32_External_RegInfo);
 939     }
 940   else if (strcmp (name, ".options") == 0)
 941     {
 942       hdr->sh_type = SHT_MIPS_OPTIONS;
 943       hdr->sh_entsize = 1;
 944     }
 945
 946   return true;
 947 }
 948
 949 /* Given a BFD section, try to locate the corresponding ELF section
 950    index.  */
 951
 952 static boolean
 953 mips_elf_section_from_bfd_section (abfd, hdr, sec, retval)
 954      bfd *abfd;
 955      Elf32_Internal_Shdr *hdr;
 956      asection *sec;
 957      int *retval;
 958 {
 959   if (strcmp (bfd_get_section_name (abfd, sec), ".scommon") == 0)
 960     {
 961       *retval = SHN_MIPS_SCOMMON;
 962       return true;
 963     }
 964   if ((asection *) hdr->rawdata == sec)
 965     return true;
 966   return false;
 967 }
 968
 969 /* Work over a section just before writing it out.  We update the GP
 970    value in the .reginfo section based on the value we are using.
 971    FIXME: We recognize sections that need the SHF_MIPS_GPREL flag by
 972    name; there has to be a better way.  */
 973
 974 static boolean
 975 mips_elf_section_processing (abfd, hdr)
 976      bfd *abfd;
 977      Elf32_Internal_Shdr *hdr;
 978 {
 979   if (hdr->sh_type == SHT_MIPS_REGINFO)
 980     {
 981       bfd_byte buf[4];
 982
 983       BFD_ASSERT (hdr->sh_size == sizeof (Elf32_External_RegInfo));
 984       BFD_ASSERT (hdr->contents == NULL);
 985
 986       if (bfd_seek (abfd,
 987                     hdr->sh_offset + sizeof (Elf32_External_RegInfo) - 4,
 988                     SEEK_SET) == -1)
 989         return false;
 990       bfd_h_put_32 (abfd, (bfd_vma) elf_gp (abfd), buf);
 991       if (bfd_write (buf, (bfd_size_type) 1, (bfd_size_type) 4, abfd) != 4)
 992         return false;
 993     }
 994
 995   if (hdr->rawdata != NULL)
 996     {
 997       const char *name = ((asection *) hdr->rawdata)->name;
 998
 999       if (strcmp (name, ".sdata") == 0)
1000         {
1001           hdr->sh_flags |= SHF_ALLOC | SHF_WRITE | SHF_MIPS_GPREL;
1002           hdr->sh_type = SHT_PROGBITS;
1003         }
1004       else if (strcmp (name, ".sbss") == 0)
1005         {
1006           hdr->sh_flags |= SHF_ALLOC | SHF_WRITE | SHF_MIPS_GPREL;
1007           hdr->sh_type = SHT_NOBITS;
1008         }
1009       else if (strcmp (name, ".lit8") == 0
1010                || strcmp (name, ".lit4") == 0)
1011         {
1012           hdr->sh_flags |= SHF_ALLOC | SHF_WRITE | SHF_MIPS_GPREL;
1013           hdr->sh_type = SHT_PROGBITS;
1014         }
1015     }
1016
1017   return true;
1018 }
1019 \f
1020 /* Read ECOFF debugging information from a .mdebug section into a
1021    ecoff_debug_info structure.  */
1022
1023 static boolean
1024 mips_elf_read_ecoff_info (abfd, section, debug)
1025      bfd *abfd;
1026      asection *section;
1027      struct ecoff_debug_info *debug;
1028 {
1029   HDRR *symhdr;
1030   const struct ecoff_debug_swap *swap;
1031   char *ext_hdr;
1032
1033   swap = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
1034
1035   ext_hdr = (char *) alloca (swap->external_hdr_size);
1036
1037   if (bfd_get_section_contents (abfd, section, ext_hdr, (file_ptr) 0,
1038                                 swap->external_hdr_size)
1039       == false)
1040     return false;
1041
1042   symhdr = &debug->symbolic_header;
1043   (*swap->swap_hdr_in) (abfd, ext_hdr, symhdr);
1044
1045   /* The symbolic header contains absolute file offsets and sizes to
1046      read.  */
1047 #define READ(ptr, offset, count, size, type)                            \
1048   if (symhdr->count == 0)                                               \
1049     debug->ptr = NULL;                                                  \
1050   else                                                                  \
1051     {                                                                   \
1052       debug->ptr = (type) malloc (size * symhdr->count);                \
1053       if (debug->ptr == NULL)                                           \
1054         {                                                               \
1055           bfd_error = no_memory;                                        \
1056           return false;                                                 \
1057         }                                                               \
1058       if (bfd_seek (abfd, (file_ptr) symhdr->offset, SEEK_SET) != 0     \
1059           || (bfd_read (debug->ptr, size, symhdr->count,                \
1060                         abfd) != size * symhdr->count))                 \
1061         return false;                                                   \
1062     }
1063
1064   READ (line, cbLineOffset, cbLine, sizeof (unsigned char), unsigned char *);
1065   READ (external_dnr, cbDnOffset, idnMax, swap->external_dnr_size, PTR);
1066   READ (external_pdr, cbPdOffset, ipdMax, swap->external_pdr_size, PTR);
1067   READ (external_sym, cbSymOffset, isymMax, swap->external_sym_size, PTR);
1068   READ (external_opt, cbOptOffset, ioptMax, swap->external_opt_size, PTR);
1069   READ (external_aux, cbAuxOffset, iauxMax, sizeof (union aux_ext),
1070         union aux_ext *);
1071   READ (ss, cbSsOffset, issMax, sizeof (char), char *);
1072   READ (ssext, cbSsExtOffset, issExtMax, sizeof (char), char *);
1073   READ (external_fdr, cbFdOffset, ifdMax, swap->external_fdr_size, PTR);
1074   READ (external_rfd, cbRfdOffset, crfd, swap->external_rfd_size, PTR);
1075   READ (external_ext, cbExtOffset, iextMax, swap->external_ext_size, PTR);
1076
1077   return true;
1078 }
1079
1080 /* Get EXTR information for a symbol.  */
1081
1082 static boolean
1083 mips_elf_get_extr (sym, esym)
1084      asymbol *sym;
1085      EXTR *esym;
1086 {
1087   if (sym->flags & BSF_SECTION_SYM)
1088     return false;
1089
1090   if (bfd_asymbol_flavour (sym) != bfd_target_elf_flavour
1091       || ((elf_symbol_type *) sym)->tc_data.mips_extr == NULL)
1092     {
1093       esym->jmptbl = 0;
1094       esym->cobol_main = 0;
1095       esym->weakext = 0;
1096       esym->reserved = 0;
1097       esym->ifd = ifdNil;
1098       /* FIXME: we can do better than this for st and sc.  */
1099       esym->asym.st = stGlobal;
1100       esym->asym.sc = scAbs;
1101       esym->asym.reserved = 0;
1102       esym->asym.index = indexNil;
1103       return true;
1104     }
1105
1106   *esym = *((elf_symbol_type *) sym)->tc_data.mips_extr;
1107
1108   return true;
1109 }
1110
1111 /* Set the symbol index for an external symbol.  This is actually not
1112    needed for ELF.  */
1113
1114 /*ARGSUSED*/
1115 static void
1116 mips_elf_set_index (sym, indx)
1117      asymbol *sym;
1118      bfd_size_type indx;
1119 {
1120 }
1121
1122 /* We need to use a special link routine to handle the .reginfo and
1123    the .mdebug sections.  We need to merge all instances of these
1124    sections together, not write them all out sequentially.  */
1125
1126 static boolean
1127 mips_elf_final_link (abfd, info)
1128      bfd *abfd;
1129      struct bfd_link_info *info;
1130 {
1131   bfd *sub;
1132   size_t outsymalloc;
1133   struct generic_write_global_symbol_info wginfo;
1134   asection **secpp;
1135   asection *o;
1136   struct bfd_link_order *p;
1137   asection *reginfo_sec, *mdebug_sec;
1138   Elf32_RegInfo reginfo;
1139   struct ecoff_debug_info debug;
1140   const struct ecoff_debug_swap *swap
1141     = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
1142   HDRR *symhdr = &debug.symbolic_header;
1143
1144   abfd->outsymbols = (asymbol **) NULL;
1145   abfd->symcount = 0;
1146   outsymalloc = 0;
1147
1148   /* Build the output symbol table.  This also reads in the symbols
1149      for all the input BFDs, keeping them in the outsymbols field.  */
1150   for (sub = info->input_bfds; sub != (bfd *) NULL; sub = sub->link_next)
1151     if (! _bfd_generic_link_output_symbols (abfd, sub, info, &outsymalloc))
1152       return false;
1153
1154   /* Accumulate the global symbols.  */
1155   wginfo.output_bfd = abfd;
1156   wginfo.psymalloc = &outsymalloc;
1157   _bfd_generic_link_hash_traverse (_bfd_generic_hash_table (info),
1158                                    _bfd_generic_link_write_global_symbol,
1159                                    (PTR) &wginfo);
1160
1161   /* Remove empty sections.  Also drop the .options section, since it
1162      has special semantics which I haven't bothered to figure out.
1163      Also drop the .gptab sections, which also require special
1164      handling which is not currently done.  Removing the .gptab
1165      sections is required for Irix 5 compatibility; I don't know about
1166      the other sections.  */
1167   secpp = &abfd->sections;
1168   while (*secpp != NULL)
1169     {
1170       if ((*secpp)->_raw_size == 0
1171           || strcmp ((*secpp)->name, ".options") == 0
1172           || strncmp ((*secpp)->name, ".gptab", 6) == 0)
1173         {
1174           *secpp = (*secpp)->next;
1175           --abfd->section_count;
1176         }
1177       else
1178         secpp = &(*secpp)->next;
1179     }
1180
1181   /* Go through the sections and collect the .reginfo and .mdebug
1182      information.  We don't write out the information until we have
1183      set the section sizes, because the ELF backend only assigns space
1184      in the file once.  */
1185   for (o = abfd->sections; o != (asection *) NULL; o = o->next)
1186     {
1187       if (strcmp (o->name, ".reginfo") == 0)
1188         {
1189           memset (&reginfo, 0, sizeof reginfo);
1190
1191           /* We have found the .reginfo section in the output file.
1192              Look through all the link_orders comprising it and merge
1193              the information together.  */
1194           for (p = o->link_order_head;
1195                p != (struct bfd_link_order *) NULL;
1196                p = p->next)
1197             {
1198               asection *input_section;
1199               bfd *input_bfd;
1200               Elf32_External_RegInfo ext;
1201               Elf32_RegInfo sub;
1202
1203               if (p->type != bfd_indirect_link_order)
1204                 continue;
1205
1206               input_section = p->u.indirect.section;
1207               input_bfd = input_section->owner;
1208               BFD_ASSERT (input_section->_raw_size
1209                           == sizeof (Elf32_External_RegInfo));
1210               if (! bfd_get_section_contents (input_bfd, input_section,
1211                                               (PTR) &ext,
1212                                               (file_ptr) 0,
1213                                               sizeof ext))
1214                 return false;
1215
1216               bfd_mips_elf32_swap_reginfo_in (input_bfd, &ext, &sub);
1217
1218               reginfo.ri_gprmask |= sub.ri_gprmask;
1219               reginfo.ri_cprmask[0] |= sub.ri_cprmask[0];
1220               reginfo.ri_cprmask[1] |= sub.ri_cprmask[1];
1221               reginfo.ri_cprmask[2] |= sub.ri_cprmask[2];
1222               reginfo.ri_cprmask[3] |= sub.ri_cprmask[3];
1223
1224               /* ri_gp_value is set by the function
1225                  mips_elf_section_processing when the section is
1226                  finally written out.  */
1227             }
1228
1229           /* Force the section size to the value we want.  */
1230           o->_raw_size = sizeof (Elf32_External_RegInfo);
1231
1232           /* Skip this section later on.  */
1233           o->link_order_head = (struct bfd_link_order *) NULL;
1234
1235           reginfo_sec = o;
1236         }
1237
1238       if (strcmp (o->name, ".mdebug") == 0)
1239         {
1240           /* We have found the .mdebug section in the output file.
1241              Look through all the link_orders comprising it and merge
1242              the information together.  */
1243           symhdr->magic = swap->sym_magic;
1244           /* FIXME: What should the version stamp be?  */
1245           symhdr->vstamp = 0;
1246           symhdr->ilineMax = 0;
1247           symhdr->cbLine = 0;
1248           symhdr->idnMax = 0;
1249           symhdr->ipdMax = 0;
1250           symhdr->isymMax = 0;
1251           symhdr->ioptMax = 0;
1252           symhdr->iauxMax = 0;
1253           symhdr->issMax = 0;
1254           symhdr->issExtMax = 0;
1255           symhdr->ifdMax = 0;
1256           symhdr->crfd = 0;
1257           symhdr->iextMax = 0;
1258
1259           /* We accumulate the debugging information itself in the
1260              debug_info structure.  */
1261           debug.line = debug.line_end = NULL;
1262           debug.external_dnr = debug.external_dnr_end = NULL;
1263           debug.external_pdr = debug.external_pdr_end = NULL;
1264           debug.external_sym = debug.external_sym_end = NULL;
1265           debug.external_opt = debug.external_opt_end = NULL;
1266           debug.external_aux = debug.external_aux_end = NULL;
1267           debug.ss = debug.ss_end = NULL;
1268           debug.ssext = debug.ssext_end = NULL;
1269           debug.external_fdr = debug.external_fdr_end = NULL;
1270           debug.external_rfd = debug.external_rfd_end = NULL;
1271           debug.external_ext = debug.external_ext_end = NULL;
1272
1273           for (p = o->link_order_head;
1274                p != (struct bfd_link_order *) NULL;
1275                p = p->next)
1276             {
1277               asection *input_section;
1278               bfd *input_bfd;
1279               const struct ecoff_debug_swap *input_swap;
1280               struct ecoff_debug_info input_debug;
1281
1282               if (p->type != bfd_indirect_link_order)
1283                 continue;
1284
1285               input_section = p->u.indirect.section;
1286               input_bfd = input_section->owner;
1287
1288               if (bfd_get_flavour (input_bfd) != bfd_target_elf_flavour
1289                   || (get_elf_backend_data (input_bfd)
1290                       ->elf_backend_ecoff_debug_swap) == NULL)
1291                 {
1292                   /* I don't know what a non MIPS ELF bfd would be
1293                      doing with a .mdebug section, but I don't really
1294                      want to deal with it.  */
1295                   continue;
1296                 }
1297
1298               input_swap = (get_elf_backend_data (input_bfd)
1299                             ->elf_backend_ecoff_debug_swap);
1300
1301               BFD_ASSERT (p->size == input_section->_raw_size);
1302
1303               /* The ECOFF linking code expects that we have already
1304                  read in the debugging information and set up an
1305                  ecoff_debug_info structure, so we do that now.  */
1306               if (! mips_elf_read_ecoff_info (input_bfd, input_section,
1307                                               &input_debug))
1308                 return false;
1309
1310               if (! (bfd_ecoff_debug_accumulate
1311                      (abfd, &debug, swap,
1312                       input_bfd, &input_debug, input_swap,
1313                       info->relocateable)))
1314                 return false;
1315
1316               /* Loop through the external symbols.  For each one with
1317                  interesting information, try to find the symbol on
1318                  the symbol table of abfd and save the information in
1319                  order to put it into the final external symbols.  */
1320               if (info->hash->creator == input_bfd->xvec)
1321                 {
1322                   char *eraw_src;
1323                   char *eraw_end;
1324
1325                   eraw_src = input_debug.external_ext;
1326                   eraw_end = (eraw_src
1327                               + (input_debug.symbolic_header.iextMax
1328                                  * input_swap->external_ext_size));
1329                   for (;
1330                        eraw_src < eraw_end;
1331                        eraw_src += input_swap->external_ext_size)
1332                     {
1333                       EXTR ext;
1334                       const char *name;
1335                       struct generic_link_hash_entry *h;
1336                       elf_symbol_type *elf_sym;
1337
1338                       (*input_swap->swap_ext_in) (input_bfd, (PTR) eraw_src,
1339                                                   &ext);
1340                       if (ext.asym.sc == scNil
1341                           || ext.asym.sc == scUndefined
1342                           || ext.asym.sc == scSUndefined)
1343                         continue;
1344
1345                       name = input_debug.ssext + ext.asym.iss;
1346                       h = ((struct generic_link_hash_entry *)
1347                            bfd_link_hash_lookup (info->hash, name, false,
1348                                                  false, true));
1349                       if (h == (struct generic_link_hash_entry *) NULL
1350                           || h->sym == (asymbol *) NULL)
1351                         continue;
1352
1353                       elf_sym = (elf_symbol_type *) (h->sym);
1354
1355                       if (elf_sym->tc_data.mips_extr != NULL)
1356                         continue;
1357
1358                       elf_sym->tc_data.mips_extr =
1359                         (EXTR *) bfd_alloc (abfd, sizeof (EXTR));
1360
1361                       ext.ifd += input_debug.ifdbase;
1362                       *elf_sym->tc_data.mips_extr = ext;
1363                     }
1364                 }
1365
1366               /* Free up the information we just read.  */
1367               free (input_debug.line);
1368               free (input_debug.external_dnr);
1369               free (input_debug.external_pdr);
1370               free (input_debug.external_sym);
1371               free (input_debug.external_opt);
1372               free (input_debug.external_aux);
1373               free (input_debug.ss);
1374               free (input_debug.ssext);
1375               free (input_debug.external_fdr);
1376               free (input_debug.external_rfd);
1377               free (input_debug.external_ext);
1378             }
1379
1380           /* Build the external symbol information.  */
1381           if (! bfd_ecoff_debug_externals (abfd, &debug, swap,
1382                                            info->relocateable,
1383                                            mips_elf_get_extr,
1384                                            mips_elf_set_index))
1385             return false;
1386
1387           /* Set the size of the section.  */
1388           o->_raw_size = bfd_ecoff_debug_size (abfd, &debug, swap);
1389
1390           /* Skip this section later on.  */
1391           o->link_order_head = (struct bfd_link_order *) NULL;
1392
1393           mdebug_sec = o;
1394         }
1395     }
1396
1397   if (info->relocateable)
1398     {
1399       /* Allocate space for the output relocs for each section.  */
1400       for (o = abfd->sections;
1401            o != (asection *) NULL;
1402            o = o->next)
1403         {
1404           o->reloc_count = 0;
1405           for (p = o->link_order_head;
1406                p != (struct bfd_link_order *) NULL;
1407                p = p->next)
1408             {
1409               if (p->type == bfd_indirect_link_order)
1410                 {
1411                   asection *input_section;
1412                   bfd *input_bfd;
1413                   bfd_size_type relsize;
1414                   arelent **relocs;
1415                   bfd_size_type reloc_count;
1416
1417                   input_section = p->u.indirect.section;
1418                   input_bfd = input_section->owner;
1419                   relsize = bfd_get_reloc_upper_bound (input_bfd,
1420                                                        input_section);
1421                   relocs = (arelent **) bfd_xmalloc (relsize);
1422                   reloc_count =
1423                     bfd_canonicalize_reloc (input_bfd, input_section,
1424                                             relocs,
1425                                             bfd_get_outsymbols (input_bfd));
1426                   BFD_ASSERT (reloc_count == input_section->reloc_count);
1427                   o->reloc_count += reloc_count;
1428                   free (relocs);
1429                 }
1430             }
1431           if (o->reloc_count > 0)
1432             {
1433               o->orelocation = ((arelent **)
1434                                 bfd_alloc (abfd,
1435                                            (o->reloc_count
1436                                             * sizeof (arelent *))));
1437               /* Reset the count so that it can be used as an index
1438                  when putting in the output relocs.  */
1439               o->reloc_count = 0;
1440             }
1441         }
1442     }
1443
1444   /* Write out the information we have accumulated.  */
1445   if (reginfo_sec != (asection *) NULL)
1446     {
1447       Elf32_External_RegInfo ext;
1448
1449       bfd_mips_elf32_swap_reginfo_out (abfd, &reginfo, &ext);
1450       if (! bfd_set_section_contents (abfd, reginfo_sec, (PTR) &ext,
1451                                       (file_ptr) 0, sizeof ext))
1452         return false;
1453     }
1454
1455   if (mdebug_sec != (asection *) NULL)
1456     {
1457       if (! abfd->output_has_begun)
1458         {
1459           /* Force the section to be given a file position.  */
1460           bfd_set_section_contents (abfd, mdebug_sec, (PTR) NULL,
1461                                     (file_ptr) 0, (bfd_size_type) 0);
1462           BFD_ASSERT (abfd->output_has_begun);
1463         }
1464       if (! bfd_ecoff_write_debug (abfd, &debug, swap, mdebug_sec->filepos))
1465         return false;
1466     }
1467
1468   /* Handle all the link order information for the sections.  */
1469   for (o = abfd->sections;
1470        o != (asection *) NULL;
1471        o = o->next)
1472     {
1473       for (p = o->link_order_head;
1474            p != (struct bfd_link_order *) NULL;
1475            p = p->next)
1476         {
1477           if (! _bfd_default_link_order (abfd, info, o, p))
1478             return false;
1479         }
1480     }
1481
1482   return true;
1483 }
1484 \f
1485 /* MIPS ELF uses two common sections.  One is the usual one, and the
1486    other is for small objects.  All the small objects are kept
1487    together, and then referenced via the gp pointer, which yields
1488    faster assembler code.  This is what we use for the small common
1489    section.  This approach is copied from ecoff.c.  */
1490 static asection mips_elf_scom_section;
1491 static asymbol mips_elf_scom_symbol;
1492 static asymbol *mips_elf_scom_symbol_ptr;
1493
1494 /* MIPS ELF also uses an acommon section, which represents an
1495    allocated common symbol which may be overridden by a
1496    definition in a shared library.  */
1497 static asection mips_elf_acom_section;
1498 static asymbol mips_elf_acom_symbol;
1499 static asymbol *mips_elf_acom_symbol_ptr;
1500
1501 /* Handle the special MIPS section numbers that a symbol may use.  */
1502
1503 static void
1504 mips_elf_symbol_processing (abfd, asym)
1505      bfd *abfd;
1506      asymbol *asym;
1507 {
1508   elf_symbol_type *elfsym;
1509
1510   elfsym = (elf_symbol_type *) asym;
1511   switch (elfsym->internal_elf_sym.st_shndx)
1512     {
1513     case SHN_MIPS_ACOMMON:
1514       /* This section is used in a dynamically linked executable file.
1515          It is an allocated common section.  The dynamic linker can
1516          either resolve these symbols to something in a shared
1517          library, or it can just leave them here.  For our purposes,
1518          we can consider these symbols to be in a new section.  */
1519       if (mips_elf_acom_section.name == NULL)
1520         {
1521           /* Initialize the acommon section.  */
1522           mips_elf_acom_section.name = ".acommon";
1523           mips_elf_acom_section.flags = SEC_NO_FLAGS;
1524           mips_elf_acom_section.output_section = &mips_elf_acom_section;
1525           mips_elf_acom_section.symbol = &mips_elf_acom_symbol;
1526           mips_elf_acom_section.symbol_ptr_ptr = &mips_elf_acom_symbol_ptr;
1527           mips_elf_acom_symbol.name = ".acommon";
1528           mips_elf_acom_symbol.flags = BSF_SECTION_SYM;
1529           mips_elf_acom_symbol.section = &mips_elf_acom_section;
1530           mips_elf_acom_symbol_ptr = &mips_elf_acom_symbol;
1531         }
1532       asym->section = &mips_elf_acom_section;
1533       break;
1534
1535     case SHN_COMMON:
1536       /* Common symbols less than the GP size are automatically
1537          treated as SHN_MIPS_SCOMMON symbols.  */
1538       if (asym->value > elf_gp_size (abfd))
1539         break;
1540       /* Fall through.  */
1541     case SHN_MIPS_SCOMMON:
1542       if (mips_elf_scom_section.name == NULL)
1543         {
1544           /* Initialize the small common section.  */
1545           mips_elf_scom_section.name = ".scommon";
1546           mips_elf_scom_section.flags = SEC_IS_COMMON;
1547           mips_elf_scom_section.output_section = &mips_elf_scom_section;
1548           mips_elf_scom_section.symbol = &mips_elf_scom_symbol;
1549           mips_elf_scom_section.symbol_ptr_ptr = &mips_elf_scom_symbol_ptr;
1550           mips_elf_scom_symbol.name = ".scommon";
1551           mips_elf_scom_symbol.flags = BSF_SECTION_SYM;
1552           mips_elf_scom_symbol.section = &mips_elf_scom_section;
1553           mips_elf_scom_symbol_ptr = &mips_elf_scom_symbol;
1554         }
1555       asym->section = &mips_elf_scom_section;
1556       asym->value = elfsym->internal_elf_sym.st_size;
1557       break;
1558
1559     case SHN_MIPS_SUNDEFINED:
1560       asym->section = &bfd_und_section;
1561       break;
1562     }
1563 }
1564 \f
1565 /* ECOFF swapping routines.  These are used when dealing with the
1566    .mdebug section, which is in the ECOFF debugging format.  */
1567 static const struct ecoff_debug_swap mips_elf_ecoff_debug_swap =
1568 {
1569   /* Symbol table magic number.  */
1570   magicSym,
1571   /* Alignment of debugging information.  E.g., 4.  */
1572   4,
1573   /* Sizes of external symbolic information.  */
1574   sizeof (struct hdr_ext),
1575   sizeof (struct dnr_ext),
1576   sizeof (struct pdr_ext),
1577   sizeof (struct sym_ext),
1578   sizeof (struct opt_ext),
1579   sizeof (struct fdr_ext),
1580   sizeof (struct rfd_ext),
1581   sizeof (struct ext_ext),
1582   /* Functions to swap in external symbolic data.  */
1583   ecoff_swap_hdr_in,
1584   ecoff_swap_dnr_in,
1585   ecoff_swap_pdr_in,
1586   ecoff_swap_sym_in,
1587   ecoff_swap_opt_in,
1588   ecoff_swap_fdr_in,
1589   ecoff_swap_rfd_in,
1590   ecoff_swap_ext_in,
1591   /* Functions to swap out external symbolic data.  */
1592   ecoff_swap_hdr_out,
1593   ecoff_swap_dnr_out,
1594   ecoff_swap_pdr_out,
1595   ecoff_swap_sym_out,
1596   ecoff_swap_opt_out,
1597   ecoff_swap_fdr_out,
1598   ecoff_swap_rfd_out,
1599   ecoff_swap_ext_out
1600 };
1601 \f
1602 #define TARGET_LITTLE_SYM               bfd_elf32_littlemips_vec
1603 #define TARGET_LITTLE_NAME              "elf32-littlemips"
1604 #define TARGET_BIG_SYM                  bfd_elf32_bigmips_vec
1605 #define TARGET_BIG_NAME                 "elf32-bigmips"
1606 #define ELF_ARCH                        bfd_arch_mips
1607 #define ELF_MACHINE_CODE                EM_MIPS
1608 #define ELF_MAXPAGESIZE                 0x10000
1609 #define elf_info_to_howto               0
1610 #define elf_info_to_howto_rel           mips_info_to_howto_rel
1611 #define elf_backend_sym_is_global       mips_elf_sym_is_global
1612 #define elf_backend_object_p            mips_elf_object_p
1613 #define elf_backend_section_from_shdr   mips_elf_section_from_shdr
1614 #define elf_backend_fake_sections       mips_elf_fake_sections
1615 #define elf_backend_section_from_bfd_section \
1616                                         mips_elf_section_from_bfd_section
1617 #define elf_backend_section_processing  mips_elf_section_processing
1618 #define elf_backend_symbol_processing   mips_elf_symbol_processing
1619 #define elf_backend_final_write_processing \
1620                                         mips_elf_final_write_processing
1621 #define elf_backend_ecoff_debug_swap    &mips_elf_ecoff_debug_swap
1622
1623 #define bfd_elf32_bfd_final_link        mips_elf_final_link
1624
1625 #include "elf32-target.h"