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