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