bfd/elf32-avr.c

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