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