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