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