bfd/elf32-avr.c

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