bfd/elf32-avr.c

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