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 /* Look through the relocs for a section during the first phase.
 738    Since we don't do .gots or .plts, we just need to consider the
 739    virtual table relocs for gc.  */
 740
 741 static bfd_boolean
 742 elf32_avr_check_relocs (bfd *abfd,
 743                         struct bfd_link_info *info,
 744                         asection *sec,
 745                         const Elf_Internal_Rela *relocs)
 746 {
 747   Elf_Internal_Shdr *symtab_hdr;
 748   struct elf_link_hash_entry **sym_hashes;
 749   const Elf_Internal_Rela *rel;
 750   const Elf_Internal_Rela *rel_end;
 751
 752   if (info->relocatable)
 753     return TRUE;
 754
 755   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
 756   sym_hashes = elf_sym_hashes (abfd);
 757
 758   rel_end = relocs + sec->reloc_count;
 759   for (rel = relocs; rel < rel_end; rel++)
 760     {
 761       struct elf_link_hash_entry *h;
 762       unsigned long r_symndx;
 763
 764       r_symndx = ELF32_R_SYM (rel->r_info);
 765       if (r_symndx < symtab_hdr->sh_info)
 766         h = NULL;
 767       else
 768         {
 769           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
 770           while (h->root.type == bfd_link_hash_indirect
 771                  || h->root.type == bfd_link_hash_warning)
 772             h = (struct elf_link_hash_entry *) h->root.u.i.link;
 773         }
 774     }
 775
 776   return TRUE;
 777 }
 778
 779 static bfd_boolean
 780 avr_stub_is_required_for_16_bit_reloc (bfd_vma relocation)
 781 {
 782   return (relocation >= 0x020000);
 783 }
 784
 785 /* Returns the address of the corresponding stub if there is one.
 786    Returns otherwise an address above 0x020000.  This function
 787    could also be used, if there is no knowledge on the section where
 788    the destination is found.  */
 789
 790 static bfd_vma
 791 avr_get_stub_addr (bfd_vma srel,
 792                    struct elf32_avr_link_hash_table *htab)
 793 {
 794   unsigned int sindex;
 795   bfd_vma stub_sec_addr =
 796               (htab->stub_sec->output_section->vma +
 797                htab->stub_sec->output_offset);
 798
 799   for (sindex = 0; sindex < htab->amt_max_entry_cnt; sindex ++)
 800     if (htab->amt_destination_addr[sindex] == srel)
 801       return htab->amt_stub_offsets[sindex] + stub_sec_addr;
 802
 803   /* Return an address that could not be reached by 16 bit relocs.  */
 804   return 0x020000;
 805 }
 806
 807 /* Perform a single relocation.  By default we use the standard BFD
 808    routines, but a few relocs, we have to do them ourselves.  */
 809
 810 static bfd_reloc_status_type
 811 avr_final_link_relocate (reloc_howto_type *                 howto,
 812                          bfd *                              input_bfd,
 813                          asection *                         input_section,
 814                          bfd_byte *                         contents,
 815                          Elf_Internal_Rela *                rel,
 816                          bfd_vma                            relocation,
 817                          struct elf32_avr_link_hash_table * htab)
 818 {
 819   bfd_reloc_status_type r = bfd_reloc_ok;
 820   bfd_vma               x;
 821   bfd_signed_vma        srel;
 822   bfd_signed_vma        reloc_addr;
 823   bfd_boolean           use_stubs = FALSE;
 824   /* Usually is 0, unless we are generating code for a bootloader.  */
 825   bfd_signed_vma        base_addr = htab->vector_base;
 826
 827   /* Absolute addr of the reloc in the final excecutable.  */
 828   reloc_addr = rel->r_offset + input_section->output_section->vma
 829                + input_section->output_offset;
 830
 831   switch (howto->type)
 832     {
 833     case R_AVR_7_PCREL:
 834       contents += rel->r_offset;
 835       srel = (bfd_signed_vma) relocation;
 836       srel += rel->r_addend;
 837       srel -= rel->r_offset;
 838       srel -= 2;        /* Branch instructions add 2 to the PC...  */
 839       srel -= (input_section->output_section->vma +
 840                input_section->output_offset);
 841
 842       if (srel & 1)
 843         return bfd_reloc_outofrange;
 844       if (srel > ((1 << 7) - 1) || (srel < - (1 << 7)))
 845         return bfd_reloc_overflow;
 846       x = bfd_get_16 (input_bfd, contents);
 847       x = (x & 0xfc07) | (((srel >> 1) << 3) & 0x3f8);
 848       bfd_put_16 (input_bfd, x, contents);
 849       break;
 850
 851     case R_AVR_13_PCREL:
 852       contents   += rel->r_offset;
 853       srel = (bfd_signed_vma) relocation;
 854       srel += rel->r_addend;
 855       srel -= rel->r_offset;
 856       srel -= 2;        /* Branch instructions add 2 to the PC...  */
 857       srel -= (input_section->output_section->vma +
 858                input_section->output_offset);
 859
 860       if (srel & 1)
 861         return bfd_reloc_outofrange;
 862
 863       srel = avr_relative_distance_considering_wrap_around (srel);
 864
 865       /* AVR addresses commands as words.  */
 866       srel >>= 1;
 867
 868       /* Check for overflow.  */
 869       if (srel < -2048 || srel > 2047)
 870         {
 871           /* Relative distance is too large.  */
 872
 873           /* Always apply WRAPAROUND for avr2, avr25, and avr4.  */
 874           switch (bfd_get_mach (input_bfd))
 875             {
 876             case bfd_mach_avr2:
 877             case bfd_mach_avr25:
 878             case bfd_mach_avr4:
 879               break;
 880
 881             default:
 882               return bfd_reloc_overflow;
 883             }
 884         }
 885
 886       x = bfd_get_16 (input_bfd, contents);
 887       x = (x & 0xf000) | (srel & 0xfff);
 888       bfd_put_16 (input_bfd, x, contents);
 889       break;
 890
 891     case R_AVR_LO8_LDI:
 892       contents += rel->r_offset;
 893       srel = (bfd_signed_vma) relocation + rel->r_addend;
 894       x = bfd_get_16 (input_bfd, contents);
 895       x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
 896       bfd_put_16 (input_bfd, x, contents);
 897       break;
 898
 899     case R_AVR_LDI:
 900       contents += rel->r_offset;
 901       srel = (bfd_signed_vma) relocation + rel->r_addend;
 902       if (((srel > 0) && (srel & 0xffff) > 255)
 903           || ((srel < 0) && ((-srel) & 0xffff) > 128))
 904         /* Remove offset for data/eeprom section.  */
 905         return bfd_reloc_overflow;
 906
 907       x = bfd_get_16 (input_bfd, contents);
 908       x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
 909       bfd_put_16 (input_bfd, x, contents);
 910       break;
 911
 912     case R_AVR_6:
 913       contents += rel->r_offset;
 914       srel = (bfd_signed_vma) relocation + rel->r_addend;
 915       if (((srel & 0xffff) > 63) || (srel < 0))
 916         /* Remove offset for data/eeprom section.  */
 917         return bfd_reloc_overflow;
 918       x = bfd_get_16 (input_bfd, contents);
 919       x = (x & 0xd3f8) | ((srel & 7) | ((srel & (3 << 3)) << 7)
 920                        | ((srel & (1 << 5)) << 8));
 921       bfd_put_16 (input_bfd, x, contents);
 922       break;
 923
 924     case R_AVR_6_ADIW:
 925       contents += rel->r_offset;
 926       srel = (bfd_signed_vma) relocation + rel->r_addend;
 927       if (((srel & 0xffff) > 63) || (srel < 0))
 928         /* Remove offset for data/eeprom section.  */
 929         return bfd_reloc_overflow;
 930       x = bfd_get_16 (input_bfd, contents);
 931       x = (x & 0xff30) | (srel & 0xf) | ((srel & 0x30) << 2);
 932       bfd_put_16 (input_bfd, x, contents);
 933       break;
 934
 935     case R_AVR_HI8_LDI:
 936       contents += rel->r_offset;
 937       srel = (bfd_signed_vma) relocation + rel->r_addend;
 938       srel = (srel >> 8) & 0xff;
 939       x = bfd_get_16 (input_bfd, contents);
 940       x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
 941       bfd_put_16 (input_bfd, x, contents);
 942       break;
 943
 944     case R_AVR_HH8_LDI:
 945       contents += rel->r_offset;
 946       srel = (bfd_signed_vma) relocation + rel->r_addend;
 947       srel = (srel >> 16) & 0xff;
 948       x = bfd_get_16 (input_bfd, contents);
 949       x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
 950       bfd_put_16 (input_bfd, x, contents);
 951       break;
 952
 953     case R_AVR_MS8_LDI:
 954       contents += rel->r_offset;
 955       srel = (bfd_signed_vma) relocation + rel->r_addend;
 956       srel = (srel >> 24) & 0xff;
 957       x = bfd_get_16 (input_bfd, contents);
 958       x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
 959       bfd_put_16 (input_bfd, x, contents);
 960       break;
 961
 962     case R_AVR_LO8_LDI_NEG:
 963       contents += rel->r_offset;
 964       srel = (bfd_signed_vma) relocation + rel->r_addend;
 965       srel = -srel;
 966       x = bfd_get_16 (input_bfd, contents);
 967       x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
 968       bfd_put_16 (input_bfd, x, contents);
 969       break;
 970
 971     case R_AVR_HI8_LDI_NEG:
 972       contents += rel->r_offset;
 973       srel = (bfd_signed_vma) relocation + rel->r_addend;
 974       srel = -srel;
 975       srel = (srel >> 8) & 0xff;
 976       x = bfd_get_16 (input_bfd, contents);
 977       x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
 978       bfd_put_16 (input_bfd, x, contents);
 979       break;
 980
 981     case R_AVR_HH8_LDI_NEG:
 982       contents += rel->r_offset;
 983       srel = (bfd_signed_vma) relocation + rel->r_addend;
 984       srel = -srel;
 985       srel = (srel >> 16) & 0xff;
 986       x = bfd_get_16 (input_bfd, contents);
 987       x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
 988       bfd_put_16 (input_bfd, x, contents);
 989       break;
 990
 991     case R_AVR_MS8_LDI_NEG:
 992       contents += rel->r_offset;
 993       srel = (bfd_signed_vma) relocation + rel->r_addend;
 994       srel = -srel;
 995       srel = (srel >> 24) & 0xff;
 996       x = bfd_get_16 (input_bfd, contents);
 997       x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
 998       bfd_put_16 (input_bfd, x, contents);
 999       break;
1000
1001     case R_AVR_LO8_LDI_GS:
1002       use_stubs = (!htab->no_stubs);
1003       /* Fall through.  */
1004     case R_AVR_LO8_LDI_PM:
1005       contents += rel->r_offset;
1006       srel = (bfd_signed_vma) relocation + rel->r_addend;
1007
1008       if (use_stubs
1009           && avr_stub_is_required_for_16_bit_reloc (srel - base_addr))
1010         {
1011           bfd_vma old_srel = srel;
1012
1013           /* We need to use the address of the stub instead.  */
1014           srel = avr_get_stub_addr (srel, htab);
1015           if (debug_stubs)
1016             printf ("LD: Using jump stub (at 0x%x) with destination 0x%x for "
1017                     "reloc at address 0x%x.\n",
1018                     (unsigned int) srel,
1019                     (unsigned int) old_srel,
1020                     (unsigned int) reloc_addr);
1021
1022           if (avr_stub_is_required_for_16_bit_reloc (srel - base_addr))
1023             return bfd_reloc_outofrange;
1024         }
1025
1026       if (srel & 1)
1027         return bfd_reloc_outofrange;
1028       srel = srel >> 1;
1029       x = bfd_get_16 (input_bfd, contents);
1030       x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
1031       bfd_put_16 (input_bfd, x, contents);
1032       break;
1033
1034     case R_AVR_HI8_LDI_GS:
1035       use_stubs = (!htab->no_stubs);
1036       /* Fall through.  */
1037     case R_AVR_HI8_LDI_PM:
1038       contents += rel->r_offset;
1039       srel = (bfd_signed_vma) relocation + rel->r_addend;
1040
1041       if (use_stubs
1042           && avr_stub_is_required_for_16_bit_reloc (srel - base_addr))
1043         {
1044           bfd_vma old_srel = srel;
1045
1046           /* We need to use the address of the stub instead.  */
1047           srel = avr_get_stub_addr (srel, htab);
1048           if (debug_stubs)
1049             printf ("LD: Using jump stub (at 0x%x) with destination 0x%x for "
1050                     "reloc at address 0x%x.\n",
1051                     (unsigned int) srel,
1052                     (unsigned int) old_srel,
1053                     (unsigned int) reloc_addr);
1054
1055           if (avr_stub_is_required_for_16_bit_reloc (srel - base_addr))
1056             return bfd_reloc_outofrange;
1057         }
1058
1059       if (srel & 1)
1060         return bfd_reloc_outofrange;
1061       srel = srel >> 1;
1062       srel = (srel >> 8) & 0xff;
1063       x = bfd_get_16 (input_bfd, contents);
1064       x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
1065       bfd_put_16 (input_bfd, x, contents);
1066       break;
1067
1068     case R_AVR_HH8_LDI_PM:
1069       contents += rel->r_offset;
1070       srel = (bfd_signed_vma) relocation + rel->r_addend;
1071       if (srel & 1)
1072         return bfd_reloc_outofrange;
1073       srel = srel >> 1;
1074       srel = (srel >> 16) & 0xff;
1075       x = bfd_get_16 (input_bfd, contents);
1076       x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
1077       bfd_put_16 (input_bfd, x, contents);
1078       break;
1079
1080     case R_AVR_LO8_LDI_PM_NEG:
1081       contents += rel->r_offset;
1082       srel = (bfd_signed_vma) relocation + rel->r_addend;
1083       srel = -srel;
1084       if (srel & 1)
1085         return bfd_reloc_outofrange;
1086       srel = srel >> 1;
1087       x = bfd_get_16 (input_bfd, contents);
1088       x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
1089       bfd_put_16 (input_bfd, x, contents);
1090       break;
1091
1092     case R_AVR_HI8_LDI_PM_NEG:
1093       contents += rel->r_offset;
1094       srel = (bfd_signed_vma) relocation + rel->r_addend;
1095       srel = -srel;
1096       if (srel & 1)
1097         return bfd_reloc_outofrange;
1098       srel = srel >> 1;
1099       srel = (srel >> 8) & 0xff;
1100       x = bfd_get_16 (input_bfd, contents);
1101       x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
1102       bfd_put_16 (input_bfd, x, contents);
1103       break;
1104
1105     case R_AVR_HH8_LDI_PM_NEG:
1106       contents += rel->r_offset;
1107       srel = (bfd_signed_vma) relocation + rel->r_addend;
1108       srel = -srel;
1109       if (srel & 1)
1110         return bfd_reloc_outofrange;
1111       srel = srel >> 1;
1112       srel = (srel >> 16) & 0xff;
1113       x = bfd_get_16 (input_bfd, contents);
1114       x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
1115       bfd_put_16 (input_bfd, x, contents);
1116       break;
1117
1118     case R_AVR_CALL:
1119       contents += rel->r_offset;
1120       srel = (bfd_signed_vma) relocation + rel->r_addend;
1121       if (srel & 1)
1122         return bfd_reloc_outofrange;
1123       srel = srel >> 1;
1124       x = bfd_get_16 (input_bfd, contents);
1125       x |= ((srel & 0x10000) | ((srel << 3) & 0x1f00000)) >> 16;
1126       bfd_put_16 (input_bfd, x, contents);
1127       bfd_put_16 (input_bfd, (bfd_vma) srel & 0xffff, contents+2);
1128       break;
1129
1130     case R_AVR_16_PM:
1131       use_stubs = (!htab->no_stubs);
1132       contents += rel->r_offset;
1133       srel = (bfd_signed_vma) relocation + rel->r_addend;
1134
1135       if (use_stubs
1136           && avr_stub_is_required_for_16_bit_reloc (srel - base_addr))
1137         {
1138           bfd_vma old_srel = srel;
1139
1140           /* We need to use the address of the stub instead.  */
1141           srel = avr_get_stub_addr (srel,htab);
1142           if (debug_stubs)
1143             printf ("LD: Using jump stub (at 0x%x) with destination 0x%x for "
1144                     "reloc at address 0x%x.\n",
1145                     (unsigned int) srel,
1146                     (unsigned int) old_srel,
1147                     (unsigned int) reloc_addr);
1148
1149           if (avr_stub_is_required_for_16_bit_reloc (srel - base_addr))
1150             return bfd_reloc_outofrange;
1151         }
1152
1153       if (srel & 1)
1154         return bfd_reloc_outofrange;
1155       srel = srel >> 1;
1156       bfd_put_16 (input_bfd, (bfd_vma) srel &0x00ffff, contents);
1157       break;
1158
1159     default:
1160       r = _bfd_final_link_relocate (howto, input_bfd, input_section,
1161                                     contents, rel->r_offset,
1162                                     relocation, rel->r_addend);
1163     }
1164
1165   return r;
1166 }
1167
1168 /* Relocate an AVR ELF section.  */
1169
1170 static bfd_boolean
1171 elf32_avr_relocate_section (bfd *output_bfd ATTRIBUTE_UNUSED,
1172                             struct bfd_link_info *info,
1173                             bfd *input_bfd,
1174                             asection *input_section,
1175                             bfd_byte *contents,
1176                             Elf_Internal_Rela *relocs,
1177                             Elf_Internal_Sym *local_syms,
1178                             asection **local_sections)
1179 {
1180   Elf_Internal_Shdr *           symtab_hdr;
1181   struct elf_link_hash_entry ** sym_hashes;
1182   Elf_Internal_Rela *           rel;
1183   Elf_Internal_Rela *           relend;
1184   struct elf32_avr_link_hash_table * htab = avr_link_hash_table (info);
1185
1186   if (htab == NULL)
1187     return FALSE;
1188
1189   symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
1190   sym_hashes = elf_sym_hashes (input_bfd);
1191   relend     = relocs + input_section->reloc_count;
1192
1193   for (rel = relocs; rel < relend; rel ++)
1194     {
1195       reloc_howto_type *           howto;
1196       unsigned long                r_symndx;
1197       Elf_Internal_Sym *           sym;
1198       asection *                   sec;
1199       struct elf_link_hash_entry * h;
1200       bfd_vma                      relocation;
1201       bfd_reloc_status_type        r;
1202       const char *                 name;
1203       int                          r_type;
1204
1205       r_type = ELF32_R_TYPE (rel->r_info);
1206       r_symndx = ELF32_R_SYM (rel->r_info);
1207       howto  = elf_avr_howto_table + r_type;
1208       h      = NULL;
1209       sym    = NULL;
1210       sec    = NULL;
1211
1212       if (r_symndx < symtab_hdr->sh_info)
1213         {
1214           sym = local_syms + r_symndx;
1215           sec = local_sections [r_symndx];
1216           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
1217
1218           name = bfd_elf_string_from_elf_section
1219             (input_bfd, symtab_hdr->sh_link, sym->st_name);
1220           name = (name == NULL) ? bfd_section_name (input_bfd, sec) : name;
1221         }
1222       else
1223         {
1224           bfd_boolean unresolved_reloc, warned;
1225
1226           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
1227                                    r_symndx, symtab_hdr, sym_hashes,
1228                                    h, sec, relocation,
1229                                    unresolved_reloc, warned);
1230
1231           name = h->root.root.string;
1232         }
1233
1234       if (sec != NULL && elf_discarded_section (sec))
1235         {
1236           /* For relocs against symbols from removed linkonce sections,
1237              or sections discarded by a linker script, we just want the
1238              section contents zeroed.  Avoid any special processing.  */
1239           _bfd_clear_contents (howto, input_bfd, contents + rel->r_offset);
1240           rel->r_info = 0;
1241           rel->r_addend = 0;
1242           continue;
1243         }
1244
1245       if (info->relocatable)
1246         continue;
1247
1248       r = avr_final_link_relocate (howto, input_bfd, input_section,
1249                                    contents, rel, relocation, htab);
1250
1251       if (r != bfd_reloc_ok)
1252         {
1253           const char * msg = (const char *) NULL;
1254
1255           switch (r)
1256             {
1257             case bfd_reloc_overflow:
1258               r = info->callbacks->reloc_overflow
1259                 (info, (h ? &h->root : NULL),
1260                  name, howto->name, (bfd_vma) 0,
1261                  input_bfd, input_section, rel->r_offset);
1262               break;
1263
1264             case bfd_reloc_undefined:
1265               r = info->callbacks->undefined_symbol
1266                 (info, name, input_bfd, input_section, rel->r_offset, TRUE);
1267               break;
1268
1269             case bfd_reloc_outofrange:
1270               msg = _("internal error: out of range error");
1271               break;
1272
1273             case bfd_reloc_notsupported:
1274               msg = _("internal error: unsupported relocation error");
1275               break;
1276
1277             case bfd_reloc_dangerous:
1278               msg = _("internal error: dangerous relocation");
1279               break;
1280
1281             default:
1282               msg = _("internal error: unknown error");
1283               break;
1284             }
1285
1286           if (msg)
1287             r = info->callbacks->warning
1288               (info, msg, name, input_bfd, input_section, rel->r_offset);
1289
1290           if (! r)
1291             return FALSE;
1292         }
1293     }
1294
1295   return TRUE;
1296 }
1297
1298 /* The final processing done just before writing out a AVR ELF object
1299    file.  This gets the AVR architecture right based on the machine
1300    number.  */
1301
1302 static void
1303 bfd_elf_avr_final_write_processing (bfd *abfd,
1304                                     bfd_boolean linker ATTRIBUTE_UNUSED)
1305 {
1306   unsigned long val;
1307
1308   switch (bfd_get_mach (abfd))
1309     {
1310     default:
1311     case bfd_mach_avr2:
1312       val = E_AVR_MACH_AVR2;
1313       break;
1314
1315     case bfd_mach_avr1:
1316       val = E_AVR_MACH_AVR1;
1317       break;
1318
1319     case bfd_mach_avr25:
1320       val = E_AVR_MACH_AVR25;
1321       break;
1322
1323     case bfd_mach_avr3:
1324       val = E_AVR_MACH_AVR3;
1325       break;
1326
1327     case bfd_mach_avr31:
1328       val = E_AVR_MACH_AVR31;
1329       break;
1330
1331     case bfd_mach_avr35:
1332       val = E_AVR_MACH_AVR35;
1333       break;
1334
1335     case bfd_mach_avr4:
1336       val = E_AVR_MACH_AVR4;
1337       break;
1338
1339     case bfd_mach_avr5:
1340       val = E_AVR_MACH_AVR5;
1341       break;
1342
1343     case bfd_mach_avr51:
1344       val = E_AVR_MACH_AVR51;
1345       break;
1346
1347     case bfd_mach_avr6:
1348       val = E_AVR_MACH_AVR6;
1349       break;
1350     }
1351
1352   elf_elfheader (abfd)->e_machine = EM_AVR;
1353   elf_elfheader (abfd)->e_flags &= ~ EF_AVR_MACH;
1354   elf_elfheader (abfd)->e_flags |= val;
1355   elf_elfheader (abfd)->e_flags |= EF_AVR_LINKRELAX_PREPARED;
1356 }
1357
1358 /* Set the right machine number.  */
1359
1360 static bfd_boolean
1361 elf32_avr_object_p (bfd *abfd)
1362 {
1363   unsigned int e_set = bfd_mach_avr2;
1364
1365   if (elf_elfheader (abfd)->e_machine == EM_AVR
1366       || elf_elfheader (abfd)->e_machine == EM_AVR_OLD)
1367     {
1368       int e_mach = elf_elfheader (abfd)->e_flags & EF_AVR_MACH;
1369
1370       switch (e_mach)
1371         {
1372         default:
1373         case E_AVR_MACH_AVR2:
1374           e_set = bfd_mach_avr2;
1375           break;
1376
1377         case E_AVR_MACH_AVR1:
1378           e_set = bfd_mach_avr1;
1379           break;
1380
1381         case E_AVR_MACH_AVR25:
1382           e_set = bfd_mach_avr25;
1383           break;
1384
1385         case E_AVR_MACH_AVR3:
1386           e_set = bfd_mach_avr3;
1387           break;
1388
1389         case E_AVR_MACH_AVR31:
1390           e_set = bfd_mach_avr31;
1391           break;
1392
1393         case E_AVR_MACH_AVR35:
1394           e_set = bfd_mach_avr35;
1395           break;
1396
1397         case E_AVR_MACH_AVR4:
1398           e_set = bfd_mach_avr4;
1399           break;
1400
1401         case E_AVR_MACH_AVR5:
1402           e_set = bfd_mach_avr5;
1403           break;
1404
1405         case E_AVR_MACH_AVR51:
1406           e_set = bfd_mach_avr51;
1407           break;
1408
1409         case E_AVR_MACH_AVR6:
1410           e_set = bfd_mach_avr6;
1411           break;
1412         }
1413     }
1414   return bfd_default_set_arch_mach (abfd, bfd_arch_avr,
1415                                     e_set);
1416 }
1417
1418
1419 /* Delete some bytes from a section while changing the size of an instruction.
1420    The parameter "addr" denotes the section-relative offset pointing just
1421    behind the shrinked instruction. "addr+count" point at the first
1422    byte just behind the original unshrinked instruction.  */
1423
1424 static bfd_boolean
1425 elf32_avr_relax_delete_bytes (bfd *abfd,
1426                               asection *sec,
1427                               bfd_vma addr,
1428                               int count)
1429 {
1430   Elf_Internal_Shdr *symtab_hdr;
1431   unsigned int sec_shndx;
1432   bfd_byte *contents;
1433   Elf_Internal_Rela *irel, *irelend;
1434   Elf_Internal_Sym *isym;
1435   Elf_Internal_Sym *isymbuf = NULL;
1436   bfd_vma toaddr;
1437   struct elf_link_hash_entry **sym_hashes;
1438   struct elf_link_hash_entry **end_hashes;
1439   unsigned int symcount;
1440
1441   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1442   sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
1443   contents = elf_section_data (sec)->this_hdr.contents;
1444
1445   toaddr = sec->size;
1446
1447   irel = elf_section_data (sec)->relocs;
1448   irelend = irel + sec->reloc_count;
1449
1450   /* Actually delete the bytes.  */
1451   if (toaddr - addr - count > 0)
1452     memmove (contents + addr, contents + addr + count,
1453              (size_t) (toaddr - addr - count));
1454   sec->size -= count;
1455
1456   /* Adjust all the reloc addresses.  */
1457   for (irel = elf_section_data (sec)->relocs; irel < irelend; irel++)
1458     {
1459       bfd_vma old_reloc_address;
1460
1461       old_reloc_address = (sec->output_section->vma
1462                            + sec->output_offset + irel->r_offset);
1463
1464       /* Get the new reloc address.  */
1465       if ((irel->r_offset > addr
1466            && irel->r_offset < toaddr))
1467         {
1468           if (debug_relax)
1469             printf ("Relocation at address 0x%x needs to be moved.\n"
1470                     "Old section offset: 0x%x, New section offset: 0x%x \n",
1471                     (unsigned int) old_reloc_address,
1472                     (unsigned int) irel->r_offset,
1473                     (unsigned int) ((irel->r_offset) - count));
1474
1475           irel->r_offset -= count;
1476         }
1477
1478     }
1479
1480    /* The reloc's own addresses are now ok. However, we need to readjust
1481       the reloc's addend, i.e. the reloc's value if two conditions are met:
1482       1.) the reloc is relative to a symbol in this section that
1483           is located in front of the shrinked instruction
1484       2.) symbol plus addend end up behind the shrinked instruction.
1485
1486       The most common case where this happens are relocs relative to
1487       the section-start symbol.
1488
1489       This step needs to be done for all of the sections of the bfd.  */
1490
1491   {
1492     struct bfd_section *isec;
1493
1494     for (isec = abfd->sections; isec; isec = isec->next)
1495      {
1496        bfd_vma symval;
1497        bfd_vma shrinked_insn_address;
1498
1499        shrinked_insn_address = (sec->output_section->vma
1500                                 + sec->output_offset + addr - count);
1501
1502        irelend = elf_section_data (isec)->relocs + isec->reloc_count;
1503        for (irel = elf_section_data (isec)->relocs;
1504             irel < irelend;
1505             irel++)
1506          {
1507            /* Read this BFD's local symbols if we haven't done
1508               so already.  */
1509            if (isymbuf == NULL && symtab_hdr->sh_info != 0)
1510              {
1511                isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
1512                if (isymbuf == NULL)
1513                  isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
1514                                                  symtab_hdr->sh_info, 0,
1515                                                  NULL, NULL, NULL);
1516                if (isymbuf == NULL)
1517                  return FALSE;
1518              }
1519
1520            /* Get the value of the symbol referred to by the reloc.  */
1521            if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
1522              {
1523                /* A local symbol.  */
1524                asection *sym_sec;
1525
1526                isym = isymbuf + ELF32_R_SYM (irel->r_info);
1527                sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
1528                symval = isym->st_value;
1529                /* If the reloc is absolute, it will not have
1530                   a symbol or section associated with it.  */
1531                if (sym_sec == sec)
1532                  {
1533                    symval += sym_sec->output_section->vma
1534                              + sym_sec->output_offset;
1535
1536                    if (debug_relax)
1537                      printf ("Checking if the relocation's "
1538                              "addend needs corrections.\n"
1539                              "Address of anchor symbol: 0x%x \n"
1540                              "Address of relocation target: 0x%x \n"
1541                              "Address of relaxed insn: 0x%x \n",
1542                              (unsigned int) symval,
1543                              (unsigned int) (symval + irel->r_addend),
1544                              (unsigned int) shrinked_insn_address);
1545
1546                    if (symval <= shrinked_insn_address
1547                        && (symval + irel->r_addend) > shrinked_insn_address)
1548                      {
1549                        irel->r_addend -= count;
1550
1551                        if (debug_relax)
1552                          printf ("Relocation's addend needed to be fixed \n");
1553                      }
1554                  }
1555                /* else...Reference symbol is absolute.  No adjustment needed.  */
1556              }
1557            /* else...Reference symbol is extern.  No need for adjusting
1558               the addend.  */
1559          }
1560      }
1561   }
1562
1563   /* Adjust the local symbols defined in this section.  */
1564   isym = (Elf_Internal_Sym *) symtab_hdr->contents;
1565   /* Fix PR 9841, there may be no local symbols.  */
1566   if (isym != NULL)
1567     {
1568       Elf_Internal_Sym *isymend;
1569
1570       isymend = isym + symtab_hdr->sh_info;
1571       for (; isym < isymend; isym++)
1572         {
1573           if (isym->st_shndx == sec_shndx
1574               && isym->st_value > addr
1575               && isym->st_value < toaddr)
1576             isym->st_value -= count;
1577         }
1578     }
1579
1580   /* Now adjust the global symbols defined in this section.  */
1581   symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
1582               - symtab_hdr->sh_info);
1583   sym_hashes = elf_sym_hashes (abfd);
1584   end_hashes = sym_hashes + symcount;
1585   for (; sym_hashes < end_hashes; sym_hashes++)
1586     {
1587       struct elf_link_hash_entry *sym_hash = *sym_hashes;
1588       if ((sym_hash->root.type == bfd_link_hash_defined
1589            || sym_hash->root.type == bfd_link_hash_defweak)
1590           && sym_hash->root.u.def.section == sec
1591           && sym_hash->root.u.def.value > addr
1592           && sym_hash->root.u.def.value < toaddr)
1593         {
1594           sym_hash->root.u.def.value -= count;
1595         }
1596     }
1597
1598   return TRUE;
1599 }
1600
1601 /* This function handles relaxing for the avr.
1602    Many important relaxing opportunities within functions are already
1603    realized by the compiler itself.
1604    Here we try to replace  call (4 bytes) ->  rcall (2 bytes)
1605    and jump -> rjmp (safes also 2 bytes).
1606    As well we now optimize seqences of
1607      - call/rcall function
1608      - ret
1609    to yield
1610      - jmp/rjmp function
1611      - ret
1612    . In case that within a sequence
1613      - jmp/rjmp label
1614      - ret
1615    the ret could no longer be reached it is optimized away. In order
1616    to check if the ret is no longer needed, it is checked that the ret's address
1617    is not the target of a branch or jump within the same section, it is checked
1618    that there is no skip instruction before the jmp/rjmp and that there
1619    is no local or global label place at the address of the ret.
1620
1621    We refrain from relaxing within sections ".vectors" and
1622    ".jumptables" in order to maintain the position of the instructions.
1623    There, however, we substitute jmp/call by a sequence rjmp,nop/rcall,nop
1624    if possible. (In future one could possibly use the space of the nop
1625    for the first instruction of the irq service function.
1626
1627    The .jumptables sections is meant to be used for a future tablejump variant
1628    for the devices with 3-byte program counter where the table itself
1629    contains 4-byte jump instructions whose relative offset must not
1630    be changed.  */
1631
1632 static bfd_boolean
1633 elf32_avr_relax_section (bfd *abfd,
1634                          asection *sec,
1635                          struct bfd_link_info *link_info,
1636                          bfd_boolean *again)
1637 {
1638   Elf_Internal_Shdr *symtab_hdr;
1639   Elf_Internal_Rela *internal_relocs;
1640   Elf_Internal_Rela *irel, *irelend;
1641   bfd_byte *contents = NULL;
1642   Elf_Internal_Sym *isymbuf = NULL;
1643   struct elf32_avr_link_hash_table *htab;
1644
1645   if (link_info->relocatable)
1646     (*link_info->callbacks->einfo)
1647       (_("%P%F: --relax and -r may not be used together\n"));
1648
1649   htab = avr_link_hash_table (link_info);
1650   if (htab == NULL)
1651     return FALSE;
1652
1653   /* Assume nothing changes.  */
1654   *again = FALSE;
1655
1656   if ((!htab->no_stubs) && (sec == htab->stub_sec))
1657     {
1658       /* We are just relaxing the stub section.
1659          Let's calculate the size needed again.  */
1660       bfd_size_type last_estimated_stub_section_size = htab->stub_sec->size;
1661
1662       if (debug_relax)
1663         printf ("Relaxing the stub section. Size prior to this pass: %i\n",
1664                 (int) last_estimated_stub_section_size);
1665
1666       elf32_avr_size_stubs (htab->stub_sec->output_section->owner,
1667                             link_info, FALSE);
1668
1669       /* Check if the number of trampolines changed.  */
1670       if (last_estimated_stub_section_size != htab->stub_sec->size)
1671         *again = TRUE;
1672
1673       if (debug_relax)
1674         printf ("Size of stub section after this pass: %i\n",
1675                 (int) htab->stub_sec->size);
1676
1677       return TRUE;
1678     }
1679
1680   /* We don't have to do anything for a relocatable link, if
1681      this section does not have relocs, or if this is not a
1682      code section.  */
1683   if (link_info->relocatable
1684       || (sec->flags & SEC_RELOC) == 0
1685       || sec->reloc_count == 0
1686       || (sec->flags & SEC_CODE) == 0)
1687     return TRUE;
1688
1689   /* Check if the object file to relax uses internal symbols so that we
1690      could fix up the relocations.  */
1691   if (!(elf_elfheader (abfd)->e_flags & EF_AVR_LINKRELAX_PREPARED))
1692     return TRUE;
1693
1694   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1695
1696   /* Get a copy of the native relocations.  */
1697   internal_relocs = (_bfd_elf_link_read_relocs
1698                      (abfd, sec, NULL, NULL, link_info->keep_memory));
1699   if (internal_relocs == NULL)
1700     goto error_return;
1701
1702   /* Walk through the relocs looking for relaxing opportunities.  */
1703   irelend = internal_relocs + sec->reloc_count;
1704   for (irel = internal_relocs; irel < irelend; irel++)
1705     {
1706       bfd_vma symval;
1707
1708       if (   ELF32_R_TYPE (irel->r_info) != R_AVR_13_PCREL
1709              && ELF32_R_TYPE (irel->r_info) != R_AVR_7_PCREL
1710              && ELF32_R_TYPE (irel->r_info) != R_AVR_CALL)
1711         continue;
1712
1713       /* Get the section contents if we haven't done so already.  */
1714       if (contents == NULL)
1715         {
1716           /* Get cached copy if it exists.  */
1717           if (elf_section_data (sec)->this_hdr.contents != NULL)
1718             contents = elf_section_data (sec)->this_hdr.contents;
1719           else
1720             {
1721               /* Go get them off disk.  */
1722               if (! bfd_malloc_and_get_section (abfd, sec, &contents))
1723                 goto error_return;
1724             }
1725         }
1726
1727       /* Read this BFD's local symbols if we haven't done so already.  */
1728       if (isymbuf == NULL && symtab_hdr->sh_info != 0)
1729         {
1730           isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
1731           if (isymbuf == NULL)
1732             isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
1733                                             symtab_hdr->sh_info, 0,
1734                                             NULL, NULL, NULL);
1735           if (isymbuf == NULL)
1736             goto error_return;
1737         }
1738
1739
1740       /* Get the value of the symbol referred to by the reloc.  */
1741       if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
1742         {
1743           /* A local symbol.  */
1744           Elf_Internal_Sym *isym;
1745           asection *sym_sec;
1746
1747           isym = isymbuf + ELF32_R_SYM (irel->r_info);
1748           sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
1749           symval = isym->st_value;
1750           /* If the reloc is absolute, it will not have
1751              a symbol or section associated with it.  */
1752           if (sym_sec)
1753             symval += sym_sec->output_section->vma
1754               + sym_sec->output_offset;
1755         }
1756       else
1757         {
1758           unsigned long indx;
1759           struct elf_link_hash_entry *h;
1760
1761           /* An external symbol.  */
1762           indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
1763           h = elf_sym_hashes (abfd)[indx];
1764           BFD_ASSERT (h != NULL);
1765           if (h->root.type != bfd_link_hash_defined
1766               && h->root.type != bfd_link_hash_defweak)
1767             /* This appears to be a reference to an undefined
1768                symbol.  Just ignore it--it will be caught by the
1769                regular reloc processing.  */
1770             continue;
1771
1772           symval = (h->root.u.def.value
1773                     + h->root.u.def.section->output_section->vma
1774                     + h->root.u.def.section->output_offset);
1775         }
1776
1777       /* For simplicity of coding, we are going to modify the section
1778          contents, the section relocs, and the BFD symbol table.  We
1779          must tell the rest of the code not to free up this
1780          information.  It would be possible to instead create a table
1781          of changes which have to be made, as is done in coff-mips.c;
1782          that would be more work, but would require less memory when
1783          the linker is run.  */
1784       switch (ELF32_R_TYPE (irel->r_info))
1785         {
1786           /* Try to turn a 22-bit absolute call/jump into an 13-bit
1787              pc-relative rcall/rjmp.  */
1788         case R_AVR_CALL:
1789           {
1790             bfd_vma value = symval + irel->r_addend;
1791             bfd_vma dot, gap;
1792             int distance_short_enough = 0;
1793
1794             /* Get the address of this instruction.  */
1795             dot = (sec->output_section->vma
1796                    + sec->output_offset + irel->r_offset);
1797
1798             /* Compute the distance from this insn to the branch target.  */
1799             gap = value - dot;
1800
1801             /* If the distance is within -4094..+4098 inclusive, then we can
1802                relax this jump/call.  +4098 because the call/jump target
1803                will be closer after the relaxation.  */
1804             if ((int) gap >= -4094 && (int) gap <= 4098)
1805               distance_short_enough = 1;
1806
1807             /* Here we handle the wrap-around case.  E.g. for a 16k device
1808                we could use a rjmp to jump from address 0x100 to 0x3d00!
1809                In order to make this work properly, we need to fill the
1810                vaiable avr_pc_wrap_around with the appropriate value.
1811                I.e. 0x4000 for a 16k device.  */
1812             {
1813               /* Shrinking the code size makes the gaps larger in the
1814                  case of wrap-arounds.  So we use a heuristical safety
1815                  margin to avoid that during relax the distance gets
1816                  again too large for the short jumps.  Let's assume
1817                  a typical code-size reduction due to relax for a
1818                  16k device of 600 bytes.  So let's use twice the
1819                  typical value as safety margin.  */
1820               int rgap;
1821               int safety_margin;
1822
1823               int assumed_shrink = 600;
1824               if (avr_pc_wrap_around > 0x4000)
1825                 assumed_shrink = 900;
1826
1827               safety_margin = 2 * assumed_shrink;
1828
1829               rgap = avr_relative_distance_considering_wrap_around (gap);
1830
1831               if (rgap >= (-4092 + safety_margin)
1832                   && rgap <= (4094 - safety_margin))
1833                 distance_short_enough = 1;
1834             }
1835
1836             if (distance_short_enough)
1837               {
1838                 unsigned char code_msb;
1839                 unsigned char code_lsb;
1840
1841                 if (debug_relax)
1842                   printf ("shrinking jump/call instruction at address 0x%x"
1843                           " in section %s\n\n",
1844                           (int) dot, sec->name);
1845
1846                 /* Note that we've changed the relocs, section contents,
1847                    etc.  */
1848                 elf_section_data (sec)->relocs = internal_relocs;
1849                 elf_section_data (sec)->this_hdr.contents = contents;
1850                 symtab_hdr->contents = (unsigned char *) isymbuf;
1851
1852                 /* Get the instruction code for relaxing.  */
1853                 code_lsb = bfd_get_8 (abfd, contents + irel->r_offset);
1854                 code_msb = bfd_get_8 (abfd, contents + irel->r_offset + 1);
1855
1856                 /* Mask out the relocation bits.  */
1857                 code_msb &= 0x94;
1858                 code_lsb &= 0x0E;
1859                 if (code_msb == 0x94 && code_lsb == 0x0E)
1860                   {
1861                     /* we are changing call -> rcall .  */
1862                     bfd_put_8 (abfd, 0x00, contents + irel->r_offset);
1863                     bfd_put_8 (abfd, 0xD0, contents + irel->r_offset + 1);
1864                   }
1865                 else if (code_msb == 0x94 && code_lsb == 0x0C)
1866                   {
1867                     /* we are changeing jump -> rjmp.  */
1868                     bfd_put_8 (abfd, 0x00, contents + irel->r_offset);
1869                     bfd_put_8 (abfd, 0xC0, contents + irel->r_offset + 1);
1870                   }
1871                 else
1872                   abort ();
1873
1874                 /* Fix the relocation's type.  */
1875                 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1876                                              R_AVR_13_PCREL);
1877
1878                 /* Check for the vector section. There we don't want to
1879                    modify the ordering!  */
1880
1881                 if (!strcmp (sec->name,".vectors")
1882                     || !strcmp (sec->name,".jumptables"))
1883                   {
1884                     /* Let's insert a nop.  */
1885                     bfd_put_8 (abfd, 0x00, contents + irel->r_offset + 2);
1886                     bfd_put_8 (abfd, 0x00, contents + irel->r_offset + 3);
1887                   }
1888                 else
1889                   {
1890                     /* Delete two bytes of data.  */
1891                     if (!elf32_avr_relax_delete_bytes (abfd, sec,
1892                                                        irel->r_offset + 2, 2))
1893                       goto error_return;
1894
1895                     /* That will change things, so, we should relax again.
1896                        Note that this is not required, and it may be slow.  */
1897                     *again = TRUE;
1898                   }
1899               }
1900           }
1901
1902         default:
1903           {
1904             unsigned char code_msb;
1905             unsigned char code_lsb;
1906             bfd_vma dot;
1907
1908             code_msb = bfd_get_8 (abfd, contents + irel->r_offset + 1);
1909             code_lsb = bfd_get_8 (abfd, contents + irel->r_offset + 0);
1910
1911             /* Get the address of this instruction.  */
1912             dot = (sec->output_section->vma
1913                    + sec->output_offset + irel->r_offset);
1914
1915             /* Here we look for rcall/ret or call/ret sequences that could be
1916                safely replaced by rjmp/ret or jmp/ret.  */
1917             if (((code_msb & 0xf0) == 0xd0)
1918                 && avr_replace_call_ret_sequences)
1919               {
1920                 /* This insn is a rcall.  */
1921                 unsigned char next_insn_msb = 0;
1922                 unsigned char next_insn_lsb = 0;
1923
1924                 if (irel->r_offset + 3 < sec->size)
1925                   {
1926                     next_insn_msb =
1927                       bfd_get_8 (abfd, contents + irel->r_offset + 3);
1928                     next_insn_lsb =
1929                       bfd_get_8 (abfd, contents + irel->r_offset + 2);
1930                   }
1931
1932                 if ((0x95 == next_insn_msb) && (0x08 == next_insn_lsb))
1933                   {
1934                     /* The next insn is a ret. We now convert the rcall insn
1935                        into a rjmp instruction.  */
1936                     code_msb &= 0xef;
1937                     bfd_put_8 (abfd, code_msb, contents + irel->r_offset + 1);
1938                     if (debug_relax)
1939                       printf ("converted rcall/ret sequence at address 0x%x"
1940                               " into rjmp/ret sequence. Section is %s\n\n",
1941                               (int) dot, sec->name);
1942                     *again = TRUE;
1943                     break;
1944                   }
1945               }
1946             else if ((0x94 == (code_msb & 0xfe))
1947                      && (0x0e == (code_lsb & 0x0e))
1948                      && avr_replace_call_ret_sequences)
1949               {
1950                 /* This insn is a call.  */
1951                 unsigned char next_insn_msb = 0;
1952                 unsigned char next_insn_lsb = 0;
1953
1954                 if (irel->r_offset + 5 < sec->size)
1955                   {
1956                     next_insn_msb =
1957                       bfd_get_8 (abfd, contents + irel->r_offset + 5);
1958                     next_insn_lsb =
1959                       bfd_get_8 (abfd, contents + irel->r_offset + 4);
1960                   }
1961
1962                 if ((0x95 == next_insn_msb) && (0x08 == next_insn_lsb))
1963                   {
1964                     /* The next insn is a ret. We now convert the call insn
1965                        into a jmp instruction.  */
1966
1967                     code_lsb &= 0xfd;
1968                     bfd_put_8 (abfd, code_lsb, contents + irel->r_offset);
1969                     if (debug_relax)
1970                       printf ("converted call/ret sequence at address 0x%x"
1971                               " into jmp/ret sequence. Section is %s\n\n",
1972                               (int) dot, sec->name);
1973                     *again = TRUE;
1974                     break;
1975                   }
1976               }
1977             else if ((0xc0 == (code_msb & 0xf0))
1978                      || ((0x94 == (code_msb & 0xfe))
1979                          && (0x0c == (code_lsb & 0x0e))))
1980               {
1981                 /* This insn is a rjmp or a jmp.  */
1982                 unsigned char next_insn_msb = 0;
1983                 unsigned char next_insn_lsb = 0;
1984                 int insn_size;
1985
1986                 if (0xc0 == (code_msb & 0xf0))
1987                   insn_size = 2; /* rjmp insn */
1988                 else
1989                   insn_size = 4; /* jmp insn */
1990
1991                 if (irel->r_offset + insn_size + 1 < sec->size)
1992                   {
1993                     next_insn_msb =
1994                       bfd_get_8 (abfd, contents + irel->r_offset
1995                                  + insn_size + 1);
1996                     next_insn_lsb =
1997                       bfd_get_8 (abfd, contents + irel->r_offset
1998                                  + insn_size);
1999                   }
2000
2001                 if ((0x95 == next_insn_msb) && (0x08 == next_insn_lsb))
2002                   {
2003                     /* The next insn is a ret. We possibly could delete
2004                        this ret. First we need to check for preceeding
2005                        sbis/sbic/sbrs or cpse "skip" instructions.  */
2006
2007                     int there_is_preceeding_non_skip_insn = 1;
2008                     bfd_vma address_of_ret;
2009
2010                     address_of_ret = dot + insn_size;
2011
2012                     if (debug_relax && (insn_size == 2))
2013                       printf ("found rjmp / ret sequence at address 0x%x\n",
2014                               (int) dot);
2015                     if (debug_relax && (insn_size == 4))
2016                       printf ("found jmp / ret sequence at address 0x%x\n",
2017                               (int) dot);
2018
2019                     /* We have to make sure that there is a preceeding insn.  */
2020                     if (irel->r_offset >= 2)
2021                       {
2022                         unsigned char preceeding_msb;
2023                         unsigned char preceeding_lsb;
2024                         preceeding_msb =
2025                           bfd_get_8 (abfd, contents + irel->r_offset - 1);
2026                         preceeding_lsb =
2027                           bfd_get_8 (abfd, contents + irel->r_offset - 2);
2028
2029                         /* sbic.  */
2030                         if (0x99 == preceeding_msb)
2031                           there_is_preceeding_non_skip_insn = 0;
2032
2033                         /* sbis.  */
2034                         if (0x9b == preceeding_msb)
2035                           there_is_preceeding_non_skip_insn = 0;
2036
2037                         /* sbrc */
2038                         if ((0xfc == (preceeding_msb & 0xfe)
2039                              && (0x00 == (preceeding_lsb & 0x08))))
2040                           there_is_preceeding_non_skip_insn = 0;
2041
2042                         /* sbrs */
2043                         if ((0xfe == (preceeding_msb & 0xfe)
2044                              && (0x00 == (preceeding_lsb & 0x08))))
2045                           there_is_preceeding_non_skip_insn = 0;
2046
2047                         /* cpse */
2048                         if (0x10 == (preceeding_msb & 0xfc))
2049                           there_is_preceeding_non_skip_insn = 0;
2050
2051                         if (there_is_preceeding_non_skip_insn == 0)
2052                           if (debug_relax)
2053                             printf ("preceeding skip insn prevents deletion of"
2054                                     " ret insn at addr 0x%x in section %s\n",
2055                                     (int) dot + 2, sec->name);
2056                       }
2057                     else
2058                       {
2059                         /* There is no previous instruction.  */
2060                         there_is_preceeding_non_skip_insn = 0;
2061                       }
2062
2063                     if (there_is_preceeding_non_skip_insn)
2064                       {
2065                         /* We now only have to make sure that there is no
2066                            local label defined at the address of the ret
2067                            instruction and that there is no local relocation
2068                            in this section pointing to the ret.  */
2069
2070                         int deleting_ret_is_safe = 1;
2071                         unsigned int section_offset_of_ret_insn =
2072                           irel->r_offset + insn_size;
2073                         Elf_Internal_Sym *isym, *isymend;
2074                         unsigned int sec_shndx;
2075
2076                         sec_shndx =
2077                           _bfd_elf_section_from_bfd_section (abfd, sec);
2078
2079                         /* Check for local symbols.  */
2080                         isym = (Elf_Internal_Sym *) symtab_hdr->contents;
2081                         isymend = isym + symtab_hdr->sh_info;
2082                         /* PR 6019: There may not be any local symbols.  */
2083                         for (; isym != NULL && isym < isymend; isym++)
2084                           {
2085                             if (isym->st_value == section_offset_of_ret_insn
2086                                 && isym->st_shndx == sec_shndx)
2087                               {
2088                                 deleting_ret_is_safe = 0;
2089                                 if (debug_relax)
2090                                   printf ("local label prevents deletion of ret "
2091                                           "insn at address 0x%x\n",
2092                                           (int) dot + insn_size);
2093                               }
2094                           }
2095
2096                         /* Now check for global symbols.  */
2097                         {
2098                           int symcount;
2099                           struct elf_link_hash_entry **sym_hashes;
2100                           struct elf_link_hash_entry **end_hashes;
2101
2102                           symcount = (symtab_hdr->sh_size
2103                                       / sizeof (Elf32_External_Sym)
2104                                       - symtab_hdr->sh_info);
2105                           sym_hashes = elf_sym_hashes (abfd);
2106                           end_hashes = sym_hashes + symcount;
2107                           for (; sym_hashes < end_hashes; sym_hashes++)
2108                             {
2109                               struct elf_link_hash_entry *sym_hash =
2110                                 *sym_hashes;
2111                               if ((sym_hash->root.type == bfd_link_hash_defined
2112                                    || sym_hash->root.type ==
2113                                    bfd_link_hash_defweak)
2114                                   && sym_hash->root.u.def.section == sec
2115                                   && sym_hash->root.u.def.value == section_offset_of_ret_insn)
2116                                 {
2117                                   deleting_ret_is_safe = 0;
2118                                   if (debug_relax)
2119                                     printf ("global label prevents deletion of "
2120                                             "ret insn at address 0x%x\n",
2121                                             (int) dot + insn_size);
2122                                 }
2123                             }
2124                         }
2125                         /* Now we check for relocations pointing to ret.  */
2126                         {
2127                           Elf_Internal_Rela *rel;
2128                           Elf_Internal_Rela *relend;
2129
2130                           relend = elf_section_data (sec)->relocs
2131                             + sec->reloc_count;
2132
2133                           for (rel = elf_section_data (sec)->relocs;
2134                                rel < relend; rel++)
2135                             {
2136                               bfd_vma reloc_target = 0;
2137
2138                               /* Read this BFD's local symbols if we haven't
2139                                  done so already.  */
2140                               if (isymbuf == NULL && symtab_hdr->sh_info != 0)
2141                                 {
2142                                   isymbuf = (Elf_Internal_Sym *)
2143                                     symtab_hdr->contents;
2144                                   if (isymbuf == NULL)
2145                                     isymbuf = bfd_elf_get_elf_syms
2146                                       (abfd,
2147                                        symtab_hdr,
2148                                        symtab_hdr->sh_info, 0,
2149                                        NULL, NULL, NULL);
2150                                   if (isymbuf == NULL)
2151                                     break;
2152                                 }
2153
2154                               /* Get the value of the symbol referred to
2155                                  by the reloc.  */
2156                               if (ELF32_R_SYM (rel->r_info)
2157                                   < symtab_hdr->sh_info)
2158                                 {
2159                                   /* A local symbol.  */
2160                                   asection *sym_sec;
2161
2162                                   isym = isymbuf
2163                                     + ELF32_R_SYM (rel->r_info);
2164                                   sym_sec = bfd_section_from_elf_index
2165                                     (abfd, isym->st_shndx);
2166                                   symval = isym->st_value;
2167
2168                                   /* If the reloc is absolute, it will not
2169                                      have a symbol or section associated
2170                                      with it.  */
2171
2172                                   if (sym_sec)
2173                                     {
2174                                       symval +=
2175                                         sym_sec->output_section->vma
2176                                         + sym_sec->output_offset;
2177                                       reloc_target = symval + rel->r_addend;
2178                                     }
2179                                   else
2180                                     {
2181                                       reloc_target = symval + rel->r_addend;
2182                                       /* Reference symbol is absolute.  */
2183                                     }
2184                                 }
2185                               /* else ... reference symbol is extern.  */
2186
2187                               if (address_of_ret == reloc_target)
2188                                 {
2189                                   deleting_ret_is_safe = 0;
2190                                   if (debug_relax)
2191                                     printf ("ret from "
2192                                             "rjmp/jmp ret sequence at address"
2193                                             " 0x%x could not be deleted. ret"
2194                                             " is target of a relocation.\n",
2195                                             (int) address_of_ret);
2196                                 }
2197                             }
2198                         }
2199
2200                         if (deleting_ret_is_safe)
2201                           {
2202                             if (debug_relax)
2203                               printf ("unreachable ret instruction "
2204                                       "at address 0x%x deleted.\n",
2205                                       (int) dot + insn_size);
2206
2207                             /* Delete two bytes of data.  */
2208                             if (!elf32_avr_relax_delete_bytes (abfd, sec,
2209                                                                irel->r_offset + insn_size, 2))
2210                               goto error_return;
2211
2212                             /* That will change things, so, we should relax
2213                                again. Note that this is not required, and it
2214                                may be slow.  */
2215                             *again = TRUE;
2216                             break;
2217                           }
2218                       }
2219
2220                   }
2221               }
2222             break;
2223           }
2224         }
2225     }
2226
2227   if (contents != NULL
2228       && elf_section_data (sec)->this_hdr.contents != contents)
2229     {
2230       if (! link_info->keep_memory)
2231         free (contents);
2232       else
2233         {
2234           /* Cache the section contents for elf_link_input_bfd.  */
2235           elf_section_data (sec)->this_hdr.contents = contents;
2236         }
2237     }
2238
2239   if (internal_relocs != NULL
2240       && elf_section_data (sec)->relocs != internal_relocs)
2241     free (internal_relocs);
2242
2243   return TRUE;
2244
2245  error_return:
2246   if (isymbuf != NULL
2247       && symtab_hdr->contents != (unsigned char *) isymbuf)
2248     free (isymbuf);
2249   if (contents != NULL
2250       && elf_section_data (sec)->this_hdr.contents != contents)
2251     free (contents);
2252   if (internal_relocs != NULL
2253       && elf_section_data (sec)->relocs != internal_relocs)
2254     free (internal_relocs);
2255
2256   return FALSE;
2257 }
2258
2259 /* This is a version of bfd_generic_get_relocated_section_contents
2260    which uses elf32_avr_relocate_section.
2261
2262    For avr it's essentially a cut and paste taken from the H8300 port.
2263    The author of the relaxation support patch for avr had absolutely no
2264    clue what is happening here but found out that this part of the code
2265    seems to be important.  */
2266
2267 static bfd_byte *
2268 elf32_avr_get_relocated_section_contents (bfd *output_bfd,
2269                                           struct bfd_link_info *link_info,
2270                                           struct bfd_link_order *link_order,
2271                                           bfd_byte *data,
2272                                           bfd_boolean relocatable,
2273                                           asymbol **symbols)
2274 {
2275   Elf_Internal_Shdr *symtab_hdr;
2276   asection *input_section = link_order->u.indirect.section;
2277   bfd *input_bfd = input_section->owner;
2278   asection **sections = NULL;
2279   Elf_Internal_Rela *internal_relocs = NULL;
2280   Elf_Internal_Sym *isymbuf = NULL;
2281
2282   /* We only need to handle the case of relaxing, or of having a
2283      particular set of section contents, specially.  */
2284   if (relocatable
2285       || elf_section_data (input_section)->this_hdr.contents == NULL)
2286     return bfd_generic_get_relocated_section_contents (output_bfd, link_info,
2287                                                        link_order, data,
2288                                                        relocatable,
2289                                                        symbols);
2290   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2291
2292   memcpy (data, elf_section_data (input_section)->this_hdr.contents,
2293           (size_t) input_section->size);
2294
2295   if ((input_section->flags & SEC_RELOC) != 0
2296       && input_section->reloc_count > 0)
2297     {
2298       asection **secpp;
2299       Elf_Internal_Sym *isym, *isymend;
2300       bfd_size_type amt;
2301
2302       internal_relocs = (_bfd_elf_link_read_relocs
2303                          (input_bfd, input_section, NULL, NULL, FALSE));
2304       if (internal_relocs == NULL)
2305         goto error_return;
2306
2307       if (symtab_hdr->sh_info != 0)
2308         {
2309           isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
2310           if (isymbuf == NULL)
2311             isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
2312                                             symtab_hdr->sh_info, 0,
2313                                             NULL, NULL, NULL);
2314           if (isymbuf == NULL)
2315             goto error_return;
2316         }
2317
2318       amt = symtab_hdr->sh_info;
2319       amt *= sizeof (asection *);
2320       sections = bfd_malloc (amt);
2321       if (sections == NULL && amt != 0)
2322         goto error_return;
2323
2324       isymend = isymbuf + symtab_hdr->sh_info;
2325       for (isym = isymbuf, secpp = sections; isym < isymend; ++isym, ++secpp)
2326         {
2327           asection *isec;
2328
2329           if (isym->st_shndx == SHN_UNDEF)
2330             isec = bfd_und_section_ptr;
2331           else if (isym->st_shndx == SHN_ABS)
2332             isec = bfd_abs_section_ptr;
2333           else if (isym->st_shndx == SHN_COMMON)
2334             isec = bfd_com_section_ptr;
2335           else
2336             isec = bfd_section_from_elf_index (input_bfd, isym->st_shndx);
2337
2338           *secpp = isec;
2339         }
2340
2341       if (! elf32_avr_relocate_section (output_bfd, link_info, input_bfd,
2342                                         input_section, data, internal_relocs,
2343                                         isymbuf, sections))
2344         goto error_return;
2345
2346       if (sections != NULL)
2347         free (sections);
2348       if (isymbuf != NULL
2349           && symtab_hdr->contents != (unsigned char *) isymbuf)
2350         free (isymbuf);
2351       if (elf_section_data (input_section)->relocs != internal_relocs)
2352         free (internal_relocs);
2353     }
2354
2355   return data;
2356
2357  error_return:
2358   if (sections != NULL)
2359     free (sections);
2360   if (isymbuf != NULL
2361       && symtab_hdr->contents != (unsigned char *) isymbuf)
2362     free (isymbuf);
2363   if (internal_relocs != NULL
2364       && elf_section_data (input_section)->relocs != internal_relocs)
2365     free (internal_relocs);
2366   return NULL;
2367 }
2368
2369
2370 /* Determines the hash entry name for a particular reloc. It consists of
2371    the identifier of the symbol section and the added reloc addend and
2372    symbol offset relative to the section the symbol is attached to.  */
2373
2374 static char *
2375 avr_stub_name (const asection *symbol_section,
2376                const bfd_vma symbol_offset,
2377                const Elf_Internal_Rela *rela)
2378 {
2379   char *stub_name;
2380   bfd_size_type len;
2381
2382   len = 8 + 1 + 8 + 1 + 1;
2383   stub_name = bfd_malloc (len);
2384
2385   sprintf (stub_name, "%08x+%08x",
2386            symbol_section->id & 0xffffffff,
2387            (unsigned int) ((rela->r_addend & 0xffffffff) + symbol_offset));
2388
2389   return stub_name;
2390 }
2391
2392
2393 /* Add a new stub entry to the stub hash.  Not all fields of the new
2394    stub entry are initialised.  */
2395
2396 static struct elf32_avr_stub_hash_entry *
2397 avr_add_stub (const char *stub_name,
2398               struct elf32_avr_link_hash_table *htab)
2399 {
2400   struct elf32_avr_stub_hash_entry *hsh;
2401
2402   /* Enter this entry into the linker stub hash table.  */
2403   hsh = avr_stub_hash_lookup (&htab->bstab, stub_name, TRUE, FALSE);
2404
2405   if (hsh == NULL)
2406     {
2407       (*_bfd_error_handler) (_("%B: cannot create stub entry %s"),
2408                              NULL, stub_name);
2409       return NULL;
2410     }
2411
2412   hsh->stub_offset = 0;
2413   return hsh;
2414 }
2415
2416 /* We assume that there is already space allocated for the stub section
2417    contents and that before building the stubs the section size is
2418    initialized to 0.  We assume that within the stub hash table entry,
2419    the absolute position of the jmp target has been written in the
2420    target_value field.  We write here the offset of the generated jmp insn
2421    relative to the trampoline section start to the stub_offset entry in
2422    the stub hash table entry.  */
2423
2424 static  bfd_boolean
2425 avr_build_one_stub (struct bfd_hash_entry *bh, void *in_arg)
2426 {
2427   struct elf32_avr_stub_hash_entry *hsh;
2428   struct bfd_link_info *info;
2429   struct elf32_avr_link_hash_table *htab;
2430   bfd *stub_bfd;
2431   bfd_byte *loc;
2432   bfd_vma target;
2433   bfd_vma starget;
2434
2435   /* Basic opcode */
2436   bfd_vma jmp_insn = 0x0000940c;
2437
2438   /* Massage our args to the form they really have.  */
2439   hsh = avr_stub_hash_entry (bh);
2440
2441   if (!hsh->is_actually_needed)
2442     return TRUE;
2443
2444   info = (struct bfd_link_info *) in_arg;
2445
2446   htab = avr_link_hash_table (info);
2447   if (htab == NULL)
2448     return FALSE;
2449
2450   target = hsh->target_value;
2451
2452   /* Make a note of the offset within the stubs for this entry.  */
2453   hsh->stub_offset = htab->stub_sec->size;
2454   loc = htab->stub_sec->contents + hsh->stub_offset;
2455
2456   stub_bfd = htab->stub_sec->owner;
2457
2458   if (debug_stubs)
2459     printf ("Building one Stub. Address: 0x%x, Offset: 0x%x\n",
2460              (unsigned int) target,
2461              (unsigned int) hsh->stub_offset);
2462
2463   /* We now have to add the information on the jump target to the bare
2464      opcode bits already set in jmp_insn.  */
2465
2466   /* Check for the alignment of the address.  */
2467   if (target & 1)
2468      return FALSE;
2469
2470   starget = target >> 1;
2471   jmp_insn |= ((starget & 0x10000) | ((starget << 3) & 0x1f00000)) >> 16;
2472   bfd_put_16 (stub_bfd, jmp_insn, loc);
2473   bfd_put_16 (stub_bfd, (bfd_vma) starget & 0xffff, loc + 2);
2474
2475   htab->stub_sec->size += 4;
2476
2477   /* Now add the entries in the address mapping table if there is still
2478      space left.  */
2479   {
2480     unsigned int nr;
2481
2482     nr = htab->amt_entry_cnt + 1;
2483     if (nr <= htab->amt_max_entry_cnt)
2484       {
2485         htab->amt_entry_cnt = nr;
2486
2487         htab->amt_stub_offsets[nr - 1] = hsh->stub_offset;
2488         htab->amt_destination_addr[nr - 1] = target;
2489       }
2490   }
2491
2492   return TRUE;
2493 }
2494
2495 static bfd_boolean
2496 avr_mark_stub_not_to_be_necessary (struct bfd_hash_entry *bh,
2497                                    void *in_arg ATTRIBUTE_UNUSED)
2498 {
2499   struct elf32_avr_stub_hash_entry *hsh;
2500
2501   hsh = avr_stub_hash_entry (bh);
2502   hsh->is_actually_needed = FALSE;
2503
2504   return TRUE;
2505 }
2506
2507 static bfd_boolean
2508 avr_size_one_stub (struct bfd_hash_entry *bh, void *in_arg)
2509 {
2510   struct elf32_avr_stub_hash_entry *hsh;
2511   struct elf32_avr_link_hash_table *htab;
2512   int size;
2513
2514   /* Massage our args to the form they really have.  */
2515   hsh = avr_stub_hash_entry (bh);
2516   htab = in_arg;
2517
2518   if (hsh->is_actually_needed)
2519     size = 4;
2520   else
2521     size = 0;
2522
2523   htab->stub_sec->size += size;
2524   return TRUE;
2525 }
2526
2527 void
2528 elf32_avr_setup_params (struct bfd_link_info *info,
2529                         bfd *avr_stub_bfd,
2530                         asection *avr_stub_section,
2531                         bfd_boolean no_stubs,
2532                         bfd_boolean deb_stubs,
2533                         bfd_boolean deb_relax,
2534                         bfd_vma pc_wrap_around,
2535                         bfd_boolean call_ret_replacement)
2536 {
2537   struct elf32_avr_link_hash_table *htab = avr_link_hash_table (info);
2538
2539   if (htab == NULL)
2540     return;
2541   htab->stub_sec = avr_stub_section;
2542   htab->stub_bfd = avr_stub_bfd;
2543   htab->no_stubs = no_stubs;
2544
2545   debug_relax = deb_relax;
2546   debug_stubs = deb_stubs;
2547   avr_pc_wrap_around = pc_wrap_around;
2548   avr_replace_call_ret_sequences = call_ret_replacement;
2549 }
2550
2551
2552 /* Set up various things so that we can make a list of input sections
2553    for each output section included in the link.  Returns -1 on error,
2554    0 when no stubs will be needed, and 1 on success.  It also sets
2555    information on the stubs bfd and the stub section in the info
2556    struct.  */
2557
2558 int
2559 elf32_avr_setup_section_lists (bfd *output_bfd,
2560                                struct bfd_link_info *info)
2561 {
2562   bfd *input_bfd;
2563   unsigned int bfd_count;
2564   int top_id, top_index;
2565   asection *section;
2566   asection **input_list, **list;
2567   bfd_size_type amt;
2568   struct elf32_avr_link_hash_table *htab = avr_link_hash_table (info);
2569
2570   if (htab == NULL || htab->no_stubs)
2571     return 0;
2572
2573   /* Count the number of input BFDs and find the top input section id.  */
2574   for (input_bfd = info->input_bfds, bfd_count = 0, top_id = 0;
2575        input_bfd != NULL;
2576        input_bfd = input_bfd->link_next)
2577     {
2578       bfd_count += 1;
2579       for (section = input_bfd->sections;
2580            section != NULL;
2581            section = section->next)
2582         if (top_id < section->id)
2583           top_id = section->id;
2584     }
2585
2586   htab->bfd_count = bfd_count;
2587
2588   /* We can't use output_bfd->section_count here to find the top output
2589      section index as some sections may have been removed, and
2590      strip_excluded_output_sections doesn't renumber the indices.  */
2591   for (section = output_bfd->sections, top_index = 0;
2592        section != NULL;
2593        section = section->next)
2594     if (top_index < section->index)
2595       top_index = section->index;
2596
2597   htab->top_index = top_index;
2598   amt = sizeof (asection *) * (top_index + 1);
2599   input_list = bfd_malloc (amt);
2600   htab->input_list = input_list;
2601   if (input_list == NULL)
2602     return -1;
2603
2604   /* For sections we aren't interested in, mark their entries with a
2605      value we can check later.  */
2606   list = input_list + top_index;
2607   do
2608     *list = bfd_abs_section_ptr;
2609   while (list-- != input_list);
2610
2611   for (section = output_bfd->sections;
2612        section != NULL;
2613        section = section->next)
2614     if ((section->flags & SEC_CODE) != 0)
2615       input_list[section->index] = NULL;
2616
2617   return 1;
2618 }
2619
2620
2621 /* Read in all local syms for all input bfds, and create hash entries
2622    for export stubs if we are building a multi-subspace shared lib.
2623    Returns -1 on error, 0 otherwise.  */
2624
2625 static int
2626 get_local_syms (bfd *input_bfd, struct bfd_link_info *info)
2627 {
2628   unsigned int bfd_indx;
2629   Elf_Internal_Sym *local_syms, **all_local_syms;
2630   struct elf32_avr_link_hash_table *htab = avr_link_hash_table (info);
2631   bfd_size_type amt;
2632
2633   if (htab == NULL)
2634     return -1;
2635
2636   /* We want to read in symbol extension records only once.  To do this
2637      we need to read in the local symbols in parallel and save them for
2638      later use; so hold pointers to the local symbols in an array.  */
2639   amt = sizeof (Elf_Internal_Sym *) * htab->bfd_count;
2640   all_local_syms = bfd_zmalloc (amt);
2641   htab->all_local_syms = all_local_syms;
2642   if (all_local_syms == NULL)
2643     return -1;
2644
2645   /* Walk over all the input BFDs, swapping in local symbols.
2646      If we are creating a shared library, create hash entries for the
2647      export stubs.  */
2648   for (bfd_indx = 0;
2649        input_bfd != NULL;
2650        input_bfd = input_bfd->link_next, bfd_indx++)
2651     {
2652       Elf_Internal_Shdr *symtab_hdr;
2653
2654       /* We'll need the symbol table in a second.  */
2655       symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2656       if (symtab_hdr->sh_info == 0)
2657         continue;
2658
2659       /* We need an array of the local symbols attached to the input bfd.  */
2660       local_syms = (Elf_Internal_Sym *) symtab_hdr->contents;
2661       if (local_syms == NULL)
2662         {
2663           local_syms = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
2664                                              symtab_hdr->sh_info, 0,
2665                                              NULL, NULL, NULL);
2666           /* Cache them for elf_link_input_bfd.  */
2667           symtab_hdr->contents = (unsigned char *) local_syms;
2668         }
2669       if (local_syms == NULL)
2670         return -1;
2671
2672       all_local_syms[bfd_indx] = local_syms;
2673     }
2674
2675   return 0;
2676 }
2677
2678 #define ADD_DUMMY_STUBS_FOR_DEBUGGING 0
2679
2680 bfd_boolean
2681 elf32_avr_size_stubs (bfd *output_bfd,
2682                       struct bfd_link_info *info,
2683                       bfd_boolean is_prealloc_run)
2684 {
2685   struct elf32_avr_link_hash_table *htab;
2686   int stub_changed = 0;
2687
2688   htab = avr_link_hash_table (info);
2689   if (htab == NULL)
2690     return FALSE;
2691
2692   /* At this point we initialize htab->vector_base
2693      To the start of the text output section.  */
2694   htab->vector_base = htab->stub_sec->output_section->vma;
2695
2696   if (get_local_syms (info->input_bfds, info))
2697     {
2698       if (htab->all_local_syms)
2699         goto error_ret_free_local;
2700       return FALSE;
2701     }
2702
2703   if (ADD_DUMMY_STUBS_FOR_DEBUGGING)
2704     {
2705       struct elf32_avr_stub_hash_entry *test;
2706
2707       test = avr_add_stub ("Hugo",htab);
2708       test->target_value = 0x123456;
2709       test->stub_offset = 13;
2710
2711       test = avr_add_stub ("Hugo2",htab);
2712       test->target_value = 0x84210;
2713       test->stub_offset = 14;
2714     }
2715
2716   while (1)
2717     {
2718       bfd *input_bfd;
2719       unsigned int bfd_indx;
2720
2721       /* We will have to re-generate the stub hash table each time anything
2722          in memory has changed.  */
2723
2724       bfd_hash_traverse (&htab->bstab, avr_mark_stub_not_to_be_necessary, htab);
2725       for (input_bfd = info->input_bfds, bfd_indx = 0;
2726            input_bfd != NULL;
2727            input_bfd = input_bfd->link_next, bfd_indx++)
2728         {
2729           Elf_Internal_Shdr *symtab_hdr;
2730           asection *section;
2731           Elf_Internal_Sym *local_syms;
2732
2733           /* We'll need the symbol table in a second.  */
2734           symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2735           if (symtab_hdr->sh_info == 0)
2736             continue;
2737
2738           local_syms = htab->all_local_syms[bfd_indx];
2739
2740           /* Walk over each section attached to the input bfd.  */
2741           for (section = input_bfd->sections;
2742                section != NULL;
2743                section = section->next)
2744             {
2745               Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
2746
2747               /* If there aren't any relocs, then there's nothing more
2748                  to do.  */
2749               if ((section->flags & SEC_RELOC) == 0
2750                   || section->reloc_count == 0)
2751                 continue;
2752
2753               /* If this section is a link-once section that will be
2754                  discarded, then don't create any stubs.  */
2755               if (section->output_section == NULL
2756                   || section->output_section->owner != output_bfd)
2757                 continue;
2758
2759               /* Get the relocs.  */
2760               internal_relocs
2761                 = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL,
2762                                              info->keep_memory);
2763               if (internal_relocs == NULL)
2764                 goto error_ret_free_local;
2765
2766               /* Now examine each relocation.  */
2767               irela = internal_relocs;
2768               irelaend = irela + section->reloc_count;
2769               for (; irela < irelaend; irela++)
2770                 {
2771                   unsigned int r_type, r_indx;
2772                   struct elf32_avr_stub_hash_entry *hsh;
2773                   asection *sym_sec;
2774                   bfd_vma sym_value;
2775                   bfd_vma destination;
2776                   struct elf_link_hash_entry *hh;
2777                   char *stub_name;
2778
2779                   r_type = ELF32_R_TYPE (irela->r_info);
2780                   r_indx = ELF32_R_SYM (irela->r_info);
2781
2782                   /* Only look for 16 bit GS relocs. No other reloc will need a
2783                      stub.  */
2784                   if (!((r_type == R_AVR_16_PM)
2785                         || (r_type == R_AVR_LO8_LDI_GS)
2786                         || (r_type == R_AVR_HI8_LDI_GS)))
2787                     continue;
2788
2789                   /* Now determine the call target, its name, value,
2790                      section.  */
2791                   sym_sec = NULL;
2792                   sym_value = 0;
2793                   destination = 0;
2794                   hh = NULL;
2795                   if (r_indx < symtab_hdr->sh_info)
2796                     {
2797                       /* It's a local symbol.  */
2798                       Elf_Internal_Sym *sym;
2799                       Elf_Internal_Shdr *hdr;
2800                       unsigned int shndx;
2801
2802                       sym = local_syms + r_indx;
2803                       if (ELF_ST_TYPE (sym->st_info) != STT_SECTION)
2804                         sym_value = sym->st_value;
2805                       shndx = sym->st_shndx;
2806                       if (shndx < elf_numsections (input_bfd))
2807                         {
2808                           hdr = elf_elfsections (input_bfd)[shndx];
2809                           sym_sec = hdr->bfd_section;
2810                           destination = (sym_value + irela->r_addend
2811                                          + sym_sec->output_offset
2812                                          + sym_sec->output_section->vma);
2813                         }
2814                     }
2815                   else
2816                     {
2817                       /* It's an external symbol.  */
2818                       int e_indx;
2819
2820                       e_indx = r_indx - symtab_hdr->sh_info;
2821                       hh = elf_sym_hashes (input_bfd)[e_indx];
2822
2823                       while (hh->root.type == bfd_link_hash_indirect
2824                              || hh->root.type == bfd_link_hash_warning)
2825                         hh = (struct elf_link_hash_entry *)
2826                               (hh->root.u.i.link);
2827
2828                       if (hh->root.type == bfd_link_hash_defined
2829                           || hh->root.type == bfd_link_hash_defweak)
2830                         {
2831                           sym_sec = hh->root.u.def.section;
2832                           sym_value = hh->root.u.def.value;
2833                           if (sym_sec->output_section != NULL)
2834                           destination = (sym_value + irela->r_addend
2835                                          + sym_sec->output_offset
2836                                          + sym_sec->output_section->vma);
2837                         }
2838                       else if (hh->root.type == bfd_link_hash_undefweak)
2839                         {
2840                           if (! info->shared)
2841                             continue;
2842                         }
2843                       else if (hh->root.type == bfd_link_hash_undefined)
2844                         {
2845                           if (! (info->unresolved_syms_in_objects == RM_IGNORE
2846                                  && (ELF_ST_VISIBILITY (hh->other)
2847                                      == STV_DEFAULT)))
2848                              continue;
2849                         }
2850                       else
2851                         {
2852                           bfd_set_error (bfd_error_bad_value);
2853
2854                           error_ret_free_internal:
2855                           if (elf_section_data (section)->relocs == NULL)
2856                             free (internal_relocs);
2857                           goto error_ret_free_local;
2858                         }
2859                     }
2860
2861                   if (! avr_stub_is_required_for_16_bit_reloc
2862                       (destination - htab->vector_base))
2863                     {
2864                       if (!is_prealloc_run)
2865                         /* We are having a reloc that does't need a stub.  */
2866                         continue;
2867
2868                       /* We don't right now know if a stub will be needed.
2869                          Let's rather be on the safe side.  */
2870                     }
2871
2872                   /* Get the name of this stub.  */
2873                   stub_name = avr_stub_name (sym_sec, sym_value, irela);
2874
2875                   if (!stub_name)
2876                     goto error_ret_free_internal;
2877
2878
2879                   hsh = avr_stub_hash_lookup (&htab->bstab,
2880                                               stub_name,
2881                                               FALSE, FALSE);
2882                   if (hsh != NULL)
2883                     {
2884                       /* The proper stub has already been created.  Mark it
2885                          to be used and write the possibly changed destination
2886                          value.  */
2887                       hsh->is_actually_needed = TRUE;
2888                       hsh->target_value = destination;
2889                       free (stub_name);
2890                       continue;
2891                     }
2892
2893                   hsh = avr_add_stub (stub_name, htab);
2894                   if (hsh == NULL)
2895                     {
2896                       free (stub_name);
2897                       goto error_ret_free_internal;
2898                     }
2899
2900                   hsh->is_actually_needed = TRUE;
2901                   hsh->target_value = destination;
2902
2903                   if (debug_stubs)
2904                     printf ("Adding stub with destination 0x%x to the"
2905                             " hash table.\n", (unsigned int) destination);
2906                   if (debug_stubs)
2907                     printf ("(Pre-Alloc run: %i)\n", is_prealloc_run);
2908
2909                   stub_changed = TRUE;
2910                 }
2911
2912               /* We're done with the internal relocs, free them.  */
2913               if (elf_section_data (section)->relocs == NULL)
2914                 free (internal_relocs);
2915             }
2916         }
2917
2918       /* Re-Calculate the number of needed stubs.  */
2919       htab->stub_sec->size = 0;
2920       bfd_hash_traverse (&htab->bstab, avr_size_one_stub, htab);
2921
2922       if (!stub_changed)
2923         break;
2924
2925       stub_changed = FALSE;
2926     }
2927
2928   free (htab->all_local_syms);
2929   return TRUE;
2930
2931  error_ret_free_local:
2932   free (htab->all_local_syms);
2933   return FALSE;
2934 }
2935
2936
2937 /* Build all the stubs associated with the current output file.  The
2938    stubs are kept in a hash table attached to the main linker hash
2939    table.  We also set up the .plt entries for statically linked PIC
2940    functions here.  This function is called via hppaelf_finish in the
2941    linker.  */
2942
2943 bfd_boolean
2944 elf32_avr_build_stubs (struct bfd_link_info *info)
2945 {
2946   asection *stub_sec;
2947   struct bfd_hash_table *table;
2948   struct elf32_avr_link_hash_table *htab;
2949   bfd_size_type total_size = 0;
2950
2951   htab = avr_link_hash_table (info);
2952   if (htab == NULL)
2953     return FALSE;
2954
2955   /* In case that there were several stub sections:  */
2956   for (stub_sec = htab->stub_bfd->sections;
2957        stub_sec != NULL;
2958        stub_sec = stub_sec->next)
2959     {
2960       bfd_size_type size;
2961
2962       /* Allocate memory to hold the linker stubs.  */
2963       size = stub_sec->size;
2964       total_size += size;
2965
2966       stub_sec->contents = bfd_zalloc (htab->stub_bfd, size);
2967       if (stub_sec->contents == NULL && size != 0)
2968         return FALSE;
2969       stub_sec->size = 0;
2970     }
2971
2972   /* Allocate memory for the adress mapping table.  */
2973   htab->amt_entry_cnt = 0;
2974   htab->amt_max_entry_cnt = total_size / 4;
2975   htab->amt_stub_offsets = bfd_malloc (sizeof (bfd_vma)
2976                                        * htab->amt_max_entry_cnt);
2977   htab->amt_destination_addr = bfd_malloc (sizeof (bfd_vma)
2978                                            * htab->amt_max_entry_cnt );
2979
2980   if (debug_stubs)
2981     printf ("Allocating %i entries in the AMT\n", htab->amt_max_entry_cnt);
2982
2983   /* Build the stubs as directed by the stub hash table.  */
2984   table = &htab->bstab;
2985   bfd_hash_traverse (table, avr_build_one_stub, info);
2986
2987   if (debug_stubs)
2988     printf ("Final Stub section Size: %i\n", (int) htab->stub_sec->size);
2989
2990   return TRUE;
2991 }
2992
2993 #define ELF_ARCH                bfd_arch_avr
2994 #define ELF_TARGET_ID           AVR_ELF_DATA
2995 #define ELF_MACHINE_CODE        EM_AVR
2996 #define ELF_MACHINE_ALT1        EM_AVR_OLD
2997 #define ELF_MAXPAGESIZE         1
2998
2999 #define TARGET_LITTLE_SYM       bfd_elf32_avr_vec
3000 #define TARGET_LITTLE_NAME      "elf32-avr"
3001
3002 #define bfd_elf32_bfd_link_hash_table_create elf32_avr_link_hash_table_create
3003 #define bfd_elf32_bfd_link_hash_table_free   elf32_avr_link_hash_table_free
3004
3005 #define elf_info_to_howto                    avr_info_to_howto_rela
3006 #define elf_info_to_howto_rel                NULL
3007 #define elf_backend_relocate_section         elf32_avr_relocate_section
3008 #define elf_backend_check_relocs             elf32_avr_check_relocs
3009 #define elf_backend_can_gc_sections          1
3010 #define elf_backend_rela_normal              1
3011 #define elf_backend_final_write_processing \
3012                                         bfd_elf_avr_final_write_processing
3013 #define elf_backend_object_p            elf32_avr_object_p
3014
3015 #define bfd_elf32_bfd_relax_section elf32_avr_relax_section
3016 #define bfd_elf32_bfd_get_relocated_section_contents \
3017                                         elf32_avr_get_relocated_section_contents
3018
3019 #include "elf32-target.h"