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