bfd/elf32-avr.c

   1 /* AVR-specific support for 32-bit ELF
   2    Copyright (C) 1999-2014 Free Software Foundation, Inc.
   3    Contributed by Denis Chertykov <denisc@overta.ru>
   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,
  20    Boston, 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/avr.h"
  27 #include "elf32-avr.h"
  28
  29 /* Enable debugging printout at stdout with this variable.  */
  30 static bfd_boolean debug_relax = FALSE;
  31
  32 /* Enable debugging printout at stdout with this variable.  */
  33 static bfd_boolean debug_stubs = FALSE;
  34
  35 static bfd_reloc_status_type
  36 bfd_elf_avr_diff_reloc (bfd *, arelent *, asymbol *, void *,
  37                         asection *, bfd *, char **);
  38
  39 /* Hash table initialization and handling.  Code is taken from the hppa port
  40    and adapted to the needs of AVR.  */
  41
  42 /* We use two hash tables to hold information for linking avr objects.
  43
  44    The first is the elf32_avr_link_hash_table which is derived from the
  45    stanard ELF linker hash table.  We use this as a place to attach the other
  46    hash table and some static information.
  47
  48    The second is the stub hash table which is derived from the base BFD
  49    hash table.  The stub hash table holds the information on the linker
  50    stubs.  */
  51
  52 struct elf32_avr_stub_hash_entry
  53 {
  54   /* Base hash table entry structure.  */
  55   struct bfd_hash_entry bh_root;
  56
  57   /* Offset within stub_sec of the beginning of this stub.  */
  58   bfd_vma stub_offset;
  59
  60   /* Given the symbol's value and its section we can determine its final
  61      value when building the stubs (so the stub knows where to jump).  */
  62   bfd_vma target_value;
  63
  64   /* This way we could mark stubs to be no longer necessary.  */
  65   bfd_boolean is_actually_needed;
  66 };
  67
  68 struct elf32_avr_link_hash_table
  69 {
  70   /* The main hash table.  */
  71   struct elf_link_hash_table etab;
  72
  73   /* The stub hash table.  */
  74   struct bfd_hash_table bstab;
  75
  76   bfd_boolean no_stubs;
  77
  78   /* Linker stub bfd.  */
  79   bfd *stub_bfd;
  80
  81   /* The stub section.  */
  82   asection *stub_sec;
  83
  84   /* Usually 0, unless we are generating code for a bootloader.  Will
  85      be initialized by elf32_avr_size_stubs to the vma offset of the
  86      output section associated with the stub section.  */
  87   bfd_vma vector_base;
  88
  89   /* Assorted information used by elf32_avr_size_stubs.  */
  90   unsigned int        bfd_count;
  91   int                 top_index;
  92   asection **         input_list;
  93   Elf_Internal_Sym ** all_local_syms;
  94
  95   /* Tables for mapping vma beyond the 128k boundary to the address of the
  96      corresponding stub.  (AMT)
  97      "amt_max_entry_cnt" reflects the number of entries that memory is allocated
  98      for in the "amt_stub_offsets" and "amt_destination_addr" arrays.
  99      "amt_entry_cnt" informs how many of these entries actually contain
 100      useful data.  */
 101   unsigned int amt_entry_cnt;
 102   unsigned int amt_max_entry_cnt;
 103   bfd_vma *    amt_stub_offsets;
 104   bfd_vma *    amt_destination_addr;
 105 };
 106
 107 /* Various hash macros and functions.  */
 108 #define avr_link_hash_table(p) \
 109   /* PR 3874: Check that we have an AVR style hash table before using it.  */\
 110   (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
 111   == AVR_ELF_DATA ? ((struct elf32_avr_link_hash_table *) ((p)->hash)) : NULL)
 112
 113 #define avr_stub_hash_entry(ent) \
 114   ((struct elf32_avr_stub_hash_entry *)(ent))
 115
 116 #define avr_stub_hash_lookup(table, string, create, copy) \
 117   ((struct elf32_avr_stub_hash_entry *) \
 118    bfd_hash_lookup ((table), (string), (create), (copy)))
 119
 120 static reloc_howto_type elf_avr_howto_table[] =
 121 {
 122   HOWTO (R_AVR_NONE,            /* type */
 123          0,                     /* rightshift */
 124          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 125          32,                    /* bitsize */
 126          FALSE,                 /* pc_relative */
 127          0,                     /* bitpos */
 128          complain_overflow_bitfield, /* complain_on_overflow */
 129          bfd_elf_generic_reloc, /* special_function */
 130          "R_AVR_NONE",          /* name */
 131          FALSE,                 /* partial_inplace */
 132          0,                     /* src_mask */
 133          0,                     /* dst_mask */
 134          FALSE),                /* pcrel_offset */
 135
 136   HOWTO (R_AVR_32,              /* type */
 137          0,                     /* rightshift */
 138          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 139          32,                    /* bitsize */
 140          FALSE,                 /* pc_relative */
 141          0,                     /* bitpos */
 142          complain_overflow_bitfield, /* complain_on_overflow */
 143          bfd_elf_generic_reloc, /* special_function */
 144          "R_AVR_32",            /* name */
 145          FALSE,                 /* partial_inplace */
 146          0xffffffff,            /* src_mask */
 147          0xffffffff,            /* dst_mask */
 148          FALSE),                /* pcrel_offset */
 149
 150   /* A 7 bit PC relative relocation.  */
 151   HOWTO (R_AVR_7_PCREL,         /* type */
 152          1,                     /* rightshift */
 153          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 154          7,                     /* bitsize */
 155          TRUE,                  /* pc_relative */
 156          3,                     /* bitpos */
 157          complain_overflow_bitfield, /* complain_on_overflow */
 158          bfd_elf_generic_reloc, /* special_function */
 159          "R_AVR_7_PCREL",       /* name */
 160          FALSE,                 /* partial_inplace */
 161          0xffff,                /* src_mask */
 162          0xffff,                /* dst_mask */
 163          TRUE),                 /* pcrel_offset */
 164
 165   /* A 13 bit PC relative relocation.  */
 166   HOWTO (R_AVR_13_PCREL,        /* type */
 167          1,                     /* rightshift */
 168          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 169          13,                    /* bitsize */
 170          TRUE,                  /* pc_relative */
 171          0,                     /* bitpos */
 172          complain_overflow_bitfield, /* complain_on_overflow */
 173          bfd_elf_generic_reloc, /* special_function */
 174          "R_AVR_13_PCREL",      /* name */
 175          FALSE,                 /* partial_inplace */
 176          0xfff,                 /* src_mask */
 177          0xfff,                 /* dst_mask */
 178          TRUE),                 /* pcrel_offset */
 179
 180   /* A 16 bit absolute relocation.  */
 181   HOWTO (R_AVR_16,              /* type */
 182          0,                     /* rightshift */
 183          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 184          16,                    /* bitsize */
 185          FALSE,                 /* pc_relative */
 186          0,                     /* bitpos */
 187          complain_overflow_dont, /* complain_on_overflow */
 188          bfd_elf_generic_reloc, /* special_function */
 189          "R_AVR_16",            /* name */
 190          FALSE,                 /* partial_inplace */
 191          0xffff,                /* src_mask */
 192          0xffff,                /* dst_mask */
 193          FALSE),                /* pcrel_offset */
 194
 195   /* A 16 bit absolute relocation for command address
 196      Will be changed when linker stubs are needed.  */
 197   HOWTO (R_AVR_16_PM,           /* type */
 198          1,                     /* rightshift */
 199          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 200          16,                    /* bitsize */
 201          FALSE,                 /* pc_relative */
 202          0,                     /* bitpos */
 203          complain_overflow_bitfield, /* complain_on_overflow */
 204          bfd_elf_generic_reloc, /* special_function */
 205          "R_AVR_16_PM",         /* name */
 206          FALSE,                 /* partial_inplace */
 207          0xffff,                /* src_mask */
 208          0xffff,                /* dst_mask */
 209          FALSE),                /* pcrel_offset */
 210   /* A low 8 bit absolute relocation of 16 bit address.
 211      For LDI command.  */
 212   HOWTO (R_AVR_LO8_LDI,         /* type */
 213          0,                     /* rightshift */
 214          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 215          8,                     /* bitsize */
 216          FALSE,                 /* pc_relative */
 217          0,                     /* bitpos */
 218          complain_overflow_dont, /* complain_on_overflow */
 219          bfd_elf_generic_reloc, /* special_function */
 220          "R_AVR_LO8_LDI",       /* name */
 221          FALSE,                 /* partial_inplace */
 222          0xffff,                /* src_mask */
 223          0xffff,                /* dst_mask */
 224          FALSE),                /* pcrel_offset */
 225   /* A high 8 bit absolute relocation of 16 bit address.
 226      For LDI command.  */
 227   HOWTO (R_AVR_HI8_LDI,         /* type */
 228          8,                     /* rightshift */
 229          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 230          8,                     /* bitsize */
 231          FALSE,                 /* pc_relative */
 232          0,                     /* bitpos */
 233          complain_overflow_dont, /* complain_on_overflow */
 234          bfd_elf_generic_reloc, /* special_function */
 235          "R_AVR_HI8_LDI",       /* name */
 236          FALSE,                 /* partial_inplace */
 237          0xffff,                /* src_mask */
 238          0xffff,                /* dst_mask */
 239          FALSE),                /* pcrel_offset */
 240   /* A high 6 bit absolute relocation of 22 bit address.
 241      For LDI command.  As well second most significant 8 bit value of
 242      a 32 bit link-time constant.  */
 243   HOWTO (R_AVR_HH8_LDI,         /* type */
 244          16,                    /* rightshift */
 245          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 246          8,                     /* bitsize */
 247          FALSE,                 /* pc_relative */
 248          0,                     /* bitpos */
 249          complain_overflow_dont, /* complain_on_overflow */
 250          bfd_elf_generic_reloc, /* special_function */
 251          "R_AVR_HH8_LDI",       /* name */
 252          FALSE,                 /* partial_inplace */
 253          0xffff,                /* src_mask */
 254          0xffff,                /* dst_mask */
 255          FALSE),                /* pcrel_offset */
 256   /* A negative low 8 bit absolute relocation of 16 bit address.
 257      For LDI command.  */
 258   HOWTO (R_AVR_LO8_LDI_NEG,     /* type */
 259          0,                     /* rightshift */
 260          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 261          8,                     /* bitsize */
 262          FALSE,                 /* pc_relative */
 263          0,                     /* bitpos */
 264          complain_overflow_dont, /* complain_on_overflow */
 265          bfd_elf_generic_reloc, /* special_function */
 266          "R_AVR_LO8_LDI_NEG",   /* name */
 267          FALSE,                 /* partial_inplace */
 268          0xffff,                /* src_mask */
 269          0xffff,                /* dst_mask */
 270          FALSE),                /* pcrel_offset */
 271   /* A negative high 8 bit absolute relocation of 16 bit address.
 272      For LDI command.  */
 273   HOWTO (R_AVR_HI8_LDI_NEG,     /* type */
 274          8,                     /* rightshift */
 275          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 276          8,                     /* bitsize */
 277          FALSE,                 /* pc_relative */
 278          0,                     /* bitpos */
 279          complain_overflow_dont, /* complain_on_overflow */
 280          bfd_elf_generic_reloc, /* special_function */
 281          "R_AVR_HI8_LDI_NEG",   /* name */
 282          FALSE,                 /* partial_inplace */
 283          0xffff,                /* src_mask */
 284          0xffff,                /* dst_mask */
 285          FALSE),                /* pcrel_offset */
 286   /* A negative high 6 bit absolute relocation of 22 bit address.
 287      For LDI command.  */
 288   HOWTO (R_AVR_HH8_LDI_NEG,     /* type */
 289          16,                    /* rightshift */
 290          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 291          8,                     /* bitsize */
 292          FALSE,                 /* pc_relative */
 293          0,                     /* bitpos */
 294          complain_overflow_dont, /* complain_on_overflow */
 295          bfd_elf_generic_reloc, /* special_function */
 296          "R_AVR_HH8_LDI_NEG",   /* name */
 297          FALSE,                 /* partial_inplace */
 298          0xffff,                /* src_mask */
 299          0xffff,                /* dst_mask */
 300          FALSE),                /* pcrel_offset */
 301   /* A low 8 bit absolute relocation of 24 bit program memory address.
 302      For LDI command.  Will not be changed when linker stubs are needed. */
 303   HOWTO (R_AVR_LO8_LDI_PM,      /* type */
 304          1,                     /* rightshift */
 305          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 306          8,                     /* bitsize */
 307          FALSE,                 /* pc_relative */
 308          0,                     /* bitpos */
 309          complain_overflow_dont, /* complain_on_overflow */
 310          bfd_elf_generic_reloc, /* special_function */
 311          "R_AVR_LO8_LDI_PM",    /* name */
 312          FALSE,                 /* partial_inplace */
 313          0xffff,                /* src_mask */
 314          0xffff,                /* dst_mask */
 315          FALSE),                /* pcrel_offset */
 316   /* A low 8 bit absolute relocation of 24 bit program memory address.
 317      For LDI command.  Will not be changed when linker stubs are needed. */
 318   HOWTO (R_AVR_HI8_LDI_PM,      /* type */
 319          9,                     /* rightshift */
 320          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 321          8,                     /* bitsize */
 322          FALSE,                 /* pc_relative */
 323          0,                     /* bitpos */
 324          complain_overflow_dont, /* complain_on_overflow */
 325          bfd_elf_generic_reloc, /* special_function */
 326          "R_AVR_HI8_LDI_PM",    /* name */
 327          FALSE,                 /* partial_inplace */
 328          0xffff,                /* src_mask */
 329          0xffff,                /* dst_mask */
 330          FALSE),                /* pcrel_offset */
 331   /* A low 8 bit absolute relocation of 24 bit program memory address.
 332      For LDI command.  Will not be changed when linker stubs are needed. */
 333   HOWTO (R_AVR_HH8_LDI_PM,      /* type */
 334          17,                    /* rightshift */
 335          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 336          8,                     /* bitsize */
 337          FALSE,                 /* pc_relative */
 338          0,                     /* bitpos */
 339          complain_overflow_dont, /* complain_on_overflow */
 340          bfd_elf_generic_reloc, /* special_function */
 341          "R_AVR_HH8_LDI_PM",    /* name */
 342          FALSE,                 /* partial_inplace */
 343          0xffff,                /* src_mask */
 344          0xffff,                /* dst_mask */
 345          FALSE),                /* pcrel_offset */
 346   /* A low 8 bit absolute relocation of 24 bit program memory address.
 347      For LDI command.  Will not be changed when linker stubs are needed. */
 348   HOWTO (R_AVR_LO8_LDI_PM_NEG,  /* type */
 349          1,                     /* rightshift */
 350          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 351          8,                     /* bitsize */
 352          FALSE,                 /* pc_relative */
 353          0,                     /* bitpos */
 354          complain_overflow_dont, /* complain_on_overflow */
 355          bfd_elf_generic_reloc, /* special_function */
 356          "R_AVR_LO8_LDI_PM_NEG", /* name */
 357          FALSE,                 /* partial_inplace */
 358          0xffff,                /* src_mask */
 359          0xffff,                /* dst_mask */
 360          FALSE),                /* pcrel_offset */
 361   /* A low 8 bit absolute relocation of 24 bit program memory address.
 362      For LDI command.  Will not be changed when linker stubs are needed. */
 363   HOWTO (R_AVR_HI8_LDI_PM_NEG,  /* type */
 364          9,                     /* rightshift */
 365          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 366          8,                     /* bitsize */
 367          FALSE,                 /* pc_relative */
 368          0,                     /* bitpos */
 369          complain_overflow_dont, /* complain_on_overflow */
 370          bfd_elf_generic_reloc, /* special_function */
 371          "R_AVR_HI8_LDI_PM_NEG", /* name */
 372          FALSE,                 /* partial_inplace */
 373          0xffff,                /* src_mask */
 374          0xffff,                /* dst_mask */
 375          FALSE),                /* pcrel_offset */
 376   /* A low 8 bit absolute relocation of 24 bit program memory address.
 377      For LDI command.  Will not be changed when linker stubs are needed. */
 378   HOWTO (R_AVR_HH8_LDI_PM_NEG,  /* type */
 379          17,                    /* rightshift */
 380          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 381          8,                     /* bitsize */
 382          FALSE,                 /* pc_relative */
 383          0,                     /* bitpos */
 384          complain_overflow_dont, /* complain_on_overflow */
 385          bfd_elf_generic_reloc, /* special_function */
 386          "R_AVR_HH8_LDI_PM_NEG", /* name */
 387          FALSE,                 /* partial_inplace */
 388          0xffff,                /* src_mask */
 389          0xffff,                /* dst_mask */
 390          FALSE),                /* pcrel_offset */
 391   /* Relocation for CALL command in ATmega.  */
 392   HOWTO (R_AVR_CALL,            /* type */
 393          1,                     /* rightshift */
 394          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 395          23,                    /* bitsize */
 396          FALSE,                 /* pc_relative */
 397          0,                     /* bitpos */
 398          complain_overflow_dont,/* complain_on_overflow */
 399          bfd_elf_generic_reloc, /* special_function */
 400          "R_AVR_CALL",          /* name */
 401          FALSE,                 /* partial_inplace */
 402          0xffffffff,            /* src_mask */
 403          0xffffffff,            /* dst_mask */
 404          FALSE),                        /* pcrel_offset */
 405   /* A 16 bit absolute relocation of 16 bit address.
 406      For LDI command.  */
 407   HOWTO (R_AVR_LDI,             /* type */
 408          0,                     /* rightshift */
 409          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 410          16,                    /* bitsize */
 411          FALSE,                 /* pc_relative */
 412          0,                     /* bitpos */
 413          complain_overflow_dont,/* complain_on_overflow */
 414          bfd_elf_generic_reloc, /* special_function */
 415          "R_AVR_LDI",           /* name */
 416          FALSE,                 /* partial_inplace */
 417          0xffff,                /* src_mask */
 418          0xffff,                /* dst_mask */
 419          FALSE),                /* pcrel_offset */
 420   /* A 6 bit absolute relocation of 6 bit offset.
 421      For ldd/sdd command.  */
 422   HOWTO (R_AVR_6,               /* type */
 423          0,                     /* rightshift */
 424          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 425          6,                     /* bitsize */
 426          FALSE,                 /* pc_relative */
 427          0,                     /* bitpos */
 428          complain_overflow_dont,/* complain_on_overflow */
 429          bfd_elf_generic_reloc, /* special_function */
 430          "R_AVR_6",             /* name */
 431          FALSE,                 /* partial_inplace */
 432          0xffff,                /* src_mask */
 433          0xffff,                /* dst_mask */
 434          FALSE),                /* pcrel_offset */
 435   /* A 6 bit absolute relocation of 6 bit offset.
 436      For sbiw/adiw command.  */
 437   HOWTO (R_AVR_6_ADIW,          /* type */
 438          0,                     /* rightshift */
 439          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 440          6,                     /* bitsize */
 441          FALSE,                 /* pc_relative */
 442          0,                     /* bitpos */
 443          complain_overflow_dont,/* complain_on_overflow */
 444          bfd_elf_generic_reloc, /* special_function */
 445          "R_AVR_6_ADIW",        /* name */
 446          FALSE,                 /* partial_inplace */
 447          0xffff,                /* src_mask */
 448          0xffff,                /* dst_mask */
 449          FALSE),                /* pcrel_offset */
 450   /* Most significant 8 bit value of a 32 bit link-time constant.  */
 451   HOWTO (R_AVR_MS8_LDI,         /* type */
 452          24,                    /* rightshift */
 453          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 454          8,                     /* bitsize */
 455          FALSE,                 /* pc_relative */
 456          0,                     /* bitpos */
 457          complain_overflow_dont, /* complain_on_overflow */
 458          bfd_elf_generic_reloc, /* special_function */
 459          "R_AVR_MS8_LDI",       /* name */
 460          FALSE,                 /* partial_inplace */
 461          0xffff,                /* src_mask */
 462          0xffff,                /* dst_mask */
 463          FALSE),                /* pcrel_offset */
 464   /* Negative most significant 8 bit value of a 32 bit link-time constant.  */
 465   HOWTO (R_AVR_MS8_LDI_NEG,     /* type */
 466          24,                    /* rightshift */
 467          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 468          8,                     /* bitsize */
 469          FALSE,                 /* pc_relative */
 470          0,                     /* bitpos */
 471          complain_overflow_dont, /* complain_on_overflow */
 472          bfd_elf_generic_reloc, /* special_function */
 473          "R_AVR_MS8_LDI_NEG",   /* name */
 474          FALSE,                 /* partial_inplace */
 475          0xffff,                /* src_mask */
 476          0xffff,                /* dst_mask */
 477          FALSE),                /* pcrel_offset */
 478   /* A low 8 bit absolute relocation of 24 bit program memory address.
 479      For LDI command.  Will be changed when linker stubs are needed.  */
 480   HOWTO (R_AVR_LO8_LDI_GS,      /* type */
 481          1,                     /* rightshift */
 482          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 483          8,                     /* bitsize */
 484          FALSE,                 /* pc_relative */
 485          0,                     /* bitpos */
 486          complain_overflow_dont, /* complain_on_overflow */
 487          bfd_elf_generic_reloc, /* special_function */
 488          "R_AVR_LO8_LDI_GS",    /* name */
 489          FALSE,                 /* partial_inplace */
 490          0xffff,                /* src_mask */
 491          0xffff,                /* dst_mask */
 492          FALSE),                /* pcrel_offset */
 493   /* A low 8 bit absolute relocation of 24 bit program memory address.
 494      For LDI command.  Will be changed when linker stubs are needed.  */
 495   HOWTO (R_AVR_HI8_LDI_GS,      /* type */
 496          9,                     /* rightshift */
 497          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 498          8,                     /* bitsize */
 499          FALSE,                 /* pc_relative */
 500          0,                     /* bitpos */
 501          complain_overflow_dont, /* complain_on_overflow */
 502          bfd_elf_generic_reloc, /* special_function */
 503          "R_AVR_HI8_LDI_GS",    /* name */
 504          FALSE,                 /* partial_inplace */
 505          0xffff,                /* src_mask */
 506          0xffff,                /* dst_mask */
 507          FALSE),                /* pcrel_offset */
 508   /* 8 bit offset.  */
 509   HOWTO (R_AVR_8,               /* type */
 510          0,                     /* rightshift */
 511          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 512          8,                     /* bitsize */
 513          FALSE,                 /* pc_relative */
 514          0,                     /* bitpos */
 515          complain_overflow_bitfield,/* complain_on_overflow */
 516          bfd_elf_generic_reloc, /* special_function */
 517          "R_AVR_8",             /* name */
 518          FALSE,                 /* partial_inplace */
 519          0x000000ff,            /* src_mask */
 520          0x000000ff,            /* dst_mask */
 521          FALSE),                /* pcrel_offset */
 522   /* lo8-part to use in  .byte lo8(sym).  */
 523   HOWTO (R_AVR_8_LO8,           /* type */
 524          0,                     /* rightshift */
 525          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 526          8,                     /* bitsize */
 527          FALSE,                 /* pc_relative */
 528          0,                     /* bitpos */
 529          complain_overflow_dont,/* complain_on_overflow */
 530          bfd_elf_generic_reloc, /* special_function */
 531          "R_AVR_8_LO8",         /* name */
 532          FALSE,                 /* partial_inplace */
 533          0xffffff,              /* src_mask */
 534          0xffffff,              /* dst_mask */
 535          FALSE),                /* pcrel_offset */
 536   /* hi8-part to use in  .byte hi8(sym).  */
 537   HOWTO (R_AVR_8_HI8,           /* type */
 538          8,                     /* rightshift */
 539          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 540          8,                     /* bitsize */
 541          FALSE,                 /* pc_relative */
 542          0,                     /* bitpos */
 543          complain_overflow_dont,/* complain_on_overflow */
 544          bfd_elf_generic_reloc, /* special_function */
 545          "R_AVR_8_HI8",         /* name */
 546          FALSE,                 /* partial_inplace */
 547          0xffffff,              /* src_mask */
 548          0xffffff,              /* dst_mask */
 549          FALSE),                /* pcrel_offset */
 550   /* hlo8-part to use in  .byte hlo8(sym).  */
 551   HOWTO (R_AVR_8_HLO8,          /* type */
 552          16,                    /* rightshift */
 553          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 554          8,                     /* bitsize */
 555          FALSE,                 /* pc_relative */
 556          0,                     /* bitpos */
 557          complain_overflow_dont,/* complain_on_overflow */
 558          bfd_elf_generic_reloc, /* special_function */
 559          "R_AVR_8_HLO8",        /* name */
 560          FALSE,                 /* partial_inplace */
 561          0xffffff,              /* src_mask */
 562          0xffffff,              /* dst_mask */
 563          FALSE),                /* pcrel_offset */
 564   HOWTO (R_AVR_DIFF8,           /* type */
 565          0,                     /* rightshift */
 566          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 567          8,                     /* bitsize */
 568          FALSE,                 /* pc_relative */
 569          0,                     /* bitpos */
 570          complain_overflow_bitfield, /* complain_on_overflow */
 571          bfd_elf_avr_diff_reloc, /* special_function */
 572          "R_AVR_DIFF8",         /* name */
 573          FALSE,                 /* partial_inplace */
 574          0,                     /* src_mask */
 575          0xff,                  /* dst_mask */
 576          FALSE),                /* pcrel_offset */
 577   HOWTO (R_AVR_DIFF16,          /* type */
 578          0,                     /* rightshift */
 579          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 580          16,                    /* bitsize */
 581          FALSE,                 /* pc_relative */
 582          0,                     /* bitpos */
 583          complain_overflow_bitfield, /* complain_on_overflow */
 584          bfd_elf_avr_diff_reloc,/* special_function */
 585          "R_AVR_DIFF16",        /* name */
 586          FALSE,                 /* partial_inplace */
 587          0,                     /* src_mask */
 588          0xffff,                /* dst_mask */
 589          FALSE),                /* pcrel_offset */
 590   HOWTO (R_AVR_DIFF32,          /* type */
 591          0,                     /* rightshift */
 592          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 593          32,                    /* bitsize */
 594          FALSE,                 /* pc_relative */
 595          0,                     /* bitpos */
 596          complain_overflow_bitfield, /* complain_on_overflow */
 597          bfd_elf_avr_diff_reloc,/* special_function */
 598          "R_AVR_DIFF32",        /* name */
 599          FALSE,                 /* partial_inplace */
 600          0,                     /* src_mask */
 601          0xffffffff,            /* dst_mask */
 602          FALSE),                /* pcrel_offset */
 603   /* 7 bit immediate for LDS/STS in Tiny core.  */
 604   HOWTO (R_AVR_LDS_STS_16,  /* type */
 605          0,                     /* rightshift */
 606          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 607          7,                     /* bitsize */
 608          FALSE,                 /* pc_relative */
 609          0,                     /* bitpos */
 610          complain_overflow_dont,/* complain_on_overflow */
 611          bfd_elf_generic_reloc, /* special_function */
 612          "R_AVR_LDS_STS_16",    /* name */
 613          FALSE,                 /* partial_inplace */
 614          0xffff,                /* src_mask */
 615          0xffff,                /* dst_mask */
 616          FALSE),                /* pcrel_offset */
 617
 618   HOWTO (R_AVR_PORT6,           /* type */
 619          0,                     /* rightshift */
 620          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 621          6,                     /* bitsize */
 622          FALSE,                 /* pc_relative */
 623          0,                     /* bitpos */
 624          complain_overflow_dont,/* complain_on_overflow */
 625          bfd_elf_generic_reloc, /* special_function */
 626          "R_AVR_PORT6",         /* name */
 627          FALSE,                 /* partial_inplace */
 628          0xffffff,              /* src_mask */
 629          0xffffff,              /* dst_mask */
 630          FALSE),                /* pcrel_offset */
 631   HOWTO (R_AVR_PORT5,           /* type */
 632          0,                     /* rightshift */
 633          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 634          5,                     /* bitsize */
 635          FALSE,                 /* pc_relative */
 636          0,                     /* bitpos */
 637          complain_overflow_dont,/* complain_on_overflow */
 638          bfd_elf_generic_reloc, /* special_function */
 639          "R_AVR_PORT5",         /* name */
 640          FALSE,                 /* partial_inplace */
 641          0xffffff,              /* src_mask */
 642          0xffffff,              /* dst_mask */
 643          FALSE)                 /* pcrel_offset */
 644 };
 645
 646 /* Map BFD reloc types to AVR ELF reloc types.  */
 647
 648 struct avr_reloc_map
 649 {
 650   bfd_reloc_code_real_type bfd_reloc_val;
 651   unsigned int elf_reloc_val;
 652 };
 653
 654 static const struct avr_reloc_map avr_reloc_map[] =
 655 {
 656   { BFD_RELOC_NONE,                 R_AVR_NONE },
 657   { BFD_RELOC_32,                   R_AVR_32 },
 658   { BFD_RELOC_AVR_7_PCREL,          R_AVR_7_PCREL },
 659   { BFD_RELOC_AVR_13_PCREL,         R_AVR_13_PCREL },
 660   { BFD_RELOC_16,                   R_AVR_16 },
 661   { BFD_RELOC_AVR_16_PM,            R_AVR_16_PM },
 662   { BFD_RELOC_AVR_LO8_LDI,          R_AVR_LO8_LDI},
 663   { BFD_RELOC_AVR_HI8_LDI,          R_AVR_HI8_LDI },
 664   { BFD_RELOC_AVR_HH8_LDI,          R_AVR_HH8_LDI },
 665   { BFD_RELOC_AVR_MS8_LDI,          R_AVR_MS8_LDI },
 666   { BFD_RELOC_AVR_LO8_LDI_NEG,      R_AVR_LO8_LDI_NEG },
 667   { BFD_RELOC_AVR_HI8_LDI_NEG,      R_AVR_HI8_LDI_NEG },
 668   { BFD_RELOC_AVR_HH8_LDI_NEG,      R_AVR_HH8_LDI_NEG },
 669   { BFD_RELOC_AVR_MS8_LDI_NEG,      R_AVR_MS8_LDI_NEG },
 670   { BFD_RELOC_AVR_LO8_LDI_PM,       R_AVR_LO8_LDI_PM },
 671   { BFD_RELOC_AVR_LO8_LDI_GS,       R_AVR_LO8_LDI_GS },
 672   { BFD_RELOC_AVR_HI8_LDI_PM,       R_AVR_HI8_LDI_PM },
 673   { BFD_RELOC_AVR_HI8_LDI_GS,       R_AVR_HI8_LDI_GS },
 674   { BFD_RELOC_AVR_HH8_LDI_PM,       R_AVR_HH8_LDI_PM },
 675   { BFD_RELOC_AVR_LO8_LDI_PM_NEG,   R_AVR_LO8_LDI_PM_NEG },
 676   { BFD_RELOC_AVR_HI8_LDI_PM_NEG,   R_AVR_HI8_LDI_PM_NEG },
 677   { BFD_RELOC_AVR_HH8_LDI_PM_NEG,   R_AVR_HH8_LDI_PM_NEG },
 678   { BFD_RELOC_AVR_CALL,             R_AVR_CALL },
 679   { BFD_RELOC_AVR_LDI,              R_AVR_LDI  },
 680   { BFD_RELOC_AVR_6,                R_AVR_6    },
 681   { BFD_RELOC_AVR_6_ADIW,           R_AVR_6_ADIW },
 682   { BFD_RELOC_8,                    R_AVR_8 },
 683   { BFD_RELOC_AVR_8_LO,             R_AVR_8_LO8 },
 684   { BFD_RELOC_AVR_8_HI,             R_AVR_8_HI8 },
 685   { BFD_RELOC_AVR_8_HLO,            R_AVR_8_HLO8 },
 686   { BFD_RELOC_AVR_DIFF8,            R_AVR_DIFF8 },
 687   { BFD_RELOC_AVR_DIFF16,           R_AVR_DIFF16 },
 688   { BFD_RELOC_AVR_DIFF32,           R_AVR_DIFF32 },
 689   { BFD_RELOC_AVR_LDS_STS_16,       R_AVR_LDS_STS_16},
 690   { BFD_RELOC_AVR_PORT6,            R_AVR_PORT6},
 691   { BFD_RELOC_AVR_PORT5,            R_AVR_PORT5}
 692 };
 693
 694 /* Meant to be filled one day with the wrap around address for the
 695    specific device.  I.e. should get the value 0x4000 for 16k devices,
 696    0x8000 for 32k devices and so on.
 697
 698    We initialize it here with a value of 0x1000000 resulting in
 699    that we will never suggest a wrap-around jump during relaxation.
 700    The logic of the source code later on assumes that in
 701    avr_pc_wrap_around one single bit is set.  */
 702 static bfd_vma avr_pc_wrap_around = 0x10000000;
 703
 704 /* If this variable holds a value different from zero, the linker relaxation
 705    machine will try to optimize call/ret sequences by a single jump
 706    instruction. This option could be switched off by a linker switch.  */
 707 static int avr_replace_call_ret_sequences = 1;
 708 \f
 709 /* Initialize an entry in the stub hash table.  */
 710
 711 static struct bfd_hash_entry *
 712 stub_hash_newfunc (struct bfd_hash_entry *entry,
 713                    struct bfd_hash_table *table,
 714                    const char *string)
 715 {
 716   /* Allocate the structure if it has not already been allocated by a
 717      subclass.  */
 718   if (entry == NULL)
 719     {
 720       entry = bfd_hash_allocate (table,
 721                                  sizeof (struct elf32_avr_stub_hash_entry));
 722       if (entry == NULL)
 723         return entry;
 724     }
 725
 726   /* Call the allocation method of the superclass.  */
 727   entry = bfd_hash_newfunc (entry, table, string);
 728   if (entry != NULL)
 729     {
 730       struct elf32_avr_stub_hash_entry *hsh;
 731
 732       /* Initialize the local fields.  */
 733       hsh = avr_stub_hash_entry (entry);
 734       hsh->stub_offset = 0;
 735       hsh->target_value = 0;
 736     }
 737
 738   return entry;
 739 }
 740
 741 /* This function is just a straight passthrough to the real
 742    function in linker.c.  Its prupose is so that its address
 743    can be compared inside the avr_link_hash_table macro.  */
 744
 745 static struct bfd_hash_entry *
 746 elf32_avr_link_hash_newfunc (struct bfd_hash_entry * entry,
 747                              struct bfd_hash_table * table,
 748                              const char * string)
 749 {
 750   return _bfd_elf_link_hash_newfunc (entry, table, string);
 751 }
 752
 753 /* Free the derived linker hash table.  */
 754
 755 static void
 756 elf32_avr_link_hash_table_free (bfd *obfd)
 757 {
 758   struct elf32_avr_link_hash_table *htab
 759     = (struct elf32_avr_link_hash_table *) obfd->link.hash;
 760
 761   /* Free the address mapping table.  */
 762   if (htab->amt_stub_offsets != NULL)
 763     free (htab->amt_stub_offsets);
 764   if (htab->amt_destination_addr != NULL)
 765     free (htab->amt_destination_addr);
 766
 767   bfd_hash_table_free (&htab->bstab);
 768   _bfd_elf_link_hash_table_free (obfd);
 769 }
 770
 771 /* Create the derived linker hash table.  The AVR ELF port uses the derived
 772    hash table to keep information specific to the AVR ELF linker (without
 773    using static variables).  */
 774
 775 static struct bfd_link_hash_table *
 776 elf32_avr_link_hash_table_create (bfd *abfd)
 777 {
 778   struct elf32_avr_link_hash_table *htab;
 779   bfd_size_type amt = sizeof (*htab);
 780
 781   htab = bfd_zmalloc (amt);
 782   if (htab == NULL)
 783     return NULL;
 784
 785   if (!_bfd_elf_link_hash_table_init (&htab->etab, abfd,
 786                                       elf32_avr_link_hash_newfunc,
 787                                       sizeof (struct elf_link_hash_entry),
 788                                       AVR_ELF_DATA))
 789     {
 790       free (htab);
 791       return NULL;
 792     }
 793
 794   /* Init the stub hash table too.  */
 795   if (!bfd_hash_table_init (&htab->bstab, stub_hash_newfunc,
 796                             sizeof (struct elf32_avr_stub_hash_entry)))
 797     {
 798       _bfd_elf_link_hash_table_free (abfd);
 799       return NULL;
 800     }
 801   htab->etab.root.hash_table_free = elf32_avr_link_hash_table_free;
 802
 803   return &htab->etab.root;
 804 }
 805
 806 /* Calculates the effective distance of a pc relative jump/call.  */
 807
 808 static int
 809 avr_relative_distance_considering_wrap_around (unsigned int distance)
 810 {
 811   unsigned int wrap_around_mask = avr_pc_wrap_around - 1;
 812   int dist_with_wrap_around = distance & wrap_around_mask;
 813
 814   if (dist_with_wrap_around > ((int) (avr_pc_wrap_around >> 1)))
 815     dist_with_wrap_around -= avr_pc_wrap_around;
 816
 817   return dist_with_wrap_around;
 818 }
 819
 820
 821 static reloc_howto_type *
 822 bfd_elf32_bfd_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
 823                                  bfd_reloc_code_real_type code)
 824 {
 825   unsigned int i;
 826
 827   for (i = 0;
 828        i < sizeof (avr_reloc_map) / sizeof (struct avr_reloc_map);
 829        i++)
 830     if (avr_reloc_map[i].bfd_reloc_val == code)
 831       return &elf_avr_howto_table[avr_reloc_map[i].elf_reloc_val];
 832
 833   return NULL;
 834 }
 835
 836 static reloc_howto_type *
 837 bfd_elf32_bfd_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
 838                                  const char *r_name)
 839 {
 840   unsigned int i;
 841
 842   for (i = 0;
 843        i < sizeof (elf_avr_howto_table) / sizeof (elf_avr_howto_table[0]);
 844        i++)
 845     if (elf_avr_howto_table[i].name != NULL
 846         && strcasecmp (elf_avr_howto_table[i].name, r_name) == 0)
 847       return &elf_avr_howto_table[i];
 848
 849   return NULL;
 850 }
 851
 852 /* Set the howto pointer for an AVR ELF reloc.  */
 853
 854 static void
 855 avr_info_to_howto_rela (bfd *abfd ATTRIBUTE_UNUSED,
 856                         arelent *cache_ptr,
 857                         Elf_Internal_Rela *dst)
 858 {
 859   unsigned int r_type;
 860
 861   r_type = ELF32_R_TYPE (dst->r_info);
 862   BFD_ASSERT (r_type < (unsigned int) R_AVR_max);
 863   cache_ptr->howto = &elf_avr_howto_table[r_type];
 864 }
 865
 866 static bfd_boolean
 867 avr_stub_is_required_for_16_bit_reloc (bfd_vma relocation)
 868 {
 869   return (relocation >= 0x020000);
 870 }
 871
 872 /* Returns the address of the corresponding stub if there is one.
 873    Returns otherwise an address above 0x020000.  This function
 874    could also be used, if there is no knowledge on the section where
 875    the destination is found.  */
 876
 877 static bfd_vma
 878 avr_get_stub_addr (bfd_vma srel,
 879                    struct elf32_avr_link_hash_table *htab)
 880 {
 881   unsigned int sindex;
 882   bfd_vma stub_sec_addr =
 883               (htab->stub_sec->output_section->vma +
 884                htab->stub_sec->output_offset);
 885
 886   for (sindex = 0; sindex < htab->amt_max_entry_cnt; sindex ++)
 887     if (htab->amt_destination_addr[sindex] == srel)
 888       return htab->amt_stub_offsets[sindex] + stub_sec_addr;
 889
 890   /* Return an address that could not be reached by 16 bit relocs.  */
 891   return 0x020000;
 892 }
 893
 894 /* Perform a diff relocation. Nothing to do, as the difference value is already
 895    written into the section's contents. */
 896
 897 static bfd_reloc_status_type
 898 bfd_elf_avr_diff_reloc (bfd *abfd ATTRIBUTE_UNUSED,
 899                       arelent *reloc_entry ATTRIBUTE_UNUSED,
 900               asymbol *symbol ATTRIBUTE_UNUSED,
 901               void *data ATTRIBUTE_UNUSED,
 902               asection *input_section ATTRIBUTE_UNUSED,
 903               bfd *output_bfd ATTRIBUTE_UNUSED,
 904               char **error_message ATTRIBUTE_UNUSED)
 905 {
 906   return bfd_reloc_ok;
 907 }
 908
 909
 910 /* Perform a single relocation.  By default we use the standard BFD
 911    routines, but a few relocs, we have to do them ourselves.  */
 912
 913 static bfd_reloc_status_type
 914 avr_final_link_relocate (reloc_howto_type *                 howto,
 915                          bfd *                              input_bfd,
 916                          asection *                         input_section,
 917                          bfd_byte *                         contents,
 918                          Elf_Internal_Rela *                rel,
 919                          bfd_vma                            relocation,
 920                          struct elf32_avr_link_hash_table * htab)
 921 {
 922   bfd_reloc_status_type r = bfd_reloc_ok;
 923   bfd_vma               x;
 924   bfd_signed_vma        srel;
 925   bfd_signed_vma        reloc_addr;
 926   bfd_boolean           use_stubs = FALSE;
 927   /* Usually is 0, unless we are generating code for a bootloader.  */
 928   bfd_signed_vma        base_addr = htab->vector_base;
 929
 930   /* Absolute addr of the reloc in the final excecutable.  */
 931   reloc_addr = rel->r_offset + input_section->output_section->vma
 932                + input_section->output_offset;
 933
 934   switch (howto->type)
 935     {
 936     case R_AVR_7_PCREL:
 937       contents += rel->r_offset;
 938       srel = (bfd_signed_vma) relocation;
 939       srel += rel->r_addend;
 940       srel -= rel->r_offset;
 941       srel -= 2;        /* Branch instructions add 2 to the PC...  */
 942       srel -= (input_section->output_section->vma +
 943                input_section->output_offset);
 944
 945       if (srel & 1)
 946         return bfd_reloc_outofrange;
 947       if (srel > ((1 << 7) - 1) || (srel < - (1 << 7)))
 948         return bfd_reloc_overflow;
 949       x = bfd_get_16 (input_bfd, contents);
 950       x = (x & 0xfc07) | (((srel >> 1) << 3) & 0x3f8);
 951       bfd_put_16 (input_bfd, x, contents);
 952       break;
 953
 954     case R_AVR_13_PCREL:
 955       contents   += rel->r_offset;
 956       srel = (bfd_signed_vma) relocation;
 957       srel += rel->r_addend;
 958       srel -= rel->r_offset;
 959       srel -= 2;        /* Branch instructions add 2 to the PC...  */
 960       srel -= (input_section->output_section->vma +
 961                input_section->output_offset);
 962
 963       if (srel & 1)
 964         return bfd_reloc_outofrange;
 965
 966       srel = avr_relative_distance_considering_wrap_around (srel);
 967
 968       /* AVR addresses commands as words.  */
 969       srel >>= 1;
 970
 971       /* Check for overflow.  */
 972       if (srel < -2048 || srel > 2047)
 973         {
 974           /* Relative distance is too large.  */
 975
 976           /* Always apply WRAPAROUND for avr2, avr25, and avr4.  */
 977           switch (bfd_get_mach (input_bfd))
 978             {
 979             case bfd_mach_avr2:
 980             case bfd_mach_avr25:
 981             case bfd_mach_avr4:
 982               break;
 983
 984             default:
 985               return bfd_reloc_overflow;
 986             }
 987         }
 988
 989       x = bfd_get_16 (input_bfd, contents);
 990       x = (x & 0xf000) | (srel & 0xfff);
 991       bfd_put_16 (input_bfd, x, contents);
 992       break;
 993
 994     case R_AVR_LO8_LDI:
 995       contents += rel->r_offset;
 996       srel = (bfd_signed_vma) relocation + rel->r_addend;
 997       x = bfd_get_16 (input_bfd, contents);
 998       x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
 999       bfd_put_16 (input_bfd, x, contents);
1000       break;
1001
1002     case R_AVR_LDI:
1003       contents += rel->r_offset;
1004       srel = (bfd_signed_vma) relocation + rel->r_addend;
1005       if (((srel > 0) && (srel & 0xffff) > 255)
1006           || ((srel < 0) && ((-srel) & 0xffff) > 128))
1007         /* Remove offset for data/eeprom section.  */
1008         return bfd_reloc_overflow;
1009
1010       x = bfd_get_16 (input_bfd, contents);
1011       x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
1012       bfd_put_16 (input_bfd, x, contents);
1013       break;
1014
1015     case R_AVR_6:
1016       contents += rel->r_offset;
1017       srel = (bfd_signed_vma) relocation + rel->r_addend;
1018       if (((srel & 0xffff) > 63) || (srel < 0))
1019         /* Remove offset for data/eeprom section.  */
1020         return bfd_reloc_overflow;
1021       x = bfd_get_16 (input_bfd, contents);
1022       x = (x & 0xd3f8) | ((srel & 7) | ((srel & (3 << 3)) << 7)
1023                        | ((srel & (1 << 5)) << 8));
1024       bfd_put_16 (input_bfd, x, contents);
1025       break;
1026
1027     case R_AVR_6_ADIW:
1028       contents += rel->r_offset;
1029       srel = (bfd_signed_vma) relocation + rel->r_addend;
1030       if (((srel & 0xffff) > 63) || (srel < 0))
1031         /* Remove offset for data/eeprom section.  */
1032         return bfd_reloc_overflow;
1033       x = bfd_get_16 (input_bfd, contents);
1034       x = (x & 0xff30) | (srel & 0xf) | ((srel & 0x30) << 2);
1035       bfd_put_16 (input_bfd, x, contents);
1036       break;
1037
1038     case R_AVR_HI8_LDI:
1039       contents += rel->r_offset;
1040       srel = (bfd_signed_vma) relocation + rel->r_addend;
1041       srel = (srel >> 8) & 0xff;
1042       x = bfd_get_16 (input_bfd, contents);
1043       x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
1044       bfd_put_16 (input_bfd, x, contents);
1045       break;
1046
1047     case R_AVR_HH8_LDI:
1048       contents += rel->r_offset;
1049       srel = (bfd_signed_vma) relocation + rel->r_addend;
1050       srel = (srel >> 16) & 0xff;
1051       x = bfd_get_16 (input_bfd, contents);
1052       x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
1053       bfd_put_16 (input_bfd, x, contents);
1054       break;
1055
1056     case R_AVR_MS8_LDI:
1057       contents += rel->r_offset;
1058       srel = (bfd_signed_vma) relocation + rel->r_addend;
1059       srel = (srel >> 24) & 0xff;
1060       x = bfd_get_16 (input_bfd, contents);
1061       x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
1062       bfd_put_16 (input_bfd, x, contents);
1063       break;
1064
1065     case R_AVR_LO8_LDI_NEG:
1066       contents += rel->r_offset;
1067       srel = (bfd_signed_vma) relocation + rel->r_addend;
1068       srel = -srel;
1069       x = bfd_get_16 (input_bfd, contents);
1070       x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
1071       bfd_put_16 (input_bfd, x, contents);
1072       break;
1073
1074     case R_AVR_HI8_LDI_NEG:
1075       contents += rel->r_offset;
1076       srel = (bfd_signed_vma) relocation + rel->r_addend;
1077       srel = -srel;
1078       srel = (srel >> 8) & 0xff;
1079       x = bfd_get_16 (input_bfd, contents);
1080       x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
1081       bfd_put_16 (input_bfd, x, contents);
1082       break;
1083
1084     case R_AVR_HH8_LDI_NEG:
1085       contents += rel->r_offset;
1086       srel = (bfd_signed_vma) relocation + rel->r_addend;
1087       srel = -srel;
1088       srel = (srel >> 16) & 0xff;
1089       x = bfd_get_16 (input_bfd, contents);
1090       x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
1091       bfd_put_16 (input_bfd, x, contents);
1092       break;
1093
1094     case R_AVR_MS8_LDI_NEG:
1095       contents += rel->r_offset;
1096       srel = (bfd_signed_vma) relocation + rel->r_addend;
1097       srel = -srel;
1098       srel = (srel >> 24) & 0xff;
1099       x = bfd_get_16 (input_bfd, contents);
1100       x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
1101       bfd_put_16 (input_bfd, x, contents);
1102       break;
1103
1104     case R_AVR_LO8_LDI_GS:
1105       use_stubs = (!htab->no_stubs);
1106       /* Fall through.  */
1107     case R_AVR_LO8_LDI_PM:
1108       contents += rel->r_offset;
1109       srel = (bfd_signed_vma) relocation + rel->r_addend;
1110
1111       if (use_stubs
1112           && avr_stub_is_required_for_16_bit_reloc (srel - base_addr))
1113         {
1114           bfd_vma old_srel = srel;
1115
1116           /* We need to use the address of the stub instead.  */
1117           srel = avr_get_stub_addr (srel, htab);
1118           if (debug_stubs)
1119             printf ("LD: Using jump stub (at 0x%x) with destination 0x%x for "
1120                     "reloc at address 0x%x.\n",
1121                     (unsigned int) srel,
1122                     (unsigned int) old_srel,
1123                     (unsigned int) reloc_addr);
1124
1125           if (avr_stub_is_required_for_16_bit_reloc (srel - base_addr))
1126             return bfd_reloc_outofrange;
1127         }
1128
1129       if (srel & 1)
1130         return bfd_reloc_outofrange;
1131       srel = srel >> 1;
1132       x = bfd_get_16 (input_bfd, contents);
1133       x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
1134       bfd_put_16 (input_bfd, x, contents);
1135       break;
1136
1137     case R_AVR_HI8_LDI_GS:
1138       use_stubs = (!htab->no_stubs);
1139       /* Fall through.  */
1140     case R_AVR_HI8_LDI_PM:
1141       contents += rel->r_offset;
1142       srel = (bfd_signed_vma) relocation + rel->r_addend;
1143
1144       if (use_stubs
1145           && avr_stub_is_required_for_16_bit_reloc (srel - base_addr))
1146         {
1147           bfd_vma old_srel = srel;
1148
1149           /* We need to use the address of the stub instead.  */
1150           srel = avr_get_stub_addr (srel, htab);
1151           if (debug_stubs)
1152             printf ("LD: Using jump stub (at 0x%x) with destination 0x%x for "
1153                     "reloc at address 0x%x.\n",
1154                     (unsigned int) srel,
1155                     (unsigned int) old_srel,
1156                     (unsigned int) reloc_addr);
1157
1158           if (avr_stub_is_required_for_16_bit_reloc (srel - base_addr))
1159             return bfd_reloc_outofrange;
1160         }
1161
1162       if (srel & 1)
1163         return bfd_reloc_outofrange;
1164       srel = srel >> 1;
1165       srel = (srel >> 8) & 0xff;
1166       x = bfd_get_16 (input_bfd, contents);
1167       x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
1168       bfd_put_16 (input_bfd, x, contents);
1169       break;
1170
1171     case R_AVR_HH8_LDI_PM:
1172       contents += rel->r_offset;
1173       srel = (bfd_signed_vma) relocation + rel->r_addend;
1174       if (srel & 1)
1175         return bfd_reloc_outofrange;
1176       srel = srel >> 1;
1177       srel = (srel >> 16) & 0xff;
1178       x = bfd_get_16 (input_bfd, contents);
1179       x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
1180       bfd_put_16 (input_bfd, x, contents);
1181       break;
1182
1183     case R_AVR_LO8_LDI_PM_NEG:
1184       contents += rel->r_offset;
1185       srel = (bfd_signed_vma) relocation + rel->r_addend;
1186       srel = -srel;
1187       if (srel & 1)
1188         return bfd_reloc_outofrange;
1189       srel = srel >> 1;
1190       x = bfd_get_16 (input_bfd, contents);
1191       x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
1192       bfd_put_16 (input_bfd, x, contents);
1193       break;
1194
1195     case R_AVR_HI8_LDI_PM_NEG:
1196       contents += rel->r_offset;
1197       srel = (bfd_signed_vma) relocation + rel->r_addend;
1198       srel = -srel;
1199       if (srel & 1)
1200         return bfd_reloc_outofrange;
1201       srel = srel >> 1;
1202       srel = (srel >> 8) & 0xff;
1203       x = bfd_get_16 (input_bfd, contents);
1204       x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
1205       bfd_put_16 (input_bfd, x, contents);
1206       break;
1207
1208     case R_AVR_HH8_LDI_PM_NEG:
1209       contents += rel->r_offset;
1210       srel = (bfd_signed_vma) relocation + rel->r_addend;
1211       srel = -srel;
1212       if (srel & 1)
1213         return bfd_reloc_outofrange;
1214       srel = srel >> 1;
1215       srel = (srel >> 16) & 0xff;
1216       x = bfd_get_16 (input_bfd, contents);
1217       x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
1218       bfd_put_16 (input_bfd, x, contents);
1219       break;
1220
1221     case R_AVR_CALL:
1222       contents += rel->r_offset;
1223       srel = (bfd_signed_vma) relocation + rel->r_addend;
1224       if (srel & 1)
1225         return bfd_reloc_outofrange;
1226       srel = srel >> 1;
1227       x = bfd_get_16 (input_bfd, contents);
1228       x |= ((srel & 0x10000) | ((srel << 3) & 0x1f00000)) >> 16;
1229       bfd_put_16 (input_bfd, x, contents);
1230       bfd_put_16 (input_bfd, (bfd_vma) srel & 0xffff, contents+2);
1231       break;
1232
1233     case R_AVR_16_PM:
1234       use_stubs = (!htab->no_stubs);
1235       contents += rel->r_offset;
1236       srel = (bfd_signed_vma) relocation + rel->r_addend;
1237
1238       if (use_stubs
1239           && avr_stub_is_required_for_16_bit_reloc (srel - base_addr))
1240         {
1241           bfd_vma old_srel = srel;
1242
1243           /* We need to use the address of the stub instead.  */
1244           srel = avr_get_stub_addr (srel,htab);
1245           if (debug_stubs)
1246             printf ("LD: Using jump stub (at 0x%x) with destination 0x%x for "
1247                     "reloc at address 0x%x.\n",
1248                     (unsigned int) srel,
1249                     (unsigned int) old_srel,
1250                     (unsigned int) reloc_addr);
1251
1252           if (avr_stub_is_required_for_16_bit_reloc (srel - base_addr))
1253             return bfd_reloc_outofrange;
1254         }
1255
1256       if (srel & 1)
1257         return bfd_reloc_outofrange;
1258       srel = srel >> 1;
1259       bfd_put_16 (input_bfd, (bfd_vma) srel &0x00ffff, contents);
1260       break;
1261
1262     case R_AVR_DIFF8:
1263     case R_AVR_DIFF16:
1264     case R_AVR_DIFF32:
1265       /* Nothing to do here, as contents already contains the diff value. */
1266       r = bfd_reloc_ok;
1267       break;
1268
1269    case R_AVR_LDS_STS_16:
1270       contents += rel->r_offset;
1271       srel = (bfd_signed_vma) relocation + rel->r_addend;
1272       if ((srel & 0xFFFF) < 0x40 || (srel & 0xFFFF) > 0xbf)
1273         return bfd_reloc_outofrange;
1274       srel = srel & 0x7f;
1275       x = bfd_get_16 (input_bfd, contents);
1276       x |= (srel & 0x0f) | ((srel & 0x30) << 5) | ((srel & 0x40) << 2);
1277       bfd_put_16 (input_bfd, x, contents);
1278       break;
1279
1280     case R_AVR_PORT6:
1281       contents += rel->r_offset;
1282       srel = (bfd_signed_vma) relocation + rel->r_addend;
1283       if ((srel & 0xffff) > 0x3f)
1284         return bfd_reloc_outofrange;
1285       x = bfd_get_16 (input_bfd, contents);
1286       x = (x & 0xf9f0) | ((srel & 0x30) << 5) | (srel & 0x0f);
1287       bfd_put_16 (input_bfd, x, contents);
1288       break;
1289
1290     case R_AVR_PORT5:
1291       contents += rel->r_offset;
1292       srel = (bfd_signed_vma) relocation + rel->r_addend;
1293       if ((srel & 0xffff) > 0x1f)
1294         return bfd_reloc_outofrange;
1295       x = bfd_get_16 (input_bfd, contents);
1296       x = (x & 0xff07) | ((srel & 0x1f) << 3);
1297       bfd_put_16 (input_bfd, x, contents);
1298       break;
1299
1300     default:
1301       r = _bfd_final_link_relocate (howto, input_bfd, input_section,
1302                                     contents, rel->r_offset,
1303                                     relocation, rel->r_addend);
1304     }
1305
1306   return r;
1307 }
1308
1309 /* Relocate an AVR ELF section.  */
1310
1311 static bfd_boolean
1312 elf32_avr_relocate_section (bfd *output_bfd ATTRIBUTE_UNUSED,
1313                             struct bfd_link_info *info,
1314                             bfd *input_bfd,
1315                             asection *input_section,
1316                             bfd_byte *contents,
1317                             Elf_Internal_Rela *relocs,
1318                             Elf_Internal_Sym *local_syms,
1319                             asection **local_sections)
1320 {
1321   Elf_Internal_Shdr *           symtab_hdr;
1322   struct elf_link_hash_entry ** sym_hashes;
1323   Elf_Internal_Rela *           rel;
1324   Elf_Internal_Rela *           relend;
1325   struct elf32_avr_link_hash_table * htab = avr_link_hash_table (info);
1326
1327   if (htab == NULL)
1328     return FALSE;
1329
1330   symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
1331   sym_hashes = elf_sym_hashes (input_bfd);
1332   relend     = relocs + input_section->reloc_count;
1333
1334   for (rel = relocs; rel < relend; rel ++)
1335     {
1336       reloc_howto_type *           howto;
1337       unsigned long                r_symndx;
1338       Elf_Internal_Sym *           sym;
1339       asection *                   sec;
1340       struct elf_link_hash_entry * h;
1341       bfd_vma                      relocation;
1342       bfd_reloc_status_type        r;
1343       const char *                 name;
1344       int                          r_type;
1345
1346       r_type = ELF32_R_TYPE (rel->r_info);
1347       r_symndx = ELF32_R_SYM (rel->r_info);
1348       howto  = elf_avr_howto_table + r_type;
1349       h      = NULL;
1350       sym    = NULL;
1351       sec    = NULL;
1352
1353       if (r_symndx < symtab_hdr->sh_info)
1354         {
1355           sym = local_syms + r_symndx;
1356           sec = local_sections [r_symndx];
1357           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
1358
1359           name = bfd_elf_string_from_elf_section
1360             (input_bfd, symtab_hdr->sh_link, sym->st_name);
1361           name = (name == NULL) ? bfd_section_name (input_bfd, sec) : name;
1362         }
1363       else
1364         {
1365           bfd_boolean unresolved_reloc, warned, ignored;
1366
1367           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
1368                                    r_symndx, symtab_hdr, sym_hashes,
1369                                    h, sec, relocation,
1370                                    unresolved_reloc, warned, ignored);
1371
1372           name = h->root.root.string;
1373         }
1374
1375       if (sec != NULL && discarded_section (sec))
1376         RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
1377                                          rel, 1, relend, howto, 0, contents);
1378
1379       if (info->relocatable)
1380         continue;
1381
1382       r = avr_final_link_relocate (howto, input_bfd, input_section,
1383                                    contents, rel, relocation, htab);
1384
1385       if (r != bfd_reloc_ok)
1386         {
1387           const char * msg = (const char *) NULL;
1388
1389           switch (r)
1390             {
1391             case bfd_reloc_overflow:
1392               r = info->callbacks->reloc_overflow
1393                 (info, (h ? &h->root : NULL),
1394                  name, howto->name, (bfd_vma) 0,
1395                  input_bfd, input_section, rel->r_offset);
1396               break;
1397
1398             case bfd_reloc_undefined:
1399               r = info->callbacks->undefined_symbol
1400                 (info, name, input_bfd, input_section, rel->r_offset, TRUE);
1401               break;
1402
1403             case bfd_reloc_outofrange:
1404               msg = _("internal error: out of range error");
1405               break;
1406
1407             case bfd_reloc_notsupported:
1408               msg = _("internal error: unsupported relocation error");
1409               break;
1410
1411             case bfd_reloc_dangerous:
1412               msg = _("internal error: dangerous relocation");
1413               break;
1414
1415             default:
1416               msg = _("internal error: unknown error");
1417               break;
1418             }
1419
1420           if (msg)
1421             r = info->callbacks->warning
1422               (info, msg, name, input_bfd, input_section, rel->r_offset);
1423
1424           if (! r)
1425             return FALSE;
1426         }
1427     }
1428
1429   return TRUE;
1430 }
1431
1432 /* The final processing done just before writing out a AVR ELF object
1433    file.  This gets the AVR architecture right based on the machine
1434    number.  */
1435
1436 static void
1437 bfd_elf_avr_final_write_processing (bfd *abfd,
1438                                     bfd_boolean linker ATTRIBUTE_UNUSED)
1439 {
1440   unsigned long val;
1441
1442   switch (bfd_get_mach (abfd))
1443     {
1444     default:
1445     case bfd_mach_avr2:
1446       val = E_AVR_MACH_AVR2;
1447       break;
1448
1449     case bfd_mach_avr1:
1450       val = E_AVR_MACH_AVR1;
1451       break;
1452
1453     case bfd_mach_avr25:
1454       val = E_AVR_MACH_AVR25;
1455       break;
1456
1457     case bfd_mach_avr3:
1458       val = E_AVR_MACH_AVR3;
1459       break;
1460
1461     case bfd_mach_avr31:
1462       val = E_AVR_MACH_AVR31;
1463       break;
1464
1465     case bfd_mach_avr35:
1466       val = E_AVR_MACH_AVR35;
1467       break;
1468
1469     case bfd_mach_avr4:
1470       val = E_AVR_MACH_AVR4;
1471       break;
1472
1473     case bfd_mach_avr5:
1474       val = E_AVR_MACH_AVR5;
1475       break;
1476
1477     case bfd_mach_avr51:
1478       val = E_AVR_MACH_AVR51;
1479       break;
1480
1481     case bfd_mach_avr6:
1482       val = E_AVR_MACH_AVR6;
1483       break;
1484
1485     case bfd_mach_avrxmega1:
1486       val = E_AVR_MACH_XMEGA1;
1487       break;
1488
1489     case bfd_mach_avrxmega2:
1490       val = E_AVR_MACH_XMEGA2;
1491       break;
1492
1493     case bfd_mach_avrxmega3:
1494       val = E_AVR_MACH_XMEGA3;
1495       break;
1496
1497     case bfd_mach_avrxmega4:
1498       val = E_AVR_MACH_XMEGA4;
1499       break;
1500
1501     case bfd_mach_avrxmega5:
1502       val = E_AVR_MACH_XMEGA5;
1503       break;
1504
1505     case bfd_mach_avrxmega6:
1506       val = E_AVR_MACH_XMEGA6;
1507       break;
1508
1509     case bfd_mach_avrxmega7:
1510       val = E_AVR_MACH_XMEGA7;
1511       break;
1512
1513    case bfd_mach_avrtiny:
1514       val = E_AVR_MACH_AVRTINY;
1515       break;
1516     }
1517
1518   elf_elfheader (abfd)->e_machine = EM_AVR;
1519   elf_elfheader (abfd)->e_flags &= ~ EF_AVR_MACH;
1520   elf_elfheader (abfd)->e_flags |= val;
1521   elf_elfheader (abfd)->e_flags |= EF_AVR_LINKRELAX_PREPARED;
1522 }
1523
1524 /* Set the right machine number.  */
1525
1526 static bfd_boolean
1527 elf32_avr_object_p (bfd *abfd)
1528 {
1529   unsigned int e_set = bfd_mach_avr2;
1530
1531   if (elf_elfheader (abfd)->e_machine == EM_AVR
1532       || elf_elfheader (abfd)->e_machine == EM_AVR_OLD)
1533     {
1534       int e_mach = elf_elfheader (abfd)->e_flags & EF_AVR_MACH;
1535
1536       switch (e_mach)
1537         {
1538         default:
1539         case E_AVR_MACH_AVR2:
1540           e_set = bfd_mach_avr2;
1541           break;
1542
1543         case E_AVR_MACH_AVR1:
1544           e_set = bfd_mach_avr1;
1545           break;
1546
1547         case E_AVR_MACH_AVR25:
1548           e_set = bfd_mach_avr25;
1549           break;
1550
1551         case E_AVR_MACH_AVR3:
1552           e_set = bfd_mach_avr3;
1553           break;
1554
1555         case E_AVR_MACH_AVR31:
1556           e_set = bfd_mach_avr31;
1557           break;
1558
1559         case E_AVR_MACH_AVR35:
1560           e_set = bfd_mach_avr35;
1561           break;
1562
1563         case E_AVR_MACH_AVR4:
1564           e_set = bfd_mach_avr4;
1565           break;
1566
1567         case E_AVR_MACH_AVR5:
1568           e_set = bfd_mach_avr5;
1569           break;
1570
1571         case E_AVR_MACH_AVR51:
1572           e_set = bfd_mach_avr51;
1573           break;
1574
1575         case E_AVR_MACH_AVR6:
1576           e_set = bfd_mach_avr6;
1577           break;
1578
1579         case E_AVR_MACH_XMEGA1:
1580           e_set = bfd_mach_avrxmega1;
1581           break;
1582
1583         case E_AVR_MACH_XMEGA2:
1584           e_set = bfd_mach_avrxmega2;
1585           break;
1586
1587         case E_AVR_MACH_XMEGA3:
1588           e_set = bfd_mach_avrxmega3;
1589           break;
1590
1591         case E_AVR_MACH_XMEGA4:
1592           e_set = bfd_mach_avrxmega4;
1593           break;
1594
1595         case E_AVR_MACH_XMEGA5:
1596           e_set = bfd_mach_avrxmega5;
1597           break;
1598
1599         case E_AVR_MACH_XMEGA6:
1600           e_set = bfd_mach_avrxmega6;
1601           break;
1602
1603         case E_AVR_MACH_XMEGA7:
1604           e_set = bfd_mach_avrxmega7;
1605           break;
1606
1607     case E_AVR_MACH_AVRTINY:
1608       e_set = bfd_mach_avrtiny;
1609       break;
1610         }
1611     }
1612   return bfd_default_set_arch_mach (abfd, bfd_arch_avr,
1613                                     e_set);
1614 }
1615
1616 /* Returns whether the relocation type passed is a diff reloc. */
1617
1618 static bfd_boolean
1619 elf32_avr_is_diff_reloc (Elf_Internal_Rela *irel)
1620 {
1621   return (ELF32_R_TYPE (irel->r_info) == R_AVR_DIFF8
1622           ||ELF32_R_TYPE (irel->r_info) == R_AVR_DIFF16
1623           || ELF32_R_TYPE (irel->r_info) == R_AVR_DIFF32);
1624 }
1625
1626 /* Reduce the diff value written in the section by count if the shrinked
1627    insn address happens to fall between the two symbols for which this
1628    diff reloc was emitted.  */
1629
1630 static void
1631 elf32_avr_adjust_diff_reloc_value (bfd *abfd,
1632                                    struct bfd_section *isec,
1633                                    Elf_Internal_Rela *irel,
1634                                    bfd_vma symval,
1635                                    bfd_vma shrinked_insn_address,
1636                                    int count)
1637 {
1638   unsigned char *reloc_contents = NULL;
1639   unsigned char *isec_contents = elf_section_data (isec)->this_hdr.contents;
1640   if (isec_contents == NULL)
1641   {
1642     if (! bfd_malloc_and_get_section (abfd, isec, &isec_contents))
1643       return;
1644
1645     elf_section_data (isec)->this_hdr.contents = isec_contents;
1646   }
1647
1648   reloc_contents = isec_contents + irel->r_offset;
1649
1650   /* Read value written in object file. */
1651  bfd_vma x = 0;
1652   switch (ELF32_R_TYPE (irel->r_info))
1653   {
1654   case R_AVR_DIFF8:
1655     {
1656       x = *reloc_contents;
1657       break;
1658     }
1659   case R_AVR_DIFF16:
1660     {
1661       x = bfd_get_16 (abfd, reloc_contents);
1662       break;
1663     }
1664   case R_AVR_DIFF32:
1665     {
1666       x = bfd_get_32 (abfd, reloc_contents);
1667       break;
1668     }
1669   default:
1670     {
1671       BFD_FAIL();
1672     }
1673   }
1674
1675   /* For a diff reloc sym1 - sym2 the diff at assembly time (x) is written
1676      into the object file at the reloc offset. sym2's logical value is
1677      symval (<start_of_section>) + reloc addend. Compute the start and end
1678      addresses and check if the shrinked insn falls between sym1 and sym2. */
1679
1680   bfd_vma end_address = symval + irel->r_addend;
1681   bfd_vma start_address = end_address - x;
1682
1683   /* Reduce the diff value by count bytes and write it back into section
1684     contents. */
1685
1686   if (shrinked_insn_address >= start_address
1687       && shrinked_insn_address <= end_address)
1688   {
1689     switch (ELF32_R_TYPE (irel->r_info))
1690     {
1691     case R_AVR_DIFF8:
1692       {
1693         *reloc_contents = (x - count);
1694         break;
1695       }
1696     case R_AVR_DIFF16:
1697       {
1698         bfd_put_16 (abfd, (x - count) & 0xFFFF, reloc_contents);
1699         break;
1700       }
1701     case R_AVR_DIFF32:
1702       {
1703         bfd_put_32 (abfd, (x - count) & 0xFFFFFFFF, reloc_contents);
1704         break;
1705       }
1706     default:
1707       {
1708         BFD_FAIL();
1709       }
1710     }
1711
1712   }
1713 }
1714
1715 /* Delete some bytes from a section while changing the size of an instruction.
1716    The parameter "addr" denotes the section-relative offset pointing just
1717    behind the shrinked instruction. "addr+count" point at the first
1718    byte just behind the original unshrinked instruction.  */
1719
1720 static bfd_boolean
1721 elf32_avr_relax_delete_bytes (bfd *abfd,
1722                               asection *sec,
1723                               bfd_vma addr,
1724                               int count)
1725 {
1726   Elf_Internal_Shdr *symtab_hdr;
1727   unsigned int sec_shndx;
1728   bfd_byte *contents;
1729   Elf_Internal_Rela *irel, *irelend;
1730   Elf_Internal_Sym *isym;
1731   Elf_Internal_Sym *isymbuf = NULL;
1732   bfd_vma toaddr;
1733   struct elf_link_hash_entry **sym_hashes;
1734   struct elf_link_hash_entry **end_hashes;
1735   unsigned int symcount;
1736
1737   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1738   sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
1739   contents = elf_section_data (sec)->this_hdr.contents;
1740
1741   toaddr = sec->size;
1742
1743   irel = elf_section_data (sec)->relocs;
1744   irelend = irel + sec->reloc_count;
1745
1746   /* Actually delete the bytes.  */
1747   if (toaddr - addr - count > 0)
1748     memmove (contents + addr, contents + addr + count,
1749              (size_t) (toaddr - addr - count));
1750   sec->size -= count;
1751
1752   /* Adjust all the reloc addresses.  */
1753   for (irel = elf_section_data (sec)->relocs; irel < irelend; irel++)
1754     {
1755       bfd_vma old_reloc_address;
1756
1757       old_reloc_address = (sec->output_section->vma
1758                            + sec->output_offset + irel->r_offset);
1759
1760       /* Get the new reloc address.  */
1761       if ((irel->r_offset > addr
1762            && irel->r_offset < toaddr))
1763         {
1764           if (debug_relax)
1765             printf ("Relocation at address 0x%x needs to be moved.\n"
1766                     "Old section offset: 0x%x, New section offset: 0x%x \n",
1767                     (unsigned int) old_reloc_address,
1768                     (unsigned int) irel->r_offset,
1769                     (unsigned int) ((irel->r_offset) - count));
1770
1771           irel->r_offset -= count;
1772         }
1773
1774     }
1775
1776    /* The reloc's own addresses are now ok. However, we need to readjust
1777       the reloc's addend, i.e. the reloc's value if two conditions are met:
1778       1.) the reloc is relative to a symbol in this section that
1779           is located in front of the shrinked instruction
1780       2.) symbol plus addend end up behind the shrinked instruction.
1781
1782       The most common case where this happens are relocs relative to
1783       the section-start symbol.
1784
1785       This step needs to be done for all of the sections of the bfd.  */
1786
1787   {
1788     struct bfd_section *isec;
1789
1790     for (isec = abfd->sections; isec; isec = isec->next)
1791      {
1792        bfd_vma symval;
1793        bfd_vma shrinked_insn_address;
1794
1795        if (isec->reloc_count == 0)
1796          continue;
1797
1798        shrinked_insn_address = (sec->output_section->vma
1799                                 + sec->output_offset + addr - count);
1800
1801        irel = elf_section_data (isec)->relocs;
1802        /* PR 12161: Read in the relocs for this section if necessary.  */
1803        if (irel == NULL)
1804          irel = _bfd_elf_link_read_relocs (abfd, isec, NULL, NULL, TRUE);
1805
1806        for (irelend = irel + isec->reloc_count;
1807             irel < irelend;
1808             irel++)
1809          {
1810            /* Read this BFD's local symbols if we haven't done
1811               so already.  */
1812            if (isymbuf == NULL && symtab_hdr->sh_info != 0)
1813              {
1814                isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
1815                if (isymbuf == NULL)
1816                  isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
1817                                                  symtab_hdr->sh_info, 0,
1818                                                  NULL, NULL, NULL);
1819                if (isymbuf == NULL)
1820                  return FALSE;
1821              }
1822
1823            /* Get the value of the symbol referred to by the reloc.  */
1824            if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
1825              {
1826                /* A local symbol.  */
1827                asection *sym_sec;
1828
1829                isym = isymbuf + ELF32_R_SYM (irel->r_info);
1830                sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
1831                symval = isym->st_value;
1832                /* If the reloc is absolute, it will not have
1833                   a symbol or section associated with it.  */
1834                if (sym_sec == sec)
1835                  {
1836                    symval += sym_sec->output_section->vma
1837                              + sym_sec->output_offset;
1838
1839                    if (debug_relax)
1840                      printf ("Checking if the relocation's "
1841                              "addend needs corrections.\n"
1842                              "Address of anchor symbol: 0x%x \n"
1843                              "Address of relocation target: 0x%x \n"
1844                              "Address of relaxed insn: 0x%x \n",
1845                              (unsigned int) symval,
1846                              (unsigned int) (symval + irel->r_addend),
1847                              (unsigned int) shrinked_insn_address);
1848
1849                    if (symval <= shrinked_insn_address
1850                        && (symval + irel->r_addend) > shrinked_insn_address)
1851                      {
1852                        if (elf32_avr_is_diff_reloc (irel))
1853                          {
1854                            elf32_avr_adjust_diff_reloc_value (abfd, isec, irel,
1855                                                          symval,
1856                                                          shrinked_insn_address,
1857                                                         count);
1858                          }
1859
1860                        irel->r_addend -= count;
1861
1862                        if (debug_relax)
1863                          printf ("Relocation's addend needed to be fixed \n");
1864                      }
1865                  }
1866                /* else...Reference symbol is absolute.  No adjustment needed.  */
1867              }
1868            /* else...Reference symbol is extern.  No need for adjusting
1869               the addend.  */
1870          }
1871      }
1872   }
1873
1874   /* Adjust the local symbols defined in this section.  */
1875   isym = (Elf_Internal_Sym *) symtab_hdr->contents;
1876   /* Fix PR 9841, there may be no local symbols.  */
1877   if (isym != NULL)
1878     {
1879       Elf_Internal_Sym *isymend;
1880
1881       isymend = isym + symtab_hdr->sh_info;
1882       for (; isym < isymend; isym++)
1883         {
1884           if (isym->st_shndx == sec_shndx
1885               && isym->st_value > addr
1886               && isym->st_value < toaddr)
1887             isym->st_value -= count;
1888         }
1889     }
1890
1891   /* Now adjust the global symbols defined in this section.  */
1892   symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
1893               - symtab_hdr->sh_info);
1894   sym_hashes = elf_sym_hashes (abfd);
1895   end_hashes = sym_hashes + symcount;
1896   for (; sym_hashes < end_hashes; sym_hashes++)
1897     {
1898       struct elf_link_hash_entry *sym_hash = *sym_hashes;
1899       if ((sym_hash->root.type == bfd_link_hash_defined
1900            || sym_hash->root.type == bfd_link_hash_defweak)
1901           && sym_hash->root.u.def.section == sec
1902           && sym_hash->root.u.def.value > addr
1903           && sym_hash->root.u.def.value < toaddr)
1904         {
1905           sym_hash->root.u.def.value -= count;
1906         }
1907     }
1908
1909   return TRUE;
1910 }
1911
1912 /* This function handles relaxing for the avr.
1913    Many important relaxing opportunities within functions are already
1914    realized by the compiler itself.
1915    Here we try to replace  call (4 bytes) ->  rcall (2 bytes)
1916    and jump -> rjmp (safes also 2 bytes).
1917    As well we now optimize seqences of
1918      - call/rcall function
1919      - ret
1920    to yield
1921      - jmp/rjmp function
1922      - ret
1923    . In case that within a sequence
1924      - jmp/rjmp label
1925      - ret
1926    the ret could no longer be reached it is optimized away. In order
1927    to check if the ret is no longer needed, it is checked that the ret's address
1928    is not the target of a branch or jump within the same section, it is checked
1929    that there is no skip instruction before the jmp/rjmp and that there
1930    is no local or global label place at the address of the ret.
1931
1932    We refrain from relaxing within sections ".vectors" and
1933    ".jumptables" in order to maintain the position of the instructions.
1934    There, however, we substitute jmp/call by a sequence rjmp,nop/rcall,nop
1935    if possible. (In future one could possibly use the space of the nop
1936    for the first instruction of the irq service function.
1937
1938    The .jumptables sections is meant to be used for a future tablejump variant
1939    for the devices with 3-byte program counter where the table itself
1940    contains 4-byte jump instructions whose relative offset must not
1941    be changed.  */
1942
1943 static bfd_boolean
1944 elf32_avr_relax_section (bfd *abfd,
1945                          asection *sec,
1946                          struct bfd_link_info *link_info,
1947                          bfd_boolean *again)
1948 {
1949   Elf_Internal_Shdr *symtab_hdr;
1950   Elf_Internal_Rela *internal_relocs;
1951   Elf_Internal_Rela *irel, *irelend;
1952   bfd_byte *contents = NULL;
1953   Elf_Internal_Sym *isymbuf = NULL;
1954   struct elf32_avr_link_hash_table *htab;
1955
1956   /* If 'shrinkable' is FALSE, do not shrink by deleting bytes while
1957      relaxing. Such shrinking can cause issues for the sections such
1958      as .vectors and .jumptables. Instead the unused bytes should be
1959      filled with nop instructions. */
1960   bfd_boolean shrinkable = TRUE;
1961
1962   if (!strcmp (sec->name,".vectors")
1963       || !strcmp (sec->name,".jumptables"))
1964     shrinkable = FALSE;
1965
1966   if (link_info->relocatable)
1967     (*link_info->callbacks->einfo)
1968       (_("%P%F: --relax and -r may not be used together\n"));
1969
1970   htab = avr_link_hash_table (link_info);
1971   if (htab == NULL)
1972     return FALSE;
1973
1974   /* Assume nothing changes.  */
1975   *again = FALSE;
1976
1977   if ((!htab->no_stubs) && (sec == htab->stub_sec))
1978     {
1979       /* We are just relaxing the stub section.
1980          Let's calculate the size needed again.  */
1981       bfd_size_type last_estimated_stub_section_size = htab->stub_sec->size;
1982
1983       if (debug_relax)
1984         printf ("Relaxing the stub section. Size prior to this pass: %i\n",
1985                 (int) last_estimated_stub_section_size);
1986
1987       elf32_avr_size_stubs (htab->stub_sec->output_section->owner,
1988                             link_info, FALSE);
1989
1990       /* Check if the number of trampolines changed.  */
1991       if (last_estimated_stub_section_size != htab->stub_sec->size)
1992         *again = TRUE;
1993
1994       if (debug_relax)
1995         printf ("Size of stub section after this pass: %i\n",
1996                 (int) htab->stub_sec->size);
1997
1998       return TRUE;
1999     }
2000
2001   /* We don't have to do anything for a relocatable link, if
2002      this section does not have relocs, or if this is not a
2003      code section.  */
2004   if (link_info->relocatable
2005       || (sec->flags & SEC_RELOC) == 0
2006       || sec->reloc_count == 0
2007       || (sec->flags & SEC_CODE) == 0)
2008     return TRUE;
2009
2010   /* Check if the object file to relax uses internal symbols so that we
2011      could fix up the relocations.  */
2012   if (!(elf_elfheader (abfd)->e_flags & EF_AVR_LINKRELAX_PREPARED))
2013     return TRUE;
2014
2015   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2016
2017   /* Get a copy of the native relocations.  */
2018   internal_relocs = (_bfd_elf_link_read_relocs
2019                      (abfd, sec, NULL, NULL, link_info->keep_memory));
2020   if (internal_relocs == NULL)
2021     goto error_return;
2022
2023   /* Walk through the relocs looking for relaxing opportunities.  */
2024   irelend = internal_relocs + sec->reloc_count;
2025   for (irel = internal_relocs; irel < irelend; irel++)
2026     {
2027       bfd_vma symval;
2028
2029       if (   ELF32_R_TYPE (irel->r_info) != R_AVR_13_PCREL
2030           && ELF32_R_TYPE (irel->r_info) != R_AVR_7_PCREL
2031           && ELF32_R_TYPE (irel->r_info) != R_AVR_CALL)
2032         continue;
2033
2034       /* Get the section contents if we haven't done so already.  */
2035       if (contents == NULL)
2036         {
2037           /* Get cached copy if it exists.  */
2038           if (elf_section_data (sec)->this_hdr.contents != NULL)
2039             contents = elf_section_data (sec)->this_hdr.contents;
2040           else
2041             {
2042               /* Go get them off disk.  */
2043               if (! bfd_malloc_and_get_section (abfd, sec, &contents))
2044                 goto error_return;
2045             }
2046         }
2047
2048       /* Read this BFD's local symbols if we haven't done so already.  */
2049       if (isymbuf == NULL && symtab_hdr->sh_info != 0)
2050         {
2051           isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
2052           if (isymbuf == NULL)
2053             isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
2054                                             symtab_hdr->sh_info, 0,
2055                                             NULL, NULL, NULL);
2056           if (isymbuf == NULL)
2057             goto error_return;
2058         }
2059
2060
2061       /* Get the value of the symbol referred to by the reloc.  */
2062       if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
2063         {
2064           /* A local symbol.  */
2065           Elf_Internal_Sym *isym;
2066           asection *sym_sec;
2067
2068           isym = isymbuf + ELF32_R_SYM (irel->r_info);
2069           sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
2070           symval = isym->st_value;
2071           /* If the reloc is absolute, it will not have
2072              a symbol or section associated with it.  */
2073           if (sym_sec)
2074             symval += sym_sec->output_section->vma
2075               + sym_sec->output_offset;
2076         }
2077       else
2078         {
2079           unsigned long indx;
2080           struct elf_link_hash_entry *h;
2081
2082           /* An external symbol.  */
2083           indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
2084           h = elf_sym_hashes (abfd)[indx];
2085           BFD_ASSERT (h != NULL);
2086           if (h->root.type != bfd_link_hash_defined
2087               && h->root.type != bfd_link_hash_defweak)
2088             /* This appears to be a reference to an undefined
2089                symbol.  Just ignore it--it will be caught by the
2090                regular reloc processing.  */
2091             continue;
2092
2093           symval = (h->root.u.def.value
2094                     + h->root.u.def.section->output_section->vma
2095                     + h->root.u.def.section->output_offset);
2096         }
2097
2098       /* For simplicity of coding, we are going to modify the section
2099          contents, the section relocs, and the BFD symbol table.  We
2100          must tell the rest of the code not to free up this
2101          information.  It would be possible to instead create a table
2102          of changes which have to be made, as is done in coff-mips.c;
2103          that would be more work, but would require less memory when
2104          the linker is run.  */
2105       switch (ELF32_R_TYPE (irel->r_info))
2106         {
2107           /* Try to turn a 22-bit absolute call/jump into an 13-bit
2108              pc-relative rcall/rjmp.  */
2109         case R_AVR_CALL:
2110           {
2111             bfd_vma value = symval + irel->r_addend;
2112             bfd_vma dot, gap;
2113             int distance_short_enough = 0;
2114
2115             /* Get the address of this instruction.  */
2116             dot = (sec->output_section->vma
2117                    + sec->output_offset + irel->r_offset);
2118
2119             /* Compute the distance from this insn to the branch target.  */
2120             gap = value - dot;
2121
2122             /* Check if the gap falls in the range that can be accommodated
2123                in 13bits signed (It is 12bits when encoded, as we deal with
2124                word addressing). */
2125             if (!shrinkable && ((int) gap >= -4096 && (int) gap <= 4095))
2126               distance_short_enough = 1;
2127             /* If shrinkable, then we can check for a range of distance which
2128                is two bytes farther on both the directions because the call
2129                or jump target will be closer by two bytes after the
2130                relaxation. */
2131             else if (shrinkable && ((int) gap >= -4094 && (int) gap <= 4097))
2132               distance_short_enough = 1;
2133
2134             /* Here we handle the wrap-around case.  E.g. for a 16k device
2135                we could use a rjmp to jump from address 0x100 to 0x3d00!
2136                In order to make this work properly, we need to fill the
2137                vaiable avr_pc_wrap_around with the appropriate value.
2138                I.e. 0x4000 for a 16k device.  */
2139             {
2140               /* Shrinking the code size makes the gaps larger in the
2141                  case of wrap-arounds.  So we use a heuristical safety
2142                  margin to avoid that during relax the distance gets
2143                  again too large for the short jumps.  Let's assume
2144                  a typical code-size reduction due to relax for a
2145                  16k device of 600 bytes.  So let's use twice the
2146                  typical value as safety margin.  */
2147               int rgap;
2148               int safety_margin;
2149
2150               int assumed_shrink = 600;
2151               if (avr_pc_wrap_around > 0x4000)
2152                 assumed_shrink = 900;
2153
2154               safety_margin = 2 * assumed_shrink;
2155
2156               rgap = avr_relative_distance_considering_wrap_around (gap);
2157
2158               if (rgap >= (-4092 + safety_margin)
2159                   && rgap <= (4094 - safety_margin))
2160                 distance_short_enough = 1;
2161             }
2162
2163             if (distance_short_enough)
2164               {
2165                 unsigned char code_msb;
2166                 unsigned char code_lsb;
2167
2168                 if (debug_relax)
2169                   printf ("shrinking jump/call instruction at address 0x%x"
2170                           " in section %s\n\n",
2171                           (int) dot, sec->name);
2172
2173                 /* Note that we've changed the relocs, section contents,
2174                    etc.  */
2175                 elf_section_data (sec)->relocs = internal_relocs;
2176                 elf_section_data (sec)->this_hdr.contents = contents;
2177                 symtab_hdr->contents = (unsigned char *) isymbuf;
2178
2179                 /* Get the instruction code for relaxing.  */
2180                 code_lsb = bfd_get_8 (abfd, contents + irel->r_offset);
2181                 code_msb = bfd_get_8 (abfd, contents + irel->r_offset + 1);
2182
2183                 /* Mask out the relocation bits.  */
2184                 code_msb &= 0x94;
2185                 code_lsb &= 0x0E;
2186                 if (code_msb == 0x94 && code_lsb == 0x0E)
2187                   {
2188                     /* we are changing call -> rcall .  */
2189                     bfd_put_8 (abfd, 0x00, contents + irel->r_offset);
2190                     bfd_put_8 (abfd, 0xD0, contents + irel->r_offset + 1);
2191                   }
2192                 else if (code_msb == 0x94 && code_lsb == 0x0C)
2193                   {
2194                     /* we are changeing jump -> rjmp.  */
2195                     bfd_put_8 (abfd, 0x00, contents + irel->r_offset);
2196                     bfd_put_8 (abfd, 0xC0, contents + irel->r_offset + 1);
2197                   }
2198                 else
2199                   abort ();
2200
2201                 /* Fix the relocation's type.  */
2202                 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
2203                                              R_AVR_13_PCREL);
2204
2205                 /* We should not modify the ordering if 'shrinkable' is
2206                    FALSE. */
2207                 if (!shrinkable)
2208                   {
2209                     /* Let's insert a nop.  */
2210                     bfd_put_8 (abfd, 0x00, contents + irel->r_offset + 2);
2211                     bfd_put_8 (abfd, 0x00, contents + irel->r_offset + 3);
2212                   }
2213                 else
2214                   {
2215                     /* Delete two bytes of data.  */
2216                     if (!elf32_avr_relax_delete_bytes (abfd, sec,
2217                                                        irel->r_offset + 2, 2))
2218                       goto error_return;
2219
2220                     /* That will change things, so, we should relax again.
2221                        Note that this is not required, and it may be slow.  */
2222                     *again = TRUE;
2223                   }
2224               }
2225           }
2226
2227         default:
2228           {
2229             unsigned char code_msb;
2230             unsigned char code_lsb;
2231             bfd_vma dot;
2232
2233             code_msb = bfd_get_8 (abfd, contents + irel->r_offset + 1);
2234             code_lsb = bfd_get_8 (abfd, contents + irel->r_offset + 0);
2235
2236             /* Get the address of this instruction.  */
2237             dot = (sec->output_section->vma
2238                    + sec->output_offset + irel->r_offset);
2239
2240             /* Here we look for rcall/ret or call/ret sequences that could be
2241                safely replaced by rjmp/ret or jmp/ret.  */
2242             if (((code_msb & 0xf0) == 0xd0)
2243                 && avr_replace_call_ret_sequences)
2244               {
2245                 /* This insn is a rcall.  */
2246                 unsigned char next_insn_msb = 0;
2247                 unsigned char next_insn_lsb = 0;
2248
2249                 if (irel->r_offset + 3 < sec->size)
2250                   {
2251                     next_insn_msb =
2252                       bfd_get_8 (abfd, contents + irel->r_offset + 3);
2253                     next_insn_lsb =
2254                       bfd_get_8 (abfd, contents + irel->r_offset + 2);
2255                   }
2256
2257                 if ((0x95 == next_insn_msb) && (0x08 == next_insn_lsb))
2258                   {
2259                     /* The next insn is a ret. We now convert the rcall insn
2260                        into a rjmp instruction.  */
2261                     code_msb &= 0xef;
2262                     bfd_put_8 (abfd, code_msb, contents + irel->r_offset + 1);
2263                     if (debug_relax)
2264                       printf ("converted rcall/ret sequence at address 0x%x"
2265                               " into rjmp/ret sequence. Section is %s\n\n",
2266                               (int) dot, sec->name);
2267                     *again = TRUE;
2268                     break;
2269                   }
2270               }
2271             else if ((0x94 == (code_msb & 0xfe))
2272                      && (0x0e == (code_lsb & 0x0e))
2273                      && avr_replace_call_ret_sequences)
2274               {
2275                 /* This insn is a call.  */
2276                 unsigned char next_insn_msb = 0;
2277                 unsigned char next_insn_lsb = 0;
2278
2279                 if (irel->r_offset + 5 < sec->size)
2280                   {
2281                     next_insn_msb =
2282                       bfd_get_8 (abfd, contents + irel->r_offset + 5);
2283                     next_insn_lsb =
2284                       bfd_get_8 (abfd, contents + irel->r_offset + 4);
2285                   }
2286
2287                 if ((0x95 == next_insn_msb) && (0x08 == next_insn_lsb))
2288                   {
2289                     /* The next insn is a ret. We now convert the call insn
2290                        into a jmp instruction.  */
2291
2292                     code_lsb &= 0xfd;
2293                     bfd_put_8 (abfd, code_lsb, contents + irel->r_offset);
2294                     if (debug_relax)
2295                       printf ("converted call/ret sequence at address 0x%x"
2296                               " into jmp/ret sequence. Section is %s\n\n",
2297                               (int) dot, sec->name);
2298                     *again = TRUE;
2299                     break;
2300                   }
2301               }
2302             else if ((0xc0 == (code_msb & 0xf0))
2303                      || ((0x94 == (code_msb & 0xfe))
2304                          && (0x0c == (code_lsb & 0x0e))))
2305               {
2306                 /* This insn is a rjmp or a jmp.  */
2307                 unsigned char next_insn_msb = 0;
2308                 unsigned char next_insn_lsb = 0;
2309                 int insn_size;
2310
2311                 if (0xc0 == (code_msb & 0xf0))
2312                   insn_size = 2; /* rjmp insn */
2313                 else
2314                   insn_size = 4; /* jmp insn */
2315
2316                 if (irel->r_offset + insn_size + 1 < sec->size)
2317                   {
2318                     next_insn_msb =
2319                       bfd_get_8 (abfd, contents + irel->r_offset
2320                                  + insn_size + 1);
2321                     next_insn_lsb =
2322                       bfd_get_8 (abfd, contents + irel->r_offset
2323                                  + insn_size);
2324                   }
2325
2326                 if ((0x95 == next_insn_msb) && (0x08 == next_insn_lsb))
2327                   {
2328                     /* The next insn is a ret. We possibly could delete
2329                        this ret. First we need to check for preceding
2330                        sbis/sbic/sbrs or cpse "skip" instructions.  */
2331
2332                     int there_is_preceding_non_skip_insn = 1;
2333                     bfd_vma address_of_ret;
2334
2335                     address_of_ret = dot + insn_size;
2336
2337                     if (debug_relax && (insn_size == 2))
2338                       printf ("found rjmp / ret sequence at address 0x%x\n",
2339                               (int) dot);
2340                     if (debug_relax && (insn_size == 4))
2341                       printf ("found jmp / ret sequence at address 0x%x\n",
2342                               (int) dot);
2343
2344                     /* We have to make sure that there is a preceding insn.  */
2345                     if (irel->r_offset >= 2)
2346                       {
2347                         unsigned char preceding_msb;
2348                         unsigned char preceding_lsb;
2349
2350                         preceding_msb =
2351                           bfd_get_8 (abfd, contents + irel->r_offset - 1);
2352                         preceding_lsb =
2353                           bfd_get_8 (abfd, contents + irel->r_offset - 2);
2354
2355                         /* sbic.  */
2356                         if (0x99 == preceding_msb)
2357                           there_is_preceding_non_skip_insn = 0;
2358
2359                         /* sbis.  */
2360                         if (0x9b == preceding_msb)
2361                           there_is_preceding_non_skip_insn = 0;
2362
2363                         /* sbrc */
2364                         if ((0xfc == (preceding_msb & 0xfe)
2365                              && (0x00 == (preceding_lsb & 0x08))))
2366                           there_is_preceding_non_skip_insn = 0;
2367
2368                         /* sbrs */
2369                         if ((0xfe == (preceding_msb & 0xfe)
2370                              && (0x00 == (preceding_lsb & 0x08))))
2371                           there_is_preceding_non_skip_insn = 0;
2372
2373                         /* cpse */
2374                         if (0x10 == (preceding_msb & 0xfc))
2375                           there_is_preceding_non_skip_insn = 0;
2376
2377                         if (there_is_preceding_non_skip_insn == 0)
2378                           if (debug_relax)
2379                             printf ("preceding skip insn prevents deletion of"
2380                                     " ret insn at Addy 0x%x in section %s\n",
2381                                     (int) dot + 2, sec->name);
2382                       }
2383                     else
2384                       {
2385                         /* There is no previous instruction.  */
2386                         there_is_preceding_non_skip_insn = 0;
2387                       }
2388
2389                     if (there_is_preceding_non_skip_insn)
2390                       {
2391                         /* We now only have to make sure that there is no
2392                            local label defined at the address of the ret
2393                            instruction and that there is no local relocation
2394                            in this section pointing to the ret.  */
2395
2396                         int deleting_ret_is_safe = 1;
2397                         unsigned int section_offset_of_ret_insn =
2398                           irel->r_offset + insn_size;
2399                         Elf_Internal_Sym *isym, *isymend;
2400                         unsigned int sec_shndx;
2401                         struct bfd_section *isec;
2402
2403                         sec_shndx =
2404                           _bfd_elf_section_from_bfd_section (abfd, sec);
2405
2406                         /* Check for local symbols.  */
2407                         isym = (Elf_Internal_Sym *) symtab_hdr->contents;
2408                         isymend = isym + symtab_hdr->sh_info;
2409                         /* PR 6019: There may not be any local symbols.  */
2410                         for (; isym != NULL && isym < isymend; isym++)
2411                           {
2412                             if (isym->st_value == section_offset_of_ret_insn
2413                                 && isym->st_shndx == sec_shndx)
2414                               {
2415                                 deleting_ret_is_safe = 0;
2416                                 if (debug_relax)
2417                                   printf ("local label prevents deletion of ret "
2418                                           "insn at address 0x%x\n",
2419                                           (int) dot + insn_size);
2420                               }
2421                           }
2422
2423                         /* Now check for global symbols.  */
2424                         {
2425                           int symcount;
2426                           struct elf_link_hash_entry **sym_hashes;
2427                           struct elf_link_hash_entry **end_hashes;
2428
2429                           symcount = (symtab_hdr->sh_size
2430                                       / sizeof (Elf32_External_Sym)
2431                                       - symtab_hdr->sh_info);
2432                           sym_hashes = elf_sym_hashes (abfd);
2433                           end_hashes = sym_hashes + symcount;
2434                           for (; sym_hashes < end_hashes; sym_hashes++)
2435                             {
2436                               struct elf_link_hash_entry *sym_hash =
2437                                 *sym_hashes;
2438                               if ((sym_hash->root.type == bfd_link_hash_defined
2439                                    || sym_hash->root.type ==
2440                                    bfd_link_hash_defweak)
2441                                   && sym_hash->root.u.def.section == sec
2442                                   && sym_hash->root.u.def.value == section_offset_of_ret_insn)
2443                                 {
2444                                   deleting_ret_is_safe = 0;
2445                                   if (debug_relax)
2446                                     printf ("global label prevents deletion of "
2447                                             "ret insn at address 0x%x\n",
2448                                             (int) dot + insn_size);
2449                                 }
2450                             }
2451                         }
2452
2453                         /* Now we check for relocations pointing to ret.  */
2454                         for (isec = abfd->sections; isec && deleting_ret_is_safe; isec = isec->next)
2455                           {
2456                             Elf_Internal_Rela *rel;
2457                             Elf_Internal_Rela *relend;
2458
2459                             rel = elf_section_data (isec)->relocs;
2460                             if (rel == NULL)
2461                               rel = _bfd_elf_link_read_relocs (abfd, isec, NULL, NULL, TRUE);
2462
2463                             relend = rel + isec->reloc_count;
2464
2465                             for (; rel && rel < relend; rel++)
2466                               {
2467                                 bfd_vma reloc_target = 0;
2468
2469                                 /* Read this BFD's local symbols if we haven't
2470                                    done so already.  */
2471                                 if (isymbuf == NULL && symtab_hdr->sh_info != 0)
2472                                   {
2473                                     isymbuf = (Elf_Internal_Sym *)
2474                                       symtab_hdr->contents;
2475                                     if (isymbuf == NULL)
2476                                       isymbuf = bfd_elf_get_elf_syms
2477                                         (abfd,
2478                                          symtab_hdr,
2479                                          symtab_hdr->sh_info, 0,
2480                                          NULL, NULL, NULL);
2481                                     if (isymbuf == NULL)
2482                                       break;
2483                                   }
2484
2485                                 /* Get the value of the symbol referred to
2486                                    by the reloc.  */
2487                                 if (ELF32_R_SYM (rel->r_info)
2488                                     < symtab_hdr->sh_info)
2489                                   {
2490                                     /* A local symbol.  */
2491                                     asection *sym_sec;
2492
2493                                     isym = isymbuf
2494                                       + ELF32_R_SYM (rel->r_info);
2495                                     sym_sec = bfd_section_from_elf_index
2496                                       (abfd, isym->st_shndx);
2497                                     symval = isym->st_value;
2498
2499                                     /* If the reloc is absolute, it will not
2500                                        have a symbol or section associated
2501                                        with it.  */
2502
2503                                     if (sym_sec)
2504                                       {
2505                                         symval +=
2506                                           sym_sec->output_section->vma
2507                                           + sym_sec->output_offset;
2508                                         reloc_target = symval + rel->r_addend;
2509                                       }
2510                                     else
2511                                       {
2512                                         reloc_target = symval + rel->r_addend;
2513                                         /* Reference symbol is absolute.  */
2514                                       }
2515                                   }
2516                                 /* else ... reference symbol is extern.  */
2517
2518                                 if (address_of_ret == reloc_target)
2519                                   {
2520                                     deleting_ret_is_safe = 0;
2521                                     if (debug_relax)
2522                                       printf ("ret from "
2523                                               "rjmp/jmp ret sequence at address"
2524                                               " 0x%x could not be deleted. ret"
2525                                               " is target of a relocation.\n",
2526                                               (int) address_of_ret);
2527                                     break;
2528                                   }
2529                               }
2530                           }
2531
2532                         if (deleting_ret_is_safe)
2533                           {
2534                             if (debug_relax)
2535                               printf ("unreachable ret instruction "
2536                                       "at address 0x%x deleted.\n",
2537                                       (int) dot + insn_size);
2538
2539                             /* Delete two bytes of data.  */
2540                             if (!elf32_avr_relax_delete_bytes (abfd, sec,
2541                                                                irel->r_offset + insn_size, 2))
2542                               goto error_return;
2543
2544                             /* That will change things, so, we should relax
2545                                again. Note that this is not required, and it
2546                                may be slow.  */
2547                             *again = TRUE;
2548                             break;
2549                           }
2550                       }
2551                   }
2552               }
2553             break;
2554           }
2555         }
2556     }
2557
2558   if (contents != NULL
2559       && elf_section_data (sec)->this_hdr.contents != contents)
2560     {
2561       if (! link_info->keep_memory)
2562         free (contents);
2563       else
2564         {
2565           /* Cache the section contents for elf_link_input_bfd.  */
2566           elf_section_data (sec)->this_hdr.contents = contents;
2567         }
2568     }
2569
2570   if (internal_relocs != NULL
2571       && elf_section_data (sec)->relocs != internal_relocs)
2572     free (internal_relocs);
2573
2574   return TRUE;
2575
2576  error_return:
2577   if (isymbuf != NULL
2578       && symtab_hdr->contents != (unsigned char *) isymbuf)
2579     free (isymbuf);
2580   if (contents != NULL
2581       && elf_section_data (sec)->this_hdr.contents != contents)
2582     free (contents);
2583   if (internal_relocs != NULL
2584       && elf_section_data (sec)->relocs != internal_relocs)
2585     free (internal_relocs);
2586
2587   return FALSE;
2588 }
2589
2590 /* This is a version of bfd_generic_get_relocated_section_contents
2591    which uses elf32_avr_relocate_section.
2592
2593    For avr it's essentially a cut and paste taken from the H8300 port.
2594    The author of the relaxation support patch for avr had absolutely no
2595    clue what is happening here but found out that this part of the code
2596    seems to be important.  */
2597
2598 static bfd_byte *
2599 elf32_avr_get_relocated_section_contents (bfd *output_bfd,
2600                                           struct bfd_link_info *link_info,
2601                                           struct bfd_link_order *link_order,
2602                                           bfd_byte *data,
2603                                           bfd_boolean relocatable,
2604                                           asymbol **symbols)
2605 {
2606   Elf_Internal_Shdr *symtab_hdr;
2607   asection *input_section = link_order->u.indirect.section;
2608   bfd *input_bfd = input_section->owner;
2609   asection **sections = NULL;
2610   Elf_Internal_Rela *internal_relocs = NULL;
2611   Elf_Internal_Sym *isymbuf = NULL;
2612
2613   /* We only need to handle the case of relaxing, or of having a
2614      particular set of section contents, specially.  */
2615   if (relocatable
2616       || elf_section_data (input_section)->this_hdr.contents == NULL)
2617     return bfd_generic_get_relocated_section_contents (output_bfd, link_info,
2618                                                        link_order, data,
2619                                                        relocatable,
2620                                                        symbols);
2621   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2622
2623   memcpy (data, elf_section_data (input_section)->this_hdr.contents,
2624           (size_t) input_section->size);
2625
2626   if ((input_section->flags & SEC_RELOC) != 0
2627       && input_section->reloc_count > 0)
2628     {
2629       asection **secpp;
2630       Elf_Internal_Sym *isym, *isymend;
2631       bfd_size_type amt;
2632
2633       internal_relocs = (_bfd_elf_link_read_relocs
2634                          (input_bfd, input_section, NULL, NULL, FALSE));
2635       if (internal_relocs == NULL)
2636         goto error_return;
2637
2638       if (symtab_hdr->sh_info != 0)
2639         {
2640           isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
2641           if (isymbuf == NULL)
2642             isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
2643                                             symtab_hdr->sh_info, 0,
2644                                             NULL, NULL, NULL);
2645           if (isymbuf == NULL)
2646             goto error_return;
2647         }
2648
2649       amt = symtab_hdr->sh_info;
2650       amt *= sizeof (asection *);
2651       sections = bfd_malloc (amt);
2652       if (sections == NULL && amt != 0)
2653         goto error_return;
2654
2655       isymend = isymbuf + symtab_hdr->sh_info;
2656       for (isym = isymbuf, secpp = sections; isym < isymend; ++isym, ++secpp)
2657         {
2658           asection *isec;
2659
2660           if (isym->st_shndx == SHN_UNDEF)
2661             isec = bfd_und_section_ptr;
2662           else if (isym->st_shndx == SHN_ABS)
2663             isec = bfd_abs_section_ptr;
2664           else if (isym->st_shndx == SHN_COMMON)
2665             isec = bfd_com_section_ptr;
2666           else
2667             isec = bfd_section_from_elf_index (input_bfd, isym->st_shndx);
2668
2669           *secpp = isec;
2670         }
2671
2672       if (! elf32_avr_relocate_section (output_bfd, link_info, input_bfd,
2673                                         input_section, data, internal_relocs,
2674                                         isymbuf, sections))
2675         goto error_return;
2676
2677       if (sections != NULL)
2678         free (sections);
2679       if (isymbuf != NULL
2680           && symtab_hdr->contents != (unsigned char *) isymbuf)
2681         free (isymbuf);
2682       if (elf_section_data (input_section)->relocs != internal_relocs)
2683         free (internal_relocs);
2684     }
2685
2686   return data;
2687
2688  error_return:
2689   if (sections != NULL)
2690     free (sections);
2691   if (isymbuf != NULL
2692       && symtab_hdr->contents != (unsigned char *) isymbuf)
2693     free (isymbuf);
2694   if (internal_relocs != NULL
2695       && elf_section_data (input_section)->relocs != internal_relocs)
2696     free (internal_relocs);
2697   return NULL;
2698 }
2699
2700
2701 /* Determines the hash entry name for a particular reloc. It consists of
2702    the identifier of the symbol section and the added reloc addend and
2703    symbol offset relative to the section the symbol is attached to.  */
2704
2705 static char *
2706 avr_stub_name (const asection *symbol_section,
2707                const bfd_vma symbol_offset,
2708                const Elf_Internal_Rela *rela)
2709 {
2710   char *stub_name;
2711   bfd_size_type len;
2712
2713   len = 8 + 1 + 8 + 1 + 1;
2714   stub_name = bfd_malloc (len);
2715
2716   sprintf (stub_name, "%08x+%08x",
2717            symbol_section->id & 0xffffffff,
2718            (unsigned int) ((rela->r_addend & 0xffffffff) + symbol_offset));
2719
2720   return stub_name;
2721 }
2722
2723
2724 /* Add a new stub entry to the stub hash.  Not all fields of the new
2725    stub entry are initialised.  */
2726
2727 static struct elf32_avr_stub_hash_entry *
2728 avr_add_stub (const char *stub_name,
2729               struct elf32_avr_link_hash_table *htab)
2730 {
2731   struct elf32_avr_stub_hash_entry *hsh;
2732
2733   /* Enter this entry into the linker stub hash table.  */
2734   hsh = avr_stub_hash_lookup (&htab->bstab, stub_name, TRUE, FALSE);
2735
2736   if (hsh == NULL)
2737     {
2738       (*_bfd_error_handler) (_("%B: cannot create stub entry %s"),
2739                              NULL, stub_name);
2740       return NULL;
2741     }
2742
2743   hsh->stub_offset = 0;
2744   return hsh;
2745 }
2746
2747 /* We assume that there is already space allocated for the stub section
2748    contents and that before building the stubs the section size is
2749    initialized to 0.  We assume that within the stub hash table entry,
2750    the absolute position of the jmp target has been written in the
2751    target_value field.  We write here the offset of the generated jmp insn
2752    relative to the trampoline section start to the stub_offset entry in
2753    the stub hash table entry.  */
2754
2755 static  bfd_boolean
2756 avr_build_one_stub (struct bfd_hash_entry *bh, void *in_arg)
2757 {
2758   struct elf32_avr_stub_hash_entry *hsh;
2759   struct bfd_link_info *info;
2760   struct elf32_avr_link_hash_table *htab;
2761   bfd *stub_bfd;
2762   bfd_byte *loc;
2763   bfd_vma target;
2764   bfd_vma starget;
2765
2766   /* Basic opcode */
2767   bfd_vma jmp_insn = 0x0000940c;
2768
2769   /* Massage our args to the form they really have.  */
2770   hsh = avr_stub_hash_entry (bh);
2771
2772   if (!hsh->is_actually_needed)
2773     return TRUE;
2774
2775   info = (struct bfd_link_info *) in_arg;
2776
2777   htab = avr_link_hash_table (info);
2778   if (htab == NULL)
2779     return FALSE;
2780
2781   target = hsh->target_value;
2782
2783   /* Make a note of the offset within the stubs for this entry.  */
2784   hsh->stub_offset = htab->stub_sec->size;
2785   loc = htab->stub_sec->contents + hsh->stub_offset;
2786
2787   stub_bfd = htab->stub_sec->owner;
2788
2789   if (debug_stubs)
2790     printf ("Building one Stub. Address: 0x%x, Offset: 0x%x\n",
2791              (unsigned int) target,
2792              (unsigned int) hsh->stub_offset);
2793
2794   /* We now have to add the information on the jump target to the bare
2795      opcode bits already set in jmp_insn.  */
2796
2797   /* Check for the alignment of the address.  */
2798   if (target & 1)
2799      return FALSE;
2800
2801   starget = target >> 1;
2802   jmp_insn |= ((starget & 0x10000) | ((starget << 3) & 0x1f00000)) >> 16;
2803   bfd_put_16 (stub_bfd, jmp_insn, loc);
2804   bfd_put_16 (stub_bfd, (bfd_vma) starget & 0xffff, loc + 2);
2805
2806   htab->stub_sec->size += 4;
2807
2808   /* Now add the entries in the address mapping table if there is still
2809      space left.  */
2810   {
2811     unsigned int nr;
2812
2813     nr = htab->amt_entry_cnt + 1;
2814     if (nr <= htab->amt_max_entry_cnt)
2815       {
2816         htab->amt_entry_cnt = nr;
2817
2818         htab->amt_stub_offsets[nr - 1] = hsh->stub_offset;
2819         htab->amt_destination_addr[nr - 1] = target;
2820       }
2821   }
2822
2823   return TRUE;
2824 }
2825
2826 static bfd_boolean
2827 avr_mark_stub_not_to_be_necessary (struct bfd_hash_entry *bh,
2828                                    void *in_arg ATTRIBUTE_UNUSED)
2829 {
2830   struct elf32_avr_stub_hash_entry *hsh;
2831
2832   hsh = avr_stub_hash_entry (bh);
2833   hsh->is_actually_needed = FALSE;
2834
2835   return TRUE;
2836 }
2837
2838 static bfd_boolean
2839 avr_size_one_stub (struct bfd_hash_entry *bh, void *in_arg)
2840 {
2841   struct elf32_avr_stub_hash_entry *hsh;
2842   struct elf32_avr_link_hash_table *htab;
2843   int size;
2844
2845   /* Massage our args to the form they really have.  */
2846   hsh = avr_stub_hash_entry (bh);
2847   htab = in_arg;
2848
2849   if (hsh->is_actually_needed)
2850     size = 4;
2851   else
2852     size = 0;
2853
2854   htab->stub_sec->size += size;
2855   return TRUE;
2856 }
2857
2858 void
2859 elf32_avr_setup_params (struct bfd_link_info *info,
2860                         bfd *avr_stub_bfd,
2861                         asection *avr_stub_section,
2862                         bfd_boolean no_stubs,
2863                         bfd_boolean deb_stubs,
2864                         bfd_boolean deb_relax,
2865                         bfd_vma pc_wrap_around,
2866                         bfd_boolean call_ret_replacement)
2867 {
2868   struct elf32_avr_link_hash_table *htab = avr_link_hash_table (info);
2869
2870   if (htab == NULL)
2871     return;
2872   htab->stub_sec = avr_stub_section;
2873   htab->stub_bfd = avr_stub_bfd;
2874   htab->no_stubs = no_stubs;
2875
2876   debug_relax = deb_relax;
2877   debug_stubs = deb_stubs;
2878   avr_pc_wrap_around = pc_wrap_around;
2879   avr_replace_call_ret_sequences = call_ret_replacement;
2880 }
2881
2882
2883 /* Set up various things so that we can make a list of input sections
2884    for each output section included in the link.  Returns -1 on error,
2885    0 when no stubs will be needed, and 1 on success.  It also sets
2886    information on the stubs bfd and the stub section in the info
2887    struct.  */
2888
2889 int
2890 elf32_avr_setup_section_lists (bfd *output_bfd,
2891                                struct bfd_link_info *info)
2892 {
2893   bfd *input_bfd;
2894   unsigned int bfd_count;
2895   int top_id, top_index;
2896   asection *section;
2897   asection **input_list, **list;
2898   bfd_size_type amt;
2899   struct elf32_avr_link_hash_table *htab = avr_link_hash_table (info);
2900
2901   if (htab == NULL || htab->no_stubs)
2902     return 0;
2903
2904   /* Count the number of input BFDs and find the top input section id.  */
2905   for (input_bfd = info->input_bfds, bfd_count = 0, top_id = 0;
2906        input_bfd != NULL;
2907        input_bfd = input_bfd->link.next)
2908     {
2909       bfd_count += 1;
2910       for (section = input_bfd->sections;
2911            section != NULL;
2912            section = section->next)
2913         if (top_id < section->id)
2914           top_id = section->id;
2915     }
2916
2917   htab->bfd_count = bfd_count;
2918
2919   /* We can't use output_bfd->section_count here to find the top output
2920      section index as some sections may have been removed, and
2921      strip_excluded_output_sections doesn't renumber the indices.  */
2922   for (section = output_bfd->sections, top_index = 0;
2923        section != NULL;
2924        section = section->next)
2925     if (top_index < section->index)
2926       top_index = section->index;
2927
2928   htab->top_index = top_index;
2929   amt = sizeof (asection *) * (top_index + 1);
2930   input_list = bfd_malloc (amt);
2931   htab->input_list = input_list;
2932   if (input_list == NULL)
2933     return -1;
2934
2935   /* For sections we aren't interested in, mark their entries with a
2936      value we can check later.  */
2937   list = input_list + top_index;
2938   do
2939     *list = bfd_abs_section_ptr;
2940   while (list-- != input_list);
2941
2942   for (section = output_bfd->sections;
2943        section != NULL;
2944        section = section->next)
2945     if ((section->flags & SEC_CODE) != 0)
2946       input_list[section->index] = NULL;
2947
2948   return 1;
2949 }
2950
2951
2952 /* Read in all local syms for all input bfds, and create hash entries
2953    for export stubs if we are building a multi-subspace shared lib.
2954    Returns -1 on error, 0 otherwise.  */
2955
2956 static int
2957 get_local_syms (bfd *input_bfd, struct bfd_link_info *info)
2958 {
2959   unsigned int bfd_indx;
2960   Elf_Internal_Sym *local_syms, **all_local_syms;
2961   struct elf32_avr_link_hash_table *htab = avr_link_hash_table (info);
2962   bfd_size_type amt;
2963
2964   if (htab == NULL)
2965     return -1;
2966
2967   /* We want to read in symbol extension records only once.  To do this
2968      we need to read in the local symbols in parallel and save them for
2969      later use; so hold pointers to the local symbols in an array.  */
2970   amt = sizeof (Elf_Internal_Sym *) * htab->bfd_count;
2971   all_local_syms = bfd_zmalloc (amt);
2972   htab->all_local_syms = all_local_syms;
2973   if (all_local_syms == NULL)
2974     return -1;
2975
2976   /* Walk over all the input BFDs, swapping in local symbols.
2977      If we are creating a shared library, create hash entries for the
2978      export stubs.  */
2979   for (bfd_indx = 0;
2980        input_bfd != NULL;
2981        input_bfd = input_bfd->link.next, bfd_indx++)
2982     {
2983       Elf_Internal_Shdr *symtab_hdr;
2984
2985       /* We'll need the symbol table in a second.  */
2986       symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2987       if (symtab_hdr->sh_info == 0)
2988         continue;
2989
2990       /* We need an array of the local symbols attached to the input bfd.  */
2991       local_syms = (Elf_Internal_Sym *) symtab_hdr->contents;
2992       if (local_syms == NULL)
2993         {
2994           local_syms = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
2995                                              symtab_hdr->sh_info, 0,
2996                                              NULL, NULL, NULL);
2997           /* Cache them for elf_link_input_bfd.  */
2998           symtab_hdr->contents = (unsigned char *) local_syms;
2999         }
3000       if (local_syms == NULL)
3001         return -1;
3002
3003       all_local_syms[bfd_indx] = local_syms;
3004     }
3005
3006   return 0;
3007 }
3008
3009 #define ADD_DUMMY_STUBS_FOR_DEBUGGING 0
3010
3011 bfd_boolean
3012 elf32_avr_size_stubs (bfd *output_bfd,
3013                       struct bfd_link_info *info,
3014                       bfd_boolean is_prealloc_run)
3015 {
3016   struct elf32_avr_link_hash_table *htab;
3017   int stub_changed = 0;
3018
3019   htab = avr_link_hash_table (info);
3020   if (htab == NULL)
3021     return FALSE;
3022
3023   /* At this point we initialize htab->vector_base
3024      To the start of the text output section.  */
3025   htab->vector_base = htab->stub_sec->output_section->vma;
3026
3027   if (get_local_syms (info->input_bfds, info))
3028     {
3029       if (htab->all_local_syms)
3030         goto error_ret_free_local;
3031       return FALSE;
3032     }
3033
3034   if (ADD_DUMMY_STUBS_FOR_DEBUGGING)
3035     {
3036       struct elf32_avr_stub_hash_entry *test;
3037
3038       test = avr_add_stub ("Hugo",htab);
3039       test->target_value = 0x123456;
3040       test->stub_offset = 13;
3041
3042       test = avr_add_stub ("Hugo2",htab);
3043       test->target_value = 0x84210;
3044       test->stub_offset = 14;
3045     }
3046
3047   while (1)
3048     {
3049       bfd *input_bfd;
3050       unsigned int bfd_indx;
3051
3052       /* We will have to re-generate the stub hash table each time anything
3053          in memory has changed.  */
3054
3055       bfd_hash_traverse (&htab->bstab, avr_mark_stub_not_to_be_necessary, htab);
3056       for (input_bfd = info->input_bfds, bfd_indx = 0;
3057            input_bfd != NULL;
3058            input_bfd = input_bfd->link.next, bfd_indx++)
3059         {
3060           Elf_Internal_Shdr *symtab_hdr;
3061           asection *section;
3062           Elf_Internal_Sym *local_syms;
3063
3064           /* We'll need the symbol table in a second.  */
3065           symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
3066           if (symtab_hdr->sh_info == 0)
3067             continue;
3068
3069           local_syms = htab->all_local_syms[bfd_indx];
3070
3071           /* Walk over each section attached to the input bfd.  */
3072           for (section = input_bfd->sections;
3073                section != NULL;
3074                section = section->next)
3075             {
3076               Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
3077
3078               /* If there aren't any relocs, then there's nothing more
3079                  to do.  */
3080               if ((section->flags & SEC_RELOC) == 0
3081                   || section->reloc_count == 0)
3082                 continue;
3083
3084               /* If this section is a link-once section that will be
3085                  discarded, then don't create any stubs.  */
3086               if (section->output_section == NULL
3087                   || section->output_section->owner != output_bfd)
3088                 continue;
3089
3090               /* Get the relocs.  */
3091               internal_relocs
3092                 = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL,
3093                                              info->keep_memory);
3094               if (internal_relocs == NULL)
3095                 goto error_ret_free_local;
3096
3097               /* Now examine each relocation.  */
3098               irela = internal_relocs;
3099               irelaend = irela + section->reloc_count;
3100               for (; irela < irelaend; irela++)
3101                 {
3102                   unsigned int r_type, r_indx;
3103                   struct elf32_avr_stub_hash_entry *hsh;
3104                   asection *sym_sec;
3105                   bfd_vma sym_value;
3106                   bfd_vma destination;
3107                   struct elf_link_hash_entry *hh;
3108                   char *stub_name;
3109
3110                   r_type = ELF32_R_TYPE (irela->r_info);
3111                   r_indx = ELF32_R_SYM (irela->r_info);
3112
3113                   /* Only look for 16 bit GS relocs. No other reloc will need a
3114                      stub.  */
3115                   if (!((r_type == R_AVR_16_PM)
3116                         || (r_type == R_AVR_LO8_LDI_GS)
3117                         || (r_type == R_AVR_HI8_LDI_GS)))
3118                     continue;
3119
3120                   /* Now determine the call target, its name, value,
3121                      section.  */
3122                   sym_sec = NULL;
3123                   sym_value = 0;
3124                   destination = 0;
3125                   hh = NULL;
3126                   if (r_indx < symtab_hdr->sh_info)
3127                     {
3128                       /* It's a local symbol.  */
3129                       Elf_Internal_Sym *sym;
3130                       Elf_Internal_Shdr *hdr;
3131                       unsigned int shndx;
3132
3133                       sym = local_syms + r_indx;
3134                       if (ELF_ST_TYPE (sym->st_info) != STT_SECTION)
3135                         sym_value = sym->st_value;
3136                       shndx = sym->st_shndx;
3137                       if (shndx < elf_numsections (input_bfd))
3138                         {
3139                           hdr = elf_elfsections (input_bfd)[shndx];
3140                           sym_sec = hdr->bfd_section;
3141                           destination = (sym_value + irela->r_addend
3142                                          + sym_sec->output_offset
3143                                          + sym_sec->output_section->vma);
3144                         }
3145                     }
3146                   else
3147                     {
3148                       /* It's an external symbol.  */
3149                       int e_indx;
3150
3151                       e_indx = r_indx - symtab_hdr->sh_info;
3152                       hh = elf_sym_hashes (input_bfd)[e_indx];
3153
3154                       while (hh->root.type == bfd_link_hash_indirect
3155                              || hh->root.type == bfd_link_hash_warning)
3156                         hh = (struct elf_link_hash_entry *)
3157                               (hh->root.u.i.link);
3158
3159                       if (hh->root.type == bfd_link_hash_defined
3160                           || hh->root.type == bfd_link_hash_defweak)
3161                         {
3162                           sym_sec = hh->root.u.def.section;
3163                           sym_value = hh->root.u.def.value;
3164                           if (sym_sec->output_section != NULL)
3165                           destination = (sym_value + irela->r_addend
3166                                          + sym_sec->output_offset
3167                                          + sym_sec->output_section->vma);
3168                         }
3169                       else if (hh->root.type == bfd_link_hash_undefweak)
3170                         {
3171                           if (! info->shared)
3172                             continue;
3173                         }
3174                       else if (hh->root.type == bfd_link_hash_undefined)
3175                         {
3176                           if (! (info->unresolved_syms_in_objects == RM_IGNORE
3177                                  && (ELF_ST_VISIBILITY (hh->other)
3178                                      == STV_DEFAULT)))
3179                              continue;
3180                         }
3181                       else
3182                         {
3183                           bfd_set_error (bfd_error_bad_value);
3184
3185                           error_ret_free_internal:
3186                           if (elf_section_data (section)->relocs == NULL)
3187                             free (internal_relocs);
3188                           goto error_ret_free_local;
3189                         }
3190                     }
3191
3192                   if (! avr_stub_is_required_for_16_bit_reloc
3193                       (destination - htab->vector_base))
3194                     {
3195                       if (!is_prealloc_run)
3196                         /* We are having a reloc that does't need a stub.  */
3197                         continue;
3198
3199                       /* We don't right now know if a stub will be needed.
3200                          Let's rather be on the safe side.  */
3201                     }
3202
3203                   /* Get the name of this stub.  */
3204                   stub_name = avr_stub_name (sym_sec, sym_value, irela);
3205
3206                   if (!stub_name)
3207                     goto error_ret_free_internal;
3208
3209
3210                   hsh = avr_stub_hash_lookup (&htab->bstab,
3211                                               stub_name,
3212                                               FALSE, FALSE);
3213                   if (hsh != NULL)
3214                     {
3215                       /* The proper stub has already been created.  Mark it
3216                          to be used and write the possibly changed destination
3217                          value.  */
3218                       hsh->is_actually_needed = TRUE;
3219                       hsh->target_value = destination;
3220                       free (stub_name);
3221                       continue;
3222                     }
3223
3224                   hsh = avr_add_stub (stub_name, htab);
3225                   if (hsh == NULL)
3226                     {
3227                       free (stub_name);
3228                       goto error_ret_free_internal;
3229                     }
3230
3231                   hsh->is_actually_needed = TRUE;
3232                   hsh->target_value = destination;
3233
3234                   if (debug_stubs)
3235                     printf ("Adding stub with destination 0x%x to the"
3236                             " hash table.\n", (unsigned int) destination);
3237                   if (debug_stubs)
3238                     printf ("(Pre-Alloc run: %i)\n", is_prealloc_run);
3239
3240                   stub_changed = TRUE;
3241                 }
3242
3243               /* We're done with the internal relocs, free them.  */
3244               if (elf_section_data (section)->relocs == NULL)
3245                 free (internal_relocs);
3246             }
3247         }
3248
3249       /* Re-Calculate the number of needed stubs.  */
3250       htab->stub_sec->size = 0;
3251       bfd_hash_traverse (&htab->bstab, avr_size_one_stub, htab);
3252
3253       if (!stub_changed)
3254         break;
3255
3256       stub_changed = FALSE;
3257     }
3258
3259   free (htab->all_local_syms);
3260   return TRUE;
3261
3262  error_ret_free_local:
3263   free (htab->all_local_syms);
3264   return FALSE;
3265 }
3266
3267
3268 /* Build all the stubs associated with the current output file.  The
3269    stubs are kept in a hash table attached to the main linker hash
3270    table.  We also set up the .plt entries for statically linked PIC
3271    functions here.  This function is called via hppaelf_finish in the
3272    linker.  */
3273
3274 bfd_boolean
3275 elf32_avr_build_stubs (struct bfd_link_info *info)
3276 {
3277   asection *stub_sec;
3278   struct bfd_hash_table *table;
3279   struct elf32_avr_link_hash_table *htab;
3280   bfd_size_type total_size = 0;
3281
3282   htab = avr_link_hash_table (info);
3283   if (htab == NULL)
3284     return FALSE;
3285
3286   /* In case that there were several stub sections:  */
3287   for (stub_sec = htab->stub_bfd->sections;
3288        stub_sec != NULL;
3289        stub_sec = stub_sec->next)
3290     {
3291       bfd_size_type size;
3292
3293       /* Allocate memory to hold the linker stubs.  */
3294       size = stub_sec->size;
3295       total_size += size;
3296
3297       stub_sec->contents = bfd_zalloc (htab->stub_bfd, size);
3298       if (stub_sec->contents == NULL && size != 0)
3299         return FALSE;
3300       stub_sec->size = 0;
3301     }
3302
3303   /* Allocate memory for the adress mapping table.  */
3304   htab->amt_entry_cnt = 0;
3305   htab->amt_max_entry_cnt = total_size / 4;
3306   htab->amt_stub_offsets = bfd_malloc (sizeof (bfd_vma)
3307                                        * htab->amt_max_entry_cnt);
3308   htab->amt_destination_addr = bfd_malloc (sizeof (bfd_vma)
3309                                            * htab->amt_max_entry_cnt );
3310
3311   if (debug_stubs)
3312     printf ("Allocating %i entries in the AMT\n", htab->amt_max_entry_cnt);
3313
3314   /* Build the stubs as directed by the stub hash table.  */
3315   table = &htab->bstab;
3316   bfd_hash_traverse (table, avr_build_one_stub, info);
3317
3318   if (debug_stubs)
3319     printf ("Final Stub section Size: %i\n", (int) htab->stub_sec->size);
3320
3321   return TRUE;
3322 }
3323
3324 #define ELF_ARCH                bfd_arch_avr
3325 #define ELF_TARGET_ID           AVR_ELF_DATA
3326 #define ELF_MACHINE_CODE        EM_AVR
3327 #define ELF_MACHINE_ALT1        EM_AVR_OLD
3328 #define ELF_MAXPAGESIZE         1
3329
3330 #define TARGET_LITTLE_SYM       avr_elf32_vec
3331 #define TARGET_LITTLE_NAME      "elf32-avr"
3332
3333 #define bfd_elf32_bfd_link_hash_table_create elf32_avr_link_hash_table_create
3334
3335 #define elf_info_to_howto                    avr_info_to_howto_rela
3336 #define elf_info_to_howto_rel                NULL
3337 #define elf_backend_relocate_section         elf32_avr_relocate_section
3338 #define elf_backend_can_gc_sections          1
3339 #define elf_backend_rela_normal              1
3340 #define elf_backend_final_write_processing \
3341                                         bfd_elf_avr_final_write_processing
3342 #define elf_backend_object_p            elf32_avr_object_p
3343
3344 #define bfd_elf32_bfd_relax_section elf32_avr_relax_section
3345 #define bfd_elf32_bfd_get_relocated_section_contents \
3346                                         elf32_avr_get_relocated_section_contents
3347
3348 #include "elf32-target.h"