bfd/elf32-avr.c

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