bfd/elf32-avr.c

   1 /* AVR-specific support for 32-bit ELF
   2    Copyright 1999, 2000, 2001, 2002, 2003, 2004, 2006
   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   ((struct elf32_avr_link_hash_table *) ((p)->hash))
 107
 108 #define avr_stub_hash_entry(ent) \
 109   ((struct elf32_avr_stub_hash_entry *)(ent))
 110
 111 #define avr_stub_hash_lookup(table, string, create, copy) \
 112   ((struct elf32_avr_stub_hash_entry *) \
 113    bfd_hash_lookup ((table), (string), (create), (copy)))
 114
 115 static reloc_howto_type elf_avr_howto_table[] =
 116 {
 117   HOWTO (R_AVR_NONE,            /* type */
 118          0,                     /* rightshift */
 119          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 120          32,                    /* bitsize */
 121          FALSE,                 /* pc_relative */
 122          0,                     /* bitpos */
 123          complain_overflow_bitfield, /* complain_on_overflow */
 124          bfd_elf_generic_reloc, /* special_function */
 125          "R_AVR_NONE",          /* name */
 126          FALSE,                 /* partial_inplace */
 127          0,                     /* src_mask */
 128          0,                     /* dst_mask */
 129          FALSE),                /* pcrel_offset */
 130
 131   HOWTO (R_AVR_32,              /* type */
 132          0,                     /* rightshift */
 133          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 134          32,                    /* bitsize */
 135          FALSE,                 /* pc_relative */
 136          0,                     /* bitpos */
 137          complain_overflow_bitfield, /* complain_on_overflow */
 138          bfd_elf_generic_reloc, /* special_function */
 139          "R_AVR_32",            /* name */
 140          FALSE,                 /* partial_inplace */
 141          0xffffffff,            /* src_mask */
 142          0xffffffff,            /* dst_mask */
 143          FALSE),                /* pcrel_offset */
 144
 145   /* A 7 bit PC relative relocation.  */
 146   HOWTO (R_AVR_7_PCREL,         /* type */
 147          1,                     /* rightshift */
 148          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 149          7,                     /* bitsize */
 150          TRUE,                  /* pc_relative */
 151          3,                     /* bitpos */
 152          complain_overflow_bitfield, /* complain_on_overflow */
 153          bfd_elf_generic_reloc, /* special_function */
 154          "R_AVR_7_PCREL",       /* name */
 155          FALSE,                 /* partial_inplace */
 156          0xffff,                /* src_mask */
 157          0xffff,                /* dst_mask */
 158          TRUE),                 /* pcrel_offset */
 159
 160   /* A 13 bit PC relative relocation.  */
 161   HOWTO (R_AVR_13_PCREL,        /* type */
 162          1,                     /* rightshift */
 163          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 164          13,                    /* bitsize */
 165          TRUE,                  /* pc_relative */
 166          0,                     /* bitpos */
 167          complain_overflow_bitfield, /* complain_on_overflow */
 168          bfd_elf_generic_reloc, /* special_function */
 169          "R_AVR_13_PCREL",      /* name */
 170          FALSE,                 /* partial_inplace */
 171          0xfff,                 /* src_mask */
 172          0xfff,                 /* dst_mask */
 173          TRUE),                 /* pcrel_offset */
 174
 175   /* A 16 bit absolute relocation.  */
 176   HOWTO (R_AVR_16,              /* type */
 177          0,                     /* rightshift */
 178          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 179          16,                    /* bitsize */
 180          FALSE,                 /* pc_relative */
 181          0,                     /* bitpos */
 182          complain_overflow_dont, /* complain_on_overflow */
 183          bfd_elf_generic_reloc, /* special_function */
 184          "R_AVR_16",            /* name */
 185          FALSE,                 /* partial_inplace */
 186          0xffff,                /* src_mask */
 187          0xffff,                /* dst_mask */
 188          FALSE),                /* pcrel_offset */
 189
 190   /* A 16 bit absolute relocation for command address
 191      Will be changed when linker stubs are needed.  */
 192   HOWTO (R_AVR_16_PM,           /* type */
 193          1,                     /* rightshift */
 194          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 195          16,                    /* bitsize */
 196          FALSE,                 /* pc_relative */
 197          0,                     /* bitpos */
 198          complain_overflow_bitfield, /* complain_on_overflow */
 199          bfd_elf_generic_reloc, /* special_function */
 200          "R_AVR_16_PM",         /* name */
 201          FALSE,                 /* partial_inplace */
 202          0xffff,                /* src_mask */
 203          0xffff,                /* dst_mask */
 204          FALSE),                /* pcrel_offset */
 205   /* A low 8 bit absolute relocation of 16 bit address.
 206      For LDI command.  */
 207   HOWTO (R_AVR_LO8_LDI,         /* type */
 208          0,                     /* rightshift */
 209          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 210          8,                     /* bitsize */
 211          FALSE,                 /* pc_relative */
 212          0,                     /* bitpos */
 213          complain_overflow_dont, /* complain_on_overflow */
 214          bfd_elf_generic_reloc, /* special_function */
 215          "R_AVR_LO8_LDI",       /* name */
 216          FALSE,                 /* partial_inplace */
 217          0xffff,                /* src_mask */
 218          0xffff,                /* dst_mask */
 219          FALSE),                /* pcrel_offset */
 220   /* A high 8 bit absolute relocation of 16 bit address.
 221      For LDI command.  */
 222   HOWTO (R_AVR_HI8_LDI,         /* type */
 223          8,                     /* rightshift */
 224          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 225          8,                     /* bitsize */
 226          FALSE,                 /* pc_relative */
 227          0,                     /* bitpos */
 228          complain_overflow_dont, /* complain_on_overflow */
 229          bfd_elf_generic_reloc, /* special_function */
 230          "R_AVR_HI8_LDI",       /* name */
 231          FALSE,                 /* partial_inplace */
 232          0xffff,                /* src_mask */
 233          0xffff,                /* dst_mask */
 234          FALSE),                /* pcrel_offset */
 235   /* A high 6 bit absolute relocation of 22 bit address.
 236      For LDI command.  As well second most significant 8 bit value of
 237      a 32 bit link-time constant.  */
 238   HOWTO (R_AVR_HH8_LDI,         /* type */
 239          16,                    /* rightshift */
 240          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 241          8,                     /* bitsize */
 242          FALSE,                 /* pc_relative */
 243          0,                     /* bitpos */
 244          complain_overflow_dont, /* complain_on_overflow */
 245          bfd_elf_generic_reloc, /* special_function */
 246          "R_AVR_HH8_LDI",       /* name */
 247          FALSE,                 /* partial_inplace */
 248          0xffff,                /* src_mask */
 249          0xffff,                /* dst_mask */
 250          FALSE),                /* pcrel_offset */
 251   /* A negative low 8 bit absolute relocation of 16 bit address.
 252      For LDI command.  */
 253   HOWTO (R_AVR_LO8_LDI_NEG,     /* type */
 254          0,                     /* rightshift */
 255          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 256          8,                     /* bitsize */
 257          FALSE,                 /* pc_relative */
 258          0,                     /* bitpos */
 259          complain_overflow_dont, /* complain_on_overflow */
 260          bfd_elf_generic_reloc, /* special_function */
 261          "R_AVR_LO8_LDI_NEG",   /* name */
 262          FALSE,                 /* partial_inplace */
 263          0xffff,                /* src_mask */
 264          0xffff,                /* dst_mask */
 265          FALSE),                /* pcrel_offset */
 266   /* A negative high 8 bit absolute relocation of 16 bit address.
 267      For LDI command.  */
 268   HOWTO (R_AVR_HI8_LDI_NEG,     /* type */
 269          8,                     /* rightshift */
 270          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 271          8,                     /* bitsize */
 272          FALSE,                 /* pc_relative */
 273          0,                     /* bitpos */
 274          complain_overflow_dont, /* complain_on_overflow */
 275          bfd_elf_generic_reloc, /* special_function */
 276          "R_AVR_HI8_LDI_NEG",   /* name */
 277          FALSE,                 /* partial_inplace */
 278          0xffff,                /* src_mask */
 279          0xffff,                /* dst_mask */
 280          FALSE),                /* pcrel_offset */
 281   /* A negative high 6 bit absolute relocation of 22 bit address.
 282      For LDI command.  */
 283   HOWTO (R_AVR_HH8_LDI_NEG,     /* type */
 284          16,                    /* rightshift */
 285          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 286          8,                     /* bitsize */
 287          FALSE,                 /* pc_relative */
 288          0,                     /* bitpos */
 289          complain_overflow_dont, /* complain_on_overflow */
 290          bfd_elf_generic_reloc, /* special_function */
 291          "R_AVR_HH8_LDI_NEG",   /* name */
 292          FALSE,                 /* partial_inplace */
 293          0xffff,                /* src_mask */
 294          0xffff,                /* dst_mask */
 295          FALSE),                /* pcrel_offset */
 296   /* A low 8 bit absolute relocation of 24 bit program memory address.
 297      For LDI command.  Will not be changed when linker stubs are needed. */
 298   HOWTO (R_AVR_LO8_LDI_PM,      /* type */
 299          1,                     /* rightshift */
 300          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 301          8,                     /* bitsize */
 302          FALSE,                 /* pc_relative */
 303          0,                     /* bitpos */
 304          complain_overflow_dont, /* complain_on_overflow */
 305          bfd_elf_generic_reloc, /* special_function */
 306          "R_AVR_LO8_LDI_PM",    /* name */
 307          FALSE,                 /* partial_inplace */
 308          0xffff,                /* src_mask */
 309          0xffff,                /* dst_mask */
 310          FALSE),                /* pcrel_offset */
 311   /* A low 8 bit absolute relocation of 24 bit program memory address.
 312      For LDI command.  Will not be changed when linker stubs are needed. */
 313   HOWTO (R_AVR_HI8_LDI_PM,      /* type */
 314          9,                     /* rightshift */
 315          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 316          8,                     /* bitsize */
 317          FALSE,                 /* pc_relative */
 318          0,                     /* bitpos */
 319          complain_overflow_dont, /* complain_on_overflow */
 320          bfd_elf_generic_reloc, /* special_function */
 321          "R_AVR_HI8_LDI_PM",    /* name */
 322          FALSE,                 /* partial_inplace */
 323          0xffff,                /* src_mask */
 324          0xffff,                /* dst_mask */
 325          FALSE),                /* pcrel_offset */
 326   /* A low 8 bit absolute relocation of 24 bit program memory address.
 327      For LDI command.  Will not be changed when linker stubs are needed. */
 328   HOWTO (R_AVR_HH8_LDI_PM,      /* type */
 329          17,                    /* rightshift */
 330          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 331          8,                     /* bitsize */
 332          FALSE,                 /* pc_relative */
 333          0,                     /* bitpos */
 334          complain_overflow_dont, /* complain_on_overflow */
 335          bfd_elf_generic_reloc, /* special_function */
 336          "R_AVR_HH8_LDI_PM",    /* name */
 337          FALSE,                 /* partial_inplace */
 338          0xffff,                /* src_mask */
 339          0xffff,                /* dst_mask */
 340          FALSE),                /* pcrel_offset */
 341   /* A low 8 bit absolute relocation of 24 bit program memory address.
 342      For LDI command.  Will not be changed when linker stubs are needed. */
 343   HOWTO (R_AVR_LO8_LDI_PM_NEG,  /* type */
 344          1,                     /* rightshift */
 345          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 346          8,                     /* bitsize */
 347          FALSE,                 /* pc_relative */
 348          0,                     /* bitpos */
 349          complain_overflow_dont, /* complain_on_overflow */
 350          bfd_elf_generic_reloc, /* special_function */
 351          "R_AVR_LO8_LDI_PM_NEG", /* name */
 352          FALSE,                 /* partial_inplace */
 353          0xffff,                /* src_mask */
 354          0xffff,                /* dst_mask */
 355          FALSE),                /* pcrel_offset */
 356   /* A low 8 bit absolute relocation of 24 bit program memory address.
 357      For LDI command.  Will not be changed when linker stubs are needed. */
 358   HOWTO (R_AVR_HI8_LDI_PM_NEG,  /* type */
 359          9,                     /* rightshift */
 360          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 361          8,                     /* bitsize */
 362          FALSE,                 /* pc_relative */
 363          0,                     /* bitpos */
 364          complain_overflow_dont, /* complain_on_overflow */
 365          bfd_elf_generic_reloc, /* special_function */
 366          "R_AVR_HI8_LDI_PM_NEG", /* name */
 367          FALSE,                 /* partial_inplace */
 368          0xffff,                /* src_mask */
 369          0xffff,                /* dst_mask */
 370          FALSE),                /* pcrel_offset */
 371   /* A low 8 bit absolute relocation of 24 bit program memory address.
 372      For LDI command.  Will not be changed when linker stubs are needed. */
 373   HOWTO (R_AVR_HH8_LDI_PM_NEG,  /* type */
 374          17,                    /* rightshift */
 375          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 376          8,                     /* bitsize */
 377          FALSE,                 /* pc_relative */
 378          0,                     /* bitpos */
 379          complain_overflow_dont, /* complain_on_overflow */
 380          bfd_elf_generic_reloc, /* special_function */
 381          "R_AVR_HH8_LDI_PM_NEG", /* name */
 382          FALSE,                 /* partial_inplace */
 383          0xffff,                /* src_mask */
 384          0xffff,                /* dst_mask */
 385          FALSE),                /* pcrel_offset */
 386   /* Relocation for CALL command in ATmega.  */
 387   HOWTO (R_AVR_CALL,            /* type */
 388          1,                     /* rightshift */
 389          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 390          23,                    /* bitsize */
 391          FALSE,                 /* pc_relative */
 392          0,                     /* bitpos */
 393          complain_overflow_dont,/* complain_on_overflow */
 394          bfd_elf_generic_reloc, /* special_function */
 395          "R_AVR_CALL",          /* name */
 396          FALSE,                 /* partial_inplace */
 397          0xffffffff,            /* src_mask */
 398          0xffffffff,            /* dst_mask */
 399          FALSE),                        /* pcrel_offset */
 400   /* A 16 bit absolute relocation of 16 bit address.
 401      For LDI command.  */
 402   HOWTO (R_AVR_LDI,             /* type */
 403          0,                     /* rightshift */
 404          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 405          16,                    /* bitsize */
 406          FALSE,                 /* pc_relative */
 407          0,                     /* bitpos */
 408          complain_overflow_dont,/* complain_on_overflow */
 409          bfd_elf_generic_reloc, /* special_function */
 410          "R_AVR_LDI",           /* name */
 411          FALSE,                 /* partial_inplace */
 412          0xffff,                /* src_mask */
 413          0xffff,                /* dst_mask */
 414          FALSE),                /* pcrel_offset */
 415   /* A 6 bit absolute relocation of 6 bit offset.
 416      For ldd/sdd command.  */
 417   HOWTO (R_AVR_6,               /* type */
 418          0,                     /* rightshift */
 419          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 420          6,                     /* bitsize */
 421          FALSE,                 /* pc_relative */
 422          0,                     /* bitpos */
 423          complain_overflow_dont,/* complain_on_overflow */
 424          bfd_elf_generic_reloc, /* special_function */
 425          "R_AVR_6",             /* name */
 426          FALSE,                 /* partial_inplace */
 427          0xffff,                /* src_mask */
 428          0xffff,                /* dst_mask */
 429          FALSE),                /* pcrel_offset */
 430   /* A 6 bit absolute relocation of 6 bit offset.
 431      For sbiw/adiw command.  */
 432   HOWTO (R_AVR_6_ADIW,          /* type */
 433          0,                     /* rightshift */
 434          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 435          6,                     /* bitsize */
 436          FALSE,                 /* pc_relative */
 437          0,                     /* bitpos */
 438          complain_overflow_dont,/* complain_on_overflow */
 439          bfd_elf_generic_reloc, /* special_function */
 440          "R_AVR_6_ADIW",        /* name */
 441          FALSE,                 /* partial_inplace */
 442          0xffff,                /* src_mask */
 443          0xffff,                /* dst_mask */
 444          FALSE),                /* pcrel_offset */
 445   /* Most significant 8 bit value of a 32 bit link-time constant.  */
 446   HOWTO (R_AVR_MS8_LDI,         /* type */
 447          24,                    /* rightshift */
 448          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 449          8,                     /* bitsize */
 450          FALSE,                 /* pc_relative */
 451          0,                     /* bitpos */
 452          complain_overflow_dont, /* complain_on_overflow */
 453          bfd_elf_generic_reloc, /* special_function */
 454          "R_AVR_MS8_LDI",       /* name */
 455          FALSE,                 /* partial_inplace */
 456          0xffff,                /* src_mask */
 457          0xffff,                /* dst_mask */
 458          FALSE),                /* pcrel_offset */
 459   /* Negative most significant 8 bit value of a 32 bit link-time constant.  */
 460   HOWTO (R_AVR_MS8_LDI_NEG,     /* type */
 461          24,                    /* rightshift */
 462          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 463          8,                     /* bitsize */
 464          FALSE,                 /* pc_relative */
 465          0,                     /* bitpos */
 466          complain_overflow_dont, /* complain_on_overflow */
 467          bfd_elf_generic_reloc, /* special_function */
 468          "R_AVR_MS8_LDI_NEG",   /* name */
 469          FALSE,                 /* partial_inplace */
 470          0xffff,                /* src_mask */
 471          0xffff,                /* dst_mask */
 472          FALSE),                /* pcrel_offset */
 473   /* A low 8 bit absolute relocation of 24 bit program memory address.
 474      For LDI command.  Will be changed when linker stubs are needed. */
 475   HOWTO (R_AVR_LO8_LDI_GS,      /* type */
 476          1,                     /* rightshift */
 477          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 478          8,                     /* bitsize */
 479          FALSE,                 /* pc_relative */
 480          0,                     /* bitpos */
 481          complain_overflow_dont, /* complain_on_overflow */
 482          bfd_elf_generic_reloc, /* special_function */
 483          "R_AVR_LO8_LDI_GS",    /* name */
 484          FALSE,                 /* partial_inplace */
 485          0xffff,                /* src_mask */
 486          0xffff,                /* dst_mask */
 487          FALSE),                /* pcrel_offset */
 488   /* A low 8 bit absolute relocation of 24 bit program memory address.
 489      For LDI command.  Will be changed when linker stubs are needed. */
 490   HOWTO (R_AVR_HI8_LDI_GS,      /* type */
 491          9,                     /* rightshift */
 492          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 493          8,                     /* bitsize */
 494          FALSE,                 /* pc_relative */
 495          0,                     /* bitpos */
 496          complain_overflow_dont, /* complain_on_overflow */
 497          bfd_elf_generic_reloc, /* special_function */
 498          "R_AVR_HI8_LDI_GS",    /* name */
 499          FALSE,                 /* partial_inplace */
 500          0xffff,                /* src_mask */
 501          0xffff,                /* dst_mask */
 502          FALSE)                 /* pcrel_offset */
 503 };
 504
 505 /* Map BFD reloc types to AVR ELF reloc types.  */
 506
 507 struct avr_reloc_map
 508 {
 509   bfd_reloc_code_real_type bfd_reloc_val;
 510   unsigned int elf_reloc_val;
 511 };
 512
 513 static const struct avr_reloc_map avr_reloc_map[] =
 514 {
 515   { BFD_RELOC_NONE,                 R_AVR_NONE },
 516   { BFD_RELOC_32,                   R_AVR_32 },
 517   { BFD_RELOC_AVR_7_PCREL,          R_AVR_7_PCREL },
 518   { BFD_RELOC_AVR_13_PCREL,         R_AVR_13_PCREL },
 519   { BFD_RELOC_16,                   R_AVR_16 },
 520   { BFD_RELOC_AVR_16_PM,            R_AVR_16_PM },
 521   { BFD_RELOC_AVR_LO8_LDI,          R_AVR_LO8_LDI},
 522   { BFD_RELOC_AVR_HI8_LDI,          R_AVR_HI8_LDI },
 523   { BFD_RELOC_AVR_HH8_LDI,          R_AVR_HH8_LDI },
 524   { BFD_RELOC_AVR_MS8_LDI,          R_AVR_MS8_LDI },
 525   { BFD_RELOC_AVR_LO8_LDI_NEG,      R_AVR_LO8_LDI_NEG },
 526   { BFD_RELOC_AVR_HI8_LDI_NEG,      R_AVR_HI8_LDI_NEG },
 527   { BFD_RELOC_AVR_HH8_LDI_NEG,      R_AVR_HH8_LDI_NEG },
 528   { BFD_RELOC_AVR_MS8_LDI_NEG,      R_AVR_MS8_LDI_NEG },
 529   { BFD_RELOC_AVR_LO8_LDI_PM,       R_AVR_LO8_LDI_PM },
 530   { BFD_RELOC_AVR_LO8_LDI_GS,       R_AVR_LO8_LDI_GS },
 531   { BFD_RELOC_AVR_HI8_LDI_PM,       R_AVR_HI8_LDI_PM },
 532   { BFD_RELOC_AVR_HI8_LDI_GS,       R_AVR_HI8_LDI_GS },
 533   { BFD_RELOC_AVR_HH8_LDI_PM,       R_AVR_HH8_LDI_PM },
 534   { BFD_RELOC_AVR_LO8_LDI_PM_NEG,   R_AVR_LO8_LDI_PM_NEG },
 535   { BFD_RELOC_AVR_HI8_LDI_PM_NEG,   R_AVR_HI8_LDI_PM_NEG },
 536   { BFD_RELOC_AVR_HH8_LDI_PM_NEG,   R_AVR_HH8_LDI_PM_NEG },
 537   { BFD_RELOC_AVR_CALL,             R_AVR_CALL },
 538   { BFD_RELOC_AVR_LDI,              R_AVR_LDI  },
 539   { BFD_RELOC_AVR_6,                R_AVR_6    },
 540   { BFD_RELOC_AVR_6_ADIW,           R_AVR_6_ADIW }
 541 };
 542
 543 /* Meant to be filled one day with the wrap around address for the
 544    specific device.  I.e. should get the value 0x4000 for 16k devices,
 545    0x8000 for 32k devices and so on.
 546
 547    We initialize it here with a value of 0x1000000 resulting in
 548    that we will never suggest a wrap-around jump during relaxation.
 549    The logic of the source code later on assumes that in
 550    avr_pc_wrap_around one single bit is set.  */
 551 static bfd_vma avr_pc_wrap_around = 0x10000000;
 552
 553 /* If this variable holds a value different from zero, the linker relaxation
 554    machine will try to optimize call/ret sequences by a single jump
 555    instruction. This option could be switched off by a linker switch.  */
 556 static int avr_replace_call_ret_sequences = 1;
 557 \f
 558 /* Initialize an entry in the stub hash table.  */
 559
 560 static struct bfd_hash_entry *
 561 stub_hash_newfunc (struct bfd_hash_entry *entry,
 562                    struct bfd_hash_table *table,
 563                    const char *string)
 564 {
 565   /* Allocate the structure if it has not already been allocated by a
 566      subclass.  */
 567   if (entry == NULL)
 568     {
 569       entry = bfd_hash_allocate (table,
 570                                  sizeof (struct elf32_avr_stub_hash_entry));
 571       if (entry == NULL)
 572         return entry;
 573     }
 574
 575   /* Call the allocation method of the superclass.  */
 576   entry = bfd_hash_newfunc (entry, table, string);
 577   if (entry != NULL)
 578     {
 579       struct elf32_avr_stub_hash_entry *hsh;
 580
 581       /* Initialize the local fields.  */
 582       hsh = avr_stub_hash_entry (entry);
 583       hsh->stub_offset = 0;
 584       hsh->target_value = 0;
 585     }
 586
 587   return entry;
 588 }
 589
 590 /* Create the derived linker hash table.  The AVR ELF port uses the derived
 591    hash table to keep information specific to the AVR ELF linker (without
 592    using static variables).  */
 593
 594 static struct bfd_link_hash_table *
 595 elf32_avr_link_hash_table_create (bfd *abfd)
 596 {
 597   struct elf32_avr_link_hash_table *htab;
 598   bfd_size_type amt = sizeof (*htab);
 599
 600   htab = bfd_malloc (amt);
 601   if (htab == NULL)
 602     return NULL;
 603
 604   if (!_bfd_elf_link_hash_table_init (&htab->etab, abfd,
 605                                       _bfd_elf_link_hash_newfunc,
 606                                       sizeof (struct elf_link_hash_entry)))
 607     {
 608       free (htab);
 609       return NULL;
 610     }
 611
 612   /* Init the stub hash table too.  */
 613   if (!bfd_hash_table_init (&htab->bstab, stub_hash_newfunc,
 614                             sizeof (struct elf32_avr_stub_hash_entry)))
 615     return NULL;
 616
 617   htab->stub_bfd = NULL;
 618   htab->stub_sec = NULL;
 619
 620   /* Initialize the address mapping table.  */
 621   htab->amt_stub_offsets = NULL;
 622   htab->amt_destination_addr = NULL;
 623   htab->amt_entry_cnt = 0;
 624   htab->amt_max_entry_cnt = 0;
 625
 626   return &htab->etab.root;
 627 }
 628
 629 /* Free the derived linker hash table.  */
 630
 631 static void
 632 elf32_avr_link_hash_table_free (struct bfd_link_hash_table *btab)
 633 {
 634   struct elf32_avr_link_hash_table *htab
 635     = (struct elf32_avr_link_hash_table *) btab;
 636
 637   /* Free the address mapping table.  */
 638   if (htab->amt_stub_offsets != NULL)
 639     free (htab->amt_stub_offsets);
 640   if (htab->amt_destination_addr != NULL)
 641     free (htab->amt_destination_addr);
 642
 643   bfd_hash_table_free (&htab->bstab);
 644   _bfd_generic_link_hash_table_free (btab);
 645 }
 646
 647 /* Calculates the effective distance of a pc relative jump/call.  */
 648
 649 static int
 650 avr_relative_distance_considering_wrap_around (unsigned int distance)
 651 {
 652   unsigned int wrap_around_mask = avr_pc_wrap_around - 1;
 653   int dist_with_wrap_around = distance & wrap_around_mask;
 654
 655   if (dist_with_wrap_around > ((int) (avr_pc_wrap_around >> 1)))
 656     dist_with_wrap_around -= avr_pc_wrap_around;
 657
 658   return dist_with_wrap_around;
 659 }
 660
 661
 662 static reloc_howto_type *
 663 bfd_elf32_bfd_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
 664                                  bfd_reloc_code_real_type code)
 665 {
 666   unsigned int i;
 667
 668   for (i = 0;
 669        i < sizeof (avr_reloc_map) / sizeof (struct avr_reloc_map);
 670        i++)
 671     if (avr_reloc_map[i].bfd_reloc_val == code)
 672       return &elf_avr_howto_table[avr_reloc_map[i].elf_reloc_val];
 673
 674   return NULL;
 675 }
 676
 677 /* Set the howto pointer for an AVR ELF reloc.  */
 678
 679 static void
 680 avr_info_to_howto_rela (bfd *abfd ATTRIBUTE_UNUSED,
 681                         arelent *cache_ptr,
 682                         Elf_Internal_Rela *dst)
 683 {
 684   unsigned int r_type;
 685
 686   r_type = ELF32_R_TYPE (dst->r_info);
 687   BFD_ASSERT (r_type < (unsigned int) R_AVR_max);
 688   cache_ptr->howto = &elf_avr_howto_table[r_type];
 689 }
 690
 691 static asection *
 692 elf32_avr_gc_mark_hook (asection *sec,
 693                         struct bfd_link_info *info ATTRIBUTE_UNUSED,
 694                         Elf_Internal_Rela *rel,
 695                         struct elf_link_hash_entry *h,
 696                         Elf_Internal_Sym *sym)
 697 {
 698   if (h != NULL)
 699     {
 700       switch (ELF32_R_TYPE (rel->r_info))
 701         {
 702         default:
 703           switch (h->root.type)
 704             {
 705             case bfd_link_hash_defined:
 706             case bfd_link_hash_defweak:
 707               return h->root.u.def.section;
 708
 709             case bfd_link_hash_common:
 710               return h->root.u.c.p->section;
 711
 712             default:
 713               break;
 714             }
 715         }
 716     }
 717   else
 718     return bfd_section_from_elf_index (sec->owner, sym->st_shndx);
 719
 720   return NULL;
 721 }
 722
 723 static bfd_boolean
 724 elf32_avr_gc_sweep_hook (bfd *abfd ATTRIBUTE_UNUSED,
 725                          struct bfd_link_info *info ATTRIBUTE_UNUSED,
 726                          asection *sec ATTRIBUTE_UNUSED,
 727                          const Elf_Internal_Rela *relocs ATTRIBUTE_UNUSED)
 728 {
 729   /* We don't use got and plt entries for avr.  */
 730   return TRUE;
 731 }
 732
 733 /* Look through the relocs for a section during the first phase.
 734    Since we don't do .gots or .plts, we just need to consider the
 735    virtual table relocs for gc.  */
 736
 737 static bfd_boolean
 738 elf32_avr_check_relocs (bfd *abfd,
 739                         struct bfd_link_info *info,
 740                         asection *sec,
 741                         const Elf_Internal_Rela *relocs)
 742 {
 743   Elf_Internal_Shdr *symtab_hdr;
 744   struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
 745   const Elf_Internal_Rela *rel;
 746   const Elf_Internal_Rela *rel_end;
 747
 748   if (info->relocatable)
 749     return TRUE;
 750
 751   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
 752   sym_hashes = elf_sym_hashes (abfd);
 753   sym_hashes_end = sym_hashes + symtab_hdr->sh_size / sizeof (Elf32_External_Sym);
 754   if (!elf_bad_symtab (abfd))
 755     sym_hashes_end -= symtab_hdr->sh_info;
 756
 757   rel_end = relocs + sec->reloc_count;
 758   for (rel = relocs; rel < rel_end; rel++)
 759     {
 760       struct elf_link_hash_entry *h;
 761       unsigned long r_symndx;
 762
 763       r_symndx = ELF32_R_SYM (rel->r_info);
 764       if (r_symndx < symtab_hdr->sh_info)
 765         h = NULL;
 766       else
 767         {
 768           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
 769           while (h->root.type == bfd_link_hash_indirect
 770                  || h->root.type == bfd_link_hash_warning)
 771             h = (struct elf_link_hash_entry *) h->root.u.i.link;
 772         }
 773     }
 774
 775   return TRUE;
 776 }
 777
 778 static bfd_boolean
 779 avr_stub_is_required_for_16_bit_reloc (bfd_vma relocation)
 780 {
 781   return (relocation >= 0x020000);
 782 }
 783
 784 /* Returns the address of the corresponding stub if there is one.
 785    Returns otherwise an address above 0x020000.  This function
 786    could also be used, if there is no knowledge on the section where
 787    the destination is found.  */
 788
 789 static bfd_vma
 790 avr_get_stub_addr (bfd_vma srel,
 791                    struct elf32_avr_link_hash_table *htab)
 792 {
 793   unsigned int index;
 794   bfd_vma stub_sec_addr =
 795               (htab->stub_sec->output_section->vma +
 796                htab->stub_sec->output_offset);
 797
 798   for (index = 0; index < htab->amt_max_entry_cnt; index ++)
 799     if (htab->amt_destination_addr[index] == srel)
 800       return htab->amt_stub_offsets[index] + stub_sec_addr;
 801
 802   /* Return an address that could not be reached by 16 bit relocs.  */
 803   return 0x020000;
 804 }
 805
 806 /* Perform a single relocation.  By default we use the standard BFD
 807    routines, but a few relocs, we have to do them ourselves.  */
 808
 809 static bfd_reloc_status_type
 810 avr_final_link_relocate (reloc_howto_type *                 howto,
 811                          bfd *                              input_bfd,
 812                          asection *                         input_section,
 813                          bfd_byte *                         contents,
 814                          Elf_Internal_Rela *                rel,
 815                          bfd_vma                            relocation,
 816                          struct elf32_avr_link_hash_table * htab)
 817 {
 818   bfd_reloc_status_type r = bfd_reloc_ok;
 819   bfd_vma               x;
 820   bfd_signed_vma        srel;
 821   bfd_signed_vma        reloc_addr;
 822   bfd_boolean           use_stubs = FALSE;
 823   /* Usually is 0, unless we are generating code for a bootloader.  */
 824   bfd_signed_vma        base_addr = htab->vector_base;
 825
 826   /* Absolute addr of the reloc in the final excecutable.  */
 827   reloc_addr = rel->r_offset + input_section->output_section->vma
 828                + input_section->output_offset;
 829
 830   switch (howto->type)
 831     {
 832     case R_AVR_7_PCREL:
 833       contents += rel->r_offset;
 834       srel = (bfd_signed_vma) relocation;
 835       srel += rel->r_addend;
 836       srel -= rel->r_offset;
 837       srel -= 2;        /* Branch instructions add 2 to the PC...  */
 838       srel -= (input_section->output_section->vma +
 839                input_section->output_offset);
 840
 841       if (srel & 1)
 842         return bfd_reloc_outofrange;
 843       if (srel > ((1 << 7) - 1) || (srel < - (1 << 7)))
 844         return bfd_reloc_overflow;
 845       x = bfd_get_16 (input_bfd, contents);
 846       x = (x & 0xfc07) | (((srel >> 1) << 3) & 0x3f8);
 847       bfd_put_16 (input_bfd, x, contents);
 848       break;
 849
 850     case R_AVR_13_PCREL:
 851       contents   += rel->r_offset;
 852       srel = (bfd_signed_vma) relocation;
 853       srel += rel->r_addend;
 854       srel -= rel->r_offset;
 855       srel -= 2;        /* Branch instructions add 2 to the PC...  */
 856       srel -= (input_section->output_section->vma +
 857                input_section->output_offset);
 858
 859       if (srel & 1)
 860         return bfd_reloc_outofrange;
 861
 862       srel = avr_relative_distance_considering_wrap_around (srel);
 863
 864       /* AVR addresses commands as words.  */
 865       srel >>= 1;
 866
 867       /* Check for overflow.  */
 868       if (srel < -2048 || srel > 2047)
 869         {
 870           /* Relative distance is too large.  */
 871
 872           /* Always apply WRAPAROUND for avr2 and avr4.  */
 873           switch (bfd_get_mach (input_bfd))
 874             {
 875             case bfd_mach_avr2:
 876             case bfd_mach_avr4:
 877               break;
 878
 879             default:
 880               return bfd_reloc_overflow;
 881             }
 882         }
 883
 884       x = bfd_get_16 (input_bfd, contents);
 885       x = (x & 0xf000) | (srel & 0xfff);
 886       bfd_put_16 (input_bfd, x, contents);
 887       break;
 888
 889     case R_AVR_LO8_LDI:
 890       contents += rel->r_offset;
 891       srel = (bfd_signed_vma) relocation + rel->r_addend;
 892       x = bfd_get_16 (input_bfd, contents);
 893       x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
 894       bfd_put_16 (input_bfd, x, contents);
 895       break;
 896
 897     case R_AVR_LDI:
 898       contents += rel->r_offset;
 899       srel = (bfd_signed_vma) relocation + rel->r_addend;
 900       if (((srel > 0) && (srel & 0xffff) > 255)
 901           || ((srel < 0) && ((-srel) & 0xffff) > 128))
 902         /* Remove offset for data/eeprom section.  */
 903         return bfd_reloc_overflow;
 904
 905       x = bfd_get_16 (input_bfd, contents);
 906       x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
 907       bfd_put_16 (input_bfd, x, contents);
 908       break;
 909
 910     case R_AVR_6:
 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 & 0xd3f8) | ((srel & 7) | ((srel & (3 << 3)) << 7)
 918                        | ((srel & (1 << 5)) << 8));
 919       bfd_put_16 (input_bfd, x, contents);
 920       break;
 921
 922     case R_AVR_6_ADIW:
 923       contents += rel->r_offset;
 924       srel = (bfd_signed_vma) relocation + rel->r_addend;
 925       if (((srel & 0xffff) > 63) || (srel < 0))
 926         /* Remove offset for data/eeprom section.  */
 927         return bfd_reloc_overflow;
 928       x = bfd_get_16 (input_bfd, contents);
 929       x = (x & 0xff30) | (srel & 0xf) | ((srel & 0x30) << 2);
 930       bfd_put_16 (input_bfd, x, contents);
 931       break;
 932
 933     case R_AVR_HI8_LDI:
 934       contents += rel->r_offset;
 935       srel = (bfd_signed_vma) relocation + rel->r_addend;
 936       srel = (srel >> 8) & 0xff;
 937       x = bfd_get_16 (input_bfd, contents);
 938       x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
 939       bfd_put_16 (input_bfd, x, contents);
 940       break;
 941
 942     case R_AVR_HH8_LDI:
 943       contents += rel->r_offset;
 944       srel = (bfd_signed_vma) relocation + rel->r_addend;
 945       srel = (srel >> 16) & 0xff;
 946       x = bfd_get_16 (input_bfd, contents);
 947       x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
 948       bfd_put_16 (input_bfd, x, contents);
 949       break;
 950
 951     case R_AVR_MS8_LDI:
 952       contents += rel->r_offset;
 953       srel = (bfd_signed_vma) relocation + rel->r_addend;
 954       srel = (srel >> 24) & 0xff;
 955       x = bfd_get_16 (input_bfd, contents);
 956       x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
 957       bfd_put_16 (input_bfd, x, contents);
 958       break;
 959
 960     case R_AVR_LO8_LDI_NEG:
 961       contents += rel->r_offset;
 962       srel = (bfd_signed_vma) relocation + rel->r_addend;
 963       srel = -srel;
 964       x = bfd_get_16 (input_bfd, contents);
 965       x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
 966       bfd_put_16 (input_bfd, x, contents);
 967       break;
 968
 969     case R_AVR_HI8_LDI_NEG:
 970       contents += rel->r_offset;
 971       srel = (bfd_signed_vma) relocation + rel->r_addend;
 972       srel = -srel;
 973       srel = (srel >> 8) & 0xff;
 974       x = bfd_get_16 (input_bfd, contents);
 975       x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
 976       bfd_put_16 (input_bfd, x, contents);
 977       break;
 978
 979     case R_AVR_HH8_LDI_NEG:
 980       contents += rel->r_offset;
 981       srel = (bfd_signed_vma) relocation + rel->r_addend;
 982       srel = -srel;
 983       srel = (srel >> 16) & 0xff;
 984       x = bfd_get_16 (input_bfd, contents);
 985       x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
 986       bfd_put_16 (input_bfd, x, contents);
 987       break;
 988
 989     case R_AVR_MS8_LDI_NEG:
 990       contents += rel->r_offset;
 991       srel = (bfd_signed_vma) relocation + rel->r_addend;
 992       srel = -srel;
 993       srel = (srel >> 24) & 0xff;
 994       x = bfd_get_16 (input_bfd, contents);
 995       x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
 996       bfd_put_16 (input_bfd, x, contents);
 997       break;
 998
 999     case R_AVR_LO8_LDI_GS:
1000       use_stubs = (!htab->no_stubs);
1001       /* Fall through.  */
1002     case R_AVR_LO8_LDI_PM:
1003       contents += rel->r_offset;
1004       srel = (bfd_signed_vma) relocation + rel->r_addend;
1005
1006       if (use_stubs
1007           && avr_stub_is_required_for_16_bit_reloc (srel - base_addr))
1008         {
1009           bfd_vma old_srel = srel;
1010
1011           /* We need to use the address of the stub instead.  */
1012           srel = avr_get_stub_addr (srel, htab);
1013           if (debug_stubs)
1014             printf ("LD: Using jump stub (at 0x%x) with destination 0x%x for "
1015                     "reloc at address 0x%x.\n",
1016                     (unsigned int) srel,
1017                     (unsigned int) old_srel,
1018                     (unsigned int) reloc_addr);
1019
1020           if (avr_stub_is_required_for_16_bit_reloc (srel - base_addr))
1021             return bfd_reloc_outofrange;
1022         }
1023
1024       if (srel & 1)
1025         return bfd_reloc_outofrange;
1026       srel = srel >> 1;
1027       x = bfd_get_16 (input_bfd, contents);
1028       x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
1029       bfd_put_16 (input_bfd, x, contents);
1030       break;
1031
1032     case R_AVR_HI8_LDI_GS:
1033       use_stubs = (!htab->no_stubs);
1034       /* Fall through.  */
1035     case R_AVR_HI8_LDI_PM:
1036       contents += rel->r_offset;
1037       srel = (bfd_signed_vma) relocation + rel->r_addend;
1038
1039       if (use_stubs
1040           && avr_stub_is_required_for_16_bit_reloc (srel - base_addr))
1041         {
1042           bfd_vma old_srel = srel;
1043
1044           /* We need to use the address of the stub instead.  */
1045           srel = avr_get_stub_addr (srel, htab);
1046           if (debug_stubs)
1047             printf ("LD: Using jump stub (at 0x%x) with destination 0x%x for "
1048                     "reloc at address 0x%x.\n",
1049                     (unsigned int) srel,
1050                     (unsigned int) old_srel,
1051                     (unsigned int) reloc_addr);
1052
1053           if (avr_stub_is_required_for_16_bit_reloc (srel - base_addr))
1054             return bfd_reloc_outofrange;
1055         }
1056
1057       if (srel & 1)
1058         return bfd_reloc_outofrange;
1059       srel = srel >> 1;
1060       srel = (srel >> 8) & 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_HH8_LDI_PM:
1067       contents += rel->r_offset;
1068       srel = (bfd_signed_vma) relocation + rel->r_addend;
1069       if (srel & 1)
1070         return bfd_reloc_outofrange;
1071       srel = srel >> 1;
1072       srel = (srel >> 16) & 0xff;
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_LO8_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       x = bfd_get_16 (input_bfd, contents);
1086       x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
1087       bfd_put_16 (input_bfd, x, contents);
1088       break;
1089
1090     case R_AVR_HI8_LDI_PM_NEG:
1091       contents += rel->r_offset;
1092       srel = (bfd_signed_vma) relocation + rel->r_addend;
1093       srel = -srel;
1094       if (srel & 1)
1095         return bfd_reloc_outofrange;
1096       srel = srel >> 1;
1097       srel = (srel >> 8) & 0xff;
1098       x = bfd_get_16 (input_bfd, contents);
1099       x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
1100       bfd_put_16 (input_bfd, x, contents);
1101       break;
1102
1103     case R_AVR_HH8_LDI_PM_NEG:
1104       contents += rel->r_offset;
1105       srel = (bfd_signed_vma) relocation + rel->r_addend;
1106       srel = -srel;
1107       if (srel & 1)
1108         return bfd_reloc_outofrange;
1109       srel = srel >> 1;
1110       srel = (srel >> 16) & 0xff;
1111       x = bfd_get_16 (input_bfd, contents);
1112       x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
1113       bfd_put_16 (input_bfd, x, contents);
1114       break;
1115
1116     case R_AVR_CALL:
1117       contents += rel->r_offset;
1118       srel = (bfd_signed_vma) relocation + rel->r_addend;
1119       if (srel & 1)
1120         return bfd_reloc_outofrange;
1121       srel = srel >> 1;
1122       x = bfd_get_16 (input_bfd, contents);
1123       x |= ((srel & 0x10000) | ((srel << 3) & 0x1f00000)) >> 16;
1124       bfd_put_16 (input_bfd, x, contents);
1125       bfd_put_16 (input_bfd, (bfd_vma) srel & 0xffff, contents+2);
1126       break;
1127
1128     case R_AVR_16_PM:
1129       use_stubs = (!htab->no_stubs);
1130       contents += rel->r_offset;
1131       srel = (bfd_signed_vma) relocation + rel->r_addend;
1132
1133       if (use_stubs
1134           && avr_stub_is_required_for_16_bit_reloc (srel - base_addr))
1135         {
1136           bfd_vma old_srel = srel;
1137
1138           /* We need to use the address of the stub instead.  */
1139           srel = avr_get_stub_addr (srel,htab);
1140           if (debug_stubs)
1141             printf ("LD: Using jump stub (at 0x%x) with destination 0x%x for "
1142                     "reloc at address 0x%x.\n",
1143                     (unsigned int) srel,
1144                     (unsigned int) old_srel,
1145                     (unsigned int) reloc_addr);
1146
1147           if (avr_stub_is_required_for_16_bit_reloc (srel - base_addr))
1148             return bfd_reloc_outofrange;
1149         }
1150
1151       if (srel & 1)
1152         return bfd_reloc_outofrange;
1153       srel = srel >> 1;
1154       bfd_put_16 (input_bfd, (bfd_vma) srel &0x00ffff, contents);
1155       break;
1156
1157     default:
1158       r = _bfd_final_link_relocate (howto, input_bfd, input_section,
1159                                     contents, rel->r_offset,
1160                                     relocation, rel->r_addend);
1161     }
1162
1163   return r;
1164 }
1165
1166 /* Relocate an AVR ELF section.  */
1167
1168 static bfd_boolean
1169 elf32_avr_relocate_section (bfd *output_bfd ATTRIBUTE_UNUSED,
1170                             struct bfd_link_info *info,
1171                             bfd *input_bfd,
1172                             asection *input_section,
1173                             bfd_byte *contents,
1174                             Elf_Internal_Rela *relocs,
1175                             Elf_Internal_Sym *local_syms,
1176                             asection **local_sections)
1177 {
1178   Elf_Internal_Shdr *           symtab_hdr;
1179   struct elf_link_hash_entry ** sym_hashes;
1180   Elf_Internal_Rela *           rel;
1181   Elf_Internal_Rela *           relend;
1182   struct elf32_avr_link_hash_table * htab = avr_link_hash_table (info);
1183
1184   if (info->relocatable)
1185     return TRUE;
1186
1187   symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
1188   sym_hashes = elf_sym_hashes (input_bfd);
1189   relend     = relocs + input_section->reloc_count;
1190
1191   for (rel = relocs; rel < relend; rel ++)
1192     {
1193       reloc_howto_type *           howto;
1194       unsigned long                r_symndx;
1195       Elf_Internal_Sym *           sym;
1196       asection *                   sec;
1197       struct elf_link_hash_entry * h;
1198       bfd_vma                      relocation;
1199       bfd_reloc_status_type        r;
1200       const char *                 name;
1201       int                          r_type;
1202
1203       /* This is a final link.  */
1204       r_type = ELF32_R_TYPE (rel->r_info);
1205       r_symndx = ELF32_R_SYM (rel->r_info);
1206       howto  = elf_avr_howto_table + ELF32_R_TYPE (rel->r_info);
1207       h      = NULL;
1208       sym    = NULL;
1209       sec    = NULL;
1210
1211       if (r_symndx < symtab_hdr->sh_info)
1212         {
1213           sym = local_syms + r_symndx;
1214           sec = local_sections [r_symndx];
1215           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
1216
1217           name = bfd_elf_string_from_elf_section
1218             (input_bfd, symtab_hdr->sh_link, sym->st_name);
1219           name = (name == NULL) ? bfd_section_name (input_bfd, sec) : name;
1220         }
1221       else
1222         {
1223           bfd_boolean unresolved_reloc, warned;
1224
1225           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
1226                                    r_symndx, symtab_hdr, sym_hashes,
1227                                    h, sec, relocation,
1228                                    unresolved_reloc, warned);
1229
1230           name = h->root.root.string;
1231         }
1232
1233       r = avr_final_link_relocate (howto, input_bfd, input_section,
1234                                    contents, rel, relocation, htab);
1235
1236       if (r != bfd_reloc_ok)
1237         {
1238           const char * msg = (const char *) NULL;
1239
1240           switch (r)
1241             {
1242             case bfd_reloc_overflow:
1243               r = info->callbacks->reloc_overflow
1244                 (info, (h ? &h->root : NULL),
1245                  name, howto->name, (bfd_vma) 0,
1246                  input_bfd, input_section, rel->r_offset);
1247               break;
1248
1249             case bfd_reloc_undefined:
1250               r = info->callbacks->undefined_symbol
1251                 (info, name, input_bfd, input_section, rel->r_offset, TRUE);
1252               break;
1253
1254             case bfd_reloc_outofrange:
1255               msg = _("internal error: out of range error");
1256               break;
1257
1258             case bfd_reloc_notsupported:
1259               msg = _("internal error: unsupported relocation error");
1260               break;
1261
1262             case bfd_reloc_dangerous:
1263               msg = _("internal error: dangerous relocation");
1264               break;
1265
1266             default:
1267               msg = _("internal error: unknown error");
1268               break;
1269             }
1270
1271           if (msg)
1272             r = info->callbacks->warning
1273               (info, msg, name, input_bfd, input_section, rel->r_offset);
1274
1275           if (! r)
1276             return FALSE;
1277         }
1278     }
1279
1280   return TRUE;
1281 }
1282
1283 /* The final processing done just before writing out a AVR ELF object
1284    file.  This gets the AVR architecture right based on the machine
1285    number.  */
1286
1287 static void
1288 bfd_elf_avr_final_write_processing (bfd *abfd,
1289                                     bfd_boolean linker ATTRIBUTE_UNUSED)
1290 {
1291   unsigned long val;
1292
1293   switch (bfd_get_mach (abfd))
1294     {
1295     default:
1296     case bfd_mach_avr2:
1297       val = E_AVR_MACH_AVR2;
1298       break;
1299
1300     case bfd_mach_avr1:
1301       val = E_AVR_MACH_AVR1;
1302       break;
1303
1304     case bfd_mach_avr3:
1305       val = E_AVR_MACH_AVR3;
1306       break;
1307
1308     case bfd_mach_avr4:
1309       val = E_AVR_MACH_AVR4;
1310       break;
1311
1312     case bfd_mach_avr5:
1313       val = E_AVR_MACH_AVR5;
1314       break;
1315
1316     case bfd_mach_avr6:
1317       val = E_AVR_MACH_AVR6;
1318       break;
1319     }
1320
1321   elf_elfheader (abfd)->e_machine = EM_AVR;
1322   elf_elfheader (abfd)->e_flags &= ~ EF_AVR_MACH;
1323   elf_elfheader (abfd)->e_flags |= val;
1324   elf_elfheader (abfd)->e_flags |= EF_AVR_LINKRELAX_PREPARED;
1325 }
1326
1327 /* Set the right machine number.  */
1328
1329 static bfd_boolean
1330 elf32_avr_object_p (bfd *abfd)
1331 {
1332   unsigned int e_set = bfd_mach_avr2;
1333
1334   if (elf_elfheader (abfd)->e_machine == EM_AVR
1335       || elf_elfheader (abfd)->e_machine == EM_AVR_OLD)
1336     {
1337       int e_mach = elf_elfheader (abfd)->e_flags & EF_AVR_MACH;
1338
1339       switch (e_mach)
1340         {
1341         default:
1342         case E_AVR_MACH_AVR2:
1343           e_set = bfd_mach_avr2;
1344           break;
1345
1346         case E_AVR_MACH_AVR1:
1347           e_set = bfd_mach_avr1;
1348           break;
1349
1350         case E_AVR_MACH_AVR3:
1351           e_set = bfd_mach_avr3;
1352           break;
1353
1354         case E_AVR_MACH_AVR4:
1355           e_set = bfd_mach_avr4;
1356           break;
1357
1358         case E_AVR_MACH_AVR5:
1359           e_set = bfd_mach_avr5;
1360           break;
1361
1362         case E_AVR_MACH_AVR6:
1363           e_set = bfd_mach_avr6;
1364           break;
1365         }
1366     }
1367   return bfd_default_set_arch_mach (abfd, bfd_arch_avr,
1368                                     e_set);
1369 }
1370
1371
1372 /* Delete some bytes from a section while changing the size of an instruction.
1373    The parameter "addr" denotes the section-relative offset pointing just
1374    behind the shrinked instruction. "addr+count" point at the first
1375    byte just behind the original unshrinked instruction.  */
1376
1377 static bfd_boolean
1378 elf32_avr_relax_delete_bytes (bfd *abfd,
1379                               asection *sec,
1380                               bfd_vma addr,
1381                               int count)
1382 {
1383   Elf_Internal_Shdr *symtab_hdr;
1384   unsigned int sec_shndx;
1385   bfd_byte *contents;
1386   Elf_Internal_Rela *irel, *irelend;
1387   Elf_Internal_Rela *irelalign;
1388   Elf_Internal_Sym *isym;
1389   Elf_Internal_Sym *isymbuf = NULL;
1390   Elf_Internal_Sym *isymend;
1391   bfd_vma toaddr;
1392   struct elf_link_hash_entry **sym_hashes;
1393   struct elf_link_hash_entry **end_hashes;
1394   unsigned int symcount;
1395
1396   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1397   sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
1398   contents = elf_section_data (sec)->this_hdr.contents;
1399
1400   /* The deletion must stop at the next ALIGN reloc for an aligment
1401      power larger than the number of bytes we are deleting.  */
1402
1403   irelalign = NULL;
1404   toaddr = sec->size;
1405
1406   irel = elf_section_data (sec)->relocs;
1407   irelend = irel + sec->reloc_count;
1408
1409   /* Actually delete the bytes.  */
1410   if (toaddr - addr - count > 0)
1411     memmove (contents + addr, contents + addr + count,
1412              (size_t) (toaddr - addr - count));
1413   sec->size -= count;
1414
1415   /* Adjust all the reloc addresses.  */
1416   for (irel = elf_section_data (sec)->relocs; irel < irelend; irel++)
1417     {
1418       bfd_vma old_reloc_address;
1419       bfd_vma shrinked_insn_address;
1420
1421       old_reloc_address = (sec->output_section->vma
1422                            + sec->output_offset + irel->r_offset);
1423       shrinked_insn_address = (sec->output_section->vma
1424                               + sec->output_offset + addr - count);
1425
1426       /* Get the new reloc address.  */
1427       if ((irel->r_offset > addr
1428            && irel->r_offset < toaddr))
1429         {
1430           if (debug_relax)
1431             printf ("Relocation at address 0x%x needs to be moved.\n"
1432                     "Old section offset: 0x%x, New section offset: 0x%x \n",
1433                     (unsigned int) old_reloc_address,
1434                     (unsigned int) irel->r_offset,
1435                     (unsigned int) ((irel->r_offset) - count));
1436
1437           irel->r_offset -= count;
1438         }
1439
1440     }
1441
1442    /* The reloc's own addresses are now ok. However, we need to readjust
1443       the reloc's addend, i.e. the reloc's value if two conditions are met:
1444       1.) the reloc is relative to a symbol in this section that
1445           is located in front of the shrinked instruction
1446       2.) symbol plus addend end up behind the shrinked instruction.
1447
1448       The most common case where this happens are relocs relative to
1449       the section-start symbol.
1450
1451       This step needs to be done for all of the sections of the bfd.  */
1452
1453   {
1454     struct bfd_section *isec;
1455
1456     for (isec = abfd->sections; isec; isec = isec->next)
1457      {
1458        bfd_vma symval;
1459        bfd_vma shrinked_insn_address;
1460
1461        shrinked_insn_address = (sec->output_section->vma
1462                                 + sec->output_offset + addr - count);
1463
1464        irelend = elf_section_data (isec)->relocs + isec->reloc_count;
1465        for (irel = elf_section_data (isec)->relocs;
1466             irel < irelend;
1467             irel++)
1468          {
1469            /* Read this BFD's local symbols if we haven't done
1470               so already.  */
1471            if (isymbuf == NULL && symtab_hdr->sh_info != 0)
1472              {
1473                isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
1474                if (isymbuf == NULL)
1475                  isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
1476                                                  symtab_hdr->sh_info, 0,
1477                                                  NULL, NULL, NULL);
1478                if (isymbuf == NULL)
1479                  return FALSE;
1480              }
1481
1482            /* Get the value of the symbol referred to by the reloc.  */
1483            if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
1484              {
1485                /* A local symbol.  */
1486                Elf_Internal_Sym *isym;
1487                asection *sym_sec;
1488
1489                isym = isymbuf + ELF32_R_SYM (irel->r_info);
1490                sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
1491                symval = isym->st_value;
1492                /* If the reloc is absolute, it will not have
1493                   a symbol or section associated with it.  */
1494                if (sym_sec == sec)
1495                  {
1496                    symval += sym_sec->output_section->vma
1497                              + sym_sec->output_offset;
1498
1499                    if (debug_relax)
1500                      printf ("Checking if the relocation's "
1501                              "addend needs corrections.\n"
1502                              "Address of anchor symbol: 0x%x \n"
1503                              "Address of relocation target: 0x%x \n"
1504                              "Address of relaxed insn: 0x%x \n",
1505                              (unsigned int) symval,
1506                              (unsigned int) (symval + irel->r_addend),
1507                              (unsigned int) shrinked_insn_address);
1508
1509                    if (symval <= shrinked_insn_address
1510                        && (symval + irel->r_addend) > shrinked_insn_address)
1511                      {
1512                        irel->r_addend -= count;
1513
1514                        if (debug_relax)
1515                          printf ("Relocation's addend needed to be fixed \n");
1516                      }
1517                  }
1518                /* else...Reference symbol is absolute.  No adjustment needed.  */
1519              }
1520            /* else...Reference symbol is extern.  No need for adjusting
1521               the addend.  */
1522          }
1523      }
1524   }
1525
1526   /* Adjust the local symbols defined in this section.  */
1527   isym = (Elf_Internal_Sym *) symtab_hdr->contents;
1528   isymend = isym + symtab_hdr->sh_info;
1529   for (; isym < isymend; isym++)
1530     {
1531       if (isym->st_shndx == sec_shndx
1532           && isym->st_value > addr
1533           && isym->st_value < toaddr)
1534         isym->st_value -= count;
1535     }
1536
1537   /* Now adjust the global symbols defined in this section.  */
1538   symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
1539               - symtab_hdr->sh_info);
1540   sym_hashes = elf_sym_hashes (abfd);
1541   end_hashes = sym_hashes + symcount;
1542   for (; sym_hashes < end_hashes; sym_hashes++)
1543     {
1544       struct elf_link_hash_entry *sym_hash = *sym_hashes;
1545       if ((sym_hash->root.type == bfd_link_hash_defined
1546            || sym_hash->root.type == bfd_link_hash_defweak)
1547           && sym_hash->root.u.def.section == sec
1548           && sym_hash->root.u.def.value > addr
1549           && sym_hash->root.u.def.value < toaddr)
1550         {
1551           sym_hash->root.u.def.value -= count;
1552         }
1553     }
1554
1555   return TRUE;
1556 }
1557
1558 /* This function handles relaxing for the avr.
1559    Many important relaxing opportunities within functions are already
1560    realized by the compiler itself.
1561    Here we try to replace  call (4 bytes) ->  rcall (2 bytes)
1562    and jump -> rjmp (safes also 2 bytes).
1563    As well we now optimize seqences of
1564      - call/rcall function
1565      - ret
1566    to yield
1567      - jmp/rjmp function
1568      - ret
1569    . In case that within a sequence
1570      - jmp/rjmp label
1571      - ret
1572    the ret could no longer be reached it is optimized away. In order
1573    to check if the ret is no longer needed, it is checked that the ret's address
1574    is not the target of a branch or jump within the same section, it is checked
1575    that there is no skip instruction before the jmp/rjmp and that there
1576    is no local or global label place at the address of the ret.
1577
1578    We refrain from relaxing within sections ".vectors" and
1579    ".jumptables" in order to maintain the position of the instructions.
1580    There, however, we substitute jmp/call by a sequence rjmp,nop/rcall,nop
1581    if possible. (In future one could possibly use the space of the nop
1582    for the first instruction of the irq service function.
1583
1584    The .jumptables sections is meant to be used for a future tablejump variant
1585    for the devices with 3-byte program counter where the table itself
1586    contains 4-byte jump instructions whose relative offset must not
1587    be changed.  */
1588
1589 static bfd_boolean
1590 elf32_avr_relax_section (bfd *abfd,
1591                          asection *sec,
1592                          struct bfd_link_info *link_info,
1593                          bfd_boolean *again)
1594 {
1595   Elf_Internal_Shdr *symtab_hdr;
1596   Elf_Internal_Rela *internal_relocs;
1597   Elf_Internal_Rela *irel, *irelend;
1598   bfd_byte *contents = NULL;
1599   Elf_Internal_Sym *isymbuf = NULL;
1600   static asection *last_input_section = NULL;
1601   static Elf_Internal_Rela *last_reloc = NULL;
1602   struct elf32_avr_link_hash_table *htab;
1603
1604   htab = avr_link_hash_table (link_info);
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
2410   target = hsh->target_value;
2411
2412   /* Make a note of the offset within the stubs for this entry.  */
2413   hsh->stub_offset = htab->stub_sec->size;
2414   loc = htab->stub_sec->contents + hsh->stub_offset;
2415
2416   stub_bfd = htab->stub_sec->owner;
2417
2418   if (debug_stubs)
2419     printf ("Building one Stub. Address: 0x%x, Offset: 0x%x\n",
2420              (unsigned int) target,
2421              (unsigned int) hsh->stub_offset);
2422
2423   /* We now have to add the information on the jump target to the bare
2424      opcode bits already set in jmp_insn.  */
2425
2426   /* Check for the alignment of the address.  */
2427   if (target & 1)
2428      return FALSE;
2429
2430   starget = target >> 1;
2431   jmp_insn |= ((starget & 0x10000) | ((starget << 3) & 0x1f00000)) >> 16;
2432   bfd_put_16 (stub_bfd, jmp_insn, loc);
2433   bfd_put_16 (stub_bfd, (bfd_vma) starget & 0xffff, loc + 2);
2434
2435   htab->stub_sec->size += 4;
2436
2437   /* Now add the entries in the address mapping table if there is still
2438      space left.  */
2439   {
2440     unsigned int nr;
2441
2442     nr = htab->amt_entry_cnt + 1;
2443     if (nr <= htab->amt_max_entry_cnt)
2444       {
2445         htab->amt_entry_cnt = nr;
2446
2447         htab->amt_stub_offsets[nr - 1] = hsh->stub_offset;
2448         htab->amt_destination_addr[nr - 1] = target;
2449       }
2450   }
2451
2452   return TRUE;
2453 }
2454
2455 static bfd_boolean
2456 avr_mark_stub_not_to_be_necessary (struct bfd_hash_entry *bh,
2457                                    void *in_arg)
2458 {
2459   struct elf32_avr_stub_hash_entry *hsh;
2460   struct elf32_avr_link_hash_table *htab;
2461
2462   htab = in_arg;
2463   hsh = avr_stub_hash_entry (bh);
2464   hsh->is_actually_needed = FALSE;
2465
2466   return TRUE;
2467 }
2468
2469 static bfd_boolean
2470 avr_size_one_stub (struct bfd_hash_entry *bh, void *in_arg)
2471 {
2472   struct elf32_avr_stub_hash_entry *hsh;
2473   struct elf32_avr_link_hash_table *htab;
2474   int size;
2475
2476   /* Massage our args to the form they really have.  */
2477   hsh = avr_stub_hash_entry (bh);
2478   htab = in_arg;
2479
2480   if (hsh->is_actually_needed)
2481     size = 4;
2482   else
2483     size = 0;
2484
2485   htab->stub_sec->size += size;
2486   return TRUE;
2487 }
2488
2489 void
2490 elf32_avr_setup_params (struct bfd_link_info *info,
2491                         bfd *avr_stub_bfd,
2492                         asection *avr_stub_section,
2493                         bfd_boolean no_stubs,
2494                         bfd_boolean deb_stubs,
2495                         bfd_boolean deb_relax,
2496                         bfd_vma pc_wrap_around,
2497                         bfd_boolean call_ret_replacement)
2498 {
2499   struct elf32_avr_link_hash_table *htab = avr_link_hash_table(info);
2500
2501   htab->stub_sec = avr_stub_section;
2502   htab->stub_bfd = avr_stub_bfd;
2503   htab->no_stubs = no_stubs;
2504
2505   debug_relax = deb_relax;
2506   debug_stubs = deb_stubs;
2507   avr_pc_wrap_around = pc_wrap_around;
2508   avr_replace_call_ret_sequences = call_ret_replacement;
2509 }
2510
2511
2512 /* Set up various things so that we can make a list of input sections
2513    for each output section included in the link.  Returns -1 on error,
2514    0 when no stubs will be needed, and 1 on success.  It also sets
2515    information on the stubs bfd and the stub section in the info
2516    struct.  */
2517
2518 int
2519 elf32_avr_setup_section_lists (bfd *output_bfd,
2520                                struct bfd_link_info *info)
2521 {
2522   bfd *input_bfd;
2523   unsigned int bfd_count;
2524   int top_id, top_index;
2525   asection *section;
2526   asection **input_list, **list;
2527   bfd_size_type amt;
2528   struct elf32_avr_link_hash_table *htab = avr_link_hash_table(info);
2529
2530   if (htab->no_stubs)
2531     return 0;
2532
2533   /* Count the number of input BFDs and find the top input section id.  */
2534   for (input_bfd = info->input_bfds, bfd_count = 0, top_id = 0;
2535        input_bfd != NULL;
2536        input_bfd = input_bfd->link_next)
2537     {
2538       bfd_count += 1;
2539       for (section = input_bfd->sections;
2540            section != NULL;
2541            section = section->next)
2542         if (top_id < section->id)
2543           top_id = section->id;
2544     }
2545
2546   htab->bfd_count = bfd_count;
2547
2548   /* We can't use output_bfd->section_count here to find the top output
2549      section index as some sections may have been removed, and
2550      strip_excluded_output_sections doesn't renumber the indices.  */
2551   for (section = output_bfd->sections, top_index = 0;
2552        section != NULL;
2553        section = section->next)
2554     if (top_index < section->index)
2555       top_index = section->index;
2556
2557   htab->top_index = top_index;
2558   amt = sizeof (asection *) * (top_index + 1);
2559   input_list = bfd_malloc (amt);
2560   htab->input_list = input_list;
2561   if (input_list == NULL)
2562     return -1;
2563
2564   /* For sections we aren't interested in, mark their entries with a
2565      value we can check later.  */
2566   list = input_list + top_index;
2567   do
2568     *list = bfd_abs_section_ptr;
2569   while (list-- != input_list);
2570
2571   for (section = output_bfd->sections;
2572        section != NULL;
2573        section = section->next)
2574     if ((section->flags & SEC_CODE) != 0)
2575       input_list[section->index] = NULL;
2576
2577   return 1;
2578 }
2579
2580
2581 /* Read in all local syms for all input bfds, and create hash entries
2582    for export stubs if we are building a multi-subspace shared lib.
2583    Returns -1 on error, 0 otherwise.  */
2584
2585 static int
2586 get_local_syms (bfd *input_bfd, struct bfd_link_info *info)
2587 {
2588   unsigned int bfd_indx;
2589   Elf_Internal_Sym *local_syms, **all_local_syms;
2590   struct elf32_avr_link_hash_table *htab = avr_link_hash_table (info);
2591
2592   /* We want to read in symbol extension records only once.  To do this
2593      we need to read in the local symbols in parallel and save them for
2594      later use; so hold pointers to the local symbols in an array.  */
2595   bfd_size_type amt = sizeof (Elf_Internal_Sym *) * htab->bfd_count;
2596   all_local_syms = bfd_zmalloc (amt);
2597   htab->all_local_syms = all_local_syms;
2598   if (all_local_syms == NULL)
2599     return -1;
2600
2601   /* Walk over all the input BFDs, swapping in local symbols.
2602      If we are creating a shared library, create hash entries for the
2603      export stubs.  */
2604   for (bfd_indx = 0;
2605        input_bfd != NULL;
2606        input_bfd = input_bfd->link_next, bfd_indx++)
2607     {
2608       Elf_Internal_Shdr *symtab_hdr;
2609
2610       /* We'll need the symbol table in a second.  */
2611       symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2612       if (symtab_hdr->sh_info == 0)
2613         continue;
2614
2615       /* We need an array of the local symbols attached to the input bfd.  */
2616       local_syms = (Elf_Internal_Sym *) symtab_hdr->contents;
2617       if (local_syms == NULL)
2618         {
2619           local_syms = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
2620                                              symtab_hdr->sh_info, 0,
2621                                              NULL, NULL, NULL);
2622           /* Cache them for elf_link_input_bfd.  */
2623           symtab_hdr->contents = (unsigned char *) local_syms;
2624         }
2625       if (local_syms == NULL)
2626         return -1;
2627
2628       all_local_syms[bfd_indx] = local_syms;
2629     }
2630
2631   return 0;
2632 }
2633
2634 #define ADD_DUMMY_STUBS_FOR_DEBUGGING 0
2635
2636 bfd_boolean
2637 elf32_avr_size_stubs (bfd *output_bfd,
2638                       struct bfd_link_info *info,
2639                       bfd_boolean is_prealloc_run)
2640 {
2641  struct elf32_avr_link_hash_table *htab;
2642  int stub_changed = 0;
2643
2644  htab = avr_link_hash_table (info);
2645
2646  /* At this point we initialize htab->vector_base
2647     To the start of the text output section.  */
2648  htab->vector_base = htab->stub_sec->output_section->vma;
2649
2650  if (get_local_syms (info->input_bfds, info))
2651    {
2652      if (htab->all_local_syms)
2653        goto error_ret_free_local;
2654      return FALSE;
2655    }
2656
2657   if (ADD_DUMMY_STUBS_FOR_DEBUGGING)
2658     {
2659       struct elf32_avr_stub_hash_entry *test;
2660
2661       test = avr_add_stub ("Hugo",htab);
2662       test->target_value = 0x123456;
2663       test->stub_offset = 13;
2664
2665       test = avr_add_stub ("Hugo2",htab);
2666       test->target_value = 0x84210;
2667       test->stub_offset = 14;
2668     }
2669
2670   while (1)
2671     {
2672       bfd *input_bfd;
2673       unsigned int bfd_indx;
2674
2675       /* We will have to re-generate the stub hash table each time anything
2676          in memory has changed.  */
2677
2678       bfd_hash_traverse (&htab->bstab, avr_mark_stub_not_to_be_necessary, htab);
2679       for (input_bfd = info->input_bfds, bfd_indx = 0;
2680            input_bfd != NULL;
2681            input_bfd = input_bfd->link_next, bfd_indx++)
2682         {
2683           Elf_Internal_Shdr *symtab_hdr;
2684           asection *section;
2685           Elf_Internal_Sym *local_syms;
2686
2687           /* We'll need the symbol table in a second.  */
2688           symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2689           if (symtab_hdr->sh_info == 0)
2690             continue;
2691
2692           local_syms = htab->all_local_syms[bfd_indx];
2693
2694           /* Walk over each section attached to the input bfd.  */
2695           for (section = input_bfd->sections;
2696                section != NULL;
2697                section = section->next)
2698             {
2699               Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
2700
2701               /* If there aren't any relocs, then there's nothing more
2702                  to do.  */
2703               if ((section->flags & SEC_RELOC) == 0
2704                   || section->reloc_count == 0)
2705                 continue;
2706
2707               /* If this section is a link-once section that will be
2708                  discarded, then don't create any stubs.  */
2709               if (section->output_section == NULL
2710                   || section->output_section->owner != output_bfd)
2711                 continue;
2712
2713               /* Get the relocs.  */
2714               internal_relocs
2715                 = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL,
2716                                              info->keep_memory);
2717               if (internal_relocs == NULL)
2718                 goto error_ret_free_local;
2719
2720               /* Now examine each relocation.  */
2721               irela = internal_relocs;
2722               irelaend = irela + section->reloc_count;
2723               for (; irela < irelaend; irela++)
2724                 {
2725                   unsigned int r_type, r_indx;
2726                   struct elf32_avr_stub_hash_entry *hsh;
2727                   asection *sym_sec;
2728                   bfd_vma sym_value;
2729                   bfd_vma destination;
2730                   struct elf_link_hash_entry *hh;
2731                   char *stub_name;
2732
2733                   r_type = ELF32_R_TYPE (irela->r_info);
2734                   r_indx = ELF32_R_SYM (irela->r_info);
2735
2736                   /* Only look for 16 bit GS relocs. No other reloc will need a
2737                      stub.  */
2738                   if (!((r_type == R_AVR_16_PM)
2739                         || (r_type == R_AVR_LO8_LDI_GS)
2740                         || (r_type == R_AVR_HI8_LDI_GS)))
2741                     continue;
2742
2743                   /* Now determine the call target, its name, value,
2744                      section.  */
2745                   sym_sec = NULL;
2746                   sym_value = 0;
2747                   destination = 0;
2748                   hh = NULL;
2749                   if (r_indx < symtab_hdr->sh_info)
2750                     {
2751                       /* It's a local symbol.  */
2752                       Elf_Internal_Sym *sym;
2753                       Elf_Internal_Shdr *hdr;
2754
2755                       sym = local_syms + r_indx;
2756                       hdr = elf_elfsections (input_bfd)[sym->st_shndx];
2757                       sym_sec = hdr->bfd_section;
2758                       if (ELF_ST_TYPE (sym->st_info) != STT_SECTION)
2759                         sym_value = sym->st_value;
2760                       destination = (sym_value + irela->r_addend
2761                                      + sym_sec->output_offset
2762                                      + sym_sec->output_section->vma);
2763                     }
2764                   else
2765                     {
2766                       /* It's an external symbol.  */
2767                       int e_indx;
2768
2769                       e_indx = r_indx - symtab_hdr->sh_info;
2770                       hh = elf_sym_hashes (input_bfd)[e_indx];
2771
2772                       while (hh->root.type == bfd_link_hash_indirect
2773                              || hh->root.type == bfd_link_hash_warning)
2774                         hh = (struct elf_link_hash_entry *)
2775                               (hh->root.u.i.link);
2776
2777                       if (hh->root.type == bfd_link_hash_defined
2778                           || hh->root.type == bfd_link_hash_defweak)
2779                         {
2780                           sym_sec = hh->root.u.def.section;
2781                           sym_value = hh->root.u.def.value;
2782                           if (sym_sec->output_section != NULL)
2783                           destination = (sym_value + irela->r_addend
2784                                          + sym_sec->output_offset
2785                                          + sym_sec->output_section->vma);
2786                         }
2787                       else if (hh->root.type == bfd_link_hash_undefweak)
2788                         {
2789                           if (! info->shared)
2790                             continue;
2791                         }
2792                       else if (hh->root.type == bfd_link_hash_undefined)
2793                         {
2794                           if (! (info->unresolved_syms_in_objects == RM_IGNORE
2795                                  && (ELF_ST_VISIBILITY (hh->other)
2796                                      == STV_DEFAULT)))
2797                              continue;
2798                         }
2799                       else
2800                         {
2801                           bfd_set_error (bfd_error_bad_value);
2802
2803                           error_ret_free_internal:
2804                           if (elf_section_data (section)->relocs == NULL)
2805                             free (internal_relocs);
2806                           goto error_ret_free_local;
2807                         }
2808                     }
2809
2810                   if (! avr_stub_is_required_for_16_bit_reloc
2811                       (destination - htab->vector_base))
2812                     {
2813                       if (!is_prealloc_run)
2814                         /* We are having a reloc that does't need a stub.  */
2815                         continue;
2816
2817                       /* We don't right now know if a stub will be needed.
2818                          Let's rather be on the safe side.  */
2819                     }
2820
2821                   /* Get the name of this stub.  */
2822                   stub_name = avr_stub_name (sym_sec, sym_value, irela);
2823
2824                   if (!stub_name)
2825                     goto error_ret_free_internal;
2826
2827
2828                   hsh = avr_stub_hash_lookup (&htab->bstab,
2829                                               stub_name,
2830                                               FALSE, FALSE);
2831                   if (hsh != NULL)
2832                     {
2833                       /* The proper stub has already been created.  Mark it
2834                          to be used and write the possibly changed destination
2835                          value.  */
2836                       hsh->is_actually_needed = TRUE;
2837                       hsh->target_value = destination;
2838                       free (stub_name);
2839                       continue;
2840                     }
2841
2842                   hsh = avr_add_stub (stub_name, htab);
2843                   if (hsh == NULL)
2844                     {
2845                       free (stub_name);
2846                       goto error_ret_free_internal;
2847                     }
2848
2849                   hsh->is_actually_needed = TRUE;
2850                   hsh->target_value = destination;
2851
2852                   if (debug_stubs)
2853                     printf ("Adding stub with destination 0x%x to the"
2854                             " hash table.\n", (unsigned int) destination);
2855                   if (debug_stubs)
2856                     printf ("(Pre-Alloc run: %i)\n", is_prealloc_run);
2857
2858                   stub_changed = TRUE;
2859                 }
2860
2861               /* We're done with the internal relocs, free them.  */
2862               if (elf_section_data (section)->relocs == NULL)
2863                 free (internal_relocs);
2864             }
2865         }
2866
2867       /* Re-Calculate the number of needed stubs.  */
2868       htab->stub_sec->size = 0;
2869       bfd_hash_traverse (&htab->bstab, avr_size_one_stub, htab);
2870
2871       if (!stub_changed)
2872         break;
2873
2874       stub_changed = FALSE;
2875     }
2876
2877   free (htab->all_local_syms);
2878   return TRUE;
2879
2880  error_ret_free_local:
2881   free (htab->all_local_syms);
2882   return FALSE;
2883 }
2884
2885
2886 /* Build all the stubs associated with the current output file.  The
2887    stubs are kept in a hash table attached to the main linker hash
2888    table.  We also set up the .plt entries for statically linked PIC
2889    functions here.  This function is called via hppaelf_finish in the
2890    linker.  */
2891
2892 bfd_boolean
2893 elf32_avr_build_stubs (struct bfd_link_info *info)
2894 {
2895   asection *stub_sec;
2896   struct bfd_hash_table *table;
2897   struct elf32_avr_link_hash_table *htab;
2898   bfd_size_type total_size = 0;
2899
2900   htab = avr_link_hash_table (info);
2901
2902   /* In case that there were several stub sections:  */
2903   for (stub_sec = htab->stub_bfd->sections;
2904        stub_sec != NULL;
2905        stub_sec = stub_sec->next)
2906     {
2907       bfd_size_type size;
2908
2909       /* Allocate memory to hold the linker stubs.  */
2910       size = stub_sec->size;
2911       total_size += size;
2912
2913       stub_sec->contents = bfd_zalloc (htab->stub_bfd, size);
2914       if (stub_sec->contents == NULL && size != 0)
2915         return FALSE;
2916       stub_sec->size = 0;
2917     }
2918
2919   /* Allocate memory for the adress mapping table.  */
2920   htab->amt_entry_cnt = 0;
2921   htab->amt_max_entry_cnt = total_size / 4;
2922   htab->amt_stub_offsets = bfd_malloc (sizeof (bfd_vma)
2923                                        * htab->amt_max_entry_cnt);
2924   htab->amt_destination_addr = bfd_malloc (sizeof (bfd_vma)
2925                                            * htab->amt_max_entry_cnt );
2926
2927   if (debug_stubs)
2928     printf ("Allocating %i entries in the AMT\n", htab->amt_max_entry_cnt);
2929
2930   /* Build the stubs as directed by the stub hash table.  */
2931   table = &htab->bstab;
2932   bfd_hash_traverse (table, avr_build_one_stub, info);
2933
2934   if (debug_stubs)
2935     printf ("Final Stub section Size: %i\n", (int) htab->stub_sec->size);
2936
2937   return TRUE;
2938 }
2939
2940 #define ELF_ARCH                bfd_arch_avr
2941 #define ELF_MACHINE_CODE        EM_AVR
2942 #define ELF_MACHINE_ALT1        EM_AVR_OLD
2943 #define ELF_MAXPAGESIZE         1
2944
2945 #define TARGET_LITTLE_SYM       bfd_elf32_avr_vec
2946 #define TARGET_LITTLE_NAME      "elf32-avr"
2947
2948 #define bfd_elf32_bfd_link_hash_table_create elf32_avr_link_hash_table_create
2949 #define bfd_elf32_bfd_link_hash_table_free   elf32_avr_link_hash_table_free
2950
2951 #define elf_info_to_howto                    avr_info_to_howto_rela
2952 #define elf_info_to_howto_rel                NULL
2953 #define elf_backend_relocate_section         elf32_avr_relocate_section
2954 #define elf_backend_gc_mark_hook             elf32_avr_gc_mark_hook
2955 #define elf_backend_gc_sweep_hook            elf32_avr_gc_sweep_hook
2956 #define elf_backend_check_relocs             elf32_avr_check_relocs
2957 #define elf_backend_can_gc_sections          1
2958 #define elf_backend_rela_normal              1
2959 #define elf_backend_final_write_processing \
2960                                         bfd_elf_avr_final_write_processing
2961 #define elf_backend_object_p            elf32_avr_object_p
2962
2963 #define bfd_elf32_bfd_relax_section elf32_avr_relax_section
2964 #define bfd_elf32_bfd_get_relocated_section_contents \
2965                                         elf32_avr_get_relocated_section_contents
2966
2967 #include "elf32-target.h"