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