bfd/elf32-avr.c

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