bfd/elf32-avr.c

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