bfd/elf32-avr.c

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