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