bfd/elf32-avr.c

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