bfd/elf32-avr.c

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