bfd/elf32-avr.c

   1 /* AVR-specific support for 32-bit ELF
   2    Copyright 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
   3    2010  Free Software Foundation, Inc.
   4    Contributed by Denis Chertykov <denisc@overta.ru>
   5
   6    This file is part of BFD, the Binary File Descriptor library.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 51 Franklin Street - Fifth Floor,
  21    Boston, MA 02110-1301, USA.  */
  22
  23 #include "sysdep.h"
  24 #include "bfd.h"
  25 #include "libbfd.h"
  26 #include "elf-bfd.h"
  27 #include "elf/avr.h"
  28 #include "elf32-avr.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 /* Hash table initialization and handling.  Code is taken from the hppa port
  37    and adapted to the needs of AVR.  */
  38
  39 /* We use two hash tables to hold information for linking avr objects.
  40
  41    The first is the elf32_avr_link_hash_table which is derived from the
  42    stanard ELF linker hash table.  We use this as a place to attach the other
  43    hash table and some static information.
  44
  45    The second is the stub hash table which is derived from the base BFD
  46    hash table.  The stub hash table holds the information on the linker
  47    stubs.  */
  48
  49 struct elf32_avr_stub_hash_entry
  50 {
  51   /* Base hash table entry structure.  */
  52   struct bfd_hash_entry bh_root;
  53
  54   /* Offset within stub_sec of the beginning of this stub.  */
  55   bfd_vma stub_offset;
  56
  57   /* Given the symbol's value and its section we can determine its final
  58      value when building the stubs (so the stub knows where to jump).  */
  59   bfd_vma target_value;
  60
  61   /* This way we could mark stubs to be no longer necessary.  */
  62   bfd_boolean is_actually_needed;
  63 };
  64
  65 struct elf32_avr_link_hash_table
  66 {
  67   /* The main hash table.  */
  68   struct elf_link_hash_table etab;
  69
  70   /* The stub hash table.  */
  71   struct bfd_hash_table bstab;
  72
  73   bfd_boolean no_stubs;
  74
  75   /* Linker stub bfd.  */
  76   bfd *stub_bfd;
  77
  78   /* The stub section.  */
  79   asection *stub_sec;
  80
  81   /* Usually 0, unless we are generating code for a bootloader.  Will
  82      be initialized by elf32_avr_size_stubs to the vma offset of the
  83      output section associated with the stub section.  */
  84   bfd_vma vector_base;
  85
  86   /* Assorted information used by elf32_avr_size_stubs.  */
  87   unsigned int        bfd_count;
  88   int                 top_index;
  89   asection **         input_list;
  90   Elf_Internal_Sym ** all_local_syms;
  91
  92   /* Tables for mapping vma beyond the 128k boundary to the address of the
  93      corresponding stub.  (AMT)
  94      "amt_max_entry_cnt" reflects the number of entries that memory is allocated
  95      for in the "amt_stub_offsets" and "amt_destination_addr" arrays.
  96      "amt_entry_cnt" informs how many of these entries actually contain
  97      useful data.  */
  98   unsigned int amt_entry_cnt;
  99   unsigned int amt_max_entry_cnt;
 100   bfd_vma *    amt_stub_offsets;
 101   bfd_vma *    amt_destination_addr;
 102 };
 103
 104 /* Various hash macros and functions.  */
 105 #define avr_link_hash_table(p) \
 106   /* PR 3874: Check that we have an AVR style hash table before using it.  */\
 107   (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
 108   == AVR_ELF_DATA ? ((struct elf32_avr_link_hash_table *) ((p)->hash)) : NULL)
 109
 110 #define avr_stub_hash_entry(ent) \
 111   ((struct elf32_avr_stub_hash_entry *)(ent))
 112
 113 #define avr_stub_hash_lookup(table, string, create, copy) \
 114   ((struct elf32_avr_stub_hash_entry *) \
 115    bfd_hash_lookup ((table), (string), (create), (copy)))
 116
 117 static reloc_howto_type elf_avr_howto_table[] =
 118 {
 119   HOWTO (R_AVR_NONE,            /* type */
 120          0,                     /* rightshift */
 121          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 122          32,                    /* bitsize */
 123          FALSE,                 /* pc_relative */
 124          0,                     /* bitpos */
 125          complain_overflow_bitfield, /* complain_on_overflow */
 126          bfd_elf_generic_reloc, /* special_function */
 127          "R_AVR_NONE",          /* name */
 128          FALSE,                 /* partial_inplace */
 129          0,                     /* src_mask */
 130          0,                     /* dst_mask */
 131          FALSE),                /* pcrel_offset */
 132
 133   HOWTO (R_AVR_32,              /* type */
 134          0,                     /* rightshift */
 135          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 136          32,                    /* bitsize */
 137          FALSE,                 /* pc_relative */
 138          0,                     /* bitpos */
 139          complain_overflow_bitfield, /* complain_on_overflow */
 140          bfd_elf_generic_reloc, /* special_function */
 141          "R_AVR_32",            /* name */
 142          FALSE,                 /* partial_inplace */
 143          0xffffffff,            /* src_mask */
 144          0xffffffff,            /* dst_mask */
 145          FALSE),                /* pcrel_offset */
 146
 147   /* A 7 bit PC relative relocation.  */
 148   HOWTO (R_AVR_7_PCREL,         /* type */
 149          1,                     /* rightshift */
 150          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 151          7,                     /* bitsize */
 152          TRUE,                  /* pc_relative */
 153          3,                     /* bitpos */
 154          complain_overflow_bitfield, /* complain_on_overflow */
 155          bfd_elf_generic_reloc, /* special_function */
 156          "R_AVR_7_PCREL",       /* name */
 157          FALSE,                 /* partial_inplace */
 158          0xffff,                /* src_mask */
 159          0xffff,                /* dst_mask */
 160          TRUE),                 /* pcrel_offset */
 161
 162   /* A 13 bit PC relative relocation.  */
 163   HOWTO (R_AVR_13_PCREL,        /* type */
 164          1,                     /* rightshift */
 165          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 166          13,                    /* bitsize */
 167          TRUE,                  /* pc_relative */
 168          0,                     /* bitpos */
 169          complain_overflow_bitfield, /* complain_on_overflow */
 170          bfd_elf_generic_reloc, /* special_function */
 171          "R_AVR_13_PCREL",      /* name */
 172          FALSE,                 /* partial_inplace */
 173          0xfff,                 /* src_mask */
 174          0xfff,                 /* dst_mask */
 175          TRUE),                 /* pcrel_offset */
 176
 177   /* A 16 bit absolute relocation.  */
 178   HOWTO (R_AVR_16,              /* type */
 179          0,                     /* rightshift */
 180          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 181          16,                    /* bitsize */
 182          FALSE,                 /* pc_relative */
 183          0,                     /* bitpos */
 184          complain_overflow_dont, /* complain_on_overflow */
 185          bfd_elf_generic_reloc, /* special_function */
 186          "R_AVR_16",            /* name */
 187          FALSE,                 /* partial_inplace */
 188          0xffff,                /* src_mask */
 189          0xffff,                /* dst_mask */
 190          FALSE),                /* pcrel_offset */
 191
 192   /* A 16 bit absolute relocation for command address
 193      Will be changed when linker stubs are needed.  */
 194   HOWTO (R_AVR_16_PM,           /* type */
 195          1,                     /* rightshift */
 196          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 197          16,                    /* bitsize */
 198          FALSE,                 /* pc_relative */
 199          0,                     /* bitpos */
 200          complain_overflow_bitfield, /* complain_on_overflow */
 201          bfd_elf_generic_reloc, /* special_function */
 202          "R_AVR_16_PM",         /* name */
 203          FALSE,                 /* partial_inplace */
 204          0xffff,                /* src_mask */
 205          0xffff,                /* dst_mask */
 206          FALSE),                /* pcrel_offset */
 207   /* A low 8 bit absolute relocation of 16 bit address.
 208      For LDI command.  */
 209   HOWTO (R_AVR_LO8_LDI,         /* type */
 210          0,                     /* rightshift */
 211          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 212          8,                     /* bitsize */
 213          FALSE,                 /* pc_relative */
 214          0,                     /* bitpos */
 215          complain_overflow_dont, /* complain_on_overflow */
 216          bfd_elf_generic_reloc, /* special_function */
 217          "R_AVR_LO8_LDI",       /* name */
 218          FALSE,                 /* partial_inplace */
 219          0xffff,                /* src_mask */
 220          0xffff,                /* dst_mask */
 221          FALSE),                /* pcrel_offset */
 222   /* A high 8 bit absolute relocation of 16 bit address.
 223      For LDI command.  */
 224   HOWTO (R_AVR_HI8_LDI,         /* type */
 225          8,                     /* rightshift */
 226          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 227          8,                     /* bitsize */
 228          FALSE,                 /* pc_relative */
 229          0,                     /* bitpos */
 230          complain_overflow_dont, /* complain_on_overflow */
 231          bfd_elf_generic_reloc, /* special_function */
 232          "R_AVR_HI8_LDI",       /* name */
 233          FALSE,                 /* partial_inplace */
 234          0xffff,                /* src_mask */
 235          0xffff,                /* dst_mask */
 236          FALSE),                /* pcrel_offset */
 237   /* A high 6 bit absolute relocation of 22 bit address.
 238      For LDI command.  As well second most significant 8 bit value of
 239      a 32 bit link-time constant.  */
 240   HOWTO (R_AVR_HH8_LDI,         /* type */
 241          16,                    /* rightshift */
 242          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 243          8,                     /* bitsize */
 244          FALSE,                 /* pc_relative */
 245          0,                     /* bitpos */
 246          complain_overflow_dont, /* complain_on_overflow */
 247          bfd_elf_generic_reloc, /* special_function */
 248          "R_AVR_HH8_LDI",       /* name */
 249          FALSE,                 /* partial_inplace */
 250          0xffff,                /* src_mask */
 251          0xffff,                /* dst_mask */
 252          FALSE),                /* pcrel_offset */
 253   /* A negative low 8 bit absolute relocation of 16 bit address.
 254      For LDI command.  */
 255   HOWTO (R_AVR_LO8_LDI_NEG,     /* type */
 256          0,                     /* rightshift */
 257          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 258          8,                     /* bitsize */
 259          FALSE,                 /* pc_relative */
 260          0,                     /* bitpos */
 261          complain_overflow_dont, /* complain_on_overflow */
 262          bfd_elf_generic_reloc, /* special_function */
 263          "R_AVR_LO8_LDI_NEG",   /* name */
 264          FALSE,                 /* partial_inplace */
 265          0xffff,                /* src_mask */
 266          0xffff,                /* dst_mask */
 267          FALSE),                /* pcrel_offset */
 268   /* A negative high 8 bit absolute relocation of 16 bit address.
 269      For LDI command.  */
 270   HOWTO (R_AVR_HI8_LDI_NEG,     /* type */
 271          8,                     /* rightshift */
 272          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 273          8,                     /* bitsize */
 274          FALSE,                 /* pc_relative */
 275          0,                     /* bitpos */
 276          complain_overflow_dont, /* complain_on_overflow */
 277          bfd_elf_generic_reloc, /* special_function */
 278          "R_AVR_HI8_LDI_NEG",   /* name */
 279          FALSE,                 /* partial_inplace */
 280          0xffff,                /* src_mask */
 281          0xffff,                /* dst_mask */
 282          FALSE),                /* pcrel_offset */
 283   /* A negative high 6 bit absolute relocation of 22 bit address.
 284      For LDI command.  */
 285   HOWTO (R_AVR_HH8_LDI_NEG,     /* type */
 286          16,                    /* rightshift */
 287          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 288          8,                     /* bitsize */
 289          FALSE,                 /* pc_relative */
 290          0,                     /* bitpos */
 291          complain_overflow_dont, /* complain_on_overflow */
 292          bfd_elf_generic_reloc, /* special_function */
 293          "R_AVR_HH8_LDI_NEG",   /* name */
 294          FALSE,                 /* partial_inplace */
 295          0xffff,                /* src_mask */
 296          0xffff,                /* dst_mask */
 297          FALSE),                /* pcrel_offset */
 298   /* A low 8 bit absolute relocation of 24 bit program memory address.
 299      For LDI command.  Will not be changed when linker stubs are needed. */
 300   HOWTO (R_AVR_LO8_LDI_PM,      /* type */
 301          1,                     /* rightshift */
 302          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 303          8,                     /* bitsize */
 304          FALSE,                 /* pc_relative */
 305          0,                     /* bitpos */
 306          complain_overflow_dont, /* complain_on_overflow */
 307          bfd_elf_generic_reloc, /* special_function */
 308          "R_AVR_LO8_LDI_PM",    /* name */
 309          FALSE,                 /* partial_inplace */
 310          0xffff,                /* src_mask */
 311          0xffff,                /* dst_mask */
 312          FALSE),                /* pcrel_offset */
 313   /* A low 8 bit absolute relocation of 24 bit program memory address.
 314      For LDI command.  Will not be changed when linker stubs are needed. */
 315   HOWTO (R_AVR_HI8_LDI_PM,      /* type */
 316          9,                     /* rightshift */
 317          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 318          8,                     /* bitsize */
 319          FALSE,                 /* pc_relative */
 320          0,                     /* bitpos */
 321          complain_overflow_dont, /* complain_on_overflow */
 322          bfd_elf_generic_reloc, /* special_function */
 323          "R_AVR_HI8_LDI_PM",    /* name */
 324          FALSE,                 /* partial_inplace */
 325          0xffff,                /* src_mask */
 326          0xffff,                /* dst_mask */
 327          FALSE),                /* pcrel_offset */
 328   /* A low 8 bit absolute relocation of 24 bit program memory address.
 329      For LDI command.  Will not be changed when linker stubs are needed. */
 330   HOWTO (R_AVR_HH8_LDI_PM,      /* type */
 331          17,                    /* rightshift */
 332          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 333          8,                     /* bitsize */
 334          FALSE,                 /* pc_relative */
 335          0,                     /* bitpos */
 336          complain_overflow_dont, /* complain_on_overflow */
 337          bfd_elf_generic_reloc, /* special_function */
 338          "R_AVR_HH8_LDI_PM",    /* name */
 339          FALSE,                 /* partial_inplace */
 340          0xffff,                /* src_mask */
 341          0xffff,                /* dst_mask */
 342          FALSE),                /* pcrel_offset */
 343   /* A low 8 bit absolute relocation of 24 bit program memory address.
 344      For LDI command.  Will not be changed when linker stubs are needed. */
 345   HOWTO (R_AVR_LO8_LDI_PM_NEG,  /* type */
 346          1,                     /* rightshift */
 347          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 348          8,                     /* bitsize */
 349          FALSE,                 /* pc_relative */
 350          0,                     /* bitpos */
 351          complain_overflow_dont, /* complain_on_overflow */
 352          bfd_elf_generic_reloc, /* special_function */
 353          "R_AVR_LO8_LDI_PM_NEG", /* name */
 354          FALSE,                 /* partial_inplace */
 355          0xffff,                /* src_mask */
 356          0xffff,                /* dst_mask */
 357          FALSE),                /* pcrel_offset */
 358   /* A low 8 bit absolute relocation of 24 bit program memory address.
 359      For LDI command.  Will not be changed when linker stubs are needed. */
 360   HOWTO (R_AVR_HI8_LDI_PM_NEG,  /* type */
 361          9,                     /* rightshift */
 362          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 363          8,                     /* bitsize */
 364          FALSE,                 /* pc_relative */
 365          0,                     /* bitpos */
 366          complain_overflow_dont, /* complain_on_overflow */
 367          bfd_elf_generic_reloc, /* special_function */
 368          "R_AVR_HI8_LDI_PM_NEG", /* name */
 369          FALSE,                 /* partial_inplace */
 370          0xffff,                /* src_mask */
 371          0xffff,                /* dst_mask */
 372          FALSE),                /* pcrel_offset */
 373   /* A low 8 bit absolute relocation of 24 bit program memory address.
 374      For LDI command.  Will not be changed when linker stubs are needed. */
 375   HOWTO (R_AVR_HH8_LDI_PM_NEG,  /* type */
 376          17,                    /* rightshift */
 377          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 378          8,                     /* bitsize */
 379          FALSE,                 /* pc_relative */
 380          0,                     /* bitpos */
 381          complain_overflow_dont, /* complain_on_overflow */
 382          bfd_elf_generic_reloc, /* special_function */
 383          "R_AVR_HH8_LDI_PM_NEG", /* name */
 384          FALSE,                 /* partial_inplace */
 385          0xffff,                /* src_mask */
 386          0xffff,                /* dst_mask */
 387          FALSE),                /* pcrel_offset */
 388   /* Relocation for CALL command in ATmega.  */
 389   HOWTO (R_AVR_CALL,            /* type */
 390          1,                     /* rightshift */
 391          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 392          23,                    /* bitsize */
 393          FALSE,                 /* pc_relative */
 394          0,                     /* bitpos */
 395          complain_overflow_dont,/* complain_on_overflow */
 396          bfd_elf_generic_reloc, /* special_function */
 397          "R_AVR_CALL",          /* name */
 398          FALSE,                 /* partial_inplace */
 399          0xffffffff,            /* src_mask */
 400          0xffffffff,            /* dst_mask */
 401          FALSE),                        /* pcrel_offset */
 402   /* A 16 bit absolute relocation of 16 bit address.
 403      For LDI command.  */
 404   HOWTO (R_AVR_LDI,             /* type */
 405          0,                     /* rightshift */
 406          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 407          16,                    /* bitsize */
 408          FALSE,                 /* pc_relative */
 409          0,                     /* bitpos */
 410          complain_overflow_dont,/* complain_on_overflow */
 411          bfd_elf_generic_reloc, /* special_function */
 412          "R_AVR_LDI",           /* name */
 413          FALSE,                 /* partial_inplace */
 414          0xffff,                /* src_mask */
 415          0xffff,                /* dst_mask */
 416          FALSE),                /* pcrel_offset */
 417   /* A 6 bit absolute relocation of 6 bit offset.
 418      For ldd/sdd command.  */
 419   HOWTO (R_AVR_6,               /* type */
 420          0,                     /* rightshift */
 421          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 422          6,                     /* bitsize */
 423          FALSE,                 /* pc_relative */
 424          0,                     /* bitpos */
 425          complain_overflow_dont,/* complain_on_overflow */
 426          bfd_elf_generic_reloc, /* special_function */
 427          "R_AVR_6",             /* name */
 428          FALSE,                 /* partial_inplace */
 429          0xffff,                /* src_mask */
 430          0xffff,                /* dst_mask */
 431          FALSE),                /* pcrel_offset */
 432   /* A 6 bit absolute relocation of 6 bit offset.
 433      For sbiw/adiw command.  */
 434   HOWTO (R_AVR_6_ADIW,          /* type */
 435          0,                     /* rightshift */
 436          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 437          6,                     /* bitsize */
 438          FALSE,                 /* pc_relative */
 439          0,                     /* bitpos */
 440          complain_overflow_dont,/* complain_on_overflow */
 441          bfd_elf_generic_reloc, /* special_function */
 442          "R_AVR_6_ADIW",        /* name */
 443          FALSE,                 /* partial_inplace */
 444          0xffff,                /* src_mask */
 445          0xffff,                /* dst_mask */
 446          FALSE),                /* pcrel_offset */
 447   /* Most significant 8 bit value of a 32 bit link-time constant.  */
 448   HOWTO (R_AVR_MS8_LDI,         /* type */
 449          24,                    /* rightshift */
 450          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 451          8,                     /* bitsize */
 452          FALSE,                 /* pc_relative */
 453          0,                     /* bitpos */
 454          complain_overflow_dont, /* complain_on_overflow */
 455          bfd_elf_generic_reloc, /* special_function */
 456          "R_AVR_MS8_LDI",       /* name */
 457          FALSE,                 /* partial_inplace */
 458          0xffff,                /* src_mask */
 459          0xffff,                /* dst_mask */
 460          FALSE),                /* pcrel_offset */
 461   /* Negative most significant 8 bit value of a 32 bit link-time constant.  */
 462   HOWTO (R_AVR_MS8_LDI_NEG,     /* type */
 463          24,                    /* rightshift */
 464          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 465          8,                     /* bitsize */
 466          FALSE,                 /* pc_relative */
 467          0,                     /* bitpos */
 468          complain_overflow_dont, /* complain_on_overflow */
 469          bfd_elf_generic_reloc, /* special_function */
 470          "R_AVR_MS8_LDI_NEG",   /* name */
 471          FALSE,                 /* partial_inplace */
 472          0xffff,                /* src_mask */
 473          0xffff,                /* dst_mask */
 474          FALSE),                /* pcrel_offset */
 475   /* A low 8 bit absolute relocation of 24 bit program memory address.
 476      For LDI command.  Will be changed when linker stubs are needed.  */
 477   HOWTO (R_AVR_LO8_LDI_GS,      /* type */
 478          1,                     /* rightshift */
 479          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 480          8,                     /* bitsize */
 481          FALSE,                 /* pc_relative */
 482          0,                     /* bitpos */
 483          complain_overflow_dont, /* complain_on_overflow */
 484          bfd_elf_generic_reloc, /* special_function */
 485          "R_AVR_LO8_LDI_GS",    /* name */
 486          FALSE,                 /* partial_inplace */
 487          0xffff,                /* src_mask */
 488          0xffff,                /* dst_mask */
 489          FALSE),                /* pcrel_offset */
 490   /* A low 8 bit absolute relocation of 24 bit program memory address.
 491      For LDI command.  Will be changed when linker stubs are needed.  */
 492   HOWTO (R_AVR_HI8_LDI_GS,      /* type */
 493          9,                     /* rightshift */
 494          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 495          8,                     /* bitsize */
 496          FALSE,                 /* pc_relative */
 497          0,                     /* bitpos */
 498          complain_overflow_dont, /* complain_on_overflow */
 499          bfd_elf_generic_reloc, /* special_function */
 500          "R_AVR_HI8_LDI_GS",    /* name */
 501          FALSE,                 /* partial_inplace */
 502          0xffff,                /* src_mask */
 503          0xffff,                /* dst_mask */
 504          FALSE),                /* pcrel_offset */
 505   /* 8 bit offset.  */
 506   HOWTO (R_AVR_8,               /* type */
 507          0,                     /* rightshift */
 508          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 509          8,                     /* bitsize */
 510          FALSE,                 /* pc_relative */
 511          0,                     /* bitpos */
 512          complain_overflow_bitfield,/* complain_on_overflow */
 513          bfd_elf_generic_reloc, /* special_function */
 514          "R_AVR_8",             /* name */
 515          FALSE,                 /* partial_inplace */
 516          0x000000ff,            /* src_mask */
 517          0x000000ff,            /* dst_mask */
 518          FALSE),                /* pcrel_offset */
 519 };
 520
 521 /* Map BFD reloc types to AVR ELF reloc types.  */
 522
 523 struct avr_reloc_map
 524 {
 525   bfd_reloc_code_real_type bfd_reloc_val;
 526   unsigned int elf_reloc_val;
 527 };
 528
 529 static const struct avr_reloc_map avr_reloc_map[] =
 530 {
 531   { BFD_RELOC_NONE,                 R_AVR_NONE },
 532   { BFD_RELOC_32,                   R_AVR_32 },
 533   { BFD_RELOC_AVR_7_PCREL,          R_AVR_7_PCREL },
 534   { BFD_RELOC_AVR_13_PCREL,         R_AVR_13_PCREL },
 535   { BFD_RELOC_16,                   R_AVR_16 },
 536   { BFD_RELOC_AVR_16_PM,            R_AVR_16_PM },
 537   { BFD_RELOC_AVR_LO8_LDI,          R_AVR_LO8_LDI},
 538   { BFD_RELOC_AVR_HI8_LDI,          R_AVR_HI8_LDI },
 539   { BFD_RELOC_AVR_HH8_LDI,          R_AVR_HH8_LDI },
 540   { BFD_RELOC_AVR_MS8_LDI,          R_AVR_MS8_LDI },
 541   { BFD_RELOC_AVR_LO8_LDI_NEG,      R_AVR_LO8_LDI_NEG },
 542   { BFD_RELOC_AVR_HI8_LDI_NEG,      R_AVR_HI8_LDI_NEG },
 543   { BFD_RELOC_AVR_HH8_LDI_NEG,      R_AVR_HH8_LDI_NEG },
 544   { BFD_RELOC_AVR_MS8_LDI_NEG,      R_AVR_MS8_LDI_NEG },
 545   { BFD_RELOC_AVR_LO8_LDI_PM,       R_AVR_LO8_LDI_PM },
 546   { BFD_RELOC_AVR_LO8_LDI_GS,       R_AVR_LO8_LDI_GS },
 547   { BFD_RELOC_AVR_HI8_LDI_PM,       R_AVR_HI8_LDI_PM },
 548   { BFD_RELOC_AVR_HI8_LDI_GS,       R_AVR_HI8_LDI_GS },
 549   { BFD_RELOC_AVR_HH8_LDI_PM,       R_AVR_HH8_LDI_PM },
 550   { BFD_RELOC_AVR_LO8_LDI_PM_NEG,   R_AVR_LO8_LDI_PM_NEG },
 551   { BFD_RELOC_AVR_HI8_LDI_PM_NEG,   R_AVR_HI8_LDI_PM_NEG },
 552   { BFD_RELOC_AVR_HH8_LDI_PM_NEG,   R_AVR_HH8_LDI_PM_NEG },
 553   { BFD_RELOC_AVR_CALL,             R_AVR_CALL },
 554   { BFD_RELOC_AVR_LDI,              R_AVR_LDI  },
 555   { BFD_RELOC_AVR_6,                R_AVR_6    },
 556   { BFD_RELOC_AVR_6_ADIW,           R_AVR_6_ADIW },
 557   { BFD_RELOC_8,                    R_AVR_8 }
 558 };
 559
 560 /* Meant to be filled one day with the wrap around address for the
 561    specific device.  I.e. should get the value 0x4000 for 16k devices,
 562    0x8000 for 32k devices and so on.
 563
 564    We initialize it here with a value of 0x1000000 resulting in
 565    that we will never suggest a wrap-around jump during relaxation.
 566    The logic of the source code later on assumes that in
 567    avr_pc_wrap_around one single bit is set.  */
 568 static bfd_vma avr_pc_wrap_around = 0x10000000;
 569
 570 /* If this variable holds a value different from zero, the linker relaxation
 571    machine will try to optimize call/ret sequences by a single jump
 572    instruction. This option could be switched off by a linker switch.  */
 573 static int avr_replace_call_ret_sequences = 1;
 574 \f
 575 /* Initialize an entry in the stub hash table.  */
 576
 577 static struct bfd_hash_entry *
 578 stub_hash_newfunc (struct bfd_hash_entry *entry,
 579                    struct bfd_hash_table *table,
 580                    const char *string)
 581 {
 582   /* Allocate the structure if it has not already been allocated by a
 583      subclass.  */
 584   if (entry == NULL)
 585     {
 586       entry = bfd_hash_allocate (table,
 587                                  sizeof (struct elf32_avr_stub_hash_entry));
 588       if (entry == NULL)
 589         return entry;
 590     }
 591
 592   /* Call the allocation method of the superclass.  */
 593   entry = bfd_hash_newfunc (entry, table, string);
 594   if (entry != NULL)
 595     {
 596       struct elf32_avr_stub_hash_entry *hsh;
 597
 598       /* Initialize the local fields.  */
 599       hsh = avr_stub_hash_entry (entry);
 600       hsh->stub_offset = 0;
 601       hsh->target_value = 0;
 602     }
 603
 604   return entry;
 605 }
 606
 607 /* This function is just a straight passthrough to the real
 608    function in linker.c.  Its prupose is so that its address
 609    can be compared inside the avr_link_hash_table macro.  */
 610
 611 static struct bfd_hash_entry *
 612 elf32_avr_link_hash_newfunc (struct bfd_hash_entry * entry,
 613                              struct bfd_hash_table * table,
 614                              const char * string)
 615 {
 616   return _bfd_elf_link_hash_newfunc (entry, table, string);
 617 }
 618
 619 /* Create the derived linker hash table.  The AVR ELF port uses the derived
 620    hash table to keep information specific to the AVR ELF linker (without
 621    using static variables).  */
 622
 623 static struct bfd_link_hash_table *
 624 elf32_avr_link_hash_table_create (bfd *abfd)
 625 {
 626   struct elf32_avr_link_hash_table *htab;
 627   bfd_size_type amt = sizeof (*htab);
 628
 629   htab = bfd_malloc (amt);
 630   if (htab == NULL)
 631     return NULL;
 632
 633   if (!_bfd_elf_link_hash_table_init (&htab->etab, abfd,
 634                                       elf32_avr_link_hash_newfunc,
 635                                       sizeof (struct elf_link_hash_entry),
 636                                       AVR_ELF_DATA))
 637     {
 638       free (htab);
 639       return NULL;
 640     }
 641
 642   /* Init the stub hash table too.  */
 643   if (!bfd_hash_table_init (&htab->bstab, stub_hash_newfunc,
 644                             sizeof (struct elf32_avr_stub_hash_entry)))
 645     return NULL;
 646
 647   htab->stub_bfd = NULL;
 648   htab->stub_sec = NULL;
 649
 650   /* Initialize the address mapping table.  */
 651   htab->amt_stub_offsets = NULL;
 652   htab->amt_destination_addr = NULL;
 653   htab->amt_entry_cnt = 0;
 654   htab->amt_max_entry_cnt = 0;
 655
 656   return &htab->etab.root;
 657 }
 658
 659 /* Free the derived linker hash table.  */
 660
 661 static void
 662 elf32_avr_link_hash_table_free (struct bfd_link_hash_table *btab)
 663 {
 664   struct elf32_avr_link_hash_table *htab
 665     = (struct elf32_avr_link_hash_table *) btab;
 666
 667   /* Free the address mapping table.  */
 668   if (htab->amt_stub_offsets != NULL)
 669     free (htab->amt_stub_offsets);
 670   if (htab->amt_destination_addr != NULL)
 671     free (htab->amt_destination_addr);
 672
 673   bfd_hash_table_free (&htab->bstab);
 674   _bfd_generic_link_hash_table_free (btab);
 675 }
 676
 677 /* Calculates the effective distance of a pc relative jump/call.  */
 678
 679 static int
 680 avr_relative_distance_considering_wrap_around (unsigned int distance)
 681 {
 682   unsigned int wrap_around_mask = avr_pc_wrap_around - 1;
 683   int dist_with_wrap_around = distance & wrap_around_mask;
 684
 685   if (dist_with_wrap_around > ((int) (avr_pc_wrap_around >> 1)))
 686     dist_with_wrap_around -= avr_pc_wrap_around;
 687
 688   return dist_with_wrap_around;
 689 }
 690
 691
 692 static reloc_howto_type *
 693 bfd_elf32_bfd_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
 694                                  bfd_reloc_code_real_type code)
 695 {
 696   unsigned int i;
 697
 698   for (i = 0;
 699        i < sizeof (avr_reloc_map) / sizeof (struct avr_reloc_map);
 700        i++)
 701     if (avr_reloc_map[i].bfd_reloc_val == code)
 702       return &elf_avr_howto_table[avr_reloc_map[i].elf_reloc_val];
 703
 704   return NULL;
 705 }
 706
 707 static reloc_howto_type *
 708 bfd_elf32_bfd_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
 709                                  const char *r_name)
 710 {
 711   unsigned int i;
 712
 713   for (i = 0;
 714        i < sizeof (elf_avr_howto_table) / sizeof (elf_avr_howto_table[0]);
 715        i++)
 716     if (elf_avr_howto_table[i].name != NULL
 717         && strcasecmp (elf_avr_howto_table[i].name, r_name) == 0)
 718       return &elf_avr_howto_table[i];
 719
 720   return NULL;
 721 }
 722
 723 /* Set the howto pointer for an AVR ELF reloc.  */
 724
 725 static void
 726 avr_info_to_howto_rela (bfd *abfd ATTRIBUTE_UNUSED,
 727                         arelent *cache_ptr,
 728                         Elf_Internal_Rela *dst)
 729 {
 730   unsigned int r_type;
 731
 732   r_type = ELF32_R_TYPE (dst->r_info);
 733   BFD_ASSERT (r_type < (unsigned int) R_AVR_max);
 734   cache_ptr->howto = &elf_avr_howto_table[r_type];
 735 }
 736
 737 static bfd_boolean
 738 avr_stub_is_required_for_16_bit_reloc (bfd_vma relocation)
 739 {
 740   return (relocation >= 0x020000);
 741 }
 742
 743 /* Returns the address of the corresponding stub if there is one.
 744    Returns otherwise an address above 0x020000.  This function
 745    could also be used, if there is no knowledge on the section where
 746    the destination is found.  */
 747
 748 static bfd_vma
 749 avr_get_stub_addr (bfd_vma srel,
 750                    struct elf32_avr_link_hash_table *htab)
 751 {
 752   unsigned int sindex;
 753   bfd_vma stub_sec_addr =
 754               (htab->stub_sec->output_section->vma +
 755                htab->stub_sec->output_offset);
 756
 757   for (sindex = 0; sindex < htab->amt_max_entry_cnt; sindex ++)
 758     if (htab->amt_destination_addr[sindex] == srel)
 759       return htab->amt_stub_offsets[sindex] + stub_sec_addr;
 760
 761   /* Return an address that could not be reached by 16 bit relocs.  */
 762   return 0x020000;
 763 }
 764
 765 /* Perform a single relocation.  By default we use the standard BFD
 766    routines, but a few relocs, we have to do them ourselves.  */
 767
 768 static bfd_reloc_status_type
 769 avr_final_link_relocate (reloc_howto_type *                 howto,
 770                          bfd *                              input_bfd,
 771                          asection *                         input_section,
 772                          bfd_byte *                         contents,
 773                          Elf_Internal_Rela *                rel,
 774                          bfd_vma                            relocation,
 775                          struct elf32_avr_link_hash_table * htab)
 776 {
 777   bfd_reloc_status_type r = bfd_reloc_ok;
 778   bfd_vma               x;
 779   bfd_signed_vma        srel;
 780   bfd_signed_vma        reloc_addr;
 781   bfd_boolean           use_stubs = FALSE;
 782   /* Usually is 0, unless we are generating code for a bootloader.  */
 783   bfd_signed_vma        base_addr = htab->vector_base;
 784
 785   /* Absolute addr of the reloc in the final excecutable.  */
 786   reloc_addr = rel->r_offset + input_section->output_section->vma
 787                + input_section->output_offset;
 788
 789   switch (howto->type)
 790     {
 791     case R_AVR_7_PCREL:
 792       contents += rel->r_offset;
 793       srel = (bfd_signed_vma) relocation;
 794       srel += rel->r_addend;
 795       srel -= rel->r_offset;
 796       srel -= 2;        /* Branch instructions add 2 to the PC...  */
 797       srel -= (input_section->output_section->vma +
 798                input_section->output_offset);
 799
 800       if (srel & 1)
 801         return bfd_reloc_outofrange;
 802       if (srel > ((1 << 7) - 1) || (srel < - (1 << 7)))
 803         return bfd_reloc_overflow;
 804       x = bfd_get_16 (input_bfd, contents);
 805       x = (x & 0xfc07) | (((srel >> 1) << 3) & 0x3f8);
 806       bfd_put_16 (input_bfd, x, contents);
 807       break;
 808
 809     case R_AVR_13_PCREL:
 810       contents   += rel->r_offset;
 811       srel = (bfd_signed_vma) relocation;
 812       srel += rel->r_addend;
 813       srel -= rel->r_offset;
 814       srel -= 2;        /* Branch instructions add 2 to the PC...  */
 815       srel -= (input_section->output_section->vma +
 816                input_section->output_offset);
 817
 818       if (srel & 1)
 819         return bfd_reloc_outofrange;
 820
 821       srel = avr_relative_distance_considering_wrap_around (srel);
 822
 823       /* AVR addresses commands as words.  */
 824       srel >>= 1;
 825
 826       /* Check for overflow.  */
 827       if (srel < -2048 || srel > 2047)
 828         {
 829           /* Relative distance is too large.  */
 830
 831           /* Always apply WRAPAROUND for avr2, avr25, and avr4.  */
 832           switch (bfd_get_mach (input_bfd))
 833             {
 834             case bfd_mach_avr2:
 835             case bfd_mach_avr25:
 836             case bfd_mach_avr4:
 837               break;
 838
 839             default:
 840               return bfd_reloc_overflow;
 841             }
 842         }
 843
 844       x = bfd_get_16 (input_bfd, contents);
 845       x = (x & 0xf000) | (srel & 0xfff);
 846       bfd_put_16 (input_bfd, x, contents);
 847       break;
 848
 849     case R_AVR_LO8_LDI:
 850       contents += rel->r_offset;
 851       srel = (bfd_signed_vma) relocation + rel->r_addend;
 852       x = bfd_get_16 (input_bfd, contents);
 853       x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
 854       bfd_put_16 (input_bfd, x, contents);
 855       break;
 856
 857     case R_AVR_LDI:
 858       contents += rel->r_offset;
 859       srel = (bfd_signed_vma) relocation + rel->r_addend;
 860       if (((srel > 0) && (srel & 0xffff) > 255)
 861           || ((srel < 0) && ((-srel) & 0xffff) > 128))
 862         /* Remove offset for data/eeprom section.  */
 863         return bfd_reloc_overflow;
 864
 865       x = bfd_get_16 (input_bfd, contents);
 866       x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
 867       bfd_put_16 (input_bfd, x, contents);
 868       break;
 869
 870     case R_AVR_6:
 871       contents += rel->r_offset;
 872       srel = (bfd_signed_vma) relocation + rel->r_addend;
 873       if (((srel & 0xffff) > 63) || (srel < 0))
 874         /* Remove offset for data/eeprom section.  */
 875         return bfd_reloc_overflow;
 876       x = bfd_get_16 (input_bfd, contents);
 877       x = (x & 0xd3f8) | ((srel & 7) | ((srel & (3 << 3)) << 7)
 878                        | ((srel & (1 << 5)) << 8));
 879       bfd_put_16 (input_bfd, x, contents);
 880       break;
 881
 882     case R_AVR_6_ADIW:
 883       contents += rel->r_offset;
 884       srel = (bfd_signed_vma) relocation + rel->r_addend;
 885       if (((srel & 0xffff) > 63) || (srel < 0))
 886         /* Remove offset for data/eeprom section.  */
 887         return bfd_reloc_overflow;
 888       x = bfd_get_16 (input_bfd, contents);
 889       x = (x & 0xff30) | (srel & 0xf) | ((srel & 0x30) << 2);
 890       bfd_put_16 (input_bfd, x, contents);
 891       break;
 892
 893     case R_AVR_HI8_LDI:
 894       contents += rel->r_offset;
 895       srel = (bfd_signed_vma) relocation + rel->r_addend;
 896       srel = (srel >> 8) & 0xff;
 897       x = bfd_get_16 (input_bfd, contents);
 898       x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
 899       bfd_put_16 (input_bfd, x, contents);
 900       break;
 901
 902     case R_AVR_HH8_LDI:
 903       contents += rel->r_offset;
 904       srel = (bfd_signed_vma) relocation + rel->r_addend;
 905       srel = (srel >> 16) & 0xff;
 906       x = bfd_get_16 (input_bfd, contents);
 907       x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
 908       bfd_put_16 (input_bfd, x, contents);
 909       break;
 910
 911     case R_AVR_MS8_LDI:
 912       contents += rel->r_offset;
 913       srel = (bfd_signed_vma) relocation + rel->r_addend;
 914       srel = (srel >> 24) & 0xff;
 915       x = bfd_get_16 (input_bfd, contents);
 916       x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
 917       bfd_put_16 (input_bfd, x, contents);
 918       break;
 919
 920     case R_AVR_LO8_LDI_NEG:
 921       contents += rel->r_offset;
 922       srel = (bfd_signed_vma) relocation + rel->r_addend;
 923       srel = -srel;
 924       x = bfd_get_16 (input_bfd, contents);
 925       x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
 926       bfd_put_16 (input_bfd, x, contents);
 927       break;
 928
 929     case R_AVR_HI8_LDI_NEG:
 930       contents += rel->r_offset;
 931       srel = (bfd_signed_vma) relocation + rel->r_addend;
 932       srel = -srel;
 933       srel = (srel >> 8) & 0xff;
 934       x = bfd_get_16 (input_bfd, contents);
 935       x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
 936       bfd_put_16 (input_bfd, x, contents);
 937       break;
 938
 939     case R_AVR_HH8_LDI_NEG:
 940       contents += rel->r_offset;
 941       srel = (bfd_signed_vma) relocation + rel->r_addend;
 942       srel = -srel;
 943       srel = (srel >> 16) & 0xff;
 944       x = bfd_get_16 (input_bfd, contents);
 945       x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
 946       bfd_put_16 (input_bfd, x, contents);
 947       break;
 948
 949     case R_AVR_MS8_LDI_NEG:
 950       contents += rel->r_offset;
 951       srel = (bfd_signed_vma) relocation + rel->r_addend;
 952       srel = -srel;
 953       srel = (srel >> 24) & 0xff;
 954       x = bfd_get_16 (input_bfd, contents);
 955       x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
 956       bfd_put_16 (input_bfd, x, contents);
 957       break;
 958
 959     case R_AVR_LO8_LDI_GS:
 960       use_stubs = (!htab->no_stubs);
 961       /* Fall through.  */
 962     case R_AVR_LO8_LDI_PM:
 963       contents += rel->r_offset;
 964       srel = (bfd_signed_vma) relocation + rel->r_addend;
 965
 966       if (use_stubs
 967           && avr_stub_is_required_for_16_bit_reloc (srel - base_addr))
 968         {
 969           bfd_vma old_srel = srel;
 970
 971           /* We need to use the address of the stub instead.  */
 972           srel = avr_get_stub_addr (srel, htab);
 973           if (debug_stubs)
 974             printf ("LD: Using jump stub (at 0x%x) with destination 0x%x for "
 975                     "reloc at address 0x%x.\n",
 976                     (unsigned int) srel,
 977                     (unsigned int) old_srel,
 978                     (unsigned int) reloc_addr);
 979
 980           if (avr_stub_is_required_for_16_bit_reloc (srel - base_addr))
 981             return bfd_reloc_outofrange;
 982         }
 983
 984       if (srel & 1)
 985         return bfd_reloc_outofrange;
 986       srel = srel >> 1;
 987       x = bfd_get_16 (input_bfd, contents);
 988       x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
 989       bfd_put_16 (input_bfd, x, contents);
 990       break;
 991
 992     case R_AVR_HI8_LDI_GS:
 993       use_stubs = (!htab->no_stubs);
 994       /* Fall through.  */
 995     case R_AVR_HI8_LDI_PM:
 996       contents += rel->r_offset;
 997       srel = (bfd_signed_vma) relocation + rel->r_addend;
 998
 999       if (use_stubs
1000           && avr_stub_is_required_for_16_bit_reloc (srel - base_addr))
1001         {
1002           bfd_vma old_srel = srel;
1003
1004           /* We need to use the address of the stub instead.  */
1005           srel = avr_get_stub_addr (srel, htab);
1006           if (debug_stubs)
1007             printf ("LD: Using jump stub (at 0x%x) with destination 0x%x for "
1008                     "reloc at address 0x%x.\n",
1009                     (unsigned int) srel,
1010                     (unsigned int) old_srel,
1011                     (unsigned int) reloc_addr);
1012
1013           if (avr_stub_is_required_for_16_bit_reloc (srel - base_addr))
1014             return bfd_reloc_outofrange;
1015         }
1016
1017       if (srel & 1)
1018         return bfd_reloc_outofrange;
1019       srel = srel >> 1;
1020       srel = (srel >> 8) & 0xff;
1021       x = bfd_get_16 (input_bfd, contents);
1022       x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
1023       bfd_put_16 (input_bfd, x, contents);
1024       break;
1025
1026     case R_AVR_HH8_LDI_PM:
1027       contents += rel->r_offset;
1028       srel = (bfd_signed_vma) relocation + rel->r_addend;
1029       if (srel & 1)
1030         return bfd_reloc_outofrange;
1031       srel = srel >> 1;
1032       srel = (srel >> 16) & 0xff;
1033       x = bfd_get_16 (input_bfd, contents);
1034       x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
1035       bfd_put_16 (input_bfd, x, contents);
1036       break;
1037
1038     case R_AVR_LO8_LDI_PM_NEG:
1039       contents += rel->r_offset;
1040       srel = (bfd_signed_vma) relocation + rel->r_addend;
1041       srel = -srel;
1042       if (srel & 1)
1043         return bfd_reloc_outofrange;
1044       srel = srel >> 1;
1045       x = bfd_get_16 (input_bfd, contents);
1046       x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
1047       bfd_put_16 (input_bfd, x, contents);
1048       break;
1049
1050     case R_AVR_HI8_LDI_PM_NEG:
1051       contents += rel->r_offset;
1052       srel = (bfd_signed_vma) relocation + rel->r_addend;
1053       srel = -srel;
1054       if (srel & 1)
1055         return bfd_reloc_outofrange;
1056       srel = srel >> 1;
1057       srel = (srel >> 8) & 0xff;
1058       x = bfd_get_16 (input_bfd, contents);
1059       x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
1060       bfd_put_16 (input_bfd, x, contents);
1061       break;
1062
1063     case R_AVR_HH8_LDI_PM_NEG:
1064       contents += rel->r_offset;
1065       srel = (bfd_signed_vma) relocation + rel->r_addend;
1066       srel = -srel;
1067       if (srel & 1)
1068         return bfd_reloc_outofrange;
1069       srel = srel >> 1;
1070       srel = (srel >> 16) & 0xff;
1071       x = bfd_get_16 (input_bfd, contents);
1072       x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
1073       bfd_put_16 (input_bfd, x, contents);
1074       break;
1075
1076     case R_AVR_CALL:
1077       contents += rel->r_offset;
1078       srel = (bfd_signed_vma) relocation + rel->r_addend;
1079       if (srel & 1)
1080         return bfd_reloc_outofrange;
1081       srel = srel >> 1;
1082       x = bfd_get_16 (input_bfd, contents);
1083       x |= ((srel & 0x10000) | ((srel << 3) & 0x1f00000)) >> 16;
1084       bfd_put_16 (input_bfd, x, contents);
1085       bfd_put_16 (input_bfd, (bfd_vma) srel & 0xffff, contents+2);
1086       break;
1087
1088     case R_AVR_16_PM:
1089       use_stubs = (!htab->no_stubs);
1090       contents += rel->r_offset;
1091       srel = (bfd_signed_vma) relocation + rel->r_addend;
1092
1093       if (use_stubs
1094           && avr_stub_is_required_for_16_bit_reloc (srel - base_addr))
1095         {
1096           bfd_vma old_srel = srel;
1097
1098           /* We need to use the address of the stub instead.  */
1099           srel = avr_get_stub_addr (srel,htab);
1100           if (debug_stubs)
1101             printf ("LD: Using jump stub (at 0x%x) with destination 0x%x for "
1102                     "reloc at address 0x%x.\n",
1103                     (unsigned int) srel,
1104                     (unsigned int) old_srel,
1105                     (unsigned int) reloc_addr);
1106
1107           if (avr_stub_is_required_for_16_bit_reloc (srel - base_addr))
1108             return bfd_reloc_outofrange;
1109         }
1110
1111       if (srel & 1)
1112         return bfd_reloc_outofrange;
1113       srel = srel >> 1;
1114       bfd_put_16 (input_bfd, (bfd_vma) srel &0x00ffff, contents);
1115       break;
1116
1117     default:
1118       r = _bfd_final_link_relocate (howto, input_bfd, input_section,
1119                                     contents, rel->r_offset,
1120                                     relocation, rel->r_addend);
1121     }
1122
1123   return r;
1124 }
1125
1126 /* Relocate an AVR ELF section.  */
1127
1128 static bfd_boolean
1129 elf32_avr_relocate_section (bfd *output_bfd ATTRIBUTE_UNUSED,
1130                             struct bfd_link_info *info,
1131                             bfd *input_bfd,
1132                             asection *input_section,
1133                             bfd_byte *contents,
1134                             Elf_Internal_Rela *relocs,
1135                             Elf_Internal_Sym *local_syms,
1136                             asection **local_sections)
1137 {
1138   Elf_Internal_Shdr *           symtab_hdr;
1139   struct elf_link_hash_entry ** sym_hashes;
1140   Elf_Internal_Rela *           rel;
1141   Elf_Internal_Rela *           relend;
1142   struct elf32_avr_link_hash_table * htab = avr_link_hash_table (info);
1143
1144   if (htab == NULL)
1145     return FALSE;
1146
1147   symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
1148   sym_hashes = elf_sym_hashes (input_bfd);
1149   relend     = relocs + input_section->reloc_count;
1150
1151   for (rel = relocs; rel < relend; rel ++)
1152     {
1153       reloc_howto_type *           howto;
1154       unsigned long                r_symndx;
1155       Elf_Internal_Sym *           sym;
1156       asection *                   sec;
1157       struct elf_link_hash_entry * h;
1158       bfd_vma                      relocation;
1159       bfd_reloc_status_type        r;
1160       const char *                 name;
1161       int                          r_type;
1162
1163       r_type = ELF32_R_TYPE (rel->r_info);
1164       r_symndx = ELF32_R_SYM (rel->r_info);
1165       howto  = elf_avr_howto_table + r_type;
1166       h      = NULL;
1167       sym    = NULL;
1168       sec    = NULL;
1169
1170       if (r_symndx < symtab_hdr->sh_info)
1171         {
1172           sym = local_syms + r_symndx;
1173           sec = local_sections [r_symndx];
1174           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
1175
1176           name = bfd_elf_string_from_elf_section
1177             (input_bfd, symtab_hdr->sh_link, sym->st_name);
1178           name = (name == NULL) ? bfd_section_name (input_bfd, sec) : name;
1179         }
1180       else
1181         {
1182           bfd_boolean unresolved_reloc, warned;
1183
1184           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
1185                                    r_symndx, symtab_hdr, sym_hashes,
1186                                    h, sec, relocation,
1187                                    unresolved_reloc, warned);
1188
1189           name = h->root.root.string;
1190         }
1191
1192       if (sec != NULL && elf_discarded_section (sec))
1193         RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
1194                                          rel, relend, howto, contents);
1195
1196       if (info->relocatable)
1197         continue;
1198
1199       r = avr_final_link_relocate (howto, input_bfd, input_section,
1200                                    contents, rel, relocation, htab);
1201
1202       if (r != bfd_reloc_ok)
1203         {
1204           const char * msg = (const char *) NULL;
1205
1206           switch (r)
1207             {
1208             case bfd_reloc_overflow:
1209               r = info->callbacks->reloc_overflow
1210                 (info, (h ? &h->root : NULL),
1211                  name, howto->name, (bfd_vma) 0,
1212                  input_bfd, input_section, rel->r_offset);
1213               break;
1214
1215             case bfd_reloc_undefined:
1216               r = info->callbacks->undefined_symbol
1217                 (info, name, input_bfd, input_section, rel->r_offset, TRUE);
1218               break;
1219
1220             case bfd_reloc_outofrange:
1221               msg = _("internal error: out of range error");
1222               break;
1223
1224             case bfd_reloc_notsupported:
1225               msg = _("internal error: unsupported relocation error");
1226               break;
1227
1228             case bfd_reloc_dangerous:
1229               msg = _("internal error: dangerous relocation");
1230               break;
1231
1232             default:
1233               msg = _("internal error: unknown error");
1234               break;
1235             }
1236
1237           if (msg)
1238             r = info->callbacks->warning
1239               (info, msg, name, input_bfd, input_section, rel->r_offset);
1240
1241           if (! r)
1242             return FALSE;
1243         }
1244     }
1245
1246   return TRUE;
1247 }
1248
1249 /* The final processing done just before writing out a AVR ELF object
1250    file.  This gets the AVR architecture right based on the machine
1251    number.  */
1252
1253 static void
1254 bfd_elf_avr_final_write_processing (bfd *abfd,
1255                                     bfd_boolean linker ATTRIBUTE_UNUSED)
1256 {
1257   unsigned long val;
1258
1259   switch (bfd_get_mach (abfd))
1260     {
1261     default:
1262     case bfd_mach_avr2:
1263       val = E_AVR_MACH_AVR2;
1264       break;
1265
1266     case bfd_mach_avr1:
1267       val = E_AVR_MACH_AVR1;
1268       break;
1269
1270     case bfd_mach_avr25:
1271       val = E_AVR_MACH_AVR25;
1272       break;
1273
1274     case bfd_mach_avr3:
1275       val = E_AVR_MACH_AVR3;
1276       break;
1277
1278     case bfd_mach_avr31:
1279       val = E_AVR_MACH_AVR31;
1280       break;
1281
1282     case bfd_mach_avr35:
1283       val = E_AVR_MACH_AVR35;
1284       break;
1285
1286     case bfd_mach_avr4:
1287       val = E_AVR_MACH_AVR4;
1288       break;
1289
1290     case bfd_mach_avr5:
1291       val = E_AVR_MACH_AVR5;
1292       break;
1293
1294     case bfd_mach_avr51:
1295       val = E_AVR_MACH_AVR51;
1296       break;
1297
1298     case bfd_mach_avr6:
1299       val = E_AVR_MACH_AVR6;
1300       break;
1301
1302     case bfd_mach_avrxmega1:
1303       val = E_AVR_MACH_XMEGA1;
1304       break;
1305
1306     case bfd_mach_avrxmega2:
1307       val = E_AVR_MACH_XMEGA2;
1308       break;
1309
1310     case bfd_mach_avrxmega3:
1311       val = E_AVR_MACH_XMEGA3;
1312       break;
1313
1314     case bfd_mach_avrxmega4:
1315       val = E_AVR_MACH_XMEGA4;
1316       break;
1317
1318     case bfd_mach_avrxmega5:
1319       val = E_AVR_MACH_XMEGA5;
1320       break;
1321
1322     case bfd_mach_avrxmega6:
1323       val = E_AVR_MACH_XMEGA6;
1324       break;
1325
1326     case bfd_mach_avrxmega7:
1327       val = E_AVR_MACH_XMEGA7;
1328       break;
1329     }
1330
1331   elf_elfheader (abfd)->e_machine = EM_AVR;
1332   elf_elfheader (abfd)->e_flags &= ~ EF_AVR_MACH;
1333   elf_elfheader (abfd)->e_flags |= val;
1334   elf_elfheader (abfd)->e_flags |= EF_AVR_LINKRELAX_PREPARED;
1335 }
1336
1337 /* Set the right machine number.  */
1338
1339 static bfd_boolean
1340 elf32_avr_object_p (bfd *abfd)
1341 {
1342   unsigned int e_set = bfd_mach_avr2;
1343
1344   if (elf_elfheader (abfd)->e_machine == EM_AVR
1345       || elf_elfheader (abfd)->e_machine == EM_AVR_OLD)
1346     {
1347       int e_mach = elf_elfheader (abfd)->e_flags & EF_AVR_MACH;
1348
1349       switch (e_mach)
1350         {
1351         default:
1352         case E_AVR_MACH_AVR2:
1353           e_set = bfd_mach_avr2;
1354           break;
1355
1356         case E_AVR_MACH_AVR1:
1357           e_set = bfd_mach_avr1;
1358           break;
1359
1360         case E_AVR_MACH_AVR25:
1361           e_set = bfd_mach_avr25;
1362           break;
1363
1364         case E_AVR_MACH_AVR3:
1365           e_set = bfd_mach_avr3;
1366           break;
1367
1368         case E_AVR_MACH_AVR31:
1369           e_set = bfd_mach_avr31;
1370           break;
1371
1372         case E_AVR_MACH_AVR35:
1373           e_set = bfd_mach_avr35;
1374           break;
1375
1376         case E_AVR_MACH_AVR4:
1377           e_set = bfd_mach_avr4;
1378           break;
1379
1380         case E_AVR_MACH_AVR5:
1381           e_set = bfd_mach_avr5;
1382           break;
1383
1384         case E_AVR_MACH_AVR51:
1385           e_set = bfd_mach_avr51;
1386           break;
1387
1388         case E_AVR_MACH_AVR6:
1389           e_set = bfd_mach_avr6;
1390           break;
1391
1392         case E_AVR_MACH_XMEGA1:
1393           e_set = bfd_mach_avrxmega1;
1394           break;
1395
1396         case E_AVR_MACH_XMEGA2:
1397           e_set = bfd_mach_avrxmega2;
1398           break;
1399
1400         case E_AVR_MACH_XMEGA3:
1401           e_set = bfd_mach_avrxmega3;
1402           break;
1403
1404         case E_AVR_MACH_XMEGA4:
1405           e_set = bfd_mach_avrxmega4;
1406           break;
1407
1408         case E_AVR_MACH_XMEGA5:
1409           e_set = bfd_mach_avrxmega5;
1410           break;
1411
1412         case E_AVR_MACH_XMEGA6:
1413           e_set = bfd_mach_avrxmega6;
1414           break;
1415
1416         case E_AVR_MACH_XMEGA7:
1417           e_set = bfd_mach_avrxmega7;
1418           break;
1419         }
1420     }
1421   return bfd_default_set_arch_mach (abfd, bfd_arch_avr,
1422                                     e_set);
1423 }
1424
1425
1426 /* Delete some bytes from a section while changing the size of an instruction.
1427    The parameter "addr" denotes the section-relative offset pointing just
1428    behind the shrinked instruction. "addr+count" point at the first
1429    byte just behind the original unshrinked instruction.  */
1430
1431 static bfd_boolean
1432 elf32_avr_relax_delete_bytes (bfd *abfd,
1433                               asection *sec,
1434                               bfd_vma addr,
1435                               int count)
1436 {
1437   Elf_Internal_Shdr *symtab_hdr;
1438   unsigned int sec_shndx;
1439   bfd_byte *contents;
1440   Elf_Internal_Rela *irel, *irelend;
1441   Elf_Internal_Sym *isym;
1442   Elf_Internal_Sym *isymbuf = NULL;
1443   bfd_vma toaddr;
1444   struct elf_link_hash_entry **sym_hashes;
1445   struct elf_link_hash_entry **end_hashes;
1446   unsigned int symcount;
1447
1448   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1449   sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
1450   contents = elf_section_data (sec)->this_hdr.contents;
1451
1452   toaddr = sec->size;
1453
1454   irel = elf_section_data (sec)->relocs;
1455   irelend = irel + sec->reloc_count;
1456
1457   /* Actually delete the bytes.  */
1458   if (toaddr - addr - count > 0)
1459     memmove (contents + addr, contents + addr + count,
1460              (size_t) (toaddr - addr - count));
1461   sec->size -= count;
1462
1463   /* Adjust all the reloc addresses.  */
1464   for (irel = elf_section_data (sec)->relocs; irel < irelend; irel++)
1465     {
1466       bfd_vma old_reloc_address;
1467
1468       old_reloc_address = (sec->output_section->vma
1469                            + sec->output_offset + irel->r_offset);
1470
1471       /* Get the new reloc address.  */
1472       if ((irel->r_offset > addr
1473            && irel->r_offset < toaddr))
1474         {
1475           if (debug_relax)
1476             printf ("Relocation at address 0x%x needs to be moved.\n"
1477                     "Old section offset: 0x%x, New section offset: 0x%x \n",
1478                     (unsigned int) old_reloc_address,
1479                     (unsigned int) irel->r_offset,
1480                     (unsigned int) ((irel->r_offset) - count));
1481
1482           irel->r_offset -= count;
1483         }
1484
1485     }
1486
1487    /* The reloc's own addresses are now ok. However, we need to readjust
1488       the reloc's addend, i.e. the reloc's value if two conditions are met:
1489       1.) the reloc is relative to a symbol in this section that
1490           is located in front of the shrinked instruction
1491       2.) symbol plus addend end up behind the shrinked instruction.
1492
1493       The most common case where this happens are relocs relative to
1494       the section-start symbol.
1495
1496       This step needs to be done for all of the sections of the bfd.  */
1497
1498   {
1499     struct bfd_section *isec;
1500
1501     for (isec = abfd->sections; isec; isec = isec->next)
1502      {
1503        bfd_vma symval;
1504        bfd_vma shrinked_insn_address;
1505
1506        shrinked_insn_address = (sec->output_section->vma
1507                                 + sec->output_offset + addr - count);
1508
1509        irelend = elf_section_data (isec)->relocs + isec->reloc_count;
1510        for (irel = elf_section_data (isec)->relocs;
1511             irel < irelend;
1512             irel++)
1513          {
1514            /* Read this BFD's local symbols if we haven't done
1515               so already.  */
1516            if (isymbuf == NULL && symtab_hdr->sh_info != 0)
1517              {
1518                isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
1519                if (isymbuf == NULL)
1520                  isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
1521                                                  symtab_hdr->sh_info, 0,
1522                                                  NULL, NULL, NULL);
1523                if (isymbuf == NULL)
1524                  return FALSE;
1525              }
1526
1527            /* Get the value of the symbol referred to by the reloc.  */
1528            if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
1529              {
1530                /* A local symbol.  */
1531                asection *sym_sec;
1532
1533                isym = isymbuf + ELF32_R_SYM (irel->r_info);
1534                sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
1535                symval = isym->st_value;
1536                /* If the reloc is absolute, it will not have
1537                   a symbol or section associated with it.  */
1538                if (sym_sec == sec)
1539                  {
1540                    symval += sym_sec->output_section->vma
1541                              + sym_sec->output_offset;
1542
1543                    if (debug_relax)
1544                      printf ("Checking if the relocation's "
1545                              "addend needs corrections.\n"
1546                              "Address of anchor symbol: 0x%x \n"
1547                              "Address of relocation target: 0x%x \n"
1548                              "Address of relaxed insn: 0x%x \n",
1549                              (unsigned int) symval,
1550                              (unsigned int) (symval + irel->r_addend),
1551                              (unsigned int) shrinked_insn_address);
1552
1553                    if (symval <= shrinked_insn_address
1554                        && (symval + irel->r_addend) > shrinked_insn_address)
1555                      {
1556                        irel->r_addend -= count;
1557
1558                        if (debug_relax)
1559                          printf ("Relocation's addend needed to be fixed \n");
1560                      }
1561                  }
1562                /* else...Reference symbol is absolute.  No adjustment needed.  */
1563              }
1564            /* else...Reference symbol is extern.  No need for adjusting
1565               the addend.  */
1566          }
1567      }
1568   }
1569
1570   /* Adjust the local symbols defined in this section.  */
1571   isym = (Elf_Internal_Sym *) symtab_hdr->contents;
1572   /* Fix PR 9841, there may be no local symbols.  */
1573   if (isym != NULL)
1574     {
1575       Elf_Internal_Sym *isymend;
1576
1577       isymend = isym + symtab_hdr->sh_info;
1578       for (; isym < isymend; isym++)
1579         {
1580           if (isym->st_shndx == sec_shndx
1581               && isym->st_value > addr
1582               && isym->st_value < toaddr)
1583             isym->st_value -= count;
1584         }
1585     }
1586
1587   /* Now adjust the global symbols defined in this section.  */
1588   symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
1589               - symtab_hdr->sh_info);
1590   sym_hashes = elf_sym_hashes (abfd);
1591   end_hashes = sym_hashes + symcount;
1592   for (; sym_hashes < end_hashes; sym_hashes++)
1593     {
1594       struct elf_link_hash_entry *sym_hash = *sym_hashes;
1595       if ((sym_hash->root.type == bfd_link_hash_defined
1596            || sym_hash->root.type == bfd_link_hash_defweak)
1597           && sym_hash->root.u.def.section == sec
1598           && sym_hash->root.u.def.value > addr
1599           && sym_hash->root.u.def.value < toaddr)
1600         {
1601           sym_hash->root.u.def.value -= count;
1602         }
1603     }
1604
1605   return TRUE;
1606 }
1607
1608 /* This function handles relaxing for the avr.
1609    Many important relaxing opportunities within functions are already
1610    realized by the compiler itself.
1611    Here we try to replace  call (4 bytes) ->  rcall (2 bytes)
1612    and jump -> rjmp (safes also 2 bytes).
1613    As well we now optimize seqences of
1614      - call/rcall function
1615      - ret
1616    to yield
1617      - jmp/rjmp function
1618      - ret
1619    . In case that within a sequence
1620      - jmp/rjmp label
1621      - ret
1622    the ret could no longer be reached it is optimized away. In order
1623    to check if the ret is no longer needed, it is checked that the ret's address
1624    is not the target of a branch or jump within the same section, it is checked
1625    that there is no skip instruction before the jmp/rjmp and that there
1626    is no local or global label place at the address of the ret.
1627
1628    We refrain from relaxing within sections ".vectors" and
1629    ".jumptables" in order to maintain the position of the instructions.
1630    There, however, we substitute jmp/call by a sequence rjmp,nop/rcall,nop
1631    if possible. (In future one could possibly use the space of the nop
1632    for the first instruction of the irq service function.
1633
1634    The .jumptables sections is meant to be used for a future tablejump variant
1635    for the devices with 3-byte program counter where the table itself
1636    contains 4-byte jump instructions whose relative offset must not
1637    be changed.  */
1638
1639 static bfd_boolean
1640 elf32_avr_relax_section (bfd *abfd,
1641                          asection *sec,
1642                          struct bfd_link_info *link_info,
1643                          bfd_boolean *again)
1644 {
1645   Elf_Internal_Shdr *symtab_hdr;
1646   Elf_Internal_Rela *internal_relocs;
1647   Elf_Internal_Rela *irel, *irelend;
1648   bfd_byte *contents = NULL;
1649   Elf_Internal_Sym *isymbuf = NULL;
1650   struct elf32_avr_link_hash_table *htab;
1651
1652   if (link_info->relocatable)
1653     (*link_info->callbacks->einfo)
1654       (_("%P%F: --relax and -r may not be used together\n"));
1655
1656   htab = avr_link_hash_table (link_info);
1657   if (htab == NULL)
1658     return FALSE;
1659
1660   /* Assume nothing changes.  */
1661   *again = FALSE;
1662
1663   if ((!htab->no_stubs) && (sec == htab->stub_sec))
1664     {
1665       /* We are just relaxing the stub section.
1666          Let's calculate the size needed again.  */
1667       bfd_size_type last_estimated_stub_section_size = htab->stub_sec->size;
1668
1669       if (debug_relax)
1670         printf ("Relaxing the stub section. Size prior to this pass: %i\n",
1671                 (int) last_estimated_stub_section_size);
1672
1673       elf32_avr_size_stubs (htab->stub_sec->output_section->owner,
1674                             link_info, FALSE);
1675
1676       /* Check if the number of trampolines changed.  */
1677       if (last_estimated_stub_section_size != htab->stub_sec->size)
1678         *again = TRUE;
1679
1680       if (debug_relax)
1681         printf ("Size of stub section after this pass: %i\n",
1682                 (int) htab->stub_sec->size);
1683
1684       return TRUE;
1685     }
1686
1687   /* We don't have to do anything for a relocatable link, if
1688      this section does not have relocs, or if this is not a
1689      code section.  */
1690   if (link_info->relocatable
1691       || (sec->flags & SEC_RELOC) == 0
1692       || sec->reloc_count == 0
1693       || (sec->flags & SEC_CODE) == 0)
1694     return TRUE;
1695
1696   /* Check if the object file to relax uses internal symbols so that we
1697      could fix up the relocations.  */
1698   if (!(elf_elfheader (abfd)->e_flags & EF_AVR_LINKRELAX_PREPARED))
1699     return TRUE;
1700
1701   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1702
1703   /* Get a copy of the native relocations.  */
1704   internal_relocs = (_bfd_elf_link_read_relocs
1705                      (abfd, sec, NULL, NULL, link_info->keep_memory));
1706   if (internal_relocs == NULL)
1707     goto error_return;
1708
1709   /* Walk through the relocs looking for relaxing opportunities.  */
1710   irelend = internal_relocs + sec->reloc_count;
1711   for (irel = internal_relocs; irel < irelend; irel++)
1712     {
1713       bfd_vma symval;
1714
1715       if (   ELF32_R_TYPE (irel->r_info) != R_AVR_13_PCREL
1716              && ELF32_R_TYPE (irel->r_info) != R_AVR_7_PCREL
1717              && ELF32_R_TYPE (irel->r_info) != R_AVR_CALL)
1718         continue;
1719
1720       /* Get the section contents if we haven't done so already.  */
1721       if (contents == NULL)
1722         {
1723           /* Get cached copy if it exists.  */
1724           if (elf_section_data (sec)->this_hdr.contents != NULL)
1725             contents = elf_section_data (sec)->this_hdr.contents;
1726           else
1727             {
1728               /* Go get them off disk.  */
1729               if (! bfd_malloc_and_get_section (abfd, sec, &contents))
1730                 goto error_return;
1731             }
1732         }
1733
1734       /* Read this BFD's local symbols if we haven't done so already.  */
1735       if (isymbuf == NULL && symtab_hdr->sh_info != 0)
1736         {
1737           isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
1738           if (isymbuf == NULL)
1739             isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
1740                                             symtab_hdr->sh_info, 0,
1741                                             NULL, NULL, NULL);
1742           if (isymbuf == NULL)
1743             goto error_return;
1744         }
1745
1746
1747       /* Get the value of the symbol referred to by the reloc.  */
1748       if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
1749         {
1750           /* A local symbol.  */
1751           Elf_Internal_Sym *isym;
1752           asection *sym_sec;
1753
1754           isym = isymbuf + ELF32_R_SYM (irel->r_info);
1755           sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
1756           symval = isym->st_value;
1757           /* If the reloc is absolute, it will not have
1758              a symbol or section associated with it.  */
1759           if (sym_sec)
1760             symval += sym_sec->output_section->vma
1761               + sym_sec->output_offset;
1762         }
1763       else
1764         {
1765           unsigned long indx;
1766           struct elf_link_hash_entry *h;
1767
1768           /* An external symbol.  */
1769           indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
1770           h = elf_sym_hashes (abfd)[indx];
1771           BFD_ASSERT (h != NULL);
1772           if (h->root.type != bfd_link_hash_defined
1773               && h->root.type != bfd_link_hash_defweak)
1774             /* This appears to be a reference to an undefined
1775                symbol.  Just ignore it--it will be caught by the
1776                regular reloc processing.  */
1777             continue;
1778
1779           symval = (h->root.u.def.value
1780                     + h->root.u.def.section->output_section->vma
1781                     + h->root.u.def.section->output_offset);
1782         }
1783
1784       /* For simplicity of coding, we are going to modify the section
1785          contents, the section relocs, and the BFD symbol table.  We
1786          must tell the rest of the code not to free up this
1787          information.  It would be possible to instead create a table
1788          of changes which have to be made, as is done in coff-mips.c;
1789          that would be more work, but would require less memory when
1790          the linker is run.  */
1791       switch (ELF32_R_TYPE (irel->r_info))
1792         {
1793           /* Try to turn a 22-bit absolute call/jump into an 13-bit
1794              pc-relative rcall/rjmp.  */
1795         case R_AVR_CALL:
1796           {
1797             bfd_vma value = symval + irel->r_addend;
1798             bfd_vma dot, gap;
1799             int distance_short_enough = 0;
1800
1801             /* Get the address of this instruction.  */
1802             dot = (sec->output_section->vma
1803                    + sec->output_offset + irel->r_offset);
1804
1805             /* Compute the distance from this insn to the branch target.  */
1806             gap = value - dot;
1807
1808             /* If the distance is within -4094..+4098 inclusive, then we can
1809                relax this jump/call.  +4098 because the call/jump target
1810                will be closer after the relaxation.  */
1811             if ((int) gap >= -4094 && (int) gap <= 4098)
1812               distance_short_enough = 1;
1813
1814             /* Here we handle the wrap-around case.  E.g. for a 16k device
1815                we could use a rjmp to jump from address 0x100 to 0x3d00!
1816                In order to make this work properly, we need to fill the
1817                vaiable avr_pc_wrap_around with the appropriate value.
1818                I.e. 0x4000 for a 16k device.  */
1819             {
1820               /* Shrinking the code size makes the gaps larger in the
1821                  case of wrap-arounds.  So we use a heuristical safety
1822                  margin to avoid that during relax the distance gets
1823                  again too large for the short jumps.  Let's assume
1824                  a typical code-size reduction due to relax for a
1825                  16k device of 600 bytes.  So let's use twice the
1826                  typical value as safety margin.  */
1827               int rgap;
1828               int safety_margin;
1829
1830               int assumed_shrink = 600;
1831               if (avr_pc_wrap_around > 0x4000)
1832                 assumed_shrink = 900;
1833
1834               safety_margin = 2 * assumed_shrink;
1835
1836               rgap = avr_relative_distance_considering_wrap_around (gap);
1837
1838               if (rgap >= (-4092 + safety_margin)
1839                   && rgap <= (4094 - safety_margin))
1840                 distance_short_enough = 1;
1841             }
1842
1843             if (distance_short_enough)
1844               {
1845                 unsigned char code_msb;
1846                 unsigned char code_lsb;
1847
1848                 if (debug_relax)
1849                   printf ("shrinking jump/call instruction at address 0x%x"
1850                           " in section %s\n\n",
1851                           (int) dot, sec->name);
1852
1853                 /* Note that we've changed the relocs, section contents,
1854                    etc.  */
1855                 elf_section_data (sec)->relocs = internal_relocs;
1856                 elf_section_data (sec)->this_hdr.contents = contents;
1857                 symtab_hdr->contents = (unsigned char *) isymbuf;
1858
1859                 /* Get the instruction code for relaxing.  */
1860                 code_lsb = bfd_get_8 (abfd, contents + irel->r_offset);
1861                 code_msb = bfd_get_8 (abfd, contents + irel->r_offset + 1);
1862
1863                 /* Mask out the relocation bits.  */
1864                 code_msb &= 0x94;
1865                 code_lsb &= 0x0E;
1866                 if (code_msb == 0x94 && code_lsb == 0x0E)
1867                   {
1868                     /* we are changing call -> rcall .  */
1869                     bfd_put_8 (abfd, 0x00, contents + irel->r_offset);
1870                     bfd_put_8 (abfd, 0xD0, contents + irel->r_offset + 1);
1871                   }
1872                 else if (code_msb == 0x94 && code_lsb == 0x0C)
1873                   {
1874                     /* we are changeing jump -> rjmp.  */
1875                     bfd_put_8 (abfd, 0x00, contents + irel->r_offset);
1876                     bfd_put_8 (abfd, 0xC0, contents + irel->r_offset + 1);
1877                   }
1878                 else
1879                   abort ();
1880
1881                 /* Fix the relocation's type.  */
1882                 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1883                                              R_AVR_13_PCREL);
1884
1885                 /* Check for the vector section. There we don't want to
1886                    modify the ordering!  */
1887
1888                 if (!strcmp (sec->name,".vectors")
1889                     || !strcmp (sec->name,".jumptables"))
1890                   {
1891                     /* Let's insert a nop.  */
1892                     bfd_put_8 (abfd, 0x00, contents + irel->r_offset + 2);
1893                     bfd_put_8 (abfd, 0x00, contents + irel->r_offset + 3);
1894                   }
1895                 else
1896                   {
1897                     /* Delete two bytes of data.  */
1898                     if (!elf32_avr_relax_delete_bytes (abfd, sec,
1899                                                        irel->r_offset + 2, 2))
1900                       goto error_return;
1901
1902                     /* That will change things, so, we should relax again.
1903                        Note that this is not required, and it may be slow.  */
1904                     *again = TRUE;
1905                   }
1906               }
1907           }
1908
1909         default:
1910           {
1911             unsigned char code_msb;
1912             unsigned char code_lsb;
1913             bfd_vma dot;
1914
1915             code_msb = bfd_get_8 (abfd, contents + irel->r_offset + 1);
1916             code_lsb = bfd_get_8 (abfd, contents + irel->r_offset + 0);
1917
1918             /* Get the address of this instruction.  */
1919             dot = (sec->output_section->vma
1920                    + sec->output_offset + irel->r_offset);
1921
1922             /* Here we look for rcall/ret or call/ret sequences that could be
1923                safely replaced by rjmp/ret or jmp/ret.  */
1924             if (((code_msb & 0xf0) == 0xd0)
1925                 && avr_replace_call_ret_sequences)
1926               {
1927                 /* This insn is a rcall.  */
1928                 unsigned char next_insn_msb = 0;
1929                 unsigned char next_insn_lsb = 0;
1930
1931                 if (irel->r_offset + 3 < sec->size)
1932                   {
1933                     next_insn_msb =
1934                       bfd_get_8 (abfd, contents + irel->r_offset + 3);
1935                     next_insn_lsb =
1936                       bfd_get_8 (abfd, contents + irel->r_offset + 2);
1937                   }
1938
1939                 if ((0x95 == next_insn_msb) && (0x08 == next_insn_lsb))
1940                   {
1941                     /* The next insn is a ret. We now convert the rcall insn
1942                        into a rjmp instruction.  */
1943                     code_msb &= 0xef;
1944                     bfd_put_8 (abfd, code_msb, contents + irel->r_offset + 1);
1945                     if (debug_relax)
1946                       printf ("converted rcall/ret sequence at address 0x%x"
1947                               " into rjmp/ret sequence. Section is %s\n\n",
1948                               (int) dot, sec->name);
1949                     *again = TRUE;
1950                     break;
1951                   }
1952               }
1953             else if ((0x94 == (code_msb & 0xfe))
1954                      && (0x0e == (code_lsb & 0x0e))
1955                      && avr_replace_call_ret_sequences)
1956               {
1957                 /* This insn is a call.  */
1958                 unsigned char next_insn_msb = 0;
1959                 unsigned char next_insn_lsb = 0;
1960
1961                 if (irel->r_offset + 5 < sec->size)
1962                   {
1963                     next_insn_msb =
1964                       bfd_get_8 (abfd, contents + irel->r_offset + 5);
1965                     next_insn_lsb =
1966                       bfd_get_8 (abfd, contents + irel->r_offset + 4);
1967                   }
1968
1969                 if ((0x95 == next_insn_msb) && (0x08 == next_insn_lsb))
1970                   {
1971                     /* The next insn is a ret. We now convert the call insn
1972                        into a jmp instruction.  */
1973
1974                     code_lsb &= 0xfd;
1975                     bfd_put_8 (abfd, code_lsb, contents + irel->r_offset);
1976                     if (debug_relax)
1977                       printf ("converted call/ret sequence at address 0x%x"
1978                               " into jmp/ret sequence. Section is %s\n\n",
1979                               (int) dot, sec->name);
1980                     *again = TRUE;
1981                     break;
1982                   }
1983               }
1984             else if ((0xc0 == (code_msb & 0xf0))
1985                      || ((0x94 == (code_msb & 0xfe))
1986                          && (0x0c == (code_lsb & 0x0e))))
1987               {
1988                 /* This insn is a rjmp or a jmp.  */
1989                 unsigned char next_insn_msb = 0;
1990                 unsigned char next_insn_lsb = 0;
1991                 int insn_size;
1992
1993                 if (0xc0 == (code_msb & 0xf0))
1994                   insn_size = 2; /* rjmp insn */
1995                 else
1996                   insn_size = 4; /* jmp insn */
1997
1998                 if (irel->r_offset + insn_size + 1 < sec->size)
1999                   {
2000                     next_insn_msb =
2001                       bfd_get_8 (abfd, contents + irel->r_offset
2002                                  + insn_size + 1);
2003                     next_insn_lsb =
2004                       bfd_get_8 (abfd, contents + irel->r_offset
2005                                  + insn_size);
2006                   }
2007
2008                 if ((0x95 == next_insn_msb) && (0x08 == next_insn_lsb))
2009                   {
2010                     /* The next insn is a ret. We possibly could delete
2011                        this ret. First we need to check for preceeding
2012                        sbis/sbic/sbrs or cpse "skip" instructions.  */
2013
2014                     int there_is_preceeding_non_skip_insn = 1;
2015                     bfd_vma address_of_ret;
2016
2017                     address_of_ret = dot + insn_size;
2018
2019                     if (debug_relax && (insn_size == 2))
2020                       printf ("found rjmp / ret sequence at address 0x%x\n",
2021                               (int) dot);
2022                     if (debug_relax && (insn_size == 4))
2023                       printf ("found jmp / ret sequence at address 0x%x\n",
2024                               (int) dot);
2025
2026                     /* We have to make sure that there is a preceeding insn.  */
2027                     if (irel->r_offset >= 2)
2028                       {
2029                         unsigned char preceeding_msb;
2030                         unsigned char preceeding_lsb;
2031                         preceeding_msb =
2032                           bfd_get_8 (abfd, contents + irel->r_offset - 1);
2033                         preceeding_lsb =
2034                           bfd_get_8 (abfd, contents + irel->r_offset - 2);
2035
2036                         /* sbic.  */
2037                         if (0x99 == preceeding_msb)
2038                           there_is_preceeding_non_skip_insn = 0;
2039
2040                         /* sbis.  */
2041                         if (0x9b == preceeding_msb)
2042                           there_is_preceeding_non_skip_insn = 0;
2043
2044                         /* sbrc */
2045                         if ((0xfc == (preceeding_msb & 0xfe)
2046                              && (0x00 == (preceeding_lsb & 0x08))))
2047                           there_is_preceeding_non_skip_insn = 0;
2048
2049                         /* sbrs */
2050                         if ((0xfe == (preceeding_msb & 0xfe)
2051                              && (0x00 == (preceeding_lsb & 0x08))))
2052                           there_is_preceeding_non_skip_insn = 0;
2053
2054                         /* cpse */
2055                         if (0x10 == (preceeding_msb & 0xfc))
2056                           there_is_preceeding_non_skip_insn = 0;
2057
2058                         if (there_is_preceeding_non_skip_insn == 0)
2059                           if (debug_relax)
2060                             printf ("preceeding skip insn prevents deletion of"
2061                                     " ret insn at addr 0x%x in section %s\n",
2062                                     (int) dot + 2, sec->name);
2063                       }
2064                     else
2065                       {
2066                         /* There is no previous instruction.  */
2067                         there_is_preceeding_non_skip_insn = 0;
2068                       }
2069
2070                     if (there_is_preceeding_non_skip_insn)
2071                       {
2072                         /* We now only have to make sure that there is no
2073                            local label defined at the address of the ret
2074                            instruction and that there is no local relocation
2075                            in this section pointing to the ret.  */
2076
2077                         int deleting_ret_is_safe = 1;
2078                         unsigned int section_offset_of_ret_insn =
2079                           irel->r_offset + insn_size;
2080                         Elf_Internal_Sym *isym, *isymend;
2081                         unsigned int sec_shndx;
2082
2083                         sec_shndx =
2084                           _bfd_elf_section_from_bfd_section (abfd, sec);
2085
2086                         /* Check for local symbols.  */
2087                         isym = (Elf_Internal_Sym *) symtab_hdr->contents;
2088                         isymend = isym + symtab_hdr->sh_info;
2089                         /* PR 6019: There may not be any local symbols.  */
2090                         for (; isym != NULL && isym < isymend; isym++)
2091                           {
2092                             if (isym->st_value == section_offset_of_ret_insn
2093                                 && isym->st_shndx == sec_shndx)
2094                               {
2095                                 deleting_ret_is_safe = 0;
2096                                 if (debug_relax)
2097                                   printf ("local label prevents deletion of ret "
2098                                           "insn at address 0x%x\n",
2099                                           (int) dot + insn_size);
2100                               }
2101                           }
2102
2103                         /* Now check for global symbols.  */
2104                         {
2105                           int symcount;
2106                           struct elf_link_hash_entry **sym_hashes;
2107                           struct elf_link_hash_entry **end_hashes;
2108
2109                           symcount = (symtab_hdr->sh_size
2110                                       / sizeof (Elf32_External_Sym)
2111                                       - symtab_hdr->sh_info);
2112                           sym_hashes = elf_sym_hashes (abfd);
2113                           end_hashes = sym_hashes + symcount;
2114                           for (; sym_hashes < end_hashes; sym_hashes++)
2115                             {
2116                               struct elf_link_hash_entry *sym_hash =
2117                                 *sym_hashes;
2118                               if ((sym_hash->root.type == bfd_link_hash_defined
2119                                    || sym_hash->root.type ==
2120                                    bfd_link_hash_defweak)
2121                                   && sym_hash->root.u.def.section == sec
2122                                   && sym_hash->root.u.def.value == section_offset_of_ret_insn)
2123                                 {
2124                                   deleting_ret_is_safe = 0;
2125                                   if (debug_relax)
2126                                     printf ("global label prevents deletion of "
2127                                             "ret insn at address 0x%x\n",
2128                                             (int) dot + insn_size);
2129                                 }
2130                             }
2131                         }
2132                         /* Now we check for relocations pointing to ret.  */
2133                         {
2134                           Elf_Internal_Rela *rel;
2135                           Elf_Internal_Rela *relend;
2136
2137                           relend = elf_section_data (sec)->relocs
2138                             + sec->reloc_count;
2139
2140                           for (rel = elf_section_data (sec)->relocs;
2141                                rel < relend; rel++)
2142                             {
2143                               bfd_vma reloc_target = 0;
2144
2145                               /* Read this BFD's local symbols if we haven't
2146                                  done so already.  */
2147                               if (isymbuf == NULL && symtab_hdr->sh_info != 0)
2148                                 {
2149                                   isymbuf = (Elf_Internal_Sym *)
2150                                     symtab_hdr->contents;
2151                                   if (isymbuf == NULL)
2152                                     isymbuf = bfd_elf_get_elf_syms
2153                                       (abfd,
2154                                        symtab_hdr,
2155                                        symtab_hdr->sh_info, 0,
2156                                        NULL, NULL, NULL);
2157                                   if (isymbuf == NULL)
2158                                     break;
2159                                 }
2160
2161                               /* Get the value of the symbol referred to
2162                                  by the reloc.  */
2163                               if (ELF32_R_SYM (rel->r_info)
2164                                   < symtab_hdr->sh_info)
2165                                 {
2166                                   /* A local symbol.  */
2167                                   asection *sym_sec;
2168
2169                                   isym = isymbuf
2170                                     + ELF32_R_SYM (rel->r_info);
2171                                   sym_sec = bfd_section_from_elf_index
2172                                     (abfd, isym->st_shndx);
2173                                   symval = isym->st_value;
2174
2175                                   /* If the reloc is absolute, it will not
2176                                      have a symbol or section associated
2177                                      with it.  */
2178
2179                                   if (sym_sec)
2180                                     {
2181                                       symval +=
2182                                         sym_sec->output_section->vma
2183                                         + sym_sec->output_offset;
2184                                       reloc_target = symval + rel->r_addend;
2185                                     }
2186                                   else
2187                                     {
2188                                       reloc_target = symval + rel->r_addend;
2189                                       /* Reference symbol is absolute.  */
2190                                     }
2191                                 }
2192                               /* else ... reference symbol is extern.  */
2193
2194                               if (address_of_ret == reloc_target)
2195                                 {
2196                                   deleting_ret_is_safe = 0;
2197                                   if (debug_relax)
2198                                     printf ("ret from "
2199                                             "rjmp/jmp ret sequence at address"
2200                                             " 0x%x could not be deleted. ret"
2201                                             " is target of a relocation.\n",
2202                                             (int) address_of_ret);
2203                                 }
2204                             }
2205                         }
2206
2207                         if (deleting_ret_is_safe)
2208                           {
2209                             if (debug_relax)
2210                               printf ("unreachable ret instruction "
2211                                       "at address 0x%x deleted.\n",
2212                                       (int) dot + insn_size);
2213
2214                             /* Delete two bytes of data.  */
2215                             if (!elf32_avr_relax_delete_bytes (abfd, sec,
2216                                                                irel->r_offset + insn_size, 2))
2217                               goto error_return;
2218
2219                             /* That will change things, so, we should relax
2220                                again. Note that this is not required, and it
2221                                may be slow.  */
2222                             *again = TRUE;
2223                             break;
2224                           }
2225                       }
2226
2227                   }
2228               }
2229             break;
2230           }
2231         }
2232     }
2233
2234   if (contents != NULL
2235       && elf_section_data (sec)->this_hdr.contents != contents)
2236     {
2237       if (! link_info->keep_memory)
2238         free (contents);
2239       else
2240         {
2241           /* Cache the section contents for elf_link_input_bfd.  */
2242           elf_section_data (sec)->this_hdr.contents = contents;
2243         }
2244     }
2245
2246   if (internal_relocs != NULL
2247       && elf_section_data (sec)->relocs != internal_relocs)
2248     free (internal_relocs);
2249
2250   return TRUE;
2251
2252  error_return:
2253   if (isymbuf != NULL
2254       && symtab_hdr->contents != (unsigned char *) isymbuf)
2255     free (isymbuf);
2256   if (contents != NULL
2257       && elf_section_data (sec)->this_hdr.contents != contents)
2258     free (contents);
2259   if (internal_relocs != NULL
2260       && elf_section_data (sec)->relocs != internal_relocs)
2261     free (internal_relocs);
2262
2263   return FALSE;
2264 }
2265
2266 /* This is a version of bfd_generic_get_relocated_section_contents
2267    which uses elf32_avr_relocate_section.
2268
2269    For avr it's essentially a cut and paste taken from the H8300 port.
2270    The author of the relaxation support patch for avr had absolutely no
2271    clue what is happening here but found out that this part of the code
2272    seems to be important.  */
2273
2274 static bfd_byte *
2275 elf32_avr_get_relocated_section_contents (bfd *output_bfd,
2276                                           struct bfd_link_info *link_info,
2277                                           struct bfd_link_order *link_order,
2278                                           bfd_byte *data,
2279                                           bfd_boolean relocatable,
2280                                           asymbol **symbols)
2281 {
2282   Elf_Internal_Shdr *symtab_hdr;
2283   asection *input_section = link_order->u.indirect.section;
2284   bfd *input_bfd = input_section->owner;
2285   asection **sections = NULL;
2286   Elf_Internal_Rela *internal_relocs = NULL;
2287   Elf_Internal_Sym *isymbuf = NULL;
2288
2289   /* We only need to handle the case of relaxing, or of having a
2290      particular set of section contents, specially.  */
2291   if (relocatable
2292       || elf_section_data (input_section)->this_hdr.contents == NULL)
2293     return bfd_generic_get_relocated_section_contents (output_bfd, link_info,
2294                                                        link_order, data,
2295                                                        relocatable,
2296                                                        symbols);
2297   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2298
2299   memcpy (data, elf_section_data (input_section)->this_hdr.contents,
2300           (size_t) input_section->size);
2301
2302   if ((input_section->flags & SEC_RELOC) != 0
2303       && input_section->reloc_count > 0)
2304     {
2305       asection **secpp;
2306       Elf_Internal_Sym *isym, *isymend;
2307       bfd_size_type amt;
2308
2309       internal_relocs = (_bfd_elf_link_read_relocs
2310                          (input_bfd, input_section, NULL, NULL, FALSE));
2311       if (internal_relocs == NULL)
2312         goto error_return;
2313
2314       if (symtab_hdr->sh_info != 0)
2315         {
2316           isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
2317           if (isymbuf == NULL)
2318             isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
2319                                             symtab_hdr->sh_info, 0,
2320                                             NULL, NULL, NULL);
2321           if (isymbuf == NULL)
2322             goto error_return;
2323         }
2324
2325       amt = symtab_hdr->sh_info;
2326       amt *= sizeof (asection *);
2327       sections = bfd_malloc (amt);
2328       if (sections == NULL && amt != 0)
2329         goto error_return;
2330
2331       isymend = isymbuf + symtab_hdr->sh_info;
2332       for (isym = isymbuf, secpp = sections; isym < isymend; ++isym, ++secpp)
2333         {
2334           asection *isec;
2335
2336           if (isym->st_shndx == SHN_UNDEF)
2337             isec = bfd_und_section_ptr;
2338           else if (isym->st_shndx == SHN_ABS)
2339             isec = bfd_abs_section_ptr;
2340           else if (isym->st_shndx == SHN_COMMON)
2341             isec = bfd_com_section_ptr;
2342           else
2343             isec = bfd_section_from_elf_index (input_bfd, isym->st_shndx);
2344
2345           *secpp = isec;
2346         }
2347
2348       if (! elf32_avr_relocate_section (output_bfd, link_info, input_bfd,
2349                                         input_section, data, internal_relocs,
2350                                         isymbuf, sections))
2351         goto error_return;
2352
2353       if (sections != NULL)
2354         free (sections);
2355       if (isymbuf != NULL
2356           && symtab_hdr->contents != (unsigned char *) isymbuf)
2357         free (isymbuf);
2358       if (elf_section_data (input_section)->relocs != internal_relocs)
2359         free (internal_relocs);
2360     }
2361
2362   return data;
2363
2364  error_return:
2365   if (sections != NULL)
2366     free (sections);
2367   if (isymbuf != NULL
2368       && symtab_hdr->contents != (unsigned char *) isymbuf)
2369     free (isymbuf);
2370   if (internal_relocs != NULL
2371       && elf_section_data (input_section)->relocs != internal_relocs)
2372     free (internal_relocs);
2373   return NULL;
2374 }
2375
2376
2377 /* Determines the hash entry name for a particular reloc. It consists of
2378    the identifier of the symbol section and the added reloc addend and
2379    symbol offset relative to the section the symbol is attached to.  */
2380
2381 static char *
2382 avr_stub_name (const asection *symbol_section,
2383                const bfd_vma symbol_offset,
2384                const Elf_Internal_Rela *rela)
2385 {
2386   char *stub_name;
2387   bfd_size_type len;
2388
2389   len = 8 + 1 + 8 + 1 + 1;
2390   stub_name = bfd_malloc (len);
2391
2392   sprintf (stub_name, "%08x+%08x",
2393            symbol_section->id & 0xffffffff,
2394            (unsigned int) ((rela->r_addend & 0xffffffff) + symbol_offset));
2395
2396   return stub_name;
2397 }
2398
2399
2400 /* Add a new stub entry to the stub hash.  Not all fields of the new
2401    stub entry are initialised.  */
2402
2403 static struct elf32_avr_stub_hash_entry *
2404 avr_add_stub (const char *stub_name,
2405               struct elf32_avr_link_hash_table *htab)
2406 {
2407   struct elf32_avr_stub_hash_entry *hsh;
2408
2409   /* Enter this entry into the linker stub hash table.  */
2410   hsh = avr_stub_hash_lookup (&htab->bstab, stub_name, TRUE, FALSE);
2411
2412   if (hsh == NULL)
2413     {
2414       (*_bfd_error_handler) (_("%B: cannot create stub entry %s"),
2415                              NULL, stub_name);
2416       return NULL;
2417     }
2418
2419   hsh->stub_offset = 0;
2420   return hsh;
2421 }
2422
2423 /* We assume that there is already space allocated for the stub section
2424    contents and that before building the stubs the section size is
2425    initialized to 0.  We assume that within the stub hash table entry,
2426    the absolute position of the jmp target has been written in the
2427    target_value field.  We write here the offset of the generated jmp insn
2428    relative to the trampoline section start to the stub_offset entry in
2429    the stub hash table entry.  */
2430
2431 static  bfd_boolean
2432 avr_build_one_stub (struct bfd_hash_entry *bh, void *in_arg)
2433 {
2434   struct elf32_avr_stub_hash_entry *hsh;
2435   struct bfd_link_info *info;
2436   struct elf32_avr_link_hash_table *htab;
2437   bfd *stub_bfd;
2438   bfd_byte *loc;
2439   bfd_vma target;
2440   bfd_vma starget;
2441
2442   /* Basic opcode */
2443   bfd_vma jmp_insn = 0x0000940c;
2444
2445   /* Massage our args to the form they really have.  */
2446   hsh = avr_stub_hash_entry (bh);
2447
2448   if (!hsh->is_actually_needed)
2449     return TRUE;
2450
2451   info = (struct bfd_link_info *) in_arg;
2452
2453   htab = avr_link_hash_table (info);
2454   if (htab == NULL)
2455     return FALSE;
2456
2457   target = hsh->target_value;
2458
2459   /* Make a note of the offset within the stubs for this entry.  */
2460   hsh->stub_offset = htab->stub_sec->size;
2461   loc = htab->stub_sec->contents + hsh->stub_offset;
2462
2463   stub_bfd = htab->stub_sec->owner;
2464
2465   if (debug_stubs)
2466     printf ("Building one Stub. Address: 0x%x, Offset: 0x%x\n",
2467              (unsigned int) target,
2468              (unsigned int) hsh->stub_offset);
2469
2470   /* We now have to add the information on the jump target to the bare
2471      opcode bits already set in jmp_insn.  */
2472
2473   /* Check for the alignment of the address.  */
2474   if (target & 1)
2475      return FALSE;
2476
2477   starget = target >> 1;
2478   jmp_insn |= ((starget & 0x10000) | ((starget << 3) & 0x1f00000)) >> 16;
2479   bfd_put_16 (stub_bfd, jmp_insn, loc);
2480   bfd_put_16 (stub_bfd, (bfd_vma) starget & 0xffff, loc + 2);
2481
2482   htab->stub_sec->size += 4;
2483
2484   /* Now add the entries in the address mapping table if there is still
2485      space left.  */
2486   {
2487     unsigned int nr;
2488
2489     nr = htab->amt_entry_cnt + 1;
2490     if (nr <= htab->amt_max_entry_cnt)
2491       {
2492         htab->amt_entry_cnt = nr;
2493
2494         htab->amt_stub_offsets[nr - 1] = hsh->stub_offset;
2495         htab->amt_destination_addr[nr - 1] = target;
2496       }
2497   }
2498
2499   return TRUE;
2500 }
2501
2502 static bfd_boolean
2503 avr_mark_stub_not_to_be_necessary (struct bfd_hash_entry *bh,
2504                                    void *in_arg ATTRIBUTE_UNUSED)
2505 {
2506   struct elf32_avr_stub_hash_entry *hsh;
2507
2508   hsh = avr_stub_hash_entry (bh);
2509   hsh->is_actually_needed = FALSE;
2510
2511   return TRUE;
2512 }
2513
2514 static bfd_boolean
2515 avr_size_one_stub (struct bfd_hash_entry *bh, void *in_arg)
2516 {
2517   struct elf32_avr_stub_hash_entry *hsh;
2518   struct elf32_avr_link_hash_table *htab;
2519   int size;
2520
2521   /* Massage our args to the form they really have.  */
2522   hsh = avr_stub_hash_entry (bh);
2523   htab = in_arg;
2524
2525   if (hsh->is_actually_needed)
2526     size = 4;
2527   else
2528     size = 0;
2529
2530   htab->stub_sec->size += size;
2531   return TRUE;
2532 }
2533
2534 void
2535 elf32_avr_setup_params (struct bfd_link_info *info,
2536                         bfd *avr_stub_bfd,
2537                         asection *avr_stub_section,
2538                         bfd_boolean no_stubs,
2539                         bfd_boolean deb_stubs,
2540                         bfd_boolean deb_relax,
2541                         bfd_vma pc_wrap_around,
2542                         bfd_boolean call_ret_replacement)
2543 {
2544   struct elf32_avr_link_hash_table *htab = avr_link_hash_table (info);
2545
2546   if (htab == NULL)
2547     return;
2548   htab->stub_sec = avr_stub_section;
2549   htab->stub_bfd = avr_stub_bfd;
2550   htab->no_stubs = no_stubs;
2551
2552   debug_relax = deb_relax;
2553   debug_stubs = deb_stubs;
2554   avr_pc_wrap_around = pc_wrap_around;
2555   avr_replace_call_ret_sequences = call_ret_replacement;
2556 }
2557
2558
2559 /* Set up various things so that we can make a list of input sections
2560    for each output section included in the link.  Returns -1 on error,
2561    0 when no stubs will be needed, and 1 on success.  It also sets
2562    information on the stubs bfd and the stub section in the info
2563    struct.  */
2564
2565 int
2566 elf32_avr_setup_section_lists (bfd *output_bfd,
2567                                struct bfd_link_info *info)
2568 {
2569   bfd *input_bfd;
2570   unsigned int bfd_count;
2571   int top_id, top_index;
2572   asection *section;
2573   asection **input_list, **list;
2574   bfd_size_type amt;
2575   struct elf32_avr_link_hash_table *htab = avr_link_hash_table (info);
2576
2577   if (htab == NULL || htab->no_stubs)
2578     return 0;
2579
2580   /* Count the number of input BFDs and find the top input section id.  */
2581   for (input_bfd = info->input_bfds, bfd_count = 0, top_id = 0;
2582        input_bfd != NULL;
2583        input_bfd = input_bfd->link_next)
2584     {
2585       bfd_count += 1;
2586       for (section = input_bfd->sections;
2587            section != NULL;
2588            section = section->next)
2589         if (top_id < section->id)
2590           top_id = section->id;
2591     }
2592
2593   htab->bfd_count = bfd_count;
2594
2595   /* We can't use output_bfd->section_count here to find the top output
2596      section index as some sections may have been removed, and
2597      strip_excluded_output_sections doesn't renumber the indices.  */
2598   for (section = output_bfd->sections, top_index = 0;
2599        section != NULL;
2600        section = section->next)
2601     if (top_index < section->index)
2602       top_index = section->index;
2603
2604   htab->top_index = top_index;
2605   amt = sizeof (asection *) * (top_index + 1);
2606   input_list = bfd_malloc (amt);
2607   htab->input_list = input_list;
2608   if (input_list == NULL)
2609     return -1;
2610
2611   /* For sections we aren't interested in, mark their entries with a
2612      value we can check later.  */
2613   list = input_list + top_index;
2614   do
2615     *list = bfd_abs_section_ptr;
2616   while (list-- != input_list);
2617
2618   for (section = output_bfd->sections;
2619        section != NULL;
2620        section = section->next)
2621     if ((section->flags & SEC_CODE) != 0)
2622       input_list[section->index] = NULL;
2623
2624   return 1;
2625 }
2626
2627
2628 /* Read in all local syms for all input bfds, and create hash entries
2629    for export stubs if we are building a multi-subspace shared lib.
2630    Returns -1 on error, 0 otherwise.  */
2631
2632 static int
2633 get_local_syms (bfd *input_bfd, struct bfd_link_info *info)
2634 {
2635   unsigned int bfd_indx;
2636   Elf_Internal_Sym *local_syms, **all_local_syms;
2637   struct elf32_avr_link_hash_table *htab = avr_link_hash_table (info);
2638   bfd_size_type amt;
2639
2640   if (htab == NULL)
2641     return -1;
2642
2643   /* We want to read in symbol extension records only once.  To do this
2644      we need to read in the local symbols in parallel and save them for
2645      later use; so hold pointers to the local symbols in an array.  */
2646   amt = sizeof (Elf_Internal_Sym *) * htab->bfd_count;
2647   all_local_syms = bfd_zmalloc (amt);
2648   htab->all_local_syms = all_local_syms;
2649   if (all_local_syms == NULL)
2650     return -1;
2651
2652   /* Walk over all the input BFDs, swapping in local symbols.
2653      If we are creating a shared library, create hash entries for the
2654      export stubs.  */
2655   for (bfd_indx = 0;
2656        input_bfd != NULL;
2657        input_bfd = input_bfd->link_next, bfd_indx++)
2658     {
2659       Elf_Internal_Shdr *symtab_hdr;
2660
2661       /* We'll need the symbol table in a second.  */
2662       symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2663       if (symtab_hdr->sh_info == 0)
2664         continue;
2665
2666       /* We need an array of the local symbols attached to the input bfd.  */
2667       local_syms = (Elf_Internal_Sym *) symtab_hdr->contents;
2668       if (local_syms == NULL)
2669         {
2670           local_syms = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
2671                                              symtab_hdr->sh_info, 0,
2672                                              NULL, NULL, NULL);
2673           /* Cache them for elf_link_input_bfd.  */
2674           symtab_hdr->contents = (unsigned char *) local_syms;
2675         }
2676       if (local_syms == NULL)
2677         return -1;
2678
2679       all_local_syms[bfd_indx] = local_syms;
2680     }
2681
2682   return 0;
2683 }
2684
2685 #define ADD_DUMMY_STUBS_FOR_DEBUGGING 0
2686
2687 bfd_boolean
2688 elf32_avr_size_stubs (bfd *output_bfd,
2689                       struct bfd_link_info *info,
2690                       bfd_boolean is_prealloc_run)
2691 {
2692   struct elf32_avr_link_hash_table *htab;
2693   int stub_changed = 0;
2694
2695   htab = avr_link_hash_table (info);
2696   if (htab == NULL)
2697     return FALSE;
2698
2699   /* At this point we initialize htab->vector_base
2700      To the start of the text output section.  */
2701   htab->vector_base = htab->stub_sec->output_section->vma;
2702
2703   if (get_local_syms (info->input_bfds, info))
2704     {
2705       if (htab->all_local_syms)
2706         goto error_ret_free_local;
2707       return FALSE;
2708     }
2709
2710   if (ADD_DUMMY_STUBS_FOR_DEBUGGING)
2711     {
2712       struct elf32_avr_stub_hash_entry *test;
2713
2714       test = avr_add_stub ("Hugo",htab);
2715       test->target_value = 0x123456;
2716       test->stub_offset = 13;
2717
2718       test = avr_add_stub ("Hugo2",htab);
2719       test->target_value = 0x84210;
2720       test->stub_offset = 14;
2721     }
2722
2723   while (1)
2724     {
2725       bfd *input_bfd;
2726       unsigned int bfd_indx;
2727
2728       /* We will have to re-generate the stub hash table each time anything
2729          in memory has changed.  */
2730
2731       bfd_hash_traverse (&htab->bstab, avr_mark_stub_not_to_be_necessary, htab);
2732       for (input_bfd = info->input_bfds, bfd_indx = 0;
2733            input_bfd != NULL;
2734            input_bfd = input_bfd->link_next, bfd_indx++)
2735         {
2736           Elf_Internal_Shdr *symtab_hdr;
2737           asection *section;
2738           Elf_Internal_Sym *local_syms;
2739
2740           /* We'll need the symbol table in a second.  */
2741           symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2742           if (symtab_hdr->sh_info == 0)
2743             continue;
2744
2745           local_syms = htab->all_local_syms[bfd_indx];
2746
2747           /* Walk over each section attached to the input bfd.  */
2748           for (section = input_bfd->sections;
2749                section != NULL;
2750                section = section->next)
2751             {
2752               Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
2753
2754               /* If there aren't any relocs, then there's nothing more
2755                  to do.  */
2756               if ((section->flags & SEC_RELOC) == 0
2757                   || section->reloc_count == 0)
2758                 continue;
2759
2760               /* If this section is a link-once section that will be
2761                  discarded, then don't create any stubs.  */
2762               if (section->output_section == NULL
2763                   || section->output_section->owner != output_bfd)
2764                 continue;
2765
2766               /* Get the relocs.  */
2767               internal_relocs
2768                 = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL,
2769                                              info->keep_memory);
2770               if (internal_relocs == NULL)
2771                 goto error_ret_free_local;
2772
2773               /* Now examine each relocation.  */
2774               irela = internal_relocs;
2775               irelaend = irela + section->reloc_count;
2776               for (; irela < irelaend; irela++)
2777                 {
2778                   unsigned int r_type, r_indx;
2779                   struct elf32_avr_stub_hash_entry *hsh;
2780                   asection *sym_sec;
2781                   bfd_vma sym_value;
2782                   bfd_vma destination;
2783                   struct elf_link_hash_entry *hh;
2784                   char *stub_name;
2785
2786                   r_type = ELF32_R_TYPE (irela->r_info);
2787                   r_indx = ELF32_R_SYM (irela->r_info);
2788
2789                   /* Only look for 16 bit GS relocs. No other reloc will need a
2790                      stub.  */
2791                   if (!((r_type == R_AVR_16_PM)
2792                         || (r_type == R_AVR_LO8_LDI_GS)
2793                         || (r_type == R_AVR_HI8_LDI_GS)))
2794                     continue;
2795
2796                   /* Now determine the call target, its name, value,
2797                      section.  */
2798                   sym_sec = NULL;
2799                   sym_value = 0;
2800                   destination = 0;
2801                   hh = NULL;
2802                   if (r_indx < symtab_hdr->sh_info)
2803                     {
2804                       /* It's a local symbol.  */
2805                       Elf_Internal_Sym *sym;
2806                       Elf_Internal_Shdr *hdr;
2807                       unsigned int shndx;
2808
2809                       sym = local_syms + r_indx;
2810                       if (ELF_ST_TYPE (sym->st_info) != STT_SECTION)
2811                         sym_value = sym->st_value;
2812                       shndx = sym->st_shndx;
2813                       if (shndx < elf_numsections (input_bfd))
2814                         {
2815                           hdr = elf_elfsections (input_bfd)[shndx];
2816                           sym_sec = hdr->bfd_section;
2817                           destination = (sym_value + irela->r_addend
2818                                          + sym_sec->output_offset
2819                                          + sym_sec->output_section->vma);
2820                         }
2821                     }
2822                   else
2823                     {
2824                       /* It's an external symbol.  */
2825                       int e_indx;
2826
2827                       e_indx = r_indx - symtab_hdr->sh_info;
2828                       hh = elf_sym_hashes (input_bfd)[e_indx];
2829
2830                       while (hh->root.type == bfd_link_hash_indirect
2831                              || hh->root.type == bfd_link_hash_warning)
2832                         hh = (struct elf_link_hash_entry *)
2833                               (hh->root.u.i.link);
2834
2835                       if (hh->root.type == bfd_link_hash_defined
2836                           || hh->root.type == bfd_link_hash_defweak)
2837                         {
2838                           sym_sec = hh->root.u.def.section;
2839                           sym_value = hh->root.u.def.value;
2840                           if (sym_sec->output_section != NULL)
2841                           destination = (sym_value + irela->r_addend
2842                                          + sym_sec->output_offset
2843                                          + sym_sec->output_section->vma);
2844                         }
2845                       else if (hh->root.type == bfd_link_hash_undefweak)
2846                         {
2847                           if (! info->shared)
2848                             continue;
2849                         }
2850                       else if (hh->root.type == bfd_link_hash_undefined)
2851                         {
2852                           if (! (info->unresolved_syms_in_objects == RM_IGNORE
2853                                  && (ELF_ST_VISIBILITY (hh->other)
2854                                      == STV_DEFAULT)))
2855                              continue;
2856                         }
2857                       else
2858                         {
2859                           bfd_set_error (bfd_error_bad_value);
2860
2861                           error_ret_free_internal:
2862                           if (elf_section_data (section)->relocs == NULL)
2863                             free (internal_relocs);
2864                           goto error_ret_free_local;
2865                         }
2866                     }
2867
2868                   if (! avr_stub_is_required_for_16_bit_reloc
2869                       (destination - htab->vector_base))
2870                     {
2871                       if (!is_prealloc_run)
2872                         /* We are having a reloc that does't need a stub.  */
2873                         continue;
2874
2875                       /* We don't right now know if a stub will be needed.
2876                          Let's rather be on the safe side.  */
2877                     }
2878
2879                   /* Get the name of this stub.  */
2880                   stub_name = avr_stub_name (sym_sec, sym_value, irela);
2881
2882                   if (!stub_name)
2883                     goto error_ret_free_internal;
2884
2885
2886                   hsh = avr_stub_hash_lookup (&htab->bstab,
2887                                               stub_name,
2888                                               FALSE, FALSE);
2889                   if (hsh != NULL)
2890                     {
2891                       /* The proper stub has already been created.  Mark it
2892                          to be used and write the possibly changed destination
2893                          value.  */
2894                       hsh->is_actually_needed = TRUE;
2895                       hsh->target_value = destination;
2896                       free (stub_name);
2897                       continue;
2898                     }
2899
2900                   hsh = avr_add_stub (stub_name, htab);
2901                   if (hsh == NULL)
2902                     {
2903                       free (stub_name);
2904                       goto error_ret_free_internal;
2905                     }
2906
2907                   hsh->is_actually_needed = TRUE;
2908                   hsh->target_value = destination;
2909
2910                   if (debug_stubs)
2911                     printf ("Adding stub with destination 0x%x to the"
2912                             " hash table.\n", (unsigned int) destination);
2913                   if (debug_stubs)
2914                     printf ("(Pre-Alloc run: %i)\n", is_prealloc_run);
2915
2916                   stub_changed = TRUE;
2917                 }
2918
2919               /* We're done with the internal relocs, free them.  */
2920               if (elf_section_data (section)->relocs == NULL)
2921                 free (internal_relocs);
2922             }
2923         }
2924
2925       /* Re-Calculate the number of needed stubs.  */
2926       htab->stub_sec->size = 0;
2927       bfd_hash_traverse (&htab->bstab, avr_size_one_stub, htab);
2928
2929       if (!stub_changed)
2930         break;
2931
2932       stub_changed = FALSE;
2933     }
2934
2935   free (htab->all_local_syms);
2936   return TRUE;
2937
2938  error_ret_free_local:
2939   free (htab->all_local_syms);
2940   return FALSE;
2941 }
2942
2943
2944 /* Build all the stubs associated with the current output file.  The
2945    stubs are kept in a hash table attached to the main linker hash
2946    table.  We also set up the .plt entries for statically linked PIC
2947    functions here.  This function is called via hppaelf_finish in the
2948    linker.  */
2949
2950 bfd_boolean
2951 elf32_avr_build_stubs (struct bfd_link_info *info)
2952 {
2953   asection *stub_sec;
2954   struct bfd_hash_table *table;
2955   struct elf32_avr_link_hash_table *htab;
2956   bfd_size_type total_size = 0;
2957
2958   htab = avr_link_hash_table (info);
2959   if (htab == NULL)
2960     return FALSE;
2961
2962   /* In case that there were several stub sections:  */
2963   for (stub_sec = htab->stub_bfd->sections;
2964        stub_sec != NULL;
2965        stub_sec = stub_sec->next)
2966     {
2967       bfd_size_type size;
2968
2969       /* Allocate memory to hold the linker stubs.  */
2970       size = stub_sec->size;
2971       total_size += size;
2972
2973       stub_sec->contents = bfd_zalloc (htab->stub_bfd, size);
2974       if (stub_sec->contents == NULL && size != 0)
2975         return FALSE;
2976       stub_sec->size = 0;
2977     }
2978
2979   /* Allocate memory for the adress mapping table.  */
2980   htab->amt_entry_cnt = 0;
2981   htab->amt_max_entry_cnt = total_size / 4;
2982   htab->amt_stub_offsets = bfd_malloc (sizeof (bfd_vma)
2983                                        * htab->amt_max_entry_cnt);
2984   htab->amt_destination_addr = bfd_malloc (sizeof (bfd_vma)
2985                                            * htab->amt_max_entry_cnt );
2986
2987   if (debug_stubs)
2988     printf ("Allocating %i entries in the AMT\n", htab->amt_max_entry_cnt);
2989
2990   /* Build the stubs as directed by the stub hash table.  */
2991   table = &htab->bstab;
2992   bfd_hash_traverse (table, avr_build_one_stub, info);
2993
2994   if (debug_stubs)
2995     printf ("Final Stub section Size: %i\n", (int) htab->stub_sec->size);
2996
2997   return TRUE;
2998 }
2999
3000 #define ELF_ARCH                bfd_arch_avr
3001 #define ELF_TARGET_ID           AVR_ELF_DATA
3002 #define ELF_MACHINE_CODE        EM_AVR
3003 #define ELF_MACHINE_ALT1        EM_AVR_OLD
3004 #define ELF_MAXPAGESIZE         1
3005
3006 #define TARGET_LITTLE_SYM       bfd_elf32_avr_vec
3007 #define TARGET_LITTLE_NAME      "elf32-avr"
3008
3009 #define bfd_elf32_bfd_link_hash_table_create elf32_avr_link_hash_table_create
3010 #define bfd_elf32_bfd_link_hash_table_free   elf32_avr_link_hash_table_free
3011
3012 #define elf_info_to_howto                    avr_info_to_howto_rela
3013 #define elf_info_to_howto_rel                NULL
3014 #define elf_backend_relocate_section         elf32_avr_relocate_section
3015 #define elf_backend_can_gc_sections          1
3016 #define elf_backend_rela_normal              1
3017 #define elf_backend_final_write_processing \
3018                                         bfd_elf_avr_final_write_processing
3019 #define elf_backend_object_p            elf32_avr_object_p
3020
3021 #define bfd_elf32_bfd_relax_section elf32_avr_relax_section
3022 #define bfd_elf32_bfd_get_relocated_section_contents \
3023                                         elf32_avr_get_relocated_section_contents
3024
3025 #include "elf32-target.h"