bfd/elf-m10300.c

   1 /* Matsushita 10300 specific support for 32-bit ELF
   2    Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
   3    2006, 2007 Free Software Foundation, Inc.
   4
   5    This file is part of BFD, the Binary File Descriptor library.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
  20    MA 02110-1301, USA.  */
  21
  22 #include "sysdep.h"
  23 #include "bfd.h"
  24 #include "libbfd.h"
  25 #include "elf-bfd.h"
  26 #include "elf/mn10300.h"
  27 #include "libiberty.h"
  28
  29 /* The mn10300 linker needs to keep track of the number of relocs that
  30    it decides to copy in check_relocs for each symbol.  This is so
  31    that it can discard PC relative relocs if it doesn't need them when
  32    linking with -Bsymbolic.  We store the information in a field
  33    extending the regular ELF linker hash table.  */
  34
  35 struct elf32_mn10300_link_hash_entry
  36 {
  37   /* The basic elf link hash table entry.  */
  38   struct elf_link_hash_entry root;
  39
  40   /* For function symbols, the number of times this function is
  41      called directly (ie by name).  */
  42   unsigned int direct_calls;
  43
  44   /* For function symbols, the size of this function's stack
  45      (if <= 255 bytes).  We stuff this into "call" instructions
  46      to this target when it's valid and profitable to do so.
  47
  48      This does not include stack allocated by movm!  */
  49   unsigned char stack_size;
  50
  51   /* For function symbols, arguments (if any) for movm instruction
  52      in the prologue.  We stuff this value into "call" instructions
  53      to the target when it's valid and profitable to do so.  */
  54   unsigned char movm_args;
  55
  56   /* For function symbols, the amount of stack space that would be allocated
  57      by the movm instruction.  This is redundant with movm_args, but we
  58      add it to the hash table to avoid computing it over and over.  */
  59   unsigned char movm_stack_size;
  60
  61 /* When set, convert all "call" instructions to this target into "calls"
  62    instructions.  */
  63 #define MN10300_CONVERT_CALL_TO_CALLS 0x1
  64
  65 /* Used to mark functions which have had redundant parts of their
  66    prologue deleted.  */
  67 #define MN10300_DELETED_PROLOGUE_BYTES 0x2
  68   unsigned char flags;
  69
  70   /* Calculated value.  */
  71   bfd_vma value;
  72 };
  73
  74 /* We derive a hash table from the main elf linker hash table so
  75    we can store state variables and a secondary hash table without
  76    resorting to global variables.  */
  77 struct elf32_mn10300_link_hash_table
  78 {
  79   /* The main hash table.  */
  80   struct elf_link_hash_table root;
  81
  82   /* A hash table for static functions.  We could derive a new hash table
  83      instead of using the full elf32_mn10300_link_hash_table if we wanted
  84      to save some memory.  */
  85   struct elf32_mn10300_link_hash_table *static_hash_table;
  86
  87   /* Random linker state flags.  */
  88 #define MN10300_HASH_ENTRIES_INITIALIZED 0x1
  89   char flags;
  90 };
  91
  92 #ifndef streq
  93 #define streq(a, b) (strcmp ((a),(b)) == 0)
  94 #endif
  95
  96 /* For MN10300 linker hash table.  */
  97
  98 /* Get the MN10300 ELF linker hash table from a link_info structure.  */
  99
 100 #define elf32_mn10300_hash_table(p) \
 101   ((struct elf32_mn10300_link_hash_table *) ((p)->hash))
 102
 103 #define elf32_mn10300_link_hash_traverse(table, func, info)             \
 104   (elf_link_hash_traverse                                               \
 105    (&(table)->root,                                                     \
 106     (bfd_boolean (*) (struct elf_link_hash_entry *, void *)) (func),    \
 107     (info)))
 108
 109 static reloc_howto_type elf_mn10300_howto_table[] =
 110 {
 111   /* Dummy relocation.  Does nothing.  */
 112   HOWTO (R_MN10300_NONE,
 113          0,
 114          2,
 115          16,
 116          FALSE,
 117          0,
 118          complain_overflow_bitfield,
 119          bfd_elf_generic_reloc,
 120          "R_MN10300_NONE",
 121          FALSE,
 122          0,
 123          0,
 124          FALSE),
 125   /* Standard 32 bit reloc.  */
 126   HOWTO (R_MN10300_32,
 127          0,
 128          2,
 129          32,
 130          FALSE,
 131          0,
 132          complain_overflow_bitfield,
 133          bfd_elf_generic_reloc,
 134          "R_MN10300_32",
 135          FALSE,
 136          0xffffffff,
 137          0xffffffff,
 138          FALSE),
 139   /* Standard 16 bit reloc.  */
 140   HOWTO (R_MN10300_16,
 141          0,
 142          1,
 143          16,
 144          FALSE,
 145          0,
 146          complain_overflow_bitfield,
 147          bfd_elf_generic_reloc,
 148          "R_MN10300_16",
 149          FALSE,
 150          0xffff,
 151          0xffff,
 152          FALSE),
 153   /* Standard 8 bit reloc.  */
 154   HOWTO (R_MN10300_8,
 155          0,
 156          0,
 157          8,
 158          FALSE,
 159          0,
 160          complain_overflow_bitfield,
 161          bfd_elf_generic_reloc,
 162          "R_MN10300_8",
 163          FALSE,
 164          0xff,
 165          0xff,
 166          FALSE),
 167   /* Standard 32bit pc-relative reloc.  */
 168   HOWTO (R_MN10300_PCREL32,
 169          0,
 170          2,
 171          32,
 172          TRUE,
 173          0,
 174          complain_overflow_bitfield,
 175          bfd_elf_generic_reloc,
 176          "R_MN10300_PCREL32",
 177          FALSE,
 178          0xffffffff,
 179          0xffffffff,
 180          TRUE),
 181   /* Standard 16bit pc-relative reloc.  */
 182   HOWTO (R_MN10300_PCREL16,
 183          0,
 184          1,
 185          16,
 186          TRUE,
 187          0,
 188          complain_overflow_bitfield,
 189          bfd_elf_generic_reloc,
 190          "R_MN10300_PCREL16",
 191          FALSE,
 192          0xffff,
 193          0xffff,
 194          TRUE),
 195   /* Standard 8 pc-relative reloc.  */
 196   HOWTO (R_MN10300_PCREL8,
 197          0,
 198          0,
 199          8,
 200          TRUE,
 201          0,
 202          complain_overflow_bitfield,
 203          bfd_elf_generic_reloc,
 204          "R_MN10300_PCREL8",
 205          FALSE,
 206          0xff,
 207          0xff,
 208          TRUE),
 209
 210   /* GNU extension to record C++ vtable hierarchy.  */
 211   HOWTO (R_MN10300_GNU_VTINHERIT, /* type */
 212          0,                     /* rightshift */
 213          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 214          0,                     /* bitsize */
 215          FALSE,                 /* pc_relative */
 216          0,                     /* bitpos */
 217          complain_overflow_dont, /* complain_on_overflow */
 218          NULL,                  /* special_function */
 219          "R_MN10300_GNU_VTINHERIT", /* name */
 220          FALSE,                 /* partial_inplace */
 221          0,                     /* src_mask */
 222          0,                     /* dst_mask */
 223          FALSE),                /* pcrel_offset */
 224
 225   /* GNU extension to record C++ vtable member usage */
 226   HOWTO (R_MN10300_GNU_VTENTRY, /* type */
 227          0,                     /* rightshift */
 228          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 229          0,                     /* bitsize */
 230          FALSE,                 /* pc_relative */
 231          0,                     /* bitpos */
 232          complain_overflow_dont, /* complain_on_overflow */
 233          NULL,                  /* special_function */
 234          "R_MN10300_GNU_VTENTRY", /* name */
 235          FALSE,                 /* partial_inplace */
 236          0,                     /* src_mask */
 237          0,                     /* dst_mask */
 238          FALSE),                /* pcrel_offset */
 239
 240   /* Standard 24 bit reloc.  */
 241   HOWTO (R_MN10300_24,
 242          0,
 243          2,
 244          24,
 245          FALSE,
 246          0,
 247          complain_overflow_bitfield,
 248          bfd_elf_generic_reloc,
 249          "R_MN10300_24",
 250          FALSE,
 251          0xffffff,
 252          0xffffff,
 253          FALSE),
 254   HOWTO (R_MN10300_GOTPC32,     /* type */
 255          0,                     /* rightshift */
 256          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 257          32,                    /* bitsize */
 258          TRUE,                  /* pc_relative */
 259          0,                     /* bitpos */
 260          complain_overflow_bitfield, /* complain_on_overflow */
 261          bfd_elf_generic_reloc, /* */
 262          "R_MN10300_GOTPC32",   /* name */
 263          FALSE,                 /* partial_inplace */
 264          0xffffffff,            /* src_mask */
 265          0xffffffff,            /* dst_mask */
 266          TRUE),                 /* pcrel_offset */
 267
 268   HOWTO (R_MN10300_GOTPC16,     /* type */
 269          0,                     /* rightshift */
 270          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 271          16,                    /* bitsize */
 272          TRUE,                  /* pc_relative */
 273          0,                     /* bitpos */
 274          complain_overflow_bitfield, /* complain_on_overflow */
 275          bfd_elf_generic_reloc, /* */
 276          "R_MN10300_GOTPC16",   /* name */
 277          FALSE,                 /* partial_inplace */
 278          0xffff,                /* src_mask */
 279          0xffff,                /* dst_mask */
 280          TRUE),                 /* pcrel_offset */
 281
 282   HOWTO (R_MN10300_GOTOFF32,    /* type */
 283          0,                     /* rightshift */
 284          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 285          32,                    /* bitsize */
 286          FALSE,                 /* pc_relative */
 287          0,                     /* bitpos */
 288          complain_overflow_bitfield, /* complain_on_overflow */
 289          bfd_elf_generic_reloc, /* */
 290          "R_MN10300_GOTOFF32",  /* name */
 291          FALSE,                 /* partial_inplace */
 292          0xffffffff,            /* src_mask */
 293          0xffffffff,            /* dst_mask */
 294          FALSE),                /* pcrel_offset */
 295
 296   HOWTO (R_MN10300_GOTOFF24,    /* type */
 297          0,                     /* rightshift */
 298          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 299          24,                    /* bitsize */
 300          FALSE,                 /* pc_relative */
 301          0,                     /* bitpos */
 302          complain_overflow_bitfield, /* complain_on_overflow */
 303          bfd_elf_generic_reloc, /* */
 304          "R_MN10300_GOTOFF24",  /* name */
 305          FALSE,                 /* partial_inplace */
 306          0xffffff,              /* src_mask */
 307          0xffffff,              /* dst_mask */
 308          FALSE),                /* pcrel_offset */
 309
 310   HOWTO (R_MN10300_GOTOFF16,    /* type */
 311          0,                     /* rightshift */
 312          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 313          16,                    /* bitsize */
 314          FALSE,                 /* pc_relative */
 315          0,                     /* bitpos */
 316          complain_overflow_bitfield, /* complain_on_overflow */
 317          bfd_elf_generic_reloc, /* */
 318          "R_MN10300_GOTOFF16",  /* name */
 319          FALSE,                 /* partial_inplace */
 320          0xffff,                /* src_mask */
 321          0xffff,                /* dst_mask */
 322          FALSE),                /* pcrel_offset */
 323
 324   HOWTO (R_MN10300_PLT32,       /* type */
 325          0,                     /* rightshift */
 326          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 327          32,                    /* bitsize */
 328          TRUE,                  /* pc_relative */
 329          0,                     /* bitpos */
 330          complain_overflow_bitfield, /* complain_on_overflow */
 331          bfd_elf_generic_reloc, /* */
 332          "R_MN10300_PLT32",     /* name */
 333          FALSE,                 /* partial_inplace */
 334          0xffffffff,            /* src_mask */
 335          0xffffffff,            /* dst_mask */
 336          TRUE),                 /* pcrel_offset */
 337
 338   HOWTO (R_MN10300_PLT16,       /* type */
 339          0,                     /* rightshift */
 340          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 341          16,                    /* bitsize */
 342          TRUE,                  /* pc_relative */
 343          0,                     /* bitpos */
 344          complain_overflow_bitfield, /* complain_on_overflow */
 345          bfd_elf_generic_reloc, /* */
 346          "R_MN10300_PLT16",     /* name */
 347          FALSE,                 /* partial_inplace */
 348          0xffff,                /* src_mask */
 349          0xffff,                /* dst_mask */
 350          TRUE),                 /* pcrel_offset */
 351
 352   HOWTO (R_MN10300_GOT32,       /* type */
 353          0,                     /* rightshift */
 354          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 355          32,                    /* bitsize */
 356          FALSE,                 /* pc_relative */
 357          0,                     /* bitpos */
 358          complain_overflow_bitfield, /* complain_on_overflow */
 359          bfd_elf_generic_reloc, /* */
 360          "R_MN10300_GOT32",     /* name */
 361          FALSE,                 /* partial_inplace */
 362          0xffffffff,            /* src_mask */
 363          0xffffffff,            /* dst_mask */
 364          FALSE),                /* pcrel_offset */
 365
 366   HOWTO (R_MN10300_GOT24,       /* type */
 367          0,                     /* rightshift */
 368          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 369          24,                    /* bitsize */
 370          FALSE,                 /* pc_relative */
 371          0,                     /* bitpos */
 372          complain_overflow_bitfield, /* complain_on_overflow */
 373          bfd_elf_generic_reloc, /* */
 374          "R_MN10300_GOT24",     /* name */
 375          FALSE,                 /* partial_inplace */
 376          0xffffffff,            /* src_mask */
 377          0xffffffff,            /* dst_mask */
 378          FALSE),                /* pcrel_offset */
 379
 380   HOWTO (R_MN10300_GOT16,       /* type */
 381          0,                     /* rightshift */
 382          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 383          16,                    /* bitsize */
 384          FALSE,                 /* pc_relative */
 385          0,                     /* bitpos */
 386          complain_overflow_bitfield, /* complain_on_overflow */
 387          bfd_elf_generic_reloc, /* */
 388          "R_MN10300_GOT16",     /* name */
 389          FALSE,                 /* partial_inplace */
 390          0xffffffff,            /* src_mask */
 391          0xffffffff,            /* dst_mask */
 392          FALSE),                /* pcrel_offset */
 393
 394   HOWTO (R_MN10300_COPY,        /* type */
 395          0,                     /* rightshift */
 396          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 397          32,                    /* bitsize */
 398          FALSE,                 /* pc_relative */
 399          0,                     /* bitpos */
 400          complain_overflow_bitfield, /* complain_on_overflow */
 401          bfd_elf_generic_reloc, /* */
 402          "R_MN10300_COPY",              /* name */
 403          FALSE,                 /* partial_inplace */
 404          0xffffffff,            /* src_mask */
 405          0xffffffff,            /* dst_mask */
 406          FALSE),                /* pcrel_offset */
 407
 408   HOWTO (R_MN10300_GLOB_DAT,    /* type */
 409          0,                     /* rightshift */
 410          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 411          32,                    /* bitsize */
 412          FALSE,                 /* pc_relative */
 413          0,                     /* bitpos */
 414          complain_overflow_bitfield, /* complain_on_overflow */
 415          bfd_elf_generic_reloc, /* */
 416          "R_MN10300_GLOB_DAT",  /* name */
 417          FALSE,                 /* partial_inplace */
 418          0xffffffff,            /* src_mask */
 419          0xffffffff,            /* dst_mask */
 420          FALSE),                /* pcrel_offset */
 421
 422   HOWTO (R_MN10300_JMP_SLOT,    /* type */
 423          0,                     /* rightshift */
 424          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 425          32,                    /* bitsize */
 426          FALSE,                 /* pc_relative */
 427          0,                     /* bitpos */
 428          complain_overflow_bitfield, /* complain_on_overflow */
 429          bfd_elf_generic_reloc, /* */
 430          "R_MN10300_JMP_SLOT",  /* name */
 431          FALSE,                 /* partial_inplace */
 432          0xffffffff,            /* src_mask */
 433          0xffffffff,            /* dst_mask */
 434          FALSE),                /* pcrel_offset */
 435
 436   HOWTO (R_MN10300_RELATIVE,    /* type */
 437          0,                     /* rightshift */
 438          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 439          32,                    /* bitsize */
 440          FALSE,                 /* pc_relative */
 441          0,                     /* bitpos */
 442          complain_overflow_bitfield, /* complain_on_overflow */
 443          bfd_elf_generic_reloc, /* */
 444          "R_MN10300_RELATIVE",  /* name */
 445          FALSE,                 /* partial_inplace */
 446          0xffffffff,            /* src_mask */
 447          0xffffffff,            /* dst_mask */
 448          FALSE),                /* pcrel_offset */
 449
 450   EMPTY_HOWTO (24),
 451   EMPTY_HOWTO (25),
 452   EMPTY_HOWTO (26),
 453   EMPTY_HOWTO (27),
 454   EMPTY_HOWTO (28),
 455   EMPTY_HOWTO (29),
 456   EMPTY_HOWTO (30),
 457   EMPTY_HOWTO (31),
 458   EMPTY_HOWTO (32),
 459
 460   HOWTO (R_MN10300_SYM_DIFF,    /* type */
 461          0,                     /* rightshift */
 462          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 463          32,                    /* bitsize */
 464          FALSE,                 /* pc_relative */
 465          0,                     /* bitpos */
 466          complain_overflow_dont,/* complain_on_overflow */
 467          NULL,                  /* special handler.  */
 468          "R_MN10300_SYM_DIFF",  /* name */
 469          FALSE,                 /* partial_inplace */
 470          0xffffffff,            /* src_mask */
 471          0xffffffff,            /* dst_mask */
 472          FALSE)                 /* pcrel_offset */
 473 };
 474
 475 struct mn10300_reloc_map
 476 {
 477   bfd_reloc_code_real_type bfd_reloc_val;
 478   unsigned char elf_reloc_val;
 479 };
 480
 481 static const struct mn10300_reloc_map mn10300_reloc_map[] =
 482 {
 483   { BFD_RELOC_NONE, R_MN10300_NONE, },
 484   { BFD_RELOC_32, R_MN10300_32, },
 485   { BFD_RELOC_16, R_MN10300_16, },
 486   { BFD_RELOC_8, R_MN10300_8, },
 487   { BFD_RELOC_32_PCREL, R_MN10300_PCREL32, },
 488   { BFD_RELOC_16_PCREL, R_MN10300_PCREL16, },
 489   { BFD_RELOC_8_PCREL, R_MN10300_PCREL8, },
 490   { BFD_RELOC_24, R_MN10300_24, },
 491   { BFD_RELOC_VTABLE_INHERIT, R_MN10300_GNU_VTINHERIT },
 492   { BFD_RELOC_VTABLE_ENTRY, R_MN10300_GNU_VTENTRY },
 493   { BFD_RELOC_32_GOT_PCREL, R_MN10300_GOTPC32 },
 494   { BFD_RELOC_16_GOT_PCREL, R_MN10300_GOTPC16 },
 495   { BFD_RELOC_32_GOTOFF, R_MN10300_GOTOFF32 },
 496   { BFD_RELOC_MN10300_GOTOFF24, R_MN10300_GOTOFF24 },
 497   { BFD_RELOC_16_GOTOFF, R_MN10300_GOTOFF16 },
 498   { BFD_RELOC_32_PLT_PCREL, R_MN10300_PLT32 },
 499   { BFD_RELOC_16_PLT_PCREL, R_MN10300_PLT16 },
 500   { BFD_RELOC_MN10300_GOT32, R_MN10300_GOT32 },
 501   { BFD_RELOC_MN10300_GOT24, R_MN10300_GOT24 },
 502   { BFD_RELOC_MN10300_GOT16, R_MN10300_GOT16 },
 503   { BFD_RELOC_MN10300_COPY, R_MN10300_COPY },
 504   { BFD_RELOC_MN10300_GLOB_DAT, R_MN10300_GLOB_DAT },
 505   { BFD_RELOC_MN10300_JMP_SLOT, R_MN10300_JMP_SLOT },
 506   { BFD_RELOC_MN10300_RELATIVE, R_MN10300_RELATIVE },
 507   { BFD_RELOC_MN10300_SYM_DIFF, R_MN10300_SYM_DIFF }
 508 };
 509
 510 /* Create the GOT section.  */
 511
 512 static bfd_boolean
 513 _bfd_mn10300_elf_create_got_section (bfd * abfd,
 514                                      struct bfd_link_info * info)
 515 {
 516   flagword   flags;
 517   flagword   pltflags;
 518   asection * s;
 519   struct elf_link_hash_entry * h;
 520   const struct elf_backend_data * bed = get_elf_backend_data (abfd);
 521   int ptralign;
 522
 523   /* This function may be called more than once.  */
 524   if (bfd_get_section_by_name (abfd, ".got") != NULL)
 525     return TRUE;
 526
 527   switch (bed->s->arch_size)
 528     {
 529     case 32:
 530       ptralign = 2;
 531       break;
 532
 533     case 64:
 534       ptralign = 3;
 535       break;
 536
 537     default:
 538       bfd_set_error (bfd_error_bad_value);
 539       return FALSE;
 540     }
 541
 542   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
 543            | SEC_LINKER_CREATED);
 544
 545   pltflags = flags;
 546   pltflags |= SEC_CODE;
 547   if (bed->plt_not_loaded)
 548     pltflags &= ~ (SEC_LOAD | SEC_HAS_CONTENTS);
 549   if (bed->plt_readonly)
 550     pltflags |= SEC_READONLY;
 551
 552   s = bfd_make_section_with_flags (abfd, ".plt", pltflags);
 553   if (s == NULL
 554       || ! bfd_set_section_alignment (abfd, s, bed->plt_alignment))
 555     return FALSE;
 556
 557   /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
 558      .plt section.  */
 559   if (bed->want_plt_sym)
 560     {
 561       h = _bfd_elf_define_linkage_sym (abfd, info, s,
 562                                        "_PROCEDURE_LINKAGE_TABLE_");
 563       elf_hash_table (info)->hplt = h;
 564       if (h == NULL)
 565         return FALSE;
 566     }
 567
 568   s = bfd_make_section_with_flags (abfd, ".got", flags);
 569   if (s == NULL
 570       || ! bfd_set_section_alignment (abfd, s, ptralign))
 571     return FALSE;
 572
 573   if (bed->want_got_plt)
 574     {
 575       s = bfd_make_section_with_flags (abfd, ".got.plt", flags);
 576       if (s == NULL
 577           || ! bfd_set_section_alignment (abfd, s, ptralign))
 578         return FALSE;
 579     }
 580
 581   /* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the .got
 582      (or .got.plt) section.  We don't do this in the linker script
 583      because we don't want to define the symbol if we are not creating
 584      a global offset table.  */
 585   h = _bfd_elf_define_linkage_sym (abfd, info, s, "_GLOBAL_OFFSET_TABLE_");
 586   elf_hash_table (info)->hgot = h;
 587   if (h == NULL)
 588     return FALSE;
 589
 590   /* The first bit of the global offset table is the header.  */
 591   s->size += bed->got_header_size;
 592
 593   return TRUE;
 594 }
 595
 596 static reloc_howto_type *
 597 bfd_elf32_bfd_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
 598                                  bfd_reloc_code_real_type code)
 599 {
 600   unsigned int i;
 601
 602   for (i = ARRAY_SIZE (mn10300_reloc_map); i--;)
 603     if (mn10300_reloc_map[i].bfd_reloc_val == code)
 604       return &elf_mn10300_howto_table[mn10300_reloc_map[i].elf_reloc_val];
 605
 606   return NULL;
 607 }
 608
 609 static reloc_howto_type *
 610 bfd_elf32_bfd_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
 611                                  const char *r_name)
 612 {
 613   unsigned int i;
 614
 615   for (i = ARRAY_SIZE (elf_mn10300_howto_table); i--;)
 616     if (elf_mn10300_howto_table[i].name != NULL
 617         && strcasecmp (elf_mn10300_howto_table[i].name, r_name) == 0)
 618       return elf_mn10300_howto_table + i;
 619
 620   return NULL;
 621 }
 622
 623 /* Set the howto pointer for an MN10300 ELF reloc.  */
 624
 625 static void
 626 mn10300_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED,
 627                        arelent *cache_ptr,
 628                        Elf_Internal_Rela *dst)
 629 {
 630   unsigned int r_type;
 631
 632   r_type = ELF32_R_TYPE (dst->r_info);
 633   BFD_ASSERT (r_type < (unsigned int) R_MN10300_MAX);
 634   cache_ptr->howto = elf_mn10300_howto_table + r_type;
 635 }
 636
 637 /* Look through the relocs for a section during the first phase.
 638    Since we don't do .gots or .plts, we just need to consider the
 639    virtual table relocs for gc.  */
 640
 641 static bfd_boolean
 642 mn10300_elf_check_relocs (bfd *abfd,
 643                           struct bfd_link_info *info,
 644                           asection *sec,
 645                           const Elf_Internal_Rela *relocs)
 646 {
 647   bfd_boolean sym_diff_reloc_seen;
 648   Elf_Internal_Shdr *symtab_hdr;
 649   struct elf_link_hash_entry **sym_hashes;
 650   const Elf_Internal_Rela *rel;
 651   const Elf_Internal_Rela *rel_end;
 652   bfd *      dynobj;
 653   bfd_vma *  local_got_offsets;
 654   asection * sgot;
 655   asection * srelgot;
 656   asection * sreloc;
 657
 658   sgot    = NULL;
 659   srelgot = NULL;
 660   sreloc  = NULL;
 661
 662   if (info->relocatable)
 663     return TRUE;
 664
 665   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
 666   sym_hashes = elf_sym_hashes (abfd);
 667
 668   dynobj = elf_hash_table (info)->dynobj;
 669   local_got_offsets = elf_local_got_offsets (abfd);
 670   rel_end = relocs + sec->reloc_count;
 671   sym_diff_reloc_seen = FALSE;
 672
 673   for (rel = relocs; rel < rel_end; rel++)
 674     {
 675       struct elf_link_hash_entry *h;
 676       unsigned long r_symndx;
 677
 678       r_symndx = ELF32_R_SYM (rel->r_info);
 679       if (r_symndx < symtab_hdr->sh_info)
 680         h = NULL;
 681       else
 682         {
 683           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
 684           while (h->root.type == bfd_link_hash_indirect
 685                  || h->root.type == bfd_link_hash_warning)
 686             h = (struct elf_link_hash_entry *) h->root.u.i.link;
 687         }
 688
 689       /* Some relocs require a global offset table.  */
 690       if (dynobj == NULL)
 691         {
 692           switch (ELF32_R_TYPE (rel->r_info))
 693             {
 694             case R_MN10300_GOT32:
 695             case R_MN10300_GOT24:
 696             case R_MN10300_GOT16:
 697             case R_MN10300_GOTOFF32:
 698             case R_MN10300_GOTOFF24:
 699             case R_MN10300_GOTOFF16:
 700             case R_MN10300_GOTPC32:
 701             case R_MN10300_GOTPC16:
 702               elf_hash_table (info)->dynobj = dynobj = abfd;
 703               if (! _bfd_mn10300_elf_create_got_section (dynobj, info))
 704                 return FALSE;
 705               break;
 706
 707             default:
 708               break;
 709             }
 710         }
 711
 712       switch (ELF32_R_TYPE (rel->r_info))
 713         {
 714         /* This relocation describes the C++ object vtable hierarchy.
 715            Reconstruct it for later use during GC.  */
 716         case R_MN10300_GNU_VTINHERIT:
 717           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
 718             return FALSE;
 719           break;
 720
 721         /* This relocation describes which C++ vtable entries are actually
 722            used.  Record for later use during GC.  */
 723         case R_MN10300_GNU_VTENTRY:
 724           BFD_ASSERT (h != NULL);
 725           if (h != NULL
 726               && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
 727             return FALSE;
 728           break;
 729         case R_MN10300_GOT32:
 730         case R_MN10300_GOT24:
 731         case R_MN10300_GOT16:
 732           /* This symbol requires a global offset table entry.  */
 733
 734           if (sgot == NULL)
 735             {
 736               sgot = bfd_get_section_by_name (dynobj, ".got");
 737               BFD_ASSERT (sgot != NULL);
 738             }
 739
 740           if (srelgot == NULL
 741               && (h != NULL || info->shared))
 742             {
 743               srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
 744               if (srelgot == NULL)
 745                 {
 746                   srelgot = bfd_make_section_with_flags (dynobj,
 747                                                          ".rela.got",
 748                                                          (SEC_ALLOC
 749                                                           | SEC_LOAD
 750                                                           | SEC_HAS_CONTENTS
 751                                                           | SEC_IN_MEMORY
 752                                                           | SEC_LINKER_CREATED
 753                                                           | SEC_READONLY));
 754                   if (srelgot == NULL
 755                       || ! bfd_set_section_alignment (dynobj, srelgot, 2))
 756                     return FALSE;
 757                 }
 758             }
 759
 760           if (h != NULL)
 761             {
 762               if (h->got.offset != (bfd_vma) -1)
 763                 /* We have already allocated space in the .got.  */
 764                 break;
 765
 766               h->got.offset = sgot->size;
 767
 768               /* Make sure this symbol is output as a dynamic symbol.  */
 769               if (h->dynindx == -1)
 770                 {
 771                   if (! bfd_elf_link_record_dynamic_symbol (info, h))
 772                     return FALSE;
 773                 }
 774
 775               srelgot->size += sizeof (Elf32_External_Rela);
 776             }
 777           else
 778             {
 779               /* This is a global offset table entry for a local
 780                  symbol.  */
 781               if (local_got_offsets == NULL)
 782                 {
 783                   size_t       size;
 784                   unsigned int i;
 785
 786                   size = symtab_hdr->sh_info * sizeof (bfd_vma);
 787                   local_got_offsets = bfd_alloc (abfd, size);
 788
 789                   if (local_got_offsets == NULL)
 790                     return FALSE;
 791                   elf_local_got_offsets (abfd) = local_got_offsets;
 792
 793                   for (i = 0; i < symtab_hdr->sh_info; i++)
 794                     local_got_offsets[i] = (bfd_vma) -1;
 795                 }
 796
 797               if (local_got_offsets[r_symndx] != (bfd_vma) -1)
 798                 /* We have already allocated space in the .got.  */
 799                 break;
 800
 801               local_got_offsets[r_symndx] = sgot->size;
 802
 803               if (info->shared)
 804                 /* If we are generating a shared object, we need to
 805                    output a R_MN10300_RELATIVE reloc so that the dynamic
 806                    linker can adjust this GOT entry.  */
 807                 srelgot->size += sizeof (Elf32_External_Rela);
 808             }
 809
 810           sgot->size += 4;
 811           break;
 812
 813         case R_MN10300_PLT32:
 814         case R_MN10300_PLT16:
 815           /* This symbol requires a procedure linkage table entry.  We
 816              actually build the entry in adjust_dynamic_symbol,
 817              because this might be a case of linking PIC code which is
 818              never referenced by a dynamic object, in which case we
 819              don't need to generate a procedure linkage table entry
 820              after all.  */
 821
 822           /* If this is a local symbol, we resolve it directly without
 823              creating a procedure linkage table entry.  */
 824           if (h == NULL)
 825             continue;
 826
 827           if (ELF_ST_VISIBILITY (h->other) == STV_INTERNAL
 828               || ELF_ST_VISIBILITY (h->other) == STV_HIDDEN)
 829             break;
 830
 831           h->needs_plt = 1;
 832           break;
 833
 834         case R_MN10300_24:
 835         case R_MN10300_16:
 836         case R_MN10300_8:
 837         case R_MN10300_PCREL32:
 838         case R_MN10300_PCREL16:
 839         case R_MN10300_PCREL8:
 840           if (h != NULL)
 841             h->non_got_ref = 1;
 842           break;
 843
 844         case R_MN10300_SYM_DIFF:
 845           sym_diff_reloc_seen = TRUE;
 846           break;
 847
 848         case R_MN10300_32:
 849           if (h != NULL)
 850             h->non_got_ref = 1;
 851
 852           /* If we are creating a shared library, then we
 853              need to copy the reloc into the shared library.  */
 854           if (info->shared
 855               && (sec->flags & SEC_ALLOC) != 0
 856               /* Do not generate a dynamic reloc for a
 857                  reloc associated with a SYM_DIFF operation.  */
 858               && ! sym_diff_reloc_seen)
 859             {
 860               asection * sym_section = NULL;
 861
 862               /* Find the section containing the
 863                  symbol involved in the relocation.  */
 864               if (h == NULL)
 865                 {
 866                   Elf_Internal_Sym * isymbuf;
 867                   Elf_Internal_Sym * isym;
 868
 869                   isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
 870                   if (isymbuf == NULL)
 871                     isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
 872                                                     symtab_hdr->sh_info, 0,
 873                                                     NULL, NULL, NULL);
 874                   if (isymbuf)
 875                     {
 876                       isym = isymbuf + r_symndx;
 877                       /* All we care about is whether this local symbol is absolute.  */
 878                       if (isym->st_shndx == SHN_ABS)
 879                         sym_section = bfd_abs_section_ptr;
 880                     }
 881                 }
 882               else
 883                 {
 884                   if (h->root.type == bfd_link_hash_defined
 885                       || h->root.type == bfd_link_hash_defweak)
 886                     sym_section = h->root.u.def.section;
 887                 }
 888
 889               /* If the symbol is absolute then the relocation can
 890                  be resolved during linking and there is no need for
 891                  a dynamic reloc.  */
 892               if (sym_section != bfd_abs_section_ptr)
 893                 {
 894                   /* When creating a shared object, we must copy these
 895                      reloc types into the output file.  We create a reloc
 896                      section in dynobj and make room for this reloc.  */
 897                   if (sreloc == NULL)
 898                     {
 899                       const char * name;
 900
 901                       name = (bfd_elf_string_from_elf_section
 902                               (abfd,
 903                                elf_elfheader (abfd)->e_shstrndx,
 904                                elf_section_data (sec)->rel_hdr.sh_name));
 905                       if (name == NULL)
 906                         return FALSE;
 907
 908                       BFD_ASSERT (CONST_STRNEQ (name, ".rela")
 909                                   && streq (bfd_get_section_name (abfd, sec), name + 5));
 910
 911                       sreloc = bfd_get_section_by_name (dynobj, name);
 912                       if (sreloc == NULL)
 913                         {
 914                           flagword flags;
 915
 916                           flags = (SEC_HAS_CONTENTS | SEC_READONLY
 917                                | SEC_IN_MEMORY | SEC_LINKER_CREATED);
 918                           if ((sec->flags & SEC_ALLOC) != 0)
 919                             flags |= SEC_ALLOC | SEC_LOAD;
 920                           sreloc = bfd_make_section_with_flags (dynobj, name, flags);
 921                           if (sreloc == NULL
 922                               || ! bfd_set_section_alignment (dynobj, sreloc, 2))
 923                             return FALSE;
 924                         }
 925                     }
 926
 927                   sreloc->size += sizeof (Elf32_External_Rela);
 928                 }
 929             }
 930
 931           break;
 932         }
 933
 934       if (ELF32_R_TYPE (rel->r_info) != R_MN10300_SYM_DIFF)
 935         sym_diff_reloc_seen = FALSE;
 936     }
 937
 938   return TRUE;
 939 }
 940
 941 /* Return the section that should be marked against GC for a given
 942    relocation.  */
 943
 944 static asection *
 945 mn10300_elf_gc_mark_hook (asection *sec,
 946                           struct bfd_link_info *info,
 947                           Elf_Internal_Rela *rel,
 948                           struct elf_link_hash_entry *h,
 949                           Elf_Internal_Sym *sym)
 950 {
 951   if (h != NULL)
 952     switch (ELF32_R_TYPE (rel->r_info))
 953       {
 954       case R_MN10300_GNU_VTINHERIT:
 955       case R_MN10300_GNU_VTENTRY:
 956         return NULL;
 957       }
 958
 959   return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
 960 }
 961
 962 /* Perform a relocation as part of a final link.  */
 963
 964 static bfd_reloc_status_type
 965 mn10300_elf_final_link_relocate (reloc_howto_type *howto,
 966                                  bfd *input_bfd,
 967                                  bfd *output_bfd ATTRIBUTE_UNUSED,
 968                                  asection *input_section,
 969                                  bfd_byte *contents,
 970                                  bfd_vma offset,
 971                                  bfd_vma value,
 972                                  bfd_vma addend,
 973                                  struct elf_link_hash_entry * h,
 974                                  unsigned long symndx,
 975                                  struct bfd_link_info *info,
 976                                  asection *sym_sec ATTRIBUTE_UNUSED,
 977                                  int is_local ATTRIBUTE_UNUSED)
 978 {
 979   static asection *  sym_diff_section;
 980   static bfd_vma     sym_diff_value;
 981   bfd_boolean is_sym_diff_reloc;
 982   unsigned long r_type = howto->type;
 983   bfd_byte * hit_data = contents + offset;
 984   bfd *      dynobj;
 985   bfd_vma *  local_got_offsets;
 986   asection * sgot;
 987   asection * splt;
 988   asection * sreloc;
 989
 990   dynobj = elf_hash_table (info)->dynobj;
 991   local_got_offsets = elf_local_got_offsets (input_bfd);
 992
 993   sgot   = NULL;
 994   splt   = NULL;
 995   sreloc = NULL;
 996
 997   switch (r_type)
 998     {
 999     case R_MN10300_24:
1000     case R_MN10300_16:
1001     case R_MN10300_8:
1002     case R_MN10300_PCREL8:
1003     case R_MN10300_PCREL16:
1004     case R_MN10300_PCREL32:
1005     case R_MN10300_GOTOFF32:
1006     case R_MN10300_GOTOFF24:
1007     case R_MN10300_GOTOFF16:
1008       if (info->shared
1009           && (input_section->flags & SEC_ALLOC) != 0
1010           && h != NULL
1011           && ! SYMBOL_REFERENCES_LOCAL (info, h))
1012         return bfd_reloc_dangerous;
1013     }
1014
1015   is_sym_diff_reloc = FALSE;
1016   if (sym_diff_section != NULL)
1017     {
1018       BFD_ASSERT (sym_diff_section == input_section);
1019
1020       switch (r_type)
1021         {
1022         case R_MN10300_32:
1023         case R_MN10300_24:
1024         case R_MN10300_16:
1025         case R_MN10300_8:
1026           value -= sym_diff_value;
1027           sym_diff_section = NULL;
1028           is_sym_diff_reloc = TRUE;
1029           break;
1030
1031         default:
1032           sym_diff_section = NULL;
1033           break;
1034         }
1035     }
1036
1037   switch (r_type)
1038     {
1039     case R_MN10300_SYM_DIFF:
1040       BFD_ASSERT (addend == 0);
1041       /* Cache the input section and value.
1042          The offset is unreliable, since relaxation may
1043          have reduced the following reloc's offset.  */
1044       sym_diff_section = input_section;
1045       sym_diff_value = value;
1046       return bfd_reloc_ok;
1047
1048     case R_MN10300_NONE:
1049       return bfd_reloc_ok;
1050
1051     case R_MN10300_32:
1052       if (info->shared
1053           /* Do not generate relocs when an R_MN10300_32 has been used
1054              with an R_MN10300_SYM_DIFF to compute a difference of two
1055              symbols.  */
1056           && is_sym_diff_reloc == FALSE
1057           /* Also, do not generate a reloc when the symbol associated
1058              with the R_MN10300_32 reloc is absolute - there is no
1059              need for a run time computation in this case.  */
1060           && sym_sec != bfd_abs_section_ptr
1061           /* If the section is not going to be allocated at load time
1062              then there is no need to generate relocs for it.  */
1063           && (input_section->flags & SEC_ALLOC) != 0)
1064         {
1065           Elf_Internal_Rela outrel;
1066           bfd_boolean skip, relocate;
1067
1068           /* When generating a shared object, these relocations are
1069              copied into the output file to be resolved at run
1070              time.  */
1071           if (sreloc == NULL)
1072             {
1073               const char * name;
1074
1075               name = (bfd_elf_string_from_elf_section
1076                       (input_bfd,
1077                        elf_elfheader (input_bfd)->e_shstrndx,
1078                        elf_section_data (input_section)->rel_hdr.sh_name));
1079               if (name == NULL)
1080                 return FALSE;
1081
1082               BFD_ASSERT (CONST_STRNEQ (name, ".rela")
1083                           && streq (bfd_get_section_name (input_bfd,
1084                                                           input_section),
1085                                     name + 5));
1086
1087               sreloc = bfd_get_section_by_name (dynobj, name);
1088               BFD_ASSERT (sreloc != NULL);
1089             }
1090
1091           skip = FALSE;
1092
1093           outrel.r_offset = _bfd_elf_section_offset (input_bfd, info,
1094                                                      input_section, offset);
1095           if (outrel.r_offset == (bfd_vma) -1)
1096             skip = TRUE;
1097
1098           outrel.r_offset += (input_section->output_section->vma
1099                               + input_section->output_offset);
1100
1101           if (skip)
1102             {
1103               memset (&outrel, 0, sizeof outrel);
1104               relocate = FALSE;
1105             }
1106           else
1107             {
1108               /* h->dynindx may be -1 if this symbol was marked to
1109                  become local.  */
1110               if (h == NULL
1111                   || SYMBOL_REFERENCES_LOCAL (info, h))
1112                 {
1113                   relocate = TRUE;
1114                   outrel.r_info = ELF32_R_INFO (0, R_MN10300_RELATIVE);
1115                   outrel.r_addend = value + addend;
1116                 }
1117               else
1118                 {
1119                   BFD_ASSERT (h->dynindx != -1);
1120                   relocate = FALSE;
1121                   outrel.r_info = ELF32_R_INFO (h->dynindx, R_MN10300_32);
1122                   outrel.r_addend = value + addend;
1123                 }
1124             }
1125
1126           bfd_elf32_swap_reloca_out (output_bfd, &outrel,
1127                                      (bfd_byte *) (((Elf32_External_Rela *) sreloc->contents)
1128                                                    + sreloc->reloc_count));
1129           ++sreloc->reloc_count;
1130
1131           /* If this reloc is against an external symbol, we do
1132              not want to fiddle with the addend.  Otherwise, we
1133              need to include the symbol value so that it becomes
1134              an addend for the dynamic reloc.  */
1135           if (! relocate)
1136             return bfd_reloc_ok;
1137         }
1138       value += addend;
1139       bfd_put_32 (input_bfd, value, hit_data);
1140       return bfd_reloc_ok;
1141
1142     case R_MN10300_24:
1143       value += addend;
1144
1145       if ((long) value > 0x7fffff || (long) value < -0x800000)
1146         return bfd_reloc_overflow;
1147
1148       bfd_put_8 (input_bfd, value & 0xff, hit_data);
1149       bfd_put_8 (input_bfd, (value >> 8) & 0xff, hit_data + 1);
1150       bfd_put_8 (input_bfd, (value >> 16) & 0xff, hit_data + 2);
1151       return bfd_reloc_ok;
1152
1153     case R_MN10300_16:
1154       value += addend;
1155
1156       if ((long) value > 0x7fff || (long) value < -0x8000)
1157         return bfd_reloc_overflow;
1158
1159       bfd_put_16 (input_bfd, value, hit_data);
1160       return bfd_reloc_ok;
1161
1162     case R_MN10300_8:
1163       value += addend;
1164
1165       if ((long) value > 0x7f || (long) value < -0x80)
1166         return bfd_reloc_overflow;
1167
1168       bfd_put_8 (input_bfd, value, hit_data);
1169       return bfd_reloc_ok;
1170
1171     case R_MN10300_PCREL8:
1172       value -= (input_section->output_section->vma
1173                 + input_section->output_offset);
1174       value -= offset;
1175       value += addend;
1176
1177       if ((long) value > 0xff || (long) value < -0x100)
1178         return bfd_reloc_overflow;
1179
1180       bfd_put_8 (input_bfd, value, hit_data);
1181       return bfd_reloc_ok;
1182
1183     case R_MN10300_PCREL16:
1184       value -= (input_section->output_section->vma
1185                 + input_section->output_offset);
1186       value -= offset;
1187       value += addend;
1188
1189       if ((long) value > 0xffff || (long) value < -0x10000)
1190         return bfd_reloc_overflow;
1191
1192       bfd_put_16 (input_bfd, value, hit_data);
1193       return bfd_reloc_ok;
1194
1195     case R_MN10300_PCREL32:
1196       value -= (input_section->output_section->vma
1197                 + input_section->output_offset);
1198       value -= offset;
1199       value += addend;
1200
1201       bfd_put_32 (input_bfd, value, hit_data);
1202       return bfd_reloc_ok;
1203
1204     case R_MN10300_GNU_VTINHERIT:
1205     case R_MN10300_GNU_VTENTRY:
1206       return bfd_reloc_ok;
1207
1208     case R_MN10300_GOTPC32:
1209       /* Use global offset table as symbol value.  */
1210       value = bfd_get_section_by_name (dynobj,
1211                                        ".got")->output_section->vma;
1212       value -= (input_section->output_section->vma
1213                 + input_section->output_offset);
1214       value -= offset;
1215       value += addend;
1216
1217       bfd_put_32 (input_bfd, value, hit_data);
1218       return bfd_reloc_ok;
1219
1220     case R_MN10300_GOTPC16:
1221       /* Use global offset table as symbol value.  */
1222       value = bfd_get_section_by_name (dynobj,
1223                                        ".got")->output_section->vma;
1224       value -= (input_section->output_section->vma
1225                 + input_section->output_offset);
1226       value -= offset;
1227       value += addend;
1228
1229       if ((long) value > 0xffff || (long) value < -0x10000)
1230         return bfd_reloc_overflow;
1231
1232       bfd_put_16 (input_bfd, value, hit_data);
1233       return bfd_reloc_ok;
1234
1235     case R_MN10300_GOTOFF32:
1236       value -= bfd_get_section_by_name (dynobj,
1237                                         ".got")->output_section->vma;
1238       value += addend;
1239
1240       bfd_put_32 (input_bfd, value, hit_data);
1241       return bfd_reloc_ok;
1242
1243     case R_MN10300_GOTOFF24:
1244       value -= bfd_get_section_by_name (dynobj,
1245                                         ".got")->output_section->vma;
1246       value += addend;
1247
1248       if ((long) value > 0x7fffff || (long) value < -0x800000)
1249         return bfd_reloc_overflow;
1250
1251       bfd_put_8 (input_bfd, value, hit_data);
1252       bfd_put_8 (input_bfd, (value >> 8) & 0xff, hit_data + 1);
1253       bfd_put_8 (input_bfd, (value >> 16) & 0xff, hit_data + 2);
1254       return bfd_reloc_ok;
1255
1256     case R_MN10300_GOTOFF16:
1257       value -= bfd_get_section_by_name (dynobj,
1258                                         ".got")->output_section->vma;
1259       value += addend;
1260
1261       if ((long) value > 0xffff || (long) value < -0x10000)
1262         return bfd_reloc_overflow;
1263
1264       bfd_put_16 (input_bfd, value, hit_data);
1265       return bfd_reloc_ok;
1266
1267     case R_MN10300_PLT32:
1268       if (h != NULL
1269           && ELF_ST_VISIBILITY (h->other) != STV_INTERNAL
1270           && ELF_ST_VISIBILITY (h->other) != STV_HIDDEN
1271           && h->plt.offset != (bfd_vma) -1)
1272         {
1273           asection * splt;
1274
1275           splt = bfd_get_section_by_name (dynobj, ".plt");
1276
1277           value = (splt->output_section->vma
1278                    + splt->output_offset
1279                    + h->plt.offset) - value;
1280         }
1281
1282       value -= (input_section->output_section->vma
1283                 + input_section->output_offset);
1284       value -= offset;
1285       value += addend;
1286
1287       bfd_put_32 (input_bfd, value, hit_data);
1288       return bfd_reloc_ok;
1289
1290     case R_MN10300_PLT16:
1291       if (h != NULL
1292           && ELF_ST_VISIBILITY (h->other) != STV_INTERNAL
1293           && ELF_ST_VISIBILITY (h->other) != STV_HIDDEN
1294           && h->plt.offset != (bfd_vma) -1)
1295         {
1296           asection * splt;
1297
1298           splt = bfd_get_section_by_name (dynobj, ".plt");
1299
1300           value = (splt->output_section->vma
1301                    + splt->output_offset
1302                    + h->plt.offset) - value;
1303         }
1304
1305       value -= (input_section->output_section->vma
1306                 + input_section->output_offset);
1307       value -= offset;
1308       value += addend;
1309
1310       if ((long) value > 0xffff || (long) value < -0x10000)
1311         return bfd_reloc_overflow;
1312
1313       bfd_put_16 (input_bfd, value, hit_data);
1314       return bfd_reloc_ok;
1315
1316     case R_MN10300_GOT32:
1317     case R_MN10300_GOT24:
1318     case R_MN10300_GOT16:
1319       {
1320         asection * sgot;
1321
1322         sgot = bfd_get_section_by_name (dynobj, ".got");
1323
1324           if (h != NULL)
1325             {
1326               bfd_vma off;
1327
1328               off = h->got.offset;
1329               BFD_ASSERT (off != (bfd_vma) -1);
1330
1331               if (! elf_hash_table (info)->dynamic_sections_created
1332                   || SYMBOL_REFERENCES_LOCAL (info, h))
1333                 /* This is actually a static link, or it is a
1334                    -Bsymbolic link and the symbol is defined
1335                    locally, or the symbol was forced to be local
1336                    because of a version file.  We must initialize
1337                    this entry in the global offset table.
1338
1339                    When doing a dynamic link, we create a .rela.got
1340                    relocation entry to initialize the value.  This
1341                    is done in the finish_dynamic_symbol routine.  */
1342                 bfd_put_32 (output_bfd, value,
1343                             sgot->contents + off);
1344
1345               value = sgot->output_offset + off;
1346             }
1347           else
1348             {
1349               bfd_vma off;
1350
1351               off = elf_local_got_offsets (input_bfd)[symndx];
1352
1353               bfd_put_32 (output_bfd, value, sgot->contents + off);
1354
1355               if (info->shared)
1356                 {
1357                   asection * srelgot;
1358                   Elf_Internal_Rela outrel;
1359
1360                   srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
1361                   BFD_ASSERT (srelgot != NULL);
1362
1363                   outrel.r_offset = (sgot->output_section->vma
1364                                      + sgot->output_offset
1365                                      + off);
1366                   outrel.r_info = ELF32_R_INFO (0, R_MN10300_RELATIVE);
1367                   outrel.r_addend = value;
1368                   bfd_elf32_swap_reloca_out (output_bfd, &outrel,
1369                                              (bfd_byte *) (((Elf32_External_Rela *)
1370                                                             srelgot->contents)
1371                                                            + srelgot->reloc_count));
1372                   ++ srelgot->reloc_count;
1373                 }
1374
1375               value = sgot->output_offset + off;
1376             }
1377       }
1378
1379       value += addend;
1380
1381       if (r_type == R_MN10300_GOT32)
1382         {
1383           bfd_put_32 (input_bfd, value, hit_data);
1384           return bfd_reloc_ok;
1385         }
1386       else if (r_type == R_MN10300_GOT24)
1387         {
1388           if ((long) value > 0x7fffff || (long) value < -0x800000)
1389             return bfd_reloc_overflow;
1390
1391           bfd_put_8 (input_bfd, value & 0xff, hit_data);
1392           bfd_put_8 (input_bfd, (value >> 8) & 0xff, hit_data + 1);
1393           bfd_put_8 (input_bfd, (value >> 16) & 0xff, hit_data + 2);
1394           return bfd_reloc_ok;
1395         }
1396       else if (r_type == R_MN10300_GOT16)
1397         {
1398           if ((long) value > 0xffff || (long) value < -0x10000)
1399             return bfd_reloc_overflow;
1400
1401           bfd_put_16 (input_bfd, value, hit_data);
1402           return bfd_reloc_ok;
1403         }
1404       /* Fall through.  */
1405
1406     default:
1407       return bfd_reloc_notsupported;
1408     }
1409 }
1410 \f
1411 /* Relocate an MN10300 ELF section.  */
1412
1413 static bfd_boolean
1414 mn10300_elf_relocate_section (bfd *output_bfd,
1415                               struct bfd_link_info *info,
1416                               bfd *input_bfd,
1417                               asection *input_section,
1418                               bfd_byte *contents,
1419                               Elf_Internal_Rela *relocs,
1420                               Elf_Internal_Sym *local_syms,
1421                               asection **local_sections)
1422 {
1423   Elf_Internal_Shdr *symtab_hdr;
1424   struct elf_link_hash_entry **sym_hashes;
1425   Elf_Internal_Rela *rel, *relend;
1426
1427   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1428   sym_hashes = elf_sym_hashes (input_bfd);
1429
1430   rel = relocs;
1431   relend = relocs + input_section->reloc_count;
1432   for (; rel < relend; rel++)
1433     {
1434       int r_type;
1435       reloc_howto_type *howto;
1436       unsigned long r_symndx;
1437       Elf_Internal_Sym *sym;
1438       asection *sec;
1439       struct elf32_mn10300_link_hash_entry *h;
1440       bfd_vma relocation;
1441       bfd_reloc_status_type r;
1442
1443       r_symndx = ELF32_R_SYM (rel->r_info);
1444       r_type = ELF32_R_TYPE (rel->r_info);
1445       howto = elf_mn10300_howto_table + r_type;
1446
1447       /* Just skip the vtable gc relocs.  */
1448       if (r_type == R_MN10300_GNU_VTINHERIT
1449           || r_type == R_MN10300_GNU_VTENTRY)
1450         continue;
1451
1452       h = NULL;
1453       sym = NULL;
1454       sec = NULL;
1455       if (r_symndx < symtab_hdr->sh_info)
1456         {
1457           sym = local_syms + r_symndx;
1458           sec = local_sections[r_symndx];
1459           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
1460         }
1461       else
1462         {
1463           bfd_boolean unresolved_reloc;
1464           bfd_boolean warned;
1465           struct elf_link_hash_entry *hh;
1466
1467           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
1468                                    r_symndx, symtab_hdr, sym_hashes,
1469                                    hh, sec, relocation,
1470                                    unresolved_reloc, warned);
1471
1472           h = (struct elf32_mn10300_link_hash_entry *) hh;
1473
1474           if ((h->root.root.type == bfd_link_hash_defined
1475               || h->root.root.type == bfd_link_hash_defweak)
1476               && (   r_type == R_MN10300_GOTPC32
1477                   || r_type == R_MN10300_GOTPC16
1478                   || ((   r_type == R_MN10300_PLT32
1479                        || r_type == R_MN10300_PLT16)
1480                       && ELF_ST_VISIBILITY (h->root.other) != STV_INTERNAL
1481                       && ELF_ST_VISIBILITY (h->root.other) != STV_HIDDEN
1482                       && h->root.plt.offset != (bfd_vma) -1)
1483                   || ((   r_type == R_MN10300_GOT32
1484                        || r_type == R_MN10300_GOT24
1485                        || r_type == R_MN10300_GOT16)
1486                       && elf_hash_table (info)->dynamic_sections_created
1487                       && !SYMBOL_REFERENCES_LOCAL (info, hh))
1488                   || (r_type == R_MN10300_32
1489                       /* _32 relocs in executables force _COPY relocs,
1490                          such that the address of the symbol ends up
1491                          being local.  */
1492                       && !info->executable
1493                       && !SYMBOL_REFERENCES_LOCAL (info, hh)
1494                       && ((input_section->flags & SEC_ALLOC) != 0
1495                           /* DWARF will emit R_MN10300_32 relocations
1496                              in its sections against symbols defined
1497                              externally in shared libraries.  We can't
1498                              do anything with them here.  */
1499                           || ((input_section->flags & SEC_DEBUGGING) != 0
1500                               && h->root.def_dynamic)))))
1501             /* In these cases, we don't need the relocation
1502                value.  We check specially because in some
1503                obscure cases sec->output_section will be NULL.  */
1504             relocation = 0;
1505
1506           else if (!info->relocatable && unresolved_reloc)
1507             (*_bfd_error_handler)
1508               (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
1509                input_bfd,
1510                input_section,
1511                (long) rel->r_offset,
1512                howto->name,
1513                h->root.root.root.string);
1514         }
1515
1516       if (sec != NULL && elf_discarded_section (sec))
1517         {
1518           /* For relocs against symbols from removed linkonce sections,
1519              or sections discarded by a linker script, we just want the
1520              section contents zeroed.  Avoid any special processing.  */
1521           _bfd_clear_contents (howto, input_bfd, contents + rel->r_offset);
1522           rel->r_info = 0;
1523           rel->r_addend = 0;
1524           continue;
1525         }
1526
1527       if (info->relocatable)
1528         continue;
1529
1530       r = mn10300_elf_final_link_relocate (howto, input_bfd, output_bfd,
1531                                            input_section,
1532                                            contents, rel->r_offset,
1533                                            relocation, rel->r_addend,
1534                                            (struct elf_link_hash_entry *) h,
1535                                            r_symndx,
1536                                            info, sec, h == NULL);
1537
1538       if (r != bfd_reloc_ok)
1539         {
1540           const char *name;
1541           const char *msg = NULL;
1542
1543           if (h != NULL)
1544             name = h->root.root.root.string;
1545           else
1546             {
1547               name = (bfd_elf_string_from_elf_section
1548                       (input_bfd, symtab_hdr->sh_link, sym->st_name));
1549               if (name == NULL || *name == '\0')
1550                 name = bfd_section_name (input_bfd, sec);
1551             }
1552
1553           switch (r)
1554             {
1555             case bfd_reloc_overflow:
1556               if (! ((*info->callbacks->reloc_overflow)
1557                      (info, (h ? &h->root.root : NULL), name,
1558                       howto->name, (bfd_vma) 0, input_bfd,
1559                       input_section, rel->r_offset)))
1560                 return FALSE;
1561               break;
1562
1563             case bfd_reloc_undefined:
1564               if (! ((*info->callbacks->undefined_symbol)
1565                      (info, name, input_bfd, input_section,
1566                       rel->r_offset, TRUE)))
1567                 return FALSE;
1568               break;
1569
1570             case bfd_reloc_outofrange:
1571               msg = _("internal error: out of range error");
1572               goto common_error;
1573
1574             case bfd_reloc_notsupported:
1575               msg = _("internal error: unsupported relocation error");
1576               goto common_error;
1577
1578             case bfd_reloc_dangerous:
1579               if (r_type == R_MN10300_PCREL32)
1580                 msg = _("error: inappropriate relocation type for shared"
1581                         " library (did you forget -fpic?)");
1582               else
1583                 msg = _("internal error: suspicious relocation type used"
1584                         " in shared library");
1585               goto common_error;
1586
1587             default:
1588               msg = _("internal error: unknown error");
1589               /* Fall through.  */
1590
1591             common_error:
1592               if (!((*info->callbacks->warning)
1593                     (info, msg, name, input_bfd, input_section,
1594                      rel->r_offset)))
1595                 return FALSE;
1596               break;
1597             }
1598         }
1599     }
1600
1601   return TRUE;
1602 }
1603
1604 /* Finish initializing one hash table entry.  */
1605
1606 static bfd_boolean
1607 elf32_mn10300_finish_hash_table_entry (struct bfd_hash_entry *gen_entry,
1608                                        void * in_args)
1609 {
1610   struct elf32_mn10300_link_hash_entry *entry;
1611   struct bfd_link_info *link_info = (struct bfd_link_info *) in_args;
1612   unsigned int byte_count = 0;
1613
1614   entry = (struct elf32_mn10300_link_hash_entry *) gen_entry;
1615
1616   if (entry->root.root.type == bfd_link_hash_warning)
1617     entry = (struct elf32_mn10300_link_hash_entry *) entry->root.root.u.i.link;
1618
1619   /* If we already know we want to convert "call" to "calls" for calls
1620      to this symbol, then return now.  */
1621   if (entry->flags == MN10300_CONVERT_CALL_TO_CALLS)
1622     return TRUE;
1623
1624   /* If there are no named calls to this symbol, or there's nothing we
1625      can move from the function itself into the "call" instruction,
1626      then note that all "call" instructions should be converted into
1627      "calls" instructions and return.  If a symbol is available for
1628      dynamic symbol resolution (overridable or overriding), avoid
1629      custom calling conventions.  */
1630   if (entry->direct_calls == 0
1631       || (entry->stack_size == 0 && entry->movm_args == 0)
1632       || (elf_hash_table (link_info)->dynamic_sections_created
1633           && ELF_ST_VISIBILITY (entry->root.other) != STV_INTERNAL
1634           && ELF_ST_VISIBILITY (entry->root.other) != STV_HIDDEN))
1635     {
1636       /* Make a note that we should convert "call" instructions to "calls"
1637          instructions for calls to this symbol.  */
1638       entry->flags |= MN10300_CONVERT_CALL_TO_CALLS;
1639       return TRUE;
1640     }
1641
1642   /* We may be able to move some instructions from the function itself into
1643      the "call" instruction.  Count how many bytes we might be able to
1644      eliminate in the function itself.  */
1645
1646   /* A movm instruction is two bytes.  */
1647   if (entry->movm_args)
1648     byte_count += 2;
1649
1650   /* Count the insn to allocate stack space too.  */
1651   if (entry->stack_size > 0)
1652     {
1653       if (entry->stack_size <= 128)
1654         byte_count += 3;
1655       else
1656         byte_count += 4;
1657     }
1658
1659   /* If using "call" will result in larger code, then turn all
1660      the associated "call" instructions into "calls" instructions.  */
1661   if (byte_count < entry->direct_calls)
1662     entry->flags |= MN10300_CONVERT_CALL_TO_CALLS;
1663
1664   /* This routine never fails.  */
1665   return TRUE;
1666 }
1667
1668 /* Used to count hash table entries.  */
1669
1670 static bfd_boolean
1671 elf32_mn10300_count_hash_table_entries (struct bfd_hash_entry *gen_entry ATTRIBUTE_UNUSED,
1672                                         void * in_args)
1673 {
1674   int *count = (int *) in_args;
1675
1676   (*count) ++;
1677   return TRUE;
1678 }
1679
1680 /* Used to enumerate hash table entries into a linear array.  */
1681
1682 static bfd_boolean
1683 elf32_mn10300_list_hash_table_entries (struct bfd_hash_entry *gen_entry,
1684                                        void * in_args)
1685 {
1686   struct bfd_hash_entry ***ptr = (struct bfd_hash_entry ***) in_args;
1687
1688   **ptr = gen_entry;
1689   (*ptr) ++;
1690   return TRUE;
1691 }
1692
1693 /* Used to sort the array created by the above.  */
1694
1695 static int
1696 sort_by_value (const void *va, const void *vb)
1697 {
1698   struct elf32_mn10300_link_hash_entry *a
1699     = *(struct elf32_mn10300_link_hash_entry **) va;
1700   struct elf32_mn10300_link_hash_entry *b
1701     = *(struct elf32_mn10300_link_hash_entry **) vb;
1702
1703   return a->value - b->value;
1704 }
1705
1706 /* Compute the stack size and movm arguments for the function
1707    referred to by HASH at address ADDR in section with
1708    contents CONTENTS, store the information in the hash table.  */
1709
1710 static void
1711 compute_function_info (bfd *abfd,
1712                        struct elf32_mn10300_link_hash_entry *hash,
1713                        bfd_vma addr,
1714                        unsigned char *contents)
1715 {
1716   unsigned char byte1, byte2;
1717   /* We only care about a very small subset of the possible prologue
1718      sequences here.  Basically we look for:
1719
1720      movm [d2,d3,a2,a3],sp (optional)
1721      add <size>,sp (optional, and only for sizes which fit in an unsigned
1722                     8 bit number)
1723
1724      If we find anything else, we quit.  */
1725
1726   /* Look for movm [regs],sp.  */
1727   byte1 = bfd_get_8 (abfd, contents + addr);
1728   byte2 = bfd_get_8 (abfd, contents + addr + 1);
1729
1730   if (byte1 == 0xcf)
1731     {
1732       hash->movm_args = byte2;
1733       addr += 2;
1734       byte1 = bfd_get_8 (abfd, contents + addr);
1735       byte2 = bfd_get_8 (abfd, contents + addr + 1);
1736     }
1737
1738   /* Now figure out how much stack space will be allocated by the movm
1739      instruction.  We need this kept separate from the function's normal
1740      stack space.  */
1741   if (hash->movm_args)
1742     {
1743       /* Space for d2.  */
1744       if (hash->movm_args & 0x80)
1745         hash->movm_stack_size += 4;
1746
1747       /* Space for d3.  */
1748       if (hash->movm_args & 0x40)
1749         hash->movm_stack_size += 4;
1750
1751       /* Space for a2.  */
1752       if (hash->movm_args & 0x20)
1753         hash->movm_stack_size += 4;
1754
1755       /* Space for a3.  */
1756       if (hash->movm_args & 0x10)
1757         hash->movm_stack_size += 4;
1758
1759       /* "other" space.  d0, d1, a0, a1, mdr, lir, lar, 4 byte pad.  */
1760       if (hash->movm_args & 0x08)
1761         hash->movm_stack_size += 8 * 4;
1762
1763       if (bfd_get_mach (abfd) == bfd_mach_am33
1764           || bfd_get_mach (abfd) == bfd_mach_am33_2)
1765         {
1766           /* "exother" space.  e0, e1, mdrq, mcrh, mcrl, mcvf */
1767           if (hash->movm_args & 0x1)
1768             hash->movm_stack_size += 6 * 4;
1769
1770           /* exreg1 space.  e4, e5, e6, e7 */
1771           if (hash->movm_args & 0x2)
1772             hash->movm_stack_size += 4 * 4;
1773
1774           /* exreg0 space.  e2, e3  */
1775           if (hash->movm_args & 0x4)
1776             hash->movm_stack_size += 2 * 4;
1777         }
1778     }
1779
1780   /* Now look for the two stack adjustment variants.  */
1781   if (byte1 == 0xf8 && byte2 == 0xfe)
1782     {
1783       int temp = bfd_get_8 (abfd, contents + addr + 2);
1784       temp = ((temp & 0xff) ^ (~0x7f)) + 0x80;
1785
1786       hash->stack_size = -temp;
1787     }
1788   else if (byte1 == 0xfa && byte2 == 0xfe)
1789     {
1790       int temp = bfd_get_16 (abfd, contents + addr + 2);
1791       temp = ((temp & 0xffff) ^ (~0x7fff)) + 0x8000;
1792       temp = -temp;
1793
1794       if (temp < 255)
1795         hash->stack_size = temp;
1796     }
1797
1798   /* If the total stack to be allocated by the call instruction is more
1799      than 255 bytes, then we can't remove the stack adjustment by using
1800      "call" (we might still be able to remove the "movm" instruction.  */
1801   if (hash->stack_size + hash->movm_stack_size > 255)
1802     hash->stack_size = 0;
1803 }
1804
1805 /* Delete some bytes from a section while relaxing.  */
1806
1807 static bfd_boolean
1808 mn10300_elf_relax_delete_bytes (bfd *abfd,
1809                                 asection *sec,
1810                                 bfd_vma addr,
1811                                 int count)
1812 {
1813   Elf_Internal_Shdr *symtab_hdr;
1814   unsigned int sec_shndx;
1815   bfd_byte *contents;
1816   Elf_Internal_Rela *irel, *irelend;
1817   Elf_Internal_Rela *irelalign;
1818   bfd_vma toaddr;
1819   Elf_Internal_Sym *isym, *isymend;
1820   struct elf_link_hash_entry **sym_hashes;
1821   struct elf_link_hash_entry **end_hashes;
1822   unsigned int symcount;
1823
1824   sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
1825
1826   contents = elf_section_data (sec)->this_hdr.contents;
1827
1828   /* The deletion must stop at the next ALIGN reloc for an aligment
1829      power larger than the number of bytes we are deleting.  */
1830
1831   irelalign = NULL;
1832   toaddr = sec->size;
1833
1834   irel = elf_section_data (sec)->relocs;
1835   irelend = irel + sec->reloc_count;
1836
1837   /* Actually delete the bytes.  */
1838   memmove (contents + addr, contents + addr + count,
1839            (size_t) (toaddr - addr - count));
1840   sec->size -= count;
1841
1842   /* Adjust all the relocs.  */
1843   for (irel = elf_section_data (sec)->relocs; irel < irelend; irel++)
1844     {
1845       /* Get the new reloc address.  */
1846       if ((irel->r_offset > addr
1847            && irel->r_offset < toaddr))
1848         irel->r_offset -= count;
1849     }
1850
1851   /* Adjust the local symbols defined in this section.  */
1852   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1853   isym = (Elf_Internal_Sym *) symtab_hdr->contents;
1854   for (isymend = isym + symtab_hdr->sh_info; isym < isymend; isym++)
1855     {
1856       if (isym->st_shndx == sec_shndx
1857           && isym->st_value > addr
1858           && isym->st_value <= toaddr)
1859         isym->st_value -= count;
1860       /* Adjust the function symbol's size as well.  */
1861       else if (isym->st_shndx == sec_shndx
1862                && ELF_ST_TYPE (isym->st_info) == STT_FUNC
1863                && isym->st_value + isym->st_size > addr
1864                && isym->st_value + isym->st_size <= toaddr)
1865         isym->st_size -= count;
1866     }
1867
1868   /* Now adjust the global symbols defined in this section.  */
1869   symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
1870               - symtab_hdr->sh_info);
1871   sym_hashes = elf_sym_hashes (abfd);
1872   end_hashes = sym_hashes + symcount;
1873   for (; sym_hashes < end_hashes; sym_hashes++)
1874     {
1875       struct elf_link_hash_entry *sym_hash = *sym_hashes;
1876
1877       if ((sym_hash->root.type == bfd_link_hash_defined
1878            || sym_hash->root.type == bfd_link_hash_defweak)
1879           && sym_hash->root.u.def.section == sec
1880           && sym_hash->root.u.def.value > addr
1881           && sym_hash->root.u.def.value <= toaddr)
1882         sym_hash->root.u.def.value -= count;
1883       /* Adjust the function symbol's size as well.  */
1884       else if (sym_hash->root.type == bfd_link_hash_defined
1885                && sym_hash->root.u.def.section == sec
1886                && sym_hash->type == STT_FUNC
1887                && sym_hash->root.u.def.value + sym_hash->size > addr
1888                && sym_hash->root.u.def.value + sym_hash->size <= toaddr)
1889         sym_hash->size -= count;
1890     }
1891
1892   return TRUE;
1893 }
1894
1895 /* Return TRUE if a symbol exists at the given address, else return
1896    FALSE.  */
1897
1898 static bfd_boolean
1899 mn10300_elf_symbol_address_p (bfd *abfd,
1900                               asection *sec,
1901                               Elf_Internal_Sym *isym,
1902                               bfd_vma addr)
1903 {
1904   Elf_Internal_Shdr *symtab_hdr;
1905   unsigned int sec_shndx;
1906   Elf_Internal_Sym *isymend;
1907   struct elf_link_hash_entry **sym_hashes;
1908   struct elf_link_hash_entry **end_hashes;
1909   unsigned int symcount;
1910
1911   sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
1912
1913   /* Examine all the symbols.  */
1914   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1915   for (isymend = isym + symtab_hdr->sh_info; isym < isymend; isym++)
1916     if (isym->st_shndx == sec_shndx
1917         && isym->st_value == addr)
1918       return TRUE;
1919
1920   symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
1921               - symtab_hdr->sh_info);
1922   sym_hashes = elf_sym_hashes (abfd);
1923   end_hashes = sym_hashes + symcount;
1924   for (; sym_hashes < end_hashes; sym_hashes++)
1925     {
1926       struct elf_link_hash_entry *sym_hash = *sym_hashes;
1927
1928       if ((sym_hash->root.type == bfd_link_hash_defined
1929            || sym_hash->root.type == bfd_link_hash_defweak)
1930           && sym_hash->root.u.def.section == sec
1931           && sym_hash->root.u.def.value == addr)
1932         return TRUE;
1933     }
1934
1935   return FALSE;
1936 }
1937
1938 /* This function handles relaxing for the mn10300.
1939
1940    There are quite a few relaxing opportunities available on the mn10300:
1941
1942         * calls:32 -> calls:16                                     2 bytes
1943         * call:32  -> call:16                                      2 bytes
1944
1945         * call:32 -> calls:32                                      1 byte
1946         * call:16 -> calls:16                                      1 byte
1947                 * These are done anytime using "calls" would result
1948                 in smaller code, or when necessary to preserve the
1949                 meaning of the program.
1950
1951         * call:32                                                  varies
1952         * call:16
1953                 * In some circumstances we can move instructions
1954                 from a function prologue into a "call" instruction.
1955                 This is only done if the resulting code is no larger
1956                 than the original code.
1957
1958         * jmp:32 -> jmp:16                                         2 bytes
1959         * jmp:16 -> bra:8                                          1 byte
1960
1961                 * If the previous instruction is a conditional branch
1962                 around the jump/bra, we may be able to reverse its condition
1963                 and change its target to the jump's target.  The jump/bra
1964                 can then be deleted.                               2 bytes
1965
1966         * mov abs32 -> mov abs16                                   1 or 2 bytes
1967
1968         * Most instructions which accept imm32 can relax to imm16  1 or 2 bytes
1969         - Most instructions which accept imm16 can relax to imm8   1 or 2 bytes
1970
1971         * Most instructions which accept d32 can relax to d16      1 or 2 bytes
1972         - Most instructions which accept d16 can relax to d8       1 or 2 bytes
1973
1974         We don't handle imm16->imm8 or d16->d8 as they're very rare
1975         and somewhat more difficult to support.  */
1976
1977 static bfd_boolean
1978 mn10300_elf_relax_section (bfd *abfd,
1979                            asection *sec,
1980                            struct bfd_link_info *link_info,
1981                            bfd_boolean *again)
1982 {
1983   Elf_Internal_Shdr *symtab_hdr;
1984   Elf_Internal_Rela *internal_relocs = NULL;
1985   Elf_Internal_Rela *irel, *irelend;
1986   bfd_byte *contents = NULL;
1987   Elf_Internal_Sym *isymbuf = NULL;
1988   struct elf32_mn10300_link_hash_table *hash_table;
1989   asection *section = sec;
1990
1991   /* Assume nothing changes.  */
1992   *again = FALSE;
1993
1994   /* We need a pointer to the mn10300 specific hash table.  */
1995   hash_table = elf32_mn10300_hash_table (link_info);
1996
1997   /* Initialize fields in each hash table entry the first time through.  */
1998   if ((hash_table->flags & MN10300_HASH_ENTRIES_INITIALIZED) == 0)
1999     {
2000       bfd *input_bfd;
2001
2002       /* Iterate over all the input bfds.  */
2003       for (input_bfd = link_info->input_bfds;
2004            input_bfd != NULL;
2005            input_bfd = input_bfd->link_next)
2006         {
2007           /* We're going to need all the symbols for each bfd.  */
2008           symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2009           if (symtab_hdr->sh_info != 0)
2010             {
2011               isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
2012               if (isymbuf == NULL)
2013                 isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
2014                                                 symtab_hdr->sh_info, 0,
2015                                                 NULL, NULL, NULL);
2016               if (isymbuf == NULL)
2017                 goto error_return;
2018             }
2019
2020           /* Iterate over each section in this bfd.  */
2021           for (section = input_bfd->sections;
2022                section != NULL;
2023                section = section->next)
2024             {
2025               struct elf32_mn10300_link_hash_entry *hash;
2026               Elf_Internal_Sym *sym;
2027               asection *sym_sec = NULL;
2028               const char *sym_name;
2029               char *new_name;
2030
2031               /* If there's nothing to do in this section, skip it.  */
2032               if (! ((section->flags & SEC_RELOC) != 0
2033                      && section->reloc_count != 0))
2034                 continue;
2035               if ((section->flags & SEC_ALLOC) == 0)
2036                 continue;
2037
2038               /* Get cached copy of section contents if it exists.  */
2039               if (elf_section_data (section)->this_hdr.contents != NULL)
2040                 contents = elf_section_data (section)->this_hdr.contents;
2041               else if (section->size != 0)
2042                 {
2043                   /* Go get them off disk.  */
2044                   if (!bfd_malloc_and_get_section (input_bfd, section,
2045                                                    &contents))
2046                     goto error_return;
2047                 }
2048               else
2049                 contents = NULL;
2050
2051               /* If there aren't any relocs, then there's nothing to do.  */
2052               if ((section->flags & SEC_RELOC) != 0
2053                   && section->reloc_count != 0)
2054                 {
2055                   /* Get a copy of the native relocations.  */
2056                   internal_relocs = _bfd_elf_link_read_relocs (input_bfd, section,
2057                                                                NULL, NULL,
2058                                                                link_info->keep_memory);
2059                   if (internal_relocs == NULL)
2060                     goto error_return;
2061
2062                   /* Now examine each relocation.  */
2063                   irel = internal_relocs;
2064                   irelend = irel + section->reloc_count;
2065                   for (; irel < irelend; irel++)
2066                     {
2067                       long r_type;
2068                       unsigned long r_index;
2069                       unsigned char code;
2070
2071                       r_type = ELF32_R_TYPE (irel->r_info);
2072                       r_index = ELF32_R_SYM (irel->r_info);
2073
2074                       if (r_type < 0 || r_type >= (int) R_MN10300_MAX)
2075                         goto error_return;
2076
2077                       /* We need the name and hash table entry of the target
2078                          symbol!  */
2079                       hash = NULL;
2080                       sym = NULL;
2081                       sym_sec = NULL;
2082
2083                       if (r_index < symtab_hdr->sh_info)
2084                         {
2085                           /* A local symbol.  */
2086                           Elf_Internal_Sym *isym;
2087                           struct elf_link_hash_table *elftab;
2088                           bfd_size_type amt;
2089
2090                           isym = isymbuf + r_index;
2091                           if (isym->st_shndx == SHN_UNDEF)
2092                             sym_sec = bfd_und_section_ptr;
2093                           else if (isym->st_shndx == SHN_ABS)
2094                             sym_sec = bfd_abs_section_ptr;
2095                           else if (isym->st_shndx == SHN_COMMON)
2096                             sym_sec = bfd_com_section_ptr;
2097                           else
2098                             sym_sec
2099                               = bfd_section_from_elf_index (input_bfd,
2100                                                             isym->st_shndx);
2101
2102                           sym_name
2103                             = bfd_elf_string_from_elf_section (input_bfd,
2104                                                                (symtab_hdr
2105                                                                 ->sh_link),
2106                                                                isym->st_name);
2107
2108                           /* If it isn't a function, then we don't care
2109                              about it.  */
2110                           if (ELF_ST_TYPE (isym->st_info) != STT_FUNC)
2111                             continue;
2112
2113                           /* Tack on an ID so we can uniquely identify this
2114                              local symbol in the global hash table.  */
2115                           amt = strlen (sym_name) + 10;
2116                           new_name = bfd_malloc (amt);
2117                           if (new_name == NULL)
2118                             goto error_return;
2119
2120                           sprintf (new_name, "%s_%08x", sym_name, sym_sec->id);
2121                           sym_name = new_name;
2122
2123                           elftab = &hash_table->static_hash_table->root;
2124                           hash = ((struct elf32_mn10300_link_hash_entry *)
2125                                   elf_link_hash_lookup (elftab, sym_name,
2126                                                         TRUE, TRUE, FALSE));
2127                           free (new_name);
2128                         }
2129                       else
2130                         {
2131                           r_index -= symtab_hdr->sh_info;
2132                           hash = (struct elf32_mn10300_link_hash_entry *)
2133                                    elf_sym_hashes (input_bfd)[r_index];
2134                         }
2135
2136                       sym_name = hash->root.root.root.string;
2137                       if ((section->flags & SEC_CODE) != 0)
2138                         {
2139                           /* If this is not a "call" instruction, then we
2140                              should convert "call" instructions to "calls"
2141                              instructions.  */
2142                           code = bfd_get_8 (input_bfd,
2143                                             contents + irel->r_offset - 1);
2144                           if (code != 0xdd && code != 0xcd)
2145                             hash->flags |= MN10300_CONVERT_CALL_TO_CALLS;
2146                         }
2147
2148                       /* If this is a jump/call, then bump the
2149                          direct_calls counter.  Else force "call" to
2150                          "calls" conversions.  */
2151                       if (r_type == R_MN10300_PCREL32
2152                           || r_type == R_MN10300_PLT32
2153                           || r_type == R_MN10300_PLT16
2154                           || r_type == R_MN10300_PCREL16)
2155                         hash->direct_calls++;
2156                       else
2157                         hash->flags |= MN10300_CONVERT_CALL_TO_CALLS;
2158                     }
2159                 }
2160
2161               /* Now look at the actual contents to get the stack size,
2162                  and a list of what registers were saved in the prologue
2163                  (ie movm_args).  */
2164               if ((section->flags & SEC_CODE) != 0)
2165                 {
2166                   Elf_Internal_Sym *isym, *isymend;
2167                   unsigned int sec_shndx;
2168                   struct elf_link_hash_entry **hashes;
2169                   struct elf_link_hash_entry **end_hashes;
2170                   unsigned int symcount;
2171
2172                   sec_shndx = _bfd_elf_section_from_bfd_section (input_bfd,
2173                                                                  section);
2174
2175                   symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
2176                               - symtab_hdr->sh_info);
2177                   hashes = elf_sym_hashes (input_bfd);
2178                   end_hashes = hashes + symcount;
2179
2180                   /* Look at each function defined in this section and
2181                      update info for that function.  */
2182                   isymend = isymbuf + symtab_hdr->sh_info;
2183                   for (isym = isymbuf; isym < isymend; isym++)
2184                     {
2185                       if (isym->st_shndx == sec_shndx
2186                           && ELF_ST_TYPE (isym->st_info) == STT_FUNC)
2187                         {
2188                           struct elf_link_hash_table *elftab;
2189                           bfd_size_type amt;
2190                           struct elf_link_hash_entry **lhashes = hashes;
2191
2192                           /* Skip a local symbol if it aliases a
2193                              global one.  */
2194                           for (; lhashes < end_hashes; lhashes++)
2195                             {
2196                               hash = (struct elf32_mn10300_link_hash_entry *) *lhashes;
2197                               if ((hash->root.root.type == bfd_link_hash_defined
2198                                    || hash->root.root.type == bfd_link_hash_defweak)
2199                                   && hash->root.root.u.def.section == section
2200                                   && hash->root.type == STT_FUNC
2201                                   && hash->root.root.u.def.value == isym->st_value)
2202                                 break;
2203                             }
2204                           if (lhashes != end_hashes)
2205                             continue;
2206
2207                           if (isym->st_shndx == SHN_UNDEF)
2208                             sym_sec = bfd_und_section_ptr;
2209                           else if (isym->st_shndx == SHN_ABS)
2210                             sym_sec = bfd_abs_section_ptr;
2211                           else if (isym->st_shndx == SHN_COMMON)
2212                             sym_sec = bfd_com_section_ptr;
2213                           else
2214                             sym_sec
2215                               = bfd_section_from_elf_index (input_bfd,
2216                                                             isym->st_shndx);
2217
2218                           sym_name = (bfd_elf_string_from_elf_section
2219                                       (input_bfd, symtab_hdr->sh_link,
2220                                        isym->st_name));
2221
2222                           /* Tack on an ID so we can uniquely identify this
2223                              local symbol in the global hash table.  */
2224                           amt = strlen (sym_name) + 10;
2225                           new_name = bfd_malloc (amt);
2226                           if (new_name == NULL)
2227                             goto error_return;
2228
2229                           sprintf (new_name, "%s_%08x", sym_name, sym_sec->id);
2230                           sym_name = new_name;
2231
2232                           elftab = &hash_table->static_hash_table->root;
2233                           hash = ((struct elf32_mn10300_link_hash_entry *)
2234                                   elf_link_hash_lookup (elftab, sym_name,
2235                                                         TRUE, TRUE, FALSE));
2236                           free (new_name);
2237                           compute_function_info (input_bfd, hash,
2238                                                  isym->st_value, contents);
2239                           hash->value = isym->st_value;
2240                         }
2241                     }
2242
2243                   for (; hashes < end_hashes; hashes++)
2244                     {
2245                       hash = (struct elf32_mn10300_link_hash_entry *) *hashes;
2246                       if ((hash->root.root.type == bfd_link_hash_defined
2247                            || hash->root.root.type == bfd_link_hash_defweak)
2248                           && hash->root.root.u.def.section == section
2249                           && hash->root.type == STT_FUNC)
2250                         compute_function_info (input_bfd, hash,
2251                                                (hash)->root.root.u.def.value,
2252                                                contents);
2253                     }
2254                 }
2255
2256               /* Cache or free any memory we allocated for the relocs.  */
2257               if (internal_relocs != NULL
2258                   && elf_section_data (section)->relocs != internal_relocs)
2259                 free (internal_relocs);
2260               internal_relocs = NULL;
2261
2262               /* Cache or free any memory we allocated for the contents.  */
2263               if (contents != NULL
2264                   && elf_section_data (section)->this_hdr.contents != contents)
2265                 {
2266                   if (! link_info->keep_memory)
2267                     free (contents);
2268                   else
2269                     {
2270                       /* Cache the section contents for elf_link_input_bfd.  */
2271                       elf_section_data (section)->this_hdr.contents = contents;
2272                     }
2273                 }
2274               contents = NULL;
2275             }
2276
2277           /* Cache or free any memory we allocated for the symbols.  */
2278           if (isymbuf != NULL
2279               && symtab_hdr->contents != (unsigned char *) isymbuf)
2280             {
2281               if (! link_info->keep_memory)
2282                 free (isymbuf);
2283               else
2284                 {
2285                   /* Cache the symbols for elf_link_input_bfd.  */
2286                   symtab_hdr->contents = (unsigned char *) isymbuf;
2287                 }
2288             }
2289           isymbuf = NULL;
2290         }
2291
2292       /* Now iterate on each symbol in the hash table and perform
2293          the final initialization steps on each.  */
2294       elf32_mn10300_link_hash_traverse (hash_table,
2295                                         elf32_mn10300_finish_hash_table_entry,
2296                                         link_info);
2297       elf32_mn10300_link_hash_traverse (hash_table->static_hash_table,
2298                                         elf32_mn10300_finish_hash_table_entry,
2299                                         link_info);
2300
2301       {
2302         /* This section of code collects all our local symbols, sorts
2303            them by value, and looks for multiple symbols referring to
2304            the same address.  For those symbols, the flags are merged.
2305            At this point, the only flag that can be set is
2306            MN10300_CONVERT_CALL_TO_CALLS, so we simply OR the flags
2307            together.  */
2308         int static_count = 0, i;
2309         struct elf32_mn10300_link_hash_entry **entries;
2310         struct elf32_mn10300_link_hash_entry **ptr;
2311
2312         elf32_mn10300_link_hash_traverse (hash_table->static_hash_table,
2313                                           elf32_mn10300_count_hash_table_entries,
2314                                           &static_count);
2315
2316         entries = bfd_malloc (static_count * sizeof (* ptr));
2317
2318         ptr = entries;
2319         elf32_mn10300_link_hash_traverse (hash_table->static_hash_table,
2320                                           elf32_mn10300_list_hash_table_entries,
2321                                           & ptr);
2322
2323         qsort (entries, static_count, sizeof (entries[0]), sort_by_value);
2324
2325         for (i = 0; i < static_count - 1; i++)
2326           if (entries[i]->value && entries[i]->value == entries[i+1]->value)
2327             {
2328               int v = entries[i]->flags;
2329               int j;
2330
2331               for (j = i + 1; j < static_count && entries[j]->value == entries[i]->value; j++)
2332                 v |= entries[j]->flags;
2333
2334               for (j = i; j < static_count && entries[j]->value == entries[i]->value; j++)
2335                 entries[j]->flags = v;
2336
2337               i = j - 1;
2338             }
2339       }
2340
2341       /* All entries in the hash table are fully initialized.  */
2342       hash_table->flags |= MN10300_HASH_ENTRIES_INITIALIZED;
2343
2344       /* Now that everything has been initialized, go through each
2345          code section and delete any prologue insns which will be
2346          redundant because their operations will be performed by
2347          a "call" instruction.  */
2348       for (input_bfd = link_info->input_bfds;
2349            input_bfd != NULL;
2350            input_bfd = input_bfd->link_next)
2351         {
2352           /* We're going to need all the local symbols for each bfd.  */
2353           symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2354           if (symtab_hdr->sh_info != 0)
2355             {
2356               isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
2357               if (isymbuf == NULL)
2358                 isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
2359                                                 symtab_hdr->sh_info, 0,
2360                                                 NULL, NULL, NULL);
2361               if (isymbuf == NULL)
2362                 goto error_return;
2363             }
2364
2365           /* Walk over each section in this bfd.  */
2366           for (section = input_bfd->sections;
2367                section != NULL;
2368                section = section->next)
2369             {
2370               unsigned int sec_shndx;
2371               Elf_Internal_Sym *isym, *isymend;
2372               struct elf_link_hash_entry **hashes;
2373               struct elf_link_hash_entry **end_hashes;
2374               unsigned int symcount;
2375
2376               /* Skip non-code sections and empty sections.  */
2377               if ((section->flags & SEC_CODE) == 0 || section->size == 0)
2378                 continue;
2379
2380               if (section->reloc_count != 0)
2381                 {
2382                   /* Get a copy of the native relocations.  */
2383                   internal_relocs = _bfd_elf_link_read_relocs (input_bfd, section,
2384                                                                NULL, NULL,
2385                                                                link_info->keep_memory);
2386                   if (internal_relocs == NULL)
2387                     goto error_return;
2388                 }
2389
2390               /* Get cached copy of section contents if it exists.  */
2391               if (elf_section_data (section)->this_hdr.contents != NULL)
2392                 contents = elf_section_data (section)->this_hdr.contents;
2393               else
2394                 {
2395                   /* Go get them off disk.  */
2396                   if (!bfd_malloc_and_get_section (input_bfd, section,
2397                                                    &contents))
2398                     goto error_return;
2399                 }
2400
2401               sec_shndx = _bfd_elf_section_from_bfd_section (input_bfd,
2402                                                              section);
2403
2404               /* Now look for any function in this section which needs
2405                  insns deleted from its prologue.  */
2406               isymend = isymbuf + symtab_hdr->sh_info;
2407               for (isym = isymbuf; isym < isymend; isym++)
2408                 {
2409                   struct elf32_mn10300_link_hash_entry *sym_hash;
2410                   asection *sym_sec = NULL;
2411                   const char *sym_name;
2412                   char *new_name;
2413                   struct elf_link_hash_table *elftab;
2414                   bfd_size_type amt;
2415
2416                   if (isym->st_shndx != sec_shndx)
2417                     continue;
2418
2419                   if (isym->st_shndx == SHN_UNDEF)
2420                     sym_sec = bfd_und_section_ptr;
2421                   else if (isym->st_shndx == SHN_ABS)
2422                     sym_sec = bfd_abs_section_ptr;
2423                   else if (isym->st_shndx == SHN_COMMON)
2424                     sym_sec = bfd_com_section_ptr;
2425                   else
2426                     sym_sec
2427                       = bfd_section_from_elf_index (input_bfd, isym->st_shndx);
2428
2429                   sym_name
2430                     = bfd_elf_string_from_elf_section (input_bfd,
2431                                                        symtab_hdr->sh_link,
2432                                                        isym->st_name);
2433
2434                   /* Tack on an ID so we can uniquely identify this
2435                      local symbol in the global hash table.  */
2436                   amt = strlen (sym_name) + 10;
2437                   new_name = bfd_malloc (amt);
2438                   if (new_name == NULL)
2439                     goto error_return;
2440                   sprintf (new_name, "%s_%08x", sym_name, sym_sec->id);
2441                   sym_name = new_name;
2442
2443                   elftab = & hash_table->static_hash_table->root;
2444                   sym_hash = (struct elf32_mn10300_link_hash_entry *)
2445                     elf_link_hash_lookup (elftab, sym_name,
2446                                           FALSE, FALSE, FALSE);
2447
2448                   free (new_name);
2449                   if (sym_hash == NULL)
2450                     continue;
2451
2452                   if (! (sym_hash->flags & MN10300_CONVERT_CALL_TO_CALLS)
2453                       && ! (sym_hash->flags & MN10300_DELETED_PROLOGUE_BYTES))
2454                     {
2455                       int bytes = 0;
2456
2457                       /* Note that we've changed things.  */
2458                       elf_section_data (section)->relocs = internal_relocs;
2459                       elf_section_data (section)->this_hdr.contents = contents;
2460                       symtab_hdr->contents = (unsigned char *) isymbuf;
2461
2462                       /* Count how many bytes we're going to delete.  */
2463                       if (sym_hash->movm_args)
2464                         bytes += 2;
2465
2466                       if (sym_hash->stack_size > 0)
2467                         {
2468                           if (sym_hash->stack_size <= 128)
2469                             bytes += 3;
2470                           else
2471                             bytes += 4;
2472                         }
2473
2474                       /* Note that we've deleted prologue bytes for this
2475                          function.  */
2476                       sym_hash->flags |= MN10300_DELETED_PROLOGUE_BYTES;
2477
2478                       /* Actually delete the bytes.  */
2479                       if (!mn10300_elf_relax_delete_bytes (input_bfd,
2480                                                            section,
2481                                                            isym->st_value,
2482                                                            bytes))
2483                         goto error_return;
2484
2485                       /* Something changed.  Not strictly necessary, but
2486                          may lead to more relaxing opportunities.  */
2487                       *again = TRUE;
2488                     }
2489                 }
2490
2491               /* Look for any global functions in this section which
2492                  need insns deleted from their prologues.  */
2493               symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
2494                           - symtab_hdr->sh_info);
2495               hashes = elf_sym_hashes (input_bfd);
2496               end_hashes = hashes + symcount;
2497               for (; hashes < end_hashes; hashes++)
2498                 {
2499                   struct elf32_mn10300_link_hash_entry *sym_hash;
2500
2501                   sym_hash = (struct elf32_mn10300_link_hash_entry *) *hashes;
2502                   if ((sym_hash->root.root.type == bfd_link_hash_defined
2503                        || sym_hash->root.root.type == bfd_link_hash_defweak)
2504                       && sym_hash->root.root.u.def.section == section
2505                       && ! (sym_hash->flags & MN10300_CONVERT_CALL_TO_CALLS)
2506                       && ! (sym_hash->flags & MN10300_DELETED_PROLOGUE_BYTES))
2507                     {
2508                       int bytes = 0;
2509                       bfd_vma symval;
2510
2511                       /* Note that we've changed things.  */
2512                       elf_section_data (section)->relocs = internal_relocs;
2513                       elf_section_data (section)->this_hdr.contents = contents;
2514                       symtab_hdr->contents = (unsigned char *) isymbuf;
2515
2516                       /* Count how many bytes we're going to delete.  */
2517                       if (sym_hash->movm_args)
2518                         bytes += 2;
2519
2520                       if (sym_hash->stack_size > 0)
2521                         {
2522                           if (sym_hash->stack_size <= 128)
2523                             bytes += 3;
2524                           else
2525                             bytes += 4;
2526                         }
2527
2528                       /* Note that we've deleted prologue bytes for this
2529                          function.  */
2530                       sym_hash->flags |= MN10300_DELETED_PROLOGUE_BYTES;
2531
2532                       /* Actually delete the bytes.  */
2533                       symval = sym_hash->root.root.u.def.value;
2534                       if (!mn10300_elf_relax_delete_bytes (input_bfd,
2535                                                            section,
2536                                                            symval,
2537                                                            bytes))
2538                         goto error_return;
2539
2540                       /* Something changed.  Not strictly necessary, but
2541                          may lead to more relaxing opportunities.  */
2542                       *again = TRUE;
2543                     }
2544                 }
2545
2546               /* Cache or free any memory we allocated for the relocs.  */
2547               if (internal_relocs != NULL
2548                   && elf_section_data (section)->relocs != internal_relocs)
2549                 free (internal_relocs);
2550               internal_relocs = NULL;
2551
2552               /* Cache or free any memory we allocated for the contents.  */
2553               if (contents != NULL
2554                   && elf_section_data (section)->this_hdr.contents != contents)
2555                 {
2556                   if (! link_info->keep_memory)
2557                     free (contents);
2558                   else
2559                     /* Cache the section contents for elf_link_input_bfd.  */
2560                     elf_section_data (section)->this_hdr.contents = contents;
2561                 }
2562               contents = NULL;
2563             }
2564
2565           /* Cache or free any memory we allocated for the symbols.  */
2566           if (isymbuf != NULL
2567               && symtab_hdr->contents != (unsigned char *) isymbuf)
2568             {
2569               if (! link_info->keep_memory)
2570                 free (isymbuf);
2571               else
2572                 /* Cache the symbols for elf_link_input_bfd.  */
2573                 symtab_hdr->contents = (unsigned char *) isymbuf;
2574             }
2575           isymbuf = NULL;
2576         }
2577     }
2578
2579   /* (Re)initialize for the basic instruction shortening/relaxing pass.  */
2580   contents = NULL;
2581   internal_relocs = NULL;
2582   isymbuf = NULL;
2583   /* For error_return.  */
2584   section = sec;
2585
2586   /* We don't have to do anything for a relocatable link, if
2587      this section does not have relocs, or if this is not a
2588      code section.  */
2589   if (link_info->relocatable
2590       || (sec->flags & SEC_RELOC) == 0
2591       || sec->reloc_count == 0
2592       || (sec->flags & SEC_CODE) == 0)
2593     return TRUE;
2594
2595   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2596
2597   /* Get a copy of the native relocations.  */
2598   internal_relocs = _bfd_elf_link_read_relocs (abfd, sec, NULL, NULL,
2599                                                link_info->keep_memory);
2600   if (internal_relocs == NULL)
2601     goto error_return;
2602
2603   /* Walk through them looking for relaxing opportunities.  */
2604   irelend = internal_relocs + sec->reloc_count;
2605   for (irel = internal_relocs; irel < irelend; irel++)
2606     {
2607       bfd_vma symval;
2608       struct elf32_mn10300_link_hash_entry *h = NULL;
2609
2610       /* If this isn't something that can be relaxed, then ignore
2611          this reloc.  */
2612       if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_NONE
2613           || ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_8
2614           || ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_MAX)
2615         continue;
2616
2617       /* Get the section contents if we haven't done so already.  */
2618       if (contents == NULL)
2619         {
2620           /* Get cached copy if it exists.  */
2621           if (elf_section_data (sec)->this_hdr.contents != NULL)
2622             contents = elf_section_data (sec)->this_hdr.contents;
2623           else
2624             {
2625               /* Go get them off disk.  */
2626               if (!bfd_malloc_and_get_section (abfd, sec, &contents))
2627                 goto error_return;
2628             }
2629         }
2630
2631       /* Read this BFD's symbols if we haven't done so already.  */
2632       if (isymbuf == NULL && symtab_hdr->sh_info != 0)
2633         {
2634           isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
2635           if (isymbuf == NULL)
2636             isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
2637                                             symtab_hdr->sh_info, 0,
2638                                             NULL, NULL, NULL);
2639           if (isymbuf == NULL)
2640             goto error_return;
2641         }
2642
2643       /* Get the value of the symbol referred to by the reloc.  */
2644       if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
2645         {
2646           Elf_Internal_Sym *isym;
2647           asection *sym_sec = NULL;
2648           const char *sym_name;
2649           char *new_name;
2650
2651           /* A local symbol.  */
2652           isym = isymbuf + ELF32_R_SYM (irel->r_info);
2653           if (isym->st_shndx == SHN_UNDEF)
2654             sym_sec = bfd_und_section_ptr;
2655           else if (isym->st_shndx == SHN_ABS)
2656             sym_sec = bfd_abs_section_ptr;
2657           else if (isym->st_shndx == SHN_COMMON)
2658             sym_sec = bfd_com_section_ptr;
2659           else
2660             sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
2661
2662           sym_name = bfd_elf_string_from_elf_section (abfd,
2663                                                       symtab_hdr->sh_link,
2664                                                       isym->st_name);
2665
2666           if ((sym_sec->flags & SEC_MERGE)
2667               && ELF_ST_TYPE (isym->st_info) == STT_SECTION
2668               && sym_sec->sec_info_type == ELF_INFO_TYPE_MERGE)
2669             {
2670               bfd_vma saved_addend;
2671
2672               saved_addend = irel->r_addend;
2673               symval = _bfd_elf_rela_local_sym (abfd, isym, & sym_sec, irel);
2674               symval += irel->r_addend;
2675               irel->r_addend = saved_addend;
2676             }
2677           else
2678             symval = (isym->st_value
2679                       + sym_sec->output_section->vma
2680                       + sym_sec->output_offset);
2681
2682           /* Tack on an ID so we can uniquely identify this
2683              local symbol in the global hash table.  */
2684           new_name = bfd_malloc ((bfd_size_type) strlen (sym_name) + 10);
2685           if (new_name == NULL)
2686             goto error_return;
2687           sprintf (new_name, "%s_%08x", sym_name, sym_sec->id);
2688           sym_name = new_name;
2689
2690           h = (struct elf32_mn10300_link_hash_entry *)
2691                 elf_link_hash_lookup (&hash_table->static_hash_table->root,
2692                                       sym_name, FALSE, FALSE, FALSE);
2693           free (new_name);
2694         }
2695       else
2696         {
2697           unsigned long indx;
2698
2699           /* An external symbol.  */
2700           indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
2701           h = (struct elf32_mn10300_link_hash_entry *)
2702                 (elf_sym_hashes (abfd)[indx]);
2703           BFD_ASSERT (h != NULL);
2704           if (h->root.root.type != bfd_link_hash_defined
2705               && h->root.root.type != bfd_link_hash_defweak)
2706             /* This appears to be a reference to an undefined
2707                symbol.  Just ignore it--it will be caught by the
2708                regular reloc processing.  */
2709             continue;
2710
2711           /* Check for a reference to a discarded symbol and ignore it.  */
2712           if (h->root.root.u.def.section->output_section == NULL)
2713             continue;
2714
2715           symval = (h->root.root.u.def.value
2716                     + h->root.root.u.def.section->output_section->vma
2717                     + h->root.root.u.def.section->output_offset);
2718         }
2719
2720       /* For simplicity of coding, we are going to modify the section
2721          contents, the section relocs, and the BFD symbol table.  We
2722          must tell the rest of the code not to free up this
2723          information.  It would be possible to instead create a table
2724          of changes which have to be made, as is done in coff-mips.c;
2725          that would be more work, but would require less memory when
2726          the linker is run.  */
2727
2728       /* Try to turn a 32bit pc-relative branch/call into a 16bit pc-relative
2729          branch/call, also deal with "call" -> "calls" conversions and
2730          insertion of prologue data into "call" instructions.  */
2731       if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_PCREL32
2732           || ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_PLT32)
2733         {
2734           bfd_vma value = symval;
2735
2736           if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_PLT32
2737               && h != NULL
2738               && ELF_ST_VISIBILITY (h->root.other) != STV_INTERNAL
2739               && ELF_ST_VISIBILITY (h->root.other) != STV_HIDDEN
2740               && h->root.plt.offset != (bfd_vma) -1)
2741             {
2742               asection * splt;
2743
2744               splt = bfd_get_section_by_name (elf_hash_table (link_info)
2745                                               ->dynobj, ".plt");
2746
2747               value = ((splt->output_section->vma
2748                         + splt->output_offset
2749                         + h->root.plt.offset)
2750                        - (sec->output_section->vma
2751                           + sec->output_offset
2752                           + irel->r_offset));
2753             }
2754
2755           /* If we've got a "call" instruction that needs to be turned
2756              into a "calls" instruction, do so now.  It saves a byte.  */
2757           if (h && (h->flags & MN10300_CONVERT_CALL_TO_CALLS))
2758             {
2759               unsigned char code;
2760
2761               /* Get the opcode.  */
2762               code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
2763
2764               /* Make sure we're working with a "call" instruction!  */
2765               if (code == 0xdd)
2766                 {
2767                   /* Note that we've changed the relocs, section contents,
2768                      etc.  */
2769                   elf_section_data (sec)->relocs = internal_relocs;
2770                   elf_section_data (sec)->this_hdr.contents = contents;
2771                   symtab_hdr->contents = (unsigned char *) isymbuf;
2772
2773                   /* Fix the opcode.  */
2774                   bfd_put_8 (abfd, 0xfc, contents + irel->r_offset - 1);
2775                   bfd_put_8 (abfd, 0xff, contents + irel->r_offset);
2776
2777                   /* Fix irel->r_offset and irel->r_addend.  */
2778                   irel->r_offset += 1;
2779                   irel->r_addend += 1;
2780
2781                   /* Delete one byte of data.  */
2782                   if (!mn10300_elf_relax_delete_bytes (abfd, sec,
2783                                                        irel->r_offset + 3, 1))
2784                     goto error_return;
2785
2786                   /* That will change things, so, we should relax again.
2787                      Note that this is not required, and it may be slow.  */
2788                   *again = TRUE;
2789                 }
2790             }
2791           else if (h)
2792             {
2793               /* We've got a "call" instruction which needs some data
2794                  from target function filled in.  */
2795               unsigned char code;
2796
2797               /* Get the opcode.  */
2798               code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
2799
2800               /* Insert data from the target function into the "call"
2801                  instruction if needed.  */
2802               if (code == 0xdd)
2803                 {
2804                   bfd_put_8 (abfd, h->movm_args, contents + irel->r_offset + 4);
2805                   bfd_put_8 (abfd, h->stack_size + h->movm_stack_size,
2806                              contents + irel->r_offset + 5);
2807                 }
2808             }
2809
2810           /* Deal with pc-relative gunk.  */
2811           value -= (sec->output_section->vma + sec->output_offset);
2812           value -= irel->r_offset;
2813           value += irel->r_addend;
2814
2815           /* See if the value will fit in 16 bits, note the high value is
2816              0x7fff + 2 as the target will be two bytes closer if we are
2817              able to relax.  */
2818           if ((long) value < 0x8001 && (long) value > -0x8000)
2819             {
2820               unsigned char code;
2821
2822               /* Get the opcode.  */
2823               code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
2824
2825               if (code != 0xdc && code != 0xdd && code != 0xff)
2826                 continue;
2827
2828               /* Note that we've changed the relocs, section contents, etc.  */
2829               elf_section_data (sec)->relocs = internal_relocs;
2830               elf_section_data (sec)->this_hdr.contents = contents;
2831               symtab_hdr->contents = (unsigned char *) isymbuf;
2832
2833               /* Fix the opcode.  */
2834               if (code == 0xdc)
2835                 bfd_put_8 (abfd, 0xcc, contents + irel->r_offset - 1);
2836               else if (code == 0xdd)
2837                 bfd_put_8 (abfd, 0xcd, contents + irel->r_offset - 1);
2838               else if (code == 0xff)
2839                 bfd_put_8 (abfd, 0xfa, contents + irel->r_offset - 2);
2840
2841               /* Fix the relocation's type.  */
2842               irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
2843                                            (ELF32_R_TYPE (irel->r_info)
2844                                             == (int) R_MN10300_PLT32)
2845                                            ? R_MN10300_PLT16 :
2846                                            R_MN10300_PCREL16);
2847
2848               /* Delete two bytes of data.  */
2849               if (!mn10300_elf_relax_delete_bytes (abfd, sec,
2850                                                    irel->r_offset + 1, 2))
2851                 goto error_return;
2852
2853               /* That will change things, so, we should relax again.
2854                  Note that this is not required, and it may be slow.  */
2855               *again = TRUE;
2856             }
2857         }
2858
2859       /* Try to turn a 16bit pc-relative branch into a 8bit pc-relative
2860          branch.  */
2861       if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_PCREL16)
2862         {
2863           bfd_vma value = symval;
2864
2865           /* If we've got a "call" instruction that needs to be turned
2866              into a "calls" instruction, do so now.  It saves a byte.  */
2867           if (h && (h->flags & MN10300_CONVERT_CALL_TO_CALLS))
2868             {
2869               unsigned char code;
2870
2871               /* Get the opcode.  */
2872               code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
2873
2874               /* Make sure we're working with a "call" instruction!  */
2875               if (code == 0xcd)
2876                 {
2877                   /* Note that we've changed the relocs, section contents,
2878                      etc.  */
2879                   elf_section_data (sec)->relocs = internal_relocs;
2880                   elf_section_data (sec)->this_hdr.contents = contents;
2881                   symtab_hdr->contents = (unsigned char *) isymbuf;
2882
2883                   /* Fix the opcode.  */
2884                   bfd_put_8 (abfd, 0xfa, contents + irel->r_offset - 1);
2885                   bfd_put_8 (abfd, 0xff, contents + irel->r_offset);
2886
2887                   /* Fix irel->r_offset and irel->r_addend.  */
2888                   irel->r_offset += 1;
2889                   irel->r_addend += 1;
2890
2891                   /* Delete one byte of data.  */
2892                   if (!mn10300_elf_relax_delete_bytes (abfd, sec,
2893                                                        irel->r_offset + 1, 1))
2894                     goto error_return;
2895
2896                   /* That will change things, so, we should relax again.
2897                      Note that this is not required, and it may be slow.  */
2898                   *again = TRUE;
2899                 }
2900             }
2901           else if (h)
2902             {
2903               unsigned char code;
2904
2905               /* Get the opcode.  */
2906               code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
2907
2908               /* Insert data from the target function into the "call"
2909                  instruction if needed.  */
2910               if (code == 0xcd)
2911                 {
2912                   bfd_put_8 (abfd, h->movm_args, contents + irel->r_offset + 2);
2913                   bfd_put_8 (abfd, h->stack_size + h->movm_stack_size,
2914                              contents + irel->r_offset + 3);
2915                 }
2916             }
2917
2918           /* Deal with pc-relative gunk.  */
2919           value -= (sec->output_section->vma + sec->output_offset);
2920           value -= irel->r_offset;
2921           value += irel->r_addend;
2922
2923           /* See if the value will fit in 8 bits, note the high value is
2924              0x7f + 1 as the target will be one bytes closer if we are
2925              able to relax.  */
2926           if ((long) value < 0x80 && (long) value > -0x80)
2927             {
2928               unsigned char code;
2929
2930               /* Get the opcode.  */
2931               code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
2932
2933               if (code != 0xcc)
2934                 continue;
2935
2936               /* Note that we've changed the relocs, section contents, etc.  */
2937               elf_section_data (sec)->relocs = internal_relocs;
2938               elf_section_data (sec)->this_hdr.contents = contents;
2939               symtab_hdr->contents = (unsigned char *) isymbuf;
2940
2941               /* Fix the opcode.  */
2942               bfd_put_8 (abfd, 0xca, contents + irel->r_offset - 1);
2943
2944               /* Fix the relocation's type.  */
2945               irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
2946                                            R_MN10300_PCREL8);
2947
2948               /* Delete one byte of data.  */
2949               if (!mn10300_elf_relax_delete_bytes (abfd, sec,
2950                                                    irel->r_offset + 1, 1))
2951                 goto error_return;
2952
2953               /* That will change things, so, we should relax again.
2954                  Note that this is not required, and it may be slow.  */
2955               *again = TRUE;
2956             }
2957         }
2958
2959       /* Try to eliminate an unconditional 8 bit pc-relative branch
2960          which immediately follows a conditional 8 bit pc-relative
2961          branch around the unconditional branch.
2962
2963             original:           new:
2964             bCC lab1            bCC' lab2
2965             bra lab2
2966            lab1:               lab1:
2967
2968          This happens when the bCC can't reach lab2 at assembly time,
2969          but due to other relaxations it can reach at link time.  */
2970       if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_PCREL8)
2971         {
2972           Elf_Internal_Rela *nrel;
2973           bfd_vma value = symval;
2974           unsigned char code;
2975
2976           /* Deal with pc-relative gunk.  */
2977           value -= (sec->output_section->vma + sec->output_offset);
2978           value -= irel->r_offset;
2979           value += irel->r_addend;
2980
2981           /* Do nothing if this reloc is the last byte in the section.  */
2982           if (irel->r_offset == sec->size)
2983             continue;
2984
2985           /* See if the next instruction is an unconditional pc-relative
2986              branch, more often than not this test will fail, so we
2987              test it first to speed things up.  */
2988           code = bfd_get_8 (abfd, contents + irel->r_offset + 1);
2989           if (code != 0xca)
2990             continue;
2991
2992           /* Also make sure the next relocation applies to the next
2993              instruction and that it's a pc-relative 8 bit branch.  */
2994           nrel = irel + 1;
2995           if (nrel == irelend
2996               || irel->r_offset + 2 != nrel->r_offset
2997               || ELF32_R_TYPE (nrel->r_info) != (int) R_MN10300_PCREL8)
2998             continue;
2999
3000           /* Make sure our destination immediately follows the
3001              unconditional branch.  */
3002           if (symval != (sec->output_section->vma + sec->output_offset
3003                          + irel->r_offset + 3))
3004             continue;
3005
3006           /* Now make sure we are a conditional branch.  This may not
3007              be necessary, but why take the chance.
3008
3009              Note these checks assume that R_MN10300_PCREL8 relocs
3010              only occur on bCC and bCCx insns.  If they occured
3011              elsewhere, we'd need to know the start of this insn
3012              for this check to be accurate.  */
3013           code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
3014           if (code != 0xc0 && code != 0xc1 && code != 0xc2
3015               && code != 0xc3 && code != 0xc4 && code != 0xc5
3016               && code != 0xc6 && code != 0xc7 && code != 0xc8
3017               && code != 0xc9 && code != 0xe8 && code != 0xe9
3018               && code != 0xea && code != 0xeb)
3019             continue;
3020
3021           /* We also have to be sure there is no symbol/label
3022              at the unconditional branch.  */
3023           if (mn10300_elf_symbol_address_p (abfd, sec, isymbuf,
3024                                             irel->r_offset + 1))
3025             continue;
3026
3027           /* Note that we've changed the relocs, section contents, etc.  */
3028           elf_section_data (sec)->relocs = internal_relocs;
3029           elf_section_data (sec)->this_hdr.contents = contents;
3030           symtab_hdr->contents = (unsigned char *) isymbuf;
3031
3032           /* Reverse the condition of the first branch.  */
3033           switch (code)
3034             {
3035             case 0xc8:
3036               code = 0xc9;
3037               break;
3038             case 0xc9:
3039               code = 0xc8;
3040               break;
3041             case 0xc0:
3042               code = 0xc2;
3043               break;
3044             case 0xc2:
3045               code = 0xc0;
3046               break;
3047             case 0xc3:
3048               code = 0xc1;
3049               break;
3050             case 0xc1:
3051               code = 0xc3;
3052               break;
3053             case 0xc4:
3054               code = 0xc6;
3055               break;
3056             case 0xc6:
3057               code = 0xc4;
3058               break;
3059             case 0xc7:
3060               code = 0xc5;
3061               break;
3062             case 0xc5:
3063               code = 0xc7;
3064               break;
3065             case 0xe8:
3066               code = 0xe9;
3067               break;
3068             case 0x9d:
3069               code = 0xe8;
3070               break;
3071             case 0xea:
3072               code = 0xeb;
3073               break;
3074             case 0xeb:
3075               code = 0xea;
3076               break;
3077             }
3078           bfd_put_8 (abfd, code, contents + irel->r_offset - 1);
3079
3080           /* Set the reloc type and symbol for the first branch
3081              from the second branch.  */
3082           irel->r_info = nrel->r_info;
3083
3084           /* Make the reloc for the second branch a null reloc.  */
3085           nrel->r_info = ELF32_R_INFO (ELF32_R_SYM (nrel->r_info),
3086                                        R_MN10300_NONE);
3087
3088           /* Delete two bytes of data.  */
3089           if (!mn10300_elf_relax_delete_bytes (abfd, sec,
3090                                                irel->r_offset + 1, 2))
3091             goto error_return;
3092
3093           /* That will change things, so, we should relax again.
3094              Note that this is not required, and it may be slow.  */
3095           *again = TRUE;
3096         }
3097
3098       /* Try to turn a 24 immediate, displacement or absolute address
3099          into a 8 immediate, displacement or absolute address.  */
3100       if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_24)
3101         {
3102           bfd_vma value = symval;
3103           value += irel->r_addend;
3104
3105           /* See if the value will fit in 8 bits.  */
3106           if ((long) value < 0x7f && (long) value > -0x80)
3107             {
3108               unsigned char code;
3109
3110               /* AM33 insns which have 24 operands are 6 bytes long and
3111                  will have 0xfd as the first byte.  */
3112
3113               /* Get the first opcode.  */
3114               code = bfd_get_8 (abfd, contents + irel->r_offset - 3);
3115
3116               if (code == 0xfd)
3117                 {
3118                   /* Get the second opcode.  */
3119                   code = bfd_get_8 (abfd, contents + irel->r_offset - 2);
3120
3121                   /* We can not relax 0x6b, 0x7b, 0x8b, 0x9b as no 24bit
3122                      equivalent instructions exists.  */
3123                   if (code != 0x6b && code != 0x7b
3124                       && code != 0x8b && code != 0x9b
3125                       && ((code & 0x0f) == 0x09 || (code & 0x0f) == 0x08
3126                           || (code & 0x0f) == 0x0a || (code & 0x0f) == 0x0b
3127                           || (code & 0x0f) == 0x0e))
3128                     {
3129                       /* Not safe if the high bit is on as relaxing may
3130                          move the value out of high mem and thus not fit
3131                          in a signed 8bit value.  This is currently over
3132                          conservative.  */
3133                       if ((value & 0x80) == 0)
3134                         {
3135                           /* Note that we've changed the relocation contents,
3136                              etc.  */
3137                           elf_section_data (sec)->relocs = internal_relocs;
3138                           elf_section_data (sec)->this_hdr.contents = contents;
3139                           symtab_hdr->contents = (unsigned char *) isymbuf;
3140
3141                           /* Fix the opcode.  */
3142                           bfd_put_8 (abfd, 0xfb, contents + irel->r_offset - 3);
3143                           bfd_put_8 (abfd, code, contents + irel->r_offset - 2);
3144
3145                           /* Fix the relocation's type.  */
3146                           irel->r_info =
3147                             ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
3148                                           R_MN10300_8);
3149
3150                           /* Delete two bytes of data.  */
3151                           if (!mn10300_elf_relax_delete_bytes (abfd, sec,
3152                                                                irel->r_offset + 1, 2))
3153                             goto error_return;
3154
3155                           /* That will change things, so, we should relax
3156                              again.  Note that this is not required, and it
3157                              may be slow.  */
3158                           *again = TRUE;
3159                           break;
3160                         }
3161                     }
3162                 }
3163             }
3164         }
3165
3166       /* Try to turn a 32bit immediate, displacement or absolute address
3167          into a 16bit immediate, displacement or absolute address.  */
3168       if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_32
3169           || ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_GOT32
3170           || ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_GOTOFF32)
3171         {
3172           bfd_vma value = symval;
3173
3174           if (ELF32_R_TYPE (irel->r_info) != (int) R_MN10300_32)
3175             {
3176               asection * sgot;
3177
3178               sgot = bfd_get_section_by_name (elf_hash_table (link_info)
3179                                               ->dynobj, ".got");
3180
3181               if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_GOT32)
3182                 {
3183                   value = sgot->output_offset;
3184
3185                   if (h)
3186                     value += h->root.got.offset;
3187                   else
3188                     value += (elf_local_got_offsets
3189                               (abfd)[ELF32_R_SYM (irel->r_info)]);
3190                 }
3191               else if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_GOTOFF32)
3192                 value -= sgot->output_section->vma;
3193               else if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_GOTPC32)
3194                 value = (sgot->output_section->vma
3195                          - (sec->output_section->vma
3196                             + sec->output_offset
3197                             + irel->r_offset));
3198               else
3199                 abort ();
3200             }
3201
3202           value += irel->r_addend;
3203
3204           /* See if the value will fit in 24 bits.
3205              We allow any 16bit match here.  We prune those we can't
3206              handle below.  */
3207           if ((long) value < 0x7fffff && (long) value > -0x800000)
3208             {
3209               unsigned char code;
3210
3211               /* AM33 insns which have 32bit operands are 7 bytes long and
3212                  will have 0xfe as the first byte.  */
3213
3214               /* Get the first opcode.  */
3215               code = bfd_get_8 (abfd, contents + irel->r_offset - 3);
3216
3217               if (code == 0xfe)
3218                 {
3219                   /* Get the second opcode.  */
3220                   code = bfd_get_8 (abfd, contents + irel->r_offset - 2);
3221
3222                   /* All the am33 32 -> 24 relaxing possibilities.  */
3223                   /* We can not relax 0x6b, 0x7b, 0x8b, 0x9b as no 24bit
3224                      equivalent instructions exists.  */
3225                   if (code != 0x6b && code != 0x7b
3226                       && code != 0x8b && code != 0x9b
3227                       && (ELF32_R_TYPE (irel->r_info)
3228                           != (int) R_MN10300_GOTPC32)
3229                       && ((code & 0x0f) == 0x09 || (code & 0x0f) == 0x08
3230                           || (code & 0x0f) == 0x0a || (code & 0x0f) == 0x0b
3231                           || (code & 0x0f) == 0x0e))
3232                     {
3233                       /* Not safe if the high bit is on as relaxing may
3234                          move the value out of high mem and thus not fit
3235                          in a signed 16bit value.  This is currently over
3236                          conservative.  */
3237                       if ((value & 0x8000) == 0)
3238                         {
3239                           /* Note that we've changed the relocation contents,
3240                              etc.  */
3241                           elf_section_data (sec)->relocs = internal_relocs;
3242                           elf_section_data (sec)->this_hdr.contents = contents;
3243                           symtab_hdr->contents = (unsigned char *) isymbuf;
3244
3245                           /* Fix the opcode.  */
3246                           bfd_put_8 (abfd, 0xfd, contents + irel->r_offset - 3);
3247                           bfd_put_8 (abfd, code, contents + irel->r_offset - 2);
3248
3249                           /* Fix the relocation's type.  */
3250                           irel->r_info =
3251                             ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
3252                                           (ELF32_R_TYPE (irel->r_info)
3253                                            == (int) R_MN10300_GOTOFF32)
3254                                           ? R_MN10300_GOTOFF24
3255                                           : (ELF32_R_TYPE (irel->r_info)
3256                                              == (int) R_MN10300_GOT32)
3257                                           ? R_MN10300_GOT24 :
3258                                           R_MN10300_24);
3259
3260                           /* Delete one byte of data.  */
3261                           if (!mn10300_elf_relax_delete_bytes (abfd, sec,
3262                                                                irel->r_offset + 3, 1))
3263                             goto error_return;
3264
3265                           /* That will change things, so, we should relax
3266                              again.  Note that this is not required, and it
3267                              may be slow.  */
3268                           *again = TRUE;
3269                           break;
3270                         }
3271                     }
3272                 }
3273             }
3274
3275           /* See if the value will fit in 16 bits.
3276              We allow any 16bit match here.  We prune those we can't
3277              handle below.  */
3278           if ((long) value < 0x7fff && (long) value > -0x8000)
3279             {
3280               unsigned char code;
3281
3282               /* Most insns which have 32bit operands are 6 bytes long;
3283                  exceptions are pcrel insns and bit insns.
3284
3285                  We handle pcrel insns above.  We don't bother trying
3286                  to handle the bit insns here.
3287
3288                  The first byte of the remaining insns will be 0xfc.  */
3289
3290               /* Get the first opcode.  */
3291               code = bfd_get_8 (abfd, contents + irel->r_offset - 2);
3292
3293               if (code != 0xfc)
3294                 continue;
3295
3296               /* Get the second opcode.  */
3297               code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
3298
3299               if ((code & 0xf0) < 0x80)
3300                 switch (code & 0xf0)
3301                   {
3302                   /* mov (d32,am),dn   -> mov (d32,am),dn
3303                      mov dm,(d32,am)   -> mov dn,(d32,am)
3304                      mov (d32,am),an   -> mov (d32,am),an
3305                      mov dm,(d32,am)   -> mov dn,(d32,am)
3306                      movbu (d32,am),dn -> movbu (d32,am),dn
3307                      movbu dm,(d32,am) -> movbu dn,(d32,am)
3308                      movhu (d32,am),dn -> movhu (d32,am),dn
3309                      movhu dm,(d32,am) -> movhu dn,(d32,am) */
3310                   case 0x00:
3311                   case 0x10:
3312                   case 0x20:
3313                   case 0x30:
3314                   case 0x40:
3315                   case 0x50:
3316                   case 0x60:
3317                   case 0x70:
3318                     /* Not safe if the high bit is on as relaxing may
3319                        move the value out of high mem and thus not fit
3320                        in a signed 16bit value.  */
3321                     if (code == 0xcc
3322                         && (value & 0x8000))
3323                       continue;
3324
3325                     /* Note that we've changed the relocation contents, etc.  */
3326                     elf_section_data (sec)->relocs = internal_relocs;
3327                     elf_section_data (sec)->this_hdr.contents = contents;
3328                     symtab_hdr->contents = (unsigned char *) isymbuf;
3329
3330                     /* Fix the opcode.  */
3331                     bfd_put_8 (abfd, 0xfa, contents + irel->r_offset - 2);
3332                     bfd_put_8 (abfd, code, contents + irel->r_offset - 1);
3333
3334                     /* Fix the relocation's type.  */
3335                     irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
3336                                                  (ELF32_R_TYPE (irel->r_info)
3337                                                   == (int) R_MN10300_GOTOFF32)
3338                                                  ? R_MN10300_GOTOFF16
3339                                                  : (ELF32_R_TYPE (irel->r_info)
3340                                                     == (int) R_MN10300_GOT32)
3341                                                  ? R_MN10300_GOT16
3342                                                  : (ELF32_R_TYPE (irel->r_info)
3343                                                     == (int) R_MN10300_GOTPC32)
3344                                                  ? R_MN10300_GOTPC16 :
3345                                                  R_MN10300_16);
3346
3347                     /* Delete two bytes of data.  */
3348                     if (!mn10300_elf_relax_delete_bytes (abfd, sec,
3349                                                          irel->r_offset + 2, 2))
3350                       goto error_return;
3351
3352                     /* That will change things, so, we should relax again.
3353                        Note that this is not required, and it may be slow.  */
3354                     *again = TRUE;
3355                     break;
3356                   }
3357               else if ((code & 0xf0) == 0x80
3358                        || (code & 0xf0) == 0x90)
3359                 switch (code & 0xf3)
3360                   {
3361                   /* mov dn,(abs32)   -> mov dn,(abs16)
3362                      movbu dn,(abs32) -> movbu dn,(abs16)
3363                      movhu dn,(abs32) -> movhu dn,(abs16)  */
3364                   case 0x81:
3365                   case 0x82:
3366                   case 0x83:
3367                     /* Note that we've changed the relocation contents, etc.  */
3368                     elf_section_data (sec)->relocs = internal_relocs;
3369                     elf_section_data (sec)->this_hdr.contents = contents;
3370                     symtab_hdr->contents = (unsigned char *) isymbuf;
3371
3372                     if ((code & 0xf3) == 0x81)
3373                       code = 0x01 + (code & 0x0c);
3374                     else if ((code & 0xf3) == 0x82)
3375                       code = 0x02 + (code & 0x0c);
3376                     else if ((code & 0xf3) == 0x83)
3377                       code = 0x03 + (code & 0x0c);
3378                     else
3379                       abort ();
3380
3381                     /* Fix the opcode.  */
3382                     bfd_put_8 (abfd, code, contents + irel->r_offset - 2);
3383
3384                     /* Fix the relocation's type.  */
3385                     irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
3386                                                  (ELF32_R_TYPE (irel->r_info)
3387                                                   == (int) R_MN10300_GOTOFF32)
3388                                                  ? R_MN10300_GOTOFF16
3389                                                  : (ELF32_R_TYPE (irel->r_info)
3390                                                     == (int) R_MN10300_GOT32)
3391                                                  ? R_MN10300_GOT16
3392                                                  : (ELF32_R_TYPE (irel->r_info)
3393                                                     == (int) R_MN10300_GOTPC32)
3394                                                  ? R_MN10300_GOTPC16 :
3395                                                  R_MN10300_16);
3396
3397                     /* The opcode got shorter too, so we have to fix the
3398                        addend and offset too!  */
3399                     irel->r_offset -= 1;
3400
3401                     /* Delete three bytes of data.  */
3402                     if (!mn10300_elf_relax_delete_bytes (abfd, sec,
3403                                                          irel->r_offset + 1, 3))
3404                       goto error_return;
3405
3406                     /* That will change things, so, we should relax again.
3407                        Note that this is not required, and it may be slow.  */
3408                     *again = TRUE;
3409                     break;
3410
3411                   /* mov am,(abs32)    -> mov am,(abs16)
3412                      mov am,(d32,sp)   -> mov am,(d16,sp)
3413                      mov dm,(d32,sp)   -> mov dm,(d32,sp)
3414                      movbu dm,(d32,sp) -> movbu dm,(d32,sp)
3415                      movhu dm,(d32,sp) -> movhu dm,(d32,sp) */
3416                   case 0x80:
3417                   case 0x90:
3418                   case 0x91:
3419                   case 0x92:
3420                   case 0x93:
3421                     /* sp-based offsets are zero-extended.  */
3422                     if (code >= 0x90 && code <= 0x93
3423                         && (long) value < 0)
3424                       continue;
3425
3426                     /* Note that we've changed the relocation contents, etc.  */
3427                     elf_section_data (sec)->relocs = internal_relocs;
3428                     elf_section_data (sec)->this_hdr.contents = contents;
3429                     symtab_hdr->contents = (unsigned char *) isymbuf;
3430
3431                     /* Fix the opcode.  */
3432                     bfd_put_8 (abfd, 0xfa, contents + irel->r_offset - 2);
3433                     bfd_put_8 (abfd, code, contents + irel->r_offset - 1);
3434
3435                     /* Fix the relocation's type.  */
3436                     irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
3437                                                  (ELF32_R_TYPE (irel->r_info)
3438                                                   == (int) R_MN10300_GOTOFF32)
3439                                                  ? R_MN10300_GOTOFF16
3440                                                  : (ELF32_R_TYPE (irel->r_info)
3441                                                     == (int) R_MN10300_GOT32)
3442                                                  ? R_MN10300_GOT16
3443                                                  : (ELF32_R_TYPE (irel->r_info)
3444                                                     == (int) R_MN10300_GOTPC32)
3445                                                  ? R_MN10300_GOTPC16 :
3446                                                  R_MN10300_16);
3447
3448                     /* Delete two bytes of data.  */
3449                     if (!mn10300_elf_relax_delete_bytes (abfd, sec,
3450                                                          irel->r_offset + 2, 2))
3451                       goto error_return;
3452
3453                     /* That will change things, so, we should relax again.
3454                        Note that this is not required, and it may be slow.  */
3455                     *again = TRUE;
3456                     break;
3457                   }
3458               else if ((code & 0xf0) < 0xf0)
3459                 switch (code & 0xfc)
3460                   {
3461                   /* mov imm32,dn     -> mov imm16,dn
3462                      mov imm32,an     -> mov imm16,an
3463                      mov (abs32),dn   -> mov (abs16),dn
3464                      movbu (abs32),dn -> movbu (abs16),dn
3465                      movhu (abs32),dn -> movhu (abs16),dn  */
3466                   case 0xcc:
3467                   case 0xdc:
3468                   case 0xa4:
3469                   case 0xa8:
3470                   case 0xac:
3471                     /* Not safe if the high bit is on as relaxing may
3472                        move the value out of high mem and thus not fit
3473                        in a signed 16bit value.  */
3474                     if (code == 0xcc
3475                         && (value & 0x8000))
3476                       continue;
3477
3478                     /* mov imm16, an zero-extends the immediate.  */
3479                     if (code == 0xdc
3480                         && (long) value < 0)
3481                       continue;
3482
3483                     /* Note that we've changed the relocation contents, etc.  */
3484                     elf_section_data (sec)->relocs = internal_relocs;
3485                     elf_section_data (sec)->this_hdr.contents = contents;
3486                     symtab_hdr->contents = (unsigned char *) isymbuf;
3487
3488                     if ((code & 0xfc) == 0xcc)
3489                       code = 0x2c + (code & 0x03);
3490                     else if ((code & 0xfc) == 0xdc)
3491                       code = 0x24 + (code & 0x03);
3492                     else if ((code & 0xfc) == 0xa4)
3493                       code = 0x30 + (code & 0x03);
3494                     else if ((code & 0xfc) == 0xa8)
3495                       code = 0x34 + (code & 0x03);
3496                     else if ((code & 0xfc) == 0xac)
3497                       code = 0x38 + (code & 0x03);
3498                     else
3499                       abort ();
3500
3501                     /* Fix the opcode.  */
3502                     bfd_put_8 (abfd, code, contents + irel->r_offset - 2);
3503
3504                     /* Fix the relocation's type.  */
3505                     irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
3506                                                  (ELF32_R_TYPE (irel->r_info)
3507                                                   == (int) R_MN10300_GOTOFF32)
3508                                                  ? R_MN10300_GOTOFF16
3509                                                  : (ELF32_R_TYPE (irel->r_info)
3510                                                     == (int) R_MN10300_GOT32)
3511                                                  ? R_MN10300_GOT16
3512                                                  : (ELF32_R_TYPE (irel->r_info)
3513                                                     == (int) R_MN10300_GOTPC32)
3514                                                  ? R_MN10300_GOTPC16 :
3515                                                  R_MN10300_16);
3516
3517                     /* The opcode got shorter too, so we have to fix the
3518                        addend and offset too!  */
3519                     irel->r_offset -= 1;
3520
3521                     /* Delete three bytes of data.  */
3522                     if (!mn10300_elf_relax_delete_bytes (abfd, sec,
3523                                                          irel->r_offset + 1, 3))
3524                       goto error_return;
3525
3526                     /* That will change things, so, we should relax again.
3527                        Note that this is not required, and it may be slow.  */
3528                     *again = TRUE;
3529                     break;
3530
3531                   /* mov (abs32),an    -> mov (abs16),an
3532                      mov (d32,sp),an   -> mov (d16,sp),an
3533                      mov (d32,sp),dn   -> mov (d16,sp),dn
3534                      movbu (d32,sp),dn -> movbu (d16,sp),dn
3535                      movhu (d32,sp),dn -> movhu (d16,sp),dn
3536                      add imm32,dn      -> add imm16,dn
3537                      cmp imm32,dn      -> cmp imm16,dn
3538                      add imm32,an      -> add imm16,an
3539                      cmp imm32,an      -> cmp imm16,an
3540                      and imm32,dn      -> and imm16,dn
3541                      or imm32,dn       -> or imm16,dn
3542                      xor imm32,dn      -> xor imm16,dn
3543                      btst imm32,dn     -> btst imm16,dn */
3544
3545                   case 0xa0:
3546                   case 0xb0:
3547                   case 0xb1:
3548                   case 0xb2:
3549                   case 0xb3:
3550                   case 0xc0:
3551                   case 0xc8:
3552
3553                   case 0xd0:
3554                   case 0xd8:
3555                   case 0xe0:
3556                   case 0xe1:
3557                   case 0xe2:
3558                   case 0xe3:
3559                     /* cmp imm16, an zero-extends the immediate.  */
3560                     if (code == 0xdc
3561                         && (long) value < 0)
3562                       continue;
3563
3564                     /* So do sp-based offsets.  */
3565                     if (code >= 0xb0 && code <= 0xb3
3566                         && (long) value < 0)
3567                       continue;
3568
3569                     /* Note that we've changed the relocation contents, etc.  */
3570                     elf_section_data (sec)->relocs = internal_relocs;
3571                     elf_section_data (sec)->this_hdr.contents = contents;
3572                     symtab_hdr->contents = (unsigned char *) isymbuf;
3573
3574                     /* Fix the opcode.  */
3575                     bfd_put_8 (abfd, 0xfa, contents + irel->r_offset - 2);
3576                     bfd_put_8 (abfd, code, contents + irel->r_offset - 1);
3577
3578                     /* Fix the relocation's type.  */
3579                     irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
3580                                                  (ELF32_R_TYPE (irel->r_info)
3581                                                   == (int) R_MN10300_GOTOFF32)
3582                                                  ? R_MN10300_GOTOFF16
3583                                                  : (ELF32_R_TYPE (irel->r_info)
3584                                                     == (int) R_MN10300_GOT32)
3585                                                  ? R_MN10300_GOT16
3586                                                  : (ELF32_R_TYPE (irel->r_info)
3587                                                     == (int) R_MN10300_GOTPC32)
3588                                                  ? R_MN10300_GOTPC16 :
3589                                                  R_MN10300_16);
3590
3591                     /* Delete two bytes of data.  */
3592                     if (!mn10300_elf_relax_delete_bytes (abfd, sec,
3593                                                          irel->r_offset + 2, 2))
3594                       goto error_return;
3595
3596                     /* That will change things, so, we should relax again.
3597                        Note that this is not required, and it may be slow.  */
3598                     *again = TRUE;
3599                     break;
3600                   }
3601               else if (code == 0xfe)
3602                 {
3603                   /* add imm32,sp -> add imm16,sp  */
3604
3605                   /* Note that we've changed the relocation contents, etc.  */
3606                   elf_section_data (sec)->relocs = internal_relocs;
3607                   elf_section_data (sec)->this_hdr.contents = contents;
3608                   symtab_hdr->contents = (unsigned char *) isymbuf;
3609
3610                   /* Fix the opcode.  */
3611                   bfd_put_8 (abfd, 0xfa, contents + irel->r_offset - 2);
3612                   bfd_put_8 (abfd, 0xfe, contents + irel->r_offset - 1);
3613
3614                   /* Fix the relocation's type.  */
3615                   irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
3616                                                (ELF32_R_TYPE (irel->r_info)
3617                                                 == (int) R_MN10300_GOT32)
3618                                                ? R_MN10300_GOT16
3619                                                : (ELF32_R_TYPE (irel->r_info)
3620                                                   == (int) R_MN10300_GOTOFF32)
3621                                                ? R_MN10300_GOTOFF16
3622                                                : (ELF32_R_TYPE (irel->r_info)
3623                                                   == (int) R_MN10300_GOTPC32)
3624                                                ? R_MN10300_GOTPC16 :
3625                                                R_MN10300_16);
3626
3627                   /* Delete two bytes of data.  */
3628                   if (!mn10300_elf_relax_delete_bytes (abfd, sec,
3629                                                        irel->r_offset + 2, 2))
3630                     goto error_return;
3631
3632                   /* That will change things, so, we should relax again.
3633                      Note that this is not required, and it may be slow.  */
3634                   *again = TRUE;
3635                   break;
3636                 }
3637             }
3638         }
3639     }
3640
3641   if (isymbuf != NULL
3642       && symtab_hdr->contents != (unsigned char *) isymbuf)
3643     {
3644       if (! link_info->keep_memory)
3645         free (isymbuf);
3646       else
3647         {
3648           /* Cache the symbols for elf_link_input_bfd.  */
3649           symtab_hdr->contents = (unsigned char *) isymbuf;
3650         }
3651     }
3652
3653   if (contents != NULL
3654       && elf_section_data (sec)->this_hdr.contents != contents)
3655     {
3656       if (! link_info->keep_memory)
3657         free (contents);
3658       else
3659         {
3660           /* Cache the section contents for elf_link_input_bfd.  */
3661           elf_section_data (sec)->this_hdr.contents = contents;
3662         }
3663     }
3664
3665   if (internal_relocs != NULL
3666       && elf_section_data (sec)->relocs != internal_relocs)
3667     free (internal_relocs);
3668
3669   return TRUE;
3670
3671  error_return:
3672   if (isymbuf != NULL
3673       && symtab_hdr->contents != (unsigned char *) isymbuf)
3674     free (isymbuf);
3675   if (contents != NULL
3676       && elf_section_data (section)->this_hdr.contents != contents)
3677     free (contents);
3678   if (internal_relocs != NULL
3679       && elf_section_data (section)->relocs != internal_relocs)
3680     free (internal_relocs);
3681
3682   return FALSE;
3683 }
3684
3685 /* This is a version of bfd_generic_get_relocated_section_contents
3686    which uses mn10300_elf_relocate_section.  */
3687
3688 static bfd_byte *
3689 mn10300_elf_get_relocated_section_contents (bfd *output_bfd,
3690                                             struct bfd_link_info *link_info,
3691                                             struct bfd_link_order *link_order,
3692                                             bfd_byte *data,
3693                                             bfd_boolean relocatable,
3694                                             asymbol **symbols)
3695 {
3696   Elf_Internal_Shdr *symtab_hdr;
3697   asection *input_section = link_order->u.indirect.section;
3698   bfd *input_bfd = input_section->owner;
3699   asection **sections = NULL;
3700   Elf_Internal_Rela *internal_relocs = NULL;
3701   Elf_Internal_Sym *isymbuf = NULL;
3702
3703   /* We only need to handle the case of relaxing, or of having a
3704      particular set of section contents, specially.  */
3705   if (relocatable
3706       || elf_section_data (input_section)->this_hdr.contents == NULL)
3707     return bfd_generic_get_relocated_section_contents (output_bfd, link_info,
3708                                                        link_order, data,
3709                                                        relocatable,
3710                                                        symbols);
3711
3712   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
3713
3714   memcpy (data, elf_section_data (input_section)->this_hdr.contents,
3715           (size_t) input_section->size);
3716
3717   if ((input_section->flags & SEC_RELOC) != 0
3718       && input_section->reloc_count > 0)
3719     {
3720       asection **secpp;
3721       Elf_Internal_Sym *isym, *isymend;
3722       bfd_size_type amt;
3723
3724       internal_relocs = _bfd_elf_link_read_relocs (input_bfd, input_section,
3725                                                    NULL, NULL, FALSE);
3726       if (internal_relocs == NULL)
3727         goto error_return;
3728
3729       if (symtab_hdr->sh_info != 0)
3730         {
3731           isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
3732           if (isymbuf == NULL)
3733             isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
3734                                             symtab_hdr->sh_info, 0,
3735                                             NULL, NULL, NULL);
3736           if (isymbuf == NULL)
3737             goto error_return;
3738         }
3739
3740       amt = symtab_hdr->sh_info;
3741       amt *= sizeof (asection *);
3742       sections = bfd_malloc (amt);
3743       if (sections == NULL && amt != 0)
3744         goto error_return;
3745
3746       isymend = isymbuf + symtab_hdr->sh_info;
3747       for (isym = isymbuf, secpp = sections; isym < isymend; ++isym, ++secpp)
3748         {
3749           asection *isec;
3750
3751           if (isym->st_shndx == SHN_UNDEF)
3752             isec = bfd_und_section_ptr;
3753           else if (isym->st_shndx == SHN_ABS)
3754             isec = bfd_abs_section_ptr;
3755           else if (isym->st_shndx == SHN_COMMON)
3756             isec = bfd_com_section_ptr;
3757           else
3758             isec = bfd_section_from_elf_index (input_bfd, isym->st_shndx);
3759
3760           *secpp = isec;
3761         }
3762
3763       if (! mn10300_elf_relocate_section (output_bfd, link_info, input_bfd,
3764                                           input_section, data, internal_relocs,
3765                                           isymbuf, sections))
3766         goto error_return;
3767
3768       if (sections != NULL)
3769         free (sections);
3770       if (isymbuf != NULL && symtab_hdr->contents != (unsigned char *) isymbuf)
3771         free (isymbuf);
3772       if (internal_relocs != elf_section_data (input_section)->relocs)
3773         free (internal_relocs);
3774     }
3775
3776   return data;
3777
3778  error_return:
3779   if (sections != NULL)
3780     free (sections);
3781   if (isymbuf != NULL && symtab_hdr->contents != (unsigned char *) isymbuf)
3782     free (isymbuf);
3783   if (internal_relocs != NULL
3784       && internal_relocs != elf_section_data (input_section)->relocs)
3785     free (internal_relocs);
3786   return NULL;
3787 }
3788
3789 /* Assorted hash table functions.  */
3790
3791 /* Initialize an entry in the link hash table.  */
3792
3793 /* Create an entry in an MN10300 ELF linker hash table.  */
3794
3795 static struct bfd_hash_entry *
3796 elf32_mn10300_link_hash_newfunc (struct bfd_hash_entry *entry,
3797                                  struct bfd_hash_table *table,
3798                                  const char *string)
3799 {
3800   struct elf32_mn10300_link_hash_entry *ret =
3801     (struct elf32_mn10300_link_hash_entry *) entry;
3802
3803   /* Allocate the structure if it has not already been allocated by a
3804      subclass.  */
3805   if (ret == NULL)
3806     ret = (struct elf32_mn10300_link_hash_entry *)
3807            bfd_hash_allocate (table, sizeof (* ret));
3808   if (ret == NULL)
3809     return (struct bfd_hash_entry *) ret;
3810
3811   /* Call the allocation method of the superclass.  */
3812   ret = (struct elf32_mn10300_link_hash_entry *)
3813          _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
3814                                      table, string);
3815   if (ret != NULL)
3816     {
3817       ret->direct_calls = 0;
3818       ret->stack_size = 0;
3819       ret->movm_args = 0;
3820       ret->movm_stack_size = 0;
3821       ret->flags = 0;
3822       ret->value = 0;
3823     }
3824
3825   return (struct bfd_hash_entry *) ret;
3826 }
3827
3828 /* Create an mn10300 ELF linker hash table.  */
3829
3830 static struct bfd_link_hash_table *
3831 elf32_mn10300_link_hash_table_create (bfd *abfd)
3832 {
3833   struct elf32_mn10300_link_hash_table *ret;
3834   bfd_size_type amt = sizeof (* ret);
3835
3836   ret = bfd_malloc (amt);
3837   if (ret == NULL)
3838     return NULL;
3839
3840   if (!_bfd_elf_link_hash_table_init (&ret->root, abfd,
3841                                       elf32_mn10300_link_hash_newfunc,
3842                                       sizeof (struct elf32_mn10300_link_hash_entry)))
3843     {
3844       free (ret);
3845       return NULL;
3846     }
3847
3848   ret->flags = 0;
3849   amt = sizeof (struct elf_link_hash_table);
3850   ret->static_hash_table = bfd_malloc (amt);
3851   if (ret->static_hash_table == NULL)
3852     {
3853       free (ret);
3854       return NULL;
3855     }
3856
3857   if (!_bfd_elf_link_hash_table_init (&ret->static_hash_table->root, abfd,
3858                                       elf32_mn10300_link_hash_newfunc,
3859                                       sizeof (struct elf32_mn10300_link_hash_entry)))
3860     {
3861       free (ret->static_hash_table);
3862       free (ret);
3863       return NULL;
3864     }
3865   return & ret->root.root;
3866 }
3867
3868 /* Free an mn10300 ELF linker hash table.  */
3869
3870 static void
3871 elf32_mn10300_link_hash_table_free (struct bfd_link_hash_table *hash)
3872 {
3873   struct elf32_mn10300_link_hash_table *ret
3874     = (struct elf32_mn10300_link_hash_table *) hash;
3875
3876   _bfd_generic_link_hash_table_free
3877     ((struct bfd_link_hash_table *) ret->static_hash_table);
3878   _bfd_generic_link_hash_table_free
3879     ((struct bfd_link_hash_table *) ret);
3880 }
3881
3882 static unsigned long
3883 elf_mn10300_mach (flagword flags)
3884 {
3885   switch (flags & EF_MN10300_MACH)
3886     {
3887     case E_MN10300_MACH_MN10300:
3888     default:
3889       return bfd_mach_mn10300;
3890
3891     case E_MN10300_MACH_AM33:
3892       return bfd_mach_am33;
3893
3894     case E_MN10300_MACH_AM33_2:
3895       return bfd_mach_am33_2;
3896     }
3897 }
3898
3899 /* The final processing done just before writing out a MN10300 ELF object
3900    file.  This gets the MN10300 architecture right based on the machine
3901    number.  */
3902
3903 static void
3904 _bfd_mn10300_elf_final_write_processing (bfd *abfd,
3905                                          bfd_boolean linker ATTRIBUTE_UNUSED)
3906 {
3907   unsigned long val;
3908
3909   switch (bfd_get_mach (abfd))
3910     {
3911     default:
3912     case bfd_mach_mn10300:
3913       val = E_MN10300_MACH_MN10300;
3914       break;
3915
3916     case bfd_mach_am33:
3917       val = E_MN10300_MACH_AM33;
3918       break;
3919
3920     case bfd_mach_am33_2:
3921       val = E_MN10300_MACH_AM33_2;
3922       break;
3923     }
3924
3925   elf_elfheader (abfd)->e_flags &= ~ (EF_MN10300_MACH);
3926   elf_elfheader (abfd)->e_flags |= val;
3927 }
3928
3929 static bfd_boolean
3930 _bfd_mn10300_elf_object_p (bfd *abfd)
3931 {
3932   bfd_default_set_arch_mach (abfd, bfd_arch_mn10300,
3933                              elf_mn10300_mach (elf_elfheader (abfd)->e_flags));
3934   return TRUE;
3935 }
3936
3937 /* Merge backend specific data from an object file to the output
3938    object file when linking.  */
3939
3940 static bfd_boolean
3941 _bfd_mn10300_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
3942 {
3943   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
3944       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
3945     return TRUE;
3946
3947   if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
3948       && bfd_get_mach (obfd) < bfd_get_mach (ibfd))
3949     {
3950       if (! bfd_set_arch_mach (obfd, bfd_get_arch (ibfd),
3951                                bfd_get_mach (ibfd)))
3952         return FALSE;
3953     }
3954
3955   return TRUE;
3956 }
3957
3958 #define PLT0_ENTRY_SIZE     15
3959 #define PLT_ENTRY_SIZE      20
3960 #define PIC_PLT_ENTRY_SIZE  24
3961
3962 static const bfd_byte elf_mn10300_plt0_entry[PLT0_ENTRY_SIZE] =
3963 {
3964   0xfc, 0xa0, 0, 0, 0, 0,       /* mov  (.got+8),a0 */
3965   0xfe, 0xe, 0x10, 0, 0, 0, 0,  /* mov  (.got+4),r1 */
3966   0xf0, 0xf4,                   /* jmp  (a0) */
3967 };
3968
3969 static const bfd_byte elf_mn10300_plt_entry[PLT_ENTRY_SIZE] =
3970 {
3971   0xfc, 0xa0, 0, 0, 0, 0,       /* mov  (nameN@GOT + .got),a0 */
3972   0xf0, 0xf4,                   /* jmp  (a0) */
3973   0xfe, 8, 0, 0, 0, 0, 0,       /* mov  reloc-table-address,r0 */
3974   0xdc, 0, 0, 0, 0,             /* jmp  .plt0 */
3975 };
3976
3977 static const bfd_byte elf_mn10300_pic_plt_entry[PIC_PLT_ENTRY_SIZE] =
3978 {
3979   0xfc, 0x22, 0, 0, 0, 0,       /* mov  (nameN@GOT,a2),a0 */
3980   0xf0, 0xf4,                   /* jmp  (a0) */
3981   0xfe, 8, 0, 0, 0, 0, 0,       /* mov  reloc-table-address,r0 */
3982   0xf8, 0x22, 8,                /* mov  (8,a2),a0 */
3983   0xfb, 0xa, 0x1a, 4,           /* mov  (4,a2),r1 */
3984   0xf0, 0xf4,                   /* jmp  (a0) */
3985 };
3986
3987 /* Return size of the first PLT entry.  */
3988 #define elf_mn10300_sizeof_plt0(info) \
3989   (info->shared ? PIC_PLT_ENTRY_SIZE : PLT0_ENTRY_SIZE)
3990
3991 /* Return size of a PLT entry.  */
3992 #define elf_mn10300_sizeof_plt(info) \
3993   (info->shared ? PIC_PLT_ENTRY_SIZE : PLT_ENTRY_SIZE)
3994
3995 /* Return offset of the PLT0 address in an absolute PLT entry.  */
3996 #define elf_mn10300_plt_plt0_offset(info) 16
3997
3998 /* Return offset of the linker in PLT0 entry.  */
3999 #define elf_mn10300_plt0_linker_offset(info) 2
4000
4001 /* Return offset of the GOT id in PLT0 entry.  */
4002 #define elf_mn10300_plt0_gotid_offset(info) 9
4003
4004 /* Return offset of the temporary in PLT entry.  */
4005 #define elf_mn10300_plt_temp_offset(info) 8
4006
4007 /* Return offset of the symbol in PLT entry.  */
4008 #define elf_mn10300_plt_symbol_offset(info) 2
4009
4010 /* Return offset of the relocation in PLT entry.  */
4011 #define elf_mn10300_plt_reloc_offset(info) 11
4012
4013 /* The name of the dynamic interpreter.  This is put in the .interp
4014    section.  */
4015
4016 #define ELF_DYNAMIC_INTERPRETER "/lib/ld.so.1"
4017
4018 /* Create dynamic sections when linking against a dynamic object.  */
4019
4020 static bfd_boolean
4021 _bfd_mn10300_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
4022 {
4023   flagword   flags;
4024   asection * s;
4025   const struct elf_backend_data * bed = get_elf_backend_data (abfd);
4026   int ptralign = 0;
4027
4028   switch (bed->s->arch_size)
4029     {
4030     case 32:
4031       ptralign = 2;
4032       break;
4033
4034     case 64:
4035       ptralign = 3;
4036       break;
4037
4038     default:
4039       bfd_set_error (bfd_error_bad_value);
4040       return FALSE;
4041     }
4042
4043   /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
4044      .rel[a].bss sections.  */
4045   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4046            | SEC_LINKER_CREATED);
4047
4048   s = bfd_make_section_with_flags (abfd,
4049                                    (bed->default_use_rela_p
4050                                     ? ".rela.plt" : ".rel.plt"),
4051                                    flags | SEC_READONLY);
4052   if (s == NULL
4053       || ! bfd_set_section_alignment (abfd, s, ptralign))
4054     return FALSE;
4055
4056   if (! _bfd_mn10300_elf_create_got_section (abfd, info))
4057     return FALSE;
4058
4059   {
4060     const char * secname;
4061     char *       relname;
4062     flagword     secflags;
4063     asection *   sec;
4064
4065     for (sec = abfd->sections; sec; sec = sec->next)
4066       {
4067         secflags = bfd_get_section_flags (abfd, sec);
4068         if ((secflags & (SEC_DATA | SEC_LINKER_CREATED))
4069             || ((secflags & SEC_HAS_CONTENTS) != SEC_HAS_CONTENTS))
4070           continue;
4071
4072         secname = bfd_get_section_name (abfd, sec);
4073         relname = bfd_malloc (strlen (secname) + 6);
4074         strcpy (relname, ".rela");
4075         strcat (relname, secname);
4076
4077         s = bfd_make_section_with_flags (abfd, relname,
4078                                          flags | SEC_READONLY);
4079         if (s == NULL
4080             || ! bfd_set_section_alignment (abfd, s, ptralign))
4081           return FALSE;
4082       }
4083   }
4084
4085   if (bed->want_dynbss)
4086     {
4087       /* The .dynbss section is a place to put symbols which are defined
4088          by dynamic objects, are referenced by regular objects, and are
4089          not functions.  We must allocate space for them in the process
4090          image and use a R_*_COPY reloc to tell the dynamic linker to
4091          initialize them at run time.  The linker script puts the .dynbss
4092          section into the .bss section of the final image.  */
4093       s = bfd_make_section_with_flags (abfd, ".dynbss",
4094                                        SEC_ALLOC | SEC_LINKER_CREATED);
4095       if (s == NULL)
4096         return FALSE;
4097
4098       /* The .rel[a].bss section holds copy relocs.  This section is not
4099          normally needed.  We need to create it here, though, so that the
4100          linker will map it to an output section.  We can't just create it
4101          only if we need it, because we will not know whether we need it
4102          until we have seen all the input files, and the first time the
4103          main linker code calls BFD after examining all the input files
4104          (size_dynamic_sections) the input sections have already been
4105          mapped to the output sections.  If the section turns out not to
4106          be needed, we can discard it later.  We will never need this
4107          section when generating a shared object, since they do not use
4108          copy relocs.  */
4109       if (! info->shared)
4110         {
4111           s = bfd_make_section_with_flags (abfd,
4112                                            (bed->default_use_rela_p
4113                                             ? ".rela.bss" : ".rel.bss"),
4114                                            flags | SEC_READONLY);
4115           if (s == NULL
4116               || ! bfd_set_section_alignment (abfd, s, ptralign))
4117             return FALSE;
4118         }
4119     }
4120
4121   return TRUE;
4122 }
4123 \f
4124 /* Adjust a symbol defined by a dynamic object and referenced by a
4125    regular object.  The current definition is in some section of the
4126    dynamic object, but we're not including those sections.  We have to
4127    change the definition to something the rest of the link can
4128    understand.  */
4129
4130 static bfd_boolean
4131 _bfd_mn10300_elf_adjust_dynamic_symbol (struct bfd_link_info * info,
4132                                         struct elf_link_hash_entry * h)
4133 {
4134   bfd * dynobj;
4135   asection * s;
4136
4137   dynobj = elf_hash_table (info)->dynobj;
4138
4139   /* Make sure we know what is going on here.  */
4140   BFD_ASSERT (dynobj != NULL
4141               && (h->needs_plt
4142                   || h->u.weakdef != NULL
4143                   || (h->def_dynamic
4144                       && h->ref_regular
4145                       && !h->def_regular)));
4146
4147   /* If this is a function, put it in the procedure linkage table.  We
4148      will fill in the contents of the procedure linkage table later,
4149      when we know the address of the .got section.  */
4150   if (h->type == STT_FUNC
4151       || h->needs_plt)
4152     {
4153       if (! info->shared
4154           && !h->def_dynamic
4155           && !h->ref_dynamic)
4156         {
4157           /* This case can occur if we saw a PLT reloc in an input
4158              file, but the symbol was never referred to by a dynamic
4159              object.  In such a case, we don't actually need to build
4160              a procedure linkage table, and we can just do a REL32
4161              reloc instead.  */
4162           BFD_ASSERT (h->needs_plt);
4163           return TRUE;
4164         }
4165
4166       /* Make sure this symbol is output as a dynamic symbol.  */
4167       if (h->dynindx == -1)
4168         {
4169           if (! bfd_elf_link_record_dynamic_symbol (info, h))
4170             return FALSE;
4171         }
4172
4173       s = bfd_get_section_by_name (dynobj, ".plt");
4174       BFD_ASSERT (s != NULL);
4175
4176       /* If this is the first .plt entry, make room for the special
4177          first entry.  */
4178       if (s->size == 0)
4179         s->size += elf_mn10300_sizeof_plt0 (info);
4180
4181       /* If this symbol is not defined in a regular file, and we are
4182          not generating a shared library, then set the symbol to this
4183          location in the .plt.  This is required to make function
4184          pointers compare as equal between the normal executable and
4185          the shared library.  */
4186       if (! info->shared
4187           && !h->def_regular)
4188         {
4189           h->root.u.def.section = s;
4190           h->root.u.def.value = s->size;
4191         }
4192
4193       h->plt.offset = s->size;
4194
4195       /* Make room for this entry.  */
4196       s->size += elf_mn10300_sizeof_plt (info);
4197
4198       /* We also need to make an entry in the .got.plt section, which
4199          will be placed in the .got section by the linker script.  */
4200       s = bfd_get_section_by_name (dynobj, ".got.plt");
4201       BFD_ASSERT (s != NULL);
4202       s->size += 4;
4203
4204       /* We also need to make an entry in the .rela.plt section.  */
4205       s = bfd_get_section_by_name (dynobj, ".rela.plt");
4206       BFD_ASSERT (s != NULL);
4207       s->size += sizeof (Elf32_External_Rela);
4208
4209       return TRUE;
4210     }
4211
4212   /* If this is a weak symbol, and there is a real definition, the
4213      processor independent code will have arranged for us to see the
4214      real definition first, and we can just use the same value.  */
4215   if (h->u.weakdef != NULL)
4216     {
4217       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
4218                   || h->u.weakdef->root.type == bfd_link_hash_defweak);
4219       h->root.u.def.section = h->u.weakdef->root.u.def.section;
4220       h->root.u.def.value = h->u.weakdef->root.u.def.value;
4221       return TRUE;
4222     }
4223
4224   /* This is a reference to a symbol defined by a dynamic object which
4225      is not a function.  */
4226
4227   /* If we are creating a shared library, we must presume that the
4228      only references to the symbol are via the global offset table.
4229      For such cases we need not do anything here; the relocations will
4230      be handled correctly by relocate_section.  */
4231   if (info->shared)
4232     return TRUE;
4233
4234   /* If there are no references to this symbol that do not use the
4235      GOT, we don't need to generate a copy reloc.  */
4236   if (!h->non_got_ref)
4237     return TRUE;
4238
4239   if (h->size == 0)
4240     {
4241       (*_bfd_error_handler) (_("dynamic variable `%s' is zero size"),
4242                              h->root.root.string);
4243       return TRUE;
4244     }
4245
4246   /* We must allocate the symbol in our .dynbss section, which will
4247      become part of the .bss section of the executable.  There will be
4248      an entry for this symbol in the .dynsym section.  The dynamic
4249      object will contain position independent code, so all references
4250      from the dynamic object to this symbol will go through the global
4251      offset table.  The dynamic linker will use the .dynsym entry to
4252      determine the address it must put in the global offset table, so
4253      both the dynamic object and the regular object will refer to the
4254      same memory location for the variable.  */
4255
4256   s = bfd_get_section_by_name (dynobj, ".dynbss");
4257   BFD_ASSERT (s != NULL);
4258
4259   /* We must generate a R_MN10300_COPY reloc to tell the dynamic linker to
4260      copy the initial value out of the dynamic object and into the
4261      runtime process image.  We need to remember the offset into the
4262      .rela.bss section we are going to use.  */
4263   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
4264     {
4265       asection * srel;
4266
4267       srel = bfd_get_section_by_name (dynobj, ".rela.bss");
4268       BFD_ASSERT (srel != NULL);
4269       srel->size += sizeof (Elf32_External_Rela);
4270       h->needs_copy = 1;
4271     }
4272
4273   return _bfd_elf_adjust_dynamic_copy (h, s);
4274 }
4275
4276 /* Set the sizes of the dynamic sections.  */
4277
4278 static bfd_boolean
4279 _bfd_mn10300_elf_size_dynamic_sections (bfd * output_bfd,
4280                                         struct bfd_link_info * info)
4281 {
4282   bfd * dynobj;
4283   asection * s;
4284   bfd_boolean plt;
4285   bfd_boolean relocs;
4286   bfd_boolean reltext;
4287
4288   dynobj = elf_hash_table (info)->dynobj;
4289   BFD_ASSERT (dynobj != NULL);
4290
4291   if (elf_hash_table (info)->dynamic_sections_created)
4292     {
4293       /* Set the contents of the .interp section to the interpreter.  */
4294       if (info->executable)
4295         {
4296           s = bfd_get_section_by_name (dynobj, ".interp");
4297           BFD_ASSERT (s != NULL);
4298           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
4299           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
4300         }
4301     }
4302   else
4303     {
4304       /* We may have created entries in the .rela.got section.
4305          However, if we are not creating the dynamic sections, we will
4306          not actually use these entries.  Reset the size of .rela.got,
4307          which will cause it to get stripped from the output file
4308          below.  */
4309       s = bfd_get_section_by_name (dynobj, ".rela.got");
4310       if (s != NULL)
4311         s->size = 0;
4312     }
4313
4314   /* The check_relocs and adjust_dynamic_symbol entry points have
4315      determined the sizes of the various dynamic sections.  Allocate
4316      memory for them.  */
4317   plt = FALSE;
4318   relocs = FALSE;
4319   reltext = FALSE;
4320   for (s = dynobj->sections; s != NULL; s = s->next)
4321     {
4322       const char * name;
4323
4324       if ((s->flags & SEC_LINKER_CREATED) == 0)
4325         continue;
4326
4327       /* It's OK to base decisions on the section name, because none
4328          of the dynobj section names depend upon the input files.  */
4329       name = bfd_get_section_name (dynobj, s);
4330
4331       if (streq (name, ".plt"))
4332         {
4333           /* Remember whether there is a PLT.  */
4334           plt = s->size != 0;
4335         }
4336       else if (CONST_STRNEQ (name, ".rela"))
4337         {
4338           if (s->size != 0)
4339             {
4340               asection * target;
4341
4342               /* Remember whether there are any reloc sections other
4343                  than .rela.plt.  */
4344               if (! streq (name, ".rela.plt"))
4345                 {
4346                   const char * outname;
4347
4348                   relocs = TRUE;
4349
4350                   /* If this relocation section applies to a read only
4351                      section, then we probably need a DT_TEXTREL
4352                      entry.  The entries in the .rela.plt section
4353                      really apply to the .got section, which we
4354                      created ourselves and so know is not readonly.  */
4355                   outname = bfd_get_section_name (output_bfd,
4356                                                   s->output_section);
4357                   target = bfd_get_section_by_name (output_bfd, outname + 5);
4358                   if (target != NULL
4359                       && (target->flags & SEC_READONLY) != 0
4360                       && (target->flags & SEC_ALLOC) != 0)
4361                     reltext = TRUE;
4362                 }
4363
4364               /* We use the reloc_count field as a counter if we need
4365                  to copy relocs into the output file.  */
4366               s->reloc_count = 0;
4367             }
4368         }
4369       else if (! CONST_STRNEQ (name, ".got")
4370                && ! streq (name, ".dynbss"))
4371         /* It's not one of our sections, so don't allocate space.  */
4372         continue;
4373
4374       if (s->size == 0)
4375         {
4376           /* If we don't need this section, strip it from the
4377              output file.  This is mostly to handle .rela.bss and
4378              .rela.plt.  We must create both sections in
4379              create_dynamic_sections, because they must be created
4380              before the linker maps input sections to output
4381              sections.  The linker does that before
4382              adjust_dynamic_symbol is called, and it is that
4383              function which decides whether anything needs to go
4384              into these sections.  */
4385           s->flags |= SEC_EXCLUDE;
4386           continue;
4387         }
4388
4389         if ((s->flags & SEC_HAS_CONTENTS) == 0)
4390           continue;
4391
4392       /* Allocate memory for the section contents.  We use bfd_zalloc
4393          here in case unused entries are not reclaimed before the
4394          section's contents are written out.  This should not happen,
4395          but this way if it does, we get a R_MN10300_NONE reloc
4396          instead of garbage.  */
4397       s->contents = bfd_zalloc (dynobj, s->size);
4398       if (s->contents == NULL)
4399         return FALSE;
4400     }
4401
4402   if (elf_hash_table (info)->dynamic_sections_created)
4403     {
4404       /* Add some entries to the .dynamic section.  We fill in the
4405          values later, in _bfd_mn10300_elf_finish_dynamic_sections,
4406          but we must add the entries now so that we get the correct
4407          size for the .dynamic section.  The DT_DEBUG entry is filled
4408          in by the dynamic linker and used by the debugger.  */
4409       if (! info->shared)
4410         {
4411           if (!_bfd_elf_add_dynamic_entry (info, DT_DEBUG, 0))
4412             return FALSE;
4413         }
4414
4415       if (plt)
4416         {
4417           if (!_bfd_elf_add_dynamic_entry (info, DT_PLTGOT, 0)
4418               || !_bfd_elf_add_dynamic_entry (info, DT_PLTRELSZ, 0)
4419               || !_bfd_elf_add_dynamic_entry (info, DT_PLTREL, DT_RELA)
4420               || !_bfd_elf_add_dynamic_entry (info, DT_JMPREL, 0))
4421             return FALSE;
4422         }
4423
4424       if (relocs)
4425         {
4426           if (!_bfd_elf_add_dynamic_entry (info, DT_RELA, 0)
4427               || !_bfd_elf_add_dynamic_entry (info, DT_RELASZ, 0)
4428               || !_bfd_elf_add_dynamic_entry (info, DT_RELAENT,
4429                                               sizeof (Elf32_External_Rela)))
4430             return FALSE;
4431         }
4432
4433       if (reltext)
4434         {
4435           if (!_bfd_elf_add_dynamic_entry (info, DT_TEXTREL, 0))
4436             return FALSE;
4437         }
4438     }
4439
4440   return TRUE;
4441 }
4442
4443 /* Finish up dynamic symbol handling.  We set the contents of various
4444    dynamic sections here.  */
4445
4446 static bfd_boolean
4447 _bfd_mn10300_elf_finish_dynamic_symbol (bfd * output_bfd,
4448                                         struct bfd_link_info * info,
4449                                         struct elf_link_hash_entry * h,
4450                                         Elf_Internal_Sym * sym)
4451 {
4452   bfd * dynobj;
4453
4454   dynobj = elf_hash_table (info)->dynobj;
4455
4456   if (h->plt.offset != (bfd_vma) -1)
4457     {
4458       asection *        splt;
4459       asection *        sgot;
4460       asection *        srel;
4461       bfd_vma           plt_index;
4462       bfd_vma           got_offset;
4463       Elf_Internal_Rela rel;
4464
4465       /* This symbol has an entry in the procedure linkage table.  Set
4466          it up.  */
4467
4468       BFD_ASSERT (h->dynindx != -1);
4469
4470       splt = bfd_get_section_by_name (dynobj, ".plt");
4471       sgot = bfd_get_section_by_name (dynobj, ".got.plt");
4472       srel = bfd_get_section_by_name (dynobj, ".rela.plt");
4473       BFD_ASSERT (splt != NULL && sgot != NULL && srel != NULL);
4474
4475       /* Get the index in the procedure linkage table which
4476          corresponds to this symbol.  This is the index of this symbol
4477          in all the symbols for which we are making plt entries.  The
4478          first entry in the procedure linkage table is reserved.  */
4479       plt_index = ((h->plt.offset - elf_mn10300_sizeof_plt0 (info))
4480                    / elf_mn10300_sizeof_plt (info));
4481
4482       /* Get the offset into the .got table of the entry that
4483          corresponds to this function.  Each .got entry is 4 bytes.
4484          The first three are reserved.  */
4485       got_offset = (plt_index + 3) * 4;
4486
4487       /* Fill in the entry in the procedure linkage table.  */
4488       if (! info->shared)
4489         {
4490           memcpy (splt->contents + h->plt.offset, elf_mn10300_plt_entry,
4491                   elf_mn10300_sizeof_plt (info));
4492           bfd_put_32 (output_bfd,
4493                       (sgot->output_section->vma
4494                        + sgot->output_offset
4495                        + got_offset),
4496                       (splt->contents + h->plt.offset
4497                        + elf_mn10300_plt_symbol_offset (info)));
4498
4499           bfd_put_32 (output_bfd,
4500                       (1 - h->plt.offset - elf_mn10300_plt_plt0_offset (info)),
4501                       (splt->contents + h->plt.offset
4502                        + elf_mn10300_plt_plt0_offset (info)));
4503         }
4504       else
4505         {
4506           memcpy (splt->contents + h->plt.offset, elf_mn10300_pic_plt_entry,
4507                   elf_mn10300_sizeof_plt (info));
4508
4509           bfd_put_32 (output_bfd, got_offset,
4510                       (splt->contents + h->plt.offset
4511                        + elf_mn10300_plt_symbol_offset (info)));
4512         }
4513
4514       bfd_put_32 (output_bfd, plt_index * sizeof (Elf32_External_Rela),
4515                   (splt->contents + h->plt.offset
4516                    + elf_mn10300_plt_reloc_offset (info)));
4517
4518       /* Fill in the entry in the global offset table.  */
4519       bfd_put_32 (output_bfd,
4520                   (splt->output_section->vma
4521                    + splt->output_offset
4522                    + h->plt.offset
4523                    + elf_mn10300_plt_temp_offset (info)),
4524                   sgot->contents + got_offset);
4525
4526       /* Fill in the entry in the .rela.plt section.  */
4527       rel.r_offset = (sgot->output_section->vma
4528                       + sgot->output_offset
4529                       + got_offset);
4530       rel.r_info = ELF32_R_INFO (h->dynindx, R_MN10300_JMP_SLOT);
4531       rel.r_addend = 0;
4532       bfd_elf32_swap_reloca_out (output_bfd, &rel,
4533                                  (bfd_byte *) ((Elf32_External_Rela *) srel->contents
4534                                                + plt_index));
4535
4536       if (!h->def_regular)
4537         /* Mark the symbol as undefined, rather than as defined in
4538            the .plt section.  Leave the value alone.  */
4539         sym->st_shndx = SHN_UNDEF;
4540     }
4541
4542   if (h->got.offset != (bfd_vma) -1)
4543     {
4544       asection *        sgot;
4545       asection *        srel;
4546       Elf_Internal_Rela rel;
4547
4548       /* This symbol has an entry in the global offset table.  Set it up.  */
4549       sgot = bfd_get_section_by_name (dynobj, ".got");
4550       srel = bfd_get_section_by_name (dynobj, ".rela.got");
4551       BFD_ASSERT (sgot != NULL && srel != NULL);
4552
4553       rel.r_offset = (sgot->output_section->vma
4554                       + sgot->output_offset
4555                       + (h->got.offset & ~1));
4556
4557       /* If this is a -Bsymbolic link, and the symbol is defined
4558          locally, we just want to emit a RELATIVE reloc.  Likewise if
4559          the symbol was forced to be local because of a version file.
4560          The entry in the global offset table will already have been
4561          initialized in the relocate_section function.  */
4562       if (info->shared
4563           && (info->symbolic || h->dynindx == -1)
4564           && h->def_regular)
4565         {
4566           rel.r_info = ELF32_R_INFO (0, R_MN10300_RELATIVE);
4567           rel.r_addend = (h->root.u.def.value
4568                           + h->root.u.def.section->output_section->vma
4569                           + h->root.u.def.section->output_offset);
4570         }
4571       else
4572         {
4573           bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset);
4574           rel.r_info = ELF32_R_INFO (h->dynindx, R_MN10300_GLOB_DAT);
4575           rel.r_addend = 0;
4576         }
4577
4578       bfd_elf32_swap_reloca_out (output_bfd, &rel,
4579                                  (bfd_byte *) ((Elf32_External_Rela *) srel->contents
4580                                                + srel->reloc_count));
4581       ++ srel->reloc_count;
4582     }
4583
4584   if (h->needs_copy)
4585     {
4586       asection *        s;
4587       Elf_Internal_Rela rel;
4588
4589       /* This symbol needs a copy reloc.  Set it up.  */
4590       BFD_ASSERT (h->dynindx != -1
4591                   && (h->root.type == bfd_link_hash_defined
4592                       || h->root.type == bfd_link_hash_defweak));
4593
4594       s = bfd_get_section_by_name (h->root.u.def.section->owner,
4595                                    ".rela.bss");
4596       BFD_ASSERT (s != NULL);
4597
4598       rel.r_offset = (h->root.u.def.value
4599                       + h->root.u.def.section->output_section->vma
4600                       + h->root.u.def.section->output_offset);
4601       rel.r_info = ELF32_R_INFO (h->dynindx, R_MN10300_COPY);
4602       rel.r_addend = 0;
4603       bfd_elf32_swap_reloca_out (output_bfd, & rel,
4604                                  (bfd_byte *) ((Elf32_External_Rela *) s->contents
4605                                                + s->reloc_count));
4606       ++ s->reloc_count;
4607     }
4608
4609   /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute.  */
4610   if (streq (h->root.root.string, "_DYNAMIC")
4611       || h == elf_hash_table (info)->hgot)
4612     sym->st_shndx = SHN_ABS;
4613
4614   return TRUE;
4615 }
4616
4617 /* Finish up the dynamic sections.  */
4618
4619 static bfd_boolean
4620 _bfd_mn10300_elf_finish_dynamic_sections (bfd * output_bfd,
4621                                           struct bfd_link_info * info)
4622 {
4623   bfd *      dynobj;
4624   asection * sgot;
4625   asection * sdyn;
4626
4627   dynobj = elf_hash_table (info)->dynobj;
4628
4629   sgot = bfd_get_section_by_name (dynobj, ".got.plt");
4630   BFD_ASSERT (sgot != NULL);
4631   sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
4632
4633   if (elf_hash_table (info)->dynamic_sections_created)
4634     {
4635       asection *           splt;
4636       Elf32_External_Dyn * dyncon;
4637       Elf32_External_Dyn * dynconend;
4638
4639       BFD_ASSERT (sdyn != NULL);
4640
4641       dyncon = (Elf32_External_Dyn *) sdyn->contents;
4642       dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
4643
4644       for (; dyncon < dynconend; dyncon++)
4645         {
4646           Elf_Internal_Dyn dyn;
4647           const char * name;
4648           asection * s;
4649
4650           bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
4651
4652           switch (dyn.d_tag)
4653             {
4654             default:
4655               break;
4656
4657             case DT_PLTGOT:
4658               name = ".got";
4659               goto get_vma;
4660
4661             case DT_JMPREL:
4662               name = ".rela.plt";
4663             get_vma:
4664               s = bfd_get_section_by_name (output_bfd, name);
4665               BFD_ASSERT (s != NULL);
4666               dyn.d_un.d_ptr = s->vma;
4667               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
4668               break;
4669
4670             case DT_PLTRELSZ:
4671               s = bfd_get_section_by_name (output_bfd, ".rela.plt");
4672               BFD_ASSERT (s != NULL);
4673               dyn.d_un.d_val = s->size;
4674               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
4675               break;
4676
4677             case DT_RELASZ:
4678               /* My reading of the SVR4 ABI indicates that the
4679                  procedure linkage table relocs (DT_JMPREL) should be
4680                  included in the overall relocs (DT_RELA).  This is
4681                  what Solaris does.  However, UnixWare can not handle
4682                  that case.  Therefore, we override the DT_RELASZ entry
4683                  here to make it not include the JMPREL relocs.  Since
4684                  the linker script arranges for .rela.plt to follow all
4685                  other relocation sections, we don't have to worry
4686                  about changing the DT_RELA entry.  */
4687               s = bfd_get_section_by_name (output_bfd, ".rela.plt");
4688               if (s != NULL)
4689                 dyn.d_un.d_val -= s->size;
4690               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
4691               break;
4692             }
4693         }
4694
4695       /* Fill in the first entry in the procedure linkage table.  */
4696       splt = bfd_get_section_by_name (dynobj, ".plt");
4697       if (splt && splt->size > 0)
4698         {
4699           if (info->shared)
4700             {
4701               memcpy (splt->contents, elf_mn10300_pic_plt_entry,
4702                       elf_mn10300_sizeof_plt (info));
4703             }
4704           else
4705             {
4706               memcpy (splt->contents, elf_mn10300_plt0_entry, PLT0_ENTRY_SIZE);
4707               bfd_put_32 (output_bfd,
4708                           sgot->output_section->vma + sgot->output_offset + 4,
4709                           splt->contents + elf_mn10300_plt0_gotid_offset (info));
4710               bfd_put_32 (output_bfd,
4711                           sgot->output_section->vma + sgot->output_offset + 8,
4712                           splt->contents + elf_mn10300_plt0_linker_offset (info));
4713             }
4714
4715           /* UnixWare sets the entsize of .plt to 4, although that doesn't
4716              really seem like the right value.  */
4717           elf_section_data (splt->output_section)->this_hdr.sh_entsize = 4;
4718         }
4719     }
4720
4721   /* Fill in the first three entries in the global offset table.  */
4722   if (sgot->size > 0)
4723     {
4724       if (sdyn == NULL)
4725         bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
4726       else
4727         bfd_put_32 (output_bfd,
4728                     sdyn->output_section->vma + sdyn->output_offset,
4729                     sgot->contents);
4730       bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4);
4731       bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
4732     }
4733
4734   elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
4735
4736   return TRUE;
4737 }
4738
4739 /* Classify relocation types, such that combreloc can sort them
4740    properly.  */
4741
4742 static enum elf_reloc_type_class
4743 _bfd_mn10300_elf_reloc_type_class (const Elf_Internal_Rela *rela)
4744 {
4745   switch ((int) ELF32_R_TYPE (rela->r_info))
4746     {
4747     case R_MN10300_RELATIVE:    return reloc_class_relative;
4748     case R_MN10300_JMP_SLOT:    return reloc_class_plt;
4749     case R_MN10300_COPY:        return reloc_class_copy;
4750     default:                    return reloc_class_normal;
4751     }
4752 }
4753
4754 #ifndef ELF_ARCH
4755 #define TARGET_LITTLE_SYM       bfd_elf32_mn10300_vec
4756 #define TARGET_LITTLE_NAME      "elf32-mn10300"
4757 #define ELF_ARCH                bfd_arch_mn10300
4758 #define ELF_MACHINE_CODE        EM_MN10300
4759 #define ELF_MACHINE_ALT1        EM_CYGNUS_MN10300
4760 #define ELF_MAXPAGESIZE         0x1000
4761 #endif
4762
4763 #define elf_info_to_howto               mn10300_info_to_howto
4764 #define elf_info_to_howto_rel           0
4765 #define elf_backend_can_gc_sections     1
4766 #define elf_backend_rela_normal         1
4767 #define elf_backend_check_relocs        mn10300_elf_check_relocs
4768 #define elf_backend_gc_mark_hook        mn10300_elf_gc_mark_hook
4769 #define elf_backend_relocate_section    mn10300_elf_relocate_section
4770 #define bfd_elf32_bfd_relax_section     mn10300_elf_relax_section
4771 #define bfd_elf32_bfd_get_relocated_section_contents \
4772                                 mn10300_elf_get_relocated_section_contents
4773 #define bfd_elf32_bfd_link_hash_table_create \
4774                                 elf32_mn10300_link_hash_table_create
4775 #define bfd_elf32_bfd_link_hash_table_free \
4776                                 elf32_mn10300_link_hash_table_free
4777
4778 #ifndef elf_symbol_leading_char
4779 #define elf_symbol_leading_char '_'
4780 #endif
4781
4782 /* So we can set bits in e_flags.  */
4783 #define elf_backend_final_write_processing \
4784                                         _bfd_mn10300_elf_final_write_processing
4785 #define elf_backend_object_p            _bfd_mn10300_elf_object_p
4786
4787 #define bfd_elf32_bfd_merge_private_bfd_data \
4788                                         _bfd_mn10300_elf_merge_private_bfd_data
4789
4790 #define elf_backend_can_gc_sections     1
4791 #define elf_backend_create_dynamic_sections \
4792   _bfd_mn10300_elf_create_dynamic_sections
4793 #define elf_backend_adjust_dynamic_symbol \
4794   _bfd_mn10300_elf_adjust_dynamic_symbol
4795 #define elf_backend_size_dynamic_sections \
4796   _bfd_mn10300_elf_size_dynamic_sections
4797 #define elf_backend_omit_section_dynsym \
4798   ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
4799 #define elf_backend_finish_dynamic_symbol \
4800   _bfd_mn10300_elf_finish_dynamic_symbol
4801 #define elf_backend_finish_dynamic_sections \
4802   _bfd_mn10300_elf_finish_dynamic_sections
4803
4804 #define elf_backend_reloc_type_class \
4805   _bfd_mn10300_elf_reloc_type_class
4806
4807 #define elf_backend_want_got_plt        1
4808 #define elf_backend_plt_readonly        1
4809 #define elf_backend_want_plt_sym        0
4810 #define elf_backend_got_header_size     12
4811
4812 #include "elf32-target.h"