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